////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Reset the rectangle.
* @param ff_xmin
* @param ff_ymin
* @param ff_xmax
* @param ff_ymax
* @return
*/
public RectangleFP Reset(int ffXmin, int ffYmin, int ffXmax, int ffYmax)
{
_ffXmin = MathFP.Min(ffXmin, ffXmax);
_ffXmax = MathFP.Max(ffXmin, ffXmax);
_ffYmin = MathFP.Min(ffYmin, ffYmax);
_ffYmax = MathFP.Max(ffYmin, ffYmax);
return(this);
}
public virtual RectangleFP Union(PointFP p)
{
if (!IsEmpty())
{
Reset(MathFP.Min(ff_xmin, p.X), MathFP.Max(ff_xmax, p.X), MathFP.Min(ff_ymin, p.Y), MathFP.Max(ff_ymax, p.Y));
}
return(this);
}
public virtual RectangleFP Reset(int ff_xmin, int ff_ymin, int ff_xmax, int ff_ymax)
{
this.ff_xmin = MathFP.Min(ff_xmin, ff_xmax);
this.ff_xmax = MathFP.Max(ff_xmin, ff_xmax);
this.ff_ymin = MathFP.Min(ff_ymin, ff_ymax);
this.ff_ymax = MathFP.Max(ff_ymin, ff_ymax);
return(this);
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* return the union of the rectangle and the given point.
* @param p
* @return
*/
public RectangleFP Union(PointFP p)
{
if (!IsEmpty())
{
Reset(MathFP.Min(_ffXmin, p.X), MathFP.Max(_ffXmax, p.X),
MathFP.Min(_ffYmin, p.Y), MathFP.Max(_ffYmax, p.Y));
}
return(this);
}
public virtual RectangleFP Union(RectangleFP r)
{
if (!r.IsEmpty())
{
if (IsEmpty())
{
Reset(r);
}
else
{
Reset(MathFP.Min(ff_xmin, r.ff_xmin), MathFP.Max(ff_xmax, r.ff_xmax), MathFP.Min(ff_ymin, r.ff_ymin), MathFP.Max(ff_ymax, r.ff_ymax));
}
}
return(this);
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Calculate the union of the two rectangle.
* @param r
* @return
*/
public RectangleFP Union(RectangleFP r)
{
if (!r.IsEmpty())
{
if (IsEmpty())
{
Reset(r);
}
else
{
Reset(MathFP.Min(_ffXmin, r._ffXmin),
MathFP.Max(_ffXmax, r._ffXmax),
MathFP.Min(_ffYmin, r._ffYmin),
MathFP.Max(_ffYmax, r._ffYmax));
}
}
return(this);
}
public static GraphicsPathFP CreateRoundRect(int ff_xmin, int ff_ymin, int ff_xmax, int ff_ymax, int ff_rx, int ff_ry)
{
int ff_rmax;
int FF_PI = MathFP.PI;
GraphicsPathFP path = new GraphicsPathFP();
path.AddMoveTo(new PointFP(ff_xmin + ff_rx, ff_ymin));
path.AddLineTo(new PointFP(ff_xmax - ff_rx, ff_ymin));
ff_rmax = MathFP.Min(ff_xmax - ff_xmin, ff_ymax - ff_ymin) / 2;
if (ff_rx > ff_rmax)
{
ff_rx = ff_rmax;
}
if (ff_ry > ff_rmax)
{
ff_ry = ff_rmax;
}
if (ff_rx != 0 && ff_ry != 0)
{
path.AddPath(GraphicsPathFP.CreateArc(ff_xmax - ff_rx * 2, ff_ymin, ff_xmax, ff_ymin + ff_ry * 2, (-FF_PI) / 2, 0, false, false));
}
path.AddLineTo(new PointFP(ff_xmax, ff_ymin + ff_ry));
path.AddLineTo(new PointFP(ff_xmax, ff_ymax - ff_ry));
if (ff_rx != 0 && ff_ry != 0)
{
path.AddPath(GraphicsPathFP.CreateArc(ff_xmax - ff_rx * 2, ff_ymax - ff_ry * 2, ff_xmax, ff_ymax, 0, FF_PI / 2, false, false));
}
path.AddLineTo(new PointFP(ff_xmax - ff_rx, ff_ymax));
path.AddLineTo(new PointFP(ff_xmin + ff_rx, ff_ymax));
if (ff_rx != 0 && ff_ry != 0)
{
path.AddPath(GraphicsPathFP.CreateArc(ff_xmin, ff_ymax - ff_ry * 2, ff_xmin + ff_rx * 2, ff_ymax, FF_PI / 2, FF_PI, false, false));
}
path.AddLineTo(new PointFP(ff_xmin, ff_ymax - ff_ry));
path.AddLineTo(new PointFP(ff_xmin, ff_ymin + ff_ry));
if (ff_rx != 0 && ff_ry != 0)
{
path.AddPath(GraphicsPathFP.CreateArc(ff_xmin, ff_ymin, ff_xmin + ff_rx * 2, ff_ymin + ff_ry * 2, -FF_PI, (-FF_PI) / 2, false, false));
}
path.AddClose();
return(path);
}
public override void LineTo(PointFP point)
{
//PointFP a = new PointFP(CurrentPoint);
PointFP pntTemp = new PointFP(point);
ff_xmin = MathFP.Min(ff_xmin, CurrentPoint.X);
ff_xmax = MathFP.Max(ff_xmax, point.X);
ff_ymin = MathFP.Min(ff_ymin, CurrentPoint.Y);
ff_ymax = MathFP.Max(ff_ymax, point.Y);
if (transformMatrix != null)
{
pntTemp.Transform(transformMatrix);
//b.Transform(transformMatrix);
}
Scanline(transformedPoint.X, transformedPoint.Y, pntTemp.X, pntTemp.Y);
transformedPoint = pntTemp;
base.LineTo(point);
}
static public int Distance(int dx, int dy)
{
dx = MathFP.Abs(dx);
dy = MathFP.Abs(dy);
if (dx == 0)
{
return(dy);
}
else if (dy == 0)
{
return(dx);
}
long len = (((long)dx * dx) >> SingleFP.DecimalBits) + (((long)dy * dy) >> SingleFP.DecimalBits);
long s = (dx + dy) - (MathFP.Min(dx, dy) >> 1);
s = (s + ((len << SingleFP.DecimalBits) / s)) >> 1;
s = (s + ((len << SingleFP.DecimalBits) / s)) >> 1;
return((int)s);
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 13JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* calculate the distance.
* @param dx
* @param dy
* @return
*/
static public int Distance(int dx, int dy)
{
dx = MathFP.Abs(dx);
dy = MathFP.Abs(dy);
if (dx == 0)
{
return(dy);
}
if (dy == 0)
{
return(dx);
}
var len = (((long)dx * dx) >> SingleFP.DECIMAL_BITS)
+ (((long)dy * dy) >> SingleFP.DECIMAL_BITS);
long s = (dx + dy) - (MathFP.Min(dx, dy) >> 1);
s = (s + ((len << SingleFP.DECIMAL_BITS) / s)) >> 1;
s = (s + ((len << SingleFP.DECIMAL_BITS) / s)) >> 1;
return((int)s);
}
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));
}
