a `@sddlmZmZmZddlmZddlmZddlZddl Z ddl Z ddl mZddlmZddlmZddlmZmZddlmZdd lmZmZmZmZmZm Z m!Z!dd lm"Z"m#Z#m$Z$dd lm%Z%dd l&m'Z'm(Z(dd l)m*Z+z ddl,Z,Wne-ydZ,Yn0z ddl.Z.Wne-y.dZ.Yn0Gddde/Z0Gddde0Z1Gddde0Z2e1e2dZ3ddZ4Gddde/Z5ddZ6ddZ7ddZ8ee6_9dS))absolute_importdivisionprint_function)Number)log10N) string_types) DataArrayDataset) OrderedDict) Dispatcherngjitcalc_res calc_bbox orient_arraycompute_coordsdshape_from_xarray_dataset) get_indicesdshape_from_pandasdshape_from_dask)Expr) resample_2dresample_2d_distributed) reductionsc@s8eZdZdZddZddZddZdd Zd d Zd S) 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. cCs.t|j|\}}|||}| |}||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)selfrangenstartendstr$.lib/python3.9/site-packages/datashader/core.pycompute_scale_and_translate1s  z Axis.compute_scale_and_translatecCs(t|d}|\}}||||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?)npZarangeinverse_mapper)rstrZpxr"r#r$r$r% compute_indexFszAxis.compute_indexcCstdS)z'A mapping from data space to axis spaceNNotImplementedErrorvalr$r$r%rXsz Axis.mappercCstdS)z'A mapping from axis space to data spaceNr+r-r$r$r%r(\szAxis.inverse_mappercCsdS)zNGiven a range (low,high), raise an error if the range is invalid for this axisNr$)rrr$r$r%validate`sz Axis.validateN) __name__ __module__ __qualname____doc__r&r*rr(r/r$r$r$r%r s rc@s0eZdZdZeeddZeeddZdS) LinearAxisz A linear AxiscCs|SNr$r-r$r$r%rgszLinearAxis.mappercCs|Sr5r$r-r$r$r%r(lszLinearAxis.inverse_mapperN)r0r1r2r3 staticmethodr rr(r$r$r$r%r4es r4c@s8eZdZdZeeddZeeddZddZdS) LogAxiszA base-10 logarithmic AxiscCs tt|Sr5)rfloatr-r$r$r%rtszLogAxis.mappercCs d}||S)N r$)r.yr$r$r%r(yszLogAxis.inverse_mappercCs0t|j|\}}t|r$t|s,tddS)Nz%Range values must be >0 for a LogAxis)rrr'Zisfinite ValueError)rrZlowZhighr$r$r%r/szLogAxis.validateN) r0r1r2r3r6r rr(r/r$r$r$r%r7rs  r7)linearlogcCsV|dur|dus0|dus0|durR|dus0|durRtdj|t|t|t|ddS)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} glyphxr:geometry)r;formatreprr>r$r$r%validate_xy_or_geometrysrDc@s|eZdZdZdddZdddZdd d Zdd dZdddZdddZ d ddZ dde dddddfddZ ddZdS)!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'``. XNr<cCsP||_||_|durdnt||_|dur.dnt||_t||_t||_dSr5) plot_width plot_heighttuplex_rangey_range _axis_lookupx_axisy_axis)rrGrHrJrKZ x_axis_typeZ y_axis_typer$r$r%__init__s  zCanvas.__init__cCsddlm}m}ddlm}td||||dur8|}|durL|||} nddlm} ddlm } t || r|j dur~|j nd } |j dur|j nd } |j t| t| f}nt || std jt|d ||} 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)countrPNr GeoDataFrameDaskGeoDataFrameNNsource must be an instance of spatialpandas.GeoDataFrame or spatialpandas.dask.DaskGeoDataFrame. Received value of type {typ}typ)glyphsrPrQrrRrD spatialpandasrTspatialpandas.daskrV isinstancerJrK cx_partitionsslicer;rBtypebypixel)rsourcer@r:aggrArPrQZ count_rdnr?rTrVrJrKr$r$r%pointss*      z Canvas.pointsrFcCsddlm}m} m} m} m} m} m}td||||durBt }|durddl m }ddl m}t||r|jdur||jnd}|jdur|jnd}|jt|t|f}nt||std jt|d ||}n||}}t||\}}|dkrtt|ttfr$t|ttfr$|||}nNt|ttfrXt|ttfrX| t|t|}ntd jt|t|d n|dkrVt|ttfrt|ttfr| t|t|}nt|tjrt|ttfr| |t|}ntt|ttfrt|tjr| t||}nFt|ttfr:t|ttfr:| ||}ntd jt|t|d ntdj|d|rt|t jt j fr|!nd|}t"#|t$||||S)aCompute 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. antialias : bool If True, draw anti-aliased lines, distributing the aggregate value across neighboring pixels to more closely approximate the line shape. If False, each position on the line affects only a single pixel, resulting in line shapes that are blocky but easier to reason about. Needs at least Numba 0.51.2 to work and can only operate on the 'sum' or 'max' aggregators. 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 LinesAxis1LinesAxis1XConstantLinesAxis1YConstantLineAxis0MultiLinesAxis1RaggedLineAxis1GeometryZLineNrrSrUrWrXrYz 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 usager@r:z 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 usageE The axis argument to Canvas.line must be 0 or 1 Received: {axis}axisz0Aggresgation: '{}' is not supported by antialias)%r[rfrgrhrirjrkrlrDrdanyr\rTr]rVr^rJrKr_r`r;rBra _broadcast_column_specificationsrrlistrIrCr'ndarraysummaxZenable_antialiaswarningswarnrb)rrcr@r:rdrprAZ antialiasrfrgrhrirjrkrlrTrVrJrKr?orig_xorig_ymessager$r$r%lineszm$                    z Canvas.linecCsddlm}m}m} m} m} m} m} m}m }m }m }m }ddl m}|durR|}|||}}}t|||\}}}|dkr|durt|ttfrt|ttfr|||}nJt|ttfrt|ttfr| t|t|}ntdjt|t|dnt|ttfr8t|ttfr8t|ttfr8||||}njt|ttfrt|ttfrt|ttfr| t|t|t|}n tdjt|t|t|d n*|dkr|durt|ttfrt|ttfr| t|t|}nt|tjrt|ttfr| |t|}ntt|ttfrJt|tjrJ|t||}nFt|ttfrvt|ttfrv|||}ntd jt|t|dqt|ttfrt|ttfrt|ttfr| t|t|t|}nt|tjr"t|ttfr"t|ttfr"||t|t|}nt|ttfr`t|tjr`t|tjr`|t|||}n^t|ttfrt|ttfrt|ttfr||||}n td jt|t|t|d ntd j|d t||||S)aCompute a reduction by pixel, mapping data to pixels as a filled area region 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 of the line defining the starting edge of the area region. * 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 ``count()``. axis : 0 or 1, default 0 Axis in source to draw lines along * 0: Draw area regions using data from the specified columns across all rows in source * 1: Draw one area region per row in source using data from the specified columns y_stack: str or number or list or tuple or np.ndarray or None Specification of the y coordinates of each vertex of the line defining the ending edge of the area region, where the x coordinate is given by the x argument described above. If y_stack is None, then the area region is filled to the y=0 line If y_stack is not None, then the form of y_stack must match the form of y. 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.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'], agg=ds.count(), axis=0) # doctest: +SKIP ... 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'], agg=ds.count(), axis=1) # doctest: +SKIP ... 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 ) AreaToZeroAxis0AreaToLineAxis0AreaToZeroAxis0MultiAreaToLineAxis0MultiAreaToZeroAxis1AreaToLineAxis1AreaToZeroAxis1XConstantAreaToLineAxis1XConstantAreaToZeroAxis1YConstantAreaToLineAxis1YConstantAreaToZeroAxis1RaggedAreaToLineAxis1RaggedrrNrz 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 usagermz 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)r@r:y_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 usagernro)r[r~rrrrrrrrrrrrrrrsr^rrrtrIr;rBrCr'rurb)rrcr@r:rdrprr~rrrrrrrrrrrany_rdnrzr{Z orig_y_stackr?r$r$r%areasy8                           z Canvas.areac Csddlm}ddlm}ddlm}ddlm}t||rz|j durJ|j nd}|j dur^|j nd} |j t |t | f}nt||st d jt|d |dur|}||} t||| |S) aCompute a reduction by pixel, mapping data to pixels as one or more filled polygons. Parameters ---------- source : xarray.DataArray or Dataset The input datasource. geometry : str Column name of a PolygonsArray of the coordinates of each line. agg : Reduction, optional Reduction to compute. Default is ``any()``. Returns ------- data : xarray.DataArray Examples -------- >>> 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 ) PolygonGeomrrrSrUNrWrXrY)r[rrrrr\rTr]rVr^rJrKr_r`r;rBrarb) rrcrArdrrrTrVrJrKr?r$r$r%polygonss$.      zCanvas.polygonsc Csddlm}m}m}ddlm}t|tr^|dus<|jdurLt |j d} n|j} || g}n"t|t rx|j } | }ntd|dur|| }|dur|dur|| j\}}n|r|std||||} } | jdks| jdkr | j| jkr td| j| jf| dur>|jdur>|j| kr>td |j |f| jdkrh|jtd u} |jtd u} t| t| d| d t| }t| t| d| d t| }| rL| rL|rL|rL|||| }||||| |j|j|j|j\}}|r|rt| }t||||S|s0|s0t||||S|||| }t||||Sn|||| }t||||Sn<| jd kr|||| }t||||Std j t | jddS)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 )QuadMeshRasterQuadMeshRectilinearQuadMeshCurvilinearmeanNrzInvalid input typezDEither specify both x and y coordinatesor allow them to be inferred.zEnsure that x- and y-coordinate arrays share the same dimensions. x-coordinates are indexed by %s dims while y-coordinates are indexed by %s dims.7DataArray name %r does not match supplied reduction %s.r<zcx- and y-coordinate arrays must have 1 or 2 dimensions. Received arrays with dimensions: {dims})dims)!r[rrrrrr^r columnrt data_varsrnameZ to_datasetr;rndimrMrLrNr'ZallcloseZlinspacelenZ is_upsamplerJrKrGrHrqZ _upsamplerbrB)rrcr@r:rdrrrZmean_rndrZyarrZxarrZ xaxis_linearZ yaxis_linearZ even_yspacingZ even_xspacingr?Zupsample_widthZupsample_heightr$r$r%quadmeshsx     $           zCanvas.quadmeshTc Csddlm}ddlm}ddlm} |} |dur^|dkr>d}n |dkrLd }ntd ddg| durp| ||} t|j d k} | r|j d } n |j d } |dur|| }n|j dur| |_ | j } | d | d| d d}}}t | |||||| |d|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)meshNr<TnearestF.Invalid interpolate method: options include {}rr)Z weight_typeinterp) r[rrrutilsrr;rBrcolumnsrrb)rZverticesZ simplicesrrdr interpolaterZmean_rdnZ create_meshrcZverts_have_weightsZ weight_colZcolsr@r:Zweightsr$r$r%trimesh.s./         zCanvas.trimeshc G CsN|dur |}|dur|}ddg} ddtjdddtjdddtjdddtjdddtjdd d tjd d d tjd d d tjd i} || vrt d | t |t t fst d t|jd} t |tjrt||j}} t |t r| dur|j| krd|j| f} t d|j| ft |t r`t|j}| dur|*,d}*g}-|*D]F}.t |.t-j.rpt/|.f|| d|)}.nt0|.fi|)}.|-1|.qFt2|-}+t3|-},|#|j(ks|$|j)kr|j)|$}/|j(|#}0||j#d}1|j#d|}2|1|2dkr|1|1|2nd}3tt&t4|0|3d}t|0|d}|j)|f|j)|f}4}5|,dkrb|4|,f|5|,f}4}5t5|4||*j}6t5|5||*j}7||j$d}8|j$d| }9|8|9dkr|8|8|9nd}:tt&t4|/|:d}t|/|d}||#f||#f};}<|,dkr|;|,f|<|,f};}t |+t-j.rHt-j6ntj6}?|=j7ddkrf|=|+fn|+f}-|>j7ddkr|-|>f7}-t3|-dkr|?|-ddn|-d}+|6j7ddkr|6|+fn|+f}-|7j7ddkr|-|7f7}-t3|-dkr|?|-ddn|-d}+|ddkr|+ddd }+|ddkrB|+ddddd f}+|durT|+8}+||+jkrj|+,|}+t9|j(|j)|j#|j$|\}@}A||@||Ai}B||g}Ct+|dd!}Dd"D]&}E|E|j:vr|j:|E|Dd#<qԐqd#|Dvrz|j:d$d|Dd#<Wn Yn0|+jd%kr>|+;gd&}+|jd}F|j<|F|B|F<|Fg|C}Ct |+|B|C|Dd'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 Nrr<firstlastmodervarstdminrwrzBExpected xarray DataArray or Dataset as the data source, found %s.z%s(%r)rzsWhen supplying a Dataset the agg reduction must specify the variable to aggregate. Available data_vars include: %r.zdSupplied reduction column %r not found in Dataset, expected one of the following data variables: %r.z.Invalid aggregation method: options include {})rrzDRaster aggregation expects a 2D or 3D DataArray, found %s dimensionsr)mask fill_valuer zCanvas 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_methodZ us_methodrr)rrf) chunksizemax_memror)res)Z _FillValueZ missing_valuernodataZNODATArZ nodatavalsr)rrr )coordsrattrs)=rqrrrrrrrrwr;rBr^rr rar0Z ReductionrrrtrKeyErrorkeysrrrvaluesrZselrdtyper'ZmaZ masked_arrayZNaNrJrKZiscloseintroundrGrHrdictZastypedaZArrayrrappendZdstackrZceilZfullZ concatenateshapeZfilledrrZ transposer)GrrcZlayerZupsample_methodZdownsample_methodZ nan_valuerdrrrZupsample_methodsZdownsample_methodsrZagg_reprrrrZydimZxdimZxvalsZyvalsleftZbottomrighttoparrayrrrZxminZyminZxmaxZymaxZ width_ratioZ height_ratiorrZcminZcmaxZrminZrmaxkwargsZ source_windowdataZlayersZarraysZarrZ num_heightZ num_widthZlpadZrpadZlpctZlshapeZrshapeZleft_padZ right_padZtpadZbpadZtpctZtshapeZbshapeZtop_padZ bottom_padconcatZxsZysrrraZ layer_dimr$r$r%rastersHC                   ""   "        " "$          z Canvas.rastercCs |j|j|j|jdS)z7Check that parameter settings are valid for this objectN)rMr/rJrNrK)rr$r$r%r/szCanvas.validate)rFrFNNr<r<)NNNN)NNNrNF)NrN)N)NNN)NNTN)r0r1r2r3rOrer}rrrrrqrrr/r$r$r$r%rEs6  , @ n B h T rEcs|t|tr(|jdkr(|js d|_|}t|trt|jdkrt|j t|j }t |||| fdd|D}|}t|tjstrt|tjrt |j||tt|jkr|}t|}n4t|tjrt|}nt|trt|}ntd|j}|||||tj0tjddt|||||WdS1sn0YdS) 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 r valuecsg|]}|vr|qSr$r$.0col cols_to_keepr$r% zbypixel..z)source must be a pandas or dask DataFrameignorez All-NaN (slice|axis) encounteredN) r^rrrZ reset_coordsr rrrtrrr _cols_to_keepZdropZto_dask_dataframepdZ DataFramecudfrrddrrr;Zmeasurer/r'rxcatch_warningsfilterwarningsrbpipeline)rcZcanvasr?rdrZdshapeZschemar$rr%rbs<           rbcCstdd|D}|D] }d||<qt|drT|jD]}|jdur8d||j<q8nrz!_cols_to_keep..TrrcSsg|]\}}|r|qSr$r$)rrZkeepitr$r$r%rrz!_cols_to_keep..)r Zrequired_columnshasattrrrritems)rr?rdrrZsubaggrr$r$r%rs          rcs@dd|D}t|dkr|S|tfdd|DSdS)NcSs"h|]}t|ttfrt|qSr$)r^rtrIr)rrr$r$r% rz3_broadcast_column_specifications..r c3s*|]"}t|ttfr|fn|VqdSr5)r^rr)rargrr$r% sz3_broadcast_column_specifications..)rpoprI)argsZlengthsr$rr%rss  rs):Z __future__rrrZnumbersrZmathrrxZnumpyr'ZpandasrZdask.dataframeZ dataframerZ dask.arrayrrZsixrZxarrayrr collectionsr rr r rrrrrrrrrZ resamplingrrrrqr ExceptionZ dask_cudfobjectrr4r7rLrDrErbrrsrr$r$r$r%sP      $      E  |7