Scanner3D.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Hardware
File: Scanner3D
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#if NDEVR_SCAN
#include <NDEVR/Device.h>
#include <NDEVR/PointScannerOptions.h>
#include <NDEVR/MaterialRaster.h>
#include <NDEVR/SnapLocation.h>
#include <NDEVR/Scan.h>
#include <NDEVR/Matrix.h>
#include <NDEVR/UUID.h>
#include <NDEVR/Time.h>
#include <NDEVR/Plane.h>
#include <NDEVR/Pointer.h>
#include <NDEVR/Vector.h>
class ScannerDriver;
namespace NDEVR
{
    struct FileRequest;
    class Scanner3D;
    class DesignObjectLookup;
    class TemperatureSensor;
    class Log;
    class Camera;
    class OrientationSensor;
    class Battery;
    class PositionSensor;
    class Light;
    class Winch;
    class BasicThread;
    class RangeSensor;
    class Connection;
    class Motor;
    class RotationBounds;
    class DistanceEncoder;
    enum ScannerState
    {
          e_scan_ready          
        , e_scanning            
        , e_movement            
        , e_manual_mode         
        , e_remote_mode         
        , e_motor_control       
        , e_measure             
        , e_maintenance_mode    
        , e_disconnected        
        , e_error               
    };

    enum class ScanPointType
    {
          e_normal              
        , e_calibrate_circle_a  
        , e_calibrate_circle_b  
        , e_calibrate_circle_c  
    };
    struct ScanSpeedProfile
    {
        ScanSpeedProfile();
        ScanSpeedProfile(TranslatedString title, fltp04 speed)
            : title(title)
            , speed(speed)
        {}
        TranslatedString title;
        fltp04 speed;
    };
    struct PolarScanResolutionInfo
    {
        Bounds<2, Angle<fltp08>> bounds;
        Vector<2, Angle<fltp08>> step = Vector<2, Angle<fltp08>>(Angle<fltp08>(DEGREES, 2.0));
        uint01 primary_angle = ROLL;
    };
    struct CartesianScanResolutionInfo
    {
        Bounds<3, fltp08> bounds = Bounds<3, fltp08>(-100.0, 100.0);
        Vector<2, fltp08> step = Vector<2, fltp08>(0.01);
    };

    enum ScanResolutionType
    {
          e_polar       
        , e_cartesian   
    };
    struct ScanProfile
    {
        UUID id = Constant<UUID>::Invalid;
        TranslatedString title;
        TranslatedString description;
        String icon;
        Buffer<ScanSpeedProfile> scan_speed_profiles;
        ScanResolutionType scan_resolution_type = ScanResolutionType::e_polar;
        CartesianScanResolutionInfo cartesian_scan_info;
        PolarScanResolutionInfo polar_scan_info;
        bool editable_bounds = true;
        bool editable_step = true;
        bool supports_raster = false;
        bool editable_raster = false;
        bool is_deployment_scan = false;
        bool is_stationary_scan = true;
        bool force_camera_visible = false;
        bool request_custom_camera_profile = false;
        bool force_video_record = false;
        bool no_point_collection = false;
        bool is_global_bounds = false;
        bool prefer_large_scanner_camera = false;
    };
    struct POINT_SCANNER_API Scanner3DScanSettings
    {
        UUID scan_profile_id;
        ScanProfile profile;
        fltp04 speed = 1.0f;
        RasterInfo raster_info;
        CartesianScanResolutionInfo cartesian_scan_info;
        PolarScanResolutionInfo polar_scan_info;
        bool is_child_of_station = true;
        void logInfo(LogPtr log) const;
    };
    struct ActiveScanStatus
    {
        TranslatedString status_message;
        String status_icon;
        TimeSpan time_remaining = Constant<TimeSpan>::Invalid;
        Time start_time = Constant<Time>::Invalid;
        RGBColor status_color = Constant<RGBColor>::Invalid;
        fltp04 percent = Constant<fltp04>::Invalid;
        bool show_status = false;
    };
    class POINT_SCANNER_API Scanner3D : public Device
    {
        Q_OBJECT
    public:
        Scanner3D(DesignObjectLookup* lookup, const Model& model, LogPtr log, QObject* parent = nullptr);
        ~Scanner3D();
 
        virtual void createScanner() = 0;
        virtual void parkDevice() {}
        [[nodiscard]] virtual Matrix<fltp08> scanModelFileTransform() const = 0;
        [[nodiscard]] virtual Matrix<fltp08> prismModelFileTransform() const;
        [[nodiscard]] virtual bool supportsState(ScannerState state) const;
        virtual void startScan(const Scanner3DScanSettings& settings) = 0;
        [[nodiscard]] virtual Buffer<ScanProfile> availableScanProfiles() const = 0;
        [[nodiscard]] virtual ScanProfile scanProfile(UUID id) const;
        [[nodiscard]] virtual Plane<3, fltp08> scanPlane(const ScanProfile& profile, uint01 dimension) const;
        [[nodiscard]] virtual Vertex<3, fltp08> scanOrigin(const ScanProfile& profile, uint01 dimension) const;
 
        virtual void addImageToRaster(const ImageData& data, const Vector<2, Angle<sint04>>& fov, const Matrix<fltp08>& camera_matrix);
        virtual void addCameraDrapeFunction(const StringView& id, std::function<void()> function);
        virtual void removeCameraDrapeFunction(const StringView& id);
        [[nodiscard]] ActiveScanStatus scanStatus() const { return m_scan_status; };
        [[nodiscard]] virtual RasterInfo defaultRasterInfo(const UUID& profile) const;
        [[nodiscard]] virtual bool supportsScanImageRaster() const { return false; }
 
        [[nodiscard]] virtual bool rollLocked() const { return false; }
        virtual bool requestRollLock(bool) { return false; }
 
        [[nodiscard]] virtual bool isScanning() const { return m_is_scanning; }
        [[nodiscard]] virtual bool isPaused() const { return m_is_paused; };
        [[nodiscard]] virtual ScannerState scannerState() const { return m_scanner_state; }
        [[nodiscard]] virtual Vector<3, Angle<fltp08>> headAngle() const;
        [[nodiscard]] virtual Vector<3, Angle<fltp08>> pointToHeadAngle(Vertex<3, fltp08> point) const;
 
        [[nodiscard]] virtual Motor* headMotor(uint01 axis) const;
        virtual void orientHead(const Vector<3, Angle<fltp08>>& head_orientation);
        [[nodiscard]] virtual RangeSensor* createRangeSensor();
        virtual void setCameraPointTarget(const Vector<3, fltp08>& target);
        virtual void clearCameraTarget();
        virtual void updateCameraTarget();
        virtual void deployStabalizer(bool stabalizer);
        virtual bool supportsStabalizer() const { return false; }
        Vertex<3, fltp08> cameraTarget() const;
        virtual void endUpdates() { };
        [[nodiscard]] virtual UUID camera() const { return m_camera; }
        [[nodiscard]] virtual Matrix<fltp08> cameraTransform() const { return  Matrix<fltp08>(1.0); }
        [[nodiscard]] virtual bool useCalibratedScan() const { return false; };
        [[nodiscard]] virtual TranslatedString scannerInfo() const;
        [[nodiscard]] virtual Matrix<fltp08> scannerMatrix() const;
        virtual bool snapViewportToScanner() const;
 
        [[nodiscard]] PointScannerOptions& options();
        [[nodiscard]] const PointScannerOptions& options() const;
 
        [[nodiscard]] virtual TimeSpan getScanTime(const Scanner3DScanSettings&) const { return Constant<TimeSpan>::Invalid; };
        [[nodiscard]] bool pauseRequested() const { return m_request_pause_scan; }
        [[nodiscard]] bool startRequested() const { return m_request_start_scan; }
        [[nodiscard]] bool stopRequested() const { return m_request_stop_scan; }
 
        virtual bool executeManualCommand(const String& command) { UNUSED(command); return false; };
        virtual void recordPoint(bool record_to_cloud = true, bool record_to_mesh = true);
        virtual void recordPoint(const PolarScanRecord<fltp04>& record);
        virtual void setScannerState(ScannerState scanner_state);
        virtual void requestConnect();
        virtual void requestDisconnect();
        virtual void requestStopScan();
        virtual void requestResumeScan();
        virtual void requestPauseScan();
        virtual uint04 meshBlendFactor() const { return 3U; }
        [[nodiscard]] virtual DynamicPointer<Scan> scan();
        [[nodiscard]] virtual Buffer<Battery*> batteries() const { return Buffer<Battery*>(); }
        [[nodiscard]] virtual Buffer<TemperatureSensor*> temperatureSensors() const { return Buffer<TemperatureSensor*>(); };
        [[nodiscard]] virtual OrientationSensor* orientationSensor() const { return nullptr; };
        [[nodiscard]] virtual PositionSensor* positionSensor() const { return nullptr; };
        [[nodiscard]] virtual Winch* deploymentWinch() const { return nullptr; }
        [[nodiscard]] virtual RotationBounds* rotationalBounds() const { return nullptr; };
        [[nodiscard]] virtual Light* light() const { return nullptr; }
        [[nodiscard]] virtual Light* redDot() const { return nullptr; }
        [[nodiscard]] virtual DistanceEncoder* distanceEncoder() const { return nullptr; }
        [[nodiscard]] virtual Connection* connection() const { return nullptr; }
        [[nodiscard]] virtual RangeSensor* rangeSensor() const { return m_range_sensor; };
 
        [[nodiscard]] virtual TimeSpan scanTime() const;
        [[nodiscard]] virtual bool usingPrism() const { return false; };
        [[nodiscard]] virtual Log* maintenanceLog() const { return nullptr; };
        [[nodiscard]] virtual const ScanSetupSettings& scanSettings() const { return m_scan_settings; }
        [[nodiscard]] virtual Matrix<fltp08> initialScanTransform() const;
        virtual void updateModel();
        virtual void clearScanStateRequests();
        [[nodiscard]] virtual bool isConnected() const;
    signals:
        void scanStatusChangedSignal();
        void scanStartedSignal();
        void scanFinishedSignal(UUID id);
        void connectionChangedSignal(bool is_connected);
    protected:
        virtual void setConnected(bool is_connected);
        virtual void createPrismModel();
        virtual void createScannerModel();
        [[nodiscard]] virtual Bounds<2, Angle<fltp08>> scanBounds() const = 0;
        virtual void stopScan() = 0;
        virtual void resumeScan() = 0;
        virtual void pauseScan() = 0;
        [[nodiscard]] virtual FileRequest scanModelFile() const;
        [[nodiscard]] virtual FileRequest prismModelFile() const;
        virtual void updateScanModel(bool scan_ended, bool force_calculate_mesh);
        virtual void finishUpdatingScanModel();
        virtual void calibrateScanModel();
        virtual void createScanObject();
        [[nodiscard]] virtual Matrix<fltp08> laserTransform(const Vector<3, Angle<fltp08>>& head_angle) const = 0;
        [[nodiscard]] virtual Matrix<fltp08> scanTransform() const { return Matrix<fltp08>(1.0); }
    protected:
        Model m_camera_point_target;
        Angle<sint04> m_anti_jitter_angle = Angle<sint04>(DEGREES, 0.3);
        fltp08 m_anti_jitter_offset = 0.005;
        Dictionary<String, std::function<void()>> m_camera_drape_functions;
        DesignObjectLookup* m_manager;
 
        ScannerState m_scanner_state;
        ActiveScanStatus m_scan_status;
        Vector<3, Motor*> m_head_motors;
        RangeSensor* m_range_sensor;
        //Scanner ID's
        UUID m_prism_model = Constant<UUID>::Invalid;
        UUID m_camera = Constant<UUID>::Invalid;
 
        ScanPointType m_scan_point_type;
 
        Time m_scan_start_time;
        Time m_start_pause_time;
        TimeSpan m_pause_time;
 
        //Scan Information
        ScanSetupSettings m_scan_settings;
        bool m_is_scanning = false;
        bool m_is_paused = false;
        DynamicPointer<Scan> m_scan;
        DynamicPointer<PointScannerOptions> m_options;
        bool m_request_start_scan = false;
        bool m_request_pause_scan = false;
        bool m_request_stop_scan = false;
        bool m_request_disconnect = false;
        bool m_request_connect = false;
        bool m_file_loaded = false;
        bool m_mesh_with_head_angle = false;
        bool m_is_connected = false;
    };
}
#endif