distanceMapGenerationTool.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
 
// Qt
#include <QImage>
#include <QSharedPointer>
 
// cloudViewer
#include <CVGeom.h>
 
// CV_DB_LIB
#include <ecvColorScale.h>
#include <ecvGLMatrix.h>
 
// system
#include <vector>
 
class ccPointCloud;
class ccMesh;
class ccPolyline;
class ccScalarField;
class ecvMainAppInterface;
 
// Default radial distance scalar field name
const char RADIAL_DIST_SF_NAME[] = "Radial distance";
// Default radii scalar field name
const char RADII_SF_NAME[] = "Radius";
 
class DistanceMapGenerationTool {
public:
    struct ProfileMetaData {
        ProfileMetaData()
            : revolDim(2),
              origin(0, 0, 0),
              heightShift(0),
              hasAxis(false),
              axis(0, 0, 1) {}
 
        ccGLMatrix computeCloudToSurfaceOriginTrans() const;
        ccGLMatrix computeCloudToProfileOriginTrans() const;
 
        int revolDim;      
        CCVector3 origin;  
        PointCoordinateType heightShift;  
        bool hasAxis;  
        CCVector3 axis;  
    };
 
 
    static bool GetPoylineMetaData(const ccPolyline* polyline,
                                   ProfileMetaData& data);
 
 
    static void SetPoylineOrigin(ccPolyline* polyline, const CCVector3& origin);
 
 
    static bool GetPoylineOrigin(const ccPolyline* polyline, CCVector3& origin);
 
 
    static void SetPoylineRevolDim(ccPolyline* polyline, int revolDim);
 
 
    static int GetPoylineRevolDim(const ccPolyline* polyline);
 
 
    static void SetPoylineAxis(ccPolyline* polyline, const CCVector3& axis);
 
 
    static bool GetPoylineAxis(const ccPolyline* polyline, CCVector3& axis);
 
 
    static void SetPolylineHeightShift(ccPolyline* polyline,
                                       PointCoordinateType heightShift);
 
 
    static bool GetPolylineHeightShift(const ccPolyline* polyline,
                                       PointCoordinateType& heightShift);
 
    static bool ComputeRadialDist(ccPointCloud* cloud,
                                  ccPolyline* profile,
                                  bool storeRadiiAsSF = false,
                                  ecvMainAppInterface* app = 0);
 
    struct MapCell {
        MapCell() : value(0), count(0) {}
 
        double value;
        unsigned count;
    };
 
    class Map : public std::vector<MapCell> {
    public:
        Map()
            : xSteps(0),
              xMin(0.0),
              xMax(0.0),
              xStep(1.0),
              ySteps(0),
              yMin(0.0),
              yMax(0.0),
              yStep(1.0),
              conical(false),
              minVal(0.0),
              maxVal(0.0),
              counterclockwise(false),
              conicalSpanRatio(0) {}
 
        unsigned xSteps;
        double xMin;
        double xMax;
        double xStep;
 
        unsigned ySteps;
        double yMin;
        double yMax;
        double yStep;
 
        // conical (true) or cylindrical (false) projection
        bool conical;
 
        // min and max values
        double minVal;
        double maxVal;
 
 
        bool counterclockwise;
 
 
        double conicalSpanRatio;
    };
 
    enum FillStrategyType {
        FILL_STRAT_MIN_DIST = 0,
        FILL_STRAT_AVG_DIST = 1,
        FILL_STRAT_MAX_DIST = 2,
        INVALID_STRATEGY_TYPE = 255,
    };
 
    enum EmptyCellFillOption {
        LEAVE_EMPTY = 0,
        FILL_WITH_ZERO = 1,
        FILL_INTERPOLATE = 2,
    };
 
 
    static QSharedPointer<Map> CreateMap(
            ccPointCloud* cloud,
            ccScalarField* sf,
            const ccGLMatrix& cloudToSurface,  // e.g. translation to the
                                               // revolution origin
            unsigned char revolutionAxisDim,
            double angStep_rad,
            double yStep,
            double yMin,
            double yMax,
            bool conical,
            bool counterclockwise,
            FillStrategyType fillStrategy,
            EmptyCellFillOption emptyCellfillOption,
            ecvMainAppInterface* app = 0);
 
    static ccMesh* ConvertConicalMapToMesh(const QSharedPointer<Map>& map,
                                           bool counterclockwise,
                                           QImage mapTexture = QImage());
 
    static double ConicalProjectN(double phi1, double phi2);
 
    static double ConicalProject(double phi, double phi1, double n);
 
    static bool ConvertCloudToCylindrical(
            ccPointCloud* cloud,
            const ccGLMatrix& cloudToSurface,  // e.g. translation to the
                                               // revolution origin
            unsigned char revolutionAxisDim,
            bool counterclockwise = false);
 
 
    static bool ConvertCloudToConical(
            ccPointCloud* cloud,
            const ccGLMatrix& cloudToSurface,  // e.g. translation to the
                                               // revolution origin
            unsigned char revolutionAxisDim,
            double latMin_rad,
            double latMax_rad,
            double conicalSpanRatio = 1.0,
            bool counterclockwise = false);
 
 
    static CCVector3 ProjectPointOnCone(double lon_rad,
                                        double lat_rad,
                                        double latMin_rad,
                                        double nProj,
                                        bool counterclockwise);
 
    static bool ComputeMinAndMaxLatitude_rad(
            ccPointCloud* cloud,
            double& minLat_rad,
            double& maxLat_rad,
            const ccGLMatrix& cloudToSurfaceOrigin,  // e.g. translation to the
                                                     // revolution origin
            unsigned char revolutionAxisDim);
 
    static bool SaveMapAsCSVMatrix(const QSharedPointer<Map>& map,
                                   QString filename,
                                   QString xUnit,
                                   QString yUnit,
                                   double xConversionFactor = 1.0,
                                   double yConversionFactor = 1.0,
                                   ecvMainAppInterface* app = 0);
 
    static QImage ConvertMapToImage(
            const QSharedPointer<Map>& map,
            ccColorScale::Shared colorScale,
            unsigned colorScaleSteps = ccColorScale::MAX_STEPS);
 
    static ccPointCloud* ConvertMapToCloud(const QSharedPointer<Map>& map,
                                           ccPolyline* profile,
                                           double baseRadius = 1.0,
                                           bool keepNaNPoints = true);
 
    static ccMesh* ConvertProfileToMesh(
            ccPolyline* profile,
            const ccGLMatrix&
                    cloudToProfile,  // e.g. translation to the profile origin
            bool counterclockwise,
            unsigned angularSteps = 36,
            QImage mapTexture = QImage());
 
    struct Measures {
        double total;
        double theoretical;
        double positive;
        double negative;
 
        Measures() : total(0), theoretical(0), positive(0), negative(0) {}
    };
 
 
    static bool ComputeSurfacesAndVolumes(const QSharedPointer<Map>& map,
                                          ccPolyline* profile,
                                          Measures& surfaces,
                                          Measures& volumes);
};