rkviewer.canvas package

Submodules

rkviewer.canvas.canvas module

The main canvas panel.

This handles user input actions, updates the model, and performs redraws after the model is updated.

class rkviewer.canvas.canvas.Alignment(value)

Bases: enum.Enum

BOTTOM = 4

CENTER = 2

GRID = 6

HORIZONTAL = 7

Arrange into a row

LEFT = 0

MIDDLE = 5

RIGHT = 1

TOP = 3

VERTICAL = 8

Arrange into a column

rkviewer.canvas.canvas.BOUNDS_EPS = 0

The padding around the canvas to ensure nodes are not moved out of bounds due to floating pont issues.

rkviewer.canvas.canvas.BOUNDS_EPS_VEC = (0, 0)

2D bounds vector formed from BOUNDS_EPS

class rkviewer.canvas.canvas.Canvas(controller, zoom_slider, *args, realsize, **kw)

Bases: wx.

The main window onto which nodes, reactions, etc. will be drawn.

MIN_ZOOM_LEVEL

The minimum zoom level the user is allowed to reach. See SetZoomLevel() for more detail.

MAX_ZOOM_LEVEL

The maximum zoom level the user is allowed to reach.

NODE_LAYER

The node layer.

REACTION_LAYER

The reaction layer.

SELECT_BOX_LAYER

The layer for the select box.

controller

The associated controller instance.

realsize

The actual, total size of canvas, including the part offscreen.

net_index

The index of the current network. Rightn now it can be zero.

sel_nodes_idx

The set of indices of the currently selected nodes.

sel_reactions_idx

The set of indices of the currently selected reactions.

sel_compartments_idx

The set of indices of the currently selected compartments.

drag_sel_nodes_idx

The set of indices tentatively selected during dragging. This is added to sel_nodes_idx only after the user has stopped drag-selecting.

drag_sel_comps_idx

See drag_sel_nodes_idx but for compartments

hovered_element

The element over which the mouse is hovering, or None.

zoom_slider

The zoom slider widget.

reaction_map

Maps node index to the set of reaction (indices) that it is in.

Parameters

• controller (IController) –

• realsize (Tuple[int, int]) –

AddPluginElement(net_index, element)

Parameters

• net_index (int) –

• element (CanvasElement) –

AlignSelectedNodes(alignment)

Align the selected nodes. Should be called only when only nodes are selected.

Parameters

alignment (Alignment) –

ArrowTipChanged()

COMPARTMENT_LAYER = 3

CalcScrolledPositionFloat(pos)

Convert logical position to scrolled (device) position, retaining floating point.

self.CalcScrolledPosition() converts the input floats to ints. This is needed if better accuracy is needed.

Parameters

pos (Vec2) –

Return type

Vec2

CalcUnscrolledPositionFloat(pos)

Parameters

pos (Vec2) –

Return type

Vec2

ClearCurrentSelection()

Clear the current highest level of selection.

If there are reactants or products marked, clear those. OTherwise clear selected nodes and reactions.

CopySelected()

CreateAliases(nodes)

Parameters

nodes (List[Node]) –

CreateCompartmentElement(comp)

Parameters

comp (Compartment) –

Return type

CompartmentElt

CreateNodeElement(node, layers)

Parameters

• node (Node) –

• layers (Union[int, Tuple[int, …]]) –

Return type

NodeElement

CreateReactionElement(rxn, layers)

Parameters

• rxn (Reaction) –

• layers (Union[int, Tuple[int, …]]) –

Return type

ReactionElement

CreateReactionFromMarked(id='r')

CutSelected()

DRAGGED_NODE_LAYER = 9

DeleteSelectedItems()

DrawActiveRectToImage()

Draw to image only the active rectangle – bounding rect of nodes, reactions, & compartments

DrawBackgroundToGC(gc)

DrawModelToGC(gc)

Parameters

gc (GraphicsContext) –

DrawVisualCuesToGC(gc)

Visual cues include reactant/product outlines, drag-selection rectangle, and compartment highlight.

FitNodeSizeToText()

FullRedraw()

Function to signal that the entire canvas needs to be redrawn.

GetBoundingRect()

Get the bounding rectangle of all nodes, reactions, and compartments.

Returns None if there are no nodes, reactions, or compartments.

Return type

Optional[Rect]

GetCompartment(comp_idx)

Parameters

comp_idx (int) –

Return type

Optional[Compartment]

GetReactionCentroids(net_index)

Helper method for ReactionForm to get access to the centroid positions.

Parameters

net_index (int) –

Return type

Dict[int, Vec2]

GetSelectedNodes(copy=False)

Get the list of selected nodes using self.sel_nodes_idx.

Return type

List[Node]

HANDLE_LAYER = 11

InWhichCompartment(nodes)

Return which compartment the given floating rectangles are in, or -1 if not in any.

This does not return which compartment the nodes currently are in. Rather, it assumes that the user is dragging the nodes (as in the nodes is floating), and tests from the highest compartment to the lowest, whether the nodes as a whole are considered inside that compartment.

Right now, a group of nodes are considered to be inside a compartment iff all the nodes are entirely within in the compartment boundaries.

Parameters

nodes (List[Node]) –

Return type

int

IncrementZoom(zooming_in, anchor)

Zoom in/out by one step on the anchor, if within zoom range.

Parameters

• zooming_in (bool) –

• anchor (Vec2) –

InputModeChanged(val)

Parameters

val (InputMode) –

KEY_MOVE_LONG_STRIDE = 10

Larger move stride for convenience; used when SHIFT is pressed.

KEY_MOVE_STRIDE = 1

Number of pixels to move when the user presses an arrow key.

LazyRefresh()

Return type

bool

MAX_ZOOM_LEVEL = 7

MILLIS_PER_REFRESH = 16

MIN_ZOOM_LEVEL = -7

MarkSelectedAsProducts()

MarkSelectedAsReactants()

NODE_LAYER = 1

OnChar(evt)

OnDidCommitNodePositions(evt)

Update reaction Bezier handles after nodes are dragged.

OnIdle(evt)

OnLeaveWindow(evt)

OnLeftDown(evt)

OnLeftUp(evt)

OnMotion(evt)

OnMouseWheel(evt)

OnPaint(evt)

OnRightUp(evt)

Right mouse button up event handler.

Note that the handling of the right click up event is determined by the canvas rather than by the individual elements.

OnScroll(evt)

OnSlider(evt)

OnWindowDestroy(evt)

Paste()

REACTION_LAYER = 2

RectInWhichCompartment(rect)

Same as InWhichCompartment but for a single rect

Parameters

rect (Rect) –

Return type

int

RedrawModelElements()

Redraw the ‘model’, i.e. non-widget, elements, such as nodes and reactions. This is used for optimizing drawing.

RegisterAllChildren(widget)

Connect all descendants of this widget to relevant events.

wxPython does not propagate events like LEFT_UP and MOTION up to the parent of the window that received it. Therefore normally there is no way for DragDrop to detect a mouse event if it occurred on top of a child widget of window. This function solves this problem by recursively connecting all child widgets of window to trigger the DragDrop handlers. Note that whatever event registered here must do evt.Skip() so that the child itself can handle its event as well.

This solution is from https://stackoverflow.com/a/27911300/9171534

RemovePluginElement(net_index, element)

Parameters

• net_index (int) –

• element (CanvasElement) –

Reset(nodes, reactions, compartments)

Update the list of nodes and apply the current scale.

Parameters

• nodes (List[Node]) –

• reactions (List[Reaction]) –

• compartments (List[Compartment]) –

ResetLayer(elt, layers)

Parameters

• elt (CanvasElement) –

• layers (Union[int, Tuple[int, …]]) –

ResetZoom()

Reset the zoom level, with the anchor on the center of the visible window.

SELECT_BOX_LAYER = 10

SelectAll()

SelectAllNodes()

SelectAllReactions()

SetOriginPos(pos)

Set the origin position (position of the topleft corner) to pos by scrolling.

Parameters

pos (Vec2) –

SetOverlayPositions()

Set the positions of the overlaid widgets.

This should be called in OnPaint so that the overlaid widgets stay in the same relative position.

SetZoomLevel(zoom, anchor)

Zoom in/out with the given anchor.

The anchor point stays at the same relative position after zooming. Note that the anchor position is scrolled position, i.e. device position

Parameters

• zoom (int) –

• anchor (Vec2) –

ShowWarningDialog(msg, caption='Warning')

Parameters

msg (str) –

SplitAliasesOnReactions(node)

Parameters

node (Node) –

ZoomCenter(zooming_in)

Zoom in on the center of the visible window.

Parameters

zooming_in (bool) –

comp_idx_map

Maps compartment index to compartment

property compartments

drawing_drag

See self._UpdateSelectedLists() for more details

findMaxX(nodes)

Find the right-most node’s x position :param self: :param l: the list of indices of the selected nodes

Parameters

nodes (List[Node]) –

findMaxY(nodes)

Find the right-most node’s x position :param self: :param l: the list of indices of the selected nodes

Parameters

nodes (List[Node]) –

findMinX(nodes)

Find the left-most node’s x position :param self: :param l: the list of indices of the selected nodes

Parameters

nodes (List[Node]) –

findMinY(nodes)

Find the left-most node’s x position :param self: :param l: the list of indices of the selected nodes

Parameters

nodes (List[Node]) –

property net_index

node_idx_map

Maps node index to node

property nodes

reaction_idx_map

Maps reaction index to reaction

property reactions

sel_comps

Current list of selected comps; cached for performance

sel_nodes

Current list of selected nodes; cached for performance

property select_box

setDefaultHandles()

property zoom_level: int

Return type

int

rkviewer.canvas.data module

Classes for storing and managing data for graph elements.

rkviewer.canvas.data.BezJ = (9, 5)

Precomputed Bezier curve data

rkviewer.canvas.data.BezJPrime = (9, 5)

Precomputed bezier curve data

rkviewer.canvas.data.CURVE_SLACK = 5

Distance allowed on either side of a curve for testing click hit.

class rkviewer.canvas.data.ChoiceItem(value, text)

Bases: tuple

property text

Alias for field number 1

property value

Alias for field number 0

class rkviewer.canvas.data.CirclePrim(fill_color=Color(r=255, g=0, b=0, a=255), border_color=Color(r=0, g=255, b=0, a=255), border_width=2)

Bases: rkviewer.canvas.data.Primitive

Parameters

• fill_color (Color) –

• border_color (Color) –

• border_width (float) –

border_color: rkviewer.config.Color = Color(r=0, g=255, b=0, a=255)

border_width: float = 2

fill_color: rkviewer.config.Color = Color(r=255, g=0, b=0, a=255)

name: ClassVar[str] = 'circle'

class rkviewer.canvas.data.Compartment(id, net_index, nodes, volume, position, size, fill, border, border_width, index=- 1)

Bases: rkviewer.canvas.data.RectData

Parameters

• id (str) –

• net_index (int) –

• nodes (List[int]) –

• volume (float) –

• position (Vec2) –

• size (Vec2) –

• fill (Colour) –

• border (Colour) –

• border_width (float) –

• index (int) –

border: wx.Colour

border_width: float

fill: wx.Colour

id: str

index: int = -1

net_index: int

nodes: List[int]

position: rkviewer.canvas.geometry.Vec2

property rect

The same as s_rect, but the rectangle is unscaled.

size: rkviewer.canvas.geometry.Vec2

Size for drawing on the GUI

volume: float

Size (i.e. length/area/volume/…) of the container

class rkviewer.canvas.data.CompositeShape(items, text_item, name)

Bases: object

Parameters

• items (List[Tuple[Primitive, Transform]]) –

• text_item (Tuple[TextPrim, Transform]) –

• name (str) –

items: List[Tuple[rkviewer.canvas.data.Primitive, rkviewer.canvas.data.Transform]]

name: str

text_item: Tuple[rkviewer.canvas.data.TextPrim, rkviewer.canvas.data.Transform]

class rkviewer.canvas.data.CompositeShapeFactory(item_factories, text_factory, name)

Bases: object

A factory for a composite shape, see PrimitiveFactory for more information.

Parameters

• item_factories (List[Tuple[PrimitiveFactory, Transform]]) –

• text_factory (Tuple[PrimitiveFactory, Transform]) –

• name (str) –

produce()

class rkviewer.canvas.data.HandleData(tip, base=None)

Bases: object

Struct for keeping handle data in-sync between the BezierHandle element and the Reaction.

tip

The position of the tip of the handle. May be modified by BezierHandle when user drags the handle element.

Type

rkviewer.canvas.geometry.Vec2

base

The position of the base of the handle. May be modified by ReactionBezier, etc. as a response to movement of nodes, handles, etc. HACK this is only updated in the do_paint method of ReactionElement, and since the BezierHandles are drawn after the ReactionElements, the position of the base happens to be updated each time, but if it were drawn before, it would be one step behind.

Type

Optional[rkviewer.canvas.geometry.Vec2]

Parameters

• tip (Vec2) –

• base (Optional[Vec2]) –

base: Optional[rkviewer.canvas.geometry.Vec2]

tip: rkviewer.canvas.geometry.Vec2

class rkviewer.canvas.data.HexagonPrim(points=((0.5, 0.0), (0.25000000000000006, 0.4330127018922193), (- 0.2499999999999999, 0.43301270189221935), (- 0.5, 6.123233995736766e-17), (- 0.2500000000000002, - 0.4330127018922192), (0.24999999999999967, - 0.4330127018922195), (0.5, - 1.2246467991473532e-16)), fill_color=Color(r=255, g=0, b=0, a=255), border_color=Color(r=0, g=255, b=0, a=255), border_width=2, radius=0.5)

Bases: rkviewer.canvas.data.PolygonPrim

Parameters

• points (Tuple[Vec2, …]) –

• fill_color (Color) –

• border_color (Color) –

• border_width (float) –

• radius (float) –

name: ClassVar[str] = 'hexagon'

points: Tuple[rkviewer.canvas.geometry.Vec2, ...] = ((0.5, 0.0), (0.25000000000000006, 0.4330127018922193), (-0.2499999999999999, 0.43301270189221935), (-0.5, 6.123233995736766e-17), (-0.2500000000000002, -0.4330127018922192), (0.24999999999999967, -0.4330127018922195), (0.5, -1.2246467991473532e-16))

rkviewer.canvas.data.INITIALIZED = False

Flag for asserting that the above data is initialized

class rkviewer.canvas.data.LinePrim(points=((0.5, 0.0), (- 0.5, 6.123233995736766e-17)), fill_color=Color(r=255, g=0, b=0, a=255), border_color=Color(r=0, g=255, b=0, a=255), border_width=2, radius=0.5)

Bases: rkviewer.canvas.data.PolygonPrim

Parameters

• points (Tuple[Vec2, …]) –

• fill_color (Color) –

• border_color (Color) –

• border_width (float) –

• radius (float) –

name: ClassVar[str] = 'line'

points: Tuple[rkviewer.canvas.geometry.Vec2, ...] = ((0.5, 0.0), (-0.5, 6.123233995736766e-17))

class rkviewer.canvas.data.ModifierTipStyle(value)

Bases: enum.Enum

An enumeration.

CIRCLE = 'circle'

TEE = 'tee'

class rkviewer.canvas.data.Node(id, net_index, *, pos, size, comp_idx=- 1, floatingNode=True, lockNode=False, shape_index=0, composite_shape=None, index=- 1, original_index=- 1)

Bases: rkviewer.canvas.data.RectData

Class that represents a Node for rendering purposes.

index

The index of the node. If this node has not yet been added to the NOM, this takes on the value of -1.

Type

int

id

The ID of the node.

Type

str

fill_color

The fill color of the node.

border_color

The border color of the node.

border_width

The border width of the node.

position

Position of the size.

Type

rkviewer.canvas.geometry.Vec2

size

Position of the size.

Type

rkviewer.canvas.geometry.Vec2

net_index

The network index of the node.

Type

int

Parameters

• id (str) –

• net_index (int) –

• pos (Vec2) –

• size (Vec2) –

• comp_idx (int) –

• floatingNode (bool) –

• lockNode (bool) –

• shape_index (int) –

• composite_shape (Optional[CompositeShape]) –

• index (int) –

• original_index (int) –

property border_color

property border_width

comp_idx: int

composite_shape: Optional[rkviewer.canvas.data.CompositeShape]

property fill_color

floatingNode: bool

id: str

index: int

lockNode: bool

net_index: int

original_index: int

position: rkviewer.canvas.geometry.Vec2

props_equal(other)

Parameters

other (Node) –

property rect

The same as s_rect, but the rectangle is unscaled.

property s_position

The scaled position of the node obtained by multiplying the scale.

property s_rect

Return scaled position/size as Rect.

Note that the fields of the returned rect is copied, so one cannot modify this node through the rect.

property s_size

The scaled size of the node obtained by multiplying the scale.

shape_index: int

size: rkviewer.canvas.geometry.Vec2

class rkviewer.canvas.data.PolygonPrim(points, fill_color=Color(r=255, g=0, b=0, a=255), border_color=Color(r=0, g=255, b=0, a=255), border_width=2, radius=0.5)

Bases: rkviewer.canvas.data.Primitive

Parameters

• points (Tuple[Vec2, …]) –

• fill_color (Color) –

• border_color (Color) –

• border_width (float) –

• radius (float) –

border_color: rkviewer.config.Color = Color(r=0, g=255, b=0, a=255)

border_width: float = 2

fill_color: rkviewer.config.Color = Color(r=255, g=0, b=0, a=255)

name: ClassVar[str] = 'polygon'

points: Tuple[rkviewer.canvas.geometry.Vec2, ...]

radius: float = 0.5

class rkviewer.canvas.data.Primitive

Bases: object

name: ClassVar[str] = 'generic primitive'

class rkviewer.canvas.data.PrimitiveFactory(prim_class, **kwargs)

Bases: object

Factory that produces primitives.

Why do we need this?

1. Dynamic population of fields. When I need a primitive, I call produce(), which creates a primitive based on the latest data, e.g. theme.

2. That’s it.

How do we achieve dynamically created fields? In the constructor of this class, we allow passing functions as values for fields. On product(), we call these functions to populate the fields. Of course, the user can still pass all-static fields, which would work as intended.

produce()

class rkviewer.canvas.data.Reaction(id, net_index, *, sources, targets, handle_positions, fill_color, line_thickness, rate_law, center_pos=None, bezierCurves=True, modifiers=None, modifier_tip_style=<ModifierTipStyle.CIRCLE: 'circle'>, index=-1)

Bases: object

Parameters

• id (str) –

• net_index (int) –

• sources (List[int]) –

• targets (List[int]) –

• handle_positions (List[Vec2]) –

• fill_color (Colour) –

• line_thickness (float) –

• rate_law (str) –

• center_pos (Optional[Vec2]) –

• bezierCurves (bool) –

• modifiers (Optional[Set[int]]) –

• modifier_tip_style (ModifierTipStyle) –

• index (int) –

bezierCurves: bool

center_pos: Optional[rkviewer.canvas.geometry.Vec2]

dest_c_handle: rkviewer.canvas.data.HandleData

fill_color: wx.Colour

handles: List[rkviewer.canvas.data.HandleData]

id: str

index: int

modifier_tip_style: rkviewer.canvas.data.ModifierTipStyle

modifiers: Set[int]

net_index: int

rate_law: str

property sources: List[int]

Return type

List[int]

src_c_handle: rkviewer.canvas.data.HandleData

property targets: List[int]

Return type

List[int]

property thickness: float

Return type

float

class rkviewer.canvas.data.ReactionBezier(reaction, reactants, products)

Bases: object

Class that keeps track of all Bezier curve data for a reaction.

TODO move this documentation to utils

CENTER_RATIO

The ratio of source centroid handle length to the distance between the zeroth node and the centroid (center handle is aligned with the zeroth node)

DUPLICATE_RATIO

Valid for a Bezier whose node is both a product and a reactant. The ratio of length of the product Bezier handle to the distance between the node and the centroid.

DUPLICATE_ROT

Rotation (radians) applied to the product Bezier handle, for nodes that are both reactant and product. The handle is rotated so as to not align perfectly with the source Bezier handle (otherwise the reactant and product curves would completely overlap).

src_beziers

List of SpeciesBezier instances for reactants.

Type

List[rkviewer.canvas.data.SpeciesBezier]

dest_beziers

List of SpeciesBezier instances for products.

Type

List[rkviewer.canvas.data.SpeciesBezier]

TODO move this to Reaction

src_c_handle

Centroid bezier handle that controls the reactant curves.

dest_c_handle

Centroid bezier handle that controls the product curves.

handles

List of all the BezierHandle instances, stored for convenience.

Parameters

• reaction (Reaction) –

• reactants (List[Node]) –

• products (List[Node]) –

center_moved(offset)

Parameters

offset (Vec2) –

dest_beziers: List[rkviewer.canvas.data.SpeciesBezier]

dest_handle_moved()

Special callback for when the dest centroid handle is moved.

do_paint(gc, fill, selected)

Parameters

• gc (GraphicsContext) –

• fill (Colour) –

• selected (bool) –

get_bounding_rect()

is_mouse_on(pos)

Return whether mouse is on the Bezier curve (not including the handles).

pos is the logical position of the mouse (and not multiplied by any scale).

Parameters

pos (Vec2) –

Return type

bool

make_handle_moved_func(sb)

Manufacture a callback function (on_moved) for the given SpeciesBezier.

Parameters

sb (SpeciesBezier) –

nodes_moved(rects)

Parameters

rects (List[Rect]) –

property real_center: rkviewer.canvas.geometry.Vec2

Return type

Vec2

src_beziers: List[rkviewer.canvas.data.SpeciesBezier]

src_handle_moved()

Special callback for when the source centroid handle is moved.

class rkviewer.canvas.data.RectData

Bases: object

position: rkviewer.canvas.geometry.Vec2

size: rkviewer.canvas.geometry.Vec2

class rkviewer.canvas.data.RectanglePrim(fill_color=Color(r=255, g=0, b=0, a=255), border_color=Color(r=0, g=255, b=0, a=255), border_width=2, corner_radius=4)

Bases: rkviewer.canvas.data.Primitive

Parameters

• fill_color (Color) –

• border_color (Color) –

• border_width (float) –

• corner_radius (float) –

border_color: rkviewer.config.Color = Color(r=0, g=255, b=0, a=255)

border_width: float = 2

corner_radius: float = 4

fill_color: rkviewer.config.Color = Color(r=255, g=0, b=0, a=255)

name: ClassVar[str] = 'rectangle'

class rkviewer.canvas.data.SpeciesBezier(node_idx, node_rect, handle, real_center, centroid_handle, is_source, thickness, bezierCurves)

Bases: object

Class that keeps track of the Bezier curve associated with a reaction species.

Note

When drawing the reaction curve, the builtin AddCurveToPoint is used. However, for the purpose of detecting a click on the curve, we still need to compute a rough approximation of the Bezier curve (e.g. 5 straight line segments). Hence why we need to compute the Bezier curve.

node

The associated node.

node_intersection

The intersection point between the handle and the padded node, i.e. the point after which the handle is not drawn, to create a gap.

Type

Optional[rkviewer.canvas.geometry.Vec2]

handle

Beizer handle for the side on the species.

Type

rkviewer.canvas.data.HandleData

cnetroid_handle

Bezier handle for the centroid, shared among all reactants/products of this reaction.

is_source

Whether this species is considered a source or a dest node.

Type

bool

arrow_adjusted_coords

Coordinate array for the arrow vertices.

bezierCurves

True if we are drawing Bezier curves. Otherwise we are drawing simple straight lines.

Type

bool

Parameters

• node_idx (int) –

• node_rect (Rect) –

• handle (HandleData) –

• real_center (Vec2) –

• centroid_handle (HandleData) –

• is_source (bool) –

• thickness (float) –

• bezierCurves (bool) –

arrow_tip_changed()

bezierCurves: bool

bezier_points: List[rkviewer.canvas.geometry.Vec2]

centroid_handle: rkviewer.canvas.data.HandleData

do_paint(gc, fill, selected)

Parameters

• gc (GraphicsContext) –

• fill (Colour) –

• selected (bool) –

get_bounding_rect()

Return type

Rect

handle: rkviewer.canvas.data.HandleData

is_on_curve(pos)

Check if position is on curve; pos is scaled logical position.

Parameters

pos (Vec2) –

Return type

bool

is_source: bool

node_idx: int

node_intersection: Optional[rkviewer.canvas.geometry.Vec2]

paint_arrow_tip(gc, fill)

Parameters

• gc (GraphicsContext) –

• fill (Colour) –

real_center: rkviewer.canvas.geometry.Vec2

thickness: float

update_curve(real_center)

Called after either the node, the centroid, or at least one of their handles changed.

Parameters

real_center (Vec2) –

class rkviewer.canvas.data.TextAlignment(value)

Bases: enum.Enum

An enumeration.

CENTER = 2

LEFT = 1

RIGHT = 3

class rkviewer.canvas.data.TextPrim(bg_color=Color(r=255, g=255, b=0, a=0), font_color=Color(r=0, g=0, b=0, a=255), font_size=11, font_family=wx.FONTFAMILY_SWISS, font_style=wx.FONTSTYLE_NORMAL, font_weight=wx.FONTWEIGHT_MEDIUM, alignment=<TextAlignment.CENTER: 2>)

Bases: rkviewer.canvas.data.Primitive

Parameters

• bg_color (Color) –

• font_color (Color) –

• font_size (int) –

• font_family (int) –

• font_style (int) –

• font_weight (int) –

• alignment (TextAlignment) –

alignment: rkviewer.canvas.data.TextAlignment = 2

bg_color: rkviewer.config.Color = Color(r=255, g=255, b=0, a=0)

font_color: rkviewer.config.Color = Color(r=0, g=0, b=0, a=255)

font_size: int = 11

name: ClassVar[str] = 'text'

class rkviewer.canvas.data.Transform(translation=(0, 0), rotation=0, scale=(1, 1))

Bases: object

Parameters

• translation (Vec2) –

• rotation (float) –

• scale (Vec2) –

rotation: float = 0

scale: rkviewer.canvas.geometry.Vec2 = (1, 1)

translation: rkviewer.canvas.geometry.Vec2 = (0, 0)

class rkviewer.canvas.data.TrianglePrim(points=((0.5, 0.0), (- 0.2499999999999999, 0.43301270189221935), (- 0.2500000000000002, - 0.4330127018922192), (0.5, - 1.2246467991473532e-16)), fill_color=Color(r=255, g=0, b=0, a=255), border_color=Color(r=0, g=255, b=0, a=255), border_width=2, radius=0.5)

Bases: rkviewer.canvas.data.PolygonPrim

Parameters

• points (Tuple[Vec2, …]) –

• fill_color (Color) –

• border_color (Color) –

• border_width (float) –

• radius (float) –

name: ClassVar[str] = 'triangle'

points: Tuple[rkviewer.canvas.geometry.Vec2, ...] = ((0.5, 0.0), (-0.2499999999999999, 0.43301270189221935), (-0.2500000000000002, -0.4330127018922192), (0.5, -1.2246467991473532e-16))

rkviewer.canvas.data.comb(n, k)

rkviewer.canvas.data.compute_centroid(rects)

Compute the centroid position of a list of reactant and product nodes.

Parameters

rects (Sequence[Rect]) –

Return type

Vec2

rkviewer.canvas.data.gen_polygon_pts(n, r=0.5, phase=0)

This function is used to define the vertices in 2D space of n-polygons. Each equilateral polygon is drawn inside a circle with specified radius.

n: the number of sides of the polygon r: radius of the circle in which the polygon is drawn phase: the phase of the first point, in radians. If phase is 0, the first point is drawn at

(r, 0) relative to the origin.

Return type

Tuple[Vec2, …]

rkviewer.canvas.data.init_bezier()

Initialize (precompute) the Bezier data.

rkviewer.canvas.data.paint_handle(gc, base, handle, hovering)

Paint the handle as given by its base and tip positions, highlighting it if hovering.

Parameters

• gc (GraphicsContext) –

• base (Vec2) –

• handle (Vec2) –

• hovering (bool) –

rkviewer.canvas.elements module

class rkviewer.canvas.elements.BezierHandle(data, layer, on_moved, on_dropped, reaction, node_idx)

Bases: rkviewer.canvas.elements.CanvasElement

Class that keeps track of a Bezier control handle tip.

HANDLE_RADIUS

radius of the control handle.

data

The associated HandleData>

Type

rkviewer.canvas.data.HandleData

on_moved

The function called when the handle is moved.

Type

Callable[[rkviewer.canvas.geometry.Vec2], None]

on_dropped

The function called when the handle is dropped (i.e. mouse up).

Type

Callable[[rkviewer.canvas.geometry.Vec2], None]

reaction

The associated Reaction.

Type

rkviewer.canvas.data.Reaction

twin

The twin BezierHandle; used only for the center handles.

node_idx

The index of the node associated with this handle. -1 if this is a source centroid handle, and -2 if this is a target centroid handle.

Type

int

Parameters

• data (HandleData) –

• layer (Union[int, Tuple[int, …]]) –

• on_moved (Callable[[Vec2], None]) –

• on_dropped (Callable[[Vec2], None]) –

• reaction (Reaction) –

• node_idx (int) –

HANDLE_RADIUS = 5

data: rkviewer.canvas.data.HandleData

node_idx: int

on_dropped: Callable[[rkviewer.canvas.geometry.Vec2], None]

on_left_down(logical_pos)

Handler for when the mouse left button is pressed down inside the shape.

Parameters

logical_pos (Vec2) –

Return type

bool

on_left_up(logical_pos)

Handler for when the mouse left button is springs up inside the shape.

Parameters

logical_pos (Vec2) –

on_mouse_drag(logical_pos, rel_pos)

Handler for when the mouse drags inside the shape, with the left mouse button down.

Parameters

• logical_pos (Vec2) –

• rel_pos (Vec2) –

Return type

bool

on_mouse_enter(logical_pos)

Handler for when the mouse has entered the shape.

Parameters

logical_pos (Vec2) –

Return type

bool

on_mouse_leave(logical_pos)

Handler for when the mouse has exited the shape

Parameters

logical_pos (Vec2) –

Return type

bool

on_moved: Callable[[rkviewer.canvas.geometry.Vec2], None]

on_paint(gc)

Paint the handle as given by its base and tip positions, highlighting it if hovering.

Parameters

gc (GraphicsContext) –

on_paint_cue(gc)

This is called to paint special visual cues tha tthe element may need to display

Parameters

gc (GraphicsContext) –

pos_inside(logical_pos)

Returns whether logical_pos is inside the diplayed shape of this element.

Parameters

logical_pos (Vec2) –

reaction: rkviewer.canvas.data.Reaction

twin = typing.Any

class rkviewer.canvas.elements.CanvasElement(layers)

Bases: object

Base class for an element positioned on the canvas.

layers

The layer(s) number of this element.

Type

Union[int, Tuple[int, …]]

enabled

Whether the element is enabled.

Type

bool

destroyed

Whether the object was destroyed (if this is True then you shouldn’t use this)

Type

bool

Parameters

layers (Union[int, Tuple[int, …]]) –

bounding_rect()

Return the bounding rectangle of the element.

Return type

Rect

destroy()

Destroy this element; override this for specific implementations.

destroyed: bool

enabled: bool

layers: Union[int, Tuple[int, ...]]

on_left_down(logical_pos)

Handler for when the mouse left button is pressed down inside the shape.

Parameters

logical_pos (Vec2) –

Return type

bool

on_left_up(logical_pos)

Handler for when the mouse left button is springs up inside the shape.

Parameters

logical_pos (Vec2) –

Return type

bool

on_mouse_drag(logical_pos, rel_pos)

Handler for when the mouse drags inside the shape, with the left mouse button down.

Parameters

• logical_pos (Vec2) –

• rel_pos (Vec2) –

Return type

bool

on_mouse_enter(logical_pos)

Handler for when the mouse has entered the shape.

Parameters

logical_pos (Vec2) –

Return type

bool

on_mouse_leave(logical_pos)

Handler for when the mouse has exited the shape

Parameters

logical_pos (Vec2) –

Return type

bool

on_mouse_move(logical_pos)

Handler for when the mouse moves inside the shape, with the left mouse button up.

Parameters

logical_pos (Vec2) –

Return type

bool

abstract on_paint(gc)

Paint the shape onto the given GraphicsContext.

This draws onto the scrolled canvas, i.e. the position of the drawn item will respond to scrolling, so you don’t need to account for that.

Parameters

gc (GraphicsContext) –

on_paint_cue(gc)

This is called to paint special visual cues tha tthe element may need to display

Parameters

gc (GraphicsContext) –

pos_inside(logical_pos)

Returns whether logical_pos is inside the diplayed shape of this element.

Parameters

logical_pos (Vec2) –

Return type

bool

set_layers(layers)

Parameters

layers (Union[int, Tuple[int, …]]) –

class rkviewer.canvas.elements.CompartmentElt(compartment, major_layer, minor_layer)

Bases: rkviewer.canvas.elements.CanvasElement

Parameters

• compartment (Compartment) –

• major_layer (int) –

• minor_layer (int) –

bounding_rect()

Return the bounding rectangle of the element.

Return type

Rect

destroyed: bool

enabled: bool

highlight_paint(gc)

Parameters

gc (GraphicsContext) –

layers: Union[int, Tuple[int, ...]]

on_left_down(logical_pos)

Handler for when the mouse left button is pressed down inside the shape.

Parameters

logical_pos (Vec2) –

Return type

bool

on_paint(gc)

Paint the shape onto the given GraphicsContext.

This draws onto the scrolled canvas, i.e. the position of the drawn item will respond to scrolling, so you don’t need to account for that.

Parameters

gc (GraphicsContext) –

pos_inside(logical_pos)

Returns whether logical_pos is inside the diplayed shape of this element.

Parameters

logical_pos (Vec2) –

Return type

bool

class rkviewer.canvas.elements.NodeElement(node, canvas, layers)

Bases: rkviewer.canvas.elements.CanvasElement

CanvasElement for nodes.

Parameters

• node (Node) –

• layers (Union[int, Tuple[int, …]]) –

bounding_rect()

Return the bounding rectangle of the element.

Return type

Rect

canvas: Any

node: rkviewer.canvas.data.Node

on_left_down(_)

Handler for when the mouse left button is pressed down inside the shape.

Parameters

_ (Vec2) –

on_paint(gc)

Paint the shape onto the given GraphicsContext.

This draws onto the scrolled canvas, i.e. the position of the drawn item will respond to scrolling, so you don’t need to account for that.

Parameters

gc (GraphicsContext) –

pos_inside(logical_pos)

Returns whether logical_pos is inside the diplayed shape of this element.

Parameters

logical_pos (Vec2) –

Return type

bool

class rkviewer.canvas.elements.ReactionCenter(parent, layers)

Bases: rkviewer.canvas.elements.CanvasElement

Parameters

• parent (ReactionElement) –

• layers (Union[int, Tuple[int, …]]) –

bounding_rect()

Return the bounding rectangle of the element.

Return type

Rect

on_left_down(logical_pos)

Handler for when the mouse left button is pressed down inside the shape.

Parameters

logical_pos (Vec2) –

Return type

bool

on_left_up(logical_pos)

Handler for when the mouse left button is springs up inside the shape.

Parameters

logical_pos (Vec2) –

Return type

bool

on_mouse_drag(logical_pos, rel_pos)

Handler for when the mouse drags inside the shape, with the left mouse button down.

Parameters

• logical_pos (Vec2) –

• rel_pos (Vec2) –

Return type

bool

on_mouse_enter(logical_pos)

Handler for when the mouse has entered the shape.

Parameters

logical_pos (Vec2) –

Return type

bool

on_mouse_leave(logical_pos)

Handler for when the mouse has exited the shape

Parameters

logical_pos (Vec2) –

Return type

bool

on_paint(gc)

Paint the shape onto the given GraphicsContext.

This draws onto the scrolled canvas, i.e. the position of the drawn item will respond to scrolling, so you don’t need to account for that.

Parameters

gc (GraphicsContext) –

on_paint_cue(gc)

This is called to paint special visual cues tha tthe element may need to display

Parameters

gc (GraphicsContext) –

parent: rkviewer.canvas.elements.ReactionElement

pos_inside(logical_pos)

Returns whether logical_pos is inside the diplayed shape of this element.

Parameters

logical_pos (Vec2) –

Return type

bool

class rkviewer.canvas.elements.ReactionElement(reaction, bezier, canvas, layers, handle_layer)

Bases: rkviewer.canvas.elements.CanvasElement

CanvasElement for reactions.

Note that if new nodes are constructed, all ReactionBezier instances that use these nodes should be re-constructed with the new nodes. On the other hand, if the nodes are merely modified, the corresponding update methods should be called.

Parameters

• reaction (Reaction) –

• bezier (ReactionBezier) –

• layers (Union[int, Tuple[int, …]]) –

• handle_layer (Union[int, Tuple[int, …]]) –

bezier: rkviewer.canvas.data.ReactionBezier

bhandles: List[rkviewer.canvas.elements.BezierHandle]

bounding_rect()

Return the bounding rectangle of the element.

Return type

Rect

canvas: Any

center_el: rkviewer.canvas.elements.ReactionCenter

commit_node_pos()

Handler for after the controller is told to move a node.

controller: rkviewer.mvc.IController

destroy()

Destroy this element; override this for specific implementations.

index_to_bz: Dict[Tuple[int, bool], rkviewer.canvas.data.SpeciesBezier]

make_drop_handle_func(ctrl, neti, reai, nodei, is_source)

Parameters

• ctrl (IController) –

• neti (int) –

• reai (int) –

• nodei (int) –

• is_source (bool) –

moved_handler_id: int

nodes_moved(evt)

Handler for after a node has moved.

Parameters

evt (CanvasEvent) –

on_left_down(logical_pos)

Handler for when the mouse left button is pressed down inside the shape.

Parameters

logical_pos (Vec2) –

Return type

bool

on_mouse_enter(logical_pos)

Handler for when the mouse has entered the shape.

Parameters

logical_pos (Vec2) –

on_paint(gc)

Paint the shape onto the given GraphicsContext.

This draws onto the scrolled canvas, i.e. the position of the drawn item will respond to scrolling, so you don’t need to account for that.

Parameters

gc (GraphicsContext) –

pos_inside(logical_pos)

Returns whether logical_pos is inside the diplayed shape of this element.

Parameters

logical_pos (Vec2) –

Return type

bool

reaction: rkviewer.canvas.data.Reaction

property selected: bool

Return type

bool

class rkviewer.canvas.elements.SelectBox(canvas, nodes, compartments, bounds, controller, net_index, layer)

Bases: rkviewer.canvas.elements.CanvasElement

Class that represents a select box, i.e. the bounding box draw around the selected nodes.

Supports moving and resizing operations.

CURSOR_TYPES

List of cursor types starting with that for the top-left handle and going clockwise.

nodes

List of selected nodes, as contained in this select box.

Type

List[rkviewer.canvas.data.Node]

related_elts

List of NodeElements related to each node instance; matches the node list 1-1.

Type

List[rkviewer.canvas.elements.CanvasElement]

bounding_rect

The exact bounding rectangle (without padding).

Type

rkviewer.canvas.geometry.Rect

mode

Current input mode of the SelectBox.

Note

The behavior of the SelectBox depends on the nodes and compartments selected, but not the reactions. The cases of behaviors are documented here:

1. Only compartments are selected. Nodes within these compartments are dragged along with them, but they are not resized.

3. Only nodes are selected, and they are all in the same compartment. In this case, the nodes may be moved normally. They also may be moved outside of their compartment to be assigned to another compartment (this is the only case where this is possible). However note that the nodes may not be resized to be larger than the containing compartment.

3. Otherwise, there are two cases depending on if the selected nodes are in the union of the selected compartments.

   1. If the selected nodes are entirely contained in the list of selected compartments, then everything is moved and resized together, as usual.

   2. Otherwise (i.e. some node is not in any selected compartment), then dragging and resizing are disabled.

Note that in case 2), if all selected nodes are in the base compartment (i.e. no compartment), then the base compartment is assumed to be selected, and resizing and moving work as usual.

Parameters

• nodes (List[Node]) –

• compartments (List[Compartment]) –

• bounds (Rect) –

• controller (IController) –

• net_index (int) –

• layer (int) –

CURSOR_TYPES = [wx.CURSOR_SIZENWSE, wx.CURSOR_SIZENS, wx.CURSOR_SIZENESW, wx.CURSOR_SIZEWE, wx.CURSOR_SIZENWSE, wx.CURSOR_SIZENS, wx.CURSOR_SIZENESW, wx.CURSOR_SIZEWE]

HANDLE_MULT = [(0, 0), (0.5, 0), (1, 0), (1, 0.5), (1, 1), (0.5, 1), (0, 1), (0, 0.5)]

class Mode(value)

Bases: enum.Enum

An enumeration.

IDLE = 0

MOVING = 1

RESIZING = 2

class SMode(value)

Bases: enum.Enum

For what this does, see “Notes” section of the class documentation.

COMP_ONLY = 0

Only compartments are selected.

CONTAINED = 2

Nodes are entirely contained in the selected compartments, or they are all in the base compartment.

NODES_IN_ONE = 1

Only nodes are selected, and they are in a single compartment.

NOT_CONTAINED = 3

Nodes are not entirely contained in the selected compartments.

comp_indices: List[int]

comp_min_ratio: Optional[rkviewer.canvas.geometry.Vec2]

compartments: List[rkviewer.canvas.data.Compartment]

compute_min_ratio()

Compute minimum size ratio resizing nodes and compartments.

Return type

Tuple[Optional[Vec2], Optional[Vec2]]

Returns

A tuple containing (node mininum resize ratio, comp minimum resize ratio). Each ratio may be None, in the case that no elements of that type is selected.

map_rel_pos(positions)

Parameters

positions (Iterable[Vec2]) –

Return type

List[Vec2]

property mode

move_offset(offset)

Parameters

offset (Vec2) –

node_indices: List[int]

node_min_ratio: Optional[rkviewer.canvas.geometry.Vec2]

nodes: List[rkviewer.canvas.data.Node]

on_left_down(logical_pos)

Handler for when the mouse left button is pressed down inside the shape.

Parameters

logical_pos (Vec2) –

on_left_up(logical_pos)

Handler for when the mouse left button is springs up inside the shape.

Parameters

logical_pos (Vec2) –

on_mouse_drag(logical_pos, rel_pos)

Handler for when the mouse drags inside the shape, with the left mouse button down.

Parameters

• logical_pos (Vec2) –

• rel_pos (Vec2) –

Return type

bool

on_mouse_enter(logical_pos)

Handler for when the mouse has entered the shape.

Parameters

logical_pos (Vec2) –

on_mouse_leave(logical_pos)

Handler for when the mouse has exited the shape

Parameters

logical_pos (Vec2) –

on_mouse_move(logical_pos)

Handler for when the mouse moves inside the shape, with the left mouse button up.

Parameters

logical_pos (Vec2) –

on_paint(gc)

Paint the shape onto the given GraphicsContext.

This draws onto the scrolled canvas, i.e. the position of the drawn item will respond to scrolling, so you don’t need to account for that.

Parameters

gc (GraphicsContext) –

outline_rect()

Helper that returns the scaled, padded bounding rectangle.

Return type

Rect

peripheral_nodes: List[rkviewer.canvas.data.Node]

pos_inside(logical_pos)

Returns whether logical_pos is inside the diplayed shape of this element.

Parameters

logical_pos (Vec2) –

related_elts: List[rkviewer.canvas.elements.CanvasElement]

special_mode: rkviewer.canvas.elements.SelectBox.SMode

update(nodes, compartments)

Parameters

• nodes (List[Node]) –

• compartments (List[Compartment]) –

rkviewer.canvas.elements.draw_circle_to_gc(gc, box, circle, is_alias)

Parameters

• gc (GraphicsContext) –

• box (Rect) –

• circle (CirclePrim) –

• is_alias (bool) –

rkviewer.canvas.elements.draw_composite_shape(gc, bounding_rect, node)

Parameters

• gc (GraphicsContext) –

• bounding_rect (Rect) –

• node (Node) –

rkviewer.canvas.elements.draw_polygon_to_gc(gc, box, poly, is_alias)

Parameters

• gc (GraphicsContext) –

• box (Rect) –

• poly (PolygonPrim) –

• is_alias (bool) –

rkviewer.canvas.elements.draw_rect_to_gc(gc, box, rect, is_alias)

Parameters

• gc (GraphicsContext) –

• box (Rect) –

• rect (RectanglePrim) –

• is_alias (bool) –

rkviewer.canvas.elements.draw_text_to_gc(gc, bounding_rect, text_string, text_item)

Parameters

• gc (GraphicsContext) –

• bounding_rect (Rect) –

• text_item (Tuple[TextPrim, Transform]) –

rkviewer.canvas.elements.layer_above(layer, count=1)

Return the next layer above this layer, without increasing the length of the layer list.

count is optionally the layer number increment.

Parameters

• layer (Union[int, Tuple[int, …]]) –

• count (int) –

Return type

Union[int, Tuple[int, …]]

rkviewer.canvas.elements.primitive_brush(color, is_alias)

Parameters

• color (Color) –

• is_alias (bool) –

rkviewer.canvas.elements.primitive_peninfo(color, width, is_alias)

Parameters

• color (Color) –

• width (float) –

• is_alias (bool) –

rkviewer.canvas.geometry module

class rkviewer.canvas.geometry.Direction(value)

Bases: enum.Enum

An enumeration.

BOTTOM = 3

LEFT = 0

RIGHT = 2

TOP = 1

class rkviewer.canvas.geometry.Orientation(value)

Bases: enum.Enum

An enumeration.

CLOCKWISE = 0

COLINEAR = 2

COUNTERCLOCKWISE = 1

class rkviewer.canvas.geometry.Rect(pos, size)

Bases: object

Class that represents a rectangle by keeping a position and a size.

Parameters

• pos (Vec2) –

• size (Vec2) –

aligned()

Return rectangle aligned to the pixel coordinate system.

Note

See https://github.com/evilnose/PyRKViewer/issues/12 for why this is necessary.

Return type

Rect

as_tuple()

Return the position and the size in a tuple.

Return type

Tuple[Vec2, Vec2]

property center_point: rkviewer.canvas.geometry.Vec2

Return type

Vec2

contains(other)

Returns whether self contains the other rectangle entirely.

Parameters

other (Rect) –

Return type

bool

nth_vertex(n)

Return the nth vertex of the rectangle.

The top-left vertex is the 0th vertex, and subsequence vertices are indexed in clockwise fashion.

Parameters

n (int) –

sides()

to_wx_rect()

union(other)

Return a Rect that contains both self and other

Parameters

other (Rect) –

Return type

Rect

class rkviewer.canvas.geometry.Vec2(x=None, y=None)

Bases: object

Class that represents a 2D vector. Supports common vector operations like add and sub.

Note

Vec2 objects are immutable, meaning one cannot modify elements of the vector.

as_int()

Convert each element to integers using int()

Return type

Vec2

as_tuple()

Return type

Tuple[Union[float, int], Union[float, int]]

dot(other)

Parameters

other (Vec2) –

Return type

Union[float, int]

elem_abs()

Return the Vec2 obtained by taking the element-wise absolute value of this Vec2.

Return type

Vec2

elem_div(other)

Return the resulting Vec2 by performing element-wise division.

Examples

>>> c = a.elem_div(b)  # is equivalent to...
>>> c = Vec2(a.x / b.x, a.y / b.y)

Parameters

other (Vec2) –

Return type

Vec2

elem_mul(other)

Return the resulting Vec2 by performing element-wise multiplication.

Examples

>>> c = a.elem_mul(b)  # is equivalent to...
>>> c = Vec2(a.x * b.x, a.y * b.y)

Parameters

other (Vec2) –

Return type

Vec2

map(op)

Map the given operation across the two elements of the vector.

Parameters

op (Callable[[Union[float, int]], Any]) –

Return type

Vec2

property norm: Union[float, int]

Return type

Union[float, int]

property norm_sq: Union[float, int]

Return type

Union[float, int]

normalized(norm=1)

Parameters

norm (Union[float, int]) –

Return type

Vec2

reduce2(op, other)

Parameters

• op (Callable[[Union[float, int], Union[float, int]], Any]) –

• other (Vec2) –

Return type

Vec2

classmethod repeat(val=1)

Return the Vec2 obtained by repeating the given scalar value across the two elements.

Examples

>>> print(Vec2.repeat(5.4))
(5.4, 5.4)

Parameters

val (Union[float, int]) –

Return type

Vec2

swapped(i, val)

Return a Vec2 equal to this one but with the ith element swapped for val.

Parameters

• i (int) –

• val (Union[float, int]) –

to_wx_point()

Convert this to wx.Point; return the result.

Return type

Point

property x

property y

rkviewer.canvas.geometry.circle_bounds(center, radius)

Return the bounding rectangle (actually a square) of circle.

Parameters

• center (Vec2) –

• radius (float) –

Return type

Rect

rkviewer.canvas.geometry.clamp_point(pos, bounds, padding=0)

Clamp the given point (pos) so that it is entirely within the bounds rectangle.

This is the same as calling clamp_rect_pos() with a clamped rectangle of size 1x1.

Return type

Vec2

Returns

The clamp position.

Parameters

• pos (Vec2) –

• bounds (Rect) –

• padding (int) –

rkviewer.canvas.geometry.clamp_point_outside(pos, bounds)

Clamp the point so that it is outside the given bounds rectangle.

The point is clamped so that its new position differs minimally from the old position.

Parameters

• pos (Vec2) –

• bounds (Rect) –

Return type

Vec2

rkviewer.canvas.geometry.clamp_rect_pos(rect, bounds, padding=0)

Clamp the position of rect, so that it is entirely within the bounds rectangle.

The position is clamped such that the new position of the rectangle moves the least amount of distance possible.

Note

The clamped rectangle must be able to fit inside the bounds rectangle, inclusive. The given rect is not modified, but a position is returned.

Return type

Vec2

Returns

The clamped position.

Parameters

• rect (Rect) –

• bounds (Rect) –

rkviewer.canvas.geometry.clamp_rect_size(rect, botright, padding=0)

Clamp the size of the given rectangle if its bottom-right corner exceeds botright.

Parameters

• rect (Rect) –

• botright (Vec2) –

• padding (int) –

Return type

Vec2

rkviewer.canvas.geometry.determinant(v1, v2)

Computes the 2D determinant of the two vectors.

Parameters

• v1 (Vec2) –

• v2 (Vec2) –

rkviewer.canvas.geometry.get_bounding_rect(rects, padding=0)

Compute the bounding rectangle of a given list of rects.

This computes the smallest possible rectangle needed to cover each of the rects (inclusive), as well as its position. Additionally a padding may be specified to provide some space.

Parameters

• rets – The list of rectangles.

• padding (float) – The padding of the bounding rectangle. If positive, there will be x pixels of padding for each side of the rectangle.

• rects (Sequence[Rect]) –

Return type

Rect

Returns

The bounding rectangle.

rkviewer.canvas.geometry.linear_coefficients(p, q)

Given two points that define a line ax + c, return (a, c)

Parameters

• p (Vec2) –

• q (Vec2) –

Return type

Tuple[float, float]

rkviewer.canvas.geometry.orientation(p1, p2, p3)

Compute the orientation of the three points listed in order.

Parameters

• p1 (Vec2) –

• p2 (Vec2) –

• p3 (Vec2) –

Return type

Orientation

rkviewer.canvas.geometry.padded_rect(rect, padding)

Return a rectangle padded by length padding, with the same center as the original.

Parameters

• rect (Rect) –

• padding (float) –

Return type

Rect

rkviewer.canvas.geometry.pt_in_circle(center, radius, point)

Returns whether point is inside the circle with the given center and radius.

Parameters

• center (Vec2) –

• radius (float) –

• point (Vec2) –

Return type

bool

rkviewer.canvas.geometry.pt_in_rect(pos, rect)

Returns whether the given position is within the rectangle, inclusive.

Parameters

• pos (Vec2) –

• rect (Rect) –

Return type

bool

rkviewer.canvas.geometry.pt_on_line(a, b, point, threshold=0)

Returns whether point is on line ab, with the given threshold distance on either side.

Parameters

• a (Vec2) –

• b (Vec2) –

• point (Vec2) –

• threshold (float) –

Return type

bool

rkviewer.canvas.geometry.rects_overlap(r1, r2)

Returns whether the two given rectangles overlap, counting if they are touching.

Parameters

• r1 (Rect) –

• r2 (Rect) –

Return type

bool

rkviewer.canvas.geometry.rotate_unit(vec, rad)

Rotate a vector by rad radians and return the rotated unit vector.

Parameters

• vec (Vec2) –

• rad (float) –

Return type

Vec2

rkviewer.canvas.geometry.segment_intersects_line(seg, line)

Returns the intersection between seg and line or None if there is no intersection.

line is defined by any two points on it.

Parameters

• seg (Tuple[Vec2, Vec2]) –

• line (Tuple[Vec2, Vec2]) –

Return type

Optional[Vec2]

rkviewer.canvas.geometry.segment_rect_intersection(segment, rect)

Parameters

• segment (Tuple[Vec2, Vec2]) –

• rect (Rect) –

Return type

Optional[Vec2]

rkviewer.canvas.geometry.segments_intersect(seg1, seg2)

Returns the intersection point if line1 and line2 intersect, and None otherwise.

Parameters

• seg1 (Tuple[Vec2, Vec2]) –

• seg2 (Tuple[Vec2, Vec2]) –

Return type

Optional[Vec2]

rkviewer.canvas.overlays module

Widgets that are floating on top of the canvas (overlaid) which do not change position on scroll.

class rkviewer.canvas.overlays.CanvasOverlay

Bases: abc.ABC

Abstract class for a fixed-position overlay within the canvas.

hovering

Used to set whether the mouse is current hovering over the overlay.

Type

bool

Note

Overlays use device positions since it makes the most sense for these static items.

abstract DoPaint(gc)

Re-paint the overlay.

Parameters

gc (GraphicsContext) –

abstract OnLeftDown(device_pos)

Trigger a mouse left button down event on the overlay.

Parameters

device_pos (Vec2) –

abstract OnLeftUp(device_pos)

Trigger a mouse left button up event on the overlay.

Parameters

device_pos (Vec2) –

abstract OnMotion(device_pos, is_down)

Trigger a mouse motion event on the overlay.

Parameters

• device_pos (Vec2) –

• is_down (bool) –

hovering: bool

property position: rkviewer.canvas.geometry.Vec2

Return the position (i.e. of the top-left corner) of the overlay.

Return type

Vec2

property size: rkviewer.canvas.geometry.Vec2

Return the size (i.e. of a rectangle) of the overlay.

Return type

Vec2

class rkviewer.canvas.overlays.Minimap(*, pos, device_pos, width, realsize, window_pos=(0, 0), window_size, pos_callback)

Bases: rkviewer.canvas.overlays.CanvasOverlay

The minimap class that derives from CanvasOverlay.

Callback

Type of the callback function called when the position of the minimap changes.

window_pos

Position of the canvas window, as updated by canvas.

Type

rkviewer.canvas.geometry.Vec2

window_size

Size of the canvas window, as updated by canvas.

Type

rkviewer.canvas.geometry.Vec2

device_pos

The device position (i.e. seen on screen) of the top left corner. Used for determining user click/drag offset. It is important to use the device_pos, since it does not change, whereas window_pos (logical position) changes based on scrolling. This coupled with delays in update causes very noticeable jitters when dragging.

Type

rkviewer.canvas.geometry.Vec2

elements

The list of elements updated by canvas.

Type

sortedcontainers.sortedlist.SortedKeyList

Parameters

• pos (Vec2) –

• device_pos (Vec2) –

• width (int) –

• realsize (Vec2) –

• window_pos (Vec2) –

• window_size (Vec2) –

• pos_callback (Callable[[Vec2], None]) –

Callback

alias of Callable[[rkviewer.canvas.geometry.Vec2], None]

DoPaint(gc)

Re-paint the overlay.

Parameters

gc (GraphicsContext) –

OnLeftDown(device_pos)

Trigger a mouse left button down event on the overlay.

Parameters

device_pos (Vec2) –

OnLeftUp(_)

Trigger a mouse left button up event on the overlay.

Parameters

_ (Vec2) –

OnMotion(device_pos, is_down)

Trigger a mouse motion event on the overlay.

Parameters

• device_pos (Vec2) –

• is_down (bool) –

device_pos: rkviewer.canvas.geometry.Vec2

property dragging

Whether the user is current dragging on the minimap window.

elements: sortedcontainers.sortedlist.SortedKeyList

property realsize

The actual, full size of the canvas, including those not visible on screen.

window_pos: rkviewer.canvas.geometry.Vec2

window_size: rkviewer.canvas.geometry.Vec2

rkviewer.canvas.state module

class rkviewer.canvas.state.ArrowTip(points)

Bases: object

Parameters

points (List[Vec2]) –

clone()

points: List[rkviewer.canvas.geometry.Vec2]

class rkviewer.canvas.state.CanvasState(scale=1, bounds=Rect((0, 0), (0, 0)), input_mode_changed=<function CanvasState.<lambda>>, _input_mode=<InputMode.SELECT: 'Select'>, arrow_tip=<rkviewer.canvas.state.ArrowTip object>)

Bases: object

The current global state of the canvas.

scale

The zoom scale of the canvas.

Type

float

multi_select

Whether the user is pressing the keys that signify multiple selection of items.

Parameters

• scale (float) –

• bounds (Rect) –

• input_mode_changed (Callable[[InputMode], None]) –

• _input_mode (InputMode) –

• arrow_tip (ArrowTip) –

arrow_tip: rkviewer.canvas.state.ArrowTip = <rkviewer.canvas.state.ArrowTip object>

bounds: rkviewer.canvas.geometry.Rect = Rect((0, 0), (0, 0))

property input_mode

input_mode_changed()

property multi_select

scale: float = 1

class rkviewer.canvas.state.InputMode(value)

Bases: enum.Enum

Enum for the current input mode of the canvas.

ADD_COMPARTMENTS = 'Add Compartments'

ADD_NODES = 'Add Nodes'

SELECT = 'Select'

ZOOM = 'Zoom'

rkviewer.canvas.utils module

Utility functions for the canvas.

This includes drawing helpers and 2D geometry functions.

class rkviewer.canvas.utils.Observer(update_callback)

Bases: abc.ABC, Generic[rkviewer.canvas.utils.T]

Observer abstract base class; encapsulates object of type T.

Parameters

update_callback (Callable[[~T], None]) –

class rkviewer.canvas.utils.SetSubject(*args)

Bases: rkviewer.canvas.utils.Subject[Set[rkviewer.canvas.utils.T]]

Subject class that encapsulates a set.

add(el)

Add an element from the set, notifying observers if the set changed.

Parameters

el (~T) –

contains(val)

Parameters

val (~T) –

Return type

bool

intersect(other)

Parameters

other (Set[~T]) –

item_copy()

Return a copy of the encapsulated set.

Return type

Set

remove(el)

Remove an element from the set, notifying observers if the set changed.

Parameters

el (~T) –

set_item(item)

Update the value of the item, notifying observers if the new value differs from the old.

Parameters

item (Set) –

union(other)

Parameters

other (Set[~T]) –

class rkviewer.canvas.utils.Subject(item)

Bases: Generic[rkviewer.canvas.utils.T]

Subject abstract base class; encapsulates object of type T.

attach(observer)

Attach an observer.

Parameters

observer (Observer) –

detach(observer)

Detach an observer.

Parameters

observer (Observer) –

notify()

Trigger an update in each Subject.

Return type

None

rkviewer.canvas.utils.default_handle_positions(centroid, reactants, products)

Parameters

• centroid (Vec2) –

• reactants (List[Node]) –

• products (List[Node]) –

rkviewer.canvas.utils.draw_rect(gc, rect, *, fill=None, border=None, border_width=1, fill_style=wx.BRUSHSTYLE_SOLID, border_style=wx.PENSTYLE_SOLID, corner_radius=0)

Draw a rectangle with the given graphics context.

Either fill or border must be specified to avoid drawing an entirely transparent rectangle.

Parameters

• gc (GraphicsContext) – The graphics context.

• rect (Rect) – The rectangle to draw.

• fill (Optional[Colour]) – If specified, the fill color of the rectangle.

• border (Optional[Colour]) – If specified, the border color of the rectangle.

• border_width (float) – The width of the borders. Defaults to 1. This cannot be 0 when border is specified.

• corner_radius (float) – The corner radius of the rounded rectangle. Defaults to 0.

rkviewer.canvas.utils.get_nodes_by_ident(nodes, ids)

Simple helper that maps the given list of IDs to their corresponding nodes.

Parameters

• nodes (List[Node]) –

• ids (Collection[str]) –

rkviewer.canvas.utils.get_nodes_by_idx(nodes, indices)

Simple helper that maps the given list of indices to their corresponding nodes.

Parameters

• nodes (List[Node]) –

• indices (Collection[int]) –

rkviewer.canvas.utils.get_rxns_by_idx(rxns, indices)

Simple helper that maps the given list of indices to their corresponding rxns.

Parameters

• rxns (List[Reaction]) –

• indices (Collection[int]) –

Module contents