private MultiPolygon CreateMP1()
		{
			Polygon[] polygons = new Polygon[2];
			LineString[] rings = new LineString[2];

			Coordinates coords = new Coordinates();
			Coordinate coord = new Coordinate(5, 1);
			coords.Add(coord);
			coord = new Coordinate(6, 2);
			coords.Add(coord);
			coord = new Coordinate(7, 3);
			coords.Add(coord);
			coord = new Coordinate(6, 4);
			coords.Add(coord);
			coord = new Coordinate(5, 5);
			coords.Add(coord);
			coord = new Coordinate(4, 4);
			coords.Add(coord);
			coord = new Coordinate(3, 3);
			coords.Add(coord);
			coord = new Coordinate(4, 2);
			coords.Add(coord);
			coord = new Coordinate(5, 1);
			coords.Add(coord);

			GeometryFactory gf = new GeometryFactory(_precMod, _sRID);

            LinearRing exterior1 = gf.CreateLinearRing(coords);
			polygons[0] = gf.CreatePolygon(exterior1);
			rings[0] = exterior1 as LineString;

			coords = new Coordinates();
			coord = new Coordinate(5, 1);
			coords.Add(coord);
			coord = new Coordinate(6, 2);
			coords.Add(coord);
			coord = new Coordinate(7, 3);
			coords.Add(coord);
			coord = new Coordinate(6, 4);
			coords.Add(coord);
			coord = new Coordinate(5, 5);
			coords.Add(coord);
			coord = new Coordinate(4, 4);
			coords.Add(coord);
			coord = new Coordinate(3, 3);
			coords.Add(coord);
			coord = new Coordinate(4, 2);
			coords.Add(coord);
			coord = new Coordinate(5, 1);
			coords.Add(coord);

			LinearRing exterior2 = gf.CreateLinearRing(coords);
			polygons[1] = gf.CreatePolygon(exterior2);
			rings[1] = exterior2;

			_mls1 = gf.CreateMultiLineString(rings);

			return gf.CreateMultiPolygon(polygons);
		}
		/// <summary>
		/// Initializes a new instance of the MultiPolygon class.
		/// </summary>
		/// <param name="polygons">
		/// The Polygons for this MultiPolygon, or null or an empty array to create 
		/// the empty geometry.  Elements may be empty Polygons, but not nulls. The 
		/// polygons must conform to the assertions specified in the 
		/// OpenGIS Simple Features Specification.
		/// </param>
		/// <param name="precisionModel">The specification of the grid of allowable 
		/// points for this MultiPolygon.</param>
		/// <param name="SRID">
		///	The ID of the Spatial Reference System used by this MultiPolygon.
		/// </param>
		internal MultiPolygon(Polygon[] polygons, PrecisionModel precisionModel, int SRID) : base(polygons, precisionModel, SRID)
		{
			if(polygons == null)
			{
				polygons = new Polygon[]{};
			}
			if (HasNullElements(polygons))
			{
				throw new ArgumentNullException("Polygon array must not contain null elements.");
			}
			_geometries = polygons;
		}
		private MultiPolygon CreateMP2()
		{
			Polygon[] polygons = new Polygon[2];

			GeometryFactory gf = new GeometryFactory(_precMod, _sRID);

			Coordinates coords = new Coordinates();
			Coordinate coord = new Coordinate(10, 13);
			coords.Add(coord);
			coord = new Coordinate(11, 13);
			coords.Add(coord);
			coord = new Coordinate(12, 13);
			coords.Add(coord);
			coord = new Coordinate(13, 14);
			coords.Add(coord);
			coord = new Coordinate(14, 15);
			coords.Add(coord);
			coord = new Coordinate(15, 16);
			coords.Add(coord);
			coord = new Coordinate(15, 17);
			coords.Add(coord);
			coord = new Coordinate(15, 18);
			coords.Add(coord);
			coord = new Coordinate(14, 19);
			coords.Add(coord);
			coord = new Coordinate(13, 20);
			coords.Add(coord);
			coord = new Coordinate(12, 21);
			coords.Add(coord);
			coord = new Coordinate(11, 21);
			coords.Add(coord);
			coord = new Coordinate(10, 21);
			coords.Add(coord);
			coord = new Coordinate(9, 20);
			coords.Add(coord);
			coord = new Coordinate(8, 19);
			coords.Add(coord);
			coord = new Coordinate(7, 18);
			coords.Add(coord);
			coord = new Coordinate(7, 17);
			coords.Add(coord);
			coord = new Coordinate(7, 16);
			coords.Add(coord);
			coord = new Coordinate(8, 15);
			coords.Add(coord);
			coord = new Coordinate(9, 14);
			coords.Add(coord);
			coord = new Coordinate(10, 13);
			coords.Add(coord);

			LinearRing exterior = gf.CreateLinearRing(coords);

			coords = new Coordinates();
			coord = new Coordinate(10, 16);
			coords.Add(coord);
			coord = new Coordinate(11, 17);
			coords.Add(coord);
			coord = new Coordinate(10, 18);
			coords.Add(coord);
			coord = new Coordinate(9, 17);
			coords.Add(coord);
			coord = new Coordinate(10, 16);
			coords.Add(coord);

			LinearRing interior = gf.CreateLinearRing(coords);
			LinearRing[] linearRings = new LinearRing[1];
			linearRings[0] = interior;

			polygons[0] = gf.CreatePolygon(exterior, linearRings);

			coords = new Coordinates();
			coord = new Coordinate(5, 1);
			coords.Add(coord);
			coord = new Coordinate(6, 2);
			coords.Add(coord);
			coord = new Coordinate(7, 3);
			coords.Add(coord);
			coord = new Coordinate(6, 4);
			coords.Add(coord);
			coord = new Coordinate(5, 5);
			coords.Add(coord);
			coord = new Coordinate(4, 4);
			coords.Add(coord);
			coord = new Coordinate(3, 3);
			coords.Add(coord);
			coord = new Coordinate(4, 2);
			coords.Add(coord);
			coord = new Coordinate(5, 1);
			coords.Add(coord);

			exterior = gf.CreateLinearRing(coords);
			polygons[1] = gf.CreatePolygon(exterior);

			return gf.CreateMultiPolygon(polygons);
		}
		/// <summary>
		/// Converts a Polygon to &lt;Polygon Text&gt; format, then
		/// Appends it to the writer.
		/// </summary>
		/// <param name="polygon">The Polygon to process.</param>
		/// <param name="level"></param>
		/// <param name="indentFirst"></param>
		/// <param name="writer"></param>
		protected void AppendPolygonText(Polygon polygon, int level, bool indentFirst, StringWriter writer)
		{
			
			if ( polygon.IsEmpty() ) 
			{
				writer.Write("EMPTY");
			}
			else 
			{
				if (indentFirst) Indent(level, writer);
				writer.Write("(");
				AppendLineStringText(polygon.Shell, level, false, writer);
				for (int i = 0; i < polygon.GetNumInteriorRing(); i++) 
				{
					writer.Write(", ");
					AppendLineStringText(polygon.Holes[i], level + 1, true, writer);
				}
				writer.Write(")");
			}		
		}
		/// <summary>
		///  Converts a Polygon to &lt;Polygon Tagged Text&gt; format,
		///  then Appends it to the writer.
		/// </summary>
		/// <param name="polygon">Th Polygon to process.</param>
		/// <param name="level"></param>
		/// <param name="writer">The stream writer to Append to.</param>
		protected void AppendPolygonTaggedText(Polygon polygon, int level, StringWriter writer)
		{
			
			writer.Write("POLYGON ");
			AppendPolygonText(polygon, level, false, writer);
			
		}
Exemple #6
0
		/// <summary>
		/// Test that each hole is inside the polygon shell.
		/// This routine assumes that the holes have previously been tested
		/// to ensure that all vertices lie on the shell or inside it.
		/// A simple test of a single point in the hole can be used,
		/// provide the point is chosen such that it does not lie on the
		/// boundary of the shell.
		/// </summary>
		/// <param name="p">The polygon to be tested for hole inclusion.</param>
		/// <param name="graph">Graph a GeometryGraph incorporating the polygon.</param>
		private void CheckHolesInShell(Polygon p, GeometryGraph graph)
		{
			LinearRing shell = (LinearRing) p.GetExteriorRing();
			Coordinates shellPts = shell.GetCoordinates();

			//PointInRing pir = new SimplePointInRing(shell);
			//PointInRing pir = new SIRtreePointInRing(shell);
			IPointInRing pir = new MCPointInRing(shell);

			for (int i = 0; i < p.GetNumInteriorRing(); i++) 
			{

				LinearRing hole = (LinearRing) p.GetInteriorRingN(i);
				Coordinate holePt = FindPtNotNode(hole.GetCoordinates(), shell, graph);
				if (holePt == null)
				{
					throw new InvalidOperationException("Unable to find a hole point not a vertex of the shell.");
				}

				bool outside = ! pir.IsInside(holePt);
				if ( outside ) 
				{
					_validErr = new TopologyValidationError(
						TopologyValidationError.HoleOutsideShell,
						holePt);
					return;
				}
			}
		}
		/// <summary>
		/// Converts a Polygon to &lt;Polygon Text&gt; format, then
		/// Appends it to the writer.
		/// </summary>
		/// <param name="polygon">The Polygon to process.</param>
		/// <param name="writer"></param>
		protected void AppendPolygonText(Polygon polygon,  TextWriter writer)
		{
			
			if (polygon.IsEmpty()) 
			{
				//writer.Write("EMPTY");
			}
			else 
			{
				AppendLineStringText(polygon.Shell,writer);
				for (int i = 0; i < polygon.GetNumInteriorRing(); i++) 
				{
					AppendLineStringText(polygon.Holes[i],  writer);
				}
				writer.Write(" Z ");
			}	
		
		}
		private void ComputeInside(Coordinate pt, Polygon poly)
		{
			if (Location.Exterior != _ptLocator.Locate(pt, poly))
			{
				_minDistance = 0.0;
			}
		}
		/// <summary>
		/// Converts the List to an array.
		/// </summary>
		/// <param name="polygons">The List to convert.</param>
		/// <returns>The List in array format.</returns>
		public static Polygon[] ToPolygonArray(ArrayList polygons) 
		{
			Polygon[] polygonArray = new Polygon[polygons.Count];
			return (Polygon[]) polygons.ToArray(typeof(Polygon));
		}
		} // private static bool ContainsPoint(Coordinate p, Geometry geom)



		private static bool ContainsPointInPolygon(Coordinate p, Polygon poly)
		{

			if ( poly.IsEmpty() ) return false;

			LinearRing shell = (LinearRing) poly.GetExteriorRing();
			if ( ! _cga.IsPointInRing( p, shell.GetCoordinates() ) )
			{
				return false;
			}

			// now test if the point lies in or on the holes
			for (int i = 0; i < poly.GetNumInteriorRing(); i++) 
			{
				LinearRing lr = poly.GetInteriorRingN( i );
				if ( _cga.IsPointInRing( p, lr.GetCoordinates() ) )
				{
					return false;
				}
			}
			return true;
		} // private static bool ContainsPointInPolygon(Coordinate p, Polygon poly)
		private bool HasRepeatedPoint(Polygon p)
		{
			LinearRing exteriorRing1;
			exteriorRing1 = (LinearRing)p.GetExteriorRing();	
			if (HasRepeatedPoint(exteriorRing1.GetCoordinates() ))
			{
				return true;
			}
			for (int i = 0; i < p.GetNumInteriorRing(); i++) 
			{
				LinearRing interiorRing = p.GetInteriorRingN(i);
				if (HasRepeatedPoint( (interiorRing).GetCoordinates() )) return true;
			}
			return false;
		}
		/// <summary>
		/// Add a Polygon to the graph.
		/// </summary>
		/// <param name="p">The polygon to add.</param>
		private void AddPolygon(Polygon p)
		{
			
			double lineDistance = _distance;
			int side = Position.Left;
			if (_distance < 0.0) 
			{
				lineDistance = -_distance;
				side = Position.Right;
			}
			int holeSide = (side == Position.Left) ? Position.Right : Position.Left;
			AddPolygonRing(
				(LinearRing) p.GetExteriorRing(),
				lineDistance,
				side,
				Location.Exterior,
				Location.Interior);

			for (int i = 0; i < p.GetNumInteriorRing(); i++) 
			{
				// Holes are topologically labelled opposite to the shell, since
				// the interior of the polygon lies on their opposite side
				// (on the left, if the hole is oriented CCW)
				LinearRing  interiorRing = p.GetInteriorRingN( i );
				AddPolygonRing(
					interiorRing,
					lineDistance,
					Position.Opposite(side),
					Location.Interior,
					Location.Exterior);
			}
			
		}
Exemple #13
0
		/// <summary>
		/// Check if a shell is incorrectly nested within a polygon.  This is the case
		/// if the shell is inside the polygon shell, but not inside a polygon hole.
		/// If the shell is inside a polygon hole, the nesting is valid.)
		/// 
		/// The algorithm used relies on the fact that the rings must be properly contained.
		/// E.g. they cannot partially overlap (this has been previously Checked by
		/// CheckRelateConsistency
		/// </summary>
		/// <param name="shell"></param>
		/// <param name="p"></param>
		/// <param name="graph"></param>
		private void CheckShellNotNested(LinearRing shell, Polygon p, GeometryGraph graph)
		{
			
			Coordinates shellPts = shell.GetCoordinates();
			// test if shell is inside polygon shell
			LinearRing polyShell =  (LinearRing) p.GetExteriorRing();
			Coordinates polyPts = polyShell.GetCoordinates();
			Coordinate shellPt = FindPtNotNode(shellPts, polyShell, graph);
			// if no point could be found, we can assume that the shell is outside the polygon
			if (shellPt == null)
				return;
			bool insidePolyShell = _cga.IsPointInRing(shellPt, polyPts);
			if (! insidePolyShell) return;

			// if no holes, this is an error!
			if (p.GetNumInteriorRing() <= 0) 
			{
				_validErr = new TopologyValidationError(
					TopologyValidationError.NestedShells,
					shellPt);
				return;
			}

			for (int i = 0; i < p.GetNumInteriorRing(); i++) 
			{
				LinearRing hole = p.GetInteriorRingN( i );
				CheckShellInsideHole(shell, hole, graph);
				if (_validErr != null) return;
			}
			
		}
Exemple #14
0
		/// <summary>
		/// Tests that no hole is nested inside another hole.
		/// </summary>
		/// <remarks>
		/// This routine assumes that the holes are disjoint.
		/// To ensure this, holes have previously been tested
		/// to ensure that:
		/// <ul>
		/// <li>they do not partially overlap
		/// (Checked by CheckRelateConsistency)</li>
		/// <li>they are not identical
		/// (Checked by CheckRelateConsistency)</li>
		/// <li>they do not touch at a vertex
		/// (Checked by ????)</li>
		/// </ul>
		/// </remarks>
		/// <param name="p"></param>
		/// <param name="graph"></param>
		private void CheckHolesNotNested(Polygon p, GeometryGraph graph)
		{
			
			QuadtreeNestedRingTester nestedTester = new QuadtreeNestedRingTester(graph);
			//SimpleNestedRingTester nestedTester = new SimpleNestedRingTester(_arg[0]);
			//SweeplineNestedRingTester nestedTester = new SweeplineNestedRingTester(_arg[0]);

			for (int i = 0; i < p.GetNumInteriorRing(); i++) 
			{
				LinearRing innerHole = p.GetInteriorRingN( i );
				nestedTester.Add(innerHole);
			}
			bool isNonNested = nestedTester.IsNonNested();
			if ( ! isNonNested ) 
			{
				_validErr = new TopologyValidationError(
					TopologyValidationError.NestedHoles,
					nestedTester.GetNestedPoint());
			}
		}
Exemple #15
0
		private void OLDCheckHolesInShell(Polygon p)
		{
			// awc: probably do'nt need this - but copy it anyway
			/*LinearRing shell =  (LinearRing) p.getExteriorRing();
			Coordinate[] shellPts = shell.getCoordinates();
			for (int i = 0; i < p.getNumInteriorRing(); i++) 
			{
				Coordinate holePt = findPtNotNode(p.getInteriorRingN(i).getCoordinates(), shell, arg[0]);
				Assert.isTrue(holePt != null, "Unable to find a hole point not a vertex of the shell");
				bool onBdy = cga.isOnLine(holePt, shellPts);
				bool inside = cga.isPointInPolygon(holePt, shellPts);
				bool outside = ! (onBdy || inside);
				if ( outside ) 
				{
					_validErr = new TopologyValidationError(
						TopologyValidationError.HOLE_OUTSIDE_SHELL,
						holePt);
					return;
				}
			}*/
			throw new NotImplementedException();
		}
		/// <summary>
		/// Creates a new multipolygon given an array of polygons.
		/// </summary>
		/// <param name="polygons">The array of polygons to be used to create the multipolygon.</param>
		/// <returns>A new multipolygon.</returns>
		public MultiPolygon CreateMultiPolygon(Polygon[] polygons) 
		{
			return new MultiPolygon(polygons, _precisionModel, _SRID);
		}
		/// <summary>
		/// Projects all the points in a multipolygon and returns a new multipolygon object.
		/// </summary>
		/// <param name="coordinateTransform">The coordinate transformation to use for projection.</param>
		/// <returns>The projected multipolygon object.</returns>
		public override Geometry Project(ICoordinateTransformation  coordinateTransform)
		{
			if (coordinateTransform==null)
			{
				throw new ArgumentNullException("coordinateTransform");
			}
			if (!(coordinateTransform.MathTransform is Geotools.CoordinateTransformations.MapProjection))
			{
				throw new ArgumentException("transform must be a MapProjection.");
			}

			Polygon[] projectedPolygons = new Polygon[_geometries.Length];
			IGeometry projectedPolygon;
			for(int i=0; i<_geometries.Length; i++)
			{
				projectedPolygon = _geometries[i].Project(coordinateTransform);
				projectedPolygons[i] = (Polygon)projectedPolygon;				
			}
			return _geometryFactory.CreateMultiPolygon(projectedPolygons);
		}
		/// <summary>
		/// Writes a polygon.
		/// </summary>
		/// <param name="poly">The polygon to be written.</param>
		private void WritePolygon(Polygon poly, byte format)
		{
			//Get the number of rings in this polygon.
			int numRings = poly.GetNumInteriorRing() + 1;

			//Write the number of rings to the stream (add one for the shell)
			_bWriter.Write(numRings);

			//Get the shell of this polygon.
			WriteLineString(poly.Shell, format);

			//Loop on the number of rings - 1 because we already wrote the shell.
			for(int i = 0; i < numRings-1; i++)
			{
				//Populate the linearRing.
				LinearRing lr = poly.GetInteriorRingN( i );

				//Write the (lineString)LinearRing.
                WriteLineString((LineString)lr, format);
			}
		}
		/// <summary>
		/// Reads a stream and converts the shapefile record to an equilivent geometry object.
		/// </summary>
		/// <param name="file">The stream to read.</param>
		/// <param name="geometryFactory">The geometry factory to use when making the object.</param>
		/// <returns>The Geometry object that represents the shape file record.</returns>
		public override Geometry Read(BigEndianBinaryReader file, GeometryFactory geometryFactory)
		{
			int shapeTypeNum = file.ReadInt32();
			ShapeType shapeType = (ShapeType)Enum.Parse(typeof(ShapeType),shapeTypeNum.ToString());
			if (shapeType != ShapeType.Polygon)
			{
				throw new ShapefileException("Attempting to load a non-polygon as polygon.");
			}

			//read and for now ignore bounds.
			double[] box = new double[4];
			for (int i = 0; i < 4; i++) 
			{
				box[i] = file.ReadDouble();
			}

			int[] partOffsets;
        
			int numParts = file.ReadInt32();
			int numPoints = file.ReadInt32();
			partOffsets = new int[numParts];
			for (int i = 0; i < numParts; i++)
			{
				partOffsets[i] = file.ReadInt32();
			}

			ArrayList shells = new ArrayList();
			ArrayList holes = new ArrayList();

			int start, finish, length;
			for (int part = 0; part < numParts; part++)
			{
				start = partOffsets[part];
				if (part == numParts - 1)
				{
					finish = numPoints;
				}
				else 
				{
					finish = partOffsets[part + 1];
				}
				length = finish - start;
				Coordinates points = new Coordinates();
				points.Capacity=length;
				for (int i = 0; i < length; i++)
				{
					Coordinate external = new Coordinate(file.ReadDouble(), file.ReadDouble() );
					Coordinate internalCoord = geometryFactory.PrecisionModel.ToInternal(external);
					points.Add(internalCoord);
				}
				LinearRing ring = geometryFactory.CreateLinearRing(points);
				//Debug.Assert(ring.IsValid()==false,"Ring is not valid.");
				if (_cga.IsCCW(points))
				{
					holes.Add(ring);
				}
				else 
				{
					shells.Add(ring);
				}
			}

			//now we have a list of all shells and all holes
			ArrayList holesForShells = new ArrayList(shells.Count);
			for (int i = 0; i < shells.Count; i++)
			{
				holesForShells.Add(new ArrayList());
			}
			//find homes
			for (int i = 0; i < holes.Count; i++)
			{
				LinearRing testRing = (LinearRing) holes[i];
				LinearRing minShell = null;
				Envelope minEnv = null;
				Envelope testEnv = testRing.GetEnvelopeInternal();
				Coordinate testPt = testRing.GetCoordinateN(0);
				LinearRing tryRing;
				for (int j = 0; j < shells.Count; j++)
				{
					tryRing = (LinearRing) shells[j];
					Envelope tryEnv = tryRing.GetEnvelopeInternal();
					if (minShell != null) 
					{
						minEnv = minShell.GetEnvelopeInternal();
					}
					bool isContained = false;
					Coordinates coordList = tryRing.GetCoordinates() ;
					if (tryEnv.Contains(testEnv)
						&& (_cga.IsPointInRing(testPt,coordList ) ||
						(PointInList(testPt,coordList)))) 
					{
						isContained = true;
					}
					// check if this new containing ring is smaller than the
					// current minimum ring
					if (isContained) 
					{
						if (minShell == null
							|| minEnv.Contains(tryEnv)) 
						{
							minShell = tryRing;
						}
					}
				}
				//if (minShell==null)
				//{
				//	throw new InvalidOperationException("Could not find shell for a hole. Try a different precision model.");
				//}
			}
			Polygon[] polygons = new Polygon[shells.Count];
			for (int i = 0; i < shells.Count; i++)
			{
				polygons[i] = geometryFactory.CreatePolygon((LinearRing) shells[i], (LinearRing[])((ArrayList) holesForShells[i]).ToArray(typeof(LinearRing)));
			}
        
			if (polygons.Length == 1)
			{
				return polygons[0];
			}
			//it's a multi part
			return geometryFactory.CreateMultiPolygon(polygons);

		}
		/// <summary>
		/// Creates a multipolygon from the wkb.
		/// </summary>
		/// <returns>A geometry.</returns>
		private Geometry CreateWKBMultiPolygon()
		{
			//Get the number of Polygons.
			int numPolygons = (int)_bReader.ReadUInt32();

			//Create a new array for the Polygons.
			Polygon[] polygons = new Polygon[numPolygons];

			//Loop on the number of polygons.
			for(int i = 0; i < numPolygons; i++)
			{
				// read polygon header
				_bReader.ReadByte();
				_bReader.ReadUInt32();
				//Create the next polygon and add it to the array.
				polygons[i] = (Polygon)CreateWKBPolygon();
			}
			//Create and return the MultiPolygon.
			return _geometryFactory.CreateMultiPolygon(polygons);
		}
		/// <summary>
		///  Converts a Polygon to &lt;Polygon Tagged Text&gt; format,
		///  then Appends it to the writer.
		/// </summary>
		/// <param name="polygon">Th Polygon to process.</param>
		/// <param name="writer">The stream writer to Append to.</param>
		protected void AppendPolygonTaggedText(Polygon polygon,  TextWriter writer)
		{
			AppendPath(writer);
			AppendPolygonText(polygon, writer);
			AppendEndPath(writer);	
		}
Exemple #22
0
        private void AddPolygon( Polygon p )
        {
            AddPolygonRing(
                (LinearRing) p.GetExteriorRing(),
                Location.Exterior,
                Location.Interior );

            for ( int i = 0; i < p.GetNumInteriorRing(); i++ )
            {
                // Holes are topologically labelled opposite to the shell, since
                // the interior of the polygon lies on their opposite side
                // (on the left, if the hole is oriented CW)
                LinearRing interiorRing = p.GetInteriorRingN( i );
                AddPolygonRing(
                    interiorRing,
                    Location.Interior,
                    Location.Exterior);
            }
        }
		} // private int Locate( Coordinate p, LinearRing ring )

		private int Locate( Coordinate p, Polygon poly )
		{
			if ( poly.IsEmpty() ) 
			{
				return Location.Exterior;
			}

			LinearRing shell = (LinearRing) poly.GetExteriorRing();

			int shellLoc = Locate( p, shell );

			if ( shellLoc == Location.Exterior )
			{
				return Location.Exterior;
			}
			if ( shellLoc == Location.Boundary )
			{
				return Location.Boundary;
			}

			// now test if the point lies in or on the holes
			for ( int i = 0; i < poly.GetNumInteriorRing(); i++ ) 
			{
				int holeLoc = Locate( p, poly.GetInteriorRingN( i ) );
				if ( holeLoc == Location.Interior )
				{
					return Location.Exterior;
				}
				if ( holeLoc == Location.Boundary )
				{
					return Location.Boundary;
				}
			} // for ( int i = 0; i < poly.NumInteriorRings; i++ )
			return Location.Interior;
		} // private int Locate( Coordinate p, Polygon poly )
Exemple #24
0
		private void CheckValid(Polygon g)
		{
			GeometryGraph graph = new GeometryGraph(0, g);
			
			CheckTooFewPoints(graph);
			if (_validErr != null) return;
			CheckConsistentArea(graph);
			if (_validErr != null) return;
			CheckNoSelfIntersectingRings(graph);
			if (_validErr != null) return;
			CheckHolesInShell(g, graph);
			if (_validErr != null) return;
			//SLOWcheckHolesNotNested(g);
			CheckHolesNotNested(g, graph);
			if (_validErr != null) return;
			CheckConnectedInteriors(graph);	
		}