示例#1
0
文件: geo.py 项目: mthh/noname-stuff
def try_open_geojson(file_path):
    replaced = False
    try:
        gdf = GeoDataFrame.from_file(file_path)
    except fiona_err.CPLE_AppDefinedError as err:
        replace_geojson_id_field(file_path)
        replaced = True
        gdf = GeoDataFrame.from_file(file_path)
    return gdf, replaced
示例#2
0
def makedata(ifile, zfield, *args):
	# if csv:
	if ifile[-4:] == '.csv':
		data = pd.read_csv(ifile, header=0)
		# Filter data
		data = data[(data[zfield] != -9999.0) & (data[lat] != -9999.0) & (pd.isnull(data[lat]) == False)]
		# Get points and Buffer to create polygon type
		coords = GeoSeries([Point(x, y) for x, y in zip(data[lon], data[lat])])
		data['geometry'] = coords.buffer(0.0001)
		# Filter out null types
		data = data[pd.isnull(data.geometry) == False]
		#Recreate index
		data.index = [i for i in range(len(data))]
		return GeoDataFrame(data)#

	elif ifile[-4:] == '.shp':
		data = GeoDataFrame.from_file(ifile)
		# Polygon types
		if isinstance(data.geometry[1], Polygon) == True:
			data = data[pd.isnull(data.geometry) == False]
			return data
		# Point types
		elif isinstance(data.geometry[1], Point) == True:
			coords = data.geometry.buffer(0.0001)
			data['geometry'] = coords
			# Filter out null types
			data = data[pd.isnull(data.geometry) == False]
			# Recreate index
			data.index = [i for i in range(len(data))]
			return GeoDataFrame(data)
		else:
			return "Filetype not supported - Only points or polygons!"
示例#3
0
def main():
	# Read in Data
	grid = GeoDataFrame.from_file(igrid)
	points = pd.read_csv(ipoints)

	# create geopoints
	geopoints = points2geo(points, lat, lon)

	# match projection info:
	## Points - should already be in wgs84
	geopoints.crs =wgs84
	geopoints['geometry'] = geopoints['geometry'].to_crs(epsg=4326)
	## Grid - project from meters to wgs84
	grid.crs = gridproj
	grid['geometry'] = grid['geometry'].to_crs(epsg=4326)
	# create uid to groupby 
	grid['id'] = [i for i in range(len(grid))] 

	# Spatial join points to grid
	join_inner_df = sjoin(grid, geopoints, how="inner")
	# Group by the uid and geometry - return mean
	join_inner_df = join_inner_df.groupby(['id','geometry'])['Decibel'].mean()
	# join_inner_df = join_inner_df.groupby(['id','geometry'])['Decibel'].max()

	# Create geodataframe & reset the index of the file
	output = GeoDataFrame(join_inner_df)
	output = output.reset_index()

	# output

	# write to file
	output.to_file(ofile)
示例#4
0
def save_reload(result_layer):
    """
    Save the 'result_layer' geodataframe as a Shapefile and reload it.

    Save the 'result_layer' geodataframe as a Shapefile (with the hope of
    taking advantage of the reparation of some geometries offered by one of the
    intermediate libraries used for saving it), then reload it and return it
    as a GeoJSON FeatureCollection, loaded in a python 'dict'.

    Parameters
    ----------
    result_layer: GeoDataFrame
        The GeoDataFrame containing the contour computed
        from smoomapy functionnality.

    Returns
    -------
    result_layer: dict
        The same layer with, hopefully, some geometry error fixed. The layer is
        returned loaded as a 'dict', using GeoJSON schema.
    """
    with tempfile.TemporaryDirectory() as tmpdirname:
        fpath = path_join(tmpdirname, 'result.shp')
        result_layer.to_file(fpath)
        gdf = GeoDataFrame.from_file(fpath)
        return json.loads(gdf[::-1].to_json())
示例#5
0
    def setUp(self):
        N = 10
        # Data from http://www.nyc.gov/html/dcp/download/bytes/nybb_13a.zip
        # saved as geopandas/examples/nybb_13a.zip.
        if not os.path.exists(os.path.join('examples', 'nybb_13a.zip')):
            with open(os.path.join('examples', 'nybb_13a.zip'), 'w') as f:
                response = urllib2.urlopen('http://www.nyc.gov/html/dcp/download/bytes/nybb_13a.zip')
                f.write(response.read())
        self.df = GeoDataFrame.from_file(
            '/nybb_13a/nybb.shp', vfs='zip://examples/nybb_13a.zip')
        self.tempdir = tempfile.mkdtemp()
        self.boros = np.array(['Staten Island', 'Queens', 'Brooklyn',
                               'Manhattan', 'Bronx'])
        self.crs = {'init': 'epsg:4326'}
        self.df2 = GeoDataFrame([
            {'geometry' : Point(x, y), 'value1': x + y, 'value2': x * y}
            for x, y in zip(range(N), range(N))], crs=self.crs)

        # Try to create the database, skip the db tests if something goes
        # wrong
        # If you'd like these tests to run, create a database called
        # 'test_geopandas' and enable postgis in it:
        # > createdb test_geopandas
        # > psql -c "CREATE EXTENSION postgis" -d test_geopandas
        try:
            self._create_db()
            self.run_db_test = True
        except (NameError, OperationalError):
            # NameError is thrown if psycopg2 fails to import at top of file
            # OperationalError is thrown if we can't connect to the database
            self.run_db_test = False
示例#6
0
 def test_to_file(self):
     tempfilename = os.path.join(self.tempdir, 'boros.shp')
     self.df.to_file(tempfilename)
     # Read layer back in?
     df = GeoDataFrame.from_file(tempfilename)
     self.assertTrue('geometry' in df)
     self.assertTrue(len(df) == 5)
     self.assertTrue(np.alltrue(df['BoroName'].values == self.boros))
示例#7
0
    def test_input_with_missing_values(self):
        gdf = GeoDataFrame.from_file("misc/nuts3_data.geojson")
        gdf.loc[12:18, "gdppps2008"] = np.NaN
        idw = SmoothIdw(gdf, "gdppps2008", power=1, nb_pts=2600, mask=gdf)
        result = idw.render(9, "jenks", 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'] = ""
        idw = SmoothIdw(gdf2, 'gdppps2008', power=1, nb_pts=1200, mask=gdf2)
        result = idw.render(9, 'jenks', output="GeoDataFrame")
        self.assertIsInstance(result, GeoDataFrame)
        self.assertEqual(len(result), 9)
示例#8
0
 def test_to_file(self):
     tempfilename = os.path.join(self.tempdir, 'boros.shp')
     self.df.to_file(tempfilename)
     # Read layer back in?
     df = GeoDataFrame.from_file(tempfilename)
     self.assertTrue('geometry' in df)
     self.assertTrue(len(df) == 5)
     self.assertTrue(np.alltrue(df['BoroName'].values == self.boros))
示例#9
0
def test_to_file_int64(tmpdir, df_points):
    tempfilename = os.path.join(str(tmpdir), "int64.shp")
    geometry = df_points.geometry
    df = GeoDataFrame(geometry=geometry)
    df["data"] = pd.array([1, np.nan] * 5, dtype=pd.Int64Dtype())
    df.to_file(tempfilename)
    df_read = GeoDataFrame.from_file(tempfilename)
    assert_geodataframe_equal(df_read, df, check_dtype=False, check_like=True)
def get_latitude(scenario_path):
    import cea.inputlocator
    data = gdf.from_file(
        cea.inputlocator.InputLocator(scenario_path).get_zone_geometry())
    data = data.to_crs(get_geographic_coordinate_system())
    latitude = data.geometry[0].centroid.coords.xy[1][0]

    return latitude
示例#11
0
def joinTrafficCounts(data_grid, utm10n):
    data_grid['gid'] = data_grid.id
    data_grid.crs = utm10n; print data_grid.crs

    osm_trafficCounts_centroids = GeoDataFrame.from_file(os.getcwd()+'/diysco2-db/_main_/yvr-open-data-traffic-counts/generated-traffic-counts-osm-split/'+'osm_trafficCounts_split_dev_'+str(50)+'_centroids.shp')
    gridded_traffic_counts = sjoin(data_grid, osm_trafficCounts_centroids, how="left")
    print len(gridded_traffic_counts)

    return gridded_traffic_counts 
示例#12
0
def convert(name: str):
    shpName = join(source_path,name, name) + '.shp'
    jsonName = join(output_path, name) + '.json'
    if not isfile(jsonName):
        gdf = GeoDataFrame.from_file(shpName, encoding='tis-620')
        gdf = gdf.to_crs(epsg=4326)
        gdf.to_file(jsonName, driver="GeoJSON")

    formatJsonFile(jsonName)
示例#13
0
def schedule_maker_main(locator, config, building=None):
    # local variables
    buildings = config.schedule_maker.buildings
    schedule_model = config.schedule_maker.schedule_model

    if schedule_model == 'deterministic':
        stochastic_schedule = False
    elif schedule_model == 'stochastic':
        stochastic_schedule = True
    else:
        raise ValueError("Invalid schedule model: {schedule_model}".format(**locals()))

    if building != None:
        buildings = [building]  # this is to run the tests

    # CHECK DATABASE
    if is_3_22(config.scenario):
        raise ValueError("""The data format of indoor comfort has been changed after v3.22. 
        Please run Data migrator in Utilities.""")

    # get variables of indoor comfort and internal loads
    internal_loads = dbf_to_dataframe(locator.get_building_internal()).set_index('Name')
    indoor_comfort = dbf_to_dataframe(locator.get_building_comfort()).set_index('Name')
    architecture = dbf_to_dataframe(locator.get_building_architecture()).set_index('Name')

    # get building properties
    prop_geometry = Gdf.from_file(locator.get_zone_geometry())
    prop_geometry['footprint'] = prop_geometry.area
    prop_geometry['GFA_m2'] = prop_geometry['footprint'] * (prop_geometry['floors_ag'] + prop_geometry['floors_bg'])
    prop_geometry['GFA_ag_m2'] = prop_geometry['footprint'] * prop_geometry['floors_ag']
    prop_geometry['GFA_bg_m2'] = prop_geometry['footprint'] * prop_geometry['floors_bg']
    prop_geometry = prop_geometry.merge(architecture, on='Name').set_index('Name')
    prop_geometry = calc_useful_areas(prop_geometry)

    # get calculation year from weather file
    weather_path = locator.get_weather_file()
    weather_data = epwreader.epw_reader(weather_path)[['year', 'drybulb_C', 'wetbulb_C',
                                                       'relhum_percent', 'windspd_ms', 'skytemp_C']]
    year = weather_data['year'][0]

    # create date range for the calculation year
    date_range = get_date_range_hours_from_year(year)

    # SCHEDULE MAKER
    n = len(buildings)
    calc_schedules_multiprocessing = cea.utilities.parallel.vectorize(calc_schedules,
                                                                      config.get_number_of_processes(),
                                                                      on_complete=print_progress)

    calc_schedules_multiprocessing(repeat(locator, n),
                                   buildings,
                                   repeat(date_range, n),
                                   [internal_loads.loc[b] for b in buildings],
                                   [indoor_comfort.loc[b] for b in buildings],
                                   [prop_geometry.loc[b] for b in buildings],
                                   repeat(stochastic_schedule, n))
    return None
示例#14
0
 def test_to_file(self):
     with tempfile.NamedTemporaryFile(suffix='.shp') as t:
         self.df.to_file(t.name)
         # Read layer back in?
         df = GeoDataFrame.from_file(t.name)
         self.assertTrue('geometry' in df)
         self.assertTrue(len(df) == 5)
         self.assertTrue(np.alltrue(df['BoroName'].values == np.array(['Staten Island',
                                'Queens', 'Brooklyn', 'Manhattan', 'Bronx'])))
示例#15
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']
示例#16
0
 def get_geo_dataframe(self):
     self._model.geo_dataframe = GeoDataFrame.from_file(
         self._model.file_path)
     # init coordination
     if self._model.coordination in CONST.EPSG:
         self._model.geo_dataframe.crs = {
             'init': 'epsg:' + str(CONST.EPSG[self._model.coordination])
         }
     print(self._model.geo_dataframe.head())
示例#17
0
def test_to_file(tmpdir, df_nybb, df_null, driver, ext):
    """ Test to_file and from_file """
    tempfilename = os.path.join(str(tmpdir), "boros." + ext)
    df_nybb.to_file(tempfilename, driver=driver)
    # Read layer back in
    df = GeoDataFrame.from_file(tempfilename)
    assert "geometry" in df
    assert len(df) == 5
    assert np.alltrue(df["BoroName"].values == df_nybb["BoroName"])

    # Write layer with null geometry out to file
    tempfilename = os.path.join(str(tmpdir), "null_geom." + ext)
    df_null.to_file(tempfilename, driver=driver)
    # Read layer back in
    df = GeoDataFrame.from_file(tempfilename)
    assert "geometry" in df
    assert len(df) == 2
    assert np.alltrue(df["Name"].values == df_null["Name"])
示例#18
0
def calc_area_buildings(locator, buildings_list):
    # initialize value
    prop_geometry = Gdf.from_file(locator.get_zone_geometry())
    prop_geometry['footprint'] = prop_geometry.area

    footprint = prop_geometry[prop_geometry["Name"].isin(buildings_list)]['footprint']
    area_below_buildings = footprint.sum()

    return area_below_buildings
示例#19
0
def test_to_file_pathlib(tmpdir, df_nybb, df_null, driver, ext):
    """ Test to_file and from_file """
    temppath = pathlib.Path(os.path.join(str(tmpdir), "boros." + ext))
    df_nybb.to_file(temppath, driver=driver)
    # Read layer back in
    df = GeoDataFrame.from_file(temppath)
    assert "geometry" in df
    assert len(df) == 5
    assert np.alltrue(df["BoroName"].values == df_nybb["BoroName"])
示例#20
0
    def test_to_file(self):
        """ Test to_file and from_file """
        tempfilename = os.path.join(self.tempdir, 'boros.shp')
        self.df.to_file(tempfilename)
        # Read layer back in
        df = GeoDataFrame.from_file(tempfilename)
        assert 'geometry' in df
        assert len(df) == 5
        assert np.alltrue(df['BoroName'].values == self.boros)

        # Write layer with null geometry out to file
        tempfilename = os.path.join(self.tempdir, 'null_geom.shp')
        self.df3.to_file(tempfilename)
        # Read layer back in
        df3 = GeoDataFrame.from_file(tempfilename)
        assert 'geometry' in df3
        assert len(df3) == 2
        assert np.alltrue(df3['Name'].values == self.line_paths)
def sampling_single(locator, random_variables, target_parameters,
                    list_building_names, config, nn_delay, climatic_variables,
                    year, use_stochastic_occupancy):
    size_city = np.shape(list_building_names)
    size_city = size_city[0]

    bld_counter = 0
    # create list of samples with a LHC sampler and save to disk (*.csv)
    samples, samples_norm, pdf_list = latin_sampler(locator, size_city,
                                                    random_variables)
    for building_name in (list_building_names):
        np.save(locator.get_calibration_folder(), samples)
        building_load = config.single_calibration.load
        override_file = Gdf.from_file(
            locator.get_zone_geometry()).set_index('Name')
        override_file = pd.DataFrame(index=override_file.index)
        problem = {
            'variables': random_variables,
            'building_load': target_parameters,
            'probabiltiy_vars': pdf_list
        }
        pickle.dump(
            problem,
            file(locator.get_calibration_problem(building_name, building_load),
                 'w'))
        sample = np.asarray(zip(random_variables, samples[bld_counter, :]))
        apply_sample_parameters(locator, sample, override_file)
        bld_counter = bld_counter + 1
    # read the saved *.csv file and replace Boolean with logical (True/False)
    overwritten = pd.read_csv(locator.get_building_overrides())
    bld_counter = 0
    for building_name in (list_building_names):
        sample = np.asarray(zip(random_variables, samples[bld_counter, :]))
        for boolean_mask in (boolean_vars):
            indices = np.where(sample == boolean_mask)

            if sample[indices[0], 1] == '0.0':
                sample[indices[0], 1] = 'False'
            else:
                sample[indices[0], 1] = 'True'

        overwritten.loc[overwritten.Name == building_name,
                        random_variables] = sample[:, 1]
        bld_counter = bld_counter + 1

    # write to csv format
    overwritten.to_csv(locator.get_building_overrides())

    #   run cea demand
    demand_main.demand_calculation(locator, config)

    #   prepare the inputs for feeding into the neural network
    urban_input_matrix, urban_taget_matrix = input_prepare_main(
        list_building_names, locator, target_parameters, nn_delay,
        climatic_variables, year, use_stochastic_occupancy)

    return urban_input_matrix, urban_taget_matrix
示例#22
0
    def test_to_file(self):
        """ Test to_file and from_file """
        tempfilename = os.path.join(self.tempdir, "boros.shp")
        self.df.to_file(tempfilename)
        # Read layer back in
        df = GeoDataFrame.from_file(tempfilename)
        self.assertTrue("geometry" in df)
        self.assertTrue(len(df) == 5)
        self.assertTrue(np.alltrue(df["BoroName"].values == self.boros))

        # Write layer with null geometry out to file
        tempfilename = os.path.join(self.tempdir, "null_geom.shp")
        self.df3.to_file(tempfilename)
        # Read layer back in
        df3 = GeoDataFrame.from_file(tempfilename)
        self.assertTrue("geometry" in df3)
        self.assertTrue(len(df3) == 2)
        self.assertTrue(np.alltrue(df3["Name"].values == self.line_paths))
示例#23
0
    def test_to_file(self):
        """ Test to_file and from_file """
        tempfilename = os.path.join(self.tempdir, 'boros.shp')
        self.df.to_file(tempfilename)
        # Read layer back in
        df = GeoDataFrame.from_file(tempfilename)
        assert 'geometry' in df
        assert len(df) == 5
        assert np.alltrue(df['BoroName'].values == self.boros)

        # Write layer with null geometry out to file
        tempfilename = os.path.join(self.tempdir, 'null_geom.shp')
        self.df3.to_file(tempfilename)
        # Read layer back in
        df3 = GeoDataFrame.from_file(tempfilename)
        assert 'geometry' in df3
        assert len(df3) == 2
        assert np.alltrue(df3['Name'].values == self.line_paths)
    def surroundings_building_records(self):
        surroundings_buildings_df = gdf.from_file(
            self.locator.get_surroundings_geometry())
        # clear in case there are repetitive buildings in the zone file
        surroundings_buildings_df = surroundings_buildings_df.loc[
            ~surroundings_buildings_df["Name"].isin(self.zone_building_names)]
        surroundings_buildings_df.reset_index(inplace=True, drop=True)

        return surroundings_buildings_df
示例#25
0
def test_geometries(tmpdir):
    point_file = '{}/test_file_point.shp'.format(tmpdir)
    polygon_file = '{}/test_file_polygon.shp'.format(tmpdir)
    polyline_file = '{}/test_file_polyline.shp'.format(tmpdir)

    _point_file(point_file)
    _polygon_file(polygon_file)
    _polyline_file(polyline_file)

    df_point = GeoDataFrame.from_file(point_file)
    df_polygon = GeoDataFrame.from_file(polygon_file)
    df_polyline = GeoDataFrame.from_file(polyline_file)

    p = (ggplot() + aes(fill='geometry.bounds.miny') + geom_map(df_polygon) +
         geom_map(df_point, size=4) + geom_map(df_polyline, size=2) +
         labs(fill='miny'))

    assert p + _theme == 'geometries'
示例#26
0
def building_2d_to_3d(locator, zone_df, surroundings_df, elevation_map, config,
                      geometry_pickle_dir):
    """
    :param locator: InputLocator - provides paths to files in a scenario
    :type locator: cea.inputlocator.InputLocator
    :param config: the configuration object to use
    :type config: cea.config.Configuration
    :return:
    """

    # Config variables
    num_processes = config.get_number_of_processes()
    zone_simplification = config.radiation.zone_geometry
    surroundings_simplification = config.radiation.surrounding_geometry
    consider_intersections = config.radiation.consider_intersections

    print('Calculating terrain intersection of building geometries')
    zone_buildings_df = zone_df.set_index('Name')
    zone_building_names = zone_buildings_df.index.values
    zone_building_solid_list = calc_building_solids(zone_buildings_df,
                                                    zone_simplification,
                                                    elevation_map,
                                                    num_processes)

    surroundings_buildings_df = surroundings_df.set_index('Name')
    surroundings_building_names = surroundings_buildings_df.index.values
    surroundings_building_solid_list = calc_building_solids(
        surroundings_buildings_df, surroundings_simplification, elevation_map,
        num_processes)

    architecture_wwr_df = gdf.from_file(
        locator.get_building_architecture()).set_index('Name')

    # calculate geometry for the surroundings
    print('Generating geometry for surrounding buildings')
    geometry_3D_surroundings = [
        calc_building_geometry_surroundings(x, y, geometry_pickle_dir) for x, y
        in zip(surroundings_building_names, surroundings_building_solid_list)
    ]

    # calculate geometry for the zone of analysis
    print('Generating geometry for buildings in the zone of analysis')
    n = len(zone_building_names)
    calc_zone_geometry_multiprocessing = cea.utilities.parallel.vectorize(
        calc_building_geometry_zone, num_processes, on_complete=print_progress)

    if consider_intersections:
        all_building_solid_list = np.append(zone_building_solid_list,
                                            surroundings_building_solid_list)
    else:
        all_building_solid_list = []
    geometry_3D_zone = calc_zone_geometry_multiprocessing(
        zone_building_names, zone_building_solid_list,
        repeat(all_building_solid_list, n), repeat(architecture_wwr_df, n),
        repeat(geometry_pickle_dir, n), repeat(consider_intersections, n))
    return geometry_3D_zone, geometry_3D_surroundings
def main():
	# read in data and fix headers
	data = pd.read_csv('/Users/Jozo/Dropbox/UBC/cirs/energyexplorer/data/optimized/energy/consumption/ceei_2010_metrovan.csv')
	data.columns = fixheaders(data)

	# electricity (mostly renewable), heating fuel (fossil fuels), & transporation (fossil fuels) by LocalGovtName
	groupedData =data.groupby(['LocalGovtName', 'LocalGovtType', 'MeasurementDesc', 'Sector'])['EnergyGJ'].sum()
	groupedData.to_csv('/Users/Jozo/Dropbox/UBC/cirs/energyexplorer/data/optimized/energy/consumption/ceei_2010_metrovan_grouped.csv')

	# read in grouped data
	newdata = pd.read_csv('/Users/Jozo/Dropbox/UBC/cirs/energyexplorer/data/optimized/energy/consumption/ceei_2010_metrovan_grouped.csv', header=False)
	newdata.columns = ['city','ctype', 'sector', 'desc', 'consump']

	# Add in metro vancouver names:
	newdata['metroname'] = pd.Series()

	for i in np.arange(0,len(newdata), 1):
		if newdata.ctype[i] == 'City' or newdata.ctype[i] == 'Village':
			newdata.metroname[i] = str(newdata.ctype[i] + " of " + newdata.city[i])

		elif newdata.city[i] == 'Delta' or newdata.city[i] == 'Langley' and newdata.ctype[i] == 'District Municipality':
			newdata.metroname[i] = str('Township' + " of " + newdata.city[i])

		elif newdata.city[i] == 'Maple Ridge' or newdata.city[i] == 'North Vancouver' or newdata.city[i] == 'West Vancouver'  and newdata.ctype[i] == 'District Municipality':
			newdata.metroname[i] = str('District' + " of " + newdata.city[i])

		elif newdata.city[i] == 'Bowen Island' and newdata.ctype[i] == 'Island Municipality':
			newdata.metroname[i] = str('Village' + " of " + newdata.city[i])

		elif newdata.city[i] == 'Metro-Vancouver' and newdata.ctype[i] == 'Regional District Unincorporated Areas':
			newdata.metroname[i] = str('Electoral Area A')

		elif newdata.city[i] == 'Metro-Vancouver' and newdata.ctype[i] == 'Regional District':
			newdata.metroname[i] = str(newdata.city[i] + " " + newdata.ctype[i])

	newdata.to_csv('/Users/Jozo/Dropbox/UBC/cirs/energyexplorer/data/optimized/energy/consumption/ceei_2010_metrovan_grouped_metronames.csv')

	# Pivot data
	newdata_pivot =newdata.pivot(index = 'metroname',columns ='sector', values='consump')
	#fill na with 0
	newdata_pivot = newdata_pivot.fillna(0)
	# fix columns
	newdata_pivot.columns = fixheaders(newdata_pivot)
	newdata_pivot.to_csv('/Users/Jozo/Dropbox/UBC/cirs/energyexplorer/data/optimized/energy/consumption/ceei_2010_metrovan_grouped_metronames_formatted.csv', index='metroname')

	''' --- merge with shapefile --- '''
	metrovan =  GeoDataFrame.from_file('/Users/Jozo/Dropbox/UBC/CIRs/EnergyExplorer/data/optimized/metroVan/metroVan.shp')
	joindata = pd.read_csv('/Users/Jozo/Dropbox/UBC/cirs/energyexplorer/data/optimized/energy/consumption/ceei_2010_metrovan_grouped_metronames_formatted.csv', header=False)

	output = GeoDataFrame.merge(metrovan, joindata, left_on="NAMEMUNI", right_on="metroname")
	outputcol = [i for i in joindata.columns]
	outputcol.append('geometry')

	output = output[outputcol]

	output.to_file('/Users/Jozo/Dropbox/UBC/CIRs/EnergyExplorer/data/optimized/energy/consumption/ceei_2010/ceei_2010_metrovan_formatted.shp')
def testing():
    from geopandas import GeoDataFrame as gpdf
    import cea.globalvar
    gv = cea.globalvar.GlobalVariables()
    from cea import inputlocator
    import time
    import simple_window_generator

    # generate windows based on geometry of vertical surfaces in radiation file
    locator = inputlocator.InputLocator(scenario_path=r'C:\reference-case\baseline')

    surface_properties = pd.read_csv(locator.get_surface_properties())
    gdf_building_architecture = gpdf.from_file(locator.get_building_architecture()).drop('geometry', axis=1).set_index('Name')
    prop_geometry = gpdf.from_file(locator.get_building_geometry())
    prop_geometry['footprint'] = prop_geometry.area
    prop_geometry['perimeter'] = prop_geometry.length
    prop_geometry = prop_geometry.drop('geometry', axis=1).set_index('Name')
    df_windows = simple_window_generator.create_windows(surface_properties, gdf_building_architecture)

    building_test = 'B153737'  # 'B154767' this building doesn't have windows
    # get building windows
    df_windows_building_test = df_windows.loc[df_windows['name_building'] == building_test].to_dict('list')
    # get building geometry
    gdf_building_test = prop_geometry.ix[building_test]
    gdf_building_architecture = gdf_building_architecture.ix[building_test]

    r_window_arg = 0.1
    temp_ext = 5
    temp_zone = 22
    u_wind = 0.5
    u_wind_10 = u_wind
    factor_cros = 1  # 1 = cross ventilation possible # TODO: get from building properties

    dict_props_nat_vent = get_properties_natural_ventilation(gdf_building_test, gdf_building_architecture, gv)
    qm_arg_in, qm_arg_out \
        = calc_qm_arg(factor_cros, temp_ext, df_windows_building_test, u_wind_10, temp_zone, r_window_arg)

    t0 = time.time()
    res = calc_air_flows(temp_zone, u_wind, temp_ext, dict_props_nat_vent)
    t1 = time.time()

    print(res)
    print(['time: ', t1 - t0])
示例#29
0
    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)
示例#30
0
    def test_to_file_with_poly_z(self):
        """Test that 3D geometries are retained in writes (GH #612)."""

        tempfilename = os.path.join(self.tempdir, 'test_3Dpoly.shp')
        poly3d = Polygon([[0, 0, 5], [0, 1, 5], [1, 1, 5], [1, 0, 5]])
        poly2d = Polygon([[0, 0], [0, 1], [1, 1], [1, 0]])
        df = GeoDataFrame({'a': [1, 2]}, geometry=[poly3d, poly2d], crs={})
        df.to_file(tempfilename)
        df_read = GeoDataFrame.from_file(tempfilename)
        assert_geoseries_equal(df.geometry, df_read.geometry)
示例#31
0
    def test_to_file_with_point_z(self):
        """Test that 3D geometries are retained in writes (GH #612)."""

        tempfilename = os.path.join(self.tempdir, 'test_3Dpoint.shp')
        point3d = Point(0, 0, 500)
        point2d = Point(1, 1)
        df = GeoDataFrame({'a': [1, 2]}, geometry=[point3d, point2d], crs={})
        df.to_file(tempfilename)
        df_read = GeoDataFrame.from_file(tempfilename)
        assert_geoseries_equal(df.geometry, df_read.geometry)
示例#32
0
def test_facet_wrap(tmpdir):
    polygon_file = '{}/test_file_polygon.shp'.format(tmpdir)
    _polygon_file(polygon_file)

    df_polygon = GeoDataFrame.from_file(polygon_file)
    df_polygon['shape'] = ['rectangle', 'triangle']

    p = (ggplot() + aes(fill='geometry.bounds.miny') + geom_map(df_polygon) +
         facet_wrap('shape') + labs(fill='miny'))
    assert p + _theme == 'facet_wrap'
    def test_to_file_with_point_z(self):
        """Test that 3D geometries are retained in writes (GH #612)."""

        tempfilename = os.path.join(self.tempdir, 'test_3Dpoint.shp')
        point3d = Point(0, 0, 500)
        point2d = Point(1, 1)
        df = GeoDataFrame({'a': [1, 2]}, geometry=[point3d, point2d], crs={})
        df.to_file(tempfilename)
        df_read = GeoDataFrame.from_file(tempfilename)
        assert_geoseries_equal(df.geometry, df_read.geometry)
示例#34
0
def test_to_file_with_poly_z(tmpdir, ext, driver):
    """Test that 3D geometries are retained in writes (GH #612)."""

    tempfilename = os.path.join(str(tmpdir), "test_3Dpoly." + ext)
    poly3d = Polygon([[0, 0, 5], [0, 1, 5], [1, 1, 5], [1, 0, 5]])
    poly2d = Polygon([[0, 0], [0, 1], [1, 1], [1, 0]])
    df = GeoDataFrame({"a": [1, 2]}, geometry=[poly3d, poly2d], crs=_CRS)
    df.to_file(tempfilename, driver=driver)
    df_read = GeoDataFrame.from_file(tempfilename)
    assert_geoseries_equal(df.geometry, df_read.geometry)
示例#35
0
def test_geometries(tmpdir):
    test_file = '{}/test_file.shp'.format(tmpdir)
    _create_test_input_files(test_file)

    df = GeoDataFrame.from_file(test_file)
    p = (ggplot(df) + aes(fill='geometry.bounds.miny') + geom_map() +
         geom_map(draw='Point', size=4) + geom_map(draw='LineString', size=2) +
         labs(fill='miny'))

    assert p + _theme == 'geometries'
    def test_to_file_with_poly_z(self):
        """Test that 3D geometries are retained in writes (GH #612)."""

        tempfilename = os.path.join(self.tempdir, 'test_3Dpoly.shp')
        poly3d = Polygon([[0, 0, 5], [0, 1, 5], [1, 1, 5], [1, 0, 5]])
        poly2d = Polygon([[0, 0], [0, 1], [1, 1], [1, 0]])
        df = GeoDataFrame({'a': [1, 2]}, geometry=[poly3d, poly2d], crs={})
        df.to_file(tempfilename)
        df_read = GeoDataFrame.from_file(tempfilename)
        assert_geoseries_equal(df.geometry, df_read.geometry)
示例#37
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
示例#38
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
示例#39
0
def test_add_stats():
    from geopandas import GeoDataFrame
    polygons = os.path.join(DATA, 'polygons.shp')
    df = GeoDataFrame.from_file(polygons)

    def mymean(x):
        return np.ma.mean(x)

    stats = zonal_stats(df.geometry, raster, add_stats={'mymean': mymean})
    for i in range(len(stats)):
        assert stats[i]['mean'] == stats[i]['mymean']
示例#40
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']
示例#41
0
def read_vector(vector, res, column=None, value=1., compute_area=False,
                dtype=np.float64, eea=False, epsg=None,
                bounds=None, grid=None, all_touched=True, fillvalue=0.,
                use_centroid=False):
    logger.debug('Reading vector as geodataframe')
    gdf = GeoDataFrame.from_file(vector)
    if use_centroid:
        gdf.geometry = gdf.geometry.centroid
    return read_df(gdf, res, column, value, compute_area,
                   dtype, eea, epsg, bounds, grid,
                   all_touched=all_touched, fillvalue=fillvalue)
示例#42
0
def main(config):
    assert os.path.exists(
        config.scenario), 'Scenario not found: %s' % config.scenario
    locator = cea.inputlocator.InputLocator(scenario=config.scenario)

    print('Running photovoltaic with scenario = %s' % config.scenario)
    print('Running photovoltaic with annual-radiation-threshold-kWh/m2 = %s' %
          config.solar.annual_radiation_threshold)
    print('Running photovoltaic with panel-on-roof = %s' %
          config.solar.panel_on_roof)
    print('Running photovoltaic with panel-on-wall = %s' %
          config.solar.panel_on_wall)
    print('Running photovoltaic with solar-window-solstice = %s' %
          config.solar.solar_window_solstice)
    print('Running photovoltaic with type-pvpanel = %s' %
          config.solar.type_pvpanel)
    if config.solar.custom_tilt_angle:
        print(
            'Running photovoltaic with custom-tilt-angle = %s and panel-tilt-angle = %s'
            % (config.solar.custom_tilt_angle, config.solar.panel_tilt_angle))
    else:
        print('Running photovoltaic with custom-tilt-angle = %s' %
              config.solar.custom_tilt_angle)
    if config.solar.custom_roof_coverage:
        print(
            'Running photovoltaic with custom-roof-coverage = %s and max-roof-coverage = %s'
            % (config.solar.custom_roof_coverage,
               config.solar.max_roof_coverage))
    else:
        print('Running photovoltaic with custom-roof-coverage = %s' %
              config.solar.custom_roof_coverage)

    building_names = locator.get_zone_building_names()
    zone_geometry_df = gdf.from_file(locator.get_zone_geometry())
    latitude, longitude = get_lat_lon_projected_shapefile(zone_geometry_df)

    # list_buildings_names =['B026', 'B036', 'B039', 'B043', 'B050'] for missing buildings
    weather_data = epwreader.epw_reader(locator.get_weather_file())
    date_local = solar_equations.calc_datetime_local_from_weather_file(
        weather_data, latitude, longitude)

    num_process = config.get_number_of_processes()
    n = len(building_names)
    cea.utilities.parallel.vectorize(calc_PV,
                                     num_process)(repeat(locator, n),
                                                  repeat(config, n),
                                                  repeat(latitude, n),
                                                  repeat(longitude, n),
                                                  repeat(weather_data, n),
                                                  repeat(date_local, n),
                                                  building_names)

    # aggregate results from all buildings
    write_aggregate_results(locator, building_names, num_process)
示例#43
0
def test_add_stats():
    from geopandas import GeoDataFrame
    polygons = os.path.join(DATA, 'polygons.shp')
    df = GeoDataFrame.from_file(polygons)

    def mymean(x):
        return np.ma.mean(x)

    stats = zonal_stats(df.geometry, raster, add_stats={'mymean': mymean})
    for i in range(len(stats)):
        assert stats[i]['mean'] == stats[i]['mymean']
示例#44
0
    def open_mask(self, mask, input_layer):
        # Read the mask according to its format:
        if isinstance(mask, GeoDataFrame):
            self.mask = mask
        elif isinstance(mask, str) and isinstance(input_layer, str) \
                and mask == input_layer:
            self.mask = self.gdf.copy()
        else:
            self.mask = GeoDataFrame.from_file(mask)

        self.check_mask()
示例#45
0
def calc_building_centroids(input_buildings_shp,
                            temp_path_building_centroids_shp,
                            list_district_scale_buildings,
                            plant_buildings,
                            consider_only_buildings_with_demand=False,
                            type_network="DH",
                            total_demand=False):
    # # get coordinate system and project to WSG 84
    zone_df = gdf.from_file(input_buildings_shp)
    zone_df = zone_df.loc[zone_df['Name'].isin(list_district_scale_buildings +
                                               plant_buildings)]
    zone_df = zone_df.reset_index(drop=True)

    # get only buildings with a demand, send out a message if there are less than 2 buildings.
    if consider_only_buildings_with_demand:
        total_demand = pd.read_csv(total_demand)
        if type_network == "DH":
            field = "QH_sys_MWhyr"
        elif type_network == "DC":
            field = "QC_sys_MWhyr"
        buildings_with_load = total_demand[
            total_demand[field] > 0.0].Name.tolist()
        selected_buildings = list(
            set(buildings_with_load).union(set(plant_buildings)))
        if len(selected_buildings) >= 2:
            zone_df = zone_df.loc[zone_df['Name'].isin(selected_buildings)]
            zone_df = zone_df.reset_index(drop=True)
        else:
            raise Exception(
                "We could not find two or more buildings with thermal energy demand the network layout "
                "will not work unless the consider_only_buildings_with_demand parameter is set to False"
            )

    zone_df = zone_df.to_crs(get_geographic_coordinate_system())
    lon = zone_df.geometry[0].centroid.coords.xy[0][0]
    lat = zone_df.geometry[0].centroid.coords.xy[1][0]

    # get coordinate system and re project to UTM
    zone_df = zone_df.to_crs(get_projected_coordinate_system(lat, lon))

    # create points with centroid
    points = zone_df.copy()
    points.geometry = zone_df['geometry'].centroid

    # # decrease the number of units of the points
    building_centroids_df = simplify_points_accurracy(points,
                                                      SHAPEFILE_TOLERANCE,
                                                      points.crs)

    # saving result
    building_centroids_df.to_file(temp_path_building_centroids_shp,
                                  driver='ESRI Shapefile')

    return building_centroids_df
示例#46
0
def test_to_file_with_point_z(tmpdir, ext, driver):
    """Test that 3D geometries are retained in writes (GH #612)."""

    tempfilename = os.path.join(str(tmpdir), 'test_3Dpoint.' + ext)
    point3d = Point(0, 0, 500)
    point2d = Point(1, 1)
    df = GeoDataFrame({'a': [1, 2]},
                      geometry=[point3d, point2d],
                      crs={'init': 'epsg:4326'})
    df.to_file(tempfilename, driver=driver)
    df_read = GeoDataFrame.from_file(tempfilename)
    assert_geoseries_equal(df.geometry, df_read.geometry)
示例#47
0
def test_to_file_with_point_z(tmpdir, ext, driver):
    """Test that 3D geometries are retained in writes (GH #612)."""

    tempfilename = os.path.join(str(tmpdir), "test_3Dpoint" + ext)
    point3d = Point(0, 0, 500)
    point2d = Point(1, 1)
    df = GeoDataFrame({"a": [1, 2]}, geometry=[point3d, point2d], crs=_CRS)
    df.to_file(tempfilename, driver=driver)
    df_read = GeoDataFrame.from_file(tempfilename)
    assert_geoseries_equal(df.geometry, df_read.geometry)
    # check the expected driver
    assert_correct_driver(tempfilename, ext)
示例#48
0
 def setUp(self):
     # Data from http://www.nyc.gov/html/dcp/download/bytes/nybb_13a.zip
     # saved as geopandas/examples/nybb_13a.zip.
     if not os.path.exists(os.path.join('examples', 'nybb_13a.zip')):
         with open(os.path.join('examples', 'nybb_13a.zip'), 'w') as f:
             response = urllib2.urlopen('http://www.nyc.gov/html/dcp/download/bytes/nybb_13a.zip')
             f.write(response.read())
     self.df = GeoDataFrame.from_file(
         '/nybb_13a/nybb.shp', vfs='zip://examples/nybb_13a.zip')
     self.tempdir = tempfile.mkdtemp()
     self.boros = np.array(['Staten Island', 'Queens', 'Brooklyn',
                            'Manhattan', 'Bronx'])
    def __init__(self, locator, settings, geometry_terrain, height_col, nfloor_col):
        self.point_to_evaluate = ''
        self.potentially_intersecting_solids = ''
        self.locator = locator
        self.height_col = height_col
        self.nfloor_col = nfloor_col
        self.settings = settings
        self.architecture_wwr_df = gdf.from_file(self.locator.get_building_architecture()).set_index('Name')

        self.terrain_intersection_curves = self.terrain_intersection_curves(geometry_terrain)

        self.zone_buildings_df = gdf.from_file(self.locator.get_zone_geometry()).set_index('Name')
        self.zone_building_names = self.zone_buildings_df.index.values
        self.zone_building_solid_list = np.vectorize(self.calc_zone_building_solids)(self.zone_building_names)

        self.surroundings_buildings_df = self.surroundings_building_records().set_index('Name')
        self.surroundings_building_names = self.surroundings_buildings_df.index.values
        self.surroundings_building_solid_list = np.vectorize(self.calc_surrounding_building_solids, otypes=[object])(self.surroundings_building_names)

        self.all_building_solid_list = np.append(self.zone_building_solid_list,
                                                          self.surroundings_building_solid_list)
示例#50
0
def test_geometries(tmpdir):
    test_file = '{}/test_file.shp'.format(tmpdir)
    _create_test_input_files(test_file)

    df = GeoDataFrame.from_file(test_file)
    p = (ggplot(df)
         + aes(fill='geometry.bounds.miny')
         + geom_map()
         + geom_map(draw='Point', size=4)
         + geom_map(draw='LineString', size=2)
         + labs(fill='miny')
         )

    assert p + _theme == 'geometries'
def lca_mobility(locator):
    """
    algorithm to calculate the primary energy and CO2 emissions for mobility
    in the area in order to compare with the 2000 Watt society benchmark
    based on SIA Standard 2039 (expanded to include industry and hospital
    buildings)
    
    Parameters
    ----------
    :param InputLocator locator: an InputLocator instance set to the scenario to work on

    Returns
    -------
    total_LCA_mobility:.csv
        csv file of yearly primary energy demand and emissions due to mobility
        for each building

    """

    # local files
    demand = pd.read_csv(locator.get_total_demand())
    prop_occupancy = gpdf.from_file(locator.get_building_occupancy()).drop('geometry', axis=1)#.set_index('Name')
    data_mobility = locator.get_data_mobility()
    factors_mobility = pd.read_excel(data_mobility, sheetname='2010')

    # local variables
    result_folder = locator.get_lca_emissions_results_folder()

    # calculate total_LCA_mobility:.csv
    vt = factors_mobility['code']
    pt = factors_mobility['PEN']
    gt = factors_mobility['CO2']

    mobility = prop_occupancy.merge(demand,on='Name')
    fields_to_plot = ['Name', 'GFA_m2', 'M_nre_pen_GJ', 'M_nre_pen_MJm2', 'M_ghg_ton', 'M_ghg_kgm2']
    mobility[fields_to_plot[3]] = 0
    mobility[fields_to_plot[5]] = 0
    for i in range(len(vt)):
        mobility[fields_to_plot[3]] += mobility[vt[i]] * pt[i]
        mobility[fields_to_plot[5]] += mobility[vt[i]] * gt[i]
    mobility[fields_to_plot[2]] = mobility['GFA_m2'] * mobility[fields_to_plot[3]] / 1000
    mobility[fields_to_plot[4]] = mobility['GFA_m2'] * mobility[fields_to_plot[5]] / 1000

    mobility[fields_to_plot].to_csv(locator.get_lca_mobility(), index=False, float_format='%.2f')
def calc_benchmark_today(locator):
    '''
    Calculates the embodied, operation, mobility and total targets (ghg_kgm2
    and pen_MJm2) for the area for the current national trend.
    CURRENTLY BASED ON INDUCITY! Need a better source.
    :param locator: an InputLocator set to the scenario to compute
    :array values_today: pen_MJm2 and ghg_kgm2 for the scenario based on benchmarked present day situation
    '''

    # local files
    demand = pd.read_csv(locator.get_total_demand())
    prop_occupancy = gpdf.from_file(locator.get_building_occupancy()).drop('geometry', axis=1)
    data_benchmark_today = locator.get_data_benchmark_today()
    occupancy = prop_occupancy.merge(demand, on='Name')

    fields = ['Name', 'pen_GJ', 'ghg_ton', 'pen_MJm2', 'ghg_kgm2']
    categories = ['embodied', 'operation', 'mobility', 'total']
    suffix = ['_GJ', '_ton', '_MJm2', '_kgm2']
    values_today = {}
    area_study = 0

    factors = pd.read_excel(data_benchmark_today, sheetname=categories[0])
    for i in range(len(factors['code'])):
        if factors['code'][i] in occupancy:
            if factors['PEN'][i] > 0 and factors['CO2'][i] > 0:
                area_study += (occupancy['GFA_m2'] * occupancy[factors['code'][i]]).sum()

    for category in categories:
        factors = pd.read_excel(data_benchmark_today, sheetname=category)
        vt = factors['code']
        pt = factors['PEN']
        gt = factors['CO2']

        for j in range(len(suffix)):
            values_today[category + suffix[j]] = 0
        for i in range(len(vt)):
            values_today[category + suffix[0]] += (occupancy['GFA_m2'] * occupancy[vt[i]] * pt[i]).sum() / 1000
            values_today[category + suffix[1]] += (occupancy['GFA_m2'] * occupancy[vt[i]] * gt[i]).sum() / 1000
        values_today[category + suffix[2]] += values_today[category + suffix[0]] / area_study * 1000
        values_today[category + suffix[3]] += values_today[category + suffix[1]] / area_study * 1000

    return values_today
def calc_benchmark_targets(locator):
    '''
    Calculates the embodied, operation, mobility and total targets (ghg_kgm2
    and pen_MJm2) for all buildings in a scenario.
    :param locator: an InputLocator set to the scenario to compute
    :array target: pen_MJm2 and ghg_kgm2 target values
    '''

    # local files
    demand = pd.read_csv(locator.get_total_demand())
    prop_occupancy = gpdf.from_file(locator.get_building_occupancy()).drop('geometry', axis=1)
    data_benchmark = locator.get_data_benchmark()
    occupancy = prop_occupancy.merge(demand,on='Name')

    fields = ['Name', 'pen_GJ', 'ghg_ton', 'pen_MJm2', 'ghg_kgm2']
    categories = ['embodied', 'operation', 'mobility', 'total']
    suffix = ['_GJ', '_ton','_MJm2', '_kgm2']
    targets = {}
    area_study = 0

    factors = pd.read_excel(data_benchmark, sheetname=categories[0])
    for i in range(len(factors['code'])):
        if factors['code'][i] in occupancy:
            if factors['PEN'][i] > 0 and factors['CO2'][i] > 0:
                area_study += (occupancy['GFA_m2'] * occupancy[factors['code'][i]]).sum()

    for category in categories:
        factors = pd.read_excel(data_benchmark, sheetname = category)
        vt = factors['code']
        pt = factors['PEN']
        gt = factors['CO2']

        for j in range(len(suffix)):
            targets[category + suffix[j]] = 0
        for i in range(len(vt)):
            targets[category+suffix[0]] += (occupancy['GFA_m2'] * occupancy[vt[i]] * pt[i]).sum() / 1000
            targets[category+suffix[1]] += (occupancy['GFA_m2'] * occupancy[vt[i]] * gt[i]).sum() / 1000
        targets[category + suffix[2]] += targets[category+suffix[0]] / area_study * 1000
        targets[category + suffix[3]] += targets[category + suffix[1]] / area_study * 1000

    return targets
示例#54
0
    def load_data(self, file_path=None):
        """
        Loads the environmental data from the provided :attr:`file_path` shapefile into a ``geopandas.GeoDataFrame``.
        A GeoDataFrame is a tablular data structure that contains a column called ``geometry`` which contains a GeoSeries of
        `Shapely <http://toblerity.org/shapely/shapely.geometry.html>`_ geometries. all other meta-data column names are
        converted to a lower-case, for consistency.

        :param string file_path: The full path to the shapefile file (including the directory and filename in one string).

        :returns: None

        """
        if file_path:
                self.file_path = file_path

        if not self.file_path:
            raise AttributeError("Please provide a file_path argument to load the data from.")

        logger.info("Loading data from %s " % self.file_path)
        self.data_full = GeoDataFrame.from_file(self.file_path)
        self.data_full.columns = [x.lower() for x in self.data_full.columns]
        logger.info("The shapefile contains data on %d environmental regions." % self.data_full.shape[0])
 def import_census_data(self):
     """
     Gets population density from census data
     Inputs:
     census_folder_loc: location of data (string)    
     census_shapefile: name of shapefile (string)
     Returns: 
         df_census: GeoDataFrame with census information
     """ 
     ## Importing shapefile 
     print 'Importing census data'
     self.df_census = GeoDataFrame.from_file(
             self.census_folder_loc + self.census_shapefile) 
     print 'Census data loaded'
     # It turns out the earth isn't flat 
     # Getting area in km**2 
     print 'Calculating area'
     area_sq_degrees = self.df_census['geometry'] 
     area_sq_km = [] 
     for region in area_sq_degrees: 
         geom_area = ops.transform(
                 partial(
                     pyproj.transform,
                     # projection GSCNAD83
                     # southern WA EPSG:2286
                     pyproj.Proj(init='EPSG:4326'), 
                     pyproj.Proj(
                         proj='aea', 
                         lat1=region.bounds[1], 
                         lat2=region.bounds[3]
                         )
                     ), 
                 region) 
         area = geom_area.area / 1000000.0  #convert m2 to km2
         area_sq_km.append( area )
     self.df_census['area'] = area_sq_km
     self.df_census['density'] = \
             self.df_census['POP10'] / self.df_census['area']
     print 'Area calculated'
示例#56
0
    def from_file(cls, filename, **kwargs):
        """Alternate constructor to create a ``GeoSeries`` from a file.

        Can load a ``GeoSeries`` from a file from any format recognized by
        `fiona`. See http://fiona.readthedocs.io/en/latest/manual.html for details.

        Parameters
        ----------
        filename : str
            File path or file handle to read from. Depending on which kwargs
            are included, the content of filename may vary. See
            http://fiona.readthedocs.io/en/latest/README.html#usage for usage details.
        kwargs : key-word arguments
            These arguments are passed to fiona.open, and can be used to
            access multi-layer data, data stored within archives (zip files),
            etc.
        """

        from geopandas import GeoDataFrame
        df = GeoDataFrame.from_file(filename, **kwargs)

        return GeoSeries(df.geometry, crs=df.crs)
示例#57
0
def addNeighborhoods(data, utm10n):
    hoods = GeoDataFrame.from_file(os.getcwd()+'/diysco2-db/_main_/yvr-open-data-neighborhoods/csg_neighborhood_areas.shp'); print hoods.crs
    hoods.crs = utm10n
    output = data.copy()
    output.iscopy = False
    print len(output)
    output = sjoin(output, hoods, how="left")
    output['temp'] = [str(i.bounds) for i in output.geometry]
    print output['temp'].head()
    output = output.drop_duplicates('temp', keep="last")
    print len(output)

    # output.index = [i for i in range(len(otu))]
    for i in range(len(output)):
        if output['NAME'].iloc[i] is None:
            output['NAME'].iloc[i] = "Stanley Park"

        if output["MAPID"].iloc[i] is None:
            output['MAPID'].iloc[i] = "SP1"

    # output = output[pd.isnull(output.co2_avg_e]
    print len(output)
    return output
示例#58
0
def calcgeostats(gridjoin, experiment, gridsize):

    # read in merged gridded geodata 
    # join_inner_df = GeoDataFrame.from_file('/Users/Jozo/Dropbox/_Projects/_GitHub/MobileCO2/Projects/05_GroupTraverse_01/data/filtered_geojson_wgs84/output/gridjoin_250m.shp')
    # join_inner_df = GeoDataFrame.from_file(iofolder+'diysco2-grid/'+ 'gridjoin_'+str(gridsize)+'m'+'.shp')
    join_inner_df = gridjoin
    # read in grid
    # path2grid = "/Users/Jozo/Dropbox/_Projects/_GitHub/MobileCO2/Projects/05_GroupTraverse_01/data/grid/grid_250m_transect.shp"
    # path2grid = iofolder+'diysco2-grid/'+"grid_"+str(gridsize)+'m'+"_transect.shp"
    path2grid = os.getcwd() + '/diysco2-db/campaigns/'+experiment+'/diysco2-grid/'+'grid_'+str(gridsize)+'m'+"_transect.shp"
    
    grid = GeoDataFrame.from_file(path2grid)
    # create grid id to groupby
    grid['id'] = [i for i in range(len(grid))]

    # run describestats function 
    co2_stats = describestats(join_inner_df, 'co2')
    temp_stats = describestats(join_inner_df, 'tempout')
    # Merge data together
    summarystats = pd.merge(co2_stats, temp_stats, left_index=True, right_index=True)

    # merge data to geogrid
    output = GeoDataFrame.merge(grid, summarystats, left_on="id", right_index=True)
    output = output.reset_index()
    # output = output.fillna(-9999)

    opath = os.getcwd() + '/diysco2-db/campaigns/'+experiment+'/diysco2-grid/'
    if(os.path.isdir(opath)):
        print "already a folder!"
    else:
        os.mkdir(opath)

    # output.to_file('/Users/Jozo/Dropbox/_Projects/_GitHub/MobileCO2/Projects/05_GroupTraverse_01/data/filtered_geojson_wgs84/output/gridstats_250m.shp')
    # output.to_file(opath+'/'+'gridstats_'+str(gridsize)+'m'+'.shp')
    output.to_file(os.getcwd() + '/diysco2-db/campaigns/'+experiment+'/diysco2-grid/'+'gridstats_'+str(gridsize)+'m'+".shp")
    # output.to_file(opath+'/'+'gridstats_'+str(gridsize)+'m'+'.geojson', driver="GeoJSON")
    return output
示例#59
0
 def setUp(self):
     # Data from http://www.nyc.gov/html/dcp/download/bytes/nybb_13a.zip
     # saved as geopandas/examples/nybb_13a.zip.
     self.df = GeoDataFrame.from_file(
         '/nybb_13a/nybb.shp', vfs='zip://examples/nybb_13a.zip')
示例#60
0
details.

First we'll import a dataset containing each borough in New York City. We'll
use the ``datasets`` module to handle this quickly.
"""
import numpy as np
import matplotlib.pyplot as plt
from shapely.geometry import Point
from geopandas import GeoSeries, GeoDataFrame
import geopandas as gpd

np.random.seed(1)
DPI = 100

path_nybb = gpd.datasets.get_path('nybb')
boros = GeoDataFrame.from_file(path_nybb)
boros = boros.set_index('BoroCode')
boros

##############################################################################
# Next, we'll plot the raw data
ax = boros.plot()
plt.xticks(rotation=90)
plt.savefig('nyc.png', dpi=DPI, bbox_inches='tight')

##############################################################################
# We can easily retrieve the convex hull of each shape. This corresponds to
# the outer edge of the shapes.
boros.geometry.convex_hull.plot()
plt.xticks(rotation=90)