stage/include/ost/img/image_handle.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
//------------------------------------------------------------------------------

/*
  basic image handle, manages shared instances of an image

  offers the Image interface

  Author: Ansgar Philippsen, Andreas Schenk
*/

#ifndef IMG_IMAGE_HANDLE_H
#define IMG_IMAGE_HANDLE_H

#include <boost/shared_ptr.hpp>

#include <ost/img/module_config.hh>
#include <ost/message.hh>
#include <ost/base.hh>

#include "data.hh"
#include "observable.hh"
#include "extent_iterator.hh"

#include "image_state/image_state_visitor_fw.hh"
#include "image_state/image_state_base_fw.hh"

#include <ost/img/module_config.hh>

namespace test_image {
  void test_Observer();
}

namespace ost { namespace img {

using image_state::ImageStateBase;
using image_state::ImageStateBasePtr;
using image_state::ImageStateNonModVisitorBase;
using image_state::ImageStateModIPVisitorBase;
using image_state::ImageStateConstModIPVisitorBase;
using image_state::ImageStateModOPVisitorBase;
using image_state::ImageStateConstModOPVisitorBase;
using image_state::ImageStateMorphVisitorBase;

// fw declarations
class Point;
class Extent;
class Size;
class NonModAlgorithm;
class ModIPAlgorithm;
class ConstModIPAlgorithm;
class ModOPAlgorithm;
class ConstModOPAlgorithm;
class DataObserver;

class DLLEXPORT InvalidImageHandle: public Error {
public:
  InvalidImageHandle(): Error("Attempt to use invalid ImageHandle") {}
};

// fw
class ConstImageHandle;


class DLLEXPORT_OST_IMG_BASE ImageHandle: public Data {
  friend ImageHandle DoCreateImage(const Extent& e, DataType type, DataDomain dom);

  // for internal observer checking
  friend void test_image::test_Observer();

  // for access to Sampling
  friend class ConstImageHandle;

  typedef Observable DataObservable;
  typedef boost::shared_ptr<DataObservable> ObsPtr;

  typedef boost::shared_ptr<ImageStateBasePtr> StatePtrPtr;

public:

  ImageHandle();


  ImageHandle(const ImageHandle& h);


  ImageHandle& operator=(const ImageHandle& h);



  ImageHandle Copy(bool cc=true) const;


  ImageHandle Extract(const Extent& e) const;


  void Paste(const Data& d);


  void Set(const ImageHandle& h);

  void Swap(ImageHandle& h);


  void Reset(const Extent &e, DataType type=REAL,DataDomain dom=SPATIAL);

  bool IsValid() const;

  long MemSize() const;



  virtual DataType GetType() const;

  virtual DataDomain GetDomain() const;


  virtual Extent GetExtent() const;


  virtual Point GetSpatialOrigin() const;

  /*
    For images in the frequency domain, a modification of the spatial origin
    usually has drastic consequences, since all values are affected by a phase shift.
  */
  void SetSpatialOrigin(const Point& p);

  /*
    See Extent for difference in even and odd dimensions. Only
    has an effect for spatial images, since frequency data always
    has origin in center.

    May have effect on values if image is in frequency domain.
  */
  void CenterSpatialOrigin();

  /*
    This method returns the aboslute coordinate of the real space spatial
    origin even when the map is in frequency space
  */
  Vec3 GetAbsoluteOrigin() const;

  /*
    This method sets the aboslutes coordinate of the real space spatial
    origin even when the map is in frequency space
  */
  void SetAbsoluteOrigin(const Vec3& c) ;

  /*
    Returns the physical dimensions of a given Point based on
    the sampling of the current domain and the absolute coordinates
    of the origin of the image
  */
  Vec3 IndexToCoord(const Point &p) const;

  /*
    Returns the location within the Data that corresponds to
    the given physical coordinate, bases on the sampling of
    the current domain and the absolute coordinates
    of the origin of the image
  */
  Vec3 CoordToIndex(const Vec3& c) const;

  /*
    Returns the physical dimensions of a Vec containing fractional Point
    coordinates. The returned value is based on
    the sampling of the current domain and the absolute coordinates
    of the origin of the image
  */
  Vec3 FractionalIndexToCoord(const Vec3 &p) const;


  virtual Real GetReal(const Point& p) const;

  void SetReal(const Point &p, Real r);

  virtual Complex GetComplex(const Point& p) const;

  void SetComplex(const Point &p, const Complex& c);

  virtual Real GetIntpolReal(const Vec3 &v) const;
  virtual Real GetIntpolReal(const Vec2 &v) const;
  virtual Real GetIntpolReal(const Real &d) const;

  virtual Complex GetIntpolComplex(const Vec3 &v) const;
  virtual Complex GetIntpolComplex(const Vec2 &v) const;
  virtual Complex GetIntpolComplex(const Real &d) const;




  virtual void Attach(DataObserver *o) const;

  virtual void Detach(DataObserver *o) const;

  virtual void Notify() const;
  virtual void Notify(const Extent& e) const;
  virtual void Notify(const Point& p) const;




  void Apply(NonModAlgorithm& a) const;


  void ApplyIP(NonModAlgorithm& a) const;

  void ApplyIP(ModIPAlgorithm& a);


  ImageHandle Apply(ModIPAlgorithm& a) const;

  void ApplyIP(const ConstModIPAlgorithm& a);


  ImageHandle Apply(const ConstModIPAlgorithm& a) const;


  void ApplyIP(ModOPAlgorithm& a);


  ImageHandle Apply(ModOPAlgorithm& a) const;


  void ApplyIP(const ConstModOPAlgorithm& a);


  ImageHandle Apply(const ConstModOPAlgorithm& a) const;



  void StateApply(ImageStateNonModVisitorBase& v) const;

  void StateApplyIP(ImageStateModIPVisitorBase& v);
  ImageHandle StateApply(ImageStateModIPVisitorBase& v) const;
  void StateApplyIP(const ImageStateConstModIPVisitorBase& v);
  ImageHandle StateApply(const ImageStateConstModIPVisitorBase& v) const;
  void StateApplyIP(ImageStateModOPVisitorBase& v);
  ImageHandle StateApply(ImageStateModOPVisitorBase& v) const;
  void StateApplyIP(const ImageStateConstModOPVisitorBase& v);
  ImageHandle StateApply(const ImageStateConstModOPVisitorBase& v) const;
  void StateApplyIP(ImageStateMorphVisitorBase& v);
  ImageHandle StateApply(ImageStateMorphVisitorBase& v) const;
  ExtentIterator GetIterator() const ;


  bool operator==(const ImageHandle& ih) const;
  bool operator!=(const ImageHandle& ih) const;

  ImageHandle& operator+=(Real v);
  ImageHandle& operator+=(const Complex& v);
  ImageHandle& operator-=(Real v);
  ImageHandle& operator-=(const Complex& v);
  ImageHandle& operator*=(Real v);
  ImageHandle& operator*=(const Complex& v);
  ImageHandle& operator/=(Real v);
  ImageHandle& operator/=(const Complex& v);

  void Reciproce();

  ImageHandle& operator+=(const ConstImageHandle& h);
  ImageHandle& operator-=(const ConstImageHandle& h);
  ImageHandle& operator*=(const ConstImageHandle& h);
  ImageHandle& operator/=(const ConstImageHandle& h);


  ImageStateBasePtr& ImageStatePtr();
  const ImageStateBasePtr& ImageStatePtr() const;
  
protected:
  ImageHandle(const StatePtrPtr& spp);

  virtual PixelSampling& Sampling();
  virtual const PixelSampling& Sampling() const;

  static ImageHandle Create(const Extent& e, DataType type, DataDomain dom);

private:
  // this is all there is to it: two shared_ptr<> instances
  StatePtrPtr impl_;
  ObsPtr obs_;

  bool equal(const ImageHandle& ih) const;
};



/*
  In contrast to ConstData and Data, which use is-a inheritance,
  ConstImageHandle implements its functionality using an instance
  of ImageHandle as a private member variable, and an implicit
  copy ctor and assignement op. This avoids Diamond-of-Death 
  virtual inheritance.

  On the downside, the complete ConstData interface needs to be
  retyped and forwarded to the ImageHandle instance. It is a reference
  to this instance that is returned for the 'upcasting' to const Data&
*/
class DLLEXPORT_OST_IMG_BASE ConstImageHandle: public ConstData {
  friend class ImageHandle;
public:
  operator const Data& () const {return handle_;}

  ConstImageHandle();


  ConstImageHandle(const ConstImageHandle& h);


  ConstImageHandle(const ImageHandle& h);


  ConstImageHandle& operator=(const ConstImageHandle& h);


  ConstImageHandle& operator=(const ImageHandle& h);


  ImageHandle Copy(bool cc=true) const;

  ImageHandle Extract(const Extent& e) const;

  bool IsValid() const;

  long MemSize() const;


  DataType GetType() const;

  DataDomain GetDomain() const;

  Extent GetExtent() const;

  Point GetSpatialOrigin() const;

  Vec3 GetAbsoluteOrigin() const;

  Vec3 IndexToCoord(const Point &p) const;

  Vec3 CoordToIndex(const Vec3& c) const;

  Vec3 FractionalIndexToCoord(const Vec3 &p) const;


  Real GetReal(const Point& p) const;

  Complex GetComplex(const Point& p) const;

  virtual Real GetIntpolReal(const Vec3 &v) const;
  virtual Real GetIntpolReal(const Vec2 &v) const;
  virtual Real GetIntpolReal(const Real &d) const;

  virtual Complex GetIntpolComplex(const Vec3 &v) const;
  virtual Complex GetIntpolComplex(const Vec2 &v) const;
  virtual Complex GetIntpolComplex(const Real &d) const;



  void Attach(DataObserver *o) const;

  void Detach(DataObserver *o) const;

  void Notify() const;
  void Notify(const Extent& e) const;
  void Notify(const Point& p) const;



  void Apply(NonModAlgorithm& a) const;
  void ApplyIP(NonModAlgorithm& a) const;

  ImageHandle Apply(ModIPAlgorithm& a) const;

  ImageHandle Apply(const ConstModIPAlgorithm& a) const;

  ImageHandle Apply(ModOPAlgorithm& a) const;

  ImageHandle Apply(const ConstModOPAlgorithm& a) const;


  void StateApply(ImageStateNonModVisitorBase& v) const;

  ImageHandle StateApply(ImageStateModIPVisitorBase& v) const;

  ImageHandle StateApply(const ImageStateConstModIPVisitorBase& v) const;

  ImageHandle StateApply(ImageStateModOPVisitorBase& v) const;

  ImageHandle StateApply(const ImageStateConstModOPVisitorBase& v) const;

  ImageHandle StateApply(ImageStateMorphVisitorBase& v) const;
  ExtentIterator GetIterator() const ;

  bool operator==(const ConstImageHandle& ih) const;
  bool operator==(const ImageHandle& ih) const;
  bool operator!=(const ConstImageHandle& ih) const;
  bool operator!=(const ImageHandle& ih) const;

  const ImageStateBasePtr& ImageStatePtr() const;

protected:

  PixelSampling& Sampling();
  const PixelSampling& Sampling() const;

private:
  // actual implementation
  ImageHandle handle_;

  bool equal(const ConstImageHandle& h) const;
  bool equal(const ImageHandle& h) const;
};


// the other comparison ops are handled as member operators
DLLEXPORT_OST_IMG_BASE bool operator==(const ImageHandle& lhs, const ConstImageHandle& rhs);
DLLEXPORT_OST_IMG_BASE bool operator!=(const ImageHandle& lhs, const ConstImageHandle& rhs);

DLLEXPORT_OST_IMG_BASE ImageHandle operator+(const ConstImageHandle& h, Real v);
DLLEXPORT_OST_IMG_BASE ImageHandle operator+(const ConstImageHandle& h, const Complex& v);
DLLEXPORT_OST_IMG_BASE ImageHandle operator+(Real v, const ConstImageHandle& h);
DLLEXPORT_OST_IMG_BASE ImageHandle operator+(const Complex& v, const ConstImageHandle& h);
DLLEXPORT_OST_IMG_BASE ImageHandle operator-(const ConstImageHandle& h, Real v);
DLLEXPORT_OST_IMG_BASE ImageHandle operator-(const ConstImageHandle& h, const Complex& v);
DLLEXPORT_OST_IMG_BASE ImageHandle operator-(Real v, const ConstImageHandle& h);
DLLEXPORT_OST_IMG_BASE ImageHandle operator-(const Complex& v, const ConstImageHandle& h);
DLLEXPORT_OST_IMG_BASE ImageHandle operator*(const ConstImageHandle& h, Real v);
DLLEXPORT_OST_IMG_BASE ImageHandle operator*(const ConstImageHandle& h, const Complex& v);
DLLEXPORT_OST_IMG_BASE ImageHandle operator*(Real v, const ConstImageHandle& h);
DLLEXPORT_OST_IMG_BASE ImageHandle operator*(const Complex& v, const ConstImageHandle& h);
DLLEXPORT_OST_IMG_BASE ImageHandle operator/(const ConstImageHandle& h, Real v);
DLLEXPORT_OST_IMG_BASE ImageHandle operator/(const ConstImageHandle& h, const Complex& v);

DLLEXPORT_OST_IMG_BASE ImageHandle operator+(const ConstImageHandle& h1, const ConstImageHandle& h2);
DLLEXPORT_OST_IMG_BASE ImageHandle operator-(const ConstImageHandle& h1, const ConstImageHandle& h2);
DLLEXPORT_OST_IMG_BASE ImageHandle operator*(const ConstImageHandle& h1, const ConstImageHandle& h2);
DLLEXPORT_OST_IMG_BASE ImageHandle operator/(const ConstImageHandle& h1, const ConstImageHandle& h2);


}} // namespace img

#endif

---