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

numpy_array_taggedshape.hxx VIGRA

1 /************************************************************************/
2 /* */
3 /* Copyright 2009 by Ullrich Koethe and Hans Meine */
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_NUMPY_ARRAY_TAGGEDSHAPE_HXX
37 #define VIGRA_NUMPY_ARRAY_TAGGEDSHAPE_HXX
38 
39 #ifndef NPY_NO_DEPRECATED_API
40 # define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
41 #endif
42 
43 #include <string>
44 #include "array_vector.hxx"
45 #include "python_utility.hxx"
46 #include "axistags.hxx"
47 
48 namespace vigra {
49 
50 namespace detail {
51 
52 inline
53 python_ptr getArrayTypeObject()
54 {
55  python_ptr arraytype((PyObject*)&PyArray_Type);
56  python_ptr vigra(PyImport_ImportModule("vigra"));
57  if(!vigra)
58  PyErr_Clear();
59  return pythonGetAttr(vigra, "standardArrayType", arraytype);
60 }
61 
62 inline
63 std::string defaultOrder(std::string defaultValue = "C")
64 {
65  python_ptr arraytype = getArrayTypeObject();
66  return pythonGetAttr(arraytype, "defaultOrder", defaultValue);
67 }
68 
69 inline
70 python_ptr defaultAxistags(int ndim, std::string order = "")
71 {
72  if(order == "")
73  order = defaultOrder();
74  python_ptr arraytype = getArrayTypeObject();
75  python_ptr func(pythonFromData("defaultAxistags"));
76  python_ptr d(pythonFromData(ndim));
77  python_ptr o(pythonFromData(order));
78  python_ptr axistags(PyObject_CallMethodObjArgs(arraytype, func.get(), d.get(), o.get(), NULL),
79  python_ptr::keep_count);
80  if(axistags)
81  return axistags;
82  PyErr_Clear();
83  return python_ptr();
84 }
85 
86 inline
87 python_ptr emptyAxistags(int ndim)
88 {
89  python_ptr arraytype = getArrayTypeObject();
90  python_ptr func(pythonFromData("_empty_axistags"));
91  python_ptr d(pythonFromData(ndim));
92  python_ptr axistags(PyObject_CallMethodObjArgs(arraytype, func.get(), d.get(), NULL),
93  python_ptr::keep_count);
94  if(axistags)
95  return axistags;
96  PyErr_Clear();
97  return python_ptr();
98 }
99 
100 inline
101 void
102 getAxisPermutationImpl(ArrayVector<npy_intp> & permute,
103  python_ptr object, const char * name,
104  AxisInfo::AxisType type, bool ignoreErrors)
105 {
106  python_ptr func(pythonFromData(name));
107  python_ptr t(pythonFromData((long)type));
108  python_ptr permutation(PyObject_CallMethodObjArgs(object, func.get(), t.get(), NULL),
109  python_ptr::keep_count);
110  if(!permutation && ignoreErrors)
111  {
112  PyErr_Clear();
113  return;
114  }
115  pythonToCppException(permutation);
116 
117  if(!PySequence_Check(permutation))
118  {
119  if(ignoreErrors)
120  return;
121  std::string message = std::string(name) + "() did not return a sequence.";
122  PyErr_SetString(PyExc_ValueError, message.c_str());
123  pythonToCppException(false);
124  }
125 
126  ArrayVector<npy_intp> res(PySequence_Length(permutation));
127  for(int k=0; k<(int)res.size(); ++k)
128  {
129  python_ptr i(PySequence_GetItem(permutation, k), python_ptr::keep_count);
130 #if PY_MAJOR_VERSION < 3
131  if(!PyInt_Check(i))
132 #else
133  if (!PyLong_Check(i))
134 #endif
135  {
136  if(ignoreErrors)
137  return;
138  std::string message = std::string(name) + "() did not return a sequence of int.";
139  PyErr_SetString(PyExc_ValueError, message.c_str());
140  pythonToCppException(false);
141  }
142 #if PY_MAJOR_VERSION < 3
143  res[k] = PyInt_AsLong(i);
144 #else
145  res[k] = PyLong_AsLong(i);
146 #endif
147  }
148  res.swap(permute);
149 }
150 
151 inline
152 void
153 getAxisPermutationImpl(ArrayVector<npy_intp> & permute,
154  python_ptr object, const char * name, bool ignoreErrors)
155 {
156  getAxisPermutationImpl(permute, object, name, AxisInfo::AllAxes, ignoreErrors);
157 }
158 
159 } // namespace detail
160 
161 /********************************************************/
162 /* */
163 /* PyAxisTags */
164 /* */
165 /********************************************************/
166 
167 // FIXME: right now, we implement this class using the standard
168 // Python C-API only. It would be easier and more efficient
169 // to use boost::python here, but it would cause NumpyArray
170 // to depend on boost, making it more difficult to use
171 // NumpyArray in connection with other glue code generators.
172 class PyAxisTags
173 {
174  public:
175  typedef PyObject * pointer;
176 
177  python_ptr axistags;
178 
179  PyAxisTags(python_ptr tags = python_ptr(), bool createCopy = false)
180  {
181  if(!tags)
182  return;
183  // FIXME: do a more elaborate type check here?
184  if(!PySequence_Check(tags))
185  {
186  PyErr_SetString(PyExc_TypeError,
187  "PyAxisTags(tags): tags argument must have type 'AxisTags'.");
188  pythonToCppException(false);
189  }
190  else if(PySequence_Length(tags) == 0)
191  {
192  return;
193  }
194 
195  if(createCopy)
196  {
197  python_ptr func(pythonFromData("__copy__"));
198  axistags = python_ptr(PyObject_CallMethodObjArgs(tags, func.get(), NULL),
199  python_ptr::keep_count);
200  }
201  else
202  {
203  axistags = tags;
204  }
205  }
206 
207  PyAxisTags(PyAxisTags const & other, bool createCopy = false)
208  {
209  if(!other.axistags)
210  return;
211  if(createCopy)
212  {
213  python_ptr func(pythonFromData("__copy__"));
214  axistags = python_ptr(PyObject_CallMethodObjArgs(other.axistags, func.get(), NULL),
215  python_ptr::keep_count);
216  }
217  else
218  {
219  axistags = other.axistags;
220  }
221  }
222 
223  PyAxisTags(int ndim, std::string const & order = "")
224  {
225  if(order != "")
226  axistags = detail::defaultAxistags(ndim, order);
227  else
228  axistags = detail::emptyAxistags(ndim);
229  }
230 
231  long size() const
232  {
233  return axistags
234  ? PySequence_Length(axistags)
235  : 0;
236  }
237 
238  long channelIndex(long defaultVal) const
239  {
240  return pythonGetAttr(axistags, "channelIndex", defaultVal);
241  }
242 
243  long channelIndex() const
244  {
245  return channelIndex(size());
246  }
247 
248  bool hasChannelAxis() const
249  {
250  return channelIndex() != size();
251  }
252 
253  long innerNonchannelIndex(long defaultVal) const
254  {
255  return pythonGetAttr(axistags, "innerNonchannelIndex", defaultVal);
256  }
257 
258  long innerNonchannelIndex() const
259  {
260  return innerNonchannelIndex(size());
261  }
262 
263  void setChannelDescription(std::string const & description)
264  {
265  if(!axistags)
266  return;
267  python_ptr d(pythonFromData(description));
268  python_ptr func(pythonFromData("setChannelDescription"));
269  python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), d.get(), NULL),
270  python_ptr::keep_count);
271  pythonToCppException(res);
272  }
273 
274  double resolution(long index)
275  {
276  if(!axistags)
277  return 0.0;
278  python_ptr func(pythonFromData("resolution"));
279  python_ptr i(pythonFromData(index));
280  python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), i.get(), NULL),
281  python_ptr::keep_count);
282  pythonToCppException(res);
283  if(!PyFloat_Check(res))
284  {
285  PyErr_SetString(PyExc_TypeError, "AxisTags.resolution() did not return float.");
286  pythonToCppException(false);
287  }
288  return PyFloat_AsDouble(res);
289  }
290 
291  void setResolution(long index, double resolution)
292  {
293  if(!axistags)
294  return;
295  python_ptr func(pythonFromData("setResolution"));
296  python_ptr i(pythonFromData(index));
297  python_ptr r(PyFloat_FromDouble(resolution), python_ptr::keep_count);
298  python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), i.get(), r.get(), NULL),
299  python_ptr::keep_count);
300  pythonToCppException(res);
301  }
302 
303  void scaleResolution(long index, double factor)
304  {
305  if(!axistags)
306  return;
307  python_ptr func(pythonFromData("scaleResolution"));
308  python_ptr i(pythonFromData(index));
309  python_ptr f(PyFloat_FromDouble(factor), python_ptr::keep_count);
310  python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), i.get(), f.get(), NULL),
311  python_ptr::keep_count);
312  pythonToCppException(res);
313  }
314 
315  void toFrequencyDomain(long index, int size, int sign = 1)
316  {
317  if(!axistags)
318  return;
319  python_ptr func(sign == 1
320  ? pythonFromData("toFrequencyDomain")
321  : pythonFromData("fromFrequencyDomain"));
322  python_ptr i(pythonFromData(index));
323  python_ptr s(pythonFromData(size));
324  python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), i.get(), s.get(), NULL),
325  python_ptr::keep_count);
326  pythonToCppException(res);
327  }
328 
329  void fromFrequencyDomain(long index, int size)
330  {
331  toFrequencyDomain(index, size, -1);
332  }
333 
334  ArrayVector<npy_intp>
335  permutationToNormalOrder(bool ignoreErrors = false) const
336  {
337  ArrayVector<npy_intp> permute;
338  detail::getAxisPermutationImpl(permute, axistags, "permutationToNormalOrder", ignoreErrors);
339  return permute;
340  }
341 
342  ArrayVector<npy_intp>
343  permutationToNormalOrder(AxisInfo::AxisType types, bool ignoreErrors = false) const
344  {
345  ArrayVector<npy_intp> permute;
346  detail::getAxisPermutationImpl(permute, axistags,
347  "permutationToNormalOrder", types, ignoreErrors);
348  return permute;
349  }
350 
351  ArrayVector<npy_intp>
352  permutationFromNormalOrder(bool ignoreErrors = false) const
353  {
354  ArrayVector<npy_intp> permute;
355  detail::getAxisPermutationImpl(permute, axistags,
356  "permutationFromNormalOrder", ignoreErrors);
357  return permute;
358  }
359 
360  ArrayVector<npy_intp>
361  permutationFromNormalOrder(AxisInfo::AxisType types, bool ignoreErrors = false) const
362  {
363  ArrayVector<npy_intp> permute;
364  detail::getAxisPermutationImpl(permute, axistags,
365  "permutationFromNormalOrder", types, ignoreErrors);
366  return permute;
367  }
368 
369  void dropChannelAxis()
370  {
371  if(!axistags)
372  return;
373  python_ptr func(pythonFromData("dropChannelAxis"));
374  python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), NULL),
375  python_ptr::keep_count);
376  pythonToCppException(res);
377  }
378 
379  void insertChannelAxis()
380  {
381  if(!axistags)
382  return;
383  python_ptr func(pythonFromData("insertChannelAxis"));
384  python_ptr res(PyObject_CallMethodObjArgs(axistags, func.get(), NULL),
385  python_ptr::keep_count);
386  pythonToCppException(res);
387  }
388 
389  operator pointer()
390  {
391  return axistags.get();
392  }
393 
394  bool operator!() const
395  {
396  return !axistags;
397  }
398 };
399 
400 /********************************************************/
401 /* */
402 /* TaggedShape */
403 /* */
404 /********************************************************/
405 
406 class TaggedShape
407 {
408  public:
409  enum ChannelAxis { first, last, none };
410 
411  ArrayVector<npy_intp> shape, original_shape;
412  PyAxisTags axistags;
413  ChannelAxis channelAxis;
414  std::string channelDescription;
415 
416  explicit TaggedShape(MultiArrayIndex size)
417  : shape(size),
418  axistags(size),
419  channelAxis(none)
420  {}
421 
422  template <class U, int N>
423  TaggedShape(TinyVector<U, N> const & sh, PyAxisTags tags)
424  : shape(sh.begin(), sh.end()),
425  original_shape(sh.begin(), sh.end()),
426  axistags(tags),
427  channelAxis(none)
428  {}
429 
430  template <class T>
431  TaggedShape(ArrayVector<T> const & sh, PyAxisTags tags)
432  : shape(sh.begin(), sh.end()),
433  original_shape(sh.begin(), sh.end()),
434  axistags(tags),
435  channelAxis(none)
436  {}
437 
438  template <class U, int N>
439  explicit TaggedShape(TinyVector<U, N> const & sh)
440  : shape(sh.begin(), sh.end()),
441  original_shape(sh.begin(), sh.end()),
442  channelAxis(none)
443  {}
444 
445  template <class T>
446  explicit TaggedShape(ArrayVector<T> const & sh)
447  : shape(sh.begin(), sh.end()),
448  original_shape(sh.begin(), sh.end()),
449  channelAxis(none)
450  {}
451 
452  template <class U, int N>
453  TaggedShape & resize(TinyVector<U, N> const & sh)
454  {
455  int start = channelAxis == first
456  ? 1
457  : 0,
458  stop = channelAxis == last
459  ? (int)size()-1
460  : (int)size();
461 
462  vigra_precondition(N == stop - start || size() == 0,
463  "TaggedShape.resize(): size mismatch.");
464 
465  if(size() == 0)
466  shape.resize(N);
467 
468  for(int k=0; k<N; ++k)
469  shape[k+start] = sh[k];
470 
471  return *this;
472  }
473 
474  TaggedShape & resize(MultiArrayIndex v1)
475  {
476  return resize(TinyVector<MultiArrayIndex, 1>(v1));
477  }
478 
479  TaggedShape & resize(MultiArrayIndex v1, MultiArrayIndex v2)
480  {
481  return resize(TinyVector<MultiArrayIndex, 2>(v1, v2));
482  }
483 
484  TaggedShape & resize(MultiArrayIndex v1, MultiArrayIndex v2, MultiArrayIndex v3)
485  {
486  return resize(TinyVector<MultiArrayIndex, 3>(v1, v2, v3));
487  }
488 
489  TaggedShape & resize(MultiArrayIndex v1, MultiArrayIndex v2,
490  MultiArrayIndex v3, MultiArrayIndex v4)
491  {
492  return resize(TinyVector<MultiArrayIndex, 4>(v1, v2, v3, v4));
493  }
494 
495  npy_intp & operator[](int i)
496  {
497  return shape[i];
498  }
499 
500  npy_intp operator[](int i) const
501  {
502  return shape[i];
503  }
504 
505  unsigned int size() const
506  {
507  return shape.size();
508  }
509 
510  TaggedShape & operator+=(int v)
511  {
512  int start = channelAxis == first
513  ? 1
514  : 0,
515  stop = channelAxis == last
516  ? (int)size()-1
517  : (int)size();
518  for(int k=start; k<stop; ++k)
519  shape[k] += v;
520 
521  return *this;
522  }
523 
524  TaggedShape & operator-=(int v)
525  {
526  return operator+=(-v);
527  }
528 
529  TaggedShape & operator*=(int factor)
530  {
531  int start = channelAxis == first
532  ? 1
533  : 0,
534  stop = channelAxis == last
535  ? (int)size()-1
536  : (int)size();
537  for(int k=start; k<stop; ++k)
538  shape[k] *= factor;
539 
540  return *this;
541  }
542 
543  void rotateToNormalOrder()
544  {
545  if(axistags && channelAxis == last)
546  {
547  int ndim = (int)size();
548 
549  npy_intp channelCount = shape[ndim-1];
550  for(int k=ndim-1; k>0; --k)
551  shape[k] = shape[k-1];
552  shape[0] = channelCount;
553 
554  channelCount = original_shape[ndim-1];
555  for(int k=ndim-1; k>0; --k)
556  original_shape[k] = original_shape[k-1];
557  original_shape[0] = channelCount;
558 
559  channelAxis = first;
560  }
561  }
562 
563  TaggedShape & setChannelDescription(std::string const & description)
564  {
565  // we only remember the description here, and will actually set
566  // it in the finalize function
567  channelDescription = description;
568  return *this;
569  }
570 
571  TaggedShape & setChannelIndexLast()
572  {
573  // FIXME: add some checks?
574  channelAxis = last;
575  return *this;
576  }
577 
578  // transposeShape() means: only shape and resolution are transposed, not the axis keys
579  template <class U, int N>
580  TaggedShape & transposeShape(TinyVector<U, N> const & p)
581  {
582  if(axistags)
583  {
584  int ntags = axistags.size();
585  ArrayVector<npy_intp> permute = axistags.permutationToNormalOrder();
586 
587  int tstart = (axistags.channelIndex(ntags) < ntags)
588  ? 1
589  : 0;
590  int sstart = (channelAxis == first)
591  ? 1
592  : 0;
593  int ndim = ntags - tstart;
594 
595  vigra_precondition(N == ndim,
596  "TaggedShape.transposeShape(): size mismatch.");
597 
598  PyAxisTags newAxistags(axistags.axistags); // force copy
599  for(int k=0; k<ndim; ++k)
600  {
601  original_shape[k+sstart] = shape[p[k]+sstart];
602  newAxistags.setResolution(permute[k+tstart], axistags.resolution(permute[p[k]+tstart]));
603  }
604  axistags = newAxistags;
605  }
606  else
607  {
608  for(int k=0; k<N; ++k)
609  {
610  original_shape[k] = shape[p[k]];
611  }
612  }
613  shape = original_shape;
614 
615  return *this;
616  }
617 
618  TaggedShape & toFrequencyDomain(int sign = 1)
619  {
620  if(axistags)
621  {
622  int ntags = axistags.size();
623 
624  ArrayVector<npy_intp> permute = axistags.permutationToNormalOrder();
625 
626  int tstart = (axistags.channelIndex(ntags) < ntags)
627  ? 1
628  : 0;
629  int sstart = (channelAxis == first)
630  ? 1
631  : 0;
632  int send = (channelAxis == last)
633  ? (int)size()-1
634  : (int)size();
635  int size = send - sstart;
636 
637  for(int k=0; k<size; ++k)
638  {
639  axistags.toFrequencyDomain(permute[k+tstart], shape[k+sstart], sign);
640  }
641  }
642  return *this;
643  }
644 
645  bool hasChannelAxis() const
646  {
647  return channelAxis !=none;
648  }
649 
650  TaggedShape & fromFrequencyDomain()
651  {
652  return toFrequencyDomain(-1);
653  }
654 
655  bool compatible(TaggedShape const & other) const
656  {
657  if(channelCount() != other.channelCount())
658  return false;
659 
660  int start = channelAxis == first
661  ? 1
662  : 0,
663  stop = channelAxis == last
664  ? (int)size()-1
665  : (int)size();
666  int ostart = other.channelAxis == first
667  ? 1
668  : 0,
669  ostop = other.channelAxis == last
670  ? (int)other.size()-1
671  : (int)other.size();
672 
673  int len = stop - start;
674  if(len != ostop - ostart)
675  return false;
676 
677  for(int k=0; k<len; ++k)
678  if(shape[k+start] != other.shape[k+ostart])
679  return false;
680  return true;
681  }
682 
683  TaggedShape & setChannelCount(int count)
684  {
685  switch(channelAxis)
686  {
687  case first:
688  if(count > 0)
689  {
690  shape[0] = count;
691  }
692  else
693  {
694  shape.erase(shape.begin());
695  original_shape.erase(original_shape.begin());
696  channelAxis = none;
697  }
698  break;
699  case last:
700  if(count > 0)
701  {
702  shape[size()-1] = count;
703  }
704  else
705  {
706  shape.pop_back();
707  original_shape.pop_back();
708  channelAxis = none;
709  }
710  break;
711  case none:
712  if(count > 0)
713  {
714  shape.push_back(count);
715  original_shape.push_back(count);
716  channelAxis = last;
717  }
718  break;
719  }
720  return *this;
721  }
722 
723  int channelCount() const
724  {
725  switch(channelAxis)
726  {
727  case first:
728  return shape[0];
729  case last:
730  return shape[size()-1];
731  default:
732  return 1;
733  }
734  }
735 };
736 
737 inline
738 void scaleAxisResolution(TaggedShape & tagged_shape)
739 {
740  if(tagged_shape.size() != tagged_shape.original_shape.size())
741  return;
742 
743  int ntags = tagged_shape.axistags.size();
744 
745  ArrayVector<npy_intp> permute = tagged_shape.axistags.permutationToNormalOrder();
746 
747  int tstart = (tagged_shape.axistags.channelIndex(ntags) < ntags)
748  ? 1
749  : 0;
750  int sstart = (tagged_shape.channelAxis == TaggedShape::first)
751  ? 1
752  : 0;
753  int size = (int)tagged_shape.size() - sstart;
754 
755  for(int k=0; k<size; ++k)
756  {
757  int sk = k + sstart;
758  if(tagged_shape.shape[sk] == tagged_shape.original_shape[sk])
759  continue;
760  double factor = (tagged_shape.original_shape[sk] - 1.0) / (tagged_shape.shape[sk] - 1.0);
761  tagged_shape.axistags.scaleResolution(permute[k+tstart], factor);
762  }
763 }
764 
765 inline
766 void unifyTaggedShapeSize(TaggedShape & tagged_shape)
767 {
768  PyAxisTags axistags = tagged_shape.axistags;
769  ArrayVector<npy_intp> & shape = tagged_shape.shape;
770 
771  int ndim = (int)shape.size();
772  int ntags = axistags.size();
773 
774  long channelIndex = axistags.channelIndex();
775 
776  if(tagged_shape.channelAxis == TaggedShape::none)
777  {
778  // shape has no channel axis
779  if(channelIndex == ntags)
780  {
781  // std::cerr << "branch (shape, axitags) 0 0\n";
782  // axistags have no channel axis either => sizes should match
783  vigra_precondition(ndim == ntags,
784  "constructArray(): size mismatch between shape and axistags.");
785  }
786  else
787  {
788  // std::cerr << "branch (shape, axitags) 0 1\n";
789  if(ndim+1 == ntags)
790  {
791  // std::cerr << " drop channel axis\n";
792  // axistags have one additional element => drop the channel tag
793  // FIXME: would it be cleaner to make this an error ?
794  axistags.dropChannelAxis();
795  }
796  else
797  {
798  vigra_precondition(ndim == ntags,
799  "constructArray(): size mismatch between shape and axistags.");
800  }
801  }
802  }
803  else
804  {
805  // shape has a channel axis
806  if(channelIndex == ntags)
807  {
808  // std::cerr << "branch (shape, axitags) 1 0\n";
809  // axistags have no channel axis => should be one element shorter
810  vigra_precondition(ndim == ntags+1,
811  "constructArray(): size mismatch between shape and axistags.");
812 
813  if(shape[0] == 1)
814  {
815  // std::cerr << " drop channel axis\n";
816  // we have a singleband image => drop the channel axis
817  shape.erase(shape.begin());
818  ndim -= 1;
819  }
820  else
821  {
822  // std::cerr << " insert channel axis\n";
823  // we have a multiband image => add a channel tag
824  axistags.insertChannelAxis();
825  }
826  }
827  else
828  {
829  // std::cerr << "branch (shape, axitags) 1 1\n";
830  // axistags have channel axis => sizes should match
831  vigra_precondition(ndim == ntags,
832  "constructArray(): size mismatch between shape and axistags.");
833  }
834  }
835 }
836 
837 inline
838 ArrayVector<npy_intp> finalizeTaggedShape(TaggedShape & tagged_shape)
839 {
840  if(tagged_shape.axistags)
841  {
842  tagged_shape.rotateToNormalOrder();
843 
844  // we assume here that the axistag object belongs to the array to be created
845  // so that we can freely edit it
846  scaleAxisResolution(tagged_shape);
847 
848  // this must be after scaleAxisResolution(), because the latter requires
849  // shape and original_shape to be still in sync
850  unifyTaggedShapeSize(tagged_shape);
851 
852  if(tagged_shape.channelDescription != "")
853  tagged_shape.axistags.setChannelDescription(tagged_shape.channelDescription);
854  }
855  return tagged_shape.shape;
856 }
857 
858 } // namespace vigra
859 
860 #endif // VIGRA_NUMPY_ARRAY_TAGGEDSHAPE_HXX
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+=
FFTWComplex< R > & operator+=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
add-assignment
Definition: fftw3.hxx:859
vigra::operator*=
FFTWComplex< R > & operator*=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
multiply-assignment
Definition: fftw3.hxx:875
vigra::sign
T sign(T t)
The sign function.
Definition: mathutil.hxx:591

© 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)