PointProjectionTools.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
// Local
#include "CVConst.h"
#include "CVPointCloud.h"
#include "CVToolbox.h"
#include "SquareMatrix.h"
 
// System
#include <list>
 
namespace cloudViewer {
 
enum TRIANGULATION_TYPES {
    DELAUNAY_2D_AXIS_ALIGNED =
            1, 
    DELAUNAY_2D_BEST_LS_PLANE = 2, 
};
 
class GenericIndexedMesh;
class GenericProgressCallback;
 
class CV_CORE_LIB_API PointProjectionTools : public CVToolbox {
public:
    static constexpr int IGNORE_MAX_EDGE_LENGTH = 0;
 
    struct Transformation {
        SquareMatrixd R;
        CCVector3d T;
        double s;
 
        Transformation() : s(1.0) {}
 
        inline CCVector3d apply(const CCVector3d& P) const {
            return s * (R * P) + T;
        }
 
        inline CCVector3 apply(const CCVector3& P) const {
            return (s * (R * P) + T).toPC();
        }
 
 
        CV_CORE_LIB_API void apply(GenericIndexedCloudPersist& cloud) const;
    };
 
 
    static PointCloud* developCloudOnCylinder(
            GenericCloud* cloud,
            PointCoordinateType radius,
            unsigned char dim = 2,
            CCVector3* center = nullptr,
            GenericProgressCallback* progressCb = nullptr);
 
 
    static PointCloud* developCloudOnCone(
            GenericCloud* cloud,
            unsigned char dim,
            PointCoordinateType baseRadius,
            float alpha,
            const CCVector3& center,
            GenericProgressCallback* progressCb = nullptr);
 
 
    static PointCloud* applyTransformation(
            GenericCloud* cloud,
            Transformation& trans,
            GenericProgressCallback* progressCb = nullptr);
 
 
    static PointCloud* applyTransformation(
            GenericIndexedCloud* cloud,
            Transformation& trans,
            GenericProgressCallback* progressCb = nullptr);
 
 
    // static CCVector3 applyTransformation(const CCVector3& P, Transformation&
    // trans);
 
 
    static GenericIndexedMesh* computeTriangulation(
            GenericIndexedCloudPersist* cloud,
            TRIANGULATION_TYPES type,
            PointCoordinateType maxEdgeLength,
            unsigned char dim,
            std::string& outputErrorStr);
 
 
    class IndexedCCVector2 : public CCVector2 {
    public:
        IndexedCCVector2() : CCVector2(), index(0) {}
        IndexedCCVector2(PointCoordinateType x, PointCoordinateType y)
            : CCVector2(x, y), index(0) {}
        IndexedCCVector2(PointCoordinateType x,
                         PointCoordinateType y,
                         unsigned i)
            : CCVector2(x, y), index(i) {}
        IndexedCCVector2(const CCVector2& v) : CCVector2(v), index(0) {}
 
        unsigned index;
    };
 
 
    static bool extractConvexHull2D(std::vector<IndexedCCVector2>& points,
                                    std::list<IndexedCCVector2*>& hullPoints);
 
 
    static bool extractConcaveHull2D(std::vector<IndexedCCVector2>& points,
                                     std::list<IndexedCCVector2*>& hullPoints,
                                     PointCoordinateType maxSquareLength = 0);
 
    static bool segmentIntersect(const CCVector2& A,
                                 const CCVector2& B,
                                 const CCVector2& C,
                                 const CCVector2& D);
};
 
}  // namespace cloudViewer