Main Page | Modules | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages | Examples | Search for 

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>
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)
void SetGPUDebugMessages (const bool doPrint)
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 IMPEX 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)
double sinc (double x)
double cubic01 (double x)
double cubic12 (double x)
const double A (-0.75)
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 createScalarATiffImage (ImageIterator upperleft, ImageIterator lowerright, ImageAccessor a, AlphaIterator alphaUpperleft, AlphaAccessor alphaA, vigra::TiffImage *tiff, int sampleformat)
 internal function to create a scalar tiff image with alpha channel
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>
V getMaxComponent (vigra::RGBValue< V > const &v)
 get the maximum component of a vector (also works for single pixel types...)
template<class V>
V getMaxComponent (V v)
 get the maximum component of a vector (also works for single pixel types...)
template<class V>
V getMinComponent (vigra::RGBValue< V > const &v)
 get the maximum component of a vector (also works for single pixel types...)
template<class V>
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)

Variables

const double AA = 0.4
const double W [] = {0.25 - AA / 2.0, 0.25, AA, 0.25, 0.25 - AA / 2.0}

Typedef Documentation

typedef float vigra_ext::dist_t
 

Definition at line 65 of file NearestFeatureTransform.h.

Referenced by distance(), and nearestFeatureTransform().

typedef PointPairT<float> vigra_ext::PointPair
 

Definition at line 121 of file utils.h.

Referenced by vigra_ext::VigQuotientEstimator::agree(), and extractRandomPoints().

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

Definition at line 122 of file utils.h.

Referenced by loadPoints(), and loadPointsC().

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 

Definition at line 78 of file ImageTransformsGPU.h.

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 

Definition at line 78 of file Interpolators.h.

Referenced by transformImageAlphaIntern(), transformImageAlphaInternMT(), transformImageDist(), and transformImageInternMT().

Function Documentation

const double A (  -0.  75  )  [static]
 

Referenced by cubic01(), cubic12(), vigra_ext::interp_cubic::emitGLSL(), and vigra_ext::VigQuotientEstimator::estimate().

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
) 
 

Definition at line 515 of file VignettingCorrection.h.

References transformImage().

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
) 
 

Definition at line 528 of file VignettingCorrection.h.

References transformImage().

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
) 
 

Definition at line 544 of file VignettingCorrection.h.

References transformImage().

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
) 
 

Definition at line 578 of file utils.h.

References transformImage().

Referenced by PanoDetector::AnalyzeImage(), convertGrayToUInt8(), HuginBase::convertTo8Bit(), celeste::convertToUInt16(), convertToUInt8(), and PreviewPanel::updatePreview().

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

Definition at line 162 of file Mask.h.

References hugin_utils::FDiff2D.

Referenced by TextureManager::TextureInfo::DefineMaskTexture(), and HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage().

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
) 
 

Definition at line 342 of file VignettingCorrection.h.

Referenced by applyRadialVigCorrection(), and applyRadialVigCorrectionDither().

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
) 
 

Definition at line 330 of file VignettingCorrection.h.

References applyRadialVigCorrection().

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

Definition at line 374 of file VignettingCorrection.h.

References applyRadialVigCorrection().

Referenced by radialVigCorrection().

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

Definition at line 66 of file ROIImage.h.

Referenced by blend(), HuginBase::Nona::estimateBlendingOrder(), HuginBase::Nona::DifferenceBlender::operator()(), and HuginBase::Nona::StackingBlender::operator()().

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.

Definition at line 46 of file ROIImage.h.

References DEBUG_ASSERT.

Referenced by blend(), HuginBase::CalculateFOV::calcFOV(), HuginBase::CenterHorizontally::centerHorizontically(), and HuginBase::Nona::DifferenceBlender::operator()().

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.

Definition at line 105 of file blend.h.

References applyRect(), blendOverlap(), vigra_ext::ROIImage< Image, Mask >::boundingBox(), DEBUG_DEBUG, vigra_ext::ROIImage< Image, Mask >::getMask(), srcImageRange(), srcMask(), srcMaskRange(), and vigra_ext::ROIImage< Image, Mask >::upperLeft().

Referenced by HuginBase::Nona::SeamBlender::operator()(), HuginBase::Nona::SimpleStitcher< ImageType, AlphaType >::stitch(), and HuginBase::Nona::WeightedStitcher< ImageType, AlphaType >::stitch().

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.

Definition at line 50 of file blend.h.

References destImage(), nearestFeatureTransform(), and srcImageRange().

Referenced by blend().

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

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

Definition at line 36 of file FitPolynom.h.

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

Definition at line 44 of file VigQuotientEstimator.h.

Referenced by optimizeVignettingQuotient().

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.

Definition at line 388 of file utils.h.

References hugin_utils::FDiff2D, hugin_utils::TDiff2D< T >::x, and hugin_utils::TDiff2D< T >::y.

Referenced by HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage().

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

Definition at line 399 of file VignettingCorrection.h.

Referenced by flatfieldVigCorrection().

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.

Definition at line 679 of file Correlation.h.

References vigra_ext::CorrelationResult::maxi, vigra_ext::CorrelationResult::maxpos, hugin_utils::TDiff2D< T >::x, and hugin_utils::TDiff2D< T >::y.

Referenced by PointFineTune(), PointFineTune2(), and PointFineTuneRotSearch().

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.

Definition at line 78 of file Correlation.h.

References DEBUG_DEBUG, vigra_ext::CorrelationResult::maxi, vigra_ext::CorrelationResult::maxpos, hugin_utils::TDiff2D< T >::x, and hugin_utils::TDiff2D< T >::y.

Referenced by PointFineTune(), PointFineTune2(), and PointFineTuneRotSearch().

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

Definition at line 544 of file tiffUtils.h.

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]
 

Definition at line 520 of file tiffUtils.h.

Referenced by HuginBase::Nona::TiffMultiLayerRemapper< ImageType, AlphaImageType >::saveRemapped().

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

Definition at line 50 of file lut.h.

References celeste::max(), and pow().

Referenced by HuginBase::Photometric::ResponseTransform< VTIn >::initWithSrcImg(), and PreviewPanel::updatePreview().

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

Definition at line 191 of file tiffUtils.h.

Referenced by vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< double > >::exec(), vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< float > >::exec(), vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< unsigned int > >::exec(), vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< int > >::exec(), vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< unsigned short > >::exec(), vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< short > >::exec(), and vigra_ext::CreateAlphaTiffImage< vigra::RGBValue< unsigned char > >::exec().

template<class ImageIterator, class ImageAccessor, class AlphaIterator, class AlphaAccessor>
void createScalarATiffImage (  ImageIterator  upperleft,
ImageIterator  lowerright,
ImageAccessor  a,
AlphaIterator  alphaUpperleft,
AlphaAccessor  alphaA,
vigra::TiffImage *  tiff,
int  sampleformat
)  [static]
 

internal function to create a scalar tiff image with alpha channel

Definition at line 130 of file tiffUtils.h.

Referenced by vigra_ext::CreateAlphaTiffImage< double >::exec(), vigra_ext::CreateAlphaTiffImage< float >::exec(), vigra_ext::CreateAlphaTiffImage< unsigned int >::exec(), vigra_ext::CreateAlphaTiffImage< int >::exec(), vigra_ext::CreateAlphaTiffImage< unsigned short >::exec(), vigra_ext::CreateAlphaTiffImage< short >::exec(), and vigra_ext::CreateAlphaTiffImage< unsigned char >::exec().

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)

Definition at line 57 of file tiffUtils.h.

References DEBUG_ASSERT.

Referenced by HuginBase::Nona::TiffMultiLayerRemapper< ImageType, AlphaImageType >::saveRemapped().

double vigra_ext::cubic01 (  double  x  )  [static]
 

Definition at line 65 of file Interpolators.h.

References A().

Referenced by vigra_ext::interp_cubic::calc_coeff().

double vigra_ext::cubic12 (  double  x  )  [static]
 

Definition at line 71 of file Interpolators.h.

References A().

Referenced by vigra_ext::interp_cubic::calc_coeff().

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]
 

Definition at line 324 of file ROIImage.h.

References vigra_ext::ROIImage< Image, Mask >::accessor(), and vigra_ext::ROIImage< Image, Mask >::upperLeft().

Referenced by APImage::_cannyEdgelList(), PanoDetector::AnalyzeImage(), blendOverlap(), PreviewColorPickerTool::CalcCorrectionForImage(), HuginBase::CalculateFOV::calcFOV(), vigra::cannyEdgeImageWithThinning(), vigra::cannyEdgelList(), vigra::cannyEdgelList3x3(), HuginBase::CenterHorizontally::centerHorizontically(), convert_file(), convertGrayToUInt8(), deghosting::Khan< PixelType >::convertImage(), HuginBase::convertTo8Bit(), celeste::convertToUInt16(), convertToUInt8(), correctImage(), correctRGB(), createCtrlPoints(), createCtrlPointsOld(), deghosting::Khan< PixelType >::createWeightMasks(), HuginLines::detectEdges(), vigra::differenceOfExponentialCrackEdgeImage(), vigra::differenceOfExponentialEdgeImage(), TestCode::drawRansacMatches(), HuginBase::Nona::estimateBlendingOrder(), findInterestPointsOnGrid(), PanoOperation::CelesteOperation::GetInternalCommand(), HuginBase::Nona::FileRemapper< ImageType, AlphaType >::getRemapped(), HuginBase::SmallRemappedImageCache::getRemapped(), deghosting::Khan< PixelType >::importRGBImage(), loadAndConvertImage(), LoadGrayImageAndConvert(), LoadGrayImageAndFindLines(), LoadImageAndConvert(), LoadImageAndFindLines(), HuginBase::ImageCache::loadImageSafely(), main(), main2(), mergeWeightedAverage(), CPEditorPanel::OnCelesteButton(), APImage::open(), PointFineTune(), PointFineTune2(), PointFineTuneRotSearch(), celeste::prepareCelesteImage(), deghosting::Khan< PixelType >::preprocessImage(), processImg(), PT::wxAddCtrlPointGridCmd::processPanorama(), reduceToNextLevelOld(), HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage(), vigra::removeShortEdges(), HuginLines::resize_image(), HuginBase::PointSampler::sampleAndExtractPoints(), HuginBase::Nona::MultiImageRemapper< ImageType, AlphaImageType >::saveRemapped(), LensCalImageCtrl::SetEdgeImage(), threshold(), PreviewPanel::updatePreview(), and weightedAverageOfImageFiles().

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]
 

Definition at line 312 of file ROIImage.h.

References vigra_ext::ROIImage< Image, Mask >::accessor(), vigra_ext::ROIImage< Image, Mask >::lowerRight(), and vigra_ext::ROIImage< Image, Mask >::upperLeft().

Referenced by PanoDetector::AnalyzeImage(), vigra::cannyEdgeImageFromGradWithThinning(), correctImage(), deghosting::Khan< PixelType >::createWeightMasks(), TextureManager::TextureInfo::DefineLevels(), celeste::getCelesteMask(), main(), PointFineTuneRotSearch(), celeste::prepareCelesteImage(), reduceNTimes(), reduceToNextLevel(), reduceToNextLevelOld(), HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage(), HuginLines::resize_image(), and PreviewPanel::updatePreview().

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

Definition at line 370 of file ROIImage.h.

References vigra_ext::ROIImage< Image, Mask >::maskAccessor(), and vigra_ext::ROIImage< Image, Mask >::maskUpperLeft().

Referenced by reduceROIImages().

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]
 

Definition at line 358 of file ROIImage.h.

References vigra_ext::ROIImage< Image, Mask >::maskAccessor(), vigra_ext::ROIImage< Image, Mask >::maskLowerRight(), and vigra_ext::ROIImage< Image, Mask >::maskUpperLeft().

dist_t distance (  uint32  deltaY  )  [inline]
 

Definition at line 71 of file NearestFeatureTransform.h.

References dist_t.

Referenced by nearestFeatureTransform().

dist_t distance (  uint32  deltaX,
dist_t *  deltaY
)  [inline]
 

Definition at line 68 of file NearestFeatureTransform.h.

References DIST_MAX, and dist_t.

Referenced by HuginBase::LensDB::LensDB::GetVignetting(), HuginBase::LensDB::LensDB::SaveVignetting(), and HuginBase::MaskPolygon::subSample().

template<class T>
bool ditheringNeeded (  T const &   ) 
 

Definition at line 219 of file VignettingCorrection.h.

References isTrueType().

template<class LUT>
void enforceMonotonicity (  LUT &  lut  ) 
 

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

Definition at line 87 of file lut.h.

Referenced by PreviewColorPickerTool::CalcCorrectionForImage(), TextureManager::TextureInfo::DefineLevels(), HuginBase::Photometric::InvResponseTransform< VTIn, VTOut >::enforceMonotonicity(), HuginBase::Photometric::ResponseTransform< VTIn >::enforceMonotonicity(), ImageVariableDialog::OnShowResponseGraph(), and HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage().

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
) 
 

Definition at line 307 of file VigQuotientEstimator.h.

References DEBUG_DEBUG, hugin_utils::FDiff2D, PointPair, hugin_utils::TDiff2D< T >::x, and hugin_utils::TDiff2D< T >::y.

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

Definition at line 778 of file ImageTransforms.h.

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
) 
 

Definition at line 43 of file InterestPoints.h.

References DEBUG_DEBUG, DEBUG_TRACE, and destImage().

Referenced by createCtrlPoints().

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

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

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

calculate quality of fit

Definition at line 55 of file FitPolynom.h.

References Matrix3::Determinant(), Matrix3::m, and X.

Referenced by subpixelMaxima().

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
) 
 

Definition at line 416 of file VignettingCorrection.h.

References combineTwoImagesDither().

Referenced by HuginBase::Nona::applyFlatfield().

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

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

Definition at line 268 of file utils.h.

Referenced by vigra_ext::ReduceToHDRFunctor< VALUETYPE >::operator()().

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

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

Definition at line 259 of file utils.h.

References celeste::max().

Referenced by HuginBase::AllPointSampler::sampleAllPanoPoints(), and HuginBase::RandomPointSampler::sampleRandomPanoPoints().

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

Definition at line 80 of file utils.h.

Referenced by convertGrayToUInt8(), HuginBase::convertTo8Bit(), celeste::convertToUInt16(), convertToUInt8(), HuginBase::Nona::FileRemapper< ImageType, AlphaType >::getRemapped(), and HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage().

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

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

Definition at line 286 of file utils.h.

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

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

Definition at line 277 of file utils.h.

References celeste::max().

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

Definition at line 399 of file ROIImage.h.

bool isTrueType (  vigra::VigraTrueType   )  [inline]
 

Definition at line 214 of file VignettingCorrection.h.

Referenced by ditheringNeeded().

bool isTrueType (  vigra::VigraFalseType   )  [inline]
 

Definition at line 210 of file VignettingCorrection.h.

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.

Definition at line 247 of file utils.h.

Referenced by celeste::LogPolar::ApplyFilter(), Ransac::compute(), deghosting::Khan< PixelType >::importRGBImage(), log(), log2(), HuginBase::Nona::mercator_erect(), deghosting::LogarithmFunctor< RGBValue< ComponentType > >::operator()(), deghosting::LogarithmFunctor< PixelType >::operator()(), HuginBase::PhotometricOptimizer::photometricError(), celeste::PGMImage::Read(), and celeste::sigmoid_train().

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

Definition at line 200 of file utils.h.

References log().

Referenced by HuginBase::PhotometricOptimizer::photometricError().

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

Definition at line 209 of file utils.h.

Referenced by vigra_ext::ApplyLogFunctor::ApplyLogFunctor(), and vigra_ext::ApplyLogFunctor::operator()().

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

Definition at line 90 of file MultiThreadOperations.h.

References DEBUG_DEBUG.

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

Definition at line 159 of file NearestFeatureTransform.h.

References dist_t, distance(), AppBase::MultiProgressDisplay::increase(), AppBase::MultiProgressDisplay::popTask(), and AppBase::MultiProgressDisplay::pushTask().

Referenced by blendOverlap().

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

Definition at line 451 of file utils.h.

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

Definition at line 444 of file utils.h.

References celeste::max().

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

Definition at line 220 of file utils.h.

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

Definition at line 188 of file utils.h.

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

Definition at line 384 of file VigQuotientEstimator.h.

References vigra_ext::VigQuotientEstimateResult::brightnessRMSE, calcVigCorrPoly(), Ransac::compute(), vigra_ext::VigQuotientEstimateResult::nUsedPoints, and hugin_utils::sqr().

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

Definition at line 344 of file Correlation.h.

References correlateImage(), correlateImageFast(), DEBUG_DEBUG, destImage(), vigra_ext::CorrelationResult::maxi, vigra_ext::CorrelationResult::maxpos, hugin_utils::simpleClipPoint(), srcImage(), subpixelMaxima(), hugin_utils::TDiff2D< T >::toDiff2D(), hugin_utils::TDiff2D< T >::x, and hugin_utils::TDiff2D< T >::y.

Referenced by createCtrlPoints(), MainFrame::OnFineTuneAll(), and CPEditorPanel::PointFineTune().

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

Definition at line 478 of file Correlation.h.

References correlateImage(), correlateImageFast(), DEBUG_DEBUG, DEBUG_ERROR, DEBUG_TRACE, destImage(), destImageRange(), hugin_utils::FDiff2D, M_PI, vigra_ext::CorrelationResult::maxAngle, vigra_ext::CorrelationResult::maxi, vigra_ext::CorrelationResult::maxpos, RAD_TO_DEG, srcImage(), srcImageRange(), subpixelMaxima(), hugin_utils::TDiff2D< T >::toDiff2D(), transformImage(), hugin_utils::TDiff2D< T >::x, and hugin_utils::TDiff2D< T >::y.

Referenced by MainFrame::OnFineTuneAll(), and CPEditorPanel::PointFineTune().

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.

Definition at line 234 of file utils.h.

Referenced by Descriptor::_euclidianDistance(), Descriptor::_gaussWeighting(), HessianDetector::_getHessianDeterminant(), HessianDetector::_slidingWDetect(), PreviewDifferenceTool::AfterDrawImagesEvent(), vigra_ext::ApplyGammaFunctor< vigra::UInt16, vigra::UInt8 >::ApplyGammaFunctor(), HuginBase::CalculateOptimalROI::autocrop(), TextureManager::Begin(), PreviewColorPickerTool::CalcCorrectionForImage(), Ransac::compute(), createGammaLUT(), HuginBase::Nona::cubeRoot_copy(), TextureManager::TextureInfo::DefineLevels(), DrawTriangle(), getDistance(), main(), Parser::lazy_pow_::operator()(), vigra_ext::ApplyGammaFunctor< TIn, TOut >::operator()(), optGetError(), pow(), print_result(), celeste::PGMImage::Read(), HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage(), and PreviewPanel::updatePreview().

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

Definition at line 180 of file utils.h.

References pow().

float pow (  float  a,
double  b
)  [inline]
 

Definition at line 172 of file utils.h.

References pow().

Referenced by vigra_ext::GammaFunctor::operator()().

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
) 
 

Definition at line 469 of file VignettingCorrection.h.

References applyRadialVigCorrectionDither(), hugin_utils::FDiff2D, hugin_utils::TDiff2D< T >::x, and hugin_utils::TDiff2D< T >::y.

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

Definition at line 80 of file Pyramid.h.

References destImageRange(), out, srcImage(), and srcImageRange().

Referenced by main2().

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

Definition at line 39 of file Pyramid.h.

References destImageRange(), out, and srcImageRange().

Referenced by HuginBase::ImageCache::loadSmallImageSafely().

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

Definition at line 465 of file ROIImage.h.

References destMask(), vigra_ext::ROIImage< Image, Mask >::getMask(), celeste::max(), and enblend::reduce().

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

Definition at line 153 of file Pyramid.h.

References destImageRange(), out, srcImage(), and srcImageRange().

Referenced by loadImagesPyr(), and OptimizePhotometricPanel::runOptimizer().

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

Definition at line 138 of file Pyramid.h.

References destImageRange(), out, and srcImageRange().

Referenced by PT::loadImagesPyr().

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

Gaussian reduction to next pyramid level.

out is rescaled to the correct size.

Definition at line 179 of file Pyramid.h.

References DEBUG_TRACE, destImage(), destImageRange(), out, srcImageRange(), and W.

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

Definition at line 64 of file lut.h.

Referenced by HuginBase::Photometric::ResponseTransform< VTIn >::initWithSrcImg().

IMPEX void vigra_ext::SetGPUDebugMessages (  const bool  doPrint  ) 
 

Definition at line 272 of file ImageTransformsGPU.cpp.

References printDebug.

Referenced by main().

double vigra_ext::sinc (  double  x  )  [static]
 

Definition at line 50 of file Interpolators.h.

Referenced by vigra_ext::interp_sinc< size_ >::calc_coeff().

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]
 

Definition at line 300 of file ROIImage.h.

References vigra_ext::ROIImage< Image, Mask >::accessor(), and vigra_ext::ROIImage< Image, Mask >::upperLeft().

Referenced by APImage::_cannyEdgelList(), PanoDetector::AnalyzeImage(), vigra::cannyEdgelList(), createCtrlPointsOld(), HuginBase::Nona::estimateBlendingOrder(), main(), ImageVariableDialog::OnShowDistortionGraph(), ImageVariableDialog::OnShowVignettingGraph(), PointFineTune(), PointFineTune2(), PointFineTuneRotSearch(), PT::wxAddCtrlPointGridCmd::processPanorama(), reduceNTimes(), reduceToNextLevel(), vigra::removeShortEdges(), HuginBase::Nona::MultiImageRemapper< ImageType, AlphaImageType >::saveRemapped(), HuginBase::Nona::SimpleStitcher< ImageType, AlphaType >::stitch(), HuginBase::Nona::ReduceStitcher< ImageType, AlphaType >::stitch(), HuginBase::Nona::WeightedStitcher< ImageType, AlphaType >::stitch(), PreviewPanel::updatePreview(), and weightedAverageOfImageFiles().

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

Definition at line 287 of file ROIImage.h.

References vigra_ext::ROIImage< Image, Mask >::accessor(), vigra_ext::ROIImage< Image, Mask >::lowerRight(), and vigra_ext::ROIImage< Image, Mask >::upperLeft().

Referenced by APImage::_cannyEdgelList(), PanoDetector::AnalyzeImage(), blend(), blendOverlap(), PreviewColorPickerTool::CalcCorrectionForImage(), vigra::cannyEdgeImageWithThinning(), vigra::cannyEdgelList(), vigra::cannyEdgelList3x3(), convertGrayToUInt8(), deghosting::Khan< PixelType >::convertImage(), HuginBase::convertTo8Bit(), celeste::convertToUInt16(), convertToUInt8(), correctImage(), correctRGB(), createCtrlPoints(), createCtrlPointsOld(), deghosting::Khan< PixelType >::createWeightMasks(), TextureManager::TextureInfo::DefineLevels(), HuginLines::detectEdges(), vigra::differenceOfExponentialCrackEdgeImage(), vigra::differenceOfExponentialEdgeImage(), TestCode::drawRansacMatches(), celeste::getCelesteMask(), PanoOperation::CelesteOperation::GetInternalCommand(), HuginBase::SmallRemappedImageCache::getRemapped(), deghosting::Khan< PixelType >::importRGBImage(), HuginBase::ImageCache::loadImageSafely(), main(), CPEditorPanel::OnCelesteButton(), PointFineTuneRotSearch(), celeste::prepareCelesteImage(), deghosting::Khan< PixelType >::preprocessImage(), PT::wxAddCtrlPointGridCmd::processPanorama(), reduceNTimes(), reduceToNextLevel(), reduceToNextLevelOld(), vigra::removeShortEdges(), HuginLines::resize_image(), HuginBase::PointSampler::sampleAndExtractPoints(), HuginBase::Nona::MultiImageRemapper< ImageType, AlphaImageType >::saveRemapped(), LensCalImageCtrl::SetEdgeImage(), APImage::show(), HuginBase::Nona::SimpleStitcher< ImageType, AlphaType >::stitch(), HuginBase::Nona::ReduceStitcher< ImageType, AlphaType >::stitch(), HuginBase::Nona::WeightedStitcher< ImageType, AlphaType >::stitch(), threshold(), PreviewPanel::updatePreview(), and weightedAverageOfImageFiles().

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]
 

Definition at line 347 of file ROIImage.h.

References vigra_ext::ROIImage< Image, Mask >::maskAccessor(), and vigra_ext::ROIImage< Image, Mask >::maskUpperLeft().

Referenced by blend(), HuginBase::CalculateFOV::calcFOV(), HuginBase::CenterHorizontally::centerHorizontically(), HuginBase::SmallRemappedImageCache::getRemapped(), HuginBase::Nona::DifferenceBlender::operator()(), and HuginBase::Nona::StackingBlender::operator()().

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]
 

Definition at line 335 of file ROIImage.h.

References vigra_ext::ROIImage< Image, Mask >::maskAccessor(), vigra_ext::ROIImage< Image, Mask >::maskLowerRight(), and vigra_ext::ROIImage< Image, Mask >::maskUpperLeft().

Referenced by blend(), HuginBase::CalculateFOV::calcFOV(), HuginBase::CenterHorizontally::centerHorizontically(), HuginBase::Nona::estimateBlendingOrder(), HuginBase::Nona::DifferenceBlender::operator()(), and HuginBase::Nona::StackingBlender::operator()().

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

Definition at line 222 of file Correlation.h.

References vigra_ext::CorrelationResult::curv, DEBUG_DEBUG, DEBUG_ERROR, DEBUG_NOTICE, FitPolynom(), hugin_utils::isnan(), vigra_ext::CorrelationResult::maxi, vigra_ext::CorrelationResult::maxpos, hugin_utils::TDiff2D< T >::x, and hugin_utils::TDiff2D< T >::y.

Referenced by PointFineTune(), PointFineTune2(), and PointFineTuneRotSearch().

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.

Definition at line 652 of file ImageTransforms.h.

References DEBUG_DEBUG, INTERP_BILINEAR, INTERP_CUBIC, INTERP_NEAREST_NEIGHBOUR, INTERP_SINC_1024, INTERP_SINC_256, INTERP_SPLINE_16, INTERP_SPLINE_36, INTERP_SPLINE_64, and transformImageInternMT().

Referenced by PanoDetector::AnalyzeImage(), applyBrightnessCorrection(), applyGammaAndBrightCorrection(), applyGammaCorrection(), applyMapping(), convertGrayToUInt8(), deghosting::Khan< PixelType >::convertImage(), celeste::convertToUInt16(), convertToUInt8(), correctImage(), createCtrlPoints(), createCtrlPointsOld(), deghosting::Khan< PixelType >::createWeightMasks(), CPImageCtrl::generateMagBitmap(), PanoOperation::CelesteOperation::GetInternalCommand(), HuginBase::Nona::FileRemapper< ImageType, AlphaType >::getRemapped(), HuginBase::ImageCache::importAndConvertAlphaImage(), HuginBase::ImageCache::importAndConvertImage(), deghosting::Khan< PixelType >::importRGBImage(), loadImagesPyr(), PT::loadImagesPyr(), main(), CPEditorPanel::OnCelesteButton(), PointFineTuneRotSearch(), celeste::prepareCelesteImage(), deghosting::Khan< PixelType >::preprocessImage(), PT::wxAddCtrlPointGridCmd::processPanorama(), HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage(), OptimizePhotometricPanel::runOptimizer(), LensCalImageCtrl::SetEdgeImage(), threshold(), and PreviewPanel::updatePreview().

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.

Definition at line 717 of file ImageTransforms.h.

References DEBUG_DEBUG, INTERP_BILINEAR, INTERP_CUBIC, INTERP_NEAREST_NEIGHBOUR, INTERP_SINC_1024, INTERP_SINC_256, INTERP_SPLINE_16, INTERP_SPLINE_36, INTERP_SPLINE_64, and transformImageAlphaInternMT().

Referenced by HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage().

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.

Definition at line 548 of file ImageTransformsGPU.h.

References DEBUG_DEBUG, INTERP_BILINEAR, INTERP_CUBIC, INTERP_NEAREST_NEIGHBOUR, INTERP_SINC_1024, INTERP_SINC_256, INTERP_SPLINE_16, INTERP_SPLINE_36, INTERP_SPLINE_64, and transformImageAlphaGPUIntern().

Referenced by HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage().

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

Definition at line 261 of file ImageTransformsGPU.h.

References vigra_ext::ImageInterpolator< SrcImageIterator, SrcAccessor, INTERPOLATOR >::emitGLSL(), AppBase::MultiProgressDisplay::popTask(), AppBase::MultiProgressDisplay::pushTask(), and transformImageGPUIntern().

Referenced by transformImageAlphaGPU().

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

Definition at line 214 of file ImageTransforms.h.

References hugin_utils::FDiff2D, Interpolator, AppBase::MultiProgressDisplay::popTask(), AppBase::MultiProgressDisplay::pushTask(), AppBase::MultiProgressDisplay::setProgress(), and zeroNegative().

Referenced by vigra_ext::TransformImageAlphaIntern< SrcImageIterator, SrcAccessor, SrcAlphaIterator, SrcAlphaAccessor, DestImageIterator, DestAccessor, TRANSFORM, PixelTransform, AlphaImageIterator, AlphaAccessor, Interpolator >::operator()(), and transformImageAlphaInternMT().

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.

Definition at line 461 of file ImageTransforms.h.

References DEBUG_DEBUG, Interpolator, and transformImageAlphaIntern().

Referenced by transformImageAlpha().

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)

Definition at line 356 of file ImageTransforms.h.

References DEBUG_ASSERT, Interpolator, AppBase::MultiProgressDisplay::popTask(), AppBase::MultiProgressDisplay::pushTask(), and AppBase::MultiProgressDisplay::setProgress().

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.

Definition at line 483 of file ImageTransformsGPU.h.

References DEBUG_DEBUG, INTERP_BILINEAR, INTERP_CUBIC, INTERP_NEAREST_NEIGHBOUR, INTERP_SINC_1024, INTERP_SINC_256, INTERP_SPLINE_16, INTERP_SPLINE_36, INTERP_SPLINE_64, and transformImageGPUIntern().

Referenced by HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage().

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)

Definition at line 182 of file ImageTransformsGPU.h.

References vigra_ext::ImageInterpolator< SrcImageIterator, SrcAccessor, INTERPOLATOR >::emitGLSL(), AppBase::MultiProgressDisplay::popTask(), and AppBase::MultiProgressDisplay::pushTask().

Referenced by transformImageAlphaGPUIntern(), and transformImageGPU().

bool IMPEX 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
) 
 

Definition at line 277 of file ImageTransformsGPU.cpp.

References ___NCFILE___, AlphaCompositeKernelSource, BytesPerPixel, CHECK_GL, checkFramebufferStatus(), compileGLSL(), cout, getms(), M_PI, makeChunks(), XGLMap, and XGLStringMap.

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)

Definition at line 103 of file ImageTransforms.h.

References hugin_utils::FDiff2D, AppBase::MultiProgressDisplay::popTask(), AppBase::MultiProgressDisplay::pushTask(), AppBase::MultiProgressDisplay::setProgress(), and zeroNegative().

Referenced by CPImageCtrl::generateMagBitmap(), vigra_ext::TransformImageIntern< SrcImageIterator, SrcAccessor, DestImageIterator, DestAccessor, TRANSFORM, PixelTransform, AlphaImageIterator, AlphaAccessor, Interpolator >::operator()(), and transformImageInternMT().

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
) 
 

Definition at line 545 of file ImageTransforms.h.

References DEBUG_DEBUG, Interpolator, and transformImageIntern().

Referenced by transformImage().

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
) 
 

Definition at line 641 of file utils.h.

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
) 
 

Definition at line 618 of file utils.h.

Referenced by PreviewColorPickerTool::CalcCorrectionForImage(), and correctImage().

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.

Definition at line 64 of file ImageTransforms.h.

Referenced by transformImageAlphaIntern(), and transformImageIntern().

template<class T>
T zeroNegative (  T  p  ) 
 

Set negative elements of a pixel to zero.

Definition at line 53 of file ImageTransforms.h.

Variable Documentation

const double vigra_ext::AA = 0.4 [static]
 

Definition at line 171 of file Pyramid.h.

const double vigra_ext::W[] = {0.25 - AA / 2.0, 0.25, AA, 0.25, 0.25 - AA / 2.0} [static]
 

Definition at line 172 of file Pyramid.h.

Referenced by reduceToNextLevelOld().

Generated on Wed Jun 19 01:26:00 2013 for Hugintrunk by  doxygen 1.3.9.1