public bool HitTestStreamOut(Point p) { bool hit = false; Point slot = this.GetStreamOutSlotPoint(); GraphicsPath gp = new GraphicsPath(); gp.AddLine(this.Width, slot.Y - UI.SLOT_DELTA, this.Width, slot.Y + UI.SLOT_DELTA); //Pen pen = new Pen(Color.Black, 20); //Graphics g = this.CreateGraphics(); hit = gp.IsOutlineVisible(p, penBlack20, g); gp.Dispose(); return(hit); }
static public Line GetLineClick(int x, int y) { for (int i = line_drawn_list.Count - 1; i >= 0; --i) { Line item = line_drawn_list[i]; var new_path = new GraphicsPath(); new_path.AddLine(item.first_point, item.second_point); if (new_path.IsOutlineVisible(x, y, new Pen(Color.Black, 5))) { return(item); } } return(new Line()); }
internal static bool HitTest(PointF point, RectangleF rectangle, SpatialTransform transform) { GraphicsPath path = new GraphicsPath(); path.AddRectangle(RectangleUtilities.ConvertToPositiveRectangle(rectangle)); Pen pen = new Pen(Brushes.White, HitTestDistance / transform.CumulativeScale); bool result = path.IsOutlineVisible(point, pen); path.Dispose(); pen.Dispose(); return(result); }
public bool Contains(PointF point, Edge edge) { if (edge.EdgeConfig.LinePoints.Count == 0) { return(false); } var path = new GraphicsPath(); path.AddLines(edge.EdgeConfig.LinePoints.ToArray()); Pen pen = edge.EdgeConfig.Selected ? edge.EdgeConfig.SelectedEdgePen : edge.EdgeConfig.EdgePen; return(path.IsOutlineVisible(point, new Pen(pen.Color, pen.Width + 15))); }
public override bool hitTest(Point p, Transform t) { if (x.Count() < 2) { return(false); } var points = x.Zip(y, (px, py) => t.transform(new PointF((float)px, (float)py))); GraphicsPath gp = new GraphicsPath(); gp.AddLines(points.ToArray()); return(gp.IsVisible(p) || gp.IsOutlineVisible(p, Stroke)); }
private void SelectElement(MouseEventArgs e) { foreach (FurnitureData furniture in FurnitureList) { if (furniture is WallData) { using (var p = new GraphicsPath()) { p.AddLines((furniture as WallData).anchors.ToArray()); Matrix transformMatrix = new Matrix(); transformMatrix.Translate(furniture.x, furniture.y); transformMatrix.Rotate(furniture.angle); p.Transform(transformMatrix); if (p.IsOutlineVisible(e.Location, new Pen(Brushes.Black, WallThickness))) { listBox1.SelectedItem = furniture; //DrawDesign(); return; } } } else { using (var p = new GraphicsPath()) { p.AddRectangle(new Rectangle(-furniture.image.Width / 2, -furniture.image.Height / 2, furniture.image.Width, furniture.image.Height)); Matrix transformMatrix = new Matrix(); transformMatrix.Translate(furniture.x, furniture.y); transformMatrix.Rotate(furniture.angle); p.Transform(transformMatrix); if (p.IsVisible(e.Location)) { listBox1.SelectedItem = furniture; //DrawDesign(); return; } } } } listBox1.SelectedItem = null; //DrawDesign(); }
/// <summary> /// check particular point is in the control range or not, not used now /// </summary> /// <param name="p"></param> /// <returns></returns> public bool HitTest(Point p) { bool hit = false; //this.ConstructGraphicsPath(null); GraphicsPath gp = new GraphicsPath(); Pen pen = new Pen(Color.Black, UI.CONNECTION_WIDTH); //hit = regionGP.IsOutlineVisible(p, pen); hit = gp.IsOutlineVisible(p, pen); pen.Dispose(); gp.Dispose(); return(hit); }
public override bool isPointBelongPrecisely(Point p) { if (points.Count != 3 || rect_bound.Width == 0 || rect_bound.Height == 0) { return(false); } using (GraphicsPath path = new GraphicsPath()) using (Pen pen = new Pen(penAttr.color, penAttr.width)) { pen.DashStyle = penAttr.dashStyle; path.AddArc(rect_bound, startAngle, sweepAngle); return(path.IsOutlineVisible(pointBeforeScaleRotate(p), pen)); } }
public override bool ClickableAt(int x, int y) { bool returnValue = base.ClickableAt(x, y); if (returnValue) { int lineThickness = GetFieldValueAsInt(FieldType.LINE_THICKNESS); using (Pen pen = new Pen(Color.White)) { pen.Width = lineThickness + 10; returnValue = freehandPath.IsOutlineVisible(x - Left, y - Top, pen); } } return(returnValue); }
// </snippet21> // Snippet for: M:System.Drawing.Drawing2D.GraphicsPath.IsOutlineVisible(System.Int32,System.Int32,System.Drawing.Pen,System.Drawing.Graphics) // <snippet22> public void IsOutlineVisibleExample(PaintEventArgs e) { GraphicsPath myPath = new GraphicsPath(); Rectangle rect = new Rectangle(20, 20, 100, 100); myPath.AddRectangle(rect); Pen testPen = new Pen(Color.Black, 20); myPath.Widen(testPen); e.Graphics.FillPath(Brushes.Black, myPath); bool visible = myPath.IsOutlineVisible(100, 50, testPen, e.Graphics); MessageBox.Show("visible = " + visible.ToString()); }
public override bool PointInFigure(PointF point) { using (var gp = new GraphicsPath()) { var ps = GetPoints(); for (var i = 1; i < ps.Length; i++) { gp.StartFigure(); gp.AddLine(ps[i - 1], ps[i]); gp.CloseFigure(); } using (var pen = new Pen(Color.Black, Stroke.Width * 5f)) return(gp.IsOutlineVisible(point, pen)); } }
public override bool isHit(Point location) { using (GraphicsPath path = graphicsPath) { if (!this.isFill) { return(path.IsOutlineVisible(location, myPen)); } else { return(path.IsVisible(location)); } } }
/// <summary> /// Determines if the given Point is near any of the lines in /// Lines.LinesList. Sets HitLine to the first found or null if /// none found. /// </summary> /// <param name="point">The input point in PictureBox coordinates.</param> /// <returns>If found.</returns> public bool hitTestLine(Point point) { if (ActiveMode != Mode.EDIT) { return(false); } Point imgPoint = imagePoint(point); bool res; HitLine = null; HitPoint = null; Debug.WriteLine("hitTestLine: ActiveMode=" + ActiveMode + " ZoomFactor=" + ZoomFactor + NL + " point=" + point + " imgPoint=" + imgPoint + NL + " LINE_WIDTH=" + LINE_WIDTH + " HIT_TOLERANCE=" + HIT_TOLERANCE); foreach (Line line in Lines.LinesList) { // First check the points // (Tolerance does not extend past the ends as it does transverse.) Region region; foreach (Point point1 in line.Points) { region = new Region(centeredSquare(point1, HIT_TOLERANCE)); res = region.IsVisible(imgPoint); if (res) { HitPoint = new HitPoint(line, line.Points.IndexOf(point1)); HitLine = line; return(true); } } // Then check the lines. using (var path = new GraphicsPath()) using (var pen = new Pen(Color.Black, HIT_TOLERANCE)) { for (int i = 1; i < line.NPoints; i++) { path.AddLine(line.Points[i - 1], line.Points[i]); } res = path.IsOutlineVisible(imgPoint, pen); if (res) { HitLine = line; return(true); } } } return(false); }
private int WhichSegmentIsVisible(Point p) { GraphicsPath g = new GraphicsPath(); int i = 0; for (i = 0; i < this.ConnectorSegmentTypes.Count; i++) { g.Reset(); g.AddLine(this.Corners[i].Location, this.Corners[i + 1].Location); if (g.IsOutlineVisible(p, visiblePen)) { break; } } return(i); }
public override bool ContainsPoint(Point p) { GraphicsPath myPath = new GraphicsPath(); myPath.AddLine(StartOrigin, EndOrigin); bool pointWithinLine = myPath.IsOutlineVisible(p, new Pen(ChosenColor, ShapeSize)); if (pointWithinLine) { return(true); } else { return(false); } }
public bool HitTestLiquidOut(Point p) { bool hit = false; Point slot = this.GetLiquidOutSlotPoint(); GraphicsPath gp = new GraphicsPath(); gp.AddLine(slot.X - UI.SLOT_DELTA, this.Height, slot.X + UI.SLOT_DELTA, this.Height); //Pen pen = new Pen(Color.Black, 20); //Graphics g = this.CreateGraphics(); hit = gp.IsOutlineVisible(p, penBlack20, g); //pen.Dispose(); //g.Dispose(); gp.Dispose(); return(hit); }
public bool Inside(Point p, Rectangle boundingBox) { bool res = false; GraphicsPath path = this.GetGraphicsPath(boundingBox); if (isFill) { res = path.IsVisible(p); } else { Pen pen = new Pen(borderColor, width + 5); res = path.IsOutlineVisible(p, pen); } return(res); }
public override bool ClickableAt(int x, int y) { int lineThickness = GetFieldValueAsInt(FieldType.LINE_THICKNESS) + 5; if (lineThickness > 0) { using (Pen pen = new Pen(Color.White)) { pen.Width = lineThickness; using (GraphicsPath path = new GraphicsPath()) { path.AddLine(Left, Top, Left + Width, Top + Height); return(path.IsOutlineVisible(x, y, pen)); } } } return(false); }
/// <summary> /// Judge which truss member has been selected via location of mouse /// </summary> /// <param name="x">X coordinate of mouse location</param> /// <param name="y">Y coordinate of mouse location</param> /// <returns>index of selected member</returns> public int SelectTrussMember(int x, int y) { Point point = new Point(x, y); for (int i = 0; i < m_graphicsPaths.Count; i++) { GraphicsPath path = (GraphicsPath)m_graphicsPaths[i]; if (path.IsOutlineVisible(point, Pens.Blue)) { m_selectMemberIndex = i; return(m_selectMemberIndex); } } m_selectMemberIndex = -1; return(m_selectMemberIndex); }
/// <summary> /// Получить список смежных одинаково ориентированных рёбер с ребром, на которую указывает курсор /// </summary> /// <param name="location"></param> /// <param name="width"></param> /// <returns></returns> private List <Edge> GetAjacentEdges(Point location, SplitKind splitKind, float width = Helper.Epsilon) { if (splitKind == SplitKind.None) { return(new List <Edge>()); } using (var grp = new GraphicsPath()) using (var pen = new Pen(Color.Black, width)) { foreach (var item in Edges.Where(edge => splitKind == SplitKind.Vertical && edge.IsVertical || splitKind == SplitKind.Horizontal && edge.IsHorizontal)) { var edge = item; grp.Reset(); grp.AddLine(edge.Node1.Offset, edge.Node2.Offset); if (grp.IsOutlineVisible(location, pen)) { var result = new List <Edge>(); var queue = new Queue <Edge>(); queue.Enqueue(edge); while (true) { if (queue.Count == 0) { break; } edge = queue.Dequeue(); var pn1 = edge.Node1; var pn2 = edge.Node2; // найти все рёбра, разделяющие общие узловые точки var list = Edges.Where(e => !result.Contains(e) && e.IsSameOrientation(edge) && (e.Node1 == pn1 || e.Node1 == pn2 || e.Node2 == pn1 || e.Node2 == pn2)).ToList(); if (list.Count > 0) { foreach (var e in list) { queue.Enqueue(e); } result.AddRange(list); } } return(result); } } } return(new List <Edge>()); }
/// <summary> /// Determine if the specified screen point lies inside the bounding box of this /// <see cref="PolyObj"/>. /// </summary> /// <param name="pt">The screen point, in pixels</param> /// <param name="pane"> /// A reference to the <see cref="PaneBase"/> object that is the parent or /// owner of this object. /// </param> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> /// <returns>true if the point lies in the bounding box, false otherwise</returns> override public bool PointInBox(PointF pt, PaneBase pane, Graphics g, float scaleFactor) { if (_points != null && _points.Count > 1) { //if (!base.PointInBox(pt, pane, g, scaleFactor)) // return false; using (GraphicsPath path = MakePath(pane)) { return(path.IsVisible(pt) || path.IsOutlineVisible(pt, new Pen(Color.AliceBlue, 2))); } } else { return(false); } }
public bool HitTestGasIn(Point p) { bool hit = false; Point slot = this.GetGasInSlotPoint(); GraphicsPath gp = new GraphicsPath(); gp.AddLine(0, slot.Y - UI.SLOT_DELTA, 0, slot.Y + UI.SLOT_DELTA); Pen pen = new Pen(Color.Black, 20); Graphics g = this.CreateGraphics(); hit = gp.IsOutlineVisible(p, pen, g); pen.Dispose(); g.Dispose(); gp.Dispose(); return(hit); }
private bool closeButtonHitTest(int x, int y) { bool hit = false; using (GraphicsPath gp = new GraphicsPath()) { gp.StartFigure(); gp.AddLines(this.m_closeButtonBounds); gp.CloseFigure(); using (Pen borderpen = new Pen(Color.Black, 1)) { if (gp.IsOutlineVisible(x, y, borderpen) || gp.IsVisible(x, y)) { hit = true; } } } return(hit); }
public override bool IsHit(PointF point) { bool res = false; using (GraphicsPath path = GraphicsPath) { if (!Filled) { res = path.IsOutlineVisible(point, myPen); } else { res = path.IsVisible(point); } } return(res); }
/// <summary> /// Shows whether a certain point from the select square in the main form /// is on the line. /// </summary> /// <param name="p">Location of the point</param> public void selectRectangle(Point p) { var isOnLine = false; using (var path = new GraphicsPath()) { using (var pen = new Pen(Brushes.Black, BorderWidth)) { path.AddLine(X1, Y1, X2, Y2); isOnLine = path.IsOutlineVisible(p, pen); } } if (!Selected) { Selected = isOnLine; } }
/// <summary> /// Вставка новой вершины в контур фигуры /// </summary> /// <param name="owner">Фигура</param> /// <param name="point">Положение указателя мышки</param> public void InsertVertex(Figure owner, PointF point) { //можем менять положение вершин? var allowVertex = Geometry.AllowedOperations.HasFlag(AllowedOperations.Vertex); if (!allowVertex) { return; //не можем менять положение вершин } var polygone = owner.Geometry as PolygoneGeometry; if (polygone == null) { return; //работаем только с полигонами } //get points in world coordinates var points = polygone.GetTransformedPoints(owner).ToList(); using (var pen = new Pen(Color.Black, 5)) { // поищем, на какой стороне фигуры добавлять новую вершину var k = polygone.IsClosed ? 0 : 1; for (var i = k; i < points.Count; i++) { // замыкаем контур отрезком, соединяющим начало и конец фигуры var pt1 = i == 0 ? points[points.Count - 1] : points[i - 1]; var pt2 = points[i]; using (var path = new GraphicsPath()) { path.AddLine(pt1, pt2); if (!path.IsOutlineVisible(point, pen)) { continue; } // вставляем новую точку points.Insert(i, point); //push polygone.SetTransformedPoints(owner, points.ToArray()); break; } } } // GrabGeometry(); }
/// <summary> /// Определяем попадание точки на контур фигуры /// </summary> /// <param name="mousePosition"></param> /// <returns></returns> public override bool Contained(Point mousePosition) { using (var path = new GraphicsPath()) { // добавляем в путь контур полилинии path.AddLines(markers.Select(x => x.Location).ToArray()); path.AddRectangles(markers.Select(x => x.Bounds).ToArray()); // ширина линии для поиска попадания равна размеру маркера using (var pen = new Pen(Color.Black, 5f)) { pen.LineJoin = LineJoin.Round; pen.StartCap = LineCap.RoundAnchor; pen.EndCap = LineCap.RoundAnchor; return(path.IsOutlineVisible(mousePosition, pen)); } } }
public override bool ClickableAt(int x, int y) { int lineThickness = GetFieldValueAsInt(FieldType.LINE_THICKNESS) + 10; if (lineThickness > 0) { using (Pen pen = new Pen(Color.White)) { pen.Width = lineThickness; SetArrowHeads((ArrowHeadCombination)GetFieldValue(FieldType.ARROWHEADS), pen); using (GraphicsPath path = new GraphicsPath()) { path.AddLine(Left, Top, Left + Width, Top + Height); return path.IsOutlineVisible(x, y, pen); } } } return false; }
private static GraphicsPath BasicDividePath(List <GraphicsPath> paths, IEnumerable <PointF> ins, PointF[] points, byte[] types, int begin, int len) { //divide figure PointF[] ps = new PointF[len]; byte[] ts = new byte[len]; Array.Copy(points, begin, ps, 0, len); Array.Copy(types, begin, ts, 0, len); GraphicsPath path = new GraphicsPath(ps, ts); //no interscetion if ((ins != null) && ins.Any(t => path.IsOutlineVisible(t, OutlinePen))) { return(path); } paths.Add(path); return(null); }
/// <summary> /// Determine if the specified screen point lies inside the bounding box of this /// <see cref="LineObj"/>. /// </summary> /// <remarks>The bounding box is calculated assuming a distance /// of <see cref="GraphPane.Default.NearestTol"/> pixels around the arrow segment. /// </remarks> /// <param name="pt">The screen point, in pixels</param> /// <param name="pane"> /// A reference to the <see cref="PaneBase"/> object that is the parent or /// owner of this object. /// </param> /// <param name="g"> /// A graphic device object to be drawn into. This is normally e.Graphics from the /// PaintEventArgs argument to the Paint() method. /// </param> /// <param name="scaleFactor"> /// The scaling factor to be used for rendering objects. This is calculated and /// passed down by the parent <see cref="GraphPane"/> object using the /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust /// font sizes, etc. according to the actual size of the graph. /// </param> /// <returns>true if the point lies in the bounding box, false otherwise</returns> public override bool PointInBox(PointF pt, PaneBase pane, Graphics g, float scaleFactor) { if (!base.PointInBox(pt, pane, g, scaleFactor)) { return(false); } // transform the x,y location from the user-defined // coordinate frame to the screen pixel location var pix = _location.TransformTopLeft(pane); var pix2 = _location.TransformBottomRight(pane); using (var pen = new Pen(Color.Black, (float)GraphPane.Default.NearestTol * 2.0F)) using (var path = new GraphicsPath()) { path.AddLine(pix, pix2); return(path.IsOutlineVisible(pt, pen)); } }