コード例 #1
0
 def test_choropleth(self, projection, hue_vars, legend_vars):
     kwargs = {'projection': projection}
     kwargs = {**kwargs, **hue_vars, **legend_vars}
     try:
         gplt.choropleth(gaussian_polys, **kwargs)
     finally:
         plt.close()
コード例 #2
0
def plot_score_DMP_correlation(monitor_data,
                               district_col='District',
                               cmap='jet'):

    corrs = []
    districts = []

    grouped = monitor_data[[district_col, 'score',
                            'delta DMP']].dropna().groupby(district_col)

    for name, group in grouped:
        corrs.append(group[['score', 'delta DMP']].corr().values[0, 1])
        districts.append(name)

    corr_data = pd.DataFrame()
    corr_data[district_col] = districts
    corr_data['Correlation'] = corrs

    corr_data = monitor_data[[district_col, 'geometry'
                              ]].drop_duplicates().merge(corr_data,
                                                         on=district_col)

    geoplot.choropleth(corr_data,
                       hue=corr_data['Correlation'],
                       cmap=cmap,
                       legend=True)
    plt.title(
        r'Correlation between the drought score and normalized $\Delta$DMP')

    return corr_data
コード例 #3
0
def plot_state_to_ax(state, ax):
    """Reusable plotting wrapper."""
    gplt.choropleth(tickets.set_index('id').loc[:, [state, 'geometry']],
                    hue=state,
                    projection=gcrs.AlbersEqualArea(), cmap='Blues',
                    linewidth=0.0, ax=ax)
    gplt.polyplot(boroughs, projection=gcrs.AlbersEqualArea(), edgecolor='black', linewidth=0.5, ax=ax)
コード例 #4
0
  def plotAll(self,figname):
    fig = plt.figure(figsize=(15, 15))
    ax1 = plt.gca()
    
    tot_people =self._blocks["density"]
    scheme = mapclassify.Quantiles(tot_people, k=5) 
 
    geoplot.choropleth(
    self._blocks, hue=tot_people, scheme=scheme,
    cmap='Oranges', figsize=(12, 8), ax=ax1
    )
    plt.savefig('density-'+figname)

    fig = plt.figure(figsize=(15, 15))
    ax1 = plt.gca()

    ctx.plot_map(self._loc, ax=ax1)
    _c = ["red", "blue"]
    for i, _r in enumerate(self._roads):
      _r.plot(ax=ax1, facecolor='none', edgecolor=_c[i])
    self._blocks.plot(ax=ax1,facecolor='none', edgecolor="black")  
    

    plt.tight_layout()

    # Plot agents
    self.grid._agdf.plot(ax=ax1)
    plt.savefig('agents-'+figname)
コード例 #5
0
def plot_state_to_ax(state, ax):
    gplt.choropleth(tickets.set_index('id').loc[:, [state, 'geometry']],
                    hue=state,
                    cmap='Blues',
                    linewidth=0.0,
                    ax=ax)
    gplt.polyplot(nyc_boroughs, edgecolor='black', linewidth=0.5, ax=ax)
コード例 #6
0
ファイル: kwarg_tests.py プロジェクト: redfrexx/geoplot
 def test_choropleth(self):
     try:
         gplt.choropleth(dataframe_gaussian_polys,
                         hue='hue_var',
                         projection=gcrs.PlateCarree(),
                         legend_kwargs={'fancybox': False})
     finally:
         plt.close()
コード例 #7
0
def update_choropleth(value):

    gdf = gpd.read_file(data_by_time)
    gdf_date = gdf[gdf['date'] == value]
    gplt.choropleth(gdf_date, hue='DMP_avg_normed')

    img = fig_to_uri(plt.gcf())
    return img
コード例 #8
0
def monitor_plot(monitor_data,
                 monitor_date,
                 date_col='date',
                 label_col=None,
                 cmap='jet'):

    month = monitor_date.month

    year = monitor_date.year

    select_date = date(year, month, 1).strftime("%Y-%m-%d")

    temp_1 = monitor_data[monitor_data[date_col] == select_date].copy()

    if (temp_1['score'].isna().sum() > 0) | (temp_1.empty):
        print('Data is not available.')
        return

    temp_2 = pd.DataFrame()

    if label_col is not None:
        temp_2 = temp_1.copy()
        temp_2['geometry'] = temp_2.centroid
        temp_2 = temp_2[temp_2[label_col]]

    norm = colors.Normalize(vmin=-0.6, vmax=0.6)

    if not temp_2.empty:
        temp_2.plot(marker='*',
                    color='white',
                    markersize=200,
                    edgecolor="black",
                    figsize=(6, 6))
        ax = plt.gca()
        geoplot.choropleth(temp_1,
                           hue=temp_1['score'],
                           cmap=cmap,
                           norm=norm,
                           legend=True,
                           ax=ax,
                           zorder=0)
    else:
        geoplot.choropleth(temp_1,
                           hue=temp_1['score'],
                           cmap=cmap,
                           norm=norm,
                           legend=True,
                           zorder=0,
                           figsize=(6, 6))

    plt.title(monitor_date.strftime("%B %Y"))

    return
コード例 #9
0
def plot_state_to_ax(state, ax):
    """Reusable plotting wrapper."""
    gplt.choropleth(tickets.set_index('id').loc[:, [state, 'geometry']],
                    hue=state,
                    projection=gcrs.AlbersEqualArea(),
                    cmap='Blues',
                    linewidth=0.0,
                    ax=ax)
    gplt.polyplot(boroughs,
                  projection=gcrs.AlbersEqualArea(),
                  edgecolor='black',
                  linewidth=0.5,
                  ax=ax)
コード例 #10
0
def plot_state_to_ax(state, ax):
    n = state_ticket_totals.loc[state]['Count']
    gplt.choropleth(tickets_by_precinct(state),
                    projection=gcrs.AlbersEqualArea(),
                    cmap='Blues',
                    linewidth=0.0,
                    ax=ax)
    gplt.polyplot(boroughs,
                  projection=gcrs.AlbersEqualArea(),
                  edgecolor='black',
                  linewidth=0.5,
                  ax=ax)
    ax.set_title("{0} (n={1})".format(state, n))
def plot_choropleth(gdf,
                    parameter,
                    title,
                    cmap,
                    outdir,
                    country_iso3,
                    filename,
                    norm=None,
                    use_scheme=False):
    fig, ax = plt.subplots()
    if use_scheme:
        try:
            scheme = mc.FisherJenks(gdf[parameter], k=5)
        except ValueError:
            logger.warning(f'Not enough values to plot {filename}')
            return 0
        # Make nice legend labels
        if gdf[parameter].max() < 10:
            format_bin = lambda bin: f'{np.round(bin, 1)}'
        else:
            precision = len(str(int(scheme.bins[0]))) - 2
            format_bin = lambda bin: f'{int(np.round(bin, -precision)):,}'
        legend_labels = [f'< {format_bin(scheme.bins[0])}'] + \
                        [f'{format_bin(scheme.bins[i] + 1)}–{format_bin(scheme.bins[i + 1])}'
                         for i in range(len(scheme.bins) - 2)] + \
                        [f'> {format_bin(scheme.bins[-2])}']
        legend_kwargs = ({'title': title})
    else:
        scheme = None
        legend_labels = None
        legend_kwargs = ({
            'orientation': 'horizontal',
            'label': title,
            'shrink': 0.5
        })
    if norm is not None:
        norm = mpl.colors.Normalize(vmin=norm[0], vmax=norm[1])
    gplt.choropleth(gdf,
                    ax=ax,
                    legend=True,
                    lw=0.5,
                    hue=parameter,
                    cmap=cmap,
                    legend_kwargs=legend_kwargs,
                    scheme=scheme,
                    legend_labels=legend_labels,
                    norm=norm)
    fig.savefig(os.path.join(outdir, f'{country_iso3}_{filename}.png'),
                dpi=150)
    plt.close(fig)
コード例 #12
0
ファイル: Plot_Map.py プロジェクト: dfreer15/AITutorials
def plot_vote(states, poll_avg):
    shapefile = 'cb_2018_us_state_5m/cb_2018_us_state_5m.shp'

    gdf = gpd.read_file(shapefile)[['NAME', 'geometry']]
    gdf.columns = ['name', 'geometry']

    poll_avg_df = pd.DataFrame({'name': states, 'poll_avg': poll_avg})

    data = gdf.merge(poll_avg_df, on='name', how='right')
    # data['poll_avg'].fillna(value=0)
    print(data)
    print(data['geometry'])

    scheme = mapclassify.Quantiles(data['poll_avg'], k=7)
    geoplot.choropleth(data, hue=data['poll_avg'], scheme=scheme, legend=True)
    plt.show()

    return
コード例 #13
0
ファイル: error_map.py プロジェクト: pgesek/ksgmet-etl
def run(map_dir_name, files):

    # europe = gpd.read_file('https://raw.githubusercontent.com/leakyMirror/map-of-europe/master/GeoJSON/europe.geojson')
    poland = gpd.read_file(
        'https://gist.githubusercontent.com/filipstachura/391ecb779d56483c070616a4d9239cc7/raw'
        '/b0793391ab0478e0d92052d204e7af493a7ecc92/poland_woj.json')

    for file in files:
        print('Generating maps for: ' + file)

        geo_file = 'maps/geo/data/error_analysis/{file}.geojson'\
            .format(
                dir_name=map_dir_name,
                file=file
            )
        data = gpd.read_file(geo_file)

        print('Geo file loaded')

        for field in FIELDS:

            print('Generating map for: ' + field)

            prop = 'error_percentage_' + field

            for row in data.values:
                for val in row:
                    if not isinstance(val, Polygon):
                        if math.isnan(val):
                            raise Exception('L:::')

            ax = geoplot.choropleth(data,
                                    hue=prop,
                                    cmap='YlOrRd',
                                    legend=True,
                                    edgecolor='lightgray',
                                    linewidth=0.0,
                                    scheme='fisher_jenks_sampled')

            ax2 = geoplot.polyplot(poland,
                                   figsize=(24, 16),
                                   ax=ax,
                                   edgecolor='black')

            plt.title('Pole: {field}, {title}'.format(
                field=field, title='Procent błędów > 2.0, pole: '))

            path = 'D:\\workspace\\MGR\\maps\\{dir_name}\\{file}'\
                .format(dir_name=map_dir_name, file=file)
            os.makedirs(name=path, exist_ok=True)

            fig = ax.get_figure()
            fig.savefig(path + '\\{field}.png'.format(field=field))

            plt.close(fig)

        print('Maps generated')
コード例 #14
0
def add_coa(option):
    #Get Bounds
    x0, x1 = ax.get_xlim()
    y0, y1 = ax.get_ylim()

    #Plot COA
    gplt.choropleth(coas,
                    ax=ax,
                    projection=geoplot.crs.WebMercator(),
                    hue=option,
                    zorder=1,
                    alpha=0.7,
                    scheme=mc.NaturalBreaks(coas[option], k=5),
                    cmap=option,
                    legend=False,
                    edgecolor='lightgray')
    #Set Extent
    ax.set_xlim(left=x0, right=x1)
    ax.set_ylim(bottom=y0, top=y1)
コード例 #15
0
def display_map3(gdf, clip, proj):
    # Setup the Voronoi axes; this creates the Voronoi regions
    ax = geoplot.voronoi(
        gdf,  # Define the GeoPandas DataFrame
        hue='total_crimes',  # df column used to color regions
        clip=clip,  # Define the voronoi clipping (map edge)
        projection=proj,  # Define the Projection
        legend=True,  # Create a legend
        edgecolor='white',  # Color of the voronoi boundaries
    )

    # Render the plot with a base map
    geoplot.choropleth(
        chicago,  # Base Map
        ax=ax,  # Axis attribute we created above
        extent=chicago.
        total_bounds,  # Set plotting boundaries to base map boundaries
        edgecolor='black',  # Color of base map's edges
        linewidth=1,  # Width of base map's edge lines
        zorder=1  # Plot base map edges above the voronoi regions
    )
コード例 #16
0
 def produce_plot(self):
     df = gpd.GeoDataFrame(self.average_vote())
     shapes = gpd.GeoDataFrame(self.redistricts)
     shapes.district += 1
     shapes = shapes.set_index("district")
     df["geometry"] = shapes.geometry
     
     xmin = df.bounds.minx.min()
     xmax = df.bounds.maxx.max()
     ymin = df.bounds.miny.min()
     ymax = df.bounds.maxy.max()
             
     norm = mplc.Normalize(vmin=0.4,vmax=1)
     
     fig = plt.figure()
     if any("democrat" == df.party):
         ax = plt.subplot(111)
         ax = geoplot.choropleth(df[df.party == "democrat"], hue = "votes", norm = norm, cmap = "Blues", legend = True, ax = ax)
     if any("republican" == df.party):
         ax = geoplot.choropleth(df[df.party == "republican"], hue = "votes", norm = norm, cmap = "Reds", legend = True, ax = ax)
     ax.set_xbound(lower = xmin, upper = xmax)
     ax.set_ybound(lower = ymin, upper = ymax)
コード例 #17
0
def plot_world_map(df):
    """ Plot a world map from a data frame """

    cases_per_million = df['total_cases_per_million']
    scheme = mapclassify.UserDefined(
        cases_per_million, bins=[100, 500, 1000, 5000, 10000, 15000, 20000])

    gplt.choropleth(
        df,
        hue=cases_per_million,
        edgecolor='white',
        linewidth=1,
        scheme=scheme,
        cmap='Reds',
        legend=True,
        figsize=(12, 6),
    )

    plt.title("Total Confirmed COVID-19 Cases Per Million as of 07-09-2020")

    # Without this, the world map doesnt load
    plt.show()
コード例 #18
0
ファイル: delta_map.py プロジェクト: pgesek/ksgmet-etl
def run(map_dir_name, files):

    # europe = gpd.read_file('https://raw.githubusercontent.com/leakyMirror/map-of-europe/master/GeoJSON/europe.geojson')
    poland = gpd.read_file('https://gist.githubusercontent.com/filipstachura/391ecb779d56483c070616a4d9239cc7/raw'
                           '/b0793391ab0478e0d92052d204e7af493a7ecc92/poland_woj.json')

    for file in files:
        print('Generating maps for: ' + file)

        geo_file = 'maps/geo/data/{dir_name}/{file}.geojson'\
            .format(
                dir_name=map_dir_name,
                file=file
            )
        data = gpd.read_file(geo_file)

        print('Geo file loaded')

        for field in FIELDS:
            for suffix in SUFFIXES:

                prop = field + suffix

                print('Generating map for: ' + prop)

                ax = geoplot.choropleth(data,
                                        hue=prop,
                                        cmap='YlOrRd',
                                        legend=True,
                                        edgecolor='lightgray',
                                        linewidth=0.0,
                                        scheme='fisher_jenks_sampled')

                ax2 = geoplot.polyplot(poland,
                                       figsize=(24, 16),
                                       ax=ax,
                                       edgecolor='black')

                plt.title('Pole: {field}, {title}'.format(field=field,
                                                          title=TITLES[suffix]))

                path = 'D:\\workspace\\MGR\\maps\\{dir_name}\\{file}'\
                    .format(dir_name=map_dir_name, file=file)
                os.makedirs(name=path, exist_ok=True)

                fig = ax.get_figure()
                fig.savefig(path + '\\{prop}_ad.png'.format(prop=prop))

                plt.close(fig)

        print('Maps generated')
コード例 #19
0
def monitor_plot_dmp(monitor_data, monitor_date, date_col='date', cmap='jet'):
    month = monitor_date.month

    year = monitor_date.year

    select_date = date(year, month, 1).strftime("%Y-%m-%d")

    temp = monitor_data[monitor_data[date_col] == select_date].copy()

    temp = temp[['geometry', 'score', 'delta DMP']].dropna()

    if (temp.empty):
        print('Data is not available.')
        return
    f, axs = plt.subplots(1, 2, figsize=(13, 6))

    norm1 = colors.Normalize(vmin=-0.6, vmax=0.6)
    geoplot.choropleth(temp,
                       hue=temp['score'],
                       cmap=cmap,
                       norm=norm1,
                       legend=True,
                       ax=axs[0])
    axs[0].title.set_text('score (' + monitor_date.strftime("%B %Y") + ')')

    norm2 = colors.Normalize(vmin=-0.6, vmax=0.6)
    geoplot.choropleth(temp,
                       hue=temp['delta DMP'],
                       cmap=cmap,
                       norm=norm2,
                       legend=True,
                       ax=axs[1])
    axs[1].title.set_text(r'normalized $\Delta$DMP (' +
                          monitor_date.strftime("%B %Y") + ')')

    return
コード例 #20
0
ファイル: choropleth.py プロジェクト: gondonlondon/Learning
def main():
    data_dir = "./data/au-cities.csv"
    world = gpd.read_file(gpd.datasets.get_path("naturalearth_lowres"))
    cities = gpd.read_file(gpd.datasets.get_path("naturalearth_cities"))

    print(world.head())
    ax = gp.polyplot(world, projection = gp.crs.Orthographic())
    ax.outline_patch.set_visible(True)

    #Graphs a choropleth of gdp / population
    gdp_per_person = world["gdp_md_est"] / world["pop_est"]
    scheme = mapclassify.Quantiles(gdp_per_person, k = 5)
    gp.choropleth(world, hue = gdp_per_person, scheme = scheme, 
    cmap = "Greens")
    print(world.head())

    #Graphs population size by establishing area size 
    #to the African continent
    africa = world[world.continent == "Africa"] 
    ax = gp.cartogram(africa, scale = "pop_est", limits = (0.2, 1), 
    edgecolor = "black")
    gp.polyplot(africa, edgecolor = "black", ax = ax)

    plt.show()
コード例 #21
0
ファイル: region_map.py プロジェクト: pgesek/ksgmet-etl
def run():
    rectangles = gpd.read_file('geo/data/rectangles.geojson')
    poland = gpd.read_file(
        'https://gist.githubusercontent.com/filipstachura/391ecb779d56483c070616a4d9239cc7/raw'
        '/b0793391ab0478e0d92052d204e7af493a7ecc92/poland_woj.json')

    for region in REGIONS:
        ax = geoplot.choropleth(rectangles,
                                hue=region,
                                cmap='Purples',
                                legend=False,
                                edgecolor='lightgray',
                                linewidth=0.0)

        ax2 = geoplot.polyplot(poland,
                               figsize=(24, 16),
                               ax=ax,
                               edgecolor='black')

        fig = ax.get_figure()
        fig.savefig('D:\\workspace\\MGR\\maps\\regions\\{region}.png'.format(
            region=region))

        plt.close(fig)
コード例 #22
0
    def test_choropleth(self):
        try:
            gplt.choropleth(series_gaussian_polys, hue=list_hue_values)
            gplt.choropleth(dataframe_gaussian_polys, hue=list_hue_values)

            gplt.choropleth(dataframe_gaussian_polys, hue=list_hue_values)
            gplt.choropleth(dataframe_gaussian_polys, hue=series_hue_values)
            gplt.choropleth(dataframe_gaussian_polys, hue=map_hue_values())
            gplt.choropleth(dataframe_gaussian_polys, hue='hue_var')
        finally:
            plt.close('all')
コード例 #23
0
ファイル: input_tests.py プロジェクト: ResidentMario/geoplot
    def test_choropleth(self):
        try:
            gplt.choropleth(series_gaussian_polys, hue=list_hue_values)
            gplt.choropleth(dataframe_gaussian_polys, hue=list_hue_values)

            gplt.choropleth(dataframe_gaussian_polys, hue=list_hue_values)
            gplt.choropleth(dataframe_gaussian_polys, hue=series_hue_values)
            gplt.choropleth(dataframe_gaussian_polys, hue=map_hue_values())
            gplt.choropleth(dataframe_gaussian_polys, hue='hue_var')
        finally:
            plt.close('all')
コード例 #24
0
            geo_country = geo_data[geo_data["name"].str.lower() ==
                                   country]  # Finds the corresponding geo data
            # Obtain all the countries that receive litter from it
            countries, tons, percs = getCountriesStats(stat)
            geo_from_countries = geo_data[geo_data["name"].str.lower().isin(
                countries)]  # Finds the corresponding geo data
            # gplt.polyplot(geo_country, figsize=(8, 4))
            # gplt.polyplot(geo_from_countries, figsize=(8, 4))
            # Note: this code sample requires gplt>=0.4.0.
            if len(tons) > 0 and len(geo_from_countries) == len(tons):
                scheme = mapclassify.Quantiles(tons, k=min(5, len(tons)))
                ax = gplt.polyplot(geo_data, figsize=(8, 4))
                # ax = gplt.webmap(geo_data, projection=gcrs.WebMercator())
                ax2 = gplt.choropleth(geo_from_countries,
                                      hue=tons,
                                      scheme=scheme,
                                      cmap='Greens',
                                      ax=ax)
                # gplt.choropleth(geo_country, hue=[1],  cmap='gray', ax=ax2)
                plt.title(country.capitalize())
                plt.show()
            else:
                print(F"------------- failed ------------")
                print(list(geo_from_countries["name"]))
                print(countries)

    exit()
    ##

    input_folder = config[GlobalModel.output_folder]
    input_file = config[GlobalModel.output_file]
コード例 #25
0
                "An exception has occured: there were not enough bins which contained buildings"
            )
            continue
        rays = rays.drop(raysWithBuildings.index.values.tolist())
        tree_list = list(rays['geometry']) + list(street['geometry'])
        strtree = STRtree(tree_list)
        pbf.accumulate_counts(strtree, street, 7)
        for k in street.index:
            grids[j].at[k, 'count'] = street.at[k, 'count']
        if i < 10:  # saves images of the plots of data for first 10 iterations
            ax = x.plot()
            scheme = mc.Quantiles(street['count'], k=20)
            gplt.choropleth(street,
                            ax=ax,
                            hue='count',
                            legend=True,
                            scheme=scheme,
                            cmap="jet",
                            legend_kwargs={'bbox_to_anchor': (1, 0.9)})
            plt.savefig('../datasets_and_generators/ANN_trainimages/x_' +
                        str(i) + '.png')
            plt.close()
    '''
    part 4: concatenates data to MASTER training data files 

    ATTENTION: when changing this file DO NOT immediately concatenate
    generated data to MASTER files, use a temporary json file by changing 
    the file name below until it is certain that the data is compatible 
    with the rest of the data set
    -compatibility involves: the data being the same shape (xpix & ypix),
    and that the format it is being saved in is consistent; refer to functions 
コード例 #26
0
                          how='inner',
                          on='HUC_8')
HUC8_Ecoregion = HUC8_Ecoregion.set_index('HUC_8', drop=True)

NARS_NLA_FINAL = pd.concat([NARS_NLA_group_aux, HUC8_Ecoregion],
                           ignore_index=False,
                           sort=False)

HUC8_NARS_NLA_FINAL = HUC8.merge(NARS_NLA_FINAL, on='HUC_8')

proj = gcrs.AlbersEqualArea()
norm = colors.LogNorm()
#cmap = matplotlib.cm.viridis
#cmap=matplotlib.cm.get_cmap()
cmap.set_under('grey')
gplt.choropleth(
    HUC8_NARS_NLA_FINAL,
    hue='PTL',
    projection=proj,
    norm=norm,
    cmap='viridis',
    k=5,
    scheme='quantiles',
    legend=True,
    legend_kwargs={'loc': 'lower right'},
    figsize=(12, 12),
    vmin=0.8
)  #, vmin=0.8, vmax=HUC8_NARS_NLA_FINAL['PTL'].max() , linewidth=0.5, edgecolor='black',)
plt.savefig('prueba6_1.pdf')
plt.savefig("obesity.png", bbox_inches='tight', pad_inches=0.1)
コード例 #27
0
q2 = gp.read_file('./Ookla shape data/2020q2')
q3 = gp.read_file('./Ookla shape data/2020q3')
q4 = gp.read_file('./Ookla shape data/2020q4')
ma = gp.read_file('./data/export-gisdata.mapc.ma_municipalities').to_crs(
    epsg=4326)

# In[57]:

data_2020 = pd.concat([q1, q2, q3, q4])

# In[59]:

ax = gplt.webmap(data_2020, projection=gcrs.WebMercator())
gplt.choropleth(data_2020,
                hue='avg_d_kbps',
                projection=gcrs.AlbersEqualArea(),
                cmap='Greens',
                legend=True,
                ax=ax)
plt.show()

# In[43]:

# use the location of the centroid of each polygon
data_2020['geometry'] = data_2020['geometry'].centroid

# In[56]:

ax = gplt.webmap(data_2020, projection=gcrs.WebMercator())
gplt.pointplot(data_2020, ax=ax, hue='avg_d_kbps', legend=True)
plt.show()
コード例 #28
0
HUC8['HUC_8'] = HUC8['HUC_8'].astype(int)
HUC8.to_csv('HUC8.csv', index=False)

HUC8_NARS_P = HUC8.merge(NARS_group_aux_filt_P, on='HUC_8')
HUC8_NARS_P.to_csv('HUC8_NARS_P.csv', index=False)
HUC8_NARS_N = HUC8.merge(NARS_group_aux_filt_N, on='HUC_8')
HUC8_NARS_N.to_csv('HUC8_NARS_N.csv', index=False)

proj = gcrs.AlbersEqualArea()
norm = colors.LogNorm()
gplt.choropleth(HUC8_NARS_P,
                hue='PTL',
                projection=proj,
                norm=norm,
                cmap='viridis',
                k=5,
                scheme='quantiles',
                legend=True,
                legend_kwargs={'loc': 'lower right'},
                figsize=(12, 12))
plt.savefig('NARS_TP.pdf')
plt.savefig("NARS_TP.png", bbox_inches='tight', pad_inches=0.1)

proj = gcrs.AlbersEqualArea()
norm = colors.LogNorm()
gplt.choropleth(HUC8_NARS_N,
                hue='NH4',
                projection=proj,
                norm=norm,
                cmap='viridis',
                k=5,
コード例 #29
0
###############################################################################
# Geoplot can re-project data into any of the map projections provided by
# CartoPy (see the list
# `here <http://scitools.org.uk/cartopy/docs/latest/crs/projections.html>`_).

import geoplot.crs as gcrs
ax = geoplot.polyplot(df, projection=gcrs.Orthographic(), figsize=(8, 4))
ax.set_global()
ax.outline_patch.set_visible(True)

###############################################################################
# ``polyplot`` is trivial and can only plot the geometries you pass to it. If
# you want to use color as a visual variable, specify a ``choropleth``. Here
# we sort GDP per person by country into five buckets by color.

geoplot.choropleth(df, hue='gdp_pp', cmap='Greens', figsize=(8, 4))

###############################################################################
# If you want to use size as a visual variable, you want a ``cartogram``. Here
# are population estimates for countries in Africa.

geoplot.cartogram(df[df['continent'] == 'Africa'],
                  scale='pop_est', limits=(0.2, 1), figsize=(7, 8))

###############################################################################
# If we have data in the shape of points in space, we may generate a
# three-dimensional heatmap on it using ``kdeplot``. This example also
# demonstrates how easy it is to stack plots on top of one another.

ax = geoplot.kdeplot(injurious_collisions.sample(1000),
                     shade=True, shade_lowest=False,
コード例 #30
0
ファイル: kwarg_tests.py プロジェクト: ResidentMario/geoplot
 def test_choropleth(self):
     try:
         gplt.choropleth(dataframe_gaussian_polys, hue='hue_var',
                         projection=gcrs.PlateCarree(), legend_kwargs={'fancybox': False})
     finally: plt.close()
コード例 #31
0
provinces_gdf = gpd.GeoDataFrame({
    'provinceid': pids,
    'provincename': pnames,
    'geometry': ppoly,
    'density': phdensity
})

hotels_gdf = gpd.GeoDataFrame({
    'hotelname': hnames,
    'geometry': hpoints,
})

gplt.choropleth(
    provinces_gdf,
    hue='density', cmap='Purples',
    projection=gplt.crs.AlbersEqualArea(),
    legend=True, legend_kwargs={'orientation': 'horizontal'}
)
plt.title("Hotel density by provinces in Armenia")
plt.savefig('hotels_density_by_provinces.png', bbox_inches='tight')

ax = gplt.kdeplot(
    hotels_gdf,
    clip=provinces_gdf.geometry,
    shade=True, shade_lowest=True,
    cmap='Reds', projection=gplt.crs.AlbersEqualArea()
)
gplt.polyplot(provinces_gdf, ax=ax, zorder=1)
plt.title("Hotels heatmap of Armenia")
plt.savefig('hotels_heatmap.png', bbox_inches='tight')
import geopandas
import geoplot
from plotnine import *

world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))

#-----------------------------Methods:plotnine-----------------------------------------------
base_plot=(ggplot()+
           geom_map(world, aes(fill='gdp_md_est'))+
         scale_fill_distiller(type='seq', palette='reds'))
print(base_plot)

#-----------------------------Methods:geoplot-----------------------------------------------
geoplot.choropleth(
    world, hue=world['gdp_md_est'],edgecolor='k',
    cmap='Reds',legend=True, figsize=(8, 4))

# Orthographic map projection
ax = geoplot.polyplot(
    world, projection=geoplot.crs.Orthographic(central_longitude=90.0, central_latitude=0.0),
    figsize=(8, 4))
geoplot.choropleth(
    world, hue=world['gdp_md_est'],
    cmap='Reds',legend=True,edgecolor='k',ax=ax)
ax.outline_patch.set_visible(True)

#-------------------------Method:basemap---------------------------------------------------
from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt
import numpy as np
コード例 #33
0
def plot_state_to_ax(state, ax):
    n = state_ticket_totals.loc[state]['Count']
    gplt.choropleth(tickets_by_precinct(state), projection=gcrs.AlbersEqualArea(), cmap='Blues',
                    linewidth=0.0, ax=ax)
    gplt.polyplot(boroughs, projection=gcrs.AlbersEqualArea(), edgecolor='black', linewidth=0.5, ax=ax)
    ax.set_title("{0} (n={1})".format(state, n))
コード例 #34
0
ファイル: main.py プロジェクト: driscoll42/GlobalDataLabMaps
gplt.polyplot(
    world,
    ax=ax,
    facecolor=missing_color,
    linewidth=0.05,
)

gplt.choropleth(
    countries_gdf,
    # projection=gcrs.Robinson(),
    ax=ax,
    hue=countries_gdf['shdi'],
    scheme=scheme,
    cmap=cmap_world,
    legend_kwargs={
        'loc': 'lower left',
        'fontsize': 10,
        'frameon': True,
        'edgecolor': background_color,
        'facecolor': background_color
    },
    linewidth=0.1,
    extent=(-180, -90, 180, 90),
    legend=True,
)

plt.tight_layout()

fig.show()
コード例 #35
0
                        subplot_kw={
                            'projection':
                            gcrs.AlbersEqualArea(central_latitude=40.7128,
                                                 central_longitude=-74.0059)
                        })

# Educated
f.suptitle('Comparison between Educated level and number of crimes',
           fontsize=16)
f.subplots_adjust(top=0.95)
gplt.choropleth(test_precincts,
                hue='Educated',
                projection=gcrs.AlbersEqualArea(central_latitude=40.7128,
                                                central_longitude=-74.0059),
                linewidth=0,
                figsize=(12, 12),
                scheme='Fisher_Jenks',
                cmap='Reds',
                legend=True,
                legend_kwargs={'loc': 'upper left'},
                ax=axarr[0])
gplt.choropleth(test_precincts,
                hue='count',
                projection=gcrs.AlbersEqualArea(central_latitude=40.7128,
                                                central_longitude=-74.0059),
                linewidth=0,
                figsize=(12, 12),
                scheme='Fisher_Jenks',
                cmap='Blues',
                legend=True,
                legend_kwargs={'loc': 'upper left'},
コード例 #36
0
# Load the data (uses the `quilt` package).
import geopandas as gpd
from quilt.data.ResidentMario import geoplot_data

census_tracts = gpd.read_file(geoplot_data.ny_census_partial())
percent_white = census_tracts['WHITE'] / census_tracts['POP2000']


# Plot the data.
import geoplot.crs as gcrs
import geoplot as gplt
import matplotlib.pyplot as plt

gplt.choropleth(census_tracts, hue=percent_white, projection=gcrs.AlbersEqualArea(),
                cmap='Purples', linewidth=0.5, edgecolor='white', k=None, legend=True)
plt.title("Percentage White Residents, 2000")
plt.savefig("ny-state-demographics.png", bbox_inches='tight', pad_inches=0.1)