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);
}
