Пример #1
0
        public void VectorTile_Overzoom_Render()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Map m = new Map(256, 256);

            m.Load(@".\data\layer.xml");

            m.ZoomToBox(-20037508.34, -20037508.34, 20037508.34, 20037508.34);
            VectorTile v1 = new VectorTile(0, 0, 0, 256, 256);

            m.Render(v1);

            m.ZoomToBox(-20037508.34, 0, 0, 20037508.34);
            VectorTile v2 = new VectorTile(1, 0, 0, 256, 256);

            m.Render(v2);

            Map renderMap = new Map(256, 256);

            renderMap.Load(@".\data\style.xml");
            Image i1 = new Image(256, 256);
            Image i2 = new Image(256, 256);

            Dictionary <string, object> options = new Dictionary <string, object>();

            options["Z"] = 1;

            v1.Render(renderMap, i1, options);
            v2.Render(renderMap, i2);

            //Small diff showing up between images
            Assert.IsTrue(i1.Compare(i2) - 500 < 0);
        }
Пример #2
0
        public void Geometry_ToWKT()
        {
            string  input   = @"{
                type: ""Feature"",
                properties: {},
                geometry: {
                    type: ""Polygon"",
                    coordinates: [[[1,1],[1,2],[2,2],[2,1],[1,1]]]
                }
            }";
            JObject feature = JObject.Parse(input);

            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "csv.input"));
            Dictionary <string, object> options = new Dictionary <string, object>()
            {
                { "type", "csv" },
                { "inline", "geojson\n'" + feature["geometry"].ToString(Formatting.None) + "'" }
            };
            Datasource ds = new Datasource(options);
            Feature    f  = ds.Featureset().Next();

            string expected = "POLYGON((1 1,1 2,2 2,2 1,1 1))";

            Assert.AreEqual(expected, f.Geometry().ToWKT());
        }
Пример #3
0
        public void VectorTile_GeoJSON()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "geojson.input"));
            string     json = @"{""type"":""FeatureCollection"",""name"":""layer"",""features"":[{""type"":""Feature"",""geometry"":{""type"":""Point"",""coordinates"":[-121.9921875,47.9899216674142]},""properties"":{""name"":""geojson data""}}]}";
            VectorTile v    = new VectorTile(0, 0, 0);

            v.AddGeoJSON(json, "layer");
            byte[] bytes = v.GetData();
            Assert.AreEqual(53, bytes.Length);
            Assert.IsFalse(v.Empty());
            Assert.IsTrue(v.Painted());
            CollectionAssert.AreEquivalent(new List <string>()
            {
                "layer"
            }, v.Names().ToList());

            //ToGeoJSON
            dynamic expected = JObject.Parse(json);
            var     results  = new List <JObject>()
            {
                JObject.Parse(v.ToGeoJSON("layer")),
                JObject.Parse(v.ToGeoJSON(0))
            };

            foreach (dynamic actual in results)
            {
                Assert.AreEqual(expected.FeatureCollection, actual.FeatureCollection);
                Assert.AreEqual(expected.features[0].properties.name, actual.features[0].properties.name);
                Assert.AreEqual(expected.features[0].geometry.type, actual.features[0].geometry.type);
                Assert.AreEqual(expected.features[0].geometry.coordinates[0], actual.features[0].geometry.coordinates[0]);
                Assert.AreEqual(expected.features[0].geometry.coordinates[1], actual.features[0].geometry.coordinates[1]);
            }
        }
Пример #4
0
        public void Geometry_ToWKB()
        {
            string  input   = @"{
                type: ""Feature"",
                properties: {},
                geometry: {
                    type: ""Polygon"",
                    coordinates: [[[1,1],[1,2],[2,2],[2,1],[1,1]]]
                }
            }";
            JObject feature = JObject.Parse(input);

            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "csv.input"));
            Dictionary <string, object> options = new Dictionary <string, object>()
            {
                { "type", "csv" },
                { "inline", "geojson\n'" + feature["geometry"].ToString(Formatting.None) + "'" }
            };
            Datasource ds = new Datasource(options);
            Feature    f  = ds.Featureset().Next();

            string hex = "01030000000100000005000000000000000000f03f000000000000f03f000000000000f03f0000000000000040000000000000004000000000000000400000000000000040000000000000f03f000000000000f03f000000000000f03f";

            byte[] expected = Enumerable.Range(0, hex.Length)
                              .Where(x => x % 2 == 0)
                              .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                              .ToArray();
            byte[] actual = f.Geometry().ToWKB();
            CollectionAssert.AreEqual(expected, actual);
        }
Пример #5
0
        public void Grid_Encode_Resolution()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Map m = new Map(256, 256);

            m.Load(@".\data\test.xml");
            m.ZoomAll();
            Grid g1 = new Grid(256, 256);

            m.Render(g1);
            List <string> data = (List <string>)g1.Encode()["grid"];

            Assert.AreEqual(64, data.Count());
            Assert.AreEqual(64, data[0].Length);

            Grid g2 = new Grid(256, 256);

            m.Render(g2);
            var options = new Dictionary <string, object>()
            {
                { "Resolution", 1 }
            };

            data = (List <string>)g1.Encode(options)["grid"];
            Assert.AreEqual(256, data.Count());
            Assert.AreEqual(256, data[0].Length);
        }
Пример #6
0
        public void Grid_Painted()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Grid g = new Grid(256, 256);

            Assert.IsFalse(g.Painted());

            Map   m = new Map(256, 256);
            Layer l = new Layer("test");

            m.AddLayer(l);
            m.Render(g);
            Assert.IsFalse(g.Painted());

            m.Clear();
            m.Load(@".\data\test.xml");
            m.ZoomAll();
            var options = new Dictionary <string, object>()
            {
                { "Fields", new List <string>()
                  {
                      "FIPS"
                  } },
                { "Layer", "world" }
            };

            m.Render(g);
            Assert.IsTrue(g.Painted());
        }
Пример #7
0
        public void Grid_Encode()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Map m = new Map(256, 256);

            m.Load(@".\data\test.xml");
            m.ZoomAll();
            Grid g       = new Grid(256, 256);
            var  options = new Dictionary <string, object>()
            {
                { "Fields", new List <string>()
                  {
                      "FIPS"
                  } },
                { "Layer", "world" }
            };

            m.Render(g, options);
            Dictionary <string, object> UTFGridDict = g.Encode();

            Assert.AreEqual(UTFGridDict.Keys.Count, 3);

            //Test for keys
            List <string> keyList = (List <string>)UTFGridDict["keys"];

            Assert.AreNotEqual(keyList.Count, 0);

            //Test for data
            Dictionary <string, object> dataDict = (Dictionary <string, object>)UTFGridDict["data"];

            Assert.AreNotEqual(dataDict.Count, 0);

            //data count should equal keys + 1
            Assert.AreEqual(keyList.Count, dataDict.Count + 1);
        }
Пример #8
0
        public void VectorTile_SimpleComposite()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Map m = new Map(256, 256);

            m.Load(@".\data\layer.xml");
            m.ZoomAll();

            VectorTile v1 = new VectorTile(0, 0, 0, 256, 256);

            m.Render(v1);
            int v1before = v1.GetData().Length;

            VectorTile v2 = new VectorTile(0, 0, 0, 256, 256);

            m.Render(v2);

            v1.Composite(new List <VectorTile>()
            {
                v2
            });
            int v1after = v1.GetData().Length;

            Assert.AreEqual(v1before * 2, v1after);
        }
Пример #9
0
        public void VectorTile_OverzoomComposite()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Map m = new Map(256, 256);

            m.Load(@".\data\layer.xml");

            VectorTile v1 = new VectorTile(1, 0, 0, 256, 256);

            m.ZoomToBox(-20037508.34, 0, 0, 20037508.34);
            m.Render(v1);
            int v1before = v1.GetData().Length;

            VectorTile v2 = new VectorTile(0, 0, 0, 256, 256);

            m.ZoomToBox(-20037508.34, -20037508.34, 20037508.34, 20037508.34);
            m.Render(v2);

            v1.Composite(new List <VectorTile>()
            {
                v2
            });
            int v1after = v1.GetData().Length;

            //composite bytes will actually be a little bit bigger than 2* original
            //Assert.AreEqual(v1before * 2, v1after);
        }
Пример #10
0
        public void Plugins_Init()
        {
            Mapnik.RegisterDefaultInputPlugins();
            List <string> ds = Mapnik.Datasources().ToList();

            Assert.IsTrue(ds.Count > 0);

            //Should return false if we try to re-register plugins
            Assert.IsFalse(Mapnik.RegisterDatasources(Mapnik.Paths["InputPlugins"]));
        }
Пример #11
0
        public void Map_QueryMapPoint_SingleLayer()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Map m = new Map(256, 256);

            m.Load(@".\data\test.xml");
            m.ZoomAll();

            Dictionary <string, object> expected = new Dictionary <string, object>()
            {
                { "AREA", 915896L },
                { "FIPS", "US" },
                { "ISO2", "US" },
                { "ISO3", "USA" },
                { "LAT", 39.622 },
                { "LON", -98.606 },
                { "NAME", "United States" },
                { "POP2005", 299846449L },
                { "REGION", 19L },
                { "SUBREGION", 21L },
                { "UN", 840L }
            };

            IEnumerable <MapQueryResult> r;
            MapQueryResult mqr;
            Dictionary <string, object> actual;

            //query by layer name
            r = m.QueryMapPoint(55, 130, "world");
            Assert.AreEqual(r.Count(), 1);
            mqr = r.ToList()[0];
            Assert.AreEqual(mqr.Layer, "world");
            actual = new Dictionary <string, object>(mqr.Featureset.Next().Attributes());
            CollectionAssert.AreEquivalent(expected, actual);

            //query by layer index
            r = m.QueryMapPoint(55, 130, 0);
            Assert.AreEqual(r.Count(), 1);
            mqr = r.ToList()[0];
            Assert.AreEqual(mqr.Layer, "world");
            actual = new Dictionary <string, object>(mqr.Featureset.Next().Attributes());
            CollectionAssert.AreEquivalent(expected, actual);

            //query all
            //query by layer name
            r = r = m.QueryMapPoint(55, 130);
            Assert.AreEqual(r.Count(), 1);
            mqr = r.ToList()[0];
            Assert.AreEqual(mqr.Layer, "world");
            actual = new Dictionary <string, object>(mqr.Featureset.Next().Attributes());
            CollectionAssert.AreEquivalent(expected, actual);
        }
Пример #12
0
        public void VectorTile_IsSolid()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Map m = new Map(256, 256);

            m.Load(@".\data\layer.xml");
            m.Extent = new double[] { -11271098.442818949, 4696291.017841229, -11192826.925854929, 4774562.534805249 };
            VectorTile v = new VectorTile(9, 112, 195);

            m.Render(v);
            Assert.IsTrue(v.Painted());
            Assert.AreEqual("world", v.IsSolid());
        }
Пример #13
0
        public void Datasource_Creation()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Dictionary <string, object> options = new Dictionary <string, object>()
            {
                { "type", "shape" },
                { "file", @".\data\world_merc.shp" }
            };

            Datasource d = new Datasource(options);

            string expectedType     = "vector";
            string expectedEncoding = "utf-8";
            string expectedGeomType = "polygon";
            Dictionary <string, string> expectedFields = new Dictionary <string, string>()
            {
                { "FIPS", "String" },
                { "ISO2", "String" },
                { "ISO3", "String" },
                { "UN", "Number" },
                { "NAME", "String" },
                { "AREA", "Number" },
                { "POP2005", "Number" },
                { "REGION", "Number" },
                { "SUBREGION", "Number" },
                { "LON", "Number" },
                { "LAT", "Number" }
            };

            double[] expectedExtent = new double[]
            {
                -20037508.342789248,
                -8283343.6938826973,
                20037508.342789244,
                18365151.363070473
            };

            Dictionary <string, object> p = new Dictionary <string, object>(d.Paramemters());

            CollectionAssert.AreEquivalent(p, options);

            double[] e = d.Extent();
            CollectionAssert.AreEqual(e, expectedExtent);

            IDictionary <string, object> desc = d.Describe();

            Assert.AreEqual(desc["type"], expectedType);
            Assert.AreEqual(desc["encoding"], expectedEncoding);
            Assert.AreEqual(desc["geometry_type"], expectedGeomType);
            CollectionAssert.AreEquivalent((Dictionary <string, string>)desc["fields"], expectedFields);
        }
Пример #14
0
        public void Font_GlobalFonts()
        {
            Mapnik.RegisterDefaultFonts();
            Mapnik.RegisterSystemFonts();
            IDictionary <string, string> files = Mapnik.FontFiles();
            IEnumerable <string>         fonts = Mapnik.Fonts();

            Assert.IsTrue(fonts.Count() > 0);
            Assert.IsTrue(files.Count() > 0);
            CollectionAssert.AreEquivalent(files.Keys.ToList(), fonts.ToList());

            // Registering system fonts should always fail on retry
            Assert.IsFalse(Mapnik.RegisterSystemFonts());
        }
Пример #15
0
        public void GridView_GetPixel()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Map m = new Map(256, 256);

            m.Load(@".\data\test.xml");
            m.ZoomAll();
            Grid g = new Grid(256, 256);

            m.Render(g);
            GridView v     = g.View(0, 0, 256, 256);
            long     pixel = v.GetPixel(25, 100);

            Assert.AreEqual(207, pixel);
        }
Пример #16
0
        public void Geometry_ToJSON()
        {
            string expected = @"{""type"":""Polygon"",""coordinates"":[[[1,1],[1,2],[2,2],[2,1],[1,1]]]}";

            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "csv.input"));
            var options = new Dictionary <string, object>()
            {
                { "type", "csv" },
                { "inline", "geojson\n'" + expected + "'" }
            };
            Datasource ds     = new Datasource(options);
            Feature    f      = ds.Featureset().Next();
            string     actual = f.Geometry().ToJSON();

            Assert.AreEqual(expected, actual);
        }
Пример #17
0
        public void VectorTile_Render_Grid()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Map m = new Map(256, 256);

            m.Load(@".\data\layer.xml");
            m.Extent = new double[] { -20037508.34, 0, 0, 20037508.34 };
            VectorTile v = new VectorTile(1, 0, 0);

            m.Render(v);

            VectorTile v2 = new VectorTile(1, 0, 0);

            v2.SetData(v.GetData());

            Map m2 = new Map(256, 256);

            m2.Load(@".\data\style.xml");
            Grid g       = new Grid(256, 256);
            var  options = new Dictionary <string, object>()
            {
                { "Fields", new List <string>()
                  {
                      "FIPS"
                  } },
                { "Layer", "world" }
            };

            v2.Render(m2, g, options);
            Dictionary <string, object> grid = g.Encode();

            Assert.AreEqual(grid.Keys.Count, 3);

            //Test for keys
            List <string> keyList = (List <string>)grid["keys"];

            Assert.AreNotEqual(keyList.Count, 0);

            //Test for data
            Dictionary <string, object> dataDict = (Dictionary <string, object>)grid["data"];

            Assert.AreNotEqual(dataDict.Count, 0);

            //data count should equal keys + 1
            Assert.AreEqual(keyList.Count, dataDict.Count + 1);
        }
Пример #18
0
        public void Image_Painted()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Image i = new Image(256, 256);

            Assert.IsFalse(i.Painted());

            Map m = new Map(256, 256);

            m.ZoomAll();
            m.Render(i);
            Assert.IsFalse(i.Painted());

            m.Load(@".\data\test.xml");
            m.ZoomAll();
            m.Render(i);
            Assert.IsTrue(i.Painted());
        }
Пример #19
0
        public void Grid_Fields()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Map m = new Map(256, 256);

            m.Load(@".\data\test.xml");
            m.ZoomAll();
            Grid          g        = new Grid(256, 256);
            List <string> expected = new List <string>()
            {
                "FIPS"
            };
            var options = new Dictionary <string, object>()
            {
                { "Fields", expected }
            };

            m.Render(g, options);

            CollectionAssert.AreEquivalent(expected, g.Fields().ToList());
        }
Пример #20
0
        public void Layer_Describe()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Dictionary <string, object> options = new Dictionary <string, object>()
            {
                { "type", "shape" },
                { "file", @".\data\world_merc.shp" }
            };
            Datasource ds = new Datasource(options);

            Layer l = new Layer("layer", "+init=epsg:4326");

            l.Datasource = ds;

            IDictionary <string, object> d = l.Describe();

            Assert.AreEqual((string)d["name"], "layer");
            Assert.AreEqual((string)d["srs"], "+init=epsg:4326");
            CollectionAssert.AreEquivalent(((List <string>)d["styles"]), new List <string>());
            CollectionAssert.AreEquivalent((Dictionary <string, object>)d["datasource"], options);
        }
Пример #21
0
        public void Map_QueryMapPoint_MultipleLayers()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Map m = new Map(256, 256);

            m.Load(@".\data\test.xml");

            Layer      l = new Layer("world2");
            Datasource d = new Datasource(
                new Dictionary <string, object>()
            {
                { "type", "shape" },
                { "file", @".\data\world_merc.shp" }
            }
                );

            l.Datasource = d;
            m.AddLayer(l);
            m.ZoomAll();

            IEnumerable <MapQueryResult> r;

            //query single layer
            r = m.QueryMapPoint(55, 130, "world2");
            Assert.AreEqual(r.Count(), 1);
            MapQueryResult mqr = r.ToList()[0];

            Assert.AreEqual(mqr.Layer, "world2");

            //query all
            r = m.QueryMapPoint(55, 130);
            Assert.AreEqual(r.Count(), 2);
            MapQueryResult mqr1 = r.ToList()[0];

            Assert.AreEqual(mqr1.Layer, "world");
            MapQueryResult mqr2 = r.ToList()[1];

            Assert.AreEqual(mqr2.Layer, "world2");
        }
Пример #22
0
        public void Featureset_Creation()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Dictionary <string, object> options = new Dictionary <string, object>()
            {
                { "type", "shape" },
                { "file", @".\data\world_merc.shp" }
            };

            Datasource d       = new Datasource(options);
            Featureset fs      = d.Featureset();
            Feature    feature = fs.Next();
            Dictionary <string, object> attr         = new Dictionary <string, object>(feature.Attributes());
            Dictionary <string, object> expectedAttr = new Dictionary <string, object>()
            {
                { "AREA", 44L },
                { "FIPS", "AC" },
                { "ISO2", "AG" },
                { "ISO3", "ATG" },
                { "LAT", 17.078 },
                { "LON", -61.783 },
                { "NAME", "Antigua and Barbuda" },
                { "POP2005", 83039L },
                { "REGION", 19L },
                { "SUBREGION", 29L },
                { "UN", 28L }
            };

            CollectionAssert.AreEquivalent(attr, expectedAttr);

            int count = 1;

            while (fs.Next() != null)
            {
                count++;
            }
            Assert.AreEqual(count, 245);
        }
Пример #23
0
        public void Geometry_ToJSON_ProjTransform()
        {
            string expected = @"{""type"":""Polygon"",""coordinates"":[[[1,1],[1,2],[2,2],[2,1],[1,1]]]}";

            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "csv.input"));
            var options = new Dictionary <string, object>()
            {
                { "type", "csv" },
                { "inline", "geojson\n'" + expected + "'" }
            };
            Datasource ds     = new Datasource(options);
            Feature    f      = ds.Featureset().Next();
            string     actual = f.Geometry().ToJSON();

            Assert.AreEqual(expected, actual);

            Projection    src         = new Projection("+init=epsg:4326");
            Projection    dest        = new Projection("+init=epsg:3857");
            ProjTransform tran        = new ProjTransform(src, dest);
            string        transformed = f.Geometry().ToJSON(tran);

            Assert.AreNotEqual(expected, transformed);
        }
Пример #24
0
        public void GridView_IsSolid()
        {
            Map m = new Map(256, 256);

            m.AddLayer(new Layer("test"));
            m.ZoomAll();
            Grid g = new Grid(256, 256);

            m.Render(g);
            GridView v1 = g.View(0, 0, 256, 256);

            Assert.IsTrue(v1.IsSolid());

            m.Clear();
            g.Clear();
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            m.Load(@".\data\test.xml");
            m.ZoomAll();
            m.Render(g);
            GridView v2 = g.View(0, 0, 256, 256);

            Assert.IsFalse(v2.IsSolid());
        }
Пример #25
0
        public void VectorTile_Render_Image()
        {
            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "shape.input"));
            Map m = new Map(256, 256);

            m.Load(@".\data\layer.xml");
            m.Extent = new double[] { -20037508.34, 0, 0, 20037508.34 };
            VectorTile v = new VectorTile(1, 0, 0);

            m.Render(v);

            VectorTile v2 = new VectorTile(1, 0, 0);

            v2.SetData(v.GetData());

            Map m2 = new Map(256, 256);

            m2.Load(@".\data\style.xml");
            Image i = new Image(256, 256);

            v2.Render(m2, i);
            Assert.AreEqual(0, i.Compare(Image.Open(@".\data\world_1.0.0.png")));
        }
Пример #26
0
        public void Feature_ToJSON()
        {
            string  input    = @"{
                type: ""Feature"",
                properties: {},
                geometry: {
                    type: ""Polygon"",
                    coordinates: [[[1,1],[1,2],[2,2],[2,1],[1,1]]]
                }
            }";
            JObject expected = JObject.Parse(input);

            Mapnik.RegisterDatasource(Path.Combine(Mapnik.Paths["InputPlugins"], "csv.input"));
            Dictionary <string, object> options = new Dictionary <string, object>()
            {
                { "type", "csv" },
                { "inline", "geojson\n'" + expected["geometry"].ToString(Formatting.None) + "'" }
            };
            Datasource ds = new Datasource(options);

            Feature f       = ds.Featureset().Next();
            JObject feature = JObject.Parse(f.ToJSON());

            Assert.AreEqual(expected["type"], feature["type"]);
            Assert.AreEqual(((JObject)expected["properties"]).Count, ((JObject)feature["properties"]).Count);
            Assert.AreEqual(expected["geometry"]["type"], feature["geometry"]["type"]);

            JArray coords = (JArray)expected["geometry"]["coordinates"][0];

            for (int i = 0; i < coords.Count; i++)
            {
                JArray coord1 = (JArray)expected["geometry"]["coordinates"][0][i];
                JArray coord2 = (JArray)feature["geometry"]["coordinates"][0][i];
                CollectionAssert.AreEquivalent(coord1.ToObject <List <double> >(), coord2.ToObject <List <double> >());
            }
        }