ecvWaveform.cpp

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#include "ecvWaveform.h"
 
// Qt
#include <QtCompat.h>
 
#include <QDataStream>
#include <QFile>
 
WaveformDescriptor::WaveformDescriptor()
    : numberOfSamples(0),
      samplingRate_ps(0),
      digitizerGain(0),
      digitizerOffset(0),
      bitsPerSample(0) {}
 
bool WaveformDescriptor::operator!=(const WaveformDescriptor& d) const {
    return d.bitsPerSample != bitsPerSample ||
           d.digitizerGain != digitizerGain ||
           d.digitizerOffset != digitizerOffset ||
           d.numberOfSamples != numberOfSamples ||
           d.samplingRate_ps != samplingRate_ps;
}
 
bool WaveformDescriptor::toFile(QFile& out, short dataVersion) const {
    // Version validation
    if (dataVersion < 44) {
        assert(false);
        return false;
    }
 
    QDataStream outStream(&out);
 
    // dataVersion >= 44
    outStream << numberOfSamples;
    outStream << samplingRate_ps;
    outStream << digitizerGain;
    outStream << digitizerOffset;
    outStream << bitsPerSample;
 
    return true;
}
 
short WaveformDescriptor::minimumFileVersion() const { return 44; }
 
bool WaveformDescriptor::fromFile(QFile& in,
                                  short dataVersion,
                                  int flags,
                                  LoadedIDMap& oldToNewIDMap) {
    QDataStream inStream(&in);
 
    if (dataVersion < 44) return false;
 
    // dataVersion >= 44
    inStream >> numberOfSamples;
    inStream >> samplingRate_ps;
    inStream >> digitizerGain;
    inStream >> digitizerOffset;
    inStream >> bitsPerSample;
 
    return true;
}
 
ccWaveform::ccWaveform(uint8_t descriptorID /*=0*/)
    : m_byteCount(0),
      m_dataOffset(0),
      m_beamDir(0, 0, 0),
      m_echoTime_ps(0),
      m_descriptorID(descriptorID),
      m_returnIndex(1) {}
 
void ccWaveform::setDataDescription(uint64_t dataOffset, uint32_t byteCount) {
    m_dataOffset = dataOffset;
    m_byteCount = byteCount;
}
 
uint32_t ccWaveform::getRawSample(uint32_t i,
                                  const WaveformDescriptor& descriptor,
                                  const uint8_t* dataStorage) const {
    if (!dataStorage) {
        assert(false);
        return 0;
    }
 
    const uint8_t* _data = data(dataStorage);
    switch (descriptor.bitsPerSample) {
        case 8:
            return _data[i];
 
        case 16:
            return reinterpret_cast<const uint16_t*>(_data)[i];
 
        case 24: {
            uint32_t v = *reinterpret_cast<const uint32_t*>(_data + 3 * i);
            //'hide' the 4th byte
            static const uint32_t Byte4Mask = 0x0FFF;
            v &= Byte4Mask;
            return v;
        }
 
        case 32:
            return reinterpret_cast<const uint32_t*>(_data)[i];
 
        default:  // other 'strange' bps values ;)
        {
            uint32_t firstBitIndex = descriptor.bitsPerSample * i;
            uint32_t firstByteIndex = (firstBitIndex >> 3);  // = divide by 8
 
            uint32_t lastBitIndex =
                    firstBitIndex + descriptor.bitsPerSample - 1;
            uint32_t lastByteIndex = (lastBitIndex >> 3);  // = divide by 8
            if (lastByteIndex >= m_byteCount) {
                assert(false);
                return 0;
            }
 
            // last byte (may be the first one!)
            uint32_t value = _data[lastByteIndex];
            {
                // number of bits used in the current byte
                uint32_t r = ((lastByteIndex + 1) % 8);
                if (r != 0) {
                    // we keep only the used bits
                    value &= ((1 << r) - 1);
                }
            }
 
            // other bytes (if any)
            while (lastByteIndex != firstByteIndex) {
                --lastByteIndex;
                value <<= 8;
                value |= _data[lastByteIndex];
            }
 
            // remove the first unused bits (if any)
            {
                uint32_t r = firstBitIndex - 8 * firstByteIndex;
                if (r != 0) {
                    value >>= r;
                }
            }
 
            return value;
        }
    }
 
    // we should never arrive here
    assert(false);
    return 0;
}
 
double ccWaveform::getSample(uint32_t i,
                             const WaveformDescriptor& descriptor,
                             const uint8_t* dataStorage) const {
    uint32_t raw = getRawSample(i, descriptor, dataStorage);
 
    return descriptor.digitizerGain * raw + descriptor.digitizerOffset;
}
 
bool ccWaveform::decodeSamples(std::vector<double>& values,
                               const WaveformDescriptor& descriptor,
                               const uint8_t* dataStorage) const {
    try {
        values.resize(descriptor.numberOfSamples);
        for (uint32_t i = 0; i < descriptor.numberOfSamples; ++i) {
            values[i] = getSample(i, descriptor, dataStorage);
        }
    } catch (const std::bad_alloc&) {
        // not enough memory
        return false;
    }
 
    return true;
}
 
bool ccWaveform::toASCII(const QString& filename,
                         const WaveformDescriptor& descriptor,
                         const uint8_t* dataStorage) const {
    if (descriptor.numberOfSamples == 0) {
        assert(false);
        return false;
    }
 
    std::vector<double> values;
    if (!decodeSamples(values, descriptor, dataStorage)) {
        CVLog::Warning(QString("[ccWaveform::toASCII] Not enough memory"));
        return false;
    }
 
    return ToASCII(filename, values, descriptor.samplingRate_ps);
}
 
bool ccWaveform::ToASCII(const QString& filename,
                         std::vector<double>& values,
                         uint32_t samplingRate_ps) {
    QFile file(filename);
    if (!file.open(QFile::Text | QFile::WriteOnly)) {
        CVLog::Warning(QString("[ccWaveform::toASCII] Failed to open file '%1' "
                               "for writing")
                               .arg(filename));
        return false;
    }
 
    QTextStream stream(&file);
    stream.setRealNumberPrecision(6);
    stream.setRealNumberNotation(QTextStream::FixedNotation);
    stream << "//time(ps);intensity" << QtCompat::endl;
 
    for (uint32_t i = 0; i < values.size(); ++i) {
        stream << i * samplingRate_ps << ";" << values[i] << QtCompat::endl;
    }
 
    file.close();
    CVLog::Print(QString("[ccWaveform::toASCII] File '%1' has been saved "
                         "successfully")
                         .arg(filename));
 
    return true;
}
 
double ccWaveform::getRange(double& minVal,
                            double& maxVal,
                            const WaveformDescriptor& descriptor,
                            const uint8_t* dataStorage) const {
    if (descriptor.numberOfSamples == 0) {
        assert(false);
        minVal = maxVal = std::numeric_limits<double>::quiet_NaN();
        return 0.0;
    } else {
        minVal = maxVal = getSample(0, descriptor, dataStorage);
    }
 
    for (uint32_t i = 1; i < descriptor.numberOfSamples; ++i) {
        double c = getSample(i, descriptor, dataStorage);
        maxVal = std::max(maxVal, c);
        minVal = std::min(minVal, c);
    }
 
    return maxVal - minVal;
}
 
CCVector3 ccWaveform::getSamplePos(float index,
                                   const CCVector3& P0,
                                   const WaveformDescriptor& descriptor) const {
    float delta_ps = m_echoTime_ps - index * descriptor.samplingRate_ps;
    return P0 + CCVector3::fromArray(m_beamDir.u) * delta_ps;
}
 
void ccWaveform::applyRigidTransformation(const ccGLMatrix& trans) {
    // we apply only the rotation
    CCVector3 u = CCVector3::fromArray(m_beamDir.u);
    trans.applyRotation(u);
    m_beamDir = CCVector3f::fromArray(u.u);
}
 
bool ccWaveform::toFile(QFile& out, short dataVersion) const {
    // Version validation
    if (dataVersion < 46) {
        assert(false);
        return false;
    }
 
    QDataStream outStream(&out);
 
    // dataVersion >= 46
    outStream << m_descriptorID;
    if (m_descriptorID != 0)  // no need to save invalid waveforms
    {
        outStream << m_byteCount;
        outStream << static_cast<quint64>(
                m_dataOffset);  // see comment below (in 'fromFile')
        outStream << m_beamDir.x;
        outStream << m_beamDir.y;
        outStream << m_beamDir.z;
        outStream << m_echoTime_ps;
        // dataVersion >= 47
        if (dataVersion >= 47) {
            outStream << m_returnIndex;
        }
    }
 
    return true;
}
 
short ccWaveform::minimumFileVersion() const {
    // Return index requires version 47, otherwise 46 is sufficient
    return (m_returnIndex != 1) ? 47 : 46;
}
 
bool ccWaveform::fromFile(QFile& in,
                          short dataVersion,
                          int flags,
                          LoadedIDMap& oldToNewIDMap) {
    QDataStream inStream(&in);
 
    if (dataVersion < 46) return false;
 
    // dataVersion >= 46
    inStream >> m_descriptorID;
    if (m_descriptorID != 0) {
        inStream >> m_byteCount;
 
        // for compilation on gcc/clang, we need to be 'more explicit'...
        //(apparently uint64_t is not 'evidently' casted to quint64?!)
        quint64 dataOffset;
        inStream >> dataOffset;
        m_dataOffset = static_cast<uint64_t>(dataOffset);
 
        inStream >> m_beamDir.x;
        inStream >> m_beamDir.y;
        inStream >> m_beamDir.z;
        inStream >> m_echoTime_ps;
 
        if (dataVersion > 46) {
            // dataVersion >= 47
            inStream >> m_returnIndex;
        } else {
            m_returnIndex = 1;
        }
    }
 
    return true;
}