ecvWaveform.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 "ecvGLMatrix.h"
#include "ecvSerializableObject.h"
 
// cloudViewer
#include <CVGeom.h>
 
// system
#include <cstdint>
#include <cstdlib>
 
class CV_DB_LIB_API WaveformDescriptor : public ccSerializableObject {
public:
    WaveformDescriptor();
 
    bool operator!=(const WaveformDescriptor& d) const;
 
    bool operator==(const WaveformDescriptor& d) const { return !(*this != d); }
 
    // inherited from ccSerializableObject
    bool isSerializable() const override { return true; }
    bool toFile(QFile& out, short dataVersion) const override;
    short minimumFileVersion() const override;
    bool fromFile(QFile& in,
                  short dataVersion,
                  int flags,
                  LoadedIDMap& oldToNewIDMap) override;
 
    uint32_t numberOfSamples;  
    uint32_t samplingRate_ps;  
    double digitizerGain;      
    double digitizerOffset;    
    uint8_t bitsPerSample;     
};
 
 
class CV_DB_LIB_API ccWaveform : public ccSerializableObject {
public:
    ccWaveform(uint8_t descriptorID = 0);
 
    ~ccWaveform() override = default;
 
 
    inline uint8_t descriptorID() const { return m_descriptorID; }
 
    inline void setDescriptorID(uint8_t id) { m_descriptorID = id; }
 
    void setDataDescription(uint64_t dataOffset, uint32_t byteCount);
 
    uint32_t getRawSample(uint32_t i,
                          const WaveformDescriptor& descriptor,
                          const uint8_t* dataStorage) const;
 
    double getSample(uint32_t i,
                     const WaveformDescriptor& descriptor,
                     const uint8_t* dataStorage) const;
 
    double getRange(double& minVal,
                    double& maxVal,
                    const WaveformDescriptor& descriptor,
                    const uint8_t* dataStorage) const;
 
    bool decodeSamples(std::vector<double>& values,
                       const WaveformDescriptor& descriptor,
                       const uint8_t* dataStorage) const;
 
    bool toASCII(const QString& filename,
                 const WaveformDescriptor& descriptor,
                 const uint8_t* dataStorage) const;
 
    static bool ToASCII(const QString& filename,
                        std::vector<double>& values,
                        uint32_t samplingRate_ps);
 
    CCVector3 getSamplePos(float i,
                           const CCVector3& P0,
                           const WaveformDescriptor& descriptor) const;
 
    inline uint32_t byteCount() const { return m_byteCount; }
 
    inline uint64_t dataOffset() const { return m_dataOffset; }
 
    inline void setDataOffset(uint64_t offset) { m_dataOffset = offset; }
 
    inline const uint8_t* data(const uint8_t* dataStorage) const {
        return dataStorage + m_dataOffset;
    }
 
    inline void setBeamDir(const CCVector3f& dir) { m_beamDir = dir; }
 
    inline const CCVector3f& beamDir() const { return m_beamDir; }
 
    inline void setEchoTime_ps(float time_ps) { m_echoTime_ps = time_ps; }
 
    inline float echoTime_ps() const { return m_echoTime_ps; }
 
    void applyRigidTransformation(const ccGLMatrix& trans);
 
    uint8_t returnIndex() const { return m_returnIndex; }
    void setReturnIndex(uint8_t index) { m_returnIndex = index; }
 
    // inherited from ccSerializableObject
    bool isSerializable() const override { return true; }
    bool toFile(QFile& out, short dataVersion) const override;
    short minimumFileVersion() const override;
    bool fromFile(QFile& in,
                  short dataVersion,
                  int flags,
                  LoadedIDMap& oldToNewIDMap) override;
 
protected:  // members
 
    uint32_t m_byteCount;
 
    uint64_t m_dataOffset;
 
 
    CCVector3f m_beamDir;
 
 
    float m_echoTime_ps;
 
 
    uint8_t m_descriptorID;
 
    uint8_t m_returnIndex;
};
 
 
class CV_DB_LIB_API ccWaveformProxy {
public:
    ccWaveformProxy(const ccWaveform& w,
                    const WaveformDescriptor& d,
                    const uint8_t* storage)
        : m_w(w), m_d(d), m_storage(storage) {}
 
    inline bool isValid() const {
        return m_storage && m_w.descriptorID() != 0 && m_d.numberOfSamples != 0;
    }
 
 
    inline uint8_t descriptorID() const { return m_w.descriptorID(); }
 
    inline uint32_t getRawSample(uint32_t i) const {
        return m_w.getRawSample(i, m_d, m_storage);
    }
 
    inline double getSample(uint32_t i) const {
        return m_w.getSample(i, m_d, m_storage);
    }
 
    inline double getRange(double& minVal, double& maxVal) const {
        return m_w.getRange(minVal, maxVal, m_d, m_storage);
    }
 
    inline bool decodeSamples(std::vector<double>& values) const {
        return m_w.decodeSamples(values, m_d, m_storage);
    }
 
    inline bool toASCII(const QString& filename) const {
        return m_w.toASCII(filename, m_d, m_storage);
    }
 
    inline CCVector3 getSamplePos(float i, const CCVector3& P0) const {
        return m_w.getSamplePos(i, P0, m_d);
    }
 
    inline uint32_t byteCount() const { return m_w.byteCount(); }
 
    inline const uint8_t* data() const { return m_w.data(m_storage); }
 
    inline const CCVector3f& beamDir() const { return m_w.beamDir(); }
 
    inline float echoTime_ps() const { return m_w.echoTime_ps(); }
 
    inline uint32_t numberOfSamples() const { return m_d.numberOfSamples; }
 
    inline const WaveformDescriptor& descriptor() const { return m_d; }
    inline const ccWaveform& waveform() const { return m_w; }
 
protected:  // members
    const ccWaveform& m_w;
    const WaveformDescriptor& m_d;
    const uint8_t* m_storage;
};