VigraImpex

Namespaces
namespace	vigra::detail

Functions
	vigra::doxygen_overloaded_function (template<... > void importImageAlpha) template< class ImageIterator
	Read the image specified by the given vigra::ImageImportInfo object including its alpha channel.
class AlphaIterator class AlphaAccessor inline void	vigra::importImageAlpha (const ImageImportInfo &import_info, ImageIterator image_iterator, ImageAccessor image_accessor, AlphaIterator alpha_iterator, AlphaAccessor alpha_accessor)
template<class ImageIterator , class ImageAccessor , class AlphaIterator , class AlphaAccessor >
void	vigra::importImageAlpha (ImageImportInfo const &import_info, pair< ImageIterator, ImageAccessor > image, pair< AlphaIterator, AlphaAccessor > alpha)
class AlphaIterator class AlphaAccessor inline void	vigra::exportImageAlpha (ImageIterator image_upper_left, ImageIterator image_lower_right, ImageAccessor image_accessor, AlphaIterator alpha_upper_left, AlphaAccessor alpha_accessor, const ImageExportInfo &export_info)
template<class ImageIterator , class ImageAccessor , class AlphaIterator , class AlphaAccessor >
void	vigra::exportImageAlpha (triple< ImageIterator, ImageIterator, ImageAccessor > image, pair< AlphaIterator, AlphaAccessor > alpha, ImageExportInfo const &export_info)

Detailed Description

Function Documentation

doxygen_overloaded_function()

vigra::doxygen_overloaded_function

(

template<... > void

exportImageAlpha

)

Read the image specified by the given vigra::ImageImportInfo object including its alpha channel.

Write the image and its alpha channel to a file.

See importImage() for more information.

Declarations

pass 2D array views:

namespace vigra {
template <class T1, class S1,
class T2, class S2>
void
importImageAlpha(ImageImportInfo const & import_info,
MultiArrayView<2, T1, S1> image,
MultiArrayView<2, T2, S2> alpha);
}

\deprecatedAPI{importImageAlpha} pass ImageIterators and DataAccessors :

namespace vigra {
template <class ImageIterator, class ImageAccessor,
class AlphaIterator, class AlphaAccessor>
void
importImageAlpha(const ImageImportInfo& importInfo,
ImageIterator imageIterator, ImageAccessor imageAccessor,
AlphaIterator alphaIterator, AlphaAccessor alphaAccessor)
}

Use argument objects in conjunction with ArgumentObjectFactories :

namespace vigra {
template <class ImageIterator, class ImageAccessor,
class AlphaIterator, class AlphaAccessor>
void
importImageAlpha(const ImageImportInfo& importInfo,
const pair<ImageIterator, ImageAccessor>& image,
const pair<AlphaIterator, AlphaAccessor>& alpha)
}

\deprecatedEnd

Usage:

#include <vigra/impexalpha.hxx>
Namespace: vigra

typedef UInt8 value_t;
ImageImportInfo info("zorro.tif");
 
if (info.isGrayscale())
{
MultiArray<2, value_t> alpha(info.shape());
MultiArray<2, value_t> image(info.shape());
 
importImageAlpha(info, image, alpha);
...
}
else
{
MultiArray<2, value_t>            alpha(info.shape());
MultiArray<2, RGBValue<value_t> > image(info.shape());
 
importImageAlpha(info, image, alpha);
...
}

\deprecatedUsage{importImageAlpha}

typedef UInt8 value_t;
ImageImportInfo info("zorro.tif");
 
if (info.isGrayscale())
{
BasicImage<value_t> alpha(info.size());
BasicImage<value_t> image(info.size());
 
importImageAlpha(info,
image.upperLeft(), image.accessor(),
alpha.upperLeft(), alpha.accessor());
...
}
else
{
BasicImage<value_t> alpha(info.size());
BasicImage<vigra::RGBValue<value_t> > image(info.size());
 
importImageAlpha(info,
image.upperLeft(), image.accessor(),
alpha.upperLeft(), alpha.accessor());
...
}

\deprecatedEnd

Preconditions

• The same preconditions hold as for importImage(), however the only image formats that support alpha channels are
• TIFF and
• PNG. In particular, JPEG does not support alpha channels.
• The alpha channel always is scalar-valued, i.e. comprises a single band.

See exportImage() for more information.

Declarations

pass 2D array views:

namespace vigra {
template <class T1, class S1,
class T2, class S2>
void
exportImageAlpha(MultiArrayView<2, T1, S1> const & image,
MultiArrayView<2, T2, S2> const & alpha,
ImageExportInfo const & export_info);
 
template <class T1, class S1,
class T2, class S2>
void
exportImageAlpha(MultiArrayView<2, T1, S1> const & image,
MultiArrayView<2, T2, S2> const & alpha,
char const * filename)
 
template <class T1, class S1,
class T2, class S2>
void
exportImageAlpha(MultiArrayView<2, T1, S1> const & image,
MultiArrayView<2, T2, S2> const & alpha,
std::string const & filename)
}

\deprecatedAPI{exportImageAlpha} pass ImageIterators and DataAccessors :

namespace vigra {
template <class ImageIterator, class ImageAccessor,
class AlphaIterator, class AlphaAccessor>
void
exportImageAlpha(ImageIterator imageUpperLeft, ImageIterator imageLowerRight, ImageAccessor imageAccessor,
AlphaIterator alphaUpperLeft, AlphaAccessor alphaAccessor,
const ImageExportInfo& exportInfo)
}

Use argument objects in conjunction with ArgumentObjectFactories :

namespace vigra {
template <class ImageIterator, class ImageAccessor,
class AlphaIterator, class AlphaAccessor>
void
exportImageAlpha(const triple<ImageIterator, ImageIterator, ImageAccessor>& image,
const pair<AlphaIterator, AlphaAccessor>& alpha,
const ImageExportInfo& exportInfo)
}

\deprecatedEnd

Usage:

#include <vigra/impexalpha.hxx>
Namespace: vigra

typedef UInt8 value_t;
 
MultiArray<2, value_t>            alpha(width, height);
MultiArray<2, RGBValue<value_t> > image(width, height);
 
... // do some image processing
 
// specify the output filename
exportImageAlpha(image, alpha, "zorro.tif");
 
// use a ImageExportInfo if you need more control over the export
exportImageAlpha(image, alpha, ImageExportInfo("zorro.tif").setPixelType("FLOAT"));

\deprecatedUsage{exportImageAlpha}

typedef UInt8 value_t;
ImageExportInfo info("zorro.tif");
 
if (info.isGrayscale())
{
BasicImage<value_t> alpha;
BasicImage<value_t> image;
 
...
 
exportImageAlpha(image.upperLeft(), image.lowerRight(), image.accessor(),
alpha.upperLeft(), alpha.accessor(),
info);
}
else
{
BasicImage<value_t> alpha;
BasicImage<vigra::RGBValue<value_t> > image;
 
...
 
exportImageAlpha(image.upperLeft(), image.lowerRight(), image.accessor(),
alpha.upperLeft(), alpha.accessor(),
info);
}

\deprecatedEnd

Preconditions

• The same preconditions hold as for exportImage(), however the only image formats that support alpha channels are
• TIFF and
• PNG. In particular, JPEG does not support alpha channels.
• The alpha channel always is scalar-valued, i.e. comprises a single band.

exportImageAlpha() [1/2]

class AlphaIterator class AlphaAccessor inline void vigra::exportImageAlpha	(	ImageIterator	image_upper_left,
		ImageIterator	image_lower_right,
		ImageAccessor	image_accessor,
		AlphaIterator	alpha_upper_left,
		AlphaAccessor	alpha_accessor,
		const ImageExportInfo &	export_info
	)

Definition at line 1043 of file impexalpha.hxx.

References vigra::detail::exportImageAlpha(), and threshold().

Referenced by correctRGB(), CreateBrightImgDlg::CreateAndSaveExposureCorrectedImage(), vigra::exportImageAlpha(), main(), SaveImage(), SaveImage(), HuginBase::Nona::detail::saveRemapped(), StackImagesAndMask(), HuginBase::Nona::SimpleStitcher< ImageType, AlphaType >::stitch(), HuginBase::Nona::WeightedStitcher< ImageType, AlphaType >::stitch(), and HuginBase::Nona::ReduceStitcher< ImageType, AlphaType >::stitch().

exportImageAlpha() [2/2]

template<class ImageIterator , class ImageAccessor , class AlphaIterator , class AlphaAccessor >

void vigra::exportImageAlpha ( triple< ImageIterator, ImageIterator, ImageAccessor >  image, pair< AlphaIterator, AlphaAccessor >  alpha, ImageExportInfo const &  export_info  )

inline

Definition at line 1073 of file impexalpha.hxx.

References vigra::exportImageAlpha(), and threshold().

importImageAlpha() [1/2]

class AlphaIterator class AlphaAccessor inline void vigra::importImageAlpha	(	const ImageImportInfo &	import_info,
		ImageIterator	image_iterator,
		ImageAccessor	image_accessor,
		AlphaIterator	alpha_iterator,
		AlphaAccessor	alpha_accessor
	)

Definition at line 479 of file impexalpha.hxx.

References vigra::detail::importImageAlpha(), and threshold().

Referenced by PanoDetector::AnalyzeImage(), HuginBase::Nona::FileRemapper< ImageType, AlphaType >::getRemapped(), HuginBase::ImageCache::importAndConvertAlphaImage(), vigra::importImageAlpha(), deghosting::Khan< PixelType >::importRGBImage(), deghosting::Khan< PixelType >::importRGBImage(), loadAndConvertImage(), LoadAndMergeImages(), LoadGrayImageAndConvert(), LoadGrayImageAndFindLines(), LoadImageAndConvert(), LoadImageAndFindLines(), HuginBase::ImageCache::loadImageSafely(), loadImagesPyr(), main2(), PrintImageInfo(), processImg(), ResaveImageFill(), StackImagesAndMask(), and weightedAverageOfImageFiles().

importImageAlpha() [2/2]

template<class ImageIterator , class ImageAccessor , class AlphaIterator , class AlphaAccessor >

void vigra::importImageAlpha ( ImageImportInfo const &  import_info, pair< ImageIterator, ImageAccessor >  image, pair< AlphaIterator, AlphaAccessor >  alpha  )

inline

Definition at line 496 of file impexalpha.hxx.

References vigra::importImageAlpha(), and threshold().