36 #ifndef VIGRA_IMPEXALPHA_HXX
37 #define VIGRA_IMPEXALPHA_HXX
41 #include "imageinfo.hxx"
43 #include "impexbase.hxx"
52 template <
class ValueType,
53 class ImageIterator,
class ImageAccessor,
54 class AlphaIterator,
class AlphaAccessor>
56 read_image_band_and_alpha(Decoder* decoder,
57 ImageIterator image_iterator, ImageAccessor image_accessor,
58 AlphaIterator alpha_iterator, AlphaAccessor alpha_accessor)
61 typedef typename AlphaIterator::row_iterator AlphaRowIterator;
63 vigra_precondition(decoder->getNumExtraBands() == 1,
64 "vigra::detail::read_image_band_and_alpha: expecting exactly one alpha band");
65 vigra_precondition(decoder->getNumBands() - decoder->getNumExtraBands() == 1,
66 "vigra::detail::read_image_band_and_alpha: expecting exactly one image band");
68 const unsigned width(decoder->getWidth());
69 const unsigned height(decoder->getHeight());
70 const unsigned offset(decoder->getOffset());
72 for (
unsigned y = 0U; y != height; ++y)
74 decoder->nextScanline();
76 const ValueType* scanline0 =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(0));
77 const ValueType* scanline1 =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(1));
79 ImageRowIterator is(image_iterator.rowIterator());
80 const ImageRowIterator is_end(is + width);
81 AlphaRowIterator as(alpha_iterator.rowIterator());
85 image_accessor.set(*scanline0, is);
89 alpha_accessor.set(*scanline1, as);
100 template <
class ValueType,
101 class ImageIterator,
class ImageAccessor,
102 class AlphaIterator,
class AlphaAccessor>
104 read_image_bands_and_alpha(Decoder* decoder,
105 ImageIterator image_iterator, ImageAccessor image_accessor,
106 AlphaIterator alpha_iterator, AlphaAccessor alpha_accessor)
109 typedef typename AlphaIterator::row_iterator AlphaRowIterator;
111 vigra_precondition(decoder->getNumExtraBands() == 1,
112 "vigra::detail::read_image_bands_and_alpha: expecting exactly one alpha band");
113 vigra_precondition(decoder->getNumBands() - decoder->getNumExtraBands() == image_accessor.size(image_iterator),
114 "vigra::detail::read_image_bands_and_alpha: number of channels and image accessor do not match");
116 const unsigned width(decoder->getWidth());
117 const unsigned height(decoder->getHeight());
118 const unsigned offset(decoder->getOffset());
119 const unsigned accessor_size(image_accessor.size(image_iterator));
124 if (accessor_size == 3U)
126 const ValueType* scanline_0;
127 const ValueType* scanline_1;
128 const ValueType* scanline_2;
129 const ValueType* scanline_3;
131 for (
unsigned y = 0U; y != height; ++y)
133 decoder->nextScanline();
135 scanline_0 =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(0));
136 scanline_1 =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(1));
137 scanline_2 =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(2));
138 scanline_3 =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(3));
140 ImageRowIterator is(image_iterator.rowIterator());
141 const ImageRowIterator is_end(is + width);
142 AlphaRowIterator as(alpha_iterator.rowIterator());
146 image_accessor.setComponent(*scanline_0, is, 0);
147 image_accessor.setComponent(*scanline_1, is, 1);
148 image_accessor.setComponent(*scanline_2, is, 2);
149 alpha_accessor.set(*scanline_3, as);
150 scanline_0 += offset;
151 scanline_1 += offset;
152 scanline_2 += offset;
153 scanline_3 += offset;
165 std::vector<const ValueType*> scanlines(accessor_size + 1U);
167 for (
unsigned y = 0U; y != height; ++y)
169 decoder->nextScanline();
171 for (
unsigned i = 0U; i != accessor_size + 1U; ++i)
173 scanlines[i] =
static_cast<const ValueType*
>(decoder->currentScanlineOfBand(i));
176 ImageRowIterator is(image_iterator.rowIterator());
177 const ImageRowIterator is_end(is + width);
178 AlphaRowIterator as(alpha_iterator.rowIterator());
182 for (
unsigned i = 0U; i != accessor_size; ++i)
184 image_accessor.setComponent(*scanlines[i], is, static_cast<int>(i));
185 scanlines[i] += offset;
189 alpha_accessor.set(*scanlines[accessor_size], as);
190 scanlines[accessor_size] += offset;
201 template <
class ImageIterator,
class ImageAccessor,
202 class AlphaIterator,
class AlphaAccessor>
205 ImageIterator image_iterator, ImageAccessor image_accessor,
206 AlphaIterator alpha_iterator, AlphaAccessor alpha_accessor,
209 VIGRA_UNIQUE_PTR<Decoder> decoder(vigra::decoder(import_info));
211 switch (pixel_t_of_string(decoder->getPixelType()))
214 read_image_band_and_alpha<UInt8>(decoder.get(),
215 image_iterator, image_accessor,
216 alpha_iterator, alpha_accessor);
218 case UNSIGNED_INT_16:
219 read_image_band_and_alpha<UInt16>(decoder.get(),
220 image_iterator, image_accessor,
221 alpha_iterator, alpha_accessor);
223 case UNSIGNED_INT_32:
224 read_image_band_and_alpha<UInt32>(decoder.get(),
225 image_iterator, image_accessor,
226 alpha_iterator, alpha_accessor);
229 read_image_band_and_alpha<Int16>(decoder.get(),
230 image_iterator, image_accessor,
231 alpha_iterator, alpha_accessor);
234 read_image_band_and_alpha<Int32>(decoder.get(),
235 image_iterator, image_accessor,
236 alpha_iterator, alpha_accessor);
239 read_image_band_and_alpha<float>(decoder.get(),
240 image_iterator, image_accessor,
241 alpha_iterator, alpha_accessor);
244 read_image_band_and_alpha<double>(decoder.get(),
245 image_iterator, image_accessor,
246 alpha_iterator, alpha_accessor);
249 vigra_fail(
"vigra::detail::importImageAlpha<scalar>: not reached");
256 template <
class ImageIterator,
class ImageAccessor,
257 class AlphaIterator,
class AlphaAccessor>
260 ImageIterator image_iterator, ImageAccessor image_accessor,
261 AlphaIterator alpha_iterator, AlphaAccessor alpha_accessor,
264 VIGRA_UNIQUE_PTR<Decoder> decoder(vigra::decoder(import_info));
266 switch (pixel_t_of_string(decoder->getPixelType()))
269 read_image_bands_and_alpha<UInt8>(decoder.get(),
270 image_iterator, image_accessor,
271 alpha_iterator, alpha_accessor);
273 case UNSIGNED_INT_16:
274 read_image_bands_and_alpha<UInt16>(decoder.get(),
275 image_iterator, image_accessor,
276 alpha_iterator, alpha_accessor);
278 case UNSIGNED_INT_32:
279 read_image_bands_and_alpha<UInt32>(decoder.get(),
280 image_iterator, image_accessor,
281 alpha_iterator, alpha_accessor);
284 read_image_bands_and_alpha<Int16>(decoder.get(),
285 image_iterator, image_accessor,
286 alpha_iterator, alpha_accessor);
289 read_image_bands_and_alpha<Int32>(decoder.get(),
290 image_iterator, image_accessor,
291 alpha_iterator, alpha_accessor);
294 read_image_bands_and_alpha<float>(decoder.get(),
295 image_iterator, image_accessor,
296 alpha_iterator, alpha_accessor);
299 read_image_bands_and_alpha<double>(decoder.get(),
300 image_iterator, image_accessor,
301 alpha_iterator, alpha_accessor);
304 vigra_fail(
"vigra::detail::importImageAlpha<non-scalar>: not reached");
386 template <
class ImageIterator,
class ImageAccessor,
387 class AlphaIterator,
class AlphaAccessor>
390 ImageIterator image_iterator, ImageAccessor image_accessor,
391 AlphaIterator alpha_iterator, AlphaAccessor alpha_accessor)
393 typedef typename ImageAccessor::value_type ImageValueType;
394 typedef typename vigra::NumericTraits<ImageValueType>::isScalar is_scalar;
396 detail::importImageAlpha(import_info,
397 image_iterator, image_accessor,
398 alpha_iterator, alpha_accessor,
403 template <
class ImageIterator,
class ImageAccessor,
404 class AlphaIterator,
class AlphaAccessor>
407 const vigra::pair<ImageIterator, ImageAccessor>& image,
408 const vigra::pair<AlphaIterator, AlphaAccessor>& alpha)
411 image.first, image.second,
412 alpha.first, alpha.second);
418 template<
class ValueType,
419 class ImageIterator,
class ImageAccessor,
class ImageScaler,
420 class AlphaIterator,
class AlphaAccessor,
class AlphaScaler>
422 write_image_band_and_alpha(Encoder* encoder,
423 ImageIterator image_upper_left, ImageIterator image_lower_right, ImageAccessor image_accessor,
424 const ImageScaler& image_scaler,
425 AlphaIterator alpha_upper_left, AlphaAccessor alpha_accessor,
426 const AlphaScaler& alpha_scaler)
429 typedef typename ImageAccessor::value_type ImageValueType;
431 typedef typename AlphaIterator::row_iterator AlphaRowIterator;
432 typedef typename AlphaAccessor::value_type AlphaValueType;
434 typedef detail::RequiresExplicitCast<ValueType> explicit_cast;
436 vigra_precondition(image_lower_right.x >= image_upper_left.x,
437 "vigra::detail::write_image_band_and_alpha: negative width");
438 vigra_precondition(image_lower_right.y >= image_upper_left.y,
439 "vigra::detail::write_image_band_and_alpha: negative height");
441 const unsigned width(static_cast<unsigned>(image_lower_right.x - image_upper_left.x));
442 const unsigned height(static_cast<unsigned>(image_lower_right.y - image_upper_left.y));
444 encoder->setWidth(width);
445 encoder->setHeight(height);
446 encoder->setNumBands(1 + 1);
447 encoder->finalizeSettings();
449 const unsigned offset(encoder->getOffset());
454 ImageIterator image_iterator(image_upper_left);
455 AlphaIterator alpha_iterator(alpha_upper_left);
457 for (
unsigned y = 0U; y != height; ++y)
459 ValueType* scanline0 =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(0));
460 ValueType* scanline1 =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(1));
462 ImageRowIterator is(image_iterator.rowIterator());
463 const ImageRowIterator is_end(is + width);
464 AlphaRowIterator as(alpha_iterator.rowIterator());
468 *scanline0 = explicit_cast::cast(image_scaler(image_accessor(is)));
472 *scanline1 = explicit_cast::cast(alpha_scaler(alpha_accessor(as)));
477 encoder->nextScanline();
485 template<
class ValueType,
486 class ImageIterator,
class ImageAccessor,
class ImageScaler,
487 class AlphaIterator,
class AlphaAccessor,
class AlphaScaler>
489 write_image_bands_and_alpha(Encoder* encoder,
490 ImageIterator image_upper_left, ImageIterator image_lower_right, ImageAccessor image_accessor,
491 const ImageScaler& image_scaler,
492 AlphaIterator alpha_upper_left, AlphaAccessor alpha_accessor,
493 const AlphaScaler& alpha_scaler)
496 typedef typename AlphaIterator::row_iterator AlphaRowIterator;
497 typedef detail::RequiresExplicitCast<ValueType> explicit_cast;
499 vigra_precondition(image_lower_right.x >= image_upper_left.x,
500 "vigra::detail::write_image_bands_and_alpha: negative width");
501 vigra_precondition(image_lower_right.y >= image_upper_left.y,
502 "vigra::detail::write_image_bands_and_alpha: negative height");
504 const unsigned width(static_cast<unsigned>(image_lower_right.x - image_upper_left.x));
505 const unsigned height(static_cast<unsigned>(image_lower_right.y - image_upper_left.y));
506 const unsigned accessor_size(image_accessor.size(image_upper_left));
508 encoder->setWidth(width);
509 encoder->setHeight(height);
510 encoder->setNumBands(accessor_size + 1U);
511 encoder->finalizeSettings();
513 const unsigned offset(encoder->getOffset());
518 ImageIterator image_iterator(image_upper_left);
519 AlphaIterator alpha_iterator(alpha_upper_left);
524 if (accessor_size == 3U)
526 ValueType* scanline_0;
527 ValueType* scanline_1;
528 ValueType* scanline_2;
529 ValueType* scanline_3;
531 for (
unsigned y = 0U; y != height; ++y)
533 scanline_0 =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(0));
534 scanline_1 =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(1));
535 scanline_2 =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(2));
536 scanline_3 =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(3));
538 ImageRowIterator is(image_iterator.rowIterator());
539 const ImageRowIterator is_end(is + width);
540 AlphaRowIterator as(alpha_iterator.rowIterator());
544 *scanline_0 = explicit_cast::cast(image_scaler(image_accessor.getComponent(is, 0)));
545 *scanline_1 = explicit_cast::cast(image_scaler(image_accessor.getComponent(is, 1)));
546 *scanline_2 = explicit_cast::cast(image_scaler(image_accessor.getComponent(is, 2)));
547 *scanline_3 = explicit_cast::cast(alpha_scaler(alpha_accessor(as)));
548 scanline_0 += offset;
549 scanline_1 += offset;
550 scanline_2 += offset;
551 scanline_3 += offset;
557 encoder->nextScanline();
565 std::vector<ValueType*> scanlines(accessor_size + 1U);
567 for (
unsigned y = 0U; y != height; ++y)
569 for (
unsigned i = 0U; i != accessor_size + 1U; ++i)
571 scanlines[i] =
static_cast<ValueType*
>(encoder->currentScanlineOfBand(i));
574 ImageRowIterator is(image_iterator.rowIterator());
575 const ImageRowIterator is_end(is + width);
576 AlphaRowIterator as(alpha_iterator.rowIterator());
580 for (
unsigned i = 0U; i != accessor_size; ++i)
582 *scanlines[i] = explicit_cast::cast(image_scaler(image_accessor.getComponent(is, static_cast<int>(i))));
583 scanlines[i] += offset;
587 *scanlines[accessor_size] = explicit_cast::cast(alpha_scaler(alpha_accessor(as)));
588 scanlines[accessor_size] += offset;
592 encoder->nextScanline();
601 template <
class ImageIterator,
class ImageAccessor,
602 class AlphaIterator,
class AlphaAccessor>
604 exportImageAlpha(ImageIterator image_upper_left, ImageIterator image_lower_right, ImageAccessor image_accessor,
605 AlphaIterator alpha_upper_left, AlphaAccessor alpha_accessor,
606 const ImageExportInfo& export_info,
609 typedef typename ImageAccessor::value_type ImageValueType;
611 VIGRA_UNIQUE_PTR<Encoder> encoder(vigra::encoder(export_info));
613 std::string pixel_type(export_info.getPixelType());
614 const bool downcast(negotiatePixelType(encoder->getFileType(), TypeAsString<ImageValueType>::result(), pixel_type));
615 const pixel_t type(pixel_t_of_string(pixel_type));
617 encoder->setPixelType(pixel_type);
619 const range_t image_source_range(find_source_value_range(export_info,
620 image_upper_left, image_lower_right, image_accessor));
621 const range_t alpha_source_range(find_source_value_range(export_info,
623 alpha_upper_left + (image_lower_right - image_upper_left),
625 const range_t destination_range(find_destination_value_range(export_info, type));
627 if ((downcast || export_info.hasForcedRangeMapping()) &&
628 (image_source_range.first != destination_range.first || image_source_range.second != destination_range.second ||
629 alpha_source_range.first != destination_range.first || alpha_source_range.second != destination_range.second))
631 const linear_transform image_rescaler(image_source_range, destination_range);
632 const linear_transform alpha_rescaler(alpha_source_range, destination_range);
637 write_image_band_and_alpha<UInt8>(encoder.get(),
638 image_upper_left, image_lower_right, image_accessor, image_rescaler,
639 alpha_upper_left, alpha_accessor, alpha_rescaler);
641 case UNSIGNED_INT_16:
642 write_image_band_and_alpha<UInt16>(encoder.get(),
643 image_upper_left, image_lower_right, image_accessor, image_rescaler,
644 alpha_upper_left, alpha_accessor, alpha_rescaler);
646 case UNSIGNED_INT_32:
647 write_image_band_and_alpha<UInt32>(encoder.get(),
648 image_upper_left, image_lower_right, image_accessor, image_rescaler,
649 alpha_upper_left, alpha_accessor, alpha_rescaler);
652 write_image_band_and_alpha<Int16>(encoder.get(),
653 image_upper_left, image_lower_right, image_accessor, image_rescaler,
654 alpha_upper_left, alpha_accessor, alpha_rescaler);
657 write_image_band_and_alpha<Int32>(encoder.get(),
658 image_upper_left, image_lower_right, image_accessor, image_rescaler,
659 alpha_upper_left, alpha_accessor, alpha_rescaler);
662 write_image_band_and_alpha<float>(encoder.get(),
663 image_upper_left, image_lower_right, image_accessor, image_rescaler,
664 alpha_upper_left, alpha_accessor, alpha_rescaler);
667 write_image_band_and_alpha<double>(encoder.get(),
668 image_upper_left, image_lower_right, image_accessor, image_rescaler,
669 alpha_upper_left, alpha_accessor, alpha_rescaler);
672 vigra_fail(
"vigra::detail::exportImageAlpha<scalar>: not reached");
680 write_image_band_and_alpha<UInt8>(encoder.get(),
681 image_upper_left, image_lower_right, image_accessor, identity(),
682 alpha_upper_left, alpha_accessor, identity());
684 case UNSIGNED_INT_16:
685 write_image_band_and_alpha<UInt16>(encoder.get(),
686 image_upper_left, image_lower_right, image_accessor, identity(),
687 alpha_upper_left, alpha_accessor, identity());
689 case UNSIGNED_INT_32:
690 write_image_band_and_alpha<UInt32>(encoder.get(),
691 image_upper_left, image_lower_right, image_accessor, identity(),
692 alpha_upper_left, alpha_accessor, identity());
695 write_image_band_and_alpha<Int16>(encoder.get(),
696 image_upper_left, image_lower_right, image_accessor, identity(),
697 alpha_upper_left, alpha_accessor, identity());
700 write_image_band_and_alpha<Int32>(encoder.get(),
701 image_upper_left, image_lower_right, image_accessor, identity(),
702 alpha_upper_left, alpha_accessor, identity());
705 write_image_band_and_alpha<float>(encoder.get(),
706 image_upper_left, image_lower_right, image_accessor, identity(),
707 alpha_upper_left, alpha_accessor, identity());
710 write_image_band_and_alpha<double>(encoder.get(),
711 image_upper_left, image_lower_right, image_accessor, identity(),
712 alpha_upper_left, alpha_accessor, identity());
715 vigra_fail(
"vigra::detail::exportImageAlpha<scalar>: not reached");
723 template <
class ImageIterator,
class ImageAccessor,
724 class AlphaIterator,
class AlphaAccessor>
726 exportImageAlpha(ImageIterator image_upper_left, ImageIterator image_lower_right, ImageAccessor image_accessor,
727 AlphaIterator alpha_upper_left, AlphaAccessor alpha_accessor,
728 const ImageExportInfo& export_info,
731 typedef typename ImageAccessor::value_type ImageBaseType;
732 typedef typename ImageBaseType::value_type ImageValueType;
734 VIGRA_UNIQUE_PTR<Encoder> encoder(vigra::encoder(export_info));
736 std::string pixel_type(export_info.getPixelType());
737 const bool downcast(negotiatePixelType(encoder->getFileType(), TypeAsString<ImageValueType>::result(), pixel_type));
738 const pixel_t type(pixel_t_of_string(pixel_type));
740 encoder->setPixelType(pixel_type);
742 vigra_precondition(isBandNumberSupported(encoder->getFileType(), image_accessor.size(image_upper_left)),
743 "exportImageAlpha(): file format does not support requested number of bands (color channels)");
745 const range_t image_source_range(find_source_value_range(export_info,
746 image_upper_left, image_lower_right, image_accessor));
747 const range_t alpha_source_range(find_source_value_range(export_info,
749 alpha_upper_left + (image_lower_right - image_upper_left),
751 const range_t destination_range(find_destination_value_range(export_info, pixel_t_of_string(pixel_type)));
753 if ((downcast || export_info.hasForcedRangeMapping()) &&
754 (image_source_range.first != destination_range.first || image_source_range.second != destination_range.second ||
755 alpha_source_range.first != destination_range.first || alpha_source_range.second != destination_range.second))
757 const linear_transform image_rescaler(image_source_range, destination_range);
758 const linear_transform alpha_rescaler(alpha_source_range, destination_range);
763 write_image_bands_and_alpha<UInt8>(encoder.get(),
764 image_upper_left, image_lower_right, image_accessor, image_rescaler,
765 alpha_upper_left, alpha_accessor, alpha_rescaler);
767 case UNSIGNED_INT_16:
768 write_image_bands_and_alpha<UInt16>(encoder.get(),
769 image_upper_left, image_lower_right, image_accessor, image_rescaler,
770 alpha_upper_left, alpha_accessor, alpha_rescaler);
772 case UNSIGNED_INT_32:
773 write_image_bands_and_alpha<UInt32>(encoder.get(),
774 image_upper_left, image_lower_right, image_accessor, image_rescaler,
775 alpha_upper_left, alpha_accessor, alpha_rescaler);
778 write_image_bands_and_alpha<Int16>(encoder.get(),
779 image_upper_left, image_lower_right, image_accessor, image_rescaler,
780 alpha_upper_left, alpha_accessor, alpha_rescaler);
783 write_image_bands_and_alpha<Int32>(encoder.get(),
784 image_upper_left, image_lower_right, image_accessor, image_rescaler,
785 alpha_upper_left, alpha_accessor, alpha_rescaler);
788 write_image_bands_and_alpha<float>(encoder.get(),
789 image_upper_left, image_lower_right, image_accessor, image_rescaler,
790 alpha_upper_left, alpha_accessor, alpha_rescaler);
793 write_image_bands_and_alpha<double>(encoder.get(),
794 image_upper_left, image_lower_right, image_accessor, image_rescaler,
795 alpha_upper_left, alpha_accessor, alpha_rescaler);
798 vigra_fail(
"vigra::detail::exportImageAlpha<non-scalar>: not reached");
806 write_image_bands_and_alpha<UInt8>(encoder.get(),
807 image_upper_left, image_lower_right, image_accessor, identity(),
808 alpha_upper_left, alpha_accessor, identity());
810 case UNSIGNED_INT_16:
811 write_image_bands_and_alpha<UInt16>(encoder.get(),
812 image_upper_left, image_lower_right, image_accessor, identity(),
813 alpha_upper_left, alpha_accessor, identity());
815 case UNSIGNED_INT_32:
816 write_image_bands_and_alpha<UInt32>(encoder.get(),
817 image_upper_left, image_lower_right, image_accessor, identity(),
818 alpha_upper_left, alpha_accessor, identity());
821 write_image_bands_and_alpha<Int16>(encoder.get(),
822 image_upper_left, image_lower_right, image_accessor, identity(),
823 alpha_upper_left, alpha_accessor, identity());
826 write_image_bands_and_alpha<Int32>(encoder.get(),
827 image_upper_left, image_lower_right, image_accessor, identity(),
828 alpha_upper_left, alpha_accessor, identity());
831 write_image_bands_and_alpha<float>(encoder.get(),
832 image_upper_left, image_lower_right, image_accessor, identity(),
833 alpha_upper_left, alpha_accessor, identity());
836 write_image_bands_and_alpha<double>(encoder.get(),
837 image_upper_left, image_lower_right, image_accessor, identity(),
838 alpha_upper_left, alpha_accessor, identity());
841 vigra_fail(
"vigra::detail::exportImageAlpha<non-scalar>: not reached");
926 template <
class ImageIterator,
class ImageAccessor,
927 class AlphaIterator,
class AlphaAccessor>
929 exportImageAlpha(ImageIterator image_upper_left, ImageIterator image_lower_right, ImageAccessor image_accessor,
930 AlphaIterator alpha_upper_left, AlphaAccessor alpha_accessor,
931 const ImageExportInfo& export_info)
933 typedef typename ImageAccessor::value_type ImageValueType;
934 typedef typename vigra::NumericTraits<ImageValueType>::isScalar is_scalar;
938 detail::exportImageAlpha(image_upper_left, image_lower_right, image_accessor,
939 alpha_upper_left, alpha_accessor,
943 catch (Encoder::TIFFCompressionException&)
945 ImageExportInfo info(export_info);
947 info.setCompression(
"");
948 detail::exportImageAlpha(image_upper_left, image_lower_right, image_accessor,
949 alpha_upper_left, alpha_accessor,
956 template <
class ImageIterator,
class ImageAccessor,
957 class AlphaIterator,
class AlphaAccessor>
959 exportImageAlpha(
const vigra::triple<ImageIterator, ImageIterator, ImageAccessor>& image,
960 const vigra::pair<AlphaIterator, AlphaAccessor>& alpha,
961 const ImageExportInfo& export_info)
964 alpha.first, alpha.second,
972 #endif // VIGRA_IMPEXALPHA_HXX
RowIteratorSelector::res row_iterator
Definition: imageiterator.hxx:606
void exportImageAlpha(...)
Write the image specified by the given vigra::ImageExportInfo object including an alpha channel...
image import and export functions
void importImageAlpha(...)
Read the image specified by the given vigra::ImageImportInfo object including its alpha channel...