ecvRasterGrid.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 "CV_db.h"
#include "ecvBBox.h"
 
// system
#include <limits>
 
class ccGenericPointCloud;
class ccPointCloud;
class ecvProgressDialog;
 
struct CV_DB_LIB_API ccRasterCell {
    ccRasterCell()
        : h(std::numeric_limits<double>::quiet_NaN()),
          avgHeight(0),
          stdDevHeight(0),
          minHeight(0),
          maxHeight(0),
          nbPoints(0),
          pointIndex(0),
          color(0, 0, 0) {}
 
    double h;
    double avgHeight;
    double stdDevHeight;
    PointCoordinateType minHeight;
    PointCoordinateType maxHeight;
    unsigned nbPoints;
    unsigned pointIndex;
    CCVector3d color;
};
 
struct CV_DB_LIB_API ccRasterGrid {
    ccRasterGrid();
 
    virtual ~ccRasterGrid();
 
    static bool ComputeGridSize(unsigned char Z,
                                const ccBBox& box,
                                double gridStep,
                                unsigned& width,
                                unsigned& height);
 
    bool init(unsigned w,
              unsigned h,
              double gridStep,
              const CCVector3d& minCorner);
 
    void clear();
    void reset();
 
    enum ExportableFields {
        PER_CELL_VALUE,
        PER_CELL_COUNT,
        PER_CELL_MIN_VALUE,
        PER_CELL_MAX_VALUE,
        PER_CELL_AVG_VALUE,
        PER_CELL_VALUE_STD_DEV,
        PER_CELL_VALUE_RANGE,
        PER_CELL_MEDIAN_VALUE,
        PER_CELL_PERCENTILE_VALUE,
        PER_CELL_UNIQUE_COUNT_VALUE,
        PER_CELL_INVALID,
    };
 
    static QString GetDefaultFieldName(ExportableFields field);
 
    ccPointCloud* convertToCloud(
            const std::vector<ExportableFields>& exportedFields,
            bool interpolateSF,
            bool interpolateColors,
            bool resampleInputCloudXY,
            bool resampleInputCloudZ,  // only considered if
                                       // resampleInputCloudXY is true!
            ccGenericPointCloud* inputCloud,
            unsigned char Z,
            const ccBBox& box,
            bool fillEmptyCells,
            double emptyCellsHeight,
            bool exportToOriginalCS) const;
 
    enum ProjectionType {
        PROJ_MINIMUM_VALUE = 0,
        PROJ_AVERAGE_VALUE = 1,
        PROJ_MAXIMUM_VALUE = 2,
        PROJ_MEDIAN_VALUE = 3,
        PROJ_INVERSE_VAR_VALUE = 4,
        INVALID_PROJECTION_TYPE = 255,
    };
 
    enum class InterpolationType { NONE = 0, DELAUNAY = 1 };
 
 
    bool fillWith(ccGenericPointCloud* cloud,
                  unsigned char projectionDimension,
                  ProjectionType projectionType,
                  bool interpolateEmptyCells,
                  ProjectionType sfInterpolation = INVALID_PROJECTION_TYPE,
                  ecvProgressDialog* progressDialog = nullptr);
 
    enum EmptyCellFillOption {
        LEAVE_EMPTY = 0,
        FILL_MINIMUM_HEIGHT = 1,
        FILL_MAXIMUM_HEIGHT = 2,
        FILL_CUSTOM_HEIGHT = 3,
        FILL_AVERAGE_HEIGHT = 4,
        INTERPOLATE_DELAUNAY = 5,
        KRIGING = 6,
    };
 
    static InterpolationType InterpolationTypeFromEmptyCellFillOption(
            EmptyCellFillOption option);
 
    void fillEmptyCells(EmptyCellFillOption fillEmptyCellsStrategy,
                        double customCellHeight = 0);
 
    unsigned updateNonEmptyCellCount();
 
    void updateCellStats();
 
    inline void setValid(bool state) { valid = state; }
    inline bool isValid() const { return valid; }
 
    std::pair<int, int> computeCellPos(const CCVector3& P,
                                       unsigned char X,
                                       unsigned char Y) const {
        CCVector3d relativePos = CCVector3d::fromArray(P.u) - minCorner;
 
        // DGM: we use the 'PixelIsArea' convention
        int i = static_cast<int>((relativePos.u[X] / gridStep + 0.5));
        int j = static_cast<int>((relativePos.u[Y] / gridStep + 0.5));
 
        return {i, j};
    }
 
    CCVector2d computeCellCenter(int i,
                                 int j,
                                 unsigned char X,
                                 unsigned char Y) const {
        return {minCorner.u[X] + (i + 0.5) * gridStep,
                minCorner.u[Y] + (j + 0.5) * gridStep};
    }
 
    using Row = std::vector<ccRasterCell>;
 
    std::vector<Row> rows;
 
    using SF = std::vector<double>;
 
    std::vector<SF> scalarFields;
 
    unsigned width;
    unsigned height;
    double gridStep;
    CCVector3d minCorner;
 
    double minHeight;
    double maxHeight;
    double meanHeight;
    unsigned nonEmptyCellCount;
    unsigned validCellCount;
 
    bool hasColors;
 
    bool valid;
};