Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
else:
xs = df[list(x_names)].values
ys = df[list(y_names)].values
do_extend = extend_cpu
# line may be clipped, then mapped to pixels
do_extend(
sx, tx, sy, ty,
xmin, xmax, ymin, ymax,
xs, ys, plot_start, *aggs_and_cols
)
return extend
class LinesAxis1(_PointLike):
"""A collection of lines (on line per row) with vertices defined
by the lists of columns in ``x`` and ``y``
Parameters
----------
x, y : list
Lists of column names for the x and y coordinates
"""
def validate(self, in_dshape):
if not all([isreal(in_dshape.measure[str(xcol)])
for xcol in self.x]):
raise ValueError('x columns must be real')
elif not all([isreal(in_dshape.measure[str(ycol)])
for ycol in self.y]):
raise ValueError('y columns must be real')
do_extend = extend_cuda[cuda_args(xs.shape)]
else:
xs = df[x_name].values
ys0 = df[y_name].values
ys1 = df[y_stack_name].values
do_extend = extend_cpu
do_extend(
sx, tx, sy, ty, xmin, xmax, ymin, ymax,
plot_start, xs, ys0, ys1, *aggs_and_cols
)
return extend
class AreaToZeroAxis0Multi(_PointLike):
def validate(self, in_dshape):
if not all([isreal(in_dshape.measure[str(xcol)]) for xcol in self.x]):
raise ValueError('x columns must be real')
elif not all(
[isreal(in_dshape.measure[str(ycol)]) for ycol in self.y]):
raise ValueError('y columns must be real')
@property
def x_label(self):
return 'x'
@property
def y_label(self):
return 'y'
def required_columns(self):
do_extend = extend_cuda[cuda_args(xs.shape)]
else:
xs = df[x_name].values
ys = df[y_name].values
do_extend = extend_cpu
# line may be clipped, then mapped to pixels
do_extend(
sx, tx, sy, ty, xmin, xmax, ymin, ymax,
xs, ys, plot_start, *aggs_and_cols
)
return extend
class LineAxis0Multi(_PointLike):
"""
"""
def validate(self, in_dshape):
if not all([isreal(in_dshape.measure[str(xcol)]) for xcol in self.x]):
raise ValueError('x columns must be real')
elif not all([isreal(in_dshape.measure[str(ycol)]) for ycol in self.y]):
raise ValueError('y columns must be real')
@property
def x_label(self):
return 'x'
@property
def y_label(self):
return 'y'
xs = self.to_gpu_matrix(df, x_names)
do_extend = extend_cuda[cuda_args(xs.shape)]
else:
xs = df[list(x_names)].values
do_extend = extend_cpu
do_extend(
sx, tx, sy, ty,
xmin, xmax, ymin, ymax,
xs, y_values, *aggs_and_cols
)
return extend
class LinesAxis1Ragged(_PointLike):
def validate(self, in_dshape):
try:
from datashader.datatypes import RaggedDtype
except ImportError:
RaggedDtype = type(None)
if not isinstance(in_dshape[str(self.x)], RaggedDtype):
raise ValueError('x must be a RaggedArray')
elif not isinstance(in_dshape[str(self.y)], RaggedDtype):
raise ValueError('y must be a RaggedArray')
def required_columns(self):
return (self.x,) + (self.y,)
def compute_x_bounds(self, df):
bounds = self._compute_bounds(df[self.x].array.flat_array)
r = ddf.map_partitions(lambda df: np.array([[
np.nanmin(df[self.x].values),
np.nanmax(df[self.x].values),
np.nanmin(df[self.y].values),
np.nanmax(df[self.y].values)]]
)).compute()
x_extents = np.nanmin(r[:, 0]), np.nanmax(r[:, 1])
y_extents = np.nanmin(r[:, 2]), np.nanmax(r[:, 3])
return (self.maybe_expand_bounds(x_extents),
self.maybe_expand_bounds(y_extents))
class Point(_PointLike):
"""A point, with center at ``x`` and ``y``.
Points map each record to a single bin.
Points falling exactly on the upper bounds are treated as a special case,
mapping into the previous bin rather than being cropped off.
Parameters
----------
x, y : str
Column names for the x and y coordinates of each point.
"""
@memoize
def _build_extend(self, x_mapper, y_mapper, info, append):
x_name = self.x
y_name = self.y
@glyph_dispatch.register(_PointLike)
@glyph_dispatch.register(_GeometryLike)
@glyph_dispatch.register(_AreaToLineLike)
def default(glyph, source, schema, canvas, summary, cuda=False):
create, info, append, _, finalize = compile_components(summary, schema, glyph, cuda)
x_mapper = canvas.x_axis.mapper
y_mapper = canvas.y_axis.mapper
extend = glyph._build_extend(x_mapper, y_mapper, info, append)
x_range = canvas.x_range or glyph.compute_x_bounds(source)
y_range = canvas.y_range or glyph.compute_y_bounds(source)
width = canvas.plot_width
height = canvas.plot_height
x_st = canvas.x_axis.compute_scale_and_translate(x_range, width)
y_st = canvas.y_axis.compute_scale_and_translate(y_range, height)
from toolz import memoize
from datashader.glyphs.points import _PointLike, _GeometryLike
from datashader.glyphs.glyph import isnull
from datashader.utils import isreal, ngjit
from numba import cuda
try:
import cudf
from ..transfer_functions._cuda_utils import cuda_args
except ImportError:
cudf = None
cuda_args = None
class LineAxis0(_PointLike):
"""A line, with vertices defined by ``x`` and ``y``.
Parameters
----------
x, y : str
Column names for the x and y coordinates of each vertex.
"""
@memoize
def _build_extend(self, x_mapper, y_mapper, info, append):
expand_aggs_and_cols = self.expand_aggs_and_cols(append)
map_onto_pixel = _build_map_onto_pixel_for_line(x_mapper, y_mapper)
draw_segment = _build_draw_segment(append, map_onto_pixel, expand_aggs_and_cols)
extend_cpu, extend_cuda = _build_extend_line_axis0(
draw_segment, expand_aggs_and_cols
)
x_name = self.x
from __future__ import absolute_import, division
import numpy as np
from toolz import memoize
from datashader.glyphs.points import _PointLike
from datashader.utils import isreal, ngjit
class _PolygonLike(_PointLike):
"""_PointLike class, with methods overridden for vertex-delimited shapes.
Key differences from _PointLike:
- added self.z as a list, representing vertex weights
- constructor accepts additional kwargs:
* weight_type (bool): Whether the weights are on vertices (True) or on the shapes (False)
* interp (bool): Whether to interpolate (True), or to have one color per shape (False)
"""
def __init__(self, x, y, z=None, weight_type=True, interp=True):
super(_PolygonLike, self).__init__(x, y)
if z is None:
self.z = []
else:
self.z = z
self.interpolate = interp
self.weight_type = weight_type
def x_label(self):
return self.x
@property
def y_label(self):
return self.y
def required_columns(self):
return self.x, self.y, self.y_stack
def compute_x_bounds(self, df):
bounds = self._compute_bounds(df[self.x])
return self.maybe_expand_bounds(bounds)
class AreaToZeroAxis0(_PointLike):
"""A filled area glyph
The area to be filled is the region from the line defined by ``x`` and
``y`` and the y=0 line
Parameters
----------
x, y
Column names for the x and y coordinates of each vertex.
"""
def compute_y_bounds(self, df):
# Compute bounds of curve
bounds = self._compute_bounds(df[self.y])
# Make sure bounds include zero
bounds = min(bounds[0], 0), max(bounds[1], 0)
do_extend = extend_cuda[cuda_args(xs.shape)]
else:
xs = df[list(x_names)].values
ys0 = df[list(y_names)].values
ys1 = df[list(y_stack_names)].values
do_extend = extend_cpu
do_extend(
sx, tx, sy, ty, xmin, xmax, ymin, ymax,
plot_start, xs, ys0, ys1, *aggs_and_cols
)
return extend
class AreaToZeroAxis1(_PointLike):
def validate(self, in_dshape):
if not all([isreal(in_dshape.measure[str(xcol)])
for xcol in self.x]):
raise ValueError('x columns must be real')
elif not all([isreal(in_dshape.measure[str(ycol)])
for ycol in self.y]):
raise ValueError('y columns must be real')
unique_x_measures = set(in_dshape.measure[str(xcol)]
for xcol in self.x)
if len(unique_x_measures) > 1:
raise ValueError('x columns must have the same data type')
unique_y_measures = set(in_dshape.measure[str(ycol)]
for ycol in self.y)
if len(unique_y_measures) > 1: