f.r.e.e. - Flexible Registration and Evaluation Engine: freImagePolyStorage.txx Source File

00001 /*=========================================================================
00002 
00003   Program:   F.R.E.E. - flexible registration evaluation engine
00004   Version:   v.1.0.0
00005   Date:      $Date: 2006/09/01 12:00:00 $
00006   Module:    $RCSfile: freImagePolyStorage.txx,v $
00007   Language:  C++
00008 
00009 
00010 
00011   Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
00012   Institute for Medical Biometry and Informatics, University of Heidelberg,
00013   Germany). All rights reserved.
00014   See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/copyright.htm
00015   for details.
00016 
00017      This software is distributed WITHOUT ANY WARRANTY; without even 
00018      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
00019      PURPOSE.  See the above copyright notices for more information.
00020 
00021 =========================================================================*/
00022 #ifndef __freImagePolyStorage_txx
00023 #define __freImagePolyStorage_txx
00024 
00025 #include "freImagePolyStorage.h"
00026 
00027 namespace FREE
00028 {
00029 
00030 template<class TPixel2D, class TPixel3D>
00031 bool
00032 ImagePolyStorage<TPixel2D,TPixel3D>::
00033 GetImage(Image2DType*& pImage) const
00034 {
00035         if (m_ImageDimension == Dim_2D)
00036         {
00037                 pImage = m_smp2DImage.GetPointer();
00038                 return true;
00039         }
00040         return false;
00041 };
00042 
00043 template<class TPixel2D, class TPixel3D>
00044 bool
00045 ImagePolyStorage<TPixel2D,TPixel3D>::
00046 GetImage(Image2DPointer& smpImage) const
00047 {
00048         Image2DType* pImage = NULL;
00049 
00050         bool result = GetImage(pImage);
00051         smpImage = pImage;
00052 
00053         return result;
00054 };
00055 
00056 template<class TPixel2D, class TPixel3D>
00057 bool
00058 ImagePolyStorage<TPixel2D,TPixel3D>::
00059 GetImage(Image3DType*& pImage) const
00060 {
00061         if (m_ImageDimension == Dim_3D)
00062         {
00063                 pImage = m_smp3DImage.GetPointer();
00064                 return true;
00065         }
00066         return false;
00067 };
00068 
00069 template<class TPixel2D, class TPixel3D>
00070 bool
00071 ImagePolyStorage<TPixel2D,TPixel3D>::
00072 GetImage(Image3DPointer& smpImage) const
00073 {
00074         Image3DType* pImage = NULL;
00075 
00076         bool result = GetImage(pImage);
00077         smpImage = pImage;
00078 
00079         return result;
00080 };
00081 
00082 template<class TPixel2D, class TPixel3D>
00083 void
00084 ImagePolyStorage<TPixel2D,TPixel3D>::
00085 SetImage(Image2DType* pImage)
00086 {
00087         m_smp2DImage = pImage;
00088         m_smp3DImage = NULL;
00089         m_ImageDimension = Dim_2D;
00090 }
00091 
00092 template<class TPixel2D, class TPixel3D>
00093 void
00094 ImagePolyStorage<TPixel2D,TPixel3D>::
00095 SetImage(Image3DType* pImage)
00096 {
00097         m_smp3DImage = pImage;
00098         m_smp2DImage = NULL;
00099         m_ImageDimension = Dim_3D;
00100 }
00101 
00102 template<class TPixel2D, class TPixel3D>
00103 bool
00104 ImagePolyStorage<TPixel2D,TPixel3D>::
00105 GetPixelByPhysicalPoint(const ImageTypes<2>::PointType& point, Pixel2DType& pixel) const
00106 {
00107         if (m_ImageDimension == Dim_2D)
00108         {
00109                 typename Image2DType::IndexType index;
00110                 if (!m_smp2DImage->TransformPhysicalPointToIndex(point, index)) return false;
00111 
00112                 return GetPixelByIndex(index,pixel);
00113         }
00114         return false;
00115 };
00116 
00117 template<class TPixel2D, class TPixel3D>
00118 bool
00119 ImagePolyStorage<TPixel2D,TPixel3D>::
00120 GetPixelByPhysicalPoint(const ImageTypes<3>::PointType& point, Pixel3DType& pixel) const
00121 {
00122         if (m_ImageDimension == Dim_3D)
00123         {
00124                 typename Image3DType::IndexType index;
00125                 if (!m_smp3DImage->TransformPhysicalPointToIndex(point, index)) return false;
00126 
00127                 return GetPixelByIndex(index,pixel);
00128         }
00129         return false;
00130 };
00131 
00132 template<class TPixel2D, class TPixel3D>
00133 bool
00134 ImagePolyStorage<TPixel2D,TPixel3D>::
00135 GetPixelByIndex(const typename Image2DType::IndexType& index, Pixel2DType& pixel) const
00136 {
00137         if (m_ImageDimension == Dim_2D)
00138         {
00139                 pixel = m_smp2DImage->GetPixel(index);
00140                 return true;
00141         }
00142         return false;
00143 };
00144 
00145 template<class TPixel2D, class TPixel3D>
00146 bool
00147 ImagePolyStorage<TPixel2D,TPixel3D>::
00148 GetPixelByIndex(const typename Image3DType::IndexType& index, Pixel3DType& pixel) const
00149 {
00150         if (m_ImageDimension == Dim_3D)
00151         {
00152                 pixel = m_smp3DImage->GetPixel(index);
00153                 return true;
00154         }
00155         return false;
00156 };
00157 
00158 
00159 template<class TPixel2D, class TPixel3D>
00160 void
00161 ImagePolyStorage<TPixel2D,TPixel3D>::
00162 Reset()
00163 {
00164         m_smp3DImage = NULL;
00165         m_smp2DImage = NULL;
00166         m_ImageDimension = Dim_Undefined;
00167 }
00168 
00170 template<class TPixel2D, class TPixel3D>
00171 ImagePolyStorage<TPixel2D,TPixel3D>::
00172 ImagePolyStorage()
00173 {
00174         Reset();
00175 };
00176 
00177 template<class TPixel2D, class TPixel3D>
00178 ImagePolyStorage<TPixel2D,TPixel3D>::
00179 ImagePolyStorage(Image2DType* pImage)
00180 {
00181         SetImage(pImage);
00182 };
00183 
00184 template<class TPixel2D, class TPixel3D>
00185 ImagePolyStorage<TPixel2D,TPixel3D>::
00186 ImagePolyStorage(Image3DType* pImage)
00187 {
00188         SetImage(pImage);
00189 };
00190 
00191 template<class TPixel2D, class TPixel3D>
00192 ImagePolyStorage<TPixel2D,TPixel3D>::
00193 ~ImagePolyStorage()
00194 {
00195         Reset();
00196 };
00197 
00198 }//end of namespace FREE
00199 
00200 #endif