_image.py

fromplotly.basedatatypesimportBaseTraceTypeas_BaseTraceType
importcopyas_copy


classImage(_BaseTraceType):

# class properties
# --------------------
_parent_path_str=""
_path_str="image"
_valid_props= {
"colormodel",
"customdata",
"customdatasrc",
"dx",
"dy",
"hoverinfo",
"hoverinfosrc",
"hoverlabel",
"hovertemplate",
"hovertemplatesrc",
"hovertext",
"hovertextsrc",
"ids",
"idssrc",
"legend",
"legendgrouptitle",
"legendrank",
"legendwidth",
"meta",
"metasrc",
"name",
"opacity",
"source",
"stream",
"text",
"textsrc",
"type",
"uid",
"uirevision",
"visible",
"x0",
"xaxis",
"y0",
"yaxis",
"z",
"zmax",
"zmin",
"zorder",
"zsmooth",
"zsrc",
 }

# colormodel
# ----------
@property
defcolormodel(self):
"""
 Color model used to map the numerical color components
 described in `z` into colors. If `source` is specified, this
 attribute will be set to `rgba256` otherwise it defaults to
 `rgb`.

 The 'colormodel' property is an enumeration that may be specified as:
 - One of the following enumeration values:
 ['rgb', 'rgba', 'rgba256', 'hsl', 'hsla']

 Returns
 -------
 Any
 """
returnself["colormodel"]

@colormodel.setter
defcolormodel(self, val):
self["colormodel"] =val

# customdata
# ----------
@property
defcustomdata(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
 """
returnself["customdata"]

@customdata.setter
defcustomdata(self, val):
self["customdata"] =val

# customdatasrc
# -------------
@property
defcustomdatasrc(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
 """
returnself["customdatasrc"]

@customdatasrc.setter
defcustomdatasrc(self, val):
self["customdatasrc"] =val

# dx
# --
@property
defdx(self):
"""
 Set the pixel's horizontal size.

 The 'dx' property is a number and may be specified as:
 - An int or float

 Returns
 -------
 int|float
 """
returnself["dx"]

@dx.setter
defdx(self, val):
self["dx"] =val

# dy
# --
@property
defdy(self):
"""
 Set the pixel's vertical size

 The 'dy' property is a number and may be specified as:
 - An int or float

 Returns
 -------
 int|float
 """
returnself["dy"]

@dy.setter
defdy(self, val):
self["dy"] =val

# hoverinfo
# ---------
@property
defhoverinfo(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', 'color', 'name', 'text'] 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
 """
returnself["hoverinfo"]

@hoverinfo.setter
defhoverinfo(self, val):
self["hoverinfo"] =val

# hoverinfosrc
# ------------
@property
defhoverinfosrc(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
 """
returnself["hoverinfosrc"]

@hoverinfosrc.setter
defhoverinfosrc(self, val):
self["hoverinfosrc"] =val

# hoverlabel
# ----------
@property
defhoverlabel(self):
"""
 The 'hoverlabel' property is an instance of Hoverlabel
 that may be specified as:
 - An instance of :class:`plotly.graph_objs.image.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.image.Hoverlabel
 """
returnself["hoverlabel"]

@hoverlabel.setter
defhoverlabel(self, val):
self["hoverlabel"] =val

# hovertemplate
# -------------
@property
defhovertemplate(self):
"""
 Template string used for rendering the information that appear
 on hover box. Note that this will override `hoverinfo`.
 Variables are inserted using %{variable}, for example "y: %{y}"
 as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When
 showing info for several points, "xother" will be added to
 those with different x positions from the first point. An
 underscore before or after "(x|y)other" will add a space on
 that side, only when this field is shown. Numbers are formatted
 using d3-format's syntax %{variable:d3-format}, for example
 "Price: %{y:$.2f}".
 https://github.com/d3/d3-format/tree/v1.4.5#d3-format for
 details on the formatting syntax. Dates are formatted using
 d3-time-format's syntax %{variable|d3-time-format}, for example
 "Day: %{2019-01-01|%A}". https://github.com/d3/d3-time-
 format/tree/v2.2.3#locale_format for details on the date
 formatting syntax. The variables available in `hovertemplate`
 are the ones emitted as event data described at this link
 https://plotly.com/javascript/plotlyjs-events/#event-data.
 Additionally, every attributes that can be specified per-point
 (the ones that are `arrayOk: true`) are available. Finally, the
 template string has access to variables `z`, `color` and
 `colormodel`. Anything contained in tag `<extra>` is displayed
 in the secondary box, for example
 "<extra>{fullData.name}</extra>". To hide the secondary box
 completely, use an empty tag `<extra></extra>`.

 The 'hovertemplate' 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
 """
returnself["hovertemplate"]

@hovertemplate.setter
defhovertemplate(self, val):
self["hovertemplate"] =val

# hovertemplatesrc
# ----------------
@property
defhovertemplatesrc(self):
"""
 Sets the source reference on Chart Studio Cloud for
 `hovertemplate`.

 The 'hovertemplatesrc' property must be specified as a string or
 as a plotly.grid_objs.Column object

 Returns
 -------
 str
 """
returnself["hovertemplatesrc"]

@hovertemplatesrc.setter
defhovertemplatesrc(self, val):
self["hovertemplatesrc"] =val

# hovertext
# ---------
@property
defhovertext(self):
"""
 Same as `text`.

 The 'hovertext' property is an array that may be specified as a tuple,
 list, numpy array, or pandas Series

 Returns
 -------
 numpy.ndarray
 """
returnself["hovertext"]

@hovertext.setter
defhovertext(self, val):
self["hovertext"] =val

# hovertextsrc
# ------------
@property
defhovertextsrc(self):
"""
 Sets the source reference on Chart Studio Cloud for
 `hovertext`.

 The 'hovertextsrc' property must be specified as a string or
 as a plotly.grid_objs.Column object

 Returns
 -------
 str
 """
returnself["hovertextsrc"]

@hovertextsrc.setter
defhovertextsrc(self, val):
self["hovertextsrc"] =val

# ids
# ---
@property
defids(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
 """
returnself["ids"]

@ids.setter
defids(self, val):
self["ids"] =val

# idssrc
# ------
@property
defidssrc(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
 """
returnself["idssrc"]

@idssrc.setter
defidssrc(self, val):
self["idssrc"] =val

# legend
# ------
@property
deflegend(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
 """
returnself["legend"]

@legend.setter
deflegend(self, val):
self["legend"] =val

# legendgrouptitle
# ----------------
@property
deflegendgrouptitle(self):
"""
 The 'legendgrouptitle' property is an instance of Legendgrouptitle
 that may be specified as:
 - An instance of :class:`plotly.graph_objs.image.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.image.Legendgrouptitle
 """
returnself["legendgrouptitle"]

@legendgrouptitle.setter
deflegendgrouptitle(self, val):
self["legendgrouptitle"] =val

# legendrank
# ----------
@property
deflegendrank(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
 """
returnself["legendrank"]

@legendrank.setter
deflegendrank(self, val):
self["legendrank"] =val

# legendwidth
# -----------
@property
deflegendwidth(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
 """
returnself["legendwidth"]

@legendwidth.setter
deflegendwidth(self, val):
self["legendwidth"] =val

# meta
# ----
@property
defmeta(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
 """
returnself["meta"]

@meta.setter
defmeta(self, val):
self["meta"] =val

# metasrc
# -------
@property
defmetasrc(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
 """
returnself["metasrc"]

@metasrc.setter
defmetasrc(self, val):
self["metasrc"] =val

# name
# ----
@property
defname(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
 """
returnself["name"]

@name.setter
defname(self, val):
self["name"] =val

# opacity
# -------
@property
defopacity(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
 """
returnself["opacity"]

@opacity.setter
defopacity(self, val):
self["opacity"] =val

# source
# ------
@property
defsource(self):
"""
 Specifies the data URI of the image to be visualized. The URI
 consists of "data:image/[<media subtype>][;base64],<data>"

 The 'source' property is a string and must be specified as:
 - A string
 - A number that will be converted to a string

 Returns
 -------
 str
 """
returnself["source"]

@source.setter
defsource(self, val):
self["source"] =val

# stream
# ------
@property
defstream(self):
"""
 The 'stream' property is an instance of Stream
 that may be specified as:
 - An instance of :class:`plotly.graph_objs.image.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.image.Stream
 """
returnself["stream"]

@stream.setter
defstream(self, val):
self["stream"] =val

# text
# ----
@property
deftext(self):
"""
 Sets the text elements associated with each z value.

 The 'text' property is an array that may be specified as a tuple,
 list, numpy array, or pandas Series

 Returns
 -------
 numpy.ndarray
 """
returnself["text"]

@text.setter
deftext(self, val):
self["text"] =val

# textsrc
# -------
@property
deftextsrc(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
 """
returnself["textsrc"]

@textsrc.setter
deftextsrc(self, val):
self["textsrc"] =val

# uid
# ---
@property
defuid(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
 """
returnself["uid"]

@uid.setter
defuid(self, val):
self["uid"] =val

# uirevision
# ----------
@property
defuirevision(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
 """
returnself["uirevision"]

@uirevision.setter
defuirevision(self, val):
self["uirevision"] =val

# visible
# -------
@property
defvisible(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
 """
returnself["visible"]

@visible.setter
defvisible(self, val):
self["visible"] =val

# x0
# --
@property
defx0(self):
"""
 Set the image's x position. The left edge of the image (or the
 right edge if the x axis is reversed or dx is negative) will be
 found at xmin=x0-dx/2

 The 'x0' property accepts values of any type

 Returns
 -------
 Any
 """
returnself["x0"]

@x0.setter
defx0(self, val):
self["x0"] =val

# xaxis
# -----
@property
defxaxis(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
 """
returnself["xaxis"]

@xaxis.setter
defxaxis(self, val):
self["xaxis"] =val

# y0
# --
@property
defy0(self):
"""
 Set the image's y position. The top edge of the image (or the
 bottom edge if the y axis is NOT reversed or if dy is negative)
 will be found at ymin=y0-dy/2. By default when an image trace
 is included, the y axis will be reversed so that the image is
 right-side-up, but you can disable this by setting
 yaxis.autorange=true or by providing an explicit y axis range.

 The 'y0' property accepts values of any type

 Returns
 -------
 Any
 """
returnself["y0"]

@y0.setter
defy0(self, val):
self["y0"] =val

# yaxis
# -----
@property
defyaxis(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
 """
returnself["yaxis"]

@yaxis.setter
defyaxis(self, val):
self["yaxis"] =val

# z
# -
@property
defz(self):
"""
 A 2-dimensional array in which each element is an array of 3 or
 4 numbers representing a color.

 The 'z' property is an array that may be specified as a tuple,
 list, numpy array, or pandas Series

 Returns
 -------
 numpy.ndarray
 """
returnself["z"]

@z.setter
defz(self, val):
self["z"] =val

# zmax
# ----
@property
defzmax(self):
"""
 Array defining the higher bound for each color component. Note
 that the default value will depend on the colormodel. For the
 `rgb` colormodel, it is [255, 255, 255]. For the `rgba`
 colormodel, it is [255, 255, 255, 1]. For the `rgba256`
 colormodel, it is [255, 255, 255, 255]. For the `hsl`
 colormodel, it is [360, 100, 100]. For the `hsla` colormodel,
 it is [360, 100, 100, 1].

 The 'zmax' property is an info array that may be specified as:

 * a list or tuple of 4 elements where:
 (0) The 'zmax[0]' property is a number and may be specified as:
 - An int or float
 (1) The 'zmax[1]' property is a number and may be specified as:
 - An int or float
 (2) The 'zmax[2]' property is a number and may be specified as:
 - An int or float
 (3) The 'zmax[3]' property is a number and may be specified as:
 - An int or float

 Returns
 -------
 list
 """
returnself["zmax"]

@zmax.setter
defzmax(self, val):
self["zmax"] =val

# zmin
# ----
@property
defzmin(self):
"""
 Array defining the lower bound for each color component. Note
 that the default value will depend on the colormodel. For the
 `rgb` colormodel, it is [0, 0, 0]. For the `rgba` colormodel,
 it is [0, 0, 0, 0]. For the `rgba256` colormodel, it is [0, 0,
 0, 0]. For the `hsl` colormodel, it is [0, 0, 0]. For the
 `hsla` colormodel, it is [0, 0, 0, 0].

 The 'zmin' property is an info array that may be specified as:

 * a list or tuple of 4 elements where:
 (0) The 'zmin[0]' property is a number and may be specified as:
 - An int or float
 (1) The 'zmin[1]' property is a number and may be specified as:
 - An int or float
 (2) The 'zmin[2]' property is a number and may be specified as:
 - An int or float
 (3) The 'zmin[3]' property is a number and may be specified as:
 - An int or float

 Returns
 -------
 list
 """
returnself["zmin"]

@zmin.setter
defzmin(self, val):
self["zmin"] =val

# zorder
# ------
@property
defzorder(self):
"""
 Sets the layer on which this trace is displayed, relative to
 other SVG traces on the same subplot. SVG traces with higher
 `zorder` appear in front of those with lower `zorder`.

 The 'zorder' property is a integer and may be specified as:
 - An int (or float that will be cast to an int)

 Returns
 -------
 int
 """
returnself["zorder"]

@zorder.setter
defzorder(self, val):
self["zorder"] =val

# zsmooth
# -------
@property
defzsmooth(self):
"""
 Picks a smoothing algorithm used to smooth `z` data. This only
 applies for image traces that use the `source` attribute.

 The 'zsmooth' property is an enumeration that may be specified as:
 - One of the following enumeration values:
 ['fast', False]