Ejemplo n.º 1
0
def get_bbox(polys, write=None, prj=None):
    '''
    parameter
    -polys: GeoDataFrame or GeoSeries
    -write: filename. If not given will not save file.
    ===
    return
    -bbox: GeoDataFrame
    '''
    W, S, E, N = polys.total_bounds
    bbox = Polygon([(W, S), (W, N), (E, N), (E, S)])
    bbox = gpd.GeoDataFrame({'geometry':[bbox]})
    
    if prj:
        bbox.crs = prj
    else:
        bbox.crs=polys.crs
        
    if write:
        bbox.to_file(filename = write)
    
    return bbox
Ejemplo n.º 2
0
def get_country_geometries(country_names=None, extent=None, resolution=10):
    """Returns a GeoDataFrame with natural earth multipolygons of the
    specified countries, resp. the parts of the countries that lie within the
    specified extent. If no arguments are given, simply returns the whole
    natural earth dataset.
    Take heed: we assume WGS84 as the CRS unless the Natural Earth download
    utility from cartopy starts including the projection information. (They
    are saving a whopping 147 bytes by omitting it.) Same goes for UTF.

    Parameters:
        country_names (list, optional): list with ISO3 names of countries, e.g
            ['ZWE', 'GBR', 'VNM', 'UZB']
        extent (tuple, optional): (min_lon, max_lon, min_lat, max_lat) assumed
            to be in the same CRS as the natural earth data.
        resolution (float, optional): 10, 50 or 110. Resolution in m. Default:
            10m

    Returns:
        GeoDataFrame
    """
    resolution = nat_earth_resolution(resolution)
    shp_file = shapereader.natural_earth(resolution=resolution,
                                         category='cultural',
                                         name='admin_0_countries')
    nat_earth = geopandas.read_file(shp_file, encoding='UTF-8')
    
    if not nat_earth.crs:
        nat_earth.crs = NE_CRS
    
    if country_names:
        if isinstance(country_names, str): 
            country_names = [country_names]
        out = nat_earth[nat_earth.ISO_A3.isin(country_names)]

    elif extent:
        bbox = Polygon([
            (extent[0], extent[2]),
            (extent[0], extent[3]),
            (extent[1], extent[3]),
            (extent[1], extent[2])
        ])
        bbox = geopandas.GeoSeries(bbox)
        bbox.crs = nat_earth.crs
        bbox = geopandas.GeoDataFrame({'geometry': bbox})
        out = geopandas.overlay(nat_earth, bbox, how="intersection")

    else:
        out = nat_earth

    return out
Ejemplo n.º 3
0
with open('completed.pkl', 'wb') as com_pickle:
    pickle.dump(completed_rides, com_pickle)

rides = pickle.load(open('geo_pickle1.pkl', 'rb'))

result = pd.concat(rides)

geo_result = geopandas.GeoSeries(result.apply(Point))

counties = geopandas.GeoSeries.from_file('counties.json')

counties_bounds = counties.total_bounds

four_points = [(counties_bounds[0], counties_bounds[1]),
               (counties_bounds[0], counties_bounds[3]),
               (counties_bounds[2], counties_bounds[3]),
               (counties_bounds[2], counties_bounds[1])]

poly = Polygon(p for p in four_points)

poly.crs = {'init': 'espg:4326'}
counties.crs = {'init': 'epsg:4326'}
geo_result.crs = {'init': 'epsg:4326'}

geo_result_1 = geo_result.where(geo_result.within(poly))

base = counties.plot(color='white', edgecolor='black')
geo_result_1.plot(ax=base, marker='o', color='red', markersize=1)

matplotlib.pyplot.show()
Ejemplo n.º 4
0
                'Multi-feature polygon detected. Only the first feature will be used to subset the GEDI data.'
            )
        ROI = ROI.geometry[0]
    except:
        print(
            'error: unable to read input geojson file or the file was not found'
        )
        sys.exit(2)
else:
    ROI = ROI.replace("'", "")
    ROI = ROI.split(',')
    ROI = [float(r) for r in ROI]
    try:
        ROI = Polygon([(ROI[1], ROI[0]), (ROI[3], ROI[0]), (ROI[3], ROI[2]),
                       (ROI[1], ROI[2])])
        ROI.crs = 'EPSG:4326'
    except:
        print(
            'error: unable to read input bounding box coordinates, the required format is: ul_lat,ul_lon,lr_lat,lr_lon'
        )
        sys.exit(2)

# Keep the exact input geometry for the final clip to ROI
finalClip = gp.GeoDataFrame([1], geometry=[ROI], crs='EPSG:4326')

# Format and set input/working directory from user-defined arg
if args.dir[-1] != '/' and args.dir[-1] != '\\':
    inDir = args.dir.strip("'").strip('"') + os.sep
else:
    inDir = args.dir
Ejemplo n.º 5
0
	def find_poly(user_analysis,Date_Ini, Date_Fin, shape_folder):
         if user_analysis == 'no':
             alldb = firebase.get('coordinatesUser/', None)
             pending = []
             for item in alldb.items(): #itera por la bd
                 usuario = item[0]
                 for item_terreno in item[1].values():
                     try:
                         if item_terreno['status'] == "Pendiente":
                             pending.append(dict({"user" : usuario , "terrain": item_terreno['uid'], "timestamp" : item_terreno['timestamp'], "name":item_terreno['name']})) 
                     except:
                         pass
             pending = sorted(pending, key = lambda i: i['timestamp'],reverse=True)
             user_analysis = pending[0]['user']+"/"+pending[0]['terrain']
             #name = pending[0]['name']
         '''
         if (Date_Ini == 'no'):
             request_date = firebase.get('coordinatesUser/'+user_analysis+'/timestamp', None) #Conseguir fecha
             time_window = firebase.get('coordinatesUser/'+user_analysis+'/years', None) #Conseguir ventana de tiempo
             Date_Ini = time.strftime('%Y-%m-%d', time.gmtime((int(request_date)/1000) - (int(time_window))*31536000))
             Date_Fin = time.strftime('%Y-%m-%d', time.gmtime(int(request_date)/1000))
         '''

         result = firebase.get('/coordinatesUser/'+user_analysis+'/Coordenadas', None)
         name = firebase.get('coordinatesUser/'+user_analysis+'/name', None) #Conseguir name lote
         lote_aoi = Polygon(result)
         polygons = []
         polygons.append(Polygon(lote_aoi))
         lote_aoi = gpd.GeoDataFrame(gpd.GeoSeries(poly for poly in polygons), columns=['geometry']) 
         
         lote_aoi.crs = {'init':'epsg:4326', 'no_defs': True}  #epsg:4326 is standard world coordinates
         #Conversión de coordenadas especificas locales
         lote_aoi_loc= lote_aoi.to_crs(32618) 
         lote_aoi_loc["x"] = lote_aoi_loc.centroid.map(lambda p: p.x) 
         lote_aoi_loc["y"] = lote_aoi_loc.centroid.map(lambda p: p.y)
         lote_aoi["x"] = float(lote_aoi.centroid.map(lambda p: p.x))
         lote_aoi["y"] = float(lote_aoi.centroid.map(lambda p: p.y))
         minx = float(lote_aoi_loc["x"])- (767.5*10)
         maxx = float(lote_aoi_loc["x"])+ (767.5*10)
         miny = float(lote_aoi_loc["y"])- (767.5*10)
         maxy = float(lote_aoi_loc["y"])+ (767.5*10)
         lote_aoi_loc["area"] = float(lote_aoi_loc.area)
         lote_aoi["area"] = lote_aoi_loc["area"] #copy area from local in meters
         #agregar nombre de lote
         lote_aoi["name"]=name
         lote_aoi_loc["name"]=name
         cols=lote_aoi.columns.tolist() 
         cols=cols[-1:]+cols[:-1] #reorder column names
         lote_aoi = lote_aoi[cols]
         lote_aoi_loc = lote_aoi_loc[cols]
         
         
         #Creación del shape respecto a coordenas de vértices
         analysis_area = user_analysis.split("/")[1]
         w = shapefile.Writer(shape_folder+analysis_area+'/big_box')
         w.field('name', 'C')
         w.poly([
                     [[minx,miny], [minx,maxy], [maxx,maxy], [maxx,miny], [minx,miny]]
                     ])
         w.record('polygon')
         w.close()
         
         #creacion de bounding box respecot a vertices, para cloud_finder
         inProj = Proj(init='epsg:32618')
         outProj = Proj(init='epsg:4326')
         x1,y1 = transform(inProj,outProj,minx,miny)
         x2,y2 = transform(inProj,outProj,maxx,maxy)
         bbox_coords_wgs84 = [x1,y2,x2,y1]
         bounding_box = BBox(bbox_coords_wgs84, crs=CRS.WGS84)

         return lote_aoi, lote_aoi_loc, minx,maxx,miny,maxy, bounding_box, user_analysis,analysis_area, Date_Ini, Date_Fin