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