std vector interface

CMakeLists.txt

@@ -160,6 +160,7 @@ elseif (UNIX)
 endif ()
 
 find_package(CUDA REQUIRED)
+enable_language(CUDA)
 if(NOT CMAKE_CUDA_ARCHITECTURES)
   set(CMAKE_CUDA_ARCHITECTURES 86)
 endif()

src/cupoch/geometry/down_sample.cu

@@ -167,6 +167,16 @@ std::shared_ptr<PointCloud> PointCloud::SelectByMask(
     return output;
 }
 
+std::shared_ptr<PointCloud> PointCloud::SelectByIndex(
+        const std::vector<size_t> &indices, bool invert) const {
+    return SelectByIndex(utility::device_vector<size_t>(indices), invert);
+}
+
+std::shared_ptr<PointCloud> PointCloud::SelectByMask(
+        const std::vector<bool> &mask, bool invert) const {
+    return SelectByMask(utility::device_vector<bool>(mask), invert);
+}
+
 std::shared_ptr<PointCloud> PointCloud::VoxelDownSample(
         float voxel_size) const {
     auto output = std::make_shared<PointCloud>();

src/cupoch/geometry/geometry_utils.cu

@@ -69,6 +69,22 @@ const utility::device_vector<Eigen::Vector3f>& ConvertVector3fVectorRef(const Ge
     }
 }
 
+const std::vector<Eigen::Vector3f> ConvertVector3fStdVector(const Geometry &geometry) {
+    switch (geometry.GetGeometryType()) {
+        case Geometry::GeometryType::PointCloud:
+            return ((const PointCloud &)geometry).GetPoints();
+        case Geometry::GeometryType::TriangleMesh:
+            return ((const TriangleMesh &)geometry).GetVertices();
+        case Geometry::GeometryType::Image:
+        case Geometry::GeometryType::Unspecified:
+        default:
+            utility::LogWarning(
+                    "[KDTreeFlann::SetGeometry] Unsupported Geometry type.");
+            throw std::runtime_error(
+                    "[KDTreeFlann::SetGeometry] Unsupported Geometry type.");
+    }
+}
+
 void ResizeAndPaintUniformColor(utility::device_vector<Eigen::Vector3f> &colors,
                                 const size_t size,
                                 const Eigen::Vector3f &color) {

src/cupoch/geometry/geometry_utils.h

@@ -27,6 +27,7 @@ namespace cupoch {
 namespace geometry {
 
 const utility::device_vector<Eigen::Vector3f>& ConvertVector3fVectorRef(const Geometry &geometry);
+const std::vector<Eigen::Vector3f> ConvertVector3fStdVector(const Geometry &geometry);
 
 /// Get Rotation Matrix from XYZ RotationType.
 Eigen::Matrix3f GetRotationMatrixFromXYZ(const Eigen::Vector3f &rotation);

src/cupoch/geometry/graph.cu

@@ -177,8 +177,9 @@ Graph<Dim>::Graph(const Graph &other)
       is_directed_(other.is_directed_) {}
 
 template <int Dim>
-thrust::host_vector<int> Graph<Dim>::GetEdgeIndexOffsets() const {
-    thrust::host_vector<int> edge_index_offsets = edge_index_offsets_;
+std::vector<int> Graph<Dim>::GetEdgeIndexOffsets() const {
+    std::vector<int> edge_index_offsets(edge_index_offsets_.size());
+    copy_device_to_host(edge_index_offsets_, edge_index_offsets);
     return edge_index_offsets;
 }
 
@@ -189,8 +190,9 @@ void Graph<Dim>::SetEdgeIndexOffsets(
 }
 
 template <int Dim>
-thrust::host_vector<float> Graph<Dim>::GetEdgeWeights() const {
-    thrust::host_vector<float> edge_weights = edge_weights_;
+std::vector<float> Graph<Dim>::GetEdgeWeights() const {
+    std::vector<float> edge_weights(edge_weights_.size());
+    copy_device_to_host(edge_weights_, edge_weights);
     return edge_weights;
 }
 
@@ -390,6 +392,18 @@ Graph<Dim> &Graph<Dim>::AddEdges(
     return AddEdges(d_edges, d_weights, lazy_add);
 }
 
+template <int Dim>
+Graph<Dim> &Graph<Dim>::AddEdges(
+        const std::vector<Eigen::Vector2i> &edges,
+        const std::vector<float> &weights,
+        bool lazy_add) {
+    utility::device_vector<Eigen::Vector2i> d_edges(edges.size());
+    copy_host_to_device(edges, d_edges);
+    utility::device_vector<float> d_weights(weights.size());
+    copy_host_to_device(weights, d_weights);
+    return AddEdges(d_edges, d_weights, lazy_add);
+}
+
 template <int Dim>
 Graph<Dim> &Graph<Dim>::RemoveEdge(const Eigen::Vector2i &edge) {
     bool has_colors = this->HasColors();
@@ -510,6 +524,13 @@ Graph<Dim> &Graph<Dim>::RemoveEdges(
     return RemoveEdges(d_edges);
 }
 
+template <int Dim>
+Graph<Dim> &Graph<Dim>::RemoveEdges(const std::vector<Eigen::Vector2i> &edges) {
+    utility::device_vector<Eigen::Vector2i> d_edges(edges.size());
+    copy_host_to_device(edges, d_edges);
+    return RemoveEdges(d_edges);
+}
+
 template <int Dim>
 Graph<Dim> &Graph<Dim>::PaintEdgeColor(const Eigen::Vector2i &edge,
                                        const Eigen::Vector3f &color) {
@@ -574,6 +595,15 @@ Graph<Dim> &Graph<Dim>::PaintEdgesColor(
     return PaintEdgesColor(d_edges, color);
 }
 
+template <int Dim>
+Graph<Dim> &Graph<Dim>::PaintEdgesColor(
+        const std::vector<Eigen::Vector2i> &edges,
+        const Eigen::Vector3f &color) {
+    utility::device_vector<Eigen::Vector2i> d_edges(edges.size());
+    copy_host_to_device(edges, d_edges);
+    return PaintEdgesColor(d_edges, color);
+}
+
 template <int Dim>
 Graph<Dim> &Graph<Dim>::PaintNodeColor(int node, const Eigen::Vector3f &color) {
     if (!HasNodeColors()) {
@@ -602,6 +632,14 @@ Graph<Dim> &Graph<Dim>::PaintNodesColor(const thrust::host_vector<int> &nodes,
     return PaintNodesColor(d_nodes, color);
 }
 
+template <int Dim>
+Graph<Dim> &Graph<Dim>::PaintNodesColor(const std::vector<int> &nodes,
+                                        const Eigen::Vector3f &color) {
+    utility::device_vector<int> d_nodes(nodes.size());
+    copy_host_to_device(nodes, d_nodes);
+    return PaintNodesColor(d_nodes, color);
+}
+
 template <int Dim>
 Graph<Dim> &Graph<Dim>::SetEdgeWeightsFromDistance() {
     edge_weights_.resize(this->lines_.size());

src/cupoch/geometry/graph.h

@@ -55,10 +55,10 @@ class Graph : public LineSet<Dim> {
     Graph(const Graph &other);
     ~Graph();
 
-    thrust::host_vector<int> GetEdgeIndexOffsets() const;
+    std::vector<int> GetEdgeIndexOffsets() const;
     void SetEdgeIndexOffsets(
             const thrust::host_vector<int> &edge_index_offsets);
-    thrust::host_vector<float> GetEdgeWeights() const;
+    std::vector<float> GetEdgeWeights() const;
     void SetEdgeWeights(const thrust::host_vector<float> &edge_weights);
 
     bool HasWeights() const {
@@ -97,11 +97,15 @@ class Graph : public LineSet<Dim> {
             const utility::pinned_host_vector<float> &weights =
                     utility::pinned_host_vector<float>(),
             bool lazy_add = false);
+    Graph<Dim> &AddEdges(const std::vector<Eigen::Vector2i> &edges,
+                        const std::vector<float> &weights = std::vector<float>(),
+                        bool lazy_add = false);
 
     Graph<Dim> &RemoveEdge(const Eigen::Vector2i &edge);
     Graph<Dim> &RemoveEdges(
             const utility::device_vector<Eigen::Vector2i> &edges);
     Graph<Dim> &RemoveEdges(const thrust::host_vector<Eigen::Vector2i> &edges);
+    Graph<Dim> &RemoveEdges(const std::vector<Eigen::Vector2i> &edges);
 
     Graph<Dim> &PaintEdgeColor(const Eigen::Vector2i &edge,
                                const Eigen::Vector3f &color);
@@ -111,12 +115,17 @@ class Graph : public LineSet<Dim> {
     Graph<Dim> &PaintEdgesColor(
             const thrust::host_vector<Eigen::Vector2i> &edges,
             const Eigen::Vector3f &color);
+    Graph<Dim> &PaintEdgesColor(
+            const std::vector<Eigen::Vector2i> &edges,
+            const Eigen::Vector3f &color);
 
     Graph<Dim> &PaintNodeColor(int node, const Eigen::Vector3f &color);
     Graph<Dim> &PaintNodesColor(const utility::device_vector<int> &nodes,
                                 const Eigen::Vector3f &color);
     Graph<Dim> &PaintNodesColor(const thrust::host_vector<int> &nodes,
                                 const Eigen::Vector3f &color);
+    Graph<Dim> &PaintNodesColor(const std::vector<int> &nodes,
+                                const Eigen::Vector3f &color);
 
     Graph<Dim> &SetEdgeWeightsFromDistance();
     Graph<Dim> &SetEdgeWeights(const utility::device_vector<Eigen::Vector2i> &edges, float weight);

src/cupoch/geometry/image.cu

@@ -389,13 +389,19 @@ Eigen::Vector2f Image::GetCenter() const {
     return Eigen::Vector2f(width_ / 2, height_ / 2);
 }
 
-thrust::host_vector<uint8_t> Image::GetData() const {
-    thrust::host_vector<uint8_t> data = data_;
+std::vector<uint8_t> Image::GetData() const {
+    std::vector<uint8_t> data(data_.size());
+    copy_device_to_host(data_, data);
     return data;
 }
 
 void Image::SetData(const thrust::host_vector<uint8_t> &data) { data_ = data; }
 
+void Image::SetData(const std::vector<uint8_t> &data) {
+    data_.resize(data.size());
+    copy_host_to_device(data, data_);
+}
+
 bool Image::TestImageBoundary(float u,
                               float v,
                               float inner_margin /* = 0.0 */) const {
@@ -519,6 +525,13 @@ std::shared_ptr<Image> Image::FilterHorizontal(
     return output;
 }
 
+std::shared_ptr<Image> Image::FilterHorizontal(
+        const std::vector<float> &kernel) const {
+    utility::device_vector<float> d_kernel(kernel.size());
+    copy_host_to_device(kernel, d_kernel);
+    return FilterHorizontal(d_kernel);
+}
+
 std::shared_ptr<Image> Image::Filter(Image::FilterType type) const {
     auto output = std::make_shared<Image>();
     if (num_of_channels_ != 1 || bytes_per_channel_ != 4) {

src/cupoch/geometry/image.h

@@ -85,8 +85,9 @@ class Image : public GeometryBaseNoTrans2D {
     Eigen::Vector2f GetMaxBound() const override;
     Eigen::Vector2f GetCenter() const override;
 
-    thrust::host_vector<uint8_t> GetData() const;
+    std::vector<uint8_t> GetData() const;
     void SetData(const thrust::host_vector<uint8_t> &data);
+    void SetData(const std::vector<uint8_t> &data);
 
     /// \brief Test if coordinate `(u, v)` is located in the inner_marge of the
     /// image.
@@ -171,6 +172,9 @@ class Image : public GeometryBaseNoTrans2D {
     std::shared_ptr<Image> FilterHorizontal(
             const utility::device_vector<float> &kernel) const;
 
+    std::shared_ptr<Image> FilterHorizontal(
+            const std::vector<float> &kernel) const;
+
     std::shared_ptr<Image> BilateralFilter(int diameter,
                                            float sigma_color,
                                            float sigma_space) const;

src/cupoch/geometry/laserscanbuffer.cu

@@ -137,8 +137,8 @@ LaserScanBuffer::LaserScanBuffer(const LaserScanBuffer& other)
       max_angle_(other.max_angle_),
       origins_(other.origins_) {}
 
-thrust::host_vector<float> LaserScanBuffer::GetRanges() const {
-    thrust::host_vector<float> ranges;
+std::vector<float> LaserScanBuffer::GetRanges() const {
+    std::vector<float> ranges;
     if (top_ == bottom_) {
         return ranges;
     }
@@ -161,8 +161,8 @@ thrust::host_vector<float> LaserScanBuffer::GetRanges() const {
     }
 }
 
-thrust::host_vector<float> LaserScanBuffer::GetIntensities() const {
-    thrust::host_vector<float> intensities;
+std::vector<float> LaserScanBuffer::GetIntensities() const {
+    std::vector<float> intensities;
     if (top_ == bottom_) {
         return intensities;
     }
@@ -303,6 +303,11 @@ template LaserScanBuffer& LaserScanBuffer::AddRanges(
         const Eigen::Matrix4f& transformation,
         const thrust::host_vector<float>& intensities);
 
+template LaserScanBuffer& LaserScanBuffer::AddRanges(
+        const std::vector<float>& ranges,
+        const Eigen::Matrix4f& transformation,
+        const std::vector<float>& intensities);
+
 
 class ContainerLikePtr {
 public:

src/cupoch/geometry/laserscanbuffer.h

@@ -48,8 +48,8 @@ class LaserScanBuffer : public GeometryBase3D {
     ~LaserScanBuffer();
     LaserScanBuffer(const LaserScanBuffer &other);
 
-    thrust::host_vector<float> GetRanges() const;
-    thrust::host_vector<float> GetIntensities() const;
+    std::vector<float> GetRanges() const;
+    std::vector<float> GetIntensities() const;
 
     LaserScanBuffer &Clear() override;
     bool IsEmpty() const override;

src/cupoch/geometry/lineset.cu

@@ -68,6 +68,13 @@ LineSet<Dim>::LineSet(
       points_(points),
       lines_(lines) {}
 
+template <int Dim>
+LineSet<Dim>::LineSet(const std::vector<Eigen::Matrix<float, Dim, 1>> &points,
+                     const std::vector<Eigen::Vector2i> &lines)
+    : GeometryBaseXD<Dim>(Geometry::GeometryType::LineSet),
+      points_(points),
+      lines_(lines) {}
+
 template <int Dim>
 LineSet<Dim>::LineSet(const std::vector<Eigen::Matrix<float, Dim, 1>> &path)
     : GeometryBaseXD<Dim>(Geometry::GeometryType::LineSet) {
@@ -101,6 +108,13 @@ void LineSet<Dim>::SetPoints(
     points_ = points;
 }
 
+template <int Dim>
+void LineSet<Dim>::SetPoints(
+        const std::vector<Eigen::Matrix<float, Dim, 1>> &points) {
+    points_.resize(points.size());
+    copy_host_to_device(points, points_);
+}
+
 template <int Dim>
 thrust::host_vector<Eigen::Matrix<float, Dim, 1>> LineSet<Dim>::GetPoints()
         const {
@@ -113,6 +127,12 @@ void LineSet<Dim>::SetLines(const thrust::host_vector<Eigen::Vector2i> &lines) {
     lines_ = lines;
 }
 
+template <int Dim>
+void LineSet<Dim>::SetLines(const std::vector<Eigen::Vector2i> &lines) {
+    lines_.resize(lines.size());
+    copy_host_to_device(lines, lines_);
+}
+
 template <int Dim>
 thrust::host_vector<Eigen::Vector2i> LineSet<Dim>::GetLines() const {
     thrust::host_vector<Eigen::Vector2i> lines = lines_;
@@ -125,6 +145,12 @@ void LineSet<Dim>::SetColors(
     colors_ = colors;
 }
 
+template <int Dim>
+void LineSet<Dim>::SetColors(const std::vector<Eigen::Vector3f> &colors) {
+    colors_.resize(colors.size());
+    copy_host_to_device(colors, colors_);
+}
+
 template <int Dim>
 thrust::host_vector<Eigen::Vector3f> LineSet<Dim>::GetColors() const {
     thrust::host_vector<Eigen::Vector3f> colors = colors_;
@@ -198,6 +224,12 @@ LineSet<Dim>::GetLineCoordinate(size_t line_index) const {
     return thrust::make_pair(points_[idxs[0]], points_[idxs[1]]);
 }
 
+template <int Dim>
+LineSet<Dim> &LineSet<Dim>::PaintUniformColor(const Eigen::Vector3f &color) {
+    ResizeAndPaintUniformColor(colors_, lines_.size(), color);
+    return *this;
+}
+
 template <int Dim>
 float LineSet<Dim>::GetMaxLineLength() const {
     return thrust::transform_reduce(

src/cupoch/geometry/lineset.h

@@ -58,18 +58,24 @@ class LineSet : public GeometryBaseXD<Dim> {
             const utility::pinned_host_vector<Eigen::Vector2i> &lines);
     LineSet(const thrust::host_vector<Eigen::Matrix<float, Dim, 1>> &points,
             const thrust::host_vector<Eigen::Vector2i> &lines);
+    LineSet(const std::vector<Eigen::Matrix<float, Dim, 1>> &points,
+            const std::vector<Eigen::Vector2i> &lines);
     LineSet(const std::vector<Eigen::Matrix<float, Dim, 1>> &path);
     LineSet(const LineSet &other);
     ~LineSet();
 
     void SetPoints(
             const thrust::host_vector<Eigen::Matrix<float, Dim, 1>> &points);
+    void SetPoints(
+            const std::vector<Eigen::Matrix<float, Dim, 1>> &points);
     thrust::host_vector<Eigen::Matrix<float, Dim, 1>> GetPoints() const;
 
     void SetLines(const thrust::host_vector<Eigen::Vector2i> &lines);
+    void SetLines(const std::vector<Eigen::Vector2i> &lines);
     thrust::host_vector<Eigen::Vector2i> GetLines() const;
 
     void SetColors(const thrust::host_vector<Eigen::Vector3f> &colors);
+    void SetColors(const std::vector<Eigen::Vector3f> &colors);
     thrust::host_vector<Eigen::Vector3f> GetColors() const;
 
 public:
@@ -99,10 +105,7 @@ class LineSet : public GeometryBaseXD<Dim> {
     GetLineCoordinate(size_t line_index) const;
 
     /// Assigns each line in the LineSet the same color \param color.
-    LineSet &PaintUniformColor(const Eigen::Vector3f &color) {
-        ResizeAndPaintUniformColor(colors_, lines_.size(), color);
-        return *this;
-    }
+    LineSet &PaintUniformColor(const Eigen::Vector3f &color);
 
     LineSet &PaintIndexedColor(const utility::device_vector<size_t> &indices,
                                const Eigen::Vector3f &color);