ecvSensor.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 "ecvColorTypes.h"
#include "ecvIndexedTransformationBuffer.h"
 
enum CC_SENSOR_TYPE {
    UNKNOWN_SENSOR,
    GROUND_BASED_LIDAR,
};
 
 
class CV_DB_LIB_API ccSensor : public ccHObject {
public:
    ccSensor(QString name);
 
    ccSensor(const ccSensor& sensor);
 
    // inherited from ccHObject
    virtual CV_CLASS_ENUM getClassID() const override {
        return CV_TYPES::SENSOR;
    }
    virtual bool isSerializable() const override { return true; }
 
    virtual void clearDrawings();
    virtual void hideShowDrawings(CC_DRAW_CONTEXT& context);
 
 
    virtual CC_SENSOR_TYPE getType() const { return UNKNOWN_SENSOR; }
 
 
    virtual inline unsigned char checkVisibility(const CCVector3& P) const {
        return POINT_VISIBLE;
    }
 
    ccIndexedTransformationBuffer* getPositions() { return m_posBuffer; }
 
    void setPositions(ccIndexedTransformationBuffer* positions) {
        m_posBuffer = positions;
    }
 
 
    bool addPosition(ccGLMatrix& trans, double index);
 
 
    bool getAbsoluteTransformation(ccIndexedTransformation& trans,
                                   double index) const;
 
    bool getActiveAbsoluteTransformation(ccIndexedTransformation& trans) const;
 
    bool getActiveAbsoluteCenter(CCVector3& vec) const;
 
    bool getActiveAbsoluteRotation(ccGLMatrix& rotation) const;
 
 
    virtual void setRigidTransformation(const ccGLMatrix& mat) {
        m_rigidTransformation = mat;
    }
 
    virtual ccGLMatrix& getRigidTransformation() {
        return m_rigidTransformation;
    }
 
    virtual const ccGLMatrix& getRigidTransformation() const {
        return m_rigidTransformation;
    }
 
    void getIndexBounds(double& minIndex, double& maxIndex) const;
 
    double getActiveIndex() const { return m_activeIndex; }
 
    void setActiveIndex(double index) { m_activeIndex = index; }
 
    void setGraphicScale(PointCoordinateType scale) { m_scale = scale; }
 
    PointCoordinateType getGraphicScale() const { return m_scale; }
 
    void setFrameColor(ecvColor::Rgb color) { m_color = color; }
    const ecvColor::Rgb& getFrameColor() const { return m_color; }
 
 
    virtual bool applyViewport();
 
    // inherited from ccHObject
    virtual void applyGLTransformation(const ccGLMatrix& trans) override;
 
protected:
    // inherited from ccHObject
    bool toFile_MeOnly(QFile& out, short dataVersion) const override;
    short minimumFileVersion_MeOnly() const override;
    bool fromFile_MeOnly(QFile& in,
                         short dataVersion,
                         int flags,
                         LoadedIDMap& oldToNewIDMap) override;
 
    ccIndexedTransformationBuffer* m_posBuffer;
 
 
    ccGLMatrix m_rigidTransformation;
 
    double m_activeIndex;
 
 
    ecvColor::Rgb m_color;
 
    PointCoordinateType m_scale;
};