class BoxAnnotation(SceneAnnotation):
name = "box_outline"
data = traitlets.Instance(BoxData)
box_width = traitlets.CFloat(0.05)
box_color = traitlets.Tuple(
traitlets.CFloat(),
traitlets.CFloat(),
traitlets.CFloat(),
default_value=(1.0, 1.0, 1.0),
)
box_alpha = traitlets.CFloat(1.0)
def draw(self, scene, program):
each = self.data.vertex_array.each
GL.glDrawArrays(GL.GL_TRIANGLES, 0, each)
def render_gui(self, imgui, renderer, scene):
changed = super(BoxAnnotation, self).render_gui(imgui, renderer, scene)
_, bw = imgui.slider_float("Width", self.box_width, 0.001, 0.250)
if _:
self.box_width = bw
changed = changed or _
_, ba = imgui.slider_float("Alpha", self.box_alpha, 0.0, 1.0)
if _:
self.box_alpha = ba
changed = changed or _
return changed
def _set_uniforms(self, scene, shader_program):
shader_program._set_uniform("box_width", self.box_width)
shader_program._set_uniform("box_alpha", self.box_alpha)
shader_program._set_uniform("box_color", np.array(self.box_color))
class AnimationWidget(widgets.DOMWidget):
"""
A widget that periodic increment a value
:param value: A float between 0 and 1
:param run: boolean with the state of the timer. True, the timer is enable
Produces the following signal. A sampling rate, the value is interpolated
with the equation val = 1/Period * t
1- ^ ____
| /
|/
0- |----->
|
period
"""
_view_name = traitlets.Unicode('AnimationView').tag(sync=True)
_model_name = traitlets.Unicode('AnimationModel').tag(sync=True)
_view_module = traitlets.Unicode('animation-widget').tag(sync=True)
_model_module = traitlets.Unicode('animation-widget').tag(sync=True)
# Signal value
value = traitlets.CFloat(0.0).tag(sync=True)
# Boolean timer is active
run = traitlets.CBool(False).tag(sync=True)
# Signal period (in ms)
period = traitlets.CFloat(5000).tag(sync=True)
# Number of samples in period
nbsamples = traitlets.CInt(100).tag(sync=True)
# Loop
loop = traitlets.CBool(False).tag(sync=True)
class OrthographicRayBlaster(RayBlaster):
center = traittypes.Array().valid(check_dtype("f4"), check_shape(3))
forward = traittypes.Array().valid(check_dtype("f4"), check_shape(3))
up = traittypes.Array().valid(check_dtype("f4"), check_shape(3))
east = traittypes.Array().valid(check_dtype("f4"), check_shape(3))
width = traitlets.CFloat(1.0)
height = traitlets.CFloat(1.0)
nx = traitlets.CInt(512)
ny = traitlets.CInt(512)
@traitlets.default("east")
def _default_east(self):
return np.cross(self.forward, self.up)
def __init__(self, *args, **kwargs):
super(OrthographicRayBlaster, self).__init__(*args, **kwargs)
# here origin is not the center, but the bottom left
self._directions = np.zeros((self.nx, self.ny, 3), dtype="f4")
self._directions[:] = self.forward[None, None, :]
self.directions = self._directions.view().reshape(
(self.nx * self.ny, 3))
self._origins = np.zeros((self.nx, self.ny, 3), dtype="f4")
offset_x, offset_y = np.mgrid[-self.width / 2:self.width / 2:self.nx *
1j, -self.height / 2:self.height /
2:self.ny * 1j, ]
self._origins[:] = (self.center + offset_x[..., None] * self.east +
offset_y[..., None] * self.up)
self.origins = self._origins.view().reshape((self.nx * self.ny, 3))
class BandScale(DiscreteScale):
type = T.Unicode('band')
align = T.CFloat()
padding = T.Float()
paddingInner = T.CFloat()
paddingOuter = T.CFloat()
class VizHistogramState(VizBaseState):
x_expression = traitlets.Unicode()
x_slice = traitlets.CInt(None, allow_none=True)
type = traitlets.CaselessStrEnum(['count', 'min', 'max', 'mean'], default_value='count')
aux = traitlets.Unicode(None, allow_none=True)
groupby = traitlets.Unicode(None, allow_none=True)
groupby_normalize = traitlets.Bool(False, allow_none=True)
x_min = traitlets.CFloat(None, allow_none=True)
x_max = traitlets.CFloat(None, allow_none=True)
grid = traitlets.Any().tag(**serialize_numpy)
grid_sliced = traitlets.Any().tag(**serialize_numpy)
x_centers = traitlets.Any().tag(**serialize_numpy)
x_shape = traitlets.CInt(None, allow_none=True)
#centers = traitlets.Any()
def __init__(self, ds, **kwargs):
super(VizHistogramState, self).__init__(ds, **kwargs)
self.observe(lambda x: self.signal_slice.emit(self), ['x_slice'])
self.observe(lambda x: self.calculate_limits(), ['x_expression', 'type', 'aux'])
# no need for recompute
# self.observe(lambda x: self.calculate_grid(), ['groupby', 'shape', 'groupby_normalize'])
# self.observe(lambda x: self.calculate_grid(), ['groupby', 'shape', 'groupby_normalize'])
self.observe(lambda x: self._update_grid(), ['x_min', 'x_max', 'shape'])
if self.x_min is None and self.x_max is None:
self.calculate_limits()
else:
self._calculate_centers()
def bin_parameters(self):
yield self.x_expression, self.x_shape or self.shape, (self.x_min, self.x_max), self.x_slice
def state_get(self):
# return {name: self.trait_metadata('grid', 'serialize', ident)(getattr(self, name) for name in self.trait_names()}
state = {}
for name in self.trait_names():
serializer = self.trait_metadata(name, 'serialize', ident)
value = serializer(getattr(self, name))
state[name] = value
return state
def state_set(self, state):
for name in self.trait_names():
if name in state:
deserializer = self.trait_metadata(name, 'deserialize', ident)
value = deserializer(state[name])
setattr(self, name, value)
def calculate_limits(self):
self._calculate_limits('x', 'x_expression')
self.signal_regrid.emit(None) # TODO this is also called in the ctor, unnec work
def limits_changed(self, change):
self.signal_regrid.emit(None) # TODO this is also called in the ctor, unnec work
@vaex.jupyter.debounced()
def _update_grid(self):
self._calculate_centers()
self.signal_regrid.emit(None)
class BackendBase(widgets.Widget):
dim = 2
limits = traitlets.List(traitlets.Tuple(traitlets.CFloat(), traitlets.CFloat()))
@staticmethod
def wants_colors():
return True
def update_vectors(self, vcount, vgrids, vcount_limits):
pass
class TransferFunctionJsBumps(TransferFunction):
_model_name = Unicode('TransferFunctionJsBumpsModel').tag(sync=True)
_model_module = Unicode('ipyvolume').tag(sync=True)
levels = traitlets.List(traitlets.CFloat(),
default_value=[0.1, 0.5, 0.8]).tag(sync=True)
opacities = traitlets.List(traitlets.CFloat(),
default_value=[0.01, 0.05, 0.1]).tag(sync=True)
widths = traitlets.List(traitlets.CFloat(),
default_value=[0.1, 0.1, 0.1]).tag(sync=True)
def control(self, max_opacity=0.2):
return widgets.VBox()
class Icosahedron(GeometricObject):
""" a spherical object
Examples
--------
>>> object = Circle()
>>> object.position
(0.0, 0.0, 0.0)
"""
radius = trait.CFloat(1).tag(sync=True)
detail = trait.CFloat(0).tag(sync=True)
class Circle(GeometricObject):
""" a spherical object
Examples
--------
>>> object = Circle()
>>> object.position
(0.0, 0.0, 0.0)
"""
radius = trait.CFloat(1).tag(sync=True)
segments = trait.CFloat(36).tag(sync=True)
class Box(GeometricObject):
""" a spherical object
Examples
--------
>>> object = Box()
>>> object.position
(0.0, 0.0, 0.0)
"""
width = trait.CFloat(1).tag(sync=True)
height = trait.CFloat(1).tag(sync=True)
depth = trait.CFloat(1).tag(sync=True)
class VolumeRendererThree(widgets.DOMWidget):
"""Widget class representing a volume (rendering) using three.js"""
_view_name = Unicode('VolumeRendererThreeView').tag(sync=True)
_view_module = Unicode('ipyvolume').tag(sync=True)
_model_name = Unicode('VolumeRendererThreeModel').tag(sync=True)
_model_module = Unicode('ipyvolume').tag(sync=True)
data = Array(default_value=None,
allow_none=True).tag(sync=True,
**array_cube_png_serialization)
data_min = traitlets.CFloat().tag(sync=True)
data_max = traitlets.CFloat().tag(sync=True)
tf = traitlets.Instance(TransferFunction, allow_none=True).tag(
sync=True, **ipywidgets.widget_serialization)
angle1 = traitlets.Float(0.1).tag(sync=True)
angle2 = traitlets.Float(0.2).tag(sync=True)
scatters = traitlets.List(traitlets.Instance(Scatter), [],
allow_none=False).tag(
sync=True, **ipywidgets.widget_serialization)
animation = traitlets.Float(1000.0).tag(sync=True)
ambient_coefficient = traitlets.Float(0.5).tag(sync=True)
diffuse_coefficient = traitlets.Float(0.8).tag(sync=True)
specular_coefficient = traitlets.Float(0.5).tag(sync=True)
specular_exponent = traitlets.Float(5).tag(sync=True)
stereo = traitlets.Bool(False).tag(sync=True)
fullscreen = traitlets.Bool(False).tag(sync=True)
width = traitlets.CInt(500).tag(sync=True)
height = traitlets.CInt(400).tag(sync=True)
downscale = traitlets.CInt(1).tag(sync=True)
show = traitlets.Unicode("Volume").tag(sync=True) # for debugging
xlim = traitlets.List(traitlets.CFloat,
default_value=[0, 1],
minlen=2,
maxlen=2).tag(sync=True)
ylim = traitlets.List(traitlets.CFloat,
default_value=[0, 1],
minlen=2,
maxlen=2).tag(sync=True)
zlim = traitlets.List(traitlets.CFloat,
default_value=[0, 1],
minlen=2,
maxlen=2).tag(sync=True)
style = traitlets.Dict(default_value=default_style).tag(sync=True)
class FieldDef(BaseObject):
"""Wrapper for Vega-Lite FieldDef definition.
Attributes
----------
aggregate: AggregateOp
Aggregation function for the field .
bin: Union(Bool, Bin)
Flag for binning a `quantitative` field, or a bin property object for binning parameters.
field: Unicode
Name of the field from which to pull a data value.
timeUnit: TimeUnit
Time unit for a `temporal` field .
title: Unicode
Title for axis or legend.
type: Type
The encoded field's type of measurement.
value: Union(CFloat, Unicode, Bool)
A constant value in visual domain.
"""
aggregate = AggregateOp(allow_none=True, default_value=None, help="""Aggregation function for the field .""")
bin = T.Union([T.Bool(allow_none=True, default_value=None), T.Instance(Bin, allow_none=True, default_value=None)])
field = T.Unicode(allow_none=True, default_value=None, help="""Name of the field from which to pull a data value.""")
timeUnit = TimeUnit(allow_none=True, default_value=None, help="""Time unit for a `temporal` field .""")
title = T.Unicode(allow_none=True, default_value=None, help="""Title for axis or legend.""")
type = Type(allow_none=True, default_value=None, help="""The encoded field's type of measurement.""")
value = T.Union([T.CFloat(allow_none=True, default_value=None), T.Unicode(allow_none=True, default_value=None), T.Bool(allow_none=True, default_value=None)])
def __init__(self, aggregate=None, bin=None, field=None, timeUnit=None, title=None, type=None, value=None, **kwargs):
kwds = dict(aggregate=aggregate, bin=bin, field=field, timeUnit=timeUnit, title=title, type=type, value=value)
kwargs.update({k:v for k, v in kwds.items() if v is not None})
super(FieldDef, self).__init__(**kwargs)
class DirectTile(StrictHasTraits, object):
name = traitlets.Bytes()
urltemplate = traitlets.Bytes()
opacity = traitlets.CFloat(max=1.0, min=0.0, default_value=1.0)
@property
def storage_key(self):
return self.name
@ndb.tasklet
def render_async(self, tile):
tile_url = self.urltemplate.format(**tile)
context = ndb.get_context()
result = yield context.urlfetch(tile_url)
if result.status_code != 200:
logging.error("error fetching: %r result: %s", tile_url, result)
raise ValueError("error fetching: %r result: %s" %
(tile_url, result))
raise ndb.Return(
Image.open(io.BytesIO(result.content)).convert("RGBA"))
def render(self, tile):
tile_url = self.urltemplate.format(**tile)
result = requests.get(tile_url)
if result.status_code != 200:
logging.error("error fetching: %r result: %s", tile_url, result)
raise ValueError("error fetching: %r result: %s" %
(tile_url, result))
return Image.open(io.BytesIO(result.content)).convert("RGBA")
class OneOfFilter(BaseObject):
"""Wrapper for Vega-Lite OneOfFilter definition.
Attributes
----------
field: Unicode
Field to be filtered.
oneOf: List(Union(Unicode, CFloat, Bool, DateTime))
A set of values that the `field`'s value should be a member of, for a data item included in the filtered data.
timeUnit: TimeUnit
time unit for the field to be filtered.
"""
field = T.Unicode(allow_none=True,
default_value=None,
help="""Field to be filtered.""")
oneOf = T.List(
T.Union([
T.Unicode(allow_none=True, default_value=None),
T.CFloat(allow_none=True, default_value=None),
T.Bool(allow_none=True, default_value=None),
T.Instance(DateTime, allow_none=True, default_value=None)
]),
allow_none=True,
default_value=None,
help=
"""A set of values that the `field`'s value should be a member of, for a data item included in the filtered data."""
)
timeUnit = TimeUnit(allow_none=True,
default_value=None,
help="""time unit for the field to be filtered.""")
def __init__(self, field=None, oneOf=None, timeUnit=None, **kwargs):
kwds = dict(field=field, oneOf=oneOf, timeUnit=timeUnit)
kwargs.update({k: v for k, v in kwds.items() if v is not None})
super(OneOfFilter, self).__init__(**kwargs)
class SceneData(traitlets.HasTraits):
"""A class that defines a collection of GPU-managed data.
This class contains the largest common set of features that can be used
OpenGL rendering: a set of vertices and a set of vertex attributes. Note
that this is distinct from the shader, which can be swapped out and
provided with these items.
"""
name = traitlets.Unicode()
vertex_array = traitlets.Instance(VertexArray)
textures = traitlets.List(trait=traitlets.Instance(Texture))
min_val = traitlets.CFloat(0.0)
max_val = traitlets.CFloat(1.0)
class RangeFilter(BaseObject):
"""Wrapper for Vega-Lite RangeFilter definition.
Attributes
----------
field: Unicode
Field to be filtered.
range: List(Union(CFloat, DateTime))
Array of inclusive minimum and maximum values for a field value of a data item to be included in the filtered data.
timeUnit: TimeUnit
time unit for the field to be filtered.
"""
field = T.Unicode(allow_none=True,
default_value=None,
help="""Field to be filtered.""")
range = T.List(
T.Union([
T.CFloat(allow_none=True, default_value=None),
T.Instance(DateTime, allow_none=True, default_value=None)
]),
allow_none=True,
default_value=None,
maxlen=2,
minlen=2,
help=
"""Array of inclusive minimum and maximum values for a field value of a data item to be included in the filtered data."""
)
timeUnit = TimeUnit(allow_none=True,
default_value=None,
help="""time unit for the field to be filtered.""")
def __init__(self, field=None, range=None, timeUnit=None, **kwargs):
kwds = dict(field=field, range=range, timeUnit=timeUnit)
kwargs.update({k: v for k, v in kwds.items() if v is not None})
super(RangeFilter, self).__init__(**kwargs)
class LonLatInput(widgets.Text):
"""
Input for entering lon, lat as comma-separated string
Link to ``model``, not ``value``! ``model`` is the 2-list of floats,
``value`` is the displayed string value.
Use ``model_is_latlon`` to reverse the order between the ``model`` and the ``value``.
"""
model = traitlets.List(traitlets.CFloat(),
default_value=(0.0, 0.0),
minlen=2,
maxlen=2)
model_is_latlon = traitlets.Bool(False)
description = traitlets.Unicode("Lat, lon (WGS84):").tag(sync=True)
continuous_update = traitlets.Bool(False).tag(sync=True)
@traitlets.observe("value")
def _sync_view_to_model(self, change):
new = change["new"]
values = [part.strip() for part in new.split(",")]
if self.model_is_latlon:
values.reverse()
self.model = values
@traitlets.observe("model")
def _sync_model_to_view(self, change):
new = change["new"]
string = "{:.4f}, {:.4f}".format(
# https://xkcd.com/2170/
*(reversed(new) if self.model_is_latlon else new))
self.value = string
class Gimbal(GeometricObject):
""" a gimbal object pointing to basis vectors
default: a red, b green, c orange,
Examples
--------
>>> gimbal = Gimbal()
>>> gimbal.position
(0.0, 0.0, 0.0)
>>> gimbal.a
(1.0, 0.0, 0.0)
>>> gimbal.a_color
'red'
>>> try:
... gimbal.linewidth = ''
... except:
... print('not valid')
not valid
"""
a = Vector3(default_value=(1, 0, 0), help='vector a').tag(sync=True)
b = Vector3(default_value=(0, 1, 0), help='vector b').tag(sync=True)
c = Vector3(default_value=(0, 0, 1), help='vector c').tag(sync=True)
a_color = Color('red').tag(sync=True)
b_color = Color('green').tag(sync=True)
c_color = Color('orange').tag(sync=True)
linewidth = trait.CFloat(1, min=0.0).tag(sync=True)
class ImageOutput(Output):
"""Output an image in RAM
Attributes
----------
format : TYPE
Description
image : TYPE
Description
vmax : TYPE
Description
vmin : TYPE
Description
"""
format = tl.CaselessStrEnum(values=['png'],
default_value='png').tag(attr=True)
mode = tl.Unicode(default_value="image").tag(attr=True)
vmin = tl.CFloat(allow_none=True, default_value=np.nan).tag(attr=True)
vmax = tl.CFloat(allow_none=True, default_value=np.nan).tag(attr=True)
image = tl.Bytes(allow_none=True, default_value=None)
def __init__(self,
node,
name,
format=None,
mode=None,
vmin=None,
vmax=None):
kwargs = {}
if format is not None:
kwargs['format'] = format
if mode is not None:
kwargs['mode'] = mode
if vmin is not None:
kwargs['vmin'] = vmin
if vmax is not None:
kwargs['vmax'] = vmax
super(ImageOutput, self).__init__(node=node, name=name, **kwargs)
# TODO: docstring?
def write(self, output, coordinates):
self.image = get_image(output,
format=self.format,
vmin=self.vmin,
vmax=self.vmax)
class TransferFunctionJsBumps(TransferFunction):
_model_name = Unicode('TransferFunctionJsBumpsModel').tag(sync=True)
_model_module = Unicode('ipyvolume').tag(sync=True)
levels = traitlets.List(traitlets.CFloat(),
default_value=[0.1, 0.5, 0.8]).tag(sync=True)
opacities = traitlets.List(traitlets.CFloat(),
default_value=[0.01, 0.05, 0.1]).tag(sync=True)
widths = traitlets.List(traitlets.CFloat(),
default_value=[0.1, 0.1, 0.1]).tag(sync=True)
def control(self, max_opacity=0.2):
return ipywidgets.VBox()
l1 = ipywidgets.FloatSlider(min=0,
max=1,
step=0.001,
value=self.level1)
l2 = ipywidgets.FloatSlider(min=0,
max=1,
step=0.001,
value=self.level2)
l3 = ipywidgets.FloatSlider(min=0,
max=1,
step=0.001,
value=self.level3)
o1 = ipywidgets.FloatSlider(min=0,
max=max_opacity,
step=0.001,
value=self.opacity1)
o2 = ipywidgets.FloatSlider(min=0,
max=max_opacity,
step=0.001,
value=self.opacity2)
o3 = ipywidgets.FloatSlider(min=0,
max=max_opacity,
step=0.001,
value=self.opacity2)
ipywidgets.jslink((self, 'level1'), (l1, 'value'))
ipywidgets.jslink((self, 'level2'), (l2, 'value'))
ipywidgets.jslink((self, 'level3'), (l3, 'value'))
ipywidgets.jslink((self, 'opacity1'), (o1, 'value'))
ipywidgets.jslink((self, 'opacity2'), (o2, 'value'))
ipywidgets.jslink((self, 'opacity3'), (o3, 'value'))
return ipywidgets.VBox([
ipywidgets.HBox([ipywidgets.Label(value="levels:"), l1, l2, l3]),
ipywidgets.HBox([ipywidgets.Label(value="opacities:"), o1, o2, o3])
])
class Figure(widgets.DOMWidget):
"""Widget class representing a volume (rendering) using three.js"""
_view_name = Unicode('FigureView').tag(sync=True)
_view_module = Unicode('ipyvolume').tag(sync=True)
_model_name = Unicode('FigureModel').tag(sync=True)
_model_module = Unicode('ipyvolume').tag(sync=True)
volume_data = Array(default_value=None, allow_none=True).tag(sync=True, **create_array_cube_png_serialization('volume_data'))
data_min = traitlets.CFloat().tag(sync=True)
data_max = traitlets.CFloat().tag(sync=True)
tf = traitlets.Instance(TransferFunction, allow_none=True).tag(sync=True, **ipywidgets.widget_serialization)
angle1 = traitlets.Float(0.1).tag(sync=True)
angle2 = traitlets.Float(0.2).tag(sync=True)
scatters = traitlets.List(traitlets.Instance(Scatter), [], allow_none=False).tag(sync=True, **ipywidgets.widget_serialization)
animation = traitlets.Float(1000.0).tag(sync=True)
animation_exponent = traitlets.Float(.5).tag(sync=True)
ambient_coefficient = traitlets.Float(0.5).tag(sync=True)
diffuse_coefficient = traitlets.Float(0.8).tag(sync=True)
specular_coefficient = traitlets.Float(0.5).tag(sync=True)
specular_exponent = traitlets.Float(5).tag(sync=True)
stereo = traitlets.Bool(False).tag(sync=True)
screen_capture_enabled = traitlets.Bool(False).tag(sync=True)
screen_capture_mime_type = traitlets.Unicode(default_value='image/png').tag(sync=True)
screen_capture_data = traitlets.Unicode(default_value=None, allow_none=True).tag(sync=True)
fullscreen = traitlets.Bool(False).tag(sync=True)
camera_control = traitlets.Unicode(default_value='trackball').tag(sync=True)
width = traitlets.CInt(500).tag(sync=True)
height = traitlets.CInt(400).tag(sync=True)
downscale = traitlets.CInt(1).tag(sync=True)
show = traitlets.Unicode("Volume").tag(sync=True) # for debugging
xlim = traitlets.List(traitlets.CFloat, default_value=[0, 1], minlen=2, maxlen=2).tag(sync=True)
ylim = traitlets.List(traitlets.CFloat, default_value=[0, 1], minlen=2, maxlen=2).tag(sync=True)
zlim = traitlets.List(traitlets.CFloat, default_value=[0, 1], minlen=2, maxlen=2).tag(sync=True)
xlabel = traitlets.Unicode("x").tag(sync=True)
ylabel = traitlets.Unicode("y").tag(sync=True)
zlabel = traitlets.Unicode("z").tag(sync=True)
style = traitlets.Dict(default_value=ipyvolume.style.default).tag(sync=True)
class MaxAbsScaler(Transformer):
''' Scale features by their maximum absolute value.
Example:
>>> import vaex
>>> df = vaex.from_arrays(x=[2,5,7,2,15], y=[-2,3,0,0,10])
>>> df
# x y
0 2 -2
1 5 3
2 7 0
3 2 0
4 15 10
>>> scaler = vaex.ml.MaxAbsScaler(features=['x', 'y'])
>>> scaler.fit_transform(df)
# x y absmax_scaled_x absmax_scaled_y
0 2 -2 0.133333 -0.2
1 5 3 0.333333 0.3
2 7 0 0.466667 0
3 2 0 0.133333 0
4 15 10 1 1
'''
prefix = traitlets.Unicode(default_value="absmax_scaled_",
help=help_prefix).tag(ui='Text')
absmax_ = traitlets.List(
traitlets.CFloat(),
help='Tha maximum absolute value of a feature.').tag(output=True)
def fit(self, df):
'''
Fit MinMaxScaler to the DataFrame.
:param df: A vaex DataFrame.
'''
absmax = df.max(['abs(%s)' % k for k in self.features]).tolist()
# Check if the absmax_ value is 0, in which case replace with 1
self.absmax_ = [value if value != 0 else 1 for value in absmax]
def transform(self, df):
'''
Transform a DataFrame with a fitted MaxAbsScaler.
:param df: A vaex DataFrame.
:return copy: a shallow copy of the DataFrame that includes the scaled features.
:rtype: DataFrame
'''
copy = df.copy()
for i, feature in enumerate(self.features):
name = self.prefix + feature
expr = copy[feature]
expr = expr / self.absmax_[i]
copy[name] = expr
return copy
class FacetCoordinate(Shelf):
# TODO: supported types for aggregate
# TODO: min and max for padding
# TODO: min for height
aggregate = T.Enum(['count'], default_value=None, allow_none=True)
padding = T.CFloat(0.1)
axis = T.Instance(Axis, default_value=None, allow_none=True)
height = T.CInt(150)
class TextAnnotation(SceneAnnotation):
name = "text_annotation"
data = traitlets.Instance(TextCharacters)
text = traitlets.CUnicode()
draw_instructions = traitlets.List()
origin = traitlets.Tuple(traitlets.CFloat(),
traitlets.CFloat(),
default_value=(-1, -1))
scale = traitlets.CFloat(1.0)
@traitlets.observe("text")
def _observe_text(self, change):
text = change["new"]
lines = text.split("\n")
draw_instructions = []
y = 0
for line in reversed(lines):
x = 0
dy = 0
for c in line:
e = self.data.characters[c]
draw_instructions.append((x, y, e.texture, e.vbo_offset))
dy = max(dy, e.vert_advance)
x += e.hori_advance
y += dy
self.draw_instructions = draw_instructions
def _set_uniforms(self, scene, shader_program):
pass
def draw(self, scene, program):
viewport = np.array(GL.glGetIntegerv(GL.GL_VIEWPORT), dtype="f4")
program._set_uniform("viewport", viewport)
each = self.data.vertex_array.each
for x, y, tex, vbo_offset in self.draw_instructions:
with tex.bind(0):
program._set_uniform("x_offset", float(x))
program._set_uniform("y_offset", float(y))
program._set_uniform("x_origin", self.origin[0])
program._set_uniform("y_origin", self.origin[1])
program._set_uniform("scale", self.scale)
GL.glDrawArrays(GL.GL_TRIANGLES, vbo_offset * each, each)
class VizBase2dState(VizBaseState):
x_expression = traitlets.Unicode()
y_expression = traitlets.Unicode()
x_slice = traitlets.CInt(None, allow_none=True)
y_slice = traitlets.CInt(None, allow_none=True)
type = traitlets.CaselessStrEnum(['count', 'min', 'max', 'mean'],
default_value='count')
aux = traitlets.Unicode(None, allow_none=True)
groupby = traitlets.Unicode(None, allow_none=True)
x_shape = traitlets.CInt(None, allow_none=True)
y_shape = traitlets.CInt(None, allow_none=True)
x_min = traitlets.CFloat()
x_max = traitlets.CFloat()
y_min = traitlets.CFloat()
y_max = traitlets.CFloat()
def __init__(self, ds, **kwargs):
super(VizBase2dState, self).__init__(ds, **kwargs)
self.observe(lambda x: self.calculate_limits(),
['x_expression', 'y_expression', 'type', 'aux'])
self.observe(lambda x: self.signal_slice.emit(self),
['x_slice', 'y_slice'])
# no need for recompute
#self.observe(lambda x: self.calculate_grid(), ['groupby', 'shape', 'groupby_normalize'])
self.observe(self.limits_changed, ['x_min', 'x_max', 'y_min', 'y_max'])
self.calculate_limits()
def bin_parameters(self):
yield self.x_expression, self.x_shape or self.shape, (
self.x_min, self.x_max), self.x_slice
yield self.y_expression, self.y_shape or self.shape, (
self.y_min, self.y_max), self.y_slice
def calculate_limits(self):
self._calculate_limits('x', 'x_expression')
self._calculate_limits('y', 'y_expression')
self.signal_regrid.emit(self)
def limits_changed(self, change):
self._calculate_centers()
self.signal_regrid.emit(self)
class FacetGridConfig(BaseObject):
"""Wrapper for Vega-Lite FacetGridConfig definition.
Attributes
----------
color: Unicode
offset: CFloat
opacity: CFloat
"""
color = T.Unicode(allow_none=True, default_value=None)
offset = T.CFloat(allow_none=True, default_value=None)
opacity = T.CFloat(allow_none=True, default_value=None)
def __init__(self, color=None, offset=None, opacity=None, **kwargs):
kwds = dict(color=color, offset=offset, opacity=opacity)
kwargs.update({k: v for k, v in kwds.items() if v is not None})
super(FacetGridConfig, self).__init__(**kwargs)
class Scale(T.HasTraits):
name = T.Unicode('')
type = T.Unicode('')
domain = T.Union([T.List, T.Tuple])
domainMax = T.CFloat()
domainMin = T.CFloat()
domainMid = T.CFloat()
domainRaw = T.Union([T.List, T.Tuple])
range = T.Union([
T.List, T.Tuple,
T.Enum([
'width', 'height', 'symbol', 'category', 'diverging', 'ordinal',
'ramp', 'heatmap'
])
])
reverse = T.Bool()
round = T.Bool()
def __call__(self, *args, **kwargs):
raise NotImplementedError(
'Scale operation not implemented, use a subclass.')
class UnitSpec(BaseObject):
"""Wrapper for Vega-Lite UnitSpec definition.
Attributes
----------
config: Config
Configuration object.
data: Data
An object describing the data source.
description: Unicode
An optional description of this mark for commenting purpose.
encoding: UnitEncoding
A key-value mapping between encoding channels and definition of fields.
height: CFloat
mark: Mark
The mark type.
name: Unicode
Name of the visualization for later reference.
transform: Transform
An object describing filter and new field calculation.
width: CFloat
"""
config = T.Instance(Config, allow_none=True, default_value=None, help="""Configuration object.""")
data = T.Instance(Data, allow_none=True, default_value=None, help="""An object describing the data source.""")
description = T.Unicode(allow_none=True, default_value=None, help="""An optional description of this mark for commenting purpose.""")
encoding = T.Instance(UnitEncoding, allow_none=True, default_value=None, help="""A key-value mapping between encoding channels and definition of fields.""")
height = T.CFloat(allow_none=True, default_value=None)
mark = Mark(allow_none=True, default_value=None, help="""The mark type.""")
name = T.Unicode(allow_none=True, default_value=None, help="""Name of the visualization for later reference.""")
transform = T.Instance(Transform, allow_none=True, default_value=None, help="""An object describing filter and new field calculation.""")
width = T.CFloat(allow_none=True, default_value=None)
def __init__(self, config=None, data=None, description=None, encoding=None, height=None, mark=None, name=None, transform=None, width=None, **kwargs):
kwds = dict(config=config, data=data, description=description, encoding=encoding, height=height, mark=mark, name=name, transform=transform, width=width)
kwargs.update({k:v for k, v in kwds.items() if v is not None})
super(UnitSpec, self).__init__(**kwargs)
class Bus(t.HasTraits):
'''Bus Model'''
name = t.CUnicode(default_value='Bus1', help='Name of Generator (str)')
bus_type = t.Enum(
values=['SWING', 'PQ', 'PV'],
default_value='PQ',
help='Bus type',
)
real_power_demand = tt.Array(default_value=[0.0],
minlen=1,
help='Active power demand (MW)')
imag_power_demand = tt.Array(default_value=[0.0],
minlen=1,
help='Reactive power demand (MVAR)')
shunt_conductance = t.CFloat(default_value=0,
help='Shunt Conductance (TODO: units)')
shunt_susceptance = t.CFloat(default_value=0,
help='Shunt Susceptance (TODO: units)')
area = t.CUnicode(default_value='0', help='Area the bus is located in')
voltage_magnitude = t.CFloat(default_value=1.0,
help='Voltage magnitude (p.u.)')
voltage_angle = t.CFloat(default_value=0.0, help='Voltage angle (deg)')
base_voltage = t.CFloat(default_value=230, help='Base voltage (kV)')
zone = t.CUnicode(default_value='0', help='Zone the bus is located in')
maximum_voltage = t.CFloat(default_value=1.05, help='Maximum voltage')
minimum_voltage = t.CFloat(default_value=0.95, help='Minimum voltage')
def __init__(self, **kwargs):
v = kwargs.pop('real_power_demand', None)
v = self._coerce_value_to_list({'value': v})
kwargs['real_power_demand'] = v
v = kwargs.pop('imag_power_demand', None)
v = self._coerce_value_to_list({'value': v})
kwargs['imag_power_demand'] = v
super(Bus, self).__init__(**kwargs)
@t.validate('real_power_demand', 'imag_power_demand')
def _coerce_value_to_list(self, proposal):
v = proposal['value']
if (v is not None and (isinstance(v, int) or isinstance(v, float))):
v = [
v,
]
elif v is None:
v = [
0.0,
]
return v
class GeometricObject(IDObject):
""" a geometric object
x,y,z should represent the centre of volume
Examples
--------
>>> gobject = GeometricObject()
>>> gobject.position
(0.0, 0.0, 0.0)
"""
position = Vector3(default_value=(0, 0, 0),
help='cartesian coordinate of pivot').tag(sync=True)
visible = trait.Bool(True).tag(sync=True)
color = Color('red').tag(sync=True)
transparency = trait.CFloat(1, min=0.0, max=1.0).tag(sync=True)
label = trait.CUnicode('-').tag(sync=True).tag(sync=True)
label_visible = trait.Bool(False).tag(sync=True)
label_color = Color('red').tag(sync=True)
label_transparency = trait.CFloat(1, min=0.0, max=1.0).tag(sync=True)
