示例#1
0
        public void ReadShapeFile_ShapeFileWithSingeFeatureMultiplePolygons_ReturnShapes()
        {
            // Setup
            string shape = TestHelper.GetTestDataPath(TestDataPath.Core.Components.Gis.IO,
                                                      "Single_Multi-Polygon_with_ID.shp");

            using (var reader = new PolygonShapeFileReader(shape))
            {
                // Call
                var polygon = (MapPolygonData)reader.ReadShapeFile();

                // Assert
                Assert.IsNotNull(polygon);
                MapFeature[] polygonFeatures = polygon.Features.ToArray();
                Assert.AreEqual(1, polygonFeatures.Length);

                MapGeometry[] polygonGeometries = polygonFeatures[0].MapGeometries.ToArray();
                Assert.AreEqual(2, polygonGeometries.Length);

                IEnumerable <Point2D>[] polygonPointCollections = polygonGeometries[0].PointCollections.ToArray();
                Assert.AreEqual(1, polygonPointCollections.Length);

                Point2D[] firstPointCollection = polygonPointCollections[0].ToArray();
                Assert.AreEqual(7, firstPointCollection.Length);
                Assert.AreEqual(-2.257, firstPointCollection[4].X, 1e-1);
                Assert.AreEqual(0.419, firstPointCollection[4].Y, 1e-1);

                Assert.AreEqual(1, polygonFeatures[0].MetaData.Count);
                Assert.AreEqual(1, polygonFeatures[0].MetaData["id"]);
                Assert.AreEqual("id", polygon.SelectedMetaDataAttribute);
            }
        }
示例#2
0
        public void ReadShapeFile_WithoutName_MapDataHasDefaultName(string name)
        {
            // Setup
            string shapeWithOnePolygon = TestHelper.GetTestDataPath(TestDataPath.Core.Components.Gis.IO,
                                                                    "Single_Polygon_with_ID.shp");

            using (var reader = new PolygonShapeFileReader(shapeWithOnePolygon))
            {
                // Call
                var polygon = (MapPolygonData)reader.ReadShapeFile(name);

                // Assert
                Assert.AreEqual("Polygoon", polygon.Name);
            }
        }
示例#3
0
        public void ReadShapeFile_ShapeFileWithMultiplePolygonFeatures_ReturnShapes()
        {
            // Setup
            string shapeWithMultiplePolygons = TestHelper.GetTestDataPath(TestDataPath.Core.Components.Gis.IO,
                                                                          "Multiple_Polygon_with_ID.shp");

            using (var reader = new PolygonShapeFileReader(shapeWithMultiplePolygons))
            {
                // Precondition
                Assert.AreEqual(4, reader.GetNumberOfFeatures());

                // Call
                var polygons = (MapPolygonData)reader.ReadShapeFile();

                // Assert
                MapFeature[] features = polygons.Features.ToArray();
                Assert.AreEqual(4, features.Length);
                Assert.AreEqual(1, polygons.MetaData.Count());
                Assert.AreEqual("id", polygons.SelectedMetaDataAttribute);

                #region Assertsions for 'polygon1'

                MapFeature    polygon1         = features[0];
                MapGeometry[] polygon1Geometry = polygon1.MapGeometries.ToArray();
                Assert.AreEqual(1, polygon1Geometry.Length);

                IEnumerable <Point2D>[] polygon1PointCollections = polygon1Geometry[0].PointCollections.ToArray();
                Assert.AreEqual(1, polygon1PointCollections.Length);

                Point2D[] polygon1FirstPointCollection = polygon1PointCollections[0].ToArray();
                Assert.AreEqual(6, polygon1FirstPointCollection.Length);
                Assert.AreEqual(-1.070, polygon1FirstPointCollection[2].X, 1e-1);
                Assert.AreEqual(0.066, polygon1FirstPointCollection[2].Y, 1e-1);

                Assert.AreEqual(1, polygon1.MetaData.Count);
                Assert.AreEqual(4, polygon1.MetaData["id"]);

                #endregion

                #region Assertsions for 'polygon2'

                MapFeature    polygon2         = features[1];
                MapGeometry[] polygon2Geometry = polygon2.MapGeometries.ToArray();
                Assert.AreEqual(1, polygon2Geometry.Length);

                IEnumerable <Point2D>[] polygon2PointCollections = polygon2Geometry[0].PointCollections.ToArray();
                Assert.AreEqual(1, polygon2PointCollections.Length);

                Point2D[] polygon2FirstPointCollection = polygon2PointCollections[0].ToArray();
                Assert.AreEqual(25, polygon2FirstPointCollection.Length);
                Assert.AreEqual(-2.172, polygon2FirstPointCollection[23].X, 1e-1);
                Assert.AreEqual(0.212, polygon2FirstPointCollection[23].Y, 1e-1);

                Assert.AreEqual(1, polygon2.MetaData.Count);
                Assert.AreEqual(3, polygon2.MetaData["id"]);

                #endregion

                #region Assertsions for 'polygon3'

                MapFeature    polygon3         = features[2];
                MapGeometry[] polygon3Geometry = polygon3.MapGeometries.ToArray();
                Assert.AreEqual(1, polygon3Geometry.Length);

                IEnumerable <Point2D>[] polygon3PointCollections = polygon3Geometry[0].PointCollections.ToArray();
                Assert.AreEqual(1, polygon3PointCollections.Length);

                Point2D[] polygon3FirstPointCollection = polygon3PointCollections[0].ToArray();
                Assert.AreEqual(10, polygon3FirstPointCollection.Length);
                Assert.AreEqual(-1.091, polygon3FirstPointCollection[0].X, 1e-1);
                Assert.AreEqual(0.566, polygon3FirstPointCollection[0].Y, 1e-1);

                Assert.AreEqual(1, polygon3.MetaData.Count);
                Assert.AreEqual(2, polygon3.MetaData["id"]);

                #endregion

                #region Assertsions for 'polygon4'

                MapFeature    polygon4         = features[3];
                MapGeometry[] polygon4Geometry = polygon4.MapGeometries.ToArray();
                Assert.AreEqual(1, polygon4Geometry.Length);

                IEnumerable <Point2D>[] polygon4PointCollections = polygon4Geometry[0].PointCollections.ToArray();
                Assert.AreEqual(1, polygon4PointCollections.Length);

                Point2D[] polygon4FirstPointCollection = polygon4PointCollections[0].ToArray();
                Assert.AreEqual(9, polygon4FirstPointCollection.Length);
                Assert.AreEqual(-1.917, polygon4FirstPointCollection[8].X, 1e-1);
                Assert.AreEqual(0.759, polygon4FirstPointCollection[8].Y, 1e-1);

                Assert.AreEqual(1, polygon4.MetaData.Count);
                Assert.AreEqual(1, polygon4.MetaData["id"]);

                #endregion
            }
        }
        private ReadResult <FeatureBasedMapData> ReadFeatureBasedMapData()
        {
            try
            {
                string    shapeFileName = Path.GetFileNameWithoutExtension(FilePath);
                Shapefile featureSet    = Shapefile.OpenFile(FilePath);

                FeatureBasedMapData importedData;

                switch (featureSet.FeatureType)
                {
                case FeatureType.Point:
                case FeatureType.MultiPoint:
                    using (ShapeFileReaderBase reader = new PointShapeFileReader(FilePath))
                    {
                        importedData = reader.ReadShapeFile(shapeFileName);
                    }

                    break;

                case FeatureType.Line:
                    using (ShapeFileReaderBase reader = new PolylineShapeFileReader(FilePath))
                    {
                        importedData = reader.ReadShapeFile(shapeFileName);
                    }

                    break;

                case FeatureType.Polygon:
                    using (ShapeFileReaderBase reader = new PolygonShapeFileReader(FilePath))
                    {
                        importedData = reader.ReadShapeFile(shapeFileName);
                    }

                    break;

                default:
                    throw new CriticalFileReadException(Resources.FeatureBasedMapDataImporter_Import_ShapeFile_Contains_Unsupported_Data);
                }

                return(new ReadResult <FeatureBasedMapData>(false)
                {
                    Items = new[]
                    {
                        importedData
                    }
                });
            }
            catch (ArgumentException)
            {
                return(HandleCriticalFileReadError(Resources.FeatureBasedMapDataImporter_Import_File_does_not_contain_geometries));
            }
            catch (FileNotFoundException)
            {
                return(HandleCriticalFileReadError(Resources.FeatureBasedMapDataImporter_Import_File_does_not_exist_or_misses_needed_files));
            }
            catch (IOException)
            {
                return(HandleCriticalFileReadError(Resources.FeatureBasedMapDataImporter_Import_An_error_occurred_when_trying_to_read_the_file));
            }
            catch (CriticalFileReadException e)
            {
                return(HandleCriticalFileReadError(e.Message));
            }
            catch (Exception)
            {
                // Because NullReferenceException or NotImplementedException when reading in a corrupt shape file
                // from a third party library is expected, we catch all the exceptions here.
                return(HandleCriticalFileReadError(Resources.FeatureBasedMapDataImporter_Import_An_error_occurred_when_trying_to_read_the_file));
            }
        }