1619 lines
51 KiB
Python
1619 lines
51 KiB
Python
from plotly.basedatatypes import BaseTraceType as _BaseTraceType
|
|
import copy as _copy
|
|
|
|
|
|
class Pointcloud(_BaseTraceType):
|
|
|
|
# class properties
|
|
# --------------------
|
|
_parent_path_str = ""
|
|
_path_str = "pointcloud"
|
|
_valid_props = {
|
|
"customdata",
|
|
"customdatasrc",
|
|
"hoverinfo",
|
|
"hoverinfosrc",
|
|
"hoverlabel",
|
|
"ids",
|
|
"idssrc",
|
|
"indices",
|
|
"indicessrc",
|
|
"legend",
|
|
"legendgroup",
|
|
"legendgrouptitle",
|
|
"legendrank",
|
|
"legendwidth",
|
|
"marker",
|
|
"meta",
|
|
"metasrc",
|
|
"name",
|
|
"opacity",
|
|
"showlegend",
|
|
"stream",
|
|
"text",
|
|
"textsrc",
|
|
"type",
|
|
"uid",
|
|
"uirevision",
|
|
"visible",
|
|
"x",
|
|
"xaxis",
|
|
"xbounds",
|
|
"xboundssrc",
|
|
"xsrc",
|
|
"xy",
|
|
"xysrc",
|
|
"y",
|
|
"yaxis",
|
|
"ybounds",
|
|
"yboundssrc",
|
|
"ysrc",
|
|
}
|
|
|
|
# customdata
|
|
# ----------
|
|
@property
|
|
def customdata(self):
|
|
"""
|
|
Assigns extra data each datum. This may be useful when
|
|
listening to hover, click and selection events. Note that,
|
|
"scatter" traces also appends customdata items in the markers
|
|
DOM elements
|
|
|
|
The 'customdata' property is an array that may be specified as a tuple,
|
|
list, numpy array, or pandas Series
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray
|
|
"""
|
|
return self["customdata"]
|
|
|
|
@customdata.setter
|
|
def customdata(self, val):
|
|
self["customdata"] = val
|
|
|
|
# customdatasrc
|
|
# -------------
|
|
@property
|
|
def customdatasrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`customdata`.
|
|
|
|
The 'customdatasrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["customdatasrc"]
|
|
|
|
@customdatasrc.setter
|
|
def customdatasrc(self, val):
|
|
self["customdatasrc"] = val
|
|
|
|
# hoverinfo
|
|
# ---------
|
|
@property
|
|
def hoverinfo(self):
|
|
"""
|
|
Determines which trace information appear on hover. If `none`
|
|
or `skip` are set, no information is displayed upon hovering.
|
|
But, if `none` is set, click and hover events are still fired.
|
|
|
|
The 'hoverinfo' property is a flaglist and may be specified
|
|
as a string containing:
|
|
- Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters
|
|
(e.g. 'x+y')
|
|
OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip')
|
|
- A list or array of the above
|
|
|
|
Returns
|
|
-------
|
|
Any|numpy.ndarray
|
|
"""
|
|
return self["hoverinfo"]
|
|
|
|
@hoverinfo.setter
|
|
def hoverinfo(self, val):
|
|
self["hoverinfo"] = val
|
|
|
|
# hoverinfosrc
|
|
# ------------
|
|
@property
|
|
def hoverinfosrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`hoverinfo`.
|
|
|
|
The 'hoverinfosrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["hoverinfosrc"]
|
|
|
|
@hoverinfosrc.setter
|
|
def hoverinfosrc(self, val):
|
|
self["hoverinfosrc"] = val
|
|
|
|
# hoverlabel
|
|
# ----------
|
|
@property
|
|
def hoverlabel(self):
|
|
"""
|
|
The 'hoverlabel' property is an instance of Hoverlabel
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.pointcloud.Hoverlabel`
|
|
- A dict of string/value properties that will be passed
|
|
to the Hoverlabel constructor
|
|
|
|
Supported dict properties:
|
|
|
|
align
|
|
Sets the horizontal alignment of the text
|
|
content within hover label box. Has an effect
|
|
only if the hover label text spans more two or
|
|
more lines
|
|
alignsrc
|
|
Sets the source reference on Chart Studio Cloud
|
|
for `align`.
|
|
bgcolor
|
|
Sets the background color of the hover labels
|
|
for this trace
|
|
bgcolorsrc
|
|
Sets the source reference on Chart Studio Cloud
|
|
for `bgcolor`.
|
|
bordercolor
|
|
Sets the border color of the hover labels for
|
|
this trace.
|
|
bordercolorsrc
|
|
Sets the source reference on Chart Studio Cloud
|
|
for `bordercolor`.
|
|
font
|
|
Sets the font used in hover labels.
|
|
namelength
|
|
Sets the default length (in number of
|
|
characters) of the trace name in the hover
|
|
labels for all traces. -1 shows the whole name
|
|
regardless of length. 0-3 shows the first 0-3
|
|
characters, and an integer >3 will show the
|
|
whole name if it is less than that many
|
|
characters, but if it is longer, will truncate
|
|
to `namelength - 3` characters and add an
|
|
ellipsis.
|
|
namelengthsrc
|
|
Sets the source reference on Chart Studio Cloud
|
|
for `namelength`.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.pointcloud.Hoverlabel
|
|
"""
|
|
return self["hoverlabel"]
|
|
|
|
@hoverlabel.setter
|
|
def hoverlabel(self, val):
|
|
self["hoverlabel"] = val
|
|
|
|
# ids
|
|
# ---
|
|
@property
|
|
def ids(self):
|
|
"""
|
|
Assigns id labels to each datum. These ids for object constancy
|
|
of data points during animation. Should be an array of strings,
|
|
not numbers or any other type.
|
|
|
|
The 'ids' property is an array that may be specified as a tuple,
|
|
list, numpy array, or pandas Series
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray
|
|
"""
|
|
return self["ids"]
|
|
|
|
@ids.setter
|
|
def ids(self, val):
|
|
self["ids"] = val
|
|
|
|
# idssrc
|
|
# ------
|
|
@property
|
|
def idssrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for `ids`.
|
|
|
|
The 'idssrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["idssrc"]
|
|
|
|
@idssrc.setter
|
|
def idssrc(self, val):
|
|
self["idssrc"] = val
|
|
|
|
# indices
|
|
# -------
|
|
@property
|
|
def indices(self):
|
|
"""
|
|
A sequential value, 0..n, supply it to avoid creating this
|
|
array inside plotting. If specified, it must be a typed
|
|
`Int32Array` array. Its length must be equal to or greater than
|
|
the number of points. For the best performance and memory use,
|
|
create one large `indices` typed array that is guaranteed to be
|
|
at least as long as the largest number of points during use,
|
|
and reuse it on each `Plotly.restyle()` call.
|
|
|
|
The 'indices' property is an array that may be specified as a tuple,
|
|
list, numpy array, or pandas Series
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray
|
|
"""
|
|
return self["indices"]
|
|
|
|
@indices.setter
|
|
def indices(self, val):
|
|
self["indices"] = val
|
|
|
|
# indicessrc
|
|
# ----------
|
|
@property
|
|
def indicessrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for `indices`.
|
|
|
|
The 'indicessrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["indicessrc"]
|
|
|
|
@indicessrc.setter
|
|
def indicessrc(self, val):
|
|
self["indicessrc"] = val
|
|
|
|
# legend
|
|
# ------
|
|
@property
|
|
def legend(self):
|
|
"""
|
|
Sets the reference to a legend to show this trace in.
|
|
References to these legends are "legend", "legend2", "legend3",
|
|
etc. Settings for these legends are set in the layout, under
|
|
`layout.legend`, `layout.legend2`, etc.
|
|
|
|
The 'legend' property is an identifier of a particular
|
|
subplot, of type 'legend', that may be specified as the string 'legend'
|
|
optionally followed by an integer >= 1
|
|
(e.g. 'legend', 'legend1', 'legend2', 'legend3', etc.)
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["legend"]
|
|
|
|
@legend.setter
|
|
def legend(self, val):
|
|
self["legend"] = val
|
|
|
|
# legendgroup
|
|
# -----------
|
|
@property
|
|
def legendgroup(self):
|
|
"""
|
|
Sets the legend group for this trace. Traces and shapes part of
|
|
the same legend group hide/show at the same time when toggling
|
|
legend items.
|
|
|
|
The 'legendgroup' property is a string and must be specified as:
|
|
- A string
|
|
- A number that will be converted to a string
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["legendgroup"]
|
|
|
|
@legendgroup.setter
|
|
def legendgroup(self, val):
|
|
self["legendgroup"] = val
|
|
|
|
# legendgrouptitle
|
|
# ----------------
|
|
@property
|
|
def legendgrouptitle(self):
|
|
"""
|
|
The 'legendgrouptitle' property is an instance of Legendgrouptitle
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.pointcloud.Legendgrouptitle`
|
|
- A dict of string/value properties that will be passed
|
|
to the Legendgrouptitle constructor
|
|
|
|
Supported dict properties:
|
|
|
|
font
|
|
Sets this legend group's title font.
|
|
text
|
|
Sets the title of the legend group.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.pointcloud.Legendgrouptitle
|
|
"""
|
|
return self["legendgrouptitle"]
|
|
|
|
@legendgrouptitle.setter
|
|
def legendgrouptitle(self, val):
|
|
self["legendgrouptitle"] = val
|
|
|
|
# legendrank
|
|
# ----------
|
|
@property
|
|
def legendrank(self):
|
|
"""
|
|
Sets the legend rank for this trace. Items and groups with
|
|
smaller ranks are presented on top/left side while with
|
|
"reversed" `legend.traceorder` they are on bottom/right side.
|
|
The default legendrank is 1000, so that you can use ranks less
|
|
than 1000 to place certain items before all unranked items, and
|
|
ranks greater than 1000 to go after all unranked items. When
|
|
having unranked or equal rank items shapes would be displayed
|
|
after traces i.e. according to their order in data and layout.
|
|
|
|
The 'legendrank' property is a number and may be specified as:
|
|
- An int or float
|
|
|
|
Returns
|
|
-------
|
|
int|float
|
|
"""
|
|
return self["legendrank"]
|
|
|
|
@legendrank.setter
|
|
def legendrank(self, val):
|
|
self["legendrank"] = val
|
|
|
|
# legendwidth
|
|
# -----------
|
|
@property
|
|
def legendwidth(self):
|
|
"""
|
|
Sets the width (in px or fraction) of the legend for this
|
|
trace.
|
|
|
|
The 'legendwidth' property is a number and may be specified as:
|
|
- An int or float in the interval [0, inf]
|
|
|
|
Returns
|
|
-------
|
|
int|float
|
|
"""
|
|
return self["legendwidth"]
|
|
|
|
@legendwidth.setter
|
|
def legendwidth(self, val):
|
|
self["legendwidth"] = val
|
|
|
|
# marker
|
|
# ------
|
|
@property
|
|
def marker(self):
|
|
"""
|
|
The 'marker' property is an instance of Marker
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.pointcloud.Marker`
|
|
- A dict of string/value properties that will be passed
|
|
to the Marker constructor
|
|
|
|
Supported dict properties:
|
|
|
|
blend
|
|
Determines if colors are blended together for a
|
|
translucency effect in case `opacity` is
|
|
specified as a value less then `1`. Setting
|
|
`blend` to `true` reduces zoom/pan speed if
|
|
used with large numbers of points.
|
|
border
|
|
:class:`plotly.graph_objects.pointcloud.marker.
|
|
Border` instance or dict with compatible
|
|
properties
|
|
color
|
|
Sets the marker fill color. It accepts a
|
|
specific color. If the color is not fully
|
|
opaque and there are hundreds of thousands of
|
|
points, it may cause slower zooming and
|
|
panning.
|
|
opacity
|
|
Sets the marker opacity. The default value is
|
|
`1` (fully opaque). If the markers are not
|
|
fully opaque and there are hundreds of
|
|
thousands of points, it may cause slower
|
|
zooming and panning. Opacity fades the color
|
|
even if `blend` is left on `false` even if
|
|
there is no translucency effect in that case.
|
|
sizemax
|
|
Sets the maximum size (in px) of the rendered
|
|
marker points. Effective when the `pointcloud`
|
|
shows only few points.
|
|
sizemin
|
|
Sets the minimum size (in px) of the rendered
|
|
marker points, effective when the `pointcloud`
|
|
shows a million or more points.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.pointcloud.Marker
|
|
"""
|
|
return self["marker"]
|
|
|
|
@marker.setter
|
|
def marker(self, val):
|
|
self["marker"] = val
|
|
|
|
# meta
|
|
# ----
|
|
@property
|
|
def meta(self):
|
|
"""
|
|
Assigns extra meta information associated with this trace that
|
|
can be used in various text attributes. Attributes such as
|
|
trace `name`, graph, axis and colorbar `title.text`, annotation
|
|
`text` `rangeselector`, `updatemenues` and `sliders` `label`
|
|
text all support `meta`. To access the trace `meta` values in
|
|
an attribute in the same trace, simply use `%{meta[i]}` where
|
|
`i` is the index or key of the `meta` item in question. To
|
|
access trace `meta` in layout attributes, use
|
|
`%{data[n[.meta[i]}` where `i` is the index or key of the
|
|
`meta` and `n` is the trace index.
|
|
|
|
The 'meta' property accepts values of any type
|
|
|
|
Returns
|
|
-------
|
|
Any|numpy.ndarray
|
|
"""
|
|
return self["meta"]
|
|
|
|
@meta.setter
|
|
def meta(self, val):
|
|
self["meta"] = val
|
|
|
|
# metasrc
|
|
# -------
|
|
@property
|
|
def metasrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for `meta`.
|
|
|
|
The 'metasrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["metasrc"]
|
|
|
|
@metasrc.setter
|
|
def metasrc(self, val):
|
|
self["metasrc"] = val
|
|
|
|
# name
|
|
# ----
|
|
@property
|
|
def name(self):
|
|
"""
|
|
Sets the trace name. The trace name appears as the legend item
|
|
and on hover.
|
|
|
|
The 'name' property is a string and must be specified as:
|
|
- A string
|
|
- A number that will be converted to a string
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["name"]
|
|
|
|
@name.setter
|
|
def name(self, val):
|
|
self["name"] = val
|
|
|
|
# opacity
|
|
# -------
|
|
@property
|
|
def opacity(self):
|
|
"""
|
|
Sets the opacity of the trace.
|
|
|
|
The 'opacity' property is a number and may be specified as:
|
|
- An int or float in the interval [0, 1]
|
|
|
|
Returns
|
|
-------
|
|
int|float
|
|
"""
|
|
return self["opacity"]
|
|
|
|
@opacity.setter
|
|
def opacity(self, val):
|
|
self["opacity"] = val
|
|
|
|
# showlegend
|
|
# ----------
|
|
@property
|
|
def showlegend(self):
|
|
"""
|
|
Determines whether or not an item corresponding to this trace
|
|
is shown in the legend.
|
|
|
|
The 'showlegend' property must be specified as a bool
|
|
(either True, or False)
|
|
|
|
Returns
|
|
-------
|
|
bool
|
|
"""
|
|
return self["showlegend"]
|
|
|
|
@showlegend.setter
|
|
def showlegend(self, val):
|
|
self["showlegend"] = val
|
|
|
|
# stream
|
|
# ------
|
|
@property
|
|
def stream(self):
|
|
"""
|
|
The 'stream' property is an instance of Stream
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.pointcloud.Stream`
|
|
- A dict of string/value properties that will be passed
|
|
to the Stream constructor
|
|
|
|
Supported dict properties:
|
|
|
|
maxpoints
|
|
Sets the maximum number of points to keep on
|
|
the plots from an incoming stream. If
|
|
`maxpoints` is set to 50, only the newest 50
|
|
points will be displayed on the plot.
|
|
token
|
|
The stream id number links a data trace on a
|
|
plot with a stream. See https://chart-
|
|
studio.plotly.com/settings for more details.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.pointcloud.Stream
|
|
"""
|
|
return self["stream"]
|
|
|
|
@stream.setter
|
|
def stream(self, val):
|
|
self["stream"] = val
|
|
|
|
# text
|
|
# ----
|
|
@property
|
|
def text(self):
|
|
"""
|
|
Sets text elements associated with each (x,y) pair. If a single
|
|
string, the same string appears over all the data points. If an
|
|
array of string, the items are mapped in order to the this
|
|
trace's (x,y) coordinates. If trace `hoverinfo` contains a
|
|
"text" flag and "hovertext" is not set, these elements will be
|
|
seen in the hover labels.
|
|
|
|
The 'text' property is a string and must be specified as:
|
|
- A string
|
|
- A number that will be converted to a string
|
|
- A tuple, list, or one-dimensional numpy array of the above
|
|
|
|
Returns
|
|
-------
|
|
str|numpy.ndarray
|
|
"""
|
|
return self["text"]
|
|
|
|
@text.setter
|
|
def text(self, val):
|
|
self["text"] = val
|
|
|
|
# textsrc
|
|
# -------
|
|
@property
|
|
def textsrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for `text`.
|
|
|
|
The 'textsrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["textsrc"]
|
|
|
|
@textsrc.setter
|
|
def textsrc(self, val):
|
|
self["textsrc"] = val
|
|
|
|
# uid
|
|
# ---
|
|
@property
|
|
def uid(self):
|
|
"""
|
|
Assign an id to this trace, Use this to provide object
|
|
constancy between traces during animations and transitions.
|
|
|
|
The 'uid' property is a string and must be specified as:
|
|
- A string
|
|
- A number that will be converted to a string
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["uid"]
|
|
|
|
@uid.setter
|
|
def uid(self, val):
|
|
self["uid"] = val
|
|
|
|
# uirevision
|
|
# ----------
|
|
@property
|
|
def uirevision(self):
|
|
"""
|
|
Controls persistence of some user-driven changes to the trace:
|
|
`constraintrange` in `parcoords` traces, as well as some
|
|
`editable: true` modifications such as `name` and
|
|
`colorbar.title`. Defaults to `layout.uirevision`. Note that
|
|
other user-driven trace attribute changes are controlled by
|
|
`layout` attributes: `trace.visible` is controlled by
|
|
`layout.legend.uirevision`, `selectedpoints` is controlled by
|
|
`layout.selectionrevision`, and `colorbar.(x|y)` (accessible
|
|
with `config: {editable: true}`) is controlled by
|
|
`layout.editrevision`. Trace changes are tracked by `uid`,
|
|
which only falls back on trace index if no `uid` is provided.
|
|
So if your app can add/remove traces before the end of the
|
|
`data` array, such that the same trace has a different index,
|
|
you can still preserve user-driven changes if you give each
|
|
trace a `uid` that stays with it as it moves.
|
|
|
|
The 'uirevision' property accepts values of any type
|
|
|
|
Returns
|
|
-------
|
|
Any
|
|
"""
|
|
return self["uirevision"]
|
|
|
|
@uirevision.setter
|
|
def uirevision(self, val):
|
|
self["uirevision"] = val
|
|
|
|
# visible
|
|
# -------
|
|
@property
|
|
def visible(self):
|
|
"""
|
|
Determines whether or not this trace is visible. If
|
|
"legendonly", the trace is not drawn, but can appear as a
|
|
legend item (provided that the legend itself is visible).
|
|
|
|
The 'visible' property is an enumeration that may be specified as:
|
|
- One of the following enumeration values:
|
|
[True, False, 'legendonly']
|
|
|
|
Returns
|
|
-------
|
|
Any
|
|
"""
|
|
return self["visible"]
|
|
|
|
@visible.setter
|
|
def visible(self, val):
|
|
self["visible"] = val
|
|
|
|
# x
|
|
# -
|
|
@property
|
|
def x(self):
|
|
"""
|
|
Sets the x coordinates.
|
|
|
|
The 'x' property is an array that may be specified as a tuple,
|
|
list, numpy array, or pandas Series
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray
|
|
"""
|
|
return self["x"]
|
|
|
|
@x.setter
|
|
def x(self, val):
|
|
self["x"] = val
|
|
|
|
# xaxis
|
|
# -----
|
|
@property
|
|
def xaxis(self):
|
|
"""
|
|
Sets a reference between this trace's x coordinates and a 2D
|
|
cartesian x axis. If "x" (the default value), the x coordinates
|
|
refer to `layout.xaxis`. If "x2", the x coordinates refer to
|
|
`layout.xaxis2`, and so on.
|
|
|
|
The 'xaxis' property is an identifier of a particular
|
|
subplot, of type 'x', that may be specified as the string 'x'
|
|
optionally followed by an integer >= 1
|
|
(e.g. 'x', 'x1', 'x2', 'x3', etc.)
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["xaxis"]
|
|
|
|
@xaxis.setter
|
|
def xaxis(self, val):
|
|
self["xaxis"] = val
|
|
|
|
# xbounds
|
|
# -------
|
|
@property
|
|
def xbounds(self):
|
|
"""
|
|
Specify `xbounds` in the shape of `[xMin, xMax] to avoid
|
|
looping through the `xy` typed array. Use it in conjunction
|
|
with `xy` and `ybounds` for the performance benefits.
|
|
|
|
The 'xbounds' property is an array that may be specified as a tuple,
|
|
list, numpy array, or pandas Series
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray
|
|
"""
|
|
return self["xbounds"]
|
|
|
|
@xbounds.setter
|
|
def xbounds(self, val):
|
|
self["xbounds"] = val
|
|
|
|
# xboundssrc
|
|
# ----------
|
|
@property
|
|
def xboundssrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for `xbounds`.
|
|
|
|
The 'xboundssrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["xboundssrc"]
|
|
|
|
@xboundssrc.setter
|
|
def xboundssrc(self, val):
|
|
self["xboundssrc"] = val
|
|
|
|
# xsrc
|
|
# ----
|
|
@property
|
|
def xsrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for `x`.
|
|
|
|
The 'xsrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["xsrc"]
|
|
|
|
@xsrc.setter
|
|
def xsrc(self, val):
|
|
self["xsrc"] = val
|
|
|
|
# xy
|
|
# --
|
|
@property
|
|
def xy(self):
|
|
"""
|
|
Faster alternative to specifying `x` and `y` separately. If
|
|
supplied, it must be a typed `Float32Array` array that
|
|
represents points such that `xy[i * 2] = x[i]` and `xy[i * 2 +
|
|
1] = y[i]`
|
|
|
|
The 'xy' property is an array that may be specified as a tuple,
|
|
list, numpy array, or pandas Series
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray
|
|
"""
|
|
return self["xy"]
|
|
|
|
@xy.setter
|
|
def xy(self, val):
|
|
self["xy"] = val
|
|
|
|
# xysrc
|
|
# -----
|
|
@property
|
|
def xysrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for `xy`.
|
|
|
|
The 'xysrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["xysrc"]
|
|
|
|
@xysrc.setter
|
|
def xysrc(self, val):
|
|
self["xysrc"] = val
|
|
|
|
# y
|
|
# -
|
|
@property
|
|
def y(self):
|
|
"""
|
|
Sets the y coordinates.
|
|
|
|
The 'y' property is an array that may be specified as a tuple,
|
|
list, numpy array, or pandas Series
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray
|
|
"""
|
|
return self["y"]
|
|
|
|
@y.setter
|
|
def y(self, val):
|
|
self["y"] = val
|
|
|
|
# yaxis
|
|
# -----
|
|
@property
|
|
def yaxis(self):
|
|
"""
|
|
Sets a reference between this trace's y coordinates and a 2D
|
|
cartesian y axis. If "y" (the default value), the y coordinates
|
|
refer to `layout.yaxis`. If "y2", the y coordinates refer to
|
|
`layout.yaxis2`, and so on.
|
|
|
|
The 'yaxis' property is an identifier of a particular
|
|
subplot, of type 'y', that may be specified as the string 'y'
|
|
optionally followed by an integer >= 1
|
|
(e.g. 'y', 'y1', 'y2', 'y3', etc.)
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["yaxis"]
|
|
|
|
@yaxis.setter
|
|
def yaxis(self, val):
|
|
self["yaxis"] = val
|
|
|
|
# ybounds
|
|
# -------
|
|
@property
|
|
def ybounds(self):
|
|
"""
|
|
Specify `ybounds` in the shape of `[yMin, yMax] to avoid
|
|
looping through the `xy` typed array. Use it in conjunction
|
|
with `xy` and `xbounds` for the performance benefits.
|
|
|
|
The 'ybounds' property is an array that may be specified as a tuple,
|
|
list, numpy array, or pandas Series
|
|
|
|
Returns
|
|
-------
|
|
numpy.ndarray
|
|
"""
|
|
return self["ybounds"]
|
|
|
|
@ybounds.setter
|
|
def ybounds(self, val):
|
|
self["ybounds"] = val
|
|
|
|
# yboundssrc
|
|
# ----------
|
|
@property
|
|
def yboundssrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for `ybounds`.
|
|
|
|
The 'yboundssrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["yboundssrc"]
|
|
|
|
@yboundssrc.setter
|
|
def yboundssrc(self, val):
|
|
self["yboundssrc"] = val
|
|
|
|
# ysrc
|
|
# ----
|
|
@property
|
|
def ysrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for `y`.
|
|
|
|
The 'ysrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["ysrc"]
|
|
|
|
@ysrc.setter
|
|
def ysrc(self, val):
|
|
self["ysrc"] = val
|
|
|
|
# type
|
|
# ----
|
|
@property
|
|
def type(self):
|
|
return self._props["type"]
|
|
|
|
# Self properties description
|
|
# ---------------------------
|
|
@property
|
|
def _prop_descriptions(self):
|
|
return """\
|
|
customdata
|
|
Assigns extra data each datum. This may be useful when
|
|
listening to hover, click and selection events. Note
|
|
that, "scatter" traces also appends customdata items in
|
|
the markers DOM elements
|
|
customdatasrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`customdata`.
|
|
hoverinfo
|
|
Determines which trace information appear on hover. If
|
|
`none` or `skip` are set, no information is displayed
|
|
upon hovering. But, if `none` is set, click and hover
|
|
events are still fired.
|
|
hoverinfosrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`hoverinfo`.
|
|
hoverlabel
|
|
:class:`plotly.graph_objects.pointcloud.Hoverlabel`
|
|
instance or dict with compatible properties
|
|
ids
|
|
Assigns id labels to each datum. These ids for object
|
|
constancy of data points during animation. Should be an
|
|
array of strings, not numbers or any other type.
|
|
idssrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`ids`.
|
|
indices
|
|
A sequential value, 0..n, supply it to avoid creating
|
|
this array inside plotting. If specified, it must be a
|
|
typed `Int32Array` array. Its length must be equal to
|
|
or greater than the number of points. For the best
|
|
performance and memory use, create one large `indices`
|
|
typed array that is guaranteed to be at least as long
|
|
as the largest number of points during use, and reuse
|
|
it on each `Plotly.restyle()` call.
|
|
indicessrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`indices`.
|
|
legend
|
|
Sets the reference to a legend to show this trace in.
|
|
References to these legends are "legend", "legend2",
|
|
"legend3", etc. Settings for these legends are set in
|
|
the layout, under `layout.legend`, `layout.legend2`,
|
|
etc.
|
|
legendgroup
|
|
Sets the legend group for this trace. Traces and shapes
|
|
part of the same legend group hide/show at the same
|
|
time when toggling legend items.
|
|
legendgrouptitle
|
|
:class:`plotly.graph_objects.pointcloud.Legendgrouptitl
|
|
e` instance or dict with compatible properties
|
|
legendrank
|
|
Sets the legend rank for this trace. Items and groups
|
|
with smaller ranks are presented on top/left side while
|
|
with "reversed" `legend.traceorder` they are on
|
|
bottom/right side. The default legendrank is 1000, so
|
|
that you can use ranks less than 1000 to place certain
|
|
items before all unranked items, and ranks greater than
|
|
1000 to go after all unranked items. When having
|
|
unranked or equal rank items shapes would be displayed
|
|
after traces i.e. according to their order in data and
|
|
layout.
|
|
legendwidth
|
|
Sets the width (in px or fraction) of the legend for
|
|
this trace.
|
|
marker
|
|
:class:`plotly.graph_objects.pointcloud.Marker`
|
|
instance or dict with compatible properties
|
|
meta
|
|
Assigns extra meta information associated with this
|
|
trace that can be used in various text attributes.
|
|
Attributes such as trace `name`, graph, axis and
|
|
colorbar `title.text`, annotation `text`
|
|
`rangeselector`, `updatemenues` and `sliders` `label`
|
|
text all support `meta`. To access the trace `meta`
|
|
values in an attribute in the same trace, simply use
|
|
`%{meta[i]}` where `i` is the index or key of the
|
|
`meta` item in question. To access trace `meta` in
|
|
layout attributes, use `%{data[n[.meta[i]}` where `i`
|
|
is the index or key of the `meta` and `n` is the trace
|
|
index.
|
|
metasrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`meta`.
|
|
name
|
|
Sets the trace name. The trace name appears as the
|
|
legend item and on hover.
|
|
opacity
|
|
Sets the opacity of the trace.
|
|
showlegend
|
|
Determines whether or not an item corresponding to this
|
|
trace is shown in the legend.
|
|
stream
|
|
:class:`plotly.graph_objects.pointcloud.Stream`
|
|
instance or dict with compatible properties
|
|
text
|
|
Sets text elements associated with each (x,y) pair. If
|
|
a single string, the same string appears over all the
|
|
data points. If an array of string, the items are
|
|
mapped in order to the this trace's (x,y) coordinates.
|
|
If trace `hoverinfo` contains a "text" flag and
|
|
"hovertext" is not set, these elements will be seen in
|
|
the hover labels.
|
|
textsrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`text`.
|
|
uid
|
|
Assign an id to this trace, Use this to provide object
|
|
constancy between traces during animations and
|
|
transitions.
|
|
uirevision
|
|
Controls persistence of some user-driven changes to the
|
|
trace: `constraintrange` in `parcoords` traces, as well
|
|
as some `editable: true` modifications such as `name`
|
|
and `colorbar.title`. Defaults to `layout.uirevision`.
|
|
Note that other user-driven trace attribute changes are
|
|
controlled by `layout` attributes: `trace.visible` is
|
|
controlled by `layout.legend.uirevision`,
|
|
`selectedpoints` is controlled by
|
|
`layout.selectionrevision`, and `colorbar.(x|y)`
|
|
(accessible with `config: {editable: true}`) is
|
|
controlled by `layout.editrevision`. Trace changes are
|
|
tracked by `uid`, which only falls back on trace index
|
|
if no `uid` is provided. So if your app can add/remove
|
|
traces before the end of the `data` array, such that
|
|
the same trace has a different index, you can still
|
|
preserve user-driven changes if you give each trace a
|
|
`uid` that stays with it as it moves.
|
|
visible
|
|
Determines whether or not this trace is visible. If
|
|
"legendonly", the trace is not drawn, but can appear as
|
|
a legend item (provided that the legend itself is
|
|
visible).
|
|
x
|
|
Sets the x coordinates.
|
|
xaxis
|
|
Sets a reference between this trace's x coordinates and
|
|
a 2D cartesian x axis. If "x" (the default value), the
|
|
x coordinates refer to `layout.xaxis`. If "x2", the x
|
|
coordinates refer to `layout.xaxis2`, and so on.
|
|
xbounds
|
|
Specify `xbounds` in the shape of `[xMin, xMax] to
|
|
avoid looping through the `xy` typed array. Use it in
|
|
conjunction with `xy` and `ybounds` for the performance
|
|
benefits.
|
|
xboundssrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`xbounds`.
|
|
xsrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`x`.
|
|
xy
|
|
Faster alternative to specifying `x` and `y`
|
|
separately. If supplied, it must be a typed
|
|
`Float32Array` array that represents points such that
|
|
`xy[i * 2] = x[i]` and `xy[i * 2 + 1] = y[i]`
|
|
xysrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`xy`.
|
|
y
|
|
Sets the y coordinates.
|
|
yaxis
|
|
Sets a reference between this trace's y coordinates and
|
|
a 2D cartesian y axis. If "y" (the default value), the
|
|
y coordinates refer to `layout.yaxis`. If "y2", the y
|
|
coordinates refer to `layout.yaxis2`, and so on.
|
|
ybounds
|
|
Specify `ybounds` in the shape of `[yMin, yMax] to
|
|
avoid looping through the `xy` typed array. Use it in
|
|
conjunction with `xy` and `xbounds` for the performance
|
|
benefits.
|
|
yboundssrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`ybounds`.
|
|
ysrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`y`.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
arg=None,
|
|
customdata=None,
|
|
customdatasrc=None,
|
|
hoverinfo=None,
|
|
hoverinfosrc=None,
|
|
hoverlabel=None,
|
|
ids=None,
|
|
idssrc=None,
|
|
indices=None,
|
|
indicessrc=None,
|
|
legend=None,
|
|
legendgroup=None,
|
|
legendgrouptitle=None,
|
|
legendrank=None,
|
|
legendwidth=None,
|
|
marker=None,
|
|
meta=None,
|
|
metasrc=None,
|
|
name=None,
|
|
opacity=None,
|
|
showlegend=None,
|
|
stream=None,
|
|
text=None,
|
|
textsrc=None,
|
|
uid=None,
|
|
uirevision=None,
|
|
visible=None,
|
|
x=None,
|
|
xaxis=None,
|
|
xbounds=None,
|
|
xboundssrc=None,
|
|
xsrc=None,
|
|
xy=None,
|
|
xysrc=None,
|
|
y=None,
|
|
yaxis=None,
|
|
ybounds=None,
|
|
yboundssrc=None,
|
|
ysrc=None,
|
|
**kwargs,
|
|
):
|
|
"""
|
|
Construct a new Pointcloud object
|
|
|
|
"pointcloud" trace is deprecated! Please consider switching to
|
|
the "scattergl" trace type. The data visualized as a point
|
|
cloud set in `x` and `y` using the WebGl plotting engine.
|
|
|
|
Parameters
|
|
----------
|
|
arg
|
|
dict of properties compatible with this constructor or
|
|
an instance of :class:`plotly.graph_objs.Pointcloud`
|
|
customdata
|
|
Assigns extra data each datum. This may be useful when
|
|
listening to hover, click and selection events. Note
|
|
that, "scatter" traces also appends customdata items in
|
|
the markers DOM elements
|
|
customdatasrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`customdata`.
|
|
hoverinfo
|
|
Determines which trace information appear on hover. If
|
|
`none` or `skip` are set, no information is displayed
|
|
upon hovering. But, if `none` is set, click and hover
|
|
events are still fired.
|
|
hoverinfosrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`hoverinfo`.
|
|
hoverlabel
|
|
:class:`plotly.graph_objects.pointcloud.Hoverlabel`
|
|
instance or dict with compatible properties
|
|
ids
|
|
Assigns id labels to each datum. These ids for object
|
|
constancy of data points during animation. Should be an
|
|
array of strings, not numbers or any other type.
|
|
idssrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`ids`.
|
|
indices
|
|
A sequential value, 0..n, supply it to avoid creating
|
|
this array inside plotting. If specified, it must be a
|
|
typed `Int32Array` array. Its length must be equal to
|
|
or greater than the number of points. For the best
|
|
performance and memory use, create one large `indices`
|
|
typed array that is guaranteed to be at least as long
|
|
as the largest number of points during use, and reuse
|
|
it on each `Plotly.restyle()` call.
|
|
indicessrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`indices`.
|
|
legend
|
|
Sets the reference to a legend to show this trace in.
|
|
References to these legends are "legend", "legend2",
|
|
"legend3", etc. Settings for these legends are set in
|
|
the layout, under `layout.legend`, `layout.legend2`,
|
|
etc.
|
|
legendgroup
|
|
Sets the legend group for this trace. Traces and shapes
|
|
part of the same legend group hide/show at the same
|
|
time when toggling legend items.
|
|
legendgrouptitle
|
|
:class:`plotly.graph_objects.pointcloud.Legendgrouptitl
|
|
e` instance or dict with compatible properties
|
|
legendrank
|
|
Sets the legend rank for this trace. Items and groups
|
|
with smaller ranks are presented on top/left side while
|
|
with "reversed" `legend.traceorder` they are on
|
|
bottom/right side. The default legendrank is 1000, so
|
|
that you can use ranks less than 1000 to place certain
|
|
items before all unranked items, and ranks greater than
|
|
1000 to go after all unranked items. When having
|
|
unranked or equal rank items shapes would be displayed
|
|
after traces i.e. according to their order in data and
|
|
layout.
|
|
legendwidth
|
|
Sets the width (in px or fraction) of the legend for
|
|
this trace.
|
|
marker
|
|
:class:`plotly.graph_objects.pointcloud.Marker`
|
|
instance or dict with compatible properties
|
|
meta
|
|
Assigns extra meta information associated with this
|
|
trace that can be used in various text attributes.
|
|
Attributes such as trace `name`, graph, axis and
|
|
colorbar `title.text`, annotation `text`
|
|
`rangeselector`, `updatemenues` and `sliders` `label`
|
|
text all support `meta`. To access the trace `meta`
|
|
values in an attribute in the same trace, simply use
|
|
`%{meta[i]}` where `i` is the index or key of the
|
|
`meta` item in question. To access trace `meta` in
|
|
layout attributes, use `%{data[n[.meta[i]}` where `i`
|
|
is the index or key of the `meta` and `n` is the trace
|
|
index.
|
|
metasrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`meta`.
|
|
name
|
|
Sets the trace name. The trace name appears as the
|
|
legend item and on hover.
|
|
opacity
|
|
Sets the opacity of the trace.
|
|
showlegend
|
|
Determines whether or not an item corresponding to this
|
|
trace is shown in the legend.
|
|
stream
|
|
:class:`plotly.graph_objects.pointcloud.Stream`
|
|
instance or dict with compatible properties
|
|
text
|
|
Sets text elements associated with each (x,y) pair. If
|
|
a single string, the same string appears over all the
|
|
data points. If an array of string, the items are
|
|
mapped in order to the this trace's (x,y) coordinates.
|
|
If trace `hoverinfo` contains a "text" flag and
|
|
"hovertext" is not set, these elements will be seen in
|
|
the hover labels.
|
|
textsrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`text`.
|
|
uid
|
|
Assign an id to this trace, Use this to provide object
|
|
constancy between traces during animations and
|
|
transitions.
|
|
uirevision
|
|
Controls persistence of some user-driven changes to the
|
|
trace: `constraintrange` in `parcoords` traces, as well
|
|
as some `editable: true` modifications such as `name`
|
|
and `colorbar.title`. Defaults to `layout.uirevision`.
|
|
Note that other user-driven trace attribute changes are
|
|
controlled by `layout` attributes: `trace.visible` is
|
|
controlled by `layout.legend.uirevision`,
|
|
`selectedpoints` is controlled by
|
|
`layout.selectionrevision`, and `colorbar.(x|y)`
|
|
(accessible with `config: {editable: true}`) is
|
|
controlled by `layout.editrevision`. Trace changes are
|
|
tracked by `uid`, which only falls back on trace index
|
|
if no `uid` is provided. So if your app can add/remove
|
|
traces before the end of the `data` array, such that
|
|
the same trace has a different index, you can still
|
|
preserve user-driven changes if you give each trace a
|
|
`uid` that stays with it as it moves.
|
|
visible
|
|
Determines whether or not this trace is visible. If
|
|
"legendonly", the trace is not drawn, but can appear as
|
|
a legend item (provided that the legend itself is
|
|
visible).
|
|
x
|
|
Sets the x coordinates.
|
|
xaxis
|
|
Sets a reference between this trace's x coordinates and
|
|
a 2D cartesian x axis. If "x" (the default value), the
|
|
x coordinates refer to `layout.xaxis`. If "x2", the x
|
|
coordinates refer to `layout.xaxis2`, and so on.
|
|
xbounds
|
|
Specify `xbounds` in the shape of `[xMin, xMax] to
|
|
avoid looping through the `xy` typed array. Use it in
|
|
conjunction with `xy` and `ybounds` for the performance
|
|
benefits.
|
|
xboundssrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`xbounds`.
|
|
xsrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`x`.
|
|
xy
|
|
Faster alternative to specifying `x` and `y`
|
|
separately. If supplied, it must be a typed
|
|
`Float32Array` array that represents points such that
|
|
`xy[i * 2] = x[i]` and `xy[i * 2 + 1] = y[i]`
|
|
xysrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`xy`.
|
|
y
|
|
Sets the y coordinates.
|
|
yaxis
|
|
Sets a reference between this trace's y coordinates and
|
|
a 2D cartesian y axis. If "y" (the default value), the
|
|
y coordinates refer to `layout.yaxis`. If "y2", the y
|
|
coordinates refer to `layout.yaxis2`, and so on.
|
|
ybounds
|
|
Specify `ybounds` in the shape of `[yMin, yMax] to
|
|
avoid looping through the `xy` typed array. Use it in
|
|
conjunction with `xy` and `xbounds` for the performance
|
|
benefits.
|
|
yboundssrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`ybounds`.
|
|
ysrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`y`.
|
|
|
|
Returns
|
|
-------
|
|
Pointcloud
|
|
"""
|
|
super(Pointcloud, self).__init__("pointcloud")
|
|
|
|
if "_parent" in kwargs:
|
|
self._parent = kwargs["_parent"]
|
|
return
|
|
|
|
# Validate arg
|
|
# ------------
|
|
if arg is None:
|
|
arg = {}
|
|
elif isinstance(arg, self.__class__):
|
|
arg = arg.to_plotly_json()
|
|
elif isinstance(arg, dict):
|
|
arg = _copy.copy(arg)
|
|
else:
|
|
raise ValueError(
|
|
"""\
|
|
The first argument to the plotly.graph_objs.Pointcloud
|
|
constructor must be a dict or
|
|
an instance of :class:`plotly.graph_objs.Pointcloud`"""
|
|
)
|
|
|
|
# Handle skip_invalid
|
|
# -------------------
|
|
self._skip_invalid = kwargs.pop("skip_invalid", False)
|
|
self._validate = kwargs.pop("_validate", True)
|
|
|
|
# Populate data dict with properties
|
|
# ----------------------------------
|
|
_v = arg.pop("customdata", None)
|
|
_v = customdata if customdata is not None else _v
|
|
if _v is not None:
|
|
self["customdata"] = _v
|
|
_v = arg.pop("customdatasrc", None)
|
|
_v = customdatasrc if customdatasrc is not None else _v
|
|
if _v is not None:
|
|
self["customdatasrc"] = _v
|
|
_v = arg.pop("hoverinfo", None)
|
|
_v = hoverinfo if hoverinfo is not None else _v
|
|
if _v is not None:
|
|
self["hoverinfo"] = _v
|
|
_v = arg.pop("hoverinfosrc", None)
|
|
_v = hoverinfosrc if hoverinfosrc is not None else _v
|
|
if _v is not None:
|
|
self["hoverinfosrc"] = _v
|
|
_v = arg.pop("hoverlabel", None)
|
|
_v = hoverlabel if hoverlabel is not None else _v
|
|
if _v is not None:
|
|
self["hoverlabel"] = _v
|
|
_v = arg.pop("ids", None)
|
|
_v = ids if ids is not None else _v
|
|
if _v is not None:
|
|
self["ids"] = _v
|
|
_v = arg.pop("idssrc", None)
|
|
_v = idssrc if idssrc is not None else _v
|
|
if _v is not None:
|
|
self["idssrc"] = _v
|
|
_v = arg.pop("indices", None)
|
|
_v = indices if indices is not None else _v
|
|
if _v is not None:
|
|
self["indices"] = _v
|
|
_v = arg.pop("indicessrc", None)
|
|
_v = indicessrc if indicessrc is not None else _v
|
|
if _v is not None:
|
|
self["indicessrc"] = _v
|
|
_v = arg.pop("legend", None)
|
|
_v = legend if legend is not None else _v
|
|
if _v is not None:
|
|
self["legend"] = _v
|
|
_v = arg.pop("legendgroup", None)
|
|
_v = legendgroup if legendgroup is not None else _v
|
|
if _v is not None:
|
|
self["legendgroup"] = _v
|
|
_v = arg.pop("legendgrouptitle", None)
|
|
_v = legendgrouptitle if legendgrouptitle is not None else _v
|
|
if _v is not None:
|
|
self["legendgrouptitle"] = _v
|
|
_v = arg.pop("legendrank", None)
|
|
_v = legendrank if legendrank is not None else _v
|
|
if _v is not None:
|
|
self["legendrank"] = _v
|
|
_v = arg.pop("legendwidth", None)
|
|
_v = legendwidth if legendwidth is not None else _v
|
|
if _v is not None:
|
|
self["legendwidth"] = _v
|
|
_v = arg.pop("marker", None)
|
|
_v = marker if marker is not None else _v
|
|
if _v is not None:
|
|
self["marker"] = _v
|
|
_v = arg.pop("meta", None)
|
|
_v = meta if meta is not None else _v
|
|
if _v is not None:
|
|
self["meta"] = _v
|
|
_v = arg.pop("metasrc", None)
|
|
_v = metasrc if metasrc is not None else _v
|
|
if _v is not None:
|
|
self["metasrc"] = _v
|
|
_v = arg.pop("name", None)
|
|
_v = name if name is not None else _v
|
|
if _v is not None:
|
|
self["name"] = _v
|
|
_v = arg.pop("opacity", None)
|
|
_v = opacity if opacity is not None else _v
|
|
if _v is not None:
|
|
self["opacity"] = _v
|
|
_v = arg.pop("showlegend", None)
|
|
_v = showlegend if showlegend is not None else _v
|
|
if _v is not None:
|
|
self["showlegend"] = _v
|
|
_v = arg.pop("stream", None)
|
|
_v = stream if stream is not None else _v
|
|
if _v is not None:
|
|
self["stream"] = _v
|
|
_v = arg.pop("text", None)
|
|
_v = text if text is not None else _v
|
|
if _v is not None:
|
|
self["text"] = _v
|
|
_v = arg.pop("textsrc", None)
|
|
_v = textsrc if textsrc is not None else _v
|
|
if _v is not None:
|
|
self["textsrc"] = _v
|
|
_v = arg.pop("uid", None)
|
|
_v = uid if uid is not None else _v
|
|
if _v is not None:
|
|
self["uid"] = _v
|
|
_v = arg.pop("uirevision", None)
|
|
_v = uirevision if uirevision is not None else _v
|
|
if _v is not None:
|
|
self["uirevision"] = _v
|
|
_v = arg.pop("visible", None)
|
|
_v = visible if visible is not None else _v
|
|
if _v is not None:
|
|
self["visible"] = _v
|
|
_v = arg.pop("x", None)
|
|
_v = x if x is not None else _v
|
|
if _v is not None:
|
|
self["x"] = _v
|
|
_v = arg.pop("xaxis", None)
|
|
_v = xaxis if xaxis is not None else _v
|
|
if _v is not None:
|
|
self["xaxis"] = _v
|
|
_v = arg.pop("xbounds", None)
|
|
_v = xbounds if xbounds is not None else _v
|
|
if _v is not None:
|
|
self["xbounds"] = _v
|
|
_v = arg.pop("xboundssrc", None)
|
|
_v = xboundssrc if xboundssrc is not None else _v
|
|
if _v is not None:
|
|
self["xboundssrc"] = _v
|
|
_v = arg.pop("xsrc", None)
|
|
_v = xsrc if xsrc is not None else _v
|
|
if _v is not None:
|
|
self["xsrc"] = _v
|
|
_v = arg.pop("xy", None)
|
|
_v = xy if xy is not None else _v
|
|
if _v is not None:
|
|
self["xy"] = _v
|
|
_v = arg.pop("xysrc", None)
|
|
_v = xysrc if xysrc is not None else _v
|
|
if _v is not None:
|
|
self["xysrc"] = _v
|
|
_v = arg.pop("y", None)
|
|
_v = y if y is not None else _v
|
|
if _v is not None:
|
|
self["y"] = _v
|
|
_v = arg.pop("yaxis", None)
|
|
_v = yaxis if yaxis is not None else _v
|
|
if _v is not None:
|
|
self["yaxis"] = _v
|
|
_v = arg.pop("ybounds", None)
|
|
_v = ybounds if ybounds is not None else _v
|
|
if _v is not None:
|
|
self["ybounds"] = _v
|
|
_v = arg.pop("yboundssrc", None)
|
|
_v = yboundssrc if yboundssrc is not None else _v
|
|
if _v is not None:
|
|
self["yboundssrc"] = _v
|
|
_v = arg.pop("ysrc", None)
|
|
_v = ysrc if ysrc is not None else _v
|
|
if _v is not None:
|
|
self["ysrc"] = _v
|
|
|
|
# Read-only literals
|
|
# ------------------
|
|
|
|
self._props["type"] = "pointcloud"
|
|
arg.pop("type", None)
|
|
|
|
# Process unknown kwargs
|
|
# ----------------------
|
|
self._process_kwargs(**dict(arg, **kwargs))
|
|
|
|
# Reset skip_invalid
|
|
# ------------------
|
|
self._skip_invalid = False
|