[ 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
48namespace vigra {
49
50template<unsigned N>
51struct 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
135template<unsigned M>
136struct NumericTraits<StridePair<M> >
137 : public NumericTraits<typename StridePair<M>::index_type>
138{};
139
140template<unsigned N>
141struct 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};
157template<unsigned M>
158struct NumericTraits<StridePairCoord<M> >
159 : public NumericTraits<typename StridePairCoord<M>::entry_type>
160{};
161
162template<unsigned N>
163struct StridePairDiff : public StridePairCoord<N>
164{
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
190template<unsigned M>
191struct NumericTraits<StridePairDiff<M> >
192 : public NumericTraits<StridePairCoord<M> >
193{};
194
195template<unsigned N, class T>
196struct 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;
239 }
240 void operator-=(stride_type x)
241 {
242 index -= x.c;
244 }
245};
246
247template<unsigned M, class T>
248struct NumericTraits<StridePairPointer<M, T> >
249 : public NumericTraits<typename StridePairPointer<M, T>::coord_type>
250{};
251
252namespace detail {
253
254template<class T, bool is_complex = NumericTraits<T>::isComplex::value,
255 bool is_vector = !NumericTraits<T>::isScalar::value>
256struct weighted_abs
257{
258 static double get(const T & x)
259 {
260 return x;
261 }
262};
263
264template<class T>
265struct 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
274template<class T, bool is_complex>
275struct weighted_abs<T, is_complex, true>
276{
277 static double get(const T & x)
278 {
279 return x.magnitude();
280 }
281};
282
283template<class T>
284struct accumulable_coord_access;
285template<class T>
286struct accumulable_value_access;
287template<class T>
288struct accumulable_weighted_access;
289
290template<unsigned N, class T>
291struct 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
298template<unsigned N, class T>
299struct 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
306template<unsigned N, class T>
307struct 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
317template<class X>
318void dismember(X & r, const X & x, unsigned i)
319{
320 r[i] = x[i];
321}
322template<unsigned N>
323void 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}
328template<unsigned N>
329void dismember(StridePairDiff<N> & r, const StridePairDiff<N> & x, unsigned i)
330{
331 r.c = static_cast<MultiArrayIndex>(r[i] = x[i]);
332}
333
334template<unsigned N, class X>
335TinyVector<X, N>
336dismember(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}
343template<unsigned N>
344TinyVector<StridePairDiff<N>, N>
345dismember(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.
366template<unsigned N, class S = StridePair<N> >
367class 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
473template <unsigned N, class S>
474struct 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
488template <unsigned N>
489struct 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
509namespace detail {
510
511template<unsigned N>
512struct 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
527template <unsigned N>
528typename detail::CoordinateMultiRangeReturns<N>::type
529coordinateMultiRange(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
548template <unsigned N, class T>
549struct 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
572template<unsigned N, class T>
573struct 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:
590template<unsigned N>
591struct CoordinateSteps
592{
593 typedef const TinyVector<double, N> & type;
594};
595
596template <unsigned int N, class T, class StrideTag>
597inline typename SrcCoordinateMultiArrayRangeReturns<N, T>::type
598srcCoordinateMultiArrayRange(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
621template <class VALUETYPE, class COORD>
622struct 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*/
654template <class Accessor, class COORD>
656{
657 public:
658 typedef typename Accessor::value_type forward_type;
660 Accessor a;
661 CoordinateConstValueAccessor(const Accessor & a_) : a(a_) {}
662 /** Read the current data item.
663 */
664 template <class ITERATOR>
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
680template<unsigned N, class T, class Accessor>
681struct 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
696template <unsigned int N, class T, class StrideTag, class Access>
697inline typename SrcCoordinateMultiArrayRangeAccessorReturns<N, T, Access>::type
698srcCoordinateMultiArrayRangeAccessor(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
725namespace std {
726
727template <unsigned N>
728ostream &
729operator<<(ostream & os, const vigra::StridePair<N> & x)
730{
731 os << "[" << x.index << ", " << x.coord << "]";
732 return os;
733}
734
735template <unsigned N>
736ostream &
737operator<<(ostream & os, const vigra::StridePairDiff<N> & x)
738{
739 os << "<" << x.c << "; "
740 << static_cast<vigra::StridePairCoord<N> >(x) << ">";
741 return os;
742}
743
744template <unsigned N, class T>
745ostream &
746operator<<(ostream & os, const vigra::StridePairPointer<N, T> & x)
747{
748 os << "[" << x.value() << ", " << x.coord() << "]";
749 return os;
750}
751
752template <class VALUETYPE, class COORD>
753ostream &
754operator<<(ostream & os,
756{
757 os << "[" << x.value() << ", " << x.coord() << "]";
758 return os;
759}
760
761} // namespace std
762
763#endif // VIGRA_COORDINATE_ITERATOR_HXX
Forward accessor to the value() part of the values an iterator points to.
Definition coordinate_iterator.hxx:656
value_type operator()(ITERATOR const &i) const
Definition coordinate_iterator.hxx:665
value_type operator()(ITERATOR const &i, DIFFERENCE const &diff) const
Definition coordinate_iterator.hxx:673
TinyVector< MultiArrayIndex, N > type
Definition multi_shape.hxx:272
Class for a single RGB value.
Definition rgbvalue.hxx:128
NormType magnitude() const
Definition rgbvalue.hxx:307
DERIVED & operator-=(TinyVectorBase< T1, SIZE, D1, D2 > const &r)
Definition tinyvector.hxx:734
DERIVED & operator+=(TinyVectorBase< T1, SIZE, D1, D2 > const &r)
Definition tinyvector.hxx:725
LookupTag< TAG, A >::result_type get(A const &a)
Definition accumulator.hxx:2942
bool operator<=(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
less or equal
Definition fixedpoint.hxx:521
bool operator>=(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
greater or equal
Definition fixedpoint.hxx:539
FFTWComplex< R > & operator+=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
add-assignment
Definition fftw3.hxx:859
FFTWComplex< R > & operator-=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
subtract-assignment
Definition fftw3.hxx:867
bool operator>(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
greater
Definition fixedpoint.hxx:530
std::ptrdiff_t MultiArrayIndex
Definition multi_fwd.hxx:60
bool operator<(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
less than
Definition fixedpoint.hxx:512

© 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.12.2