Example Fundamental Matrix - Revision history

Peter at 00:31, 18 January 2022

2022-01-18T00:31:04Z

← Older revision		Revision as of 00:31, 18 January 2022
Line 8:		Line 8:
	The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.		The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.

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

	Concepts:		Concepts:
Line 46:		Line 46:
	public static DMatrixRMaj robustFundamental( List<AssociatedPair> matches,		public static DMatrixRMaj robustFundamental( List<AssociatedPair> matches,
	List<AssociatedPair> inliers, double inlierThreshold ) {		List<AssociatedPair> inliers, double inlierThreshold ) {
	~~ConfigRansac~~ configRansac = new ConfigRansac();		var configRansac = new ConfigRansac();
	configRansac.inlierThreshold = inlierThreshold;		configRansac.inlierThreshold = inlierThreshold;
	configRansac.iterations = 1000;		configRansac.iterations = 1000;
Line 68:		Line 68:

	// Improve the estimate of the fundamental matrix using non-linear optimization		// Improve the estimate of the fundamental matrix using non-linear optimization
	~~DMatrixRMaj~~ F = new DMatrixRMaj(3, 3);		var F = new DMatrixRMaj(3, 3);
	ModelFitter<DMatrixRMaj, AssociatedPair> refine =		ModelFitter<DMatrixRMaj, AssociatedPair> refine =
	FactoryMultiView.fundamentalRefine(1e-8, 400, EpipolarError.SAMPSON);		FactoryMultiView.fundamentalRefine(1e-8, 400, EpipolarError.SAMPSON);
Line 87:		Line 87:
	Estimate1ofEpipolar estimateF = FactoryMultiView.fundamental_1(EnumFundamental.LINEAR_8, 0);		Estimate1ofEpipolar estimateF = FactoryMultiView.fundamental_1(EnumFundamental.LINEAR_8, 0);

	~~DMatrixRMaj~~ F = new DMatrixRMaj(3, 3);		var F = new DMatrixRMaj(3, 3);
	if (!estimateF.process(matches, F))		if (!estimateF.process(matches, F))
	throw new IllegalArgumentException("Failed");		throw new IllegalArgumentException("Failed");
Line 101:		Line 101:
	*/		*/
	public static List<AssociatedPair> computeMatches( BufferedImage left, BufferedImage right ) {		public static List<AssociatedPair> computeMatches( BufferedImage left, BufferedImage right ) {
	DetectDescribePoint detDesc = FactoryDetectDescribe.surfStable(		DetectDescribePoint<GrayF32, TupleDesc_F64> detDesc = FactoryDetectDescribe.surfStable(
	new ConfigFastHessian(0, 2, 400, 1, 9, 4, 4), null, null, GrayF32.class);		new ConfigFastHessian(0, 2, 400, 1, 9, 4, 4), null, null, GrayF32.class);
	// DetectDescribePoint detDesc = FactoryDetectDescribe.sift(null,new ConfigSiftDetector(2,0,200,5),null,null);		// DetectDescribePoint detDesc = FactoryDetectDescribe.sift(null,new ConfigSiftDetector(2,0,200,5),null,null);
Line 108:		Line 108:
	AssociateDescription<TupleDesc_F64> associate = FactoryAssociation.greedy(new ConfigAssociateGreedy(true, 0.1), scorer);		AssociateDescription<TupleDesc_F64> associate = FactoryAssociation.greedy(new ConfigAssociateGreedy(true, 0.1), scorer);

	~~ExampleAssociatePoints<GrayF32, TupleDesc_F64>~~ findMatches =		var findMatches = new ExampleAssociatePoints<>(detDesc, associate, GrayF32.class);
	new ExampleAssociatePoints<>(detDesc, associate, GrayF32.class);

	findMatches.associate(left, right);		findMatches.associate(left, right);
Line 118:		Line 117:
	for (int i = 0; i < matchIndexes.size; i++) {		for (int i = 0; i < matchIndexes.size; i++) {
	AssociatedIndex a = matchIndexes.get(i);		AssociatedIndex a = matchIndexes.get(i);
	~~AssociatedPair~~ p = new AssociatedPair(findMatches.pointsA.get(a.src), findMatches.pointsB.get(a.dst));		var p = new AssociatedPair(findMatches.pointsA.get(a.src), findMatches.pointsB.get(a.dst));
	matches.add(p);		matches.add(p);
	}		}
Line 152:		Line 151:

	// display the inlier matches found using the robust estimator		// display the inlier matches found using the robust estimator
	~~AssociationPanel~~ panel = new AssociationPanel(20);		var panel = new AssociationPanel(20);
	panel.setAssociation(inliers);		panel.setAssociation(inliers);
	panel.setImages(imageA, imageB);		panel.setImages(imageA, imageB);

Peter at 20:08, 12 July 2021

2021-07-12T20:08:03Z

← Older revision		Revision as of 20:08, 12 July 2021
Line 8:		Line 8:
	The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.		The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.

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

	Concepts:		Concepts:
Line 36:		Line 36:
	* @author Peter Abeles		* @author Peter Abeles
	*/		*/
	public class ~~ExampleFundamentalMatrix~~ {		public class ExampleComputeFundamentalMatrix {
	/**		/**
	* Given a set of noisy observations, compute the Fundamental matrix while removing the noise.		* Given a set of noisy observations, compute the Fundamental matrix while removing the noise.

Peter at 02:47, 22 December 2020

2020-12-22T02:47:11Z

Peter at 05:32, 18 May 2020

2020-05-18T05:32:06Z

← Older revision		Revision as of 05:32, 18 May 2020
Line 8:		Line 8:
	The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.		The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.

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

	Concepts:		Concepts:
Line 17:		Line 17:
	Related Examples:		Related Examples:
	* [[Example_Remove_Lens_Distortion\| Removing Lens Distortion]]		* [[Example_Remove_Lens_Distortion\| Removing Lens Distortion]]
	* [[Example_Rectification_Uncalibrated\| Rectify Uncalibrated Stereo Pair]]

	= Example Code =		= Example Code =
Line 52:		Line 51:
	ConfigRansac configRansac = new ConfigRansac();		ConfigRansac configRansac = new ConfigRansac();
	configRansac.inlierThreshold = inlierThreshold;		configRansac.inlierThreshold = inlierThreshold;
	configRansac.~~maxIterations~~ = 1000;		configRansac.iterations = 1000;
	ConfigFundamental configFundamental = new ConfigFundamental();		ConfigFundamental configFundamental = new ConfigFundamental();
	configFundamental.which = EnumFundamental.LINEAR_7;		configFundamental.which = EnumFundamental.LINEAR_7;
Line 110:		Line 109:

	ScoreAssociation<BrightFeature> scorer = FactoryAssociation.scoreEuclidean(BrightFeature.class,true);		ScoreAssociation<BrightFeature> scorer = FactoryAssociation.scoreEuclidean(BrightFeature.class,true);
	AssociateDescription<BrightFeature> associate = FactoryAssociation.greedy(~~scorer~~, 0.1, ~~true~~);		AssociateDescription<BrightFeature> associate = FactoryAssociation.greedy(new ConfigAssociateGreedy(true,0.1),scorer);

	ExampleAssociatePoints<GrayF32,BrightFeature> findMatches =		ExampleAssociatePoints<GrayF32,BrightFeature> findMatches =
Line 118:		Line 117:

	List<AssociatedPair> matches = new ArrayList<>();		List<AssociatedPair> matches = new ArrayList<>();
	~~FastQueue~~<AssociatedIndex> matchIndexes = associate.getMatches();		FastAccess<AssociatedIndex> matchIndexes = associate.getMatches();

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

Peter at 04:05, 27 December 2018

2018-12-27T04:05:20Z

← Older revision		Revision as of 04:05, 27 December 2018
Line 8:		Line 8:
	The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.		The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.31/examples/src/main/java/boofcv/examples/stereo/ExampleFundamentalMatrix.java ExampleFundamentalMatrix.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.32/examples/src/main/java/boofcv/examples/stereo/ExampleFundamentalMatrix.java ExampleFundamentalMatrix.java]

	Concepts:		Concepts:
Line 48:		Line 48:
	*/		*/
	public static DMatrixRMaj robustFundamental( List<AssociatedPair> matches ,		public static DMatrixRMaj robustFundamental( List<AssociatedPair> matches ,
	List<AssociatedPair> inliers ) {		List<AssociatedPair> inliers , double inlierThreshold ) {

	ConfigRansac configRansac = new ConfigRansac();		ConfigRansac configRansac = new ConfigRansac();
	configRansac.inlierThreshold = ~~0.2~~;		configRansac.inlierThreshold = inlierThreshold;
	configRansac.maxIterations = ~~2000~~;		configRansac.maxIterations = 1000;
	ConfigFundamental configFundamental = new ConfigFundamental();		ConfigFundamental configFundamental = new ConfigFundamental();
	configFundamental.which = EnumFundamental.LINEAR_7;		configFundamental.which = EnumFundamental.LINEAR_7;
	configFundamental.numResolve = 2;		configFundamental.numResolve = 2;
			configFundamental.errorModel = ConfigFundamental.ErrorModel.GEOMETRIC;
			// geometric error is the most accurate error metric, but also the slowest to compute. See how the
			// results change if you switch to sampson and how much faster it is. You also should adjust
			// the inlier threshold.

	~~Ransac~~<DMatrixRMaj, AssociatedPair> ransac =		ModelMatcher<DMatrixRMaj, AssociatedPair> ransac =
	FactoryMultiViewRobust.fundamentalRansac(configFundamental,configRansac);		FactoryMultiViewRobust.fundamentalRansac(configFundamental,configRansac);

Line 102:		Line 106:
	public static List<AssociatedPair> computeMatches( BufferedImage left , BufferedImage right ) {		public static List<AssociatedPair> computeMatches( BufferedImage left , BufferedImage right ) {
	DetectDescribePoint detDesc = FactoryDetectDescribe.surfStable(		DetectDescribePoint detDesc = FactoryDetectDescribe.surfStable(
	new ConfigFastHessian(1, 2, ~~200~~, 1, 9, 4, 4), null,null, GrayF32.class);		new ConfigFastHessian(0, 2, 400, 1, 9, 4, 4), null,null, GrayF32.class);
	// DetectDescribePoint detDesc = FactoryDetectDescribe.sift(null,new ConfigSiftDetector(2,0,200,5),null,null);		// DetectDescribePoint detDesc = FactoryDetectDescribe.sift(null,new ConfigSiftDetector(2,0,200,5),null,null);

Line 142:		Line 146:
	// The results should be difference since there are many false associations in the simple model		// The results should be difference since there are many false associations in the simple model
	// Also note that the fundamental matrix is only defined up to a scale factor.		// Also note that the fundamental matrix is only defined up to a scale factor.
	F = robustFundamental(matches, inliers);		F = robustFundamental(matches, inliers, 0.5);
	System.out.println("Robust");		System.out.println("Robust");
	CommonOps_DDRM.divide(F, NormOps_DDRM.normF(F)); // scale to make comparision easier		CommonOps_DDRM.divide(F, NormOps_DDRM.normF(F)); // scale to make comparision easier

Peter at 03:05, 17 October 2018

2018-10-17T03:05:00Z

← Older revision		Revision as of 03:05, 17 October 2018
Line 8:		Line 8:
	The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.		The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.27/examples/src/boofcv/examples/stereo/ExampleFundamentalMatrix.java ExampleFundamentalMatrix.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.31/examples/src/main/java/boofcv/examples/stereo/ExampleFundamentalMatrix.java ExampleFundamentalMatrix.java]

	Concepts:		Concepts:
Line 50:		Line 50:
	List<AssociatedPair> inliers ) {		List<AssociatedPair> inliers ) {

	~~// used to create and copy new instances of the fit model~~		ConfigRansac configRansac = new ConfigRansac();
	~~ModelManager<DMatrixRMaj> managerF~~ = new ~~ModelManagerEpipolarMatrix~~();		configRansac.inlierThreshold = 0.2;
	~~// Select which linear algorithm is to be used~~. ~~Try playing with the number of remove ambiguity points~~		configRansac.maxIterations = 2000;
	~~Estimate1ofEpipolar estimateF~~ = ~~FactoryMultiView~~.~~computeFundamental_1(EnumFundamental.LINEAR_7,~~ 2);		ConfigFundamental configFundamental = new ConfigFundamental();
	~~// Wrapper so that this estimator can be used by the robust estimator~~		configFundamental.which = EnumFundamental.LINEAR_7;
	~~GenerateEpipolarMatrix generateF~~ = new ~~GenerateEpipolarMatrix~~(~~estimateF~~);		configFundamental.numResolve = 2;

	~~// How the error is measured~~		Ransac<DMatrixRMaj, AssociatedPair> ransac =
	~~DistanceFromModelResidual~~<DMatrixRMaj,AssociatedPair> ~~errorMetric~~ =		FactoryMultiViewRobust.fundamentalRansac(configFundamental,configRansac);
	~~new DistanceFromModelResidual<>(new FundamentalResidualSampson());~~

	~~// Use RANSAC to estimate the Fundamental matrix~~
	~~ModelMatcher<DMatrixRMaj,AssociatedPair> robustF =~~
	~~new Ransac<>~~(~~123123, managerF, generateF, errorMetric~~, ~~6000, 0.1~~);

	// Estimate the fundamental matrix while removing outliers		// Estimate the fundamental matrix while removing outliers
	if( !~~robustF~~.process(matches) )		if( !ransac.process(matches) )
	throw new IllegalArgumentException("Failed");		throw new IllegalArgumentException("Failed");

	// save the set of features that were used to compute the fundamental matrix		// save the set of features that were used to compute the fundamental matrix
	inliers.addAll(~~robustF~~.getMatchSet());		inliers.addAll(ransac.getMatchSet());

	// Improve the estimate of the fundamental matrix using non-linear optimization		// Improve the estimate of the fundamental matrix using non-linear optimization
	DMatrixRMaj F = new DMatrixRMaj(3,3);		DMatrixRMaj F = new DMatrixRMaj(3,3);
	ModelFitter<DMatrixRMaj,AssociatedPair> refine =		ModelFitter<DMatrixRMaj,AssociatedPair> refine =
	FactoryMultiView.~~refineFundamental~~(1e-8, 400, EpipolarError.SAMPSON);		FactoryMultiView.fundamentalRefine(1e-8, 400, EpipolarError.SAMPSON);
	if( !refine.fitModel(inliers, ~~robustF~~.getModelParameters(), F) )		if( !refine.fitModel(inliers, ransac.getModelParameters(), F) )
	throw new IllegalArgumentException("Failed");		throw new IllegalArgumentException("Failed");

Line 90:		Line 85:
	public static DMatrixRMaj simpleFundamental( List<AssociatedPair> matches ) {		public static DMatrixRMaj simpleFundamental( List<AssociatedPair> matches ) {
	// Use the 8-point algorithm since it will work with an arbitrary number of points		// Use the 8-point algorithm since it will work with an arbitrary number of points
	Estimate1ofEpipolar estimateF = FactoryMultiView.~~computeFundamental_1~~(EnumFundamental.LINEAR_8, 0);		Estimate1ofEpipolar estimateF = FactoryMultiView.fundamental_1(EnumFundamental.LINEAR_8, 0);

	DMatrixRMaj F = new DMatrixRMaj(3,3);		DMatrixRMaj F = new DMatrixRMaj(3,3);
Line 111:		Line 106:

	ScoreAssociation<BrightFeature> scorer = FactoryAssociation.scoreEuclidean(BrightFeature.class,true);		ScoreAssociation<BrightFeature> scorer = FactoryAssociation.scoreEuclidean(BrightFeature.class,true);
	AssociateDescription<BrightFeature> associate = FactoryAssociation.greedy(scorer, 1, true);		AssociateDescription<BrightFeature> associate = FactoryAssociation.greedy(scorer, 0.1, true);

	ExampleAssociatePoints<GrayF32,BrightFeature> findMatches =		ExampleAssociatePoints<GrayF32,BrightFeature> findMatches =
Line 149:		Line 144:
	F = robustFundamental(matches, inliers);		F = robustFundamental(matches, inliers);
	System.out.println("Robust");		System.out.println("Robust");
			CommonOps_DDRM.divide(F, NormOps_DDRM.normF(F)); // scale to make comparision easier
	F.print();		F.print();

	F = simpleFundamental(matches);		F = simpleFundamental(matches);
	System.out.println("Simple");		System.out.println("Simple");
			CommonOps_DDRM.divide(F, NormOps_DDRM.normF(F));
	F.print();		F.print();

Peter at 16:14, 17 August 2017

2017-08-17T16:14:26Z

Peter at 00:59, 2 December 2016

2016-12-02T00:59:55Z

← Older revision		Revision as of 00:59, 2 December 2016
Line 8:		Line 8:
	The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.		The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.

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

	Concepts:		Concepts:
Line 14:		Line 14:
	* Fundamental matrix		* Fundamental matrix
	* Stereo Vision		* Stereo Vision

	~~Relevant Applets:~~
	* [[Applet_Calibrate_Planar_Mono\| Monocular Camera Calibration]]

	Related Examples:		Related Examples:
Line 62:		Line 59:
	// How the error is measured		// How the error is measured
	DistanceFromModelResidual<DenseMatrix64F,AssociatedPair> errorMetric =		DistanceFromModelResidual<DenseMatrix64F,AssociatedPair> errorMetric =
	new DistanceFromModelResidual<~~DenseMatrix64F,AssociatedPair~~>(new FundamentalResidualSampson());		new DistanceFromModelResidual<>(new FundamentalResidualSampson());

	// Use RANSAC to estimate the Fundamental matrix		// Use RANSAC to estimate the Fundamental matrix
	ModelMatcher<DenseMatrix64F,AssociatedPair> robustF =		ModelMatcher<DenseMatrix64F,AssociatedPair> robustF =
	new Ransac<~~DenseMatrix64F, AssociatedPair~~>(123123,managerF,generateF,errorMetric,6000,0.1);		new Ransac<>(123123, managerF, generateF, errorMetric, 6000, 0.1);

	// Estimate the fundamental matrix while removing outliers		// Estimate the fundamental matrix while removing outliers
Line 117:		Line 114:

	ExampleAssociatePoints<GrayF32,BrightFeature> findMatches =		ExampleAssociatePoints<GrayF32,BrightFeature> findMatches =
	new ExampleAssociatePoints<~~GrayF32,BrightFeature~~> (detDesc, associate, GrayF32.class);		new ExampleAssociatePoints<>(detDesc, associate, GrayF32.class);

	findMatches.associate(left,right);		findMatches.associate(left,right);

	List<AssociatedPair> matches = new ArrayList<~~AssociatedPair~~>();		List<AssociatedPair> matches = new ArrayList<>();
	FastQueue<AssociatedIndex> matchIndexes = associate.getMatches();		FastQueue<AssociatedIndex> matchIndexes = associate.getMatches();

Line 145:		Line 142:
	DenseMatrix64F F;		DenseMatrix64F F;
	// List of matches that matched the model		// List of matches that matched the model
	List<AssociatedPair> inliers = new ArrayList<~~AssociatedPair~~>();		List<AssociatedPair> inliers = new ArrayList<>();

	// estimate and print the results using a robust and simple estimator		// estimate and print the results using a robust and simple estimator

Peter at 05:47, 28 March 2016

2016-03-28T05:47:09Z

← Older revision		Revision as of 05:47, 28 March 2016
Line 8:		Line 8:
	The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.		The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.

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

	Concepts:		Concepts:
Line 110:		Line 110:
	public static List<AssociatedPair> computeMatches( BufferedImage left , BufferedImage right ) {		public static List<AssociatedPair> computeMatches( BufferedImage left , BufferedImage right ) {
	DetectDescribePoint detDesc = FactoryDetectDescribe.surfStable(		DetectDescribePoint detDesc = FactoryDetectDescribe.surfStable(
	new ConfigFastHessian(1, 2, 200, 1, 9, 4, 4), null,null, ~~ImageFloat32~~.class);		new ConfigFastHessian(1, 2, 200, 1, 9, 4, 4), null,null, GrayF32.class);
	// DetectDescribePoint detDesc = FactoryDetectDescribe.sift(null,new ConfigSiftDetector(2,0,200,5),null,null);		// DetectDescribePoint detDesc = FactoryDetectDescribe.sift(null,new ConfigSiftDetector(2,0,200,5),null,null);

Line 116:		Line 116:
	AssociateDescription<BrightFeature> associate = FactoryAssociation.greedy(scorer, 1, true);		AssociateDescription<BrightFeature> associate = FactoryAssociation.greedy(scorer, 1, true);

	ExampleAssociatePoints<~~ImageFloat32~~,BrightFeature> findMatches =		ExampleAssociatePoints<GrayF32,BrightFeature> findMatches =
	new ExampleAssociatePoints<~~ImageFloat32~~,BrightFeature> (detDesc, associate, ~~ImageFloat32~~.class);		new ExampleAssociatePoints<GrayF32,BrightFeature> (detDesc, associate, GrayF32.class);

	findMatches.associate(left,right);		findMatches.associate(left,right);

Peter at 05:11, 24 January 2016

2016-01-24T05:11:00Z

← Older revision		Revision as of 05:11, 24 January 2016
Line 8:		Line 8:
	The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.		The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.

	Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.20/examples/src/boofcv/examples/stereo/ExampleFundamentalMatrix.java ExampleFundamentalMatrix.java]		Example File: [https://github.com/lessthanoptimal/BoofCV/blob/v0.21/examples/src/boofcv/examples/stereo/ExampleFundamentalMatrix.java ExampleFundamentalMatrix.java]

	Concepts:		Concepts:
Line 113:		Line 113:
	// DetectDescribePoint detDesc = FactoryDetectDescribe.sift(null,new ConfigSiftDetector(2,0,200,5),null,null);		// DetectDescribePoint detDesc = FactoryDetectDescribe.sift(null,new ConfigSiftDetector(2,0,200,5),null,null);

	ScoreAssociation<~~SurfFeature~~> scorer = FactoryAssociation.scoreEuclidean(~~SurfFeature~~.class,true);		ScoreAssociation<BrightFeature> scorer = FactoryAssociation.scoreEuclidean(BrightFeature.class,true);
	AssociateDescription<~~SurfFeature~~> associate = FactoryAssociation.greedy(scorer, 1, true);		AssociateDescription<BrightFeature> associate = FactoryAssociation.greedy(scorer, 1, true);

	ExampleAssociatePoints<ImageFloat32,~~SurfFeature~~> findMatches =		ExampleAssociatePoints<ImageFloat32,BrightFeature> findMatches =
	new ExampleAssociatePoints<ImageFloat32,~~SurfFeature~~> (detDesc, associate, ImageFloat32.class);		new ExampleAssociatePoints<ImageFloat32,BrightFeature> (detDesc, associate, ImageFloat32.class);

	findMatches.associate(left,right);		findMatches.associate(left,right);

← Older revision		Revision as of 02:47, 22 December 2020
Line 8:		Line 8:
	The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.		The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.

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

	Concepts:		Concepts:
Line 22:		Line 22:
	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">
	/**		/**
	* A Fundamental matrix describes the epipolar relationship between two images. If two points, one from		* A Fundamental matrix describes the epipolar relationship between two images. If two points, one from
	* each image, match, then the inner product around the Fundamental matrix will be zero. If a fundamental		* each image, match, then the inner product around the Fundamental matrix will be zero. If a fundamental
	* matrix is known, then information about the scene and its structure can be extracted.		* matrix is known, then information about the scene and its structure can be extracted.
	*		*
	* Below are two examples of how a Fundamental matrix can be computed using different.		* Below are two examples of how a Fundamental matrix can be computed using different.
	* The robust technique attempts to find the best fit Fundamental matrix to the data while removing noisy		* The robust technique attempts to find the best fit Fundamental matrix to the data while removing noisy
	* matches, The simple version just assumes that all the matches are correct. Similar techniques can be used		* matches, The simple version just assumes that all the matches are correct. Similar techniques can be used
	* to fit various other types of motion or structural models to observations.		* to fit various other types of motion or structural models to observations.
	*		*
	* The input image and associated features are displayed in a window. In another window, inlier features		* The input image and associated features are displayed in a window. In another window, inlier features
	* from robust model fitting are shown.		* from robust model fitting are shown.
	*		*
Line 37:		Line 37:
	*/		*/
	public class ExampleFundamentalMatrix {		public class ExampleFundamentalMatrix {

	/**		/**
	* Given a set of noisy observations, compute the Fundamental matrix while removing		* Given a set of noisy observations, compute the Fundamental matrix while removing the noise.
	* the noise.
	*		*
	* @param matches List of associated features between the two images		* @param matches List of associated features between the two images
Line 46:		Line 44:
	* @return The found fundamental matrix.		* @return The found fundamental matrix.
	*/		*/
	public static DMatrixRMaj robustFundamental( List<AssociatedPair> matches ,		public static DMatrixRMaj robustFundamental( List<AssociatedPair> matches,
	List<AssociatedPair> inliers , double inlierThreshold ) {		List<AssociatedPair> inliers, double inlierThreshold ) {

	ConfigRansac configRansac = new ConfigRansac();		ConfigRansac configRansac = new ConfigRansac();
	configRansac.inlierThreshold = inlierThreshold;		configRansac.inlierThreshold = inlierThreshold;
Line 61:		Line 58:

	ModelMatcher<DMatrixRMaj, AssociatedPair> ransac =		ModelMatcher<DMatrixRMaj, AssociatedPair> ransac =
	FactoryMultiViewRobust.fundamentalRansac(configFundamental,configRansac);		FactoryMultiViewRobust.fundamentalRansac(configFundamental, configRansac);

	// Estimate the fundamental matrix while removing outliers		// Estimate the fundamental matrix while removing outliers
	if( !ransac.process(matches) )		if (!ransac.process(matches))
	throw new IllegalArgumentException("Failed");		throw new IllegalArgumentException("Failed");

Line 71:		Line 68:

	// Improve the estimate of the fundamental matrix using non-linear optimization		// Improve the estimate of the fundamental matrix using non-linear optimization
	DMatrixRMaj F = new DMatrixRMaj(3,3);		DMatrixRMaj F = new DMatrixRMaj(3, 3);
	ModelFitter<DMatrixRMaj,AssociatedPair> refine =		ModelFitter<DMatrixRMaj, AssociatedPair> refine =
	FactoryMultiView.fundamentalRefine(1e-8, 400, EpipolarError.SAMPSON);		FactoryMultiView.fundamentalRefine(1e-8, 400, EpipolarError.SAMPSON);
	if( !refine.fitModel(inliers, ransac.getModelParameters(), F) )		if (!refine.fitModel(inliers, ransac.getModelParameters(), F))
	throw new IllegalArgumentException("Failed");		throw new IllegalArgumentException("Failed");

Line 83:		Line 80:
	/**		/**
	* If the set of associated features are known to be correct, then the fundamental matrix can		* If the set of associated features are known to be correct, then the fundamental matrix can
	* be computed directly with a lot less code. The down side is that this technique is very		* be computed directly with a lot less code. The down side is that this technique is very
	* sensitive to noise.		* sensitive to noise.
	*/		*/
Line 90:		Line 87:
	Estimate1ofEpipolar estimateF = FactoryMultiView.fundamental_1(EnumFundamental.LINEAR_8, 0);		Estimate1ofEpipolar estimateF = FactoryMultiView.fundamental_1(EnumFundamental.LINEAR_8, 0);

	DMatrixRMaj F = new DMatrixRMaj(3,3);		DMatrixRMaj F = new DMatrixRMaj(3, 3);
	if( !estimateF.process(matches,F) )		if (!estimateF.process(matches, F))
	throw new IllegalArgumentException("Failed");		throw new IllegalArgumentException("Failed");

Line 103:		Line 100:
	* fundamental matrix.		* fundamental matrix.
	*/		*/
	public static List<AssociatedPair> computeMatches( BufferedImage left , BufferedImage right ) {		public static List<AssociatedPair> computeMatches( BufferedImage left, BufferedImage right ) {
	DetectDescribePoint detDesc = FactoryDetectDescribe.surfStable(		DetectDescribePoint detDesc = FactoryDetectDescribe.surfStable(
	new ConfigFastHessian(0, 2, 400, 1, 9, 4, 4), null,null, GrayF32.class);		new ConfigFastHessian(0, 2, 400, 1, 9, 4, 4), null, null, GrayF32.class);
	// DetectDescribePoint detDesc = FactoryDetectDescribe.sift(null,new ConfigSiftDetector(2,0,200,5),null,null);		// DetectDescribePoint detDesc = FactoryDetectDescribe.sift(null,new ConfigSiftDetector(2,0,200,5),null,null);

	ScoreAssociation<~~BrightFeature~~> scorer = FactoryAssociation.scoreEuclidean(~~BrightFeature~~.class,true);		ScoreAssociation<TupleDesc_F64> scorer = FactoryAssociation.scoreEuclidean(TupleDesc_F64.class, true);
	AssociateDescription<~~BrightFeature~~> associate = FactoryAssociation.greedy(new ConfigAssociateGreedy(true,0.1),scorer);		AssociateDescription<TupleDesc_F64> associate = FactoryAssociation.greedy(new ConfigAssociateGreedy(true, 0.1), scorer);

	ExampleAssociatePoints<GrayF32,~~BrightFeature~~> findMatches =		ExampleAssociatePoints<GrayF32, TupleDesc_F64> findMatches =
	new ExampleAssociatePoints<>(detDesc, associate, GrayF32.class);		new ExampleAssociatePoints<>(detDesc, associate, GrayF32.class);

	findMatches.associate(left,right);		findMatches.associate(left, right);

	List<AssociatedPair> matches = new ArrayList<>();		List<AssociatedPair> matches = new ArrayList<>();
	FastAccess<AssociatedIndex> matchIndexes = associate.getMatches();		FastAccess<AssociatedIndex> matchIndexes = associate.getMatches();

	for( int i = 0; i < matchIndexes.size; i++ ) {		for (int i = 0; i < matchIndexes.size; i++) {
	AssociatedIndex a = matchIndexes.get(i);		AssociatedIndex a = matchIndexes.get(i);
	AssociatedPair p = new AssociatedPair(findMatches.pointsA.get(a.src) , findMatches.pointsB.get(a.dst));		AssociatedPair p = new AssociatedPair(findMatches.pointsA.get(a.src), findMatches.pointsB.get(a.dst));
	matches.add( p);		matches.add(p);
	}		}

Line 128:		Line 125:
	}		}

	public static void main( String ~~args~~[] ) {		public static void main( String[] args ) {

	String dir = UtilIO.pathExample("structure/");		String dir = UtilIO.pathExample("structure/");

	BufferedImage imageA = UtilImageIO.loadImage(dir , "undist_cyto_01.jpg");		BufferedImage imageA = UtilImageIO.loadImage(dir, "undist_cyto_01.jpg");
	BufferedImage imageB = UtilImageIO.loadImage(dir , "undist_cyto_02.jpg");		BufferedImage imageB = UtilImageIO.loadImage(dir, "undist_cyto_02.jpg");

	List<AssociatedPair> matches = computeMatches(imageA,imageB);		List<AssociatedPair> matches = computeMatches(imageA, imageB);

	// Where the fundamental matrix is stored		// Where the fundamental matrix is stored
Line 158:		Line 154:
	AssociationPanel panel = new AssociationPanel(20);		AssociationPanel panel = new AssociationPanel(20);
	panel.setAssociation(inliers);		panel.setAssociation(inliers);
	panel.setImages(imageA,imageB);		panel.setImages(imageA, imageB);

	ShowImages.showWindow(panel, "Inlier Pairs");		ShowImages.showWindow(panel, "Inlier Pairs");

← Older revision		Revision as of 16:14, 17 August 2017
Line 8:		Line 8:
	The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.		The Fundamental matrix is a 3 by 3 matrix which describes the geometric (epipolar) relationship between two images. In the example below, features are automatically found and the fundamental matrix computed using two different techniques. The robust technique uses RANSAC to remove incorrect image pairs (see image above) followed by non-linear optimization. The simple technique assumes that all the image pairs are correct (not true in this scenario) and apply a fast to compute linear algorithm.

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

	Concepts:		Concepts:
Line 47:		Line 47:
	* @return The found fundamental matrix.		* @return The found fundamental matrix.
	*/		*/
	public static ~~DenseMatrix64F~~ robustFundamental( List<AssociatedPair> matches ,		public static DMatrixRMaj robustFundamental( List<AssociatedPair> matches ,
	List<AssociatedPair> inliers ) {		List<AssociatedPair> inliers ) {

	// used to create and copy new instances of the fit model		// used to create and copy new instances of the fit model
	ModelManager<~~DenseMatrix64F~~> managerF = new ModelManagerEpipolarMatrix();		ModelManager<DMatrixRMaj> managerF = new ModelManagerEpipolarMatrix();
	// Select which linear algorithm is to be used. Try playing with the number of remove ambiguity points		// Select which linear algorithm is to be used. Try playing with the number of remove ambiguity points
	Estimate1ofEpipolar estimateF = FactoryMultiView.computeFundamental_1(~~EnumEpipolar~~.~~FUNDAMENTAL_7_LINEAR~~, 2);		Estimate1ofEpipolar estimateF = FactoryMultiView.computeFundamental_1(EnumFundamental.LINEAR_7, 2);
	// Wrapper so that this estimator can be used by the robust estimator		// Wrapper so that this estimator can be used by the robust estimator
	GenerateEpipolarMatrix generateF = new GenerateEpipolarMatrix(estimateF);		GenerateEpipolarMatrix generateF = new GenerateEpipolarMatrix(estimateF);

	// How the error is measured		// How the error is measured
	DistanceFromModelResidual<~~DenseMatrix64F~~,AssociatedPair> errorMetric =		DistanceFromModelResidual<DMatrixRMaj,AssociatedPair> errorMetric =
	new DistanceFromModelResidual<>(new FundamentalResidualSampson());		new DistanceFromModelResidual<>(new FundamentalResidualSampson());

	// Use RANSAC to estimate the Fundamental matrix		// Use RANSAC to estimate the Fundamental matrix
	ModelMatcher<~~DenseMatrix64F~~,AssociatedPair> robustF =		ModelMatcher<DMatrixRMaj,AssociatedPair> robustF =
	new Ransac<>(123123, managerF, generateF, errorMetric, 6000, 0.1);		new Ransac<>(123123, managerF, generateF, errorMetric, 6000, 0.1);

Line 73:		Line 73:

	// Improve the estimate of the fundamental matrix using non-linear optimization		// Improve the estimate of the fundamental matrix using non-linear optimization
	~~DenseMatrix64F~~ F = new ~~DenseMatrix64F~~(3,3);		DMatrixRMaj F = new DMatrixRMaj(3,3);
	ModelFitter<~~DenseMatrix64F~~,AssociatedPair> refine =		ModelFitter<DMatrixRMaj,AssociatedPair> refine =
	FactoryMultiView.refineFundamental(1e-8, 400, EpipolarError.SAMPSON);		FactoryMultiView.refineFundamental(1e-8, 400, EpipolarError.SAMPSON);
	if( !refine.fitModel(inliers, robustF.getModelParameters(), F) )		if( !refine.fitModel(inliers, robustF.getModelParameters(), F) )
Line 88:		Line 88:
	* sensitive to noise.		* sensitive to noise.
	*/		*/
	public static ~~DenseMatrix64F~~ simpleFundamental( List<AssociatedPair> matches ) {		public static DMatrixRMaj simpleFundamental( List<AssociatedPair> matches ) {
	// Use the 8-point algorithm since it will work with an arbitrary number of points		// Use the 8-point algorithm since it will work with an arbitrary number of points
	Estimate1ofEpipolar estimateF = FactoryMultiView.computeFundamental_1(~~EnumEpipolar~~.~~FUNDAMENTAL_8_LINEAR~~, 0);		Estimate1ofEpipolar estimateF = FactoryMultiView.computeFundamental_1(EnumFundamental.LINEAR_8, 0);

	~~DenseMatrix64F~~ F = new ~~DenseMatrix64F~~(3,3);		DMatrixRMaj F = new DMatrixRMaj(3,3);
	if( !estimateF.process(matches,F) )		if( !estimateF.process(matches,F) )
	throw new IllegalArgumentException("Failed");		throw new IllegalArgumentException("Failed");
Line 140:		Line 140:

	// Where the fundamental matrix is stored		// Where the fundamental matrix is stored
	~~DenseMatrix64F~~ F;		DMatrixRMaj F;
	// List of matches that matched the model		// List of matches that matched the model
	List<AssociatedPair> inliers = new ArrayList<>();		List<AssociatedPair> inliers = new ArrayList<>();