[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]
00001 /************************************************************************/ 00002 /* */ 00003 /* Copyright 2009-2010 by Ullrich Koethe */ 00004 /* */ 00005 /* This file is part of the VIGRA computer vision library. */ 00006 /* The VIGRA Website is */ 00007 /* http://hci.iwr.uni-heidelberg.de/vigra/ */ 00008 /* Please direct questions, bug reports, and contributions to */ 00009 /* ullrich.koethe@iwr.uni-heidelberg.de or */ 00010 /* vigra@informatik.uni-hamburg.de */ 00011 /* */ 00012 /* Permission is hereby granted, free of charge, to any person */ 00013 /* obtaining a copy of this software and associated documentation */ 00014 /* files (the "Software"), to deal in the Software without */ 00015 /* restriction, including without limitation the rights to use, */ 00016 /* copy, modify, merge, publish, distribute, sublicense, and/or */ 00017 /* sell copies of the Software, and to permit persons to whom the */ 00018 /* Software is furnished to do so, subject to the following */ 00019 /* conditions: */ 00020 /* */ 00021 /* The above copyright notice and this permission notice shall be */ 00022 /* included in all copies or substantial portions of the */ 00023 /* Software. */ 00024 /* */ 00025 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */ 00026 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */ 00027 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */ 00028 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */ 00029 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */ 00030 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */ 00031 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */ 00032 /* OTHER DEALINGS IN THE SOFTWARE. */ 00033 /* */ 00034 /************************************************************************/ 00035 00036 #ifndef VIGRA_CELLIMAGE_HXX 00037 #define VIGRA_CELLIMAGE_HXX 00038 00039 #include <vigra/basicimage.hxx> 00040 #include <vigra/pixelneighborhood.hxx> 00041 #include <functional> 00042 00043 namespace vigra { 00044 00045 namespace cellimage { 00046 00047 enum CellType { CellTypeRegion = 0, 00048 CellTypeLine = 1, 00049 CellTypeVertex = 2, 00050 CellTypeError = 3, 00051 CellTypeVertexOrLine = 4, 00052 CellTypeErrorOrLine = 5 }; 00053 00054 // ------------------------------------------------------------------- 00055 // CellPixel, CellImage 00056 // ------------------------------------------------------------------- 00057 typedef unsigned int CellLabel; 00058 00059 struct CellPixel 00060 { 00061 private: 00062 CellLabel typeLabel_; 00063 00064 friend struct CellPixelSerializer; 00065 00066 public: 00067 CellPixel() {} 00068 CellPixel(CellType type, CellLabel label = 0) 00069 : typeLabel_((label << 2) | type) 00070 {} 00071 00072 inline CellType type() const 00073 { return (CellType)(typeLabel_ & 3); } 00074 inline void setType(CellType type) 00075 { typeLabel_ = (label() << 2) | type; } 00076 inline void setType(CellType type, CellLabel label) 00077 { typeLabel_ = label << 2 | type; } 00078 00079 inline CellLabel label() const 00080 { return typeLabel_ >> 2; } 00081 inline void setLabel(CellLabel label) 00082 { typeLabel_ = label << 2 | type(); } 00083 inline void setLabel(CellLabel label, CellType type) 00084 { typeLabel_ = label << 2 | type; } 00085 00086 bool operator==(CellPixel const & rhs) const 00087 { return typeLabel_ == rhs.typeLabel_; } 00088 00089 bool operator!=(CellPixel const & rhs) const 00090 { return typeLabel_ != rhs.typeLabel_; } 00091 }; 00092 00093 typedef BasicImage<CellPixel> CellImage; 00094 00095 typedef vigra::NeighborhoodCirculator<CellImage::Iterator, EightNeighborCode> 00096 CellImageEightCirculator; 00097 00098 // ------------------------------------------------------------------- 00099 // CellPixel Serialization 00100 // ------------------------------------------------------------------- 00101 struct CellPixelSerializer 00102 { 00103 int operator()(CellPixel const &p) const 00104 { 00105 return p.typeLabel_; 00106 } 00107 00108 CellPixel operator()(int i) const 00109 { 00110 CellPixel result; 00111 result.typeLabel_ = i; 00112 return result; 00113 } 00114 }; 00115 00116 // ------------------------------------------------------------------- 00117 // CellPixel/CellImage Accessors 00118 // ------------------------------------------------------------------- 00119 template<class VALUE_TYPE = CellType> 00120 struct TypeAccessor 00121 { 00122 typedef VALUE_TYPE value_type; 00123 typedef VALUE_TYPE result_type; 00124 00125 template<class Iterator> 00126 value_type operator()(const Iterator &it) const 00127 { 00128 return it->type(); 00129 } 00130 00131 template<class Iterator> 00132 void set(value_type type, const Iterator &it) const 00133 { 00134 it->setType(type); 00135 } 00136 }; 00137 00138 typedef TypeAccessor<unsigned char> TypeAsByteAccessor; 00139 00140 typedef TypeAccessor<> CellTypeAccessor; 00141 00142 struct LabelAccessor 00143 { 00144 typedef CellLabel value_type; 00145 00146 template<class Iterator> 00147 CellLabel operator()(const Iterator &it) const 00148 { 00149 return it->label(); 00150 } 00151 00152 template<class Iterator> 00153 void set(CellLabel label, const Iterator &it) const 00154 { 00155 it->setLabel(label); 00156 } 00157 }; 00158 00159 template<CellType type> 00160 struct LabelWriter 00161 { 00162 typedef CellLabel value_type; 00163 00164 template<class Iterator> 00165 void set(CellLabel label, const Iterator &it) const 00166 { 00167 it->setLabel(label, type); 00168 } 00169 }; 00170 00171 template<CellType type> 00172 struct CellTypeEquals : public std::unary_function<CellType, bool> 00173 { 00174 bool operator()(CellType t) const 00175 { 00176 return t == type; 00177 } 00178 00179 template<class Iterator> 00180 bool operator()(const Iterator &it) const 00181 { 00182 return it->type() == type; 00183 } 00184 }; 00185 00186 struct CellMask : public std::unary_function<vigra::cellimage::CellPixel, bool> 00187 { 00188 vigra::cellimage::CellPixel maskPixel_; 00189 00190 CellMask(vigra::cellimage::CellPixel maskPixel) 00191 : maskPixel_(maskPixel) 00192 {} 00193 00194 template<class Iterator> 00195 bool operator()(const Iterator &it) const 00196 { 00197 return *it == maskPixel_; 00198 } 00199 }; 00200 00201 // ------------------------------------------------------------------- 00202 // RelabelFunctor (unused!) 00203 // ------------------------------------------------------------------- 00204 template<class VALUETYPE> 00205 struct RelabelFunctor 00206 { 00207 typedef VALUETYPE value_type; 00208 typedef VALUETYPE argument_type; 00209 typedef VALUETYPE result_type; 00210 00211 RelabelFunctor(VALUETYPE oldValue, VALUETYPE newValue) 00212 : oldValue_(oldValue), 00213 newValue_(newValue) 00214 {} 00215 00216 VALUETYPE operator()(VALUETYPE value) const 00217 { 00218 return (value == oldValue_) ? newValue_ : value; 00219 } 00220 00221 VALUETYPE oldValue_, newValue_; 00222 }; 00223 00224 // ------------------------------------------------------------------- 00225 // inspectCell 00226 // ------------------------------------------------------------------- 00227 // thinking about "typename IteratorTraits<EndIterator>::DefaultAccessor": 00228 // is not needed since we're not implementing srcCellRange here, but 00229 // algorithms. 00230 // srcCellRange can not be implemented that easy, because most VIGRA 00231 // functions expect an ImageIterator, not a std::iterator 00232 template <class EndIterator, class Accessor, class Functor> 00233 void inspectCell(EndIterator endIterator, Accessor a, Functor & f) 00234 { 00235 for(; endIterator.inRange(); ++endIterator) 00236 f(a(endIterator)); 00237 } 00238 00239 template <class EndIterator, class Functor> 00240 void inspectCell(EndIterator endIterator, Functor & f) 00241 { 00242 for(; endIterator.inRange(); ++endIterator) 00243 f(*endIterator); 00244 } 00245 00246 // ------------------------------------------------------------------- 00247 // transformCell 00248 // ------------------------------------------------------------------- 00249 template <class SrcEndIterator, class SrcAccessor, 00250 class DestEndIterator, class DestAccessor, class Functor> 00251 void transformCell(SrcEndIterator srcEndIterator, SrcAccessor sa, 00252 DestEndIterator destEndIterator, DestAccessor da, 00253 Functor const & f) 00254 { 00255 for(; srcEndIterator.inRange(); ++srcEndIterator, ++destEndIterator) 00256 da.set(f(sa(srcEndIterator)), destEndIterator); 00257 } 00258 00259 template <class SrcEndIterator, class DestEndIterator, class Functor> 00260 void transformCell(SrcEndIterator srcEndIterator, 00261 DestEndIterator destEndIterator, 00262 Functor const & f) 00263 { 00264 for(; srcEndIterator.inRange(); ++srcEndIterator, ++destEndIterator) 00265 *destEndIterator = f(*srcEndIterator); 00266 } 00267 00268 } // namespace cellimage 00269 00270 } // namespace vigra 00271 00272 #endif // VIGRA_CELLIMAGE_HXX
© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) |
html generated using doxygen and Python
|