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

Inheritance diagram for eVision.EImageStitcher:

Collaboration diagram for eVision.EImageStitcher:

Public Member Functions
	EImageStitcher ()
	Constructs a EImageStitcher.
	EImageStitcher (eVision.EImageStitcher other)
	Copy operator.
void	Stitch (eVision.EImageC24[] images, eVision.EImageC24 output, uint rowCount, uint colCount, eVision.EStitchingGridOrder gridOrder)
	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 (eVision.EImageC24[] images, eVision.EImageC24 output, uint rowCount, uint colCount)
	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 (eVision.EImageC24[] images, eVision.EImageC24 output, uint rowCount)
	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 (eVision.EImageC24[] images, eVision.EImageC24 output)
	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 (eVision.EImageBW8[] images, eVision.EImageBW8 output, uint rowCount, uint colCount, eVision.EStitchingGridOrder gridOrder)
	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 (eVision.EImageBW8[] images, eVision.EImageBW8 output, uint rowCount, uint colCount)
	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 (eVision.EImageBW8[] images, eVision.EImageBW8 output, uint rowCount)
	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 (eVision.EImageBW8[] images, eVision.EImageBW8 output)
	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 (eVision.EImageC24[] images, eVision.ERegion[] regions, eVision.EImageC24 output, uint rowCount, uint colCount, eVision.EStitchingGridOrder gridOrder)
	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 (eVision.EImageC24[] images, eVision.ERegion[] regions, eVision.EImageC24 output, uint rowCount, uint colCount)
	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 (eVision.EImageC24[] images, eVision.ERegion[] regions, eVision.EImageC24 output, uint rowCount)
	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 (eVision.EImageC24[] images, eVision.ERegion[] regions, eVision.EImageC24 output)
	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 (eVision.EImageBW8[] images, eVision.ERegion[] regions, eVision.EImageBW8 output, uint rowCount, uint colCount, eVision.EStitchingGridOrder gridOrder)
	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 (eVision.EImageBW8[] images, eVision.ERegion[] regions, eVision.EImageBW8 output, uint rowCount, uint colCount)
	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 (eVision.EImageBW8[] images, eVision.ERegion[] regions, eVision.EImageBW8 output, uint rowCount)
	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 (eVision.EImageBW8[] images, eVision.ERegion[] regions, eVision.EImageBW8 output)
	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 (eVision.EImageC24[] images, eVision.EImageC24 output, int referenceImageIndex, uint rowCount, uint colCount, eVision.EStitchingGridOrder gridOrder)
	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 (eVision.EImageC24[] images, eVision.EImageC24 output, int referenceImageIndex, uint rowCount, uint colCount)
	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 (eVision.EImageC24[] images, eVision.EImageC24 output, int referenceImageIndex, uint rowCount)
	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 (eVision.EImageC24[] images, eVision.EImageC24 output, int referenceImageIndex)
	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 (eVision.EImageBW8[] images, eVision.EImageBW8 output, int referenceImageIndex, uint rowCount, uint colCount, eVision.EStitchingGridOrder gridOrder)
	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 (eVision.EImageBW8[] images, eVision.EImageBW8 output, int referenceImageIndex, uint rowCount, uint colCount)
	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 (eVision.EImageBW8[] images, eVision.EImageBW8 output, int referenceImageIndex, uint rowCount)
	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 (eVision.EImageBW8[] images, eVision.EImageBW8 output, int referenceImageIndex)
	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 (eVision.EImageC24[] images, eVision.ERegion[] regions, eVision.EImageC24 output, int referenceImageIndex, uint rowCount, uint colCount, eVision.EStitchingGridOrder gridOrder)
	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 (eVision.EImageC24[] images, eVision.ERegion[] regions, eVision.EImageC24 output, int referenceImageIndex, uint rowCount, uint colCount)
	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 (eVision.EImageC24[] images, eVision.ERegion[] regions, eVision.EImageC24 output, int referenceImageIndex, uint rowCount)
	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 (eVision.EImageC24[] images, eVision.ERegion[] regions, eVision.EImageC24 output, int referenceImageIndex)
	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 (eVision.EImageBW8[] images, eVision.ERegion[] regions, eVision.EImageBW8 output, int referenceImageIndex, uint rowCount, uint colCount, eVision.EStitchingGridOrder gridOrder)
	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 (eVision.EImageBW8[] images, eVision.ERegion[] regions, eVision.EImageBW8 output, int referenceImageIndex, uint rowCount, uint colCount)
	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 (eVision.EImageBW8[] images, eVision.ERegion[] regions, eVision.EImageBW8 output, int referenceImageIndex, uint rowCount)
	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 (eVision.EImageBW8[] images, eVision.ERegion[] regions, eVision.EImageBW8 output, int referenceImageIndex)
	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, uint rowCount, uint colCount, eVision.EStitchingGridOrder gridOrder)
	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, uint rowCount, uint colCount)
	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, uint rowCount)
	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)
	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 (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 (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 (eVision.EImageC24 image, 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 (eVision.EImageBW8 image, 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, int n)
	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)
	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)
	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)
	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)
	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)
	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.
double[]	GetMatrix (int n)
	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	Save (string path)
	Saves the EImageStitcher. The given ESerializer must have been created for writing.
void	Save (eVision.ESerializer serializer)
	Saves the EImageStitcher. The given ESerializer must have been created for writing.
void	Load (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 (eVision.EImageBW8[] images, uint rowCount, uint colCount, 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 (eVision.EImageBW8[] images, uint rowCount, uint 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 (eVision.EImageBW8[] images, uint 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 (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 (eVision.EImageBW8[] images, eVision.ERegion[] regions, uint rowCount, uint colCount, 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 (eVision.EImageBW8[] images, eVision.ERegion[] regions, uint rowCount, uint 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 (eVision.EImageBW8[] images, eVision.ERegion[] regions, uint 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 (eVision.EImageBW8[] images, 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 (eVision.EImageC24[] images, uint rowCount, uint colCount, 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 (eVision.EImageC24[] images, uint rowCount, uint 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 (eVision.EImageC24[] images, uint 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 (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 (eVision.EImageC24[] images, eVision.ERegion[] regions, uint rowCount, uint colCount, 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 (eVision.EImageC24[] images, eVision.ERegion[] regions, uint rowCount, uint 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 (eVision.EImageC24[] images, eVision.ERegion[] regions, uint 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 (eVision.EImageC24[] images, 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 (eVision.EImageBW8[] images, int referenceImageIndex, uint rowCount, uint colCount, eVision.EStitchingGridOrder gridOrder)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (eVision.EImageBW8[] images, int referenceImageIndex, uint rowCount, uint colCount)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (eVision.EImageBW8[] images, int referenceImageIndex, uint rowCount)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (eVision.EImageBW8[] images, int referenceImageIndex)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (eVision.EImageBW8[] images, eVision.ERegion[] regions, int referenceImageIndex, uint rowCount, uint colCount, eVision.EStitchingGridOrder gridOrder)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (eVision.EImageBW8[] images, eVision.ERegion[] regions, int referenceImageIndex, uint rowCount, uint colCount)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (eVision.EImageBW8[] images, eVision.ERegion[] regions, int referenceImageIndex, uint rowCount)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageBW8 (eVision.EImageBW8[] images, eVision.ERegion[] regions, int referenceImageIndex)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (eVision.EImageC24[] images, int referenceImageIndex, uint rowCount, uint colCount, eVision.EStitchingGridOrder gridOrder)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (eVision.EImageC24[] images, int referenceImageIndex, uint rowCount, uint colCount)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (eVision.EImageC24[] images, int referenceImageIndex, uint rowCount)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (eVision.EImageC24[] images, int referenceImageIndex)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (eVision.EImageC24[] images, eVision.ERegion[] regions, int referenceImageIndex, uint rowCount, uint colCount, eVision.EStitchingGridOrder gridOrder)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (eVision.EImageC24[] images, eVision.ERegion[] regions, int referenceImageIndex, uint rowCount, uint colCount)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (eVision.EImageC24[] images, eVision.ERegion[] regions, int referenceImageIndex, uint rowCount)
	See EImageStitcher.LearnBW8 (or EImageStitcher.LearnC24) and EImageStitcher.StitchWithReferenceImage.
void	LearnWithReferenceImageC24 (eVision.EImageC24[] images, eVision.ERegion[] regions, int 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.

Properties
bool	FeatureScalingEnabled `[get, set]`
	Gets whether images should be scaled down before the feature points are computed.
float	GridOverlapX `[get, set]`
	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	GridOverlapY `[get, set]`
	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.
eVision.EStitchingAlgorithm	Algorithm `[get, set]`
	Sets or Gets the algorithm used by the EImageStitcher. One can either prioritize speed or robustness. Speed is prioritized by default.
bool	IsLearned `[get]`
	Returns the current learning state of EImageStitcher. EImageStitcher.Reset resets this to false.

Detailed Description

Stitch calibrated images together, forming a seamless panoramic image.

License(s): EasyImage

Constructor & Destructor Documentation

◆ EImageStitcher() [1/2]

eVision.EImageStitcher.EImageStitcher ( )

Constructs a EImageStitcher.

◆ EImageStitcher() [2/2]

eVision.EImageStitcher.EImageStitcher ( eVision.EImageStitcher other )

Copy operator.

Parameters

other Another EImageStitcher.

Member Function Documentation

◆ DrawPoints()

void eVision.EImageStitcher.DrawPoints	(	eVision.EDrawAdapter	drawAdapter,
		int	n )

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 )

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 )

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 )

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 )

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 )

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.

◆ GetMatrix()

double[] eVision.EImageStitcher.GetMatrix ( int n )

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 ( 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	(	eVision.EImageBW8[]	images,
		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	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		uint	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	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		uint	rowCount,
		uint	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	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		uint	rowCount,
		uint	colCount,
		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	(	eVision.EImageBW8[]	images,
		uint	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	(	eVision.EImageBW8[]	images,
		uint	rowCount,
		uint	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	(	eVision.EImageBW8[]	images,
		uint	rowCount,
		uint	colCount,
		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 ( 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	(	eVision.EImageC24[]	images,
		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	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		uint	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	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		uint	rowCount,
		uint	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	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		uint	rowCount,
		uint	colCount,
		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	(	eVision.EImageC24[]	images,
		uint	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	(	eVision.EImageC24[]	images,
		uint	rowCount,
		uint	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	(	eVision.EImageC24[]	images,
		uint	rowCount,
		uint	colCount,
		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	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		int	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	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		int	referenceImageIndex,
		uint	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	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		int	referenceImageIndex,
		uint	rowCount,
		uint	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	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		int	referenceImageIndex,
		uint	rowCount,
		uint	colCount,
		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	(	eVision.EImageBW8[]	images,
		int	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	(	eVision.EImageBW8[]	images,
		int	referenceImageIndex,
		uint	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	(	eVision.EImageBW8[]	images,
		int	referenceImageIndex,
		uint	rowCount,
		uint	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	(	eVision.EImageBW8[]	images,
		int	referenceImageIndex,
		uint	rowCount,
		uint	colCount,
		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	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		int	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	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		int	referenceImageIndex,
		uint	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	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		int	referenceImageIndex,
		uint	rowCount,
		uint	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	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		int	referenceImageIndex,
		uint	rowCount,
		uint	colCount,
		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	(	eVision.EImageC24[]	images,
		int	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	(	eVision.EImageC24[]	images,
		int	referenceImageIndex,
		uint	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	(	eVision.EImageC24[]	images,
		int	referenceImageIndex,
		uint	rowCount,
		uint	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	(	eVision.EImageC24[]	images,
		int	referenceImageIndex,
		uint	rowCount,
		uint	colCount,
		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 ( eVision.ESerializer serializer )

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

Parameters

serializer The serializer.

◆ Load() [2/2]

void eVision.EImageStitcher.Load ( string path )

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

Parameters

path	The file path.

◆ ProcessImage() [1/4]

void eVision.EImageStitcher.ProcessImage ( 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	(	eVision.EImageBW8	image,
		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 ( 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	(	eVision.EImageC24	image,
		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 ( eVision.ESerializer serializer )

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

Parameters

serializer The serializer.

◆ Save() [2/2]

void eVision.EImageStitcher.Save ( string path )

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

Parameters

path	The file path.

◆ StartIncrementalStitching() [1/4]

void eVision.EImageStitcher.StartIncrementalStitching ( eVision.EImageType imageType )

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:

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

While incremental stitching mode happens in this order:

Capture image 1 (asynchronously submit it to EImageStitcher with EImageStitcher.ProcessImage).
Capture image 2 (asynchronously submit it to EImageStitcher with EImageStitcher.ProcessImage). ...
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,
		uint	rowCount )

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:

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

While incremental stitching mode happens in this order:

Capture image 1 (asynchronously submit it to EImageStitcher with EImageStitcher.ProcessImage).
Capture image 2 (asynchronously submit it to EImageStitcher with EImageStitcher.ProcessImage). ...
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,
		uint	rowCount,
		uint	colCount )

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:

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

While incremental stitching mode happens in this order:

Capture image 1 (asynchronously submit it to EImageStitcher with EImageStitcher.ProcessImage).
Capture image 2 (asynchronously submit it to EImageStitcher with EImageStitcher.ProcessImage). ...
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,
		uint	rowCount,
		uint	colCount,
		eVision.EStitchingGridOrder	gridOrder )

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:

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

While incremental stitching mode happens in this order:

Capture image 1 (asynchronously submit it to EImageStitcher with EImageStitcher.ProcessImage).
Capture image 2 (asynchronously submit it to EImageStitcher with EImageStitcher.ProcessImage). ...
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	(	eVision.EImageBW8[]	images,
		eVision.EImageBW8	output )

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() [2/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageBW8[]	images,
		eVision.EImageBW8	output,
		uint	rowCount )

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() [3/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageBW8[]	images,
		eVision.EImageBW8	output,
		uint	rowCount,
		uint	colCount )

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() [4/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageBW8[]	images,
		eVision.EImageBW8	output,
		uint	rowCount,
		uint	colCount,
		eVision.EStitchingGridOrder	gridOrder )

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() [5/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageBW8	output )

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() [6/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageBW8	output,
		uint	rowCount )

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() [7/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageBW8	output,
		uint	rowCount,
		uint	colCount )

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() [8/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageBW8	output,
		uint	rowCount,
		uint	colCount,
		eVision.EStitchingGridOrder	gridOrder )

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() [9/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageC24[]	images,
		eVision.EImageC24	output )

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() [10/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageC24[]	images,
		eVision.EImageC24	output,
		uint	rowCount )

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() [11/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageC24[]	images,
		eVision.EImageC24	output,
		uint	rowCount,
		uint	colCount )

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() [12/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageC24[]	images,
		eVision.EImageC24	output,
		uint	rowCount,
		uint	colCount,
		eVision.EStitchingGridOrder	gridOrder )

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() [13/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageC24	output )

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() [14/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageC24	output,
		uint	rowCount )

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() [15/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageC24	output,
		uint	rowCount,
		uint	colCount )

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() [16/16]

void eVision.EImageStitcher.Stitch	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageC24	output,
		uint	rowCount,
		uint	colCount,
		eVision.EStitchingGridOrder	gridOrder )

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.

◆ StitchWithReferenceImage() [1/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageBW8[]	images,
		eVision.EImageBW8	output,
		int	referenceImageIndex )

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() [2/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageBW8[]	images,
		eVision.EImageBW8	output,
		int	referenceImageIndex,
		uint	rowCount )

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() [3/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageBW8[]	images,
		eVision.EImageBW8	output,
		int	referenceImageIndex,
		uint	rowCount,
		uint	colCount )

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() [4/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageBW8[]	images,
		eVision.EImageBW8	output,
		int	referenceImageIndex,
		uint	rowCount,
		uint	colCount,
		eVision.EStitchingGridOrder	gridOrder )

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() [5/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageBW8	output,
		int	referenceImageIndex )

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() [6/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageBW8	output,
		int	referenceImageIndex,
		uint	rowCount )

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() [7/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageBW8	output,
		int	referenceImageIndex,
		uint	rowCount,
		uint	colCount )

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() [8/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageBW8[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageBW8	output,
		int	referenceImageIndex,
		uint	rowCount,
		uint	colCount,
		eVision.EStitchingGridOrder	gridOrder )

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() [9/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageC24[]	images,
		eVision.EImageC24	output,
		int	referenceImageIndex )

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() [10/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageC24[]	images,
		eVision.EImageC24	output,
		int	referenceImageIndex,
		uint	rowCount )

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() [11/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageC24[]	images,
		eVision.EImageC24	output,
		int	referenceImageIndex,
		uint	rowCount,
		uint	colCount )

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() [12/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageC24[]	images,
		eVision.EImageC24	output,
		int	referenceImageIndex,
		uint	rowCount,
		uint	colCount,
		eVision.EStitchingGridOrder	gridOrder )

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() [13/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageC24	output,
		int	referenceImageIndex )

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() [14/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageC24	output,
		int	referenceImageIndex,
		uint	rowCount )

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() [15/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageC24	output,
		int	referenceImageIndex,
		uint	rowCount,
		uint	colCount )

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() [16/16]

void eVision.EImageStitcher.StitchWithReferenceImage	(	eVision.EImageC24[]	images,
		eVision.ERegion[]	regions,
		eVision.EImageC24	output,
		int	referenceImageIndex,
		uint	rowCount,
		uint	colCount,
		eVision.EStitchingGridOrder	gridOrder )

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.

Property Documentation

◆ Algorithm

eVision.EStitchingAlgorithm eVision.EImageStitcher.Algorithm

getset

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

◆ FeatureScalingEnabled

bool eVision.EImageStitcher.FeatureScalingEnabled

getset

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

◆ GridOverlapX

float eVision.EImageStitcher.GridOverlapX

getset

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.

◆ GridOverlapY

float eVision.EImageStitcher.GridOverlapY

getset

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.

◆ IsLearned

bool eVision.EImageStitcher.IsLearned

get

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

Public Member Functions

Properties

Detailed Description

Constructor & Destructor Documentation

◆ EImageStitcher() [1/2]

◆ EImageStitcher() [2/2]

Member Function Documentation

◆ DrawPoints()

◆ DrawTransformations() [1/5]

◆ DrawTransformations() [2/5]

◆ DrawTransformations() [3/5]

◆ DrawTransformations() [4/5]

◆ DrawTransformations() [5/5]

◆ FinalizeIncrementalStitching() [1/2]

◆ FinalizeIncrementalStitching() [2/2]

◆ GetMatrix()

◆ LearnBW8() [1/8]

◆ LearnBW8() [2/8]

◆ LearnBW8() [3/8]

◆ LearnBW8() [4/8]

◆ LearnBW8() [5/8]

◆ LearnBW8() [6/8]

◆ LearnBW8() [7/8]

◆ LearnBW8() [8/8]

◆ LearnC24() [1/8]

◆ LearnC24() [2/8]

◆ LearnC24() [3/8]

◆ LearnC24() [4/8]

◆ LearnC24() [5/8]

◆ LearnC24() [6/8]

◆ LearnC24() [7/8]

◆ LearnC24() [8/8]

◆ LearnWithReferenceImageBW8() [1/8]

◆ LearnWithReferenceImageBW8() [2/8]

◆ LearnWithReferenceImageBW8() [3/8]

◆ LearnWithReferenceImageBW8() [4/8]

◆ LearnWithReferenceImageBW8() [5/8]

◆ LearnWithReferenceImageBW8() [6/8]

◆ LearnWithReferenceImageBW8() [7/8]

◆ LearnWithReferenceImageBW8() [8/8]

◆ LearnWithReferenceImageC24() [1/8]

◆ LearnWithReferenceImageC24() [2/8]

◆ LearnWithReferenceImageC24() [3/8]

◆ LearnWithReferenceImageC24() [4/8]

◆ LearnWithReferenceImageC24() [5/8]

◆ LearnWithReferenceImageC24() [6/8]

◆ LearnWithReferenceImageC24() [7/8]

◆ LearnWithReferenceImageC24() [8/8]

◆ Load() [1/2]

◆ Load() [2/2]

◆ ProcessImage() [1/4]

◆ ProcessImage() [2/4]

◆ ProcessImage() [3/4]

◆ ProcessImage() [4/4]

◆ Reset()

◆ Save() [1/2]

◆ Save() [2/2]

◆ StartIncrementalStitching() [1/4]

◆ StartIncrementalStitching() [2/4]

◆ StartIncrementalStitching() [3/4]

◆ StartIncrementalStitching() [4/4]

◆ Stitch() [1/16]

◆ Stitch() [2/16]

◆ Stitch() [3/16]

◆ Stitch() [4/16]

◆ Stitch() [5/16]

◆ Stitch() [6/16]

◆ Stitch() [7/16]

◆ Stitch() [8/16]

◆ Stitch() [9/16]

◆ Stitch() [10/16]

◆ Stitch() [11/16]

◆ Stitch() [12/16]

◆ Stitch() [13/16]

◆ Stitch() [14/16]

◆ Stitch() [15/16]

◆ Stitch() [16/16]

◆ StitchWithReferenceImage() [1/16]

◆ StitchWithReferenceImage() [2/16]

◆ StitchWithReferenceImage() [3/16]