vigra - vigra/coordinate_iterator.hxx Source File

[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

coordinate_iterator.hxx |

1 /************************************************************************/
2 /* */
3 /* Copyright 2011-2012 by Markus Nullmeier and Ullrich Koethe */
4 /* */
5 /* This file is part of the VIGRA computer vision library. */
6 /* The VIGRA Website is */
7 /* http://hci.iwr.uni-heidelberg.de/vigra/ */
8 /* Please direct questions, bug reports, and contributions to */
9 /* ullrich.koethe@iwr.uni-heidelberg.de or */
10 /* vigra@informatik.uni-hamburg.de */
11 /* */
12 /* Permission is hereby granted, free of charge, to any person */
13 /* obtaining a copy of this software and associated documentation */
14 /* files (the "Software"), to deal in the Software without */
15 /* restriction, including without limitation the rights to use, */
16 /* copy, modify, merge, publish, distribute, sublicense, and/or */
17 /* sell copies of the Software, and to permit persons to whom the */
18 /* Software is furnished to do so, subject to the following */
19 /* conditions: */
20 /* */
21 /* The above copyright notice and this permission notice shall be */
22 /* included in all copies or substantial portions of the */
23 /* Software. */
24 /* */
25 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
26 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
27 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
28 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
29 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
30 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
31 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
32 /* OTHER DEALINGS IN THE SOFTWARE. */
33 /* */
34 /************************************************************************/
35
36 #ifndef VIGRA_COORDINATE_ITERATOR_HXX
37 #define VIGRA_COORDINATE_ITERATOR_HXX
38
39 #include <complex>
40
41 #include "tuple.hxx"
42 #include "accessor.hxx"
43 #include "tinyvector.hxx"
44 #include "numerictraits.hxx"
45 #include "multi_iterator.hxx"
46 #include "multi_array.hxx"
47
48 namespace vigra {
49
50 template<unsigned N>
51 struct StridePair
52 {
53 typedef typename MultiArrayShape<N>::type index_type;
54 typedef TinyVector<double, N> coord_type;
55 typedef coord_type deref_type;
56 typedef StridePair type;
57 typedef StridePair stride_type;
58 typedef TinyVector<type, N> stride_array_type;
59 typedef TinyVector<index_type, N> shape_array_type;
60 typedef shape_array_type shape_type;
61
62 index_type index;
63 coord_type coord;
64
65 StridePair(const index_type & i) : index(i), coord(i) {}
66 StridePair(const coord_type & c) : index(), coord(c) {}
67 StridePair(const index_type & i, const coord_type & c)
68 : index (i), coord(c) {}
69 StridePair( MultiArrayIndex i, const coord_type & c)
70 : index(index_type(i)), coord(c) {}
71 StridePair() {}
72
73 // use just the coordinates for further processing ...
74 const coord_type & operator*() const
75 {
76 return this->coord;
77 }
78
79 void operator+=(const StridePair & x)
80 {
81 index += x.index;
82 coord += x.coord;
83 }
84 void operator-=(const StridePair & x)
85 {
86 index -= x.index;
87 coord -= x.coord;
88 }
89 StridePair operator+(const StridePair & x)
90 {
91 StridePair ret = *this;
92 ret += x;
93 return ret;
94 }
95 StridePair operator-(const StridePair & x)
96 {
97 StridePair ret = *this;
98 ret -= x;
99 return ret;
100 }
101 StridePair operator*(const StridePair & x)
102 {
103 StridePair ret = *this;
104 ret.index *= x.index;
105 ret.coord *= x.coord;
106 return ret;
107 }
108 StridePair operator/(const StridePair & x)
109 {
110 StridePair ret = *this;
111 ret.index /= x.index;
112 ret.coord /= x.coord;
113 return ret;
114 }
115
116 MultiArrayIndex & idx0()
117 {
118 return index[0];
119 }
120 const index_type & idx() const
121 {
122 return index;
123 }
124
125 double & dim0()
126 {
127 return coord[0];
128 }
129 double dim0() const
130 {
131 return coord[0];
132 }
133 };
134
135 template<unsigned M>
136 struct NumericTraits<StridePair<M> >
137 : public NumericTraits<typename StridePair<M>::index_type>
138 {};
139
140 template<unsigned N>
141 struct StridePairCoord : public TinyVector<double, N>
142 {
143 typedef TinyVector<double, N> entry_type;
144
145 StridePairCoord(const entry_type & c) : entry_type(c) {}
146 StridePairCoord() {}
147
148 double & dim0()
149 {
150 return (*this)[0];
151 }
152 double dim0() const
153 {
154 return (*this)[0];
155 }
156 };
157 template<unsigned M>
158 struct NumericTraits<StridePairCoord<M> >
159 : public NumericTraits<typename StridePairCoord<M>::entry_type>
160 {};
161
162 template<unsigned N>
163 struct StridePairDiff : public StridePairCoord<N>
164 {
165 MultiArrayIndex c;
166
167 typedef StridePairCoord<N> base_type;
168 StridePairDiff(MultiArrayIndex c_, const base_type & x)
169 : base_type(x), c(c_) {}
170 StridePairDiff(const base_type & x)
171 : base_type(x), c(0) {}
172 StridePairDiff(const TinyVector<double, N> & x)
173 : base_type(x), c(0) {}
174 StridePairDiff(const TinyVector<MultiArrayIndex, N> & x)
175 : base_type(x), c(0) {}
176 StridePairDiff() : c(0) {}
177
178 const base_type & base() const
179 {
180 return *this;
181 }
182 StridePairDiff operator*(const StridePairDiff & x)
183 {
184 StridePairDiff ret = base() * x.base();
185 ret.c = c * x.c;
186 return ret;
187 }
188 };
189
190 template<unsigned M>
191 struct NumericTraits<StridePairDiff<M> >
192 : public NumericTraits<StridePairCoord<M> >
193 {};
194
195 template<unsigned N, class T>
196 struct StridePairPointer : public StridePairCoord<N>
197 {
198 typedef const T* index_type;
199 typedef StridePairCoord<N> coord_type;
200 typedef typename coord_type::entry_type coord_num_type;
201 typedef StridePairPointer type;
202 typedef type deref_type;
203 typedef StridePairDiff<N> stride_type;
204 typedef TinyVector<stride_type, N> stride_array_type;
205 typedef typename MultiArrayShape<N>::type shape_array_type;
206 typedef shape_array_type shape_type;
207
208 index_type index;
209
210 StridePairPointer(const index_type & i, const coord_type & c)
211 : coord_type(c), index(i) {}
212
213 const type & operator*() const
214 {
215 return *this;
216 }
217 const T & value() const
218 {
219 return *index;
220 }
221 const coord_type & coord() const
222 {
223 return *this;
224 }
225
226 index_type & idx0()
227 {
228 return index;
229 }
230 const index_type & idx() const
231 {
232 return index;
233 }
234
235 void operator+=(stride_type x)
236 {
237 index += x.c;
238 coord_type::operator+=(x);
239 }
240 void operator-=(stride_type x)
241 {
242 index -= x.c;
243 coord_type::operator-=(x);
244 }
245 };
246
247 template<unsigned M, class T>
248 struct NumericTraits<StridePairPointer<M, T> >
249 : public NumericTraits<typename StridePairPointer<M, T>::coord_type>
250 {};
251
252 namespace detail {
253
254 template<class T, bool is_complex = NumericTraits<T>::isComplex::value,
255 bool is_vector = !NumericTraits<T>::isScalar::value>
256 struct weighted_abs
257 {
258 static double get(const T & x)
259 {
260 return x;
261 }
262 };
263
264 template<class T>
265 struct weighted_abs<T, true, false>
266 {
267 static double get(const T & x)
268 {
269 using std::abs;
270 return abs(x);
271 }
272 };
273
274 template<class T, bool is_complex>
275 struct weighted_abs<T, is_complex, true>
276 {
277 static double get(const T & x)
278 {
279 return x.magnitude();
280 }
281 };
282
283 template<class T>
284 struct accumulable_coord_access;
285 template<class T>
286 struct accumulable_value_access;
287 template<class T>
288 struct accumulable_weighted_access;
289
290 template<unsigned N, class T>
291 struct accumulable_coord_access<StridePairPointer<N, T> >
292 {
293 typedef StridePairPointer<N, T> accumulable_type;
294 typedef typename accumulable_type::coord_num_type type;
295 static const type & get(const accumulable_type & v) { return v.coord(); }
296 };
297
298 template<unsigned N, class T>
299 struct accumulable_value_access<StridePairPointer<N, T> >
300 {
301 typedef StridePairPointer<N, T> accumulable_type;
302 typedef T type;
303 static const type & get(const accumulable_type & v) { return v.value(); }
304 };
305
306 template<unsigned N, class T>
307 struct accumulable_weighted_access<StridePairPointer<N, T> >
308 {
309 typedef StridePairPointer<N, T> accumulable_type;
310 typedef typename accumulable_type::coord_num_type type;
311 static type get(const accumulable_type & v)
312 {
313 return weighted_abs<T>::get(v.value()) * v.coord();
314 }
315 };
316
317 template<class X>
318 void dismember(X & r, const X & x, unsigned i)
319 {
320 r[i] = x[i];
321 }
322 template<unsigned N>
323 void dismember(StridePair<N> & r, const StridePair<N> & x, unsigned i)
324 {
325 r.index[i] = x.index[i];
326 r.coord[i] = x.coord[i];
327 }
328 template<unsigned N>
329 void dismember(StridePairDiff<N> & r, const StridePairDiff<N> & x, unsigned i)
330 {
331 r.c = static_cast<MultiArrayIndex>(r[i] = x[i]);
332 }
333
334 template<unsigned N, class X>
335 TinyVector<X, N>
336 dismember(const X & x)
337 {
338 TinyVector<X, N> ret;
339 for (unsigned i = 0; i != N; ++i)
340 dismember(ret[i], x, i);
341 return ret;
342 }
343 template<unsigned N>
344 TinyVector<StridePairDiff<N>, N>
345 dismember(const TinyVector<MultiArrayIndex, N> & x,
346 const StridePairCoord<N> & y)
347 {
348 typedef StridePairDiff<N> type;
349 TinyVector<type, N> ret;
350 for (unsigned i = 0; i != N; ++i)
351 {
352 ret[i].c = x[i];
353 ret[i][i] = y[i];
354 }
355 return ret;
356 }
357
358 } // namespace detail
359
360 // A fake "pointer" for MultiIterator containing coordinates.
361 // Indices (or a pointer) cannot be circumvented in coordiante iterators,
362 // since floating point addition is not associative and
363 // iterator comparison is done via via '<' or '!='. Class CoordinateStride
364 // thus forwards iterator comparison to the index or pointer part
365 // of its template parameter S.
366 template<unsigned N, class S = StridePair<N> >
367 class CoordinateStride : protected S
368 {
369 public:
370 typedef MultiArrayIndex difference_type;
371 typedef typename S::stride_type stride_type;
372 typedef typename S::deref_type deref_type;
373 typedef CoordinateStride<N> type;
374 typedef typename S::coord_type coord_type;
375 typedef typename S::index_type index_type;
376 typedef typename S::shape_array_type shape_array_type;
377
378 protected:
379 double stride_0;
380
381 CoordinateStride(void*) {} // used MultiIterator ctor, unused.
382
383 public:
384 CoordinateStride(const S & x, double s0)
385 : S(x), stride_0(s0) {}
386
387 #ifndef DOXYGEN
388 using S::operator*;
389 using S::idx0;
390 using S::idx;
391 using S::dim0;
392 using S::operator+=;
393 using S::operator-=;
394 #endif
395
396 void operator++()
397 {
398 ++idx0();
399 dim0() += stride_0;
400 }
401 void operator--()
402 {
403 --idx0();
404 dim0() -= stride_0;
405 }
406 void operator+=(difference_type n)
407 {
408 idx0() += n;
409 dim0() += n * stride_0;
410 }
411 void operator-=(difference_type n)
412 {
413 idx0() -= n;
414 dim0() -= n * stride_0;
415 }
416
417 stride_type operator[](difference_type n) const
418 {
419 type ret = *this;
420 ret[0] += n;
421 return ret;
422 }
423
424 stride_type operator[](stride_type x) const
425 {
426 return *this + x;
427 }
428
429 // ... but use the idx() for comparisons:
430 bool operator!=(const CoordinateStride & y) const
431 {
432 return idx() != y.idx();
433 }
434 bool operator==(const CoordinateStride & y) const
435 {
436 if (stride_0 != y.stride_0)
437 return false;
438 return idx() == y.idx();
439 }
440 bool operator<(const CoordinateStride & y) const
441 {
442 return idx() < y.idx();
443 }
444
445 bool operator<=(const CoordinateStride & y) const
446 {
447 if (stride_0 == y.stride_0)
448 return true;
449 return *this < y;
450 }
451 bool operator>(const CoordinateStride & y) const
452 {
453 return y < *this;
454 }
455 bool operator>=(const CoordinateStride & y) const
456 {
457 if (stride_0 == y.stride_0)
458 return true;
459 return operator>(y);
460 }
461
462 friend std::ostream &
463 operator<<(std::ostream & os, const CoordinateStride & x)
464 {
465 os << "{" << x.stride_0 << ": " << static_cast<const S &>(x) << "}";
466 return os;
467 }
468
469 typedef MultiIterator<N, deref_type, const deref_type &, CoordinateStride>
470 iterator_type;
471 };
472
473 template <unsigned N, class S>
474 struct MultiIteratorStrideTraits<CoordinateStride<N, S> >
475 {
476 typedef typename S::stride_type stride_type;
477 typedef typename S::stride_array_type stride_array_type;
478 typedef typename S::shape_array_type shape_array_type;
479 static stride_array_type shift(const stride_array_type & s, unsigned d)
480 {
481 stride_array_type ret;
482 for (unsigned i = d; i != N; ++i)
483 ret[i - d] = s[i];
484 return ret;
485 }
486 };
487
488 template <unsigned N>
489 struct CoordinateMultiIterator : public CoordinateStride<N>::iterator_type
490 {
491 typedef CoordinateStride<N> ptr_type;
492 typedef typename ptr_type::iterator_type base_type;
493 typedef typename ptr_type::stride_type stride_type;
494 typedef typename ptr_type::shape_array_type shape_array_type;
495 typedef typename ptr_type::coord_type coord_type;
496 typedef typename ptr_type::index_type index_type;
497
498 CoordinateMultiIterator(const stride_type & origin,
499 const stride_type & stride,
500 const index_type & shape)
501
502 : base_type(ptr_type(origin, stride.dim0()),
503 detail::dismember<N>(stride),
504 detail::dismember<N>(shape)) {}
505
506 CoordinateMultiIterator(const base_type & x) : base_type(x) {}
507 };
508
509 namespace detail {
510
511 template<unsigned N>
512 struct CoordinateMultiRangeReturns
513 {
514 typedef CoordinateMultiIterator<N> iterator_type;
515 typedef typename iterator_type::coord_type coord_type;
516 typedef StridePair<N> pair_type;
517 typedef typename pair_type::type stride_type;
518 typedef typename pair_type::stride_array_type stride_array_type;
519
520 typedef typename AccessorTraits<coord_type>::default_const_accessor
521 access_type;
522 typedef triple<iterator_type, stride_array_type, access_type> type;
523 };
524
525 } // namespace detail
526
527 template <unsigned N>
528 typename detail::CoordinateMultiRangeReturns<N>::type
529 coordinateMultiRange(const typename MultiArrayShape<N>::type & shape,
530 const TinyVector<double, N> & stride
531 = TinyVector<double, N>(1.0),
532 const TinyVector<double, N> & origin
533 = TinyVector<double, N>(0.0))
534 {
535 typedef typename
536 detail::CoordinateMultiRangeReturns<N>::stride_type stride_type;
537 typedef typename
538 detail::CoordinateMultiRangeReturns<N>::access_type access_type;
539
540 return typename detail::CoordinateMultiRangeReturns<N>::type
541 (CoordinateMultiIterator<N>(stride_type(0, origin),
542 stride_type(1, stride),
543 shape),
544 detail::dismember<N>(stride_type(shape)),
545 access_type());
546 }
547
548 template <unsigned N, class T>
549 struct CombinedMultiIterator
550 : public CoordinateStride<N, StridePairPointer<N, T> >::iterator_type
551 {
552 typedef StridePairPointer<N, T> pair_type;
553 typedef CoordinateStride<N, pair_type> ptr_type;
554 typedef typename ptr_type::iterator_type base_type;
555 typedef typename ptr_type::stride_type stride_type;
556 typedef typename ptr_type::coord_type coord_type;
557 typedef typename pair_type::shape_array_type shape_array_type;
558
559 CombinedMultiIterator(const T* raw_pointer,
560 const stride_type & origin,
561 const TinyVector<MultiArrayIndex, N> & pointer_stride,
562 const stride_type & stride,
563 const shape_array_type & shape)
564
565 : base_type(ptr_type(pair_type(raw_pointer, origin), stride.dim0()),
566 detail::dismember<N>(pointer_stride, stride),
567 shape) {}
568
569 CombinedMultiIterator(const base_type & x) : base_type(x) {}
570 };
571
572 template<unsigned N, class T>
573 struct SrcCoordinateMultiArrayRangeReturns
574 {
575 typedef CombinedMultiIterator<N, T> iterator_type;
576 typedef typename iterator_type::coord_type coord_type;
577 typedef typename iterator_type::pair_type pair_type;
578 typedef typename iterator_type::ptr_type ptr_type;
579 typedef typename ptr_type::deref_type deref_type;
580 typedef typename iterator_type::stride_type stride_type;
581 typedef typename pair_type::stride_array_type stride_array_type;
582 typedef typename pair_type::shape_array_type shape_array_type;
583
584 typedef typename AccessorTraits<deref_type>::default_const_accessor
585 access_type;
586 typedef triple<iterator_type, stride_array_type, access_type> type;
587 };
588
589 // work around GCC 4.4.3 template argument deduction bug:
590 template<unsigned N>
591 struct CoordinateSteps
592 {
593 typedef const TinyVector<double, N> & type;
594 };
595
596 template <unsigned int N, class T, class StrideTag>
597 inline typename SrcCoordinateMultiArrayRangeReturns<N, T>::type
598 srcCoordinateMultiArrayRange(const MultiArrayView<N, T, StrideTag> & array,
599 typename CoordinateSteps<N>::type stride
600 = TinyVector<double, N>(1.0),
601 typename CoordinateSteps<N>::type origin
602 = TinyVector<double, N>(0.0))
603 {
604 typedef SrcCoordinateMultiArrayRangeReturns<N, T> returns;
605 typedef typename returns::type type;
606 typedef typename returns::stride_type stride_type;
607 typedef typename returns::access_type access_type;
608 typedef typename returns::iterator_type iterator_type;
609 typedef typename returns::shape_array_type shape_array_type;
610
611 shape_array_type shape = array.shape();
612 return type(iterator_type(array.traverser_begin().get(),
613 stride_type(origin),
614 array.stride(),
615 stride_type(stride),
616 shape),
617 detail::dismember<N>(stride_type(shape)),
618 access_type());
619 }
620
621 template <class VALUETYPE, class COORD>
622 struct AccessorCoordinatePair
623 {
624 typedef VALUETYPE value_type;
625 typedef COORD coord_type;
626 typedef AccessorCoordinatePair type;
627
628 value_type v;
629 const coord_type & c;
630
631 AccessorCoordinatePair(const value_type & v_, const coord_type & c_)
632 : v(v_), c(c_) {}
633
634 const value_type & value() const
635 {
636 return v;
637 }
638 const coord_type & coord() const
639 {
640 return c;
641 }
642 };
643
644 /** \brief Forward accessor to the value() part of the values an iterator
645 points to.
646
647 CoordinateConstValueAccessor is a accessor that forwards
648 the underlying accessor's operator() read functions.
649 It passes its arguments <em>by value</em>.
650
651 <b>\#include</b> <vigra/coordinate_iterator.hxx><br>
652 Namespace: vigra
653 */
654 template <class Accessor, class COORD>
655 class CoordinateConstValueAccessor
656 {
657 public:
658 typedef typename Accessor::value_type forward_type;
659 typedef AccessorCoordinatePair<forward_type, COORD> value_type;
660 Accessor a;
661 CoordinateConstValueAccessor(const Accessor & a_) : a(a_) {}
662 /** Read the current data item.
663 */
664 template <class ITERATOR>
665 value_type operator()(ITERATOR const & i) const
666 {
667 const typename ITERATOR::value_type & x = *i;
668 return value_type(a(&x.value()), x.coord());
669 }
670 /** Read the data item at an offset.
671 */
672 template <class ITERATOR, class DIFFERENCE>
673 value_type operator()(ITERATOR const & i, DIFFERENCE const & diff) const
674 {
675 const typename ITERATOR::value_type & x = i[diff];
676 return value_type(a(&x.value()), x.coord());
677 }
678 };
679
680 template<unsigned N, class T, class Accessor>
681 struct SrcCoordinateMultiArrayRangeAccessorReturns
682 {
683 typedef CombinedMultiIterator<N, T> iterator_type;
684 typedef typename iterator_type::coord_type coord_type;
685 typedef typename iterator_type::pair_type pair_type;
686 typedef typename iterator_type::ptr_type ptr_type;
687 typedef typename ptr_type::deref_type deref_type;
688 typedef typename iterator_type::stride_type stride_type;
689 typedef typename pair_type::stride_array_type stride_array_type;
690 typedef typename pair_type::shape_array_type shape_array_type;
691
692 typedef CoordinateConstValueAccessor<Accessor, coord_type> access_type;
693 typedef triple<iterator_type, stride_array_type, access_type> type;
694 };
695
696 template <unsigned int N, class T, class StrideTag, class Access>
697 inline typename SrcCoordinateMultiArrayRangeAccessorReturns<N, T, Access>::type
698 srcCoordinateMultiArrayRangeAccessor(const MultiArrayView<N, T, StrideTag> &
699 array,
700 Access a,
701 typename CoordinateSteps<N>::type stride
702 = TinyVector<double, N>(1.0),
703 typename CoordinateSteps<N>::type origin
704 = TinyVector<double, N>(0.0))
705 {
706 typedef SrcCoordinateMultiArrayRangeAccessorReturns<N, T, Access> returns;
707 typedef typename returns::type type;
708 typedef typename returns::stride_type stride_type;
709 typedef typename returns::access_type access_type;
710 typedef typename returns::iterator_type iterator_type;
711 typedef typename returns::shape_array_type shape_array_type;
712
713 shape_array_type shape = array.shape();
714 return type(iterator_type(array.traverser_begin().get(),
715 stride_type(origin),
716 array.stride(),
717 stride_type(stride),
718 shape),
719 detail::dismember<N>(stride_type(shape)),
720 access_type(a));
721 }
722
723 } // namespace vigra
724
725 namespace std {
726
727 template <unsigned N>
728 ostream &
729 operator<<(ostream & os, const vigra::StridePair<N> & x)
730 {
731 os << "[" << x.index << ", " << x.coord << "]";
732 return os;
733 }
734
735 template <unsigned N>
736 ostream &
737 operator<<(ostream & os, const vigra::StridePairDiff<N> & x)
738 {
739 os << "<" << x.c << "; "
740 << static_cast<vigra::StridePairCoord<N> >(x) << ">";
741 return os;
742 }
743
744 template <unsigned N, class T>
745 ostream &
746 operator<<(ostream & os, const vigra::StridePairPointer<N, T> & x)
747 {
748 os << "[" << x.value() << ", " << x.coord() << "]";
749 return os;
750 }
751
752 template <class VALUETYPE, class COORD>
753 ostream &
754 operator<<(ostream & os,
755 const vigra::AccessorCoordinatePair<VALUETYPE, COORD> & x)
756 {
757 os << "[" << x.value() << ", " << x.coord() << "]";
758 return os;
759 }
760
761 } // namespace std
762
763 #endif // VIGRA_COORDINATE_ITERATOR_HXX
vigra::get
CoupledHandleCast< TARGET_INDEX, Handle >::reference get(Handle &handle)
Definition: multi_handle.hxx:927
vigra::CoordinateConstValueAccessor::operator()
value_type operator()(ITERATOR const &i, DIFFERENCE const &diff) const
Definition: coordinate_iterator.hxx:673
vigra::operator-
Diff2D operator-(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:711
vigra::operator+
Diff2D operator+(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:739
vigra::MultiArrayIndex
std::ptrdiff_t MultiArrayIndex
Definition: multi_fwd.hxx:60
vigra::operator-=
FFTWComplex< R > & operator-=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
subtract-assignment
Definition: fftw3.hxx:867
vigra::operator<=
bool operator<=(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
less or equal
Definition: fixedpoint.hxx:521
vigra::operator+=
FFTWComplex< R > & operator+=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
add-assignment
Definition: fftw3.hxx:859
vigra::CoordinateConstValueAccessor::operator()
value_type operator()(ITERATOR const &i) const
Definition: coordinate_iterator.hxx:665
vigra::operator!=
bool operator!=(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
not equal
Definition: fftw3.hxx:841
vigra::operator==
bool operator==(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
equal
Definition: fftw3.hxx:825
vigra::operator<
bool operator<(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
less than
Definition: fixedpoint.hxx:512
vigra::operator>=
bool operator>=(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
greater or equal
Definition: fixedpoint.hxx:539
vigra::abs
FFTWComplex< R >::NormType abs(const FFTWComplex< R > &a)
absolute value (= magnitude)
Definition: fftw3.hxx:1002
vigra::CoordinateConstValueAccessor
Forward accessor to the value() part of the values an iterator points to.
Definition: coordinate_iterator.hxx:655
vigra::operator>
bool operator>(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
greater
Definition: fixedpoint.hxx:530

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany | html generated using doxygen and Python vigra 1.11.1 (Fri May 19 2017)