vigra_ext Namespace Reference


Classes

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

Namespaces

namespace  EMoR

Typedefs

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

Enumerations

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

Functions

template<class SrcImageIterator, class SrcAccessor>
void applyMask (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > img, HuginBase::MaskPolygonVector masks)
template<typename ImgIter, typename ImgAccessor, typename ImgMaskIter, typename ImgMaskAccessor, typename PanoIter, typename PanoAccessor, typename MaskIter, typename MaskAccessor>
void blendOverlap (vigra::triple< ImgIter, ImgIter, ImgAccessor > image, std::pair< ImgMaskIter, ImgMaskAccessor > imageMask, std::pair< PanoIter, PanoAccessor > pano, std::pair< MaskIter, MaskAccessor > panoMask, AppBase::MultiProgressDisplay &progress)
 blends two images, they overlap and the iterators point to excatly the same position.
template<typename ImageType, typename AlphaImageType, typename PanoIter, typename PanoAccessor, typename AlphaIter, typename AlphaAccessor>
void blend (vigra_ext::ROIImage< ImageType, AlphaImageType > &img, vigra::triple< PanoIter, PanoIter, PanoAccessor > pano, std::pair< AlphaIter, AlphaAccessor > alpha, vigra::Rect2D &panoROI, AppBase::MultiProgressDisplay &progress)
 blend img into pano, using alpha mask and panoROI
template<class SrcImage, class DestImage, class KernelImage>
CorrelationResult correlateImageFast (SrcImage &src, DestImage &dest, KernelImage &kernel, vigra::Diff2D kul, vigra::Diff2D klr, double threshold=0.7)
 correlate a template with an image.
template<class Iterator, class Accessor>
CorrelationResult subpixelMaxima (vigra::triple< Iterator, Iterator, Accessor > img, vigra::Diff2D max)
 find the subpixel maxima by fitting 2nd order polynoms to x and y.
template<class IMAGET, class IMAGES>
CorrelationResult PointFineTune (const IMAGET &templImg, vigra::Diff2D templPos, int templSize, const IMAGES &searchImg, vigra::Diff2D searchPos, int sWidth)
 fine tune a point with normalized cross correlation
template<class IMAGET, class IMAGES>
CorrelationResult PointFineTuneRotSearch (const IMAGET &templImg, vigra::Diff2D templPos, int templSize, const IMAGES &searchImg, vigra::Diff2D searchPos, int sWidth, double startAngle, double stopAngle, int angleSteps)
 fine tune a point with normalized cross correlation, searches x,y and phi (rotation around z)
template<class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor, class KernelIterator, class KernelAccessor>
CorrelationResult correlateImage (SrcIterator sul, SrcIterator slr, SrcAccessor as, DestIterator dul, DestAccessor ad, KernelIterator ki, KernelAccessor ak, vigra::Diff2D kul, vigra::Diff2D klr, double threshold=0.7)
 correlate a template with an image.
template<typename M>
double calcDeterminant3 (const M &m)
 calculate the determinat of a 3x3 matrix using the sarrus formula
template<class T>
void FitPolynom (T x, T xend, T y, double &a, double &b, double &c)
 fit a second order polynom to a data set
template<class T>
zeroNegative (T p)
 Set negative elements of a pixel to zero.
template<class T>
vigra::RGBValue< T > zeroNegative (vigra::RGBValue< T > p)
 Set negative elements of a pixel to zero.
template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageIntern (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, std::pair< AlphaImageIterator, AlphaAccessor > alpha, TRANSFORM &transform, PixelTransform &pixelTransform, vigra::Diff2D destUL, Interpolator interp, bool warparound, AppBase::MultiProgressDisplay &prog)
 Transform an image into the panorama.
template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageAlphaIntern (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, std::pair< SrcAlphaIterator, SrcAlphaAccessor > srcAlpha, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, std::pair< AlphaImageIterator, AlphaAccessor > alpha, TRANSFORM &transform, PixelTransform &pixelTransform, vigra::Diff2D destUL, Interpolator interp, bool warparound, AppBase::MultiProgressDisplay &prog)
 transform input images with alpha channel
template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class DistImageIterator, class DistAccessor, class Interpolator>
void transformImageDist (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, vigra::Diff2D destUL, TRANSFORM &transform, vigra::triple< DistImageIterator, DistImageIterator, DistAccessor > centerDist, Interpolator &interp, AppBase::MultiProgressDisplay &prog)
 Transform an image into the panorama.
template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void transformImageAlphaInternMT (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, std::pair< SrcAlphaIterator, SrcAlphaAccessor > srcAlpha, vigra::triple< DestImageIterator, DestImageIterator, DestAccessor > dest, std::pair< AlphaImageIterator, AlphaAccessor > alpha, TRANSFORM &transform, PixelTransform &pixelTransform, vigra::Diff2D destUL, Interpolator interp, bool warparound, AppBase::MultiProgressDisplay &prog)
 multithreaded image transformation.
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)
static double sinc (double x)
static double cubic01 (double x)
static double cubic12 (double x)
static 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>
static 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>
getMaxComponent (vigra::RGBValue< V > const &v)
 get the maximum component of a vector (also works for single pixel types.
template<class V>
getMaxComponent (V v)
 get the maximum component of a vector (also works for single pixel types.
template<class V>
getMinComponent (vigra::RGBValue< V > const &v)
 get the maximum component of a vector (also works for single pixel types.
template<class V>
getMinComponent (V v)
 get the maximum component of a vector (also works for single pixel types.
template<class SrcImageIterator, class SrcAccessor>
void circularCrop (vigra::triple< SrcImageIterator, SrcImageIterator, SrcAccessor > img, hugin_utils::FDiff2D middle, double radius)
 Apply a circular crop to img.
template<class T>
vigra::NumericTraits< T
>::RealPromote 
normalizeValue (T v, vigra::VigraTrueType)
 normalize a pixel to 0.
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

static const double AA = 0.4
static 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.

typedef PointPairT<float> vigra_ext::PointPair

Definition at line 121 of file utils.h.

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

Definition at line 122 of file utils.h.


Enumeration Type Documentation

anonymous enum

Enumerator:
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 vigra_ext::Interpolator

enum with all interpolation methods

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


Function Documentation

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

Definition at line 162 of file Mask.h.

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

template<typename ImgIter, typename ImgAccessor, typename ImgMaskIter, typename ImgMaskAccessor, typename PanoIter, typename PanoAccessor, typename MaskIter, typename MaskAccessor>
void vigra_ext::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 ImageType, typename AlphaImageType, typename PanoIter, typename PanoAccessor, typename AlphaIter, typename AlphaAccessor>
void vigra_ext::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(), and srcMaskRange().

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

template<class SrcImage, class DestImage, class KernelImage>
CorrelationResult vigra_ext::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 vigra_ext::EMoR::h, and threshold().

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

template<class Iterator, class Accessor>
CorrelationResult vigra_ext::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 IMAGET, class IMAGES>
CorrelationResult vigra_ext::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(), srcImageRange(), subpixelMaxima(), hugin_utils::TDiff2D< T >::toDiff2D(), hugin_utils::TDiff2D< T >::x, and hugin_utils::TDiff2D< T >::y.

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

template<class IMAGET, class IMAGES>
CorrelationResult vigra_ext::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(), INTERP_CUBIC, M_PI, vigra_ext::CorrelationResult::maxi, vigra_ext::CorrelationResult::maxpos, RAD_TO_DEG, srcImage(), srcImageRange(), subpixelMaxima(), and transformImage().

Referenced by MainFrame::OnFineTuneAll().

template<class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor, class KernelIterator, class KernelAccessor>
CorrelationResult vigra_ext::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::EMoR::h, vigra_ext::CorrelationResult::maxi, vigra_ext::CorrelationResult::maxpos, threshold(), hugin_utils::TDiff2D< T >::x, and hugin_utils::TDiff2D< T >::y.

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

template<typename M>
double vigra_ext::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 T>
void vigra_ext::FitPolynom ( x,
xend,
y,
double &  a,
double &  b,
double &  c 
)

fit a second order polynom to a data set

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

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

calculate quality of fit

Definition at line 55 of file FitPolynom.h.

References A(), and X.

Referenced by subpixelMaxima().

template<class T>
T vigra_ext::zeroNegative ( p  ) 

Set negative elements of a pixel to zero.

Definition at line 53 of file ImageTransforms.h.

Referenced by transformImageAlphaIntern(), and transformImageIntern().

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

Set negative elements of a pixel to zero.

Definition at line 64 of file ImageTransforms.h.

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void vigra_ext::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 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 SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void vigra_ext::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 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 DestImageIterator, class DestAccessor, class TRANSFORM, class DistImageIterator, class DistAccessor, class Interpolator>
void vigra_ext::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, AppBase::MultiProgressDisplay::popTask(), AppBase::MultiProgressDisplay::pushTask(), and AppBase::MultiProgressDisplay::setProgress().

template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void vigra_ext::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.

Definition at line 461 of file ImageTransforms.h.

References DEBUG_DEBUG, vigra_ext::ThreadManager::get(), vigra_ext::ThreadManager::getNThreads(), and transformImageAlphaIntern().

Referenced by transformImageAlpha().

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void vigra_ext::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, vigra_ext::ThreadManager::get(), vigra_ext::ThreadManager::getNThreads(), and transformImageIntern().

Referenced by transformImage().

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class AlphaImageIterator, class AlphaAccessor, class TRANSFORM, class PixelTransform>
void vigra_ext::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(), 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 vigra_ext::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 T, int nr>
void vigra_ext::fillVector ( vec[3],
T &  val,
int  len 
)

Definition at line 778 of file ImageTransforms.h.

IMPEX void vigra_ext::SetGPUDebugMessages ( const bool  doPrint  ) 

Definition at line 272 of file ImageTransformsGPU.cpp.

References printDebug.

Referenced by main().

bool vigra_ext::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(), printDebug, XGLMap, and XGLStringMap.

Referenced by transformImageAlphaGPUIntern(), transformImageGPU(), and transformImageGPUIntern().

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

vigra_ext::DEFINE_GPUNUMERICTRAITS ( vigra::Int8  ,
XGL_LUMINANCE8_ALPHA8  ,
XGL_RGBA8  ,
XGL_LUMINANCE8  ,
XGL_RGB8  ,
XGL_BYTE   
)

vigra_ext::DEFINE_GPUNUMERICTRAITS ( vigra::UInt8  ,
XGL_LUMINANCE8_ALPHA8  ,
XGL_RGBA8  ,
XGL_LUMINANCE8  ,
XGL_RGB8  ,
XGL_UNSIGNED_BYTE   
)

vigra_ext::DEFINE_GPUNUMERICTRAITS ( vigra::Int16  ,
XGL_LUMINANCE16_ALPHA16  ,
XGL_RGBA16  ,
XGL_LUMINANCE16  ,
XGL_RGB16  ,
XGL_SHORT   
)

vigra_ext::DEFINE_GPUNUMERICTRAITS ( vigra::UInt16  ,
XGL_LUMINANCE16_ALPHA16  ,
XGL_RGBA16  ,
XGL_LUMINANCE16  ,
XGL_RGB16  ,
XGL_UNSIGNED_SHORT   
)

vigra_ext::DEFINE_GPUNUMERICTRAITS ( vigra::Int32  ,
XGL_LUMINANCE_ALPHA32F  ,
XGL_RGBA32F  ,
XGL_LUMINANCE32F  ,
XGL_RGB32F  ,
XGL_INT   
)

vigra_ext::DEFINE_GPUNUMERICTRAITS ( vigra::UInt32  ,
XGL_LUMINANCE_ALPHA32F  ,
XGL_RGBA32F  ,
XGL_LUMINANCE32F  ,
XGL_RGB32F  ,
XGL_UNSIGNED_INT   
)

vigra_ext::DEFINE_GPUNUMERICTRAITS ( float  ,
XGL_LUMINANCE_ALPHA32F  ,
XGL_RGBA32F  ,
XGL_LUMINANCE32F  ,
XGL_RGB32F  ,
XGL_FLOAT   
)

vigra_ext::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 vigra_ext::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(), AppBase::MultiProgressDisplay::pushTask(), transformImageGPUIntern(), and XGL_BYTE.

template<class SrcImageIterator, class SrcAccessor, class SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class TRANSFORM, class PixelTransform, class AlphaImageIterator, class AlphaAccessor, class Interpolator>
void vigra_ext::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 cerr, cout, vigra_ext::ImageInterpolator< SrcImageIterator, SrcAccessor, INTERPOLATOR >::emitGLSL(), celeste::max(), celeste::min(), AppBase::MultiProgressDisplay::popTask(), AppBase::MultiProgressDisplay::pushTask(), transformImageGPUIntern(), XGL_FLOAT, XGL_RGB, and XGL_RGBA.

Referenced by transformImageAlphaGPU().

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class AlphaImageIterator, class AlphaAccessor, class TRANSFORM, class PixelTransform>
void vigra_ext::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 SrcAlphaIterator, class SrcAlphaAccessor, class DestImageIterator, class DestAccessor, class AlphaImageIterator, class AlphaAccessor, class TRANSFORM, class PixelTransform>
void vigra_ext::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 ImageIter, class ImageAcc>
void vigra_ext::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, destImage(), and srcImageRange().

Referenced by createCtrlPoints().

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

Definition at line 50 of file Interpolators.h.

References M_PI.

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

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

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

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

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

template<class VECTOR>
void vigra_ext::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 VEC, class VEC2>
void vigra_ext::resizeLUT ( const VEC &  iLUT,
VEC2 &  oLUT 
)

Definition at line 64 of file lut.h.

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

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

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

Definition at line 87 of file lut.h.

References celeste::max().

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 SrcIter, class SrcAcc, class DestIter, class DestAcc, class Function>
void vigra_ext::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, vigra_ext::ThreadManager::get(), and vigra_ext::ThreadManager::getNThreads().

dist_t vigra_ext::distance ( uint32  deltaX,
dist_t deltaY 
) [inline]

Definition at line 68 of file NearestFeatureTransform.h.

References DIST_MAX.

Referenced by nearestFeatureTransform(), LensCalImageCtrl::OnMouseEvent(), PreviewDragTool::ReallyAfterDrawImagesEvent(), GreatCircleArc::squareDistance(), and HuginBase::MaskPolygon::subSample().

dist_t vigra_ext::distance ( uint32  deltaY  )  [inline]

Definition at line 71 of file NearestFeatureTransform.h.

template<typename Feat1Iter, typename Feat1Accessor, typename Feat2Iter, typename Feat2Accessor, typename Mask1Iter, typename Mask1Accessor, typename Mask2Iter, typename Mask2Accessor>
void vigra_ext::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 cerr, DIST_MAX, DIST_MIN, distance(), AppBase::MultiProgressDisplay::increase(), AppBase::MultiProgressDisplay::popTask(), AppBase::MultiProgressDisplay::pushTask(), and srcImageRange().

Referenced by blendOverlap().

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

Definition at line 39 of file Pyramid.h.

References destImageRange(), vigra_ext::EMoR::h, and srcImageRange().

Referenced by HuginBase::ImageCache::loadSmallImageSafely(), and main2().

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

Definition at line 80 of file Pyramid.h.

References destImageRange(), vigra_ext::EMoR::h, srcImage(), and srcImageRange().

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

Definition at line 138 of file Pyramid.h.

References destImageRange(), vigra_ext::EMoR::h, and srcImageRange().

Referenced by loadImagesPyr(), and PT::loadImagesPyr().

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

Definition at line 153 of file Pyramid.h.

References destImageRange(), vigra_ext::EMoR::h, srcImage(), and srcImageRange().

template<class Image>
void vigra_ext::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(), srcImageRange(), and W.

template<class ImgIter, class ImgAcc>
vigra::triple<ImgIter, ImgIter, ImgAcc> vigra_ext::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(), HuginBase::Nona::estimateBlendingOrder(), HuginBase::Nona::DifferenceBlender::operator()(), HuginBase::Nona::StackingBlender::operator()(), and HuginBase::Nona::MultiImageRemapper< vigra::FRGBImage, AlphaImageType >::saveRemapped().

template<class ImgIter, class ImgAcc>
vigra::pair<ImgIter, ImgAcc> vigra_ext::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.

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> vigra_ext::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 HuginLines::_getVerticalLines(), PanoDetector::AnalyzeImage(), blend(), blendOverlap(), PreviewColorPickerTool::CalcCorrectionForImage(), convertGrayToUInt8(), deghosting::Khan< PixelType >::convertImage(), HuginBase::convertTo8Bit(), celeste::convertToUInt16(), convertToUInt8(), correctImage(), correctRGB(), createCtrlPoints(), createCtrlPointsOld(), deghosting::Khan< PixelType >::createWeightMasks(), TextureManager::TextureInfo::DefineLevels(), HuginLines::detectEdges(), TestCode::drawRansacMatches(), HuginBase::estimateImageAlpha(), findInterestPointsOnGrid(), CPImageCtrl::generateMagBitmap(), LensCalImageCtrl::GenerateRemappedImage(), celeste::getCelesteMask(), PanoOperation::CelesteOperation::GetInternalCommand(), HuginBase::Nona::FileRemapper< ImageType, AlphaType >::getRemapped(), HuginBase::SmallRemappedImageCache::getRemapped(), deghosting::Khan< PixelType >::importRGBImage(), HuginBase::ImageCache::loadImageSafely(), loadImagesPyr(), PT::loadImagesPyr(), main(), nearestFeatureTransform(), CPEditorPanel::OnCelesteButton(), HuginBase::Nona::DifferenceBlender::operator()(), HuginBase::Nona::StackingBlender::operator()(), PointFineTune(), PointFineTune2(), PointFineTuneRotSearch(), celeste::prepareCelesteImage(), deghosting::Khan< PixelType >::preprocessImage(), PT::wxAddCtrlPointGridCmd::processPanorama(), reduceNTimes(), reduceToNextLevel(), reduceToNextLevelOld(), HuginBase::Nona::remapImage(), MaskImageCtrl::rescaleImage(), HuginLines::resize_image(), HuginBase::PointSampler::sampleAndExtractPoints(), HuginBase::Nona::TiffMultiLayerRemapper< ImageType, AlphaImageType >::saveRemapped(), HuginBase::Nona::MultiImageRemapper< vigra::FRGBImage, AlphaImageType >::saveRemapped(), LensCalImageCtrl::SetEdgeImage(), HuginBase::Nona::SimpleStitcher< ImageType, AlphaType >::stitch(), HuginBase::Nona::ReduceStitcher< ImageType, AlphaType >::stitch(), HuginBase::Nona::WeightedStitcher< ImageType, AlphaType >::stitch(), threshold(), PreviewPanel::updatePreview(), and weightedAverageOfImageFiles().

template<typename Image, typename Mask>
vigra::pair<typename ROIImage<Image, Mask>::image_const_traverser, typename ROIImage<Image, Mask>::ImageConstAccessor> vigra_ext::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 HuginLines::_getVerticalLines(), PanoDetector::AnalyzeImage(), HuginBase::Nona::applyFlatfield(), createCtrlPointsOld(), HuginBase::Nona::estimateBlendingOrder(), main(), ImageVariableDialog::OnShowDistortionGraph(), ImageVariableDialog::OnShowVignettingGraph(), PointFineTune(), PointFineTune2(), PointFineTuneRotSearch(), PT::wxAddCtrlPointGridCmd::processPanorama(), reduceNTimes(), reduceToNextLevel(), HuginBase::Nona::remapImage(), HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage(), HuginBase::Nona::MultiImageRemapper< vigra::FRGBImage, 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<class Image, class Alpha>
vigra::triple<typename ROIImage<Image,Alpha>::image_traverser, typename ROIImage<Image,Alpha>::image_traverser, typename ROIImage<Image,Alpha>::ImageAccessor> vigra_ext::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(), correctImage(), deghosting::Khan< PixelType >::createWeightMasks(), TextureManager::TextureInfo::DefineLevels(), TextureManager::TextureInfo::DefineMaskTexture(), CPImageCtrl::generateMagBitmap(), celeste::getCelesteMask(), main(), PointFineTuneRotSearch(), celeste::prepareCelesteImage(), reduceNTimes(), reduceToNextLevel(), reduceToNextLevelOld(), HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage(), HuginLines::resize_image(), HuginBase::Nona::SimpleStitcher< ImageType, AlphaType >::stitch(), HuginBase::Nona::ReduceStitcher< ImageType, AlphaType >::stitch(), HuginBase::Nona::WeightedStitcher< ImageType, AlphaType >::stitch(), and PreviewPanel::updatePreview().

template<class Image, class Alpha>
vigra::pair<typename ROIImage<Image,Alpha>::image_traverser, typename ROIImage<Image,Alpha>::ImageAccessor> vigra_ext::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 PanoDetector::AnalyzeImage(), HuginBase::Nona::applyFlatfield(), blendOverlap(), PreviewColorPickerTool::CalcCorrectionForImage(), HuginBase::CalculateFOV::calcFOV(), 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(), DetectKeypoints(), TestCode::drawRansacMatches(), HuginBase::Nona::estimateBlendingOrder(), HuginBase::estimateImageAlpha(), findInterestPointsOnGrid(), CPImageCtrl::generateMagBitmap(), PanoOperation::CelesteOperation::GetInternalCommand(), HuginBase::Nona::FileRemapper< ImageType, AlphaType >::getRemapped(), HuginBase::SmallRemappedImageCache::getRemapped(), deghosting::Khan< PixelType >::importRGBImage(), loadAndConvertImage(), LoadGrayImageAndConvert(), LoadGrayImageAndFindLines(), LoadImageAndConvert(), LoadImageAndFindLines(), HuginBase::ImageCache::loadImageSafely(), loadImagesPyr(), PT::loadImagesPyr(), main(), main2(), mergeWeightedAverage(), CPEditorPanel::OnCelesteButton(), PointFineTune(), PointFineTune2(), PointFineTuneRotSearch(), celeste::prepareCelesteImage(), deghosting::Khan< PixelType >::preprocessImage(), processImg(), PT::wxAddCtrlPointGridCmd::processPanorama(), reduceToNextLevelOld(), HuginBase::Nona::RemappedPanoImage< RemapImage, AlphaImage >::remapImage(), HuginLines::resize_image(), HuginBase::PointSampler::sampleAndExtractPoints(), HuginBase::Nona::MultiImageRemapper< vigra::FRGBImage, AlphaImageType >::saveRemapped(), LensCalImageCtrl::SetEdgeImage(), 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::triple<typename ROIImage<Image,Alpha>::mask_const_traverser, typename ROIImage<Image,Alpha>::mask_const_traverser, typename ROIImage<Image,Alpha>::MaskConstAccessor> vigra_ext::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()(), HuginBase::Nona::StackingBlender::operator()(), and HuginBase::Nona::MultiImageRemapper< vigra::FRGBImage, AlphaImageType >::saveRemapped().

template<class Image, class Alpha>
vigra::pair<typename ROIImage<Image,Alpha>::mask_const_traverser, typename ROIImage<Image,Alpha>::MaskConstAccessor> vigra_ext::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_traverser, typename ROIImage<Image,Alpha>::mask_traverser, typename ROIImage<Image,Alpha>::MaskAccessor> vigra_ext::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().

template<class Image, class Alpha>
vigra::pair<typename ROIImage<Image,Alpha>::mask_traverser, typename ROIImage<Image,Alpha>::MaskAccessor> vigra_ext::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().

template<class ImgIter, class ImgAcc, class MaskIter, class MaskAcc, class Functor>
void vigra_ext::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.

template<class ROIIMG, class DestIter, class DestAccessor, class MaskIter, class MaskAccessor, class FUNCTOR>
void vigra_ext::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 celeste::max(), and enblend::reduce().

void vigra_ext::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().

template<class ImageIterator, class ImageAccessor, class AlphaIterator, class AlphaAccessor>
static void vigra_ext::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.

References vigra_ext::EMoR::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().

template<class ImageIterator, class ImageAccessor, class AlphaIterator, class AlphaAccessor>
void vigra_ext::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.

References vigra_ext::EMoR::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 vigra_ext::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 createAlphaTiffImage(), and HuginBase::Nona::TiffMultiLayerRemapper< ImageType, AlphaImageType >::saveRemapped().

template<class ImageIterator, class ImageAccessor, class AlphaIterator, class BImageAccessor>
void vigra_ext::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.

References createAlphaTiffImage().

vigra_ext::LUT_TRAITS ( unsigned  char,
UCHAR_MAX   
)

vigra_ext::LUT_TRAITS ( signed  char,
SCHAR_MAX   
)

vigra_ext::LUT_TRAITS ( unsigned  short,
USHRT_MAX   
)

vigra_ext::LUT_TRAITS ( signed  short,
SHRT_MAX   
)

vigra_ext::LUT_TRAITS ( unsigned  int,
UINT_MAX   
)

vigra_ext::LUT_TRAITS ( signed  int,
INT_MAX   
)

vigra_ext::LUT_TRAITS ( float  ,
1.  0 
)

vigra_ext::LUT_TRAITS ( double  ,
1.  0 
)

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

Definition at line 80 of file utils.h.

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

vigra_ext::VT_TRAITS ( vigra::UInt8   ) 

vigra_ext::VT_TRAITS ( vigra::Int16   ) 

vigra_ext::VT_TRAITS ( vigra::UInt16   ) 

vigra_ext::VT_TRAITS ( vigra::Int32   ) 

vigra_ext::VT_TRAITS ( vigra::UInt32   ) 

vigra_ext::VT_TRAITS ( float   ) 

vigra_ext::VT_TRAITS ( double   ) 

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

Definition at line 172 of file utils.h.

Referenced by 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(), main(), Parser::lazy_pow_::operator()(), vigra_ext::GammaFunctor::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> vigra_ext::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().

template<class V1, unsigned int R, unsigned int G, unsigned int B, class V2>
vigra::RGBValue<V1, R, G, B>& vigra_ext::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.

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

component-wise logarithm

Definition at line 200 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> vigra_ext::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()().

template<class V1, unsigned int R, unsigned int G, unsigned int B, class V2>
vigra::PromoteTraits<vigra::RGBValue<V1, R, G, B>, V2 >::Promote vigra_ext::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 V, int SIZE, class D1, class D2>
vigra::TinyVector<V, SIZE> vigra_ext::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.

References pow().

template<class V, int SIZE, class D1, class D2>
vigra::TinyVector<V, SIZE> vigra_ext::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.

References log().

template<class V>
V vigra_ext::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::Photometric::InvResponseTransform< VTIn, VTOut >::hdrWeight(), vigra_ext::ReduceToHDRFunctor< VALUETYPE >::operator()(), HuginBase::AllPointSampler::sampleAllPanoPoints(), and HuginBase::RandomPointSampler::sampleRandomPanoPoints().

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

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

..)

Definition at line 268 of file utils.h.

template<class V>
V vigra_ext::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 V>
V vigra_ext::getMinComponent ( 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 SrcImageIterator, class SrcAccessor>
void vigra_ext::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::TDiff2D< T >::x, and hugin_utils::TDiff2D< T >::y.

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

template<class T>
vigra::NumericTraits<T>::RealPromote vigra_ext::normalizeValue ( 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 T>
vigra::NumericTraits<T>::RealPromote vigra_ext::normalizeValue ( v,
vigra::VigraFalseType   
)

Definition at line 451 of file utils.h.

template<class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor, class T>
void vigra_ext::applyMapping ( vigra::triple< SrcIterator, SrcIterator, SrcAccessor >  img,
vigra::pair< DestIterator, DestAccessor >  dest,
min,
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, class DestImageIterator, class DestAccessor, class Functor>
void vigra_ext::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(), correctImage(), and transformImageSpatial().

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void vigra_ext::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.

References transformImageSpatial().

bool vigra_ext::isTrueType ( vigra::VigraFalseType   )  [inline]

Definition at line 210 of file VignettingCorrection.h.

Referenced by ditheringNeeded().

bool vigra_ext::isTrueType ( vigra::VigraTrueType   )  [inline]

Definition at line 214 of file VignettingCorrection.h.

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

Definition at line 219 of file VignettingCorrection.h.

References isTrueType().

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void vigra_ext::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.

Referenced by applyRadialVigCorrectionDither().

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void vigra_ext::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.

template<class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor, class Functor>
void vigra_ext::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 ImgAccessor, class FFIter, class FFAccessor, class DestIter, class DestAccessor, class Functor>
void vigra_ext::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 ImgIter, class ImgAccessor, class FFIter, class FFAccessor, class DestIter, class DestAccessor>
void vigra_ext::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 ImgIter, class ImgAccessor, class DestIter, class DestAccessor>
void vigra_ext::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::TDiff2D< T >::x, and hugin_utils::TDiff2D< T >::y.

template<class ImgIter, class ImgAccessor, class DestIter, class DestAccessor>
void vigra_ext::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 vigra_ext::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 vigra_ext::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 PITER>
double vigra_ext::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 ImageType, class CoordType>
void vigra_ext::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::TDiff2D< T >::x, and hugin_utils::TDiff2D< T >::y.

VigQuotientEstimateResult vigra_ext::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().


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 22 Oct 2014 for Hugintrunk by  doxygen 1.4.7