d0/d96/image__handle_8hh_source.html

 //------------------------------------------------------------------------------

 // 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

 //------------------------------------------------------------------------------


 /*

   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

ost::img::ConstModOPAlgorithm
out-of-place modification const algorithm
Definition: data_algorithm.hh:143

ost::img::InvalidImageHandle::InvalidImageHandle
InvalidImageHandle()
Definition: image_handle.hh:76

ost::img::NonModAlgorithm
Non-modifying Algorithm, abstract base class.
Definition: data_algorithm.hh:66

ost::img::Observable
templated observable class
Definition: observable.hh:44

observable.hh

ost::img::DataDomain
DataDomain
underlying data type
Definition: data_types.hh:42

Real
float Real
Definition: base.hh:44

Complex
std::complex< Real > Complex
Definition: base.hh:51

ost::img::operator/
DLLEXPORT_OST_IMG_BASE ImageHandle operator/(const ConstImageHandle &h, Real v)

ost::img::operator+
DLLEXPORT_OST_IMG_BASE ImageHandle operator+(const ConstImageHandle &h, Real v)

ost::img::Data
Abstract base class for data.
Definition: data.hh:253

image_state_visitor_fw.hh

extent_iterator.hh

ost::img::operator!=
DLLEXPORT_OST_IMG_BASE bool operator!=(const ImageHandle &lhs, const ConstImageHandle &rhs)

ost::img::DataType
DataType
Definition: data_types.hh:37

ost::img::ConstData
Abstract base class for read-only data.
Definition: data.hh:70

ost::info::Extract
T Extract(const info::InfoGroup &g, const String &n)
Convenience function to extract a value from an item.
Definition: info_item.hh:128

ost::img::PixelSampling
Helper class to handle pixel sampling.
Definition: pixel_sampling.hh:55

ost::img::Extent
Defines lower and upper valid indices.
Definition: extent.hh:60

ost::img::SPATIAL
Definition: data_types.hh:42

test_image::test_Observer
void test_Observer()

ost::img::ExtentIterator
Extent iterator.
Definition: extent_iterator.hh:52

ost::img::ConstModIPAlgorithm
In-place modification const algorithm.
Definition: data_algorithm.hh:107

data.hh

base.hh

ost::img::DataObserver
Abstract base class of data observer.
Definition: data_observer.hh:59

module_config.hh

image_state_base_fw.hh

ost::img::ModIPAlgorithm
In-place modification algorithm.
Definition: data_algorithm.hh:89

ost::img::InvalidImageHandle
Exception thrown upon invalid image handle usage.
Definition: image_handle.hh:74

ost::img::ConstImageHandle
read-only ImageHandle implementation
Definition: image_handle.hh:516

ost::img::operator==
DLLEXPORT_OST_IMG_BASE bool operator==(const ImageHandle &lhs, const ConstImageHandle &rhs)

ost::img::ModOPAlgorithm
out-of-place modification algorithm
Definition: data_algorithm.hh:125

ost::img::ImageHandle
Manage shared instances of images.
Definition: image_handle.hh:111

ost::img::image_state::ImageStateBasePtr
boost::shared_ptr< ImageStateBase > ImageStateBasePtr
Definition: image_state_base_fw.hh:32

ost::Error
Definition: message.hh:35

ost::img::REAL
Definition: data_types.hh:37

message.hh

ost::img::Point
class encapsulating 1D to 3D point
Definition: point.hh:43

DLLEXPORT_OST_IMG_BASE
#define DLLEXPORT_OST_IMG_BASE
Definition: module_config.hh:33

ost::img::operator*
DLLEXPORT_OST_IMG_BASE ImageHandle operator*(const ConstImageHandle &h, Real v)

ost::img::operator-
DLLEXPORT_OST_IMG_BASE ImageHandle operator-(const ConstImageHandle &h, Real v)