You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
758 lines
22 KiB
Python
758 lines
22 KiB
Python
from . import artist
|
|
from .axes import Axes
|
|
from .backend_bases import RendererBase, MouseEvent
|
|
from .path import Path
|
|
from .transforms import Transform, Bbox
|
|
|
|
from typing import Any, Literal, overload
|
|
|
|
import numpy as np
|
|
from numpy.typing import ArrayLike
|
|
from .typing import ColorType, LineStyleType, CapStyleType, JoinStyleType
|
|
|
|
class Patch(artist.Artist):
|
|
zorder: float
|
|
def __init__(
|
|
self,
|
|
*,
|
|
edgecolor: ColorType | None = ...,
|
|
facecolor: ColorType | None = ...,
|
|
color: ColorType | None = ...,
|
|
linewidth: float | None = ...,
|
|
linestyle: LineStyleType | None = ...,
|
|
antialiased: bool | None = ...,
|
|
hatch: str | None = ...,
|
|
fill: bool = ...,
|
|
capstyle: CapStyleType | None = ...,
|
|
joinstyle: JoinStyleType | None = ...,
|
|
**kwargs,
|
|
) -> None: ...
|
|
def get_verts(self) -> ArrayLike: ...
|
|
def contains(self, mouseevent: MouseEvent, radius: float | None = None) -> tuple[bool, dict[Any, Any]]: ...
|
|
def contains_point(
|
|
self, point: tuple[float, float], radius: float | None = ...
|
|
) -> bool: ...
|
|
def contains_points(
|
|
self, points: ArrayLike, radius: float | None = ...
|
|
) -> np.ndarray: ...
|
|
def get_extents(self) -> Bbox: ...
|
|
def get_transform(self) -> Transform: ...
|
|
def get_data_transform(self) -> Transform: ...
|
|
def get_patch_transform(self) -> Transform: ...
|
|
def get_antialiased(self) -> bool: ...
|
|
def get_edgecolor(self) -> ColorType: ...
|
|
def get_facecolor(self) -> ColorType: ...
|
|
def get_linewidth(self) -> float: ...
|
|
def get_linestyle(self) -> LineStyleType: ...
|
|
def set_antialiased(self, aa: bool | None) -> None: ...
|
|
def set_edgecolor(self, color: ColorType | None) -> None: ...
|
|
def set_facecolor(self, color: ColorType | None) -> None: ...
|
|
def set_color(self, c: ColorType | None) -> None: ...
|
|
def set_alpha(self, alpha: float | None) -> None: ...
|
|
def set_linewidth(self, w: float | None) -> None: ...
|
|
def set_linestyle(self, ls: LineStyleType | None) -> None: ...
|
|
def set_fill(self, b: bool) -> None: ...
|
|
def get_fill(self) -> bool: ...
|
|
fill = property(get_fill, set_fill)
|
|
def set_capstyle(self, s: CapStyleType) -> None: ...
|
|
def get_capstyle(self) -> Literal["butt", "projecting", "round"]: ...
|
|
def set_joinstyle(self, s: JoinStyleType) -> None: ...
|
|
def get_joinstyle(self) -> Literal["miter", "round", "bevel"]: ...
|
|
def set_hatch(self, hatch: str) -> None: ...
|
|
def set_hatch_linewidth(self, lw: float) -> None: ...
|
|
def get_hatch_linewidth(self) -> float: ...
|
|
def get_hatch(self) -> str: ...
|
|
def get_path(self) -> Path: ...
|
|
|
|
class Shadow(Patch):
|
|
patch: Patch
|
|
def __init__(self, patch: Patch, ox: float, oy: float, *, shade: float = ..., **kwargs) -> None: ...
|
|
|
|
class Rectangle(Patch):
|
|
angle: float
|
|
def __init__(
|
|
self,
|
|
xy: tuple[float, float],
|
|
width: float,
|
|
height: float,
|
|
*,
|
|
angle: float = ...,
|
|
rotation_point: Literal["xy", "center"] | tuple[float, float] = ...,
|
|
**kwargs,
|
|
) -> None: ...
|
|
@property
|
|
def rotation_point(self) -> Literal["xy", "center"] | tuple[float, float]: ...
|
|
@rotation_point.setter
|
|
def rotation_point(
|
|
self, value: Literal["xy", "center"] | tuple[float, float]
|
|
) -> None: ...
|
|
def get_x(self) -> float: ...
|
|
def get_y(self) -> float: ...
|
|
def get_xy(self) -> tuple[float, float]: ...
|
|
def get_corners(self) -> np.ndarray: ...
|
|
def get_center(self) -> np.ndarray: ...
|
|
def get_width(self) -> float: ...
|
|
def get_height(self) -> float: ...
|
|
def get_angle(self) -> float: ...
|
|
def set_x(self, x: float) -> None: ...
|
|
def set_y(self, y: float) -> None: ...
|
|
def set_angle(self, angle: float) -> None: ...
|
|
def set_xy(self, xy: tuple[float, float]) -> None: ...
|
|
def set_width(self, w: float) -> None: ...
|
|
def set_height(self, h: float) -> None: ...
|
|
@overload
|
|
def set_bounds(self, args: tuple[float, float, float, float], /) -> None: ...
|
|
@overload
|
|
def set_bounds(
|
|
self, left: float, bottom: float, width: float, height: float, /
|
|
) -> None: ...
|
|
def get_bbox(self) -> Bbox: ...
|
|
xy = property(get_xy, set_xy)
|
|
|
|
class RegularPolygon(Patch):
|
|
xy: tuple[float, float]
|
|
numvertices: int
|
|
orientation: float
|
|
radius: float
|
|
def __init__(
|
|
self,
|
|
xy: tuple[float, float],
|
|
numVertices: int,
|
|
*,
|
|
radius: float = ...,
|
|
orientation: float = ...,
|
|
**kwargs,
|
|
) -> None: ...
|
|
|
|
class PathPatch(Patch):
|
|
def __init__(self, path: Path, **kwargs) -> None: ...
|
|
def set_path(self, path: Path) -> None: ...
|
|
|
|
class StepPatch(PathPatch):
|
|
orientation: Literal["vertical", "horizontal"]
|
|
def __init__(
|
|
self,
|
|
values: ArrayLike,
|
|
edges: ArrayLike,
|
|
*,
|
|
orientation: Literal["vertical", "horizontal"] = ...,
|
|
baseline: float = ...,
|
|
**kwargs,
|
|
) -> None: ...
|
|
|
|
# NamedTuple StairData, defined in body of method
|
|
def get_data(self) -> tuple[np.ndarray, np.ndarray, float]: ...
|
|
def set_data(
|
|
self,
|
|
values: ArrayLike | None = ...,
|
|
edges: ArrayLike | None = ...,
|
|
baseline: float | None = ...,
|
|
) -> None: ...
|
|
|
|
class Polygon(Patch):
|
|
def __init__(self, xy: ArrayLike, *, closed: bool = ..., **kwargs) -> None: ...
|
|
def get_closed(self) -> bool: ...
|
|
def set_closed(self, closed: bool) -> None: ...
|
|
def get_xy(self) -> np.ndarray: ...
|
|
def set_xy(self, xy: ArrayLike) -> None: ...
|
|
xy = property(get_xy, set_xy)
|
|
|
|
class Wedge(Patch):
|
|
center: tuple[float, float]
|
|
r: float
|
|
theta1: float
|
|
theta2: float
|
|
width: float | None
|
|
def __init__(
|
|
self,
|
|
center: tuple[float, float],
|
|
r: float,
|
|
theta1: float,
|
|
theta2: float,
|
|
*,
|
|
width: float | None = ...,
|
|
**kwargs,
|
|
) -> None: ...
|
|
def set_center(self, center: tuple[float, float]) -> None: ...
|
|
def set_radius(self, radius: float) -> None: ...
|
|
def set_theta1(self, theta1: float) -> None: ...
|
|
def set_theta2(self, theta2: float) -> None: ...
|
|
def set_width(self, width: float | None) -> None: ...
|
|
|
|
class Arrow(Patch):
|
|
def __init__(
|
|
self, x: float, y: float, dx: float, dy: float, *, width: float = ..., **kwargs
|
|
) -> None: ...
|
|
def set_data(
|
|
self,
|
|
x: float | None = ...,
|
|
y: float | None = ...,
|
|
dx: float | None = ...,
|
|
dy: float | None = ...,
|
|
width: float | None = ...,
|
|
) -> None: ...
|
|
class FancyArrow(Polygon):
|
|
def __init__(
|
|
self,
|
|
x: float,
|
|
y: float,
|
|
dx: float,
|
|
dy: float,
|
|
*,
|
|
width: float = ...,
|
|
length_includes_head: bool = ...,
|
|
head_width: float | None = ...,
|
|
head_length: float | None = ...,
|
|
shape: Literal["full", "left", "right"] = ...,
|
|
overhang: float = ...,
|
|
head_starts_at_zero: bool = ...,
|
|
**kwargs,
|
|
) -> None: ...
|
|
def set_data(
|
|
self,
|
|
*,
|
|
x: float | None = ...,
|
|
y: float | None = ...,
|
|
dx: float | None = ...,
|
|
dy: float | None = ...,
|
|
width: float | None = ...,
|
|
head_width: float | None = ...,
|
|
head_length: float | None = ...,
|
|
) -> None: ...
|
|
|
|
class CirclePolygon(RegularPolygon):
|
|
def __init__(
|
|
self,
|
|
xy: tuple[float, float],
|
|
radius: float = ...,
|
|
*,
|
|
resolution: int = ...,
|
|
**kwargs,
|
|
) -> None: ...
|
|
|
|
class Ellipse(Patch):
|
|
def __init__(
|
|
self,
|
|
xy: tuple[float, float],
|
|
width: float,
|
|
height: float,
|
|
*,
|
|
angle: float = ...,
|
|
**kwargs,
|
|
) -> None: ...
|
|
def set_center(self, xy: tuple[float, float]) -> None: ...
|
|
def get_center(self) -> float: ...
|
|
center = property(get_center, set_center)
|
|
|
|
def set_width(self, width: float) -> None: ...
|
|
def get_width(self) -> float: ...
|
|
width = property(get_width, set_width)
|
|
|
|
def set_height(self, height: float) -> None: ...
|
|
def get_height(self) -> float: ...
|
|
height = property(get_height, set_height)
|
|
|
|
def set_angle(self, angle: float) -> None: ...
|
|
def get_angle(self) -> float: ...
|
|
angle = property(get_angle, set_angle)
|
|
|
|
def get_corners(self) -> np.ndarray: ...
|
|
|
|
def get_vertices(self) -> list[tuple[float, float]]: ...
|
|
def get_co_vertices(self) -> list[tuple[float, float]]: ...
|
|
|
|
|
|
class Annulus(Patch):
|
|
a: float
|
|
b: float
|
|
def __init__(
|
|
self,
|
|
xy: tuple[float, float],
|
|
r: float | tuple[float, float],
|
|
width: float,
|
|
angle: float = ...,
|
|
**kwargs,
|
|
) -> None: ...
|
|
def set_center(self, xy: tuple[float, float]) -> None: ...
|
|
def get_center(self) -> tuple[float, float]: ...
|
|
center = property(get_center, set_center)
|
|
|
|
def set_width(self, width: float) -> None: ...
|
|
def get_width(self) -> float: ...
|
|
width = property(get_width, set_width)
|
|
|
|
def set_angle(self, angle: float) -> None: ...
|
|
def get_angle(self) -> float: ...
|
|
angle = property(get_angle, set_angle)
|
|
|
|
def set_semimajor(self, a: float) -> None: ...
|
|
def set_semiminor(self, b: float) -> None: ...
|
|
def set_radii(self, r: float | tuple[float, float]) -> None: ...
|
|
def get_radii(self) -> tuple[float, float]: ...
|
|
radii = property(get_radii, set_radii)
|
|
|
|
class Circle(Ellipse):
|
|
def __init__(
|
|
self, xy: tuple[float, float], radius: float = ..., **kwargs
|
|
) -> None: ...
|
|
def set_radius(self, radius: float) -> None: ...
|
|
def get_radius(self) -> float: ...
|
|
radius = property(get_radius, set_radius)
|
|
|
|
class Arc(Ellipse):
|
|
theta1: float
|
|
theta2: float
|
|
def __init__(
|
|
self,
|
|
xy: tuple[float, float],
|
|
width: float,
|
|
height: float,
|
|
*,
|
|
angle: float = ...,
|
|
theta1: float = ...,
|
|
theta2: float = ...,
|
|
**kwargs,
|
|
) -> None: ...
|
|
|
|
def bbox_artist(
|
|
artist: artist.Artist,
|
|
renderer: RendererBase,
|
|
props: dict[str, Any] | None = ...,
|
|
fill: bool = ...,
|
|
) -> None: ...
|
|
def draw_bbox(
|
|
bbox: Bbox,
|
|
renderer: RendererBase,
|
|
color: ColorType = ...,
|
|
trans: Transform | None = ...,
|
|
) -> None: ...
|
|
|
|
class _Style:
|
|
def __new__(cls, stylename, **kwargs): ...
|
|
@classmethod
|
|
def get_styles(cls) -> dict[str, type]: ...
|
|
@classmethod
|
|
def pprint_styles(cls) -> str: ...
|
|
@classmethod
|
|
def register(cls, name: str, style: type) -> None: ...
|
|
|
|
class BoxStyle(_Style):
|
|
class Square(BoxStyle):
|
|
pad: float
|
|
def __init__(self, pad: float = ...) -> None: ...
|
|
def __call__(
|
|
self,
|
|
x0: float,
|
|
y0: float,
|
|
width: float,
|
|
height: float,
|
|
mutation_size: float,
|
|
) -> Path: ...
|
|
|
|
class Circle(BoxStyle):
|
|
pad: float
|
|
def __init__(self, pad: float = ...) -> None: ...
|
|
def __call__(
|
|
self,
|
|
x0: float,
|
|
y0: float,
|
|
width: float,
|
|
height: float,
|
|
mutation_size: float,
|
|
) -> Path: ...
|
|
|
|
class Ellipse(BoxStyle):
|
|
pad: float
|
|
def __init__(self, pad: float = ...) -> None: ...
|
|
def __call__(
|
|
self,
|
|
x0: float,
|
|
y0: float,
|
|
width: float,
|
|
height: float,
|
|
mutation_size: float,
|
|
) -> Path: ...
|
|
|
|
class LArrow(BoxStyle):
|
|
pad: float
|
|
def __init__(self, pad: float = ...) -> None: ...
|
|
def __call__(
|
|
self,
|
|
x0: float,
|
|
y0: float,
|
|
width: float,
|
|
height: float,
|
|
mutation_size: float,
|
|
) -> Path: ...
|
|
|
|
class RArrow(LArrow):
|
|
def __call__(
|
|
self,
|
|
x0: float,
|
|
y0: float,
|
|
width: float,
|
|
height: float,
|
|
mutation_size: float,
|
|
) -> Path: ...
|
|
|
|
class DArrow(BoxStyle):
|
|
pad: float
|
|
def __init__(self, pad: float = ...) -> None: ...
|
|
def __call__(
|
|
self,
|
|
x0: float,
|
|
y0: float,
|
|
width: float,
|
|
height: float,
|
|
mutation_size: float,
|
|
) -> Path: ...
|
|
|
|
class Round(BoxStyle):
|
|
pad: float
|
|
rounding_size: float | None
|
|
def __init__(
|
|
self, pad: float = ..., rounding_size: float | None = ...
|
|
) -> None: ...
|
|
def __call__(
|
|
self,
|
|
x0: float,
|
|
y0: float,
|
|
width: float,
|
|
height: float,
|
|
mutation_size: float,
|
|
) -> Path: ...
|
|
|
|
class Round4(BoxStyle):
|
|
pad: float
|
|
rounding_size: float | None
|
|
def __init__(
|
|
self, pad: float = ..., rounding_size: float | None = ...
|
|
) -> None: ...
|
|
def __call__(
|
|
self,
|
|
x0: float,
|
|
y0: float,
|
|
width: float,
|
|
height: float,
|
|
mutation_size: float,
|
|
) -> Path: ...
|
|
|
|
class Sawtooth(BoxStyle):
|
|
pad: float
|
|
tooth_size: float | None
|
|
def __init__(
|
|
self, pad: float = ..., tooth_size: float | None = ...
|
|
) -> None: ...
|
|
def __call__(
|
|
self,
|
|
x0: float,
|
|
y0: float,
|
|
width: float,
|
|
height: float,
|
|
mutation_size: float,
|
|
) -> Path: ...
|
|
|
|
class Roundtooth(Sawtooth):
|
|
def __call__(
|
|
self,
|
|
x0: float,
|
|
y0: float,
|
|
width: float,
|
|
height: float,
|
|
mutation_size: float,
|
|
) -> Path: ...
|
|
|
|
class ConnectionStyle(_Style):
|
|
class _Base(ConnectionStyle):
|
|
def __call__(
|
|
self,
|
|
posA: tuple[float, float],
|
|
posB: tuple[float, float],
|
|
shrinkA: float = ...,
|
|
shrinkB: float = ...,
|
|
patchA: Patch | None = ...,
|
|
patchB: Patch | None = ...,
|
|
) -> Path: ...
|
|
|
|
class Arc3(_Base):
|
|
rad: float
|
|
def __init__(self, rad: float = ...) -> None: ...
|
|
def connect(
|
|
self, posA: tuple[float, float], posB: tuple[float, float]
|
|
) -> Path: ...
|
|
|
|
class Angle3(_Base):
|
|
angleA: float
|
|
angleB: float
|
|
def __init__(self, angleA: float = ..., angleB: float = ...) -> None: ...
|
|
def connect(
|
|
self, posA: tuple[float, float], posB: tuple[float, float]
|
|
) -> Path: ...
|
|
|
|
class Angle(_Base):
|
|
angleA: float
|
|
angleB: float
|
|
rad: float
|
|
def __init__(
|
|
self, angleA: float = ..., angleB: float = ..., rad: float = ...
|
|
) -> None: ...
|
|
def connect(
|
|
self, posA: tuple[float, float], posB: tuple[float, float]
|
|
) -> Path: ...
|
|
|
|
class Arc(_Base):
|
|
angleA: float
|
|
angleB: float
|
|
armA: float | None
|
|
armB: float | None
|
|
rad: float
|
|
def __init__(
|
|
self,
|
|
angleA: float = ...,
|
|
angleB: float = ...,
|
|
armA: float | None = ...,
|
|
armB: float | None = ...,
|
|
rad: float = ...,
|
|
) -> None: ...
|
|
def connect(
|
|
self, posA: tuple[float, float], posB: tuple[float, float]
|
|
) -> Path: ...
|
|
|
|
class Bar(_Base):
|
|
armA: float
|
|
armB: float
|
|
fraction: float
|
|
angle: float | None
|
|
def __init__(
|
|
self,
|
|
armA: float = ...,
|
|
armB: float = ...,
|
|
fraction: float = ...,
|
|
angle: float | None = ...,
|
|
) -> None: ...
|
|
def connect(
|
|
self, posA: tuple[float, float], posB: tuple[float, float]
|
|
) -> Path: ...
|
|
|
|
class ArrowStyle(_Style):
|
|
class _Base(ArrowStyle):
|
|
@staticmethod
|
|
def ensure_quadratic_bezier(path: Path) -> list[float]: ...
|
|
def transmute(
|
|
self, path: Path, mutation_size: float, linewidth: float
|
|
) -> tuple[Path, bool]: ...
|
|
def __call__(
|
|
self,
|
|
path: Path,
|
|
mutation_size: float,
|
|
linewidth: float,
|
|
aspect_ratio: float = ...,
|
|
) -> tuple[Path, bool]: ...
|
|
|
|
class _Curve(_Base):
|
|
arrow: str
|
|
fillbegin: bool
|
|
fillend: bool
|
|
def __init__(
|
|
self,
|
|
head_length: float = ...,
|
|
head_width: float = ...,
|
|
widthA: float = ...,
|
|
widthB: float = ...,
|
|
lengthA: float = ...,
|
|
lengthB: float = ...,
|
|
angleA: float | None = ...,
|
|
angleB: float | None = ...,
|
|
scaleA: float | None = ...,
|
|
scaleB: float | None = ...,
|
|
) -> None: ...
|
|
|
|
class Curve(_Curve):
|
|
def __init__(self) -> None: ...
|
|
|
|
class CurveA(_Curve):
|
|
arrow: str
|
|
|
|
class CurveB(_Curve):
|
|
arrow: str
|
|
|
|
class CurveAB(_Curve):
|
|
arrow: str
|
|
|
|
class CurveFilledA(_Curve):
|
|
arrow: str
|
|
|
|
class CurveFilledB(_Curve):
|
|
arrow: str
|
|
|
|
class CurveFilledAB(_Curve):
|
|
arrow: str
|
|
|
|
class BracketA(_Curve):
|
|
arrow: str
|
|
def __init__(
|
|
self, widthA: float = ..., lengthA: float = ..., angleA: float = ...
|
|
) -> None: ...
|
|
|
|
class BracketB(_Curve):
|
|
arrow: str
|
|
def __init__(
|
|
self, widthB: float = ..., lengthB: float = ..., angleB: float = ...
|
|
) -> None: ...
|
|
|
|
class BracketAB(_Curve):
|
|
arrow: str
|
|
def __init__(
|
|
self,
|
|
widthA: float = ...,
|
|
lengthA: float = ...,
|
|
angleA: float = ...,
|
|
widthB: float = ...,
|
|
lengthB: float = ...,
|
|
angleB: float = ...,
|
|
) -> None: ...
|
|
|
|
class BarAB(_Curve):
|
|
arrow: str
|
|
def __init__(
|
|
self,
|
|
widthA: float = ...,
|
|
angleA: float = ...,
|
|
widthB: float = ...,
|
|
angleB: float = ...,
|
|
) -> None: ...
|
|
|
|
class BracketCurve(_Curve):
|
|
arrow: str
|
|
def __init__(
|
|
self, widthA: float = ..., lengthA: float = ..., angleA: float | None = ...
|
|
) -> None: ...
|
|
|
|
class CurveBracket(_Curve):
|
|
arrow: str
|
|
def __init__(
|
|
self, widthB: float = ..., lengthB: float = ..., angleB: float | None = ...
|
|
) -> None: ...
|
|
|
|
class Simple(_Base):
|
|
def __init__(
|
|
self,
|
|
head_length: float = ...,
|
|
head_width: float = ...,
|
|
tail_width: float = ...,
|
|
) -> None: ...
|
|
|
|
class Fancy(_Base):
|
|
def __init__(
|
|
self,
|
|
head_length: float = ...,
|
|
head_width: float = ...,
|
|
tail_width: float = ...,
|
|
) -> None: ...
|
|
|
|
class Wedge(_Base):
|
|
tail_width: float
|
|
shrink_factor: float
|
|
def __init__(
|
|
self, tail_width: float = ..., shrink_factor: float = ...
|
|
) -> None: ...
|
|
|
|
class FancyBboxPatch(Patch):
|
|
def __init__(
|
|
self,
|
|
xy: tuple[float, float],
|
|
width: float,
|
|
height: float,
|
|
boxstyle: str | BoxStyle = ...,
|
|
*,
|
|
mutation_scale: float = ...,
|
|
mutation_aspect: float = ...,
|
|
**kwargs,
|
|
) -> None: ...
|
|
def set_boxstyle(self, boxstyle: str | BoxStyle | None = ..., **kwargs) -> None: ...
|
|
def get_boxstyle(self) -> BoxStyle: ...
|
|
def set_mutation_scale(self, scale: float) -> None: ...
|
|
def get_mutation_scale(self) -> float: ...
|
|
def set_mutation_aspect(self, aspect: float) -> None: ...
|
|
def get_mutation_aspect(self) -> float: ...
|
|
def get_x(self) -> float: ...
|
|
def get_y(self) -> float: ...
|
|
def get_width(self) -> float: ...
|
|
def get_height(self) -> float: ...
|
|
def set_x(self, x: float) -> None: ...
|
|
def set_y(self, y: float) -> None: ...
|
|
def set_width(self, w: float) -> None: ...
|
|
def set_height(self, h: float) -> None: ...
|
|
@overload
|
|
def set_bounds(self, args: tuple[float, float, float, float], /) -> None: ...
|
|
@overload
|
|
def set_bounds(
|
|
self, left: float, bottom: float, width: float, height: float, /
|
|
) -> None: ...
|
|
def get_bbox(self) -> Bbox: ...
|
|
|
|
class FancyArrowPatch(Patch):
|
|
patchA: Patch
|
|
patchB: Patch
|
|
shrinkA: float
|
|
shrinkB: float
|
|
def __init__(
|
|
self,
|
|
posA: tuple[float, float] | None = ...,
|
|
posB: tuple[float, float] | None = ...,
|
|
*,
|
|
path: Path | None = ...,
|
|
arrowstyle: str | ArrowStyle = ...,
|
|
connectionstyle: str | ConnectionStyle = ...,
|
|
patchA: Patch | None = ...,
|
|
patchB: Patch | None = ...,
|
|
shrinkA: float = ...,
|
|
shrinkB: float = ...,
|
|
mutation_scale: float = ...,
|
|
mutation_aspect: float | None = ...,
|
|
**kwargs,
|
|
) -> None: ...
|
|
def set_positions(
|
|
self, posA: tuple[float, float], posB: tuple[float, float]
|
|
) -> None: ...
|
|
def set_patchA(self, patchA: Patch) -> None: ...
|
|
def set_patchB(self, patchB: Patch) -> None: ...
|
|
def set_connectionstyle(self, connectionstyle: str | ConnectionStyle | None = ..., **kwargs) -> None: ...
|
|
def get_connectionstyle(self) -> ConnectionStyle: ...
|
|
def set_arrowstyle(self, arrowstyle: str | ArrowStyle | None = ..., **kwargs) -> None: ...
|
|
def get_arrowstyle(self) -> ArrowStyle: ...
|
|
def set_mutation_scale(self, scale: float) -> None: ...
|
|
def get_mutation_scale(self) -> float: ...
|
|
def set_mutation_aspect(self, aspect: float | None) -> None: ...
|
|
def get_mutation_aspect(self) -> float: ...
|
|
|
|
class ConnectionPatch(FancyArrowPatch):
|
|
xy1: tuple[float, float]
|
|
xy2: tuple[float, float]
|
|
coords1: str | Transform
|
|
coords2: str | Transform | None
|
|
axesA: Axes | None
|
|
axesB: Axes | None
|
|
def __init__(
|
|
self,
|
|
xyA: tuple[float, float],
|
|
xyB: tuple[float, float],
|
|
coordsA: str | Transform,
|
|
coordsB: str | Transform | None = ...,
|
|
*,
|
|
axesA: Axes | None = ...,
|
|
axesB: Axes | None = ...,
|
|
arrowstyle: str | ArrowStyle = ...,
|
|
connectionstyle: str | ConnectionStyle = ...,
|
|
patchA: Patch | None = ...,
|
|
patchB: Patch | None = ...,
|
|
shrinkA: float = ...,
|
|
shrinkB: float = ...,
|
|
mutation_scale: float = ...,
|
|
mutation_aspect: float | None = ...,
|
|
clip_on: bool = ...,
|
|
**kwargs,
|
|
) -> None: ...
|
|
def set_annotation_clip(self, b: bool | None) -> None: ...
|
|
def get_annotation_clip(self) -> bool | None: ...
|