def test_geoseries_warning(self):
     # Geopandas Issue #305
     with pytest.raises(NotImplementedError):
         overlay(self.polydf,
                 self.polydf2.geometry,
                 how="union",
                 **self.kwargs)
    def test_geometry_not_named_geometry(self):
        # Geopandas Issue #306
        # Add points and flip names
        polydf3 = self.polydf.copy()
        polydf3 = polydf3.rename(columns={'geometry': 'polygons'})
        polydf3 = polydf3.set_geometry('polygons')
        polydf3['geometry'] = self.pointdf.geometry.loc[0:4]
        assert polydf3.geometry.name == 'polygons'

        df = overlay(polydf3, self.polydf2, how="union", **self.kwargs)
        assert type(df) is GeoDataFrame
        df2 = overlay(self.polydf, self.polydf2, how="union", **self.kwargs)
        assert df.geom_almost_equals(df2).all()
    def test_union_no_index(self):
        # explicitly ignore indicies
        dfB = overlay(self.polydf,
                      self.polydf2,
                      how="union",
                      use_sindex=False,
                      **self.kwargs)
        assert dfB.shape == self.union_shape

        # remove indicies from df
        self.polydf._sindex = None
        self.polydf2._sindex = None
        dfC = overlay(self.polydf, self.polydf2, how="union", **self.kwargs)
        assert dfC.shape == self.union_shape
    def test_symmetric_difference(self):
        df = overlay(self.polydf,
                     self.polydf2,
                     how="symmetric_difference",
                     **self.kwargs)

        assert df.shape == (15, 9)
 def test_intersection(self):
     df = overlay(self.polydf,
                  self.polydf2,
                  how="intersection",
                  **self.kwargs)
     assert df['BoroName'][0] is not None
     assert df.shape == (68, 7)
    def test_difference(self):
        df = overlay(self.polydf,
                     self.polydf2,
                     how="difference",
                     **self.kwargs)

        rows, cols = self.polydf.shape

        assert df.shape == (rows, cols + 1)  #add one for the index
    def test_union_no_index(self):
        # explicitly ignore indicies
        df = overlay(self.polydf,
                     self.polydf2,
                     how="union",
                     keep_index=False,
                     **self.kwargs)

        assert df.shape[1] == 7
    def test_difference(self):
        df = overlay(self.polydf,
                     self.polydf2,
                     how="difference",
                     **self.kwargs)
        # ALERT: the original difference algorithm creates invalid columns.
        # If taking the difference of polydf and polydf2, there should be no
        # geometries containing any attributes from polydf2. Yet the original
        # algorithm creates the attribute fields for all fields in polydf2 and
        # fills them with `None` or `NaN`.

        # assert df.shape == (86, 7) #this shape contains 2 invalid columns

        # df = geopandas.overlay(polydf, polydf2, how='difference')
        # df.dropna().shape
        # >>> (86, 5)
        assert df.shape == (86, 5)
    def test_identity(self):
        df = overlay(self.polydf, self.polydf2, how="identity", **self.kwargs)
        df['area'] = df.geometry.area

        polydf = self.polydf.copy()

        polydf['area'] = polydf.geometry.area
        ck = polydf.groupby(polydf.index)['area'].sum()
        check = df.groupby(['idx1'])['area'].sum()
        df_area = df.geometry.area.sum()
        polydf_area = self.polydf.geometry.area.sum()
        error = (polydf_area - df_area) / polydf_area

        assert -self.tol < error < self.tol
        assert_series_equal(check,
                            ck,
                            check_names=False,
                            check_index_type=False)
        assert df.shape[1] == 9 + 1  # add one for the 'area' field
Ejemplo n.º 10
0
    def test_symmetric_difference(self):
        df = overlay(self.polydf,
                     self.polydf2,
                     how="symmetric_difference",
                     **self.kwargs)
        # ALERT: the original algorithm creates invalid geometries.
        # Symmetric differece geometries should be in either polydf or polydf2.
        # Any resulting geometries without attributes from one or the other is
        # completely invalid.

        # assert df.shape == (122, 7) # this shape contains invalid geometries

        # Use 'Shape_Area' as the field to indicate polydf and 'value1' as the
        # field for polydf2
        # df = geopandas.overlay(polydf, polydf2, how="symmetric_difference")
        # len(df.loc[(out['Shape_Area'].isnull()) & (df['value1'].isnull())])
        # >>> 10
        invalid_sym_diff_geom_len = 10
        assert df.shape == (122 - invalid_sym_diff_geom_len, 7)
Ejemplo n.º 11
0
    def test_union(self):
        df = overlay(self.polydf, self.polydf2, how="union", **self.kwargs)
        df['area'] = df.geometry.area

        polydf = self.polydf.copy()
        polydf2 = self.polydf2.copy()

        polydf['area'] = polydf.geometry.area
        ck1 = polydf.groupby(polydf.index)['area'].sum()
        polydf2['area'] = polydf2.to_crs(polydf.crs).geometry.area
        ck2 = polydf2.groupby(polydf2.index)['area'].sum()

        assert type(df) is GeoDataFrame
        assert df.crs == self.polydf.crs
        assert 'value1' in df.columns and 'Shape_Area' in df.columns
        for ix, ck in zip(['idx1', 'idx2'], [ck1, ck2]):
            check = df.groupby([ix])['area'].sum()
            assert_series_equal(check,
                                ck,
                                check_names=False,
                                check_index_type=False)
Ejemplo n.º 12
0
 def test_union(self):
     df = overlay(self.polydf, self.polydf2, how="union", **self.kwargs)
     assert type(df) is GeoDataFrame
     assert df.shape == self.union_shape
     assert 'value1' in df.columns and 'Shape_Area' in df.columns
Ejemplo n.º 13
0
    def test_duplicate_column_name(self):
        polydf2r = self.polydf2.rename(columns={'value2': 'Shape_Area'})
        df = overlay(self.polydf, polydf2r, how="union", **self.kwargs)

        assert 'Shape_Area_2' in df.columns and 'Shape_Area' in df.columns
Ejemplo n.º 14
0
 def test_nonpoly(self):
     with pytest.raises(TypeError):
         overlay(self.pointdf, self.polydf, how="union", **self.kwargs)
Ejemplo n.º 15
0
 def test_bad_how(self):
     with pytest.raises(ValueError):
         overlay(self.polydf, self.polydf, how="spandex", **self.kwargs)
Ejemplo n.º 16
0
 def test_identity(self):
     df = overlay(self.polydf, self.polydf2, how="identity", **self.kwargs)
     assert df.shape == (154, 7)