[an error occurred while processing this directive]
Main Page | Modules | Namespace List | Class Hierarchy | Class List | File List | Namespace Members | Class Members | File Members | Related Pages

vigra_ext Namespace Reference


Classes

struct  vigra_ext::CorrelationResult
 Maximum of correlation, position and value. More...
class  vigra_ext::RotateTransform
 clockwise rotation around a origin point, and a translation afterwards. More...
class  vigra_ext::ReadFunctorAccessor< Functor, Accessor >
 This class can be used to apply a function when reading the input image. More...
class  vigra_ext::WriteFunctorAccessor< Functor, Accessor, ValueType >
 This class can be used to apply a function when writing to an image. More...
class  vigra_ext::SplitVector2Accessor< Iter1, Acc1, Iter2, Acc2 >
 define a write only accessor for a virtual Image<TinyVector<Acc1::value_type>, 2> image, which actually consists of two Images. More...
class  vigra_ext::SplitVectorNAccessor< Iter1, Acc1, Iter2, Acc2, SIZE >
 split a vector image into a vector and a scalar image More...
class  vigra_ext::MergeScalarScalar2VectorAccessor< Iter1, Acc1, Iter2, Acc2 >
 merge two scalar images into a vector image. More...
class  vigra_ext::MergeVectorScalar2VectorAccessor< Iter1, Acc1, Iter2, Acc2, SIZE >
 merge a vector and a scalar image into a vector image. More...
class  vigra_ext::ImageSplittingAccessor< Iter1, Acc1, Iter2, Acc2, SIZE >
 An accessor to encapsulate write access to a multiband image, and move divide it into two images. More...
struct  vigra_ext::Multiply< T >
 a sample functor that can be used to multiply pixel values with a constant More...
class  vigra_ext::ReduceToHDRFunctor< VALUETYPE >
struct  vigra_ext::TransformImageIntern< SrcImageIterator, SrcAccessor, DestImageIterator, DestAccessor, TRANSFORM, PixelTransform, AlphaImageIterator, AlphaAccessor, Interpolator >
 functor version (for threaded remapping) More...
struct  vigra_ext::TransformImageAlphaIntern< SrcImageIterator, SrcAccessor, SrcAlphaIterator, SrcAlphaAccessor, DestImageIterator, DestAccessor, TRANSFORM, PixelTransform, AlphaImageIterator, AlphaAccessor, Interpolator >
 functor version (for threaded remapping) More...
struct  vigra_ext::Error_GpuNumericTraits_not_specialized_for_this_case
struct  vigra_ext::GpuNumericTraits< A >
struct  vigra_ext::interp_nearest
 nearest neighbour, stupid, but might be useful somewhere More...
struct  vigra_ext::interp_bilin
 simple bilinear interpolation More...
struct  vigra_ext::interp_cubic
 cubic interpolation More...
struct  vigra_ext::interp_spline16
 spline16 interpolation More...
struct  vigra_ext::interp_spline36
 spline36 interpolation More...
struct  vigra_ext::interp_spline64
 spline64 interpolation More...
struct  vigra_ext::interp_sinc< size_ >
 sinc interpolation, with variable width More...
class  vigra_ext::ImageInterpolator< SrcImageIterator, SrcAccessor, INTERPOLATOR >
 "wrapper" for efficient interpolation access to an image More...
class  vigra_ext::ImageMaskInterpolator< SrcImageIterator, SrcAccessor, MaskIterator, MaskAccessor, INTERPOLATOR >
 "wrapper" for efficient interpolation access to an image More...
class  vigra_ext::InterpolatingAccessor< ACCESSOR, VALUETYPE, INTERPOLATOR >
 interpolation at non-integer positions. More...
struct  vigra_ext::LUTFunctor< VTIn, LUT >
 functor to apply a LUT to gray and color images. More...
struct  vigra_ext::InvLUTFunctor< VT1, LUT >
 functor to apply a LUT to gray and color images. More...
struct  vigra_ext::ExposureResponseFunctor< OP >
 just apply exposure and response to linear data More...
struct  vigra_ext::MultiLayerImage< Image, Mask >
 A multilayer image is simply a collection consisting of multiple ROIImages. More...
class  vigra_ext::ThreadManager
 Thread "manager". More...
class  vigra_ext::ROIImage< Image, Mask >
 brief description.. More...
struct  vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< unsigned char > >
struct  vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< short > >
struct  vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< unsigned short > >
struct  vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< int > >
struct  vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< unsigned int > >
struct  vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< float > >
struct  vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< double > >
struct  vigra_ext::CreateAlphaTiffImage< unsigned char >
struct  vigra_ext::CreateAlphaTiffImage< short >
struct  vigra_ext::CreateAlphaTiffImage< unsigned short >
struct  vigra_ext::CreateAlphaTiffImage< int >
struct  vigra_ext::CreateAlphaTiffImage< unsigned int >
struct  vigra_ext::CreateAlphaTiffImage< float >
struct  vigra_ext::CreateAlphaTiffImage< double >
struct  vigra_ext::PointPairT< VALUE >
struct  vigra_ext::ValueTypeTraits< T1 >
struct  vigra_ext::OverlapSizeCounter
 count pixels that are > 0 in both images More...
struct  vigra_ext::NestFunctor< F1, F2 >
 functor to combine two functors: result = f1( f2(v) ) More...
struct  vigra_ext::MaskPixelCounter
 count pixels that are > 0 in a single image More...
struct  vigra_ext::PassThroughFunctor< T >
 does nothing More...
struct  vigra_ext::LinearTransform< DestValueType >
struct  vigra_ext::ApplyLogFunctor
struct  vigra_ext::ApplyGammaFunctor< TIn, TOut >
struct  vigra_ext::ApplyGammaFunctor< vigra::UInt16, vigra::UInt8 >
class  vigra_ext::VigCorrFlatDivFunctor< VT1, VT2, InvResp, Adjust >
class  vigra_ext::VigCorrDivFunctor< VT1, InvResp, VigFunc, Adjust >
class  vigra_ext::VigCorrFlatAddFunctor< VT1, VT2, InvResp, Adjust >
class  vigra_ext::VigCorrAddFunctor< VT1, InvResp, VigFunc, Adjust >
struct  vigra_ext::PolySqDistFunctor< NTERMS >
struct  vigra_ext::DitherFunctor< T >
 Dither code taken from enblend and adapted to a standalone functor. More...
struct  vigra_ext::GammaFunctor
struct  vigra_ext::LinearTransformFunctor< PT >
 Calculate ret = p * a + b. More...
struct  vigra_ext::VigQuotientEstimateResult
class  vigra_ext::VigQuotientEstimator
 This class estimates the parameters of the vignetting curve. More...

Typedefs

typedef float dist_t
typedef PointPairT< float > PointPair
typedef PointPairT< vigra::RGBValue<
float > > 
PointPairRGB

Enumerations

enum  {
  XGL_BYTE = 0, XGL_UNSIGNED_BYTE, XGL_SHORT, XGL_UNSIGNED_SHORT,
  XGL_INT, XGL_UNSIGNED_INT, XGL_FLOAT, XGL_RGBA8,
  XGL_RGBA16, XGL_RGBA32F, XGL_LUMINANCE8_ALPHA8, XGL_LUMINANCE16_ALPHA16,
  XGL_LUMINANCE_ALPHA32F, XGL_RGB8, XGL_RGB16, XGL_RGB32F,
  XGL_LUMINANCE8, XGL_LUMINANCE16, XGL_LUMINANCE32F, XGL_LUMINANCE,
  XGL_RGB, XGL_LUMINANCE_ALPHA, XGL_RGBA
}
enum  Interpolator {
  INTERP_CUBIC = 0, INTERP_SPLINE_16, INTERP_SPLINE_36, INTERP_SINC_256,
  INTERP_SPLINE_64, INTERP_BILINEAR, INTERP_NEAREST_NEIGHBOUR, INTERP_SINC_1024
}
 enum with all interpolation methods More...

Functions

template<class SrcImageIterator, class SrcAccessor>
void applyMask (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > img, HuginBase::MaskPolygonVector masks)
template<typename ImgIter, typename ImgAccessor, typename ImgMaskIter, typename ImgMaskAccessor, typename PanoIter, typename PanoAccessor, typename MaskIter, typename MaskAccessor>
void blendOverlap (vigra::triple< ImgIter, ImgIter, ImgAccessor > image, std::pair< ImgMaskIter, ImgMaskAccessor > imageMask, std::pair< PanoIter, PanoAccessor > pano, std::pair< MaskIter, MaskAccessor > panoMask, AppBase::MultiProgressDisplay &progress)
 blends two images, they overlap and the iterators point to excatly the same position.
template<typename ImageType, typename AlphaImageType, typename PanoIter, typename PanoAccessor, typename AlphaIter, typename AlphaAccessor>
void blend (vigra_ext::ROIImage< ImageType, AlphaImageType > &img, vigra::triple< PanoIter, PanoIter, PanoAccessor > pano, std::pair< AlphaIter, AlphaAccessor > alpha, vigra::Rect2D &panoROI, AppBase::MultiProgressDisplay &progress)
 blend img into pano, using alpha mask and panoROI
template<class SrcImage, class DestImage, class KernelImage>
CorrelationResult correlateImageFast (SrcImage &src, DestImage &dest, KernelImage &kernel, vigra::Diff2D kul, vigra::Diff2D klr, double threshold=0.7)
 correlate a template with an image.
template<class Iterator, class Accessor>
CorrelationResult subpixelMaxima (vigra::triple< Iterator, Iterator, Accessor > img, vigra::Diff2D max)
 find the subpixel maxima by fitting 2nd order polynoms to x and y.
template<class IMAGET, class IMAGES>
CorrelationResult PointFineTune (const IMAGET &templImg, vigra::Diff2D templPos, int templSize, const IMAGES &searchImg, vigra::Diff2D searchPos, int sWidth)
 fine tune a point with normalized cross correlation
template<class IMAGET, class IMAGES>
CorrelationResult PointFineTuneRotSearch (const IMAGET &templImg, vigra::Diff2D templPos, int templSize, const IMAGES &searchImg, vigra::Diff2D searchPos, int sWidth, double startAngle, double stopAngle, int angleSteps)
 fine tune a point with normalized cross correlation, searches x,y and phi (rotation around z)
template<class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor, class KernelIterator, class KernelAccessor>
CorrelationResult correlateImage (SrcIterator sul, SrcIterator slr, SrcAccessor as, DestIterator dul, DestAccessor ad, KernelIterator ki, KernelAccessor ak, vigra::Diff2D kul, vigra::Diff2D klr, double threshold=0.7)
 correlate a template with an image.
template<typename M>
double calcDeterminant3 (const M &m)
 calculate the determinat of a 3x3 matrix using the sarrus formula
template<class T>
void FitPolynom (T x, T xend, T y, double &a, double &b, double &c)
 fit a second order polynom to a data set
template<class T>
zeroNegative (T p)
 Set negative elements of a pixel to zero.
template<class T>
vigra::RGBValue< T > zeroNegative (vigra::RGBValue< T > p)
 Set negative elements of a pixel to zero.
template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageIntern (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, std::pair< AlphaImageIterator, AlphaAccessor > alpha, TRANSFORM &transform, PixelTransform &pixelTransform, vigra::Diff2D destUL, Interpolator interp, bool warparound, AppBase::MultiProgressDisplay &prog)
 Transform an image into the panorama.
template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageAlphaIntern (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, std::pair< SrcAlphaIterator, SrcAlphaAccessor > srcAlpha, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, std::pair< AlphaImageIterator, AlphaAccessor > alpha, TRANSFORM &transform, PixelTransform &pixelTransform, vigra::Diff2D destUL, Interpolator interp, bool warparound, AppBase::MultiProgressDisplay &prog)
 transform input images with alpha channel
template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class DistImageIterator, class DistAccessor, class Interpolator>
void transformImageDist (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, vigra::Diff2D destUL, TRANSFORM &transform, vigra::triple< DistImageIterator, DistImageIterator, DistAccessor > centerDist, Interpolator &interp, AppBase::MultiProgressDisplay &prog)
 Transform an image into the panorama.
template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageAlphaInternMT (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, std::pair< SrcAlphaIterator, SrcAlphaAccessor > srcAlpha, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, std::pair< AlphaImageIterator, AlphaAccessor > alpha, TRANSFORM &transform, PixelTransform &pixelTransform, vigra::Diff2D destUL, Interpolator interp, bool warparound, AppBase::MultiProgressDisplay &prog)
 multithreaded image transformation. multithreaded image transformation.
template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageInternMT (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, std::pair< AlphaImageIterator, AlphaAccessor > alpha, TRANSFORM &transform, PixelTransform &pixelTransform, vigra::Diff2D destUL, Interpolator interp, bool warparound, AppBase::MultiProgressDisplay &prog)
template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class AlphaImageIterator, class AlphaAccessor, class TRANSFORM, class PixelTransform>
void transformImage (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, std::pair< AlphaImageIterator, AlphaAccessor > alpha, vigra::Diff2D destUL, TRANSFORM &transform, PixelTransform &pixelTransform, bool warparound, Interpolator interpol, AppBase::MultiProgressDisplay &progress)
 Transform an image into the panorama.
template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class AlphaImageIterator, class AlphaAccessor, class TRANSFORM, class PixelTransform>
void transformImageAlpha (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, std::pair< SrcAlphaIterator, SrcAlphaAccessor > srcAlpha, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, std::pair< AlphaImageIterator, AlphaAccessor > alpha, vigra::Diff2D destUL, TRANSFORM &transform, PixelTransform &pixelTransform, bool warparound, Interpolator interpol, AppBase::MultiProgressDisplay &progress)
 Transform image, and respect a possible alpha channel.
template<class T, int nr>
void fillVector (T vec[3], T &val, int len)
bool transformImageGPUIntern (const std::string &coordXformGLSL, const std::string &interpolatorGLSL, const int interpolatorSize, const std::string &photometricGLSL, const vector< double > &invLut, const vector< double > &destLut, const vigra::Diff2D srcSize, const void *const srcBuffer, const int srcGLInternalFormat, const int srcGLTransferFormat, const int srcGLFormat, const int srcGLType, const void *const srcAlphaBuffer, const int srcAlphaGLType, const vigra::Diff2D destUL, const vigra::Diff2D destSize, void *const destBuffer, const int destGLInternalFormat, const int destGLTransferFormat, const int destGLFormat, const int destGLType, void *const destAlphaBuffer, const int destAlphaGLType, const bool warparound)
bool transformImageGPUIntern (const std::string &coordXformGLSL, const std::string &interpolatorGLSL, const int interpolatorSize, const std::string &photometricGLSL, const std::vector< double > &invLut, const std::vector< double > &destLut, const vigra::Diff2D srcSize, const void *const srcBuffer, const int srcGLInternalFormat, const int srcGLTransferFormat, const int srcGLFormat, const int srcGLType, const void *const srcAlphaBuffer, const int srcAlphaGLType, const vigra::Diff2D destUL, const vigra::Diff2D destSize, void *const destBuffer, const int destGLInternalFormat, const int destGLTransferFormat, const int destGLFormat, const int destGLType, void *const destAlphaBuffer, const int destAlphaGLType, const bool warparound)
 DEFINE_GPUNUMERICTRAITS (vigra::Int8, XGL_LUMINANCE8_ALPHA8, XGL_RGBA8, XGL_LUMINANCE8, XGL_RGB8, XGL_BYTE)
 DEFINE_GPUNUMERICTRAITS (vigra::UInt8, XGL_LUMINANCE8_ALPHA8, XGL_RGBA8, XGL_LUMINANCE8, XGL_RGB8, XGL_UNSIGNED_BYTE)
 DEFINE_GPUNUMERICTRAITS (vigra::Int16, XGL_LUMINANCE16_ALPHA16, XGL_RGBA16, XGL_LUMINANCE16, XGL_RGB16, XGL_SHORT)
 DEFINE_GPUNUMERICTRAITS (vigra::UInt16, XGL_LUMINANCE16_ALPHA16, XGL_RGBA16, XGL_LUMINANCE16, XGL_RGB16, XGL_UNSIGNED_SHORT)
 DEFINE_GPUNUMERICTRAITS (vigra::Int32, XGL_LUMINANCE_ALPHA32F, XGL_RGBA32F, XGL_LUMINANCE32F, XGL_RGB32F, XGL_INT)
 DEFINE_GPUNUMERICTRAITS (vigra::UInt32, XGL_LUMINANCE_ALPHA32F, XGL_RGBA32F, XGL_LUMINANCE32F, XGL_RGB32F, XGL_UNSIGNED_INT)
 DEFINE_GPUNUMERICTRAITS (float, XGL_LUMINANCE_ALPHA32F, XGL_RGBA32F, XGL_LUMINANCE32F, XGL_RGB32F, XGL_FLOAT)
 DEFINE_GPUNUMERICTRAITS (double, XGL_LUMINANCE_ALPHA32F, XGL_RGBA32F, XGL_LUMINANCE32F, XGL_RGB32F, XGL_FLOAT)
template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageGPUIntern (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, std::pair< AlphaImageIterator, AlphaAccessor > alpha, TRANSFORM &transform, PixelTransform &pixelTransform, vigra::Diff2D destUL, Interpolator interp, bool warparound, AppBase::MultiProgressDisplay &prog)
 Transform an image into the panorama.
template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageAlphaGPUIntern (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, std::pair< SrcAlphaIterator, SrcAlphaAccessor > srcAlpha, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, std::pair< AlphaImageIterator, AlphaAccessor > alpha, TRANSFORM &transform, PixelTransform &pixelTransform, vigra::Diff2D destUL, Interpolator interp, bool warparound, AppBase::MultiProgressDisplay &prog)
 transform input images with alpha channel
template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class AlphaImageIterator, class AlphaAccessor, class TRANSFORM, class PixelTransform>
void transformImageGPU (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, std::pair< AlphaImageIterator, AlphaAccessor > alpha, vigra::Diff2D destUL, TRANSFORM &transform, PixelTransform &pixelTransform, bool warparound, Interpolator interpol, AppBase::MultiProgressDisplay &progress)
 Transform an image into the panorama.
template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class AlphaImageIterator, class AlphaAccessor, class TRANSFORM, class PixelTransform>
void transformImageAlphaGPU (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, std::pair< SrcAlphaIterator, SrcAlphaAccessor > srcAlpha, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, std::pair< AlphaImageIterator, AlphaAccessor > alpha, vigra::Diff2D destUL, TRANSFORM &transform, PixelTransform &pixelTransform, bool warparound, Interpolator interpol, AppBase::MultiProgressDisplay &progress)
 Transform image, and respect a possible alpha channel.
template<class ImageIter, class ImageAcc>
void findInterestPointsOnGrid (vigra::triple< ImageIter, ImageIter, ImageAcc > img, double scale, unsigned nPoints, unsigned grid, std::vector< std::multimap< double, vigra::Diff2D > > &allPoints)
template<class VECTOR>
void createGammaLUT (double gamma, VECTOR &lut)
template<class VEC, class VEC2>
void resizeLUT (const VEC &iLUT, VEC2 &oLUT)
template<class LUT>
void enforceMonotonicity (LUT &lut)
 enforce monotonicity of an array (mostly used for lookup tables)
template<class SrcIter, class SrcAcc, class DestIter, class DestAcc, class Function>
void multithreadOperation (vigra::triple< SrcIter, SrcIter, SrcAcc > src, vigra::pair< DestIter, DestAcc > dest, Function op)
 operation to do multithreaded image processing operations
dist_t distance (uint32 deltaX, dist_t *deltaY)
dist_t distance (uint32 deltaY)
template<typename Feat1Iter, typename Feat1Accessor, typename Feat2Iter, typename Feat2Accessor, typename Mask1Iter, typename Mask1Accessor, typename Mask2Iter, typename Mask2Accessor>
void nearestFeatureTransform (vigra::triple< Feat1Iter, Feat1Iter, Feat1Accessor > feat1, std::pair< Feat2Iter, Feat2Accessor > feat2, std::pair< Mask1Iter, Mask1Accessor > mask1, std::pair< Mask2Iter, Mask2Accessor > mask2, AppBase::MultiProgressDisplay &progress)
 Perform a nearest feature transform on the input image within the union bounding box.
template<class ImageIn, class Image>
void reduceNTimes (ImageIn &in, Image &out, int n)
template<class Image, class ImageMask>
void reduceNTimes (Image &in, ImageMask &inMask, Image &out, ImageMask &outMask, int n)
template<class ImageIn, class ImageOut>
void reduceToNextLevel (ImageIn &in, ImageOut &out)
template<class ImageIn, class ImageInMask, class ImageOut, class ImageOutMask>
void reduceToNextLevel (ImageIn &in, ImageInMask &inMask, ImageOut &out, ImageOutMask &outMask)
template<class Image>
void reduceToNextLevelOld (Image &in, Image &out)
 Gaussian reduction to next pyramid level.
template<class ImgIter, class ImgAcc>
vigra::triple< ImgIter, ImgIter,
ImgAcc > 
applyRect (vigra::Rect2D &r, vigra::triple< ImgIter, ImgIter, ImgAcc > img)
 apply a roi to an image area
template<class ImgIter, class ImgAcc>
vigra::pair< ImgIter, ImgAcc > applyRect (vigra::Rect2D &r, vigra::pair< ImgIter, ImgAcc > img)
 apply a roi to an image
template<typename Image, typename Mask>
vigra::triple< typename ROIImage<
Image, Mask >::image_const_traverser,
typename ROIImage< Image,
Mask >::image_const_traverser,
typename ROIImage< Image,
Mask >::ImageConstAccessor > 
srcImageRange (const ROIImage< Image, Mask > &img)
 helper function for ROIImages
template<typename Image, typename Mask>
vigra::pair< typename ROIImage<
Image, Mask >::image_const_traverser,
typename ROIImage< Image,
Mask >::ImageConstAccessor > 
srcImage (const ROIImage< Image, Mask > &img)
template<class Image, class Alpha>
vigra::triple< typename ROIImage<
Image, Alpha >::image_traverser,
typename ROIImage< Image,
Alpha >::image_traverser,
typename ROIImage< Image,
Alpha >::ImageAccessor > 
destImageRange (ROIImage< Image, Alpha > &img)
template<class Image, class Alpha>
vigra::pair< typename ROIImage<
Image, Alpha >::image_traverser,
typename ROIImage< Image,
Alpha >::ImageAccessor > 
destImage (ROIImage< Image, Alpha > &img)
template<class Image, class Alpha>
vigra::triple< typename ROIImage<
Image, Alpha >::mask_const_traverser,
typename ROIImage< Image,
Alpha >::mask_const_traverser,
typename ROIImage< Image,
Alpha >::MaskConstAccessor > 
srcMaskRange (const ROIImage< Image, Alpha > &img)
template<class Image, class Alpha>
vigra::pair< typename ROIImage<
Image, Alpha >::mask_const_traverser,
typename ROIImage< Image,
Alpha >::MaskConstAccessor > 
srcMask (const ROIImage< Image, Alpha > &img)
template<class Image, class Alpha>
vigra::triple< typename ROIImage<
Image, Alpha >::mask_traverser,
typename ROIImage< Image,
Alpha >::mask_traverser,
typename ROIImage< Image,
Alpha >::MaskAccessor > 
destMaskRange (ROIImage< Image, Alpha > &img)
template<class Image, class Alpha>
vigra::pair< typename ROIImage<
Image, Alpha >::mask_traverser,
typename ROIImage< Image,
Alpha >::MaskAccessor > 
destMask (ROIImage< Image, Alpha > &img)
template<class ImgIter, class ImgAcc, class MaskIter, class MaskAcc, class Functor>
void inspectImagesIf (std::vector< ImgIter > imgs, std::vector< MaskIter > masks, std::vector< vigra::Rect2D > rois, Functor &f)
 function to inspect a variable number of images.
template<class ROIIMG, class DestIter, class DestAccessor, class MaskIter, class MaskAccessor, class FUNCTOR>
void reduceROIImages (std::vector< ROIIMG * > images, vigra::triple< DestIter, DestIter, DestAccessor > dest, vigra::pair< MaskIter, MaskAccessor > destMask, FUNCTOR &reduce)
 algorithm to reduce a set of ROI images
void createTiffDirectory (vigra::TiffImage *tiff, const std::string &pagename, const std::string &documentname, const std::string comp, uint16 page, uint16 nImg, vigra::Diff2D offset, vigra::Size2D fullSize, const vigra::ImageExportInfo::ICCProfile &icc)
 write a new Tiff directory, for a new layer
template<class ImageIterator, class ImageAccessor, class AlphaIterator, class AlphaAccessor>
void createRGBATiffImage (ImageIterator upperleft, ImageIterator lowerright, ImageAccessor a, AlphaIterator alphaUpperleft, AlphaAccessor alphaA, vigra::TiffImage *tiff, int sampleformat)
 internal function to create a RGB tiff image with alpha channel
template<class ImageIterator, class ImageAccessor, class AlphaIterator, class AlphaAccessor>
void createAlphaTiffImage (ImageIterator upperleft, ImageIterator lowerright, ImageAccessor a, AlphaIterator alphaUpperleft, AlphaAccessor alphaA, vigra::TiffImage *tiff)
template<class ImageIterator, class ImageAccessor, class AlphaIterator, class BImageAccessor>
void createAlphaTiffImage (vigra::triple< ImageIterator, ImageIterator, ImageAccessor > src, vigra::pair< AlphaIterator, BImageAccessor > alpha, vigra::TiffImage *tiff)
 save an image and an alpha channel to a tiff file.
 LUT_TRAITS (unsigned char, UCHAR_MAX)
 LUT_TRAITS (signed char, SCHAR_MAX)
 LUT_TRAITS (unsigned short, USHRT_MAX)
 LUT_TRAITS (signed short, SHRT_MAX)
 LUT_TRAITS (unsigned int, UINT_MAX)
 LUT_TRAITS (signed int, INT_MAX)
 LUT_TRAITS (float, 1.0)
 LUT_TRAITS (double, 1.0)
double getMaxValForPixelType (const std::string &v)
 VT_TRAITS (vigra::UInt8)
 VT_TRAITS (vigra::Int16)
 VT_TRAITS (vigra::UInt16)
 VT_TRAITS (vigra::Int32)
 VT_TRAITS (vigra::UInt32)
 VT_TRAITS (float)
 VT_TRAITS (double)
float pow (float a, double b)
template<class T, unsigned int R, unsigned int G, unsigned int B>
vigra::RGBValue< T, R, G, B > pow (vigra::RGBValue< T, R, G, B > const &v, double e)
 component-wise absolute value
template<class V1, unsigned int R, unsigned int G, unsigned int B, class V2>
vigra::RGBValue< V1, R, G,
B > & 
operator+= (vigra::RGBValue< V1, R, G, B > &l, V2 const &r)
 add a scalar to all components
template<class T, unsigned int RIDX, unsigned int GIDX, unsigned int BIDX>
vigra::RGBValue< T, RIDX,
GIDX, BIDX > 
log (vigra::RGBValue< T, RIDX, GIDX, BIDX > const &v)
 component-wise logarithm
template<class T, unsigned int RIDX, unsigned int GIDX, unsigned int BIDX>
vigra::RGBValue< T, RIDX,
GIDX, BIDX > 
log10 (vigra::RGBValue< T, RIDX, GIDX, BIDX > const &v)
 component-wise logarithm
template<class V1, unsigned int R, unsigned int G, unsigned int B, class V2>
vigra::PromoteTraits< vigra::RGBValue<
V1, R, G, B >, V2 >::Promote 
operator+ (vigra::RGBValue< V1, R, G, B > const &r1, V2 const &r2)
 add a scalar to all components
template<class V, int SIZE, class D1, class D2>
vigra::TinyVector< V, SIZE > pow (vigra::TinyVector< V, SIZE > const &v, double e)
 Apply pow() function to each vector component.
template<class V, int SIZE, class D1, class D2>
vigra::TinyVector< V, SIZE > log (vigra::TinyVector< V, SIZE > const &v, double e)
 Apply log() function to each vector component.
template<class V>
getMaxComponent (vigra::RGBValue< V > const &v)
 get the maximum component of a vector (also works for single pixel types...)
template<class V>
getMaxComponent (V v)
 get the maximum component of a vector (also works for single pixel types...)
template<class V>
getMinComponent (vigra::RGBValue< V > const &v)
 get the maximum component of a vector (also works for single pixel types...)
template<class V>
getMinComponent (V v)
 get the maximum component of a vector (also works for single pixel types...)
template<class SrcImageIterator, class SrcAccessor>
void circularCrop (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > img, hugin_utils::FDiff2D middle, double radius)
 Apply a circular crop to img.
template<class T>
vigra::NumericTraits< T
>::RealPromote 
normalizeValue (T v, vigra::VigraTrueType)
 normalize a pixel to 0..1 Only has an effect on integer pixel types
template<class T>
vigra::NumericTraits< T
>::RealPromote 
normalizeValue (T v, vigra::VigraFalseType)
template<class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor, class T>
void applyMapping (vigra::triple< SrcIterator, SrcIterator, SrcAccessor > img, vigra::pair< DestIterator, DestAccessor > dest, T min, T max, int mapping)
template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void transformImageSpatial (SrcImageIterator src_upperleft, SrcImageIterator src_lowerright, SrcAccessor sa, DestImageIterator dest_upperleft, DestAccessor da, Functor const &f, vigra::Diff2D ul)
template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void transformImageSpatial (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, vigra::pair< DestImageIterator, DestAccessor > dest, Functor const &f, vigra::Diff2D ul)
bool isTrueType (vigra::VigraFalseType)
bool isTrueType (vigra::VigraTrueType)
template<class T>
bool ditheringNeeded (T const &)
template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void applyRadialVigCorrection (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, vigra::pair< DestImageIterator, DestAccessor > dest, double cx, double cy, Functor const &f)
template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void applyRadialVigCorrection (SrcImageIterator src_upperleft, SrcImageIterator src_lowerright, SrcAccessor sa, DestImageIterator dest_upperleft, DestAccessor da, double cx, double cy, Functor const &f)
template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void applyRadialVigCorrectionDither (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, vigra::pair< DestImageIterator, DestAccessor > dest, double cx, double cy, Functor const &f, bool dither)
 Apply flatfield correction with dithering.
template<class ImgIter, class ImgAccessor, class FFIter, class FFAccessor, class DestIter, class DestAccessor, class Functor>
void combineTwoImagesDither (vigra::triple< ImgIter, ImgIter, ImgAccessor > srcImg, vigra::pair< FFIter, FFAccessor > ffImg, vigra::pair< DestIter, DestAccessor > destImg, Functor const &f, bool dither)
 Apply combine two images.
template<class ImgIter, class ImgAccessor, class FFIter, class FFAccessor, class DestIter, class DestAccessor>
void flatfieldVigCorrection (vigra::triple< ImgIter, ImgIter, ImgAccessor > srcImg, vigra::pair< FFIter, FFAccessor > ffImg, vigra::pair< DestIter, DestAccessor > destImg, double gamma, double gammaMaxVal, bool division, typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote a, typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote b, bool dither)
template<class ImgIter, class ImgAccessor, class DestIter, class DestAccessor>
void radialVigCorrection (vigra::triple< ImgIter, ImgIter, ImgAccessor > srcImg, vigra::pair< DestIter, DestAccessor > destImg, double gamma, double gammaMaxVal, const std::vector< double > &radCoeff, hugin_utils::FDiff2D center, bool division, typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote a, typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote b, bool dither)
template<class ImgIter, class ImgAccessor, class DestIter, class DestAccessor>
void applyBrightnessCorrection (vigra::triple< ImgIter, ImgIter, ImgAccessor > srcImg, vigra::pair< DestIter, DestAccessor > destImg, typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote a, typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote b)
template<class ImgIter, class ImgAccessor, class DestIter, class DestAccessor>
void applyGammaAndBrightCorrection (vigra::triple< ImgIter, ImgIter, ImgAccessor > srcImg, vigra::pair< DestIter, DestAccessor > destImg, double gamma, double maxGVal, typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote a, typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote b)
template<class ImgIter, class ImgAccessor, class DestIter, class DestAccessor>
void applyGammaCorrection (vigra::triple< ImgIter, ImgIter, ImgAccessor > srcImg, vigra::pair< DestIter, DestAccessor > destImg, double gamma, double maxGVal)
template<class PITER>
double calcVigCorrPoly (PITER p, double r)
 function to calculate the vignetting correction: 1 + p[0]*r^2 + p[1]*r^4 + p[2]*r^6
template<class ImageType, class CoordType>
void extractRandomPoints (std::vector< vigra_ext::ROIImage< ImageType, vigra::BImage > * > &remapped, std::vector< CoordType > &imgXCoord, std::vector< CoordType > &imgYCoord, const std::vector< vigra::Size2D > &imgSize, const std::vector< hugin_utils::FDiff2D > &imgCenter, unsigned nPointsPerOverlap, std::vector< PointPair > &points, unsigned &nBadPoints)
VigQuotientEstimateResult optimizeVignettingQuotient (const std::vector< PointPair > &points, double ransacDelta, std::vector< double > &vigCoeff)


Typedef Documentation

typedef float vigra_ext::dist_t
 

typedef PointPairT<float> vigra_ext::PointPair
 

typedef PointPairT<vigra::RGBValue<float> > vigra_ext::PointPairRGB
 


Enumeration Type Documentation

anonymous enum
 

Enumeration values:
XGL_BYTE 
XGL_UNSIGNED_BYTE 
XGL_SHORT 
XGL_UNSIGNED_SHORT 
XGL_INT 
XGL_UNSIGNED_INT 
XGL_FLOAT 
XGL_RGBA8 
XGL_RGBA16 
XGL_RGBA32F 
XGL_LUMINANCE8_ALPHA8 
XGL_LUMINANCE16_ALPHA16 
XGL_LUMINANCE_ALPHA32F 
XGL_RGB8 
XGL_RGB16 
XGL_RGB32F 
XGL_LUMINANCE8 
XGL_LUMINANCE16 
XGL_LUMINANCE32F 
XGL_LUMINANCE 
XGL_RGB 
XGL_LUMINANCE_ALPHA 
XGL_RGBA 

enum Interpolator
 

enum with all interpolation methods

Enumeration values:
INTERP_CUBIC 
INTERP_SPLINE_16 
INTERP_SPLINE_36 
INTERP_SINC_256 
INTERP_SPLINE_64 
INTERP_BILINEAR 
INTERP_NEAREST_NEIGHBOUR 
INTERP_SINC_1024 


Function Documentation

template<class ImgIter, class ImgAccessor, class DestIter, class DestAccessor>
void applyBrightnessCorrection vigra::triple< ImgIter, ImgIter, ImgAccessor >  srcImg,
vigra::pair< DestIter, DestAccessor >  destImg,
typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote  a,
typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote  b
 

template<class ImgIter, class ImgAccessor, class DestIter, class DestAccessor>
void applyGammaAndBrightCorrection vigra::triple< ImgIter, ImgIter, ImgAccessor >  srcImg,
vigra::pair< DestIter, DestAccessor >  destImg,
double  gamma,
double  maxGVal,
typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote  a,
typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote  b
 

template<class ImgIter, class ImgAccessor, class DestIter, class DestAccessor>
void applyGammaCorrection vigra::triple< ImgIter, ImgIter, ImgAccessor >  srcImg,
vigra::pair< DestIter, DestAccessor >  destImg,
double  gamma,
double  maxGVal
 

template<class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor, class T>
void applyMapping vigra::triple< SrcIterator, SrcIterator, SrcAccessor >  img,
vigra::pair< DestIterator, DestAccessor >  dest,
min,
max,
int  mapping
 

template<class SrcImageIterator, class SrcAccessor>
void applyMask vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  img,
HuginBase::MaskPolygonVector  masks
 

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void applyRadialVigCorrection SrcImageIterator  src_upperleft,
SrcImageIterator  src_lowerright,
SrcAccessor  sa,
DestImageIterator  dest_upperleft,
DestAccessor  da,
double  cx,
double  cy,
Functor const &  f
 

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void applyRadialVigCorrection vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
vigra::pair< DestImageIterator, DestAccessor >  dest,
double  cx,
double  cy,
Functor const &  f
 

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void applyRadialVigCorrectionDither vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
vigra::pair< DestImageIterator, DestAccessor >  dest,
double  cx,
double  cy,
Functor const &  f,
bool  dither
 

Apply flatfield correction with dithering.

If dither is true, dithering will be performed

template<class ImgIter, class ImgAcc>
vigra::pair<ImgIter, ImgAcc> applyRect vigra::Rect2D &  r,
vigra::pair< ImgIter, ImgAcc >  img
 

apply a roi to an image

adjusts the iterators, so that they iterate over the region specifed by r

template<class ImgIter, class ImgAcc>
vigra::triple<ImgIter, ImgIter, ImgAcc> applyRect vigra::Rect2D &  r,
vigra::triple< ImgIter, ImgIter, ImgAcc >  img
 

apply a roi to an image area

adjusts the iterators, so that they iterate over the region specifed by r

Ignores the lowerRight in img. If r is bigger than the new iterators will point outside of the other one.

template<typename ImageType, typename AlphaImageType, typename PanoIter, typename PanoAccessor, typename AlphaIter, typename AlphaAccessor>
void blend vigra_ext::ROIImage< ImageType, AlphaImageType > &  img,
vigra::triple< PanoIter, PanoIter, PanoAccessor >  pano,
std::pair< AlphaIter, AlphaAccessor >  alpha,
vigra::Rect2D &  panoROI,
AppBase::MultiProgressDisplay progress
 

blend img into pano, using alpha mask and panoROI

updates pano, alpha and panoROI.

Parameters:
img is the image that should be blended,
pano destinatation image
alpha destination image alpha
panoROI used part of pano. Does not indicate the allocated part! It is supposed that pano is defined at least where img is defined.
progress Display progress there.

template<typename ImgIter, typename ImgAccessor, typename ImgMaskIter, typename ImgMaskAccessor, typename PanoIter, typename PanoAccessor, typename MaskIter, typename MaskAccessor>
void blendOverlap vigra::triple< ImgIter, ImgIter, ImgAccessor >  image,
std::pair< ImgMaskIter, ImgMaskAccessor >  imageMask,
std::pair< PanoIter, PanoAccessor >  pano,
std::pair< MaskIter, MaskAccessor >  panoMask,
AppBase::MultiProgressDisplay progress
 

blends two images, they overlap and the iterators point to excatly the same position.

template<typename M>
double calcDeterminant3 const M &  m  ) 
 

calculate the determinat of a 3x3 matrix using the sarrus formula

template<class PITER>
double calcVigCorrPoly PITER  p,
double  r
 

function to calculate the vignetting correction: 1 + p[0]*r^2 + p[1]*r^4 + p[2]*r^6

template<class SrcImageIterator, class SrcAccessor>
void circularCrop vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  img,
hugin_utils::FDiff2D  middle,
double  radius
 

Apply a circular crop to img.

Sets all pixels that are outside of the circle specified by middle and radius to zero.

template<class ImgIter, class ImgAccessor, class FFIter, class FFAccessor, class DestIter, class DestAccessor, class Functor>
void combineTwoImagesDither vigra::triple< ImgIter, ImgIter, ImgAccessor >  srcImg,
vigra::pair< FFIter, FFAccessor >  ffImg,
vigra::pair< DestIter, DestAccessor >  destImg,
Functor const &  f,
bool  dither
 

Apply combine two images.

If dither is true, dithering will be performed

template<class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor, class KernelIterator, class KernelAccessor>
CorrelationResult correlateImage SrcIterator  sul,
SrcIterator  slr,
SrcAccessor  as,
DestIterator  dul,
DestAccessor  ad,
KernelIterator  ki,
KernelAccessor  ak,
vigra::Diff2D  kul,
vigra::Diff2D  klr,
double  threshold = 0.7
 

correlate a template with an image.

most code is taken from vigra::convoluteImage. See its documentation for further information.

Correlation result already contains the maximum position and its correlation value. it should be possible to set a threshold here.

template<class SrcImage, class DestImage, class KernelImage>
CorrelationResult correlateImageFast SrcImage &  src,
DestImage &  dest,
KernelImage &  kernel,
vigra::Diff2D  kul,
vigra::Diff2D  klr,
double  threshold = 0.7
 

correlate a template with an image.

This tries to be faster than the other version, because it uses the image data directly.

most code is taken from vigra::convoluteImage. See its documentation for further information.

Correlation result already contains the maximum position and its correlation value. it should be possible to set a threshold here.

template<class ImageIterator, class ImageAccessor, class AlphaIterator, class BImageAccessor>
void createAlphaTiffImage vigra::triple< ImageIterator, ImageIterator, ImageAccessor >  src,
vigra::pair< AlphaIterator, BImageAccessor >  alpha,
vigra::TiffImage *  tiff
 

save an image and an alpha channel to a tiff file.

so far, only gray and RGB images are supported. the alpha channel is stored with the same type as the color channels.

If the alpha channels uses a different type as the color channel (for example 8 bit alpha channel, float color channels), they are converted to a sensible value. (0..1 for float alpha).

template<class ImageIterator, class ImageAccessor, class AlphaIterator, class AlphaAccessor>
void createAlphaTiffImage ImageIterator  upperleft,
ImageIterator  lowerright,
ImageAccessor  a,
AlphaIterator  alphaUpperleft,
AlphaAccessor  alphaA,
vigra::TiffImage *  tiff
[inline]
 

template<class VECTOR>
void createGammaLUT double  gamma,
VECTOR &  lut
[inline]
 

template<class ImageIterator, class ImageAccessor, class AlphaIterator, class AlphaAccessor>
void createRGBATiffImage ImageIterator  upperleft,
ImageIterator  lowerright,
ImageAccessor  a,
AlphaIterator  alphaUpperleft,
AlphaAccessor  alphaA,
vigra::TiffImage *  tiff,
int  sampleformat
 

internal function to create a RGB tiff image with alpha channel

void createTiffDirectory vigra::TiffImage *  tiff,
const std::string &  pagename,
const std::string &  documentname,
const std::string  comp,
uint16  page,
uint16  nImg,
vigra::Diff2D  offset,
vigra::Size2D  fullSize,
const vigra::ImageExportInfo::ICCProfile &  icc
[inline]
 

write a new Tiff directory, for a new layer

Parameters:
tiff tiff struct
pagename pagename for tiff layer
documentname for tiff layer
page page number
nImg total number of pages, needed for "image page/nImg" display
offset layer offset in pixels (must be positive)

DEFINE_GPUNUMERICTRAITS double  ,
XGL_LUMINANCE_ALPHA32F  ,
XGL_RGBA32F  ,
XGL_LUMINANCE32F  ,
XGL_RGB32F  ,
XGL_FLOAT 
 

DEFINE_GPUNUMERICTRAITS float  ,
XGL_LUMINANCE_ALPHA32F  ,
XGL_RGBA32F  ,
XGL_LUMINANCE32F  ,
XGL_RGB32F  ,
XGL_FLOAT 
 

DEFINE_GPUNUMERICTRAITS vigra::UInt32  ,
XGL_LUMINANCE_ALPHA32F  ,
XGL_RGBA32F  ,
XGL_LUMINANCE32F  ,
XGL_RGB32F  ,
XGL_UNSIGNED_INT 
 

DEFINE_GPUNUMERICTRAITS vigra::Int32  ,
XGL_LUMINANCE_ALPHA32F  ,
XGL_RGBA32F  ,
XGL_LUMINANCE32F  ,
XGL_RGB32F  ,
XGL_INT 
 

DEFINE_GPUNUMERICTRAITS vigra::UInt16  ,
XGL_LUMINANCE16_ALPHA16  ,
XGL_RGBA16  ,
XGL_LUMINANCE16  ,
XGL_RGB16  ,
XGL_UNSIGNED_SHORT 
 

DEFINE_GPUNUMERICTRAITS vigra::Int16  ,
XGL_LUMINANCE16_ALPHA16  ,
XGL_RGBA16  ,
XGL_LUMINANCE16  ,
XGL_RGB16  ,
XGL_SHORT 
 

DEFINE_GPUNUMERICTRAITS vigra::UInt8  ,
XGL_LUMINANCE8_ALPHA8  ,
XGL_RGBA8  ,
XGL_LUMINANCE8  ,
XGL_RGB8  ,
XGL_UNSIGNED_BYTE 
 

DEFINE_GPUNUMERICTRAITS vigra::Int8  ,
XGL_LUMINANCE8_ALPHA8  ,
XGL_RGBA8  ,
XGL_LUMINANCE8  ,
XGL_RGB8  ,
XGL_BYTE 
 

template<class Image, class Alpha>
vigra::pair<typename ROIImage<Image,Alpha>::image_traverser, typename ROIImage<Image,Alpha>::ImageAccessor> destImage ROIImage< Image, Alpha > &  img  )  [inline]
 

template<class Image, class Alpha>
vigra::triple<typename ROIImage<Image,Alpha>::image_traverser, typename ROIImage<Image,Alpha>::image_traverser, typename ROIImage<Image,Alpha>::ImageAccessor> destImageRange ROIImage< Image, Alpha > &  img  )  [inline]
 

template<class Image, class Alpha>
vigra::pair<typename ROIImage<Image,Alpha>::mask_traverser, typename ROIImage<Image,Alpha>::MaskAccessor> destMask ROIImage< Image, Alpha > &  img  )  [inline]
 

template<class Image, class Alpha>
vigra::triple<typename ROIImage<Image,Alpha>::mask_traverser, typename ROIImage<Image,Alpha>::mask_traverser, typename ROIImage<Image,Alpha>::MaskAccessor> destMaskRange ROIImage< Image, Alpha > &  img  )  [inline]
 

dist_t distance uint32  deltaY  )  [inline]
 

dist_t distance uint32  deltaX,
dist_t deltaY
[inline]
 

template<class T>
bool ditheringNeeded T const &   ) 
 

template<class LUT>
void enforceMonotonicity LUT &  lut  ) 
 

enforce monotonicity of an array (mostly used for lookup tables)

template<class ImageType, class CoordType>
void extractRandomPoints std::vector< vigra_ext::ROIImage< ImageType, vigra::BImage > * > &  remapped,
std::vector< CoordType > &  imgXCoord,
std::vector< CoordType > &  imgYCoord,
const std::vector< vigra::Size2D > &  imgSize,
const std::vector< hugin_utils::FDiff2D > &  imgCenter,
unsigned  nPointsPerOverlap,
std::vector< PointPair > &  points,
unsigned &  nBadPoints
 

template<class T, int nr>
void fillVector vec[3],
T &  val,
int  len
 

template<class ImageIter, class ImageAcc>
void findInterestPointsOnGrid vigra::triple< ImageIter, ImageIter, ImageAcc >  img,
double  scale,
unsigned  nPoints,
unsigned  grid,
std::vector< std::multimap< double, vigra::Diff2D > > &  allPoints
 

template<class T>
void FitPolynom x,
xend,
y,
double a,
double b,
double c
 

fit a second order polynom to a data set

y = a + b*x + c*x^2

uses a least mean square fit, give at least 3 points.

calculate quality of fit

template<class ImgIter, class ImgAccessor, class FFIter, class FFAccessor, class DestIter, class DestAccessor>
void flatfieldVigCorrection vigra::triple< ImgIter, ImgIter, ImgAccessor >  srcImg,
vigra::pair< FFIter, FFAccessor >  ffImg,
vigra::pair< DestIter, DestAccessor >  destImg,
double  gamma,
double  gammaMaxVal,
bool  division,
typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote  a,
typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote  b,
bool  dither
 

template<class V>
V getMaxComponent v  )  [inline]
 

get the maximum component of a vector (also works for single pixel types...)

template<class V>
V getMaxComponent vigra::RGBValue< V > const &  v  )  [inline]
 

get the maximum component of a vector (also works for single pixel types...)

double getMaxValForPixelType const std::string &  v  )  [inline]
 

template<class V>
V getMinComponent v  )  [inline]
 

get the maximum component of a vector (also works for single pixel types...)

template<class V>
V getMinComponent vigra::RGBValue< V > const &  v  )  [inline]
 

get the maximum component of a vector (also works for single pixel types...)

template<class ImgIter, class ImgAcc, class MaskIter, class MaskAcc, class Functor>
void inspectImagesIf std::vector< ImgIter >  imgs,
std::vector< MaskIter >  masks,
std::vector< vigra::Rect2D >  rois,
Functor &  f
 

function to inspect a variable number of images.

They do not need to overlap, and will be only evaluated inside their ROI

bool isTrueType vigra::VigraTrueType   )  [inline]
 

bool isTrueType vigra::VigraFalseType   )  [inline]
 

template<class V, int SIZE, class D1, class D2>
vigra::TinyVector<V, SIZE> log vigra::TinyVector< V, SIZE > const &  v,
double  e
[inline]
 

Apply log() function to each vector component.

template<class T, unsigned int RIDX, unsigned int GIDX, unsigned int BIDX>
vigra::RGBValue<T, RIDX, GIDX, BIDX> log vigra::RGBValue< T, RIDX, GIDX, BIDX > const &  v  )  [inline]
 

component-wise logarithm

template<class T, unsigned int RIDX, unsigned int GIDX, unsigned int BIDX>
vigra::RGBValue<T, RIDX, GIDX, BIDX> log10 vigra::RGBValue< T, RIDX, GIDX, BIDX > const &  v  )  [inline]
 

component-wise logarithm

LUT_TRAITS double  ,
1.  0
 

LUT_TRAITS float  ,
1.  0
 

LUT_TRAITS signed  int,
INT_MAX 
 

LUT_TRAITS unsigned  int,
UINT_MAX 
 

LUT_TRAITS signed  short,
SHRT_MAX 
 

LUT_TRAITS unsigned  short,
USHRT_MAX 
 

LUT_TRAITS signed  char,
SCHAR_MAX 
 

LUT_TRAITS unsigned  char,
UCHAR_MAX 
 

template<class SrcIter, class SrcAcc, class DestIter, class DestAcc, class Function>
void multithreadOperation vigra::triple< SrcIter, SrcIter, SrcAcc >  src,
vigra::pair< DestIter, DestAcc >  dest,
Function  op
 

operation to do multithreaded image processing operations

Function op should be a function that transforms one source image to a destination image. Function op should tale src and dest as arguments.

If it requires more arguments, boost::bind should be used to create a functor for it.

Note that the op has to take src and dest by value and not by reference, since they are not

template<typename Feat1Iter, typename Feat1Accessor, typename Feat2Iter, typename Feat2Accessor, typename Mask1Iter, typename Mask1Accessor, typename Mask2Iter, typename Mask2Accessor>
void nearestFeatureTransform vigra::triple< Feat1Iter, Feat1Iter, Feat1Accessor >  feat1,
std::pair< Feat2Iter, Feat2Accessor >  feat2,
std::pair< Mask1Iter, Mask1Accessor >  mask1,
std::pair< Mask2Iter, Mask2Accessor >  mask2,
AppBase::MultiProgressDisplay progress
 

Perform a nearest feature transform on the input image within the union bounding box.

For each thinnable pixel, determine if the pixel is closer to a green pixel or a blue pixel. Make the thinnable pixel the same color as the closest green or blue pixel.

note about the color channels: b = whiteimage = mask1 note about the color channels: g = blackimage = mask2

template<class T>
vigra::NumericTraits<T>::RealPromote normalizeValue v,
vigra::VigraFalseType 
 

template<class T>
vigra::NumericTraits<T>::RealPromote normalizeValue v,
vigra::VigraTrueType 
 

normalize a pixel to 0..1 Only has an effect on integer pixel types

template<class V1, unsigned int R, unsigned int G, unsigned int B, class V2>
vigra::PromoteTraits<vigra::RGBValue<V1, R, G, B>, V2 >::Promote operator+ vigra::RGBValue< V1, R, G, B > const &  r1,
V2 const &  r2
[inline]
 

add a scalar to all components

template<class V1, unsigned int R, unsigned int G, unsigned int B, class V2>
vigra::RGBValue<V1, R, G, B>& operator+= vigra::RGBValue< V1, R, G, B > &  l,
V2 const &  r
[inline]
 

add a scalar to all components

VigQuotientEstimateResult optimizeVignettingQuotient const std::vector< PointPair > &  points,
double  ransacDelta,
std::vector< double > &  vigCoeff
[inline]
 

template<class IMAGET, class IMAGES>
CorrelationResult PointFineTune const IMAGET &  templImg,
vigra::Diff2D  templPos,
int  templSize,
const IMAGES &  searchImg,
vigra::Diff2D  searchPos,
int  sWidth
 

fine tune a point with normalized cross correlation

takes a patch of templSize by templSize from templImg images at tmplPos and searches it on the searchImg, at searchPos, in a neighbourhood of sWidth by sWidth.

The result in returned in tunedPos

Returns:
correlation value

template<class IMAGET, class IMAGES>
CorrelationResult PointFineTuneRotSearch const IMAGET &  templImg,
vigra::Diff2D  templPos,
int  templSize,
const IMAGES &  searchImg,
vigra::Diff2D  searchPos,
int  sWidth,
double  startAngle,
double  stopAngle,
int  angleSteps
 

fine tune a point with normalized cross correlation, searches x,y and phi (rotation around z)

takes a patch of templSize by templSize from templImg images at tmplPos and searches it on the searchImg, at searchPos, in a neighbourhood of sWidth by sWidth.

The result in returned in tunedPos

Returns:
correlation value

template<class V, int SIZE, class D1, class D2>
vigra::TinyVector<V, SIZE> pow vigra::TinyVector< V, SIZE > const &  v,
double  e
[inline]
 

Apply pow() function to each vector component.

template<class T, unsigned int R, unsigned int G, unsigned int B>
vigra::RGBValue<T, R, G, B> pow vigra::RGBValue< T, R, G, B > const &  v,
double  e
[inline]
 

component-wise absolute value

float pow float  a,
double  b
[inline]
 

template<class ImgIter, class ImgAccessor, class DestIter, class DestAccessor>
void radialVigCorrection vigra::triple< ImgIter, ImgIter, ImgAccessor >  srcImg,
vigra::pair< DestIter, DestAccessor >  destImg,
double  gamma,
double  gammaMaxVal,
const std::vector< double > &  radCoeff,
hugin_utils::FDiff2D  center,
bool  division,
typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote  a,
typename vigra::NumericTraits< typename ImgAccessor::value_type >::RealPromote  b,
bool  dither
 

template<class Image, class ImageMask>
void reduceNTimes Image &  in,
ImageMask &  inMask,
Image &  out,
ImageMask &  outMask,
int  n
 

template<class ImageIn, class Image>
void reduceNTimes ImageIn &  in,
Image &  out,
int  n
 

template<class ROIIMG, class DestIter, class DestAccessor, class MaskIter, class MaskAccessor, class FUNCTOR>
void reduceROIImages std::vector< ROIIMG * >  images,
vigra::triple< DestIter, DestIter, DestAccessor >  dest,
vigra::pair< MaskIter, MaskAccessor >  destMask,
FUNCTOR &  reduce
 

algorithm to reduce a set of ROI images

template<class ImageIn, class ImageInMask, class ImageOut, class ImageOutMask>
void reduceToNextLevel ImageIn &  in,
ImageInMask &  inMask,
ImageOut &  out,
ImageOutMask &  outMask
 

template<class ImageIn, class ImageOut>
void reduceToNextLevel ImageIn &  in,
ImageOut &  out
 

template<class Image>
void reduceToNextLevelOld Image &  in,
Image &  out
 

Gaussian reduction to next pyramid level.

out is rescaled to the correct size.

template<class VEC, class VEC2>
void resizeLUT const VEC &  iLUT,
VEC2 &  oLUT
 

template<typename Image, typename Mask>
vigra::pair<typename ROIImage<Image, Mask>::image_const_traverser, typename ROIImage<Image, Mask>::ImageConstAccessor> srcImage const ROIImage< Image, Mask > &  img  )  [inline]
 

template<typename Image, typename Mask>
vigra::triple<typename ROIImage<Image, Mask>::image_const_traverser, typename ROIImage<Image, Mask>::image_const_traverser, typename ROIImage<Image, Mask>::ImageConstAccessor> srcImageRange const ROIImage< Image, Mask > &  img  )  [inline]
 

helper function for ROIImages

template<class Image, class Alpha>
vigra::pair<typename ROIImage<Image,Alpha>::mask_const_traverser, typename ROIImage<Image,Alpha>::MaskConstAccessor> srcMask const ROIImage< Image, Alpha > &  img  )  [inline]
 

template<class Image, class Alpha>
vigra::triple<typename ROIImage<Image,Alpha>::mask_const_traverser, typename ROIImage<Image,Alpha>::mask_const_traverser, typename ROIImage<Image,Alpha>::MaskConstAccessor> srcMaskRange const ROIImage< Image, Alpha > &  img  )  [inline]
 

template<class Iterator, class Accessor>
CorrelationResult subpixelMaxima vigra::triple< Iterator, Iterator, Accessor >  img,
vigra::Diff2D  max
 

find the subpixel maxima by fitting 2nd order polynoms to x and y.

this estimates the x and y values separately. Don't know if this is the best way, but it works well

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class AlphaImageIterator, class AlphaAccessor, class TRANSFORM, class PixelTransform>
void transformImage vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
vigra::triple< DestImageIterator, DestImageIterator, DestAccessor >  dest,
std::pair< AlphaImageIterator, AlphaAccessor >  alpha,
vigra::Diff2D  destUL,
TRANSFORM &  transform,
PixelTransform &  pixelTransform,
bool  warparound,
Interpolator  interpol,
AppBase::MultiProgressDisplay progress
 

Transform an image into the panorama.

It can be used for partial transformations as well, if the boundig box of a remapped image is known.

Usage: create an output image that should contain the remapped src image. if dest doesn't cover the whole output panorama, use destUL to specify the offset of dest from the output panorama.

Parameters:
src source image
dest (partial) panorama image. the image size needed to hold the complete remapped image can be calculated using calcBorderPoints().
destUL upper left point of dest in final panorama. set to (0,0) if dest has the same size as the complete panorama.
transform function used to remap the picture.
centerDist image, with the same size as dest, that will contain the distance of the corrosponding pixel from the center of src. This is useful to calculate nice seams. Use a null image if this information is not needed.
interpol Interpolation algorithm that should be used.

template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class AlphaImageIterator, class AlphaAccessor, class TRANSFORM, class PixelTransform>
void transformImageAlpha vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
std::pair< SrcAlphaIterator, SrcAlphaAccessor >  srcAlpha,
vigra::triple< DestImageIterator, DestImageIterator, DestAccessor >  dest,
std::pair< AlphaImageIterator, AlphaAccessor >  alpha,
vigra::Diff2D  destUL,
TRANSFORM &  transform,
PixelTransform &  pixelTransform,
bool  warparound,
Interpolator  interpol,
AppBase::MultiProgressDisplay progress
 

Transform image, and respect a possible alpha channel.

template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class AlphaImageIterator, class AlphaAccessor, class TRANSFORM, class PixelTransform>
void transformImageAlphaGPU vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
std::pair< SrcAlphaIterator, SrcAlphaAccessor >  srcAlpha,
vigra::triple< DestImageIterator, DestImageIterator, DestAccessor >  dest,
std::pair< AlphaImageIterator, AlphaAccessor >  alpha,
vigra::Diff2D  destUL,
TRANSFORM &  transform,
PixelTransform &  pixelTransform,
bool  warparound,
Interpolator  interpol,
AppBase::MultiProgressDisplay progress
 

Transform image, and respect a possible alpha channel.

template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageAlphaGPUIntern vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
std::pair< SrcAlphaIterator, SrcAlphaAccessor >  srcAlpha,
vigra::triple< DestImageIterator, DestImageIterator, DestAccessor >  dest,
std::pair< AlphaImageIterator, AlphaAccessor >  alpha,
TRANSFORM &  transform,
PixelTransform &  pixelTransform,
vigra::Diff2D  destUL,
Interpolator  interp,
bool  warparound,
AppBase::MultiProgressDisplay prog
 

transform input images with alpha channel

template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageAlphaIntern vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
std::pair< SrcAlphaIterator, SrcAlphaAccessor >  srcAlpha,
vigra::triple< DestImageIterator, DestImageIterator, DestAccessor >  dest,
std::pair< AlphaImageIterator, AlphaAccessor >  alpha,
TRANSFORM &  transform,
PixelTransform &  pixelTransform,
vigra::Diff2D  destUL,
Interpolator  interp,
bool  warparound,
AppBase::MultiProgressDisplay prog
 

transform input images with alpha channel

template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageAlphaInternMT vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
std::pair< SrcAlphaIterator, SrcAlphaAccessor >  srcAlpha,
vigra::triple< DestImageIterator, DestImageIterator, DestAccessor >  dest,
std::pair< AlphaImageIterator, AlphaAccessor >  alpha,
TRANSFORM &  transform,
PixelTransform &  pixelTransform,
vigra::Diff2D  destUL,
Interpolator  interp,
bool  warparound,
AppBase::MultiProgressDisplay prog
 

multithreaded image transformation. multithreaded image transformation.

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class DistImageIterator, class DistAccessor, class Interpolator>
void transformImageDist vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
vigra::triple< DestImageIterator, DestImageIterator, DestAccessor >  dest,
vigra::Diff2D  destUL,
TRANSFORM &  transform,
vigra::triple< DistImageIterator, DistImageIterator, DistAccessor >  centerDist,
Interpolator interp,
AppBase::MultiProgressDisplay prog
 

Transform an image into the panorama.

It can be used for partial transformations as well, if the boundig box of a remapped image is known.

Usage: create an output image that should contain the remapped src image. if dest doesn't cover the whole output panorama, use destUL to specify the offset of dest from the output panorama.

Parameters:
src source image
dest (partial) panorama image. the image size needed to hold the complete remapped image can be calculated using calcBorderPoints().
destUL upper left point of dest in final panorama. set to (0,0) if dest has the same size as the complete panorama.
transform function used to remap the picture.
centerDist image, with the same size as dest, that will contain the distance of the corrosponding pixel from the center of src. This is useful to calculate nice seams. Use a null image if this information is not needed.
interp Interpolator class (calculates weights for interpolation)

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class AlphaImageIterator, class AlphaAccessor, class TRANSFORM, class PixelTransform>
void transformImageGPU vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
vigra::triple< DestImageIterator, DestImageIterator, DestAccessor >  dest,
std::pair< AlphaImageIterator, AlphaAccessor >  alpha,
vigra::Diff2D  destUL,
TRANSFORM &  transform,
PixelTransform &  pixelTransform,
bool  warparound,
Interpolator  interpol,
AppBase::MultiProgressDisplay progress
 

Transform an image into the panorama.

Uses the GPU for processing.

It can be used for partial transformations as well, if the boundig box of a remapped image is known.

Usage: create an output image that should contain the remapped src image. if dest doesn't cover the whole output panorama, use destUL to specify the offset of dest from the output panorama.

Parameters:
src source image
dest (partial) panorama image. the image size needed to hold the complete remapped image can be calculated using calcBorderPoints().
destUL upper left point of dest in final panorama. set to (0,0) if dest has the same size as the complete panorama.
transform function used to remap the picture.
centerDist image, with the same size as dest, that will contain the distance of the corrosponding pixel from the center of src. This is useful to calculate nice seams. Use a null image if this information is not needed.
interpol Interpolation algorithm that should be used.

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageGPUIntern vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
vigra::triple< DestImageIterator, DestImageIterator, DestAccessor >  dest,
std::pair< AlphaImageIterator, AlphaAccessor >  alpha,
TRANSFORM &  transform,
PixelTransform &  pixelTransform,
vigra::Diff2D  destUL,
Interpolator  interp,
bool  warparound,
AppBase::MultiProgressDisplay prog
 

Transform an image into the panorama.

Uses the GPU for processing.

It can be used for partial transformations as well, if the bounding box of a remapped image is known.

Usage: create an output image that should contain the remapped src image. if dest doesn't cover the whole output panorama, use destUL to specify the offset of dest from the output panorama.

Parameters:
src source image
dest (partial) panorama image. the image size needed to hold the complete remapped image can be calculated using calcBorderPoints().
destUL upper left point of dest in final panorama. set to (0,0) if dest has the same size as the complete panorama.
transform function used to remap the picture.
centerDist image, with the same size as dest, that will contain the distance of the corrosponding pixel from the center of src. This is useful to calculate nice seams. Use a null image if this information is not needed.
interp Interpolator class (calculates weights for interpolation)

bool transformImageGPUIntern const std::string &  coordXformGLSL,
const std::string &  interpolatorGLSL,
const int  interpolatorSize,
const std::string &  photometricGLSL,
const std::vector< double > &  invLut,
const std::vector< double > &  destLut,
const vigra::Diff2D  srcSize,
const void *const   srcBuffer,
const int  srcGLInternalFormat,
const int  srcGLTransferFormat,
const int  srcGLFormat,
const int  srcGLType,
const void *const   srcAlphaBuffer,
const int  srcAlphaGLType,
const vigra::Diff2D  destUL,
const vigra::Diff2D  destSize,
void *const   destBuffer,
const int  destGLInternalFormat,
const int  destGLTransferFormat,
const int  destGLFormat,
const int  destGLType,
void *const   destAlphaBuffer,
const int  destAlphaGLType,
const bool  warparound
 

bool transformImageGPUIntern const std::string &  coordXformGLSL,
const std::string &  interpolatorGLSL,
const int  interpolatorSize,
const std::string &  photometricGLSL,
const vector< double > &  invLut,
const vector< double > &  destLut,
const vigra::Diff2D  srcSize,
const void *const   srcBuffer,
const int  srcGLInternalFormat,
const int  srcGLTransferFormat,
const int  srcGLFormat,
const int  srcGLType,
const void *const   srcAlphaBuffer,
const int  srcAlphaGLType,
const vigra::Diff2D  destUL,
const vigra::Diff2D  destSize,
void *const   destBuffer,
const int  destGLInternalFormat,
const int  destGLTransferFormat,
const int  destGLFormat,
const int  destGLType,
void *const   destAlphaBuffer,
const int  destAlphaGLType,
const bool  warparound
 

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageIntern vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
vigra::triple< DestImageIterator, DestImageIterator, DestAccessor >  dest,
std::pair< AlphaImageIterator, AlphaAccessor >  alpha,
TRANSFORM &  transform,
PixelTransform &  pixelTransform,
vigra::Diff2D  destUL,
Interpolator  interp,
bool  warparound,
AppBase::MultiProgressDisplay prog
 

Transform an image into the panorama.

It can be used for partial transformations as well, if the bounding box of a remapped image is known.

Usage: create an output image that should contain the remapped src image. if dest doesn't cover the whole output panorama, use destUL to specify the offset of dest from the output panorama.

Parameters:
src source image
dest (partial) panorama image. the image size needed to hold the complete remapped image can be calculated using calcBorderPoints().
destUL upper left point of dest in final panorama. set to (0,0) if dest has the same size as the complete panorama.
transform function used to remap the picture.
centerDist image, with the same size as dest, that will contain the distance of the corrosponding pixel from the center of src. This is useful to calculate nice seams. Use a null image if this information is not needed.
interp Interpolator class (calculates weights for interpolation)

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageInternMT vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
vigra::triple< DestImageIterator, DestImageIterator, DestAccessor >  dest,
std::pair< AlphaImageIterator, AlphaAccessor >  alpha,
TRANSFORM &  transform,
PixelTransform &  pixelTransform,
vigra::Diff2D  destUL,
Interpolator  interp,
bool  warparound,
AppBase::MultiProgressDisplay prog
 

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void transformImageSpatial vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor >  src,
vigra::pair< DestImageIterator, DestAccessor >  dest,
Functor const &  f,
vigra::Diff2D  ul
 

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void transformImageSpatial SrcImageIterator  src_upperleft,
SrcImageIterator  src_lowerright,
SrcAccessor  sa,
DestImageIterator  dest_upperleft,
DestAccessor  da,
Functor const &  f,
vigra::Diff2D  ul
 

VT_TRAITS double   ) 
 

VT_TRAITS float   ) 
 

VT_TRAITS vigra::UInt32   ) 
 

VT_TRAITS vigra::Int32   ) 
 

VT_TRAITS vigra::UInt16   ) 
 

VT_TRAITS vigra::Int16   ) 
 

VT_TRAITS vigra::UInt8   ) 
 

template<class T>
vigra::RGBValue<T> zeroNegative vigra::RGBValue< T >  p  ) 
 

Set negative elements of a pixel to zero.

template<class T>
T zeroNegative p  ) 
 

Set negative elements of a pixel to zero.


Generated on Mon Sep 20 01:01:37 2010 for Hugintrunk by doxygen 1.3.9.1