New/pybind

.gitignore

@@ -7,6 +7,7 @@ build14/
 build15/
 build-xcode/
 build-gcc/
+build-dep/
 build14-rdp/
 src/Sandbox/
 src/Visualization/Shader/Shader.h

src/CMakeLists.txt

@@ -12,6 +12,9 @@ set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 option(Open3D_BUILD_TESTS "Build the Open3D test programs" ON)
 option(Open3D_BUILD_LIBREALSENSE "Build support for Intel RealSense camera" ON)
 option(Open3D_USE_OPENMP "Use OpenMP multi-threading" ON)
+option(Open3D_BUILD_PYTHON_BINDING "Build Python binding for Open3D" ON)
+option(Open3D_BUILD_PYTHON_BINDING_TESTS "Copy Test files for Open3D Python binding" ON)
+option(Open3D_USE_NATIVE_DEPENDENCY_BUILD "Prioritize using native dependency build" ON)
 
 # default built type
 if(NOT CMAKE_BUILD_TYPE)
@@ -26,7 +29,6 @@ include_directories(
 	${Open3D_SOURCE_DIR}/External
 	${Open3D_SOURCE_DIR}/External/Eigen
 	${Open3D_SOURCE_DIR}/External/GLFW/include
-	${Open3D_SOURCE_DIR}/External/glew/include
 	${Open3D_SOURCE_DIR}/External/librealsense/include
 	)
 
@@ -58,17 +60,14 @@ elseif(CYGWIN)
 elseif(APPLE)
 	add_definitions(-DUNIX)
 	# enable c++11
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fvisibility=hidden")
 	# compile speed optimization for clang
 	add_definitions(-O3)
-	# disable OpenMP since it is not currently supported on OSX
-	message(STATUS "Compiling on OSX")
-	message(STATUS "Disable OpenMP since it is not supported on OSX.")
-	set(Open3D_USE_OPENMP OFF)
 elseif(UNIX)
 	add_definitions(-DUNIX)
 	# enable c++11
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fPIC")
 	add_compile_options(-Wno-deprecated-declarations)
 	add_compile_options(-Wno-unused-result)
 	add_definitions(-O3)
@@ -92,7 +91,14 @@ if (Open3D_USE_OPENMP)
 endif()
 
 message(STATUS "Open3D_BUILD_LIBREALSENSE=${Open3D_BUILD_LIBREALSENSE}")
+message(STATUS "Open3D_BUILD_PYTHON_BINDING=${Open3D_BUILD_PYTHON_BINDING}")
+message(STATUS "Open3D_BUILD_PYTHON_BINDING_TESTS=${Open3D_BUILD_PYTHON_BINDING_TESTS}")
+
+# Handling dependencies
 add_subdirectory(External)
+include_directories(${GLEW_INCLUDE_DIRS})
+
+# Open3D libraries
 add_subdirectory(Core)
 add_subdirectory(Tools)
 add_subdirectory(IO)
@@ -112,3 +118,8 @@ if(EXISTS "${Open3D_SOURCE_DIR}/Sandbox/CMakeLists.txt")
 	message(STATUS "Build projects in Sandbox")
 	add_subdirectory(Sandbox)
 endif(EXISTS "${Open3D_SOURCE_DIR}/Sandbox/CMakeLists.txt")
+
+# Python binding
+if (Open3D_BUILD_PYTHON_BINDING)
+	add_subdirectory(Python)
+endif(Open3D_BUILD_PYTHON_BINDING)

src/Core/Geometry/EstimateNormals.cpp

@@ -149,6 +149,7 @@ bool EstimateNormals(PointCloud &cloud,
 			cloud.normals_[i] = normal;
 		}
 	}
+
 	return true;
 }
 

src/Core/Geometry/Geometry2D.h

@@ -26,6 +26,7 @@
 
 #pragma once
 
+#include <Eigen/Core>
 #include <Core/Geometry/Geometry.h>
 
 namespace three {

src/Core/Geometry/Geometry3D.h

@@ -44,7 +44,7 @@ class Geometry3D : public Geometry
 	bool IsEmpty() const override = 0;
 	virtual Eigen::Vector3d GetMinBound() const = 0;
 	virtual Eigen::Vector3d GetMaxBound() const = 0;
-	virtual void Transform(const Eigen::Matrix4d & transformation) = 0;
+	virtual void Transform(const Eigen::Matrix4d &transformation) = 0;
 };
 
 }	// namespace three

src/Core/Geometry/Image.h

@@ -43,8 +43,8 @@ class Image : public Geometry2D
 public:
 	void Clear() override;
 	bool IsEmpty() const override;
-	Eigen::Vector2d GetMinBound() const final;
-	Eigen::Vector2d GetMaxBound() const final;
+	Eigen::Vector2d GetMinBound() const override;
+	Eigen::Vector2d GetMaxBound() const override;
 
 public:
 	virtual bool HasData() const {

src/Core/Geometry/KDTreeFlann.cpp

@@ -41,6 +41,11 @@ KDTreeFlann::KDTreeFlann()
 {
 }
 
+KDTreeFlann::KDTreeFlann(const Geometry &geometry)
+{
+	SetGeometry(geometry);
+}
+
 KDTreeFlann::~KDTreeFlann()
 {
 }
@@ -88,9 +93,14 @@ int KDTreeFlann::Search(const T &query, const KDTreeSearchParam &param,
 		return SearchKNN(query, ((const KDTreeSearchParamKNN &)param).knn_, 
 				indices, distance2);
 	case KDTreeSearchParam::SEARCH_RADIUS:
-		return SearchRadius(query, 
-				((const KDTreeSearchParamRadius &)param).radius_, indices, 
-				distance2, ((const KDTreeSearchParamRadius &)param).max_nn_);
+		return SearchRadius(query,
+				((const KDTreeSearchParamRadius &)param).radius_, indices,
+				distance2);
+	case KDTreeSearchParam::SEARCH_HYBRID:
+		return SearchHybrid(query,
+				((const KDTreeSearchParamHybrid &)param).radius_,
+				((const KDTreeSearchParamHybrid &)param).max_nn_,
+				indices, distance2);
 	default:
 		return -1;
 	}
@@ -101,9 +111,9 @@ template<typename T>
 int KDTreeFlann::SearchKNN(const T &query, int knn, std::vector<int> &indices,
 		std::vector<double> &distance2) const
 {
-	// This is optimized code for heavily repeated search
+	// This is optimized code for heavily repeated search.
 	// Other flann::Index::knnSearch() implementations lose performance due to
-	// memory allocation/deallocation
+	// memory allocation/deallocation.
 	if (data_.empty() || dataset_size_ <= 0 || 
 			query.rows() != dimension_ || knn < 0)
 	{
@@ -114,24 +124,27 @@ int KDTreeFlann::SearchKNN(const T &query, int knn, std::vector<int> &indices,
 	distance2.resize(knn);
 	flann::Matrix<int> indices_flann(indices.data(), query_flann.rows, knn);
 	flann::Matrix<double> dists_flann(distance2.data(), query_flann.rows, knn);
-	return flann_index_->knnSearch(query_flann, indices_flann, dists_flann, knn,
-			flann::SearchParams(-1, 0.0));
+	int k = flann_index_->knnSearch(query_flann, indices_flann, dists_flann,
+			knn, flann::SearchParams(-1, 0.0));
+	indices.resize(k);
+	distance2.resize(k);
+	return k;
 }
 
 template<typename T>
 int KDTreeFlann::SearchRadius(const T &query, double radius,
-		std::vector<int> &indices, std::vector<double> &distance2,
-		int max_nn/* = -1*/) const
+		std::vector<int> &indices, std::vector<double> &distance2) const
 {
-	// This is optimized code for heavily repeated search
+	// This is optimized code for heavily repeated search.
+	// Since max_nn is not given, we let flann to do its own memory management.
 	// Other flann::Index::radiusSearch() implementations lose performance due
-	// to memory management and CPU caching
+	// to memory management and CPU caching.
 	if (data_.empty() || dataset_size_ <= 0 || query.rows() != dimension_) {
 		return -1;
 	}
 	flann::Matrix<double> query_flann((double *)query.data(), 1, dimension_);
 	flann::SearchParams param(-1, 0.0);
-	param.max_neighbors = max_nn;
+	param.max_neighbors = -1;
 	std::vector<std::vector<int>> indices_vec(1);
 	std::vector<std::vector<double>> dists_vec(1);
 	int k = flann_index_->radiusSearch(query_flann, indices_vec, dists_vec,
@@ -141,6 +154,33 @@ int KDTreeFlann::SearchRadius(const T &query, double radius,
 	return k;
 }
 
+template<typename T>
+int KDTreeFlann::SearchHybrid(const T &query, double radius, int max_nn,
+		std::vector<int> &indices, std::vector<double> &distance2) const
+{
+	// This is optimized code for heavily repeated search.
+	// It is also the recommended setting for search.
+	// Other flann::Index::radiusSearch() implementations lose performance due
+	// to memory allocation/deallocation.
+	if (data_.empty() || dataset_size_ <= 0 || query.rows() != dimension_ ||
+			max_nn < 0) {
+		return -1;
+	}
+	flann::Matrix<double> query_flann((double *)query.data(), 1, dimension_);
+	flann::SearchParams param(-1, 0.0);
+	param.max_neighbors = max_nn;
+	indices.resize(max_nn);
+	distance2.resize(max_nn);
+	flann::Matrix<int> indices_flann(indices.data(), query_flann.rows, max_nn);
+	flann::Matrix<double> dists_flann(distance2.data(), query_flann.rows,
+			max_nn);
+	int k = flann_index_->radiusSearch(query_flann, indices_flann, dists_flann, 
+			float(radius * radius), param);
+	indices.resize(k);
+	distance2.resize(k);
+	return k;
+}
+
 template int KDTreeFlann::Search<Eigen::Vector3d>(const Eigen::Vector3d &query,
 		const three::KDTreeSearchParam &param, std::vector<int> &indices,
 		std::vector<double> &distance2) const;
@@ -149,7 +189,10 @@ template int KDTreeFlann::SearchKNN<Eigen::Vector3d>(
 		std::vector<double> &distance2) const;
 template int KDTreeFlann::SearchRadius<Eigen::Vector3d>(
 		const Eigen::Vector3d &query, double radius, std::vector<int> &indices,
-		std::vector<double> &distance2, int max_nn) const;
+		std::vector<double> &distance2) const;
+template int KDTreeFlann::SearchHybrid<Eigen::Vector3d>(
+		const Eigen::Vector3d &query, double radius, int max_nn,
+		std::vector<int> &indices, std::vector<double> &distance2) const;
 
 }	// namespace three
 

src/Core/Geometry/KDTreeFlann.h

@@ -44,7 +44,8 @@ class KDTreeFlann
 {
 public:
 	KDTreeFlann();
-	virtual ~KDTreeFlann();
+	KDTreeFlann(const Geometry &geometry);
+	~KDTreeFlann();
 	KDTreeFlann(const KDTreeFlann &) = delete;
 	KDTreeFlann &operator=(const KDTreeFlann &) = delete;
 
@@ -61,7 +62,11 @@ class KDTreeFlann
 
 	template<typename T>
 	int SearchRadius(const T &query, double radius, std::vector<int> &indices,
-			std::vector<double> &distance2, int max_nn = -1) const;
+			std::vector<double> &distance2) const;
+
+	template<typename T>
+	int SearchHybrid(const T &query, double radius, int max_nn,
+			std::vector<int> &indices, std::vector<double> &distance2) const;
 
 protected:
 	std::vector<double> data_;

src/Core/Geometry/KDTreeSearchParam.h

@@ -34,6 +34,7 @@ class KDTreeSearchParam
 	enum SearchType {
 		SEARCH_KNN = 0,
 		SEARCH_RADIUS = 1,
+		SEARCH_HYBRID = 2,
 	};
 
 public:
@@ -61,9 +62,18 @@ class KDTreeSearchParamKNN : public KDTreeSearchParam
 class KDTreeSearchParamRadius : public KDTreeSearchParam
 {
 public:
-	KDTreeSearchParamRadius(double radius, int max_nn = -1) : 
-			KDTreeSearchParam(SEARCH_RADIUS),
-			radius_(radius), max_nn_(max_nn) {}
+	KDTreeSearchParamRadius(double radius) : 
+			KDTreeSearchParam(SEARCH_RADIUS), radius_(radius) {}
+public:
+	double radius_;
+};
+
+class KDTreeSearchParamHybrid : public KDTreeSearchParam
+{
+public:
+	KDTreeSearchParamHybrid(double radius, int max_nn) :
+			KDTreeSearchParam(SEARCH_HYBRID), radius_(radius),
+			max_nn_(max_nn) {}
 public:
 	double radius_;
 	int max_nn_;

src/Core/Geometry/PointCloud.cpp

@@ -112,7 +112,7 @@ PointCloud &PointCloud::operator+=(const PointCloud &cloud)
 	return (*this);
 }
 
-const PointCloud PointCloud::operator+(const PointCloud &cloud)
+PointCloud PointCloud::operator+(const PointCloud &cloud) const
 {
 	return (PointCloud(*this) += cloud);
 }

src/Core/Geometry/PointCloud.h

@@ -51,8 +51,8 @@ class PointCloud : public Geometry3D
 	void Transform(const Eigen::Matrix4d &transformation) override;
 
 public:
-	virtual PointCloud &operator+=(const PointCloud &cloud);
-	virtual const PointCloud operator+(const PointCloud &cloud);
+	PointCloud &operator+=(const PointCloud &cloud);
+	PointCloud operator+(const PointCloud &cloud) const;
 
 public:
 	bool HasPoints() const {
@@ -72,6 +72,13 @@ class PointCloud : public Geometry3D
 			normals_[i].normalize();
 		}
 	}
+
+	void PaintUniformColor(const Eigen::Vector3d &color) {
+		colors_.resize(points_.size());
+		for (size_t i = 0; i < points_.size(); i++) {
+			colors_[i] = color;
+		}
+	}
 
 public:
 	std::vector<Eigen::Vector3d> points_;
@@ -92,6 +99,15 @@ std::shared_ptr<PointCloud> CreatePointCloudFromDepthImage(
 		const Eigen::Matrix4d &extrinsic = Eigen::Matrix4d::Identity(), 
 		double depth_scale = 1000.0);
 
+/// Factory function to create a pointcloud from a pair of RGB-D image and
+/// a camera model (PointCloudFactory.cpp)
+/// Return an empty pointcloud if the conversion fails.
+std::shared_ptr<PointCloud> CreatePointCloudFromRGBDImage(
+		const Image &depth, const Image &color,
+		const PinholeCameraIntrinsic &intrinsic,
+		const Eigen::Matrix4d &extrinsic = Eigen::Matrix4d::Identity(), 
+		double depth_scale = 1000.0);
+
 /// Function to select points from input pointcloud into output pointcloud
 /// Points with indices in \param indices are selected.
 /// Input and output cannot be the same pointcloud.
@@ -110,7 +126,7 @@ bool VoxelDownSample(const PointCloud &input, double voxel_size,
 /// \param every_k_points indicates the sample rate.
 /// Input and output cannot be the same pointcloud.
 bool UniformDownSample(const PointCloud &input, size_t every_k_points,
-		PointCloud &output_cloud);
+		PointCloud &output);
 
 /// Function to crop input pointcloud into output pointcloud
 /// All points with coordinates less than \param min_bound or larger than
@@ -133,7 +149,7 @@ bool OrientNormalsToAlignWithDirection(PointCloud &cloud,
 		const Eigen::Vector3d &orientation_reference =
 		Eigen::Vector3d(0.0, 0.0, 1.0));
 
-/// Function to compute the normals of a point cloud
+/// Function to orient the normals of a point cloud
 /// \param cloud is the input point cloud. It also stores the output normals.
 /// Normals are oriented with towards \param camera_location.
 bool OrientNormalsTowardsCameraLocation(PointCloud &cloud,