[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]
00001 /************************************************************************/ 00002 /* */ 00003 /* Copyright 1998-2002 by Ullrich Koethe */ 00004 /* Cognitive Systems Group, University of Hamburg, Germany */ 00005 /* */ 00006 /* This file is part of the VIGRA computer vision library. */ 00007 /* The VIGRA Website is */ 00008 /* http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/ */ 00009 /* Please direct questions, bug reports, and contributions to */ 00010 /* ullrich.koethe@iwr.uni-heidelberg.de or */ 00011 /* vigra@informatik.uni-hamburg.de */ 00012 /* */ 00013 /* Permission is hereby granted, free of charge, to any person */ 00014 /* obtaining a copy of this software and associated documentation */ 00015 /* files (the "Software"), to deal in the Software without */ 00016 /* restriction, including without limitation the rights to use, */ 00017 /* copy, modify, merge, publish, distribute, sublicense, and/or */ 00018 /* sell copies of the Software, and to permit persons to whom the */ 00019 /* Software is furnished to do so, subject to the following */ 00020 /* conditions: */ 00021 /* */ 00022 /* The above copyright notice and this permission notice shall be */ 00023 /* included in all copies or substantial portions of the */ 00024 /* Software. */ 00025 /* */ 00026 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */ 00027 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */ 00028 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */ 00029 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */ 00030 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */ 00031 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */ 00032 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */ 00033 /* OTHER DEALINGS IN THE SOFTWARE. */ 00034 /* */ 00035 /************************************************************************/ 00036 00037 #ifndef VIGRA_BASICIMAGEVIEW_HXX 00038 #define VIGRA_BASICIMAGEVIEW_HXX 00039 00040 #include "imageiterator.hxx" 00041 #include "initimage.hxx" 00042 00043 namespace vigra { 00044 00045 00046 /********************************************************/ 00047 /* */ 00048 /* BasicImageView */ 00049 /* */ 00050 /********************************************************/ 00051 00052 /** \brief BasicImage using foreign memory. 00053 00054 This class provides the same interface as \ref vigra::BasicImage 00055 (with the exception of <tt>resize()</tt>) but the image's 00056 memory is provided from the outside instead of allocated internally. 00057 00058 A <tt>BasicImageView</tt> can also be created from a 00059 \ref vigra::MultiArrayView with the appropriate shape -- see 00060 \ref MultiArrayToImage. 00061 00062 <b>\#include</b> <<a href="basicimageview_8hxx-source.html">vigra/basicimageview.hxx</a>> 00063 00064 Namespace: vigra 00065 */ 00066 template <class PIXELTYPE> 00067 class BasicImageView 00068 { 00069 public: 00070 00071 /** the BasicImageView's pixel type 00072 */ 00073 typedef PIXELTYPE value_type; 00074 00075 /** the BasicImageView's pixel type 00076 */ 00077 typedef PIXELTYPE PixelType; 00078 00079 /** the BasicImageView's reference type (i.e. the 00080 return type of image[diff] and image(dx,dy)) 00081 */ 00082 typedef PIXELTYPE & reference; 00083 00084 /** the BasicImageView's const reference type (i.e. the 00085 return type of image[diff] and image(dx,dy) when image is const) 00086 */ 00087 typedef PIXELTYPE const & const_reference; 00088 00089 /** the BasicImageView's pointer type 00090 */ 00091 typedef PIXELTYPE * pointer; 00092 00093 /** the BasicImageView's const pointer type 00094 */ 00095 typedef PIXELTYPE const * const_pointer; 00096 00097 /** the BasicImageView's 1D random access iterator 00098 (note: lower case 'iterator' is a STL compatible 1D random 00099 access iterator, don't confuse with capitalized Iterator) 00100 */ 00101 typedef PIXELTYPE * iterator; 00102 00103 /** deprecated, use <TT>iterator</TT> instead 00104 */ 00105 typedef PIXELTYPE * ScanOrderIterator; 00106 00107 /** the BasicImageView's 1D random access const iterator 00108 (note: lower case 'const_iterator' is a STL compatible 1D 00109 random access const iterator) 00110 */ 00111 typedef PIXELTYPE const * const_iterator; 00112 00113 /** deprecated, use <TT>const_iterator</TT> instead 00114 */ 00115 typedef PIXELTYPE const * ConstScanOrderIterator; 00116 00117 /** the BasicImageView's 2D random access iterator ('traverser') 00118 */ 00119 typedef ImageIterator<value_type> traverser; 00120 00121 /** deprecated, use <TT>traverser</TT> instead 00122 */ 00123 typedef ImageIterator<value_type> Iterator; 00124 00125 /** the BasicImageView's 2D random access const iterator ('const traverser') 00126 */ 00127 typedef ConstImageIterator<value_type> const_traverser; 00128 00129 /** deprecated, use <TT>const_traverser</TT> instead 00130 */ 00131 typedef ConstImageIterator<value_type> ConstIterator; 00132 00133 /** the row iterator associated with the traverser 00134 */ 00135 typedef typename traverser::row_iterator row_iterator; 00136 00137 /** the const row iterator associated with the const_traverser 00138 */ 00139 typedef typename const_traverser::row_iterator const_row_iterator; 00140 00141 /** the column iterator associated with the traverser 00142 */ 00143 typedef typename traverser::column_iterator column_iterator; 00144 00145 /** the const column iterator associated with the const_traverser 00146 */ 00147 typedef typename const_traverser::column_iterator const_column_iterator; 00148 00149 /** the BasicImageView's difference type (argument type of image[diff]) 00150 */ 00151 typedef Diff2D difference_type; 00152 00153 /** the BasicImageView's size type (result type of image.size()) 00154 */ 00155 typedef Size2D size_type; 00156 00157 /** the BasicImageView's default accessor 00158 */ 00159 typedef typename 00160 IteratorTraits<traverser>::DefaultAccessor Accessor; 00161 00162 /** the BasicImageView's default const accessor 00163 */ 00164 typedef typename 00165 IteratorTraits<const_traverser>::DefaultAccessor ConstAccessor; 00166 00167 /** construct image of size 0x0 00168 */ 00169 BasicImageView() 00170 : data_(0), 00171 width_(0), 00172 height_(0), 00173 stride_(0) 00174 {} 00175 00176 /** construct view of size w x h 00177 */ 00178 BasicImageView(const_pointer data, int w, int h, int stride = 0) 00179 : data_(const_cast<pointer>(data)), 00180 width_(w), 00181 height_(h), 00182 stride_(stride == 0 ? w : stride) 00183 {} 00184 00185 /** construct view of size size.x x size.y 00186 */ 00187 BasicImageView(const_pointer data, difference_type const & size, int stride = 0) 00188 : data_(const_cast<pointer>(data)), 00189 width_(size.x), 00190 height_(size.y), 00191 stride_(stride == 0 ? size.x : stride) 00192 {} 00193 00194 /** set Image with const value 00195 */ 00196 BasicImageView & init(value_type const & pixel) 00197 { 00198 initImage(upperLeft(), lowerRight(), accessor(), pixel); 00199 00200 return *this; 00201 } 00202 00203 /** width of Image 00204 */ 00205 int width() const 00206 { 00207 return width_; 00208 } 00209 00210 /** height of Image 00211 */ 00212 int height() const 00213 { 00214 return height_; 00215 } 00216 00217 /** stride of Image. 00218 Memory offset between the start of two successive rows. 00219 */ 00220 int stride() const 00221 { 00222 return stride_; 00223 } 00224 00225 /** size of Image 00226 */ 00227 size_type size() const 00228 { 00229 return size_type(width(), height()); 00230 } 00231 00232 /** test whether a given coordinate is inside the image 00233 */ 00234 bool isInside(difference_type const & d) const 00235 { 00236 return d.x >= 0 && d.y >= 0 && 00237 d.x < width() && d.y < height(); 00238 } 00239 00240 /** access pixel at given location. <br> 00241 usage: <TT> value_type value = image[Diff2D(1,2)] </TT> 00242 */ 00243 reference operator[](difference_type const & d) 00244 { 00245 return data_[d.y*stride_ + d.x]; 00246 } 00247 00248 /** read pixel at given location. <br> 00249 usage: <TT> value_type value = image[Diff2D(1,2)] </TT> 00250 */ 00251 const_reference operator[](difference_type const & d) const 00252 { 00253 return data_[d.y*stride_ + d.x]; 00254 } 00255 00256 /** access pixel at given location. <br> 00257 usage: <TT> value_type value = image(1,2) </TT> 00258 */ 00259 reference operator()(int dx, int dy) 00260 { 00261 return data_[dy*stride_ + dx]; 00262 } 00263 00264 /** read pixel at given location. <br> 00265 usage: <TT> value_type value = image(1,2) </TT> 00266 */ 00267 const_reference operator()(int dx, int dy) const 00268 { 00269 return data_[dy*stride_ + dx]; 00270 } 00271 00272 /** access pixel at given location. 00273 Note that the 'x' index is the trailing index. <br> 00274 usage: <TT> value_type value = image[2][1] </TT> 00275 */ 00276 pointer operator[](int dy) 00277 { 00278 return data_ + dy*stride_; 00279 } 00280 00281 /** read pixel at given location. 00282 Note that the 'x' index is the trailing index. <br> 00283 usage: <TT> value_type value = image[2][1] </TT> 00284 */ 00285 const_pointer operator[](int dy) const 00286 { 00287 return data_ + dy*stride_; 00288 } 00289 00290 /** init 2D random access iterator poining to upper left pixel 00291 */ 00292 traverser upperLeft() 00293 { 00294 return traverser(data_, stride_); 00295 } 00296 00297 /** init 2D random access iterator poining to 00298 pixel(width, height), i.e. one pixel right and below lower right 00299 corner of the image as is common in C/C++. 00300 */ 00301 traverser lowerRight() 00302 { 00303 return upperLeft() + size(); 00304 } 00305 00306 /** init 2D random access const iterator poining to upper left pixel 00307 */ 00308 const_traverser upperLeft() const 00309 { 00310 return const_traverser(data_, stride_); 00311 } 00312 00313 /** init 2D random access const iterator poining to 00314 pixel(width, height), i.e. one pixel right and below lower right 00315 corner of the image as is common in C/C++. 00316 */ 00317 const_traverser lowerRight() const 00318 { 00319 return upperLeft() + size(); 00320 } 00321 00322 /** init 1D random access iterator pointing to first pixel. 00323 Note: Only works if stride equals width. 00324 */ 00325 iterator begin() 00326 { 00327 vigra_precondition(stride_ == width_, 00328 "BasicImageView::begin(): " 00329 "can only create scan order iterator if width() == stride()."); 00330 return data_; 00331 } 00332 00333 /** init 1D random access iterator pointing past the end. 00334 Note: Only works if stride equals width. 00335 */ 00336 iterator end() 00337 { 00338 vigra_precondition(stride_ == width_, 00339 "BasicImageView::end(): " 00340 "can only create scan order iterator if width() == stride()."); 00341 return data_ + width() * height(); 00342 } 00343 00344 /** init 1D random access const iterator pointing to first pixel. 00345 Note: Only works if stride equals width. 00346 */ 00347 const_iterator begin() const 00348 { 00349 vigra_precondition(stride_ == width_, 00350 "BasicImageView::begin(): " 00351 "can only create scan order iterator if width() == stride()."); 00352 return data_; 00353 } 00354 00355 /** init 1D random access const iterator pointing past the end. 00356 Note: Only works if stride equals width. 00357 */ 00358 const_iterator end() const 00359 { 00360 vigra_precondition(stride_ == width_, 00361 "BasicImageView::end(): " 00362 "can only create scan order iterator if width() == stride()."); 00363 return data_ + width() * height(); 00364 } 00365 00366 /** init 1D random access iterator pointing to first pixel of row \a y 00367 */ 00368 row_iterator rowBegin(int y) 00369 { 00370 return data_ + stride_ * y; 00371 } 00372 00373 /** init 1D random access iterator pointing past the end of row \a y 00374 */ 00375 row_iterator rowEnd(int y) 00376 { 00377 return rowBegin(y) + width(); 00378 } 00379 00380 /** init 1D random access const iterator pointing to first pixel of row \a y 00381 */ 00382 const_row_iterator rowBegin(int y) const 00383 { 00384 return data_ + stride_ * y; 00385 } 00386 00387 /** init 1D random access const iterator pointing past the end of row \a y 00388 */ 00389 const_row_iterator rowEnd(int y) const 00390 { 00391 return rowBegin(y) + width(); 00392 } 00393 00394 /** init 1D random access iterator pointing to first pixel of column \a x 00395 */ 00396 column_iterator columnBegin(int x) 00397 { 00398 typedef typename column_iterator::BaseType Iter; 00399 return column_iterator(Iter(data_ + x, stride_)); 00400 } 00401 00402 /** init 1D random access iterator pointing past the end of column \a x 00403 */ 00404 column_iterator columnEnd(int x) 00405 { 00406 return columnBegin(x) + height(); 00407 } 00408 00409 /** init 1D random access const iterator pointing to first pixel of column \a x 00410 */ 00411 const_column_iterator columnBegin(int x) const 00412 { 00413 typedef typename const_column_iterator::BaseType Iter; 00414 return const_column_iterator(Iter(data_ + x, stride_)); 00415 } 00416 00417 /** init 1D random access const iterator pointing past the end of column \a x 00418 */ 00419 const_column_iterator columnEnd(int x) const 00420 { 00421 return columnBegin(x) + height(); 00422 } 00423 00424 /** get a pointer to the internal data 00425 */ 00426 const_pointer data() const 00427 { 00428 return data_; 00429 } 00430 00431 /** return default accessor 00432 */ 00433 Accessor accessor() 00434 { 00435 return Accessor(); 00436 } 00437 00438 /** return default const accessor 00439 */ 00440 ConstAccessor accessor() const 00441 { 00442 return ConstAccessor(); 00443 } 00444 00445 private: 00446 00447 pointer data_; 00448 int width_, height_, stride_; 00449 }; 00450 00451 00452 /********************************************************/ 00453 /* */ 00454 /* argument object factories */ 00455 /* */ 00456 /********************************************************/ 00457 00458 template <class PixelType, class Accessor> 00459 inline triple<typename BasicImageView<PixelType>::const_traverser, 00460 typename BasicImageView<PixelType>::const_traverser, Accessor> 00461 srcImageRange(BasicImageView<PixelType> const & img, Accessor a) 00462 { 00463 return triple<typename BasicImageView<PixelType>::const_traverser, 00464 typename BasicImageView<PixelType>::const_traverser, 00465 Accessor>(img.upperLeft(), 00466 img.lowerRight(), 00467 a); 00468 } 00469 00470 template <class PixelType, class Accessor> 00471 inline triple<typename BasicImageView<PixelType>::const_traverser, 00472 typename BasicImageView<PixelType>::const_traverser, Accessor> 00473 srcImageRange(BasicImageView<PixelType> const & img, Rect2D const & roi, Accessor a) 00474 { 00475 vigra_precondition(roi.left() >= 0 && roi.top() >= 0 && 00476 roi.right() <= img.width() && roi.bottom() <= img.height(), 00477 "srcImageRange(): ROI rectangle outside image."); 00478 return triple<typename BasicImageView<PixelType>::const_traverser, 00479 typename BasicImageView<PixelType>::const_traverser, 00480 Accessor>(img.upperLeft() + roi.upperLeft(), 00481 img.upperLeft() + roi.lowerRight(), 00482 a); 00483 } 00484 00485 template <class PixelType, class Accessor> 00486 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor> 00487 srcImage(BasicImageView<PixelType> const & img, Accessor a) 00488 { 00489 return pair<typename BasicImageView<PixelType>::const_traverser, 00490 Accessor>(img.upperLeft(), a); 00491 } 00492 00493 template <class PixelType, class Accessor> 00494 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor> 00495 srcImage(BasicImageView<PixelType> const & img, Point2D const & ul, Accessor a) 00496 { 00497 vigra_precondition(img.isInside(ul), 00498 "srcImage(): ROI rectangle outside image."); 00499 return pair<typename BasicImageView<PixelType>::const_traverser, 00500 Accessor>(img.upperLeft() + ul, a); 00501 } 00502 00503 template <class PixelType, class Accessor> 00504 inline triple<typename BasicImageView<PixelType>::traverser, 00505 typename BasicImageView<PixelType>::traverser, Accessor> 00506 destImageRange(BasicImageView<PixelType> & img, Accessor a) 00507 { 00508 return triple<typename BasicImageView<PixelType>::traverser, 00509 typename BasicImageView<PixelType>::traverser, 00510 Accessor>(img.upperLeft(), 00511 img.lowerRight(), 00512 a); 00513 } 00514 00515 template <class PixelType, class Accessor> 00516 inline triple<typename BasicImageView<PixelType>::traverser, 00517 typename BasicImageView<PixelType>::traverser, Accessor> 00518 destImageRange(BasicImageView<PixelType> & img, Rect2D const & roi, Accessor a) 00519 { 00520 vigra_precondition(roi.left() >= 0 && roi.top() >= 0 && 00521 roi.right() <= img.width() && roi.bottom() <= img.height(), 00522 "destImageRange(): ROI rectangle outside image."); 00523 return triple<typename BasicImageView<PixelType>::traverser, 00524 typename BasicImageView<PixelType>::traverser, 00525 Accessor>(img.upperLeft() + roi.upperLeft(), 00526 img.upperLeft() + roi.lowerRight(), 00527 a); 00528 } 00529 00530 template <class PixelType, class Accessor> 00531 inline pair<typename BasicImageView<PixelType>::traverser, Accessor> 00532 destImage(BasicImageView<PixelType> & img, Accessor a) 00533 { 00534 return pair<typename BasicImageView<PixelType>::traverser, 00535 Accessor>(img.upperLeft(), a); 00536 } 00537 00538 template <class PixelType, class Accessor> 00539 inline pair<typename BasicImageView<PixelType>::traverser, Accessor> 00540 destImage(BasicImageView<PixelType> & img, Point2D const & ul, Accessor a) 00541 { 00542 vigra_precondition(img.isInside(ul), 00543 "destImage(): ROI rectangle outside image."); 00544 return pair<typename BasicImageView<PixelType>::traverser, 00545 Accessor>(img.upperLeft() + ul, a); 00546 } 00547 00548 template <class PixelType, class Accessor> 00549 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor> 00550 maskImage(BasicImageView<PixelType> const & img, Accessor a) 00551 { 00552 return pair<typename BasicImageView<PixelType>::const_traverser, 00553 Accessor>(img.upperLeft(), a); 00554 } 00555 00556 template <class PixelType, class Accessor> 00557 inline pair<typename BasicImageView<PixelType>::const_traverser, Accessor> 00558 maskImage(BasicImageView<PixelType> const & img, Point2D const & ul, Accessor a) 00559 { 00560 vigra_precondition(img.isInside(ul), 00561 "maskImage(): ROI rectangle outside image."); 00562 return pair<typename BasicImageView<PixelType>::const_traverser, 00563 Accessor>(img.upperLeft() + ul, a); 00564 } 00565 00566 /****************************************************************/ 00567 00568 template <class PixelType> 00569 inline triple<typename BasicImageView<PixelType>::const_traverser, 00570 typename BasicImageView<PixelType>::const_traverser, 00571 typename BasicImageView<PixelType>::ConstAccessor> 00572 srcImageRange(BasicImageView<PixelType> const & img) 00573 { 00574 return triple<typename BasicImageView<PixelType>::const_traverser, 00575 typename BasicImageView<PixelType>::const_traverser, 00576 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft(), 00577 img.lowerRight(), 00578 img.accessor()); 00579 } 00580 00581 template <class PixelType> 00582 inline triple<typename BasicImageView<PixelType>::const_traverser, 00583 typename BasicImageView<PixelType>::const_traverser, 00584 typename BasicImageView<PixelType>::ConstAccessor> 00585 srcImageRange(BasicImageView<PixelType> const & img, Rect2D const & roi) 00586 { 00587 vigra_precondition(roi.left() >= 0 && roi.top() >= 0 && 00588 roi.right() <= img.width() && roi.bottom() <= img.height(), 00589 "srcImageRange(): ROI rectangle outside image."); 00590 return triple<typename BasicImageView<PixelType>::const_traverser, 00591 typename BasicImageView<PixelType>::const_traverser, 00592 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft() + roi.upperLeft(), 00593 img.upperLeft() + roi.lowerRight(), 00594 img.accessor()); 00595 } 00596 00597 template <class PixelType> 00598 inline pair< typename BasicImageView<PixelType>::const_traverser, 00599 typename BasicImageView<PixelType>::ConstAccessor> 00600 srcImage(BasicImageView<PixelType> const & img) 00601 { 00602 return pair<typename BasicImageView<PixelType>::const_traverser, 00603 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft(), 00604 img.accessor()); 00605 } 00606 00607 template <class PixelType> 00608 inline pair< typename BasicImageView<PixelType>::const_traverser, 00609 typename BasicImageView<PixelType>::ConstAccessor> 00610 srcImage(BasicImageView<PixelType> const & img, Point2D const & ul) 00611 { 00612 vigra_precondition(img.isInside(ul), 00613 "srcImage(): ROI rectangle outside image."); 00614 return pair<typename BasicImageView<PixelType>::const_traverser, 00615 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft() + ul, 00616 img.accessor()); 00617 } 00618 00619 template <class PixelType> 00620 inline triple< typename BasicImageView<PixelType>::traverser, 00621 typename BasicImageView<PixelType>::traverser, 00622 typename BasicImageView<PixelType>::Accessor> 00623 destImageRange(BasicImageView<PixelType> & img) 00624 { 00625 return triple<typename BasicImageView<PixelType>::traverser, 00626 typename BasicImageView<PixelType>::traverser, 00627 typename BasicImageView<PixelType>::Accessor>(img.upperLeft(), 00628 img.lowerRight(), 00629 img.accessor()); 00630 } 00631 00632 template <class PixelType> 00633 inline triple< typename BasicImageView<PixelType>::traverser, 00634 typename BasicImageView<PixelType>::traverser, 00635 typename BasicImageView<PixelType>::Accessor> 00636 destImageRange(BasicImageView<PixelType> & img, Rect2D const & roi) 00637 { 00638 vigra_precondition(roi.left() >= 0 && roi.top() >= 0 && 00639 roi.right() <= img.width() && roi.bottom() <= img.height(), 00640 "destImageRange(): ROI rectangle outside image."); 00641 return triple<typename BasicImageView<PixelType>::traverser, 00642 typename BasicImageView<PixelType>::traverser, 00643 typename BasicImageView<PixelType>::Accessor>(img.upperLeft() + roi.upperLeft(), 00644 img.upperLeft() + roi.lowerRight(), 00645 img.accessor()); 00646 } 00647 00648 template <class PixelType> 00649 inline pair< typename BasicImageView<PixelType>::traverser, 00650 typename BasicImageView<PixelType>::Accessor> 00651 destImage(BasicImageView<PixelType> & img) 00652 { 00653 return pair<typename BasicImageView<PixelType>::traverser, 00654 typename BasicImageView<PixelType>::Accessor>(img.upperLeft(), 00655 img.accessor()); 00656 } 00657 00658 template <class PixelType> 00659 inline pair< typename BasicImageView<PixelType>::traverser, 00660 typename BasicImageView<PixelType>::Accessor> 00661 destImage(BasicImageView<PixelType> & img, Point2D const & ul) 00662 { 00663 vigra_precondition(img.isInside(ul), 00664 "destImage(): ROI rectangle outside image."); 00665 return pair<typename BasicImageView<PixelType>::traverser, 00666 typename BasicImageView<PixelType>::Accessor>(img.upperLeft() + ul, 00667 img.accessor()); 00668 } 00669 00670 template <class PixelType> 00671 inline pair< typename BasicImageView<PixelType>::const_traverser, 00672 typename BasicImageView<PixelType>::ConstAccessor> 00673 maskImage(BasicImageView<PixelType> const & img) 00674 { 00675 return pair<typename BasicImageView<PixelType>::const_traverser, 00676 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft(), 00677 img.accessor()); 00678 } 00679 00680 template <class PixelType> 00681 inline pair< typename BasicImageView<PixelType>::const_traverser, 00682 typename BasicImageView<PixelType>::ConstAccessor> 00683 maskImage(BasicImageView<PixelType> const & img, Point2D const & ul) 00684 { 00685 vigra_precondition(img.isInside(ul), 00686 "maskImage(): ROI rectangle outside image."); 00687 return pair<typename BasicImageView<PixelType>::const_traverser, 00688 typename BasicImageView<PixelType>::ConstAccessor>(img.upperLeft() + ul, 00689 img.accessor()); 00690 } 00691 00692 } // namespace vigra 00693 00694 #endif /* VIGRA_BASICIMAGEVIEW_HXX */
© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) |
html generated using doxygen and Python
|