ecvGBLSensor.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 "LineSet.h"
#include "ecvDepthBuffer.h"
#include "ecvOrientedBBox.h"
#include "ecvSensor.h"
 
// CV_CORE_LIB
#include <GenericCloud.h>
 
class ccPointCloud;
 
 
class CV_DB_LIB_API ccGBLSensor : public ccSensor {
public:
 
    enum ROTATION_ORDER { YAW_THEN_PITCH = 0, PITCH_THEN_YAW = 1 };
 
 
    explicit ccGBLSensor(ROTATION_ORDER rotOrder = YAW_THEN_PITCH);
 
 
    ccGBLSensor(const ccGBLSensor& sensor);
 
    ~ccGBLSensor() override = default;
 
    // inherited from ccHObject
    CV_CLASS_ENUM getClassID() const override { return CV_TYPES::GBL_SENSOR; }
    bool isSerializable() const override { return true; }
    ccBBox getOwnBB(bool withGLFeatures = false) override;
    ccBBox getOwnFitBB(ccGLMatrix& trans) override;
 
    virtual void clearDrawings() override;
    virtual void hideShowDrawings(CC_DRAW_CONTEXT& context) override;
 
    // inherited from ccSensor
    bool applyViewport() override;
 
 
    unsigned char checkVisibility(const CCVector3& P) const override;
 
 
    bool computeAutoParameters(cloudViewer::GenericCloud* theCloud);
 
 
    static QString GetErrorString(int errorCode);
 
public:  // setters and getters
 
    void setPitchRange(PointCoordinateType minPhi, PointCoordinateType maxPhi);
 
    inline PointCoordinateType getMinPitch() const { return m_phiMin; }
 
    inline PointCoordinateType getMaxPitch() const { return m_phiMax; }
 
 
    void setPitchStep(PointCoordinateType dPhi);
 
    inline PointCoordinateType getPitchStep() const { return m_deltaPhi; }
 
    bool pitchIsShifted() const { return m_pitchAnglesAreShifted; }
 
 
    void setYawRange(PointCoordinateType minTheta,
                     PointCoordinateType maxTheta);
 
    inline PointCoordinateType getMinYaw() const { return m_thetaMin; }
 
    inline PointCoordinateType getMaxYaw() const { return m_thetaMax; }
 
 
    void setYawStep(PointCoordinateType dTheta);
 
    inline PointCoordinateType getYawStep() const { return m_deltaTheta; }
 
    bool yawIsShifted() const { return m_yawAnglesAreShifted; }
 
    inline PointCoordinateType getSensorRange() const { return m_sensorRange; }
 
 
    inline void setSensorRange(PointCoordinateType range) {
        m_sensorRange = range;
    }
 
    inline PointCoordinateType getUncertainty() const { return m_uncertainty; }
 
 
    inline void setUncertainty(PointCoordinateType u) { m_uncertainty = u; }
 
    ROTATION_ORDER getRotationOrder() const { return m_rotationOrder; }
 
 
    inline void setRotationOrder(ROTATION_ORDER rotOrder) {
        m_rotationOrder = rotOrder;
    }
 
public:  // projection tools
 
    void projectPoint(const CCVector3& sourcePoint,
                      CCVector2& destPoint,
                      PointCoordinateType& depth,
                      double posIndex = 0) const;
 
    using NormalGrid = std::vector<CCVector3>;
 
 
    NormalGrid* projectNormals(cloudViewer::GenericCloud* cloud,
                               const NormalGrid& norms,
                               double posIndex = 0) const;
 
    using ColorGrid = std::vector<ecvColor::Rgb>;
 
 
    ColorGrid* projectColors(cloudViewer::GenericCloud* cloud,
                             const ColorGrid& rgbColors) const;
 
public:  // depth buffer management
 
    bool computeDepthBuffer(cloudViewer::GenericCloud* cloud,
                            int& errorCode,
                            ccPointCloud* projectedCloud = nullptr);
 
 
    inline const ccDepthBuffer& getDepthBuffer() const { return m_depthBuffer; }
 
    void clearDepthBuffer();
 
    const cloudViewer::geometry::LineSet& getSensorLegLines() const {
        return m_leg;
    }
    const cloudViewer::geometry::LineSet& getSensorAxis() const {
        return m_axis;
    }
    const ecvOrientedBBox& getSensorHead() const { return m_obbHead; }
 
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;
    void drawMeOnly(CC_DRAW_CONTEXT& context) override;
 
    bool convertToDepthMapCoords(PointCoordinateType yaw,
                                 PointCoordinateType pitch,
                                 unsigned& i,
                                 unsigned& j) const;
 
 
    PointCoordinateType m_phiMin;
 
    PointCoordinateType m_phiMax;
    PointCoordinateType m_deltaPhi;
    bool m_pitchAnglesAreShifted;
 
 
    PointCoordinateType m_thetaMin;
 
    PointCoordinateType m_thetaMax;
    PointCoordinateType m_deltaTheta;
    bool m_yawAnglesAreShifted;
 
    ROTATION_ORDER m_rotationOrder;
 
    PointCoordinateType m_sensorRange;
    PointCoordinateType m_uncertainty;
 
    ccDepthBuffer m_depthBuffer;
 
    ecvOrientedBBox m_obbHead;
    cloudViewer::geometry::LineSet m_leg;
    cloudViewer::geometry::LineSet m_axis;
};