mirror of
https://github.com/aykhans/AzSuicideDataVisualization.git
synced 2025-04-22 10:28:02 +00:00
964 lines
38 KiB
Python
964 lines
38 KiB
Python
from plotly.basedatatypes import BaseTraceHierarchyType as _BaseTraceHierarchyType
|
|
import copy as _copy
|
|
|
|
|
|
class Line(_BaseTraceHierarchyType):
|
|
|
|
# class properties
|
|
# --------------------
|
|
_parent_path_str = "scatter3d"
|
|
_path_str = "scatter3d.line"
|
|
_valid_props = {
|
|
"autocolorscale",
|
|
"cauto",
|
|
"cmax",
|
|
"cmid",
|
|
"cmin",
|
|
"color",
|
|
"coloraxis",
|
|
"colorbar",
|
|
"colorscale",
|
|
"colorsrc",
|
|
"dash",
|
|
"reversescale",
|
|
"showscale",
|
|
"width",
|
|
}
|
|
|
|
# autocolorscale
|
|
# --------------
|
|
@property
|
|
def autocolorscale(self):
|
|
"""
|
|
Determines whether the colorscale is a default palette
|
|
(`autocolorscale: true`) or the palette determined by
|
|
`line.colorscale`. Has an effect only if in `line.color` is set
|
|
to a numerical array. In case `colorscale` is unspecified or
|
|
`autocolorscale` is true, the default palette will be chosen
|
|
according to whether numbers in the `color` array are all
|
|
positive, all negative or mixed.
|
|
|
|
The 'autocolorscale' property must be specified as a bool
|
|
(either True, or False)
|
|
|
|
Returns
|
|
-------
|
|
bool
|
|
"""
|
|
return self["autocolorscale"]
|
|
|
|
@autocolorscale.setter
|
|
def autocolorscale(self, val):
|
|
self["autocolorscale"] = val
|
|
|
|
# cauto
|
|
# -----
|
|
@property
|
|
def cauto(self):
|
|
"""
|
|
Determines whether or not the color domain is computed with
|
|
respect to the input data (here in `line.color`) or the bounds
|
|
set in `line.cmin` and `line.cmax` Has an effect only if in
|
|
`line.color` is set to a numerical array. Defaults to `false`
|
|
when `line.cmin` and `line.cmax` are set by the user.
|
|
|
|
The 'cauto' property must be specified as a bool
|
|
(either True, or False)
|
|
|
|
Returns
|
|
-------
|
|
bool
|
|
"""
|
|
return self["cauto"]
|
|
|
|
@cauto.setter
|
|
def cauto(self, val):
|
|
self["cauto"] = val
|
|
|
|
# cmax
|
|
# ----
|
|
@property
|
|
def cmax(self):
|
|
"""
|
|
Sets the upper bound of the color domain. Has an effect only if
|
|
in `line.color` is set to a numerical array. Value should have
|
|
the same units as in `line.color` and if set, `line.cmin` must
|
|
be set as well.
|
|
|
|
The 'cmax' property is a number and may be specified as:
|
|
- An int or float
|
|
|
|
Returns
|
|
-------
|
|
int|float
|
|
"""
|
|
return self["cmax"]
|
|
|
|
@cmax.setter
|
|
def cmax(self, val):
|
|
self["cmax"] = val
|
|
|
|
# cmid
|
|
# ----
|
|
@property
|
|
def cmid(self):
|
|
"""
|
|
Sets the mid-point of the color domain by scaling `line.cmin`
|
|
and/or `line.cmax` to be equidistant to this point. Has an
|
|
effect only if in `line.color` is set to a numerical array.
|
|
Value should have the same units as in `line.color`. Has no
|
|
effect when `line.cauto` is `false`.
|
|
|
|
The 'cmid' property is a number and may be specified as:
|
|
- An int or float
|
|
|
|
Returns
|
|
-------
|
|
int|float
|
|
"""
|
|
return self["cmid"]
|
|
|
|
@cmid.setter
|
|
def cmid(self, val):
|
|
self["cmid"] = val
|
|
|
|
# cmin
|
|
# ----
|
|
@property
|
|
def cmin(self):
|
|
"""
|
|
Sets the lower bound of the color domain. Has an effect only if
|
|
in `line.color` is set to a numerical array. Value should have
|
|
the same units as in `line.color` and if set, `line.cmax` must
|
|
be set as well.
|
|
|
|
The 'cmin' property is a number and may be specified as:
|
|
- An int or float
|
|
|
|
Returns
|
|
-------
|
|
int|float
|
|
"""
|
|
return self["cmin"]
|
|
|
|
@cmin.setter
|
|
def cmin(self, val):
|
|
self["cmin"] = val
|
|
|
|
# color
|
|
# -----
|
|
@property
|
|
def color(self):
|
|
"""
|
|
Sets the line color. It accepts either a specific color or an
|
|
array of numbers that are mapped to the colorscale relative to
|
|
the max and min values of the array or relative to `line.cmin`
|
|
and `line.cmax` if set.
|
|
|
|
The 'color' property is a color and may be specified as:
|
|
- A hex string (e.g. '#ff0000')
|
|
- An rgb/rgba string (e.g. 'rgb(255,0,0)')
|
|
- An hsl/hsla string (e.g. 'hsl(0,100%,50%)')
|
|
- An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
|
|
- A named CSS color:
|
|
aliceblue, antiquewhite, aqua, aquamarine, azure,
|
|
beige, bisque, black, blanchedalmond, blue,
|
|
blueviolet, brown, burlywood, cadetblue,
|
|
chartreuse, chocolate, coral, cornflowerblue,
|
|
cornsilk, crimson, cyan, darkblue, darkcyan,
|
|
darkgoldenrod, darkgray, darkgrey, darkgreen,
|
|
darkkhaki, darkmagenta, darkolivegreen, darkorange,
|
|
darkorchid, darkred, darksalmon, darkseagreen,
|
|
darkslateblue, darkslategray, darkslategrey,
|
|
darkturquoise, darkviolet, deeppink, deepskyblue,
|
|
dimgray, dimgrey, dodgerblue, firebrick,
|
|
floralwhite, forestgreen, fuchsia, gainsboro,
|
|
ghostwhite, gold, goldenrod, gray, grey, green,
|
|
greenyellow, honeydew, hotpink, indianred, indigo,
|
|
ivory, khaki, lavender, lavenderblush, lawngreen,
|
|
lemonchiffon, lightblue, lightcoral, lightcyan,
|
|
lightgoldenrodyellow, lightgray, lightgrey,
|
|
lightgreen, lightpink, lightsalmon, lightseagreen,
|
|
lightskyblue, lightslategray, lightslategrey,
|
|
lightsteelblue, lightyellow, lime, limegreen,
|
|
linen, magenta, maroon, mediumaquamarine,
|
|
mediumblue, mediumorchid, mediumpurple,
|
|
mediumseagreen, mediumslateblue, mediumspringgreen,
|
|
mediumturquoise, mediumvioletred, midnightblue,
|
|
mintcream, mistyrose, moccasin, navajowhite, navy,
|
|
oldlace, olive, olivedrab, orange, orangered,
|
|
orchid, palegoldenrod, palegreen, paleturquoise,
|
|
palevioletred, papayawhip, peachpuff, peru, pink,
|
|
plum, powderblue, purple, red, rosybrown,
|
|
royalblue, rebeccapurple, saddlebrown, salmon,
|
|
sandybrown, seagreen, seashell, sienna, silver,
|
|
skyblue, slateblue, slategray, slategrey, snow,
|
|
springgreen, steelblue, tan, teal, thistle, tomato,
|
|
turquoise, violet, wheat, white, whitesmoke,
|
|
yellow, yellowgreen
|
|
- A number that will be interpreted as a color
|
|
according to scatter3d.line.colorscale
|
|
- A list or array of any of the above
|
|
|
|
Returns
|
|
-------
|
|
str|numpy.ndarray
|
|
"""
|
|
return self["color"]
|
|
|
|
@color.setter
|
|
def color(self, val):
|
|
self["color"] = val
|
|
|
|
# coloraxis
|
|
# ---------
|
|
@property
|
|
def coloraxis(self):
|
|
"""
|
|
Sets a reference to a shared color axis. References to these
|
|
shared color axes are "coloraxis", "coloraxis2", "coloraxis3",
|
|
etc. Settings for these shared color axes are set in the
|
|
layout, under `layout.coloraxis`, `layout.coloraxis2`, etc.
|
|
Note that multiple color scales can be linked to the same color
|
|
axis.
|
|
|
|
The 'coloraxis' property is an identifier of a particular
|
|
subplot, of type 'coloraxis', that may be specified as the string 'coloraxis'
|
|
optionally followed by an integer >= 1
|
|
(e.g. 'coloraxis', 'coloraxis1', 'coloraxis2', 'coloraxis3', etc.)
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["coloraxis"]
|
|
|
|
@coloraxis.setter
|
|
def coloraxis(self, val):
|
|
self["coloraxis"] = val
|
|
|
|
# colorbar
|
|
# --------
|
|
@property
|
|
def colorbar(self):
|
|
"""
|
|
The 'colorbar' property is an instance of ColorBar
|
|
that may be specified as:
|
|
- An instance of :class:`plotly.graph_objs.scatter3d.line.ColorBar`
|
|
- A dict of string/value properties that will be passed
|
|
to the ColorBar constructor
|
|
|
|
Supported dict properties:
|
|
|
|
bgcolor
|
|
Sets the color of padded area.
|
|
bordercolor
|
|
Sets the axis line color.
|
|
borderwidth
|
|
Sets the width (in px) or the border enclosing
|
|
this color bar.
|
|
dtick
|
|
Sets the step in-between ticks on this axis.
|
|
Use with `tick0`. Must be a positive number, or
|
|
special strings available to "log" and "date"
|
|
axes. If the axis `type` is "log", then ticks
|
|
are set every 10^(n*dtick) where n is the tick
|
|
number. For example, to set a tick mark at 1,
|
|
10, 100, 1000, ... set dtick to 1. To set tick
|
|
marks at 1, 100, 10000, ... set dtick to 2. To
|
|
set tick marks at 1, 5, 25, 125, 625, 3125, ...
|
|
set dtick to log_10(5), or 0.69897000433. "log"
|
|
has several special values; "L<f>", where `f`
|
|
is a positive number, gives ticks linearly
|
|
spaced in value (but not position). For example
|
|
`tick0` = 0.1, `dtick` = "L0.5" will put ticks
|
|
at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10
|
|
plus small digits between, use "D1" (all
|
|
digits) or "D2" (only 2 and 5). `tick0` is
|
|
ignored for "D1" and "D2". If the axis `type`
|
|
is "date", then you must convert the time to
|
|
milliseconds. For example, to set the interval
|
|
between ticks to one day, set `dtick` to
|
|
86400000.0. "date" also has special values
|
|
"M<n>" gives ticks spaced by a number of
|
|
months. `n` must be a positive integer. To set
|
|
ticks on the 15th of every third month, set
|
|
`tick0` to "2000-01-15" and `dtick` to "M3". To
|
|
set ticks every 4 years, set `dtick` to "M48"
|
|
exponentformat
|
|
Determines a formatting rule for the tick
|
|
exponents. For example, consider the number
|
|
1,000,000,000. If "none", it appears as
|
|
1,000,000,000. If "e", 1e+9. If "E", 1E+9. If
|
|
"power", 1x10^9 (with 9 in a super script). If
|
|
"SI", 1G. If "B", 1B.
|
|
len
|
|
Sets the length of the color bar This measure
|
|
excludes the padding of both ends. That is, the
|
|
color bar length is this length minus the
|
|
padding on both ends.
|
|
lenmode
|
|
Determines whether this color bar's length
|
|
(i.e. the measure in the color variation
|
|
direction) is set in units of plot "fraction"
|
|
or in *pixels. Use `len` to set the value.
|
|
minexponent
|
|
Hide SI prefix for 10^n if |n| is below this
|
|
number. This only has an effect when
|
|
`tickformat` is "SI" or "B".
|
|
nticks
|
|
Specifies the maximum number of ticks for the
|
|
particular axis. The actual number of ticks
|
|
will be chosen automatically to be less than or
|
|
equal to `nticks`. Has an effect only if
|
|
`tickmode` is set to "auto".
|
|
orientation
|
|
Sets the orientation of the colorbar.
|
|
outlinecolor
|
|
Sets the axis line color.
|
|
outlinewidth
|
|
Sets the width (in px) of the axis line.
|
|
separatethousands
|
|
If "true", even 4-digit integers are separated
|
|
showexponent
|
|
If "all", all exponents are shown besides their
|
|
significands. If "first", only the exponent of
|
|
the first tick is shown. If "last", only the
|
|
exponent of the last tick is shown. If "none",
|
|
no exponents appear.
|
|
showticklabels
|
|
Determines whether or not the tick labels are
|
|
drawn.
|
|
showtickprefix
|
|
If "all", all tick labels are displayed with a
|
|
prefix. If "first", only the first tick is
|
|
displayed with a prefix. If "last", only the
|
|
last tick is displayed with a suffix. If
|
|
"none", tick prefixes are hidden.
|
|
showticksuffix
|
|
Same as `showtickprefix` but for tick suffixes.
|
|
thickness
|
|
Sets the thickness of the color bar This
|
|
measure excludes the size of the padding, ticks
|
|
and labels.
|
|
thicknessmode
|
|
Determines whether this color bar's thickness
|
|
(i.e. the measure in the constant color
|
|
direction) is set in units of plot "fraction"
|
|
or in "pixels". Use `thickness` to set the
|
|
value.
|
|
tick0
|
|
Sets the placement of the first tick on this
|
|
axis. Use with `dtick`. If the axis `type` is
|
|
"log", then you must take the log of your
|
|
starting tick (e.g. to set the starting tick to
|
|
100, set the `tick0` to 2) except when
|
|
`dtick`=*L<f>* (see `dtick` for more info). If
|
|
the axis `type` is "date", it should be a date
|
|
string, like date data. If the axis `type` is
|
|
"category", it should be a number, using the
|
|
scale where each category is assigned a serial
|
|
number from zero in the order it appears.
|
|
tickangle
|
|
Sets the angle of the tick labels with respect
|
|
to the horizontal. For example, a `tickangle`
|
|
of -90 draws the tick labels vertically.
|
|
tickcolor
|
|
Sets the tick color.
|
|
tickfont
|
|
Sets the color bar's tick label font
|
|
tickformat
|
|
Sets the tick label formatting rule using d3
|
|
formatting mini-languages which are very
|
|
similar to those in Python. For numbers, see: h
|
|
ttps://github.com/d3/d3-format/tree/v1.4.5#d3-f
|
|
ormat. And for dates see:
|
|
https://github.com/d3/d3-time-
|
|
format/tree/v2.2.3#locale_format. We add two
|
|
items to d3's date formatter: "%h" for half of
|
|
the year as a decimal number as well as "%{n}f"
|
|
for fractional seconds with n digits. For
|
|
example, *2016-10-13 09:15:23.456* with
|
|
tickformat "%H~%M~%S.%2f" would display
|
|
"09~15~23.46"
|
|
tickformatstops
|
|
A tuple of :class:`plotly.graph_objects.scatter
|
|
3d.line.colorbar.Tickformatstop` instances or
|
|
dicts with compatible properties
|
|
tickformatstopdefaults
|
|
When used in a template (as layout.template.dat
|
|
a.scatter3d.line.colorbar.tickformatstopdefault
|
|
s), sets the default property values to use for
|
|
elements of
|
|
scatter3d.line.colorbar.tickformatstops
|
|
ticklabeloverflow
|
|
Determines how we handle tick labels that would
|
|
overflow either the graph div or the domain of
|
|
the axis. The default value for inside tick
|
|
labels is *hide past domain*. In other cases
|
|
the default is *hide past div*.
|
|
ticklabelposition
|
|
Determines where tick labels are drawn relative
|
|
to the ticks. Left and right options are used
|
|
when `orientation` is "h", top and bottom when
|
|
`orientation` is "v".
|
|
ticklabelstep
|
|
Sets the spacing between tick labels as
|
|
compared to the spacing between ticks. A value
|
|
of 1 (default) means each tick gets a label. A
|
|
value of 2 means shows every 2nd label. A
|
|
larger value n means only every nth tick is
|
|
labeled. `tick0` determines which labels are
|
|
shown. Not implemented for axes with `type`
|
|
"log" or "multicategory", or when `tickmode` is
|
|
"array".
|
|
ticklen
|
|
Sets the tick length (in px).
|
|
tickmode
|
|
Sets the tick mode for this axis. If "auto",
|
|
the number of ticks is set via `nticks`. If
|
|
"linear", the placement of the ticks is
|
|
determined by a starting position `tick0` and a
|
|
tick step `dtick` ("linear" is the default
|
|
value if `tick0` and `dtick` are provided). If
|
|
"array", the placement of the ticks is set via
|
|
`tickvals` and the tick text is `ticktext`.
|
|
("array" is the default value if `tickvals` is
|
|
provided).
|
|
tickprefix
|
|
Sets a tick label prefix.
|
|
ticks
|
|
Determines whether ticks are drawn or not. If
|
|
"", this axis' ticks are not drawn. If
|
|
"outside" ("inside"), this axis' are drawn
|
|
outside (inside) the axis lines.
|
|
ticksuffix
|
|
Sets a tick label suffix.
|
|
ticktext
|
|
Sets the text displayed at the ticks position
|
|
via `tickvals`. Only has an effect if
|
|
`tickmode` is set to "array". Used with
|
|
`tickvals`.
|
|
ticktextsrc
|
|
Sets the source reference on Chart Studio Cloud
|
|
for `ticktext`.
|
|
tickvals
|
|
Sets the values at which ticks on this axis
|
|
appear. Only has an effect if `tickmode` is set
|
|
to "array". Used with `ticktext`.
|
|
tickvalssrc
|
|
Sets the source reference on Chart Studio Cloud
|
|
for `tickvals`.
|
|
tickwidth
|
|
Sets the tick width (in px).
|
|
title
|
|
:class:`plotly.graph_objects.scatter3d.line.col
|
|
orbar.Title` instance or dict with compatible
|
|
properties
|
|
titlefont
|
|
Deprecated: Please use
|
|
scatter3d.line.colorbar.title.font instead.
|
|
Sets this color bar's title font. Note that the
|
|
title's font used to be set by the now
|
|
deprecated `titlefont` attribute.
|
|
titleside
|
|
Deprecated: Please use
|
|
scatter3d.line.colorbar.title.side instead.
|
|
Determines the location of color bar's title
|
|
with respect to the color bar. Defaults to
|
|
"top" when `orientation` if "v" and defaults
|
|
to "right" when `orientation` if "h". Note that
|
|
the title's location used to be set by the now
|
|
deprecated `titleside` attribute.
|
|
x
|
|
Sets the x position of the color bar (in plot
|
|
fraction). Defaults to 1.02 when `orientation`
|
|
is "v" and 0.5 when `orientation` is "h".
|
|
xanchor
|
|
Sets this color bar's horizontal position
|
|
anchor. This anchor binds the `x` position to
|
|
the "left", "center" or "right" of the color
|
|
bar. Defaults to "left" when `orientation` is
|
|
"v" and "center" when `orientation` is "h".
|
|
xpad
|
|
Sets the amount of padding (in px) along the x
|
|
direction.
|
|
y
|
|
Sets the y position of the color bar (in plot
|
|
fraction). Defaults to 0.5 when `orientation`
|
|
is "v" and 1.02 when `orientation` is "h".
|
|
yanchor
|
|
Sets this color bar's vertical position anchor
|
|
This anchor binds the `y` position to the
|
|
"top", "middle" or "bottom" of the color bar.
|
|
Defaults to "middle" when `orientation` is "v"
|
|
and "bottom" when `orientation` is "h".
|
|
ypad
|
|
Sets the amount of padding (in px) along the y
|
|
direction.
|
|
|
|
Returns
|
|
-------
|
|
plotly.graph_objs.scatter3d.line.ColorBar
|
|
"""
|
|
return self["colorbar"]
|
|
|
|
@colorbar.setter
|
|
def colorbar(self, val):
|
|
self["colorbar"] = val
|
|
|
|
# colorscale
|
|
# ----------
|
|
@property
|
|
def colorscale(self):
|
|
"""
|
|
Sets the colorscale. Has an effect only if in `line.color` is
|
|
set to a numerical array. The colorscale must be an array
|
|
containing arrays mapping a normalized value to an rgb, rgba,
|
|
hex, hsl, hsv, or named color string. At minimum, a mapping for
|
|
the lowest (0) and highest (1) values are required. For
|
|
example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To
|
|
control the bounds of the colorscale in color space, use
|
|
`line.cmin` and `line.cmax`. Alternatively, `colorscale` may be
|
|
a palette name string of the following list: Blackbody,Bluered,
|
|
Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portla
|
|
nd,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.
|
|
|
|
The 'colorscale' property is a colorscale and may be
|
|
specified as:
|
|
- A list of colors that will be spaced evenly to create the colorscale.
|
|
Many predefined colorscale lists are included in the sequential, diverging,
|
|
and cyclical modules in the plotly.colors package.
|
|
- A list of 2-element lists where the first element is the
|
|
normalized color level value (starting at 0 and ending at 1),
|
|
and the second item is a valid color string.
|
|
(e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']])
|
|
- One of the following named colorscales:
|
|
['aggrnyl', 'agsunset', 'algae', 'amp', 'armyrose', 'balance',
|
|
'blackbody', 'bluered', 'blues', 'blugrn', 'bluyl', 'brbg',
|
|
'brwnyl', 'bugn', 'bupu', 'burg', 'burgyl', 'cividis', 'curl',
|
|
'darkmint', 'deep', 'delta', 'dense', 'earth', 'edge', 'electric',
|
|
'emrld', 'fall', 'geyser', 'gnbu', 'gray', 'greens', 'greys',
|
|
'haline', 'hot', 'hsv', 'ice', 'icefire', 'inferno', 'jet',
|
|
'magenta', 'magma', 'matter', 'mint', 'mrybm', 'mygbm', 'oranges',
|
|
'orrd', 'oryel', 'oxy', 'peach', 'phase', 'picnic', 'pinkyl',
|
|
'piyg', 'plasma', 'plotly3', 'portland', 'prgn', 'pubu', 'pubugn',
|
|
'puor', 'purd', 'purp', 'purples', 'purpor', 'rainbow', 'rdbu',
|
|
'rdgy', 'rdpu', 'rdylbu', 'rdylgn', 'redor', 'reds', 'solar',
|
|
'spectral', 'speed', 'sunset', 'sunsetdark', 'teal', 'tealgrn',
|
|
'tealrose', 'tempo', 'temps', 'thermal', 'tropic', 'turbid',
|
|
'turbo', 'twilight', 'viridis', 'ylgn', 'ylgnbu', 'ylorbr',
|
|
'ylorrd'].
|
|
Appending '_r' to a named colorscale reverses it.
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["colorscale"]
|
|
|
|
@colorscale.setter
|
|
def colorscale(self, val):
|
|
self["colorscale"] = val
|
|
|
|
# colorsrc
|
|
# --------
|
|
@property
|
|
def colorsrc(self):
|
|
"""
|
|
Sets the source reference on Chart Studio Cloud for `color`.
|
|
|
|
The 'colorsrc' property must be specified as a string or
|
|
as a plotly.grid_objs.Column object
|
|
|
|
Returns
|
|
-------
|
|
str
|
|
"""
|
|
return self["colorsrc"]
|
|
|
|
@colorsrc.setter
|
|
def colorsrc(self, val):
|
|
self["colorsrc"] = val
|
|
|
|
# dash
|
|
# ----
|
|
@property
|
|
def dash(self):
|
|
"""
|
|
Sets the dash style of the lines.
|
|
|
|
The 'dash' property is an enumeration that may be specified as:
|
|
- One of the following enumeration values:
|
|
['dash', 'dashdot', 'dot', 'longdash', 'longdashdot',
|
|
'solid']
|
|
|
|
Returns
|
|
-------
|
|
Any
|
|
"""
|
|
return self["dash"]
|
|
|
|
@dash.setter
|
|
def dash(self, val):
|
|
self["dash"] = val
|
|
|
|
# reversescale
|
|
# ------------
|
|
@property
|
|
def reversescale(self):
|
|
"""
|
|
Reverses the color mapping if true. Has an effect only if in
|
|
`line.color` is set to a numerical array. If true, `line.cmin`
|
|
will correspond to the last color in the array and `line.cmax`
|
|
will correspond to the first color.
|
|
|
|
The 'reversescale' property must be specified as a bool
|
|
(either True, or False)
|
|
|
|
Returns
|
|
-------
|
|
bool
|
|
"""
|
|
return self["reversescale"]
|
|
|
|
@reversescale.setter
|
|
def reversescale(self, val):
|
|
self["reversescale"] = val
|
|
|
|
# showscale
|
|
# ---------
|
|
@property
|
|
def showscale(self):
|
|
"""
|
|
Determines whether or not a colorbar is displayed for this
|
|
trace. Has an effect only if in `line.color` is set to a
|
|
numerical array.
|
|
|
|
The 'showscale' property must be specified as a bool
|
|
(either True, or False)
|
|
|
|
Returns
|
|
-------
|
|
bool
|
|
"""
|
|
return self["showscale"]
|
|
|
|
@showscale.setter
|
|
def showscale(self, val):
|
|
self["showscale"] = val
|
|
|
|
# width
|
|
# -----
|
|
@property
|
|
def width(self):
|
|
"""
|
|
Sets the line width (in px).
|
|
|
|
The 'width' property is a number and may be specified as:
|
|
- An int or float in the interval [0, inf]
|
|
|
|
Returns
|
|
-------
|
|
int|float
|
|
"""
|
|
return self["width"]
|
|
|
|
@width.setter
|
|
def width(self, val):
|
|
self["width"] = val
|
|
|
|
# Self properties description
|
|
# ---------------------------
|
|
@property
|
|
def _prop_descriptions(self):
|
|
return """\
|
|
autocolorscale
|
|
Determines whether the colorscale is a default palette
|
|
(`autocolorscale: true`) or the palette determined by
|
|
`line.colorscale`. Has an effect only if in
|
|
`line.color` is set to a numerical array. In case
|
|
`colorscale` is unspecified or `autocolorscale` is
|
|
true, the default palette will be chosen according to
|
|
whether numbers in the `color` array are all positive,
|
|
all negative or mixed.
|
|
cauto
|
|
Determines whether or not the color domain is computed
|
|
with respect to the input data (here in `line.color`)
|
|
or the bounds set in `line.cmin` and `line.cmax` Has an
|
|
effect only if in `line.color` is set to a numerical
|
|
array. Defaults to `false` when `line.cmin` and
|
|
`line.cmax` are set by the user.
|
|
cmax
|
|
Sets the upper bound of the color domain. Has an effect
|
|
only if in `line.color` is set to a numerical array.
|
|
Value should have the same units as in `line.color` and
|
|
if set, `line.cmin` must be set as well.
|
|
cmid
|
|
Sets the mid-point of the color domain by scaling
|
|
`line.cmin` and/or `line.cmax` to be equidistant to
|
|
this point. Has an effect only if in `line.color` is
|
|
set to a numerical array. Value should have the same
|
|
units as in `line.color`. Has no effect when
|
|
`line.cauto` is `false`.
|
|
cmin
|
|
Sets the lower bound of the color domain. Has an effect
|
|
only if in `line.color` is set to a numerical array.
|
|
Value should have the same units as in `line.color` and
|
|
if set, `line.cmax` must be set as well.
|
|
color
|
|
Sets the line color. It accepts either a specific color
|
|
or an array of numbers that are mapped to the
|
|
colorscale relative to the max and min values of the
|
|
array or relative to `line.cmin` and `line.cmax` if
|
|
set.
|
|
coloraxis
|
|
Sets a reference to a shared color axis. References to
|
|
these shared color axes are "coloraxis", "coloraxis2",
|
|
"coloraxis3", etc. Settings for these shared color axes
|
|
are set in the layout, under `layout.coloraxis`,
|
|
`layout.coloraxis2`, etc. Note that multiple color
|
|
scales can be linked to the same color axis.
|
|
colorbar
|
|
:class:`plotly.graph_objects.scatter3d.line.ColorBar`
|
|
instance or dict with compatible properties
|
|
colorscale
|
|
Sets the colorscale. Has an effect only if in
|
|
`line.color` is set to a numerical array. The
|
|
colorscale must be an array containing arrays mapping a
|
|
normalized value to an rgb, rgba, hex, hsl, hsv, or
|
|
named color string. At minimum, a mapping for the
|
|
lowest (0) and highest (1) values are required. For
|
|
example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`.
|
|
To control the bounds of the colorscale in color space,
|
|
use `line.cmin` and `line.cmax`. Alternatively,
|
|
`colorscale` may be a palette name string of the
|
|
following list: Blackbody,Bluered,Blues,Cividis,Earth,E
|
|
lectric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,Rd
|
|
Bu,Reds,Viridis,YlGnBu,YlOrRd.
|
|
colorsrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`color`.
|
|
dash
|
|
Sets the dash style of the lines.
|
|
reversescale
|
|
Reverses the color mapping if true. Has an effect only
|
|
if in `line.color` is set to a numerical array. If
|
|
true, `line.cmin` will correspond to the last color in
|
|
the array and `line.cmax` will correspond to the first
|
|
color.
|
|
showscale
|
|
Determines whether or not a colorbar is displayed for
|
|
this trace. Has an effect only if in `line.color` is
|
|
set to a numerical array.
|
|
width
|
|
Sets the line width (in px).
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
arg=None,
|
|
autocolorscale=None,
|
|
cauto=None,
|
|
cmax=None,
|
|
cmid=None,
|
|
cmin=None,
|
|
color=None,
|
|
coloraxis=None,
|
|
colorbar=None,
|
|
colorscale=None,
|
|
colorsrc=None,
|
|
dash=None,
|
|
reversescale=None,
|
|
showscale=None,
|
|
width=None,
|
|
**kwargs,
|
|
):
|
|
"""
|
|
Construct a new Line object
|
|
|
|
Parameters
|
|
----------
|
|
arg
|
|
dict of properties compatible with this constructor or
|
|
an instance of
|
|
:class:`plotly.graph_objs.scatter3d.Line`
|
|
autocolorscale
|
|
Determines whether the colorscale is a default palette
|
|
(`autocolorscale: true`) or the palette determined by
|
|
`line.colorscale`. Has an effect only if in
|
|
`line.color` is set to a numerical array. In case
|
|
`colorscale` is unspecified or `autocolorscale` is
|
|
true, the default palette will be chosen according to
|
|
whether numbers in the `color` array are all positive,
|
|
all negative or mixed.
|
|
cauto
|
|
Determines whether or not the color domain is computed
|
|
with respect to the input data (here in `line.color`)
|
|
or the bounds set in `line.cmin` and `line.cmax` Has an
|
|
effect only if in `line.color` is set to a numerical
|
|
array. Defaults to `false` when `line.cmin` and
|
|
`line.cmax` are set by the user.
|
|
cmax
|
|
Sets the upper bound of the color domain. Has an effect
|
|
only if in `line.color` is set to a numerical array.
|
|
Value should have the same units as in `line.color` and
|
|
if set, `line.cmin` must be set as well.
|
|
cmid
|
|
Sets the mid-point of the color domain by scaling
|
|
`line.cmin` and/or `line.cmax` to be equidistant to
|
|
this point. Has an effect only if in `line.color` is
|
|
set to a numerical array. Value should have the same
|
|
units as in `line.color`. Has no effect when
|
|
`line.cauto` is `false`.
|
|
cmin
|
|
Sets the lower bound of the color domain. Has an effect
|
|
only if in `line.color` is set to a numerical array.
|
|
Value should have the same units as in `line.color` and
|
|
if set, `line.cmax` must be set as well.
|
|
color
|
|
Sets the line color. It accepts either a specific color
|
|
or an array of numbers that are mapped to the
|
|
colorscale relative to the max and min values of the
|
|
array or relative to `line.cmin` and `line.cmax` if
|
|
set.
|
|
coloraxis
|
|
Sets a reference to a shared color axis. References to
|
|
these shared color axes are "coloraxis", "coloraxis2",
|
|
"coloraxis3", etc. Settings for these shared color axes
|
|
are set in the layout, under `layout.coloraxis`,
|
|
`layout.coloraxis2`, etc. Note that multiple color
|
|
scales can be linked to the same color axis.
|
|
colorbar
|
|
:class:`plotly.graph_objects.scatter3d.line.ColorBar`
|
|
instance or dict with compatible properties
|
|
colorscale
|
|
Sets the colorscale. Has an effect only if in
|
|
`line.color` is set to a numerical array. The
|
|
colorscale must be an array containing arrays mapping a
|
|
normalized value to an rgb, rgba, hex, hsl, hsv, or
|
|
named color string. At minimum, a mapping for the
|
|
lowest (0) and highest (1) values are required. For
|
|
example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`.
|
|
To control the bounds of the colorscale in color space,
|
|
use `line.cmin` and `line.cmax`. Alternatively,
|
|
`colorscale` may be a palette name string of the
|
|
following list: Blackbody,Bluered,Blues,Cividis,Earth,E
|
|
lectric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,Rd
|
|
Bu,Reds,Viridis,YlGnBu,YlOrRd.
|
|
colorsrc
|
|
Sets the source reference on Chart Studio Cloud for
|
|
`color`.
|
|
dash
|
|
Sets the dash style of the lines.
|
|
reversescale
|
|
Reverses the color mapping if true. Has an effect only
|
|
if in `line.color` is set to a numerical array. If
|
|
true, `line.cmin` will correspond to the last color in
|
|
the array and `line.cmax` will correspond to the first
|
|
color.
|
|
showscale
|
|
Determines whether or not a colorbar is displayed for
|
|
this trace. Has an effect only if in `line.color` is
|
|
set to a numerical array.
|
|
width
|
|
Sets the line width (in px).
|
|
|
|
Returns
|
|
-------
|
|
Line
|
|
"""
|
|
super(Line, self).__init__("line")
|
|
|
|
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.scatter3d.Line
|
|
constructor must be a dict or
|
|
an instance of :class:`plotly.graph_objs.scatter3d.Line`"""
|
|
)
|
|
|
|
# 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("autocolorscale", None)
|
|
_v = autocolorscale if autocolorscale is not None else _v
|
|
if _v is not None:
|
|
self["autocolorscale"] = _v
|
|
_v = arg.pop("cauto", None)
|
|
_v = cauto if cauto is not None else _v
|
|
if _v is not None:
|
|
self["cauto"] = _v
|
|
_v = arg.pop("cmax", None)
|
|
_v = cmax if cmax is not None else _v
|
|
if _v is not None:
|
|
self["cmax"] = _v
|
|
_v = arg.pop("cmid", None)
|
|
_v = cmid if cmid is not None else _v
|
|
if _v is not None:
|
|
self["cmid"] = _v
|
|
_v = arg.pop("cmin", None)
|
|
_v = cmin if cmin is not None else _v
|
|
if _v is not None:
|
|
self["cmin"] = _v
|
|
_v = arg.pop("color", None)
|
|
_v = color if color is not None else _v
|
|
if _v is not None:
|
|
self["color"] = _v
|
|
_v = arg.pop("coloraxis", None)
|
|
_v = coloraxis if coloraxis is not None else _v
|
|
if _v is not None:
|
|
self["coloraxis"] = _v
|
|
_v = arg.pop("colorbar", None)
|
|
_v = colorbar if colorbar is not None else _v
|
|
if _v is not None:
|
|
self["colorbar"] = _v
|
|
_v = arg.pop("colorscale", None)
|
|
_v = colorscale if colorscale is not None else _v
|
|
if _v is not None:
|
|
self["colorscale"] = _v
|
|
_v = arg.pop("colorsrc", None)
|
|
_v = colorsrc if colorsrc is not None else _v
|
|
if _v is not None:
|
|
self["colorsrc"] = _v
|
|
_v = arg.pop("dash", None)
|
|
_v = dash if dash is not None else _v
|
|
if _v is not None:
|
|
self["dash"] = _v
|
|
_v = arg.pop("reversescale", None)
|
|
_v = reversescale if reversescale is not None else _v
|
|
if _v is not None:
|
|
self["reversescale"] = _v
|
|
_v = arg.pop("showscale", None)
|
|
_v = showscale if showscale is not None else _v
|
|
if _v is not None:
|
|
self["showscale"] = _v
|
|
_v = arg.pop("width", None)
|
|
_v = width if width is not None else _v
|
|
if _v is not None:
|
|
self["width"] = _v
|
|
|
|
# Process unknown kwargs
|
|
# ----------------------
|
|
self._process_kwargs(**dict(arg, **kwargs))
|
|
|
|
# Reset skip_invalid
|
|
# ------------------
|
|
self._skip_invalid = False
|