Hugintrunk: HuginBase Namespace Reference

 {ImageVariableGroup::IVE_Size,
               ImageVariableGroup::IVE_Projection,
               ImageVariableGroup::IVE_HFOV,
               ImageVariableGroup::IVE_ResponseType,
               ImageVariableGroup::IVE_EMoRParams,
               ImageVariableGroup::IVE_ExposureValue,
               ImageVariableGroup::IVE_Gamma,
               ImageVariableGroup::IVE_WhiteBalanceRed,
               ImageVariableGroup::IVE_WhiteBalanceBlue,
               ImageVariableGroup::IVE_RadialDistortion,
               ImageVariableGroup::IVE_RadialDistortionRed,
               ImageVariableGroup::IVE_RadialDistortionBlue,
               ImageVariableGroup::IVE_RadialDistortionCenterShift,
               ImageVariableGroup::IVE_Shear,
               ImageVariableGroup::IVE_VigCorrMode,
               ImageVariableGroup::IVE_FlatfieldFilename,
               ImageVariableGroup::IVE_RadialVigCorrCoeff,
               ImageVariableGroup::IVE_RadialVigCorrCenterShift
            }

    std::set<ConstImageVariableGroup::ImageVariableEnum>(lens_variables_array,
                                                         lens_variables_array + 18)

 {ImageVariableGroup::IVE_Yaw,
               ImageVariableGroup::IVE_Pitch,
               ImageVariableGroup::IVE_Roll,
               ImageVariableGroup::IVE_Stack,
               ImageVariableGroup::IVE_X,
               ImageVariableGroup::IVE_Y,
               ImageVariableGroup::IVE_Z,
               ImageVariableGroup::IVE_TranslationPlaneYaw,
               ImageVariableGroup::IVE_TranslationPlanePitch
            }

    std::set<ConstImageVariableGroup::ImageVariableEnum>(stack_variables_array,
                                                         stack_variables_array + 9)

HuginBase Namespace Reference

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation


Classes
class	HuginBase::AssistantMakefilelibExport
struct	HuginBase::AssistantMakefilelibExport::AssistantPrograms
class	HuginBase::CalculateCPStatistics
	just some common implementation; probably not so useful More...
class	HuginBase::CalculateCPStatisticsError
class	HuginBase::CalculateCPStatisticsRadial
class	HuginBase::CalculateMeanExposure
class	HuginBase::CalculateOptimalROI
struct	HuginBase::CalculateOptimalROI::nonrec
class	HuginBase::CalculateOptimalScale
class	HuginBase::SetWidthOptimal
class	HuginBase::CalculateImageOverlap
	class for calculating overlap of images More...
class	HuginBase::RotatePanorama
class	HuginBase::StraightenPanorama
class	HuginBase::TranslatePanorama
class	HuginBase::CalculateFOV
class	HuginBase::CenterHorizontally
class	HuginBase::ComputeImageROI
class	HuginBase::CalculateFitPanorama
class	HuginBase::FitPanorama
class	HuginBase::NonaFileOutputStitcher
	This class will use the stitchPanorama function of nona. More...
struct	HuginBase::OverlapSizeCounter
	count pixels that are > 0 in both images More...
class	HuginBase::PhotometricOptimizer
struct	HuginBase::PhotometricOptimizer::VarMapping
struct	HuginBase::PhotometricOptimizer::OptimData
class	HuginBase::SmartPhotometricOptimizer
class	HuginBase::OptVarSpec
class	HuginBase::PTOptEstimator
	Estimator for RANSAC based adjustment of pairwise parameters. More...
class	HuginBase::PTOptimizer
class	HuginBase::RANSACOptimizer
	Pairwise ransac optimisation. More...
class	HuginBase::AutoOptimise
class	HuginBase::AutoOptimise::OptimiseVisitor
	a traverse functor to optimise the image links More...
class	HuginBase::SmartOptimizerStub
class	HuginBase::SmartOptimise
class	HuginBase::PanoramaMakefilelibExport
struct	HuginBase::PanoramaMakefilelibExport::PTPrograms
class	HuginBase::PanoramaAlgorithm
class	HuginBase::TimeConsumingPanoramaAlgorithm
class	HuginBase::PointSampler
class	HuginBase::AllPointSampler
class	HuginBase::RandomPointSampler
class	HuginBase::StitcherAlgorithm
	Just a conceptual base class... More...
class	HuginBase::ImageStitcherAlgorithm
	stitch to file output More...
class	HuginBase::FileOutputStitcherAlgorithm
	stitch to file output More...
class	HuginBase::SmallRemappedImageCache
	class to cache remapped images, loaded from the hugin small image cache. More...
class	HuginBase::GetRange< T1 >
class	HuginBase::ImageCache
	This is a cache for all the images we use. More...
struct	HuginBase::ImageCache::Entry
	information about an image inside the cache More...
class	HuginBase::ImageCache::Request
	Request for an image to load Connect to the ready signal so when the image loads you can respond. More...
struct	HuginBase::ImageCache::PyramidKey
	get a pyramid image. More...
class	HuginBase::PanoCommand< StringType >
	Default panorama cmd, provides undo with mementos. More...
class	HuginBase::ControlPoint
	represents a control point More...
class	HuginBase::ImageVariable< Type >
	An ImageVariable stores a value that can be linked to other ImageVariables of the same type. More...
class	HuginBase::ConstImageVariableGroup
	An ImageVariableGroup is a collection of image variables that can have some shared variable values. More...
class	HuginBase::ImageVariableGroup
	Same as above, but use a non const panorama. More...
class	HuginBase::PTOVariableConverterNoOp
	Parent class to anything that aids conversion between PTO file variables and the image variables of SrcPanoImg. More...
class	HuginBase::PTOVariableConverterSingle< code1, code2, code3, T >
	Object to group conversion functions for PTO format variables of up to three characters representing a single variable in SrcPanoImg. More...
class	HuginBase::PTOVariableConverterVectorChar< base_code, T, size >
	Object to group conversion functions for PTO format variables representing a std::vector variable in SrcPanoImg, using an identifying first character. More...
class	HuginBase::PTOVariableConverterVector< T, size >
	Object to group conversion functions for PTO format variables representing a std::vector variable in SrcPanoImg, using characters stating from 'a'. More...
class	HuginBase::PTOVariableConverterFDiff2D< code_x1, code_y1, code_x2, code_y2 >
	Object to group conversion functions for PTO format variables representing a hugin_utils::FDiff2D variable in SrcPanoImg. More...
class	HuginBase::Lens
class	HuginBase::MaskPolygon
	base class, which stores one mask polygon More...
class	HuginBase::PanoramaMemento
	Memento class for a Panorama object. More...
class	HuginBase::Panorama
	Model for a panorama. More...
class	HuginBase::PanoramaData
	Model for a panorama. More...
class	HuginBase::PanoramaObserver
	this handler class will receive change events from the Panorama. More...
class	HuginBase::PanoramaDataMemento
	Memento class for a PanoramaData object. More...
class	HuginBase::ManagedPanoramaData
class	HuginBase::PanoramaOptions
	Panorama image options. More...
class	HuginBase::Variable
	a variable has a value and a name. More...
class	HuginBase::LinkedVariable
class	HuginBase::LensVariable
	A lens variable can be linked. More...
struct	HuginBase::PrintVar
	functor to print a variable. More...
class	HuginBase::BaseSrcPanoImage
	Base class containing all the variables, but missing some of the other important functions and with some daft accessors. More...
class	HuginBase::SrcPanoImage
	All variables of a source image. More...
class	HuginBase::ConstStandardImageVariableGroups
	Make an ImageVariableGroup for lenses and other common concepts. More...
class	HuginBase::StandardImageVariableGroups
Typedefs
typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::undirectedS, boost::property< boost::vertex_color_t, boost::default_color_type > >	CPGraph
	graph of images, connected with control points.
typedef std::vector< std::set< unsigned > >	CPComponents
	components in a control point graph
typedef boost::property< boost::edge_weight_t, float >	OverlapEdgeProperty
typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::undirectedS, boost::property< boost::vertex_color_t, boost::default_color_type >, OverlapEdgeProperty >	OverlapGraph
	A graph that contains all image as nodes (vertexes), overlaps are given by edges.
typedef std::vector< ControlPoint >	CPVector
typedef std::pair< unsigned int, ControlPoint >	CPoint
typedef std::vector< CPoint >	CPointVector
typedef PTOVariableConverterNoOp	PTOVariableConverterForFilename
	image_variables.h
typedef PTOVariableConverterNoOp	PTOVariableConverterForSize
typedef PTOVariableConverterNoOp	PTOVariableConverterForProjection
typedef PTOVariableConverterSingle< 'v'>	PTOVariableConverterForHFOV
typedef PTOVariableConverterNoOp	PTOVariableConverterForResponseType
typedef PTOVariableConverterVectorChar< 'R', float, 5 >	PTOVariableConverterForEMoRParams
typedef PTOVariableConverterSingle< 'E', 'e', 'v'>	PTOVariableConverterForExposureValue
typedef PTOVariableConverterNoOp	PTOVariableConverterForGamma
typedef PTOVariableConverterSingle< 'E', 'r'>	PTOVariableConverterForWhiteBalanceRed
typedef PTOVariableConverterSingle< 'E', 'b'>	PTOVariableConverterForWhiteBalanceBlue
typedef PTOVariableConverterSingle< 'r'>	PTOVariableConverterForRoll
typedef PTOVariableConverterSingle< 'p'>	PTOVariableConverterForPitch
typedef PTOVariableConverterSingle< 'y'>	PTOVariableConverterForYaw
typedef PTOVariableConverterSingle< 'T','r','X'>	PTOVariableConverterForX
typedef PTOVariableConverterSingle< 'T','r','Y'>	PTOVariableConverterForY
typedef PTOVariableConverterSingle< 'T','r','Z'>	PTOVariableConverterForZ
typedef PTOVariableConverterSingle< 'T','p','y'>	PTOVariableConverterForTranslationPlaneYaw
typedef PTOVariableConverterSingle< 'T','p','p'>	PTOVariableConverterForTranslationPlanePitch
typedef PTOVariableConverterSingle< 'j'>	PTOVariableConverterForStack
typedef PTOVariableConverterVector< double, 3 >	PTOVariableConverterForRadialDistortion
typedef PTOVariableConverterNoOp	PTOVariableConverterForRadialDistortionRed
typedef PTOVariableConverterNoOp	PTOVariableConverterForRadialDistortionBlue
typedef PTOVariableConverterFDiff2D< 'd', 'e'>	PTOVariableConverterForRadialDistortionCenterShift
typedef PTOVariableConverterFDiff2D< 'g', 't'>	PTOVariableConverterForShear
typedef PTOVariableConverterNoOp	PTOVariableConverterForCropMode
typedef PTOVariableConverterNoOp	PTOVariableConverterForCropRect
typedef PTOVariableConverterNoOp	PTOVariableConverterForAutoCenterCrop
typedef PTOVariableConverterNoOp	PTOVariableConverterForFlatfieldFilename
typedef PTOVariableConverterNoOp	PTOVariableConverterForVigCorrMode
typedef PTOVariableConverterVectorChar< 'V', double, 4 >	PTOVariableConverterForRadialVigCorrCoeff
typedef PTOVariableConverterFDiff2D< 'V','V', 'x','y'>	PTOVariableConverterForRadialVigCorrCenterShift
typedef PTOVariableConverterNoOp	PTOVariableConverterForExifModel
typedef PTOVariableConverterNoOp	PTOVariableConverterForExifMake
typedef PTOVariableConverterNoOp	PTOVariableConverterForExifLens
typedef PTOVariableConverterNoOp	PTOVariableConverterForExifCropFactor
typedef PTOVariableConverterNoOp	PTOVariableConverterForExifFocalLength
typedef PTOVariableConverterNoOp	PTOVariableConverterForExifOrientation
typedef PTOVariableConverterNoOp	PTOVariableConverterForExifAperture
typedef PTOVariableConverterNoOp	PTOVariableConverterForExifISO
typedef PTOVariableConverterNoOp	PTOVariableConverterForExifDistance
typedef PTOVariableConverterNoOp	PTOVariableConverterForExifFocalLength35
typedef PTOVariableConverterNoOp	PTOVariableConverterForExifExposureTime
typedef PTOVariableConverterNoOp	PTOVariableConverterForExifDate
typedef PTOVariableConverterNoOp	PTOVariableConverterForExifExposureMode
typedef PTOVariableConverterNoOp	PTOVariableConverterForMasks
typedef PTOVariableConverterNoOp	PTOVariableConverterForActiveMasks
typedef PTOVariableConverterNoOp	PTOVariableConverterForActive
typedef PTOVariableConverterNoOp	PTOVariableConverterForLensNr
typedef std::vector< Lens >	LensVector
typedef std::vector< FDiff2D >	VectorPolygon
	vector, which stores coordinates of one polygon
typedef std::vector< MaskPolygon >	MaskPolygonVector
typedef std::set< unsigned int >	UIntSet
typedef std::vector< unsigned int >	UIntVector
typedef std::map< std::string, Variable >	VariableMap
typedef std::vector< VariableMap >	VariableMapVector
typedef std::map< std::string, LensVariable >	LensVarMap
typedef std::vector< std::set< std::string > >	OptimizeVector
typedef std::vector< SrcPanoImage >	ImageVector
Enumerations
enum	clipSide { clipLeft = 0, clipRight, clipTop, clipBottom }
enum	OptimizerSwitches { OPT_PAIR = 0x0001, OPT_POSITION = 0x0002, OPT_VIEW = 0x0004, OPT_BARREL = 0x0008, OPT_ALL = 0x0010, OPT_TRANSLATION = 0x0020, OPT_EXPOSURE = 0x0001, OPT_WHITEBALANCE = 0x0002, OPT_VIGNETTING = 0x0004, OPT_VIGNETTING_CENTER = 0x0008, OPT_RESPONSE = 0x0010 }
	defines all optimizer switches, they can be combined with OR More...
Functions
vector< UIntSet >	getHDRStacks (const PanoramaData &pano, UIntSet allImgs, PanoramaOptions opts)
	returns vector of set of output stacks
vector< UIntSet >	getExposureLayers (const PanoramaData &pano, UIntSet allImgs, PanoramaOptions opts)
	returns vector of set of output exposure layers
UIntSet	getImagesinROI (const PanoramaData &pano, const UIntSet activeImages)
	returns set of images which are visible in output ROI
UIntSet	getCPoutsideLimit_pair (Panorama pano, double n)
	optimises images pairwise and removes for every image pair control points with error > mean+n*sigma
UIntSet	getCPoutsideLimit (Panorama pano, double n, bool skipOptimisation)
	optimises the whole panorama and removes all control points with error > mean+n*sigma
UIntSet	getCPinMasks (HuginBase::Panorama pano)
	returns these control points, which are in masks
template<class TRANSFORM>
void	estimateImageRect (const SrcPanoImage &src, const PanoramaOptions &dest, TRANSFORM &transf, vigra::Rect2D &imgRect)
	calculate the outline of the image
template<class TRANSFORM>
void	estimateImageAlpha (const SrcPanoImage &src, const PanoramaOptions &dest, TRANSFORM &transf, vigra::Rect2D &imgRect, vigra::BImage &alpha, double &scale)
vigra::Rect2D	estimateOutputROI (const PanoramaData &pano, const PanoramaOptions &opts, unsigned i)
void	createCPGraph (const PanoramaData &pano, CPGraph &graph)
	create a control point graph structure, with links representing one or more control points
int	findCPComponents (const CPGraph &graph, CPComponents &comp)
void	createOverlapGraph (const PanoramaData &pano, OverlapGraph &graph)
	create a graph with all overlaps, and a suitable blend order.
double	weightHuber (double x, double sigma)
	expects the abs(error) values
const makefile::string	hdrgrayRemappedExt ("_gray.pgm")
	constants
const makefile::string	hdrRemappedExt (".exr")
const makefile::string	ldrRemappedExt (".tif")
const makefile::string	ldrRemappedMode ("TIFF_m")
const makefile::string	hdrRemappedMode ("EXR_m")
void	printstacks (const std::vector< UIntSet > &stackdata)
	Simple helper to output stacks for debugging.
template<typename T>
void	append (std::vector< T > &dst, const std::vector< T > &src)
	Copys all of src to the end of test.
template<typename T>
void	append (std::vector< T > &vec, const T &element)
	Simply calls push_back, convinience function.
	VIGRA_EXT_GETRANGE (vigra::UInt8, 0, 255)
	VIGRA_EXT_GETRANGE (vigra::Int16, 0, 32767)
	VIGRA_EXT_GETRANGE (vigra::UInt16, 0, 65535)
	VIGRA_EXT_GETRANGE (vigra::Int32, 0, 2147483647)
	VIGRA_EXT_GETRANGE (vigra::UInt32, 0, 4294967295u)
	VIGRA_EXT_GETRANGE (float, 0, 1.0f)
	VIGRA_EXT_GETRANGE (double, 0, 1.0)
template<class SrcIMG>
void	convertTo8Bit (SrcIMG &src, const std::string &origType, vigra::BRGBImage &dest)
bool	clip_isSide (const FDiff2D p, const vigra::Rect2D r, const clipSide side)
FDiff2D	clip_getIntersection (const FDiff2D p, const FDiff2D q, const vigra::Rect2D r, const clipSide side)
VectorPolygon	clip_onPlane (const VectorPolygon polygon, const vigra::Rect2D r, const clipSide side)
bool	clip_insideCircle (const FDiff2D p, const FDiff2D center, const double radius)
	check if point is inside circle
std::vector< FDiff2D >	clip_getIntersectionCircle (const FDiff2D p, const FDiff2D s, const FDiff2D center, const double radius)
	returns intersection of line and circle
double	angle_between (const FDiff2D a, const FDiff2D b)
	calculates angle between vector a and b in radians
void	generateArc (VectorPolygon &poly, const FDiff2D s, const FDiff2D center, const double radius, const bool clockwise)
	adds an arc with given radius at the end of the polygon, the point is not added to the arc
void	LoadMaskFromStream (std::istream &stream, vigra::Size2D &imageSize, MaskPolygonVector &newMasks, size_t imgNr)
	load the mask from stream
void	SaveMaskToStream (std::ostream &stream, vigra::Size2D imageSize, MaskPolygon &maskToWrite, size_t imgNr)
	save the mask into stream
void	UpdateOptVectorSet (std::set< std::string > &imgVar, const std::string var, const bool opt)
void	fillVariableMap (VariableMap &vars)
	fill map with all image & lens variables
void	fillLensVarMap (LensVarMap &variables)
	just lens variables
void	printVariableMap (std::ostream &o, const VariableMap &vars)
	print a variable map to `o`
Variables
const int	maskOffset = 100
	polygon can exceed the image maximal maskOffset pixels in each direction bigger polygons will be clipped after loading
const ConstImageVariableGroup::ImageVariableEnum	lens_variables_array []
	The image variables that are specific to lenses.
const std::set< ConstImageVariableGroup::ImageVariableEnum >	lens_variables_set
	A set containing the lens image variables.
const ConstImageVariableGroup::ImageVariableEnum	stack_variables_array []
	The image variables that are specific to stack.
const std::set< ConstImageVariableGroup::ImageVariableEnum >	stack_variables_set
	A set containing the stack image variables.