private static void DrawLinestring(Geometry.Linestring linestring, Geometry.Box box, Graphics graphics, Settings settings, Geometry.Traits traits)
{
LocalCS cs = new LocalCS(box, graphics);
Drawer drawer = new Drawer(graphics, settings.color);
if (traits.Unit == Geometry.Unit.None)
{
for (int i = 1; i < linestring.Count; ++i)
{
PointF p0 = cs.Convert(linestring[i - 1]);
PointF p1 = cs.Convert(linestring[i]);
drawer.DrawLine(p0, p1);
if (settings.showDir)
{
drawer.DrawDir(p0, p1);
}
}
}
else // Radian, Degree
{
Drawer.PeriodicDrawableRange pd = new Drawer.PeriodicDrawableRange(cs, linestring, false, traits.Unit, settings.densify);
Geometry.Interval interval = RelativeEnvelopeLon(linestring, false, traits.Unit);
drawer.DrawPeriodic(cs, box, interval, traits.Unit, pd, false, settings.showDir, settings.showDots);
}
}
// -------------------------------------------------
// Util
// -------------------------------------------------
private static Geometry.Interval RelativeEnvelopeLon(Geometry.IRandomAccessRange <Geometry.Point> points, bool closed, Geometry.Unit unit)
{
Geometry.Interval result = null;
if (points.Count < 1)
{
result = new Geometry.Interval();
Geometry.AssignInverse(result);
return(result);
}
double x0 = points[0][0];
result = new Geometry.Interval(x0);
int count = points.Count + (closed ? 1 : 0);
for (int ii = 1; ii < count; ++ii)
{
int i = ii % points.Count;
double xi = points[i][0];
double distNorm = Geometry.NormalizedAngleSigned(xi - x0, unit); // [-pi, pi]
double x1 = x0 + distNorm;
result.Expand(x1);
x0 = x1;
}
return(result);
}
public void Draw(Geometry.Box box, Graphics graphics, Settings settings, Geometry.Traits traits)
{
LocalCS cs = new LocalCS(box, graphics);
Drawer drawer = new Drawer(graphics, settings.color);
if (traits.Unit == Geometry.Unit.None)
{
PointF[] dst_points = cs.Convert(this);
if (dst_points != null)
{
drawer.FillPolygon(dst_points);
drawer.DrawPolygon(dst_points);
if (settings.showDir)
{
drawer.DrawDirs(dst_points, true);
drawer.DrawPoint(dst_points[0].X, dst_points[0].Y);
}
}
}
else
{
Drawer.PeriodicDrawableRange pd = new Drawer.PeriodicDrawableRange(cs, this, true, traits.Unit, settings.densify);
Geometry.Interval interval = RelativeEnvelopeLon(this, true, traits.Unit);
drawer.DrawPeriodic(cs, box, interval, traits.Unit, pd, true, settings.showDir, settings.showDots);
if (settings.showDir && this.Count > 0)
{
drawer.DrawPeriodicPoint(cs, this[0], box, traits.Unit, settings.showDots);
}
}
}
public static Geometry.Interval RelativeEnvelopeLon(Geometry.IRandomAccessRange <Geometry.Point> outer,
IEnumerable <Geometry.IRandomAccessRange <Geometry.Point> > inners,
Geometry.Unit unit)
{
Geometry.Interval result = RelativeEnvelopeLon(outer, true, unit);
foreach (var inner in inners)
{
result.Expand(RelativeEnvelopeLon(inner, true, unit));
}
return(result);
}
public void DrawPeriodic(LocalCS cs,
Geometry.Box box, Geometry.Interval interval, Geometry.Unit unit,
IPeriodicDrawable drawer,
bool fill, bool drawDirs, bool drawDots)
{
double twoPi = Geometry.FullAngle(unit);
float periodf = cs.ConvertDimensionX(twoPi);
float box_minf = cs.ConvertX(box.Min[0]);
float box_maxf = cs.ConvertX(box.Max[0]);
float minf = cs.ConvertX(interval.Min);
float maxf = cs.ConvertX(interval.Max);
if (maxf >= box_minf && minf <= box_maxf)
{
drawer.DrawOne(this, 0, fill, drawDirs, drawDots);
}
// west
float minf_i = minf;
float maxf_i = maxf;
float translationf = 0;
while (maxf_i >= box_minf &&
Util.Assign(ref maxf_i, maxf_i - periodf))
{
translationf -= periodf;
minf_i -= periodf;
//maxf_i -= periodf; // subtracted above
if (maxf_i >= box_minf && minf_i <= box_maxf)
{
drawer.DrawOne(this, translationf, fill, drawDirs, drawDots);
}
}
// east
minf_i = minf;
maxf_i = maxf;
translationf = 0;
while (minf_i <= box_maxf &&
Util.Assign(ref minf_i, minf_i + periodf))
{
translationf += periodf;
//minf_i += periodf; // added above
maxf_i += periodf;
if (maxf_i >= box_minf && minf_i <= box_maxf)
{
drawer.DrawOne(this, translationf, fill, drawDirs, drawDots);
}
}
}
public void DrawPeriodic(LocalCS cs,
Geometry.Box box, Geometry.Interval interval, Geometry.Unit unit,
IPeriodicDrawable drawer,
bool fill, bool drawDirs, bool drawDots)
{
double pi = Geometry.HalfAngle(unit);
float periodf = cs.ConvertDimensionX(2 * pi);
float box_minf = cs.ConvertX(box.Min[0]);
float box_maxf = cs.ConvertX(box.Max[0]);
float minf = cs.ConvertX(interval.Min);
float maxf = cs.ConvertX(interval.Max);
if (maxf >= box_minf && minf <= box_maxf)
{
drawer.DrawOne(this, 0, fill, drawDirs, drawDots);
}
// west
float minf_i = minf;
float maxf_i = maxf;
float translationf = 0;
while (maxf_i >= box_minf)
{
translationf -= periodf;
minf_i -= periodf;
maxf_i -= periodf;
if (maxf_i >= box_minf && minf_i <= box_maxf)
{
drawer.DrawOne(this, translationf, fill, drawDirs, drawDots);
}
}
// east
minf_i = minf;
maxf_i = maxf;
translationf = 0;
while (minf_i <= box_maxf)
{
translationf += periodf;
minf_i += periodf;
maxf_i += periodf;
if (maxf_i >= box_minf && minf_i <= box_maxf)
{
drawer.DrawOne(this, translationf, fill, drawDirs, drawDots);
}
}
}
public void Draw(Geometry.Box box, Graphics graphics, Settings settings, Geometry.Traits traits)
{
LocalCS cs = new LocalCS(box, graphics);
Drawer drawer = new Drawer(graphics, settings.color);
float rx = cs.ConvertDimensionX(Radius);
float ry = cs.ConvertDimensionY(Radius);
if (rx < 0 || ry < 0)
{
return;
}
if (traits.Unit == Geometry.Unit.None)
{
PointF c = cs.Convert(Center);
if (rx == 0 || ry == 0)
{
drawer.DrawPoint(c.X, c.Y);
}
else
{
float x = c.X - rx;
float y = c.Y - ry;
float w = rx * 2;
float h = ry * 2;
drawer.DrawEllipse(x, y, w, h);
drawer.FillEllipse(x, y, w, h);
}
}
else // Radian, Degree
{
if (rx == 0 || ry == 0)
{
drawer.DrawPeriodicPoint(cs, Center, box, traits.Unit, settings.showDots);
}
else
{
Drawer.PeriodicDrawableNSphere pd = new Drawer.PeriodicDrawableNSphere(cs, this, traits.Unit);
Geometry.Interval interval = RelativeEnvelopeLon(this, traits.Unit);
drawer.DrawPeriodic(cs, box, interval, traits.Unit, pd, true, false, settings.showDots);
}
}
}
public void Draw(Geometry.Box box, Graphics graphics, Settings settings, Geometry.Traits traits)
{
LocalCS cs = new LocalCS(box, graphics);
Drawer drawer = new Drawer(graphics, settings.color);
if (traits.Unit == Geometry.Unit.None)
{
PointF p0 = cs.Convert(this[0]);
PointF p1 = cs.Convert(this[1]);
drawer.DrawLine(p0, p1);
if (settings.showDir)
{
drawer.DrawDir(p0, p1);
}
}
else // Radian, Degree
{
Drawer.PeriodicDrawableRange pd = new Drawer.PeriodicDrawableRange(cs, this, false, traits.Unit, settings.densify);
Geometry.Interval interval = RelativeEnvelopeLon(this, false, traits.Unit);
drawer.DrawPeriodic(cs, box, interval, traits.Unit, pd, false, settings.showDir, settings.showDots);
}
}
private static void DrawPolygon(Geometry.Polygon polygon, Geometry.Box box, Graphics graphics, Settings settings, Geometry.Traits traits)
{
LocalCS cs = new LocalCS(box, graphics);
Drawer drawer = new Drawer(graphics, settings.color);
if (traits.Unit == Geometry.Unit.None)
{
PointF[] dst_outer_points = cs.Convert(polygon.Outer);
if (dst_outer_points != null)
{
GraphicsPath gp = new GraphicsPath();
gp.AddPolygon(dst_outer_points);
if (settings.showDir)
{
drawer.DrawDirs(dst_outer_points, true);
drawer.DrawPoint(dst_outer_points[0]);
}
foreach (Ring inner in polygon.Inners)
{
PointF[] dst_inner_points = cs.Convert(inner);
if (dst_inner_points != null)
{
gp.AddPolygon(dst_inner_points);
if (settings.showDir)
{
drawer.DrawDirs(dst_inner_points, true);
drawer.DrawPoint(dst_inner_points[0]);
}
}
}
drawer.FillPath(gp);
drawer.DrawPath(gp);
}
}
else
{
Drawer.PeriodicDrawablePolygon pd = new Drawer.PeriodicDrawablePolygon(cs, polygon.Outer, polygon.Inners, traits.Unit, settings.densify);
Geometry.Interval interval = RelativeEnvelopeLon(polygon.Outer, polygon.Inners, traits.Unit);
drawer.DrawPeriodic(cs, box, interval, traits.Unit, pd, true, settings.showDir, settings.showDots);
if (settings.showDir)
{
if (settings.showDir && polygon.Outer.Count > 0)
{
drawer.DrawPeriodicPoint(cs, polygon.Outer[0], box, traits.Unit, settings.showDots);
}
foreach (Ring inner in polygon.Inners)
{
if (inner.Count > 0)
{
drawer.DrawPeriodicPoint(cs, inner[0], box, traits.Unit, settings.showDots);
}
}
}
}
}
public void Draw(Geometry.Box box, Graphics graphics, Settings settings, Geometry.Traits traits)
{
LocalCS cs = new LocalCS(box, graphics);
Drawer drawer = new Drawer(graphics, settings.color);
double width = Dim(0);
double height = Dim(1);
float rw = cs.ConvertDimensionX(Math.Abs(width));
float rh = cs.ConvertDimensionY(Math.Abs(height));
if (traits.Unit == Geometry.Unit.None)
{
float rx = cs.ConvertX(Math.Min(Min[0], Max[0]));
float ry = cs.ConvertY(Math.Max(Min[1], Max[1]));
if (rw == 0 && rh == 0)
{
drawer.DrawPoint(rx, ry);
}
else if (rw == 0 || rh == 0)
{
drawer.DrawLine(rx, ry, rx + rw, ry + rh);
}
else
{
drawer.DrawRectangle(rx, ry, rw, rh);
bool isInvalid = width < 0 || height < 0;
if (!isInvalid)
{
drawer.FillRectangle(rx, ry, rw, rh);
}
else
{
drawer.DrawLine(rx, ry, rx + rw, ry + rh);
drawer.DrawLine(rx + rw, ry, rx, ry + rh);
}
}
}
else // Radian, Degree
{
if (rw == 0 && rh == 0)
{
drawer.DrawPeriodicPoint(cs, Min, box, traits.Unit, settings.showDots);
}
else if (rw == 0 || rh == 0)
{
Geometry.Segment seg = new Geometry.Segment(Min, Max);
Drawer.PeriodicDrawableBox pd = new Drawer.PeriodicDrawableBox(cs, seg, traits.Unit);
Geometry.Interval interval = RelativeEnvelopeLon(seg, false, traits.Unit);
drawer.DrawPeriodic(cs, box, interval, traits.Unit, pd, false, false, settings.showDots);
}
else
{
Geometry.Ring ring = new Geometry.Ring();
ring.Add(new Geometry.Point(Min[0], Min[1]));
ring.Add(new Geometry.Point(Max[0], Min[1]));
ring.Add(new Geometry.Point(Max[0], Max[1]));
ring.Add(new Geometry.Point(Min[0], Max[1]));
Drawer.PeriodicDrawableBox pd = new Drawer.PeriodicDrawableBox(cs, ring, traits.Unit);
Geometry.Interval interval = RelativeEnvelopeLon(ring, true, traits.Unit);
drawer.DrawPeriodic(cs, box, interval, traits.Unit, pd, true, false, settings.showDots);
}
}
}
