Mercurial > hg > orthanc-stone
comparison Framework/Scene2DViewport/AngleMeasureTool.cpp @ 880:9953f16c304d am-dev
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 |