/// <summary> /// Constructs a new polygonal region of interest, specifying an <see cref="IPointsGraphic"/> as the source of the definition and pixel data. /// </summary> /// <param name="polygon">The polygonal graphic that represents the region of interest.</param> public PolygonalRoi(IPointsGraphic polygon) : base(polygon.ParentPresentationImage) { if (polygon.Points.Count < 4 || !polygon.Points.IsClosed) // a valid points graphic needs 4 endpoints to define 3 sides { throw new ArgumentException("Supplied graphic must be a valid closed polygon.", "polygon"); } polygon.CoordinateSystem = CoordinateSystem.Source; try { // this list of vertices *has* the repeated start point, so we remove it here // the repeated point is an artifact of the polyline graphics system, and should not be replicated in abstract polygon models. List <PointF> vertices = new List <PointF>(polygon.Points.Count - 1); for (int n = 0; n < polygon.Points.Count - 1; n++) { vertices.Add(polygon.Points[n]); } _polygon = new PolygonF(vertices); } finally { polygon.ResetCoordinateSystem(); } }
private void InstallSnapPointGraphic(bool install) { IPointsGraphic subject = this.Graphic; CompositeGraphic parent = subject.ParentGraphic as CompositeGraphic; if (parent == null) { return; } if (install && subject.Points.Count > 0) { if (_snapPoint == null) { _snapPoint = new SnapPointGraphic(); } if (!parent.Graphics.Contains(_snapPoint)) { parent.Graphics.Add(_snapPoint); } _snapPoint.CoordinateSystem = subject.CoordinateSystem; _snapPoint.Location = subject.Points[0]; _snapPoint.ResetCoordinateSystem(); parent.Draw(); } else if (_snapPoint != null && parent.Graphics.Contains(_snapPoint)) { parent.Graphics.Remove(_snapPoint); parent.Draw(); } }
private double GetCurrentLength() { Units units = Units.Centimeters; IPointsGraphic line = LineGraphic; line.CoordinateSystem = CoordinateSystem.Source; try { double length = RoiLengthAnalyzer.CalculateLength(line.Points[0], line.Points[1], Frame.NormalizedPixelSpacing, ref units); if (units == Units.Centimeters) { return(length); } else { return(0.0); } } finally { line.ResetCoordinateSystem(); } }
public void Select(IGraphic graphic) { if (graphic != null) { Platform.CheckFalse(ReferenceEquals(graphic.ParentPresentationImage, null), "Supplied graphic must be on the same presentation image."); Platform.CheckTrue(ReferenceEquals(graphic.ParentPresentationImage, this.ParentPresentationImage), "Supplied graphic must be on the same presentation image."); } IPointsGraphic value = GetLine(graphic); if (_selectedLine != value) { if (_selectedLine != null) { _selectedLine.Points.PointAdded -= OnSelectedLinePointChanged; _selectedLine.Points.PointChanged -= OnSelectedLinePointChanged; _selectedLine.Points.PointRemoved -= OnSelectedLinePointChanged; _selectedLine.Points.PointsCleared -= OnSelectedLinePointsCleared; } _selectedLine = value; if (_selectedLine != null) { _selectedLine.Points.PointAdded += OnSelectedLinePointChanged; _selectedLine.Points.PointChanged += OnSelectedLinePointChanged; _selectedLine.Points.PointRemoved += OnSelectedLinePointChanged; _selectedLine.Points.PointsCleared += OnSelectedLinePointsCleared; } Visible = _selectedLine != null; _isDirty = true; } }
private static bool IsClosed(IPointsGraphic g) { if (g.Points.Count > 2) { return(FloatComparer.AreEqual(g.Points[0], g.Points[g.Points.Count - 1])); } return(false); }
private void OnOverlayGraphicsItemRemoved(object sender, ListEventArgs <IGraphic> e) { IPointsGraphic lineGraphic = GetLine(e.Item); if (ReferenceEquals(_selectedLine, lineGraphic)) { this.Select(null); } }
private void ResyncEndPoints() { IPointsGraphic pointsGraphic = this.Subject; if (pointsGraphic.Points.Count > 1) { pointsGraphic.Points[pointsGraphic.Points.Count - 1] = pointsGraphic.Points[0]; } }
/// <summary> /// Constructs an interactive builder for the specified graphic. /// </summary> /// <param name="maximumVertices">The maximum number of vertices to accept.</param> /// <param name="minimumVertices">The minimum number of vertices to accept.</param> /// <param name="pointsGraphic">The graphic to be interactively built.</param> public InteractivePolylineGraphicBuilder(int maximumVertices, int minimumVertices, IPointsGraphic pointsGraphic) : base(pointsGraphic) { Platform.CheckPositive(minimumVertices, "minimumVertices"); Platform.CheckTrue(maximumVertices >= minimumVertices, "max vertices >= min vertices"); Platform.CheckTrue(minimumVertices > 1, "min vertices > 1"); _maximumVertices = maximumVertices; _minimumVertices = minimumVertices; }
private static void ApplyCalibration(double lengthInMm, IPointsGraphic line, Frame frame, IDesktopWindow desktopWindow) { double aspectRatio; if (frame.PixelAspectRatio.IsNull) { // When there is no aspect ratio tag, the image is displayed with the aspect ratio // of the pixel spacing, so just keep the aspect ratio the same as // what's displayed. Otherwise, after calibration, a 2cm line drawn horizontally // would be visibly different from a 2cm line drawn vertically. if (!frame.NormalizedPixelSpacing.IsNull) { aspectRatio = frame.NormalizedPixelSpacing.AspectRatio; } else { aspectRatio = 1; } } else { aspectRatio = frame.PixelAspectRatio.Value; } line.CoordinateSystem = CoordinateSystem.Source; double widthInPixels = line.Points[1].X - line.Points[0].X; double heightInPixels = line.Points[1].Y - line.Points[0].Y; line.ResetCoordinateSystem(); if (widthInPixels == 0 && heightInPixels == 0) { desktopWindow.ShowMessageBox(SR.ErrorCannotCalibrateZeroLengthRuler, MessageBoxActions.Ok); return; } double pixelSpacingWidth, pixelSpacingHeight; CalculatePixelSpacing( lengthInMm, widthInPixels, heightInPixels, aspectRatio, out pixelSpacingWidth, out pixelSpacingHeight); frame.NormalizedPixelSpacing.Calibrate(pixelSpacingHeight, pixelSpacingWidth); line.ParentPresentationImage.Draw(); }
private IPointsGraphic GetSelectedPolyline() { RoiGraphic graphic = GetSelectedRoi(); if (graphic == null) { return(null); } IPointsGraphic line = graphic.Subject as IPointsGraphic; if (line == null) { return(null); } return(line); }
/// <summary> /// Computes the index for insertion of a new point on an existing <see cref="IPointsGraphic"/>. /// </summary> private int IndexOfNextClosestPoint(IPointsGraphic subject, PointF point) { int index = 0; double best = double.MaxValue; PointF closestPoint = this.GetClosestPoint(point); PointF temp = PointF.Empty; for (int n = 0; n < subject.Points.Count - 1; n++) { double distance = Vector.DistanceFromPointToLine(closestPoint, subject.Points[n], subject.Points[n + 1], ref temp); if (distance < best) { best = distance; index = n + 1; } } return(index); }
/// <summary> /// Called to notify the derived class of a control point change event. /// </summary> /// <param name="index">The index of the point that changed.</param> /// <param name="point">The value of the point that changed.</param> protected override void OnControlPointChanged(int index, PointF point) { base.OnControlPointChanged(index, point); IPointsGraphic pointsGraphic = this.Subject; if (pointsGraphic.Points.Count > 1) { if (index == 0) { base.OnControlPointChanged(pointsGraphic.Points.Count - 1, point); } if (index == pointsGraphic.Points.Count - 1) { base.OnControlPointChanged(0, point); } } }
/// <summary> /// Called to notify that a vertex in the subject graphic has changed. /// </summary> /// <param name="index">The index of the vertex that changed.</param> protected override void OnSubjectPointChanged(int index) { base.OnSubjectPointChanged(index); IPointsGraphic pointsGraphic = this.Subject; if (pointsGraphic.Points.Count > 1) { if (index == 0) { base.OnSubjectPointChanged(pointsGraphic.Points.Count - 1); } if (index == pointsGraphic.Points.Count - 1) { base.OnSubjectPointChanged(0); } } }
/// <summary> /// Constructs a new linear region of interest, specifying an <see cref="IPointsGraphic"/> as the source of the definition and pixel data. /// </summary> /// <param name="polyline">The linear graphic that represents the region of interest.</param> public LinearRoi(IPointsGraphic polyline) : base(polyline.ParentPresentationImage) { polyline.CoordinateSystem = CoordinateSystem.Source; try { List <PointF> points = new List <PointF>(); foreach (PointF point in polyline.Points) { points.Add(point); } _points = points.AsReadOnly(); } finally { polyline.ResetCoordinateSystem(); } Platform.CheckTrue(_points.Count >= 2, "At least 2 points must be specified."); }
/// <summary> /// Constructs a new linear region of interest, specifying an <see cref="IPointsGraphic"/> as the source of the definition and pixel data. /// </summary> /// <param name="polyline">The linear graphic that represents the region of interest.</param> public LinearRoi(IPointsGraphic polyline) : base(polyline.ParentPresentationImage) { polyline.CoordinateSystem = CoordinateSystem.Source; try { List<PointF> points = new List<PointF>(); foreach(PointF point in polyline.Points) { points.Add(point); } _points = points.AsReadOnly(); } finally { polyline.ResetCoordinateSystem(); } Platform.CheckTrue(_points.Count >= 2, "At least 2 points must be specified."); }
/// <summary> /// Called to insert a vertex at the point where the context menu was last invoked. /// </summary> protected virtual void InsertVertex() { if (!_canAddRemoveVertices) { return; } object memento = this.CreateMemento(); IPointsGraphic subject = this.Subject; subject.CoordinateSystem = CoordinateSystem.Destination; try { int index = this.HitTestControlPoint(Point.Round(_lastContextMenuPoint)); if (index < 0) { // if inserting in middle of line, find which index to insert at index = IndexOfNextClosestPoint(subject, _lastContextMenuPoint); } else if (index == subject.Points.Count - 1) { // if inserting on last point, append instead of inserting before index++; } if (index >= 0) { subject.Points.Insert(index, _lastContextMenuPoint); } } finally { subject.ResetCoordinateSystem(); } AddToCommandHistory(this, memento, this.CreateMemento()); }
/// <summary> /// Called to remove the vertex at the point where the context menu was last invoked. /// </summary> protected virtual void DeleteVertex() { if (!_canAddRemoveVertices) { return; } object memento = this.CreateMemento(); IPointsGraphic subject = this.Subject; if (subject.Points.Count > 1) { int index = this.HitTestControlPoint(Point.Round(_lastContextMenuPoint)); if (index >= 0 && index < subject.Points.Count) { subject.Points.RemoveAt(index); } } AddToCommandHistory(this, memento, this.CreateMemento()); }
/// <summary> /// Constructs a new polygonal region of interest, specifying an <see cref="IPointsGraphic"/> as the source of the definition and pixel data. /// </summary> /// <param name="polygon">The polygonal graphic that represents the region of interest.</param> public PolygonalRoi(IPointsGraphic polygon) : base(polygon.ParentPresentationImage) { if (polygon.Points.Count < 4 || !polygon.Points.IsClosed) // a valid points graphic needs 4 endpoints to define 3 sides throw new ArgumentException("Supplied graphic must be a valid closed polygon.", "polygon"); polygon.CoordinateSystem = CoordinateSystem.Source; try { // this list of vertices *has* the repeated start point, so we remove it here // the repeated point is an artifact of the polyline graphics system, and should not be replicated in abstract polygon models. List<PointF> vertices = new List<PointF>(polygon.Points.Count - 1); for (int n = 0; n < polygon.Points.Count - 1; n++) { vertices.Add(polygon.Points[n]); } _polygon = new PolygonF(vertices); } finally { polygon.ResetCoordinateSystem(); } }
/// <summary> /// Constructs an interactive builder for the specified graphic. /// </summary> /// <param name="maximumVertices">The maximum number of vertices to accept.</param> /// <param name="pointsGraphic">The graphic to be interactively built.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="maximumVertices"/> is less than 3.</exception> public InteractivePolygonGraphicBuilder(int maximumVertices, IPointsGraphic pointsGraphic) : base(pointsGraphic) { Platform.CheckArgumentRange(maximumVertices, 3, int.MaxValue, "maximumVertices"); _maximumVertices = maximumVertices; }
public bool ComputeProfile() { IPointsGraphic line = GetSelectedPolyline(); // For now, make sure the ROI is a polyline if (line == null || line.Points.Count != 2) { this.Enabled = false; return(false); } IImageGraphicProvider imageGraphicProvider = line.ParentPresentationImage as IImageGraphicProvider; if (imageGraphicProvider == null) { this.Enabled = false; return(false); } // For now, only allow ROIs of grayscale images GrayscaleImageGraphic image = imageGraphicProvider.ImageGraphic as GrayscaleImageGraphic; if (image == null) { this.Enabled = false; return(false); } line.CoordinateSystem = CoordinateSystem.Source; Point pt1 = new Point((int)line.Points[0].X, (int)line.Points[0].Y); Point pt2 = new Point((int)line.Points[1].X, (int)line.Points[1].Y); if (pt1.X < 0 || pt1.X > image.Columns - 1 || pt2.X < 0 || pt2.X > image.Columns - 1 || pt1.Y < 0 || pt1.Y > image.Rows - 1 || pt2.Y < 0 || pt2.Y > image.Rows - 1) { this.Enabled = false; return(false); } List <Point> pixels = BresenhamLine(pt1, pt2); _pixelIndices = new int[pixels.Count]; _pixelValues = new double[pixels.Count]; int i = 0; foreach (Point pixel in pixels) { int rawPixelValue = image.PixelData.GetPixel(pixel.X, pixel.Y); _pixelIndices[i] = i; _pixelValues[i] = (int)image.ModalityLut[rawPixelValue]; i++; } this.Enabled = true; return(true); }
public static InteractivePolygonGraphicBuilder CreatePolygonalShutterBuilder(IPointsGraphic graphic) { return new InteractivePolygonalShutterBuilder(graphic); }
/// <summary> /// Constructs an interactive builder for the specified graphic. /// </summary> /// <param name="pointsGraphic">The graphic to be interactively built.</param> public InteractivePolygonGraphicBuilder(IPointsGraphic pointsGraphic) : this(int.MaxValue, pointsGraphic) { }
public InteractivePolygonalShutterBuilder(IPointsGraphic graphic) : base(graphic) { graphic.Color = _normalColor; }
/// <summary> /// Constructs an interactive builder for the specified graphic. /// </summary> /// <param name="maximumVertices">The maximum number of vertices to accept.</param> /// <param name="pointsGraphic">The graphic to be interactively built.</param> public InteractiveHeartRatioLineGraphicBuilder(int maximumVertices, IPointsGraphic pointsGraphic) : this(maximumVertices, 2, pointsGraphic) { }
/// <summary> /// Constructs an interactive builder for the specified graphic. /// </summary> /// <param name="maximumVertices">The maximum number of vertices to accept.</param> /// <param name="pointsGraphic">The graphic to be interactively built.</param> public InteractivePolylineGraphicBuilder(int maximumVertices, IPointsGraphic pointsGraphic) : this(maximumVertices, 2, pointsGraphic) { }
public static InteractivePolygonGraphicBuilder CreatePolygonalShutterBuilder(IPointsGraphic graphic) { return(new InteractivePolygonalShutterBuilder(graphic)); }
/// <summary> /// Constructs an interactive builder for the specified graphic. /// </summary> /// <param name="pointsGraphic">The graphic to be interactively built.</param> public InteractivePolylineGraphicBuilder(IPointsGraphic pointsGraphic) : this(int.MaxValue, pointsGraphic) {}
internal static void TestCalibration(double lengthInMm, IPointsGraphic graphic) { Frame frame = ((IImageSopProvider)graphic.ParentPresentationImage).Frame; ApplyCalibration(lengthInMm, graphic, frame, null); }
/// <summary> /// Constructs an interactive builder for the specified graphic. /// </summary> /// <param name="pointsGraphic">The graphic to be interactively built.</param> public InteractiveHeartRatioLineGraphicBuilder(IPointsGraphic pointsGraphic) : this(int.MaxValue, pointsGraphic) { }
private static bool IsClosed(IPointsGraphic g) { if (g.Points.Count > 2) return FloatComparer.AreEqual(g.Points[0], g.Points[g.Points.Count - 1]); return false; }
/// <summary> /// Computes the index for insertion of a new point on an existing <see cref="IPointsGraphic"/>. /// </summary> private int IndexOfNextClosestPoint(IPointsGraphic subject, PointF point) { int index = 0; double best = double.MaxValue; PointF closestPoint = this.GetClosestPoint(point); PointF temp = PointF.Empty; for (int n = 0; n < subject.Points.Count - 1; n++) { double distance = Vector.DistanceFromPointToLine(closestPoint, subject.Points[n], subject.Points[n + 1], ref temp); if (distance < best) { best = distance; index = n + 1; } } return index; }
public override void OnDrawing() { base.OnDrawing(); if (!_isDirty) { return; } IOverlayGraphicsProvider overlayGraphicsProvider = this.ParentPresentationImage as IOverlayGraphicsProvider; if (overlayGraphicsProvider == null) { return; } IList <ShowAnglesToolGraphic> freeAngleGraphics = CollectionUtils.Cast <ShowAnglesToolGraphic>(this.Graphics); if (this.Visible && _selectedLine != null && _selectedLine.Points.Count == 2) { _selectedLine.CoordinateSystem = CoordinateSystem.Source; try { foreach (IGraphic otherLineGraphic in overlayGraphicsProvider.OverlayGraphics) { IPointsGraphic otherLine = GetLine(otherLineGraphic); if (otherLine != null && !ReferenceEquals(otherLine, _selectedLine) && otherLine.Points.Count == 2) { ShowAnglesToolGraphic showAnglesToolGraphic; if (freeAngleGraphics.Count > 0) { freeAngleGraphics.Remove(showAnglesToolGraphic = freeAngleGraphics[0]); } else { this.Graphics.Add(showAnglesToolGraphic = new ShowAnglesToolGraphic()); } showAnglesToolGraphic.CoordinateSystem = otherLine.CoordinateSystem = CoordinateSystem.Source; try { showAnglesToolGraphic.SetEndpoints(_selectedLine.Points[0], _selectedLine.Points[1], otherLine.Points[0], otherLine.Points[1]); } finally { showAnglesToolGraphic.ResetCoordinateSystem(); otherLine.ResetCoordinateSystem(); } } } } finally { _selectedLine.ResetCoordinateSystem(); } } foreach (IGraphic freeAngleGraphic in freeAngleGraphics) { this.Graphics.Remove(freeAngleGraphic); freeAngleGraphic.Dispose(); } }
private static void ApplyCalibration(double lengthInMm, IPointsGraphic line, Frame frame, IDesktopWindow desktopWindow) { double aspectRatio; if (frame.PixelAspectRatio.IsNull) { // When there is no aspect ratio tag, the image is displayed with the aspect ratio // of the pixel spacing, so just keep the aspect ratio the same as // what's displayed. Otherwise, after calibration, a 2cm line drawn horizontally // would be visibly different from a 2cm line drawn vertically. if (!frame.NormalizedPixelSpacing.IsNull) aspectRatio = frame.NormalizedPixelSpacing.AspectRatio; else aspectRatio = 1; } else { aspectRatio = frame.PixelAspectRatio.Value; } line.CoordinateSystem = CoordinateSystem.Source; double widthInPixels = line.Points[1].X - line.Points[0].X; double heightInPixels = line.Points[1].Y - line.Points[0].Y; line.ResetCoordinateSystem(); if (widthInPixels == 0 && heightInPixels == 0) { desktopWindow.ShowMessageBox(SR.ErrorCannotCalibrateZeroLengthRuler, MessageBoxActions.Ok); return; } double pixelSpacingWidth, pixelSpacingHeight; CalculatePixelSpacing( lengthInMm, widthInPixels, heightInPixels, aspectRatio, out pixelSpacingWidth, out pixelSpacingHeight); frame.NormalizedPixelSpacing.Calibrate(pixelSpacingHeight, pixelSpacingWidth); line.ParentPresentationImage.Draw(); }