LasScalarFieldSaver.cpp

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#include "LasScalarFieldSaver.h"
 
#include <ecvScalarField.h>
#include <laszip/laszip_api.h>
 
LasScalarFieldSaver::LasScalarFieldSaver(std::vector<LasScalarField>&&      standardFields,
                                         std::vector<LasExtraScalarField>&& extraFields)
    : m_standardFields(standardFields)
    , m_extraFields(extraFields)
{
}
 
void LasScalarFieldSaver::handleScalarFields(size_t pointIndex, laszip_point& point)
{
    for (const LasScalarField& field : m_standardFields)
    {
        Q_ASSERT_X(field.sf != nullptr, __func__, "LasScalarField has a null ptr to ccScalarField");
        ScalarType value = field.sf->getValue(pointIndex);
        value            = std::max(field.range.min, value);
        value            = std::min(field.range.max, value);
        switch (field.id)
        {
        case LasScalarField::Intensity:
            if (field.sf)
            {
                point.intensity = static_cast<laszip_U16>(value);
            }
            break;
        case LasScalarField::ReturnNumber:
            if (field.sf)
            {
                point.return_number = static_cast<laszip_U8>(value);
            }
            break;
        case LasScalarField::NumberOfReturns:
            if (field.sf)
            {
                point.number_of_returns = static_cast<laszip_U8>(value);
            }
            break;
        case LasScalarField::ScanDirectionFlag:
            if (field.sf)
            {
                point.scan_direction_flag = (static_cast<laszip_U8>(value) > 0);
            }
            break;
        case LasScalarField::EdgeOfFlightLine:
            if (field.sf)
            {
                point.edge_of_flight_line = (static_cast<laszip_U8>(value) > 0);
            }
            break;
        case LasScalarField::Classification:
            if (field.sf)
            {
                point.classification = static_cast<laszip_U8>(value);
            }
        case LasScalarField::SyntheticFlag:
            if (field.sf)
            {
                point.synthetic_flag = (static_cast<laszip_U8>(value) > 0);
            }
            break;
        case LasScalarField::KeypointFlag:
            if (field.sf)
            {
                point.keypoint_flag = (static_cast<laszip_U8>(value) > 0);
            }
            break;
        case LasScalarField::WithheldFlag:
            if (field.sf)
            {
                point.withheld_flag = (static_cast<laszip_U8>(value) > 0);
            }
            break;
        case LasScalarField::ScanAngleRank:
            if (field.sf)
            {
                point.scan_angle_rank = static_cast<laszip_I8>(value);
            }
        case LasScalarField::UserData:
            if (field.sf)
            {
                point.user_data = static_cast<laszip_U8>(value);
            }
            break;
        case LasScalarField::PointSourceId:
            if (field.sf)
            {
                point.point_source_ID = static_cast<laszip_U16>(value);
            }
            break;
        case LasScalarField::GpsTime:
            if (field.sf)
            {
                point.gps_time = static_cast<laszip_F64>(value) + field.sf->getGlobalShift();
            }
            break;
        case LasScalarField::ExtendedScanAngle:
            if (field.sf)
            {
                point.extended_scan_angle = static_cast<laszip_I16>(value / SCAN_ANGLE_SCALE);
            }
            break;
        case LasScalarField::ExtendedScannerChannel:
            if (field.sf)
            {
                point.extended_scanner_channel = static_cast<laszip_U8>(value);
            }
            break;
        case LasScalarField::OverlapFlag:
            if (field.sf)
            {
                point.extended_classification_flags |= (static_cast<laszip_U8>(value) > 0) ? LasDetails::OVERLAP_FLAG_BIT_MASK : 0;
            }
            break;
        case LasScalarField::ExtendedClassification:
            if (field.sf)
            {
                point.extended_classification = static_cast<laszip_U8>(value);
            }
            break;
        case LasScalarField::ExtendedReturnNumber:
            if (field.sf)
            {
                point.extended_return_number = static_cast<laszip_U16>(value);
            }
            break;
        case LasScalarField::ExtendedNumberOfReturns:
            if (field.sf)
            {
                point.extended_number_of_returns = static_cast<laszip_U16>(value);
            }
            break;
        case LasScalarField::NearInfrared:
            if (field.sf)
            {
                point.rgb[3] = static_cast<laszip_U16>(value);
            }
            break;
        }
    }
}
 
void LasScalarFieldSaver::handleExtraFields(size_t pointIndex, laszip_point& point)
{
    if (point.num_extra_bytes == 0 || point.extra_bytes == nullptr)
    {
        return;
    }
 
    ScalarType values[LasExtraScalarField::MAX_DIM_SIZE] = {0.0};
 
    for (const LasExtraScalarField& extraField : m_extraFields)
    {
        laszip_U8* dataStart = point.extra_bytes + extraField.byteOffset;
 
        assert(extraField.byteOffset < static_cast<unsigned>(point.num_extra_bytes));
        assert(extraField.byteOffset + extraField.byteSize() <= static_cast<unsigned>(point.num_extra_bytes));
 
        for (size_t elemIndex{0}; elemIndex < extraField.numElements(); ++elemIndex)
        {
            values[elemIndex] = (*extraField.scalarFields[elemIndex])[pointIndex];
        }
 
        if (extraField.scaleIsRelevant() || extraField.offsetIsRelevant())
        {
            assert(extraField.numElements() <= 3);
            for (size_t elemIndex{0}; elemIndex < extraField.numElements(); ++elemIndex)
            {
                values[elemIndex] = (values[elemIndex] - extraField.offsets[elemIndex]) / extraField.scales[elemIndex];
            }
        }
 
        for (unsigned i = 0; i < extraField.numElements(); i++)
        {
            switch (extraField.type)
            {
            case LasExtraScalarField::u8:
                WriteScalarValueAs<uint8_t>(values[i], dataStart);
                break;
            case LasExtraScalarField::u16:
                WriteScalarValueAs<uint16_t>(values[i], dataStart);
                break;
            case LasExtraScalarField::u32:
                WriteScalarValueAs<uint32_t>(values[i], dataStart);
                break;
            case LasExtraScalarField::u64:
                WriteScalarValueAs<uint64_t>(values[i], dataStart);
                break;
            case LasExtraScalarField::i8:
                WriteScalarValueAs<int8_t>(values[i], dataStart);
                break;
            case LasExtraScalarField::i16:
                WriteScalarValueAs<int16_t>(values[i], dataStart);
                break;
            case LasExtraScalarField::i32:
                WriteScalarValueAs<int32_t>(values[i], dataStart);
                break;
            case LasExtraScalarField::i64:
                WriteScalarValueAs<int64_t>(values[i], dataStart);
                break;
            case LasExtraScalarField::f32:
                WriteScalarValueAs<float>(values[i], dataStart);
                break;
            case LasExtraScalarField::f64:
                WriteScalarValueAs<double>(values[i], dataStart);
                break;
            case LasExtraScalarField::Undocumented:
            case LasExtraScalarField::Invalid:
                break;
            }
            dataStart += extraField.elementSize();
        }
    }
}