LASFields.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
 
// qCC_db
#include <ecvPointCloud.h>
#include <ecvScalarField.h>
 
// Qt
#include <QSharedPointer>
 
// System
#include <vector>
 
class ccScalarField;
class ccPointCloud;
 
static const char LAS_SCALE_X_META_DATA[] = "LAS.scale.x";
static const char LAS_SCALE_Y_META_DATA[] = "LAS.scale.y";
static const char LAS_SCALE_Z_META_DATA[] = "LAS.scale.z";
static const char LAS_OFFSET_X_META_DATA[] = "LAS.offset.x";
static const char LAS_OFFSET_Y_META_DATA[] = "LAS.offset.y";
static const char LAS_OFFSET_Z_META_DATA[] = "LAS.offset.z";
static const char LAS_VERSION_MAJOR_META_DATA[] = "LAS.version.major";
static const char LAS_VERSION_MINOR_META_DATA[] = "LAS.version.minor";
static const char LAS_POINT_FORMAT_META_DATA[] = "LAS.point_format";
static const char LAS_GLOBAL_ENCODING_META_DATA[] = "LAS.global_encoding";
static const char LAS_PROJECT_UUID_META_DATA[] = "LAS.project_uuid";
 
enum LAS_FIELDS {
    LAS_X = 0,
    LAS_Y = 1,
    LAS_Z = 2,
    LAS_INTENSITY = 3,
    LAS_RETURN_NUMBER = 4,
    LAS_NUMBER_OF_RETURNS = 5,
    LAS_SCAN_DIRECTION = 6,
    LAS_FLIGHT_LINE_EDGE = 7,
    LAS_CLASSIFICATION = 8,
    LAS_SCAN_ANGLE_RANK = 9,
    LAS_USER_DATA = 10,
    LAS_POINT_SOURCE_ID = 11,
    LAS_RED = 12,
    LAS_GREEN = 13,
    LAS_BLUE = 14,
    LAS_TIME = 15,
    LAS_EXTRA = 16,
    // Sub fields
    LAS_CLASSIF_VALUE = 17,
    LAS_CLASSIF_SYNTHETIC = 18,
    LAS_CLASSIF_KEYPOINT = 19,
    LAS_CLASSIF_WITHHELD = 20,
    LAS_CLASSIF_OVERLAP = 21,
    // Invald flag
    LAS_INVALID = 255
};
 
const char LAS_FIELD_NAMES[][28] = {
        "X",
        "Y",
        "Z",
        "Intensity",
        "ReturnNumber",
        "NumberOfReturns",
        "ScanDirectionFlag",
        "EdgeOfFlightLine",
        "Classification",
        "ScanAngleRank",
        "UserData",
        "PointSourceId",
        "Red",
        "Green",
        "Blue",
        "GpsTime",
        "extra",
        "[Classif] Value",
        "[Classif] Synthetic flag",
        "[Classif] Key-point flag",
        "[Classif] Withheld flag",
        "[Classif] Overlap flag",
};
 
struct LasField {
    typedef QSharedPointer<LasField> Shared;
 
    LasField(LAS_FIELDS fieldType = LAS_INVALID,
             double defaultVal = 0,
             double min = 0.0,
             double max = -1.0,
             uint8_t _minPointFormat = 0)
        : type(fieldType),
          sf(nullptr),
          firstValue(0.0),
          minValue(min),
          maxValue(max),
          defaultValue(defaultVal),
          minPointFormat(_minPointFormat) {}
 
    virtual inline QString getName() const {
        return type < LAS_INVALID ? QString(LAS_FIELD_NAMES[type]) : QString();
    }
 
    static bool GetLASFields(ccPointCloud* cloud,
                             std::vector<LasField>& fieldsToSave,
                             uint8_t& minPointFormat) {
        try {
            // official LAS fields
            std::vector<LasField> lasFields;
            lasFields.reserve(14);
            {
                lasFields.emplace_back(LAS_CLASSIFICATION, 0, 0, 255,
                                       0);  // unsigned char: between 0 and 255
                lasFields.emplace_back(LAS_CLASSIF_VALUE, 0, 0, 31,
                                       0);  // 5 bits: between 0 and 31
                lasFields.emplace_back(LAS_CLASSIF_SYNTHETIC, 0, 0, 1,
                                       0);  // 1 bit: 0 or 1
                lasFields.emplace_back(LAS_CLASSIF_KEYPOINT, 0, 0, 1,
                                       0);  // 1 bit: 0 or 1
                lasFields.emplace_back(LAS_CLASSIF_WITHHELD, 0, 0, 1,
                                       0);  // 1 bit: 0 or 1
                lasFields.emplace_back(LAS_CLASSIF_OVERLAP, 0, 0, 1,
                                       6);  // 1 bit: 0 or 1
                lasFields.emplace_back(LAS_INTENSITY, 0, 0, 65535,
                                       0);  // 16 bits: between 0 and 65536
                lasFields.emplace_back(LAS_TIME, 0, 0, -1.0,
                                       1);  // 8 bytes (double)
                lasFields.emplace_back(LAS_RETURN_NUMBER, 1, 1, 7,
                                       0);  // 3 bits: between 1 and 7
                lasFields.emplace_back(LAS_NUMBER_OF_RETURNS, 1, 1, 7,
                                       0);  // 3 bits: between 1 and 7
                lasFields.emplace_back(LAS_SCAN_DIRECTION, 0, 0, 1,
                                       0);  // 1 bit: 0 or 1
                lasFields.emplace_back(LAS_FLIGHT_LINE_EDGE, 0, 0, 1,
                                       0);  // 1 bit: 0 or 1
                lasFields.emplace_back(LAS_SCAN_ANGLE_RANK, 0, -90, 90,
                                       0);  // signed char: between -90 and +90
                lasFields.emplace_back(LAS_USER_DATA, 0, 0, 255,
                                       0);  // unsigned char: between 0 and 255
                lasFields.emplace_back(LAS_POINT_SOURCE_ID, 1, 0, 65535,
                                       0);  // 16 bits: between 1 and 65536
            }
 
            // we are going to check now the existing cloud SFs
            for (unsigned i = 0; i < cloud->getNumberOfScalarFields(); ++i) {
                ccScalarField* sf =
                        static_cast<ccScalarField*>(cloud->getScalarField(i));
                // find an equivalent in official LAS fields
                QString sfName = QString(sf->getName()).toUpper();
                bool outBounds = false;
                for (size_t j = 0; j < lasFields.size(); ++j) {
                    // if the name matches
                    if (sfName == lasFields[j].getName().toUpper()) {
                        // check bounds
                        double sfMin = sf->getGlobalShift() + sf->getMax();
                        double sfMax = sf->getGlobalShift() + sf->getMax();
                        if (sfMin < lasFields[j].minValue ||
                            (lasFields[j].maxValue != -1.0 &&
                             sfMax > lasFields[j].maxValue))  // outbounds?
                        {
                            CVLog::Warning(
                                    QString("[LAS] Found a '%1' scalar field, "
                                            "but its values outbound LAS "
                                            "specifications (%2-%3)...")
                                            .arg(sf->getName())
                                            .arg(lasFields[j].minValue)
                                            .arg(lasFields[j].maxValue));
                            outBounds = true;
                        } else {
                            // we add the SF to the list of saved fields
                            fieldsToSave.push_back(lasFields[j]);
                            fieldsToSave.back().sf = sf;
 
                            minPointFormat = std::max(
                                    minPointFormat,
                                    fieldsToSave.back().minPointFormat);
                        }
                        break;
                    }
                }
            }
        } catch (const std::bad_alloc&) {
            CVLog::Warning("[LasField::GetLASFields] Not enough memory");
            return false;
        }
 
        return true;
    }
 
    static unsigned GetFormatRecordLength(uint8_t pointFormat) {
        switch (pointFormat) {
            case 0:
                return 20;  // 0 - base
            case 1:
                return 20 + 8;  // 1 - base + GPS
            case 2:
                return 20 + 6;  // 2 - base + RGB
            case 3:
                return 20 + 8 + 6;  // 3 - base + GPS + RGB
            case 4:
                return 20 + 8 + 29;  // 4 - base + GPS + FWF
            case 5:
                return 20 + 8 + 6 + 29;  // 5 - base + GPS + FWF + RGB
            case 6:
                return 30;  // 6  - base (GPS included)
            case 7:
                return 30 + 6;  // 7  - base + RGB
            case 8:
                return 30 + 6 + 2;  // 8  - base + RGB + NIR (not used)
            case 9:
                return 30 + 29;  // 9  - base + FWF
            case 10:
                return 30 + 6 + 2 + 29;  // 10 - base + RGB + NIR + FWF
            default:
                assert(false);
                return 0;
        }
    }
 
    static uint8_t VersionMinorForPointFormat(uint8_t pointFormat) {
        return pointFormat >= 6 ? 4 : 2;
    }
 
    static uint8_t UpdateMinPointFormat(uint8_t minPointFormat,
                                        bool withRGB,
                                        bool withFWF,
                                        bool allowLegacyFormats = true) {
        // can we keep the (short) legacy formats?
        if (allowLegacyFormats && minPointFormat < 6) {
            // LAS formats:
            // 0 - base
            // 1 - base + GPS TIME
            // 2 - base + RGB
            // 3 - base + GPS + RGB
            // 4 - base + GPS + FWF
            // 5 - base + GPS + FWF + RGB
 
            if (withFWF) {
                // 0, 1 --> 4
                minPointFormat = std::max(minPointFormat, (uint8_t)4);
            }
 
            if (withRGB) {
                if (minPointFormat < 2) {
                    // 0 --> 2
                    // 1 --> 3
                    minPointFormat += 2;
                } else if (minPointFormat == 4) {
                    // 4 --> 5
                    minPointFormat = 5;
                }
                // else the format already has colors
            }
        } else  // we'll use extended versions (up to 15 returns, up to 256
                // classes for classification, higher precision scan angle)
        {
            // new LAS formats:
            // 6  - base (GPS included)
            // 7  - base + RGB
            // 8  - base + RGB + NIR (not used)
            // 9  - base + FWF
            // 10 - base + FWF + RGB + NIR
            assert(minPointFormat <= 6);  // in effect, standard LAS fields will
                                          // only require version 6 at most
 
            minPointFormat = std::max(minPointFormat, (uint8_t)6);
            // FWF data?
            if (withFWF) {
                // 6 --> 9
                minPointFormat = std::max(minPointFormat, (uint8_t)9);
            }
            // Colors?
            if (withRGB) {
                if (minPointFormat == 6) {
                    // 6 --> 7
                    minPointFormat = 7;
                } else if (minPointFormat == 9) {
                    // 9 --> 10
                    minPointFormat = 10;
                }
            }
        }
 
        return minPointFormat;
    }
 
    static QString SanitizeString(const QString& str) {
        QString sanitizedStr = str;
        sanitizedStr.replace('=', "_eq_");
        sanitizedStr.replace(' ', "__");
 
        if (sanitizedStr.size() > 32) {
            sanitizedStr = sanitizedStr.left(32);
        }
 
        return sanitizedStr;
    }
 
    static QString DesanitizeString(const QString& str) {
        QString desanitizedStr = str;
        desanitizedStr.replace("_eq_", "=");
        desanitizedStr.replace("__", " ");
 
        return desanitizedStr;
    }
 
    double getSafeValue(unsigned index) const {
        if (sf) {
            ScalarType value = sf->getValue(index);
 
            // PDAL doesn't accept NaN values
            if (cloudViewer::ScalarField::ValidValue(value)) {
                return value;
            } else {
                return defaultValue;
            }
        }
 
        assert(false);
        return defaultValue;
    }
 
    LAS_FIELDS type;
    ccScalarField* sf;
    double firstValue;
    double minValue;
    double maxValue;
    double defaultValue;
    uint8_t minPointFormat;
};