aabpl 0.1.0__py3-none-any.whl

aabpl/__init__.py

@@ -0,0 +1,24 @@
+# from importlib.metadata import version
+# TODO replace * with more expliced exports for the final version of the package 
+# # from .radius_search import *
+# import utils
+# import testing
+# import illustrations
+# import radius_search
+from . import main
+# from .main import *
+# from .radius_search.optimal_grid_spacing import *
+# from .radius_search.offset_regions import *
+# from ..utils.general import *
+# from ..illustrations.illustrate_nested_grid import *
+# from ..illustrations.illustrate_optimal_grid_spacing import *
+# from ..illustrations.illustrate_point_to_cell_region_assignment import *
+# # from .nested_search import *
+# from .radius_search.radius_search_class import *
+# from ..illustrations.plot_utils import *
+# from .radius_search.two_dimensional_weak_ordering_class import *
+# from .main import *
+# from ..illustrations.plot_utils import *
+# TODO ensure to no exports imports (like np.array)?
+
+# __version__ = version('primelocations')

aabpl/doc/docstrings.py

@@ -0,0 +1,12 @@
+arguments_to_replace = list({
+'<y_coord_name>':(
+"""x (numpy.array):
+    Array of x/longtitude coordinates"""
+)
+    
+}.items())
+
+def fixdocstring(func):
+    # for k,v in arguments_to_replace:
+    #     func.__doc__ = func.__doc__.replace(k, v)
+    return func

aabpl/illustrations/__init__.py

@@ -0,0 +1,4 @@
+# from .plot_utils import *
+# from .illustrate_nested_grid import *
+# from .illustrate_optimal_grid_spacing import *
+# from .illustrate_point_to_cell_region_assignment import *

aabpl/illustrations/distribution_plot.py

@@ -0,0 +1,109 @@
+from pandas import DataFrame as _pd_DataFrame
+from numpy import (
+    array as _np_array,
+    linspace as _np_linspace,
+    searchsorted as _np_searchsorted
+)
+from matplotlib.pyplot import (subplots as _plt_subplots)
+
+def create_distribution_plot(
+        sums_df:_pd_DataFrame,
+        cluster_threshold_values:list,
+        k_th_percentiles:list,
+        radius=None,
+        plot_kwargs:dict={},
+):
+    """
+    TODO Descripiton
+    """
+    (n_random_points, ncols) = sums_df.shape
+    # specify default plot kwargs and add defaults
+    default_kwargs = {
+        's':0.8,
+        'color':'#eaa',
+
+        'figsize': (5*ncols,5),
+        'fig':None,
+        'axs':None,
+        
+        'hlines':{'color':'red', 'linewidth':1},
+        'vlines':{'color':'red', 'linewidth':1},
+    }
+    kwargs = {}
+    for k in plot_kwargs:
+        if k in [k for k,v in default_kwargs.items() if type(v)==dict]:
+            kwargs[k] = {**default_kwargs.pop(k), **plot_kwargs.pop(k)}
+    kwargs.update(default_kwargs)
+    kwargs.update(plot_kwargs)
+    figsize = kwargs.pop('figsize')
+    fig = kwargs.pop('fig')
+    axs = kwargs.pop('axs')
+
+    if fig is None or axs is None:
+        fig, axs = _plt_subplots(1,ncols, figsize=figsize)
+    
+    fig.suptitle(
+        "Values for indicator" + ("" if ncols==1 else "s") + 
+        ("" if radius is None else (" within "+ str(radius) +" distance")) +
+        " around " + str(n_random_points)+ " randomly points drawn within valid area."
+    )
+
+    xmin, xmax = 0, 100
+    xs = _np_linspace(xmin,xmax,n_random_points)
+    vals = sums_df.values
+    colnames = sums_df.columns
+
+    for (i, colname, cluster_threshold_value, k_th_percentile) in zip(
+        range(ncols), colnames, cluster_threshold_values, k_th_percentiles):
+        ys = vals[:,i]
+        ys.sort()
+        ymin, ymax = ys.min(),ys.max()
+        # round percentile value as far as necessary only 
+        # e.g. threshold value is 10.5328... and next smaller/larger in distribution are 10.51..., 10.6... 
+        # rounding to threshold value to firrst digit s.t. thath it lies between those value is sufficient (e.g. 10.53) 
+        idx = _np_searchsorted(ys, cluster_threshold_value)
+        next_smaller_val, next_larger_val = ys[max([0,idx-1])], ys[idx]
+        sufficient_digits = next((
+            i for i in range(100) if (
+                (
+                    (next_smaller_val == next_larger_val or cluster_threshold_values==next_smaller_val) and 
+                    round(next_smaller_val,i)==next_smaller_val
+                ) or (
+                    round(next_larger_val, i) != round(cluster_threshold_value, i) and 
+                    round(next_smaller_val, i) != round(cluster_threshold_value, i)
+                )
+        )),100)
+        
+        ax_title = (
+            "Threshold value for "+str(k_th_percentile)+"th-percentile is "+
+            str(round(cluster_threshold_value, sufficient_digits)) + " for "+ colname
+        )
+        
+        # SELECT AX (IF MULTIPLE)
+        ax = axs.flat[i] if ncols > 1 else axs
+        
+        # SET TITLE
+        ax.set_title(ax_title)
+
+        # SET TICKS
+        xtick_steps, ytick_steps = 5, 5
+        xticks = _np_array(sorted(
+           [x for x in _np_linspace(xmin,xmax,xtick_steps) if abs(x-k_th_percentile) > (xmax-xmin)/(xtick_steps*2)] + 
+           [k_th_percentile]
+        ))
+        ax.set_xticks(xticks, labels=xticks)
+        yticks = _np_array(sorted([y for y in _np_linspace(ymin,ymax,ytick_steps) if abs(cluster_threshold_value-y)>(ymax-ymin)/(ytick_steps*10)] + [cluster_threshold_value]))
+        ax.set_yticks(yticks, labels=[round(t, sufficient_digits) for t in yticks])
+
+        # ADD CUTOFF LINES
+        ax.hlines(y=cluster_threshold_value, xmin=xmin,xmax=xmax, **kwargs.pop('hlines'))
+        ax.vlines(x=k_th_percentile, ymin=ymin,ymax=ymax, **kwargs.pop('vlines'))
+        
+        # ADD DISTRIUBTION PLOT
+        ax.scatter(x=xs,y=ys, **plot_kwargs)
+        
+        # SET LIMITS
+        ax.set_xlim([xmin,xmax])
+        ax.set_ylim([ymin,ymax])
+    #
+#

aabpl/illustrations/illustrate_cell_pattern.py

@@ -0,0 +1,75 @@
+from numpy import (
+    array as _np_array, 
+    unique as _np_unique, 
+    linspace, invert, flip, transpose, 
+    concatenate, 
+    sign as _np_sign, 
+    zeros, min, max, equal, where, 
+    logical_or, logical_and, all, newaxis
+)
+from math import ceil as _math_ceil
+from pandas import DataFrame as _pd_DataFrame
+from matplotlib.pyplot import (subplots as _plt_subplots, figure as _plt_figure)
+from matplotlib.patches import Circle as _plt_circle, Rectangle as _plt_Rectangle
+from matplotlib.figure import Figure as _plt_Figure
+from matplotlib.axes._axes import Axes as _plt_Axes
+from .plot_utils import (
+    create_grid_cell_patches,  create_grid_cell_patches_by_type,  create_grid_cell_rectangles, 
+    create_trgl1_patch,  create_buffered_trgl1_patch,  create_buffered_square_patch, create_debuffered_square_patch, create_debuffered_trgl1_patch, dual_circle_union_patch,
+)
+from .illustrate_point_to_cell_region_assignment import (add_grid_cell_rectangles_by_color,add_circle_patches,)
+from ..utils.distances_to_cell import ( get_cells_relevant_for_disk_by_type, get_cell_farthest_vertex_to_point,  )
+from ..utils.general import ( flatten_list, )
+
+
+def plot_cell_pattern(
+    contained_cells, 
+    overlapped_cells, 
+    all_cells,
+    radius:float,
+    grid_spacing:float, 
+    add_idxs:bool=True,
+    **plot_kwargs,
+):
+
+    """
+    Illustrate method
+    """
+    # specify default plot kwargs and add defaults
+    plot_kwargs = {
+        'fig':None,
+        'ax':None,
+        's':0.8,
+        'color':'#eaa',
+        'figsize': (20,30),
+        **plot_kwargs
+    }
+    figsize = plot_kwargs.pop('figsize')
+    fig = plot_kwargs.pop('fig')
+    ax = plot_kwargs.pop('ax')
+    ###### initialize plot  ######################
+
+    if ax is None:
+        fig, ax = _plt_subplots(1,1, figsize=figsize)
+    ################################################################################################################
+    colors = ['#ccc', 'green', 'red']
+    for (row, col), color in flatten_list(
+        [[((row, col), color) for row, col in cells] for cells,color in zip(
+        [all_cells, contained_cells, overlapped_cells],
+        colors)]):
+        ax.add_patch(_plt_Rectangle(
+            xy = (col-0.5, row-0.5), 
+            width=1, height=1, 
+            linewidth=.7, facecolor=color, edgecolor=color, alpha=0.3
+        ))
+        if add_idxs and color == colors[0]:
+            ax.annotate(text=str(row)+","+str(col), xy=(col,row),horizontalalignment='center')
+
+    ratio = radius/grid_spacing
+    cell_steps_max = _math_ceil(ratio+1.5)
+
+    ax.set_xlim((-cell_steps_max,+cell_steps_max))
+    ax.set_ylim((-cell_steps_max,+cell_steps_max))
+    ax.set_aspect('equal', adjustable='box')
+    #
+#

aabpl/illustrations/illustrate_nested_grid.py

@@ -0,0 +1,90 @@
+from numpy import (
+    array,
+    unique as _np_unique,
+    ones as _np_ones,
+    linspace, invert, flip, transpose, concatenate, sign, zeros, min, max,
+    equal, where, logical_or, logical_and, all, newaxis
+)
+from matplotlib.pyplot import (get_cmap as _plt_get_cmap, subplots as _plt_subplots)
+from matplotlib.patches import Rectangle as _plt_Rectangle
+
+from .plot_utils import (
+    create_grid_cell_patches, 
+    create_grid_cell_patches_by_type, 
+    )
+
+
+def illustrate_nested_grid(
+            grid:dict,
+            pts_lat_lon,
+            cell_ids,
+            y_min:float=None,
+            y_max:float=None,
+            x_min:float=None,
+            x_max:float=None,
+):
+
+    """
+    Illustrate method
+    """
+    # unpack vals
+    grid_spacing = grid.spacing
+    nested_grid = grid['nested']
+
+    # filter pts to be inside bounds:
+    filter_mask = _np_ones(len(pts_lat_lon),dtype=bool) 
+    if y_min != None:
+        filter_mask = filter_mask * (pts_lat_lon[:,0]>=y_min)
+    if y_max != None:
+        filter_mask = filter_mask * (pts_lat_lon[:,0]<=y_max)
+    if x_min != None:
+        filter_mask = filter_mask * (pts_lat_lon[:,1]>=x_min)
+    if x_max != None:
+        filter_mask = filter_mask * (pts_lat_lon[:,1]<=x_max)
+    
+    pts_lat_lon = pts_lat_lon[filter_mask] 
+    cell_ids = cell_ids[filter_mask]
+    print('N Pts:',len(cell_ids), 'in', len(_np_unique(cell_ids)),'cells.')
+
+    def unpackNestedGrid(cell_dict:dict, nest_lvl:int=0):
+        """
+        TODO Check to move it outside as independent functions
+        """
+        res = []
+        if 'quadrants' in cell_dict:
+            for quadrant in cell_dict['quadrants']:
+                res += unpackNestedGrid(cell_dict=quadrant,nest_lvl=nest_lvl+1) 
+        res += [(nest_lvl, tuple([*tuple([*cell_dict['bounds']])]))]
+        return res
+    
+    flat_nested_grid = []
+    for cell_id in _np_unique(cell_ids):
+        flat_nested_grid += unpackNestedGrid(nested_grid[cell_id],nest_lvl=0)
+
+    flat_nested_grid = sorted(flat_nested_grid)
+    max_nest_level = flat_nested_grid[-1][0]
+    print('max_nest_level',max_nest_level)
+    cmp = _plt_get_cmap("YlOrBr",max_nest_level)
+    # print(flat_nested_grid)
+    nested_patches = [_plt_Rectangle(
+                # x         y           width           height
+                (x_min, y_min), x_max-x_min, y_max-y_min, 
+                linewidth=.7, facecolor=(cmp(nest_lvl) if max_nest_level>0 else 'grey'), edgecolor='#444', alpha=1
+                ) for nest_lvl, ((y_min, x_min), (y_max, x_max) ) in flat_nested_grid]
+    
+        
+    fig, ax = _plt_subplots(figsize=(15,10))
+
+    for patchToAdd in nested_patches:
+        ax.add_patch(patchToAdd)
+
+    ax.scatter(x=pts_lat_lon[:,1], y=pts_lat_lon[:,0], s=0.2,color='black')
+    x_steps = grid.x_steps
+    y_steps = grid.y_steps
+    ax.set_xticks(x_steps)
+    ax.set_yticks(y_steps)
+    ax.set_xlim(left=x_min, right=x_max)
+    ax.set_ylim(bottom=y_min, top=y_max)
+    ax.set_aspect('equal', adjustable='box')
+    ax.grid()
+#

aabpl/illustrations/illustrate_optimal_grid_spacing.py

@@ -0,0 +1,294 @@
+from numpy import (array, unique, linspace, invert, flip, transpose, concatenate, sign, zeros, 
+    min as _np_min, max as _np_max, equal, where, logical_or, logical_and, all, newaxis)
+from pandas import DataFrame as _pd_DataFrame
+from matplotlib import pyplot as plt
+from matplotlib.animation import (FuncAnimation as _plt_FuncAnimation, PillowWriter as _plt_PillowWriter)
+from matplotlib.figure import Figure as _plt_Figure
+from matplotlib.axes._axes import Axes as _plt_Axes
+# from math import ceil,asin,acos
+from .plot_utils import (
+    create_grid_cell_patches, 
+    create_grid_cell_patches_by_type, 
+    create_circle_patches
+)
+
+## Animation / GIF for varying grid spacings
+
+def set_animation_frames( 
+    relevantGridSizes:_pd_DataFrame,
+    allGridSizes:_pd_DataFrame,
+    largest:float=400,
+    frames_between_relevant:int = 6
+    )->list:
+    """
+    Returns vector of gridsizes -> each grid_spacing will be an iteration frame
+    """
+    # define GIF steps
+    animation_frames = [largest]
+    allGridSizes_indexes = list(allGridSizes.index)
+
+    for gridsize_0,gridsize_1 in zip(relevantGridSizes.index[:-1], relevantGridSizes.index[1:]):
+        
+        pos_0, pos_1 = allGridSizes_indexes.index(gridsize_0), allGridSizes_indexes.index(gridsize_1)
+        
+        #
+        if (pos_1-pos_0) > frames_between_relevant:
+            # number of position that should moved along per allGridSizes_indexes frame 
+            stepsize_factor = (pos_1-pos_0)//frames_between_relevant
+            # move an aditional positon for the n<stepsize_adjust frames
+            stepsize_adjust = (pos_1-pos_0)%frames_between_relevant
+            
+            animation_frames += [
+                allGridSizes_indexes[pos_0+s*stepsize_factor+int(stepsize_adjust<s)] 
+                for s in range(frames_between_relevant)
+                ]
+        else:
+            #
+            animation_frames += allGridSizes_indexes[pos_0+1:pos_1+1]
+            
+    print('Animate GIF with '+str(len(animation_frames))+' frames.')
+
+    return animation_frames
+
+
+def add_coverage_plot(
+        fig:_plt_Figure,
+        allGridSizes:_pd_DataFrame,
+        ymax:float=3,
+        yticks:list=[.5,1]
+    ) -> _plt_Axes:
+    """
+    adds new axis to fig and create a stackplot on it that shows:
+     - percent of area within grid cells that are completly within
+     - stacked percent of area within grid cells that are potetially intersected
+     - 
+    Returns: axes 
+    """
+    ax_coverage = fig.add_axes([0.6, 0.63, 0.3, 0.25])
+        
+    ax_coverage.stackplot(
+        allGridSizes['grid_spacing'],allGridSizes['share_contain']*100,allGridSizes['share_overlap']*100,
+        colors=['green', 'red']
+        )
+    ax_coverage.plot(allGridSizes['grid_spacing'], allGridSizes['share_overlap']*100, color='#000')
+    min_x, max_x = min(allGridSizes['grid_spacing']),max(allGridSizes['grid_spacing'])
+    ax_coverage.set_xlim(min_x,max_x)
+    ax_coverage.set_ylim(0,100*ymax)
+    
+    ax_coverage.set_yticks([100*x for x in sorted(yticks+[round(ymax)])])
+    
+    # add hline at 100%
+    ax_coverage.hlines(y=100,xmin=min_x,xmax=max_x,linewidth=2,color='#000')
+    
+    return ax_coverage
+#
+
+def add_cell_counter_plot(
+        fig:_plt_Figure,
+        allGridSizes:_pd_DataFrame,
+        ymax:float=3,
+        yticks:list=[.5,1]
+    ) -> _plt_Axes:
+    """
+    adds new axis to fig and create a step plot on that counts number of cells:
+    - which are fully contained s.t. the sum of emplyoment will be requested
+    - which (might be) intersected s.t. all points within will need to be checked whether they are within radius  
+    Returns: axes 
+    """
+    ax_counter = fig.add_axes([0.6, 0.43, 0.3, 0.25])
+        
+    ax_counter.plot(
+        allGridSizes['grid_spacing'], allGridSizes['contain_count'], color='green'
+        )
+    ax_counter.plot(
+        allGridSizes['grid_spacing'], allGridSizes['overlap_count'], color='red'
+        )
+    ax_counter.plot(allGridSizes['grid_spacing'], allGridSizes['overlap_count'], color='#000')
+    minx, maxx = min(allGridSizes['grid_spacing']),max(allGridSizes['grid_spacing'])
+    ax_counter.set_xlim(minx,maxx)
+    ax_counter.set_ylim(0,max(allGridSizes['contain_count']+allGridSizes['overlap_count']))
+    
+    ax_counter.set_yticks(yticks)
+    
+    return ax_counter
+#
+
+def update_fig_title(fig, grid_spacing:float,it:dict):
+    """
+    updates fig.suptitle with rounded grid_spacing of current frame
+    """
+    # display grid_spacing as title
+    gridsize_rnd = round(grid_spacing,2) 
+    fig.suptitle(
+        (' ' if gridsize_rnd >= 100 else '') +
+        str(gridsize_rnd)[:5+int(gridsize_rnd >= 100)] +
+        '0'*max(0,len(str(gridsize_rnd))-int(gridsize_rnd >= 100)-3) +
+        '. Frame: '+str(it)
+    )
+#
+
+def update_main_axis_frame(
+        allGridSizes:_pd_DataFrame, 
+        grid_spacing:float, 
+        ax_main,
+        ax_min:float=0, 
+        ax_max:float=1,
+        radius:float=750,
+    ) -> list:
+    # clear previous picture
+    ax_main.clear()
+    
+    listOfPatches = []
+    # create patches for grid cell: green=overlapped, red= (potentially) intersected, grey=outside 
+    listOfPatches += create_grid_cell_patches( 
+        grid_spacing=grid_spacing, 
+        ax_min=ax_min, 
+        ax_max=ax_max,
+        contain_cells_row_col=allGridSizes.loc[grid_spacing, 'contain_ids'],
+        overlap_cells_row_col=allGridSizes.loc[grid_spacing, 'overlap_ids'],
+        )
+    
+    # create patches for circle around bottom left and top right corner of center grid cell
+    listOfPatches += create_circle_patches(
+        grid_spacing=grid_spacing,
+        radius=radius
+    )
+
+    for patchToAdd in listOfPatches:
+        ax_main.add_patch(patchToAdd)
+
+    points = [p[0] for p in [
+        ax_main.plot(0, 0, marker='x', color='black'),
+    ]]
+
+    # set tickmarks and limits
+    ax_main.set_yticks([radius-grid_spacing/2, radius, radius+grid_spacing/2]) 
+    ax_main.set_xticks([radius-grid_spacing/2, radius, radius+grid_spacing/2]) 
+    ax_main.set_xlim(ax_min,ax_max)
+    ax_main.set_ylim(ax_min,ax_max)
+    ax_main.set_aspect('equal', adjustable='box')
+
+    return *listOfPatches, *points, #, point1,
+#
+
+def update_coverage_axis_frame(
+    grid_spacing:float,
+    max_gridsize:float,
+    min_gridsize:float,
+    ax_coverage,
+    vline,
+    ) -> tuple:
+    """
+    
+    """
+    # update vline
+    if vline != None:
+            vline.remove()
+    vline = ax_coverage.vlines(x=grid_spacing, ymin=0, ymax=3)
+    ax_coverage.set_xticks([round(x,0) for x in set([min_gridsize, grid_spacing, max_gridsize])])
+    return (vline,)
+#
+
+def create_optimal_grid_spacing_gif (
+        relevantGridSizes:_pd_DataFrame,
+        allGridSizes:_pd_DataFrame,
+        largest:float=400,
+        smallest:float=80,
+        radius:float=750,
+        frames_between_relevant:int = 6,
+        FuncAnimation_interval:int=500,
+        FuncAnimation_repeat:bool=True,
+        FuncAnimation_repeat_delay:int=1500,
+        FuncAnimation_cache_frame_data:bool=True,
+        dpi:int=50,
+        PillowWriterFps:int=10,
+        output_dir:str='./opt_grid_'
+        )->tuple:
+    
+    print('Create GIF')
+    # initialise plot and main axis
+    fig,ax_main = plt.subplots()
+
+    # define ax limits for main axis 
+    min_gridsize = min(relevantGridSizes['grid_spacing'])
+    max_gridsize = max(relevantGridSizes['grid_spacing'])
+    max_relevant_cells = max(relevantGridSizes['contain_count']+relevantGridSizes['overlap_count'])
+    ax_min=-max_gridsize/2
+    ax_max= max_gridsize*(max(relevantGridSizes['cell_steps_max'])-.5)    
+    
+    # add stackplot to top right corner
+    ax_coverage = add_coverage_plot(
+        fig=fig, allGridSizes=allGridSizes,
+        ymax=1.01*max(relevantGridSizes['share_contain']+relevantGridSizes['share_overlap']),
+        yticks=[.5,1])
+
+    # ax_counter = add_cell_counter_plot(
+    #     fig=fig, 
+    #     allGridSizes=allGridSizes,
+    #     ymax=max_relevant_cells,
+    #     yticks=[int(x*max_relevant_cells/4) for x in range(1,5)]
+    #     )
+    
+    # 
+    an_dct={
+        'it':0,
+        'vline':None
+        }
+
+    def animate(grid_spacing):
+        """
+        function to pass into FuncAnimation to create GIF. 
+        Will be supplied with list of gridsizes to iterate over.
+        """
+        an_dct['it']=an_dct['it']+1
+        
+        update_fig_title(fig=fig,grid_spacing=grid_spacing,it=an_dct['it'])
+        
+        # update main axis:
+        artistObjects = update_main_axis_frame(
+            allGridSizes=allGridSizes, 
+            grid_spacing=grid_spacing,
+            ax_main=ax_main, 
+            ax_min=ax_min, 
+            ax_max=ax_max,
+            radius=radius,
+        )
+        
+        #
+        an_dct['vline'], = update_coverage_axis_frame(
+            grid_spacing=grid_spacing,
+            max_gridsize=max_gridsize,
+            min_gridsize=min_gridsize,
+            ax_coverage=ax_coverage,
+            vline=an_dct['vline']
+            ) 
+
+        return artistObjects
+    #
+
+    animation_frames = set_animation_frames(
+        relevantGridSizes=relevantGridSizes,
+        allGridSizes=allGridSizes,
+        largest=largest,
+        frames_between_relevant=frames_between_relevant
+        )
+
+    ani = _plt_FuncAnimation(
+        fig, 
+        animate, 
+        interval=FuncAnimation_interval, 
+        blit=True, 
+        repeat=FuncAnimation_repeat, repeat_delay=FuncAnimation_repeat_delay, 
+        cache_frame_data=FuncAnimation_cache_frame_data,
+        frames=animation_frames
+        )    
+
+    print('Save GIF')
+    ani.save(
+        output_dir+str(largest)+"_"+str(smallest)+".gif", 
+        dpi=dpi, 
+        writer=_plt_PillowWriter(fps=PillowWriterFps)
+        )
+
+    return fig,ax_main,ax_coverage,#ax_counter,
+#