/// <summary>
/// Label an isolated node with its relationship to the target point.
/// </summary>
private void LabelIncompleteNode(GraphComponent n, int targetIndex)
{
var loc = _ptLocator.Locate(n.Coordinate, arg[targetIndex].Geometry);
// MD - 2008-10-24 - experimental for now
//int loc = arg[targetIndex].Locate(n.Coordinate);
n.Label.SetLocation(targetIndex, loc);
}
public void TestPolygon()
{
var pointLocator = new PointLocator();
var polygon = reader.Read("POLYGON ((70 340, 430 50, 70 50, 70 340))");
Assert.That(pointLocator.Locate(new Coordinate(420, 340), polygon), Is.EqualTo(Location.Exterior));
Assert.That(pointLocator.Locate(new Coordinate(350, 50), polygon), Is.EqualTo(Location.Boundary));
Assert.That(pointLocator.Locate(new Coordinate(410, 50), polygon), Is.EqualTo(Location.Boundary));
Assert.That(pointLocator.Locate(new Coordinate(190, 150), polygon), Is.EqualTo(Location.Interior));
}
public void testPointLocator()
{
var pointLocator = new PointLocator();
var polygon = reader.Read("POLYGON ((70 340, 430 50, 70 50, 70 340))");
Assert.AreEqual(Location.Exterior, pointLocator.Locate(new Coordinate(420, 340), polygon));
Assert.AreEqual(Location.Boundary, pointLocator.Locate(new Coordinate(350, 50), polygon));
Assert.AreEqual(Location.Boundary, pointLocator.Locate(new Coordinate(410, 50), polygon));
Assert.AreEqual(Location.Interior, pointLocator.Locate(new Coordinate(190, 150), polygon));
}
/// <summary>
/// Label an isolated edge of a graph with its relationship to the target point.
/// If the target has dim 2 or 1, the edge can either be in the interior or the exterior.
/// If the target has dim 0, the edge must be in the exterior.
/// </summary>
/// <param name="e"></param>
/// <param name="targetIndex"></param>
/// <param name="target"></param>
private void LabelIsolatedEdge(Edge e, int targetIndex, IGeometry target)
{
// this won't work for GeometryCollections with both dim 2 and 1 geoms
if (target.Dimension > 0)
{
// since edge is not in boundary, may not need the full generality of PointLocator?
// Possibly should use ptInArea locator instead? We probably know here
// that the edge does not touch the bdy of the target Geometry
Locations loc = ptLocator.Locate(e.Coordinate, target);
e.Label.SetAllLocations(targetIndex, loc);
}
else e.Label.SetAllLocations(targetIndex, Locations.Exterior);
}
/// <summary>
/// Label an isolated node with its relationship to the target geometry.
/// </summary>
private void LabelIsolatedLine(Edge e, int targetIndex)
{
int loc = ptLocator.Locate(e.Coordinate,
op.GetArgGeometry(targetIndex));
e.Label.SetLocation(targetIndex, loc);
}
private void ComputeInside(Coordinate pt, Polygon poly)
{
if (Location.Exterior != _ptLocator.Locate(pt, poly))
{
_minDistance = 0.0;
}
}
public IGeometry Union()
{
PointLocator locater = new PointLocator();
// use a set to eliminate duplicates, as required for union
var exteriorCoords = new HashSet <Coordinate>();
foreach (IPoint point in PointExtracter.GetPoints(_pointGeom))
{
Coordinate coord = point.Coordinate;
Location loc = locater.Locate(coord, _otherGeom);
if (loc == Location.Exterior)
{
exteriorCoords.Add(coord);
}
}
// if no points are in exterior, return the other geom
if (exteriorCoords.Count == 0)
{
return(_otherGeom);
}
// make a puntal geometry of appropriate size
var exteriorCoordsArray = new Coordinate[exteriorCoords.Count];
exteriorCoords.CopyTo(exteriorCoordsArray, 0);
Array.Sort(exteriorCoordsArray);
ICoordinateSequence coords = _geomFact.CoordinateSequenceFactory.Create(exteriorCoordsArray);
IGeometry ptComp = coords.Count == 1 ? (IGeometry)_geomFact.CreatePoint(coords.GetCoordinate(0)) : _geomFact.CreateMultiPoint(coords);
// add point component to the other geometry
return(GeometryCombiner.Combine(ptComp, _otherGeom));
}
public void testPointLocatorLinearRingLineString()
{
var pointLocator = new PointLocator();
var gc = reader.Read("GEOMETRYCOLLECTION( LINESTRING(0 0, 10 10), LINEARRING(10 10, 10 20, 20 10, 10 10))");
Assert.AreEqual(Location.Boundary, pointLocator.Locate(new Coordinate(10, 10), gc));
}
public Location Locate(Coordinate p)
{
// TODO: optimize this with a segment index
var locator = new PointLocator();
return(locator.Locate(p, _inputGeom));
}
private void RunPtLocator(Location expected, Coordinate pt, string wkt)
{
var geom = reader.Read(wkt);
var pointLocator = new PointLocator();
var loc = pointLocator.Locate(pt, geom);
Assert.AreEqual(expected, loc);
}
} // private void LabelIsolatedEdges( int thisIndex, int targetIndex )
/// <summary>
/// Label an isolated edge of a graph with its relationship to the target geometry.
/// If the target has dim 2 or 1, the edge can either be in the interior or the exterior.
/// If the target has dim 0, the edge must be in the exterior.
/// </summary>
/// <param name="e"></param>
/// <param name="targetIndex"></param>
/// <param name="target"></param>
private void LabelIsolatedEdge(Edge e, int targetIndex, Geometry target)
{
// this won't work for GeometryCollections with both dim 2 and 1 geoms
if (target.GetDimension() > 0)
{
// since edge is not in boundary, may not need the full generality of PointLocator?
// Possibly should use ptInArea locator instead? We probably know here
// that the edge does not touch the bdy of the target Geometry
int loc = _ptLocator.Locate(e.GetCoordinate(), target);
e.Label.SetAllLocations(targetIndex, loc);
} // if ( target.Dimension > 0)
else
{
e.Label.SetAllLocations(targetIndex, Location.Exterior);
}
//Trace.WriteLine( e.Label.ToString() );
} // private void LabelIsolatedEdge(Edge e, int targetIndex, Geometry target)
private void RunPtLocator(Location expected, Coordinate pt, String wkt)
{
IGeometry geom = reader.Read(wkt);
PointLocator pointLocator = new PointLocator();
Location loc = pointLocator.Locate(pt, geom);
Assert.AreEqual(expected, loc);
}
/// <summary>
///
/// </summary>
/// <param name="ptLoc"></param>
/// <param name="poly"></param>
/// <param name="locPtPoly"></param>
private void ComputeInside(GeometryLocation ptLoc, IPolygon poly, GeometryLocation[] locPtPoly)
{
ICoordinate pt = ptLoc.Coordinate;
if (Locations.Exterior != ptLocator.Locate(pt, poly))
{
minDistance = 0.0;
locPtPoly[0] = ptLoc;
GeometryLocation locPoly = new GeometryLocation(poly, pt);
locPtPoly[1] = locPoly;
return;
}
}
private void ComputeContainmentDistance(GeometryLocation ptLoc,
Polygon poly,
GeometryLocation[] locPtPoly)
{
var pt = ptLoc.Coordinate;
// if pt is not in exterior, distance to geom is 0
if (Location.Exterior != _ptLocator.Locate(pt, poly))
{
_minDistance = 0.0;
locPtPoly[0] = ptLoc;
locPtPoly[1] = new GeometryLocation(poly, pt);
}
}
// MD - experimental for now
/// <summary>
/// Determines the <see cref="Location"/> of the given <see cref="Coordinate"/> in this geometry.
/// </summary>
/// <param name="pt">The point to test</param>
/// <returns>
/// The location of the point in the geometry
/// </returns>
public Location Locate(Coordinate pt)
{
if (_parentGeom is IPolygonal && _parentGeom.NumGeometries > 50)
{
// lazily init point locator
if (_areaPtLocator == null)
{
_areaPtLocator = new IndexedPointInAreaLocator(_parentGeom);
}
return(_areaPtLocator.Locate(pt));
}
return(_ptLocator.Locate(pt, _parentGeom));
}
// MD - experimental for now
///<summary>
/// Determines the <see cref="Location"/> of the given <see cref="Coordinate"/> in this geometry.
///</summary>
/// <param name="pt">The point to test</param>
/// <returns>
/// The location of the point in the geometry
/// </returns>
public Location Locate(Coordinate pt)
{
if (_parentGeom is IPolygonal && _parentGeom.NumGeometries > 50)
{
// lazily init point locator
if (_areaPtLocator == null)
{
_areaPtLocator = new NetTopologySuite.Algorithm.Locate.IndexedPointInAreaLocator(_parentGeom);
}
return _areaPtLocator.Locate(pt);
}
return _ptLocator.Locate(pt, _parentGeom);
}
private void ComputeInside(DistanceLocation ptLoc, Polygon poly,
DistanceLocation[] locPtPoly)
{
Coordinate pt = ptLoc.Coordinate;
if (LocationType.Exterior != ptLocator.Locate(pt, poly))
{
minDistance = 0.0;
locPtPoly[0] = ptLoc;
DistanceLocation locPoly = new DistanceLocation(poly, pt);
locPtPoly[1] = locPoly;
return;
}
}
/// <summary>
///
/// </summary>
/// <param name="ptLoc"></param>
/// <param name="poly"></param>
/// <param name="locPtPoly"></param>
private void ComputeInside(GeometryLocation ptLoc, IGeometry poly, GeometryLocation[] locPtPoly)
{
Coordinate pt = ptLoc.Coordinate;
if (LocationType.Exterior == _ptLocator.Locate(pt, poly))
{
return;
}
_minDistance = 0.0;
locPtPoly[0] = ptLoc;
GeometryLocation locPoly = new GeometryLocation(poly, pt);
locPtPoly[1] = locPoly;
return;
}
public Location GetLocation(Coordinate pt)
{
if (IsWithinToleranceOfBoundary(pt))
{
return(Location.Boundary);
}
/*
* double dist = linework.distance(point);
*
* // if point is close to boundary, it is considered to be on the boundary
* if (dist < tolerance)
* return Location.BOUNDARY;
*/
// now we know point must be clearly inside or outside geometry, so return actual location value
return(_ptLocator.Locate(pt, _g));
}
public IGeometry Union()
{
PointLocator locater = new PointLocator();
// use a set to eliminate duplicates, as required for union
#if Goletas
HashSet <ICoordinate> exteriorCoords = new HashSet <ICoordinate>();
#else
TreeSet exteriorCoords = new TreeSet();
#endif
foreach (IPoint point in PointExtracter.GetPoints(_pointGeom))
{
ICoordinate coord = point.Coordinate;
Locations loc = locater.Locate(coord, _otherGeom);
if (loc == Locations.Exterior)
{
exteriorCoords.Add(coord);
}
}
// if no points are in exterior, return the other geom
if (exteriorCoords.Count == 0)
{
return(_otherGeom);
}
// make a puntal geometry of appropriate size
IGeometry ptComp = null;
ICoordinateSequence coords = _geomFact.CoordinateSequenceFactory.Create(exteriorCoords.ToArray());
ptComp = coords.Count == 1 ? (IGeometry)_geomFact.CreatePoint(coords.GetCoordinate(0)) : _geomFact.CreateMultiPoint(coords);
// add point component to the other geometry
return(GeometryCombiner.Combine(ptComp, _otherGeom));
}
/// <summary>
/// Label an isolated node with its relationship to the target point.
/// </summary>
private void LabelIncompleteNode(Node n, int targetIndex)
{
LocationType loc = _ptLocator.Locate(n.Coordinate, Arg[targetIndex].Geometry);
n.Label.SetLocation(targetIndex, loc);
}
} // private void LabelIncompleteNodes()
/// <summary>
/// Label an isolated node with its relationship to the target geometry.
/// </summary>
/// <param name="n"></param>
/// <param name="targetIndex"></param>
private void LabelIncompleteNode(Node n, int targetIndex)
{
int loc = _ptLocator.Locate(n.GetCoordinate(), _arg[targetIndex].Geometry);
n.Label.SetLocation(targetIndex, loc);
} // private void LabelIncompleteNode( Node n, int targetIndex )
/// <summary>
/// Label an isolated node with its relationship to the target point.
/// </summary>
private void LabelIncompleteNode(GraphComponent n, int targetIndex)
{
var loc = ptLocator.Locate(n.Coordinate, arg[targetIndex].Geometry);
n.Label.SetLocation(targetIndex, loc);
}
