Mercurial > hg > orthanc-stone

comparison Framework/Scene2DViewport/AngleMeasureTool.cpp @ 880:9953f16c304d am-dev

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge
author Alain Mazy <alain@mazy.be>
date Fri, 05 Jul 2019 15:33:02 +0200
parents c71ef52602a0
children 0aff28f15ea2
comparison
equal deleted inserted replaced
879:12b591d5d63c 880:9953f16c304d
18 * along with this program. If not, see <http://www.gnu.org/licenses/>. 18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 **/ 19 **/
20 20
21 #include "AngleMeasureTool.h" 21 #include "AngleMeasureTool.h"
22 #include "MeasureToolsToolbox.h" 22 #include "MeasureToolsToolbox.h"
23 #include "EditAngleMeasureTracker.h"
23 #include "LayerHolder.h" 24 #include "LayerHolder.h"
24 25
25 #include <Core/Logging.h> 26 #include <Core/Logging.h>
26 27
27 #include <boost/math/constants/constants.hpp> 28 #include <boost/math/constants/constants.hpp>
41 // layers 42 // layers
42 AngleMeasureTool::AngleMeasureTool( 43 AngleMeasureTool::AngleMeasureTool(
43 MessageBroker& broker, boost::weak_ptr<ViewportController> controllerW) 44 MessageBroker& broker, boost::weak_ptr<ViewportController> controllerW)
44 : MeasureTool(broker, controllerW) 45 : MeasureTool(broker, controllerW)
45 , layerHolder_(boost::make_shared<LayerHolder>(controllerW,1,5)) 46 , layerHolder_(boost::make_shared<LayerHolder>(controllerW,1,5))
47 , angleHighlightArea_(AngleHighlightArea_None)
46 { 48 {
47 49
48 } 50 }
49 51
50 AngleMeasureTool::~AngleMeasureTool() 52 AngleMeasureTool::~AngleMeasureTool()
73 { 75 {
74 side2End_ = pt; 76 side2End_ = pt;
75 RefreshScene(); 77 RefreshScene();
76 } 78 }
77 79
80 void AngleMeasureTool::SetAngleHighlightArea(AngleHighlightArea area)
81 {
82 if (angleHighlightArea_ != area)
83 {
84 angleHighlightArea_ = area;
85 RefreshScene();
86 }
87 }
88
89 void AngleMeasureTool::ResetHighlightState()
90 {
91 SetAngleHighlightArea(AngleHighlightArea_None);
92 }
93
94
95 boost::shared_ptr<OrthancStone::MeasureToolMemento> AngleMeasureTool::GetMemento() const
96 {
97 boost::shared_ptr<AngleMeasureToolMemento> memento(new AngleMeasureToolMemento());
98 memento->center_ = center_;
99 memento->side1End_ = side1End_;
100 memento->side2End_ = side2End_;
101 return memento;
102 }
103
104 void AngleMeasureTool::SetMemento(boost::shared_ptr<MeasureToolMemento> mementoBase)
105 {
106 boost::shared_ptr<AngleMeasureToolMemento> memento = boost::dynamic_pointer_cast<AngleMeasureToolMemento>(mementoBase);
107 ORTHANC_ASSERT(memento.get() != NULL, "Internal error: wrong (or bad) memento");
108 center_ = memento->center_;
109 side1End_ = memento->side1End_;
110 side2End_ = memento->side2End_;
111 RefreshScene();
112 }
113
114 void AngleMeasureTool::Highlight(ScenePoint2D p)
115 {
116 AngleHighlightArea angleHighlightArea = AngleHitTest(p);
117 SetAngleHighlightArea(angleHighlightArea);
118 }
119
120 AngleMeasureTool::AngleHighlightArea AngleMeasureTool::AngleHitTest(ScenePoint2D p) const
121 {
122 const double pixelToScene =
123 GetScene()->GetCanvasToSceneTransform().ComputeZoom();
124 const double SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD = pixelToScene * HIT_TEST_MAX_DISTANCE_CANVAS_COORD * pixelToScene * HIT_TEST_MAX_DISTANCE_CANVAS_COORD;
125
126 {
127 const double sqDistanceFromSide1End = ScenePoint2D::SquaredDistancePtPt(p, side1End_);
128 if (sqDistanceFromSide1End <= SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD)
129 return AngleHighlightArea_Side1End;
130 }
131
132 {
133 const double sqDistanceFromSide2End = ScenePoint2D::SquaredDistancePtPt(p, side2End_);
134 if (sqDistanceFromSide2End <= SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD)
135 return AngleHighlightArea_Side2End;
136 }
137
138 {
139 const double sqDistanceFromCenter = ScenePoint2D::SquaredDistancePtPt(p, center_);
140 if (sqDistanceFromCenter <= SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD)
141 return AngleHighlightArea_Center;
142 }
143
144 {
145 const double sqDistanceFromSide1 = ScenePoint2D::SquaredDistancePtSegment(center_, side1End_, p);
146 if (sqDistanceFromSide1 <= SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD)
147 return AngleHighlightArea_Side1;
148 }
149
150 {
151 const double sqDistanceFromSide2 = ScenePoint2D::SquaredDistancePtSegment(center_, side2End_, p);
152 if (sqDistanceFromSide2 <= SQUARED_HIT_TEST_MAX_DISTANCE_SCENE_COORD)
153 return AngleHighlightArea_Side2;
154 }
155
156 return AngleHighlightArea_None;
157 }
78 158
79 bool AngleMeasureTool::HitTest(ScenePoint2D p) const 159 bool AngleMeasureTool::HitTest(ScenePoint2D p) const
80 { 160 {
81 throw std::logic_error("The method or operation is not implemented."); 161 return AngleHitTest(p) != AngleHighlightArea_None;
162 }
163
164
165 boost::shared_ptr<IFlexiblePointerTracker> AngleMeasureTool::CreateEditionTracker(const PointerEvent& e)
166 {
167 ScenePoint2D scenePos = e.GetMainPosition().Apply(
168 GetScene()->GetCanvasToSceneTransform());
169
170 if (!HitTest(scenePos))
171 return boost::shared_ptr<IFlexiblePointerTracker>();
172
173 /**
174 new EditLineMeasureTracker(
175 boost::shared_ptr<LineMeasureTool> measureTool;
176 MessageBroker & broker,
177 boost::weak_ptr<ViewportController> controllerW,
178 const PointerEvent & e);
179 */
180 boost::shared_ptr<EditAngleMeasureTracker> editAngleMeasureTracker(
181 new EditAngleMeasureTracker(shared_from_this(), GetBroker(), GetController(), e));
182 return editAngleMeasureTracker;
82 } 183 }
83 184
84 void AngleMeasureTool::SetCenter(ScenePoint2D pt) 185 void AngleMeasureTool::SetCenter(ScenePoint2D pt)
85 { 186 {
86 center_ = pt; 187 center_ = pt;
99 { 200 {
100 // Fill the polyline layer with the measurement lines 201 // Fill the polyline layer with the measurement lines
101 PolylineSceneLayer* polylineLayer = layerHolder_->GetPolylineLayer(0); 202 PolylineSceneLayer* polylineLayer = layerHolder_->GetPolylineLayer(0);
102 polylineLayer->ClearAllChains(); 203 polylineLayer->ClearAllChains();
103 204
104 const Color color(0, 183, 17); 205 const Color color(TOOL_ANGLE_LINES_COLOR_RED, TOOL_ANGLE_LINES_COLOR_GREEN, TOOL_ANGLE_LINES_COLOR_BLUE);
206 const Color highlightColor(TOOL_ANGLE_LINES_HL_COLOR_RED, TOOL_ANGLE_LINES_HL_COLOR_GREEN, TOOL_ANGLE_LINES_HL_COLOR_BLUE);
105 207
106 // sides 208 // sides
107 { 209 {
108 { 210 {
109 PolylineSceneLayer::Chain chain; 211 PolylineSceneLayer::Chain chain;
110 chain.push_back(side1End_); 212 chain.push_back(side1End_);
111 chain.push_back(center_); 213 chain.push_back(center_);
112 polylineLayer->AddChain(chain, false, color); 214
215 if ((angleHighlightArea_ == AngleHighlightArea_Side1) || (angleHighlightArea_ == AngleHighlightArea_Side2))
216 polylineLayer->AddChain(chain, false, highlightColor);
217 else
218 polylineLayer->AddChain(chain, false, color);
113 } 219 }
114 { 220 {
115 PolylineSceneLayer::Chain chain; 221 PolylineSceneLayer::Chain chain;
116 chain.push_back(side2End_); 222 chain.push_back(side2End_);
117 chain.push_back(center_); 223 chain.push_back(center_);
118 polylineLayer->AddChain(chain, false, color); 224 if ((angleHighlightArea_ == AngleHighlightArea_Side1) || (angleHighlightArea_ == AngleHighlightArea_Side2))
225 polylineLayer->AddChain(chain, false, highlightColor);
226 else
227 polylineLayer->AddChain(chain, false, color);
119 } 228 }
120 } 229 }
121 230
122 // Create the handles 231 // Create the handles
123 { 232 {
124 { 233 {
125 PolylineSceneLayer::Chain chain; 234 PolylineSceneLayer::Chain chain;
126 //TODO: take DPI into account 235 //TODO: take DPI into account
127 AddSquare(chain, GetScene(), side1End_, 236 AddSquare(chain, GetScene(), side1End_,
128 GetController()->GetHandleSideLengthS()); 237 GetController()->GetHandleSideLengthS());
129 polylineLayer->AddChain(chain, true, color); 238
239 if (angleHighlightArea_ == AngleHighlightArea_Side1End)
240 polylineLayer->AddChain(chain, true, highlightColor);
241 else
242 polylineLayer->AddChain(chain, true, color);
243
130 } 244 }
131 { 245 {
132 PolylineSceneLayer::Chain chain; 246 PolylineSceneLayer::Chain chain;
133 //TODO: take DPI into account 247 //TODO: take DPI into account
134 AddSquare(chain, GetScene(), side2End_, 248 AddSquare(chain, GetScene(), side2End_,
135 GetController()->GetHandleSideLengthS()); 249 GetController()->GetHandleSideLengthS());
136 polylineLayer->AddChain(chain, true, color); 250
251 if (angleHighlightArea_ == AngleHighlightArea_Side2End)
252 polylineLayer->AddChain(chain, true, highlightColor);
253 else
254 polylineLayer->AddChain(chain, true, color);
137 } 255 }
138 } 256 }
139 257
140 // Create the arc 258 // Create the arc
141 { 259 {
142 PolylineSceneLayer::Chain chain; 260 PolylineSceneLayer::Chain chain;
143 261
144 AddShortestArc(chain, side1End_, center_, side2End_, 262 AddShortestArc(chain, side1End_, center_, side2End_,
145 controller->GetAngleToolArcRadiusS()); 263 controller->GetAngleToolArcRadiusS());
146 polylineLayer->AddChain(chain, false, color); 264 if (angleHighlightArea_ == AngleHighlightArea_Center)
265 polylineLayer->AddChain(chain, false, highlightColor);
266 else
267 polylineLayer->AddChain(chain, false, color);
147 } 268 }
148 } 269 }
149 { 270 {
150 // Set the text layer 271 // Set the text layer
151 272