--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Framework/Scene2DViewport/AngleMeasureTool.cpp	Wed May 15 16:56:17 2019 +0200
@@ -0,0 +1,283 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2019 Osimis S.A., Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ **/
+
+#include "AngleMeasureTool.h"
+#include "MeasureToolsToolbox.h"
+
+#include <Core/Logging.h>
+
+#include <boost/math/constants/constants.hpp>
+
+extern void TrackerSample_SetInfoDisplayMessage(std::string key, std::string value);
+
+namespace OrthancStone
+{
+  AngleMeasureTool::~AngleMeasureTool()
+  {
+    // this measuring tool is a RABI for the corresponding visual layers
+    // stored in the 2D scene
+    Disable();
+    RemoveFromScene();
+  }
+
+  void AngleMeasureTool::RemoveFromScene()
+  {
+    if (layersCreated)
+    {
+      assert(GetScene()->HasLayer(polylineZIndex_));
+      assert(GetScene()->HasLayer(textBaseZIndex_));
+      GetScene()->DeleteLayer(polylineZIndex_);
+      GetScene()->DeleteLayer(textBaseZIndex_);
+    }
+  }
+
+  void AngleMeasureTool::SetSide1End(ScenePoint2D pt)
+  {
+    side1End_ = pt;
+    RefreshScene();
+  }
+
+  void AngleMeasureTool::SetSide2End(ScenePoint2D pt)
+  {
+    side2End_ = pt;
+    RefreshScene();
+  }
+
+  void AngleMeasureTool::SetCenter(ScenePoint2D pt)
+  {
+    center_ = pt;
+    RefreshScene();
+  }
+  
+  PolylineSceneLayer* AngleMeasureTool::GetPolylineLayer()
+  {
+    assert(GetScene()->HasLayer(polylineZIndex_));
+    ISceneLayer* layer = &(GetScene()->GetLayer(polylineZIndex_));
+    PolylineSceneLayer* concreteLayer = dynamic_cast<PolylineSceneLayer*>(layer);
+    assert(concreteLayer != NULL);
+    return concreteLayer;
+  }
+
+  void AngleMeasureTool::RefreshScene()
+  {
+    if (IsEnabled())
+    {
+      // get the scaling factor 
+      const double pixelToScene =
+        GetScene()->GetCanvasToSceneTransform().ComputeZoom();
+
+      if (!layersCreated)
+      {
+        // Create the layers if need be
+
+        assert(textBaseZIndex_ == -1);
+        {
+          polylineZIndex_ = GetScene()->GetMaxDepth() + 100;
+          //LOG(INFO) << "set polylineZIndex_ to: " << polylineZIndex_;
+          std::auto_ptr<PolylineSceneLayer> layer(new PolylineSceneLayer());
+          GetScene()->SetLayer(polylineZIndex_, layer.release());
+
+        }
+        {
+          textBaseZIndex_ = GetScene()->GetMaxDepth() + 100;
+          // create the four text background layers
+          {
+            std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer());
+            GetScene()->SetLayer(textBaseZIndex_, layer.release());
+          }
+          {
+            std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer());
+            GetScene()->SetLayer(textBaseZIndex_+1, layer.release());
+          }
+          {
+            std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer());
+            GetScene()->SetLayer(textBaseZIndex_+2, layer.release());
+          }
+          {
+            std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer());
+            GetScene()->SetLayer(textBaseZIndex_+3, layer.release());
+          }
+          
+          // and the text layer itself
+          {
+            std::auto_ptr<TextSceneLayer> layer(new TextSceneLayer());
+            GetScene()->SetLayer(textBaseZIndex_+4, layer.release());
+          }
+          
+        }
+        layersCreated = true;
+      }
+      else
+      {
+        assert(GetScene()->HasLayer(polylineZIndex_));
+        assert(GetScene()->HasLayer(textBaseZIndex_));
+      }
+      {
+        // Fill the polyline layer with the measurement line
+
+        PolylineSceneLayer* polylineLayer = GetPolylineLayer();
+        polylineLayer->ClearAllChains();
+        polylineLayer->SetColor(0, 183, 17);
+
+        // sides
+        {
+          {
+            PolylineSceneLayer::Chain chain;
+            chain.push_back(side1End_);
+            chain.push_back(center_);
+            polylineLayer->AddChain(chain, false);
+          }
+          {
+            PolylineSceneLayer::Chain chain;
+            chain.push_back(side2End_);
+            chain.push_back(center_);
+            polylineLayer->AddChain(chain, false);
+          }
+        }
+
+        // handles
+        {
+          //void AddSquare(PolylineSceneLayer::Chain& chain,const Scene2D& scene,const ScenePoint2D& centerS,const double& sideLength)
+
+          {
+            PolylineSceneLayer::Chain chain;
+            AddSquare(chain, *GetScene(), side1End_, 10.0* pixelToScene); //TODO: take DPI into account
+            polylineLayer->AddChain(chain, true);
+          }
+
+          {
+            PolylineSceneLayer::Chain chain;
+            AddSquare(chain, *GetScene(), side2End_, 10.0* pixelToScene); //TODO: take DPI into account
+            polylineLayer->AddChain(chain, true);
+          }
+        }
+
+        // arc
+        {
+          PolylineSceneLayer::Chain chain;
+
+          const double ARC_RADIUS_CANVAS_COORD = 30.0;
+          AddShortestArc(chain, *GetScene(), side1End_, center_, side2End_, 
+            ARC_RADIUS_CANVAS_COORD*pixelToScene);
+          polylineLayer->AddChain(chain, false);
+        }
+      }
+      {
+        // Set the text layer
+
+        double p1cAngle = atan2(
+          side1End_.GetY() - center_.GetY(),
+          side1End_.GetX() - center_.GetX());
+
+
+        double p2cAngle = atan2(
+          side2End_.GetY() - center_.GetY(),
+          side2End_.GetX() - center_.GetX());
+
+        double delta = NormalizeAngle(p2cAngle - p1cAngle);
+
+
+        double theta = p1cAngle + delta/2;
+
+
+        const double TEXT_CENTER_DISTANCE_CANVAS_COORD = 90;
+
+        double offsetX = TEXT_CENTER_DISTANCE_CANVAS_COORD * cos(theta);
+
+        double offsetY = TEXT_CENTER_DISTANCE_CANVAS_COORD * sin(theta);
+
+        double pointX = center_.GetX() + offsetX * pixelToScene;
+        double pointY = center_.GetY() + offsetY * pixelToScene;
+
+        char buf[64];
+        double angleDeg = RadiansToDegrees(delta);
+
+        // http://www.ltg.ed.ac.uk/~richard/utf-8.cgi?input=00B0&mode=hex
+        sprintf(buf, "%0.02f\xc2\xb0", angleDeg);
+
+        SetTextLayerOutlineProperties(
+          *GetScene(), textBaseZIndex_, buf, ScenePoint2D(pointX, pointY));
+
+        // TODO:make it togglable
+        bool enableInfoDisplay = false;
+        if (enableInfoDisplay)
+        {
+          TrackerSample_SetInfoDisplayMessage("center_.GetX()",
+            boost::lexical_cast<std::string>(center_.GetX()));
+
+          TrackerSample_SetInfoDisplayMessage("center_.GetY()",
+            boost::lexical_cast<std::string>(center_.GetY()));
+
+          TrackerSample_SetInfoDisplayMessage("side1End_.GetX()",
+            boost::lexical_cast<std::string>(side1End_.GetX()));
+
+          TrackerSample_SetInfoDisplayMessage("side1End_.GetY()",
+            boost::lexical_cast<std::string>(side1End_.GetY()));
+
+          TrackerSample_SetInfoDisplayMessage("side2End_.GetX()",
+            boost::lexical_cast<std::string>(side2End_.GetX()));
+
+          TrackerSample_SetInfoDisplayMessage("side2End_.GetY()",
+            boost::lexical_cast<std::string>(side2End_.GetY()));
+
+          TrackerSample_SetInfoDisplayMessage("p1cAngle (deg)",
+            boost::lexical_cast<std::string>(RadiansToDegrees(p1cAngle)));
+
+          TrackerSample_SetInfoDisplayMessage("delta (deg)",
+            boost::lexical_cast<std::string>(RadiansToDegrees(delta)));
+
+          TrackerSample_SetInfoDisplayMessage("theta (deg)",
+            boost::lexical_cast<std::string>(RadiansToDegrees(theta)));
+
+          TrackerSample_SetInfoDisplayMessage("p2cAngle (deg)",
+            boost::lexical_cast<std::string>(RadiansToDegrees(p2cAngle)));
+
+          TrackerSample_SetInfoDisplayMessage("offsetX (pix)",
+            boost::lexical_cast<std::string>(offsetX));
+
+          TrackerSample_SetInfoDisplayMessage("offsetY (pix)",
+            boost::lexical_cast<std::string>(offsetY));
+
+          TrackerSample_SetInfoDisplayMessage("pointX",
+            boost::lexical_cast<std::string>(pointX));
+
+          TrackerSample_SetInfoDisplayMessage("pointY",
+            boost::lexical_cast<std::string>(pointY));
+
+          TrackerSample_SetInfoDisplayMessage("angleDeg",
+            boost::lexical_cast<std::string>(angleDeg));
+        }
+
+
+
+      }
+    }
+    else
+    {
+      if (layersCreated)
+      {
+        RemoveFromScene();
+        layersCreated = false;
+      }
+    }
+  }
+
+
+}