data.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2020 by the OpenStructure authors
// Copyright (C) 2003-2010 by the IPLT authors
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 3.0 of the License, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//------------------------------------------------------------------------------
 
/*
  abstract base class for generic data
 
  Author: Ansgar Philippsen
*/
 
#ifndef IMG_DATA_H
#define IMG_DATA_H
 
#include <cmath>
 
#include <boost/shared_ptr.hpp>
 
#include <ost/img/module_config.hh>
#include <ost/base.hh>
#include "point.hh"
#include "extent.hh"
#include "data_types.hh"
#include "extent_iterator.hh"
#include "vecmat.hh"
 
 
namespace ost { namespace img {
 
 
//using namespace info;
 
// forward declaration
class NonModAlgorithm;
class ModIPAlgorithm;
class DataObserver;
class PixelSampling;
class ImageHandle;
 
 
class DLLEXPORT_OST_IMG_BASE ConstData {
public:
  ConstData();
  virtual ~ConstData();
 
  virtual DataType GetType() const = 0;
 
  virtual DataDomain GetDomain() const = 0;
 
 
  bool IsSpatial() const {return GetDomain()==SPATIAL;}
 
 
  bool IsFrequency() const {
    return GetDomain()==FREQUENCY || GetDomain()==HALF_FREQUENCY;
  }
 
 
  bool IsReal() const {return GetType()==REAL;}
 
 
  bool IsComplex() const {return GetType()==COMPLEX;}
 
  virtual Extent GetExtent() const = 0;
 
  virtual Point GetSpatialOrigin() const = 0;
 
 
  Size GetSize() const {return GetExtent().GetSize();}
 
 
  virtual Real GetReal(const Point &p) const = 0;
 
  virtual Complex GetComplex(const Point &p) const = 0;
 
  virtual Real GetIntpolReal(const Vec3 &v) const = 0;
  virtual Real GetIntpolReal(const Vec2 &v) const = 0;
  virtual Real GetIntpolReal(const Real &d) const = 0;
 
  virtual Complex GetIntpolComplex(const Vec3 &v) const = 0;
  virtual Complex GetIntpolComplex(const Vec2 &v) const = 0;
  virtual Complex GetIntpolComplex(const Real &d) const = 0;
 
 
  /*
    Only a NonModAlgorithm can be applied to a Data instance,
    the Mod IP/OP variants are part of the ImageHandle interface
  */
  virtual void Apply(NonModAlgorithm& a) const = 0;
  virtual void ApplyIP(NonModAlgorithm& a) const=0;
 
  
  virtual void Attach(DataObserver *o) const = 0;
 
  virtual void Detach(DataObserver *o) const = 0;
 
  virtual void Notify() const = 0;
 
  virtual Real OverallDifference(const ConstData& d) const;
  virtual Real NormDifference(const ConstData& d) const;
 
 
 
  Vec3 GetPixelSampling() const;
 
  Vec3 GetSpatialSampling() const;
 
  Vec3 GetFrequencySampling() const;
 
  // Index to coordinate conversion
  /*
    Returns the physical dimensions of a given Point based on
    the sampling of the current domain.
  */
  //Vec3 IndexToCoord(const Point &p) const;
 
  // Convert coordinates back to (fractional) indices
  /*
    Returns the location within the Data that corresponds to
    the given physical coordinate.
  */
  //Vec3 CoordToIndex(const Vec3& c) const;
 
 
 
 protected:
  ConstData(const ConstData& d);
  ConstData& operator=(const ConstData& d);
 
  virtual PixelSampling& Sampling() = 0;
  virtual const PixelSampling& Sampling() const = 0;
 
  void CalcIntpolWeights(Vec3 v, Real w[8], Point p[8]) const;
 
private:
 
};
 
 
 
class DLLEXPORT_OST_IMG_BASE Data: public ConstData {
public:
  Data();
  virtual ~Data();
 
  
  virtual void SetSpatialOrigin(const Point& o) = 0;
 
 
  void SetPixelSampling(const Vec3&);
  void SetPixelSampling(Real d) {SetPixelSampling(Vec3(d,d,d));}
  void SetSpatialSampling(const Vec3&);
  void SetSpatialSampling(Real d) {SetSpatialSampling(Vec3(d,d,d));}
 
  virtual void Apply(NonModAlgorithm& a) const=0;
  virtual void ApplyIP(NonModAlgorithm& a) const=0;
 
 protected:
  Data(const Data& d);
  Data& operator=(const Data& d);
};
 
 
 
}} // namespace img
 
#endif