feat: Add EllipsoidVolumeAnnotationActor

src/src/Rendering/Measure/EllipsoidVolumeAnnotationActor.cpp

@@ -0,0 +1,149 @@
+#include "EllipsoidVolumeAnnotationActor.h"
+
+#include <vtkObjectFactory.h>
+#include <vtkPolyData.h>
+#include <vtkProperty2D.h>
+#include <vtkActor2D.h>
+#include <vtkRenderer.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkTextMapper.h>
+#include <vtkTextProperty.h>
+
+#include <QFile>
+#include "Common/QGlobals.h"
+
+#include "Interaction/ActorDraggableInteractorStyle.h"
+#include "Rendering/Core/ControlPointActor.h"
+#include "UI/Widget/Measure/calibrationWidget.h"
+
+vtkStandardNewMacro(EllipsoidVolumeAnnotationActor)
+
+EllipsoidVolumeAnnotationActor::EllipsoidVolumeAnnotationActor() : DraggableActor(),
+                                                                   mRuler1(RulerAnnotationActor::New()),
+                                                                   mRuler2(RulerAnnotationActor::New()),
+                                                                   mRuler3(RulerAnnotationActor::New()),
+                                                                   mCurrentRuler(mRuler1),
+                                                                   measured(0)
+{
+    mRuler1->SetDistanceName(mRuler1->GetDistanceName()+"1");
+    mRuler2->SetDistanceName(mRuler2->GetDistanceName()+"2");
+    mRuler3->SetDistanceName(mRuler3->GetDistanceName()+"3");
+    mRuler1->AddObserver(MeasureChangedEvent,this,&EllipsoidVolumeAnnotationActor::measureCallback);
+    mRuler2->AddObserver(MeasureChangedEvent,this,&EllipsoidVolumeAnnotationActor::measureCallback);
+    mRuler3->AddObserver(MeasureChangedEvent,this,&EllipsoidVolumeAnnotationActor::measureCallback);
+
+}
+
+EllipsoidVolumeAnnotationActor::~EllipsoidVolumeAnnotationActor() {
+    if (mRuler1)mRuler1->Delete();
+    if (mRuler2)mRuler2->Delete();
+    if (mRuler3)mRuler3->Delete();
+}
+
+void EllipsoidVolumeAnnotationActor::measureCallback()
+{
+    EventObject* obj = new EventObject;
+    switch (measured)
+    {
+    case 1:
+    {
+        obj->AddDetailValue("dis1", mRuler1->GetRealDistance());
+    }
+    break;
+    case 2:
+    {
+        obj->AddDetailValue("dis1", mRuler1->GetRealDistance());
+        obj->AddDetailValue("dis2", mRuler2->GetRealDistance());
+    }
+    break;
+    case 3:
+    {
+        obj->AddDetailValue("dis1", mRuler1->GetRealDistance());
+        obj->AddDetailValue("dis2", mRuler2->GetRealDistance());
+        obj->AddDetailValue("dis3", mRuler3->GetRealDistance());
+        obj->AddDetailValue("Volume",
+        vtkMath::Pi() * (4.0 / 3.0) * (mRuler1->GetRealDistance()*.5) *
+        (mRuler2->GetRealDistance() * 0.5) * (mRuler3->GetRealDistance() * 0.5));
+    }
+    break;
+    default:
+        return;
+    }
+    EventsCenter::Default()->TriggerEvent(VolumeMeasured, obj);
+}
+
+void EllipsoidVolumeAnnotationActor::BuildShape() {
+    
+}
+
+Measure *EllipsoidVolumeAnnotationActor::GetNextMeasure()
+{
+    return this;
+}
+
+vtkProp *EllipsoidVolumeAnnotationActor::GetProp() {
+    return this;
+}
+
+bool EllipsoidVolumeAnnotationActor::onMeasureLeftButtonDown(vtkRenderWindowInteractor * aInteractor)
+{
+    if (mCurrentRuler)
+    {
+        if (mCurrentRuler == mRuler1)
+        {
+            mRuler2->SetRenderer(nullptr);
+            mRuler3->SetRenderer(nullptr);
+            measured = 0;
+        }
+        measured++;
+        return mCurrentRuler->onMeasureLeftButtonDown(aInteractor);
+    }
+    return false;
+}
+
+void EllipsoidVolumeAnnotationActor::onMeasureMouseMove(vtkRenderWindowInteractor * aInteractor)
+{
+    mCurrentRuler->onMeasureMouseMove(aInteractor);
+    measureCallback();
+}
+
+bool EllipsoidVolumeAnnotationActor::onMeasureLeftButtonUp(vtkRenderWindowInteractor * aInteractor)
+{
+    if (mCurrentRuler)
+    {
+        bool ret =  mCurrentRuler->onMeasureLeftButtonUp(aInteractor);
+        if (mCurrentRuler == mRuler1) {
+            mCurrentRuler = mRuler2;
+        }
+        else if (mCurrentRuler == mRuler2) {
+            mCurrentRuler = mRuler3;
+        }
+        else if (mCurrentRuler == mRuler3){
+            mCurrentRuler = mRuler1;
+        }
+        return ret;
+    }
+    return false;
+}
+
+void EllipsoidVolumeAnnotationActor::onTerminate(vtkRenderWindowInteractor * aInteractor)
+{
+    // Measure::onTerminate(aInteractor);
+}
+
+void EllipsoidVolumeAnnotationActor::ForceDelete()
+{
+
+}
+
+void EllipsoidVolumeAnnotationActor::ClearRenderingState(vtkRenderer* aRenderer)
+{
+    if (nullptr == aRenderer || mRuler1->GetRenderer()==aRenderer || mRuler2->GetRenderer()==aRenderer || mRuler3->GetRenderer() == aRenderer)
+    {
+        mRuler1->SetRenderer(nullptr);
+        mRuler2->SetRenderer(nullptr);
+        mRuler3->SetRenderer(nullptr);
+        mCurrentRuler = mRuler1;
+    }
+}

src/src/Rendering/Measure/EllipsoidVolumeAnnotationActor.h

@@ -0,0 +1,52 @@
+#ifndef ELLIPSOID_VOLUME_ANNOTATION_ACTOR
+#define ELLIPSOID_VOLUME_ANNOTATION_ACTOR
+
+#include "RulerAnnotationActor.h"
+
+class vtkTextProperty;
+
+class EllipsoidVolumeAnnotationActor : public DraggableActor, public Measure {
+public:
+    static EllipsoidVolumeAnnotationActor* Default(){
+        static EllipsoidVolumeAnnotationActor defaultInstance;
+        return &defaultInstance;
+    }
+
+    static EllipsoidVolumeAnnotationActor *New();
+
+    vtkTypeMacro(EllipsoidVolumeAnnotationActor, DraggableActor);
+
+    void BuildShape() override;
+
+    Measure* GetNextMeasure() override;
+
+    vtkProp* GetProp() ;
+
+    bool onMeasureLeftButtonDown(vtkRenderWindowInteractor *) override;
+
+    void onMeasureMouseMove(vtkRenderWindowInteractor *) override;
+
+    bool onMeasureLeftButtonUp(vtkRenderWindowInteractor *) override;
+    
+    void onTerminate(vtkRenderWindowInteractor *) override;
+
+    void ForceDelete() override ;
+
+    void ClearRenderingState(vtkRenderer* aRenderer = nullptr);
+
+
+protected:
+    EllipsoidVolumeAnnotationActor();
+
+    ~EllipsoidVolumeAnnotationActor() override;
+
+private:
+    void measureCallback();
+    RulerAnnotationActor* mRuler1;
+    RulerAnnotationActor* mRuler2;
+    RulerAnnotationActor* mRuler3;
+    RulerAnnotationActor* mCurrentRuler;
+    int measured;
+};
+
+#endif /* ELLIPSOID_VOLUME_ANNOTATION_ACTOR */