Annotaion.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 <Utils/PCLCloud.h>
#include <vtkSmartPointer.h>
 
#include <vector>
 
struct BoxLabel {
    BoxLabel() {
        type = "unknown";
        this->detail.center_x = this->detail.center_y = this->detail.center_z =
                0;
        this->detail.yaw = 2;
        this->detail.length = this->detail.width = this->detail.height = 1;
    }
    BoxLabel(const double p1[3],
             const double p2[3],
             std::string type_ = "unknown") {
        type = type_;
        this->detail.center_x = (p1[0] + p2[0]) / 2;
        this->detail.center_y = (p1[1] + p2[1]) / 2;
        this->detail.center_z = (p1[2] + p2[2]) / 2;
        this->detail.yaw = 0;
        this->detail.length = p2[0] - p1[0];
        this->detail.width = p2[1] - p1[1];
        this->detail.height = p2[2] - p1[2];
    }
    std::string type;
    union {
        double data[7];
        struct {
            double center_x;
            double center_y;
            double center_z;
            double length;
            double width;
            double height;
            double yaw;
        } detail;
    };
 
    std::string toString() {
        char buffer[200];
        sprintf(buffer, "%s %f %f %f %f %f %f %f", type.c_str(), data[0],
                data[1], data[2], data[3], data[4], data[5], data[6]);
        return std::string(buffer);
    }
};
 
class vtkBalloonWidget;
class vtkBoxWidgetCallback0;
class vtkBoxWidgetCallback1;
class vtkAnnotationBoxSource;
class vtkBoxWidgetRestricted;
 
class vtkTransform;
class vtkRenderWindowInteractor;
class vtkActor;
class vtkPolyDataMapper;
 
class Annotation {
    friend class Annotaions;
 
public:
    Annotation(const std::vector<int>& slice, std::string type_);
 
    Annotation(const BoxLabel& label, bool visible_ = true, bool lock_ = false);
 
    Annotation(const PointCloudI::Ptr cloud,
               std::vector<int>& slice,
               std::string type_);
 
    ~Annotation();
 
    BoxLabel getBoxLabel();
 
    void applyTransform(vtkSmartPointer<vtkTransform> t);
 
    void picked(vtkRenderWindowInteractor* interactor);
 
    void unpicked();
 
    void adjustToAnchor();
 
    void setType(const std::string value);
    vtkSmartPointer<vtkActor> getActor() const;
    std::string getType() const;
 
    const std::vector<int>& getSlice() const;
 
protected:
    void initial();
 
    void colorAnnotation(int color_index = -1);
 
    void setAnchorPoint(const PointCloudI::Ptr cloud,
                        const std::vector<int>& slice);
 
    double computeScaleAndCenterShift(double o[3], double scs[2]);
 
private:
    std::string type;
    vtkSmartPointer<vtkAnnotationBoxSource> source;
    vtkSmartPointer<vtkActor> actor;
    vtkSmartPointer<vtkPolyDataMapper> mapper;
    vtkSmartPointer<vtkTransform> transform;
 
    vtkSmartPointer<vtkBoxWidgetRestricted> boxWidget;
    vtkSmartPointer<vtkBoxWidgetCallback0> boxWidgetCallback0;
    vtkSmartPointer<vtkBoxWidgetCallback1> boxWidgetCallback1;
 
    std::vector<double*> anchorPoints;
 
    std::vector<int> m_slice;
 
    double center[3];
 
    // NOTE not used
    bool visible;
    bool lock;
 
public:
    static std::vector<std::string>* GetTypes();
 
    static std::size_t GetTypeIndex(std::string type_);
 
    static std::string GetTypeByIndex(size_t index);
 
    static void ComputeOBB(const PointCloudI::Ptr cloud,
                           std::vector<int>& slice,
                           double p1[3],
                           double p2[3]);
 
protected:
    static std::vector<std::string>* types;
};
 
class Annotaions {
public:
    explicit Annotaions(vtkRenderWindowInteractor* interactor = nullptr);
 
    void preserve(size_t num = 0);
    void release();
 
    void add(Annotation* anno);
    void remove(Annotation* anno);
    void clear();
    std::size_t getSize();
 
    void updateLabels(Annotation* anno, bool resetFlag = false);
 
    void loadAnnotations(std::string filename, int mode);
 
    void saveAnnotations(std::string filename, int mode);
 
    bool getAnnotations(std::vector<int>& annos) const;
 
    Annotation* getAnnotation(vtkActor* actor);
    Annotation* getAnnotation(std::size_t index);
    void getAnnotations(const std::string& type,
                        std::vector<Annotation*>& annotations);
    int getAnnotationIndex(Annotation* anno);
    std::vector<Annotation*>& getAnnotations();
 
    inline int getLabelByIndex(std::size_t index) {
        if (index >= m_capacity) {
            return -1;
        }
        return m_labeledCloudIndex[index];
    }
 
    void updateBalloonByIndex(std::size_t index);
    void updateBalloonByAnno(Annotation* anno);
 
protected:
    std::vector<Annotation*> m_annotations;
 
    vtkRenderWindowInteractor* m_interactor;
    vtkSmartPointer<vtkBalloonWidget> m_balloonWidget;
 
    int* m_labeledCloudIndex = nullptr;
    size_t m_capacity = 0;
};