stage/include/ost/img/data.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2011 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

---