Example Stereo Visual Odometry - Revision history

Peter at 00:51, 3 September 2022

2022-09-03T00:51:33Z

← Older revision		Revision as of 00:51, 3 September 2022
Line 7:		Line 7:
	Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.		Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.39/examples/src/main/java/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.41/examples/src/main/java/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]

	Concepts:		Concepts:
Line 109:		Line 109:
	return "";		return "";

	~~AccessPointTracks3D~~ access = (AccessPointTracks3D)alg;		var access = (AccessPointTracks3D)alg;

	int N = access.getTotalTracks();		int N = access.getTotalTracks();

Peter at 03:28, 9 October 2021

2021-10-09T03:28:28Z

← Older revision		Revision as of 03:28, 9 October 2021
Line 7:		Line 7:
	Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.		Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.38/examples/src/main/java/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.39/examples/src/main/java/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]

	Concepts:		Concepts:
Line 44:		Line 44:
	SimpleImageSequence<GrayU8> video2 = media.openVideo(		SimpleImageSequence<GrayU8> video2 = media.openVideo(
	new File(directory, "right.mjpeg").getPath(), ImageType.single(GrayU8.class));		new File(directory, "right.mjpeg").getPath(), ImageType.single(GrayU8.class));

			var config = new ConfigStereoMonoTrackPnP();

	// Specify which tracker and how it will behave		// Specify which tracker and how it will behave
	~~var configKlt~~ = ~~new ConfigPKlt()~~;		config.tracker.typeTracker = ConfigPointTracker.TrackerType.KLT;
	~~configKlt~~.pyramidLevels = ConfigDiscreteLevels.levels(4);		config.tracker.klt.pyramidLevels = ConfigDiscreteLevels.levels(4);
	~~configKlt~~.templateRadius = 4;		config.tracker.klt.templateRadius = 4;
	~~configKlt~~.toleranceFB = 3;		config.tracker.klt.toleranceFB = 3;
	~~configKlt~~.pruneClose = true;		config.tracker.klt.pruneClose = true;

	~~var configDet = new ConfigPointDetector();~~		config.tracker.detDesc.detectPoint.type = PointDetectorTypes.SHI_TOMASI;
	~~configDet~~.type = PointDetectorTypes.SHI_TOMASI;		config.tracker.detDesc.detectPoint.shiTomasi.radius = 4;
	~~configDet~~.shiTomasi.radius = 4;		config.tracker.detDesc.detectPoint.general.maxFeatures = 300;
	~~configDet~~.general.maxFeatures = 300;		config.tracker.detDesc.detectPoint.general.radius = 5;
	~~configDet~~.general.radius = 5;

	// We will estimate the location of features using block matching stereo		// We will estimate the location of features using block matching stereo
	~~var configBM = new ConfigDisparityBM();~~		config.disparity.errorType = DisparityError.CENSUS;
	~~configBM~~.errorType = DisparityError.CENSUS;		config.disparity.disparityMin = 0;
	~~configBM~~.disparityMin = 0;		config.disparity.disparityRange = 50;
	~~configBM~~.disparityRange = 50;		config.disparity.regionRadiusX = 3;
	~~configBM~~.regionRadiusX = 3;		config.disparity.regionRadiusY = 3;
	~~configBM~~.regionRadiusY = 3;		config.disparity.maxPerPixelError = 30;
	~~configBM~~.maxPerPixelError = 30;		config.disparity.texture = 0.05;
	~~configBM~~.texture = 0.05;		config.disparity.validateRtoL = 1;
	~~configBM~~.validateRtoL = 1;		config.disparity.subpixel = true;
	~~configBM~~.subpixel = true;

	// Configurations related to how the structure is chained together frame to frame		// Configurations related to how the structure is chained together frame to frame
	~~var configVisOdom = new ConfigVisOdomTrackPnP();~~		config.scene.keyframes.geoMinCoverage = 0.4;
	~~configVisOdom~~.keyframes.geoMinCoverage = 0.4;		config.scene.ransac.iterations = 200;
	~~configVisOdom~~.ransac.iterations = 200;		config.scene.ransac.inlierThreshold = 1.0;
	~~configVisOdom~~.ransac.inlierThreshold = 1.0;

	// Declare each component then visual odometry		// Declare each component then visual odometry
	~~PointTracker<GrayU8> tracker = FactoryPointTracker.klt(configKlt, configDet, GrayU8.class, GrayS16.class);~~		StereoVisualOdometry<GrayU8> visodom = FactoryVisualOdometry.stereoMonoPnP(config, GrayU8.class);
	~~StereoDisparitySparse<GrayU8> disparity = FactoryStereoDisparity.sparseRectifiedBM(configBM, GrayU8.class);~~
	StereoVisualOdometry<GrayU8> visodom = FactoryVisualOdometry.stereoMonoPnP(~~configVisOdom, disparity, tracker~~, GrayU8.class);

	// Optionally dump verbose debugging information to stdout		// Optionally dump verbose debugging information to stdout
	// ~~Set<String> configuration = new HashSet<>();~~		// visodom.setVerbose(System.out, BoofMiscOps.hashSet(BoofVerbose.RUNTIME, VisualOdometry.VERBOSE_TRACKING));
	~~// configuration~~.~~add~~(~~VisualOdometry~~.~~VERBOSE_RUNTIME);~~
	~~// configuration~~.~~add~~(VisualOdometry.VERBOSE_TRACKING);
	~~// visodom.setVerbose(System.out,configuration~~);

	// Pass in intrinsic/extrinsic calibration. This can be changed in the future.		// Pass in intrinsic/extrinsic calibration. This can be changed in the future.

Peter at 19:54, 12 July 2021

2021-07-12T19:54:00Z

← Older revision		Revision as of 19:54, 12 July 2021
Line 7:		Line 7:
	Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.		Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.

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

	Concepts:		Concepts:
Line 87:		Line 87:
	// visodom.setVerbose(System.out,configuration);		// visodom.setVerbose(System.out,configuration);

	// Pass in intrinsic/extrinsic calibration. This can be changed in the future.		// Pass in intrinsic/extrinsic calibration. This can be changed in the future.
	visodom.setCalibration(stereoParam);		visodom.setCalibration(stereoParam);

Line 103:		Line 103:
	Vector3D_F64 T = leftToWorld.getT();		Vector3D_F64 T = leftToWorld.getT();

	System.out.printf("Location %8.2f %8.2f %8.2f %s\n", T.x, T.y, T.z, trackStats(visodom));		System.out.printf("Location %8.2f %8.2f %8.2f, %s\n", T.x, T.y, T.z, trackStats(visodom));
	}		}
	System.out.printf("FPS %4.2f\n", video1.getFrameNumber()/((System.nanoTime() - startTime)*1e-9));		System.out.printf("FPS %4.2f\n", video1.getFrameNumber()/((System.nanoTime() - startTime)*1e-9));
Line 111:		Line 111:
	* If the algorithm implements AccessPointTracks3D create a string which summarizing different tracking information		* If the algorithm implements AccessPointTracks3D create a string which summarizing different tracking information
	*/		*/
	public static String trackStats( ~~StereoVisualOdometry~~ alg ) {		public static String trackStats( VisualOdometry alg ) {
	if (!(alg instanceof AccessPointTracks3D))		if (!(alg instanceof AccessPointTracks3D))
	return "";		return "";
Line 117:		Line 117:
	AccessPointTracks3D access = (AccessPointTracks3D)alg;		AccessPointTracks3D access = (AccessPointTracks3D)alg;

	~~int count = 0;~~
	int N = access.getTotalTracks();		int N = access.getTotalTracks();
			int totalInliers = 0;
	int totalNew = 0;		int totalNew = 0;
	for (int i = 0; i < N; i++) {		for (int i = 0; i < N; i++) {
	if (access.isTrackInlier(i))		if (access.isTrackInlier(i))
	~~count~~++;		totalInliers++;
	~~else~~ if (access.isTrackNew(i)) {
			if (access.isTrackNew(i))
	totalNew++;		totalNew++;
	}
	}		}

	return String.format("inlier %5.1f%% new %4d total %d", 100.0*~~count~~/(N ~~- totalNew)~~, totalNew, N);		return String.format("inlier: %5.1f%% new %4d total %d", 100.0*totalInliers/N, totalNew, N);
	}		}
	}		}
	</syntaxhighlight>		</syntaxhighlight>

Peter at 02:45, 22 December 2020

2020-12-22T02:45:51Z

← Older revision		Revision as of 02:45, 22 December 2020
Line 7:		Line 7:
	Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.		Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.36/examples/src/main/java/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.37/examples/src/main/java/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]

	Concepts:		Concepts:
Line 33:		Line 33:
	*/		*/
	public class ExampleVisualOdometryStereo {		public class ExampleVisualOdometryStereo {
			public static void main( String[] args ) {
	public static void main( String ~~args~~[] ) {

	MediaManager media = DefaultMediaManager.INSTANCE;		MediaManager media = DefaultMediaManager.INSTANCE;

Line 41:		Line 39:

	// load camera description and the video sequence		// load camera description and the video sequence
	StereoParameters stereoParam = CalibrationIO.load(media.openFile(new File(directory , "stereo.yaml").getPath()));		StereoParameters stereoParam = CalibrationIO.load(media.openFile(new File(directory, "stereo.yaml").getPath()));
	SimpleImageSequence<GrayU8> video1 = media.openVideo(		SimpleImageSequence<GrayU8> video1 = media.openVideo(
	new File(directory , "left.mjpeg").getPath(), ImageType.single(GrayU8.class));		new File(directory, "left.mjpeg").getPath(), ImageType.single(GrayU8.class));
	SimpleImageSequence<GrayU8> video2 = media.openVideo(		SimpleImageSequence<GrayU8> video2 = media.openVideo(
	new File(directory,"right.mjpeg").getPath(), ImageType.single(GrayU8.class));		new File(directory, "right.mjpeg").getPath(), ImageType.single(GrayU8.class));

	// Specify which tracker and how it will behave		// Specify which tracker and how it will behave
Line 79:		Line 77:

	// Declare each component then visual odometry		// Declare each component then visual odometry
	PointTracker<GrayU8> tracker = FactoryPointTracker.klt(configKlt, configDet,GrayU8.class, GrayS16.class);		PointTracker<GrayU8> tracker = FactoryPointTracker.klt(configKlt, configDet, GrayU8.class, GrayS16.class);
	StereoDisparitySparse<GrayU8> disparity = FactoryStereoDisparity.sparseRectifiedBM(configBM, GrayU8.class);		StereoDisparitySparse<GrayU8> disparity = FactoryStereoDisparity.sparseRectifiedBM(configBM, GrayU8.class);
	StereoVisualOdometry<GrayU8> visodom = FactoryVisualOdometry.stereoMonoPnP(configVisOdom,disparity,tracker, GrayU8.class);		StereoVisualOdometry<GrayU8> visodom = FactoryVisualOdometry.stereoMonoPnP(configVisOdom, disparity, tracker, GrayU8.class);

	// Optionally dump verbose debugging information to stdout		// Optionally dump verbose debugging information to stdout
Line 94:		Line 92:
	// Process the video sequence and output the location plus number of inliers		// Process the video sequence and output the location plus number of inliers
	long startTime = System.nanoTime();		long startTime = System.nanoTime();
	while( video1.hasNext() ) {		while (video1.hasNext()) {
	GrayU8 left = video1.next();		GrayU8 left = video1.next();
	GrayU8 right = video2.next();		GrayU8 right = video2.next();

	if( !visodom.process(left,right) ) {		if (!visodom.process(left, right)) {
	throw new RuntimeException("VO Failed!");		throw new RuntimeException("VO Failed!");
	}		}
Line 107:		Line 105:
	System.out.printf("Location %8.2f %8.2f %8.2f %s\n", T.x, T.y, T.z, trackStats(visodom));		System.out.printf("Location %8.2f %8.2f %8.2f %s\n", T.x, T.y, T.z, trackStats(visodom));
	}		}
	System.out.printf("FPS %4.2f\n", video1.getFrameNumber()/((System.nanoTime()-startTime)*1e-9));		System.out.printf("FPS %4.2f\n", video1.getFrameNumber()/((System.nanoTime() - startTime)*1e-9));
	}		}

Line 113:		Line 111:
	* If the algorithm implements AccessPointTracks3D create a string which summarizing different tracking information		* If the algorithm implements AccessPointTracks3D create a string which summarizing different tracking information
	*/		*/
	public static String trackStats(StereoVisualOdometry alg) {		public static String trackStats( StereoVisualOdometry alg ) {
	if( !(alg instanceof AccessPointTracks3D))		if (!(alg instanceof AccessPointTracks3D))
	return "";		return "";

Line 122:		Line 120:
	int N = access.getTotalTracks();		int N = access.getTotalTracks();
	int totalNew = 0;		int totalNew = 0;
	for( int i = 0; i < N; i++ ) {		for (int i = 0; i < N; i++) {
	if( access.isTrackInlier(i) )		if (access.isTrackInlier(i))
	count++;		count++;
	else if( access.isTrackNew(i) ) {		else if (access.isTrackNew(i)) {
	totalNew++;		totalNew++;
	}		}
	}		}

	return String.format("inlier %5.1f%% new %4d total %d", 100.0 * count / (N-totalNew),totalNew,N);		return String.format("inlier %5.1f%% new %4d total %d", 100.0*count/(N - totalNew), totalNew, N);
	}		}
	}		}
	</syntaxhighlight>		</syntaxhighlight>

Peter at 04:17, 22 June 2020

2020-06-22T04:17:36Z

← Older revision		Revision as of 04:17, 22 June 2020
Line 15:		Line 15:

	Relevant Videos:		Relevant Videos:
	* [~~http~~://www.youtube.com/watch?v=D4I4NHSGaOc ~~Youtube~~]		* [https://www.youtube.com/watch?v=8pn9Ebw90uk&t=292s Video 2020]
			* [https://www.youtube.com/watch?v=D4I4NHSGaOc Video 2013]

	Related Tutorials/Example Code:		Related Tutorials/Example Code:

Peter at 03:26, 19 May 2020

2020-05-19T03:26:39Z

← Older revision		Revision as of 03:26, 19 May 2020
Line 1:		Line 1:
	<center>		<center>
	<gallery widths=758px heights=384px >		<gallery widths=758px heights=384px >
	File:Stereo_visual_odometry_screenshot.jpg\|Screenshot from visual odometry demonstration. ~~Example just outputs estimated location~~.		File:Stereo_visual_odometry_screenshot.jpg\|Screenshot from visual odometry demonstration. Red squares are camera locations and colorized dots are part of sparse reconstruction used to estimate motion.
	</gallery>		</gallery>
	</center>		</center>

Peter at 05:30, 18 May 2020

2020-05-18T05:30:50Z

← Older revision		Revision as of 05:30, 18 May 2020
Line 7:		Line 7:
	Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.		Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.36/examples/main/java~~/src~~/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.36/examples/src/main/java/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]

	Concepts:		Concepts:

Peter at 05:28, 18 May 2020

2020-05-18T05:28:15Z

← Older revision		Revision as of 05:28, 18 May 2020
Line 7:		Line 7:
	Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.		Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.32/examples/src/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.36/examples/main/java/src/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]

	Concepts:		Concepts:
Line 46:		Line 46:
	new File(directory,"right.mjpeg").getPath(), ImageType.single(GrayU8.class));		new File(directory,"right.mjpeg").getPath(), ImageType.single(GrayU8.class));

	// ~~specify~~ how ~~the image features are going to be tracked~~		// Specify which tracker and how it will behave
	~~PkltConfig~~ configKlt = new ~~PkltConfig~~();		var configKlt = new ConfigPKlt();
	configKlt.~~pyramidScaling~~ = ~~new int[]{1, 2,~~ 4~~, 8}~~;		configKlt.pyramidLevels = ConfigDiscreteLevels.levels(4);
	configKlt.templateRadius = 3;		configKlt.templateRadius = 4;
			configKlt.toleranceFB = 3;
			configKlt.pruneClose = true;

	~~PointTrackerTwoPass<GrayU8> tracker~~ =		var configDet = new ConfigPointDetector();
	~~FactoryPointTrackerTwoPass.klt(configKlt,~~ new ~~ConfigGeneralDetector~~(~~600, 3, 1~~),		configDet.type = PointDetectorTypes.SHI_TOMASI;
	~~GrayU8~~.~~class, GrayS16~~.~~class)~~;		configDet.shiTomasi.radius = 4;
			configDet.general.maxFeatures = 300;
			configDet.general.radius = 5;

	// ~~computes~~ the ~~depth~~ of ~~each point~~		// We will estimate the location of features using block matching stereo
	~~StereoDisparitySparse<GrayU8> disparity~~ =		var configBM = new ConfigDisparityBM();
	~~FactoryStereoDisparity~~.~~regionSparseWta(~~0~~, 150,~~ 3, 3, 30~~, -~~1, true~~, GrayU8.class)~~;		configBM.errorType = DisparityError.CENSUS;
			configBM.disparityMin = 0;
			configBM.disparityRange = 50;
			configBM.regionRadiusX = 3;
			configBM.regionRadiusY = 3;
			configBM.maxPerPixelError = 30;
			configBM.texture = 0.05;
			configBM.validateRtoL = 1;
			configBM.subpixel = true;

	// ~~declares~~ the ~~algorithm~~		// Configurations related to how the structure is chained together frame to frame
	~~StereoVisualOdometry~~<GrayU8> ~~visualOdometry~~ = ~~FactoryVisualOdometry~~.~~stereoDepth~~(~~1.5~~,~~120~~, 2,~~200~~,50,~~true,~~		var configVisOdom = new ConfigVisOdomTrackPnP();
	disparity, tracker, GrayU8.class);		configVisOdom.keyframes.geoMinCoverage = 0.4;
			configVisOdom.ransac.iterations = 200;
			configVisOdom.ransac.inlierThreshold = 1.0;

			// Declare each component then visual odometry
			PointTracker<GrayU8> tracker = FactoryPointTracker.klt(configKlt, configDet,GrayU8.class, GrayS16.class);
			StereoDisparitySparse<GrayU8> disparity = FactoryStereoDisparity.sparseRectifiedBM(configBM, GrayU8.class);
			StereoVisualOdometry<GrayU8> visodom = FactoryVisualOdometry.stereoMonoPnP(configVisOdom,disparity,tracker, GrayU8.class);

			// Optionally dump verbose debugging information to stdout
			// Set<String> configuration = new HashSet<>();
			// configuration.add(VisualOdometry.VERBOSE_RUNTIME);
			// configuration.add(VisualOdometry.VERBOSE_TRACKING);
			// visodom.setVerbose(System.out,configuration);

	// Pass in intrinsic/extrinsic calibration. This can be changed in the future.		// Pass in intrinsic/extrinsic calibration. This can be changed in the future.
	~~visualOdometry~~.setCalibration(stereoParam);		visodom.setCalibration(stereoParam);

	// Process the video sequence and output the location plus number of inliers		// Process the video sequence and output the location plus number of inliers
			long startTime = System.nanoTime();
	while( video1.hasNext() ) {		while( video1.hasNext() ) {
	GrayU8 left = video1.next();		GrayU8 left = video1.next();
	GrayU8 right = video2.next();		GrayU8 right = video2.next();

	if( !~~visualOdometry~~.process(left,right) ) {		if( !visodom.process(left,right) ) {
	throw new RuntimeException("VO Failed!");		throw new RuntimeException("VO Failed!");
	}		}

	Se3_F64 leftToWorld = ~~visualOdometry~~.getCameraToWorld();		Se3_F64 leftToWorld = visodom.getCameraToWorld();
	Vector3D_F64 T = leftToWorld.getT();		Vector3D_F64 T = leftToWorld.getT();

	System.out.printf("Location %8.2f %8.2f %8.2f ~~inliers~~ %s\n", T.x, T.y, T.z, ~~inlierPercent~~(~~visualOdometry~~));		System.out.printf("Location %8.2f %8.2f %8.2f %s\n", T.x, T.y, T.z, trackStats(visodom));
	}		}
			System.out.printf("FPS %4.2f\n", video1.getFrameNumber()/((System.nanoTime()-startTime)*1e-9));
	}		}

	/**		/**
	* If the algorithm implements AccessPointTracks3D~~, then count the number of inlier features~~		* If the algorithm implements AccessPointTracks3D create a string which summarizing different tracking information
	* and return a string.
	*/		*/
	public static String ~~inlierPercent~~(StereoVisualOdometry alg) {		public static String trackStats(StereoVisualOdometry alg) {
	if( !(alg instanceof AccessPointTracks3D))		if( !(alg instanceof AccessPointTracks3D))
	return "";		return "";
Line 93:		Line 119:

	int count = 0;		int count = 0;
	int N = access.~~getAllTracks().size~~();		int N = access.getTotalTracks();
			int totalNew = 0;
	for( int i = 0; i < N; i++ ) {		for( int i = 0; i < N; i++ ) {
	if( access.~~isInlier~~(i) )		if( access.isTrackInlier(i) )
	count++;		count++;
			else if( access.isTrackNew(i) ) {
			totalNew++;
			}
	}		}

	return String.format("%%%~~5.3f~~", 100.0 * count / N);		return String.format("inlier %5.1f%% new %4d total %d", 100.0 * count / (N-totalNew),totalNew,N);
	}		}
	}		}
	</syntaxhighlight>		</syntaxhighlight>

Peter at 04:04, 27 December 2018

2018-12-27T04:04:25Z

← Older revision		Revision as of 04:04, 27 December 2018
Line 7:		Line 7:
	Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.		Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.25/examples/src/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.32/examples/src/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]

	Concepts:		Concepts:
Line 40:		Line 40:

	// load camera description and the video sequence		// load camera description and the video sequence
	StereoParameters stereoParam = CalibrationIO.load(media.openFile(directory + "stereo.yaml"));		StereoParameters stereoParam = CalibrationIO.load(media.openFile(new File(directory , "stereo.yaml").getPath()));
	SimpleImageSequence<GrayU8> video1 = media.openVideo(directory + "left.mjpeg", ImageType.single(GrayU8.class));		SimpleImageSequence<GrayU8> video1 = media.openVideo(
	SimpleImageSequence<GrayU8> video2 = media.openVideo(directory+"right.mjpeg", ImageType.single(GrayU8.class));		new File(directory , "left.mjpeg").getPath(), ImageType.single(GrayU8.class));
			SimpleImageSequence<GrayU8> video2 = media.openVideo(
			new File(directory,"right.mjpeg").getPath(), ImageType.single(GrayU8.class));

	// specify how the image features are going to be tracked		// specify how the image features are going to be tracked

Peter at 04:08, 8 December 2016

2016-12-08T04:08:26Z

← Older revision		Revision as of 04:08, 8 December 2016
Line 1:		Line 1:
	<center>		<center>
	<gallery widths=758px heights=384px >		<gallery widths=758px heights=384px >
	File:Stereo_visual_odometry_screenshot.jpg\|Screenshot from visual odometry ~~applet~~. Example just outputs estimated location.		File:Stereo_visual_odometry_screenshot.jpg\|Screenshot from visual odometry demonstration. Example just outputs estimated location.
	</gallery>		</gallery>
	</center>		</center>

	Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are ~~inheritly~~ more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual ~~odometyr~~ algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.		Stereo visual odometry estimates the camera's egomotion using a pair of calibrated cameras. Stereo camera systems are inherently more stable than monocular ones because the stereo pair provides good triangulation of image features and resolves the scale ambiguity. The example below shows how to use a high level interface with visual odometry algorithms. The basic high level interface hides internal data structures which are useful in many applications, which is why an optional interface is provided for accessing some of those structures.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.25/examples/src/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.25/examples/src/boofcv/examples/sfm/ExampleVisualOdometryStereo.java ExampleVisualOdometryStereo.java]