36 #ifndef VIGRA_IMPEXALPHA_HXX
37 #define VIGRA_IMPEXALPHA_HXX
41 #include "imageinfo.hxx"
43 #include "impexbase.hxx"
44 #include "multi_shape.hxx"
53 template <
class ValueType,
54 class ImageIterator,
class ImageAccessor,
55 class AlphaIterator,
class AlphaAccessor>
57 read_image_band_and_alpha(Decoder* decoder,
58 ImageIterator image_iterator, ImageAccessor image_accessor,
59 AlphaIterator alpha_iterator, AlphaAccessor alpha_accessor)
62 typedef typename AlphaIterator::row_iterator AlphaRowIterator;
64 vigra_precondition(decoder->getNumExtraBands() == 1,
65 "vigra::detail::read_image_band_and_alpha: expecting exactly one alpha band");
66 vigra_precondition(decoder->getNumBands() - decoder->getNumExtraBands() == 1,
67 "vigra::detail::read_image_band_and_alpha: expecting exactly one image band");
69 const unsigned width(decoder->getWidth());
70 const unsigned height(decoder->getHeight());
71 const unsigned offset(decoder->getOffset());
73 for (
unsigned y = 0U; y != height; ++y)
75 decoder->nextScanline();
77 const ValueType* scanline0 =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(0));
78 const ValueType* scanline1 =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(1));
80 ImageRowIterator is(image_iterator.rowIterator());
81 const ImageRowIterator is_end(is + width);
82 AlphaRowIterator as(alpha_iterator.rowIterator());
86 image_accessor.set(*scanline0, is);
90 alpha_accessor.set(*scanline1, as);
101 template <
class ValueType,
102 class ImageIterator,
class ImageAccessor,
103 class AlphaIterator,
class AlphaAccessor>
105 read_image_bands_and_alpha(Decoder* decoder,
106 ImageIterator image_iterator, ImageAccessor image_accessor,
107 AlphaIterator alpha_iterator, AlphaAccessor alpha_accessor)
110 typedef typename AlphaIterator::row_iterator AlphaRowIterator;
112 vigra_precondition(decoder->getNumExtraBands() == 1,
113 "vigra::detail::read_image_bands_and_alpha: expecting exactly one alpha band");
114 vigra_precondition(decoder->getNumBands() - decoder->getNumExtraBands() == image_accessor.size(image_iterator),
115 "vigra::detail::read_image_bands_and_alpha: number of channels and image accessor do not match");
117 const unsigned width(decoder->getWidth());
118 const unsigned height(decoder->getHeight());
119 const unsigned offset(decoder->getOffset());
120 const unsigned accessor_size(image_accessor.size(image_iterator));
125 if (accessor_size == 3U)
127 const ValueType* scanline_0;
128 const ValueType* scanline_1;
129 const ValueType* scanline_2;
130 const ValueType* scanline_3;
132 for (
unsigned y = 0U; y != height; ++y)
134 decoder->nextScanline();
136 scanline_0 =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(0));
137 scanline_1 =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(1));
138 scanline_2 =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(2));
139 scanline_3 =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(3));
141 ImageRowIterator is(image_iterator.rowIterator());
142 const ImageRowIterator is_end(is + width);
143 AlphaRowIterator as(alpha_iterator.rowIterator());
147 image_accessor.setComponent(*scanline_0, is, 0);
148 image_accessor.setComponent(*scanline_1, is, 1);
149 image_accessor.setComponent(*scanline_2, is, 2);
150 alpha_accessor.set(*scanline_3, as);
151 scanline_0 += offset;
152 scanline_1 += offset;
153 scanline_2 += offset;
154 scanline_3 += offset;
166 std::vector<const ValueType*> scanlines(accessor_size + 1U);
168 for (
unsigned y = 0U; y != height; ++y)
170 decoder->nextScanline();
172 for (
unsigned i = 0U; i != accessor_size + 1U; ++i)
174 scanlines[i] =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(i));
177 ImageRowIterator is(image_iterator.rowIterator());
178 const ImageRowIterator is_end(is + width);
179 AlphaRowIterator as(alpha_iterator.rowIterator());
183 for (
unsigned i = 0U; i != accessor_size; ++i)
185 image_accessor.setComponent(*scanlines[i], is, static_cast<int>(i));
186 scanlines[i] += offset;
190 alpha_accessor.set(*scanlines[accessor_size], as);
191 scanlines[accessor_size] += offset;
202 template <
class ImageIterator,
class ImageAccessor,
203 class AlphaIterator,
class AlphaAccessor>
206 ImageIterator image_iterator, ImageAccessor image_accessor,
207 AlphaIterator alpha_iterator, AlphaAccessor alpha_accessor,
210 VIGRA_UNIQUE_PTR<Decoder> decoder(vigra::decoder(import_info));
212 switch (pixel_t_of_string(decoder->getPixelType()))
215 read_image_band_and_alpha<UInt8>(decoder.get(),
216 image_iterator, image_accessor,
217 alpha_iterator, alpha_accessor);
219 case UNSIGNED_INT_16:
220 read_image_band_and_alpha<UInt16>(decoder.get(),
221 image_iterator, image_accessor,
222 alpha_iterator, alpha_accessor);
224 case UNSIGNED_INT_32:
225 read_image_band_and_alpha<UInt32>(decoder.get(),
226 image_iterator, image_accessor,
227 alpha_iterator, alpha_accessor);
230 read_image_band_and_alpha<Int16>(decoder.get(),
231 image_iterator, image_accessor,
232 alpha_iterator, alpha_accessor);
235 read_image_band_and_alpha<Int32>(decoder.get(),
236 image_iterator, image_accessor,
237 alpha_iterator, alpha_accessor);
240 read_image_band_and_alpha<float>(decoder.get(),
241 image_iterator, image_accessor,
242 alpha_iterator, alpha_accessor);
245 read_image_band_and_alpha<double>(decoder.get(),
246 image_iterator, image_accessor,
247 alpha_iterator, alpha_accessor);
250 vigra_fail(
"vigra::detail::importImageAlpha<scalar>: not reached");
257 template <
class ImageIterator,
class ImageAccessor,
258 class AlphaIterator,
class AlphaAccessor>
261 ImageIterator image_iterator, ImageAccessor image_accessor,
262 AlphaIterator alpha_iterator, AlphaAccessor alpha_accessor,
265 VIGRA_UNIQUE_PTR<Decoder> decoder(vigra::decoder(import_info));
267 switch (pixel_t_of_string(decoder->getPixelType()))
270 read_image_bands_and_alpha<UInt8>(decoder.get(),
271 image_iterator, image_accessor,
272 alpha_iterator, alpha_accessor);
274 case UNSIGNED_INT_16:
275 read_image_bands_and_alpha<UInt16>(decoder.get(),
276 image_iterator, image_accessor,
277 alpha_iterator, alpha_accessor);
279 case UNSIGNED_INT_32:
280 read_image_bands_and_alpha<UInt32>(decoder.get(),
281 image_iterator, image_accessor,
282 alpha_iterator, alpha_accessor);
285 read_image_bands_and_alpha<Int16>(decoder.get(),
286 image_iterator, image_accessor,
287 alpha_iterator, alpha_accessor);
290 read_image_bands_and_alpha<Int32>(decoder.get(),
291 image_iterator, image_accessor,
292 alpha_iterator, alpha_accessor);
295 read_image_bands_and_alpha<float>(decoder.get(),
296 image_iterator, image_accessor,
297 alpha_iterator, alpha_accessor);
300 read_image_bands_and_alpha<double>(decoder.get(),
301 image_iterator, image_accessor,
302 alpha_iterator, alpha_accessor);
305 vigra_fail(
"vigra::detail::importImageAlpha<non-scalar>: not reached");
427 template <
class ImageIterator,
class ImageAccessor,
428 class AlphaIterator,
class AlphaAccessor>
431 ImageIterator image_iterator, ImageAccessor image_accessor,
432 AlphaIterator alpha_iterator, AlphaAccessor alpha_accessor)
434 typedef typename ImageAccessor::value_type ImageValueType;
435 typedef typename vigra::NumericTraits<ImageValueType>::isScalar is_scalar;
437 detail::importImageAlpha(import_info,
438 image_iterator, image_accessor,
439 alpha_iterator, alpha_accessor,
444 template <
class ImageIterator,
class ImageAccessor,
445 class AlphaIterator,
class AlphaAccessor>
448 pair<ImageIterator, ImageAccessor> image,
449 pair<AlphaIterator, AlphaAccessor> alpha)
452 image.first, image.second,
453 alpha.first, alpha.second);
456 template <
class T1,
class S1,
460 MultiArrayView<2, T1, S1> image,
461 MultiArrayView<2, T2, S2> alpha)
463 vigra_precondition(import_info.shape() == image.shape() && import_info.shape() == alpha.shape(),
464 "importImageAlpha(): shape mismatch between input and output.");
471 template<
class ValueType,
472 class ImageIterator,
class ImageAccessor,
class ImageScaler,
473 class AlphaIterator,
class AlphaAccessor,
class AlphaScaler>
475 write_image_band_and_alpha(Encoder* encoder,
476 ImageIterator image_upper_left, ImageIterator image_lower_right, ImageAccessor image_accessor,
477 const ImageScaler& image_scaler,
478 AlphaIterator alpha_upper_left, AlphaAccessor alpha_accessor,
479 const AlphaScaler& alpha_scaler)
482 typedef typename AlphaIterator::row_iterator AlphaRowIterator;
484 typedef detail::RequiresExplicitCast<ValueType> explicit_cast;
486 vigra_precondition(image_lower_right.x >= image_upper_left.x,
487 "vigra::detail::write_image_band_and_alpha: negative width");
488 vigra_precondition(image_lower_right.y >= image_upper_left.y,
489 "vigra::detail::write_image_band_and_alpha: negative height");
491 const unsigned width(static_cast<unsigned>(image_lower_right.x - image_upper_left.x));
492 const unsigned height(static_cast<unsigned>(image_lower_right.y - image_upper_left.y));
494 encoder->setWidth(width);
495 encoder->setHeight(height);
496 encoder->setNumBands(1 + 1);
497 encoder->finalizeSettings();
499 const unsigned offset(encoder->getOffset());
504 ImageIterator image_iterator(image_upper_left);
505 AlphaIterator alpha_iterator(alpha_upper_left);
507 for (
unsigned y = 0U; y != height; ++y)
509 ValueType* scanline0 =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(0));
510 ValueType* scanline1 =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(1));
512 ImageRowIterator is(image_iterator.rowIterator());
513 const ImageRowIterator is_end(is + width);
514 AlphaRowIterator as(alpha_iterator.rowIterator());
518 *scanline0 = explicit_cast::cast(image_scaler(image_accessor(is)));
522 *scanline1 = explicit_cast::cast(alpha_scaler(alpha_accessor(as)));
527 encoder->nextScanline();
535 template<
class ValueType,
536 class ImageIterator,
class ImageAccessor,
class ImageScaler,
537 class AlphaIterator,
class AlphaAccessor,
class AlphaScaler>
539 write_image_bands_and_alpha(Encoder* encoder,
540 ImageIterator image_upper_left, ImageIterator image_lower_right, ImageAccessor image_accessor,
541 const ImageScaler& image_scaler,
542 AlphaIterator alpha_upper_left, AlphaAccessor alpha_accessor,
543 const AlphaScaler& alpha_scaler)
546 typedef typename AlphaIterator::row_iterator AlphaRowIterator;
547 typedef detail::RequiresExplicitCast<ValueType> explicit_cast;
549 vigra_precondition(image_lower_right.x >= image_upper_left.x,
550 "vigra::detail::write_image_bands_and_alpha: negative width");
551 vigra_precondition(image_lower_right.y >= image_upper_left.y,
552 "vigra::detail::write_image_bands_and_alpha: negative height");
554 const unsigned width(static_cast<unsigned>(image_lower_right.x - image_upper_left.x));
555 const unsigned height(static_cast<unsigned>(image_lower_right.y - image_upper_left.y));
556 const unsigned accessor_size(image_accessor.size(image_upper_left));
558 encoder->setWidth(width);
559 encoder->setHeight(height);
560 encoder->setNumBands(accessor_size + 1U);
561 encoder->finalizeSettings();
563 const unsigned offset(encoder->getOffset());
568 ImageIterator image_iterator(image_upper_left);
569 AlphaIterator alpha_iterator(alpha_upper_left);
574 if (accessor_size == 3U)
576 ValueType* scanline_0;
577 ValueType* scanline_1;
578 ValueType* scanline_2;
579 ValueType* scanline_3;
581 for (
unsigned y = 0U; y != height; ++y)
583 scanline_0 =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(0));
584 scanline_1 =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(1));
585 scanline_2 =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(2));
586 scanline_3 =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(3));
588 ImageRowIterator is(image_iterator.rowIterator());
589 const ImageRowIterator is_end(is + width);
590 AlphaRowIterator as(alpha_iterator.rowIterator());
594 *scanline_0 = explicit_cast::cast(image_scaler(image_accessor.getComponent(is, 0)));
595 *scanline_1 = explicit_cast::cast(image_scaler(image_accessor.getComponent(is, 1)));
596 *scanline_2 = explicit_cast::cast(image_scaler(image_accessor.getComponent(is, 2)));
597 *scanline_3 = explicit_cast::cast(alpha_scaler(alpha_accessor(as)));
598 scanline_0 += offset;
599 scanline_1 += offset;
600 scanline_2 += offset;
601 scanline_3 += offset;
607 encoder->nextScanline();
615 std::vector<ValueType*> scanlines(accessor_size + 1U);
617 for (
unsigned y = 0U; y != height; ++y)
619 for (
unsigned i = 0U; i != accessor_size + 1U; ++i)
621 scanlines[i] =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(i));
624 ImageRowIterator is(image_iterator.rowIterator());
625 const ImageRowIterator is_end(is + width);
626 AlphaRowIterator as(alpha_iterator.rowIterator());
630 for (
unsigned i = 0U; i != accessor_size; ++i)
632 *scanlines[i] = explicit_cast::cast(image_scaler(image_accessor.getComponent(is, static_cast<int>(i))));
633 scanlines[i] += offset;
637 *scanlines[accessor_size] = explicit_cast::cast(alpha_scaler(alpha_accessor(as)));
638 scanlines[accessor_size] += offset;
642 encoder->nextScanline();
651 template <
class ImageIterator,
class ImageAccessor,
652 class AlphaIterator,
class AlphaAccessor>
654 exportImageAlpha(ImageIterator image_upper_left, ImageIterator image_lower_right, ImageAccessor image_accessor,
655 AlphaIterator alpha_upper_left, AlphaAccessor alpha_accessor,
656 const ImageExportInfo& export_info,
659 typedef typename ImageAccessor::value_type ImageValueType;
661 VIGRA_UNIQUE_PTR<Encoder> encoder(vigra::encoder(export_info));
663 std::string pixel_type(export_info.getPixelType());
664 const bool downcast(negotiatePixelType(encoder->getFileType(), TypeAsString<ImageValueType>::result(), pixel_type));
665 const pixel_t type(pixel_t_of_string(pixel_type));
667 encoder->setPixelType(pixel_type);
669 const range_t image_source_range(find_source_value_range(export_info,
670 image_upper_left, image_lower_right, image_accessor));
671 const range_t alpha_source_range(find_source_value_range(export_info,
673 alpha_upper_left + (image_lower_right - image_upper_left),
675 const range_t destination_range(find_destination_value_range(export_info, type));
677 if ((downcast || export_info.hasForcedRangeMapping()) &&
678 (image_source_range.first != destination_range.first || image_source_range.second != destination_range.second ||
679 alpha_source_range.first != destination_range.first || alpha_source_range.second != destination_range.second))
681 const linear_transform image_rescaler(image_source_range, destination_range);
682 const linear_transform alpha_rescaler(alpha_source_range, destination_range);
687 write_image_band_and_alpha<UInt8>(encoder.get(),
688 image_upper_left, image_lower_right, image_accessor, image_rescaler,
689 alpha_upper_left, alpha_accessor, alpha_rescaler);
691 case UNSIGNED_INT_16:
692 write_image_band_and_alpha<UInt16>(encoder.get(),
693 image_upper_left, image_lower_right, image_accessor, image_rescaler,
694 alpha_upper_left, alpha_accessor, alpha_rescaler);
696 case UNSIGNED_INT_32:
697 write_image_band_and_alpha<UInt32>(encoder.get(),
698 image_upper_left, image_lower_right, image_accessor, image_rescaler,
699 alpha_upper_left, alpha_accessor, alpha_rescaler);
702 write_image_band_and_alpha<Int16>(encoder.get(),
703 image_upper_left, image_lower_right, image_accessor, image_rescaler,
704 alpha_upper_left, alpha_accessor, alpha_rescaler);
707 write_image_band_and_alpha<Int32>(encoder.get(),
708 image_upper_left, image_lower_right, image_accessor, image_rescaler,
709 alpha_upper_left, alpha_accessor, alpha_rescaler);
712 write_image_band_and_alpha<float>(encoder.get(),
713 image_upper_left, image_lower_right, image_accessor, image_rescaler,
714 alpha_upper_left, alpha_accessor, alpha_rescaler);
717 write_image_band_and_alpha<double>(encoder.get(),
718 image_upper_left, image_lower_right, image_accessor, image_rescaler,
719 alpha_upper_left, alpha_accessor, alpha_rescaler);
722 vigra_fail(
"vigra::detail::exportImageAlpha<scalar>: not reached");
730 write_image_band_and_alpha<UInt8>(encoder.get(),
731 image_upper_left, image_lower_right, image_accessor, identity(),
732 alpha_upper_left, alpha_accessor, identity());
734 case UNSIGNED_INT_16:
735 write_image_band_and_alpha<UInt16>(encoder.get(),
736 image_upper_left, image_lower_right, image_accessor, identity(),
737 alpha_upper_left, alpha_accessor, identity());
739 case UNSIGNED_INT_32:
740 write_image_band_and_alpha<UInt32>(encoder.get(),
741 image_upper_left, image_lower_right, image_accessor, identity(),
742 alpha_upper_left, alpha_accessor, identity());
745 write_image_band_and_alpha<Int16>(encoder.get(),
746 image_upper_left, image_lower_right, image_accessor, identity(),
747 alpha_upper_left, alpha_accessor, identity());
750 write_image_band_and_alpha<Int32>(encoder.get(),
751 image_upper_left, image_lower_right, image_accessor, identity(),
752 alpha_upper_left, alpha_accessor, identity());
755 write_image_band_and_alpha<float>(encoder.get(),
756 image_upper_left, image_lower_right, image_accessor, identity(),
757 alpha_upper_left, alpha_accessor, identity());
760 write_image_band_and_alpha<double>(encoder.get(),
761 image_upper_left, image_lower_right, image_accessor, identity(),
762 alpha_upper_left, alpha_accessor, identity());
765 vigra_fail(
"vigra::detail::exportImageAlpha<scalar>: not reached");
773 template <
class ImageIterator,
class ImageAccessor,
774 class AlphaIterator,
class AlphaAccessor>
776 exportImageAlpha(ImageIterator image_upper_left, ImageIterator image_lower_right, ImageAccessor image_accessor,
777 AlphaIterator alpha_upper_left, AlphaAccessor alpha_accessor,
778 const ImageExportInfo& export_info,
781 typedef typename ImageAccessor::value_type ImageBaseType;
782 typedef typename ImageBaseType::value_type ImageValueType;
784 VIGRA_UNIQUE_PTR<Encoder> encoder(vigra::encoder(export_info));
786 std::string pixel_type(export_info.getPixelType());
787 const bool downcast(negotiatePixelType(encoder->getFileType(), TypeAsString<ImageValueType>::result(), pixel_type));
788 const pixel_t type(pixel_t_of_string(pixel_type));
790 encoder->setPixelType(pixel_type);
792 vigra_precondition(isBandNumberSupported(encoder->getFileType(), image_accessor.size(image_upper_left) + 1U),
793 "exportImageAlpha(): file format does not support requested number of bands (color channels)");
795 const range_t image_source_range(find_source_value_range(export_info,
796 image_upper_left, image_lower_right, image_accessor));
797 const range_t alpha_source_range(find_source_value_range(export_info,
799 alpha_upper_left + (image_lower_right - image_upper_left),
801 const range_t destination_range(find_destination_value_range(export_info, pixel_t_of_string(pixel_type)));
803 if ((downcast || export_info.hasForcedRangeMapping()) &&
804 (image_source_range.first != destination_range.first || image_source_range.second != destination_range.second ||
805 alpha_source_range.first != destination_range.first || alpha_source_range.second != destination_range.second))
807 const linear_transform image_rescaler(image_source_range, destination_range);
808 const linear_transform alpha_rescaler(alpha_source_range, destination_range);
813 write_image_bands_and_alpha<UInt8>(encoder.get(),
814 image_upper_left, image_lower_right, image_accessor, image_rescaler,
815 alpha_upper_left, alpha_accessor, alpha_rescaler);
817 case UNSIGNED_INT_16:
818 write_image_bands_and_alpha<UInt16>(encoder.get(),
819 image_upper_left, image_lower_right, image_accessor, image_rescaler,
820 alpha_upper_left, alpha_accessor, alpha_rescaler);
822 case UNSIGNED_INT_32:
823 write_image_bands_and_alpha<UInt32>(encoder.get(),
824 image_upper_left, image_lower_right, image_accessor, image_rescaler,
825 alpha_upper_left, alpha_accessor, alpha_rescaler);
828 write_image_bands_and_alpha<Int16>(encoder.get(),
829 image_upper_left, image_lower_right, image_accessor, image_rescaler,
830 alpha_upper_left, alpha_accessor, alpha_rescaler);
833 write_image_bands_and_alpha<Int32>(encoder.get(),
834 image_upper_left, image_lower_right, image_accessor, image_rescaler,
835 alpha_upper_left, alpha_accessor, alpha_rescaler);
838 write_image_bands_and_alpha<float>(encoder.get(),
839 image_upper_left, image_lower_right, image_accessor, image_rescaler,
840 alpha_upper_left, alpha_accessor, alpha_rescaler);
843 write_image_bands_and_alpha<double>(encoder.get(),
844 image_upper_left, image_lower_right, image_accessor, image_rescaler,
845 alpha_upper_left, alpha_accessor, alpha_rescaler);
848 vigra_fail(
"vigra::detail::exportImageAlpha<non-scalar>: not reached");
856 write_image_bands_and_alpha<UInt8>(encoder.get(),
857 image_upper_left, image_lower_right, image_accessor, identity(),
858 alpha_upper_left, alpha_accessor, identity());
860 case UNSIGNED_INT_16:
861 write_image_bands_and_alpha<UInt16>(encoder.get(),
862 image_upper_left, image_lower_right, image_accessor, identity(),
863 alpha_upper_left, alpha_accessor, identity());
865 case UNSIGNED_INT_32:
866 write_image_bands_and_alpha<UInt32>(encoder.get(),
867 image_upper_left, image_lower_right, image_accessor, identity(),
868 alpha_upper_left, alpha_accessor, identity());
871 write_image_bands_and_alpha<Int16>(encoder.get(),
872 image_upper_left, image_lower_right, image_accessor, identity(),
873 alpha_upper_left, alpha_accessor, identity());
876 write_image_bands_and_alpha<Int32>(encoder.get(),
877 image_upper_left, image_lower_right, image_accessor, identity(),
878 alpha_upper_left, alpha_accessor, identity());
881 write_image_bands_and_alpha<float>(encoder.get(),
882 image_upper_left, image_lower_right, image_accessor, identity(),
883 alpha_upper_left, alpha_accessor, identity());
886 write_image_bands_and_alpha<double>(encoder.get(),
887 image_upper_left, image_lower_right, image_accessor, identity(),
888 alpha_upper_left, alpha_accessor, identity());
891 vigra_fail(
"vigra::detail::exportImageAlpha<non-scalar>: not reached");
1021 template <
class ImageIterator,
class ImageAccessor,
1022 class AlphaIterator,
class AlphaAccessor>
1024 exportImageAlpha(ImageIterator image_upper_left, ImageIterator image_lower_right, ImageAccessor image_accessor,
1025 AlphaIterator alpha_upper_left, AlphaAccessor alpha_accessor,
1026 const ImageExportInfo& export_info)
1028 typedef typename ImageAccessor::value_type ImageValueType;
1029 typedef typename vigra::NumericTraits<ImageValueType>::isScalar is_scalar;
1033 detail::exportImageAlpha(image_upper_left, image_lower_right, image_accessor,
1034 alpha_upper_left, alpha_accessor,
1038 catch (Encoder::TIFFCompressionException&)
1040 ImageExportInfo info(export_info);
1042 info.setCompression(
"");
1043 detail::exportImageAlpha(image_upper_left, image_lower_right, image_accessor,
1044 alpha_upper_left, alpha_accessor,
1051 template <
class ImageIterator,
class ImageAccessor,
1052 class AlphaIterator,
class AlphaAccessor>
1054 exportImageAlpha(triple<ImageIterator, ImageIterator, ImageAccessor> image,
1055 pair<AlphaIterator, AlphaAccessor> alpha,
1056 ImageExportInfo
const & export_info)
1059 alpha.first, alpha.second,
1063 template <
class T1,
class S1,
1067 MultiArrayView<2, T2, S2>
const & alpha,
1068 ImageExportInfo
const & export_info)
1075 template <
class T1,
class S1,
1079 MultiArrayView<2, T2, S2>
const & alpha,
1082 ImageExportInfo export_info(name);
1088 template <
class T1,
class S1,
1092 MultiArrayView<2, T2, S2>
const & alpha,
1093 std::string
const & name)
1095 ImageExportInfo export_info(name.c_str());
1105 #endif // VIGRA_IMPEXALPHA_HXX
RowIteratorSelector::res row_iterator
Definition: imageiterator.hxx:605
doxygen_overloaded_function(template<...> void separableConvolveBlockwise) template< unsigned int N
Separated convolution on ChunkedArrays.
void exportImageAlpha(...)
Write the image and its alpha channel to a file.
image import and export functions
void importImageAlpha(...)
Read the image specified by the given vigra::ImageImportInfo object including its alpha channel...