generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Doxygen documentation: shape, superres, videostab

Browse Source
This commit is contained in:
Maksim Shabunin
2014-11-20 17:08:58 +03:00
parent ceb6e8bd94
commit 9d89f8d3dc
21 changed files with 407 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
modules/shape/include/opencv2/shape.hpp
View File

@@ -48,6 +48,10 @@
#include "opencv2/shape/hist_cost.hpp"
#include "opencv2/shape/shape_distance.hpp"
/**
@defgroup shape Shape Distance and Matching
*/
namespace cv
{
CV_EXPORTS bool initModule_shape();

14
modules/shape/include/opencv2/shape/emdL1.hpp
View File

@@ -51,8 +51,22 @@ namespace cv
* EMDL1 Function *
\****************************************************************************************/
//! @addtogroup shape
//! @{
/** @brief Computes the "minimal work" distance between two weighted point configurations base on the papers
"EMD-L1: An efficient and Robust Algorithm for comparing histogram-based descriptors", by Haibin
Ling and Kazunori Okuda; and "The Earth Mover's Distance is the Mallows Distance: Some Insights from
Statistics", by Elizaveta Levina and Peter Bickel.
@param signature1 First signature, a single column floating-point matrix. Each row is the value of
the histogram in each bin.
@param signature2 Second signature of the same format and size as signature1.
*/
CV_EXPORTS float EMDL1(InputArray signature1, InputArray signature2);
//! @}
}//namespace cv
#endif

20
modules/shape/include/opencv2/shape/hist_cost.hpp
View File

@@ -49,8 +49,10 @@
namespace cv
{
/*!
* The base class for HistogramCostExtractor.
//! @addtogroup shape
//! @{
/** @brief Abstract base class for histogram cost algorithms.
*/
class CV_EXPORTS_W HistogramCostExtractor : public Algorithm
{
@@ -64,7 +66,8 @@ public:
CV_WRAP virtual float getDefaultCost() const = 0;
};
/*! */
/** @brief A norm based cost extraction. :
*/
class CV_EXPORTS_W NormHistogramCostExtractor : public HistogramCostExtractor
{
public:
@@ -75,7 +78,8 @@ public:
CV_EXPORTS_W Ptr<HistogramCostExtractor>
createNormHistogramCostExtractor(int flag=DIST_L2, int nDummies=25, float defaultCost=0.2f);
/*! */
/** @brief An EMD based cost extraction. :
*/
class CV_EXPORTS_W EMDHistogramCostExtractor : public HistogramCostExtractor
{
public:
@@ -86,18 +90,22 @@ public:
CV_EXPORTS_W Ptr<HistogramCostExtractor>
createEMDHistogramCostExtractor(int flag=DIST_L2, int nDummies=25, float defaultCost=0.2f);
/*! */
/** @brief An Chi based cost extraction. :
*/
class CV_EXPORTS_W ChiHistogramCostExtractor : public HistogramCostExtractor
{};
CV_EXPORTS_W Ptr<HistogramCostExtractor> createChiHistogramCostExtractor(int nDummies=25, float defaultCost=0.2f);
/*! */
/** @brief An EMD-L1 based cost extraction. :
*/
class CV_EXPORTS_W EMDL1HistogramCostExtractor : public HistogramCostExtractor
{};
CV_EXPORTS_W Ptr<HistogramCostExtractor>
createEMDL1HistogramCostExtractor(int nDummies=25, float defaultCost=0.2f);
//! @}
} // cv
#endif

105
modules/shape/include/opencv2/shape/shape_distance.hpp
View File

@@ -50,65 +50,131 @@
namespace cv
{
/*!
* The base class for ShapeDistanceExtractor.
* This is just to define the common interface for
* shape comparisson techniques.
//! @addtogroup shape
//! @{
/** @brief Abstract base class for shape distance algorithms.
*/
class CV_EXPORTS_W ShapeDistanceExtractor : public Algorithm
{
public:
/** @brief Compute the shape distance between two shapes defined by its contours.
@param contour1 Contour defining first shape.
@param contour2 Contour defining second shape.
*/
CV_WRAP virtual float computeDistance(InputArray contour1, InputArray contour2) = 0;
};
/***********************************************************************************/
/***********************************************************************************/
/***********************************************************************************/
/*!
* Shape Context implementation.
* The SCD class implements SCD algorithm proposed by Belongie et al.in
* "Shape Matching and Object Recognition Using Shape Contexts".
* Implemented by Juan M. Perez for the GSOC 2013.
*/
/** @brief Implementation of the Shape Context descriptor and matching algorithm
proposed by Belongie et al. in "Shape Matching and Object Recognition Using Shape Contexts" (PAMI
2002). This implementation is packaged in a generic scheme, in order to allow you the
implementation of the common variations of the original pipeline.
*/
class CV_EXPORTS_W ShapeContextDistanceExtractor : public ShapeDistanceExtractor
{
public:
/** @brief Establish the number of angular bins for the Shape Context Descriptor used in the shape matching
pipeline.
@param nAngularBins The number of angular bins in the shape context descriptor.
*/
CV_WRAP virtual void setAngularBins(int nAngularBins) = 0;
CV_WRAP virtual int getAngularBins() const = 0;
/** @brief Establish the number of radial bins for the Shape Context Descriptor used in the shape matching
pipeline.
@param nRadialBins The number of radial bins in the shape context descriptor.
*/
CV_WRAP virtual void setRadialBins(int nRadialBins) = 0;
CV_WRAP virtual int getRadialBins() const = 0;
/** @brief Set the inner radius of the shape context descriptor.
@param innerRadius The value of the inner radius.
*/
CV_WRAP virtual void setInnerRadius(float innerRadius) = 0;
CV_WRAP virtual float getInnerRadius() const = 0;
/** @brief Set the outer radius of the shape context descriptor.
@param outerRadius The value of the outer radius.
*/
CV_WRAP virtual void setOuterRadius(float outerRadius) = 0;
CV_WRAP virtual float getOuterRadius() const = 0;
CV_WRAP virtual void setRotationInvariant(bool rotationInvariant) = 0;
CV_WRAP virtual bool getRotationInvariant() const = 0;
/** @brief Set the weight of the shape context distance in the final value of the shape distance. The shape
context distance between two shapes is defined as the symmetric sum of shape context matching costs
over best matching points. The final value of the shape distance is a user-defined linear
combination of the shape context distance, an image appearance distance, and a bending energy.
@param shapeContextWeight The weight of the shape context distance in the final distance value.
*/
CV_WRAP virtual void setShapeContextWeight(float shapeContextWeight) = 0;
CV_WRAP virtual float getShapeContextWeight() const = 0;
/** @brief Set the weight of the Image Appearance cost in the final value of the shape distance. The image
appearance cost is defined as the sum of squared brightness differences in Gaussian windows around
corresponding image points. The final value of the shape distance is a user-defined linear
combination of the shape context distance, an image appearance distance, and a bending energy. If
this value is set to a number different from 0, is mandatory to set the images that correspond to
each shape.
@param imageAppearanceWeight The weight of the appearance cost in the final distance value.
*/
CV_WRAP virtual void setImageAppearanceWeight(float imageAppearanceWeight) = 0;
CV_WRAP virtual float getImageAppearanceWeight() const = 0;
/** @brief Set the weight of the Bending Energy in the final value of the shape distance. The bending energy
definition depends on what transformation is being used to align the shapes. The final value of the
shape distance is a user-defined linear combination of the shape context distance, an image
appearance distance, and a bending energy.
@param bendingEnergyWeight The weight of the Bending Energy in the final distance value.
*/
CV_WRAP virtual void setBendingEnergyWeight(float bendingEnergyWeight) = 0;
CV_WRAP virtual float getBendingEnergyWeight() const = 0;
/** @brief Set the images that correspond to each shape. This images are used in the calculation of the Image
Appearance cost.
@param image1 Image corresponding to the shape defined by contours1.
@param image2 Image corresponding to the shape defined by contours2.
*/
CV_WRAP virtual void setImages(InputArray image1, InputArray image2) = 0;
CV_WRAP virtual void getImages(OutputArray image1, OutputArray image2) const = 0;
CV_WRAP virtual void setIterations(int iterations) = 0;
CV_WRAP virtual int getIterations() const = 0;
/** @brief Set the algorithm used for building the shape context descriptor cost matrix.
@param comparer Smart pointer to a HistogramCostExtractor, an algorithm that defines the cost
matrix between descriptors.
*/
CV_WRAP virtual void setCostExtractor(Ptr<HistogramCostExtractor> comparer) = 0;
CV_WRAP virtual Ptr<HistogramCostExtractor> getCostExtractor() const = 0;
/** @brief Set the value of the standard deviation for the Gaussian window for the image appearance cost.
@param sigma Standard Deviation.
*/
CV_WRAP virtual void setStdDev(float sigma) = 0;
CV_WRAP virtual float getStdDev() const = 0;
/** @brief Set the algorithm used for aligning the shapes.
@param transformer Smart pointer to a ShapeTransformer, an algorithm that defines the aligning
transformation.
*/
CV_WRAP virtual void setTransformAlgorithm(Ptr<ShapeTransformer> transformer) = 0;
CV_WRAP virtual Ptr<ShapeTransformer> getTransformAlgorithm() const = 0;
};
@@ -123,15 +189,28 @@ CV_EXPORTS_W Ptr<ShapeContextDistanceExtractor>
/***********************************************************************************/
/***********************************************************************************/
/***********************************************************************************/
/*!
* Hausdorff distace implementation based on
/** @brief A simple Hausdorff distance measure between shapes defined by contours
according to the paper "Comparing Images using the Hausdorff distance." by D.P. Huttenlocher, G.A.
Klanderman, and W.J. Rucklidge. (PAMI 1993). :
*/
class CV_EXPORTS_W HausdorffDistanceExtractor : public ShapeDistanceExtractor
{
public:
/** @brief Set the norm used to compute the Hausdorff value between two shapes. It can be L1 or L2 norm.
@param distanceFlag Flag indicating which norm is used to compute the Hausdorff distance
(NORM\_L1, NORM\_L2).
*/
CV_WRAP virtual void setDistanceFlag(int distanceFlag) = 0;
CV_WRAP virtual int getDistanceFlag() const = 0;
/** @brief This method sets the rank proportion (or fractional value) that establish the Kth ranked value of
the partial Hausdorff distance. Experimentally had been shown that 0.6 is a good value to compare
shapes.
@param rankProportion fractional value (between 0 and 1).
*/
CV_WRAP virtual void setRankProportion(float rankProportion) = 0;
CV_WRAP virtual float getRankProportion() const = 0;
};
@@ -139,5 +218,7 @@ public:
/* Constructor */
CV_EXPORTS_W Ptr<HausdorffDistanceExtractor> createHausdorffDistanceExtractor(int distanceFlag=cv::NORM_L2, float rankProp=0.6f);
//! @}
} // cv
#endif

55
modules/shape/include/opencv2/shape/shape_transformer.hpp
View File

@@ -50,20 +50,38 @@
namespace cv
{
/*!
* The base class for ShapeTransformer.
* This is just to define the common interface for
* shape transformation techniques.
//! @addtogroup shape
//! @{
/** @brief Abstract base class for shape transformation algorithms.
*/
class CV_EXPORTS_W ShapeTransformer : public Algorithm
{
public:
/* Estimate, Apply Transformation and return Transforming cost*/
/** @brief Estimate the transformation parameters of the current transformer algorithm, based on point matches.
@param transformingShape Contour defining first shape.
@param targetShape Contour defining second shape (Target).
@param matches Standard vector of Matches between points.
*/
CV_WRAP virtual void estimateTransformation(InputArray transformingShape, InputArray targetShape,
std::vector<DMatch>& matches) = 0;
/** @brief Apply a transformation, given a pre-estimated transformation parameters.
@param input Contour (set of points) to apply the transformation.
@param output Output contour.
*/
CV_WRAP virtual float applyTransformation(InputArray input, OutputArray output=noArray()) = 0;
/** @brief Apply a transformation, given a pre-estimated transformation parameters, to an Image.
@param transformingImage Input image.
@param output Output image.
@param flags Image interpolation method.
@param borderMode border style.
@param borderValue border value.
*/
CV_WRAP virtual void warpImage(InputArray transformingImage, OutputArray output,
int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT,
const Scalar& borderValue=Scalar()) const = 0;
@@ -71,30 +89,33 @@ public:
/***********************************************************************************/
/***********************************************************************************/
/*!
* Thin Plate Spline Transformation
* Implementation of the TPS transformation
* according to "Principal Warps: Thin-Plate Splines and the
* Decomposition of Deformations" by Juan Manuel Perez for the GSOC 2013
*/
/** @brief Definition of the transformation
ocupied in the paper "Principal Warps: Thin-Plate Splines and Decomposition of Deformations", by
F.L. Bookstein (PAMI 1989). :
*/
class CV_EXPORTS_W ThinPlateSplineShapeTransformer : public ShapeTransformer
{
public:
/** @brief Set the regularization parameter for relaxing the exact interpolation requirements of the TPS
algorithm.
@param beta value of the regularization parameter.
*/
CV_WRAP virtual void setRegularizationParameter(double beta) = 0;
CV_WRAP virtual double getRegularizationParameter() const = 0;
};
/* Complete constructor */
/** Complete constructor */
CV_EXPORTS_W Ptr<ThinPlateSplineShapeTransformer>
createThinPlateSplineShapeTransformer(double regularizationParameter=0);
/***********************************************************************************/
/***********************************************************************************/
/*!
* Affine Transformation as a derivated from ShapeTransformer
*/
/** @brief Wrapper class for the OpenCV Affine Transformation algorithm. :
*/
class CV_EXPORTS_W AffineTransformer : public ShapeTransformer
{
public:
@@ -102,8 +123,10 @@ public:
CV_WRAP virtual bool getFullAffine() const = 0;
};
/* Complete constructor */
/** Complete constructor */
CV_EXPORTS_W Ptr<AffineTransformer> createAffineTransformer(bool fullAffine);
//! @}
} // cv
#endif