# HG changeset patch # User Sebastien Jodogne # Date 1667234624 -3600 # Node ID a595776232bb1bf2cbb7a02f65aeaae6847f072c # Parent e29783c92419ff2814ec7786aef7249ff80f95de added ellipse probe diff -r e29783c92419 -r a595776232bb OrthancStone/Sources/Scene2D/AnnotationsSceneLayer.cpp --- a/OrthancStone/Sources/Scene2D/AnnotationsSceneLayer.cpp Mon Oct 31 15:20:18 2022 +0100 +++ b/OrthancStone/Sources/Scene2D/AnnotationsSceneLayer.cpp Mon Oct 31 17:43:44 2022 +0100 @@ -26,7 +26,7 @@ #include "MacroSceneLayer.h" #include "PolylineSceneLayer.h" #include "TextSceneLayer.h" -#include "TextureBaseSceneLayer.h" // TODO REMOVE +#include "TextureBaseSceneLayer.h" #include #include @@ -56,6 +56,7 @@ static const char* const VALUE_PIXELS = "pixels"; static const char* const VALUE_PIXEL_PROBE = "pixel-probe"; static const char* const VALUE_RECTANGLE_PROBE = "rectangle-probe"; +static const char* const VALUE_ELLIPSE_PROBE = "ellipse-probe"; #if 0 static OrthancStone::Color COLOR_PRIMITIVES(192, 192, 192); @@ -792,6 +793,154 @@ }; + class AnnotationsSceneLayer::Ellipse : public GeometricPrimitive + { + private: + ScenePoint2D p1_; + ScenePoint2D p2_; + ScenePoint2D delta_; + + double GetCenterX() const + { + return (p1_.GetX() + p2_.GetX()) / 2.0 + delta_.GetX(); + } + + double GetCenterY() const + { + return (p1_.GetY() + p2_.GetY()) / 2.0 + delta_.GetY(); + } + + double GetRadiusX() const + { + return std::abs(p1_.GetX() - p2_.GetX()) / 2.0; + } + + double GetRadiusY() const + { + return std::abs(p1_.GetY() - p2_.GetY()) / 2.0; + } + + public: + Ellipse(Annotation& parentAnnotation, + const ScenePoint2D& p1, + const ScenePoint2D& p2) : + GeometricPrimitive(parentAnnotation, 2), + p1_(p1), + p2_(p2), + delta_(0, 0) + { + } + + void SetPosition(const ScenePoint2D& p1, + const ScenePoint2D& p2) + { + SetModified(true); + p1_ = p1; + p2_ = p2; + delta_ = ScenePoint2D(0, 0); + } + + ScenePoint2D GetPosition1() const + { + return p1_ + delta_; + } + + ScenePoint2D GetPosition2() const + { + return p2_ + delta_; + } + + double GetArea() const + { + return PI * GetRadiusX() * GetRadiusY(); + } + + bool IsPointInside(const ScenePoint2D& p) const + { + const double radiusX = GetRadiusX(); + const double radiusY = GetRadiusY(); + + double a, b, x, y; + + if (radiusX > radiusY) + { + // The ellipse is horizontal => we are in the case described + // on Wikipedia: + // https://en.wikipedia.org/wiki/Ellipse#Standard_equation + + a = radiusX; + b = radiusY; + x = p.GetX() - GetCenterX(); + y = p.GetY() - GetCenterY(); + } + else + { + a = radiusY; + b = radiusX; + x = p.GetY() - GetCenterY(); + y = p.GetX() - GetCenterX(); + } + + const double c = sqrt(a * a - b * b); + + return (sqrt((x - c) * (x - c) + y * y) + + sqrt((x + c) * (x + c) + y * y)) <= 2.0 * a; + } + + virtual bool IsHit(const ScenePoint2D& p, + const Scene2D& scene) const ORTHANC_OVERRIDE + { + const double zoom = scene.GetSceneToCanvasTransform().ComputeZoom(); + + const double radiusX = GetRadiusX(); + const double radiusY = GetRadiusY(); + + // Warning: This is only an approximation of the + // point-to-ellipse distance, as explained here: + // https://blog.chatfield.io/simple-method-for-distance-to-ellipse/ + + const double x = (p.GetX() - GetCenterX()) / radiusX; + const double y = (p.GetY() - GetCenterY()) / radiusY; + const double t = atan2(y, x); + const double xx = cos(t) - x; + const double yy = sin(t) - y; + + const double approximateDistance = sqrt(xx * xx + yy * yy) * (radiusX + radiusY) / 2.0; + return std::abs(approximateDistance) * zoom <= HANDLE_SIZE / 2.0; + } + + virtual void RenderPolylineLayer(PolylineSceneLayer& polyline, + const Scene2D& scene) ORTHANC_OVERRIDE + { + static unsigned int NUM_SEGMENTS = 128; + polyline.AddArc(GetCenterX(), GetCenterY(), GetRadiusX(), GetRadiusY(), 0, 2.0 * PI, GetActiveColor(), NUM_SEGMENTS); + } + + virtual void RenderOtherLayers(MacroSceneLayer& macro, + const Scene2D& scene) ORTHANC_OVERRIDE + { + } + + virtual void MovePreview(const ScenePoint2D& delta, + const Scene2D& scene) ORTHANC_OVERRIDE + { + SetModified(true); + delta_ = delta; + GetParentAnnotation().SignalMove(*this, scene); + } + + virtual void MoveDone(const ScenePoint2D& delta, + const Scene2D& scene) ORTHANC_OVERRIDE + { + SetModified(true); + p1_ = p1_ + delta; + p2_ = p2_ + delta; + delta_ = ScenePoint2D(0, 0); + GetParentAnnotation().SignalMove(*this, scene); + } + }; + + class AnnotationsSceneLayer::EditPrimitiveTracker : public IFlexiblePointerTracker { private: @@ -1552,7 +1701,7 @@ { const double area = std::abs(x1 - x2) * std::abs(y1 - y2); - sprintf(buf, "%0.2f cm%c%c", + sprintf(buf, "Area: %0.2f cm%c%c", area / 100.0, 0xc2, 0xb2 /* two bytes corresponding to two power in UTF-8 */); text = buf; @@ -1768,6 +1917,201 @@ }; + class AnnotationsSceneLayer::EllipseProbeAnnotation : public ProbingAnnotation + { + private: + Handle& handle1_; + Handle& handle2_; + Ellipse& ellipse_; + Text& label_; + + protected: + virtual void UpdateProbeForLayer(const ISceneLayer& layer) ORTHANC_OVERRIDE + { + double x1 = handle1_.GetCenter().GetX(); + double y1 = handle1_.GetCenter().GetY(); + double x2 = handle2_.GetCenter().GetX(); + double y2 = handle2_.GetCenter().GetY(); + + // Put the label to the right of the right-most handle + //const double y = std::min(y1, y2); + const double y = (y1 + y2) / 2.0; + if (x1 < x2) + { + label_.SetPosition(x2, y); + } + else + { + label_.SetPosition(x1, y); + } + + std::string text; + + char buf[32]; + + if (GetUnits() == 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; + } + + if (layer.GetType() == ISceneLayer::Type_FloatTexture) + { + const TextureBaseSceneLayer& texture = dynamic_cast(layer); + const AffineTransform2D& textureToScene = texture.GetTransform(); + const AffineTransform2D sceneToTexture = AffineTransform2D::Invert(textureToScene); + + const Orthanc::ImageAccessor& image = texture.GetTexture(); + assert(image.GetFormat() == Orthanc::PixelFormat_Float32); + + sceneToTexture.Apply(x1, y1); + sceneToTexture.Apply(x2, y2); + int ix1 = static_cast(std::floor(x1)); + int iy1 = static_cast(std::floor(y1)); + int ix2 = static_cast(std::floor(x2)); + int iy2 = static_cast(std::floor(y2)); + + if (ix1 > ix2) + { + std::swap(ix1, ix2); + } + + if (iy1 > iy2) + { + std::swap(iy1, iy2); + } + + LinearAlgebra::OnlineVarianceEstimator estimator; + + for (int y = std::max(0, iy1); y <= std::min(static_cast(image.GetHeight()) - 1, iy2); y++) + { + int x = std::max(0, ix1); + const float* p = reinterpret_cast(image.GetConstRow(y)) + x; + + for (; x <= std::min(static_cast(image.GetWidth()) - 1, ix2); x++, p++) + { + double yy = static_cast(y) + 0.5; + double xx = static_cast(x) + 0.5; + textureToScene.Apply(xx, yy); + if (ellipse_.IsPointInside(ScenePoint2D(xx, yy))) + { + estimator.AddSample(*p); + } + } + } + + if (estimator.GetCount() > 0) + { + if (!text.empty()) + { + text += "\n"; + } + sprintf(buf, "Mean: %0.1f\nStdDev: %0.1f", estimator.GetMean(), estimator.GetStandardDeviation()); + text += buf; + } + } + + label_.SetText(text); + } + + public: + EllipseProbeAnnotation(AnnotationsSceneLayer& that, + Units units, + const ScenePoint2D& p1, + const ScenePoint2D& p2) : + ProbingAnnotation(that, units), + handle1_(AddTypedPrimitive(new Handle(*this, Handle::Shape_Square, p1))), + handle2_(AddTypedPrimitive(new Handle(*this, Handle::Shape_Square, p2))), + ellipse_(AddTypedPrimitive(new Ellipse(*this, p1, p2))), + label_(AddTypedPrimitive(new Text(that, *this))) + { + TextSceneLayer content; + content.SetAnchor(BitmapAnchor_CenterLeft); + content.SetBorder(10); + content.SetText("?"); + + label_.SetContent(content); + label_.SetColor(COLOR_TEXT); + } + + virtual unsigned int GetHandlesCount() const ORTHANC_OVERRIDE + { + return 2; + } + + virtual Handle& GetHandle(unsigned int index) const ORTHANC_OVERRIDE + { + switch (index) + { + case 0: + return handle1_; + + case 1: + return handle2_; + + default: + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + } + + virtual void SignalMove(GeometricPrimitive& primitive, + const Scene2D& scene) ORTHANC_OVERRIDE + { + if (&primitive == &handle1_ || + &primitive == &handle2_) + { + ellipse_.SetPosition(handle1_.GetCenter(), handle2_.GetCenter()); + } + else if (&primitive == &ellipse_) + { + handle1_.SetCenter(ellipse_.GetPosition1()); + handle2_.SetCenter(ellipse_.GetPosition2()); + } + else + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); + } + + TagProbeAsChanged(); + } + + virtual void Serialize(Json::Value& target) ORTHANC_OVERRIDE + { + target = Json::objectValue; + target[KEY_TYPE] = VALUE_ELLIPSE_PROBE; + target[KEY_X1] = handle1_.GetCenter().GetX(); + target[KEY_Y1] = handle1_.GetCenter().GetY(); + target[KEY_X2] = handle2_.GetCenter().GetX(); + target[KEY_Y2] = handle2_.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.isMember(KEY_Y2) && + source[KEY_X1].isNumeric() && + source[KEY_Y1].isNumeric() && + source[KEY_X2].isNumeric() && + source[KEY_Y2].isNumeric()) + { + new EllipseProbeAnnotation(target, units, + ScenePoint2D(source[KEY_X1].asDouble(), source[KEY_Y1].asDouble()), + ScenePoint2D(source[KEY_X2].asDouble(), source[KEY_Y2].asDouble())); + } + else + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat, "Cannot unserialize an ellipse probe annotation"); + } + } + }; + + class AnnotationsSceneLayer::CreateTwoHandlesTracker : public IFlexiblePointerTracker { private: @@ -2254,6 +2598,12 @@ return new CreateTwoHandlesTracker(*annotation, scene.GetCanvasToSceneTransform()); } + case Tool_EllipseProbe: + { + Annotation* annotation = new EllipseProbeAnnotation(*this, units_, s, s); + return new CreateTwoHandlesTracker(*annotation, scene.GetCanvasToSceneTransform()); + } + default: return NULL; } @@ -2355,6 +2705,10 @@ { RectangleProbeAnnotation::Unserialize(*this, units_, annotations[i]); } + else if (type == VALUE_ELLIPSE_PROBE) + { + EllipseProbeAnnotation::Unserialize(*this, units_, annotations[i]); + } else { LOG(ERROR) << "Cannot unserialize unknown type of annotation: " << type; diff -r e29783c92419 -r a595776232bb OrthancStone/Sources/Scene2D/AnnotationsSceneLayer.h --- a/OrthancStone/Sources/Scene2D/AnnotationsSceneLayer.h Mon Oct 31 15:20:18 2022 +0100 +++ b/OrthancStone/Sources/Scene2D/AnnotationsSceneLayer.h Mon Oct 31 17:43:44 2022 +0100 @@ -55,6 +55,7 @@ class Circle; class Arc; class Text; + class Ellipse; class Annotation; class ProbingAnnotation; @@ -63,12 +64,12 @@ class AngleAnnotation; class CircleAnnotation; class RectangleProbeAnnotation; + class EllipseProbeAnnotation; class EditPrimitiveTracker; class CreateTwoHandlesTracker; class CreateAngleTracker; class CreatePixelProbeTracker; - class CreateRectangleProbeTracker; class RemoveTracker; typedef std::set GeometricPrimitives;