Esempio n. 1
0
def segQuality(inVector, inImage):
    # open the vector
    lyr = fiona.open(inVector)
    features = [x for x in lyr]
    values = np.zeros([len(features), 5], dtype=float)
    # loop over features
    for  i in range(len(features)):
        geometry1 = shape(features[i]['geometry'])
        
        restFeatures = features[:i] + features[(i+ 1):]
        
        value = zonal_stats(geometry1, inImage, stats=['count'], add_stats={'mymean':mymean, "myvarianza":varianza } )
            
        df =  pd.DataFrame.from_dict(value, orient='columns', dtype=None)
        
            
        for j in range(len(restFeatures)):        
            geometry2 = shape(features[j]['geometry'])   
            if geometry2.intersects(geometry1) == True:
                #print("They touch")
                value = zonal_stats(geometry2, inImage, stats=['count'], add_stats={'mymean':mymean, "myvarianza":varianza } )
                df = df.append(pd.DataFrame.from_dict(value, orient='columns', dtype=None))
            
        values[i,0] = df.iloc[0,0] # count
        values[i,1] = df.iloc[0,1] # mean
        values[i,2] = df.iloc[0,2] # myvarianza
        values[i,3] = np.var(df.iloc[:,1]) # varianza between
        values[i,4] = len(df.iloc[1:]) # neighbours
    # get overal values   
    intraVarWeighted = np.nansum( values[:,0]*values[:,2] ) / np.nansum(values[:,0])
    interVarWeighted = np.nansum( values[:,4]*values[:,3] ) / np.nansum(values[:,4])
    normVariance = (intraVarWeighted - interVarWeighted) / (intraVarWeighted + interVarWeighted)
    numberSegments =  len(values[:,4])
    
    return( intraVarWeighted, interVarWeighted, normVariance, numberSegments )
Esempio n. 2
0
def test_nan_counts():
    from affine import Affine
    transform = Affine(1, 0, 1, 0, -1, 3)

    data = np.array([
        [np.nan, np.nan, np.nan],
        [0, 0, 0],
        [1, 4, 5]
    ])

    # geom extends an additional row to left
    geom = 'POLYGON ((1 0, 4 0, 4 3, 1 3, 1 0))'

    # nan stat is requested
    stats = zonal_stats(geom, data, affine=transform, nodata=0.0, stats="*")

    for res in stats:
        assert res['count'] == 3  # 3 pixels of valid data
        assert res['nodata'] == 3  # 3 pixels of nodata
        assert res['nan'] == 3  # 3 pixels of nans

    # nan are ignored if nan stat is not requested
    stats = zonal_stats(geom, data, affine=transform, nodata=0.0, stats="count nodata")

    for res in stats:
        assert res['count'] == 3  # 3 pixels of valid data
        assert res['nodata'] == 3  # 3 pixels of nodata
        assert 'nan' not in res
Esempio n. 3
0
def test_mini_raster():
    polygons = os.path.join(DATA, 'polygons.shp')
    stats = zonal_stats(polygons, raster, raster_out=True)
    stats2 = zonal_stats(polygons, stats[0]['mini_raster_array'],
                         raster_out=True, affine=stats[0]['mini_raster_affine'])
    assert (stats[0]['mini_raster_array'] == stats2[0]['mini_raster_array']).sum() == \
        stats[0]['count']
Esempio n. 4
0
def test_nopoints():
    with pytest.raises(TypeError):
        shapely_to_ogr_type('Point')
    with pytest.raises(TypeError):
        shapely_to_ogr_type('MultiPoint')

        zonal_stats(geoms, raster, global_src_extent=True)
Esempio n. 5
0
def test_mini_raster():
    polygons = os.path.join(DATA, 'polygons.shp')
    stats = zonal_stats(polygons, raster, raster_out=True)
    stats2 = zonal_stats(polygons, stats[0]['mini_raster'],
                         raster_out=True, transform=stats[0]['mini_raster_GT'])
    assert (stats[0]['mini_raster'] == stats2[0]['mini_raster']).sum() == \
        stats[0]['count']
Esempio n. 6
0
def test_band_alias():
    polygons = os.path.join(DATA, 'polygons.shp')
    stats_a = zonal_stats(polygons, raster)
    stats_b = zonal_stats(polygons, raster, band=1)
    with pytest.deprecated_call():
        stats_c = zonal_stats(polygons, raster, band_num=1)
    assert stats_a[0]['count'] == stats_b[0]['count'] == stats_c[0]['count']
Esempio n. 7
0
def test_copy_properties_warn():
    polygons = os.path.join(DATA, 'polygons.shp')
    # run once to trigger any other unrelated deprecation warnings
    # so the test does not catch them instead
    stats_a = zonal_stats(polygons, raster)
    with pytest.deprecated_call():
        stats_b = zonal_stats(polygons, raster, copy_properties=True)
    assert stats_a == stats_b
Esempio n. 8
0
def test_mini_raster():
    from geopandas import GeoDataFrame
    polygons = os.path.join(DATA, 'polygons.shp')
    df = GeoDataFrame.from_file(polygons)
    stats = zonal_stats(df.geometry, raster, raster_out=True)
    stats2 = zonal_stats(df.geometry, stats[0]['mini_raster'],
                         raster_out=True, transform=stats[0]['mini_raster_GT'])
    assert (stats[0]['mini_raster'] == stats2[0]['mini_raster']).sum() == \
        stats[0]['count']
Esempio n. 9
0
def test_transform():
    with rasterio.open(raster) as src:
        arr = src.read(1)
        affine = src.transform
    polygons = os.path.join(DATA, 'polygons.shp')

    stats = zonal_stats(polygons, arr, affine=affine)
    stats2 = zonal_stats(polygons, arr, transform=affine.to_gdal())
    assert stats == stats2
    pytest.deprecated_call(zonal_stats, polygons, raster, transform=affine.to_gdal())
Esempio n. 10
0
def test_direct_features_collections():
    polygons = os.path.join(DATA, 'polygons.shp')
    features = read_features(polygons)
    collection = read_featurecollection(polygons)

    stats_direct = zonal_stats(polygons, raster)
    stats_features = zonal_stats(features, raster)
    stats_collection = zonal_stats(collection, raster)

    assert stats_direct == stats_features == stats_collection
Esempio n. 11
0
def test_range():
    polygons = os.path.join(DATA, 'polygons.shp')
    stats = zonal_stats(polygons, raster, stats="range min max")
    for stat in stats:
        assert stat['range'] == stat['max'] - stat['min']
    ranges = [x['range'] for x in stats]
    # without min/max specified
    stats = zonal_stats(polygons, raster, stats="range")
    assert 'min' not in stats[0]
    assert ranges == [x['range'] for x in stats]
Esempio n. 12
0
def test_featurecollection():
    from geopandas import GeoDataFrame
    polygons = os.path.join(DATA, 'polygons.shp')
    df = GeoDataFrame.from_file(polygons)
    assert df.__geo_interface__['type'] == 'FeatureCollection'

    stats = zonal_stats(polygons, raster)

    # geointerface featurecollection
    stats2 = zonal_stats(df, raster)
    assert stats == stats2
Esempio n. 13
0
def test_ndarray_affine():
    polygons = os.path.join(DATA, 'polygons.shp')
    arr, gt = _get_raster_array_gt(raster)
    stats1 = zonal_stats(polygons, arr, transform=gt)

    from affine import Affine
    atrans = Affine.from_gdal(*gt)
    stats2 = zonal_stats(polygons, arr, transform=atrans)
    assert stats1[0]['count'] == stats2[0]['count']

    stats3 = zonal_stats(polygons, arr, affine=gt)
    assert stats1[0]['count'] == stats3[0]['count']
Esempio n. 14
0
def test_geodataframe_zonal():
    polygons = os.path.join(DATA, 'polygons.shp')

    try:
        import geopandas as gpd
        df = gpd.read_file(polygons)
        if not hasattr(df, '__geo_interface__'):
            pytest.skip("This version of geopandas doesn't support df.__geo_interface__")
    except ImportError:
        pytest.skip("Can't import geopands")

    expected = zonal_stats(polygons, raster)
    assert zonal_stats(df, raster) == expected
Esempio n. 15
0
def test_ndarray():
    arr, gt = _get_raster_array_gt(raster)
    polygons = os.path.join(DATA, 'polygons.shp')
    stats = zonal_stats(polygons, arr, transform=gt)
    assert stats == zonal_stats(polygons, raster)
    assert stats[0]['count'] == 75
    assert stats[1]['count'] == 50

    points = os.path.join(DATA, 'points.shp')
    stats = zonal_stats(points, arr, transform=gt)
    assert stats == zonal_stats(points, raster)
    assert sum([x['count'] for x in stats]) == 3
    assert round(stats[0]['mean'], 3) == 11.386
    assert round(stats[1]['mean'], 3) == 35.547
Esempio n. 16
0
def zonalStats(zonesShape, raster, reclassTable, statsResultTable):

    # max is count * maxVal where maxVal is the largest 'to' value in the reclassTable
    [lowerLimitList, upperLimitList, toValueList] = reclassCSVColumns(reclassTable)
    toValueList.sort()
    max = toValueList.pop()
    # rasterstats zonal_stats returns a dictionary for each Feature in the zonesShape vector in a list
    zs = zonal_stats(zonesShape, raster, geojson_out=True, stats=['count', 'sum'])
    l = []
    # for each dictionary in the zs list returned by rasterstats
    ds = ogr.Open(zonesShape)
    sqlString = "SELECT FID, OGR_GEOM_AREA, DN FROM {0}".format(os.path.splitext(os.path.basename(zonesShape))[0])
    layer = ds.ExecuteSQL(sqlString)
    for d in zs: 
        feature=layer.GetFeature(long(d['id']))
        sqM=feature.GetField("OGR_GEOM_AREA")
        l.append((d['id'], sqM, d['properties']['DN'], d['properties']['sum'], 
                 d['properties']['count'],  int(d['properties']['count']) * max)) 

    f = open(statsResultTable,'wt')
    try:
        writer = csv.writer(f)
        writer.writerow(('Unique region ID', 'Area in square meters', 'Raster value', 'Sum', 'Count', 'Count*maxVal'))
        for tup in l:
            writer.writerow(tup)
    finally:
        f.close()
Esempio n. 17
0
def test_prefix():
    polygons = os.path.join(DATA, 'polygons.shp')
    stats = zonal_stats(polygons, raster, prefix="TEST")
    for key in ['count', 'min', 'max', 'mean']:
        assert key not in stats[0]
    for key in ['TESTcount', 'TESTmin', 'TESTmax', 'TESTmean']:
        assert key in stats[0]
Esempio n. 18
0
def test_categorical():
    polygons = os.path.join(DATA, 'polygons.shp')
    categorical_raster = os.path.join(DATA, 'slope_classes.tif')
    stats = zonal_stats(polygons, categorical_raster, categorical=True)
    assert len(stats) == 2
    assert stats[0][1.0] == 75
    assert 5.0 in stats[1]
Esempio n. 19
0
def zs_h2o(gis_path, net_data):
    """
    Returns zonal stats of raster data from shapefile.
    """

    # Affine transformation information:
    # a = width of a pixel
    # b = row rotation (typically zero)
    # c = x-coordinate of the upper-left corner of the upper-left pixel
    # d = column rotation (typically zero)
    # e = height of a pixel (typically negative)
    # f = y-coordinate of the of the upper-left corner of the upper-left pixel

    # These were taken from the MACA netcdf file
    a = 0.0417
    b = 0
    c = -116.6056 - a
    d = 0
    e = -0.0417
    f = 49.3127 - e
    aff = Affine(a, b, c, d, e, f)

    # Get zone stats for climate divisions
    stats = ['min', 'max', 'mean', 'median', 'count', 'std']
    zs = zonal_stats(gis_path, net_data, affine=aff, stats=stats)
    return zs
def calculate_pop_value(node, raster_array, affine):
    stats = zonal_stats(node.polygon, raster_array, affine=affine, stats="sum", nodata=-1)
    total = stats[0]['sum']
    if total:
        return total
    else:
        return 0
Esempio n. 21
0
def test_geojson_out():
    polygons = os.path.join(DATA, 'polygons.shp')
    features = zonal_stats(polygons, raster, geojson_out=True)
    for feature in features:
        assert feature['type'] == 'Feature'
        assert 'id' in feature['properties']  # from orig
        assert 'count' in feature['properties']  # from zonal stats
Esempio n. 22
0
File: zs.py Progetto: akrherz/pyIEM
    def compute_gridnav(self, geometries, grid):
        """Figure out how these geometries map to our grid

        Args:
          grid (numpy.ndarray): the array to sample values for
          geometries (geopandas.GeoSeries): geometries to compute over, this
            should not change over the lifetime of this object
        """
        if geometries is None:
            _LOG.warning(
                ("Cowardly refusing to compute gridnav "
                 "with None geometries")
            )
            return
        # TODO: check nodata usage here
        zs = zonal_stats(geometries, grid, affine=self.affine, nodata=-1,
                         all_touched=True, raster_out=True)
        (gridysz, gridxsz) = grid.shape
        # print("in grid size y: %s x: %s" % (gridysz, gridxsz))
        for entry in zs:
            aff = entry['mini_raster_affine']
            # print(aff)
            x0 = int((aff.c - self.affine.c) / self.affine.a)
            y0 = int((self.affine.f - aff.f) / abs(self.affine.e))
            (ysz, xsz) = entry['mini_raster_array'].mask.shape
            mask = entry['mini_raster_array'].mask
            # print("IN: x0: %s y0: %s xsz: %s ysz: %s" % (x0, y0, xsz, ysz))
            if x0 >= gridxsz or y0 >= gridysz:
                # print("out of bounds, skipping")
                self.gridnav.append(None)
                continue
            if x0 < 0:
                mask = mask[:, abs(x0):]
                xsz -= abs(x0)
                x0 = 0
            if (x0 + xsz) >= gridxsz:
                clipx = (x0 + xsz) - gridxsz
                # print('clipping %s x points' % (clipx, ))
                mask = mask[:, :(0 - clipx)]
                xsz -= clipx
            if y0 < 0:
                mask = mask[abs(y0):, :]
                ysz -= abs(y0)
                y0 = 0
            if (y0 + ysz) >= gridysz:
                clipy = (y0 + ysz) - gridysz
                # print('clipping %s y points' % (clipy, ))
                mask = mask[:(0 - clipy), :]
                ysz -= clipy

            # TODO: likely need some more thought above to prevent this
            if ysz < 0 or xsz < 0:
                self.gridnav.append(None)
                continue

            # print("OUT: x0: %s y0: %s xsz: %s ysz: %s" % (x0, y0, xsz, ysz))
            self.gridnav.append(
                GRIDINFO(x0=x0, y0=y0,
                         xsz=xsz, ysz=ysz,
                         mask=mask))
Esempio n. 23
0
def test_iterable_geolike():
    reader = shapefile.Reader(os.path.join(DATA, 'polygons.shp'))
    geoms = [x.shape.__geo_interface__ for x in reader.shapeRecords()]
    stats = zonal_stats(geoms, raster)
    assert len(stats) == 2
    assert stats[0]['count'] == 75
    assert stats[1]['count'] == 50
    def rasterstats_statistics(self,admin_vect_file):

        from rasterstats import zonal_stats
        stats = zonal_stats(admin_vect_file, self.population_raster)
        print stats

        return "Calcoli statistici effettuati per categorie cicloni e popolazione....\n"
Esempio n. 25
0
def main():
    for t in tifs:
        stats = rasterstats.zonal_stats(inshp,t,stats=['sum'],copy_properties=True)
        df = pd.DataFrame(stats)
        df.set_index("BasinID",inplace=True)
        df.sort_index(inplace=True)
        df.to_csv(t[:-4]+'.csv')
def coverage(raster, regions, key_property=None):
    if key_property is None:
        key_property = 'id'

    with rasterio.open(raster) as r:
        res = r.res
        cell_area = res[0] * res[1]

    def _not_nodata(x):
        return (~x.mask).sum()

    with fiona.open(regions) as features:
        key_mapping = {}

        areas = {}
        keys = []

        stats = zonal_stats(
            features,
            raster,
            stats='',
            add_stats={'count':_not_nodata},
            geojson_out=True)

    def _coverage(item):
        count = item['properties']['count']
        total_area = shapely.geometry.shape(item['geometry']).area
        return count * cell_area / total_area

    result = {
        item['properties'][key_property]: _coverage(item)
        for item in stats}

    return result
Esempio n. 27
0
def test_some_nodata():
    polygons = os.path.join(DATA, 'polygons.shp')
    raster = os.path.join(DATA, 'slope_nodata.tif')
    stats = zonal_stats(polygons, raster, stats=['nodata', 'count'])
    assert stats[0]['nodata'] == 36
    assert stats[0]['count'] == 39
    assert stats[1]['nodata'] == 19
    assert stats[1]['count'] == 31
Esempio n. 28
0
def test_main():
    polygons = os.path.join(DATA, 'polygons.shp')
    stats = zonal_stats(polygons, raster)
    for key in ['__fid__', 'count', 'min', 'max', 'mean']:
        assert key in stats[0]
    assert len(stats) == 2
    assert stats[0]['count'] == 75
    assert stats[1]['count'] == 50
Esempio n. 29
0
def test_percentile_good():
    polygons = os.path.join(DATA, 'polygons.shp')
    stats = zonal_stats(polygons, raster,
                        stats="median percentile_50 percentile_90")
    assert 'percentile_50' in stats[0].keys()
    assert 'percentile_90' in stats[0].keys()
    assert stats[0]['percentile_50'] == stats[0]['median']
    assert stats[0]['percentile_50'] <= stats[0]['percentile_90']
Esempio n. 30
0
def test_all_nodata():
    polygons = os.path.join(DATA, 'polygons.shp')
    raster = os.path.join(DATA, 'all_nodata.tif')
    stats = zonal_stats(polygons, raster, stats=['nodata', 'count'])
    assert stats[0]['nodata'] == 75
    assert stats[0]['count'] == 0
    assert stats[1]['nodata'] == 50
    assert stats[1]['count'] == 0
Esempio n. 31
0
def zonal_stats_by_basin(raster, shapefile, output_dir, output_crs=3762):

    output_projection = CRS.from_epsg(output_crs)

    output_filename = f'stats_{os.path.basename(raster[:-4])}.geojson'

    with rio.open(raster) as src:

        # Read shapefile
        gdf_unprojected = gpd.read_file(shapefile)

        # Reproject to same CRS as input raster
        gdf = gdf_unprojected.to_crs(src.crs)

        # Clean empty and null geometries
        gdf = gdf.loc[~(gdf.geometry.is_empty | gdf.geometry.isna())]

        # Explode MultiPolygons to turn them into Polygons
        gdf = gdf.loc[gdf.geometry.geom_type ==
                      'MultiPolygon'].explode().reset_index(drop=True)

        # Create new 'mean' attribute and apply stats_mask2 to populate this column
        #gdf['mean'] = gdf.geometry.apply(lambda x: stats_mask2(x, src)).apply(np.ma.mean)
        gdf = gpd.GeoDataFrame.from_features(zonal_stats(gdf,
                                                         raster,
                                                         geojson_out=True,
                                                         stats='mean',
                                                         nodata=-9999),
                                             crs=gdf.crs)

        # Reproject GeoDataFrame to output_crs
        gdf.to_crs(epsg=output_crs, inplace=True)

        # Write the new GeoJSON file to output_dir
        print(os.path.join(output_dir, output_filename))
        gdf.to_file(os.path.join(output_dir, output_filename),
                    driver='GeoJSON')

    return True
Esempio n. 32
0
def intersect_network(network, network_details, hazard_details):
    sector = network_details['sector']
    node_or_edge = network_details['node_or_edge']

    hazard_path = hazard_details['path']
    model = hazard_details['model']
    return_period = hazard_details['r_period']

    all_stats = zonal_stats(network, hazard_path, stats=['max'])

    for stats, element in zip(all_stats, network):
        max_ = stats['max']
        if max_ is not None and max_ > 0 and max_ < 999:
            yield (
                node_or_edge,
                sector,
                str(element['properties']['id']),
                model,
                str(int(return_period)),
                str(max_),
                element['properties']['highway']
            )
def fast_append_profile_in_gdf(geodataframe,
                               raster_path,
                               force_crs_match=True):
    """Function that appends the columns of the profile in a geopandas according to a given raster taking advantage of rasterstats
    
    geodataframe    : a GeoDataFrame from geopandas that has overlay with the raster. The variables of the profile will be appended in this data.
                      If some polygon do not overlay the raster, consider a preprocessing step using the function subset_gdf_polygons_from_raster.
    
    raster_path     : the path to the associated raster image.
    
    force_crs_match : bool. Default is True.
                      Wheter the Coordinate Reference System (CRS) of the polygon will be reprojected to the CRS of the raster file. 
                      It is recommended to let this argument as True.
                      
    Notes
    -----
    The generated geodataframe will input the value 0 for each Type that is not present in the raster for each polygon. 
    
    """

    _check_presence_of_crs(geodataframe)
    raster_path = fetch_quilt_path(raster_path)
    if force_crs_match:
        raster = rasterio.open(raster_path)
        geodataframe = geodataframe.to_crs(crs=raster.crs.data)
    else:
        warnings.warn(
            "The GeoDataFrame is not being reprojected. The clipping might be being performing on unmatching polygon to the raster."
        )

    zonal_gjson = rs.zonal_stats(geodataframe,
                                 raster_path,
                                 prefix="Type_",
                                 geojson_out=True,
                                 categorical=True)

    zonal_ppt_gdf = GeoDataFrame.from_features(zonal_gjson)

    return zonal_ppt_gdf
def rasterStatistics2(feature, featureID, inRaster, calculateStat):
    #https://pypi.python.org/pypi/rasterstats/0.3.2
    #http://www.lfd.uci.edu/~gohlke/pythonlibs/#rasterio

    from rasterstats import zonal_stats

    try:
        #convert feature to temp shapefile
        arcpy.FeatureClassToFeatureClass_conversion(feature, tempFolder,
                                                    'temp.shp')

        #get values
        stats = zonal_stats(tempFolder + '/temp.shp',
                            inRaster,
                            nodata=0,
                            stats=[calculateStat.lower()])
        data = ResultObj(featureID, stats[0])
        return data

    except:
        tb = format_exc()
        raise Exception(tb)
Esempio n. 35
0
def test_iterable_features_geo():
    # pyshp doesnt do feature-level geo_interface so we need to construct it
    reader = shapefile.Reader(os.path.join(DATA, 'polygons.shp'))
    features = []

    class FeatureThing(object):
        pass

    fields = reader.fields[1:]
    field_names = [field[0] for field in fields]
    for sr in reader.shapeRecords():
        geom = sr.shape.__geo_interface__
        atr = dict(list(zip(field_names, sr.record)))
        obj = FeatureThing()
        obj.__geo_interface__ = dict(geometry=geom,
                                     properties=atr,
                                     type="Feature")
        features.append(obj)
    stats = zonal_stats(features, raster)
    assert len(stats) == 2
    assert stats[0]['count'] == 75
    assert stats[1]['count'] == 50
Esempio n. 36
0
def cmip_exog_var_timeseries_creator(path_to_cmip6_data, path_to_save_folder, exogenous_variable, country, region, polygon, rcp):
    csv_file_name = path_to_save_folder + "/" + exogenous_variable + "_predictions/NEX_GDDP_yearly_" + rcp + "_" + exogenous_variable + "_Timeseries_" + country + "_" + region + ".csv"        
    if os.path.isfile(csv_file_name):
        print("File at path: ", csv_file_name, " exists already")
        return
    
    
    files_list = sorted(os.listdir(path_to_cmip6_data))
    years_to_predict = 81

    files_list = [x for x in files_list if rcp in x ]
    files_list = [x for x in files_list if exogenous_variable in x ]

    time_series = {"Year": [], "Value": []}



    for file in files_list:
        temp = zonal_stats(polygon, path_to_cmip6_data + file, stats="mean")
        if exogenous_variable == "prec":
            time_series["Value"].append(temp[0]["mean"] * 31556926/10)
        else: 
            time_series["Value"].append(temp[0]["mean"]-273)


    starting_year = 2019
    years = list(range(starting_year, starting_year + years_to_predict))
    for year in years:
        date = str(year)
        time_series["Year"].append(date)


    zd = zip(*time_series.values())
    with open(csv_file_name, 'w') as file:
        writer = csv.writer(file, delimiter=',')
        writer.writerow(time_series.keys())
        writer.writerows(zd)

    return
Esempio n. 37
0
def historical_index_timeseries_creator(path_to_hist_index_data, path_to_save_folder, index_name, country, region, polygon):
    csv_file_name = path_to_save_folder + "/" + index_name + "_historical/Historical_" + index_name + "_Timeseries_" + country + "_" + region + ".csv"
    if os.path.isfile(csv_file_name):
        print("File at path: ", csv_file_name, " exists already")
        return
    files_list = sorted(os.listdir(path_to_hist_index_data))
    time_series = {"Year": [], "Value": []}

    for file in files_list[:-1]: 
        date = file[-8:-4]
        temp = zonal_stats(polygon, path_to_hist_index_data + file, stats="mean")
        time_series["Year"].append(date)
        time_series["Value"].append(temp[0]["mean"])


    zd = zip(*time_series.values())
    with open(csv_file_name, 'w') as file:
        writer = csv.writer(file, delimiter=',')
        writer.writerow(time_series.keys())
        writer.writerows(zd)

    return
Esempio n. 38
0
def extract_mean(codename, shp, raster_list, classes):
    extract_by_mask = []

    for feature in classes:
        polygon = shp.loc[(shp[str(codename)] == feature)]
        polygon_bbox = polygon.total_bounds

        for raster in raster_list:
            data = raster[
                -8:-4]  ## the name of the raster it's the year, with tha
            tiff_rec = rasterio.open(raster)
            window = tiff_rec.window(*polygon_bbox)
            tiff_rec_np = tiff_rec.read(1, window=window)
            transform = tiff_rec.window_transform(window)
            stats = zonal_stats(polygon, tiff_rec_np, affine=transform)

            for i in stats:
                media = i['mean']
                lista = [feature, data, media]
                extract_by_mask.append(lista)

    return extract_by_mask
Esempio n. 39
0
    def get_zonal_stats_from_point(self,
                                   point: Vector3) -> List[Optional[Dict]]:
        results = []
        if self.boundary_data:
            for plugin in (x for x in (self.terrain_data, self.attribute_data,
                                       self.flow_dir_data, self.flow_dir_data)
                           if x is not None):
                if plugin is self.terrain_data:
                    var = self._elevation_attribute.selected
                elif plugin is self.attribute_data:
                    var = self._attribute.selected
                else:
                    var = ''

                raster = plugin.get_data(var)
                affine = plugin.affine
                res = plugin.resolution
                var_stats = plugin.variable_stats(var)
                nodata = var_stats.nodata_value

                # Transform point coordinates to crs of raster
                p = shapely.geometry.Point(
                    *transform.xy(affine, point.x / res, point.y / res))
                zones = []
                for feat in self.boundary_data.get_features():
                    if shapely.geometry.shape(feat['geometry']).contains(p):
                        zones.append(feat)

                # Retrieve zonal stats for this raster
                result = zonal_stats(zones,
                                     raster,
                                     affine=affine,
                                     nodata=nodata,
                                     add_stats=self.zonal_stats)
                for j, row in enumerate(result):
                    row['Name'] = "{} (Zone {})".format(
                        plugin.data_name, zones[j].get('id'))
                    results.append(row)
        return results
def calculate_column_change(pop_raster, poly_layer):
    """Calculates flood impact per isochrone for each column."""
    pop_data = []
    poly_layer = poly_layer[[
        'counter_1', 'cap_int_1', 'counter_2', 'cap_int_2', 'geometry'
    ]]

    for poly_idx_n, poly_cap_n, poly_idx_2, poly_cap_2, poly_geom in zip(
            poly_layer['counter_1'], poly_layer['cap_int_1'],
            poly_layer['counter_2'], poly_layer['cap_int_2'],
            poly_layer['geometry']):
        feature = gpd.GeoSeries([poly_geom]).to_json()
        # drop geometries with an area size smaller than 1m²
        if area(mapping(poly_geom)) > 0.000009039:
            # calculate population for given area
            pop_stats = zonal_stats(feature, pop_raster, stats=['sum'])
            poly_area = area(mapping(poly_geom)) / 1e+6  # in kilometer
            pop_data.append([
                poly_idx_n, poly_cap_n, poly_idx_2, poly_cap_2,
                pop_stats[0]['sum'], poly_area, poly_geom
            ])

    df = pd.DataFrame(pop_data,
                      columns=[
                          'counter_1', 'cap_int_1', 'counter_2', 'cap_int_2',
                          'pop', 'area', 'geometry'
                      ])
    df.dropna(subset=['pop'])

    df['pop_area'] = df['pop'] / df['area']  # population density
    df['cap_pop'] = (df['cap_int_1'] / df['pop']) * 100000
    df['cap_dens'] = df['cap_int_1'] / df['pop_area']
    df['cap_dens_2'] = df['cap_int_2'] / df['pop_area']
    df['cap_dens_d'] = df['cap_dens_2'] - df['cap_dens']

    df = df.replace([np.inf, -np.inf], np.nan)
    result_geodf = gpd.GeoDataFrame(df, geometry='geometry')

    return result_geodf
def do_zonal_stats(buffs, raster, csv_pth, num, log_out, stats):
    try:
        u.verify_dir(csv_pth)
        dataset = raster.split('\\')[-2].replace(' ', '_')
        raster_name_to_csv = os.path.basename(raster).replace('.tif', '.csv')
        csv_name = '__'.join([dataset, raster_name_to_csv])
        csv_out = os.path.join(csv_pth, csv_name)

        start = timer()
        u.write_to_log(
            '  {}) Raster: {}'.format(num, os.path.basename(raster)), log_out)

        stats = zonal_stats(buffs, raster, stats=stats, geojson_out=True)
        print('    zonal_stats... ({} sec.)'.format(round(timer() - start, 2)))

        start = timer()
        attributes = []
        for item in stats:
            #print ('{}'.format(item['properties']))
            attributes.append(item['properties'])
        print('    append dicts... ({} sec.)'.format(round(timer() - start,
                                                           2)))

        start = timer()
        with open(csv_out, 'w', newline='') as outfile:
            fp = csv.DictWriter(outfile, attributes[0].keys())
            fp.writeheader()
            fp.writerows(attributes)
        print('    write to csv... ({} sec.)'.format(round(timer() - start,
                                                           2)))
        u.write_to_log('    CSV file: {}'.format(csv_out), log_out)
        u.write_to_log('    Log file: {}'.format(log_out), log_out)

    except Exception as e:
        u.write_to_log(str(e), log_out)
        u.write_to_log(
            'FINISH BUFFERS: {}'.format(time.strftime("%Y-%m-%d  %H:%M:%S")),
            log_out)
Esempio n. 42
0
def extractarray(rasterpath, shpfile, tile, projectname, ui):

    date = os.path.split(rasterpath)[-1].split('_')[1][:8]
    band = os.path.splitext(os.path.split(rasterpath)[-1])[0].split('_')[-2]

    print('arrayextractor started')

    a = zonal_stats(shpfile,
                    rasterpath,
                    stats=['mean'],
                    band=1,
                    geojson_out=True,
                    all_touched=False,
                    raster_out=True,
                    nodata=np.nan)

    myarrays = []

    for x in a:
        myarray = x['properties']['mini_raster_array']
        myarray = myarray.filled(-9999)
        myarray = myarray[myarray != -9999]
        myarray = myarray.flatten()
        if np.count_nonzero(myarray) == 0:
            continue
        count = len(myarray)

        myid = [x['properties'][ui.idname]]
        arr = myarray.tolist()
        myid.extend(arr)
        arr = myid

        meta = extractmeta(rasterpath, myid[0], date, count, projectname, band,
                           tile)

        myarrays.append(arr)

    tocsv(date, band, myarrays, tile, projectname)
Esempio n. 43
0
def corine_stats(root, burnt_areas, corine_path):
    os.chdir(root)
    ba = burnt_areas
    list_columns = [
        'id', 'COUNTRY', 'AREA_HA', 'BROADLEA', 'CONIFER', 'MIXED', 'SCLEROPH',
        'TRANSIT', 'OTHERNATLC', 'AGRIAREAS', 'ARTIFSURF', 'OTHERLC',
        'PERCNA2K'
    ]
    ba = ba[list_columns]

    f = csv.reader(open('corine_key.csv'))
    corine_dict = {}
    for row in f:
        corine_dict[row[0]] = row[1]
    corine_dict['1'] = corine_dict.pop('1')
    corine_dict = {int(k): v for k, v in corine_dict.items()}
    ba_raw = zonal_stats(ba, corine_path, categorical=True)
    df_ba_raw = pd.DataFrame.from_dict(ba_raw)
    df_ba_raw = df_ba_raw.rename(columns=corine_dict)
    df_ba_raw = df_ba_raw.T
    df_ba_raw.to_csv('corine_ba_raw.csv')
    df_mapped = df_ba_raw.groupby(df_ba_raw.index).sum()
    df_mapped = df_mapped.T
    df_mapped.to_csv('corine_ba_raw2.csv')
    df = df_mapped
    print('--PM')
    print(ba.columns)
    l = ba['id'].to_list()
    a = ba['AREA_HA'].to_list()
    df = df.assign(id=l, area=a)
    # df.to_csv('__df_test.csv')
    df_merge = df.merge(ba[['id', 'COUNTRY' '']], how='inner', on='id')
    df_group = df_merge.groupby(['COUNTRY']).sum()
    df_group.to_csv('__test_group.csv')
    print('\n----- df group columns\n')
    print(df_group.columns)
    print('---end')
    pass
Esempio n. 44
0
def _fast_append_profile_in_gdf(geodataframe,
                                raster_path,
                                force_crs_match=True):
    """Append categorical zonal statistics (counts by pixel type) as columns to an input geodataframe.

    geodataframe : geopandas.GeoDataFrame
        geodataframe that has overlay with the raster. If some polygon do not overlay the raster,
        consider a preprocessing step using the function subset_gdf_polygons_from_raster.
    raster_path : str
        path to the raster image.
    force_crs_match : bool, Default is True.
        Whether the Coordinate Reference System (CRS) of the polygon will be reprojected to
        the CRS of the raster file. It is recommended to let this argument as True.

    Notes
    -----
    The generated geodataframe will input the value 0 for each Type that is not present in the raster
    for each polygon.
    """

    _check_presence_of_crs(geodataframe)
    if force_crs_match:
        with rio.open(raster_path) as raster:
            geodataframe = geodataframe.to_crs(crs=raster.crs.data)
    else:
        warnings.warn(
            "The GeoDataFrame is not being reprojected. The clipping might be being performing on unmatching polygon to the raster."
        )

    zonal_gjson = rs.zonal_stats(geodataframe,
                                 raster_path,
                                 prefix="Type_",
                                 geojson_out=True,
                                 categorical=True)

    zonal_ppt_gdf = gpd.GeoDataFrame.from_features(zonal_gjson)

    return zonal_ppt_gdf
Esempio n. 45
0
def run_function(params):
    # Prepare the parameters
    subject_ref = params['subject']
    raster = params['raster']
    stats = params.get('stats', 'mean')
    geojson_out = params.get('geojson_out', True)

    try:
        subject = fiona.open(subject_ref)
        subject_types = get_subject_types(subject)

        if 'Polygon' in subject_types or 'MultiPolygon' in subject_types:
            features = zonal_stats(subject,
                                   raster,
                                   stats=stats,
                                   geojson_out=geojson_out)
        elif 'Point' in subject_types or 'MultiPoint' in subject_types:
            features = point_query(subject, raster, geojson_out=geojson_out)
        else:
            raise ValueError(
                "Input features need to be either all Polygons or Points. Doesn't look like they are."
            )

        # Decorate return as either GeoJSON FeatureCollection (other way to do this?) or just the array of stats
        if geojson_out:
            return FeatureCollection(features)
        else:
            return features
    except ValueError as e:
        if e == 'Specify either bounds or window':
            raise ValueError(
                "One or more features are lacking geometry or have null/empty values"
            )

    except AttributeError:
        raise ValueError(
            "Error calculating zonalstats. Please confirm every input "
            "geometry is valid, and contains coordinates")
Esempio n. 46
0
def zonal_stats_csv(polygon,raster,headers,filename,year):
    stats = rasterstats.zonal_stats(
        polygon,
        raster,
        stats='sum',
        geojson_out=True
        )#,stats='count min mean max median')

    # Default encoding to utf-8 for odd string characters
    import sys
    reload(sys)
    sys.setdefaultencoding('utf-8')

    # Write to CSV
    with open(filename,'w') as f:
        f.write(','.join(headers))
        f.write('\n')
        for x in stats: 
    	    p = x['properties']
	    s = [str(p[h]).encode('utf-8') for h in headers]
            s[1] = s[1].replace(',','')
	    f.write(','.join(s))
	    f.write('\n')
Esempio n. 47
0
def calculate_stats(zones,
                    geotiff,
                    group_by=None,
                    stats=DEFAULT_STATS,
                    prefix='stats_',
                    geojson_out=False):
    """Calculate stats."""
    if group_by:
        zones = _group_zones(zones, group_by)

    stats = zonal_stats(zones,
                        geotiff,
                        stats=stats,
                        prefix=prefix,
                        geojson_out=geojson_out)

    if not geojson_out:
        feature_properties = _extract_features_properties(zones)
        stats = [{
            **properties,
            **stat
        } for stat, properties in zip(stats, feature_properties)]
    return stats
Esempio n. 48
0
def integrate_shapes(filename: str, shapefile: str,
                     target: str) -> gpd.GeoDataFrame:
    """
    This functions opens a geotiff with desired data, converts to a raster,
    integrate the data into polygons and returns a GeoDataFrame object.

    Parameters:
        cuencas_shp: Path to shapefile
    Returns:
        cuencas_gdf_ppn (GeoDataFrame): a geodataframe with cuerncas and ppn
    """

    cuencas_gdf: gpd.GeoDataFrame = gpd.read_file(shapefile, encoding='utf-8')
    df_zs = pd.DataFrame(zonal_stats(shapefile, filename, all_touched=True))

    cuencas_gdf_ppn = pd.concat([cuencas_gdf, df_zs],
                                axis=1).dropna(subset=['mean'])
    if target == "zonas":
        COLUM_REPLACE = {'Name': 'zona'}
        cuencas_gdf_ppn = cuencas_gdf_ppn.rename(columns=COLUM_REPLACE)
        return cuencas_gdf_ppn[['zona', 'geometry', 'mean']]

    return None
Esempio n. 49
0
def get_zonal_stats(polygon, tif_file_path):
    ''' 
     Given a single polygon and the path to the corresponding tif file,
     calculates zonal stats for the shape outlined by the polygon and returns
     them as a dataframe.
     '''

    df = pd.DataFrame()

    for i in range(1, 4):

        tats = rasterstats.zonal_stats(
            polygon,
            tif_file_path,
            stats=['min', 'max', 'median', 'majority', 'sum'],
            band=i)

        df[i] = pd.Series(tats[0]['median'])

    df['roof'] = polygon['roof_material']
    df.set_index('roof', inplace=True)

    return df
Esempio n. 50
0
def postprocess_CHM(df, lookup_pool):
    """Field measured height must be within min_diff meters of canopy model"""
    #Extract zonal stats
    try:
        CHM_path = find_sensor_path(lookup_pool=lookup_pool, bounds=df.total_bounds)
    except Exception as e:
        raise ValueError("Cannot find CHM path for {} from plot {} in lookup_pool: {}".format(df.total_bounds, df.plotID.unique(),e))
    draped_boxes = rasterstats.zonal_stats(df.geometry.__geo_interface__,
                                           CHM_path,
                                           add_stats={'q99': non_zero_99_quantile})
    df["CHM_height"] = [x["q99"] for x in draped_boxes]

    #if height is null, assign it
    df.height.fillna(df["CHM_height"], inplace=True)
    
    df = df[df.CHM_height>1]        
    
    ##Rename column
    #if remove:
        ##drop points with less than 1 m height        
        #df = df[(abs(df.height - df.CHM_height) < min_diff)]

    return df
def test_switzerland_rooftop_area():
    with open(PATH_TO_SONNENDACH_AREA_ESTIMATE, "r") as f_sonnendach_estimate:
        sonnendach_estimate = float(f_sonnendach_estimate.readline())
    with fiona.open(PATH_TO_NUTS.as_posix(), "r", layer="nuts0") as shapefile:
        switzerland = [
            feature["geometry"] for feature in shapefile
            if feature["properties"]["country_code"] == "CHE"
        ]
        assert len(switzerland) == 1
    with rasterio.open(PATH_TO_AREAS.as_posix()) as src:
        transform = src.transform
        areas = src.read(1)
    with rasterio.open(PATH_TO_CATEGORIES.as_posix()) as src:
        categories = src.read(1)
    areas[categories != Eligibility.ROOFTOP_PV] = 0
    zs = zonal_stats(switzerland,
                     areas,
                     affine=transform,
                     stats="sum",
                     nodata=-999)
    our_estimate = zs[0]["sum"]
    assert our_estimate == pytest.approx(sonnendach_estimate,
                                         0.02)  # 2% tolerance
Esempio n. 52
0
def zonal_to_shp(tifs_dir, shp_path):
    """
    calculate zonal statistics of list of tifs in directory
    using countries shapefile
    """
    tifs_glob_str = tifs_dir + '/*.tif'
    tifs = glob.glob(tifs_glob_str)
    ids = get_tif_ids(tifs_dir)
    geodataframe = gpd.GeoDataFrame.from_file(shp_path)
    for idx, tif in enumerate(tifs):
        stats = zonal_stats(shp_path, tif, nodata=255, stats='count mean')
        li_stats = []
        for i in range(len(stats)):
            try:
                the_mean = stats[i]['mean']
                the_count = stats[i]['count']
                the_total = the_mean * the_count
            except:
                the_total = 255
            li_stats.append(the_total)
        s_stats = pd.Series(li_stats, name=ids[idx])
        geodataframe = geodataframe.join(s_stats)
    return geodataframe
Esempio n. 53
0
def extract_features(image,
                     image_label,
                     segments,
                     stats=["mean"],
                     band_num=1,
                     image_transform=None,
                     nodata=-9999):
    """
    Extract features by calculating raster statistics
    
    Inputs:
    image: nd array or str 
        Image to retrieve statistics from, array or path to image file.
    image_label: str
        Label describing content of image.
    segments: geopandas GeoDataFrame or str
        Segments to retrieve statistics for, GeoDataFrame or path to segments file.
    stats: list (default=["mean"])
        List of statistics to calculate.
    band_num: int (default=1)
        Image band number to use (counting from 1).
    image_transform: Affine or None (default=None)
        Transformation from pixel to geographic coordinates, only required if image is ndarray.
    nodata: float or None (default=-9999)
        Value to assign if no image data to retrieve.
    Outputs:
    image_label: str
    statistics: list of dicts
    """
    print("{} - {} - Extracting features for {}".format(
        datetime.datetime.now(), os.getpid(), image_label))
    return image_label, rs.zonal_stats(segments,
                                       image,
                                       stats=stats,
                                       affine=image_transform,
                                       band_num=band_num,
                                       nodata=nodata)
def main():
    print(datetime.now().time())
    # Read data
    zones = geopandas.read_file(zones_file)
    # Uncomment next 3 rows, if you need to read the file from disk.
    # zonal_stats does not directly work with rasterio opened file, but needs data and transformation variables
    raster = rasterio.open(raster_file)
    affine = raster.transform
    array = raster.read(1)

    results = zonal_stats(zones.geometry,
                          array,
                          affine=affine,
                          stats=statistics)
    # Use this if raster data is not read to memory
    #results = zonal_stats(zones.geometry, raster_file, stats=statistics)

    # Join the results back to geopandas dataframe
    for stat in statistics:
        results_as_list = [d[stat] for d in results]
        zones[stat] = results_as_list

    # Write the results to file
    zones.to_file(zonal_file)
Esempio n. 55
0
def labelPburns():
    print("Reading filepaths...")
    filepath_mask = Path("./results")
    fps_masks = sorted(list(filepath_mask.glob("predict*.tif")))

    print("Going through all shapefiles...")
    pathShapeFiles = Path("./data/shapefiles/trainingData")
    for i in range(len(fps_masks) - 2):
        nameID = fps_masks[i].name.split('_')[3].replace('.tif', '')
        fileShapes = sorted(list(pathShapeFiles.glob("*" + nameID + "*.shp")))

        print("reading raster")
        raster_src_mask, mask = readOneImg(fps_masks[i])

        print("reading shapefiles for", nameID)
        for fileShape in fileShapes:
            gdf = gpd.read_file(fileShape)
            gdfcrs = gdf.crs

            prediction_segs = zonal_stats(
                gdf['geometry'],
                mask,
                affine=raster_src_mask.meta['transform'],
                stats='majority',
                nodata=-999,
                all_touched=True)

            df = pd.DataFrame(prediction_segs)
            gdf['pred_burn'] = df.to_numpy()
            gdf = gdf.astype({"pred_burn": int})
            gdf = gpd.GeoDataFrame(gdf, crs=gdfcrs)

            newFileName = fileShape.parent / Path(
                fileShape.name.split('.shp')[0] + "_pburn.shp")
            print("writing to path...", newFileName)
            gdf.to_file(newFileName)
Esempio n. 56
0
def add_zonal_fields(vector,
                     raster,
                     affine,
                     prefix,
                     band=0,
                     stats=['mean', 'min', 'max', 'std']):
    """
    Adds zonal statistics to an existing vector file.

    Add more documentation.

    """
    raster_stats = zonal_stats(vector,
                               raster[band],
                               stats=stats,
                               affine=affine)
    for item in raster_stats:
        items = tuple(item.items())
        for k, v in items:
            item[prefix + "_" + k] = v
            item.pop(k)

    for v, rs in zip(vector, raster_stats):
        v['properties'] = OrderedDict(v['properties'], **rs)
Esempio n. 57
0
def ZonalShapeDensity(shapegdf, zonegdf, cellsize, shapetoarray=None):
    # works only under following situations, future upgrades to accommodate other units
    # density unit: square mile
    # input unit: meters
    """
    :param GeoDataFrame shapegdf: input shape features can be either line or polygon features
    :param GeoDataFrame zonegdf: zone GeoDataFrame units to collect statistics
    :param int cellsize: the cell size used to convert vector to raster
    :param obj shapetoarray: the numpy array to use, if a desired numpy array has already been created
    :return: a pandas series that contains the density value for each zone feature
    :rtype: Series
    """
    if shapetoarray is None:
        indata = ShapeToArray(shapegdf, cellsize)
    else:
        indata = shapetoarray
    zonegdf = zonegdf.join(
        pd.DataFrame(zonal_stats(zonegdf.centroid.buffer(907.9751),
                                 indata[0],
                                 affine=indata[1],
                                 stats=['sum'],
                                 nodata=0),
                     index=zonegdf.index))
    return zonegdf['sum'] * 1.4142 * cellsize / 1609.344
Esempio n. 58
0
    def get_zonal_stats_from_feature(
            self, feature: LinearRing) -> List[Optional[Dict]]:
        results = []
        if self.terrain_data:

            # Normalize feature coordinates to terrain resolution
            t_res = self.terrain_data.resolution
            normalized_coords = [(p[0] / t_res, p[1] / t_res)
                                 for p in feature.coords]

            for plugin in (x for x in (self.terrain_data, self.attribute_data,
                                       self.flow_dir_data, self.flow_dir_data)
                           if x is not None):
                if plugin is self.terrain_data:
                    var = self._elevation_attribute.selected
                elif plugin is self.attribute_data:
                    var = self._attribute.selected
                else:
                    var = ''

                raster = plugin.get_data(var, Timeline.app().current)
                affine = plugin.affine
                var_stats = plugin.variable_stats(var)
                nodata = var_stats.nodata_value
                feat = Polygon(
                    *[[transform.xy(affine, *p) for p in normalized_coords]])

                # Transform normalized raster coordinates to CRS of raster to query and obtain results
                result = zonal_stats(feat,
                                     raster,
                                     affine=affine,
                                     nodata=nodata,
                                     add_stats=self.zonal_stats)[0]
                result['Name'] = plugin.data_name
                results.append(result)
        return results
Esempio n. 59
0
def calc_stats(rx, ry, gdf, ndist, trsfm, tps):
    # fonction calculant les stats à partir de la géodatabase(gdf). rx,ry = reso spatiale, ndist=nb de districts, trsfm=géométrie de la matrice de la variable, tps=matrice des dates
    # matrices vides aux dimensions du "bloc temporel" (len(tps) correspond à l'axe 0 de la mat tps) et du nombre de districts/aires/pays (ndist)
    nb_px = np.zeros((len(tps), ndist))
    nb_px[:] = np.nan
    v_max = np.zeros((len(tps), ndist))
    v_max[:] = np.nan
    v_mean = np.zeros((len(tps), ndist))
    v_mean[:] = np.nan
    v_med = np.zeros((len(tps), ndist))
    v_med[:] = np.nan
    v_min = np.zeros((len(tps), ndist))
    v_min[:] = np.nan
    v_std = np.zeros((len(tps), ndist))
    v_std[:] = np.nan
    for i in range(len(tps)):
        # "micro-pixelisation" pour obtenir une pseudo-résolution plus fine, adéquate au découpage district/aire
        var1 = np.repeat(tps[i, ...], 100 * ry, axis=0)
        var2 = np.repeat(var1, 100 * rx, axis=1)
        val_input = np.ma.masked_array(var2, np.isnan(var2))
        stats = zonal_stats(
            gdf['geometry'],
            val_input,
            transform=trsfm,
            stats=['min', 'max', 'mean', 'count', 'std',
                   'median'])  #fonction stat du module rasterstats
        df = gdf.join(
            pd.DataFrame(stats))  # chargement des stats dans la geodataframe
        #chargement des stats dans les différentes matrices
        nb_px[i, :] = np.array(df['count'].ix[:])
        v_max[i, :] = np.array(df['max'].ix[:])
        v_mean[i, :] = np.array(df['mean'].ix[:])
        v_med[i, :] = np.array(df['median'].ix[:])
        v_min[i, :] = np.array(df['min'].ix[:])
        v_std[i, :] = np.array(df['std'].ix[:])
    return nb_px, v_max, v_mean, v_med, v_min, v_std
Esempio n. 60
0
 def chop(self, time_var='time', value_var='scpdsi'):
     """Chop the raster stats over the years."""
     nc_var = self.nc_ds[value_var]
     logger.info(f'{len(nc_var)}')
     nc_times = self.nc_ds[time_var].values
     logger.info(f'Parsing {len(nc_times)} times')
     for nc_time in nc_times:
         logger.info(f'Parsing time {nc_time}')
         nc_arr = nc_var.sel(time=nc_time)
         nc_arr_values = nc_arr.values
         stats_data = zonal_stats(self.shape_file,
                                  nc_arr_values,
                                  affine=self.affine,
                                  stats=self.statistics,
                                  geojson_out=self.geojson,
                                  all_touched=self.all_touched)
         sd = pd.DataFrame.from_dict(stats_data)
         df = pd.DataFrame(self.shape_df)
         dat = pd.concat([df, sd], axis=1)
         logging.info(f'{nc_time}')
         dat['time'] = nc_time
         if self.geometry is False:
             dat.drop(columns='geometry', inplace=True, errors='ignore')
         self.df_list.append(dat)