a Dfw~@sddlmZddlZddlZddlmZddlZddlZ ddl Z ddl m Z ddlmZddlmZddlmZzddlmZWneyedZYn0z ddlZWneydZYn0zddlmZWneyedZYn0zddlmZWneyedZYn0Gdd d eZ ej!d d d Z"ej!d d d d Z#e$d de%dej&'DZ(GdddZ)GdddZ*ddZ+ddZ,ddZ-ddZ.ddZ/ddZ0d d!Z1dd"d#Z2dd%d&Z3dd)d*Z4d+d,Z5dd0d1Z6d2d3Z7d4d5Z8d6d7Z9e d8d9d:d;d<Z:d=d>Z;d?d@ZdEdFZ?ddGdHZ@e"dIdJZAe"dKdLZBe#dMdNZCe#dOdPZDe#dQdRZEe#dSdTZFe"dUdVZGe"dWdXZHe#dYdZZIe#d[d\ZJe"d]d^ZKe#d_d`ZLe#dadbZMe"dcddZNe#dedfZOe#dgdhZPe"didjZQe#dkdlZRe#dmdnZSe#dodpZTe"dqdrZUe"dsdtZVe"dudvZWe"dwdxZXe"dydzZYe"d{d|ZZe"d}d~Z[e"ddZ\dS)) annotationsN)getmro)memoize) DataArray) RaggedDtype) GeometryDtypec@seZdZdZdS)VisibleDeprecationWarningzVisible deprecation warning. By default, python will not show deprecation warnings, so this class can be used when a very visible warning is helpful, for example because the usage is most likely a user bug. N)__name__ __module__ __qualname____doc__r r ]/nfs/NAS7/SABIOD/METHODE/ermites/ermites_venv/lib/python3.9/site-packages/datashader/utils.pyr'srT)nopythonnogil)rrparallelcCsg|] }t|qSr )int).0xr r r 4rz([0-9]+)\.([0-9]+)\.([0-9]+)c@s0eZdZdZddZddZddZdd Zd S) ExprzBase class for expression-like objects. Implements hashing and equality checks. Subclasses should implement an ``inputs`` attribute/property, containing a tuple of everything that fully defines that expression. cCstt||fSN)hashtype_hashable_inputsselfr r r__hash__@sz Expr.__hash__cCs t|t|uo||kSr)rrrotherr r r__eq__Csz Expr.__eq__cCs ||k Srr rr r r__ne__Gsz Expr.__ne__cCs\g}|jD]H}t|ttfr,|t|q t|tjrH||q ||q t|S)zt Return a version of the inputs tuple that is suitable for hashing and equality comparisons ) inputs isinstancelistsetappendtuplenpZndarraytobytes)rresultipr r rrJs   zExpr._hashable_inputsN)r r r r rr!r"rr r r rr9s rc@s*eZdZdZddZd ddZddZdS) DispatcherzSimple single dispatch.cCs i|_dSr)_lookuprr r r__init__]szDispatcher.__init__NcsF|durfddSttr8D]}||q$n |j<|S)z6Register dispatch of `func` on arguments of type `typ`Ncs |Sr)register)frtypr rcrz%Dispatcher.register..)r$r(r0r.)rr3functr r2rr0`s  zDispatcher.registercOs~|j}t|}||vr0|||g|Ri|St|ddD]*}||vr@|||g|Ri|Sq@td|dS)NzNo dispatch for {0} type)r.rr TypeErrorformat)rheadrestkwargsZlkr3clsr r r__call__ks zDispatcher.__call__)N)r r r r r/r0r>r r r rr-[s r-cCs$tj|}t|tjo"|tjjvS)zCheck if a datashape is numeric and real. Example ------- >>> isrealfloat('int32') False >>> isrealfloat('float64') True >>> isrealfloat('string') False >>> isrealfloat('complex64') False ) datashape predicateslaunderr$UnittypesetsZfloatingdtr r r isrealfloatys rFcCs$tj|}t|tjo"|tjjvS)zCheck if a datashape is numeric and real. Example ------- >>> isreal('int32') True >>> isreal('float64') True >>> isreal('string') False >>> isreal('complex64') False )r?r@rAr$rBrCrealrDr r risreals rHcCsftt|j}|||d|||}t|}tj|dd}||@}t |d|j ddS)aWnansum where all-NaN values remain NaNs. Note: In NumPy <=1.9 NaN is returned for slices that are all NaN, while later versions return 0. This function emulates the older behavior, which allows using NaN as a missing value indicator. Parameters ---------- array: Array to sum over axis: Axis to sum over raxis) r%rangendimremoveinsertZ transposer)isnanallwheresum)arrayrJTZ missing_valsZ all_emptyZ set_to_zeror r rnansum_missings      rUc Csp|jdd\}}|jdd\}}||j}||j}|d|d|d}|d|d|d}||fS)zCalculate the resolution of xarray.DataArray raster and return it as the two-tuple (xres, yres). yres is positive if it is decreasing. Nrr7)shapedimsvalues) rasterhwZydimZxdimZxcoordsZycoordsZxresZyresr r rcalc_ress  r^c Cs.|ddkr|n|}|ddkr0|n|}tj}}tj }}t|dd|gd|d |ggdg} ddt|ft|dft|t|ffD]V\} } t| t| | dg\} } }| |kr| }| |kr| }| |kr| }| |kr| }q|dd|dd}}||||||||fS)aCalculate the bounding box of a raster, and return it in a four-element tuple: (xmin, ymin, xmax, ymax). This calculation assumes the raster is uniformly sampled (equivalent to a flat-earth assumption, for geographic data) so that an affine transform (using the "Augmented Matrix" approach) suffices: https://en.wikipedia.org/wiki/Affine_transformation#Augmented_matrix Parameters ---------- xs : numpy.array 1D NumPy array of floats representing the x-values of a raster. This likely originated from an xarray.DataArray or xarray.Dataset object (xr.open_rasterio). ys : numpy.array 1D NumPy array of floats representing the y-values of a raster. This likely originated from an xarray.DataArray or xarray.Dataset object (xr.open_rasterio). res : tuple Two-tuple (int, int) which includes x and y resolutions (aka "grid/cell sizes"), respectively. rr7)r_r_?)rrr`@)maxminr)infrSlendot)xsysresZxboundZyboundZxminZyminZxmaxZymaxZAbZx_Zy_ry_ZxpadZypadr r r calc_bboxs(  0rlc Cst|}t|d}||}}||}||||||}}t|||t|||} } | | krz| | fS| | fS)ai Transform continuous start and end coordinates into array indices. Parameters ---------- start : float coordinate of the lower bound. end : float coordinate of the upper bound. coords : numpy.ndarray coordinate values along the axis. res : tuple Resolution along an axis (aka "grid/cell sizes") ra)reabsrcrbr) startendcoordsrisizeZhalfZvminZvmaxspanZsidxZeidxr r r get_indicess "rscCs<|r|ddddddf}|r8|ddddddf}|S)N.rWr )rSxflipyflipr r r _flip_arrays rvcCs|durt|}|j}|dur*||d}t|dtjrFtddnd}t|dtjrftddnd}|d|k}|d|k}t|||}|S)a  Reorients the array to a canonical orientation depending on whether the x and y-resolution values are positive or negative. Parameters ---------- raster : DataArray xarray DataArray to be reoriented res : tuple Two-tuple (int, int) which includes x and y resolutions (aka "grid/cell sizes"), respectively. layer : int Index of the raster layer to be reoriented (optional) Returns ------- array : numpy.ndarray Reoriented 2d NumPy ndarray Nr7rns)r^datar$r)Z timedelta64rv)r[riZlayerrSZr0zeroZr1zerortrur r r orient_arrays      rymeancs|jdd\}}|d||td||tftfddtD}|dkrrtj|ddS|dkrtj|ddS|d krtj|ddS|d krtj|ddS|d krtj |ddS|d krtj |ddS|d krtj |ddSt ddS)z3Create downsampled aggregate factor in pixels unitsNcs&g|]fddtDqS)cs$g|]}|ddfqSrr )ri)crarrfactorjr rr5sz3downsample_aggregate...)rK)rr}r~)rrr5sz(downsample_aggregate..rzrrIrRrbrcZmedianZstdvarzNInvalid 'how' downsample method. Options mean, sum, max, min, median, std, var) rXrr)Z concatenaterKZnanmeanZnansumnanmaxnanminZ nanmedianZnanstdZnanvar ValueError) aggregater~howrhrgconcatr rrdownsample_aggregate1s(, rlinearcCst|j}t|j}|dkr4|j|jdk}|dkrXt|||dddf}n2tjdt||tj ||j d|dddf}t |||fS)zHelper function similar to np.linspace which return values from aggregate min value to aggregate max value in either linear or log space. rrN)basenumdtype) r)rrZrrxrcZlinspaceZlogspacelog1perr)rrrZmax_valZmin_valvalsr r rsummarize_aggregate_valuesLs     rcsgfdd}|S)z& simple arg caching decorator cs,rd|kr$||fdd<dS)Nrr7r )argsr1lastr rrkhszhold.._r )r1rkr rrholdbsr.png.cCsXddlm}tj|s"t||r0|||}|tj||||rT|SdS)zPGiven a datashader Image object, saves it to a disk file in the requested formatr)set_backgroundN) Zdatashader.transfer_functionsrospathexistsmkdirZto_pilsavejoin)imgfilenamefmtZ_returnZ export_pathZ backgroundrr r r export_imageos    rcCsvt|ttfrt|}t|ttfr0t|}tjd}||d}ttd|tjd|tj}||fS)a Projects the given (longitude, latitude) values into Web Mercator coordinates (meters East of Greenwich and meters North of the Equator). Longitude and latitude can be provided as scalars, Pandas columns, or Numpy arrays, and will be returned in the same form. Lists or tuples will be converted to Numpy arrays. Examples: easting, northing = lnglat_to_meters(-74,40.71) easting, northing = lnglat_to_meters(np.array([-74]),np.array([40.71])) df=pandas.DataFrame(dict(longitude=np.array([-74]),latitude=np.array([40.71]))) df.loc[:, 'longitude'], df.loc[:, 'latitude'] = lnglat_to_meters(df.longitude,df.latitude) iRagf@Zgv@)r$r%r(r)rSpilogtan)Z longitudeZlatitudeZ origin_shiftZeastingZnorthingr r rlnglat_to_meters~s    (rcCstt|jttjjs.)rer?Recordcolumnsrr rrdshape_from_pandassrcCst|dS)Nr)r(Z __dask_keys__)rr<r r rr4rr4)keycsFfddjD}j|ddtjtfddjDfS)z;Return a datashape.DataShape object given a dask dataframe.csPg|]H}t|jttjjs6t|jtjjjrt|j dds|qS)ZknownT) r$rrrrrrrrr)rrrr rrs z$dshape_from_dask..F)indexcs"g|]}|t|dfqS)r)rZ get_partitionrrr rrs)rZ categorizer?rr)rZ cat_columnsr rrdshape_from_dasks rcs.tjtfddtjtjDS)z;Return a datashape.DataShape object given a xarray Dataset.csg|]}|t|fqSr rrZxr_dsr rrsz.dshape_from_xarray_dataset..)r?rrr%Z data_varsrprr rrdshape_from_xarray_datasetsrcCst|jdd}tj|d<||dd<t||jd}t|jd|jddf}tj|dddf<||ddddf<t||dS)aU Converts a set of multiple sequences (eg: time series), stored as a 2 dimensional numpy array into a pandas dataframe that can be plotted by datashader. The pandas dataframe eventually contains two columns ('x' and 'y') with the data. Each time series is separated by a row of NaNs. Discussion at: https://github.com/bokeh/datashader/issues/286#issuecomment-334619499 x_values: 1D numpy array with the values to be plotted on the x axis (eg: time) y_values: 2D numpy array with the sequences to be plotted of shape (num sequences X length of each sequence) rr7rWN)rrj)r)zerosrXnanZtiler DataFrameflatten)Zx_valuesZy_valuesrrjr r r!dataframe_from_multiple_sequencess  rc Csgd}|j|jd|ftjddf}|\}}}t||||dkrZgd}|jdd|f}|jdks|tj}tj|j|dd}|t |j dd|j d}t j ||j d} t|j dk} | s|j d } |jddd fd | | <| S) zkHelper for ``datashader.utils.mesh()``. Both arguments are assumed to be Pandas DataFrame objects. )rr7r{rNr{)rr{r7int64rI)r)rZrr)rZcrossitemrZtakeZreshapeprodrXrrrrerepeat) vertices simplicesZwindingZ first_triabcZ vertex_idxsrriZverts_have_weightsZ weight_colr r r_pd_meshs $   " rcCsPt||}t|j|j}ttt|d|d}tj ||d}|S)ziHelper for ``datashader.utils.mesh()``. Both arguments are assumed to be Dask DataFrame objects. r) chunksize) rrrbZ npartitionsrr)ceilrerZ from_pandas)rrriZapprox_npartitionsrr r r_dd_meshs rcCs|jjddksJd|jjdddd}|sBJdt|jdksh|jjddkshJd t|t j rt|t j rt ||St ||S) zMerge vertices and simplices into a triangular mesh, suitable to be passed into the ``Canvas.trimesh()`` method via the ``mesh`` keyword-argument. Both arguments are assumed to be Dask DataFrame objects. r7rzFAt least three vertex columns are required for the triangle definitionNcSst|tjSr)r)Z issubdtypeintegerrDr r rr4<rzmesh..z^Simplices must be integral. You may consider casting simplices to integers with ".astype(int)"r{zMIf no vertex weight column is provided, a triangle weight column is required.) rZrXrZilocmaprPrerr$rrrr)rrZsimplices_all_intsr r rmesh1s   rcCs|r||i|S||SdSrr )r5rr<r r rapplyLsrcCs|dkp|dk S)zQ Equivalent to isnan for floats, but also numba compatible with integers rr valr r risnullSsrcCs|dkS)zO Check for -1 which is equivalent to NaN for some integer aggregations rWr rr r risminus1[srcCsL|}|}tt|D](}t||rt||s||||<qdS)zPFirst of 2 arrays but taking nans into account. Return the first array. Nravelnbprangererretr r|r r rnanfirst_in_placecs rcCs@|}|}tt|D]}t||s||||<qdS)zOLast of 2 arrays but taking nans into account. Return the first array. Nrrr r rnanlast_in_placeos  rcCsv|}|}tt|D]R}t||rHt||sp||||<qt||s||||kr||||<qdS)zMax of 2 arrays but taking nans into account. Could use np.nanmax but would need to replace zeros with nans where both arrays are nans. Return the first array. Nrrr r rnanmax_in_place{s  rcCsv|}|}tt|D]R}t||rHt||sp||||<qt||s||||kr||||<qdS)zMin of 2 arrays but taking nans into account. Could use np.nanmin but would need to replace zeros with nans where both arrays are nans. Accepts 3D (ny, nx, ncat) and 2D (ny, nx) arrays. Return the first array. Nrrr r rnanmin_in_places  rcCs>t|}t|d|dD]}||d||<q|||<|dS)a(Insert a value into a 1D array at a particular index, but before doing that shift the previous values along one to make room. For use in ``FloatingNReduction`` classes such as ``max_n`` and ``first_n`` which store ``n`` values per pixel. Parameters ---------- target : 1d numpy array Target pixel array. value : float Value to insert into target pixel array. index : int Index to insert at. Returns ------- Index beyond insertion, i.e. where the first shifted value now sits. r7rW)rerK)targetvaluernr|r r rshift_and_inserts rcCsXt|}d}|D]B}t|r"qTqt||D]$}t||r,|||<|d}qq,qdS)afSingle pixel implementation of nanfirst_n_in_place. ret_pixel and other_pixel are both 1D arrays of the same length. Walk along other_pixel a value at a time, find insertion index in ret_pixel and shift values along to insert. Next other_pixel value is inserted at a higher index, so this walks the two pixel arrays just once each. rr7N)rerrKZ ret_pixelZ other_pixelristartZ other_valuer|r r r_nanfirst_n_impls  rc Cs\|j\}}}}t|D]>}t|D]0}t|D]"}t||||f||||fq0q$qdSzN3d version of nanfirst_n_in_place_4d, taking arrays of shape (ny, nx, n). NrXrrrKr rr nynxZncat_nrjrrr r rnanfirst_n_in_place_4ds   rcCsH|j\}}}t|D],}t|D]}t|||f|||fq"qdSrrrr rrrrjrr r rnanfirst_n_in_place_3ds  rcCsHt|}d}|D]2}t|r"qDqt||D]}t|||}qq,qdS)aeSingle pixel implementation of nanlast_n_in_place. ret_pixel and other_pixel are both 1D arrays of the same length. Walk along other_pixel a value at a time, find insertion index in ret_pixel and shift values along to insert. Next other_pixel value is inserted at a higher index, so this walks the two pixel arrays just once each. rNrerrKrrr r r_nanlast_n_impls  r c Cs\|j\}}}}t|D]>}t|D]0}t|D]"}t||||f||||fq0q$qdSrrXrrrKr rr r rnanlast_n_in_place_4ds   r cCsH|j\}}}t|D],}t|D]}t|||f|||fq"qdS)zM3d version of nanlast_n_in_place_4d, taking arrays of shape (ny, nx, n). Nr rr r rnanlast_n_in_place_3ds  r cCs`t|}d}|D]J}t|r"q\qt||D],}t||sH|||kr,t|||}qq,qdS)adSingle pixel implementation of nanmax_n_in_place. ret_pixel and other_pixel are both 1D arrays of the same length. Walk along other_pixel a value at a time, find insertion index in ret_pixel and shift values along to insert. Next other_pixel value is inserted at a higher index, so this walks the two pixel arrays just once each. rNrrr r r_nanmax_n_impls  r c Cs\|j\}}}}t|D]>}t|D]0}t|D]"}t||||f||||fq0q$qdS)aCombine two max-n arrays, taking nans into account. Max-n arrays are 4D with shape (ny, nx, ncat, n) where ny and nx are the number of pixels, ncat the number of categories (will be 1 if not using a categorical reduction) and the last axis containing n values in descending order. If there are fewer than n values it is padded with nans. Return the first array. NrXrrrKr rr r rnanmax_n_in_place_4d's   rcCsH|j\}}}t|D],}t|D]}t|||f|||fq"qdS)zL3d version of nanmax_n_in_place_4d, taking arrays of shape (ny, nx, n). Nrrr r rnanmax_n_in_place_3d7s  rcCs`t|}d}|D]J}t|r"q\qt||D],}t||sH|||kr,t|||}qq,qdS)adSingle pixel implementation of nanmin_n_in_place. ret_pixel and other_pixel are both 1D arrays of the same length. Walk along other_pixel a value at a time, find insertion index in ret_pixel and shift values along to insert. Next other_pixel value is inserted at a higher index, so this walks the two pixel arrays just once each. rNrrr r r_nanmin_n_implAs  rc Cs\|j\}}}}t|D]>}t|D]0}t|D]"}t||||f||||fq0q$qdS)aCombine two min-n arrays, taking nans into account. Min-n arrays are 4D with shape (ny, nx, ncat, n) where ny and nx are the number of pixels, ncat the number of categories (will be 1 if not using a categorical reduction) and the last axis containing n values in ascending order. If there are fewer than n values it is padded with nans. Return the first array. NrXrrrKrrr r rnanmin_n_in_place_4dWs   rcCsH|j\}}}t|D],}t|D]}t|||f|||fq"qdS)zL3d version of nanmin_n_in_place_4d, taking arrays of shape (ny, nx, n). Nrrr r rnanmin_n_in_place_3dgs  rcCsn|}|}tt|D]J}t||rHt||sh||||<qt||s||||7<qdS)zSum of 2 arrays but taking nans into account. Could use np.nansum but would need to replace zeros with nans where both arrays are nans. Return the first array. Nrrr r rnansum_in_placeqs   rcCsZ|}|}tt|D]8}||dkr||dksH||||kr||||<qdS)zMaximum of 2 arrays of row indexes. Row indexes are integers from 0 upwards, missing data is -1. Return the first array. rWNrrKrerr r rrow_max_in_places (rcCsZ|}|}tt|D]8}||dkr||dksH||||kr||||<qdS)zMinimum of 2 arrays of row indexes. Row indexes are integers from 0 upwards, missing data is -1. Return the first array. rWNrrr r rrow_min_in_places (rcCs`t|}d}|D]J}|dkr"q\qt||D],}||dksH|||kr,t|||}qq,qdS)aeSingle pixel implementation of row_max_n_in_place. ret_pixel and other_pixel are both 1D arrays of the same length. Walk along other_pixel a value at a time, find insertion index in ret_pixel and shift values along to insert. Next other_pixel value is inserted at a higher index, so this walks the two pixel arrays just once each. rrWNrerKrrr r r_row_max_n_impls  rc CsZ|j\}}}}t|D]>}t|D]0}t|D]"}t||||f||||fq.q"qdS)zCombine two row_max_n signed integer arrays. Equivalent to nanmax_n_in_place with -1 replacing NaN for missing data. Return the first array. NrXrKrrr r rrow_max_n_in_place_4ds    rcCsF|j\}}}t|D],}t|D]}t|||f|||fq qdSrrrr r rrow_max_n_in_place_3ds   rcCs`t|}d}|D]J}|dkr"q\qt||D],}||dksH|||kr,t|||}qq,qdS)aeSingle pixel implementation of row_min_n_in_place. ret_pixel and other_pixel are both 1D arrays of the same length. Walk along other_pixel a value at a time, find insertion index in ret_pixel and shift values along to insert. Next other_pixel value is inserted at a higher index, so this walks the two pixel arrays just once each. rrWNrrr r r_row_min_n_impls  rc CsZ|j\}}}}t|D]>}t|D]0}t|D]"}t||||f||||fq.q"qdS)zCombine two row_min_n signed integer arrays. Equivalent to nanmin_n_in_place with -1 replacing NaN for missing data. Return the first array. NrXrKrrr r rrow_min_n_in_place_4ds    r cCsF|j\}}}t|D],}t|D]}t|||f|||fq qdSrrrr r rrow_min_n_in_place_3ds   r!)NN)rz)rr)rTrr)N)] __future__rrreinspectrZnumbarnumpyr)ZpandasrZtoolzrZxarrayrZdask.dataframeZ dataframerZdatashader.datashaper?Zdatashader.datatypesr ImportErrorrr ExceptionZgeopandas.arrayrrZspatialpandas.geometry UserWarningrZjitZngjitZngjit_parallelr(match __version__groupsZ numba_versionrr-rFrHrUr^rlrsrvryrrrrrrrrrrrrrrrrrrrrrrrrr r r r rrrrrrrrrrrrr r!r r r rs             " , !   +