OptechScanner.h

#pragma once
#define OPTECH_RT_API 0
#if OPTECH_RT_API
#include "Hardware/Headers/Scanner3D.h"
#include "Hardware/Headers/GPSSensor.h"
#include "Widgets/Headers/PhysicalCameraView.h"
#include "Design/Headers/PolarPointFilter.h"
#include "Base/Headers/Time.h"
#include "Base/Headers/Pointer.hpp"
#include "Base/Headers/Thread.h"
#include "Base/Headers/INIInterface.h"
#include <Rt_Types.h>
#include <Rt_Integration.h>
#include <QObject>
#include <vector>
class ScannerDriver;
namespace NDEVR
{
    class FileRequest;
    class DesignObjectLookup;
    class Log;
    class OptechMotor;
    class Battery;
    class OptechScannerConnection;
    class OptechRangeSensor;
    class OptechScannerPositionSensor;
    class SocketIOChannel;
    class OptechBase;

    class OptechScanner : public Scanner3D, public INIInterface
    {
        Q_OBJECT
    public:
        OptechScanner(Connection* connection, DesignObjectLookup* manager, Log* log, QObject* parent = nullptr);
        virtual ~OptechScanner();
        virtual TimeSpan updateInterval() const override;
 
        virtual TimeSpan getScanTime(ScanMode scan, fltp04 speed, Vector<2, Angle> angle_of_separation) const override;
        virtual String scannerType() const override;
        virtual void standardUpdate();
        virtual Motor* headMotor(uint01 axis) const override;
        virtual void startScan(ScanMode scan_mode, fltp04 speed, Vector<2, Angle> angle_of_separation, bool continuous) override;
        virtual void stopScan() override;
        virtual void pauseScan() override;
        virtual void resumeScan() override;
        virtual void createScanner() override;
        virtual bool isValid() const override;
        virtual bool canDeploy() const override;
        void updateCamera();
        virtual void recordPoint(bool record_to_cloud = true, bool record_to_mesh = true) override;
        Vector<3, Angle> headAngle() const override;
 
        virtual void orientHead(const Vector<3, Angle>& head_orientation) override;
        virtual bool supportsContinuousScan() const override { return false; }
        virtual bool executeManualCommand(const String& command) override;
        virtual bool scanModeSupported(ScanMode scan_mode) const override;
        virtual Bounds<2, Angle> scanBounds() const;
        void requestDisconnect(bool disconnect) { m_request_disconnect = disconnect; }
        virtual String defaultStationName() const override;
        virtual void setScannerState(ScannerState scanner_state) override;
        virtual PositionSensor* positionSensor() const override;
        virtual RangeSensor* rangeSensor() const override;
        ScannerState scannerState() const override;
 
        virtual Connection* connection() const override;
        bool requestRemoteForwarding() override;
        [[nodiscard]] virtual Buffer<Battery*> batteries() const;
        [[nodiscard]] virtual Buffer<TemperatureSensor*> temperatureSensors() const;
        [[nodiscard]] virtual OrientationSensor* orientationSensor() const;
 
    
    protected:
        void updateModel();
        void setSerialNo(int serial);
        void recordPoint(const PolarScanRecord& record, bool record_to_cloud = true, bool record_to_mesh = true) override;
        virtual FileRequest scanModelFile() const override;
        virtual Matrix<fltp08> scanModelFileTransform() const;
        virtual void update() override;
        void parkDevice() override;
        Matrix<fltp08> laserTransform(const Vector<3, Angle>& head_angle) const override;
        virtual Matrix<fltp08> scanTransform() const;
        virtual INIFactory getINI() override;
        void disconnect();
 
 
    protected:
        bool updateState();
        int ProcessPoints(std::vector<Optech::RtLidar::LidarPoint>& lidarPointsArray);
        struct BinaryFrameData
        {
            uint02 measurement_data_points;          
            TypeAngle<fltp08> rotation_speed;        
            TypeAngle<fltp08> resolution;             
            uint01 time_status;                       
            Time frame_time;                          
        };
        Optech::RtLidar::ScannerType m_scanner_type;
        Optech::RtLidar::SelectedReturn m_selected_return;
        Optech::RtLidar::SystemState m_optech_scanner_state;
        Optech::RtLidar::ConnectionState m_connection_state;
        
        Time m_start_time;
 
        Time m_last_standard_refresh;
        bool m_is_valid;
        bool m_responses_on;
        Angle m_current_angle;
        PolarPointFilter m_filter;
        Vector<3, Angle> m_beam_offset;
        Vertex<3, fltp08> m_last_position;
        Vertex<3, fltp08> m_velocity;
        Bounds<1, Angle> m_angle_bounds;
        mutable Time m_last_scan_update_time;
        mutable Time m_last_prop_update_time;
        mutable String m_station_name;
        bool m_is_dynamic;
        bool m_use_filter;
        bool m_record_points;
        bool m_motion_only;
        bool m_has_reference;
        bool m_is_initializing_scan;
        Bounds<1, Angle> m_current_sweep_bounds;
        String m_connection_string;
        Motor* m_scope = nullptr;
        Motor* m_head = nullptr;
        Connection* m_connection = nullptr;
        OptechScannerPositionSensor* m_position_sensor = nullptr;
        RangeSensor* m_range_sensor = nullptr;
        SurveyParameters m_survey_parameters;
        TemperatureSensor* m_booster_temp = nullptr;
        TemperatureSensor* m_prepump_temp = nullptr;
        TemperatureSensor* m_seed_temp = nullptr;
        TemperatureSensor* m_case_temp = nullptr;
        Battery* m_battery = nullptr;
 
        GPSSensor* m_gps_sensor;
        OrientationSensor* m_orientation_sensor = nullptr;
    };
}
#endif