public static Geometry GridPoints(Geometry g, int nCells)
{
var env = FunctionsUtil.GetEnvelopeOrDefault(g);
var geomFact = FunctionsUtil.GetFactoryOrDefault(g);
int nCellsOnSideY = (int)Math.Sqrt(nCells);
int nCellsOnSideX = nCells / nCellsOnSideY;
double cellSizeX = env.Width / (nCellsOnSideX - 1);
double cellSizeY = env.Height / (nCellsOnSideY - 1);
var pts = new CoordinateList();
for (int i = 0; i < nCellsOnSideX; i++)
{
for (int j = 0; j < nCellsOnSideY; j++)
{
double x = env.MinX + i * cellSizeX;
double y = env.MinY + j * cellSizeY;
pts.Add(new Coordinate(x, y));
}
}
return(geomFact.CreateMultiPointFromCoords(pts.ToCoordinateArray()));
}
public static Geometry ToPoints(Geometry g1, Geometry g2)
{
var geoms = FunctionsUtil.BuildGeometry(g1, g2);
return(FunctionsUtil.GetFactoryOrDefault(new[] { g1, g2 })
.CreateMultiPointFromCoords(geoms.Coordinates));
}
private static IGeometry CreateJ(IGeometry g)
{
var gf = FunctionsUtil.GetFactoryOrDefault(g);
var jTop = new Coordinate[]
{
new Coordinate(0, HEIGHT),
new Coordinate(J_WIDTH, HEIGHT),
new Coordinate(J_WIDTH, J_RADIUS)
};
var jBottom = new Coordinate[]
{
new Coordinate(J_WIDTH - J_RADIUS, 0),
new Coordinate(0, 0)
};
var gsf = new GeometricShapeFactory(gf);
gsf.Base = new Coordinate(J_WIDTH - 2 * J_RADIUS, 0);
gsf.Size = 2 * J_RADIUS;
gsf.NumPoints = 10;
var jArc = gsf.CreateArc(1.5 * Math.PI, 0.5 * Math.PI);
var coordList = new CoordinateList();
coordList.Add(jTop, false);
coordList.Add(((IGeometry)jArc).Reverse().Coordinates, false, 1, jArc.NumPoints - 1);
coordList.Add(jBottom, false);
return(gf.CreateLineString(coordList.ToCoordinateArray()));
}
public static IGeometry Grid(IGeometry g, int nCells)
{
var geoms = new List <IGeometry>();
var env = FunctionsUtil.GetEnvelopeOrDefault(g);
var geomFact = FunctionsUtil.GetFactoryOrDefault(g);
var nCellsOnSide = (int)Math.Sqrt(nCells) + 1;
var cellSizeX = env.Width / nCellsOnSide;
var cellSizeY = env.Height / nCellsOnSide;
for (var i = 0; i < nCellsOnSide; i++)
{
for (var j = 0; j < nCellsOnSide; j++)
{
var x1 = env.MinX + i * cellSizeX;
var y1 = env.MinY + j * cellSizeY;
var x2 = env.MinX + (i + 1) * cellSizeX;
var y2 = env.MinY + (j + 1) * cellSizeY;
var cellEnv = new Envelope(x1, x2, y1, y2);
geoms.Add(geomFact.ToGeometry(cellEnv));
}
}
return(geomFact.BuildGeometry(geoms));
}
public static IGeometry RandomSegmentsInGrid(IGeometry g, int nPts)
{
var env = FunctionsUtil.GetEnvelopeOrDefault(g);
var geomFact = FunctionsUtil.GetFactoryOrDefault(g);
int nCell = (int)Math.Sqrt(nPts) + 1;
double xLen = env.Width / nCell;
double yLen = env.Height / nCell;
var lines = new List <IGeometry>();
for (int i = 0; i < nCell; i++)
{
for (int j = 0; j < nCell; j++)
{
double x0 = env.MinX + i * xLen + xLen * RND.NextDouble();
double y0 = env.MinY + j * yLen + yLen * RND.NextDouble();
double x1 = env.MinX + i * xLen + xLen * RND.NextDouble();
double y1 = env.MinY + j * yLen + yLen * RND.NextDouble();
lines.Add(geomFact.CreateLineString(new[]
{
new Coordinate(x0, y0), new Coordinate(x1, y1)
}));
}
}
return(geomFact.BuildGeometry(lines));
}
public static Geometry ToLines(Geometry g1, Geometry g2)
{
var geoms = FunctionsUtil.BuildGeometry(g1, g2);
return(FunctionsUtil.GetFactoryOrDefault(new[] { g1, g2 })
.BuildGeometry(LinearComponentExtracter.GetLines(geoms)));
}
public static IGeometry RandomRadialPoints(IGeometry g, int nPts)
{
var env = FunctionsUtil.GetEnvelopeOrDefault(g);
var geomFact = FunctionsUtil.GetFactoryOrDefault(g);
double xLen = env.Width;
double yLen = env.Height;
double rMax = Math.Min(xLen, yLen) / 2.0;
double centreX = env.MinX + xLen / 2;
double centreY = env.MinY + yLen / 2;
var pts = new List <IPoint>();
for (int i = 0; i < nPts; i++)
{
double rand = RND.NextDouble();
//use rand^2 to accentuate radial distribution
double r = rMax * rand * rand;
double ang = 2 * Math.PI * RND.NextDouble();
double x = centreX + r * Math.Cos(ang);
double y = centreY + r * Math.Sin(ang);
pts.Add(geomFact.CreatePoint(new Coordinate(x, y)));
}
return(geomFact.BuildGeometry(pts.ToArray()));
}
public static IGeometry Circumcentre(IGeometry g)
{
Coordinate[] pts = TrianglePts(g);
Coordinate cc = Triangle.Circumcentre(pts[0], pts[1], pts[2]);
IGeometryFactory geomFact = FunctionsUtil.GetFactoryOrDefault(g);
return(geomFact.CreatePoint(cc));
}
public static Geometry Circumcentre(Geometry g)
{
var pts = TrianglePts(g);
var cc = Triangle.Circumcentre(pts[0], pts[1], pts[2]);
var geomFact = FunctionsUtil.GetFactoryOrDefault(g);
return(geomFact.CreatePoint(cc));
}
public static IGeometry Incentre(IGeometry g)
{
var pts = TrianglePts(g);
var t = new Triangle(pts[0], pts[1], pts[2]);
var cc = t.InCentre();
var geomFact = FunctionsUtil.GetFactoryOrDefault(g);
return(geomFact.CreatePoint(cc));
}
public static Geometry Centroid(Geometry g)
{
return(GeometryMapper.Map(g, itm =>
{
var pts = TrianglePts(itm);
var cc = Triangle.Centroid(pts[0], pts[1], pts[2]);
var geomFact = FunctionsUtil.GetFactoryOrDefault(g);
return geomFact.CreatePoint(cc);
}));
}
public static Geometry FindInteriorNodes(Geometry geom)
{
var intFinder = NodingIntersectionFinder.CreateInteriorIntersectionsFinder(new RobustLineIntersector());
ProcessNodes(geom, intFinder);
var intPts = intFinder.Intersections;
return(FunctionsUtil.GetFactoryOrDefault((Geometry)null)
.CreateMultiPointFromCoords(Dedup(intPts)));
}
public static Geometry AngleBisectors(Geometry g)
{
var pts = TrianglePts(g);
var cc = Triangle.InCentre(pts[0], pts[1], pts[2]);
var geomFact = FunctionsUtil.GetFactoryOrDefault(g);
var line = new LineString[3];
line[0] = geomFact.CreateLineString(new Coordinate[] { pts[0], cc });
line[1] = geomFact.CreateLineString(new Coordinate[] { pts[1], cc });
line[2] = geomFact.CreateLineString(new Coordinate[] { pts[2], cc });
return(geomFact.CreateMultiLineString(line));
}
public static Geometry FindOneNode(Geometry geom)
{
var nv = new FastNodingValidator(SegmentStringUtil.ExtractNodedSegmentStrings(geom));
bool temp = nv.IsValid;
var intPts = nv.Intersections;
if (intPts.Count == 0)
{
return(null);
}
return(FunctionsUtil.GetFactoryOrDefault((Geometry)null).CreatePoint((Coordinate)intPts[0]));
}
private static IGeometry FromSegmentStrings(IList <ISegmentString> segStrings)
{
var lines = new ILineString[segStrings.Count];
int index = 0;
foreach (var ss in segStrings)
{
var line = FunctionsUtil.GetFactoryOrDefault(null).CreateLineString(ss.Coordinates);
lines[index++] = line;
}
return(FunctionsUtil.GetFactoryOrDefault(null).CreateMultiLineString(lines));
}
public static IGeometry AngleBisectors(IGeometry g)
{
Coordinate[] pts = TrianglePts(g);
Triangle t = new Triangle(pts[0], pts[1], pts[2]);
Coordinate cc = t.InCentre();
IGeometryFactory geomFact = FunctionsUtil.GetFactoryOrDefault(g);
ILineString[] line = new ILineString[3];
line[0] = geomFact.CreateLineString(new[] { pts[0], cc });
line[1] = geomFact.CreateLineString(new[] { pts[1], cc });
line[2] = geomFact.CreateLineString(new[] { pts[2], cc });
return(geomFact.CreateMultiLineString(line));
}
/// <summary>
/// Reduces precision pointwise, then snap-rounds.
/// Note that output set may not contain non-unique linework
/// (and thus cannot be used as input to Polygonizer directly).
/// UnaryUnion is one way to make the linework unique.
/// </summary>
/// <param name="geom">A geometry containing linework to node</param>
/// <param name="scaleFactor">the precision model scale factor to use</param>
/// <returns>The noded, snap-rounded linework</returns>
public static Geometry SnapRoundWithPointwisePrecisionReduction(Geometry geom, double scaleFactor)
{
var pm = new PrecisionModel(scaleFactor);
var roundedGeom = GeometryPrecisionReducer.ReducePointwise(geom, pm);
var geomList = new List <Geometry>();
geomList.Add(roundedGeom);
var noder = new GeometryNoder(pm);
var lines = noder.Node(geomList);
return(FunctionsUtil.GetFactoryOrDefault(geom).BuildGeometry(lines.Cast <Geometry>().ToArray()));
}
public static IGeometry ComponentBuffers(IGeometry g, double distance)
{
var bufs = new List <IGeometry>();
foreach (var comp in new GeometryCollectionEnumerator((IGeometryCollection)g))
{
if (comp is IGeometryCollection)
{
continue;
}
bufs.Add(comp.Buffer(distance));
}
return(FunctionsUtil.GetFactoryOrDefault(g)
.CreateGeometryCollection(GeometryFactory.ToGeometryArray(bufs)));
}
/// <summary>
/// Nodes the linework of a set of Geometrys using SnapRounding.
/// </summary>
/// <param name="geoms">A collection of geometries</param>
/// <returns>A collection of LineString geometries representing the noded linework of the input</returns>
public ICollection <IGeometry> Node(ICollection <IGeometry> geoms)
{
// get geometry factory
_geomFact = FunctionsUtil.GetFactoryOrDefault(geoms);
var segStrings = ExtractSegmentStrings(geoms);
//Noder sr = new SimpleSnapRounder(pm);
var sr = new MCIndexSnapRounder(_pm);
sr.ComputeNodes(segStrings);
var nodedLines = GetNodedLines(segStrings);
return(nodedLines);
}
public static IGeometry NodeWithPointwisePrecision(IGeometry geom, double scaleFactor)
{
var pm = new PrecisionModel(scaleFactor);
var roundedGeom = SimpleGeometryPrecisionReducer.Reduce(geom, pm);
var geomList = new List <IGeometry>();
geomList.Add(roundedGeom);
var noder = new GeometryNoder(pm);
var lines = noder.Node(geomList);
return(FunctionsUtil.GetFactoryOrDefault(geom).BuildGeometry(CollectionUtil.Cast <IGeometry>((ICollection)lines)));
}
/// <summary>Reduces precision pointwise, then snap-rounds.
/// <para/>
/// Note that output set may not contain non-unique linework
/// (and thus cannot be used as input to Polygonizer directly).
/// <c>UnaryUnion</c> is one way to make the linework unique.
/// </summary>
/// <param name="geom">A Geometry containing linework to node</param>
/// <param name="scaleFactor">The precision model scale factor to use</param>
/// <returns>The noded, snap-rounded linework</returns>
public static IGeometry SnapRoundLines(
IGeometry geom, double scaleFactor)
{
IPrecisionModel pm = new PrecisionModel(scaleFactor);
var roundedGeom = GeometryPrecisionReducer.ReducePointwise(geom, pm);
var geomList = new List <IGeometry>();
geomList.Add(roundedGeom);
var noder = new GeometrySnapRounder(pm);
var lines = noder.Node(geomList);
return(FunctionsUtil.GetFactoryOrDefault(geom).BuildGeometry(lines));
}
public static Geometry PerpendicularBisectors(Geometry g)
{
var pts = TrianglePts(g);
var cc = Triangle.Circumcentre(pts[0], pts[1], pts[2]);
var geomFact = FunctionsUtil.GetFactoryOrDefault(g);
var line = new LineString[3];
var p0 = (new LineSegment(pts[1], pts[2])).ClosestPoint(cc);
line[0] = geomFact.CreateLineString(new[] { p0, cc });
var p1 = (new LineSegment(pts[0], pts[2])).ClosestPoint(cc);
line[1] = geomFact.CreateLineString(new[] { p1, cc });
var p2 = (new LineSegment(pts[0], pts[1])).ClosestPoint(cc);
line[2] = geomFact.CreateLineString(new[] { p2, cc });
return(geomFact.CreateMultiLineString(line));
}
public static IGeometry RandomLineString(IGeometry g, int nPts)
{
var env = FunctionsUtil.GetEnvelopeOrDefault(g);
var geomFact = FunctionsUtil.GetFactoryOrDefault(g);
double width = env.Width;
double hgt = env.Height;
var pts = new Coordinate[nPts];
for (int i = 0; i < nPts; i++)
{
double xLen = width * RND.NextDouble();
double yLen = hgt * RND.NextDouble();
pts[i] = RandomPtAround(env.Centre, xLen, yLen);
}
return(geomFact.CreateLineString(pts));
}
public static IGeometry RandomPoints(IGeometry g, int nPts)
{
var env = FunctionsUtil.GetEnvelopeOrDefault(g);
var geomFact = FunctionsUtil.GetFactoryOrDefault(g);
double xLen = env.Width;
double yLen = env.Height;
var pts = new List <IPoint>();
for (int i = 0; i < nPts; i++)
{
double x = env.MinX + xLen * RND.NextDouble();
double y = env.MinY + yLen * RND.NextDouble();
pts.Add(geomFact.CreatePoint(new Coordinate(x, y)));
}
return(geomFact.BuildGeometry(pts.ToArray()));
}
public static IGeometry CheckNoding(Geometry geom)
{
var segs = CreateSegmentStrings(geom);
var nv = new FastNodingValidator(segs);
nv.FindAllIntersections = true;
var res = nv.IsValid;
var intPts = nv.Intersections;
var pts = new IPoint[intPts.Count];
for (var i = 0; i < intPts.Count; i++)
{
var coord = intPts[i];
// use default factory in case intersections are not fixed
pts[i] = FunctionsUtil.GetFactoryOrDefault(null).CreatePoint(coord);
}
return(FunctionsUtil.GetFactoryOrDefault(null).CreateMultiPoint(
pts));
}
private static IGeometry CreateS(IGeometry g)
{
var gf = FunctionsUtil.GetFactoryOrDefault(g);
double centreX = WIDTH - S_RADIUS;
var top = new[]
{
new Coordinate(WIDTH, HEIGHT),
new Coordinate(centreX, HEIGHT)
};
var bottom = new[]
{
new Coordinate(centreX, 0),
new Coordinate(WIDTH - 2 * S_RADIUS, 0)
};
var gsf = new GeometricShapeFactory(gf);
gsf.Centre = new Coordinate(centreX, HEIGHT - S_RADIUS);
gsf.Size = 2 * S_RADIUS;
gsf.NumPoints = 10;
var arcTop = gsf.CreateArc(0.5 * Math.PI, Math.PI);
var gsf2 = new GeometricShapeFactory(gf);
gsf2.Centre = new Coordinate(centreX, S_RADIUS);
gsf2.Size = 2 * S_RADIUS;
gsf2.NumPoints = 10;
var arcBottom = (ILineString)((IGeometry)gsf2.CreateArc(1.5 * Math.PI, Math.PI)).Reverse();
var coordList = new CoordinateList();
coordList.Add(top, false);
coordList.Add(arcTop.Coordinates, false, 1, arcTop.NumPoints - 1);
coordList.Add(new Coordinate(centreX, HEIGHT / 2));
coordList.Add(arcBottom.Coordinates, false, 1, arcBottom.NumPoints - 1);
coordList.Add(bottom, false);
return(gf.CreateLineString(coordList.ToCoordinateArray()));
}
private static IGeometry FontGlyph(IGeometry g, String text, Font font)
{
var env = FunctionsUtil.GetEnvelopeOrDefault(g);
var geomFact = FunctionsUtil.GetFactoryOrDefault(g);
var textGeom = FontGlyphReader.Read(text, font, geomFact);
var envText = textGeom.EnvelopeInternal;
if (g != null)
{
// transform to baseline
var baseText0 = new Coordinate(envText.MinX, envText.MinY);
var baseText1 = new Coordinate(envText.MaxX, envText.MinY);
var baseGeom0 = new Coordinate(env.MinX, env.MinY);
var baseGeom1 = new Coordinate(env.MaxX, env.MinY);
AffineTransformation trans = AffineTransformationFactory.CreateFromBaseLines(baseText0, baseText1,
baseGeom0, baseGeom1);
return(trans.Transform(textGeom));
}
return(textGeom);
}
public static IGeometry HaltonPointsWithBases(IGeometry g, int nPts, int basei, int basej)
{
var env = FunctionsUtil.GetEnvelopeOrDefault(g);
var pts = new Coordinate[nPts];
var baseX = env.MinX;
var baseY = env.MinY;
var i = 0;
while (i < nPts)
{
var x = baseX + env.Width * HaltonOrdinate(i + 1, basei);
var y = baseY + env.Height * HaltonOrdinate(i + 1, basej);
var p = new Coordinate(x, y);
if (env.Contains(p))
{
pts[i++] = new Coordinate(p);
}
}
return(FunctionsUtil.GetFactoryOrDefault(g).CreateMultiPoint(pts));
}
private static IGeometry CreateT(IGeometry g)
{
var gf = FunctionsUtil.GetFactoryOrDefault(g);
var tTop = new[]
{
new Coordinate(J_WIDTH, HEIGHT),
new Coordinate(WIDTH - S_RADIUS - 5, HEIGHT)
};
var tBottom = new[]
{
new Coordinate(J_WIDTH + 0.5 * T_WIDTH, HEIGHT),
new Coordinate(J_WIDTH + 0.5 * T_WIDTH, 0)
};
var lines = new[]
{
gf.CreateLineString(tTop),
gf.CreateLineString(tBottom)
};
return(gf.CreateMultiLineString(lines));
}
public static IGeometry RandomRectilinearWalk(IGeometry g, int nPts)
{
var env = FunctionsUtil.GetEnvelopeOrDefault(g);
var geomFact = FunctionsUtil.GetFactoryOrDefault(g);
double xLen = env.Width;
double yLen = env.Height;
var pts = new Coordinate[nPts];
bool xory = true;
for (int i = 0; i < nPts; i++)
{
Coordinate pt;
if (i == 0)
{
pt = RandomPtAround(env.Centre, xLen, yLen);
}
else
{
double dist = xLen * (RND.NextDouble() - 0.5);
double x = pts[i - 1].X;
double y = pts[i - 1].Y;
if (xory)
{
x += dist;
}
else
{
y += dist;
}
// switch orientation
xory = !xory;
pt = new Coordinate(x, y);
}
pts[i] = pt;
}
return(geomFact.CreateLineString(pts));
}