Merge branch 'develop' into feature/OptimizedMatches

Author: BCOM\nduong

SolARModuleOpenCV.pri

@@ -11,6 +11,8 @@ HEADERS += interfaces/SolAR2D3DcorrespondencesFinderOpencv.h \
     interfaces/SolARDescriptorMatcherHammingBruteForceOpencv.h \
     interfaces/SolARDescriptorMatcherKNNOpencv.h \
     interfaces/SolARDescriptorMatcherRadiusOpencv.h \
+    interfaces/SolARDescriptorMatcherGeometricOpencv.h \
+    interfaces/SolARDescriptorMatcherRegionOpencv.h \
     interfaces/SolARDescriptorsExtractorAKAZE2Opencv.h \
     interfaces/SolARDescriptorsExtractorAKAZEOpencv.h \
     interfaces/SolARDescriptorsExtractorORBOpencv.h \
@@ -47,6 +49,10 @@ HEADERS += interfaces/SolAR2D3DcorrespondencesFinderOpencv.h \
     interfaces/SolARPoseEstimationSACPnpOpencv.h \
     interfaces/SolARPoseFinderFrom2D2DOpencv.h \
     interfaces/SolARProjectOpencv.h \
+	interfaces/SolARStereo2DPointsRectificationOpencv.h \
+    interfaces/SolARStereoCalibrationOpencv.h \
+    interfaces/SolARStereoDescriptorMatcherOpencv.h \
+    interfaces/SolARStereoImageRectificationOpencv.h \
     interfaces/SolARSVDFundamentalMatrixDecomposerOpencv.h\
     interfaces/SolARUndistortPointsOpencv.h \
     interfaces/SolARUnprojectPlanarPointsOpencv.h \
@@ -77,6 +83,8 @@ SOURCES +=  src/AKAZE2/akaze.cpp \
     src/SolARDescriptorMatcherHammingBruteForceOpencv.cpp \
     src/SolARDescriptorMatcherKNNOpencv.cpp \
     src/SolARDescriptorMatcherRadiusOpencv.cpp \
+    src/SolARDescriptorMatcherGeometricOpencv.cpp \
+    src/SolARDescriptorMatcherRegionOpencv.cpp \
     src/SolARDescriptorsExtractorAKAZE2Opencv.cpp \
     src/SolARDescriptorsExtractorAKAZEOpencv.cpp \
     src/SolARDescriptorsExtractorORBOpencv.cpp \
@@ -111,6 +119,10 @@ SOURCES +=  src/AKAZE2/akaze.cpp \
     src/SolARPoseEstimationSACPnpOpencv.cpp \
     src/SolARPoseFinderFrom2D2DOpencv.cpp \
     src/SolARProjectOpencv.cpp \
+	src/SolARStereo2DPointsRectificationOpencv.cpp \
+    src/SolARStereoCalibrationOpencv.cpp \
+    src/SolARStereoDescriptorMatcherOpencv.cpp \
+    src/SolARStereoImageRectificationOpencv.cpp \
     src/SolARSVDFundamentalMatrixDecomposerOpencv.cpp \
     src/SolARSVDTriangulationOpencv.cpp \
     src/SolARUndistortPointsOpencv.cpp \

SolARModuleOpenCV.pro

@@ -2,11 +2,13 @@
 QT       -= core gui
 CONFIG -= qt
 
+QMAKE_PROJECT_DEPTH = 0
+
 ## global defintions : target lib name, version
 INSTALLSUBDIR = SolARBuild
 TARGET = SolARModuleOpenCV
 FRAMEWORK = $$TARGET
-VERSION=0.9.3
+VERSION=0.10.0
 
 DEFINES += MYVERSION=$${VERSION}
 DEFINES += TEMPLATE_LIBRARY
@@ -59,6 +61,7 @@ macx {
     QMAKE_CXXFLAGS += -mmacosx-version-min=10.7 -std=c11 -std=c++11 -O3 -fPIC#-x objective-c++
     QMAKE_LFLAGS += -mmacosx-version-min=10.7 -v -lstdc++
     LIBS += -lstdc++ -lc -lpthread
+    LIBS += -L/usr/local/lib
 }
 
 win32 {

bcom-SolARModuleOpenCV.pc.in

@@ -5,7 +5,7 @@ libdir=${exec_prefix}/lib
 includedir=${prefix}/interfaces
 Name: SolARModuleOpenCV
 Description:
-Version: 0.9.4
+Version: 0.10.0
 Requires:
 Libs: -L${libdir} -l${libname}
 Libs.private: ${libdir}/${pfx}${libname}.${lext}

interfaces/SolARCameraCalibrationOpencv.h

@@ -21,7 +21,7 @@
 
 #include <string>
 #include "opencv2/videoio.hpp"
-#include "xpcf/component/ComponentBase.h"
+#include "xpcf/component/ConfigurableBase.h"
 
 #include "SolAROpencvAPI.h"
 
@@ -37,93 +37,38 @@ namespace OPENCV {
  */
 
 class SOLAROPENCV_EXPORT_API SolARCameraCalibrationOpencv :
-	public org::bcom::xpcf::ComponentBase,
+	public org::bcom::xpcf::ConfigurableBase,
 	public api::input::devices::ICameraCalibration
 {
 public:
-	enum ProcessMode
-	{
-		SOLAR_DETECT = 0,
-		SOLAR_CAPTURE = 1,
-		SOLAR_CALIBRATED = 2
-	};
+    SolARCameraCalibrationOpencv();
+    ~SolARCameraCalibrationOpencv() override;
+    /// @brief Calibrate the camera device from a sequence of images
+    /// @param[in] images The set of images for calibration
+    /// @param[out] camParams The camera paramters
+    /// @return FrameworkReturnCode::_SUCCESS if calibration succeed, else FrameworkReturnCode::_ERROR_
+    FrameworkReturnCode calibrate(const std::vector<SRef<SolAR::datastructure::Image>>& images,
+                                  SolAR::datastructure::CameraParameters & camParams) override;
 
-public:
-	SolARCameraCalibrationOpencv();
-    virtual ~SolARCameraCalibrationOpencv() override;
-    /// @brief this method calibrates and fixes an unkonwn camera intrinsic parameters from a offline video stream,
-    /// it saves the result calibration file inside output folder.
-    /// @param[in] inputVideo: path of the video stream captured by the unkown camera.
-    /// @param[out] output: path of the folder where a result calibration file will be written.
-    bool calibrate(const std::string & inputVideo, const std::string & output) override;
-    /// @brief this method calibrates and fixes an unkonwn camera intrinsic parameters from a online video stream,
-    /// it saves the result calibration file inside output folder.
-    /// @param[in] camera_id: id of the unkown camera from which the video stream is grabbed.
-    /// @param[out] output: path of the folder where a result calibration file will be written.
-    bool calibrate(int camera_id, const std::string & output) override;
-    /// @brief this method is used to set intrinsic parameters and distorsion of the camera
-    /// @param[in] Camera calibration matrix parameters.
-    /// @param[in] Camera distorsion parameters.
-    bool setParameters(const std::string & config_file) override;
-	virtual void unloadComponent() override;
+	void unloadComponent() override;
 
+private:
+	bool findChessboardCornersImage(SRef<SolAR::datastructure::Image>& image,
+									cv::Mat & displayImage,
+									std::vector<cv::Point2f>& corners);
 
 private:
-protected:
+    cv::Mat m_camMatrix;
+    cv::Mat m_camDistortion;
 	cv::Size m_boardSize;
-	cv::Size m_imageSize;
-	cv::Mat m_camMatrix;
-	cv::Mat m_camDistorsion;
-
+	cv::Size m_imageSize;	
 	float m_squareSize;
-	float m_aspectRatio;
-
-	int m_nframes;
+	int m_nbFrames = 30;
+	int m_nbDropFrames = 0;
 	int m_flags;
-	int m_delay;
-
-    virtual bool process(cv::VideoCapture &, const std::string &);
-	
-	static double computeReprojectionErrors(const std::vector<std::vector<cv::Point3f> >& objectPoints,
-		const std::vector<std::vector<cv::Point2f> >& imagePoints,
-		const std::vector<cv::Mat>& rvecs, const std::vector<cv::Mat>& tvecs,
-		const cv::Mat& cameraMatrix, const cv::Mat& distCoeffs,
-		std::vector<float>& perViewErrors);
-
-	static void calcChessboardCorners(cv::Size boardSize, float squareSize, std::vector<cv::Point3f>& corners);
-
-    static bool runCalibration(const std::vector<std::vector<cv::Point2f>> & imagePoints,
-		cv::Size imageSize,
-		cv::Size boardSize,
-		float squareSize,
-		float aspectRatio,
-		int flags,
-		cv::Mat& cameraMatrix,
-		cv::Mat& distCoeffs,
-		std::vector<cv::Mat>& rvecs,
-		std::vector<cv::Mat>& tvecs,
-		std::vector<float>& reprojErrs,
-		double& totalAvgErr);
-
-	static void saveCameraParams(const std::string& filename,
-		cv::Size imageSize,
-		cv::Size boardSize,
-		float squareSize,
-		float aspectRatio,
-		int flags,
-		const cv::Mat& cameraMatrix,
-		const cv::Mat& distCoeffs);
-
-	static bool runAndSave(const std::string& outputFilename,
-		const std::vector<std::vector<cv::Point2f> >& imagePoints,
-		cv::Size imageSize,
-		cv::Size boardSize,
-		float squareSize,
-		float aspectRatio,
-		int flags,
-		cv::Mat& cameraMatrix,
-		cv::Mat& distCoeffs);
+	int m_waitTime = 30;	
 };
+
 }
 }
 }  // end of namespace Solar

interfaces/SolARDescriptorMatcherGeometricOpencv.h

@@ -0,0 +1,98 @@
+/**
+ * @copyright Copyright (c) 2017 B-com http://www.b-com.com/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SOLARDESCRIPTORMATCHERGEOMETRICOPENCV_H
+#define SOLARDESCRIPTORMATCHERGEOMETRICOPENCV_H
+
+#include "base/features/ADescriptorMatcherGeometric.h"
+#include "SolAROpencvAPI.h"
+#include <limits>
+#include "opencv2/core.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include <opencv2/calib3d.hpp>
+
+namespace SolAR {
+namespace MODULES {
+namespace OPENCV {
+
+/**
+ * @class SolARDescriptorMatcherGeometricOpencv
+ * @brief <B>Matches two sets of descriptors based on geometric constraints.</B>
+ * <TT>UUID: 389ece8b-9e29-45ae-bd60-de1784ff0931</TT>
+ * 
+ * @SolARComponentPropertiesBegin
+ * @SolARComponentProperty{ distanceRatio,
+ *                           distance ratio used to keep good matches.<br/>
+ *                             Several matches can correspond to a given keypoint of the first image. The first match with the best score is always retained.<br>
+ *                             But here\, we can also retain the second match if its distance or score is greater than the score of the best match * m_distanceRatio.,
+ *                           @SolARComponentPropertyDescNum{ float, [0..MAX FLOAT], default: 0.75f }}
+ * @SolARComponentProperty{ paddingRatio,
+ *                          ,
+ *                          @SolARComponentPropertyDescNum{ float, [0..MAX FLOAT], 0.003f }}
+ * @SolARComponentProperty{ matchingDistanceMax,
+ *                          ,
+ *                          @SolARComponentPropertyDescNum{ float, [0..MAX FLOAT], 500.f }}
+ * @SolARComponentPropertiesEnd
+ * 
+ * 
+ */
+
+class SOLAROPENCV_EXPORT_API SolARDescriptorMatcherGeometricOpencv : public base::features::ADescriptorMatcherGeometric {
+public:
+    /// @brief SolARDescriptorMatcherGeometricOpencv constructor
+    SolARDescriptorMatcherGeometricOpencv();
+
+    /// @brief SolARDescriptorMatcherGeometricOpencv destructor
+    ~SolARDescriptorMatcherGeometricOpencv() override;
+
+	/// @brief Match two sets of descriptors from two frames based on epipolar constraint.
+	/// @param[in] descriptors1 The first set of descriptors.
+	/// @param[in] descriptors2 The second set of descriptors.
+	/// @param[in] undistortedKeypoints1 The first set of undistorted keypoints.
+	/// @param[in] undistortedKeypoints2 The second set of undistorted keypoints.
+	/// @param[in] pose1 The first pose.
+	/// @param[in] pose2 The second pose.
+	/// @param[in] camParams The intrinsic parameters of the camera.
+	/// @param[out] matches A vector of matches representing pairs of indices relatively to the first and second set of descriptors.
+	/// @param[in] mask The indices of descriptors in the first frame are used for matching to the second frame. If it is empty then all will be used.
+	/// @return FrameworkReturnCode::_SUCCESS if matching succeed, else FrameworkReturnCode::_ERROR_
+    FrameworkReturnCode match(const SRef<SolAR::datastructure::DescriptorBuffer> descriptors1,
+                              const SRef<SolAR::datastructure::DescriptorBuffer> descriptors2,
+                              const std::vector<SolAR::datastructure::Keypoint> &undistortedKeypoints1,
+                              const std::vector<SolAR::datastructure::Keypoint> &undistortedKeypoints2,
+                              const SolAR::datastructure::Transform3Df& pose1,
+                              const SolAR::datastructure::Transform3Df& pose2,
+                              const SolAR::datastructure::CameraParameters& camParams,
+                              std::vector<SolAR::datastructure::DescriptorMatch> & matches,
+                              const std::vector<uint32_t>& mask = {}) override;
+
+	void unloadComponent() override;
+
+private:
+    float m_distanceRatio = 0.75f;
+    float m_paddingRatio = 0.003f;
+	float m_matchingDistanceMax = 500.f;
+    cv::FlannBasedMatcher m_matcher;
+
+};
+
+}
+}
+}  // end of namespace SolAR
+
+#endif // SOLARDESCRIPTORMATCHERGEOMETRICOPENCV_H

interfaces/SolARDescriptorMatcherHammingBruteForceOpencv.h

@@ -17,22 +17,14 @@
 #ifndef SOLARDESCRIPTORMATCHERHAMMINGBRUTEFORCEMOPENCV_H
 #define SOLARDESCRIPTORMATCHERHAMMINGBRUTEFORCEMOPENCV_H
 
-#include "api/features/IDescriptorMatcher.h"
-
-// Definition of SolARDescriptorMatcherOpencv Class //
-// part of SolAR namespace //
-
-#include "xpcf/component/ConfigurableBase.h"
+#include "base/features/ADescriptorMatcher.h"
 #include "SolAROpencvAPI.h"
 #include <string>
 #include "opencv2/core.hpp"
 #include "opencv2/features2d.hpp"
 #include "opencv2/imgcodecs.hpp"
 #include "opencv2/highgui.hpp"
 
-#include "datastructure/DescriptorMatch.h"
-#include "datastructure/DescriptorBuffer.h"
-
 namespace SolAR {
 namespace MODULES {
 namespace OPENCV {
@@ -53,39 +45,27 @@ namespace OPENCV {
  * 
  */
 
-class SOLAROPENCV_EXPORT_API SolARDescriptorMatcherHammingBruteForceOpencv : public org::bcom::xpcf::ConfigurableBase,
-        public api::features::IDescriptorMatcher {
+class SOLAROPENCV_EXPORT_API SolARDescriptorMatcherHammingBruteForceOpencv : public base::features::ADescriptorMatcher {
 public:
     SolARDescriptorMatcherHammingBruteForceOpencv();
     ~SolARDescriptorMatcherHammingBruteForceOpencv() override;
-    void unloadComponent () override final;
 
-    /// @brief Matches two descriptors desc1 and desc2 respectively based on hamming distance
-    /// [in] desc1: source descriptor.
-    /// [in] desc2: target descriptor.
-    /// [out] matches: ensemble of detected matches, a pair of source/target indices.
-    ///@return IDescriptorMatcher::RetCode::DESCRIPTORS_MATCHER_OK if succeed.
-  IDescriptorMatcher::RetCode match(
-            const SRef<datastructure::DescriptorBuffer> desc1,
-            const SRef<datastructure::DescriptorBuffer> desc2,
-            std::vector<datastructure::DescriptorMatch> & matches) override;
-  /// @brief Matches a  descriptor desc1 with an ensemble of descriptors desc2 based on hamming distance
-  /// [in] desc1: source descriptor.
-  /// [in] desc2: target descriptors.
-  /// [out] matches: ensemble of detected matches, a pair of source/target indices.
-  ///@return IDescriptorMatcher::RetCode::DESCRIPTORS_MATCHER_OK if succeed.
-    IDescriptorMatcher::RetCode match(
-           const SRef<datastructure::DescriptorBuffer> descriptors1,
-           const std::vector<SRef<datastructure::DescriptorBuffer>> & descriptors2,
-           std::vector<datastructure::DescriptorMatch> & matches) override;
+	/// @brief Match two sets of descriptors together
+	/// @param[in] descriptors1 The first set of descriptors organized in a dedicated buffer structure.
+	/// @param[in] descriptors2 The second set of descriptors organized in a dedicated buffer structure.
+	/// @param[out] matches A vector of matches representing pairs of indices relatively to the first and second set of descriptors.
+	/// @return FrameworkReturnCode::_SUCCESS if matching succeed, else FrameworkReturnCode::_ERROR_
+    FrameworkReturnCode match(const SRef<SolAR::datastructure::DescriptorBuffer> descriptors1,
+                              const SRef<SolAR::datastructure::DescriptorBuffer> descriptors2,
+                              std::vector<SolAR::datastructure::DescriptorMatch> & matches) override;
+
+	void unloadComponent() override;
 
 private:
     /// @brief distance ratio used to keep good matches.
     /// Several matches can correspond to a given keypoint of the first image. The first match with the best score is always retained.
     /// But here, we can also retain the next matches if their distances or scores is greater than the score of the best match * m_distanceRatio.
     float m_distanceRatio = 0.75f;
-
-
     int m_id;
     cv::BFMatcher m_matcher;