LasScalarFieldLoader.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
 
// ##########################################################################
// #                                                                        #
// #                CloudViewer PLUGIN: LAS-IO Plugin                      #
// #                                                                        #
// #  This program is free software; you can redistribute it and/or modify  #
// #  it under the terms of the GNU General Public License as published by  #
// #  the Free Software Foundation; version 2 of the License.               #
// #                                                                        #
// #  This program is distributed in the hope that it will be useful,       #
// #  but WITHOUT ANY WARRANTY; without even the implied warranty of        #
// #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         #
// #  GNU General Public License for more details.                          #
// #                                                                        #
// #                   COPYRIGHT: Thomas Montaigu                           #
// #                                                                        #
// ##########################################################################
 
#include "LasDetails.h"
#include "LasExtraScalarField.h"
#include "LasScalarField.h"
 
// DB
#include <FileIOFilter.h>
#include <ecvPointCloud.h>
 
// Qt
#include <QFileInfo>
 
// LASzip
#include <laszip/laszip_api.h>
 
class LasScalarFieldLoader
{
  public:
    LasScalarFieldLoader(std::vector<LasScalarField>&      standardScalarFields,
                         std::vector<LasExtraScalarField>& extraScalarFields,
                         ccPointCloud&                     pointCloud);
 
    CC_FILE_ERROR handleScalarFields(ccPointCloud& pointCloud, const laszip_point& currentPoint);
 
    CC_FILE_ERROR handleRGBValue(ccPointCloud& pointCloud, const laszip_point& currentPoint);
 
    CC_FILE_ERROR handleExtraScalarFields(ccPointCloud& pointCloud, const laszip_point& currentPoint);
 
    inline void setIgnoreFieldsWithDefaultValues(bool state)
    {
        m_ignoreFieldsWithDefaultValues = state;
    }
 
    inline void setForce8bitRgbMode(bool state)
    {
        m_force8bitRgbMode = state;
    }
 
    inline void setManualTimeShift(double timeShift)
    {
        m_manualTimeShiftValue = timeShift;
    }
 
    inline const std::vector<LasScalarField>& standardFields() const
    {
        return m_standardFields;
    }
 
    inline const std::vector<LasExtraScalarField>& extraFields() const
    {
        return m_extraScalarFields;
    }
 
  private:
    template <typename T>
    CC_FILE_ERROR handleScalarField(LasScalarField& sfInfo, ccPointCloud& pointCloud, T currentValue);
 
    CC_FILE_ERROR handleGpsTime(LasScalarField& sfInfo, ccPointCloud& pointCloud, double currentValue);
 
    bool createScalarFieldsForExtraBytes(ccPointCloud& pointCloud);
 
    template <typename T>
    static ScalarType ParseValueOfType(uint8_t* source);
 
    template <typename T, typename V>
    static V ParseValueOfTypeAs(const uint8_t* source);
 
    void parseRawValues(const LasExtraScalarField& extraField, const uint8_t* dataStart);
 
    template <typename T>
    void handleOptionsFor(const LasExtraScalarField& extraField, T values[3]);
 
  private:
    bool                              m_force8bitRgbMode{false};
    bool                              m_ignoreFieldsWithDefaultValues{true};
    double                            m_manualTimeShiftValue{std::numeric_limits<double>::quiet_NaN()};
    unsigned char                     m_colorCompShift{0};
    std::vector<LasScalarField>&      m_standardFields;
    std::vector<LasExtraScalarField>& m_extraScalarFields;
 
    union
    {
        uint64_t unsignedValues[LasExtraScalarField::MAX_DIM_SIZE];
        int64_t  signedValues[LasExtraScalarField::MAX_DIM_SIZE];
        double   floatingValues[LasExtraScalarField::MAX_DIM_SIZE];
    } m_rawValues;
};