orthanc-stone: Applications/Samples/Sdl/SingleFrameViewer/SdlSimpleViewer.cpp comparison

comparison Applications/Samples/Sdl/SingleFrameViewer/SdlSimpleViewer.cpp @ 1798:41f3872bd7d2

create angle tool and delete measure tool

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Thu, 20 May 2021 11:10:14 +0200
parents	013dec434a84
children	1125793d82d3

comparison

equal deleted inserted replaced

-:013dec434a84
+:41f3872bd7d2
 namespace OrthancStone
 {
 class AnnotationsOverlay : public boost::noncopyable
 {
+public:
+enum Tool
+{
+Tool_Edit,
+Tool_None,
+Tool_Segment,
+Tool_Angle,
+Tool_Circle,
+Tool_Erase
+};
 private:
 class Measure;
 class Primitive : public boost::noncopyable
 {
 Color     color_;
 Color     hoverColor_;
 bool      isHover_;
 int       depth_;
-protected:
-Measure& GetParentMeasure() const
-{
-return parentMeasure_;
-}
 public:
 Primitive(Measure& parentMeasure,
 int depth) :
 modified_(true),
 parentMeasure_(parentMeasure),
 virtual ~Primitive()
 {
 }
+Measure& GetParentMeasure() const
+{
+return parentMeasure_;
+}
 int GetDepth() const
 {
 return depth_;
 }
 class SegmentMeasure : public Measure
 {
 private:
+bool      showLabel_;
 Handle&   handle1_;
 Handle&   handle2_;
 Segment&  segment_;
 Text&     label_;
 void UpdateLabel()
 {
-TextSceneLayer content;
+if (showLabel_)
+{
-double x1 = handle1_.GetCenter().GetX();
+TextSceneLayer content;
-double y1 = handle1_.GetCenter().GetY();
-double x2 = handle2_.GetCenter().GetX();
+double x1 = handle1_.GetCenter().GetX();
-double y2 = handle2_.GetCenter().GetY();
+double y1 = handle1_.GetCenter().GetY();
+double x2 = handle2_.GetCenter().GetX();
+double y2 = handle2_.GetCenter().GetY();
 // Put the label to the right of the right-most handle
 if (x1 < x2)
 {
 content.SetPosition(x2, y2);
 }
 else
 {
 content.SetPosition(x1, y1);
 }
 content.SetAnchor(BitmapAnchor_CenterLeft);
 content.SetBorder(10);
 double dx = x1 - x2;
 double dy = y1 - y2;
 char buf[32];
 sprintf(buf, "%0.2f cm", sqrt(dx * dx + dy * dy) / 10.0);
 content.SetText(buf);
 label_.SetContent(content);
+}
 }
 public:
 SegmentMeasure(AnnotationsOverlay& that,
+bool showLabel,
 const ScenePoint2D& p1,
 const ScenePoint2D& p2) :
 Measure(that),
+showLabel_(showLabel),
 handle1_(AddTypedPrimitive<Handle>(new Handle(*this, p1))),
 handle2_(AddTypedPrimitive<Handle>(new Handle(*this, p2))),
 segment_(AddTypedPrimitive<Segment>(new Segment(*this, p1, p2))),
 label_(AddTypedPrimitive<Text>(new Text(that, *this)))
 {
 label_.SetColor(Color(255, 0, 0));
 UpdateLabel();
+}
+Handle& GetHandle1() const
+{
+return handle1_;
 }
 Handle& GetHandle2() const
 {
 return handle2_;
 {
 label_.SetColor(Color(255, 0, 0));
 UpdateLabel();
 }
+Handle& GetEndHandle() const
+{
+return endHandle_;
+}
 virtual void SignalMove(Primitive& primitive) ORTHANC_OVERRIDE
 {
 if (&primitive == &startHandle_)
 {
 segment1_.SetPosition(startHandle_.GetCenter(), middleHandle_.GetCenter());
 measure_ = new CircleMeasure(that, sceneClick, sceneClick);
 handle2_ = &dynamic_cast<CircleMeasure*>(measure_)->GetHandle2();
 }
 else
 {
-measure_ = new SegmentMeasure(that, sceneClick, sceneClick);
+measure_ = new SegmentMeasure(that, true /* show label */, sceneClick, sceneClick);
 handle2_ = &dynamic_cast<SegmentMeasure*>(measure_)->GetHandle2();
 }
 assert(measure_ != NULL &&
 handle2_ != NULL);
 }
 }
 };
+class CreateAngleTracker : public IFlexiblePointerTracker
+{
+private:
+AnnotationsOverlay&  that_;
+SegmentMeasure*      segment_;
+AngleMeasure*        angle_;
+AffineTransform2D    canvasToScene_;
+public:
+CreateAngleTracker(AnnotationsOverlay& that,
+const ScenePoint2D& sceneClick,
+const AffineTransform2D& canvasToScene) :
+that_(that),
+segment_(NULL),
+angle_(NULL),
+canvasToScene_(canvasToScene)
+{
+segment_ = new SegmentMeasure(that, false /* no length label */, sceneClick, sceneClick);
+}
+virtual void PointerMove(const PointerEvent& event) ORTHANC_OVERRIDE
+{
+if (segment_ != NULL)
+{
+segment_->GetHandle2().SetCenter(event.GetMainPosition().Apply(canvasToScene_));
+segment_->SignalMove(segment_->GetHandle2());
+}
+if (angle_ != NULL)
+{
+angle_->GetEndHandle().SetCenter(event.GetMainPosition().Apply(canvasToScene_));
+angle_->SignalMove(angle_->GetEndHandle());
+}
+}
+virtual void PointerUp(const PointerEvent& event) ORTHANC_OVERRIDE
+{
+if (segment_ != NULL)
+{
+// End of first step: The first segment is available, now create the angle
+angle_ = new AngleMeasure(that_, segment_->GetHandle1().GetCenter(),
+segment_->GetHandle2().GetCenter(),
+segment_->GetHandle2().GetCenter());
+that_.DeleteMeasure(segment_);
+segment_ = NULL;
+}
+else
+{
+angle_ = NULL;  // IsAlive() becomes false
+}
+}
+virtual void PointerDown(const PointerEvent& event) ORTHANC_OVERRIDE
+{
+}
+virtual bool IsAlive() const ORTHANC_OVERRIDE
+{
+return (segment_ != NULL ||
+angle_ != NULL);
+}
+virtual void Cancel() ORTHANC_OVERRIDE
+{
+if (segment_ != NULL)
+{
+that_.DeleteMeasure(segment_);
+segment_ = NULL;
+}
+if (angle_ != NULL)
+{
+that_.DeleteMeasure(angle_);
+angle_ = NULL;
+}
+}
+};
+// Dummy tracker that is only used for deletion, in order to warn
+// the caller that the mouse action was taken into consideration
+class EraseTracker : public IFlexiblePointerTracker
+{
+public:
+EraseTracker()
+{
+}
+virtual void PointerMove(const PointerEvent& event) ORTHANC_OVERRIDE
+{
+}
+virtual void PointerUp(const PointerEvent& event) ORTHANC_OVERRIDE
+{
+}
+virtual void PointerDown(const PointerEvent& event) ORTHANC_OVERRIDE
+{
+}
+virtual bool IsAlive() const ORTHANC_OVERRIDE
+{
+return false;
+}
+virtual void Cancel() ORTHANC_OVERRIDE
+{
+}
+};
 typedef std::set<Primitive*>  Primitives;
 typedef std::set<Measure*>    Measures;
 typedef std::set<size_t>      SubLayers;
+Tool        activeTool_;
 size_t      macroLayerIndex_;
 size_t      polylineSubLayer_;
 Primitives  primitives_;
 Measures    measures_;
 SubLayers   subLayersToRemove_;
 subLayersToRemove_.insert(subLayerIndex);
 }
 public:
 AnnotationsOverlay(size_t macroLayerIndex) :
+activeTool_(Tool_Edit),
 macroLayerIndex_(macroLayerIndex),
 polylineSubLayer_(0)  // dummy initialization
 {
-measures_.insert(new SegmentMeasure(*this, ScenePoint2D(0, 0), ScenePoint2D(100, 100)));
+measures_.insert(new SegmentMeasure(*this, true /* show label */, ScenePoint2D(0, 0), ScenePoint2D(100, 100)));
 measures_.insert(new AngleMeasure(*this, ScenePoint2D(100, 50), ScenePoint2D(150, 40), ScenePoint2D(200, 50)));
 measures_.insert(new CircleMeasure(*this, ScenePoint2D(50, 200), ScenePoint2D(100, 250)));
 }
 ~AnnotationsOverlay()
 }
 measures_.clear();
 }
+void SetActiveTool(Tool tool)
+{
+activeTool_ = tool;
+}
+Tool GetActiveTool() const
+{
+return activeTool_;
+}
 void Render(Scene2D& scene)
 {
 MacroSceneLayer* macro = NULL;
 if (scene.HasLayer(macroLayerIndex_))
 }
 bool SetMouseHover(const ScenePoint2D& p /* expressed in canvas coordinates */,
 const Scene2D& scene)
 {
-bool needsRefresh = false;
+if (activeTool_ == Tool_None)
+{
-const ScenePoint2D s = p.Apply(scene.GetCanvasToSceneTransform());
+return ClearHover();
+}
-for (Primitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
+else
 {
-assert(*it != NULL);
+bool needsRefresh = false;
-bool hover = (*it)->IsHit(s, scene);
+const ScenePoint2D s = p.Apply(scene.GetCanvasToSceneTransform());
-if ((*it)->IsHover() != hover)
-{
+for (Primitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
-needsRefresh = true;
+{
-}
+assert(*it != NULL);
+bool hover = (*it)->IsHit(s, scene);
+if ((*it)->IsHover() != hover)
+{
+needsRefresh = true;
+}
 (*it)->SetHover(hover);
 }
 return needsRefresh;
+}
 }
 IFlexiblePointerTracker* CreateTracker(const ScenePoint2D& p /* expressed in canvas coordinates */,
 const Scene2D& scene)
 {
-const ScenePoint2D s = p.Apply(scene.GetCanvasToSceneTransform());
+if (activeTool_ == Tool_None)
+{
-int bestDepth;
+return NULL;
-std::unique_ptr<IFlexiblePointerTracker> tracker;
+}
+else
-for (Primitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
+{
-{
+const ScenePoint2D s = p.Apply(scene.GetCanvasToSceneTransform());
-assert(*it != NULL);
-if ((*it)->IsHit(s, scene))
+Primitive* bestHit = NULL;
-{
-if (tracker.get() == NULL ||
+for (Primitives::iterator it = primitives_.begin(); it != primitives_.end(); ++it)
-bestDepth > (*it)->GetDepth())
+{
+assert(*it != NULL);
+if ((*it)->IsHit(s, scene))
 {
-tracker.reset(new EditPrimitiveTracker(**it, s, scene.GetCanvasToSceneTransform()));
+if (bestHit == NULL ||
-bestDepth = (*it)->GetDepth();
+bestHit->GetDepth() > (*it)->GetDepth())
+{
+bestHit = *it;
+}
 }
 }
-}
+if (bestHit != NULL)
-if (tracker.get() == NULL)
+{
-{
+if (activeTool_ == Tool_Erase)
-tracker.reset(new CreateSegmentOrCircleTracker(*this, true /* circle */, s, scene.GetCanvasToSceneTransform()));
+{
-}
+DeleteMeasure(&bestHit->GetParentMeasure());
+return new EraseTracker;
-return tracker.release();
+}
+else
+{
+return new EditPrimitiveTracker(*bestHit, s, scene.GetCanvasToSceneTransform());
+}
+}
+else
+{
+switch (activeTool_)
+{
+case Tool_Segment:
+return new CreateSegmentOrCircleTracker(*this, false /* segment */, s, scene.GetCanvasToSceneTransform());
+case Tool_Circle:
+return new CreateSegmentOrCircleTracker(*this, true /* circle */, s, scene.GetCanvasToSceneTransform());
+case Tool_Angle:
+return new CreateAngleTracker(*this, s, scene.GetCanvasToSceneTransform());
+default:
+return NULL;
+}
+}
+}
 }
 };
 }
 #endif
 boost::shared_ptr<OrthancStone::AngleMeasureTool> angleMeasureTool(OrthancStone::AngleMeasureTool::Create(viewport));
 bool angleMeasureFirst = true;
 angleMeasureTool->Disable();
 OrthancStone::AnnotationsOverlay overlay(10);
+overlay.SetActiveTool(OrthancStone::AnnotationsOverlay::Tool_Angle);
 boost::shared_ptr<SdlSimpleViewerApplication> application(
 SdlSimpleViewerApplication::Create(context, viewport));
 OrthancStone::DicomSource source;

Mercurial > hg > orthanc-stone

comparison Applications/Samples/Sdl/SingleFrameViewer/SdlSimpleViewer.cpp @ 1798:41f3872bd7d2