cvGenericMeasurementTool.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
 
#include "ui_cvGenericMeasurementToolDlg.h"
 
// CV_CORE_LIB
#include <CVGeom.h>
#include <CVLog.h>
#include <CVTools.h>
 
// VTK
#include <vtkSmartPointer.h>
 
// QT
#include <QList>
#include <QObject>
#include <QString>
#include <QWidget>
 
namespace PclUtils {
class PCLVis;
}
class ecvGenericVisualizer3D;
class cvPointPickingHelper;
 
class vtkActor;
class vtkProp;
class vtkRenderWindowInteractor;
class vtkRenderer;
class vtkAbstractWidget;
 
class ccHObject;
 
class cvGenericMeasurementTool : public QWidget {
    Q_OBJECT
signals:
    void measurementValueChanged();
 
    void pointPickingRequested(int pointIndex);
 
    void pointPickingCancelled();
 
public:
    explicit cvGenericMeasurementTool(QWidget* parent = nullptr);
    virtual ~cvGenericMeasurementTool();
 
    virtual void start();
    virtual void update();
    virtual void reset();
    virtual ccHObject* getOutput();
 
    virtual bool initModel();
    virtual bool setInput(ccHObject* obj);
 
    virtual void showWidget(bool state) { /* not impl */ }
    virtual void clearAllActor();
 
    virtual double getMeasurementValue() const { return 0.0; }
 
    virtual void getPoint1(double pos[3]) const {
        if (pos) {
            pos[0] = pos[1] = pos[2] = 0.0;
        }
    }
 
    virtual void getPoint2(double pos[3]) const {
        if (pos) {
            pos[0] = pos[1] = pos[2] = 0.0;
        }
    }
 
    virtual void getCenter(double pos[3]) const {
        if (pos) {
            pos[0] = pos[1] = pos[2] = 0.0;
        }
    }
 
    virtual void setPoint1(double pos[3]) { /* not impl */ }
 
    virtual void setPoint2(double pos[3]) { /* not impl */ }
 
    virtual void setCenter(double pos[3]) { /* not impl */ }
 
    virtual void setColor(double r, double g, double b) { /* not impl */ }
 
    virtual bool getColor(double& r, double& g, double& b) const {
        Q_UNUSED(r);
        Q_UNUSED(g);
        Q_UNUSED(b);
        return false;
    }
 
    virtual void lockInteraction() { /* not impl */ }
 
    virtual void unlockInteraction() { /* not impl */ }
 
    virtual void setInstanceLabel(const QString& label) { /* not impl */ }
 
    virtual void setFontFamily(const QString& family);
 
    virtual void setFontSize(int size);
 
    virtual void setBold(bool bold);
 
    virtual void setItalic(bool italic);
 
    virtual void setShadow(bool shadow);
 
    virtual void setFontOpacity(double opacity);
 
    virtual void setFontColor(double r, double g, double b);
 
    virtual void setHorizontalJustification(const QString& justification);
 
    virtual void setVerticalJustification(const QString& justification);
 
    QString getFontFamily() const { return m_fontFamily; }
    int getFontSize() const { return m_fontSize; }
    void getFontColor(double& r, double& g, double& b) const {
        r = m_fontColor[0];
        g = m_fontColor[1];
        b = m_fontColor[2];
    }
    bool getFontBold() const { return m_fontBold; }
    bool getFontItalic() const { return m_fontItalic; }
    bool getFontShadow() const { return m_fontShadow; }
    double getFontOpacity() const { return m_fontOpacity; }
    QString getHorizontalJustification() const {
        return m_horizontalJustification;
    }
    QString getVerticalJustification() const { return m_verticalJustification; }
 
protected:
    virtual void applyFontProperties() = 0;
 
public:
    void setUpViewer(PclUtils::PCLVis* viewer);
    void setInteractor(vtkRenderWindowInteractor* interactor);
    inline vtkRenderWindowInteractor* getInteractor() { return m_interactor; }
    inline vtkRenderer* getRenderer() { return m_renderer; }
 
    void setupShortcuts(QWidget* vtkWidget);
 
    void disableShortcuts();
 
    void clearPickingCache();
 
protected:
    virtual void modelReady();
    virtual void dataChanged() { /* not impl */ }
 
    void safeOff(vtkAbstractWidget* widget);
 
    virtual void initTool() { /* not impl */ }
    virtual void createUi() { /* not impl */ }
 
    virtual void setupPointPickingShortcuts(QWidget* vtkWidget) {
        Q_UNUSED(vtkWidget);
    }
 
    void updatePickingHelpers();
 
    void addActor(const vtkSmartPointer<vtkProp> actor);
    void removeActor(const vtkSmartPointer<vtkProp> actor);
 
protected:
    Ui::GenericMeasurementToolDlg* m_ui = nullptr;
 
    std::string m_id;
    ccHObject* m_entity = nullptr;
    PclUtils::PCLVis* m_viewer = nullptr;
    vtkRenderWindowInteractor* m_interactor = nullptr;
    vtkRenderer* m_renderer = nullptr;
 
    vtkSmartPointer<vtkActor> m_modelActor;
 
    QList<cvPointPickingHelper*> m_pickingHelpers;
 
    QWidget* m_vtkWidget = nullptr;
 
    QString m_fontFamily = "Arial";
    int m_fontSize = 6;  // Default font size for better readability
    double m_fontColor[3] = {1.0, 1.0, 1.0};  // White by default
    bool m_fontBold = false;
    bool m_fontItalic = false;
    bool m_fontShadow = true;
    double m_fontOpacity = 1.0;
    QString m_horizontalJustification = "Left";
    QString m_verticalJustification = "Bottom";
};