private void AddLineCap(PointFP p1, PointFP p2, int lineCap) { if (lineCap == PenFP.LINECAP_BUTT || p1.Equals(p2)) { return; } int dx = p2.X - p1.X; int dy = p2.Y - p1.Y; int len = PointFP.Distance(dx, dy); PointFP[] cap = lineCap == PenFP.LINECAP_ROUND?GraphicsPathFP.roundCap:GraphicsPathFP.squareCap; dx = MathFP.Mul(ff_rad, MathFP.Div(dx, len)); dy = MathFP.Mul(ff_rad, MathFP.Div(dy, len)); MatrixFP m = new MatrixFP(dx, dx, dy, -dy, p2.X, p2.Y); outline.AddMoveTo(new PointFP(0, GraphicsPathFP.One).Transform(m)); for (int i = 0; i < cap.Length; i++) { outline.AddLineTo(new PointFP(cap[i]).Transform(m)); } outline.AddLineTo(new PointFP(0, -GraphicsPathFP.One).Transform(m)); outline.AddClose(); }
//////////////////////////////////////////////////////////////////////////// //--------------------------------- REVISIONS ------------------------------ // Date Name Tracking # Description // --------- ------------------- ------------- ---------------------- // 13JUN2009 James Shen Initial Creation //////////////////////////////////////////////////////////////////////////// /** * Scale operation. * @param ff_sx * @param ff_sy * @return */ public MatrixFP Scale(int ffSx, int ffSy) { Reset(MathFP.Mul(ffSx, ScaleX), MathFP.Mul(ffSy, ScaleY), MathFP.Mul(ffSy, RotateX), MathFP.Mul(ffSx, RotateY), MathFP.Mul(ffSx, TranslateX), MathFP.Mul(ffSy, TranslateY)); return(this); }
private void AddLineCap(PointFP p1, PointFP p2, int lineCap) { if (lineCap == PenFP.LINECAP_BUTT || p1.Equals(p2)) { return; } var dx = p2.X - p1.X; var dy = p2.Y - p1.Y; var len = PointFP.Distance(dx, dy); var cap = lineCap == PenFP.LINECAP_ROUND ? GraphicsPathFP.ROUNDCAP : GraphicsPathFP.SQUARECAP; dx = MathFP.Mul(_ffRad, MathFP.Div(dx, len)); dy = MathFP.Mul(_ffRad, MathFP.Div(dy, len)); var m = new MatrixFP(dx, dx, dy, -dy, p2.X, p2.Y); _outline.AddMoveTo(new PointFP(0, GraphicsPathFP.ONE).Transform(m)); for (var i = 0; i < cap.Length; i++) { _outline.AddLineTo(new PointFP(cap[i]).Transform(m)); } _outline.AddLineTo(new PointFP(0, -GraphicsPathFP.ONE).Transform(m)); _outline.AddClose(); }
public LineFP GetHeadOutline(int ff_rad) { PointFP p = new PointFP(P1.X - P2.X, P1.Y - P2.Y); int len = Length; p.Reset(MathFP.Div(-p.Y, len), MathFP.Div(p.X, len)); p.Reset(MathFP.Mul(p.X, ff_rad), MathFP.Mul(p.Y, ff_rad)); return(new LineFP(P1.X - p.X, P1.Y - p.Y, P1.X + p.X, P1.Y + p.Y)); }
//////////////////////////////////////////////////////////////////////////// //--------------------------------- REVISIONS ------------------------------ // Date Name Tracking # Description // --------- ------------------- ------------- ---------------------- // 13JUN2009 James Shen Initial Creation //////////////////////////////////////////////////////////////////////////// /** * Get the head outline. * @param ff_rad * @return */ public LineFP GetHeadOutline(int ffRad) { var p = new PointFP(Pt1.X - Pt2.X, Pt1.Y - Pt2.Y); var len = GetLength(); p.Reset(MathFP.Div(-p.Y, len), MathFP.Div(p.X, len)); p.Reset(MathFP.Mul(p.X, ffRad), MathFP.Mul(p.Y, ffRad)); return(new LineFP(Pt1.X - p.X, Pt1.Y - p.Y, Pt1.X + p.X, Pt1.Y + p.Y)); }
//////////////////////////////////////////////////////////////////////////// //--------------------------------- REVISIONS ------------------------------ // Date Name Tracking # Description // --------- ------------------- ------------- ---------------------- // 13JUN2009 James Shen Initial Creation //////////////////////////////////////////////////////////////////////////// /** * multipy with another matrix. * @param m * @return */ public MatrixFP Multiply(MatrixFP m) { Reset(MathFP.Mul(m.ScaleX, ScaleX) + MathFP.Mul(m.RotateY, RotateX), MathFP.Mul(m.RotateX, RotateY) + MathFP.Mul(m.ScaleY, ScaleY), MathFP.Mul(m.RotateX, ScaleX) + MathFP.Mul(m.ScaleY, RotateX), MathFP.Mul(m.ScaleX, RotateY) + MathFP.Mul(m.RotateY, ScaleY), MathFP.Mul(m.ScaleX, TranslateX) + MathFP.Mul(m.RotateY, TranslateY) + m.TranslateX, MathFP.Mul(m.RotateX, TranslateX) + MathFP.Mul(m.ScaleY, TranslateY) + m.TranslateY); return(this); }
public LineFP GetTailOutline(int ff_rad) { PointFP c = Center; PointFP p = new PointFP(P2.X - c.X, P2.Y - c.Y); p.Reset(p.Y, -p.X); int dis = PointFP.Distance(PointFP.Origin, p); if (dis == 0) { dis = 1; } p.Reset(MathFP.Div(MathFP.Mul(p.X, ff_rad), dis), MathFP.Div(MathFP.Mul(p.Y, ff_rad), dis)); return(new LineFP(P2.X - p.X, P2.Y - p.Y, P2.X + p.X, P2.Y + p.Y)); }
//////////////////////////////////////////////////////////////////////////// //--------------------------------- REVISIONS ------------------------------ // Date Name Tracking # Description // --------- ------------------- ------------- ---------------------- // 13JUN2009 James Shen Initial Creation //////////////////////////////////////////////////////////////////////////// /** * get the tail outline. * @param ff_rad * @return */ public LineFP GetTailOutline(int ffRad) { var c = GetCenter(); var p = new PointFP(Pt2.X - c.X, Pt2.Y - c.Y); p.Reset(p.Y, -p.X); var dis = PointFP.Distance(PointFP.Origin, p); if (dis == 0) { dis = 1; } p.Reset(MathFP.Div(MathFP.Mul(p.X, ffRad), dis), MathFP.Div(MathFP.Mul(p.Y, ffRad), dis)); return(new LineFP(Pt2.X - p.X, Pt2.Y - p.Y, Pt2.X + p.X, Pt2.Y + p.Y)); }
//////////////////////////////////////////////////////////////////////////// //--------------------------------- REVISIONS ------------------------------ // Date Name Tracking # Description // --------- ------------------- ------------- ---------------------- // 13JUN2009 James Shen Initial Creation //////////////////////////////////////////////////////////////////////////// /** * * @param distance * @return */ internal PointFP GetPointAtDistance(int distance) { var lineLength = GetLength(); if (distance > lineLength) { return(null); } if (distance == lineLength) { return(new PointFP(Pt2)); } var scale = MathFP.Div(distance, lineLength); var pointFP = new PointFP(); pointFP.Reset(Pt1.X + MathFP.Mul(Pt2.X - Pt1.X, scale), Pt1.Y + MathFP.Mul(Pt2.Y - Pt1.Y, scale)); return(pointFP); }
public GradientBrushFP(int ff_xmin, int ff_ymin, int ff_xmax, int ff_ymax, int ff_angle, int type) { bounds.Reset(ff_xmin, ff_ymin, ff_xmax == ff_xmin ? ff_xmin + 1 : ff_xmax, ff_ymax == ff_ymin ? ff_ymin + 1 : ff_ymax); matrix = new MatrixFP(); matrix.Translate(-(ff_xmin + ff_xmax) / 2, -(ff_ymin + ff_ymax) / 2); matrix.Rotate(-ff_angle); this.type = type; if (type == RADIAL_GRADIENT) { matrix.Scale(MathFP.Div(SingleFP.One, bounds.Width), MathFP.Div(SingleFP.One, bounds.Height)); } int ff_ang = MathFP.Atan(MathFP.Div(bounds.Height, bounds.Width == 0 ? 1 : bounds.Width)); int ff_len = PointFP.Distance(bounds.Height, bounds.Width); ff_length = MathFP.Mul(ff_len, MathFP.Max( MathFP.Abs(MathFP.Cos(ff_angle - ff_ang)), MathFP.Abs(MathFP.Cos(ff_angle + ff_ang)))); }
//////////////////////////////////////////////////////////////////////////// //--------------------------------- REVISIONS ------------------------------ // Date Name Tracking # Description // --------- ------------------- ------------- ---------------------- // 13JUN2009 James Shen Initial Creation //////////////////////////////////////////////////////////////////////////// /** * invert the matrix. * @return */ public MatrixFP Invert() { int ffDet = Determinant(); if (ffDet == 0) { Reset(); } else { var ffSxNew = MathFP.Div(ScaleY, ffDet); var ffSyNew = MathFP.Div(ScaleX, ffDet); var ffRxNew = -MathFP.Div(RotateX, ffDet); var ffRyNew = -MathFP.Div(RotateY, ffDet); var ffTxNew = MathFP.Div(MathFP.Mul(TranslateY, RotateY) - MathFP.Mul(TranslateX, ScaleY), ffDet); var ffTyNew = -MathFP.Div(MathFP.Mul(TranslateY, ScaleX) - MathFP.Mul(TranslateX, RotateX), ffDet); Reset(ffSxNew, ffSyNew, ffRxNew, ffRyNew, ffTxNew, ffTyNew); } return(this); }
//////////////////////////////////////////////////////////////////////////// //--------------------------------- REVISIONS ------------------------------ // Date Name Tracking # Description // --------- ------------------- ------------- ---------------------- // 13JUN2009 James Shen Initial Creation //////////////////////////////////////////////////////////////////////////// /** * transform the point with give matrix. * @param m * @return */ public PointFP Transform(MatrixFP m) { Reset(MathFP.Mul(X, m.ScaleX) + MathFP.Mul(Y, m.RotateY) + m.TranslateX, MathFP.Mul(Y, m.ScaleY) + MathFP.Mul(X, m.RotateX) + m.TranslateY); return(this); }
public static bool Intersects(LineFP l1, LineFP l2, PointFP intersection) { int x = SingleFP.NaN; int y = SingleFP.NaN; if (intersection != null) { intersection.Reset(x, y); } int ax0 = l1.P1.X; int ax1 = l1.P2.X; int ay0 = l1.P1.Y; int ay1 = l1.P2.Y; int bx0 = l2.P1.X; int bx1 = l2.P2.X; int by0 = l2.P1.Y; int by1 = l2.P2.Y; int adx = (ax1 - ax0); int ady = (ay1 - ay0); int bdx = (bx1 - bx0); int bdy = (by1 - by0); if (IsZero(adx) && IsZero(bdx)) { return(IsEqual(ax0, bx0)); } else if (IsZero(ady) && IsZero(bdy)) { return(IsEqual(ay0, by0)); } else if (IsZero(adx)) { // A vertical x = ax0; y = IsZero(bdy)?by0:MathFP.Mul(MathFP.Div(bdy, bdx), x - bx0) + by0; } else if (IsZero(bdx)) { // B vertical x = bx0; y = IsZero(ady)?ay0:MathFP.Mul(MathFP.Div(ady, adx), x - ax0) + ay0; } else if (IsZero(ady)) { y = ay0; x = MathFP.Mul(MathFP.Div(bdx, bdy), y - by0) + bx0; } else if (IsZero(bdy)) { y = by0; x = MathFP.Mul(MathFP.Div(adx, ady), y - ay0) + ax0; } else { int xma = MathFP.Div(ady, adx); // slope segment A int xba = ay0 - (MathFP.Mul(ax0, xma)); // y intercept of segment A int xmb = MathFP.Div(bdy, bdx); // slope segment B int xbb = by0 - (MathFP.Mul(bx0, xmb)); // y intercept of segment B // parallel lines? if (xma == xmb) { // Need trig functions return(xba == xbb); } else { // Calculate points of intersection // At the intersection of line segment A and B, XA=XB=XINT and YA=YB=YINT x = MathFP.Div((xbb - xba), (xma - xmb)); y = (MathFP.Mul(xma, x)) + xba; } } // After the point or points of intersection are calculated, each // solution must be checked to ensure that the point of intersection lies // on line segment A and B. int minxa = MathFP.Min(ax0, ax1); int maxxa = MathFP.Max(ax0, ax1); int minya = MathFP.Min(ay0, ay1); int maxya = MathFP.Max(ay0, ay1); int minxb = MathFP.Min(bx0, bx1); int maxxb = MathFP.Max(bx0, bx1); int minyb = MathFP.Min(by0, by1); int maxyb = MathFP.Max(by0, by1); if (intersection != null) { intersection.Reset(x, y); } return((x >= minxa) && (x <= maxxa) && (y >= minya) && (y <= maxya) && (x >= minxb) && (x <= maxxb) && (y >= minyb) && (y <= maxyb)); }
public virtual PointFP Transform(MatrixFP m) { Reset(MathFP.Mul(X, m.Sx) + MathFP.Mul(Y, m.Ry) + m.Tx, MathFP.Mul(Y, m.Sy) + MathFP.Mul(X, m.Rx) + m.Ty); return(this); }
public static PointFP CalcControlPoint(PointFP p1, PointFP p2, PointFP p3, int ff_factor) { PointFP ps = new PointFP(p2.X + MathFP.Mul(p2.X - p1.X, ff_factor), p2.Y + MathFP.Mul(p2.Y - p1.Y, ff_factor)); return(new LineFP(new LineFP(p2, ps).Center, new LineFP(p2, p3).Center).Center); }
public static GraphicsPathFP CreateArc(int ff_xmin, int ff_ymin, int ff_xmax, int ff_ymax, int ff_startangle, int ff_sweepangle, bool closed, bool standalone) { if (ff_sweepangle < 0) { ff_startangle += ff_sweepangle; ff_sweepangle = -ff_sweepangle; } int segments = MathFP.Round(MathFP.Div(4 * MathFP.Abs(ff_sweepangle), MathFP.PI)) >> SingleFP.DecimalBits; if (segments == 0) { segments = 1; } GraphicsPathFP path = new GraphicsPathFP(); int ff_darg = ff_sweepangle / segments; int ff_arg = ff_startangle; int ff_lastcos = MathFP.Cos(ff_startangle); int ff_lastsin = MathFP.Sin(ff_startangle); int ff_xc = (ff_xmin + ff_xmax) / 2; int ff_yc = (ff_ymin + ff_ymax) / 2; int ff_rx = (ff_xmax - ff_xmin) / 2; int ff_ry = (ff_ymax - ff_ymin) / 2; int ff_RXBETA = MathFP.Mul(17381, ff_rx); int ff_RYBETA = MathFP.Mul(17381, ff_ry); int ff_currcos, ff_currsin, ff_x1, ff_y1, ff_x2, ff_y2; if (closed) { path.AddMoveTo(new PointFP(ff_xc, ff_yc)); } for (int i = 1; i <= segments; i++) { ff_arg = i == segments?ff_startangle + ff_sweepangle:ff_arg + ff_darg; ff_currcos = MathFP.Cos(ff_arg); ff_currsin = MathFP.Sin(ff_arg); ff_x1 = ff_xc + MathFP.Mul(ff_rx, ff_lastcos); ff_y1 = ff_yc + MathFP.Mul(ff_ry, ff_lastsin); ff_x2 = ff_xc + MathFP.Mul(ff_rx, ff_currcos); ff_y2 = ff_yc + MathFP.Mul(ff_ry, ff_currsin); if (i == 1) { if (closed) { path.AddLineTo(new PointFP(ff_x1, ff_y1)); } else if (standalone) { path.AddMoveTo(new PointFP(ff_x1, ff_y1)); } } path.AddCurveTo( new PointFP(ff_x1 - MathFP.Mul(ff_RXBETA, ff_lastsin), ff_y1 + MathFP.Mul(ff_RYBETA, ff_lastcos)), new PointFP(ff_x2 + MathFP.Mul(ff_RXBETA, ff_currsin), ff_y2 - MathFP.Mul(ff_RYBETA, ff_currcos)), new PointFP(ff_x2, ff_y2)); ff_lastcos = ff_currcos; ff_lastsin = ff_currsin; } if (closed) { path.AddClose(); } return(path); }
//////////////////////////////////////////////////////////////////////////// //--------------------------------- REVISIONS ------------------------------ // Date Name Tracking # Description // --------- ------------------- ------------- ---------------------- // 13JUN2009 James Shen Initial Creation //////////////////////////////////////////////////////////////////////////// /** * calculat the determinat of the matrix. * @return */ private int Determinant() { var ffDet = MathFP.Mul(ScaleX, ScaleY) - MathFP.Mul(RotateX, RotateY); return(ffDet); }