|LeddlmZddlmZddlmZddlZddlZddl Z ddl m Z ddlmZddlmZmZddlmZmZmZmZmZmZddlmZmZmZdd lmZdd lm Z m!Z!dd l"m#Z$ ddl%Z%n #e&$rdZ%YnwxYw ddl'Z'n #e&$rdZ'YnwxYw ddl(Z(n #e&$rdZ(YnwxYwGd d Z)Gdde)Z*Gdde)Z+e*e+dZ,dZ-GddZ.dddZ/dZ0dZ1dZ2ee/_3dS)) annotations)Number)log10N) DataArrayDataset) Dispatcherngjitcalc_res calc_bbox orient_arraydshape_from_xarray_dataset) get_indicesdshape_from_pandasdshape_from_dask)Expr) resample_2dresample_2d_distributed) reductionsc0eZdZdZdZdZdZdZdZdS)AxisauInterface for implementing axis transformations. Instances hold implementations of transformations to and from axis space. The default implementation is equivalent to: >>> def forward_transform(data_x): ... scale * mapper(data_x) + t >>> def inverse_transform(axis_x): ... inverse_mapper((axis_x - t)/s) Where ``mapper`` and ``inverse_mapper`` are elementwise functions mapping to and from axis-space respectively, and ``scale`` and ``transform`` are parameters describing a linear scale and translate transformation, computed by the ``compute_scale_and_translate`` method. cVt|j|\}}|||z z }| |z}||fS)aCompute the scale and translate parameters for a linear transformation ``output = s * input + t``, mapping from data space to axis space. Parameters ---------- range : tuple A tuple representing the range ``[min, max]`` along the axis, in data space. Both min and max are inclusive. n : int The number of bins along the axis. Returns ------- s, t : floats )mapmapper)selfrangenstartendsts /lib/python3.11/site-packages/datashader/core.pycompute_scale_and_translatez Axis.compute_scale_and_translate4s: e,, s sU{O FQJ!t cptj|dz}|\}}|||z |z S)a)Compute a 1D array representing the axis index. Parameters ---------- st : tuple A tuple of ``(scale, translate)`` parameters. n : int The number of bins along the dimension. Returns ------- index : ndarray g?)nparangeinverse_mapper)rstrpxr r!s r" compute_indexzAxis.compute_indexIs;Yq\\# 1""BFA:...r$ct)z'A mapping from data space to axis spaceNotImplementedErrorvals r"rz Axis.mapper[!!r$ct)z'A mapping from axis space to data spacer-r/s r"r(zAxis.inverse_mapper_r1r$cdS)zNGiven a range (low,high), raise an error if the range is invalid for this axisNrrs r"validatez Axis.validatecs r$N) __name__ __module__ __qualname____doc__r#r+rr(r6r4r$r"rr#si *///$""""""     r$rc^eZdZdZeedZeedZdS) LinearAxisz A linear Axisc|SNr4r/s r"rzLinearAxis.mapperj  r$c|Sr>r4r/s r"r(zLinearAxis.inverse_mapperor?r$N)r7r8r9r: staticmethodr rr(r4r$r"r<r<hsb  U\  U\r$r<cdeZdZdZeedZeedZdZdS)LogAxiszA base-10 logarithmic Axisc:tt|Sr>)rfloatr/s r"rzLogAxis.mapperwsU3ZZ   r$cd}||zS)N r4)r0ys r"r(zLogAxis.inverse_mapper|s #v r$c\|dS|ddks |ddkrtddS)Nrrz,Range values must be >0 for logarithmic axes ValueErrorr5s r"r6zLogAxis.validates; = F 8q==E!HMMKLL L*Mr$N) r7r8r9r:rAr rr(r6r4r$r"rCrCusv$$ !! U\!  U\MMMMMr$rC)linearlogc ||||Q||Otd|t|t|t|dSdS)Nz {glyph} coordinates may be specified by providing both the x and y arguments, or by providing the geometry argument. Received: x: {x} y: {y} geometry: {geometry} glyphxrHgeometry)rKformatreprrOs r"validate_xy_or_geometryrUsmai19  amq}  F$q''T!WWtH~~FFF HH H ! }}r$ceZdZdZ ddZddZ dd Zdd Zdd Zdd Z ddZ dde j dddddfdZ dZdZdZdZdS)CanvasaAn abstract canvas representing the space in which to bin. Parameters ---------- plot_width, plot_height : int, optional Width and height of the output aggregate in pixels. x_range, y_range : tuple, optional A tuple representing the bounds inclusive space ``[min, max]`` along the axis. x_axis_type, y_axis_type : str, optional The type of the axis. Valid options are ``'linear'`` [default], and ``'log'``. XNrLc||_||_|dnt||_|dnt||_t ||_t ||_dSr>) plot_width plot_heighttuplex_rangey_range _axis_lookupx_axisy_axis)rrZr[r]r^ x_axis_type y_axis_types r"__init__zCanvas.__init__sY%&&ttE'NN &ttE'NN ";/ ";/ r$cddlm}m}ddlm}t d|||| |}| |||} nt rht|t jj rI|j |j nd} |j |j nd} |j t| t| f}||} nt r&t|t jr ||} n[||x} | }ddlm} | |} n0t%d t)| t+||| |S) aCompute a reduction by pixel, mapping data to pixels as points. Parameters ---------- source : pandas.DataFrame, dask.DataFrame, or xarray.DataArray/Dataset The input datasource. x, y : str Column names for the x and y coordinates of each point. If provided, the geometry argument may not also be provided. agg : Reduction, optional Reduction to compute. Default is ``count()``. geometry: str Column name of a PointsArray of the coordinates of each point. If provided, the x and y arguments may not also be provided. r)PointMultiPointGeometry)countrfNNNr)MultiPointGeoPandassource must be an instance of spatialpandas.GeoDataFrame, spatialpandas.dask.DaskGeoDataFrame, geopandas.GeoDataFrame, or dask_geopandas.GeoDataFrame. Received objects of type {typ}typ)glyphsrfrgrrhrU spatialpandas isinstancedaskDaskGeoDataFramer]r^ cx_partitionsslice GeoDataFrame_source_from_geopandasdatashader.glyphs.pointsrjrKrStypebypixel)rsourcerQrHaggrRrfrg count_rdnrPr]r^geopandas_sourcerjs r"pointsz Canvas.pointss 65555555222222Ax888 ;)++C  E!QKKEE +FM4F4W!X!X +*.,*B$,, *.,*B$,, -eWoug.NO**844 +:fm6P#Q#Q +**844&*&A&A&&I&II"V)HHHHHH++H55 RRXRX LLSYS*S*+++ vtUC000r$rFc  ddlm} m} m} m} m} m}m}m}td||||tj }|d}|r|dkrtd|rd}|trit|tjjrJ|j|jnd}|j|jnd}|jt)|t)|f}||}n tr't|tjr ||}n||x}|}dd lm}||}ntd t5| t|t6rt|t8rt|t8r||}||}|jdkrtd |j|jd krtd|j||jvrtdt?|j j}|!|}||||}n||}}tE||\}}|dkrt|tFt8fr*t|tFt8fr| ||}nKt|t>tHfrDt|t>tHfr(| tI|tI|}ntdtK|tK||dkrt|t>tHfrDt|t>tHfr(| tI|tI|}nFt|tLj'r6t|t>tHfr| |tI|}nt|t>tHfr4t|tLj'r| tI||}nt|tFt8fr)t|tFt8fr |||}natdtK|tK|td||dkrXtPrt|tPj)s!tTr0t|tTj)rtWj,dd}|-||j.r|}t|tj/r|j0}t|tj tj1tj2tj3tj4tj5tj6tj7tj8tj9tj:tj;tj<tj=tj>fstt5|dt|||||j.S)aRCompute a reduction by pixel, mapping data to pixels as one or more lines. For aggregates that take in extra fields, the interpolated bins will receive the fields from the previous point. In pseudocode: >>> for i in range(len(rows) - 1): # doctest: +SKIP ... row0 = rows[i] ... row1 = rows[i + 1] ... for xi, yi in interpolate(row0.x, row0.y, row1.x, row1.y): ... add_to_aggregate(xi, yi, row0) Parameters ---------- source : pandas.DataFrame, dask.DataFrame, or xarray.DataArray/Dataset The input datasource. x, y : str or number or list or tuple or np.ndarray Specification of the x and y coordinates of each vertex * str or number: Column labels in source * list or tuple: List or tuple of column labels in source * np.ndarray: When axis=1, a literal array of the coordinates to be used for every row agg : Reduction, optional Reduction to compute. Default is ``any()``. axis : 0 or 1, default 0 Axis in source to draw lines along * 0: Draw lines using data from the specified columns across all rows in source * 1: Draw one line per row in source using data from the specified columns geometry : str Column name of a LinesArray of the coordinates of each line. If provided, the x and y arguments may not also be provided. line_width : number, optional Width of the line to draw, in pixels. If zero, the default, lines are drawn using a simple algorithm with a blocky single-pixel width based on whether the line passes through each pixel or does not. If greater than one, lines are drawn with the specified width using a slower and more complex antialiasing algorithm with fractional values along each edge, so that lines have a more uniform visual appearance across all angles. Line widths between 0 and 1 effectively use a line_width of 1 pixel but with a proportionate reduction in the strength of each pixel, approximating the visual appearance of a subpixel line width. antialias : bool, optional This option is kept for backward compatibility only. ``True`` is equivalent to ``line_width=1`` and ``False`` (the default) to ``line_width=0``. Do not specify both ``antialias`` and ``line_width`` in the same call as a ``ValueError`` will be raised if they disagree. Examples -------- Define a canvas and a pandas DataFrame with 6 rows >>> import pandas as pd # doctest: +SKIP ... import numpy as np ... import datashader as ds ... from datashader import Canvas ... import datashader.transfer_functions as tf ... cvs = Canvas() ... df = pd.DataFrame({ ... 'A1': [1, 1.5, 2, 2.5, 3, 4], ... 'A2': [1.5, 2, 3, 3.2, 4, 5], ... 'B1': [10, 12, 11, 14, 13, 15], ... 'B2': [11, 9, 10, 7, 8, 12], ... }, dtype='float64') Aggregate one line across all rows, with coordinates df.A1 by df.B1 >>> agg = cvs.line(df, x='A1', y='B1', axis=0) # doctest: +SKIP ... tf.spread(tf.shade(agg)) Aggregate two lines across all rows. The first with coordinates df.A1 by df.B1 and the second with coordinates df.A2 by df.B2 >>> agg = cvs.line(df, x=['A1', 'A2'], y=['B1', 'B2'], axis=0) # doctest: +SKIP ... tf.spread(tf.shade(agg)) Aggregate two lines across all rows where the lines share the same x coordinates. The first line will have coordinates df.A1 by df.B1 and the second will have coordinates df.A1 by df.B2 >>> agg = cvs.line(df, x='A1', y=['B1', 'B2'], axis=0) # doctest: +SKIP ... tf.spread(tf.shade(agg)) Aggregate 6 length-2 lines, one per row, where the ith line has coordinates [df.A1[i], df.A2[i]] by [df.B1[i], df.B2[i]] >>> agg = cvs.line(df, x=['A1', 'A2'], y=['B1', 'B2'], axis=1) # doctest: +SKIP ... tf.spread(tf.shade(agg)) Aggregate 6 length-4 lines, one per row, where the x coordinates of every line are [0, 1, 2, 3] and the y coordinates of the ith line are [df.A1[i], df.A2[i], df.B1[i], df.B2[i]]. >>> agg = cvs.line(df, # doctest: +SKIP ... x=np.arange(4), ... y=['A1', 'A2', 'B1', 'B2'], ... axis=1) ... tf.spread(tf.shade(agg)) Aggregate RaggedArrays of variable length lines, one per row (requires pandas >= 0.24.0) >>> df_ragged = pd.DataFrame({ # doctest: +SKIP ... 'A1': pd.array([ ... [1, 1.5], [2, 2.5, 3], [1.5, 2, 3, 4], [3.2, 4, 5]], ... dtype='Ragged[float32]'), ... 'B1': pd.array([ ... [10, 12], [11, 14, 13], [10, 7, 9, 10], [7, 8, 12]], ... dtype='Ragged[float32]'), ... 'group': pd.Categorical([0, 1, 2, 1]) ... }) ... ... agg = cvs.line(df_ragged, x='A1', y='B1', axis=1) ... tf.spread(tf.shade(agg)) Aggregate RaggedArrays of variable length lines by group column, one per row (requires pandas >= 0.24.0) >>> agg = cvs.line(df_ragged, x='A1', y='B1', # doctest: +SKIP ... agg=ds.count_cat('group'), axis=1) ... tf.spread(tf.shade(agg)) r) LineAxis0 LinesAxis1LinesAxis1XConstantLinesAxis1YConstantLineAxis0MultiLinesAxis1RaggedLineAxis1GeometryLinesXarrayCommonXLineNrzgDo not specify values for both the line_width and antialias keyword arguments; use line_width instead.g?ri)LineAxis1GeoPandasrkrlz"x array must have 1 dimension not z#y array must have 2 dimensions not z/x must be one of the coordinate dimensions of yz Invalid combination of x and y arguments to Canvas.line when axis=0. Received: x: {x} y: {y} See docstring for more information on valid usagerQrHz Invalid combination of x and y arguments to Canvas.line when axis=1. Received: x: {x} y: {y} See docstring for more information on valid usagezE The axis argument to Canvas.line must be 0 or 1 Received: {axis}axiszYAntialiased lines are not supported for CUDA-backed sources, so reverting to line_width=0z0 reduction not implemented for antialiased lines antialias)ArnrrrrrrrrrUrdanyrKrorprqrrr]r^rsrtrurvdatashader.glyphs.linerrSrxrstrndimdimslistcoordsindex _broadcast_column_specificationsrr\rTr&ndarraycudf DataFrame dask_cudfwarningswarnset_line_width antialiasedby reductionrhmaxminsumsummary _sum_zero_first_or_lastmeanmax_nmin_n_first_n_or_last_n_max_or_min_row_index_max_n_or_min_n_row_indexwherer.ry)rrzrQrHr{rrR line_widthrrrrrrrrrr]r^rPr}rx_arry_arr y_coord_dims x_dim_indexorig_xorig_y non_cat_aggs r"linez Canvas.linesr V V V V V V V V V V V V V V V V V V V V 1h777 ;&((C  J  HqGHH H  J   +FM4F4W!X!X +*.,*B$,, *.,*B$,, -eWoug.NO))(33 +:fm6P#Q#Q +))(33&*&A&A&&I&II"V)EEEEEE**844 RRXRX LLSYS*S*+++  ( (< +Z3-?-?< +JqRUDVDV< +1IE1IEzQ !Rej!R!RSSSzQ !Suz!S!STTT "" !RSSS 122L&,,Q//K&&q![99EEFF3Aq99DAqqyyq63-00 9"1vsm44 9%IaOOEE T5M22 9"1tUm44 9*N588U1XX>>EE$&5 6>> import pandas as pd # doctest: +SKIP ... import numpy as np ... import datashader as ds ... from datashader import Canvas ... import datashader.transfer_functions as tf ... cvs = Canvas() ... df = pd.DataFrame({ ... 'A1': [1, 1.5, 2, 2.5, 3, 4], ... 'A2': [1.6, 2.1, 2.9, 3.2, 4.2, 5], ... 'B1': [10, 12, 11, 14, 13, 15], ... 'B2': [11, 9, 10, 7, 8, 12], ... }, dtype='float64') Aggregate one area region across all rows, that starts with coordinates df.A1 by df.B1 and is filled to the y=0 line >>> agg = cvs.area(df, x='A1', y='B1', # doctest: +SKIP ... agg=ds.count(), axis=0) ... tf.shade(agg) Aggregate one area region across all rows, that starts with coordinates df.A1 by df.B1 and is filled to the line with coordinates df.A1 by df.B2 >>> agg = cvs.area(df, x='A1', y='B1', y_stack='B2', # doctest: +SKIP ... agg=ds.count(), axis=0) ... tf.shade(agg) Aggregate two area regions across all rows. The first starting with coordinates df.A1 by df.B1 and the second with coordinates df.A2 by df.B2. Both regions are filled to the y=0 line >>> agg = cvs.area(df, x=['A1', 'A2'], y=['B1', 'B2'], # doctest: +SKIP agg=ds.count(), axis=0) ... tf.shade(agg) Aggregate two area regions across all rows where the regions share the same x coordinates. The first region will start with coordinates df.A1 by df.B1 and the second will start with coordinates df.A1 by df.B2. Both regions are filled to the y=0 line >>> agg = cvs.area(df, x='A1', y=['B1', 'B2'], agg=ds.count(), axis=0) # doctest: +SKIP ... tf.shade(agg) Aggregate 6 length-2 area regions, one per row, where the ith region starts with coordinates [df.A1[i], df.A2[i]] by [df.B1[i], df.B2[i]] and is filled to the y=0 line >>> agg = cvs.area(df, x=['A1', 'A2'], y=['B1', 'B2'], # doctest: +SKIP agg=ds.count(), axis=1) ... tf.shade(agg) Aggregate 6 length-4 area regions, one per row, where the starting x coordinates of every region are [0, 1, 2, 3] and the starting y coordinates of the ith region are [df.A1[i], df.A2[i], df.B1[i], df.B2[i]]. All regions are filled to the y=0 line >>> agg = cvs.area(df, # doctest: +SKIP ... x=np.arange(4), ... y=['A1', 'A2', 'B1', 'B2'], ... agg=ds.count(), ... axis=1) ... tf.shade(agg) Aggregate RaggedArrays of variable length area regions, one per row. The starting coordinates of the ith region are df_ragged.A1 by df_ragged.B1 and the regions are filled to the y=0 line. (requires pandas >= 0.24.0) >>> df_ragged = pd.DataFrame({ # doctest: +SKIP ... 'A1': pd.array([ ... [1, 1.5], [2, 2.5, 3], [1.5, 2, 3, 4], [3.2, 4, 5]], ... dtype='Ragged[float32]'), ... 'B1': pd.array([ ... [10, 12], [11, 14, 13], [10, 7, 9, 10], [7, 8, 12]], ... dtype='Ragged[float32]'), ... 'B2': pd.array([ ... [6, 10], [9, 10, 18], [9, 5, 6, 8], [4, 5, 11]], ... dtype='Ragged[float32]'), ... 'group': pd.Categorical([0, 1, 2, 1]) ... }) ... ... agg = cvs.area(df_ragged, x='A1', y='B1', agg=ds.count(), axis=1) ... tf.shade(agg) Instead of filling regions to the y=0 line, fill to the line with coordinates df_ragged.A1 by df_ragged.B2 >>> agg = cvs.area(df_ragged, x='A1', y='B1', y_stack='B2', # doctest: +SKIP ... agg=ds.count(), axis=1) ... tf.shade(agg) (requires pandas >= 0.24.0) r) AreaToZeroAxis0AreaToLineAxis0AreaToZeroAxis0MultiAreaToLineAxis0MultiAreaToZeroAxis1AreaToLineAxis1AreaToZeroAxis1XConstantAreaToLineAxis1XConstantAreaToZeroAxis1YConstantAreaToLineAxis1YConstantAreaToZeroAxis1RaggedAreaToLineAxis1RaggedrNrz Invalid combination of x and y arguments to Canvas.area when axis=0. Received: x: {x} y: {y} See docstring for more information on valid usagerz Invalid combination of x, y, and y_stack arguments to Canvas.area when axis=0. Received: x: {x} y: {y} y_stack: {y_stack} See docstring for more information on valid usage)rQrHy_stackz Invalid combination of x and y arguments to Canvas.area when axis=1. Received: x: {x} y: {y} See docstring for more information on valid usagez Invalid combination of x, y, and y_stack arguments to Canvas.area when axis=1. Received: x: {x} y: {y} y_stack: {y_stack} See docstring for more information on valid usagezE The axis argument to Canvas.area must be 0 or 1 Received: {axis}r)rnrrrrrrrrrrrrrrrrprrrr\rKrSrTr&rry)rrzrQrHr{rrrrrrrrrrrrrrany_rdnrr orig_y_stackrPs r"areaz Canvas.areasBv                             /..... ;'))C()!W 8AwGG 1g 199q63-00 /"1vsm44 /+OAq11EE T5M22 / T5M22 /00q588DDEE$&5 6>> import datashader as ds # doctest: +SKIP ... import datashader.transfer_functions as tf ... from spatialpandas.geometry import PolygonArray ... from spatialpandas import GeoDataFrame ... import pandas as pd ... ... polygons = PolygonArray([ ... # First Element ... [[0, 0, 1, 0, 2, 2, -1, 4, 0, 0], # Filled quadrilateral (CCW order) ... [0.5, 1, 1, 2, 1.5, 1.5, 0.5, 1], # Triangular hole (CW order) ... [0, 2, 0, 2.5, 0.5, 2.5, 0.5, 2, 0, 2], # Rectangular hole (CW order) ... [2.5, 3, 3.5, 3, 3.5, 4, 2.5, 3], # Filled triangle ... ], ... ... # Second Element ... [[3, 0, 3, 2, 4, 2, 4, 0, 3, 0], # Filled rectangle (CCW order) ... # Rectangular hole (CW order) ... [3.25, 0.25, 3.75, 0.25, 3.75, 1.75, 3.25, 1.75, 3.25, 0.25], ... ] ... ]) ... ... df = GeoDataFrame({'polygons': polygons, 'v': range(len(polygons))}) ... ... cvs = ds.Canvas() ... agg = cvs.polygons(df, geometry='polygons', agg=ds.sum('v')) ... tf.shade(agg) r PolygonGeomrNri)GeopandasPolygonGeomzsource must be an instance of spatialpandas.GeoDataFrame, spatialpandas.dask.DaskGeoDataFrame, geopandas.GeoDataFrame or dask_geopandas.GeoDataFrame, not )rnrrrrorprqrrr]r^rsrtrurvglyphs.polygonrrKrxry) rrzrRr{rrr]r^rPr}rs r"polygonszCanvas.polygonssa\ ('''''......  DZ 0B0STT D&*l&>dllLG&*l&>dllLG)%/5'?*JKFK))EE  Dz&-2LMM DK))EE"&"="=f"E"EE R%F < < < < < <((22EEC48LLCCDD D ;'))CvtUC000r$c dddlm}m}m}ddlm}t |tr5||jt|j d} n|j} || g}n@t |tr|j } | }ntd| || }|||| j\}}n|r|std||||} } | jdks | jdkr0| j| jkr td| jd | jd | -|j&|j| krtd |j d |d | jdkrr|jt$du} |jt$du} t)j| t)j| d| dt/| }t)j| t)j| d| dt/| }| r| r|r|r|||| }||||| |j|j|j|j\}}|r(|r&t;j| }t?||||S|s|st?||||S|||| }t?||||S|||| }t?||||S| jdkr|||| }t?||||Std t| j)aSamples a recti- or curvi-linear quadmesh by canvas size and bounds. Parameters ---------- source : xarray.DataArray or Dataset The input datasource. x, y : str Column names for the x and y coordinates of each point. agg : Reduction, optional Reduction to compute. Default is ``mean()``. Note that agg is ignored when upsampling. Returns ------- data : xarray.DataArray r)QuadMeshRasterQuadMeshRectilinearQuadMeshCurvilinearrNrzInvalid input typezDEither specify both x and y coordinatesor allow them to be inferred.z_Ensure that x- and y-coordinate arrays share the same dimensions. x-coordinates are indexed by z) dims while y-coordinates are indexed by z dims.DataArray name # does not match supplied reduction .rLrzcx- and y-coordinate arrays must have 1 or 2 dimensions. Received arrays with dimensions: {dims})r)!rnrrrrrrprcolumnr data_varsrname to_datasetrKrrr`r_rar&allcloselinspacelen is_upsampler]r^rZr[r _upsampleryrS)rrzrQrHr{rrrmean_rndryarrxarr xaxis_linear yaxis_linear even_yspacing even_xspacingrPupsample_widthupsample_heights r"quadmeshzCanvas.quadmeshs" UTTTTTTTTT 100000 fg & & 3{cj0F,--a0zTF^FF  * * 3;D&&((FF122 2 ;(4..C 9$<$DAqq >! >=>> >AYq d IMMTY]] TY0F0F*#iii 455 5  J*J$&&*$kkk333011 1 9>>;,x*@@L;,x*@@LKbk$q'48SYY??MKbk$q'48SYY??M 9  9 9= 9&q!T22272C2C1dDL$,)933/" =o =,t,,C"64<<<'=="64<<<0/1d;;E"64<<<,+Aq$77vtUC888 Y!^^''1d33E6444 4//5v$)__060&0&'' 'r$Tc ddlm}ddlm}ddlm} |} |6|dkrd}n-|dkrd }n$t d ddg| | ||} t|j d k} | r|j d } n |j d } | || }n|j | |_ | j } | d | d| d d}}}t| |||||| ||S)a Compute a reduction by pixel, mapping data to pixels as a triangle. >>> import datashader as ds >>> verts = pd.DataFrame({'x': [0, 5, 10], ... 'y': [0, 10, 0], ... 'weight': [1, 5, 3]}, ... columns=['x', 'y', 'weight']) >>> tris = pd.DataFrame({'v0': [2], 'v1': [0], 'v2': [1]}, ... columns=['v0', 'v1', 'v2']) >>> cvs = ds.Canvas(x_range=(verts.x.min(), verts.x.max()), ... y_range=(verts.y.min(), verts.y.max())) >>> untested = cvs.trimesh(verts, tris) Parameters ---------- vertices : pandas.DataFrame, dask.DataFrame The input datasource for triangle vertex coordinates. These can be interpreted as the x/y coordinates of the vertices, with optional weights for value interpolation. Columns should be ordered corresponding to 'x', 'y', followed by zero or more (optional) columns containing vertex values. The rows need not be ordered. The column data types must be floating point or integer. simplices : pandas.DataFrame, dask.DataFrame The input datasource for triangle (simplex) definitions. These can be interpreted as rows of ``vertices``, aka positions in the ``vertices`` index. Columns should be ordered corresponding to 'vertex0', 'vertex1', and 'vertex2'. Order of the vertices can be clockwise or counter-clockwise; it does not matter as long as the data is consistent for all simplices in the dataframe. The rows need not be ordered. The data type for the first three columns in the dataframe must be integer. agg : Reduction, optional Reduction to compute. Default is ``mean()``. mesh : pandas.DataFrame, optional An ordered triangle mesh in tabular form, used for optimization purposes. This dataframe is expected to have come from ``datashader.utils.mesh()``. If this argument is not None, the first two arguments are ignored. interpolate : str, optional default=linear Method to use for interpolation between specified values. ``nearest`` means to use a single value for the whole triangle, and ``linear`` means to do bilinear interpolation of the pixels within each triangle (a weighted average of the vertex values). For backwards compatibility, also accepts ``interp=True`` for ``linear`` and ``interp=False`` for ``nearest``. r) Trianglesr)meshNrLTnearestF.Invalid interpolate method: options include {}rr) weight_typeinterp) rnrrrutilsrrKrSrcolumnsrry)rvertices simplicesrr{r interpolatermean_rdn create_meshrzverts_have_weights weight_colcolsrQrHweightss r"trimeshzCanvas.trimeshzso^ &%%%%%000000......  "h&& )) !Q!X!Xi("*"*+++ > [955F !122Q6  .!)!,JJ"*1-J ;(:&&CC Z #CJ~Qa$qrr(g1vtYYq!WJ\6<&>&>&>?BDD Dr$c ||}||}ddg} iddtjdddtjdddtjdddtjdddtjdd d tjd d d tjd d d tjd } || vr"td | t|ttfs$td t|jzd} t|tjr`t||j} }t|tr5| 3|j| kr(|jd| d} td|jd| dt|trOt'|j}| td|z| |jvrt+d| d|d|| }|| vrAtd t'| | |}|jdvrtd|jzt1|}|jdd\}}||j||j}}t7|||\}}}}||jd,i|jd|i}t;||}|+||k}t<j |||}|}n3t=j!|j"t<j#rd}n t<j$}|j% ||f|_%|j& ||f|_&t|j%d|}t|j&d|}t|j%d|}t|j&d|}t||z |j%d|j%dz z d} t||z |j&d|j&dz z d}!t=j'| dst=j'|!drtdttQtS|j*| zd}"ttQtS|j+|!zd}#tY||||d\}$}%tY||||d\}&}'t[|"|#|||}(|jdkrh||&|'dz|$|%dzf})|d vr|).d!})t|)t^j0rtc|)f|| d"|(}*n te|)fi|(}*d}+n|dd|&|'dz|$|%dzf})|d vr|).d!})g},|)D]O}-t|-t^j0rtc|-f|| d"|(}-n te|-fi|(}-|,3|-Pt=j4|,}*tk|,}+|"|j*ks |#|j+kr|j+|#z }.|j*|"z }/||j%dz }0|j%d|z }1|0|1zdkr|0|0|1zz nd}2ttQt=j6|/|2zd}t|/|z d}|j+|f|j+|f}4}3|+dkr |3|+fz|4|+fz}4}3t=j7|3||)j"}5t=j7|4||)j"}6||j&dz }7|j&d|z }8|7|8zdkr|7|7|8zz nd}9ttQt=j6|.|9zd}t|.|z d}||"f||"f};}:|+dkr |:|+fz|;|+fz};}:t=j7|:||)j"}||,d#n|,d}*|5j9ddkr|5|*fn|*f},|6j9ddkr|,|6fz },tk|,dkr |>|,d#n|,d}*|ddkr |*ddd$}*|ddkr|*ddddd$f}*t=j:||g|j%ot=j;||j*k}?t=j:||g|j&ot=j;||j+k}@|?r|}An\|j<=|j%|j*}B|j<>|B|j*}A|ddkr |Addd$}A|@r|}Cn\|j?=|j&|j+}D|j?>|D|j+}C|ddkr |Cddd$}C||A||Ci}E||g}Ft[|d|j%|j&%}Gd&D]}H|H|j@vr|j@|H|Gd'<nd'|Gvr( |j@d(d|Gd'<n#t$rYnwxYw|*jd)kr:|*Bgd*}*|jd}I|jC|I|E|I<|Ig|Fz}Ft|*|E|F|G+S)-aO Sample a raster dataset by canvas size and bounds. Handles 2D or 3D xarray DataArrays, assuming that the last two array dimensions are the y- and x-axis that are to be resampled. If a 3D array is supplied a layer may be specified to resample to select the layer along the first dimension to resample. Missing values (those having the value indicated by the "nodata" attribute of the raster) are replaced with `NaN` if floats, and 0 if int. Also supports resampling out-of-core DataArrays backed by dask Arrays. By default it will try to maintain the same chunksize in the output array but a custom chunksize may be provided. If there are memory constraints they may be defined using the max_mem parameter, which determines how large the chunks in memory may be. Parameters ---------- source : xarray.DataArray or xr.Dataset 2D or 3D labelled array (if Dataset, the agg reduction must define the data variable). layer : float For a 3D array, value along the z dimension : optional default=None ds_method : str (optional) Grid cell aggregation method for a possible downsampling. us_method : str (optional) Grid cell interpolation method for a possible upsampling. nan_value : int or float, optional Optional nan_value which will be masked out when applying the resampling. agg : Reduction, optional default=mean() Resampling mode when downsampling raster. The supported options include: first, last, mean, mode, var, std, min, The agg can be specified as either a string name or as a reduction function, but note that the function object will be used only to extract the agg type (mean, max, etc.) and the optional column name; the hardcoded raster code supports only a fixed set of reductions and ignores the actual code of the provided agg. interpolate : str, optional default=linear Resampling mode when upsampling raster. options include: nearest, linear. chunksize : tuple(int, int) (optional) Size of the output chunks. By default this the chunk size is inherited from the *src* array. max_mem : int (optional) The maximum number of bytes that should be loaded into memory during the regridding operation. Returns ------- data : xarray.Dataset NrrLfirstlastmodervarstdrrrzBExpected xarray DataArray or Dataset as the data source, found %s.()rrrzsWhen supplying a Dataset the agg reduction must specify the variable to aggregate. Available data_vars include: %r.zSupplied reduction column zE not found in Dataset, expected one of the following data variables: z.Invalid aggregation method: options include {})rrzDRaster aggregation expects a 2D or 3D DataArray, found %s dimensionsr)mask fill_valuerzCanvas x_range or y_range values do not match closely enough with the data source to be able to accurately rasterize. Please provide ranges that are more accurate.)wh ds_method us_methodr r)rrf) chunksizemax_memrr)resr]r^) _FillValue missing_valuer nodataNODATAr nodatavalsr)rrr)rrattrsr4)DrrrrrrrrrrKrSrprrrxr7 ReductionrrrrKeyErrorkeysrr rvaluesr selr r&ma masked_array issubdtypedtypeintegernanr]r^iscloseintroundrZr[rdictastypedaArrayrrappenddstackrceilfull concatenateshapersizer`r#r+rar Exception transposer)Jrrzlayerupsample_methoddownsample_method nan_valuer{rrrupsample_methodsdownsample_methodsragg_reprrrrydimxdimxvalsyvalsleftbottomrighttoparrayr r xminyminxmaxymax width_ratio height_ratior rcmincmaxrminrmaxkwargs source_windowdatalayersarraysarr num_height num_widthlpadrpadlpctlshapershapeleft_pad right_padtpadbpadtpcttshapebshapetop_pad bottom_padconcatclose_xclose_yxsx_stysy_strrra layer_dimsJ r"rasterz Canvas.rasters F  !C  'K%h/=gg=rx=$V=/1wv=$V=/1wv=%V=02wv=$E =02ve = $E = 02ve = $E = 02ve =$E=02ve= . . .MTT ""## #&9g"677 6:#F||4566 6 c2< ( ( :s))SZC69-- :&2DK6))'*|||VVV< j"(+++xxx"9::: fg & & $V-..I~ "DFO"PQQQv///h8>  KLLLF^F (--// / /MTT',,..//1122 2&s+ ;f $ $>@F LMM Mv[% dd|*F4L,?u#,UE3#?#? feS  6:88Q 788FVS))  )#DE&&u4I&NNE"JJ ]6< 4 4 JJJ <  MN** - 4 4S 9 9 F$ # #c28,,51"'0'"" ""CC&c44V44C c""""9V$$D[[F   1(8#8#8)A-J!+I$,q/)D<?T)D+/$;??44$;''Ds279t#34455q99D D(!,,E".58H%7PFFzz!'6)!3Vvi5Gwvz=3FGGH M4GHHI$,q/)D<?T)D+/$;??44$;''Dc"'*t"34455q99Cc)1--F!1X{FFzz!'6)!3Vvi5Ggfj-2EFFG]5HIIJ'1$'A'AUR^^r~F(/ a(81(<()>h%%TGFq!A%%9,&-0[[1__66&q))))&)D q6A::":D q6A::44R4=D+tUmT\::`rwu~~QUQ`?`+vsmT\::arwu~~QUQa?a  BB;::4<YYD**4AAB1vzz"X  BB;::4<IYZZD**41ABBB1vzz"XD"%d|Qt|LLL S  AFL  "(,q/h! 5  "(,|">>>))),,D AI & i 8F9 ;t#Df4uEEEEs8j jjcn|j||j|dSr>)r`r6ra)rr]r^s r"validate_rangeszCanvas.validate_rangess4 W%%% W%%%%%r$c<|dks|dkrtddS)Nrz>Invalid size: plot_width and plot_height must be bigger than 0rJ)rwidthheights r" validate_sizezCanvas.validate_sizes) A::1]^^ ^%r$c||j|j||j|jdS)z7Check that parameter settings are valid for this objectN)rqr]r^rurZr[)rs r"r6zCanvas.validates= T\4<888 4?D,<=====r$c  ddl}n#t$rd}YnwxYw ddl}n#t$rd}YnwxYw|rt||js|r=t||jr'ddlm}ddlm}|||dkrtdt||jr|j |j ntj tj f}|j |j ntj tj f}ddlm }|j||d|d|d|d} |j| }n=|j |j nd }|j |j nd }|jt%|t%|f}|SdS) z Check if the specified source is a geopandas or dask-geopandas GeoDataFrame. If so, spatially filter the source and return it. If not, return None. rN)Version) __version__z2.0.0z8Use of GeoPandas in Datashader requires Shapely >= 2.0.0)boxrri) geopandas ImportErrordask_geopandasrprupackaging.versionrxshapelyryr]r&infr^rzsindexqueryiloccxrt) rrzr{r}rxshapely_versionr]r^rzrs r"rvzCanvas._source_from_geopandass          III  " ! ! ! ! ! " " "!NNN " :fi.DEE  ",V^5P"Q"Q  2 1 1 1 1 1 > > > > > >w'''''*:*:::!"\]]]&)"899 E*.,*B$,,"&RTRXHY*.,*B$,,"&RTRXHY'''''' ++CC GAJPQ T[\]T^,_,_``U+*.,*B$,, *.,*B$,, 5'?E7O#CDM4s  ..)rXrXNNrLrL)NNNN)NNNrNrF)NrNr>)NNN)NNTN)r7r8r9r:rdr~rrrrrrrrorqrur6rvr4r$r"rWrWs_  47'+3;0000.1.1.1.1`GK%*wNwNwNwNrm1m1m1m1^E1E1E1E1Nd'd'd'd'TRDRDRDRDl'!(ZFZFZFZFx&&&___>>> $$$$$r$rWFrc xt|||\}}|j}|||||tj5tjddt ||||||cdddS#1swxYwYdS)aCompute an aggregate grouped by pixel sized bins. Aggregate input data ``source`` into a grid with shape and axis matching ``canvas``, mapping data to bins by ``glyph``, and aggregating by reduction ``agg``. Parameters ---------- source : pandas.DataFrame, dask.DataFrame Input datasource canvas : Canvas glyph : Glyph agg : Reduction ignorez All-NaN (slice|axis) encounteredrN)_bypixel_sanitisemeasurer6rcatch_warningsfilterwarningsrypipeline)rzcanvasrPr{rdshapeschemas r"ryrys'vuc::NFF ^F NN6LL OO  " "YY*MNNNsiXXYYYYYYYYYYYYYYYYYYs-5B//B36B3ct|tr-|jdkr"|jsd|_|}t|t rt |jdkrt|j t|j z}t|||| fd|D}|}t|tjs!t"rt|t"jrt|j||t t |jkr{d}ddlm}t||r!t+||jjdd}|}|8t+||jjdd|||jj_t3|}nat|t4jrt7|\}}n4t|t rt9|}nt;d||fS)Nrvaluecg|]}|v| Sr4r4).0col cols_to_keeps r" z%_bypixel_sanitise..Cs#"U"U"U3S =T=T3=T=T=Tr$r_sindexz)source must be a pandas or dask DataFrame)rprrr reset_coordsrrrrrrr _cols_to_keep drop_varsto_dask_dataframepdrrrrrgetattrrRrErrddrrrK)rzrPr{rrrrrs @r"rr:sF&)$$')9)9{ "!FK$$&&&'"",s6;'7'71'<'<v}))++,,tF4D4I4I4K4K/L/LL$WeS99 !!"U"U"U"U'"U"U"UVV))++62<((F F 88F%V^UC@@ |  s6>22 2 2F 3 3 3 3 3 3%-- P !7!=y$OOL)F"F5>28)TJJR7=u~&,4#F++ FBL ) )F)&11 FG $ $F+F33DEEE 6>r$ctd|D}|D]}d||<fd||d|DS)z Return which columns from the supplied data source are kept as they are needed by the specified agg. Excludes any SpecialColumn. ci|]}|dS)Fr4)rrs r" z!_cols_to_keep..js777e777r$Tct|dr|jD]}||dSt|dr&|jD]}|dtjjfvrd||<dS|jdtjjfvr d||j<dSdS)NrrT)hasattrrrr SpecialColumnRowIndexr)rr{subaggrrecurses r"rz_cols_to_keep..recursens 3 ! ! ,* . . f---- . . S) $ $ ,+ 0 0$(8(A!BBB+/L( 0 0Zb&6&?@ @ @'+L $ $ $A @r$cg|] \}}|| Sr4r4)rrkeepits r"rz!_cols_to_keep..{s! B B BKC6 BC B B Br$)r)required_columnsitems)rrPr{rrrs @r"rres 77w77788L%%''!! S , , , , , GL# B B<#5#5#7#7 B B BBr$cd|D}t|dkr|S|tfd|DS)Ncdh|]-}t|ttft|.Sr4)rprr\r)rrms r" z3_broadcast_column_specifications..s1DDD!z!dE]'C'CDs1vvDDDr$rc3`K|](}t|ttfr|fzn|V)dSr>)rprr)rargrs r" z3_broadcast_column_specifications..sT  %S63-88 ASFQJJc      r$)rpopr\)argslengthsrs @r"rr~sqDDtDDDG 7||q KKMM          r$)4 __future__rnumbersrmathrrnumpyr&pandasrdask.dataframe dataframer dask.arrayrEr+xarrayrrrr r r r r rrrrr resamplingrrrrrr4rrorr<rCr_rUrWryrrrrr4r$r"rs;""""""%%%%%%%%DDDDDDDDDD<<<<<<<<KKKK DDDIIIMMMB B B B B B B B J        MMMMMdMMM*%*,,wwyy99  H H HBBBBBBBBJ$6;YYYYY8(((VCCC2    :<<s6"A''A10A15A::BBB BB