public Analyzer(double meanX, double meanY, GraphicsPath path) { Counters = new RunningCount[Enum.GetValues(typeof(AnalysisMetric)).Length]; foreach(AnalysisMetric metric in Enum.GetValues(typeof(AnalysisMetric))) Counters[(int)metric] = new RunningCount(metric); MeanX = meanX; MeanY = meanY; path.Flatten(); using(GraphicsPathIterator PathIterator = new GraphicsPathIterator(path)) { using(GraphicsPath Subpath = new GraphicsPath()) { Paths = new List<PointF[]>(); bool Closed; while(PathIterator.NextSubpath(Subpath, out Closed) > 0) { Paths.Add(Subpath.PathPoints); Subpath.Reset(); } } } }
public static void WarpPath(GraphicsPath path, PointF[] destPoints, RectangleF srcRect, Matrix matrix = null, WarpMode warpMode = WarpMode.Perspective, float flatness = 0.25f) { if (path.PointCount == 0) return; path.Flatten(matrix, flatness); var pathData = path.PathData; var pnts = path.PathPoints; var srcPoints = new PointF[] { new PointF(srcRect.Left, srcRect.Top), new PointF(srcRect.Right, srcRect.Top), new PointF(srcRect.Left, srcRect.Bottom), new PointF(srcRect.Right, srcRect.Bottom) }; var count = pnts.Length; float x1, y1; int i; if (warpMode == WarpMode.Perspective) { CalcProjectiveXformCoeffs(srcPoints, destPoints, out coeffs); for (i = 0; i < count; i++) { x1 = pnts[i].X; y1 = pnts[i].Y; var factor = 1.0f / (coeffs[6] * x1 + coeffs[7] * y1 + 1.0f); pnts[i].X = (float)(factor * (coeffs[0] * x1 + coeffs[1] * y1 + coeffs[2])); pnts[i].Y = (float)(factor * (coeffs[3] * x1 + coeffs[4] * y1 + coeffs[5])); } } else { CalcBilinearXformCoeffs(srcPoints, destPoints, out coeffs); for (i = 0; i < count; i++) { x1 = pnts[i].X; y1 = pnts[i].Y; pnts[i].X = (float)(coeffs[0] * x1 + coeffs[1] * y1 + coeffs[2] * x1 * y1 + coeffs[3]); pnts[i].Y = (float)(coeffs[4] * x1 + coeffs[5] * y1 + coeffs[6] * x1 * y1 + coeffs[7]); } } GraphicsPath warpedPath = new GraphicsPath(pnts, pathData.Types); if (warpedPath != null) { FillMode fm = path.FillMode; path.Reset(); path.FillMode = fm; path.AddPath(warpedPath, true); warpedPath.Dispose(); } }
/// <summary> /// Get the desired Rounded Rectangle path. /// </summary> private static GraphicsPath GetEllipse(RectangleF baseRect) { GraphicsPath mPath = new GraphicsPath(); mPath.AddEllipse(baseRect); mPath.CloseFigure(); mPath.Flatten(); return mPath; }
private void Form2_Paint(object sender, PaintEventArgs e) { //패스 그래디언트 Point[] pts = { new Point(100, 0), new Point(0, 100), new Point(200, 100) }; PathGradientBrush B = new PathGradientBrush(pts, WrapMode.Tile); e.Graphics.FillRectangle(B, ClientRectangle); //패스 그래디언트 끝 //패스변형 GraphicsPath Path = new GraphicsPath(); Path.AddString("한글", new FontFamily("궁서"), 0, 100, new Point(10, 30), new StringFormat()); //확장 후 외곽선 그리기 Path.Widen(new Pen(Color.Black, 3)); e.Graphics.DrawPath(Pens.Black, Path); //확장 후 채우기 Path.Widen(new Pen(Color.Blue, 3)); e.Graphics.DrawPath(Pens.Black, Path); //곡선 펴기 Path.Flatten(new Matrix(), 12f); e.Graphics.DrawPath(Pens.Black, Path); //회전 Matrix M = new Matrix(); M.Rotate(-10); Path.Transform(M); e.Graphics.FillPath(Brushes.Blue, Path); //휘기 RectangleF R = Path.GetBounds(); PointF[] arPoint = new PointF[4]; arPoint[0] = new PointF(R.Left, R.Top + 30); arPoint[1] = new PointF(R.Right, R.Top - 10); arPoint[2] = new PointF(R.Left + 10, R.Bottom - 10); arPoint[3] = new PointF(R.Right + 30, R.Bottom + 30); Path.Warp(arPoint, R); e.Graphics.FillPath(Brushes.Blue, Path); //클리핑 //graphicspath path= new graphicspath(); //path.fillmode = fillmode.winding; //path.addellipse(50, 10, 100, 80); //path.addellipse(20, 45, 160, 120); //e.graphics.fillpath(brushes.white, path); //e.graphics.setclip(path); //for (int y = 0; y < bottom; y+= 20) //{ // string str = "눈사람의 모양의클리핑 영역에 글자를 쓴것입니다"; // e.graphics.drawstring(str, font, brushes.blue, 0, y); //} //클리핑 끝 }
private static void DrawColorWheel(Graphics gr, Color outline_color, int xmin, int ymin, int wid, int hgt) { Rectangle rect = new Rectangle(xmin, ymin, wid, hgt); GraphicsPath wheel_path = new GraphicsPath(); wheel_path.AddEllipse(rect); wheel_path.Flatten(); float num_pts = (wheel_path.PointCount - 1) / 6; Color[] surround_colors = new Color[wheel_path.PointCount]; int index = 0; InterpolateColors(surround_colors, ref index, 1 * num_pts, 255, 255, 0, 0, 255, 255, 0, 255); InterpolateColors(surround_colors, ref index, 2 * num_pts, 255, 255, 0, 255, 255, 0, 0, 255); InterpolateColors(surround_colors, ref index, 3 * num_pts, 255, 0, 0, 255, 255, 0, 255, 255); InterpolateColors(surround_colors, ref index, 4 * num_pts, 255, 0, 255, 255, 255, 0, 255, 0); InterpolateColors(surround_colors, ref index, 5 * num_pts, 255, 0, 255, 0, 255, 255, 255, 0); InterpolateColors(surround_colors, ref index, wheel_path.PointCount, 255, 255, 255, 0, 255, 255, 0, 0); using (PathGradientBrush path_brush = new PathGradientBrush(wheel_path)) { path_brush.CenterColor = Color.White; path_brush.SurroundColors = surround_colors; gr.FillPath(path_brush, wheel_path); // It looks better if we outline the wheel. using (Pen thick_pen = new Pen(outline_color, 2)) { gr.DrawPath(thick_pen, wheel_path); } } }
public void Flatten_Polygon () { GraphicsPath path = new GraphicsPath (); path.AddPolygon (new Point[4] { new Point (0, 0), new Point (10, 10), new Point (20, 20), new Point (40, 40) }); GraphicsPath clone = (GraphicsPath) path.Clone (); path.Flatten (); ComparePaths (path, clone); }
public void Flatten_Pie () { GraphicsPath path = new GraphicsPath (); path.AddPie (0, 0, 100, 100, 30, 30); GraphicsPath clone = (GraphicsPath) path.Clone (); path.Flatten (); CompareFlats (path, clone); }
public void DrawTextOnPath() { PointF[] tmpPoints; PointF[] points = new PointF[25001]; int count = 0; GraphicsPath gp = new GraphicsPath(_pathdata.Points, _pathdata.Types) { FillMode = FillMode.Winding }; _regionList.Clear(); gp.Flatten(null, 1); try { PointF tmpPoint = gp.PathPoints[0]; int i; for (i = 0; i <= gp.PathPoints.Length - 2; i++) { if (gp.PathTypes[i + 1] == (byte)PathPointType.Start | (gp.PathTypes[i] & (byte)PathPointType.CloseSubpath) == (byte)PathPointType.CloseSubpath) { tmpPoints = GetLinePoints(gp.PathPoints[i], tmpPoint, 1); Array.ConstrainedCopy(tmpPoints, 0, points, count, tmpPoints.Length); count += 1; tmpPoint = gp.PathPoints[i + 1]; } else { tmpPoints = GetLinePoints(gp.PathPoints[i], gp.PathPoints[i + 1], 1); Array.ConstrainedCopy(tmpPoints, 0, points, count, tmpPoints.Length); count += tmpPoints.Length - 1; } } tmpPoints = new PointF[count]; Array.Copy(points, tmpPoints, count); points = CleanPoints(tmpPoints); count = points.Length - 1; DrawText(points, count); } catch (Exception ex) { LastError = ex; } }
//--------------------------------------------------------------------- private void GenerateAustPlusRandomEllipses(int count) { subjects.Clear(); //load map of Australia from resource ... _assembly = Assembly.GetExecutingAssembly(); polyStream = _assembly.GetManifestResourceStream("GuiDemo.aust.bin"); int len = (int)polyStream.Length; byte[] b = new byte[len]; polyStream.Read(b, 0, len); int polyCnt = BitConverter.ToInt32(b, 0); int k = 4; for (int i = 0; i < polyCnt; ++i) { int vertCnt = BitConverter.ToInt32(b, k); k += 4; Polygon pg = new Polygon(vertCnt); for (int j = 0; j < vertCnt; ++j) { float x = BitConverter.ToSingle(b, k) * scale; float y = BitConverter.ToSingle(b, k + 4) * scale; k += 8; pg.Add(new IntPoint((int)x, (int)y)); } subjects.Add(pg); } clips.Clear(); Random rand = new Random(); GraphicsPath path = new GraphicsPath(); Point pt = new Point(); const int ellipse_size = 100, margin = 10; for (int i = 0; i < count; ++i) { int w = pictureBox1.ClientRectangle.Width - ellipse_size - margin *2; int h = pictureBox1.ClientRectangle.Height - ellipse_size - margin * 2 - statusStrip1.Height; pt.X = rand.Next(w) + margin; pt.Y = rand.Next(h) + margin; int size = rand.Next(ellipse_size - 20) + 20; path.Reset(); path.AddEllipse(pt.X, pt.Y, size, size); path.Flatten(); Polygon clip = new Polygon(path.PathPoints.Count()); foreach (PointF p in path.PathPoints) clip.Add(new IntPoint((int)(p.X * scale), (int)(p.Y * scale))); clips.Add(clip); } }
/// <summary> /// Produces DXF output for Flowchart shape /// </summary> /// <param name="rect">Bounding Rectangle</param> /// <param name="ShapeStyle">Flowchart shape style</param> /// <param name="st">ElementTemplate reference if shape is complex null otherwise</param> /// <param name="crLine">Line color</param> /// <param name="RA">Rotation angle</param> /// <param name="dash">DashStyle</param> /// <param name="LineWidth">Line width ( not used)</param> /// <param name="Offset">Offset if it's necessary</param> /// <param name="WCS2UCS">if true conversion for world-coordinate to user-coordinate is required</param> /// <param name="gr">GraphicsPath to be assigned</param> /// <param name="result">>DXF output string</param> /// <returns>true if successfull otherwise false</returns> public bool Shape2Str( RectangleF rect, BoxStyle ShapeStyle, ElementTemplate[] st, Color crLine, float RA, DashStyle dash, Single LineWidth, float Offset, bool WCS2UCS, ref GraphicsPath gr, ref string result ) { float X = 0, Y = 0, X1 = 0, Y1 = 0, X2 = 0, Y2 = 0, X3 = 0, Y3 = 0; bool DisableStringOutput = false; PointF[] pts = null; bool bOk = false; string PathPart = ""; GraphicsPath gr_temp = new GraphicsPath(FillMode.Winding); try { if ( gr == null ) throw new Exception("Empty Graphics Path reference passed"); DisableStringOutput = ( result == null ); // Detecting box's style switch (ShapeStyle) { case BoxStyle.Rectangle: gr.AddRectangle(rect); break; case BoxStyle.Ellipse: gr.AddEllipse(rect.X,rect.Y,rect.Width, rect.Height); break; case BoxStyle.RoundedRectangle: gr = Utilities.getRoundRect(rect.X, rect.Y, rect.Width, rect.Height,10); break; case BoxStyle.Delay: gr.AddRectangle(rect); break; case BoxStyle.Rhombus: pts = new PointF[4] {new PointF((rect.Left + rect.Right) / 2, rect.Top - Offset), new PointF(Math.Max(rect.Right, rect.Left) + Offset, (rect.Top + rect.Bottom) / 2), new PointF((rect.Left + rect.Right) / 2, Math.Max(rect.Bottom, rect.Top) + Offset), new PointF(rect.Left - Offset,(rect.Top + rect.Bottom) / 2)}; gr.AddPolygon(pts); break; case BoxStyle.Shape: // if shape is complex then processing all its elements if (st == null) throw new Exception("Empty shape reference in the complex shape"); foreach (ElementTemplate et in st ) { switch ( et.getClassId()) { case 28: // If shape element is arc ArcTemplate at = et as ArcTemplate; double rx = 0, ry = 0 , cx = 0, cy = 0; rx = rect.Width * (at.Bounds.Width/200); ry = rect.Height * (at.Bounds.Height/200); cx = rect.X + rect.Width*(at.Bounds.X/100) + rx; cy = rect.Y + rect.Height*(at.Bounds.Y/100) + ry; gr.AddArc((float) (cx - rx), (float) ( cy - ry) , (float) rx*2, (float) ry*2, at.StartAngle ,at.SweepAngle); float StartAngle = 180 + at.StartAngle + (360 - at.SweepAngle) - RA, EndAngle = StartAngle + at.SweepAngle; if ( rx != ry ) { float iAngleC = 0; double majorx = 0, majory = 0; if (at.StartAngle<0) iAngleC = 360 - Math.Abs(at.StartAngle); else iAngleC = at.StartAngle; majorx = (rx < ry) ? 0 : rx; majory = (rx < ry) ? ry : 0; if (( iAngleC >=0 ) && (iAngleC<90)) { majorx*=-1; majory*=-1; } else if (( iAngleC >=90 ) && (iAngleC<180)) { } else if (( iAngleC >=180 ) && (iAngleC<270)) { majorx*=-1; majory*=-1; } else if (( iAngleC >=270 ) && (iAngleC<=360)) { } StartAngle = at.StartAngle + RA; EndAngle = StartAngle + at.SweepAngle; if ((at.SweepAngle>=270) && (at.SweepAngle<360)) { if ( ry > rx ) { StartAngle = at.StartAngle + RA + 90 + ( 360 - at.SweepAngle); EndAngle = at.StartAngle + RA + 90; } } else if (at.SweepAngle>=180) { if (ry>rx) { StartAngle-=90; EndAngle-=90; } } PathPart = String.Format(provider, " 0\nELLIPSE\n 100\nAcDbEntity\n{0:HAN} 8\n{5}\n 62\n{6:ACI}\n 100\nAcDbEllipse\n 10\n{0:U}\n 20\n{1:U}\n 11\n{7:U}\n 21\n{8:U}\n 40\n{9:U}\n 41\n{3:U}\n 42\n{4:U}\n", cx, m_FlowChart.DocExtents.Height - cy,0, (StartAngle*Math.PI)/180 , (EndAngle*Math.PI)/180, SHAPE_LAYER, crLine, majorx , majory , (rx < ry) ? rx/ry : ry/rx); } else { PathPart = String.Format(provider, " 0\nARC\n 100\nAcDbEntity\n{0:HAN} 8\n{5}\n 62\n{6:ACI}\n 100\nAcDbCircle\n 10\n{0:U}\n 20\n{1:U}\n 40\n{2:U}\n 100\nAcDbArc\n 50\n{3}\n 51\n{4}\n", cx, m_FlowChart.DocExtents.Height - cy,rx, StartAngle , EndAngle, SHAPE_LAYER, crLine); } break; case 29: // If shape element is bezier curve BezierTemplate bt = et as BezierTemplate; X = rect.X + rect.Width * (bt.Coordinates[0]/100); Y = rect.Y + rect.Height* (bt.Coordinates[1]/100); X1 = rect.X + rect.Width * (bt.Coordinates[2]/100); Y1 = rect.Y + rect.Height* (bt.Coordinates[3]/100); X2 = rect.X + rect.Width * (bt.Coordinates[4]/100); Y2 = rect.Y + rect.Height* (bt.Coordinates[5]/100); X3 = rect.X + rect.Width * (bt.Coordinates[6]/100); Y3 = rect.Y + rect.Height* (bt.Coordinates[7]/100); gr_temp.Reset(); gr_temp.AddBezier(X,Y,X1,Y1,X2,Y2,X3,Y3); gr.AddBezier(X,Y,X1,Y1,X2,Y2,X3,Y3); // Applying rotation if it's necessary pts = RotatePoints(RA , new PointF(rect.X + rect.Width/2,rect.Y + rect.Height/2), gr_temp); gr_temp.Flatten(); PointF[] pts2 = gr_temp.PathData.Points.Clone() as PointF[]; PathPart = String.Format(provider, "0\nPOLYLINE\n{0:HAN} 100\nAcDbEntity\n8\n{0}\n 62\n{1:ACI}\n 100\nAcDb2dPolyline\n 66\n1\n 70\n4\n 75\n6\n{2}{3}0\nSEQEND\n 100\nAcDbEntity\n{0:HAN}", SHAPE_LAYER, crLine, Pt2String(pts,crLine,SHAPE_LAYER,DxLineType.ltVertex, dash, 16), Pt2String(pts2,crLine,SHAPE_LAYER,DxLineType.ltVertex, dash, 8)); break; case 30: // If shape element is line LineTemplate lt = et as LineTemplate; X1 = rect.X + rect.Width * (lt.Coordinates[0]/100); Y1 = rect.Y + rect.Height* (lt.Coordinates[1]/100); X2 = rect.X + rect.Width * (lt.Coordinates[2]/100); Y2 = rect.Y + rect.Height* (lt.Coordinates[3]/100); gr_temp.Reset(); gr_temp.AddLine(X1,Y1,X2,Y2); gr.AddLine(X1,Y1,X2,Y2); // Applying rotation if it's necessary pts = RotatePoints(RA , new PointF(rect.X + rect.Width/2,rect.Y + rect.Height/2), gr_temp); PathPart = Pt2String(pts, crLine,SHAPE_LAYER,DxLineType.ltSingle,DashStyle.Solid, 1); break; } result+=PathPart; } break; default: gr.AddRectangle(rect); break; } // Converting shapes coordinates from UCS to WSC TranslateCoords(RA , new PointF(rect.X + rect.Width/2,rect.Y + rect.Height/2), WCS2UCS, ref gr); gr.Flatten(); // If string output is required producing DXF string if (!DisableStringOutput) { if ( result=="" ) { pts = gr.PathPoints.Clone() as PointF[]; result = Pt2String(pts, crLine, SHAPE_LAYER, DxLineType.ltClosedSingle, dash, LineWidth); } } bOk = true; } catch ( Exception ex) { Trace.WriteLine(String.Format("{0} error {1}\n","Box2Str",ex.Message)); bOk = false; } return bOk; }
/// <summary> /// Creates a rectangular <see cref="GraphicsPath"/> with rounded edges, optionally with an open title /// region specified by the parameters <paramref name="titleInset"/> and <paramref name="titleWidth"/>. /// </summary> /// <param name="baseRect">The rect which surrounds the created path.</param> /// <param name="radiusX">The X radius of the rounded edges.</param> /// <param name="radiusY">The Y radius of the rounded edges.</param> /// <param name="withTitleRegion">If set to <c>true</c>, a title region will be left out.</param> /// <param name="titleInset">Inset of the title region behind the corner. This parameter will only be used if /// <paramref name="withTitleRegion"/> is set to <c>true</c>.</param> /// <param name="titleWidth">Width of the title region to leave out. This parameter will only be used if /// <paramref name="withTitleRegion"/> is set to <c>true</c>.</param> public static GraphicsPath CreateRoundedRectWithTitleRegionPath(RectangleF baseRect, float radiusX, float radiusY, bool withTitleRegion, float titleInset, float titleWidth) { GraphicsPath result = new GraphicsPath(); if (radiusX <= 0.0f && radiusY <= 0.0f || baseRect.Width == 0 || baseRect.Height == 0) { // if corner radius is less than or equal to zero, return the original rectangle if (withTitleRegion) { // If we should leave out a title region, we need to do it manually, because we need to start next to the // title. titleWidth = Math.Min(titleWidth, baseRect.Width - 2 * titleInset); // Right from the title to the upper right edge result.AddLine(baseRect.Left + 2* titleInset + titleWidth, baseRect.Top, baseRect.Right, baseRect.Top); // Upper right edge to lower right edge result.AddLine(baseRect.Right, baseRect.Top, baseRect.Right, baseRect.Bottom); // Lower right edge to lower left edge result.AddLine(baseRect.Right, baseRect.Bottom, baseRect.Left, baseRect.Bottom); // Lower left edge to upper left edge result.AddLine(baseRect.Left, baseRect.Bottom, baseRect.Left, baseRect.Top); // Upper left edge to the left side of the title result.AddLine(baseRect.Left, baseRect.Top, baseRect.Left + titleInset, baseRect.Top); } else result.AddRectangle(baseRect); } else { if (radiusX >= baseRect.Width / 2f) radiusX = baseRect.Width/2f; if (radiusY >= baseRect.Height / 2f) radiusY = baseRect.Height/2f; // create the arc for the rectangle sides and declare a graphics path object for the drawing SizeF sizeF = new SizeF(radiusX * 2f, radiusY * 2f); RectangleF arc = new RectangleF(baseRect.Location, sizeF); if (withTitleRegion) { titleWidth = Math.Min(titleWidth, baseRect.Width - 2 * (radiusX + titleInset)); // Right of the title to the upper right edge result.AddLine(baseRect.Left + radiusX + titleInset + titleWidth, baseRect.Top, baseRect.Right - radiusX, baseRect.Top); } // Top right arc arc.X = baseRect.Right - radiusX * 2f; result.AddArc(arc, 270, 90); // Bottom right arc arc.Y = baseRect.Bottom - radiusY * 2f; result.AddArc(arc, 0, 90); // Bottom left arc arc.X = baseRect.Left; result.AddArc(arc, 90, 90); // Top left arc arc.Y = baseRect.Top; result.AddArc(arc, 180, 90); if (withTitleRegion) // Upper left edge to the left side of the title result.AddLine(baseRect.Left + radiusX, baseRect.Top, baseRect.Left + radiusX + titleInset, baseRect.Top); else result.CloseFigure(); } result.Flatten(); return result; }
/// <summary> /// Repaints the form with cool background and stuff /// </summary> /// <param name="graph">The graphics object to paint to, the element will be drawn to 0, 0</param> public override void Paint(Graphics graph) { //Draws Rectangular Shapes if (Shape == ModelShape.Arrow) { _arrowPath = new GraphicsPath(); //Draws the basic shape Pen arrowPen; if (Highlight < 1) arrowPen = new Pen(Color.Cyan, 3F); else arrowPen = new Pen(Color.Black, 3F); //Draws the curved arrow Point[] lineArray = new Point[4]; lineArray[0] = new Point(_startPoint.X, _startPoint.Y); lineArray[1] = new Point(_startPoint.X - ((_startPoint.X - _stopPoint.X) / 3), _startPoint.Y); lineArray[2] = new Point(_stopPoint.X - ((_stopPoint.X - _startPoint.X) / 3), _stopPoint.Y); lineArray[3] = new Point(_stopPoint.X, _stopPoint.Y); graph.DrawBeziers(arrowPen, lineArray); _arrowPath.AddBeziers(lineArray); _arrowPath.Flatten(); //Draws the arrow head Point[] arrowArray = new Point[3]; arrowArray[0] = _stopPoint; arrowArray[1] = new Point(_stopPoint.X - (5 * Math.Sign(_stopPoint.X - _startPoint.X)), _stopPoint.Y - 2); arrowArray[2] = new Point(_stopPoint.X - (5 * Math.Sign(_stopPoint.X - _startPoint.X)), _stopPoint.Y + 2); graph.DrawPolygon(arrowPen, arrowArray); //Garbage collection arrowPen.Dispose(); } }
public void Flatten_Empty () { GraphicsPath path = new GraphicsPath (); GraphicsPath clone = (GraphicsPath) path.Clone (); // this is a no-op as there's nothing in the path path.Flatten (); ComparePaths (path, clone); }
//--------------------------------------------------------------------- private void GenerateAustPlusRandomEllipses(int count) { subjects.Clear(); //load map of Australia from resource ... Assembly _assembly = Assembly.GetExecutingAssembly(); using (BinaryReader polyStream = new BinaryReader(_assembly.GetManifestResourceStream("GuiDemo.aust.bin"))) { int polyCnt = polyStream.ReadInt32(); for (int i = 0; i < polyCnt; ++i) { int vertCnt = polyStream.ReadInt32(); Polygon pg = new Polygon(vertCnt); for (int j = 0; j < vertCnt; ++j) { float x = polyStream.ReadSingle() * scale; float y = polyStream.ReadSingle() * scale; pg.Add(new IntPoint((int)x, (int)y)); } subjects.Add(pg); } } clips.Clear(); Random rand = new Random(); using (GraphicsPath path = new GraphicsPath()) { const int ellipse_size = 100, margin = 10; for (int i = 0; i < count; ++i) { int w = pictureBox1.ClientRectangle.Width - ellipse_size - margin * 2; int h = pictureBox1.ClientRectangle.Height - ellipse_size - margin * 2 - statusStrip1.Height; int x = rand.Next(w) + margin; int y = rand.Next(h) + margin; int size = rand.Next(ellipse_size - 20) + 20; path.Reset(); path.AddEllipse(x, y, size, size); path.Flatten(); Polygon clip = new Polygon(path.PathPoints.Count()); foreach (PointF p in path.PathPoints) clip.Add(new IntPoint((int)(p.X * scale), (int)(p.Y * scale))); clips.Add(clip); } } }
/// <summary> /// Get the desired Rounded Rectangle path. /// </summary> private GraphicsPath GetLine(RectangleF baseRect) { float x1 = (float) X1; float y1 = (float) Y1; float x2 = (float) X2; float y2 = (float) Y2; float w = (float) Math.Sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)); float ang = (y2 - y1) / (x2 - x1); ang = (float) Math.Atan(ang); ang *= (float) (180.0f / Math.PI); GraphicsPath mPath = new GraphicsPath(); System.Drawing.Rectangle r = new System.Drawing.Rectangle((int) x1, (int) y1, (int) w, (int) StrokeThickness); mPath.AddRectangle(r); mPath.CloseFigure(); using (Matrix matrix = new Matrix()) { matrix.RotateAt(ang, new PointF(x1, y1), MatrixOrder.Append); matrix.Translate(baseRect.X, baseRect.Y, MatrixOrder.Append); RectangleF bounds = mPath.GetBounds(matrix); matrix.Scale(baseRect.Width / bounds.Width, baseRect.Height / bounds.Height); mPath.Transform(matrix); } mPath.Flatten(); return mPath; }
/// <summary> /// Build new polygon from ellipse. The ellipse is /// defined by the specified bounding rectangle. The /// second parameter specifies how close the /// polygon approximates the ellipse. /// Factor of 0 specifies simplest polygon, while /// factor 100 specifies the most complex polygon. /// </summary> /// <param name="bounds"></param> /// <param name="factor"></param> public Polygon(RectangleF bounds, int factor) { if (factor < 0) factor = 0; if (factor > 100) factor = 100; GraphicsPath path = new GraphicsPath(); path.AddEllipse(bounds); path.Flatten(new Matrix(), (float)factor / 100f); _points = new PointList(path.PathPoints); path.Dispose(); Complete(); }
public void buildObjectToLua(StringBuilder sb, float XRatio, float YRatio, CoronaObject objectToBuild) { float moyenneRatio = (XRatio + YRatio) / 2; if (objectToBuild.isEntity == false) { DisplayObject obj = objectToBuild.DisplayObject; string objName = obj.Name.Replace(" ", ""); string paramsName = "params_" + objName; //Create Gradient color if enabled string gradient = "nil"; if (obj.GradientColor.isEnabled == true) { string color1 = "{" + obj.GradientColor.color1.R + "," + obj.GradientColor.color1.G + "," + obj.GradientColor.color1.B + "}"; string color2 = "{" + obj.GradientColor.color2.R + "," + obj.GradientColor.color2.G + "," + obj.GradientColor.color2.B + "}"; string direction = "\"" + obj.GradientColor.direction.ToString() + "\""; gradient = "{" + color1 + "," + color2 + "," + direction + "}"; } sb.AppendLine("\tlocal " + paramsName + " = {}"); if (objectToBuild.EntityParent != null) { sb.AppendLine("\t" + paramsName + ".entityParent = " + this.Name.Replace(" ", "") + "." + objectToBuild.EntityParent.Name); } if (obj.Type.Equals("IMAGE")) { Size finalSize = new Size(Convert.ToInt32(obj.SurfaceRect.Size.Width * XRatio), Convert.ToInt32(obj.SurfaceRect.Size.Height * YRatio)); String paramsObj = "\t" + paramsName + ".name = \"" + objName + "\"\n" + "\t" + paramsName + ".type = \"IMAGE\" \n" + "\t" + paramsName + ".isHandledByTilesMap = " + obj.CoronaObjectParent.IsHandledByTilesMap.ToString().ToLower() + "\n" + "\t" + paramsName + ".x = " + ((float)obj.SurfaceRect.X * XRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".y = " + ((float)obj.SurfaceRect.Y * YRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".width = " + finalSize.Width.ToString() + "\n" + "\t" + paramsName + ".height = " + finalSize.Height.ToString() + "\n" + "\t" + paramsName + ".blendMode = \"" + obj.blendMode + "\"\n" + "\t" + paramsName + ".rotation = " + obj.Rotation + "\n" + "\t" + paramsName + ".alpha = " + obj.Alpha.ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".gradient = " + gradient + "\n" + "\t" + paramsName + ".pathImage = \"" + obj.OriginalAssetName.ToLower() + finalSize.Width + "x" + finalSize.Height + ".png\"\n" + "\t" + paramsName + ".displayGroupParent = " + this.Name.Replace(" ", "") + ".displayGroup\n\n"; sb.Append(paramsObj); sb.AppendLine("\t" + paramsName + ".isDraggable = " + obj.CoronaObjectParent.isDraggable.ToString().ToLower()); if (obj.CoronaObjectParent.isDraggable == true) { sb.AppendLine("\t" + paramsName + ".dragDamping = " + obj.CoronaObjectParent.DragDamping.ToString().Replace(",", ".")); sb.AppendLine("\t" + paramsName + ".dragMaxForce = " + obj.CoronaObjectParent.DragMaxForce); sb.AppendLine("\t" + paramsName + ".dragFrequency = " + obj.CoronaObjectParent.DragFrequency); } if (obj.CoronaObjectParent.isDraggable == true) sb.AppendLine("\t" + paramsName + ".dragBody = dragBody"); String createObj = "\t" + this.Name + "." + objName + " = objectInstance.Object.create(" + paramsName + ")"; sb.AppendLine(createObj); if (obj.ImageFillColor.IsEmpty == false) { sb.AppendLine("\t" + this.Name + "." + objName + ".object:setFillColor(" + obj.ImageFillColor.R + "," + obj.ImageFillColor.G + "," + obj.ImageFillColor.B + ")"); } } //Sinon si c'est un SPRITE else if (obj.Type.Equals("SPRITE")) { string sequenceName = obj.CurrentSequence; if (sequenceName == "DEFAULT" || sequenceName == "") sequenceName = "nil"; else { sequenceName = "\"" + sequenceName + "\""; } //Creer les params de l'objet String paramsSprite = "\t" + paramsName + ".name = \"" + objName + "\"\n" + "\t" + paramsName + ".type = \"SPRITE\" \n" + "\t" + paramsName + ".isHandledByTilesMap = " + obj.CoronaObjectParent.IsHandledByTilesMap.ToString().ToLower() + "\n" + "\t" + paramsName + ".x = " + ((float)obj.SurfaceRect.X * XRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".y = " + ((float)obj.SurfaceRect.Y * YRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".spriteSet = " + obj.SpriteSet.Name + "\n" + "\t" + paramsName + ".rotation = " + obj.Rotation + "\n" + "\t" + paramsName + ".blendMode = \"" + obj.blendMode + "\"\n" + "\t" + paramsName + ".sequenceName = " + sequenceName+ "\n" + "\t" + paramsName + ".firstFrameIndex = " + (obj.CurrentFrame +1) + "\n" + "\t" + paramsName + ".autoPlay = " + obj.AutoPlay.ToString().ToLower() + "\n" + "\t" + paramsName + ".alpha = " + obj.Alpha.ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".gradient = " + gradient + "\n" + "\t" + paramsName + ".scale = 1/currentSuffix.value\n" + "\t" + paramsName + ".displayGroupParent = " + this.Name.Replace(" ", "") + ".displayGroup\n\n"; //Ajouter la sprite set de l'objet sb.Append(paramsSprite); sb.AppendLine("\t" + paramsName + ".isDraggable = " + obj.CoronaObjectParent.isDraggable.ToString().ToLower()); if (obj.CoronaObjectParent.isDraggable == true) { sb.AppendLine("\t" + paramsName + ".dragBody = dragBody"); sb.AppendLine("\t" + paramsName + ".dragDamping = " + obj.CoronaObjectParent.DragDamping.ToString().Replace(",", ".")); sb.AppendLine("\t" + paramsName + ".dragMaxForce = " + obj.CoronaObjectParent.DragMaxForce); sb.AppendLine("\t" + paramsName + ".dragFrequency = " + obj.CoronaObjectParent.DragFrequency); } sb.AppendLine("\t" + this.Name + "." + objName + " = objectInstance.Object.create(" + paramsName + ")"); //if (obj.SpriteSet.Sequences.Count > 0) // sb.AppendLine("\t" + this.Name + "." + objName + ".currentSequence = \"" + obj.SpriteSet.Sequences[0].Name + "\""); } else if (obj.Type.Equals("FIGURE")) { //Si c'est un rectangle if (obj.Figure.ShapeType.Equals("RECTANGLE")) { //Recuperer le rectangle Rect rect = obj.Figure as Rect; String paramsObj = "\t" + paramsName + ".name = \"" + objName + "\"\n" + "\t" + paramsName + ".type = \"RECTANGLE\" \n" + "\t" + paramsName + ".isHandledByTilesMap = " + obj.CoronaObjectParent.IsHandledByTilesMap.ToString().ToLower() + "\n" + "\t" + paramsName + ".isRounded = " + rect.isRounded.ToString().ToLower() + "\n" + "\t" + paramsName + ".x = " + ((float)rect.Position.X * XRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".y = " + ((float)rect.Position.Y * YRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".width = " + ((float)rect.Width * XRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".height = " + ((float)rect.Height * YRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".rotation = " + obj.Rotation + "\n" + "\t" + paramsName + ".blendMode = \"" + obj.blendMode + "\"\n" + "\t" + paramsName + ".gradient = " + gradient + "\n" + "\t" + paramsName + ".alpha = " + obj.Alpha.ToString().Replace(",", ".") + "\n"; if (rect.isRounded == true) { paramsObj += "\t" + paramsName + ".cornerRadius = " + rect.cornerRadius + "\n"; } if (obj.Figure.Fill == true) paramsObj += "\t" + paramsName + ".backColor = { R = " + rect.FillColor.R + ",G = " + rect.FillColor.G + ", B = " + rect.FillColor.B + "}\n"; else paramsObj += "\t" + paramsName + ".backColor = { R = 0, G = 0, B= 0}\n"; paramsObj += "\t" + paramsName + ".strokeColor = { R = " + rect.StrokeColor.R + ",G = " + rect.StrokeColor.G + ", B = " + rect.StrokeColor.B + "}\n" + "\t" + paramsName + ".strokeWidth = " + rect.StrokeSize + "\n" + "\t" + paramsName + ".displayGroupParent = " + this.Name.Replace(" ", "") + ".displayGroup\n\n"; sb.Append(paramsObj); sb.AppendLine("\t" + paramsName + ".isDraggable = " + obj.CoronaObjectParent.isDraggable.ToString().ToLower()); if (obj.CoronaObjectParent.isDraggable == true) { sb.AppendLine("\t" + paramsName + ".dragBody = dragBody"); sb.AppendLine("\t" + paramsName + ".dragDamping = " + obj.CoronaObjectParent.DragDamping.ToString().Replace(",", ".")); sb.AppendLine("\t" + paramsName + ".dragMaxForce = " + obj.CoronaObjectParent.DragMaxForce); sb.AppendLine("\t" + paramsName + ".dragFrequency = " + obj.CoronaObjectParent.DragFrequency); } String createObj = "\t" + this.Name + "." + objName + " = objectInstance.Object.create(" + paramsName + ")"; sb.AppendLine(createObj); } else if (obj.Figure.ShapeType.Equals("CIRCLE")) { //Recuperer le cercle Cercle cercle = obj.Figure as Cercle; String paramsObj = "\t" + paramsName + ".name = \"" + objName + "\"\n" + "\t" + paramsName + ".type = \"CIRCLE\" \n" + "\t" + paramsName + ".isHandledByTilesMap = " + obj.CoronaObjectParent.IsHandledByTilesMap.ToString().ToLower() + "\n" + "\t" + paramsName + ".x = " + ((float)cercle.Position.X * XRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".y = " + ((float)cercle.Position.Y * YRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".radius = " + ((float)cercle.Rayon * moyenneRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".rotation = " + obj.Rotation + "\n" + "\t" + paramsName + ".blendMode = \"" + obj.blendMode + "\"\n" + "\t" + paramsName + ".alpha = " + obj.Alpha.ToString().Replace(",", ".") + "\n"; if (obj.Figure.Fill == true) paramsObj += "\t" + paramsName + ".backColor = { R = " + cercle.FillColor.R + ",G = " + cercle.FillColor.G + ", B = " + cercle.FillColor.B + "}\n"; else paramsObj += "\t" + paramsName + ".backColor = { R = 0, G = 0, B= 0}\n"; paramsObj += "\t" + paramsName + ".strokeColor = { R = " + cercle.StrokeColor.R + ",G = " + cercle.StrokeColor.G + ", B = " + cercle.StrokeColor.B + "}\n" + "\t" + paramsName + ".strokeWidth = " + cercle.StrokeSize + "\n" + "\t" + paramsName + ".displayGroupParent = " + this.Name.Replace(" ", "") + ".displayGroup\n\n"; sb.Append(paramsObj); sb.AppendLine("\t" + paramsName + ".isDraggable = " + obj.CoronaObjectParent.isDraggable.ToString().ToLower()); if (obj.CoronaObjectParent.isDraggable == true) { sb.AppendLine("\t" + paramsName + ".dragBody = dragBody"); sb.AppendLine("\t" + paramsName + ".dragDamping = " + obj.CoronaObjectParent.DragDamping.ToString().Replace(",", ".")); sb.AppendLine("\t" + paramsName + ".dragMaxForce = " + obj.CoronaObjectParent.DragMaxForce); sb.AppendLine("\t" + paramsName + ".dragFrequency = " + obj.CoronaObjectParent.DragFrequency); } String createObj = "\t" + this.Name + "." + objName + " = objectInstance.Object.create(" + paramsName + ")"; sb.AppendLine(createObj); } else if (obj.Figure.ShapeType.Equals("LINE")) { //Recuperer le cercle Line line = obj.Figure as Line; //Create table of points string tabPoints = "\tlocal points_" + objName + "= {"; for (int k = 0; k < line.Points.Count; k++) { if (k % 50 == 0) tabPoints += "\n\t\t"; tabPoints += (((float)line.Points[k].X * XRatio).ToString().Replace(",", ".")) + "," + (((float)line.Points[k].Y * YRatio).ToString().Replace(",", ".")); if (k != line.Points.Count - 1) tabPoints += ","; } tabPoints += "\t}"; String paramsObj = "\t" + paramsName + ".name = \"" + objName + "\"\n" + "\t" + paramsName + ".type = \"LINE\"\n" + "\t" + paramsName + ".isHandledByTilesMap = " + obj.CoronaObjectParent.IsHandledByTilesMap.ToString().ToLower() + "\n" + "\t" + paramsName + ".tabPoints = points_" + objName + "\n" + "\t" + paramsName + ".rotation = " + obj.Rotation + "\n" + "\t" + paramsName + ".blendMode = \"" + obj.blendMode + "\"\n" + "\t" + paramsName + ".alpha = " + obj.Alpha.ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".gradient = " + gradient + "\n" + "\t" + paramsName + ".backColor = { R = " + line.StrokeColor.R + ",G = " + line.StrokeColor.G + ", B = " + line.StrokeColor.B + "}\n" + "\t" + paramsName + ".strokeWidth = " + line.StrokeSize + "\n" + "\t" + paramsName + ".displayGroupParent = " + this.Name.Replace(" ", "") + ".displayGroup\n\n"; sb.Append(tabPoints); sb.Append(paramsObj); sb.AppendLine("\t" + paramsName + ".isDraggable = " + obj.CoronaObjectParent.isDraggable.ToString().ToLower()); if (obj.CoronaObjectParent.isDraggable == true) { sb.AppendLine("\t" + paramsName + ".dragBody = dragBody"); sb.AppendLine("\t" + paramsName + ".dragDamping = " + obj.CoronaObjectParent.DragDamping.ToString().Replace(",", ".")); sb.AppendLine("\t" + paramsName + ".dragMaxForce = " + obj.CoronaObjectParent.DragMaxForce); sb.AppendLine("\t" + paramsName + ".dragFrequency = " + obj.CoronaObjectParent.DragFrequency); } String createObj = "\t" + this.Name + "." + objName + " = objectInstance.Object.create(" + paramsName + ")"; sb.AppendLine(createObj); } else if (obj.Figure.ShapeType.Equals("CURVE")) { //Recuperer le cercle CourbeBezier courbe = obj.Figure as CourbeBezier; GraphicsPath path = new GraphicsPath(FillMode.Winding); path.AddCurve(courbe.UserPoints.ToArray()); path.Flatten(); PointF[] finalPoints = path.PathPoints; //Create table of points string tabPoints = "\tlocal points_" + objName + "= {"; for (int k = 0; k < finalPoints.Length; k++) { if (k % 10 == 0) tabPoints += "\n\t\t"; tabPoints += ((float)finalPoints[k].X * XRatio).ToString().Replace(",", ".") + "," + ((float)finalPoints[k].Y * YRatio).ToString().Replace(",", "."); if (k != finalPoints.Length - 1) tabPoints += ","; } tabPoints += "\t}\n"; String paramsObj = "\t" + paramsName + ".name = \"" + objName + "\"\n" + "\t" + paramsName + ".type = \"CURVE\"\n" + "\t" + paramsName + ".isHandledByTilesMap = " + obj.CoronaObjectParent.IsHandledByTilesMap.ToString().ToLower() + "\n" + "\t" + paramsName + ".tabPoints = points_" + objName + "\n" + "\t" + paramsName + ".rotation = " + obj.Rotation + "\n" + "\t" + paramsName + ".blendMode = \"" + obj.blendMode + "\"\n" + "\t" + paramsName + ".alpha = " + obj.Alpha.ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".gradient = " + gradient + "\n" + "\t" + paramsName + ".backColor = { R = " + courbe.StrokeColor.R + ",G = " + courbe.StrokeColor.G + ", B = " + courbe.StrokeColor.B + "}\n" + "\t" + paramsName + ".strokeWidth = " + courbe.StrokeSize + "\n" + "\t" + paramsName + ".displayGroupParent = " + this.Name.Replace(" ", "") + ".displayGroup\n\n"; sb.Append(tabPoints); sb.Append(paramsObj); sb.AppendLine("\t" + paramsName + ".isDraggable = " + obj.CoronaObjectParent.isDraggable.ToString().ToLower()); if (obj.CoronaObjectParent.isDraggable == true) { sb.AppendLine("\t" + paramsName + ".dragBody = dragBody"); sb.AppendLine("\t" + paramsName + ".dragDamping = " + obj.CoronaObjectParent.DragDamping.ToString().Replace(",", ".")); sb.AppendLine("\t" + paramsName + ".dragMaxForce = " + obj.CoronaObjectParent.DragMaxForce); sb.AppendLine("\t" + paramsName + ".dragFrequency = " + obj.CoronaObjectParent.DragFrequency); } String createObj = "\t" + this.Name + "." + objName + " = objectInstance.Object.create(" + paramsName + ")"; sb.AppendLine(createObj); } else if (obj.Figure.ShapeType.Equals("TEXT")) { //Recuperer le cercle Texte text = obj.Figure as Texte; if (text.font2.FontItem == null) text.font2.FontItem = new GameEditor.FontManager.FontItem("DEFAULT", this.SceneParent.projectParent); if (!text.font2.FontItem.NameForAndroid.Equals("DEFAULT")) { string fontDeclaration = text.font2.FontItem.GenerateCode(); sb.AppendLine(fontDeclaration); } else { sb.AppendLine("\tlocal font = nil"); } String paramsObj = "\t" + paramsName + ".name = \"" + objName + "\"\n" + "\t" + paramsName + ".type = \"TEXT\" \n" + "\t" + paramsName + ".isHandledByTilesMap = " + obj.CoronaObjectParent.IsHandledByTilesMap.ToString().ToLower() + "\n" + "\t" + paramsName + ".x = " + ((float)text.Position.X * XRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".y = " + ((float)text.Position.Y * YRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".width = " + ((float)obj.SurfaceRect.Width * XRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".height = "+((float)0 * YRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".text = \"" + @text.Txt.Replace("\r\n",@"\n").Replace("\"","\\\"") + "\"\n" + "\t" + paramsName + ".rotation = " + obj.Rotation + "\n" + "\t" + paramsName + ".blendMode = \"" + obj.blendMode + "\"\n" + "\t" + paramsName + ".alpha = " + obj.Alpha.ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".gradient = " + gradient + "\n" + "\t" + paramsName + ".textColor = { R = " + text.FillColor.R + ",G = " + text.FillColor.G + ", B = " + text.FillColor.B + "}\n" + "\t" + paramsName + ".textSize = " + (((float)text.font2.Size * 1.4f) * XRatio).ToString().Replace(",", ".") + "\n" + "\t" + paramsName + ".textFont = font\n" + "\t" + paramsName + ".displayGroupParent = " + this.Name.Replace(" ", "") + ".displayGroup\n\n"; sb.Append(paramsObj); sb.AppendLine("\t" + paramsName + ".isDraggable = " + obj.CoronaObjectParent.isDraggable.ToString().ToLower()); if (obj.CoronaObjectParent.isDraggable == true) { sb.AppendLine("\t" + paramsName + ".dragBody = dragBody"); sb.AppendLine("\t" + paramsName + ".dragDamping = " + obj.CoronaObjectParent.DragDamping.ToString().Replace(",", ".")); sb.AppendLine("\t" + paramsName + ".dragMaxForce = " + obj.CoronaObjectParent.DragMaxForce); sb.AppendLine("\t" + paramsName + ".dragFrequency = " + obj.CoronaObjectParent.DragFrequency); } String createObj = "\t" + this.Name + "." + objName + " = objectInstance.Object.create(" + paramsName + ")"; sb.AppendLine(createObj); } } //Ajouter l'object dans les interactions de la tilesmap si elle existe dans le layer if (this.TilesMap != null && obj.CoronaObjectParent.IsHandledByTilesMap == true) { if (this.TilesMap.isEnabled == true) { sb.AppendLine("\t" + this.Name + "." + this.TilesMap.TilesMapName + ":addExternalObjectToInteractWith(" + objName + ")"); } } //CREER Le mask DE L OBJET SI ELLE EXISTE ----------------------------------------- if (obj.CoronaObjectParent.BitmapMask != null && obj.CoronaObjectParent.BitmapMask.MaskImage != null && obj.CoronaObjectParent.BitmapMask.IsMaskEnabled == true) { sb.AppendLine("\tlocal " + objName + "_mask = graphics.newMask(\"" + objName.ToLower() + "_mask.png\")"); sb.AppendLine("\t" + this.Name + "." + objName + ".object:setMask(" + objName + "_mask)"); } //CREER LA PHYSIC DE L OBJET SI ELLE EXISTE ----------------------------------------- if (obj.CoronaObjectParent.PhysicsBody != null) { PhysicsBody ph = obj.CoronaObjectParent.PhysicsBody; if (ph.Mode != PhysicsBody.PhysicBodyMode.Inactive) { CoronaObject coronaObject = obj.CoronaObjectParent; ////Creer le fichier lua associé //PhysicBodyLuaGenerator gen = new PhysicBodyLuaGenerator(coronaObject.PhysicsBody); //gen.writeToLua(new DirectoryInfo(this.SceneParent.projectParent.BuildFolderPath), XRatio, YRatio); //if(File.Exists(this.SceneParent.projectParent.SourceFolderPath+"\\body" + objName.ToLower()+".lua")) // File.Delete(this.SceneParent.projectParent.SourceFolderPath+"\\body" + objName.ToLower()+".lua"); //Faire le require correspondant sb.AppendLine("\tlocal body_" + objName + " = require(\"body" + objName.ToLower() + "\")" + ".startBody(" + this.Name + "." + objName + ")"); } } //CREER Le PATH FOLLOW DE L OBJET SI ELLE EXISTE ----------------------------------------- if (obj.CoronaObjectParent.PathFollow != null) { PathFollow path = obj.CoronaObjectParent.PathFollow; if (path.isEnabled == true) { CoronaObject coronaObject = obj.CoronaObjectParent; sb.AppendLine("\tlocal " + objName + "_pathFollow = " + path.getPointsTableLua(XRatio, YRatio)); sb.AppendLine("\tlocal " + objName + "_pathFollow_params = {}"); sb.AppendLine("\t" + objName + "_pathFollow_params.isCyclic = " + coronaObject.PathFollow.isCyclic.ToString().ToLower()); sb.AppendLine("\t" + objName + "_pathFollow_params.removeOnComplete = " + coronaObject.PathFollow.removeOnComplete.ToString().ToLower()); sb.AppendLine("\t" + objName + "_pathFollow_params.rotate = " + coronaObject.PathFollow.Rotate.ToString().ToLower()); sb.AppendLine("\t" + objName + "_pathFollow_params.targetObject = " + this.Name + "." + objName); sb.AppendLine("\t" + objName + "_pathFollow_params.path = " + objName + "_pathFollow"); sb.AppendLine("\t" + objName + "_pathFollow_params.speed = " + coronaObject.PathFollow.speed); sb.AppendLine("\t" + objName + "_pathFollow_params.iteration = " + coronaObject.PathFollow.Iteration); sb.AppendLine("\t" + this.Name + "." + objName + ".pathFollow = pathFollowInstance.PathFollow.create(" + objName + "_pathFollow_params)"); } } /* sb.AppendLine("\t" + this.Name + "." + objName + ":setOnStartBehaviour(" + obj.CoronaObjectParent.onStartFunction + ")"); sb.AppendLine("\t" + this.Name + "." + objName + ":setOnPauseBehaviour(" + obj.CoronaObjectParent.onPauseFunction + ")"); sb.AppendLine("\t" + this.Name + "." + objName + ":setOnDeleteBehaviour(" + obj.CoronaObjectParent.onDeleteFunction + ")");*/ } }
protected override void OnPaint(PaintEventArgs e) { #region Declare the internal variables SolidBrush bSolid = null; LinearGradientBrush bGradient = null; Pen p; Bitmap bmp; Graphics g; GraphicsPath gpTitlePath, gpRegion; Rectangle rectTopArea, rectBottomArea; Rectangle rectLeftCorner, rectRightCorner; Rectangle rectTitleBar/*, rectTitleIcon*/; StringFormat sf; SizeF sizeTitleText; Size sizeTitleBar, sizeTitleBody; #endregion #region Initialize the common variables // Create a new Bitmap object bmp = new Bitmap(this.Width, this.Height); // Initialize the Form Graphics instance g = Graphics.FromImage(bmp); g.SmoothingMode = SmoothingMode.HighSpeed; g.CompositingQuality = CompositingQuality.HighQuality; g.InterpolationMode = InterpolationMode.High; // Create a new Brush object bSolid = new SolidBrush(this.transparentColor); // Fill all the area with pink (will be used to create the transparent region) g.FillRectangle(bSolid, 0, 0, this.Width, this.Height); // Dispose the Brush object bSolid.Dispose(); bSolid = null; // Create the rectangles that will be used to round the corners of the form rectLeftCorner = new Rectangle(0, 0, (edgeRadius * 2), (edgeRadius * 2)); rectRightCorner = new Rectangle(this.Width - (edgeRadius * 2) - 1, 0, (edgeRadius * 2), (edgeRadius * 2)); // Create the remaining rectangles to complete the form rectTopArea = new Rectangle(edgeRadius, 0, this.Width - (edgeRadius * 2), this.Height); rectBottomArea = new Rectangle(0, edgeRadius, this.Width, this.Height); #endregion #region Calculate the TitleBar and Body dimensions sizeTitleText = g.MeasureString(this.Text, this.TitleFont); sizeTitleBar = new Size(0, 0); sizeTitleBar.Width = this.Width; sizeTitleBar.Height = Convert.ToInt32(sizeTitleText.Height) + (padding * 2); if (this.Icon != null && sizeTitleBar.Height < 16 + (padding * 2)) { sizeTitleBar.Height = 16 + (padding * 2); } sizeTitleBody = new Size(0, 0); sizeTitleBody.Width = this.Width; sizeTitleBody.Height = this.Height - sizeTitleBar.Height; rectTitleBar = new Rectangle(0, 0, sizeTitleBar.Width, sizeTitleBar.Height); rectBody = new Rectangle(0, sizeTitleBar.Height, sizeTitleBody.Width, sizeTitleBody.Height); #endregion #region Draw the TitleBar background color // Create a GraphicsPath instance to map our form title shape gpTitlePath = new GraphicsPath(); gpTitlePath.AddArc(rectLeftCorner, 180, 90); gpTitlePath.AddArc(rectRightCorner, 270, 90); GraphicsPath gTitlePath2 = new GraphicsPath(); gTitlePath2.AddRectangle(new Rectangle(0, edgeRadius, rectTitleBar.Width - 1, rectTitleBar.Height)); gTitlePath2.AddPath(gpTitlePath, true); gTitlePath2.Flatten(); if (this.TitleStyle == ColorStyle.Solid) { // Create a new Brush object bSolid = new SolidBrush(this.TitleForeColor); // Fill the title area g.FillPath(bSolid, gTitlePath2); // Dispose the Brush object bSolid.Dispose(); bSolid = null; } else { switch (this.TitleStyle) { case ColorStyle.BackwardDiagonalGradient : // Create a new Brush object bGradient = new LinearGradientBrush(rectTitleBar, this.TitleForeColor, this.TitleBackColor, LinearGradientMode.BackwardDiagonal); break; case ColorStyle.ForwardDiagonalGradient : // Create a new Brush object bGradient = new LinearGradientBrush(rectTitleBar, this.TitleForeColor, this.TitleBackColor, LinearGradientMode.ForwardDiagonal); break; case ColorStyle.HorizontalGradient : // Create a new Brush object bGradient = new LinearGradientBrush(rectTitleBar, this.TitleForeColor, this.TitleBackColor, LinearGradientMode.Horizontal); break; case ColorStyle.VerticalGradient : // Create a new Brush object bGradient = new LinearGradientBrush(rectTitleBar, this.TitleForeColor, this.TitleBackColor, LinearGradientMode.Vertical); break; } g.FillPath(bGradient, gTitlePath2); // Dispose the LinearGradientBrush object bGradient.Dispose(); bGradient = null; } #endregion #region Draw the Title icons and text // Draw the Title icon and text bSolid = new SolidBrush(this.TitleColor); sf = new StringFormat(); sf.Alignment = StringAlignment.Near; sf.FormatFlags = StringFormatFlags.NoWrap; sf.Trimming = StringTrimming.None; rectTitleArea = new Rectangle(0, 0, 0, 0); rectTitleArea.X = edgeRadius / 2 + padding; rectTitleArea.Y = Convert.ToInt32((rectTitleBar.Height - sizeTitleText.Height) / 2); rectTitleArea.Width = this.Width - (edgeRadius * 2) - padding; rectTitleArea.Height = padding + Convert.ToInt32(sizeTitleText.Height); #region Draw the Application icon // commented out because it generated an unreachable code warning //if (this.Icon != null && 1 == 2) //{ // if (this.bmpIcon == null) // { // bmpIcon = this.Icon.ToBitmap(); // } // rectTitleIcon = new Rectangle(0, 0, 0, 0); // rectTitleIcon.X = edgeRadius / 2 + padding; // rectTitleIcon.Y = Convert.ToInt32((rectTitleBar.Height - sizeTitleText.Height) / 2); // rectTitleIcon.Width = 16; // rectTitleIcon.Height = 16; // g.SmoothingMode = SmoothingMode.HighQuality; // g.DrawImage(bmpIcon, rectTitleIcon, 0, 0, 32,32, GraphicsUnit.Pixel); // g.SmoothingMode = SmoothingMode.None; // // Compensate for the space taken by the icon image // rectTitleArea.X = rectTitleArea.X + 16 + padding; //} #endregion #region Draw the Close icon rectCloseIcon = new Rectangle(0, 0, 0, 0); rectCloseIcon.X = this.Width - edgeRadius - padding - 16 + 2; rectCloseIcon.Y = Convert.ToInt32((rectTitleBar.Height - sizeTitleText.Height) / 2) + 2; rectCloseIcon.Width = 16 - 2; rectCloseIcon.Height = 16 - 2; // Create a new Pen object if (this.onCloseIcon == false) p = new Pen(this.IconsNormalColor, 1); else p = new Pen(this.IconsHiLiteColor, 1); g.DrawLine(p, rectCloseIcon.X + 1, rectCloseIcon.Y, rectCloseIcon.X + rectCloseIcon.Width - 1, rectCloseIcon.Y); g.DrawLine(p, rectCloseIcon.X, rectCloseIcon.Y + 1, rectCloseIcon.X, rectCloseIcon.Y + rectCloseIcon.Height - 1); g.DrawLine(p, rectCloseIcon.X + rectCloseIcon.Width, rectCloseIcon.Y + 1, rectCloseIcon.X + rectCloseIcon.Width, rectCloseIcon.Y + rectCloseIcon.Height - 1); g.DrawLine(p, rectCloseIcon.X + 1, rectCloseIcon.Y + rectCloseIcon.Height, rectCloseIcon.X + rectCloseIcon.Width - 1, rectCloseIcon.Y + rectCloseIcon.Height); // Dispose the Pen object p.Dispose(); p = null; // Create a new Pen object if (this.onCloseIcon == false) p = new Pen(this.IconsNormalColor, 2); else p = new Pen(this.IconsHiLiteColor, 2); g.DrawLine(p, rectCloseIcon.X + 3, rectCloseIcon.Y + 3, rectCloseIcon.X + rectCloseIcon.Width - 3, rectCloseIcon.Y + rectCloseIcon.Height - 3); g.DrawLine(p, rectCloseIcon.X + rectCloseIcon.Width - 3, rectCloseIcon.Y + 3, rectCloseIcon.X + 3, rectCloseIcon.Y + rectCloseIcon.Height - 3); rectCloseIcon.Width += 1; rectCloseIcon.Height += 1; #endregion #region Draw the Minimize icon rectMinimizeIcon = new Rectangle(0, 0, 0, 0); rectMinimizeIcon.X = this.Width - edgeRadius - (padding * 2) - (16 * 2) + 2; rectMinimizeIcon.Y = Convert.ToInt32((rectTitleBar.Height - sizeTitleText.Height) / 2) + 2; rectMinimizeIcon.Width = 16 - 2; rectMinimizeIcon.Height = 16 - 2; // Create a new Pen object if (this.onMinimizeIcon == false) p = new Pen(this.IconsNormalColor, 1); else p = new Pen(this.IconsHiLiteColor, 1); g.DrawLine(p, rectMinimizeIcon.X + 1, rectMinimizeIcon.Y, rectMinimizeIcon.X + rectMinimizeIcon.Width - 1, rectMinimizeIcon.Y); g.DrawLine(p, rectMinimizeIcon.X, rectMinimizeIcon.Y + 1, rectMinimizeIcon.X, rectMinimizeIcon.Y + rectMinimizeIcon.Height - 1); g.DrawLine(p, rectMinimizeIcon.X + rectMinimizeIcon.Width, rectMinimizeIcon.Y + 1, rectMinimizeIcon.X + rectMinimizeIcon.Width, rectMinimizeIcon.Y + rectMinimizeIcon.Height - 1); g.DrawLine(p, rectMinimizeIcon.X + 1, rectMinimizeIcon.Y + rectMinimizeIcon.Height, rectMinimizeIcon.X + rectMinimizeIcon.Width - 1, rectMinimizeIcon.Y + rectMinimizeIcon.Height); // Dispose the Pen object p.Dispose(); p = null; // Create a new Pen object if (this.onMinimizeIcon == false) p = new Pen(this.IconsNormalColor, 2); else p = new Pen(this.IconsHiLiteColor, 2); g.DrawLine(p, rectMinimizeIcon.X + 3, rectMinimizeIcon.Y + rectMinimizeIcon.Height - 3, rectMinimizeIcon.X + rectMinimizeIcon.Width - 2, rectMinimizeIcon.Y + rectMinimizeIcon.Height - 3); rectMinimizeIcon.Width += 1; rectMinimizeIcon.Height += 1; #endregion // Compensate for the space taken by the icon image rectTitleArea.Width = rectTitleArea.Width - 50; g.SmoothingMode = SmoothingMode.AntiAlias; g.DrawString(this.Text, this.TitleFont, bSolid, rectTitleArea, sf); g.SmoothingMode = SmoothingMode.None; // Make sure that TitleArea Rectangle values covers the whole title area rectTitleArea.X = 0; rectTitleArea.Y = 0; rectTitleArea.Width = this.Width; // Dispose the StringFormat object sf.Dispose(); sf = null; // Dispose the Brush object bSolid.Dispose(); bSolid = null; #endregion #region Draw the Body background color if (this.windowMaximized == true) { if (this.BodyStyle == ColorStyle.Solid) { // Create a new Brush object bSolid = new SolidBrush(this.BodyForeColor); // Fill the body area g.FillRectangle(bSolid, rectBody); // Dispose the Brush object bSolid.Dispose(); bSolid = null; } else { switch (this.BodyStyle) { case ColorStyle.BackwardDiagonalGradient : // Create a new Brush object bGradient = new LinearGradientBrush(rectBody, this.BodyForeColor, this.BodyBackColor, LinearGradientMode.BackwardDiagonal); break; case ColorStyle.ForwardDiagonalGradient : // Create a new Brush object bGradient = new LinearGradientBrush(rectBody, this.BodyForeColor, this.BodyBackColor, LinearGradientMode.ForwardDiagonal); break; case ColorStyle.HorizontalGradient : // Create a new Brush object bGradient = new LinearGradientBrush(rectBody, this.BodyForeColor, this.BodyBackColor, LinearGradientMode.Horizontal); break; case ColorStyle.VerticalGradient : // Create a new Brush object bGradient = new LinearGradientBrush(rectBody, this.BodyForeColor, this.BodyBackColor, LinearGradientMode.Vertical); break; } // Fill the body area g.FillRectangle(bGradient, rectBody); // Dispose the LinearGradientBrush object bGradient.Dispose(); bGradient = null; } } #endregion #region Draw the Resizable symbol if (this.IsResizable == true && this.windowMaximized == true) { rectResizableArea = new Rectangle(0, 0, 0, 0); rectResizableArea.X = this.Width - padding - 11; rectResizableArea.Y = this.Height - padding - 11; rectResizableArea.Height = padding + 11; rectResizableArea.Width = padding + 11; // Create a new Pen object p = new Pen(this.ResizableColor, 2); // Draw the resizable symbol g.DrawLine(p, this.Width - padding - 11, this.Height - padding, this.Width - padding, this.Height - padding - 11); g.DrawLine(p, this.Width - padding - 7, this.Height - padding, this.Width - padding, this.Height - padding - 7); g.DrawLine(p, this.Width - padding - 3, this.Height - padding, this.Width - padding, this.Height - padding - 3); // Dispose the Pen object p.Dispose(); p = null; } #endregion #region Draw the Form Outline // Create a new Pen object p = new Pen(this.OutlineColor, this.OutlineSize); // Draw the form outline g.DrawArc(p, rectLeftCorner, 180, 90); g.DrawArc(p, rectRightCorner, 270, 90); g.DrawLine(p, edgeRadius, 0, this.Width - edgeRadius, 0); g.DrawLine(p, 0, edgeRadius, 0, this.Height); g.DrawLine(p, this.Width - 1, edgeRadius, this.Width - 1, this.Height); g.DrawLine(p, 0, this.Height - 1, this.Width, this.Height - 1); // Dispose the Pen object p.Dispose(); p = null; #endregion #region Create/Apply a transparent region if (this.Region != null) { this.Region.Dispose(); this.Region = null; } // Create GraphicsPath to be used to crop the region required gpRegion = new GraphicsPath(); // Loop through every pixel in the top left corner. // Create a 1 x 1 rectangle regions of pixels that do not match the transparent color for (int x = rectLeftCorner.X; x < rectLeftCorner.Width; x++) { for (int y = rectLeftCorner.Y; y < rectLeftCorner.Height / 2; y++) { if (isSameColor(bmp.GetPixel(x, y), this.transparentColor) == false) { gpRegion.AddRectangle(new Rectangle(x, y, 1, 1)); } } } // Loop through every pixel in the top right corner. // Create a 1 x 1 rectangle regions of pixels that do not match the transparent color for (int x = rectRightCorner.X + 1; x < rectRightCorner.X + rectRightCorner.Width + 1; x++) { for (int y = rectRightCorner.Y; y < rectRightCorner.Y + rectRightCorner.Height / 2; y++) { if (isSameColor(bmp.GetPixel(x, y), this.transparentColor) == false) { gpRegion.AddRectangle(new Rectangle(x, y, 1, 1)); } } } // Create the remaining rectangular regions to complete cover all the windows form area gpRegion.AddRectangle(new Rectangle(rectLeftCorner.Width, 0, this.Width - (edgeRadius * 4), rectLeftCorner.Height / 2)); gpRegion.AddRectangle(new Rectangle(0, rectLeftCorner.Height / 2, this.Width, this.Height)); // Apply region this.Region = new Region(gpRegion); #endregion #region Draw the buffered image on the windows form Graphics object // Draw the buffered image on the windows form Graphics object e.Graphics.DrawImageUnscaled(bmp, 0, 0, this.Width, this.Height); // Dispose the Graphics object g.Dispose(); g = null; // Dispose the Bitmap object bmp.Dispose(); bmp = null; #endregion }
private void Flatten1(Graphics g) { GraphicsPath myPath = new GraphicsPath(); Matrix translateMatrix = new Matrix(); translateMatrix.Translate(0, 10); Point point1 = new Point(20, 120); Point point2 = new Point(70, 30); Point point3 = new Point(130, 220); Point point4 = new Point(180, 120); Point[] points = {point1, point2, point3, point4}; myPath.AddCurve(points); g.DrawPath(new Pen(Color.Black, 1), myPath); var pathPoints = myPath.PathPoints; var pathTypes = myPath.PathTypes; Console.WriteLine("Flatten before Flattening"); for (int i = 0; i < myPath.PathTypes.Length; i++) { Console.WriteLine("{0} - {1},{2}", (PathPointType)pathTypes[i], pathPoints[i].X, pathPoints[i].Y); } myPath.Flatten(translateMatrix, 10); pathPoints = myPath.PathPoints; pathTypes = myPath.PathTypes; Console.WriteLine("Flatten after Flattening"); for (int i = 0; i < myPath.PathTypes.Length; i++) { Console.WriteLine("{0} - {1},{2}", (PathPointType)pathTypes[i], pathPoints[i].X, pathPoints[i].Y); } g.DrawPath(new Pen(Color.Red, 1), myPath); }
public void Flatten_Rectangle () { GraphicsPath path = new GraphicsPath (); path.AddRectangle (new Rectangle (0, 0, 100, 100)); GraphicsPath clone = (GraphicsPath) path.Clone (); path.Flatten (); ComparePaths (path, clone); }
public IEnumerable<MapObject> Create(IDGenerator generator, Box box, ITexture texture, int roundDecimals) { var width = box.Width; var length = Math.Max(1, Math.Abs((int) box.Length)); var height = box.Height; var flatten = (float) _flattenFactor.Value; var text = _text.GetValue(); var family = _fontChooser.GetFontFamily(); var style = Enum.GetValues(typeof (FontStyle)).OfType<FontStyle>().FirstOrDefault(fs => family.IsStyleAvailable(fs)); if (!family.IsStyleAvailable(style)) family = FontFamily.GenericSansSerif; var set = new PolygonSet(); var sizes = new List<RectangleF>(); using (var bmp = new Bitmap(1,1)) { using (var g = System.Drawing.Graphics.FromImage(bmp)) { using (var font = new Font(family, length, style, GraphicsUnit.Pixel)) { for (var i = 0; i < text.Length; i += 32) { using (var sf = new StringFormat(StringFormat.GenericTypographic)) { var rem = Math.Min(text.Length, i + 32) - i; var range = Enumerable.Range(0, rem).Select(x => new CharacterRange(x, 1)).ToArray(); sf.SetMeasurableCharacterRanges(range); var reg = g.MeasureCharacterRanges(text.Substring(i, rem), font, new RectangleF(0, 0, float.MaxValue, float.MaxValue), sf); sizes.AddRange(reg.Select(x => x.GetBounds(g))); } } } } } var xOffset = box.Start.DX; var yOffset = box.End.DY; for (var ci = 0; ci < text.Length; ci++) { var c = text[ci]; var size = sizes[ci]; var gp = new GraphicsPath(); gp.AddString(c.ToString(CultureInfo.InvariantCulture), family, (int)style, length, new PointF(0, 0), StringFormat.GenericTypographic); gp.Flatten(new System.Drawing.Drawing2D.Matrix(), flatten); var polygons = new List<Polygon>(); var poly = new List<PolygonPoint>(); for (var i = 0; i < gp.PointCount; i++) { var type = gp.PathTypes[i]; var point = gp.PathPoints[i]; poly.Add(new PolygonPoint(point.X + xOffset, -point.Y + yOffset)); if ((type & 0x80) == 0x80) { polygons.Add(new Polygon(poly)); poly.Clear(); } } var tri = new List<Polygon>(); Polygon polygon = null; foreach (var p in polygons) { if (polygon == null) { polygon = p; tri.Add(p); } else if (p.CalculateWindingOrder() != polygon.CalculateWindingOrder()) { polygon.AddHole(p); } else { polygon = null; tri.Add(p); } } foreach (var pp in tri) { try { P2T.Triangulate(pp); set.Add(pp); } catch { // Ignore } } xOffset += size.Width; } var zOffset = box.Start.Z; foreach (var polygon in set.Polygons) { foreach (var t in polygon.Triangles) { var points = t.Points.Select(x => new Coordinate((decimal) x.X, (decimal) x.Y, zOffset).Round(roundDecimals)).ToList(); var faces = new List<Coordinate[]>(); // Add the vertical faces var z = new Coordinate(0, 0, height).Round(roundDecimals); for (var j = 0; j < points.Count; j++) { var next = (j + 1) % points.Count; faces.Add(new[] {points[j], points[j] + z, points[next] + z, points[next]}); } // Add the top and bottom faces faces.Add(points.ToArray()); faces.Add(points.Select(x => x + z).Reverse().ToArray()); // Nothing new here, move along var solid = new Solid(generator.GetNextObjectID()) {Colour = Colour.GetRandomBrushColour()}; foreach (var arr in faces) { var face = new Face(generator.GetNextFaceID()) { Parent = solid, Plane = new Plane(arr[0], arr[1], arr[2]), Colour = solid.Colour, Texture = {Texture = texture} }; face.Vertices.AddRange(arr.Select(x => new Vertex(x, face))); face.UpdateBoundingBox(); face.AlignTextureToFace(); solid.Faces.Add(face); } solid.UpdateBoundingBox(); yield return solid; } } }
public void Flatten_NullFloat () { GraphicsPath path = new GraphicsPath (); GraphicsPath clone = (GraphicsPath) path.Clone (); // this is a no-op as there's nothing in the path // an no matrix to apply path.Flatten (null, 1f); ComparePaths (path, clone); }
public void Flatten_Arc () { GraphicsPath path = new GraphicsPath (); path.AddArc (0f, 0f, 100f, 100f, 30, 30); GraphicsPath clone = (GraphicsPath) path.Clone (); path.Flatten (); CompareFlats (path, clone); }
private int getNearestLine(RectangleF hit) { int result = -1; if (LineList.Items.Count == 0) return -1; for (int i = 0; i < LineList.Items.Count; i++) { PointF[] tmp = (Lines[i] as PData).Lines; using (GraphicsPath gp = new GraphicsPath()) { gp.AddLines(tmp); gp.Flatten(null, .1f); tmp = gp.PathPoints; for (int j = 0; j < tmp.Length; j++) { PointF p = new PointF(tmp[j].X * pb.ClientSize.Width, tmp[j].Y * pb.ClientSize.Height); if (hit.Contains(p)) { result = i; break; } } if (result > -1) break; } } return result; }
static List<PointF> GetArrowLinePoints(float x1, float y1, float x2, float y2, out float centerX, out float centerY, float extra_thickness = 0) { var widthX = (x2 - x1); var lengthX = Math.Max(60, Math.Abs(widthX / 2)) //+ Math.Max(0, -widthX / 2) ; var lengthY = 0;// Math.Max(-170, Math.Min(-120.0f, widthX - 120.0f)) + 120.0f; if (widthX < 120) lengthX = 60; var yB = ((y1 + y2) / 2) + lengthY;// (y2 + ((y1 - y2) / 2) * 0.75f) + lengthY; var yC = y2 + yB; var xC = (x1 + x2) / 2; var xA = x1 + lengthX; var xB = x2 - lengthX; /* if (widthX >= 120) { xA = xB = xC = x2 - 60; } //*/ var points = new List<PointF> { new PointF(x1, y1), new PointF(xA, y1), new PointF(xB, y2), new PointF(x2 - GraphConstants.ConnectorSize - extra_thickness, y2) }; var t = 1.0f;//Math.Min(1, Math.Max(0, (widthX - 30) / 60.0f)); var yA = (yB * t) + (yC * (1 - t)); if (widthX <= 120) { points.Insert(2, new PointF(xB, yA)); points.Insert(2, new PointF(xC, yA)); points.Insert(2, new PointF(xA, yA)); } //* using (var tempPath = new GraphicsPath()) { tempPath.AddBeziers(points.ToArray()); tempPath.Flatten(); points = tempPath.PathPoints.ToList(); } //*/ var angles = new PointF[points.Count - 1]; var lengths = new float[points.Count - 1]; float totalLength = 0; centerX = 0; centerY = 0; points.Add(points[points.Count - 1]); for (int i = 0; i < points.Count - 2; i++) { var pt1 = points[i]; var pt2 = points[i + 1]; var pt3 = points[i + 2]; var deltaX = (float)((pt2.X - pt1.X) + (pt3.X - pt2.X)); var deltaY = (float)((pt2.Y - pt1.Y) + (pt3.Y - pt2.Y)); var length = (float)Math.Sqrt((deltaX * deltaX) + (deltaY * deltaY)); if (length <= 1.0f) { points.RemoveAt(i); i--; continue; } lengths[i] = length; totalLength += length; angles[i].X = deltaX / length; angles[i].Y = deltaY / length; } float midLength = (totalLength / 2.0f);// * 0.75f; float startWidth = extra_thickness + 0.75f; float endWidth = extra_thickness + (GraphConstants.ConnectorSize / 3.5f); float currentLength = 0; var newPoints = new List<PointF>(); newPoints.Add(points[0]); for (int i = 0; i < points.Count - 2; i++) { var angle = angles[i]; var point = points[i + 1]; var length = lengths[i]; var width = (((currentLength * (endWidth - startWidth)) / totalLength) + startWidth); var angleX = angle.X * width; var angleY = angle.Y * width; var newLength = currentLength + length; if (currentLength <= midLength && newLength >= midLength) { var dX = point.X - points[i].X; var dY = point.Y - points[i].Y; var t1 = midLength - currentLength; var l = length; centerX = points[i].X + ((dX * t1) / l); centerY = points[i].Y + ((dY * t1) / l); } var pt1 = new PointF(point.X - angleY, point.Y + angleX); var pt2 = new PointF(point.X + angleY, point.Y - angleX); if (Math.Abs(newPoints[newPoints.Count - 1].X - pt1.X) > 1.0f || Math.Abs(newPoints[newPoints.Count - 1].Y - pt1.Y) > 1.0f) newPoints.Add(pt1); if (Math.Abs(newPoints[0].X - pt2.X) > 1.0f || Math.Abs(newPoints[0].Y - pt2.Y) > 1.0f) newPoints.Insert(0, pt2); currentLength = newLength; } return newPoints; }
public void Flatten_Ellipse () { GraphicsPath path = new GraphicsPath (); path.AddEllipse (10f, 10f, 100f, 100f); GraphicsPath clone = (GraphicsPath) path.Clone (); path.Flatten (); CompareFlats (path, clone); }
/// <summary> /// Produces DXF output from various type of lines /// </summary> /// <param name="pt">Point array of the line points</param> /// <param name="crLine">Line color</param> /// <param name="LayerName">Name of the layer to place the line</param> /// <param name="dlt">Line type according to DxLineType enum</param> /// <param name="dash">Line dash style</param> /// <param name="LineWidth">Used for bezier curves ( if 8 - points, 16 - controls points )</param> /// <returns>DXF output string</returns> public string Pt2String(PointF[] pt, Color crLine , string LayerName, DxLineType dlt , DashStyle dash , Single LineWidth ) { string sResult = ""; bool IsClosedLine = false; long SegCount = 0; bool FirstOrLast = false; try { // Validating input parameters if ( pt == null ) throw new Exception("Null points array passed"); if ( pt.Length == 0 ) throw new Exception("Empty points array passed"); IsClosedLine = (pt[0] == pt[pt.Length-1]); if (( dlt == DxLineType.ltSingle) || (dlt == DxLineType.ltClosedSingle)) SegCount = pt.Length - 1; else SegCount = pt.Length; // Processing all line points according to its type for ( int i=0; i< SegCount ; i++) { FirstOrLast =((i ==0) || (i == SegCount-1)); switch ( dlt) { case DxLineType.ltSingle: case DxLineType.ltClosedSingle: sResult+=String.Format(provider, "0\nLINE\n 100\nAcDbEntity\n{0:HAN} 8\n{1}\n 6\n{6:DASH_STYLE}\n62\n{0:ACI}\n 100\nAcDbLine\n 10\n{2:U}\n 20\n{3:U}\n 11\n{4:U}\n 21\n{5:U}\n", crLine, LayerName, pt[i].X, pt[i].Y, pt[i+1].X, pt[i+1].Y, dash); break; case DxLineType.ltBezier: sResult+=String.Format(provider, " 0\nVERTEX\n 100\nAcDbEntity\n{0:HAN} 8\n{2}\n 62\n{4:ACI}\n100\nAcDbVertex\n 100\nAcDb2dVertex\n 10\n{0:U}\n 20\n{1:U}\n 70\n{3}\n", pt[i].X, pt[i].Y, LayerName, 16 , crLine, dash); break; case DxLineType.ltVertex: sResult+=String.Format(provider, " 0\nVERTEX\n 100\nAcDbEntity\n{0:HAN} 8\n{2}\n 62\n{4:ACI}\n100\nAcDbVertex\n 100\nAcDb2dVertex\n 10\n{0:U}\n 20\n{1:U}\n 70\n{3}\n", pt[i].X, pt[i].Y, LayerName, LineWidth, crLine); break; case DxLineType.ltPoly: sResult+=String.Format(provider, " 10\n{0:U}\n 20\n{1:U}\n", pt[i].X, pt[i].Y); break; case DxLineType.ltHatch: sResult+=String.Format(provider, " 10\n{0:U}\n 20\n{1:U}\n", pt[i].X, pt[i].Y); break; default: throw new Exception("Line type is not supported"); } } // Post - processing some types of line if (dlt == DxLineType.ltClosedSingle) sResult+=String.Format(provider, "0\nLINE\n 100\nAcDbEntity\n{0:HAN} 8\n{1}\n 6\n{6:DASH_STYLE}\n62\n{0:ACI}\n 100\nAcDbLine\n 10\n{2:U}\n 20\n{3:U}\n 11\n{4:U}\n 21\n{5:U}\n", crLine, LayerName, pt[pt.Length - 1].X, pt[pt.Length - 1].Y, pt[0].X, pt[0].Y, dash); if ( dlt == DxLineType.ltPoly ) sResult = String.Format(provider, "0\nLWPOLYLINE\n 100\nAcDbEntity\n{0:HAN} 8\n{1}\n 6\n{5:DASH_STYLE}\n62\n{0:ACI}\n 100\nAcDbPolyline\n 90\n{2}\n 70\n{4}\n{3}", crLine, LayerName, pt.Length , sResult, IsClosedLine ? "1" : "0", dash); if ( dlt == DxLineType.ltBezier ) { GraphicsPath gr_temp = new GraphicsPath(FillMode.Winding); gr_temp.AddBeziers(pt); gr_temp.Flatten(); PointF[] pts2 = gr_temp.PathData.Points as PointF[]; sResult = String.Format(provider, "0\nPOLYLINE\n{0:HAN} 100\nAcDbEntity\n 8\n{0}\n 6\n{4:DASH_STYLE}\n 62\n{1:ACI}\n 100\nAcDb2dPolyline\n 66\n1\n 70\n4\n 75\n6\n{2}{3} 0\nSEQEND\n 100\nAcDbEntity\n{0:HAN}", LayerName, crLine, sResult, Pt2String(pts2,crLine,LayerName,DxLineType.ltVertex, dash, 8), dash); gr_temp.Dispose(); } } catch ( Exception ex) { sResult = ""; m_status = ex.Message; Trace.WriteLine(String.Format("{0} error {1}\n","DxfHelper.Pt2String",ex.Message)); } return sResult; }
public void Flatten_Line () { GraphicsPath path = new GraphicsPath (); path.AddLine (10f, 10f, 100f, 100f); GraphicsPath clone = (GraphicsPath) path.Clone (); path.Flatten (); ComparePaths (path, clone); }
public void Flatten_Curve () { GraphicsPath path = new GraphicsPath (); path.AddCurve (new Point[4] { new Point (0, 0), new Point (40, 20), new Point (20, 40), new Point (40, 40) }); GraphicsPath clone = (GraphicsPath) path.Clone (); path.Flatten (); CompareFlats (path, clone); }
private void DrawText(PointF[] points, int maxPoints) { GraphicsPath gp = new GraphicsPath(_pathdata.Points, _pathdata.Types) { FillMode = FillMode.Winding }; gp.Flatten(); gp.Dispose(); Graphics g = _graphics; GraphicsContainer graphicsContainer = g.BeginContainer(); //g.TranslateTransform(_graphicsPath.GetBounds().X, _graphicsPath.GetBounds().Y); int count = 0; PointF point1 = default(PointF); int charStep = 0; double maxWidthText = default(double); int i; for (i = 0; i <= _text.Length - 1; i++) { maxWidthText += StringRegion(g, i); } switch (_pathalign) { case TextPathAlign.Left: point1 = points[0]; count = 0; break; case TextPathAlign.Center: count = (int)((maxPoints - maxWidthText) / 2); if (count > 0) { point1 = points[count]; } else { point1 = points[0]; } break; case TextPathAlign.Right: count = (int)(maxPoints - maxWidthText - (double)StringRegion(g, _text.Length - 1) * LetterSpacePercentage / 100); if (count > 0) { point1 = points[count]; } else { point1 = points[0]; } break; } while (!(charStep > _text.Length - 1)) { int lStrWidth = (int)(StringRegion(g, charStep) * LetterSpacePercentage / 100); if ((count + lStrWidth / 2) >= 0 & (count + lStrWidth) < maxPoints) { count += lStrWidth; PointF point2 = points[count]; PointF point = points[count - lStrWidth / 2]; double angle = GetAngle(point1, point2); DrawRotatedText(g, _text[charStep].ToString(), (float)angle, point); point1 = points[count]; } else { count += lStrWidth; } charStep += 1; } g.EndContainer(graphicsContainer); }