PointScannerDialog.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: NDEVR
File: PointScannerDialog
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#if NDEVR_SCAN
#include <NDEVR/PointScannerOptions.h>
#include <NDEVR/Scanner3D.h>
#include <NDEVR/PhysicalCameraView.h>
#include <NDEVR/ViewportManager.h>
#include <NDEVR/Button.h>
#include <NDEVR/ProgressWidget.h>
#include <NDEVR/OrientationSensor.h>
#include <NDEVR/Deployment.h>
#include <NDEVR/KeyController.h>
#include <NDEVR/UUID.h>
#include <NDEVR/Buffer.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/INIInterface.h>
#include <QWidget>
#include <QPointer>
#include <QProgressBar>
class QTableWidget;
namespace Ui
{
    class PointScannerUI;
}
namespace NDEVR
{
    class PhotoDrapingSettings;
    class CameraLocationCombo;
    class Scanner3D;
    class Joystick;
    class AsciiFileOutputStream;
    class INIFactory;
    class QCustomDockWidget;
    class ContainerWidget;
    class BasicThread;
    class QTModelManager;
    class ColorChannelCombo;
    class UUID;
    class StationEditor;
    class ControllerInterface;
    class Button;
    class DeploymentWidget;
    class DistanceEncoder;
    class ConnectionStatusWidget;
    class CustomPointScanDialog;
    template<class t_type>
    class DockWidget;
    enum class ScanMode;
    
    class POINT_SCANNER_API PointScannerDialog : public QWidget, public ViewportManager
    {
        Q_OBJECT
    public:
        PointScannerDialog(QTModelManager* manager, QWidget* parent = nullptr);
        virtual ~PointScannerDialog();
        virtual void findDevices();
        virtual void setCurrentScanner(Scanner3D* scanner);
        virtual void setDeploymentEncoder(DistanceEncoder* encoder);
        ContainerWidget* viewContainer() const;
        
        bool useRemoteWidgets() const { return m_remote_widget; }
        Buffer<QPointer<QWidget>> remoteWidgets();
        QSize sizeHint() const override;
        bool cameraVisible() const { return m_camera_visible; }
        bool showCameraDuringScan() const { return options().allow_camera_during_scan.get(); }
        PointScannerOptions& options();
        const PointScannerOptions& options() const;
        virtual void requestStation(UUID id);
        virtual void requestDeployment(UUID id);
        virtual bool processKeyEvent(const StringView& id, const KeyEvent& key_event, DesignObjectLookup* lookup, Camera* camera);
        virtual void returnToBaseAction(PopupInfo info);
        Bounds<2, Angle<fltp08>> getPolarScanBounds(UUID mode) const;
        Bounds<3, fltp08> getCartesianScanBounds(UUID mode) const;
        UUID scanCamera() const;
        void swapToScannerCamera();
        PhysicalCameraView* pCameraView();
        virtual void onGlobalLayoutUpdated(Buffer<QPointer<DockWidget<CameraView>>>& removed_views) override;
        virtual bool removeView(QPointer<DockWidget<CameraView>> view) override;
        virtual bool addView(QPointer<DockWidget<CameraView>> view) override;
    protected:
        void initMeasureTab();
        //Prevents double clicking buttons
        bool checkAndSetCommandTime();
        StringAllocatingView videoRecordName();
        bool hasActiveDeployment() const;
        void updateEncoderState();
        void updateAutoCameraSwap();
        bool preferDockedCamera() const;
        void setupDeploymentScanButton(ScanProfile profile);
        void setupBoretrakWidget();
        void addQuickCommands();
        void setupScanProfiles();
        void speakCurrentDepth(fltp08 depth, uint04 count = Constant<uint04>::Invalid);
        void setupScanObjectWidget();
        void updateScanButtons(bool scanning, bool paused);
        void resizeEvent(QResizeEvent* event) override;
        virtual void hideEvent(QHideEvent *event) override;
        virtual void showEvent(QShowEvent *event) override;
        bool event(QEvent* event) override;
        Buffer<Angle<fltp08>> polarStepOptions() const;
        Buffer<fltp08> cartesianStepOptions() const;
        ScanProfile currentScanProfile() const;
        Angle<fltp08> currentPolarStep() const;
        fltp08 currentCartesianStep() const;
        fltp04 currentSpeed() const;
        void updateInfoBox();
        void setToNewStation(bool show_dialog);
        void updateWidgets(int animation_time, bool force);
        void updateStation(UUID station, int animation_time);
        void updateDeployment(UUID deployment, int animation_time);
        void updateOrientationLabels();
        bool shouldShowVideo() const;
        void setupForSearchScanners(const Buffer<QPointer<Connection>>& connections_to_test);
        void endSetupForSearchScanners(const Buffer<Scanner3D*>& scanners_found);
        void setProgressFormat(const TranslatedString& format);
        void setProgress(fltp04 percent);
        void initJoystick();
        void updateScannerState(int animation_time, bool force);
        CustomPointScanDialog* customAnglesWidget();
        PhotoDrapingSettings* photoDrapingWidget();
        void markAction();
    public slots:
        void updateScanStatusSlot();
        void updateOrientationSlot();
        void updateLockAngles();
        void updateGyroState();
        void onScanProfileChanged();
        void updateWidget();
        void startScan();
        void onLaserToggle(bool is_on);
        void onLastHitToggle();
        void modelDeletedSlot(UUID id);
        void objectsUpdatedSlot(Buffer<UUID> id);
        void scanEndedSlot(UUID id);
        void clearAllSlot();
        void boretrakRemovedSlot();
        void boretrakAddedSlot();
        void scanStartedSlot();
        void performImageDrape();
        void onConnectionStatusChanged(bool connected);
        void setShowStationOnNew(bool show_station) { m_show_station_on_new = show_station; }
        void setRemoteWidget(bool use_remote);
        void setCameraVisible(bool visible);
        void setButtonsActive(bool active);
        void updateDeploymentPosition();
        void updateConnectedController();
    protected slots:
        void stationChangedSlot(UUID id);
        void deploymentChangedSlot(UUID id);
        void updateFromController();
    signals:
        void cameraVisibilityChangedSignal(bool visible);
        void requestRemoteWidgetSignal(bool use_remote);
        void scannerSetSignal(Scanner3D* scanner);
    protected:
        QTModelManager* m_model_manager = nullptr;
        CameraLocationCombo* m_station_zoom_combo = nullptr;
        DeploymentWidget* m_popup_deployment_widget = nullptr;
        Joystick* m_joystick = nullptr;
        CustomPointScanDialog* m_popup_custom_point_dialog = nullptr;
        PhotoDrapingSettings* m_popup_photo_draping_settings = nullptr;
        //CameraLocationCombo* m_scanner_zoom_combo;
        QPointer<DockWidget<CameraView>> m_camera_view;
 
        ControllerInterface* m_controller = nullptr;
        Scanner3D* m_scanner = nullptr;
        Scanner3D* m_try_scanner = nullptr;
        DistanceEncoder* m_current_encoder = nullptr;
        Motor* m_deployment_motor = nullptr;
        Resource<uint04> m_search_attempt_count;
        QTimer* m_image_drape_timer = nullptr;
        QTimer* m_button_action_timer = nullptr;
        Ui::PointScannerUI* ui;
        Dictionary<String, ConnectionStatusWidget*> m_connection_widgets;
        UUID m_last_scan_object;
        Vector<2, fltp04> m_joy_location;
        QPointer<Button> m_remote_find_scanner_button = nullptr;
        QPointer<Button> m_remote_play_button = nullptr;
        QPointer<Button> m_remote_pause_button = nullptr;
        QPointer<Button> m_remote_stop_button = nullptr;
        QPointer<Button> m_remote_circle_scan = nullptr;
        QPointer<Button> m_joystick_circle_scan = nullptr;
        QPointer<Button> m_remote_deployment_action_button = nullptr;
        QPointer<Button> m_camera_view_light_button = nullptr;
        QPointer<Button> m_joystick_record_button = nullptr;
        QPointer<Button> m_joystick_light_button = nullptr;
        QPointer<Button> m_joystick_go_home_button = nullptr;
 
        QPointer<ProgressWidget> m_remote_progress_bar = nullptr;
        Time m_last_command_time = Constant<Time>::Invalid;
        StationEditor* m_station_editor = nullptr;
        ScannerState m_last_scanner_state;
        BasicThread* m_scan_finder_thread = nullptr;
        BasicThread* m_station_creater_thread = nullptr;
        Buffer<QPointer<Button>> m_remote_buttons;
        GyroState m_last_gyro_state;
        UUID m_requested_station;
        UUID m_requested_deployment;
        fltp08 m_last_reading_interval = Constant<fltp08>::Invalid;
        bool m_show_station_on_new = true;
        bool m_zoom_station_on_new = true;
        bool m_showing_scan_ended_message = false;
        bool m_remote_widget = false;
        bool m_last_was_scanning = false;
        bool m_last_was_paused = false;
        bool m_camera_visible = false;
        bool m_is_showing_calibrate = false;
        bool m_stop_video_on_finish = false;
        bool m_action_buttons_enabled = true;
 
    };
}
#endif