eVision::EImageStitcher Class Reference

Stitch calibrated images together, forming a seamless panoramic image. More...

#include <eVision/EasyImage/EImageStitcher.h>

Collaboration diagram for eVision::EImageStitcher:

Public Member Functions
	EImageStitcher ()
	Constructs a EImageStitcher.
	EImageStitcher (const eVision::EImageStitcher &other)
	Copy operator.
virtual	~EImageStitcher () throw ()
bool	operator== (const eVision::EImageStitcher &other) const
	Checks if this EImageStitcher instance is strictly equal to another.
eVision::EImageStitcher &	operator= (const eVision::EImageStitcher &other)
	Copy operator.
void	Stitch (const std::vector< eVision::EImageC24 > &images, eVision::EImageC24 &output, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageC24 > &images, eVision::EImageC24 &output, uint32_t rowCount, uint32_t colCount) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageC24 > &images, eVision::EImageC24 &output, uint32_t rowCount) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageC24 > &images, eVision::EImageC24 &output) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageBW8 > &images, eVision::EImageBW8 &output, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageBW8 > &images, eVision::EImageBW8 &output, uint32_t rowCount, uint32_t colCount) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageBW8 > &images, eVision::EImageBW8 &output, uint32_t rowCount) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageBW8 > &images, eVision::EImageBW8 &output) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageC24 &output, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageC24 &output, uint32_t rowCount, uint32_t colCount) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageC24 &output, uint32_t rowCount) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageC24 &output) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageBW8 &output, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageBW8 &output, uint32_t rowCount, uint32_t colCount) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageBW8 &output, uint32_t rowCount) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	Stitch (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageBW8 &output) const
	Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:
void	StitchWithReferenceImage (const std::vector< eVision::EImageC24 > &images, eVision::EImageC24 &output, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageC24 > &images, eVision::EImageC24 &output, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageC24 > &images, eVision::EImageC24 &output, int32_t referenceImageIndex, uint32_t rowCount) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageC24 > &images, eVision::EImageC24 &output, int32_t referenceImageIndex) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageBW8 > &images, eVision::EImageBW8 &output, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageBW8 > &images, eVision::EImageBW8 &output, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageBW8 > &images, eVision::EImageBW8 &output, int32_t referenceImageIndex, uint32_t rowCount) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageBW8 > &images, eVision::EImageBW8 &output, int32_t referenceImageIndex) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageC24 &output, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageC24 &output, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageC24 &output, int32_t referenceImageIndex, uint32_t rowCount) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageC24 &output, int32_t referenceImageIndex) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageBW8 &output, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageBW8 &output, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageBW8 &output, int32_t referenceImageIndex, uint32_t rowCount) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StitchWithReferenceImage (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, eVision::EImageBW8 &output, int32_t referenceImageIndex) const
	Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.
void	StartIncrementalStitching (eVision::EImageType imageType, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder) const
	Puts the stitcher into incremental stitching mode. During incremental stitching mode, it is assumed that the time between two image captures is significant. It essentially separates EImageStitcher::Stitch into multiple function calls. Thus, it is possible to distribute some parts of the stitching computation between image captures by asynchronously calling EImageStitcher::ProcessImage. Simple stitching mode happens in this order:
void	StartIncrementalStitching (eVision::EImageType imageType, uint32_t rowCount, uint32_t colCount) const
	Puts the stitcher into incremental stitching mode. During incremental stitching mode, it is assumed that the time between two image captures is significant. It essentially separates EImageStitcher::Stitch into multiple function calls. Thus, it is possible to distribute some parts of the stitching computation between image captures by asynchronously calling EImageStitcher::ProcessImage. Simple stitching mode happens in this order:
void	StartIncrementalStitching (eVision::EImageType imageType, uint32_t rowCount) const
	Puts the stitcher into incremental stitching mode. During incremental stitching mode, it is assumed that the time between two image captures is significant. It essentially separates EImageStitcher::Stitch into multiple function calls. Thus, it is possible to distribute some parts of the stitching computation between image captures by asynchronously calling EImageStitcher::ProcessImage. Simple stitching mode happens in this order:
void	StartIncrementalStitching (eVision::EImageType imageType) const
	Puts the stitcher into incremental stitching mode. During incremental stitching mode, it is assumed that the time between two image captures is significant. It essentially separates EImageStitcher::Stitch into multiple function calls. Thus, it is possible to distribute some parts of the stitching computation between image captures by asynchronously calling EImageStitcher::ProcessImage. Simple stitching mode happens in this order:
void	ProcessImage (const eVision::EImageC24 &image)
	When in incremental stitching mode, EImageStitcher::ProcessImage can be called multiple times to successively add image to the final image. Significant part of the computation happens in EImageStitcher::ProcessImage. EImageStitcher::ProcessImage is a blocking function. Handling the asynchronousity or any kind of multi-threading is left to the user. EImageStitcher::ProcessImage is not multi-thread safe.
void	ProcessImage (const eVision::EImageBW8 &image)
	When in incremental stitching mode, EImageStitcher::ProcessImage can be called multiple times to successively add image to the final image. Significant part of the computation happens in EImageStitcher::ProcessImage. EImageStitcher::ProcessImage is a blocking function. Handling the asynchronousity or any kind of multi-threading is left to the user. EImageStitcher::ProcessImage is not multi-thread safe.
void	ProcessImage (const eVision::EImageC24 &image, const eVision::ERegion &region)
	When in incremental stitching mode, EImageStitcher::ProcessImage can be called multiple times to successively add image to the final image. Significant part of the computation happens in EImageStitcher::ProcessImage. EImageStitcher::ProcessImage is a blocking function. Handling the asynchronousity or any kind of multi-threading is left to the user. EImageStitcher::ProcessImage is not multi-thread safe.
void	ProcessImage (const eVision::EImageBW8 &image, const eVision::ERegion &region)
	When in incremental stitching mode, EImageStitcher::ProcessImage can be called multiple times to successively add image to the final image. Significant part of the computation happens in EImageStitcher::ProcessImage. EImageStitcher::ProcessImage is a blocking function. Handling the asynchronousity or any kind of multi-threading is left to the user. EImageStitcher::ProcessImage is not multi-thread safe.
void	FinalizeIncrementalStitching (eVision::EImageC24 &output)
	Finalizes the stitching. Computes and returns the final image.
void	FinalizeIncrementalStitching (eVision::EImageBW8 &output)
	Finalizes the stitching. Computes and returns the final image.
void	DrawPoints (eVision::EDrawAdapter *drawAdapter, int32_t n) const
	Draw features points used to stitch the n-th image. Must be called after a stitching. This method does not draw the n-th image. It has to be done beforehand.
void	DrawTransformations (eVision::EDrawAdapter *drawAdapter, float zoomX, float zoomY, float panX, float panY) const
	For each stitched patch, draw a rectangle with the related transformation applied. Must be called after a stitching. This method doesn't draw the final image. It has to be done beforehand.
void	DrawTransformations (eVision::EDrawAdapter *drawAdapter, float zoomX, float zoomY, float panX) const
	For each stitched patch, draw a rectangle with the related transformation applied. Must be called after a stitching. This method doesn't draw the final image. It has to be done beforehand.
void	DrawTransformations (eVision::EDrawAdapter *drawAdapter, float zoomX, float zoomY) const
	For each stitched patch, draw a rectangle with the related transformation applied. Must be called after a stitching. This method doesn't draw the final image. It has to be done beforehand.
void	DrawTransformations (eVision::EDrawAdapter *drawAdapter, float zoomX) const
	For each stitched patch, draw a rectangle with the related transformation applied. Must be called after a stitching. This method doesn't draw the final image. It has to be done beforehand.
void	DrawTransformations (eVision::EDrawAdapter *drawAdapter) const
	For each stitched patch, draw a rectangle with the related transformation applied. Must be called after a stitching. This method doesn't draw the final image. It has to be done beforehand.
std::vector< double >	GetMatrix (int32_t n) const
	Returns the affine matrix applied to input image n-th to compose the final image. The returned vector is a row-ordered 3x2 matrix Must be called after a successful stitching.
void	SetFeatureScalingEnabled (bool newValue)
	When finding the feature points on a specific input image, the image can be scaled down to speed up the process. This does not influence the resolution of the output image. With EImageStitcher, the costliest operation is finding the feature points. An efficient way of cutting the time spent doing this operation is to simply run the internal filter on a lower-resolution image. In our internal tests, the majority of stitching that works with FeatureScalingEnabled sets to true also works with FeatureScalingEnabled sets to false, while the opposite isn’t always true. Especially when the feature points to base the stitching on are already very small (down-sizing the input images would render them invisible).
bool	GetFeatureScalingEnabled () const
	Gets whether images should be scaled down before the feature points are computed.
void	SetGridOverlapX (float overlapX)
	Sets the size of the horizontal overlap between two adjacent patches. The overlap value is relative to the image width and is expressed in percentage. It is used to define a surface to restrict the feature points computation. It is only used when column count and row count are different from zero. Default value is 15% (0.15). When column count and row count are both zero (specified when calling EImageStitcher::Stitch for example), the class is not in grid mode. The entire surface of the patch is used to compute the feature points. The best overlap depends on your image and application. The chosen overlap can impact the precision. Moreover, it can also depend on the image resolution. For example, 10% overlap for 256x256 images would mean finding feature points only in a band of 25 pixels which is not much.
void	SetGridOverlapY (float overlapY)
	Sets the size of the vertical overlap between two adjacent patches. The overlap value is relative to the image height and is expressed in percentage. It is used to define a surface to restrict the feature points computation. It is only used when column count and row count are different from zero. Default value is 15% (0.15). When column count and row count are equal to zero (specified when calling EImageStitcher::Stitch for example), the class is not in grid mode. The entire surface of the patch is used to compute the feature points. The best overlap depends on your image and application. The chosen overlap can impact the precision. Moreover, it can also depend on the image resolution. For example, 10% overlap for 256x256 images would mean finding feature points only in a band of 25 pixels which is not much.
float	GetGridOverlapX () const
	Returns the size of the horizontal overlap between two adjacent patches. The overlap value is relative to the image width and is expressed in percentage.
float	GetGridOverlapY () const
	Returns the size of the vertical overlap between two adjacent patches. The overlap value is relative to the image height and is expressed in percentage.
void	SetAlgorithm (eVision::EStitchingAlgorithm algorithm)
	Sets or Gets the algorithm used by the EImageStitcher. One can either prioritize speed or robustness. Speed is prioritized by default.
eVision::EStitchingAlgorithm	GetAlgorithm () const
	Sets or Gets the algorithm used by the EImageStitcher. One can either prioritize speed or robustness. Speed is prioritized by default.
void	Save (const std::string &path)
	Saves the EImageStitcher. The given ESerializer must have been created for writing.
void	Save (eVision::ESerializer *serializer) const
	Saves the EImageStitcher. The given ESerializer must have been created for writing.
void	Load (const std::string &path)
	Loads the EImageStitcher. The given ESerializer must have been created for reading.
void	Load (eVision::ESerializer *serializer)
	Loads the EImageStitcher. The given ESerializer must have been created for reading.
void	LearnBW8 (const std::vector< eVision::EImageBW8 > &images, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnBW8 (const std::vector< eVision::EImageBW8 > &images, uint32_t rowCount, uint32_t colCount)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnBW8 (const std::vector< eVision::EImageBW8 > &images, uint32_t rowCount)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnBW8 (const std::vector< eVision::EImageBW8 > &images)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnBW8 (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnBW8 (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, uint32_t rowCount, uint32_t colCount)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnBW8 (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, uint32_t rowCount)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnBW8 (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnC24 (const std::vector< eVision::EImageC24 > &images, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnC24 (const std::vector< eVision::EImageC24 > &images, uint32_t rowCount, uint32_t colCount)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnC24 (const std::vector< eVision::EImageC24 > &images, uint32_t rowCount)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnC24 (const std::vector< eVision::EImageC24 > &images)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnC24 (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnC24 (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, uint32_t rowCount, uint32_t colCount)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnC24 (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, uint32_t rowCount)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnC24 (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions)
	Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.
void	LearnWithReferenceImageBW8 (const std::vector< eVision::EImageBW8 > &images, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (const std::vector< eVision::EImageBW8 > &images, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (const std::vector< eVision::EImageBW8 > &images, int32_t referenceImageIndex, uint32_t rowCount)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (const std::vector< eVision::EImageBW8 > &images, int32_t referenceImageIndex)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, int32_t referenceImageIndex, uint32_t rowCount)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (const std::vector< eVision::EImageBW8 > &images, const std::vector< eVision::ERegion > &regions, int32_t referenceImageIndex)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (const std::vector< eVision::EImageC24 > &images, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (const std::vector< eVision::EImageC24 > &images, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (const std::vector< eVision::EImageC24 > &images, int32_t referenceImageIndex, uint32_t rowCount)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (const std::vector< eVision::EImageC24 > &images, int32_t referenceImageIndex)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount, const eVision::EStitchingGridOrder &gridOrder)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, int32_t referenceImageIndex, uint32_t rowCount, uint32_t colCount)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, int32_t referenceImageIndex, uint32_t rowCount)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (const std::vector< eVision::EImageC24 > &images, const std::vector< eVision::ERegion > &regions, int32_t referenceImageIndex)
	See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.
void	Reset ()
	Resets the current state of this EImageStitcher (learn or incremental mode namely). Frees temporary resources.
bool	GetIsLearned () const
	Returns the current learning state of EImageStitcher. EImageStitcher::Reset resets this to false.
	EImageStitcher (CppWrapperInternal::InternalConstructor)

Public Attributes
CppWrapperInternal::WrappedClass	wrappedClass_

Detailed Description

Stitch calibrated images together, forming a seamless panoramic image.

License(s): EasyImage

Constructor & Destructor Documentation

EImageStitcher() [1/3]

eVision::EImageStitcher::EImageStitcher

(

)

Constructs a EImageStitcher.

EImageStitcher() [2/3]

eVision::EImageStitcher::EImageStitcher

(

const eVision::EImageStitcher &

other

)

Copy operator.

Parameters

other

Another EImageStitcher.

~EImageStitcher()

eVision::EImageStitcher::~EImageStitcher ( ) throw (  )

virtual

EImageStitcher() [3/3]

eVision::EImageStitcher::EImageStitcher

(

CppWrapperInternal::InternalConstructor

)

Member Function Documentation

DrawPoints()

void eVision::EImageStitcher::DrawPoints	(	eVision::EDrawAdapter *	drawAdapter,
		int32_t	n ) const

Draw features points used to stitch the n-th image. Must be called after a stitching. This method does not draw the n-th image. It has to be done beforehand.

Parameters

drawAdapter	Draw adapter to draw onto.
n	Index of the image whose feature points should be drawn.

DrawTransformations() [1/5]

void eVision::EImageStitcher::DrawTransformations

(

eVision::EDrawAdapter *

drawAdapter

)

const

For each stitched patch, draw a rectangle with the related transformation applied. Must be called after a stitching. This method doesn't draw the final image. It has to be done beforehand.

Parameters

drawAdapter

Draw adapter to draw onto.

DrawTransformations() [2/5]

void eVision::EImageStitcher::DrawTransformations	(	eVision::EDrawAdapter *	drawAdapter,
		float	zoomX ) const

For each stitched patch, draw a rectangle with the related transformation applied. Must be called after a stitching. This method doesn't draw the final image. It has to be done beforehand.

Parameters

drawAdapter	Draw adapter to draw onto.
zoomX	Horizontal zooming factor. By default, true scale is used.

DrawTransformations() [3/5]

void eVision::EImageStitcher::DrawTransformations	(	eVision::EDrawAdapter *	drawAdapter,
		float	zoomX,
		float	zoomY ) const

For each stitched patch, draw a rectangle with the related transformation applied. Must be called after a stitching. This method doesn't draw the final image. It has to be done beforehand.

Parameters

drawAdapter	Draw adapter to draw onto.
zoomX	Horizontal zooming factor. By default, true scale is used.
zoomY	Vertical zooming factor. If set to 0 (default), the horizontal zooming factor is used instead, to provide isotropic zooming.

DrawTransformations() [4/5]

void eVision::EImageStitcher::DrawTransformations	(	eVision::EDrawAdapter *	drawAdapter,
		float	zoomX,
		float	zoomY,
		float	panX ) const

For each stitched patch, draw a rectangle with the related transformation applied. Must be called after a stitching. This method doesn't draw the final image. It has to be done beforehand.

Parameters

drawAdapter	Draw adapter to draw onto.
zoomX	Horizontal zooming factor. By default, true scale is used.
zoomY	Vertical zooming factor. If set to 0 (default), the horizontal zooming factor is used instead, to provide isotropic zooming.
panX	Horizontal panning value expressed in pixels. By default, no panning occurs.

DrawTransformations() [5/5]

void eVision::EImageStitcher::DrawTransformations	(	eVision::EDrawAdapter *	drawAdapter,
		float	zoomX,
		float	zoomY,
		float	panX,
		float	panY ) const

For each stitched patch, draw a rectangle with the related transformation applied. Must be called after a stitching. This method doesn't draw the final image. It has to be done beforehand.

Parameters

drawAdapter	Draw adapter to draw onto.
zoomX	Horizontal zooming factor. By default, true scale is used.
zoomY	Vertical zooming factor. If set to 0 (default), the horizontal zooming factor is used instead, to provide isotropic zooming.
panX	Horizontal panning value expressed in pixels. By default, no panning occurs.
panY	Vertical panning value expressed in pixels. By default, no panning occurs.

FinalizeIncrementalStitching() [1/2]

void eVision::EImageStitcher::FinalizeIncrementalStitching

(

eVision::EImageBW8 &

output

)

Finalizes the stitching. Computes and returns the final image.

Parameters

output

Output image. This image will be resized by this method and its content lost.

FinalizeIncrementalStitching() [2/2]

void eVision::EImageStitcher::FinalizeIncrementalStitching

(

eVision::EImageC24 &

output

)

Finalizes the stitching. Computes and returns the final image.

Parameters

output

Output image. This image will be resized by this method and its content lost.

GetAlgorithm()

eVision::EStitchingAlgorithm eVision::EImageStitcher::GetAlgorithm

(

)

const

Sets or Gets the algorithm used by the EImageStitcher. One can either prioritize speed or robustness. Speed is prioritized by default.

GetFeatureScalingEnabled()

bool eVision::EImageStitcher::GetFeatureScalingEnabled

(

)

const

Gets whether images should be scaled down before the feature points are computed.

GetGridOverlapX()

float eVision::EImageStitcher::GetGridOverlapX

(

)

const

Returns the size of the horizontal overlap between two adjacent patches. The overlap value is relative to the image width and is expressed in percentage.

GetGridOverlapY()

float eVision::EImageStitcher::GetGridOverlapY

(

)

const

Returns the size of the vertical overlap between two adjacent patches. The overlap value is relative to the image height and is expressed in percentage.

GetIsLearned()

bool eVision::EImageStitcher::GetIsLearned

(

)

const

Returns the current learning state of EImageStitcher. EImageStitcher::Reset resets this to false.

GetMatrix()

std::vector< double > eVision::EImageStitcher::GetMatrix

(

int32_t

n

)

const

Returns the affine matrix applied to input image n-th to compose the final image. The returned vector is a row-ordered 3x2 matrix Must be called after a successful stitching.

Parameters

n	Index of the image whose affine matrix should be returned.

LearnBW8() [1/8]

void eVision::EImageStitcher::LearnBW8

(

const std::vector< eVision::EImageBW8 > &

images

)

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageStitcher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images

Input images. Each image must belong to the same plan.

LearnBW8() [2/8]

void eVision::EImageStitcher::LearnBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageStitcher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.

LearnBW8() [3/8]

void eVision::EImageStitcher::LearnBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		uint32_t	rowCount )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageStitcher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
rowCount	Number of rows.

LearnBW8() [4/8]

void eVision::EImageStitcher::LearnBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		uint32_t	rowCount,
		uint32_t	colCount )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageStitcher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
rowCount	Number of rows.
colCount	Number of columns.

LearnBW8() [5/8]

void eVision::EImageStitcher::LearnBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageStitcher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

LearnBW8() [6/8]

void eVision::EImageStitcher::LearnBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		uint32_t	rowCount )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageStitcher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
rowCount	Number of rows.

LearnBW8() [7/8]

void eVision::EImageStitcher::LearnBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		uint32_t	rowCount,
		uint32_t	colCount )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageStitcher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
rowCount	Number of rows.
colCount	Number of columns.

LearnBW8() [8/8]

void eVision::EImageStitcher::LearnBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageStitcher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

LearnC24() [1/8]

void eVision::EImageStitcher::LearnC24

(

const std::vector< eVision::EImageC24 > &

images

)

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageSticher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images

Input images. Each image must belong to the same plan.

LearnC24() [2/8]

void eVision::EImageStitcher::LearnC24	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageSticher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.

LearnC24() [3/8]

void eVision::EImageStitcher::LearnC24	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		uint32_t	rowCount )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageSticher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
rowCount	Number of rows.

LearnC24() [4/8]

void eVision::EImageStitcher::LearnC24	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		uint32_t	rowCount,
		uint32_t	colCount )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageSticher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
rowCount	Number of rows.
colCount	Number of columns.

LearnC24() [5/8]

void eVision::EImageStitcher::LearnC24	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageSticher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

LearnC24() [6/8]

void eVision::EImageStitcher::LearnC24	(	const std::vector< eVision::EImageC24 > &	images,
		uint32_t	rowCount )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageSticher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
rowCount	Number of rows.

LearnC24() [7/8]

void eVision::EImageStitcher::LearnC24	(	const std::vector< eVision::EImageC24 > &	images,
		uint32_t	rowCount,
		uint32_t	colCount )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageSticher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
rowCount	Number of rows.
colCount	Number of columns.

LearnC24() [8/8]

void eVision::EImageStitcher::LearnC24	(	const std::vector< eVision::EImageC24 > &	images,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder )

Computes the necessary transformations to apply on each input images. Subsequent calls to the Stitch methods will use these transformations instead of re-computing them. Thus, they are expected to be faster.

It is assumed that all the set of input images (in Learn and in next Stitch methods) are correctly ordered, have the same size, and that all their images must have the same dimension.

Learning to stitch on a pattern with strong feature points to maximize the precision and then apply the stitching on images in production is a valable usage. See the New eVision Studio example where the EImageSticher is applied on a piece of tissue (low number of reliable feature points) after being learned on a pattern (high number of reliable feature points).

Throw an exception if the learning failed (the same as if a regular stitching operation fails).

Parameters

images	Input images. Each image must belong to the same plan.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

LearnWithReferenceImageBW8() [1/8]

void eVision::EImageStitcher::LearnWithReferenceImageBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		int32_t	referenceImageIndex )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
referenceImageIndex	Index of the image to start the stitching from.

LearnWithReferenceImageBW8() [2/8]

void eVision::EImageStitcher::LearnWithReferenceImageBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		int32_t	referenceImageIndex,
		uint32_t	rowCount )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.

LearnWithReferenceImageBW8() [3/8]

void eVision::EImageStitcher::LearnWithReferenceImageBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.

LearnWithReferenceImageBW8() [4/8]

void eVision::EImageStitcher::LearnWithReferenceImageBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

LearnWithReferenceImageBW8() [5/8]

void eVision::EImageStitcher::LearnWithReferenceImageBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		int32_t	referenceImageIndex )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
referenceImageIndex	Index of the image to start the stitching from.

LearnWithReferenceImageBW8() [6/8]

void eVision::EImageStitcher::LearnWithReferenceImageBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		int32_t	referenceImageIndex,
		uint32_t	rowCount )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.

LearnWithReferenceImageBW8() [7/8]

void eVision::EImageStitcher::LearnWithReferenceImageBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.

LearnWithReferenceImageBW8() [8/8]

void eVision::EImageStitcher::LearnWithReferenceImageBW8	(	const std::vector< eVision::EImageBW8 > &	images,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

LearnWithReferenceImageC24() [1/8]

void eVision::EImageStitcher::LearnWithReferenceImageC24	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		int32_t	referenceImageIndex )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
referenceImageIndex	Index of the image to start the stitching from.

LearnWithReferenceImageC24() [2/8]

void eVision::EImageStitcher::LearnWithReferenceImageC24	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		int32_t	referenceImageIndex,
		uint32_t	rowCount )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.

LearnWithReferenceImageC24() [3/8]

void eVision::EImageStitcher::LearnWithReferenceImageC24	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.

LearnWithReferenceImageC24() [4/8]

void eVision::EImageStitcher::LearnWithReferenceImageC24	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Regions returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

LearnWithReferenceImageC24() [5/8]

void eVision::EImageStitcher::LearnWithReferenceImageC24	(	const std::vector< eVision::EImageC24 > &	images,
		int32_t	referenceImageIndex )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
referenceImageIndex	Index of the image to start the stitching from.

LearnWithReferenceImageC24() [6/8]

void eVision::EImageStitcher::LearnWithReferenceImageC24	(	const std::vector< eVision::EImageC24 > &	images,
		int32_t	referenceImageIndex,
		uint32_t	rowCount )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.

LearnWithReferenceImageC24() [7/8]

void eVision::EImageStitcher::LearnWithReferenceImageC24	(	const std::vector< eVision::EImageC24 > &	images,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.

LearnWithReferenceImageC24() [8/8]

void eVision::EImageStitcher::LearnWithReferenceImageC24	(	const std::vector< eVision::EImageC24 > &	images,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder )

See EImageStitcher::LearnBW8 (or EImageStitcher::LearnC24) and EImageStitcher::StitchWithReferenceImage.

Parameters

images	Input images. Each image must belong to the same plan.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

Load() [1/2]

void eVision::EImageStitcher::Load

(

const std::string &

path

)

Loads the EImageStitcher. The given ESerializer must have been created for reading.

Parameters

path	The file path.

Load() [2/2]

void eVision::EImageStitcher::Load

(

eVision::ESerializer *

serializer

)

Loads the EImageStitcher. The given ESerializer must have been created for reading.

Parameters

serializer

The serializer.

operator=()

eVision::EImageStitcher & eVision::EImageStitcher::operator=

(

const eVision::EImageStitcher &

other

)

Copy operator.

Parameters

other

Another EImageStitcher.

operator==()

bool eVision::EImageStitcher::operator==

(

const eVision::EImageStitcher &

other

)

const

Checks if this EImageStitcher instance is strictly equal to another.

Parameters

other

Reference to the other EImageStitcher instance

ProcessImage() [1/4]

void eVision::EImageStitcher::ProcessImage

(

const eVision::EImageBW8 &

image

)

When in incremental stitching mode, EImageStitcher::ProcessImage can be called multiple times to successively add image to the final image. Significant part of the computation happens in EImageStitcher::ProcessImage. EImageStitcher::ProcessImage is a blocking function. Handling the asynchronousity or any kind of multi-threading is left to the user. EImageStitcher::ProcessImage is not multi-thread safe.

Parameters

image

Image to add.

ProcessImage() [2/4]

void eVision::EImageStitcher::ProcessImage	(	const eVision::EImageBW8 &	image,
		const eVision::ERegion &	region )

When in incremental stitching mode, EImageStitcher::ProcessImage can be called multiple times to successively add image to the final image. Significant part of the computation happens in EImageStitcher::ProcessImage. EImageStitcher::ProcessImage is a blocking function. Handling the asynchronousity or any kind of multi-threading is left to the user. EImageStitcher::ProcessImage is not multi-thread safe.

Parameters

image	Image to add.
region	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.

ProcessImage() [3/4]

void eVision::EImageStitcher::ProcessImage

(

const eVision::EImageC24 &

image

)

When in incremental stitching mode, EImageStitcher::ProcessImage can be called multiple times to successively add image to the final image. Significant part of the computation happens in EImageStitcher::ProcessImage. EImageStitcher::ProcessImage is a blocking function. Handling the asynchronousity or any kind of multi-threading is left to the user. EImageStitcher::ProcessImage is not multi-thread safe.

Parameters

image

Image to add.

ProcessImage() [4/4]

void eVision::EImageStitcher::ProcessImage	(	const eVision::EImageC24 &	image,
		const eVision::ERegion &	region )

When in incremental stitching mode, EImageStitcher::ProcessImage can be called multiple times to successively add image to the final image. Significant part of the computation happens in EImageStitcher::ProcessImage. EImageStitcher::ProcessImage is a blocking function. Handling the asynchronousity or any kind of multi-threading is left to the user. EImageStitcher::ProcessImage is not multi-thread safe.

Parameters

image	Image to add.
region	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.

Reset()

void eVision::EImageStitcher::Reset

(

)

Resets the current state of this EImageStitcher (learn or incremental mode namely). Frees temporary resources.

Save() [1/2]

void eVision::EImageStitcher::Save

(

const std::string &

path

)

Saves the EImageStitcher. The given ESerializer must have been created for writing.

Parameters

path	The file path.

Save() [2/2]

void eVision::EImageStitcher::Save

(

eVision::ESerializer *

serializer

)

const

Saves the EImageStitcher. The given ESerializer must have been created for writing.

Parameters

serializer

The serializer.

SetAlgorithm()

void eVision::EImageStitcher::SetAlgorithm

(

eVision::EStitchingAlgorithm

algorithm

)

Sets or Gets the algorithm used by the EImageStitcher. One can either prioritize speed or robustness. Speed is prioritized by default.

Parameters

algorithm

the algorithm to use.

SetFeatureScalingEnabled()

void eVision::EImageStitcher::SetFeatureScalingEnabled

(

bool

newValue

)

When finding the feature points on a specific input image, the image can be scaled down to speed up the process. This does not influence the resolution of the output image. With EImageStitcher, the costliest operation is finding the feature points. An efficient way of cutting the time spent doing this operation is to simply run the internal filter on a lower-resolution image. In our internal tests, the majority of stitching that works with FeatureScalingEnabled sets to true also works with FeatureScalingEnabled sets to false, while the opposite isn’t always true. Especially when the feature points to base the stitching on are already very small (down-sizing the input images would render them invisible).

The default value is true.

Parameters

newValue

Whether images should be scaled down before the feature points are computed.

SetGridOverlapX()

void eVision::EImageStitcher::SetGridOverlapX

(

float

overlapX

)

Sets the size of the horizontal overlap between two adjacent patches. The overlap value is relative to the image width and is expressed in percentage. It is used to define a surface to restrict the feature points computation. It is only used when column count and row count are different from zero. Default value is 15% (0.15). When column count and row count are both zero (specified when calling EImageStitcher::Stitch for example), the class is not in grid mode. The entire surface of the patch is used to compute the feature points. The best overlap depends on your image and application. The chosen overlap can impact the precision. Moreover, it can also depend on the image resolution. For example, 10% overlap for 256x256 images would mean finding feature points only in a band of 25 pixels which is not much.

Parameters

overlapX

New overlap value.

SetGridOverlapY()

void eVision::EImageStitcher::SetGridOverlapY

(

float

overlapY

)

Sets the size of the vertical overlap between two adjacent patches. The overlap value is relative to the image height and is expressed in percentage. It is used to define a surface to restrict the feature points computation. It is only used when column count and row count are different from zero. Default value is 15% (0.15). When column count and row count are equal to zero (specified when calling EImageStitcher::Stitch for example), the class is not in grid mode. The entire surface of the patch is used to compute the feature points. The best overlap depends on your image and application. The chosen overlap can impact the precision. Moreover, it can also depend on the image resolution. For example, 10% overlap for 256x256 images would mean finding feature points only in a band of 25 pixels which is not much.

Parameters

overlapY

New overlap value.

StartIncrementalStitching() [1/4]

void eVision::EImageStitcher::StartIncrementalStitching

(

eVision::EImageType

imageType

)

const

Puts the stitcher into incremental stitching mode. During incremental stitching mode, it is assumed that the time between two image captures is significant. It essentially separates EImageStitcher::Stitch into multiple function calls. Thus, it is possible to distribute some parts of the stitching computation between image captures by asynchronously calling EImageStitcher::ProcessImage. Simple stitching mode happens in this order:

1. Capture image 1.
2. Capture image 2. ...
3. Stitch all images.

While incremental stitching mode happens in this order:

1. Capture image 1 (asynchronously submit it to EImageStitcher with EImageStitcher::ProcessImage).
2. Capture image 2 (asynchronously submit it to EImageStitcher with EImageStitcher::ProcessImage). ...
3. Finalize stitching.

Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Parameters

imageType

Image type of the output and of each input images.

StartIncrementalStitching() [2/4]

void eVision::EImageStitcher::StartIncrementalStitching	(	eVision::EImageType	imageType,
		uint32_t	rowCount ) const

Puts the stitcher into incremental stitching mode. During incremental stitching mode, it is assumed that the time between two image captures is significant. It essentially separates EImageStitcher::Stitch into multiple function calls. Thus, it is possible to distribute some parts of the stitching computation between image captures by asynchronously calling EImageStitcher::ProcessImage. Simple stitching mode happens in this order:

1. Capture image 1.
2. Capture image 2. ...
3. Stitch all images.

While incremental stitching mode happens in this order:

1. Capture image 1 (asynchronously submit it to EImageStitcher with EImageStitcher::ProcessImage).
2. Capture image 2 (asynchronously submit it to EImageStitcher with EImageStitcher::ProcessImage). ...
3. Finalize stitching.

Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Parameters

imageType	Image type of the output and of each input images.
rowCount	Number of rows.

StartIncrementalStitching() [3/4]

void eVision::EImageStitcher::StartIncrementalStitching	(	eVision::EImageType	imageType,
		uint32_t	rowCount,
		uint32_t	colCount ) const

Puts the stitcher into incremental stitching mode. During incremental stitching mode, it is assumed that the time between two image captures is significant. It essentially separates EImageStitcher::Stitch into multiple function calls. Thus, it is possible to distribute some parts of the stitching computation between image captures by asynchronously calling EImageStitcher::ProcessImage. Simple stitching mode happens in this order:

1. Capture image 1.
2. Capture image 2. ...
3. Stitch all images.

While incremental stitching mode happens in this order:

1. Capture image 1 (asynchronously submit it to EImageStitcher with EImageStitcher::ProcessImage).
2. Capture image 2 (asynchronously submit it to EImageStitcher with EImageStitcher::ProcessImage). ...
3. Finalize stitching.

Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Parameters

imageType	Image type of the output and of each input images.
rowCount	Number of rows.
colCount	Number of columns.

StartIncrementalStitching() [4/4]

void eVision::EImageStitcher::StartIncrementalStitching	(	eVision::EImageType	imageType,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder ) const

Puts the stitcher into incremental stitching mode. During incremental stitching mode, it is assumed that the time between two image captures is significant. It essentially separates EImageStitcher::Stitch into multiple function calls. Thus, it is possible to distribute some parts of the stitching computation between image captures by asynchronously calling EImageStitcher::ProcessImage. Simple stitching mode happens in this order:

1. Capture image 1.
2. Capture image 2. ...
3. Stitch all images.

While incremental stitching mode happens in this order:

1. Capture image 1 (asynchronously submit it to EImageStitcher with EImageStitcher::ProcessImage).
2. Capture image 2 (asynchronously submit it to EImageStitcher with EImageStitcher::ProcessImage). ...
3. Finalize stitching.

Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Parameters

imageType	Image type of the output and of each input images.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

Stitch() [1/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageBW8 &	output ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.

Stitch() [2/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageBW8 &	output,
		uint32_t	rowCount ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
rowCount	Number of rows.

Stitch() [3/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageBW8 &	output,
		uint32_t	rowCount,
		uint32_t	colCount ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
rowCount	Number of rows.
colCount	Number of columns.

Stitch() [4/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageBW8 &	output,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

Stitch() [5/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageBW8 > &	images,
		eVision::EImageBW8 &	output ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.

Stitch() [6/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageBW8 > &	images,
		eVision::EImageBW8 &	output,
		uint32_t	rowCount ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
rowCount	Number of rows.

Stitch() [7/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageBW8 > &	images,
		eVision::EImageBW8 &	output,
		uint32_t	rowCount,
		uint32_t	colCount ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
rowCount	Number of rows.
colCount	Number of columns.

Stitch() [8/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageBW8 > &	images,
		eVision::EImageBW8 &	output,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

Stitch() [9/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageC24 &	output ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.

Stitch() [10/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageC24 &	output,
		uint32_t	rowCount ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
rowCount	Number of rows.

Stitch() [11/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageC24 &	output,
		uint32_t	rowCount,
		uint32_t	colCount ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
rowCount	Number of rows.
colCount	Number of columns.

Stitch() [12/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageC24 &	output,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

Stitch() [13/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageC24 > &	images,
		eVision::EImageC24 &	output ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.

Stitch() [14/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageC24 > &	images,
		eVision::EImageC24 &	output,
		uint32_t	rowCount ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
rowCount	Number of rows.

Stitch() [15/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageC24 > &	images,
		eVision::EImageC24 &	output,
		uint32_t	rowCount,
		uint32_t	colCount ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
rowCount	Number of rows.
colCount	Number of columns.

Stitch() [16/16]

void eVision::EImageStitcher::Stitch	(	const std::vector< eVision::EImageC24 > &	images,
		eVision::EImageC24 &	output,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder ) const

Stitch calibrated images together. Stitching happens iteratively from the reference image which defines the overall orientation of the final image. The reference image is automatically inferred after computing matching possibilities. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching. When in grid mode, the image as assumed to be taken in the following fashion:

1	2	3
4	5	6
7	8	9

Precision depends on your images. Stitching works by finding and matching common feature points between a pair of images. These pairs of points can then be used to compute the transformation to be applied to the images to compose the final image. Therefore, the precision of stitching can be increased by :

• Increasing the number of feature points shared between two images
• Increasing the number of unique features points, to avoid false positive matches. To minimize the number of false positives, the Overlap parameter can be adjusted. A smaller overlap will yield a smaller number of points.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

StitchWithReferenceImage() [1/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageBW8 &	output,
		int32_t	referenceImageIndex ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.

StitchWithReferenceImage() [2/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageBW8 &	output,
		int32_t	referenceImageIndex,
		uint32_t	rowCount ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.

StitchWithReferenceImage() [3/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageBW8 &	output,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.

StitchWithReferenceImage() [4/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageBW8 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageBW8 &	output,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

StitchWithReferenceImage() [5/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageBW8 > &	images,
		eVision::EImageBW8 &	output,
		int32_t	referenceImageIndex ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.

StitchWithReferenceImage() [6/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageBW8 > &	images,
		eVision::EImageBW8 &	output,
		int32_t	referenceImageIndex,
		uint32_t	rowCount ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.

StitchWithReferenceImage() [7/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageBW8 > &	images,
		eVision::EImageBW8 &	output,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.

StitchWithReferenceImage() [8/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageBW8 > &	images,
		eVision::EImageBW8 &	output,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

StitchWithReferenceImage() [9/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageC24 &	output,
		int32_t	referenceImageIndex ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.

StitchWithReferenceImage() [10/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageC24 &	output,
		int32_t	referenceImageIndex,
		uint32_t	rowCount ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.

StitchWithReferenceImage() [11/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageC24 &	output,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.

StitchWithReferenceImage() [12/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageC24 > &	images,
		const std::vector< eVision::ERegion > &	regions,
		eVision::EImageC24 &	output,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
regions	Region returned by the ECameraCalibration::Unwarp or EWorldShape::Unwarp methods. Indicates which pixel belong to the original image during blending.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

StitchWithReferenceImage() [13/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageC24 > &	images,
		eVision::EImageC24 &	output,
		int32_t	referenceImageIndex ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.

StitchWithReferenceImage() [14/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageC24 > &	images,
		eVision::EImageC24 &	output,
		int32_t	referenceImageIndex,
		uint32_t	rowCount ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.

StitchWithReferenceImage() [15/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageC24 > &	images,
		eVision::EImageC24 &	output,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.

StitchWithReferenceImage() [16/16]

void eVision::EImageStitcher::StitchWithReferenceImage	(	const std::vector< eVision::EImageC24 > &	images,
		eVision::EImageC24 &	output,
		int32_t	referenceImageIndex,
		uint32_t	rowCount,
		uint32_t	colCount,
		const eVision::EStitchingGridOrder &	gridOrder ) const

Stitch calibrated images together. Stitching happens iteratively from the base image which defines the overall orientation of the final image. The reference image is explicitly given. If the images were taken in a grid fashion, the shape of the grid can be referenced by specifying its number of rows and columns. Doing so speeds up the matching process and can improve the result. Specifying a number of rows and columns of zero defaults to not using a grid when matching.

Parameters

images	Input images. Each image must belong to the same plan.
output	Output image. This image will be resized by this method and its content lost.
referenceImageIndex	Index of the image to start the stitching from.
rowCount	Number of rows.
colCount	Number of columns.
gridOrder	Grid traversal definition.

Member Data Documentation

wrappedClass_

CppWrapperInternal::WrappedClass eVision::EImageStitcher::wrappedClass_