Example Image Stitching - Revision history

Peter at 22:54, 17 January 2022

2022-01-17T22:54:53Z

Peter at 18:15, 12 July 2021

2021-07-12T18:15:30Z

← Older revision		Revision as of 18:15, 12 July 2021
Line 9:		Line 9:
	This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.		This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.37/examples/src/main/java/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.38/examples/src/main/java/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]

	Concepts:		Concepts:
Line 42:		Line 42:
	/**		/**
	* Using abstracted code, find a transform which minimizes the difference between corresponding features		* Using abstracted code, find a transform which minimizes the difference between corresponding features
	* in both images. This code is completely model independent and is the core algorithms.		* in both images. This code is completely model independent and is the core algorithms.
	*/		*/
	public static <T extends ImageGray<T>, FD extends TupleDesc> Homography2D_F64		public static <T extends ImageGray<T>, TD extends TupleDesc<TD>> Homography2D_F64
	computeTransform( T imageA, T imageB,		computeTransform( T imageA, T imageB,
	DetectDescribePoint<T, FD> detDesc,		DetectDescribePoint<T, TD> detDesc,
	AssociateDescription<FD> associate,		AssociateDescription<TD> associate,
	ModelMatcher<Homography2D_F64, AssociatedPair> modelMatcher ) {		ModelMatcher<Homography2D_F64, AssociatedPair> modelMatcher ) {
	// get the length of the description		// get the length of the description
	List<Point2D_F64> pointsA = new ArrayList<>();		List<Point2D_F64> pointsA = new ArrayList<>();
	DogArray<FD> descA = UtilFeature.~~createQueue~~(detDesc, 100);		DogArray<TD> descA = UtilFeature.createArray(detDesc, 100);
	List<Point2D_F64> pointsB = new ArrayList<>();		List<Point2D_F64> pointsB = new ArrayList<>();
	DogArray<FD> descB = UtilFeature.~~createQueue~~(detDesc, 100);		DogArray<TD> descB = UtilFeature.createArray(detDesc, 100);

	// extract feature locations and descriptions from each image		// extract feature locations and descriptions from each image
Line 88:		Line 88:
	* Detects features inside the two images and computes descriptions at those points.		* Detects features inside the two images and computes descriptions at those points.
	*/		*/
	private static <T extends ImageGray<T>, FD extends TupleDesc>		private static <T extends ImageGray<T>, TD extends TupleDesc<TD>>
	void describeImage( T image,		void describeImage( T image,
	DetectDescribePoint<T, FD> detDesc,		DetectDescribePoint<T, TD> detDesc,
	List<Point2D_F64> points,		List<Point2D_F64> points,
	DogArray<FD> listDescs ) {		DogArray<TD> listDescs ) {
	detDesc.detect(image);		detDesc.detect(image);

Line 116:		Line 116:
	AssociateDescription<TupleDesc_F64> associate = FactoryAssociation.greedy(new ConfigAssociateGreedy(true, 2), scorer);		AssociateDescription<TupleDesc_F64> associate = FactoryAssociation.greedy(new ConfigAssociateGreedy(true, 2), scorer);

	// fit the images using a homography. This works well for rotations and distant objects.		// fit the images using a homography. This works well for rotations and distant objects.
	ModelMatcher<Homography2D_F64, AssociatedPair> modelMatcher =		ModelMatcher<Homography2D_F64, AssociatedPair> modelMatcher =
	FactoryMultiViewRobust.homographyRansac(null, new ConfigRansac(60, 3));		FactoryMultiViewRobust.homographyRansac(null, new ConfigRansac(60, 3));
Line 154:		Line 154:

	// Render first image		// Render first image
	model.~~set~~(fromWorkToA);		model.setTo(fromWorkToA);
	distort.apply(colorA, work);		distort.apply(colorA, work);

	// Render second image		// Render second image
	Homography2D_F64 fromWorkToB = fromWorkToA.concat(fromAtoB, null);		Homography2D_F64 fromWorkToB = fromWorkToA.concat(fromAtoB, null);
	model.~~set~~(fromWorkToB);		model.setTo(fromWorkToB);
	distort.apply(colorB, work);		distort.apply(colorB, work);

Peter at 02:07, 22 December 2020

2020-12-22T02:07:05Z

Show changes

Peter at 05:10, 18 May 2020

2020-05-18T05:10:21Z

← Older revision		Revision as of 05:10, 18 May 2020
Line 9:		Line 9:
	This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.		This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.33/examples/src/main/java/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.36/examples/src/main/java/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]

	Concepts:		Concepts:
Line 67:		Line 67:

	// create a list of AssociatedPairs that tell the model matcher how a feature moved		// create a list of AssociatedPairs that tell the model matcher how a feature moved
	~~FastQueue~~<AssociatedIndex> matches = associate.getMatches();		FastAccess<AssociatedIndex> matches = associate.getMatches();
	List<AssociatedPair> pairs = new ArrayList<>();		List<AssociatedPair> pairs = new ArrayList<>();

Line 117:		Line 117:
	new ConfigFastHessian(1, 2, 200, 1, 9, 4, 4), null,null, imageType);		new ConfigFastHessian(1, 2, 200, 1, 9, 4, 4), null,null, imageType);
	ScoreAssociation<BrightFeature> scorer = FactoryAssociation.scoreEuclidean(BrightFeature.class,true);		ScoreAssociation<BrightFeature> scorer = FactoryAssociation.scoreEuclidean(BrightFeature.class,true);
	AssociateDescription<BrightFeature> associate = FactoryAssociation.greedy(~~scorer~~,2,~~true~~);		AssociateDescription<BrightFeature> associate = FactoryAssociation.greedy(new ConfigAssociateGreedy(true,2),scorer);

	// fit the images using a homography. This works well for rotations and distant objects.		// fit the images using a homography. This works well for rotations and distant objects.

Peter at 13:55, 15 March 2019

2019-03-15T13:55:32Z

← Older revision		Revision as of 13:55, 15 March 2019
Line 9:		Line 9:
	This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.		This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.27/examples/src/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.33/examples/src/main/java/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]

	Concepts:		Concepts:

Peter at 00:10, 21 January 2018

2018-01-21T00:10:21Z

← Older revision		Revision as of 00:10, 21 January 2018
Line 19:		Line 19:

	Relevant Videos:		Relevant Videos:
	* [http://www.youtube.com/watch?v=59RJeLlDAxQ ~~Youtube~~ Video]		* [http://www.youtube.com/watch?v=59RJeLlDAxQ YouTube Video]

Peter at 00:04, 21 January 2018

2018-01-21T00:04:12Z

← Older revision		Revision as of 00:04, 21 January 2018
Line 19:		Line 19:

	Relevant Videos:		Relevant Videos:
	*([http://www.youtube.com/watch?v=59RJeLlDAxQ Youtube Video]		* [http://www.youtube.com/watch?v=59RJeLlDAxQ Youtube Video]

Peter at 15:47, 17 August 2017

2017-08-17T15:47:29Z

← Older revision		Revision as of 15:47, 17 August 2017
Line 9:		Line 9:
	This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.		This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.25/examples/src/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.27/examples/src/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]

	Concepts:		Concepts:
Line 19:		Line 19:

	Relevant Videos:		Relevant Videos:
	* ~~[[Applet_Video_Mosaic\| Video Mosaic]]~~ ([http://www.youtube.com/watch?v=59RJeLlDAxQ Youtube Video])		*([http://www.youtube.com/watch?v=59RJeLlDAxQ Youtube Video]


Line 45:		Line 45:
	* in both images. This code is completely model independent and is the core algorithms.		* in both images. This code is completely model independent and is the core algorithms.
	*/		*/
	public static<T extends ImageGray, FD extends TupleDesc> Homography2D_F64		public static<T extends ImageGray<T>, FD extends TupleDesc> Homography2D_F64
	computeTransform( T imageA , T imageB ,		computeTransform( T imageA , T imageB ,
	DetectDescribePoint<T,FD> detDesc ,		DetectDescribePoint<T,FD> detDesc ,
Line 90:		Line 90:
	* Detects features inside the two images and computes descriptions at those points.		* Detects features inside the two images and computes descriptions at those points.
	*/		*/
	private static <T extends ImageGray, FD extends TupleDesc>		private static <T extends ImageGray<T>, FD extends TupleDesc>
	void describeImage(T image,		void describeImage(T image,
	DetectDescribePoint<T,FD> detDesc,		DetectDescribePoint<T,FD> detDesc,
Line 107:		Line 107:
	* Given two input images create and display an image where the two have been overlayed on top of each other.		* Given two input images create and display an image where the two have been overlayed on top of each other.
	*/		*/
	public static <T extends ImageGray>		public static <T extends ImageGray<T>>
	void stitch( BufferedImage imageA , BufferedImage imageB , Class<T> imageType )		void stitch( BufferedImage imageA , BufferedImage imageB , Class<T> imageType )
	{		{
Line 139:		Line 139:
	// Convert into a BoofCV color format		// Convert into a BoofCV color format
	Planar<GrayF32> colorA =		Planar<GrayF32> colorA =
	ConvertBufferedImage.~~convertFromMulti~~(imageA, null, true, GrayF32.class);		ConvertBufferedImage.convertFromPlanar(imageA, null, true, GrayF32.class);
	Planar<GrayF32> colorB =		Planar<GrayF32> colorB =
	ConvertBufferedImage.~~convertFromMulti~~(imageB, null,true, GrayF32.class);		ConvertBufferedImage.convertFromPlanar(imageB, null,true, GrayF32.class);

	// Where the output images are rendered into		// Where the output images are rendered into

Peter at 23:32, 1 December 2016

2016-12-01T23:32:40Z

← Older revision		Revision as of 23:32, 1 December 2016
Line 9:		Line 9:
	This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.		This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.23/examples/src/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.25/examples/src/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]

	Concepts:		Concepts:
Line 18:		Line 18:
	* Homography		* Homography

			Relevant Videos:
	Relevant ~~Applets~~:
	* [[Applet_Associate_Points\| Associate Points]]
	* [[Applet_Description_Region\| Region Description]]
	* [[Applet_Video_Mosaic\| Video Mosaic]] ([http://www.youtube.com/watch?v=59RJeLlDAxQ Youtube Video])		* [[Applet_Video_Mosaic\| Video Mosaic]] ([http://www.youtube.com/watch?v=59RJeLlDAxQ Youtube Video])
	* [[Applet_Video_Stabilization\| Video Stabilization]]


	Related Examples:		Related Examples:
			* [[Example_Associate_Interest_Points\| Associate Interest Points]]
	* [[Example_Video_Mosaic\| Video Mosaic]]		* [[Example_Video_Mosaic\| Video Mosaic]]

Line 55:		Line 52:
	{		{
	// get the length of the description		// get the length of the description
	List<Point2D_F64> pointsA = new ArrayList<~~Point2D_F64~~>();		List<Point2D_F64> pointsA = new ArrayList<>();
	FastQueue<FD> descA = UtilFeature.createQueue(detDesc,100);		FastQueue<FD> descA = UtilFeature.createQueue(detDesc,100);
	List<Point2D_F64> pointsB = new ArrayList<~~Point2D_F64~~>();		List<Point2D_F64> pointsB = new ArrayList<>();
	FastQueue<FD> descB = UtilFeature.createQueue(detDesc,100);		FastQueue<FD> descB = UtilFeature.createQueue(detDesc,100);

Line 71:		Line 68:
	// create a list of AssociatedPairs that tell the model matcher how a feature moved		// create a list of AssociatedPairs that tell the model matcher how a feature moved
	FastQueue<AssociatedIndex> matches = associate.getMatches();		FastQueue<AssociatedIndex> matches = associate.getMatches();
	List<AssociatedPair> pairs = new ArrayList<~~AssociatedPair~~>();		List<AssociatedPair> pairs = new ArrayList<>();

	for( int i = 0; i < matches.size(); i++ ) {		for( int i = 0; i < matches.size(); i++ ) {

Peter at 06:03, 28 March 2016

2016-03-28T06:03:21Z

← Older revision		Revision as of 06:03, 28 March 2016
Line 9:		Line 9:
	This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.		This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.21/examples/src/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.23/examples/src/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]

	Concepts:		Concepts:
Line 48:		Line 48:
	* in both images. This code is completely model independent and is the core algorithms.		* in both images. This code is completely model independent and is the core algorithms.
	*/		*/
	public static<T extends ~~ImageSingleBand~~, FD extends TupleDesc> Homography2D_F64		public static<T extends ImageGray, FD extends TupleDesc> Homography2D_F64
	computeTransform( T imageA , T imageB ,		computeTransform( T imageA , T imageB ,
	DetectDescribePoint<T,FD> detDesc ,		DetectDescribePoint<T,FD> detDesc ,
Line 93:		Line 93:
	* Detects features inside the two images and computes descriptions at those points.		* Detects features inside the two images and computes descriptions at those points.
	*/		*/
	private static <T extends ~~ImageSingleBand~~, FD extends TupleDesc>		private static <T extends ImageGray, FD extends TupleDesc>
	void describeImage(T image,		void describeImage(T image,
	DetectDescribePoint<T,FD> detDesc,		DetectDescribePoint<T,FD> detDesc,
Line 110:		Line 110:
	* Given two input images create and display an image where the two have been overlayed on top of each other.		* Given two input images create and display an image where the two have been overlayed on top of each other.
	*/		*/
	public static <T extends ~~ImageSingleBand~~>		public static <T extends ImageGray>
	void stitch( BufferedImage imageA , BufferedImage imageB , Class<T> imageType )		void stitch( BufferedImage imageA , BufferedImage imageB , Class<T> imageType )
	{		{
Line 141:		Line 141:

	// Convert into a BoofCV color format		// Convert into a BoofCV color format
	~~MultiSpectral~~<~~ImageFloat32~~> colorA =		Planar<GrayF32> colorA =
	ConvertBufferedImage.convertFromMulti(imageA, null, true, ~~ImageFloat32~~.class);		ConvertBufferedImage.convertFromMulti(imageA, null, true, GrayF32.class);
	~~MultiSpectral~~<~~ImageFloat32~~> colorB =		Planar<GrayF32> colorB =
	ConvertBufferedImage.convertFromMulti(imageB, null,true, ~~ImageFloat32~~.class);		ConvertBufferedImage.convertFromMulti(imageB, null,true, GrayF32.class);

	// Where the output images are rendered into		// Where the output images are rendered into
	~~MultiSpectral~~<~~ImageFloat32~~> work = colorA.createSameShape();		Planar<GrayF32> work = colorA.createSameShape();

	// Adjust the transform so that the whole image can appear inside of it		// Adjust the transform so that the whole image can appear inside of it
Line 155:		Line 155:
	// Used to render the results onto an image		// Used to render the results onto an image
	PixelTransformHomography_F32 model = new PixelTransformHomography_F32();		PixelTransformHomography_F32 model = new PixelTransformHomography_F32();
	InterpolatePixelS<~~ImageFloat32~~> interp = FactoryInterpolation.bilinearPixelS(~~ImageFloat32~~.class, BorderType.~~VALUE~~);		InterpolatePixelS<GrayF32> interp = FactoryInterpolation.bilinearPixelS(GrayF32.class, BorderType.ZERO);
	ImageDistort<~~MultiSpectral~~<~~ImageFloat32~~>,~~MultiSpectral~~<~~ImageFloat32~~>> distort =		ImageDistort<Planar<GrayF32>,Planar<GrayF32>> distort =
	DistortSupport.~~createDistortMS~~(~~ImageFloat32~~.class, model, interp, false);		DistortSupport.createDistortPL(GrayF32.class, model, interp, false);
	distort.setRenderAll(false);		distort.setRenderAll(false);

Line 205:		Line 205:
	imageA = UtilImageIO.loadImage(UtilIO.pathExample("stitch/mountain_rotate_01.jpg"));		imageA = UtilImageIO.loadImage(UtilIO.pathExample("stitch/mountain_rotate_01.jpg"));
	imageB = UtilImageIO.loadImage(UtilIO.pathExample("stitch/mountain_rotate_03.jpg"));		imageB = UtilImageIO.loadImage(UtilIO.pathExample("stitch/mountain_rotate_03.jpg"));
	stitch(imageA,imageB, ~~ImageFloat32~~.class);		stitch(imageA,imageB, GrayF32.class);
	imageA = UtilImageIO.loadImage(UtilIO.pathExample("stitch/kayak_01.jpg"));		imageA = UtilImageIO.loadImage(UtilIO.pathExample("stitch/kayak_01.jpg"));
	imageB = UtilImageIO.loadImage(UtilIO.pathExample("stitch/kayak_03.jpg"));		imageB = UtilImageIO.loadImage(UtilIO.pathExample("stitch/kayak_03.jpg"));
	stitch(imageA,imageB, ~~ImageFloat32~~.class);		stitch(imageA,imageB, GrayF32.class);
	imageA = UtilImageIO.loadImage(UtilIO.pathExample("scale/rainforest_01.jpg"));		imageA = UtilImageIO.loadImage(UtilIO.pathExample("scale/rainforest_01.jpg"));
	imageB = UtilImageIO.loadImage(UtilIO.pathExample("scale/rainforest_02.jpg"));		imageB = UtilImageIO.loadImage(UtilIO.pathExample("scale/rainforest_02.jpg"));
	stitch(imageA,imageB, ~~ImageFloat32~~.class);		stitch(imageA,imageB, GrayF32.class);
	}		}
	}		}
	</syntaxhighlight>		</syntaxhighlight>

← Older revision		Revision as of 22:54, 17 January 2022
Line 9:		Line 9:
	This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.		This example is designed to demonstrate several aspects of BoofCV by stitching images together. Image stitching refers to combining two or more overlapping images together into a single large image. When stitching images together the goal is to find a 2D geometric transform which minimize the error (difference in appearance) in overlapping regions. There are many ways to do this, in the example below point image features are found, associated, and then a 2D transform is found robustly using the associated features.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.38/examples/src/main/java/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.40/examples/src/main/java/boofcv/examples/geometry/ExampleImageStitching.java ExampleImageStitching.java]

	Concepts:		Concepts:
Line 195:		Line 195:
	public static void main( String[] args ) {		public static void main( String[] args ) {
	BufferedImage imageA, imageB;		BufferedImage imageA, imageB;
	imageA = UtilImageIO.~~loadImage~~(UtilIO.pathExample("stitch/mountain_rotate_01.jpg"));		imageA = UtilImageIO.loadImageNotNull(UtilIO.pathExample("stitch/mountain_rotate_01.jpg"));
	imageB = UtilImageIO.~~loadImage~~(UtilIO.pathExample("stitch/mountain_rotate_03.jpg"));		imageB = UtilImageIO.loadImageNotNull(UtilIO.pathExample("stitch/mountain_rotate_03.jpg"));
	stitch(imageA, imageB, GrayF32.class);		stitch(imageA, imageB, GrayF32.class);
	imageA = UtilImageIO.~~loadImage~~(UtilIO.pathExample("stitch/kayak_01.jpg"));		imageA = UtilImageIO.loadImageNotNull(UtilIO.pathExample("stitch/kayak_01.jpg"));
	imageB = UtilImageIO.~~loadImage~~(UtilIO.pathExample("stitch/kayak_03.jpg"));		imageB = UtilImageIO.loadImageNotNull(UtilIO.pathExample("stitch/kayak_03.jpg"));
	stitch(imageA, imageB, GrayF32.class);		stitch(imageA, imageB, GrayF32.class);
	imageA = UtilImageIO.~~loadImage~~(UtilIO.pathExample("scale/rainforest_01.jpg"));		imageA = UtilImageIO.loadImageNotNull(UtilIO.pathExample("scale/rainforest_01.jpg"));
	imageB = UtilImageIO.~~loadImage~~(UtilIO.pathExample("scale/rainforest_02.jpg"));		imageB = UtilImageIO.loadImageNotNull(UtilIO.pathExample("scale/rainforest_02.jpg"));
	stitch(imageA, imageB, GrayF32.class);		stitch(imageA, imageB, GrayF32.class);
	}		}
	}		}
	</syntaxhighlight>		</syntaxhighlight>