Mercurial > hg > orthanc-stone

comparison OrthancStone/Sources/Scene2D/AnnotationsSceneLayer.cpp @ 1998:1fa3f484008e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
added arrows to AnnotationsSceneLayer::Segment
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 02 Nov 2022 13:08:50 +0100
parents f03a827f8b47
children 709b90ae0f89
comparison
equal deleted inserted replaced
1997:c622219a3388 1998:1fa3f484008e
32 #include <OrthancException.h> 32 #include <OrthancException.h>
33 33
34 #include <boost/math/constants/constants.hpp> 34 #include <boost/math/constants/constants.hpp>
35 #include <list> 35 #include <list>
36 36
37 static const double PI = boost::math::constants::pi<double>();
38
37 static const double HANDLE_SIZE = 10.0; 39 static const double HANDLE_SIZE = 10.0;
38 static const double PI = boost::math::constants::pi<double>(); 40 static const double ARROW_LENGTH = 1.5 * HANDLE_SIZE;
41 static const double ARROW_ANGLE = 20.0 * PI / 180.0;
39 42
40 static const char* const KEY_ANNOTATIONS = "annotations"; 43 static const char* const KEY_ANNOTATIONS = "annotations";
41 static const char* const KEY_TYPE = "type"; 44 static const char* const KEY_TYPE = "type";
45 static const char* const KEY_TEXT = "text";
42 static const char* const KEY_X = "x"; 46 static const char* const KEY_X = "x";
43 static const char* const KEY_Y = "y"; 47 static const char* const KEY_Y = "y";
44 static const char* const KEY_X1 = "x1"; 48 static const char* const KEY_X1 = "x1";
45 static const char* const KEY_Y1 = "y1"; 49 static const char* const KEY_Y1 = "y1";
46 static const char* const KEY_X2 = "x2"; 50 static const char* const KEY_X2 = "x2";
49 static const char* const KEY_Y3 = "y3"; 53 static const char* const KEY_Y3 = "y3";
50 static const char* const KEY_UNITS = "units"; 54 static const char* const KEY_UNITS = "units";
51 55
52 static const char* const VALUE_ANGLE = "angle"; 56 static const char* const VALUE_ANGLE = "angle";
53 static const char* const VALUE_CIRCLE = "circle"; 57 static const char* const VALUE_CIRCLE = "circle";
54 static const char* const VALUE_SEGMENT = "segment"; 58 static const char* const VALUE_LENGTH = "length";
55 static const char* const VALUE_MILLIMETERS = "millimeters"; 59 static const char* const VALUE_MILLIMETERS = "millimeters";
56 static const char* const VALUE_PIXELS = "pixels"; 60 static const char* const VALUE_PIXELS = "pixels";
57 static const char* const VALUE_PIXEL_PROBE = "pixel-probe"; 61 static const char* const VALUE_PIXEL_PROBE = "pixel-probe";
58 static const char* const VALUE_RECTANGLE_PROBE = "rectangle-probe"; 62 static const char* const VALUE_RECTANGLE_PROBE = "rectangle-probe";
59 static const char* const VALUE_ELLIPSE_PROBE = "ellipse-probe"; 63 static const char* const VALUE_ELLIPSE_PROBE = "ellipse-probe";
64 static const char* const VALUE_TEXT_ANNOTATION = "text";
60 65
61 #if 0 66 #if 0
62 static OrthancStone::Color COLOR_PRIMITIVES(192, 192, 192); 67 static OrthancStone::Color COLOR_PRIMITIVES(192, 192, 192);
63 static OrthancStone::Color COLOR_HOVER(0, 255, 0); 68 static OrthancStone::Color COLOR_HOVER(0, 255, 0);
64 static OrthancStone::Color COLOR_TEXT(255, 0, 0); 69 static OrthancStone::Color COLOR_TEXT(255, 0, 0);
299 } 304 }
300 305
301 void SetCenter(double x, 306 void SetCenter(double x,
302 double y) 307 double y)
303 { 308 {
304 SetModified(true); 309 SetCenter(ScenePoint2D(x, y));
305 center_ = ScenePoint2D(x, y);
306 delta_ = ScenePoint2D(0, 0);
307 } 310 }
308 311
309 ScenePoint2D GetCenter() const 312 ScenePoint2D GetCenter() const
310 { 313 {
311 return center_ + delta_; 314 return center_ + delta_;
392 { 395 {
393 private: 396 private:
394 ScenePoint2D p1_; 397 ScenePoint2D p1_;
395 ScenePoint2D p2_; 398 ScenePoint2D p2_;
396 ScenePoint2D delta_; 399 ScenePoint2D delta_;
400 bool hasStartArrow_;
401 bool hasEndArrow_;
397 402
398 public: 403 public:
399 Segment(Annotation& parentAnnotation, 404 Segment(Annotation& parentAnnotation,
400 const ScenePoint2D& p1, 405 const ScenePoint2D& p1,
401 const ScenePoint2D& p2) : 406 const ScenePoint2D& p2) :
402 GeometricPrimitive(parentAnnotation, 1), // Can only be selected if no handle matches 407 GeometricPrimitive(parentAnnotation, 1), // Can only be selected if no handle matches
403 p1_(p1), 408 p1_(p1),
404 p2_(p2), 409 p2_(p2),
405 delta_(0, 0) 410 delta_(0, 0),
411 hasStartArrow_(false),
412 hasEndArrow_(false)
406 { 413 {
407 } 414 }
408 415
409 Segment(Annotation& parentAnnotation, 416 Segment(Annotation& parentAnnotation,
410 double x1, 417 double x1,
412 double x2, 419 double x2,
413 double y2) : 420 double y2) :
414 GeometricPrimitive(parentAnnotation, 1), // Can only be selected if no handle matches 421 GeometricPrimitive(parentAnnotation, 1), // Can only be selected if no handle matches
415 p1_(x1, y1), 422 p1_(x1, y1),
416 p2_(x2, y2), 423 p2_(x2, y2),
417 delta_(0, 0) 424 delta_(0, 0),
425 hasStartArrow_(false),
426 hasEndArrow_(false)
418 { 427 {
419 } 428 }
420 429
421 void SetPosition(const ScenePoint2D& p1, 430 void SetPosition(const ScenePoint2D& p1,
422 const ScenePoint2D& p2) 431 const ScenePoint2D& p2)
446 ScenePoint2D GetPosition2() const 455 ScenePoint2D GetPosition2() const
447 { 456 {
448 return p2_ + delta_; 457 return p2_ + delta_;
449 } 458 }
450 459
460 void SetStartArrow(bool enabled)
461 {
462 SetModified(true);
463 hasStartArrow_ = enabled;
464 }
465
466 bool HasStartArrow() const
467 {
468 return hasStartArrow_;
469 }
470
471 void SetEndArrow(bool enabled)
472 {
473 SetModified(true);
474 hasEndArrow_ = enabled;
475 }
476
477 bool HasEndArrow() const
478 {
479 return hasEndArrow_;
480 }
481
451 virtual bool IsHit(const ScenePoint2D& p, 482 virtual bool IsHit(const ScenePoint2D& p,
452 const Scene2D& scene) const ORTHANC_OVERRIDE 483 const Scene2D& scene) const ORTHANC_OVERRIDE
453 { 484 {
454 const double zoom = scene.GetSceneToCanvasTransform().ComputeZoom(); 485 const double zoom = scene.GetSceneToCanvasTransform().ComputeZoom();
455 return (ScenePoint2D::SquaredDistancePtSegment(p1_ + delta_, p2_ + delta_, p) * zoom * zoom <= 486 return (ScenePoint2D::SquaredDistancePtSegment(p1_ + delta_, p2_ + delta_, p) * zoom * zoom <=
457 } 488 }
458 489
459 virtual void RenderPolylineLayer(PolylineSceneLayer& polyline, 490 virtual void RenderPolylineLayer(PolylineSceneLayer& polyline,
460 const Scene2D& scene) ORTHANC_OVERRIDE 491 const Scene2D& scene) ORTHANC_OVERRIDE
461 { 492 {
462 polyline.AddSegment(p1_ + delta_, p2_ + delta_, GetActiveColor()); 493 const Color color = GetActiveColor();
494 const ScenePoint2D a(p1_ + delta_);
495 const ScenePoint2D b(p2_ + delta_);
496
497 polyline.AddSegment(a, b, color);
498
499 if (hasStartArrow_ ||
500 hasEndArrow_)
501 {
502 const double length = ARROW_LENGTH / scene.GetSceneToCanvasTransform().ComputeZoom();
503 const double angle = atan2(b.GetY() - a.GetY(), b.GetX() - a.GetX());
504
505 if (hasStartArrow_)
506 {
507 polyline.AddSegment(a, a + ScenePoint2D(
508 length * cos(angle + ARROW_ANGLE),
509 length * sin(angle + ARROW_ANGLE)), color);
510 polyline.AddSegment(a, a + ScenePoint2D(
511 length * cos(angle - ARROW_ANGLE),
512 length * sin(angle - ARROW_ANGLE)), color);
513 }
514
515 if (hasEndArrow_)
516 {
517 polyline.AddSegment(b, b + ScenePoint2D(
518 length * cos(angle + ARROW_ANGLE + PI),
519 length * sin(angle + ARROW_ANGLE + PI)), color);
520 polyline.AddSegment(b, b + ScenePoint2D(
521 length * cos(angle - ARROW_ANGLE + PI),
522 length * sin(angle - ARROW_ANGLE + PI)), color);
523 }
524 }
463 } 525 }
464 526
465 virtual void RenderOtherLayers(MacroSceneLayer& macro, 527 virtual void RenderOtherLayers(MacroSceneLayer& macro,
466 const Scene2D& scene) ORTHANC_OVERRIDE 528 const Scene2D& scene) ORTHANC_OVERRIDE
467 { 529 {
994 primitive_.MoveDone(sceneClick_, scene); // TODO Check this 1056 primitive_.MoveDone(sceneClick_, scene); // TODO Check this
995 } 1057 }
996 }; 1058 };
997 1059
998 1060
999 class AnnotationsSceneLayer::SegmentAnnotation : public Annotation 1061 class AnnotationsSceneLayer::LengthAnnotation : public Annotation
1000 { 1062 {
1001 private: 1063 private:
1002 bool showLabel_; 1064 bool showLabel_;
1003 Handle& handle1_; 1065 Handle& handle1_;
1004 Handle& handle2_; 1066 Handle& handle2_;
1052 label_.SetContent(content); 1114 label_.SetContent(content);
1053 } 1115 }
1054 } 1116 }
1055 1117
1056 public: 1118 public:
1057 SegmentAnnotation(AnnotationsSceneLayer& that, 1119 LengthAnnotation(AnnotationsSceneLayer& that,
1058 Units units, 1120 Units units,
1059 bool showLabel, 1121 bool showLabel,
1060 const ScenePoint2D& p1, 1122 const ScenePoint2D& p1,
1061 const ScenePoint2D& p2) : 1123 const ScenePoint2D& p2) :
1062 Annotation(that, units), 1124 Annotation(that, units),
1063 showLabel_(showLabel), 1125 showLabel_(showLabel),
1064 handle1_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_Square, p1))), 1126 handle1_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_Square, p1))),
1065 handle2_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_Square, p2))), 1127 handle2_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_Square, p2))),
1066 segment_(AddTypedPrimitive<Segment>(new Segment(*this, p1, p2))), 1128 segment_(AddTypedPrimitive<Segment>(new Segment(*this, p1, p2))),
1116 } 1178 }
1117 1179
1118 virtual void Serialize(Json::Value& target) ORTHANC_OVERRIDE 1180 virtual void Serialize(Json::Value& target) ORTHANC_OVERRIDE
1119 { 1181 {
1120 target = Json::objectValue; 1182 target = Json::objectValue;
1121 target[KEY_TYPE] = VALUE_SEGMENT; 1183 target[KEY_TYPE] = VALUE_LENGTH;
1122 target[KEY_X1] = handle1_.GetCenter().GetX(); 1184 target[KEY_X1] = handle1_.GetCenter().GetX();
1123 target[KEY_Y1] = handle1_.GetCenter().GetY(); 1185 target[KEY_Y1] = handle1_.GetCenter().GetY();
1124 target[KEY_X2] = handle2_.GetCenter().GetX(); 1186 target[KEY_X2] = handle2_.GetCenter().GetX();
1125 target[KEY_Y2] = handle2_.GetCenter().GetY(); 1187 target[KEY_Y2] = handle2_.GetCenter().GetY();
1126 } 1188 }
1136 source[KEY_X1].isNumeric() && 1198 source[KEY_X1].isNumeric() &&
1137 source[KEY_Y1].isNumeric() && 1199 source[KEY_Y1].isNumeric() &&
1138 source[KEY_X2].isNumeric() && 1200 source[KEY_X2].isNumeric() &&
1139 source[KEY_Y2].isNumeric()) 1201 source[KEY_Y2].isNumeric())
1140 { 1202 {
1141 new SegmentAnnotation(target, units, true, 1203 new LengthAnnotation(target, units, true,
1142 ScenePoint2D(source[KEY_X1].asDouble(), source[KEY_Y1].asDouble()), 1204 ScenePoint2D(source[KEY_X1].asDouble(), source[KEY_Y1].asDouble()),
1143 ScenePoint2D(source[KEY_X2].asDouble(), source[KEY_Y2].asDouble())); 1205 ScenePoint2D(source[KEY_X2].asDouble(), source[KEY_Y2].asDouble()));
1144 } 1206 }
1145 else 1207 else
1146 { 1208 {
1147 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat, "Cannot unserialize an segment annotation"); 1209 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat, "Cannot unserialize a length annotation");
1148 } 1210 }
1149 } 1211 }
1150 }; 1212 };
1151 1213
1152 1214
2177 2239
2178 class AnnotationsSceneLayer::CreateAngleTracker : public IFlexiblePointerTracker 2240 class AnnotationsSceneLayer::CreateAngleTracker : public IFlexiblePointerTracker
2179 { 2241 {
2180 private: 2242 private:
2181 AnnotationsSceneLayer& that_; 2243 AnnotationsSceneLayer& that_;
2182 SegmentAnnotation* segment_; 2244 LengthAnnotation* length_;
2183 AngleAnnotation* angle_; 2245 AngleAnnotation* angle_;
2184 AffineTransform2D canvasToScene_; 2246 AffineTransform2D canvasToScene_;
2185 2247
2186 public: 2248 public:
2187 CreateAngleTracker(AnnotationsSceneLayer& that, 2249 CreateAngleTracker(AnnotationsSceneLayer& that,
2188 Units units, 2250 Units units,
2189 const ScenePoint2D& sceneClick, 2251 const ScenePoint2D& sceneClick,
2190 const AffineTransform2D& canvasToScene) : 2252 const AffineTransform2D& canvasToScene) :
2191 that_(that), 2253 that_(that),
2192 segment_(NULL), 2254 length_(NULL),
2193 angle_(NULL), 2255 angle_(NULL),
2194 canvasToScene_(canvasToScene) 2256 canvasToScene_(canvasToScene)
2195 { 2257 {
2196 segment_ = new SegmentAnnotation(that, units, false /* no length label */, sceneClick, sceneClick); 2258 length_ = new LengthAnnotation(that, units, false /* no length label */, sceneClick, sceneClick);
2197 } 2259 }
2198 2260
2199 virtual void PointerMove(const PointerEvent& event, 2261 virtual void PointerMove(const PointerEvent& event,
2200 const Scene2D& scene) ORTHANC_OVERRIDE 2262 const Scene2D& scene) ORTHANC_OVERRIDE
2201 { 2263 {
2202 if (segment_ != NULL) 2264 if (length_ != NULL)
2203 { 2265 {
2204 segment_->GetHandle(1).SetCenter(event.GetMainPosition().Apply(canvasToScene_)); 2266 length_->GetHandle(1).SetCenter(event.GetMainPosition().Apply(canvasToScene_));
2205 segment_->SignalMove(segment_->GetHandle(1), scene); 2267 length_->SignalMove(length_->GetHandle(1), scene);
2206 that_.BroadcastMessage(AnnotationChangedMessage(that_)); 2268 that_.BroadcastMessage(AnnotationChangedMessage(that_));
2207 } 2269 }
2208 2270
2209 if (angle_ != NULL) 2271 if (angle_ != NULL)
2210 { 2272 {
2215 } 2277 }
2216 2278
2217 virtual void PointerUp(const PointerEvent& event, 2279 virtual void PointerUp(const PointerEvent& event,
2218 const Scene2D& scene) ORTHANC_OVERRIDE 2280 const Scene2D& scene) ORTHANC_OVERRIDE
2219 { 2281 {
2220 if (segment_ != NULL) 2282 if (length_ != NULL)
2221 { 2283 {
2222 // End of first step: The first segment is available, now create the angle 2284 // End of first step: The first segment is available, now create the angle
2223 2285
2224 angle_ = new AngleAnnotation(that_, segment_->GetUnits(), segment_->GetHandle(0).GetCenter(), 2286 angle_ = new AngleAnnotation(that_, length_->GetUnits(), length_->GetHandle(0).GetCenter(),
2225 segment_->GetHandle(1).GetCenter(), 2287 length_->GetHandle(1).GetCenter(),
2226 segment_->GetHandle(1).GetCenter()); 2288 length_->GetHandle(1).GetCenter());
2227 2289
2228 that_.DeleteAnnotation(segment_); 2290 that_.DeleteAnnotation(length_);
2229 segment_ = NULL; 2291 length_ = NULL;
2230 2292
2231 that_.BroadcastMessage(AnnotationChangedMessage(that_)); 2293 that_.BroadcastMessage(AnnotationChangedMessage(that_));
2232 } 2294 }
2233 else 2295 else
2234 { 2296 {
2243 { 2305 {
2244 } 2306 }
2245 2307
2246 virtual bool IsAlive() const ORTHANC_OVERRIDE 2308 virtual bool IsAlive() const ORTHANC_OVERRIDE
2247 { 2309 {
2248 return (segment_ != NULL || 2310 return (length_ != NULL ||
2249 angle_ != NULL); 2311 angle_ != NULL);
2250 } 2312 }
2251 2313
2252 virtual void Cancel(const Scene2D& scene) ORTHANC_OVERRIDE 2314 virtual void Cancel(const Scene2D& scene) ORTHANC_OVERRIDE
2253 { 2315 {
2254 if (segment_ != NULL) 2316 if (length_ != NULL)
2255 { 2317 {
2256 that_.DeleteAnnotation(segment_); 2318 that_.DeleteAnnotation(length_);
2257 segment_ = NULL; 2319 length_ = NULL;
2258 } 2320 }
2259 2321
2260 if (angle_ != NULL) 2322 if (angle_ != NULL)
2261 { 2323 {
2262 that_.DeleteAnnotation(angle_); 2324 that_.DeleteAnnotation(angle_);
2409 units_ = units; 2471 units_ = units;
2410 } 2472 }
2411 } 2473 }
2412 2474
2413 2475
2414 void AnnotationsSceneLayer::AddSegmentAnnotation(const ScenePoint2D& p1, 2476 void AnnotationsSceneLayer::AddLengthAnnotation(const ScenePoint2D& p1,
2415 const ScenePoint2D& p2) 2477 const ScenePoint2D& p2)
2416 { 2478 {
2417 annotations_.insert(new SegmentAnnotation(*this, units_, true /* show label */, p1, p2)); 2479 annotations_.insert(new LengthAnnotation(*this, units_, true /* show label */, p1, p2));
2418 } 2480 }
2419 2481
2420 2482
2421 void AnnotationsSceneLayer::AddCircleAnnotation(const ScenePoint2D& p1, 2483 void AnnotationsSceneLayer::AddCircleAnnotation(const ScenePoint2D& p1,
2422 const ScenePoint2D& p2) 2484 const ScenePoint2D& p2)
2576 } 2638 }
2577 else 2639 else
2578 { 2640 {
2579 switch (activeTool_) 2641 switch (activeTool_)
2580 { 2642 {
2581 case Tool_Segment: 2643 case Tool_Length:
2582 { 2644 {
2583 Annotation* annotation = new SegmentAnnotation(*this, units_, true /* show label */, s, s); 2645 Annotation* annotation = new LengthAnnotation(*this, units_, true /* show label */, s, s);
2584 return new CreateTwoHandlesTracker(*annotation, scene.GetCanvasToSceneTransform()); 2646 return new CreateTwoHandlesTracker(*annotation, scene.GetCanvasToSceneTransform());
2585 } 2647 }
2586 2648
2587 case Tool_Circle: 2649 case Tool_Circle:
2588 { 2650 {
2606 { 2668 {
2607 Annotation* annotation = new EllipseProbeAnnotation(*this, units_, s, s); 2669 Annotation* annotation = new EllipseProbeAnnotation(*this, units_, s, s);
2608 return new CreateTwoHandlesTracker(*annotation, scene.GetCanvasToSceneTransform()); 2670 return new CreateTwoHandlesTracker(*annotation, scene.GetCanvasToSceneTransform());
2609 } 2671 }
2610 2672
2673 /*case Tool_TextAnnotation:
2674 {
2675 Annotation* annotation = new TextAnnotation(*this, units_, true show label, s, s);
2676 return new CreateTwoHandlesTracker(*annotation, scene.GetCanvasToSceneTransform());
2677 }*/
2678
2611 default: 2679 default:
2612 return NULL; 2680 return NULL;
2613 } 2681 }
2614 } 2682 }
2615 } 2683 }
2695 } 2763 }
2696 else if (type == VALUE_CIRCLE) 2764 else if (type == VALUE_CIRCLE)
2697 { 2765 {
2698 CircleAnnotation::Unserialize(*this, units_, annotations[i]); 2766 CircleAnnotation::Unserialize(*this, units_, annotations[i]);
2699 } 2767 }
2700 else if (type == VALUE_SEGMENT) 2768 else if (type == VALUE_LENGTH)
2701 { 2769 {
2702 SegmentAnnotation::Unserialize(*this, units_, annotations[i]); 2770 LengthAnnotation::Unserialize(*this, units_, annotations[i]);
2703 } 2771 }
2704 else if (type == VALUE_PIXEL_PROBE) 2772 else if (type == VALUE_PIXEL_PROBE)
2705 { 2773 {
2706 PixelProbeAnnotation::Unserialize(*this, units_, annotations[i]); 2774 PixelProbeAnnotation::Unserialize(*this, units_, annotations[i]);
2707 } 2775 }
2711 } 2779 }
2712 else if (type == VALUE_ELLIPSE_PROBE) 2780 else if (type == VALUE_ELLIPSE_PROBE)
2713 { 2781 {
2714 EllipseProbeAnnotation::Unserialize(*this, units_, annotations[i]); 2782 EllipseProbeAnnotation::Unserialize(*this, units_, annotations[i]);
2715 } 2783 }
2784 /*else if (type == VALUE_TEXT_ANNOTATION)
2785 {
2786 TextAnnotation::Unserialize(*this, units_, annotations[i]);
2787 }*/
2716 else 2788 else
2717 { 2789 {
2718 LOG(ERROR) << "Cannot unserialize unknown type of annotation: " << type; 2790 LOG(ERROR) << "Cannot unserialize unknown type of annotation: " << type;
2719 } 2791 }
2720 } 2792 }