def test_object_stewart_two_var(self): # Test the OO approach with two variables : StePot = SmoothStewart("misc/nuts3_data.geojson", "gdppps2008", span=65000, beta=2, resolution=80000, variable_name2="pop2008", mask="misc/nuts3_data.geojson") result = StePot.render(8, "equal_interval", output="Geodataframe") self.assertIsInstance(result, GeoDataFrame) self.assertEqual(len(result), 8)
def test_from_polygon_layer_no_crs(self): gdf = GeoDataFrame.from_file("misc/nuts3_data.geojson") gdf.crs = '' # Convert the input layer to a polygon layer (instead of multipolygon): gdf.geometry = gdf.geometry.union(gdf.geometry) StePot = SmoothStewart(gdf, "gdppps2008", span=65000, beta=2, resolution=100000, mask="misc/nuts3_data.geojson") # Use equal interval : result = StePot.render(8, "equal_interval", output="Geodataframe") self.assertIsInstance(result, GeoDataFrame) self.assertEqual(len(result), 8)
def test_from_point_layer_and_maximal_breaks(self): gdf = GeoDataFrame.from_file("misc/nuts3_data.geojson").to_crs({"init": "epsg:4326"}) # Convert the input layer to a point layer : gdf.geometry = gdf.geometry.centroid StePot = SmoothStewart(gdf, "gdppps2008", span=65000, beta=2, resolution=80000, mask="misc/nuts3_data.geojson") # Use equal interval : result = StePot.render(9, "equal_interval", output="Geodataframe") self.assertIsInstance(result, GeoDataFrame) self.assertEqual(len(result), 9) # Use maximal breaks discretisation method: result = StePot.render(9, "maximal_breaks", output="Geodataframe") self.assertIsInstance(result, GeoDataFrame)
def test_object_stewart(self): # Test the OO approach for building smoothed map with stewart potentials StePot = SmoothStewart("misc/nuts3_data.geojson", "pop2008", span=65000, beta=2, resolution=90000, mask="misc/nuts3_data.geojson") # Test using percentiles : result = StePot.render(nb_class=10, disc_func="percentiles", output="geodataframe") self.assertIsInstance(result, GeoDataFrame) self.assertEqual(len(result), 10) # Test using somes already choosed break values : my_breaks = [0, 197000, 1295000, 2093000, 3091000, 5888000, 10186000, 12000000] result = StePot.render( nb_class=48, # bogus values as `nb_class` and disc_func="foobar", # ... disc_func should be overrided user_defined_breaks=my_breaks, # ... by the `user_defined_breaks` params output="geodataframe") # ... and this is what we are testing here self.assertIsInstance(result, GeoDataFrame) self.assertEqual(len(result), 8) # Assert these break values were actually used : for wanted_break, obtained_break in zip(my_breaks[1:-1], result["max"][:-1]): self.assertAlmostEqual(wanted_break, obtained_break) # Test again using another discretization method : "head tail breaks" # (should define automatically the number of class) result = StePot.render(nb_class=None, disc_func="head_tail", output="geodataframe") self.assertIsInstance(result, GeoDataFrame) # Test that the object has a nice representation : a = str(StePot) b = repr(StePot) self.assertEqual(a, b) self.assertIn("SmoothStewart - variable :", a) self.assertIn("{} features".format(len(StePot.gdf)), a)
def test_distance_not_geo(self): # First whith one variable : StePot = SmoothStewart("misc/nuts3_data.geojson", "gdppps2008", resolution=100000, span=65000, beta=3, mask="misc/nuts3_data.geojson", distGeo=False) result = StePot.render(8, "equal_interval", output="Geodataframe") self.assertIsInstance(result, GeoDataFrame) self.assertEqual(len(result), 8) # Then with two variables and a custom projection to use : StePot = SmoothStewart("misc/nuts3_data.geojson", "gdppps2008", span=65000, beta=2, resolution=80000, variable_name2="pop2008", mask="misc/nuts3_data.geojson", distGeo=False, projDistance={"init": "epsg:3035"}) result = StePot.render(8, "equal_interval", output="Geodataframe") self.assertIsInstance(result, GeoDataFrame) self.assertEqual(len(result), 8) self.assertEqual(result.crs, {'init': 'epsg:3035'})
def test_errors(self): # Test with a wrong interaction function name : with self.assertRaises(ValueError): StePot = SmoothStewart("misc/nuts3_data.geojson", "gdppps2008", span=65000, beta=2, typefct="abcdefg") StePot = SmoothStewart("misc/nuts3_data.geojson", "gdppps2008", span=65000, beta=2, resolution=90000) # Test with a wrong discretization function name : with self.assertRaises(ValueError): StePot.render(9, "foo", output="Geodataframe")
def test_wrong_dtype_missing_values(self): gdf = GeoDataFrame.from_file("misc/nuts3_data.geojson") gdf.loc[12:18, "gdppps2008"] = np.NaN gdf.loc[25:35, "pop2008"] = np.NaN gdf.loc[0:len(gdf)-1, "pop2008"] = gdf["pop2008"].astype(str) StePot = SmoothStewart(gdf, "gdppps2008", span=65000, beta=2, resolution=100000, mask="misc/nuts3_data.geojson") result = StePot.render(9, "equal_interval", output="Geodataframe") self.assertIsInstance(result, GeoDataFrame) self.assertEqual(len(result), 9) StePot = SmoothStewart(gdf, "gdppps2008", variable_name2="pop2008", span=65000, beta=2, resolution=100000, mask="misc/nuts3_data.geojson") result = StePot.render(9, "equal_interval", output="Geodataframe") self.assertIsInstance(result, GeoDataFrame) self.assertEqual(len(result), 9)
def test_input_with_missing_values(self): gdf = GeoDataFrame.from_file("misc/nuts3_data.geojson") gdf.loc[12:18, "gdppps2008"] = np.NaN StePot = SmoothStewart(gdf, "gdppps2008", span=65000, beta=2, resolution=100000, mask=gdf) result = StePot.render(9, "equal_interval", output="Geodataframe") self.assertIsInstance(result, GeoDataFrame) self.assertEqual(len(result), 9) gdf2 = GeoDataFrame.from_file('misc/nuts3_data.geojson').to_crs({"init": "epsg:3035"}) gdf2.loc[:, 'gdppps2008'] = gdf2['gdppps2008'].astype(object) gdf2.loc[15:20, 'gdppps2008'] = "" gdf2.loc[75:78, 'gdppps2008'] = "" StePot = SmoothStewart(gdf2, 'gdppps2008', span=65000, beta=2, resolution=80000, mask=gdf2) result = StePot.render(9, 'equal_interval', output="GeoDataFrame") self.assertIsInstance(result, GeoDataFrame) self.assertEqual(len(result), 9)
def test_from_gdf_with_new_mask(self): gdf = GeoDataFrame.from_file("misc/nuts3_data.geojson") # Let's use pareto function for this one : StePot = SmoothStewart(gdf, "gdppps2008", typefct="pareto", span=65000, beta=2.33, resolution=80000, mask=None) result = StePot.render(6, output="Geodataframe") self.assertIsInstance(result, GeoDataFrame) self.assertEqual(len(result), 6) # Finally, use a mask (from a file) : result = StePot.render(5, output="Geodataframe", new_mask="misc/nuts3_data.geojson") self.assertIsInstance(result, GeoDataFrame) self.assertEqual(StePot.use_mask, True) self.assertEqual(len(result), 5) # Or from a GeoDataFrame : result = StePot.render(6, output="Geodataframe", new_mask=gdf) self.assertIsInstance(result, GeoDataFrame) self.assertEqual(StePot.use_mask, True) self.assertEqual(len(result), 6) # # Nope, no mask : # result = StePot.render(5, output="Geodataframe", # new_mask=None) # self.assertIsInstance(result, GeoDataFrame) # self.assertEqual(StePot.use_mask, False) # self.assertEqual(len(result), 5) # Test that it skips the mask parameter if the layer provided as a mask # is not a Polygon/MultiPolygon layer : gdf_mask = gdf[1:50].copy() gdf_mask.geometry = gdf_mask.geometry.centroid result = StePot.render(5, output="Geodataframe", new_mask=gdf_mask) self.assertIsInstance(result, GeoDataFrame) self.assertEqual(StePot.use_mask, False) self.assertEqual(len(result), 5)
def quick_stewart_mod(input_geojson_points, variable_name, span, beta=2, typefct='exponential', nb_class=None, disc_kind=None, resolution=None, mask=None, variable_name2=None, user_defined_breaks=None): """ Compute a smoothed map (modified function from smoomapy). Parameters ---------- input_geojson_points: str Path to file to use as input (Points/Polygons), must contains a relevant numerical field. variable_name: str The name of the variable to use (numerical field only). span: int The span! beta: float The beta! typefct: str, default "exponential" The type of function in {"exponential", "pareto"} nb_class: int, default None The number of class, if unset will most likely be 8. resolution: int, default None The resolution to use (in unit of the input file), if not set a resolution will be used in order to make a grid containing around 12000 pts. mask: str, default None Path to the file (Polygons only) to use as clipping mask. user_defined_breaks: list or tuple, default None A list of ordered break to use to construct the contours (override `nb_class` value if any) Returns ------- smoothed_geojson: bytes The result dumped as GeoJSON (utf-8 encoded). breaks: dict The break values used. """ StePot = SmoothStewart( input_geojson_points, variable_name, span, beta, typefct, resolution=resolution, variable_name2=variable_name2, mask=mask, distGeo=False, projDistance='+proj=natearth') result = StePot.render(nb_class, disc_kind, user_defined_breaks, output="GeoDataFrame") _min, _max = result[["min", "max"]].values.T.tolist() result.to_crs({'init': 'epsg:4326'}, inplace=True) if not mask: # In some weird cases, when not using a clipping mask, some resulting # geometries seems to be malformed, but hopefully saving it # to shapefile then reopening it seems to fix that: res = save_reload(result) else: res = json.loads(result[::-1].to_json()) repairCoordsPole(res) return ( json.dumps(res).encode(), {"min": _min[::-1], "max": _max[::-1]})