orthanc-stone: OrthancStone/Sources/Scene2D/AnnotationsSceneLayer.cpp comparison

comparison OrthancStone/Sources/Scene2D/AnnotationsSceneLayer.cpp @ 2000:3e9ced39cd1b

simplification

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 02 Nov 2022 13:52:14 +0100
parents	709b90ae0f89
children	e943a84da9ac

comparison

equal deleted inserted replaced

-:709b90ae0f89
+:3e9ced39cd1b
 private:
 typedef std::list<GeometricPrimitive*>  GeometricPrimitives;
 AnnotationsSceneLayer&  that_;
 GeometricPrimitives     primitives_;
-Units                   units_;
 public:
-explicit Annotation(AnnotationsSceneLayer& that,
+explicit Annotation(AnnotationsSceneLayer& that) :
-Units units) :
+that_(that)
-that_(that),
-units_(units)
 {
 that.AddAnnotation(this);
 }
 virtual ~Annotation()
 }
 AnnotationsSceneLayer& GetParentLayer() const
 {
 return that_;
-}
-Units GetUnits() const
-{
-return units_;
 }
 GeometricPrimitive* AddPrimitive(GeometricPrimitive* primitive)
 {
 if (primitive == NULL)
 segment_.SetEndArrow(enabled);
 }
 public:
 SegmentAnnotation(AnnotationsSceneLayer& that,
-Units units,
 Handle::Shape shape1,
 const ScenePoint2D& p1,
 Handle::Shape shape2,
 const ScenePoint2D& p2) :
-Annotation(that, units),
+Annotation(that),
 handle1_(AddTypedPrimitive<Handle>(new Handle(*this, shape1, p1))),
 handle2_(AddTypedPrimitive<Handle>(new Handle(*this, shape2, p2))),
 segment_(AddTypedPrimitive<Segment>(new Segment(*this, p1, p2))),
 label_(AddTypedPrimitive<Text>(new Text(that, *this)))
 {
 class AnnotationsSceneLayer::LengthAnnotation : public SegmentAnnotation
 {
 private:
-bool      showLabel_;
+Units  units_;
+bool   showLabel_;
 void UpdateLabel()
 {
 if (showLabel_)
 {
 double dx = x1 - x2;
 double dy = y1 - y2;
 char buf[32];
-switch (GetUnits())
+switch (units_)
 {
 case Units_Millimeters:
 sprintf(buf, "%0.2f cm", sqrt(dx * dx + dy * dy) / 10.0);
 break;
 LengthAnnotation(AnnotationsSceneLayer& that,
 Units units,
 bool showLabel,
 const ScenePoint2D& p1,
 const ScenePoint2D& p2) :
-SegmentAnnotation(that, units, Handle::Shape_Square, p1, Handle::Shape_Square, p2),
+SegmentAnnotation(that, Handle::Shape_Square, p1, Handle::Shape_Square, p2),
+units_(units),
 showLabel_(showLabel)
 {
 UpdateLabel();
 }
 class AnnotationsSceneLayer::TextAnnotation : public SegmentAnnotation
 {
 public:
 TextAnnotation(AnnotationsSceneLayer& that,
-Units units,
 const std::string& label,
 const ScenePoint2D& p1,
 const ScenePoint2D& p2) :
-SegmentAnnotation(that, units, Handle::Shape_Invisible, p1, Handle::Shape_Square, p2)
+SegmentAnnotation(that, Handle::Shape_Invisible, p1, Handle::Shape_Square, p2)
 {
 SetStartArrow(true);
 UpdateLabel(label);
 }
 target[KEY_Y2] = GetHandle2().GetCenter().GetY();
 target[KEY_LABEL] = GetCurrentLabel();
 }
 static void Unserialize(AnnotationsSceneLayer& target,
-Units units,
 const Json::Value& source)
 {
 if (source.isMember(KEY_X1) &&
 source.isMember(KEY_Y1) &&
 source.isMember(KEY_X2) &&
 source[KEY_Y1].isNumeric() &&
 source[KEY_X2].isNumeric() &&
 source[KEY_Y2].isNumeric() &&
 source[KEY_LABEL].isString())
 {
-new TextAnnotation(target, units, source[KEY_LABEL].asString(),
+new TextAnnotation(target, source[KEY_LABEL].asString(),
 ScenePoint2D(source[KEY_X1].asDouble(), source[KEY_Y1].asDouble()),
 ScenePoint2D(source[KEY_X2].asDouble(), source[KEY_Y2].asDouble()));
 }
 else
 {
 {
 probeChanged_ = true;
 }
 public:
-ProbingAnnotation(AnnotationsSceneLayer& that,
+ProbingAnnotation(AnnotationsSceneLayer& that) :
-Units units) :
+Annotation(that),
-Annotation(that, units),
 probedLayer_(that.GetProbedLayer()),
 probeChanged_(true),
 lastLayerRevision_(0)
 {
 }
 }
 }
 public:
 PixelProbeAnnotation(AnnotationsSceneLayer& that,
-Units units,
 const ScenePoint2D& p) :
-ProbingAnnotation(that, units),
+ProbingAnnotation(that),
 handle_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_CrossedSquare, p))),
 label_(AddTypedPrimitive<Text>(new Text(that, *this)))
 {
 TextSceneLayer content;
 content.SetPosition(handle_.GetCenter().GetX(), handle_.GetCenter().GetY());
 target[KEY_X] = handle_.GetCenter().GetX();
 target[KEY_Y] = handle_.GetCenter().GetY();
 }
 static void Unserialize(AnnotationsSceneLayer& target,
-Units units,
 const Json::Value& source)
 {
 if (source.isMember(KEY_X) &&
 source.isMember(KEY_Y) &&
 source[KEY_X].isNumeric() &&
 source[KEY_Y].isNumeric())
 {
-new PixelProbeAnnotation(target, units,
+new PixelProbeAnnotation(target, ScenePoint2D(source[KEY_X].asDouble(), source[KEY_Y].asDouble()));
-ScenePoint2D(source[KEY_X].asDouble(), source[KEY_Y].asDouble()));
 }
 else
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat, "Cannot unserialize a pixel probe");
 }
 label_.SetContent(content);
 }
 public:
 AngleAnnotation(AnnotationsSceneLayer& that,
-Units units,
 const ScenePoint2D& start,
 const ScenePoint2D& middle,
 const ScenePoint2D& end) :
-Annotation(that, units),
+Annotation(that),
 startHandle_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_Square, start))),
 middleHandle_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_Square, middle))),
 endHandle_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_Square, end))),
 segment1_(AddTypedPrimitive<Segment>(new Segment(*this, start, middle))),
 segment2_(AddTypedPrimitive<Segment>(new Segment(*this, middle, end))),
 target[KEY_X3] = endHandle_.GetCenter().GetX();
 target[KEY_Y3] = endHandle_.GetCenter().GetY();
 }
 static void Unserialize(AnnotationsSceneLayer& target,
-Units units,
 const Json::Value& source)
 {
 if (source.isMember(KEY_X1) &&
 source.isMember(KEY_Y1) &&
 source.isMember(KEY_X2) &&
 source[KEY_X2].isNumeric() &&
 source[KEY_Y2].isNumeric() &&
 source[KEY_X3].isNumeric() &&
 source[KEY_Y3].isNumeric())
 {
-new AngleAnnotation(target, units,
+new AngleAnnotation(target,
 ScenePoint2D(source[KEY_X1].asDouble(), source[KEY_Y1].asDouble()),
 ScenePoint2D(source[KEY_X2].asDouble(), source[KEY_Y2].asDouble()),
 ScenePoint2D(source[KEY_X3].asDouble(), source[KEY_Y3].asDouble()));
 }
 else
 class AnnotationsSceneLayer::CircleAnnotation : public Annotation
 {
 private:
+Units     units_;
 Handle&   handle1_;
 Handle&   handle2_;
 Segment&  segment_;
 Circle&   circle_;
 Text&     label_;
 double area = PI * diameter * diameter / 4.0;
 char buf[32];
-switch (GetUnits())
+switch (units_)
 {
 case Units_Millimeters:
 sprintf(buf, "%0.2f cm\n%0.2f cm%c%c",
 diameter / 10.0,
 area / 100.0,
 public:
 CircleAnnotation(AnnotationsSceneLayer& that,
 Units units,
 const ScenePoint2D& p1,
 const ScenePoint2D& p2) :
-Annotation(that, units),
+Annotation(that),
+units_(units),
 handle1_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_Square, p1))),
 handle2_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_Square, p2))),
 segment_(AddTypedPrimitive<Segment>(new Segment(*this, p1, p2))),
 circle_(AddTypedPrimitive<Circle>(new Circle(*this, p1, p2))),
 label_(AddTypedPrimitive<Text>(new Text(that, *this)))
 class AnnotationsSceneLayer::RectangleProbeAnnotation : public ProbingAnnotation
 {
 private:
+Units     units_;
 Handle&   handle1_;
 Handle&   handle2_;
 Segment&  segment1_;
 Segment&  segment2_;
 Segment&  segment3_;
 std::string text;
 char buf[32];
-if (GetUnits() == Units_Millimeters)
+if (units_ == Units_Millimeters)
 {
 const double area = std::abs(x1 - x2) * std::abs(y1 - y2);
 sprintf(buf, "Area: %0.2f cm%c%c",
 area / 100.0,
 public:
 RectangleProbeAnnotation(AnnotationsSceneLayer& that,
 Units units,
 const ScenePoint2D& p1,
 const ScenePoint2D& p2) :
-ProbingAnnotation(that, units),
+ProbingAnnotation(that),
+units_(units),
 handle1_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_Square, p1))),
 handle2_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_Square, p2))),
 segment1_(AddTypedPrimitive<Segment>(new Segment(*this, p1.GetX(), p1.GetY(), p2.GetX(), p1.GetY()))),
 segment2_(AddTypedPrimitive<Segment>(new Segment(*this, p2.GetX(), p1.GetY(), p2.GetX(), p2.GetY()))),
 segment3_(AddTypedPrimitive<Segment>(new Segment(*this, p1.GetX(), p2.GetY(), p2.GetX(), p2.GetY()))),
 class AnnotationsSceneLayer::EllipseProbeAnnotation : public ProbingAnnotation
 {
 private:
+Units     units_;
 Handle&   handle1_;
 Handle&   handle2_;
 Ellipse&  ellipse_;
 Text&     label_;
 std::string text;
 char buf[32];
-if (GetUnits() == Units_Millimeters)
+if (units_ == Units_Millimeters)
 {
 sprintf(buf, "Area: %0.2f cm%c%c",
 ellipse_.GetArea() / 100.0,
 0xc2, 0xb2 /* two bytes corresponding to two power in UTF-8 */);
 text = buf;
 public:
 EllipseProbeAnnotation(AnnotationsSceneLayer& that,
 Units units,
 const ScenePoint2D& p1,
 const ScenePoint2D& p2) :
-ProbingAnnotation(that, units),
+ProbingAnnotation(that),
+units_(units),
 handle1_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_Square, p1))),
 handle2_(AddTypedPrimitive<Handle>(new Handle(*this, Handle::Shape_Square, p2))),
 ellipse_(AddTypedPrimitive<Ellipse>(new Ellipse(*this, p1, p2))),
 label_(AddTypedPrimitive<Text>(new Text(that, *this)))
 {
 AngleAnnotation*        angle_;
 AffineTransform2D       canvasToScene_;
 public:
 CreateAngleTracker(AnnotationsSceneLayer& that,
-Units units,
 const ScenePoint2D& sceneClick,
 const AffineTransform2D& canvasToScene) :
 that_(that),
 length_(NULL),
 angle_(NULL),
 canvasToScene_(canvasToScene)
 {
-length_ = new LengthAnnotation(that, units, false /* no length label */, sceneClick, sceneClick);
+length_ = new LengthAnnotation(that, that.GetUnits(), false /* no length label */, sceneClick, sceneClick);
 }
 virtual void PointerMove(const PointerEvent& event,
 const Scene2D& scene) ORTHANC_OVERRIDE
 {
 {
 if (length_ != NULL)
 {
 // End of first step: The first segment is available, now create the angle
-angle_ = new AngleAnnotation(that_, length_->GetUnits(), length_->GetHandle(0).GetCenter(),
+angle_ = new AngleAnnotation(that_, length_->GetHandle(0).GetCenter(),
 length_->GetHandle(1).GetCenter(),
 length_->GetHandle(1).GetCenter());
 that_.DeleteAnnotation(length_);
 length_ = NULL;
 class AnnotationsSceneLayer::CreatePixelProbeTracker : public IFlexiblePointerTracker
 {
 public:
 CreatePixelProbeTracker(AnnotationsSceneLayer& that,
-Units units,
 const ScenePoint2D& sceneClick,
 const Scene2D& scene)
 {
-PixelProbeAnnotation* annotation = new PixelProbeAnnotation(that, units, sceneClick);
+PixelProbeAnnotation* annotation = new PixelProbeAnnotation(that, sceneClick);
 annotation->UpdateProbe(scene);
 that.BroadcastMessage(AnnotationAddedMessage(that));
 }
 virtual void PointerMove(const PointerEvent& event,
 void AnnotationsSceneLayer::AddAngleAnnotation(const ScenePoint2D& p1,
 const ScenePoint2D& p2,
 const ScenePoint2D& p3)
 {
-annotations_.insert(new AngleAnnotation(*this, units_, p1, p2, p3));
+annotations_.insert(new AngleAnnotation(*this, p1, p2, p3));
 }
 void AnnotationsSceneLayer::Render(Scene2D& scene)
 {
 Annotation* annotation = new CircleAnnotation(*this, units_, s, s);
 return new CreateTwoHandlesTracker(*annotation, scene.GetCanvasToSceneTransform());
 }
 case Tool_Angle:
-return new CreateAngleTracker(*this, units_, s, scene.GetCanvasToSceneTransform());
+return new CreateAngleTracker(*this, s, scene.GetCanvasToSceneTransform());
 case Tool_PixelProbe:
-return new CreatePixelProbeTracker(*this, units_, s, scene);
+return new CreatePixelProbeTracker(*this, s, scene);
 case Tool_RectangleProbe:
 {
 Annotation* annotation = new RectangleProbeAnnotation(*this, units_, s, s);
 return new CreateTwoHandlesTracker(*annotation, scene.GetCanvasToSceneTransform());
 return new CreateTwoHandlesTracker(*annotation, scene.GetCanvasToSceneTransform());
 }
 case Tool_TextAnnotation:
 {
-Annotation* annotation = new TextAnnotation(*this, units_, "" /* empty label */, s, s);
+Annotation* annotation = new TextAnnotation(*this, "" /* empty label */, s, s);
 return new CreateTwoHandlesTracker(*annotation, scene.GetCanvasToSceneTransform());
 }
 default:
 return NULL;
 const std::string& type = annotations[i][KEY_TYPE].asString();
 if (type == VALUE_ANGLE)
 {
-AngleAnnotation::Unserialize(*this, units_, annotations[i]);
+AngleAnnotation::Unserialize(*this, annotations[i]);
 }
 else if (type == VALUE_CIRCLE)
 {
 CircleAnnotation::Unserialize(*this, units_, annotations[i]);
 }
 {
 LengthAnnotation::Unserialize(*this, units_, annotations[i]);
 }
 else if (type == VALUE_PIXEL_PROBE)
 {
-PixelProbeAnnotation::Unserialize(*this, units_, annotations[i]);
+PixelProbeAnnotation::Unserialize(*this, annotations[i]);
 }
 else if (type == VALUE_RECTANGLE_PROBE)
 {
 RectangleProbeAnnotation::Unserialize(*this, units_, annotations[i]);
 }
 {
 EllipseProbeAnnotation::Unserialize(*this, units_, annotations[i]);
 }
 else if (type == VALUE_TEXT_ANNOTATION)
 {
-TextAnnotation::Unserialize(*this, units_, annotations[i]);
+TextAnnotation::Unserialize(*this, annotations[i]);
 }
 else
 {
 LOG(ERROR) << "Cannot unserialize unknown type of annotation: " << type;
 }

Mercurial > hg > orthanc-stone

comparison OrthancStone/Sources/Scene2D/AnnotationsSceneLayer.cpp @ 2000:3e9ced39cd1b