BALL  1.4.1
regularData1D.h
Go to the documentation of this file.
00001 // -*- Mode: C++; tab-width: 2; -*-
00002 // vi: set ts=2:
00003 //
00004 
00005 #ifndef BALL_DATATYPE_REGULARDATA1D_H
00006 #define BALL_DATATYPE_REGULARDATA1D_H
00007 
00008 #ifndef BALL_COMMON_H
00009 # include <BALL/common.h>
00010 #endif
00011 
00012 #ifndef BALL_SYSTEM_FILE_H
00013 # include <BALL/SYSTEM/file.h>
00014 #endif
00015 
00016 #ifndef BALL_SYSTEM_BINARYFILEADAPTOR_H
00017 # include <BALL/SYSTEM/binaryFileAdaptor.h>
00018 #endif
00019 
00020 #include <vector>
00021 #include <iostream>
00022 #include <fstream>
00023 #include <iterator>
00024 #include <algorithm>
00025 
00026 namespace BALL
00027 {
00039   template <typename ValueType>
00040   class TRegularData1D
00041   {
00042     public:
00043       
00044     BALL_CREATE(TRegularData1D<ValueType>)
00045 
00046     
00049 
00051     typedef Position IndexType;
00053     typedef std::vector<ValueType>  VectorType;
00055     typedef double CoordinateType;
00057     typedef typename std::vector<ValueType>::iterator Iterator;
00059     typedef typename std::vector<ValueType>::const_iterator ConstIterator;
00061 
00062     //  STL compatibility types
00063     //
00064     typedef ValueType value_type;
00065     typedef typename std::vector<ValueType>::iterator iterator;
00066     typedef typename std::vector<ValueType>::const_iterator const_iterator;
00067     typedef typename std::vector<ValueType>::reference reference;
00068     typedef typename std::vector<ValueType>::const_reference const_reference;
00069     typedef typename std::vector<ValueType>::pointer pointer;
00070     typedef typename std::vector<ValueType>::difference_type difference_type;
00071     typedef typename std::vector<ValueType>::size_type size_type;
00072 
00076       
00078     TRegularData1D();
00079 
00083     TRegularData1D(const TRegularData1D& data);
00084   
00088     TRegularData1D(const CoordinateType& origin, const CoordinateType& dimension, const CoordinateType& spacing);
00089 
00093     TRegularData1D(const IndexType& size);
00094 
00098     TRegularData1D(const VectorType& data, const CoordinateType& origin = 0.0, const CoordinateType& dimension = 1.0);
00099 
00101     virtual ~TRegularData1D();
00102 
00104     virtual void clear();
00106 
00107 
00111 
00116     TRegularData1D& operator = (const TRegularData1D<ValueType>& data);
00117 
00122     TRegularData1D& operator = (const VectorType& data);
00123 
00125 
00129 
00130     bool operator == (const TRegularData1D& data) const;
00131 
00133     BALL_INLINE bool operator != (const TRegularData1D& data) const { return !this->operator == (data); }
00134 
00136     BALL_INLINE bool empty() const { return data_.empty(); }
00137 
00139     bool isInside(const CoordinateType& x) const;
00141 
00145 
00146     BALL_INLINE ConstIterator begin() const { return data_.begin(); }
00148     BALL_INLINE ConstIterator end() const { return data_.end(); }
00150     BALL_INLINE Iterator begin() { return data_.begin(); }
00152     BALL_INLINE Iterator end() { return data_.end(); }
00154 
00158     
00159     // STL compatibility
00160     BALL_INLINE size_type size() const { return data_.size(); }
00161     BALL_INLINE size_type max_size() const { return data_.max_size(); }
00162     BALL_INLINE void swap(TRegularData1D<ValueType>& data) { std::swap(*this, data); }
00163 
00168     const ValueType& getData(const IndexType& index) const;
00169 
00174     ValueType& getData(const IndexType& index);
00175 
00180     const ValueType& operator [] (const IndexType& index) const { return data_[index]; }
00181       
00186     ValueType& operator [] (const IndexType& index) { return data_[index]; }
00187     
00196     ValueType operator () (const CoordinateType& x) const;
00197 
00204     ValueType getInterpolatedValue(const CoordinateType& x) const;
00205       
00212     void getEnclosingIndices(const CoordinateType& x, Position& lower, Position& upper) const;
00213 
00218     void getEnclosingValues(const CoordinateType& x, ValueType& lower, ValueType& upper) const;
00219 
00224     CoordinateType getCoordinates(const IndexType& index) const;
00225 
00232     IndexType getClosestIndex(const CoordinateType& x) const;
00233       
00240     IndexType getLowerIndex(const CoordinateType& x) const;
00241       
00248     const ValueType& getClosestValue(const CoordinateType& x) const;
00249       
00256     ValueType& getClosestValue(const CoordinateType& x);
00257       
00259     BALL_INLINE IndexType getSize() const { return (IndexType)data_.size(); }
00260 
00265     BALL_INLINE const CoordinateType& getOrigin() const { return origin_; }
00266     
00271     BALL_INLINE const CoordinateType& getSpacing() const {  return spacing_; }
00272           
00275     BALL_INLINE void setOrigin(const CoordinateType& origin) { origin_ = origin; }
00276 
00282     BALL_INLINE const CoordinateType& getDimension() const { return dimension_; }
00283 
00289     BALL_INLINE void setDimension(const CoordinateType& dimension) { dimension_ = dimension; }
00290 
00303     void resize(const IndexType& size);
00304 
00314     void rescale(const IndexType& new_size);
00315 
00319     ValueType calculateMean() const;
00320     
00324     ValueType calculateSD() const;
00325     
00329     void binaryWrite(const String& filename) const;
00330 
00334     void binaryRead(const String& filename);
00336   
00337     
00338     protected:
00340     CoordinateType  origin_;
00341 
00343     CoordinateType  dimension_;
00344 
00346     CoordinateType  spacing_;
00347 
00349     VectorType      data_;
00350 
00352     typedef struct { ValueType bt[1024]; } BlockValueType;
00353   };
00354 
00357   typedef TRegularData1D<float> RegularData1D;
00358   
00359   template <typename ValueType>
00360   TRegularData1D<ValueType>::TRegularData1D()
00361     : origin_(0.0),
00362       dimension_(0.0),
00363       spacing_(1.0),
00364       data_()
00365   {
00366   }
00367 
00368   template <typename ValueType>
00369   TRegularData1D<ValueType>::~TRegularData1D()
00370   {
00371   }
00372 
00373   template <typename ValueType>
00374   TRegularData1D<ValueType>::TRegularData1D(const TRegularData1D<ValueType>& data)
00375     : origin_(data.origin_),
00376       dimension_(data.dimension_),
00377       spacing_(data.spacing_),
00378       data_()
00379   {
00380     // Try to catch allocation errors and rethrow them as OutOfMemory
00381     try
00382     {
00383       data_ = data.data_;
00384     }
00385     catch (std::bad_alloc&)
00386     {
00387       throw Exception::OutOfMemory(__FILE__, __LINE__, data.size() * sizeof(ValueType));
00388     }
00389   }
00390 
00391   template <typename ValueType>
00392   TRegularData1D<ValueType>::TRegularData1D
00393     (const typename TRegularData1D<ValueType>::CoordinateType& origin, 
00394      const typename TRegularData1D<ValueType>::CoordinateType& dimension, 
00395      const typename TRegularData1D<ValueType>::CoordinateType& spacing)
00396     : origin_(origin),
00397       dimension_(dimension),
00398       spacing_(spacing),
00399       data_()
00400   {
00401     // Determine the size of the vector
00402     size_type size = (size_type)(dimension_ / spacing_ + 1.0);
00403 
00404     // Try to catch allocation errors and rethrow them as OutOfMemory
00405     try
00406     {
00407       data_.resize(size);
00408     }
00409     catch (std::bad_alloc&)
00410     {
00411       throw Exception::OutOfMemory(__FILE__, __LINE__, size * sizeof(ValueType));
00412     }
00413   }
00414       
00415   template <typename ValueType>
00416   TRegularData1D<ValueType>::TRegularData1D
00417     (const typename TRegularData1D<ValueType>::VectorType& data, 
00418      const typename TRegularData1D<ValueType>::CoordinateType& origin, 
00419      const typename TRegularData1D<ValueType>::CoordinateType& dimension)
00420     : origin_(origin),
00421       dimension_(dimension),
00422       spacing_(dimension / ((double)data.size()-1)),
00423       data_()
00424   {
00425     // Try to catch allocation errors and rethrow them as OutOfMemory
00426     try
00427     {
00428       data_ = data;
00429     }
00430     catch (std::bad_alloc&)
00431     {
00432       throw Exception::OutOfMemory(__FILE__, __LINE__, data.size() * sizeof(ValueType));
00433     }
00434   }
00435 
00436 
00437   template <class ValueType>
00438   TRegularData1D<ValueType>::TRegularData1D
00439     (const typename TRegularData1D<ValueType>::IndexType& size)
00440     : origin_(0.0),
00441       dimension_(1.0),
00442       data_()
00443   {
00444     // Compute the grid spacing
00445     spacing_ = dimension_ / (double)(size - 1);
00446 
00447     try
00448     {
00449       data_.resize(size);
00450     }
00451     catch (std::bad_alloc&)
00452     {
00453       data_.resize(0);
00454       throw Exception::OutOfMemory(__FILE__, __LINE__, size * sizeof(ValueType));
00455     }
00456   }
00457 
00458   template <typename ValueType>
00459   void TRegularData1D<ValueType>::clear()
00460   {
00461     // iterate over the data and reset all values to their default
00462     // boundaries and vector size remain unchanged
00463     static ValueType default_value = ValueType();
00464     std::fill(data_.begin(), data_.end(), default_value);
00465   }
00466 
00467   template <typename ValueType>
00468   TRegularData1D<ValueType>& TRegularData1D<ValueType>::operator = (const TRegularData1D<ValueType>& rhs)
00469   {
00470     // copy all members...
00471     origin_ = rhs.origin_;
00472     dimension_ = rhs.dimension_;
00473     spacing_ = rhs.spacing_;
00474     try 
00475     {
00476       data_ = rhs.data_;
00477     }
00478     catch (std::bad_alloc&)
00479     {
00480       data_.resize(0);
00481       throw Exception::OutOfMemory(__FILE__, __LINE__, rhs.size() * sizeof(ValueType));
00482     }
00483 
00484     return *this;
00485   }
00486 
00487   template <typename ValueType>
00488   TRegularData1D<ValueType>& TRegularData1D<ValueType>::operator = (const VectorType& rhs)
00489   {
00490     // Copy the data. The boundaries remain unchanged.
00491     try 
00492     {
00493       data_ = rhs;
00494     }
00495     catch (std::bad_alloc&)
00496     {
00497       data_.resize(0);
00498       throw Exception::OutOfMemory(__FILE__, __LINE__, rhs.size() * sizeof(ValueType));
00499     }
00500     
00501     return *this;
00502   }
00503 
00504   template <typename ValueType>
00505   bool TRegularData1D<ValueType>::operator == (const TRegularData1D<ValueType>& data) const
00506   {
00507     return (origin_ == data.origin_ 
00508             && dimension_ == data.dimension_ 
00509             && data_ == data.data_);
00510   }
00511 
00512   template <class ValueType>
00513   BALL_INLINE
00514   bool TRegularData1D<ValueType>::isInside(const typename TRegularData1D<ValueType>::CoordinateType& r) const
00515   {
00516     return ((r >= origin_) && (r <= (origin_ + dimension_)));
00517   }
00518 
00519   template <typename ValueType>
00520   BALL_INLINE
00521   const ValueType& TRegularData1D<ValueType>::getData(const IndexType& index) const
00522   {
00523     if (index >= data_.size())
00524     {
00525       throw Exception::OutOfGrid(__FILE__, __LINE__);
00526     }
00527     return data_[index];
00528   }
00529     
00530   template <typename ValueType>
00531   BALL_INLINE
00532   ValueType& TRegularData1D<ValueType>::getData(const IndexType& index)
00533   {
00534     if (index >= data_.size())
00535     {
00536       throw Exception::OutOfGrid(__FILE__, __LINE__);
00537     }
00538     return data_[index];
00539   }
00540     
00541   template <typename ValueType>
00542   void TRegularData1D<ValueType>::getEnclosingIndices
00543     (const typename TRegularData1D<ValueType>::CoordinateType& x,
00544      Position& lower, Position& upper) const
00545   {
00546     if (!isInside(x) || (data_.size() < 2))
00547     {
00548       throw Exception::OutOfGrid(__FILE__, __LINE__);
00549     }
00550     lower = (Position)floor((x - origin_) / spacing_);
00551     if (lower == data_.size() - 1)
00552     {
00553       // If we are on the right most data point, we cannot interpolate to the right!
00554       lower = data_.size() - 2;
00555     }
00556     upper = lower + 1;
00557   }
00558 
00559   template <typename ValueType>
00560   void TRegularData1D<ValueType>::getEnclosingValues
00561     (const typename TRegularData1D<ValueType>::CoordinateType& x,
00562      ValueType& lower, ValueType& upper) const
00563   {
00564     Position lower_index;
00565     Position upper_index;
00566     getEnclosingIndices(x, lower_index, upper_index);
00567     lower = data_[lower_index];
00568     upper = data_[upper_index];
00569   }
00570 
00571   template <typename ValueType>
00572   BALL_INLINE
00573   ValueType TRegularData1D<ValueType>::getInterpolatedValue(const CoordinateType& x) const
00574   {
00575     if (!isInside(x))
00576     {
00577       throw Exception::OutOfGrid(__FILE__, __LINE__);
00578     }
00579     return operator () (x);
00580   }
00581       
00582   template <typename ValueType>
00583   BALL_INLINE
00584   typename TRegularData1D<ValueType>::CoordinateType TRegularData1D<ValueType>::getCoordinates
00585     (const typename TRegularData1D<ValueType>::IndexType& index) const
00586   {
00587     if ((index >= data_.size()) || (data_.size() == 0))
00588     {
00589       throw Exception::OutOfGrid(__FILE__, __LINE__);
00590     }
00591 
00592     return (CoordinateType)(origin_ + (double)index / ((double)data_.size()-1) * dimension_);
00593   }
00594 
00595   template <typename ValueType>
00596   BALL_INLINE
00597   typename TRegularData1D<ValueType>::IndexType TRegularData1D<ValueType>::getClosestIndex(const CoordinateType& x) const
00598   {
00599     if ((x < origin_) || (x > (origin_ + dimension_)))
00600     {
00601       throw Exception::OutOfGrid(__FILE__, __LINE__);
00602     }
00603 
00604     return (IndexType)(size_type)floor((x - origin_) / spacing_ + 0.5);
00605   }
00606       
00607   template <typename ValueType>
00608   BALL_INLINE
00609   typename TRegularData1D<ValueType>::IndexType TRegularData1D<ValueType>::getLowerIndex(const CoordinateType& x) const
00610   {
00611     if ((x < origin_) || (x > (origin_ + dimension_)))
00612     {
00613       throw Exception::OutOfGrid(__FILE__, __LINE__);
00614     }
00615 
00616     return (IndexType)(size_type)floor((x - origin_) / spacing_);
00617   }
00618       
00619   template <typename ValueType>
00620   BALL_INLINE
00621   const ValueType& TRegularData1D<ValueType>::getClosestValue(const CoordinateType& x) const
00622   {
00623     if ((x < origin_) || (x > (origin_ + dimension_)))
00624     {
00625       throw Exception::OutOfGrid(__FILE__, __LINE__);
00626     }
00627     
00628     // Round to the closest data point.
00629     size_type index = (size_type)floor((x - origin_) / spacing_ + 0.5);
00630     return data_[index];
00631   }
00632       
00633   template <typename ValueType>
00634   BALL_INLINE
00635   ValueType& TRegularData1D<ValueType>::getClosestValue(const CoordinateType& x)
00636   {
00637     if ((x < origin_) || (x > (origin_ + dimension_)))
00638     {
00639       throw Exception::OutOfGrid(__FILE__, __LINE__);
00640     }
00641     
00642     // Round to the closest data point.
00643     size_type index = (size_type)floor((x - origin_) / spacing_ + 0.5);
00644     return data_[index];
00645   }
00646       
00647   template <typename ValueType>
00648   BALL_INLINE
00649   ValueType TRegularData1D<ValueType>::calculateMean() const
00650   {
00651     IndexType data_points = this->getSize();
00652     ValueType mean = 0;
00653     for (IndexType i = 0; i < data_points; i++)
00654     {
00655       mean += data_[i];
00656     }
00657     mean /= data_points;
00658     return mean;
00659   }
00660   
00661   template <typename ValueType>
00662   BALL_INLINE
00663   ValueType TRegularData1D<ValueType>::calculateSD() const
00664   {
00665     IndexType data_points = this->getSize();
00666     ValueType stddev = 0;
00667     ValueType mean = this->calculateMean();
00668     for (IndexType i = 0; i < data_points; i++)
00669     {
00670       stddev += (pow(data_[i]-mean,2));
00671     }
00672     stddev /= (data_points-1);
00673     stddev = sqrt(stddev);
00674     return stddev;
00675   }
00676     
00677   template <typename ValueType>
00678   BALL_INLINE
00679   ValueType TRegularData1D<ValueType>::operator () (const CoordinateType& x) const
00680   {
00681     size_type left_index = (size_type)floor((x - origin_) / spacing_);
00682     if (left_index == data_.size() - 1)
00683     {
00684       // If we are on the right most data point, we cannot interpolate to the right!
00685       return data_[data_.size() - 1];
00686     }
00687     
00688     // Interpolate between the point to the left and the point to the right.
00689     double d = 1.0 - (((x - origin_) - (double)left_index * spacing_) / spacing_);
00690     return data_[left_index] * d + (1.0 - d) * data_[left_index + 1];
00691   }
00692       
00693   template <typename ValueType>
00694   void TRegularData1D<ValueType>::resize
00695     (const typename TRegularData1D<ValueType>::IndexType& new_size)
00696   {
00697     // Rescale dimension to the new size.
00698     if (data_.size() > 0)
00699     {
00700       dimension_ *= (double)new_size / (double)data_.size();
00701     }
00702 
00703     // Try to resize the vactor and rethrow any bad_allocs.
00704     try
00705     {
00706       data_.resize(new_size);
00707     }
00708     catch (std::bad_alloc&)
00709     {
00710       // The resulting vector is empty and thus well-defined.
00711       data_.resize(0);
00712       throw Exception::OutOfMemory(__FILE__, __LINE__, new_size * sizeof(ValueType));
00713     }
00714   }
00715     
00716   template <typename ValueType>
00717   void TRegularData1D<ValueType>::rescale
00718     (const typename TRegularData1D<ValueType>::IndexType& new_size)
00719   {
00720     // if the new and the old size coincide: done.
00721     if (new_size == (IndexType)data_.size())
00722     {
00723       return;
00724     }
00725 
00726     // Catch any bad_allocs throw by vector::resize
00727     try
00728     {
00729       // if the data set is empty...
00730       if (data_.size() == 0)
00731       {
00732         // ...there's nothing to do: a resize was requested
00733         data_.resize(new_size);
00734         return;
00735       }
00736       
00737       // if the data set contains only a single value,
00738       // we fill everything with this value
00739       if ((data_.size() == 1) && (new_size > 1))
00740       {
00741         ValueType old_value = data_[0];
00742         data_.resize(new_size);
00743         for (IndexType i = 1; i < new_size; i++)
00744         {
00745           data_[i] = old_value;
00746         }
00747 
00748         return;
00749       }
00750 
00751       // that's the default case: use linear interpolation
00752       // to determine the values at the new positions
00753       VectorType new_data(new_size);
00754       CoordinateType factor1 = (CoordinateType)data_.size() / (CoordinateType)new_size;
00755       CoordinateType factor2 = (CoordinateType)(data_.size() - 1) / (new_size - 1);
00756 
00757       for (Size i = 0; i < new_size; i++)
00758       {
00759         // determine the interval of the old data set we are currently in
00760         // ([old_idx, old_idx + 1])
00761         IndexType old_idx = (IndexType)((CoordinateType)i * factor1);
00762 
00763         // consider numerical inaccuracies...
00764         if (old_idx >= (data_.size() - 1))
00765         {
00766           old_idx = data_.size() - 2;
00767         }
00768         CoordinateType factor3 = (CoordinateType)i * factor2 - (CoordinateType)old_idx;
00769         new_data[i] = data_[old_idx] * (1 - factor3) + factor3 * data_[old_idx + 1];
00770       }
00771 
00772       // assign the new data
00773       data_ = new_data;
00774     }
00775     catch (std::bad_alloc&)
00776     {
00777       // Make sure we are in a well-defined state.
00778       data_.resize(0);
00779       throw Exception::OutOfMemory(__FILE__, __LINE__, new_size * sizeof(ValueType));     
00780     }
00781   }
00782 
00785 
00786   template <typename ValueType>
00787   std::ostream& operator << (std::ostream& os, const TRegularData1D<ValueType>& data)
00788   {
00789     // Write the grid origin, dimension, and number of grid points
00790     os << data.getOrigin() << std::endl
00791        << data.getOrigin() + data.getDimension() << std::endl
00792        << data.getSize() - 1 << std::endl;
00793 
00794     // Write the array contents.
00795     std::copy(data.begin(), data.end(), std::ostream_iterator<ValueType>(os, "\n"));
00796     return os;
00797   }
00798 
00800   template <typename ValueType>
00801   std::istream& operator >> (std::istream& is, TRegularData1D<ValueType>& grid)
00802   {
00803     typename TRegularData1D<ValueType>::CoordinateType origin;
00804     typename TRegularData1D<ValueType>::CoordinateType dimension;
00805     typename TRegularData1D<ValueType>::IndexType size;
00806 
00807     is >> origin;
00808     is >> dimension;
00809     is >> size;
00810     
00811     dimension -= origin;
00812     size++;
00813 
00814     grid.resize(size);
00815     grid.setOrigin(origin);
00816     grid.setDimension(dimension);
00817 
00818     std::copy(std::istream_iterator<ValueType>(is), 
00819               std::istream_iterator<ValueType>(), 
00820               grid.begin());
00821     //    std::copy_n(std::istream_iterator<ValueType>(is), grid.size(), grid.begin());
00822     
00823     return is;
00824   }
00825 
00826   template <typename ValueType>
00827   void TRegularData1D<ValueType>::binaryWrite(const String& filename) const
00828   {
00829     File outfile(filename, std::ios::out|std::ios::binary);
00830     if (!outfile.isValid()) 
00831     {
00832       throw Exception::FileNotFound(__FILE__, __LINE__, filename);
00833     }
00834 
00835     BinaryFileAdaptor<BlockValueType> adapt_block;
00836     BinaryFileAdaptor<ValueType>      adapt_single;
00837     
00838     // write all information we need to recreate the grid
00839     BinaryFileAdaptor<CoordinateType> adapt_coordinate;
00840     BinaryFileAdaptor<Size>           adapt_size;
00841 
00842     adapt_size.setData(data_.size());
00843     outfile << adapt_size;
00844     
00845     adapt_coordinate.setData(origin_);
00846     outfile << adapt_coordinate;
00847 
00848     adapt_coordinate.setData(dimension_);
00849     outfile << adapt_coordinate;
00850 
00851     adapt_coordinate.setData(spacing_);
00852     outfile << adapt_coordinate;
00853 
00854     // we slide a window of size 1024 over our data
00855     Index window_pos = 0;
00856     while (((int)data_.size() - (1024 + window_pos)) >= 0 )
00857     {
00858       adapt_block.setData(*(BlockValueType*)&(data_[window_pos]));
00859       outfile << adapt_block;
00860       window_pos += 1024;
00861     }
00862 
00863     // now we have to write the remaining data one by one
00864     for (Size i = window_pos; i < data_.size(); i++)
00865     {
00866       adapt_single.setData(data_[i]);
00867       outfile << adapt_single;
00868     }
00869 
00870     // that's it. I hope...
00871     outfile.close();
00872   }
00873 
00874   template <typename ValueType>
00875   void TRegularData1D<ValueType>::binaryRead(const String& filename)
00876   {
00877     File infile(filename, std::ios::in|std::ios::binary);
00878     if (!infile.isValid()) throw Exception::FileNotFound(__FILE__, __LINE__, filename);
00879     
00880     BinaryFileAdaptor<BlockValueType> adapt_block;
00881     BinaryFileAdaptor<ValueType>      adapt_single;
00882     
00883     // read all information we need to recreate the grid
00884     BinaryFileAdaptor<CoordinateType> adapt_coordinate;
00885     BinaryFileAdaptor<Size>           adapt_size;
00886 
00887     infile >> adapt_size;
00888     Size new_size = adapt_size.getData();
00889   
00890     infile >> adapt_coordinate;
00891     origin_ = adapt_coordinate.getData();
00892 
00893     infile >> adapt_coordinate;
00894     dimension_ = adapt_coordinate.getData();
00895 
00896     infile >> adapt_coordinate;
00897     spacing_ = adapt_coordinate.getData();
00898 
00899     data_.resize(new_size);
00900 
00901     // we slide a window of size 1024 over our data
00902     Index window_pos = 0;
00903     
00904     while ( ((int)data_.size() - (1024 + window_pos)) >= 0 )
00905     {
00906       infile >> adapt_block;
00907       *(BlockValueType*)(&(data_[window_pos])) = adapt_block.getData();
00908       /*
00909       for (Size i=0; i<1024; i++)
00910       {
00911         data_[i+window_pos] = adapt_block.getData().bt[i];
00912       }
00913       */
00914       window_pos+=1024;
00915     }
00916 
00917     // now we have to read the remaining data one by one
00918     for (Size i=window_pos; i<data_.size(); i++)
00919     {
00920       infile >> adapt_single;
00921       data_[i] = adapt_single.getData();
00922     }
00923 
00924     // that's it. I hope...
00925     infile.close();
00926   }
00927 } // namespace BALL
00928 
00929 #endif // BALL_DATATYPE_REGULARDATA1D_H
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines