padne.ui

Attributes

log
VERTEX_SHADER_MESH
FRAGMENT_SHADER_MESH
VERTEX_SHADER_DISCONNECTED
FRAGMENT_SHADER_DISCONNECTED
VERTEX_SHADER_EDGES
FRAGMENT_SHADER_EDGES
VERTEX_SHADER_POINTS
FRAGMENT_SHADER_POINTS

Classes

BaseSpatialIndex
VertexSpatialIndex	Spatial index for fast vertex value lookups within a layer.
FaceSpatialIndex	Spatial index for fast face value lookups within a layer.
BaseTool	Helper class that provides a standard way to create an ABC using
PanTool	Helper class that provides a standard way to create an ABC using
SetMinValueTool	Helper class that provides a standard way to create an ABC using
SetMaxValueTool	Helper class that provides a standard way to create an ABC using
ToolManager
AppToolBar
ShaderProgram
RenderedMesh
RenderedPoints
SliderScale	Maps a 0..1 slider fraction to a value in [lo, hi] and back.
LinearScale	Maps a 0..1 slider fraction to a value in [lo, hi] and back.
LogScale	Fraction 0 is exactly lo, (0, 1] spans decades decades below hi
ColorScaleState	Snapshot of a rendering mode's color scale, as shown by ColorScaleWidget.
MeshViewer
EditableValueLabel	A QLabel that turns into a QLineEdit on double-click for in-place value editing.
ColorScaleWidget	Color scale with min/max sliders and a percentile cap toggle.
PreparedUI	GL-free UI preparation for a solution (see prepare_ui_data).
MainWindow

Functions

prepare_ui_data(→ PreparedUI)	Build the GL-free UI data for solution: per-mode spatial indices and the
configure_opengl(→ None)	Configure OpenGL settings for the application.
main(→ int)	Main entry point for the UI application.

Module Contents

padne.ui.log

padne.ui.VERTEX_SHADER_MESH = Multiline-String

Show Value

"""
#version 330 core
layout(location = 0) in vec2 position;
layout(location = 1) in float color;
out float frag_value;
uniform mat4 mvp;

void main() {
    gl_Position = mvp * vec4(position, 0.0, 1.0);
    frag_value = color;
}
"""

padne.ui.FRAGMENT_SHADER_MESH = Multiline-String

Show Value

"""
#version 330 core
in float frag_value;
out vec4 out_color;

#define COLOR_COUNT 256
uniform float v_max = 1.0;
uniform float v_min = 0.0;
uniform vec3 color_map[COLOR_COUNT];

void main() {
    float t = (frag_value - v_min) / (v_max - v_min);
    float rescaled = t * COLOR_COUNT;
    int idx = clamp(int(rescaled), 0, COLOR_COUNT - 1);

    out_color = vec4(color_map[idx], 1.0);
}
"""

padne.ui.VERTEX_SHADER_DISCONNECTED = Multiline-String

Show Value

"""
#version 330 core
layout(location = 0) in vec2 position;
layout(location = 1) in float color;  // We still have the color attribute but ignore it
uniform mat4 mvp;

void main() {
    gl_Position = mvp * vec4(position, 0.0, 1.0);
}
"""

padne.ui.FRAGMENT_SHADER_DISCONNECTED = Multiline-String

Show Value

"""
#version 330 core
out vec4 out_color;

void main() {
    // Render disconnected copper in a subdued gray
    out_color = vec4(0.1, 0.1, 0.1, 1.0);
}
"""

padne.ui.VERTEX_SHADER_EDGES = Multiline-String

Show Value

"""
#version 330 core
layout(location = 0) in vec2 position;
layout(location = 1) in vec3 color;
out vec3 frag_color;
uniform mat4 mvp;

void main() {
    gl_Position = mvp * vec4(position, 0.0, 1.0);
    frag_color = color;
}
"""

padne.ui.FRAGMENT_SHADER_EDGES = Multiline-String

Show Value

"""
#version 330 core
in vec3 frag_color;
out vec4 out_color;

void main() {
    out_color = vec4(frag_color, 1.0);
}
"""

padne.ui.VERTEX_SHADER_POINTS = Multiline-String

Show Value

"""
#version 330 core
layout(location = 0) in vec2 position;
layout(location = 1) in vec3 vertex_color;
out vec3 frag_color;
uniform mat4 mvp;
uniform float point_size = 5.0;

void main() {
    gl_Position = mvp * vec4(position, 0.0, 1.0);
    gl_PointSize = point_size;
    frag_color = vertex_color; // Pass color to fragment shader
}
"""

padne.ui.FRAGMENT_SHADER_POINTS = Multiline-String

Show Value

"""
#version 330 core
in vec3 frag_color; // Input color from vertex shader
out vec4 out_color;

void main() {
    out_color = vec4(frag_color, 1.0);
}
"""

class padne.ui.BaseSpatialIndex

tree: scipy.spatial.cKDTree | None

values: numpy.ndarray

shape: shapely.geometry.MultiPolygon

classmethod from_layer_data(layer: padne.solver.problem.Layer, layer_solution: padne.solver.LayerSolution, value_transform: Callable[[numpy.ndarray], numpy.ndarray] | None = None) → BaseSpatialIndex

query_nearest(x: float, y: float) → float | None

Find nearest value to given coordinates.

class padne.ui.VertexSpatialIndex

Bases: BaseSpatialIndex

Spatial index for fast vertex value lookups within a layer.

class padne.ui.FaceSpatialIndex

Bases: BaseSpatialIndex

Spatial index for fast face value lookups within a layer.

class padne.ui.BaseTool(mesh_viewer: MeshViewer, tool_manager: ToolManager)

Bases: abc.ABC

Helper class that provides a standard way to create an ABC using inheritance.

mesh_viewer

tool_manager

property name: str

Abstractmethod:

Returns the display name of the tool.

property status_tip: str

Abstractmethod:

Returns the status tip for the tool.

property shortcut: tuple[PySide6.QtCore.Qt.Key, PySide6.QtCore.Qt.KeyboardModifier] | None

on_shortcut_press(world_point: padne.mesh.Point)

Handles a shortcut press event.

on_mesh_click(world_point: padne.mesh.Point, event: PySide6.QtGui.QMouseEvent)

Handles a click event on the mesh.

on_screen_drag(dx: float, dy: float, event: PySide6.QtGui.QMouseEvent)

Handles a screen drag event.

class padne.ui.PanTool(mesh_viewer: MeshViewer, tool_manager: ToolManager)

Bases: BaseTool

Helper class that provides a standard way to create an ABC using inheritance.

property name: str

Returns the display name of the tool.

property status_tip: str

Returns the status tip for the tool.

on_screen_drag(dx: float, dy: float, event: PySide6.QtGui.QMouseEvent)

Handles a screen drag event.

class padne.ui.SetMinValueTool(mesh_viewer: MeshViewer, tool_manager: ToolManager)

Bases: PanTool

Helper class that provides a standard way to create an ABC using inheritance.

property name: str

Returns the display name of the tool.

property status_tip: str

Returns the status tip for the tool.

property shortcut

on_mesh_click(world_point: padne.mesh.Point, event: PySide6.QtGui.QMouseEvent)

Handles a click event on the mesh.

on_shortcut_press(world_point: padne.mesh.Point)

Handles a shortcut press event.

class padne.ui.SetMaxValueTool(mesh_viewer: MeshViewer, tool_manager: ToolManager)

Bases: PanTool

Helper class that provides a standard way to create an ABC using inheritance.

property name: str

Returns the display name of the tool.

property status_tip: str

Returns the status tip for the tool.

property shortcut

on_mesh_click(world_point: padne.mesh.Point, event: PySide6.QtGui.QMouseEvent)

Handles a click event on the mesh.

on_shortcut_press(world_point: padne.mesh.Point)

Handles a shortcut press event.

class padne.ui.ToolManager(mesh_viewer: MeshViewer, parent=None)

Bases: PySide6.QtCore.QObject

mesh_viewer

available_tools: list[BaseTool]

active_tool: BaseTool

activate_tool(tool_to_activate: BaseTool)

handle_mesh_click(world_point: padne.mesh.Point, event: PySide6.QtGui.QMouseEvent)

handle_screen_drag(dx: float, dy: float, event: PySide6.QtGui.QMouseEvent)

handle_key_press_in_mesh(world_point: padne.mesh.Point, key: PySide6.QtCore.Qt.Key, modifiers: PySide6.QtCore.Qt.KeyboardModifiers)

class padne.ui.AppToolBar(tool_manager: ToolManager, mesh_viewer: MeshViewer, parent=None)

Bases: PySide6.QtWidgets.QToolBar

tool_manager

mesh_viewer

updateLayerSelectionMenu(layer_names: list[str])

updateActiveLayerInMenu(active_layer_name: str)

updateActiveModeInMenu(active_mode_name: str)

Update which mode action is checked.

class padne.ui.ShaderProgram

shader_program: PySide6.QtOpenGL.QOpenGLShaderProgram

classmethod from_source(vertex_source, fragment_source)

set_mvp(mvp: numpy.ndarray)

use()

class padne.ui.RenderedMesh

vao_triangles: int

triangle_count: int

vao_edges: int

edge_count: int

vao_boundary: int

boundary_count: int

class PreparedData

triangle_vertices: numpy.ndarray[numpy.float32]

triangle_colors: numpy.ndarray[numpy.float32]

edge_vertices: numpy.ndarray[numpy.float32]

edge_colors: numpy.ndarray[numpy.float32]

boundary_vertices: numpy.ndarray[numpy.float32]

boundary_colors: numpy.ndarray[numpy.float32]

classmethod from_prepared_data(data: RenderedMesh) → RenderedMesh

class PreparedGeometry

Read-only CPU geometry shared by the two field rendering modes.

triangles: numpy.ndarray

triangle_vertices: numpy.ndarray

edge_vertices: numpy.ndarray

edge_colors: numpy.ndarray

boundary_vertices: numpy.ndarray

boundary_colors: numpy.ndarray

with_colors(colors: numpy.ndarray) → RenderedMesh

classmethod prepare_geometry(msh: padne.mesh.Mesh) → RenderedMesh

Extract face-ordered geometry without Python half-edge traversal.

Interior edges deliberately occur twice, matching the original drawing order. Boundary edges include both the exterior and any hole rims. Native extraction releases the GIL; each task owns its output arrays.

classmethod prepare_zero_form(msh: padne.mesh.Mesh, values: padne.mesh.ZeroForm, geometry: RenderedMesh | None = None) → RenderedMesh

classmethod prepare_two_form(msh: padne.mesh.Mesh, values: padne.mesh.TwoForm, geometry: RenderedMesh | None = None) → RenderedMesh

render_triangles()

render_edges()

render_boundary()

classmethod prepare_mesh(msh: padne.mesh.Mesh, geometry: RenderedMesh | None = None) → RenderedMesh

Prepare disconnected copper, with a zero-valued field.

class padne.ui.RenderedPoints

vao_points: int

point_count: int

classmethod from_points(points_data: list[tuple[tuple[float, float], tuple[float, float, float]]])

render()

class padne.ui.SliderScale

Bases: abc.ABC

Maps a 0..1 slider fraction to a value in [lo, hi] and back.

abstractmethod value_at(fraction: float, lo: float, hi: float) → float

abstractmethod fraction_of(value: float, lo: float, hi: float) → float

class padne.ui.LinearScale

Bases: SliderScale

Maps a 0..1 slider fraction to a value in [lo, hi] and back.

value_at(fraction: float, lo: float, hi: float) → float

fraction_of(value: float, lo: float, hi: float) → float

class padne.ui.LogScale

Bases: SliderScale

Fraction 0 is exactly lo, (0, 1] spans decades decades below hi logarithmically, so one slider step is a constant ratio.

decades: float = 4.0

value_at(fraction: float, lo: float, hi: float) → float

fraction_of(value: float, lo: float, hi: float) → float

class padne.ui.ColorScaleState

Snapshot of a rendering mode’s color scale, as shown by ColorScaleWidget.

min_value: float

max_value: float

slider_lo: float

slider_hi: float

slider_scale: SliderScale

capped: bool

cap_percentile: float

unit: str

color_map: padne.colormaps.UniformColorMap

class padne.ui.MeshViewer(parent=None)

Bases: PySide6.QtOpenGLWidgets.QOpenGLWidget

class BaseRenderingMode

unit: str

name: str

color_map: padne.colormaps.UniformColorMap

slider_scale: ClassVar[SliderScale]

cap_percentile: ClassVar[float] = 99.9

min_value: float = 0.0

max_value: float = 1.0

capped: bool = False

data_range: tuple[float, float] = (0.0, 1.0)

percentile_max: float = 1.0

solution: padne.solver.Solution | None = None

spatial_indices: dict[str, BaseSpatialIndex]

rendered_meshes: dict[str, list[RenderedMesh]]

disconnected_rendered_meshes: dict[str, list[RenderedMesh]]

property slider_range: tuple[float, float]

autoscale() → None

Set the color range to the whole slider range.

set_min(value: float) → None

Set the color minimum, pushing the maximum up if needed.

set_max(value: float) → None

Set the color maximum, pushing the minimum down if needed.

set_capped(capped: bool) → None

Toggle the cap; only clamps the color range, never rescales it.

color_scale_state() → ColorScaleState

abstractmethod set_solution(solution: padne.solver.Solution, geometries: dict[padne.mesh.Mesh, RenderedMesh] | None = None, disconnected: dict[str, list[RenderedMesh]] | None = None)

Initialize this mode with solution data (build indices + meshes).

pick_nearest_value(layer_name: str, world_x: float, world_y: float) → float | None

Pick value at coordinates using spatial index.

get_rendered_meshes_for_layer(layer_name: str) → list[RenderedMesh]

Get pre-built rendered meshes for a layer.

get_disconnected_rendered_meshes_for_layer(layer_name: str) → list[RenderedMesh]

Get pre-built disconnected rendered meshes for a layer.

class VoltageRenderingMode

Bases: BaseRenderingMode

unit: str = 'V'

name: str = 'Potential'

color_map: padne.colormaps.UniformColorMap

class PowerDensityRenderingMode

Bases: BaseRenderingMode

unit: str = 'W/mm²'

name: str = 'Power Density'

color_map: padne.colormaps.UniformColorMap

slider_scale: ClassVar[SliderScale]

capped: bool = True

class CurrentDensityRenderingMode

Bases: PowerDensityRenderingMode

unit: str = 'A/mm²'

name: str = 'Current Density'

color_map: padne.colormaps.UniformColorMap

set_solution(solution: padne.solver.Solution, geometries: dict[padne.mesh.Mesh, RenderedMesh] | None = None, disconnected: dict[str, list[RenderedMesh]] | None = None)

Initialize this mode with solution data (build indices + meshes).

colorScaleChanged

currentLayerChanged

availableLayersChanged

currentModeChanged

meshClicked

screenDragged

keyPressedInMesh

mousePositionChanged

visibilityChanged

classmethod default_modes() → list[MeshViewer]

The rendering modes in menu order, constructible without a widget.

solution: None | padne.solver.Solution = None

rendered_connection_points: dict[str, RenderedPoints]

connection_points_visible: bool = True

modes

current_mode_index = 0

scale = 1.0

offset_x = 0.0

offset_y = 0.0

needs_initial_autoscale = False

last_mouse_screen_pos: PySide6.QtCore.QPointF | None = None

last_mouse_position_change_ts

current_layer_index = 0

visible_layers = []

mesh_shader = None

disconnected_shader = None

edge_shader = None

points_shader = None

edges_visible = True

outline_visible = True

property current_rendering_mode: BaseRenderingMode

Get the currently active rendering mode.

property current_layer_name: str

Get the name of the currently active layer.

property aspect_ratio: float

Get the current aspect ratio (width/height).

autoscaleValue() → None

Automatically adjust the min/max values for color scaling using the current rendering mode.

setCapped(capped: bool) → None

Toggle the percentile cap of the current rendering mode.

autoscaleXY() → None

Automatically adjust the offset and scale to fit all meshes in the view. Sets the view to display all meshes with a small margin around them.

setSolution(prepared: PreparedUI)

Install a solution prepared by prepare_ui_data.

setupConnectionPointsData() → None

Set up the connection points data for rendering.

initializeGL() → None

Initialize OpenGL settings.

resizeGL(width: int, height: int) → None

Handle window resizing.

paintGL() → None

Render the mesh using shaders.

mousePressEvent(event: PySide6.QtGui.QMouseEvent) → None

Handle mouse press events.

mouseMoveEvent(event: PySide6.QtGui.QMouseEvent) → None

Handle mouse movement.

mouseReleaseEvent(event: PySide6.QtGui.QMouseEvent) → None

Handle mouse release events.

panViewByScreenDelta(dx_screen: float, dy_screen: float) → None

Pans the view based on a screen delta.

Args:

dx_screen: Change in x screen coordinate. dy_screen: Change in y screen coordinate.

setMinValue(value: float) → None

Sets the minimum of the color scale; clamps max upward if needed.

setMaxValue(value: float) → None

Sets the maximum of the color scale; clamps min downward if needed.

setMinValueFromWorldPoint(world_point: padne.mesh.Point) → None

Sets the minimum value of the color scale from a world point. If the selected value is greater than the current maximum, both min and max are set to the selected value.

Args:

world_point: The point in world coordinates.

setMaxValueFromWorldPoint(world_point: padne.mesh.Point) → None

Sets the maximum value of the color scale from a world point. If the selected value is less than the current minimum, both min and max are set to the selected value.

Args:

world_point: The point in world coordinates.

wheelEvent(event: PySide6.QtGui.QWheelEvent) → None

Handle mouse wheel for zooming towards cursor position.

keyPressEvent(event: PySide6.QtGui.QKeyEvent) → None

Handle keyboard events.

switchLayerBy(direction: int = 1) → None

Switch to the next or previous layer in the cycle.

Args:

direction: 1 for next layer, -1 for previous layer

setEdgesVisible(visible: bool)

Slot to set the visibility of mesh edges.

setOutlineVisible(visible: bool)

Slot to set the visibility of outline edges.

setConnectionPointsVisible(visible: bool)

Slot to set the visibility of connection points.

setCurrentLayerByName(layer_name: str)

Sets the current layer by its name.

setCurrentModeByName(mode_name: str)

Sets the current rendering mode by its name.

class padne.ui.EditableValueLabel(parent=None)

Bases: PySide6.QtWidgets.QLabel

A QLabel that turns into a QLineEdit on double-click for in-place value editing.

valueEdited

value = 0.0

unit = ''

setValue(value: float, unit: str) → None

mouseDoubleClickEvent(event: PySide6.QtGui.QMouseEvent) → None

eventFilter(watched, event)

class padne.ui.ColorScaleWidget(parent=None)

Bases: PySide6.QtWidgets.QWidget

Color scale with min/max sliders and a percentile cap toggle.

unitChanged

minValueEdited

maxValueEdited

capToggled

state

delta_label: PySide6.QtWidgets.QLabel | None = None

max_label: EditableValueLabel | None = None

min_label: EditableValueLabel | None = None

min_slider: PySide6.QtWidgets.QSlider | None = None

max_slider: PySide6.QtWidgets.QSlider | None = None

percentile_checkbox: PySide6.QtWidgets.QCheckBox | None = None

setupUI() → None

Set up the UI components.

setState(state: ColorScaleState) → None

Show state; does not re-emit any edit signals.

updateLabels() → None

Update the delta and range labels.

paintEvent(event: PySide6.QtGui.QPaintEvent) → None

Paint the color gradient scale.

class padne.ui.PreparedUI

GL-free UI preparation for a solution (see prepare_ui_data).

solution: padne.solver.Solution

modes: list[MeshViewer]

padne.ui.prepare_ui_data(solution: padne.solver.Solution) → PreparedUI

Build the GL-free UI data for solution: per-mode spatial indices and the prepared render arrays.

CPU-only native/numpy work – it never touches Qt or the OpenGL context, so it can run before the window exists. The GL side (VAO upload, shader compilation) still happens later, on the render thread.

class padne.ui.MainWindow(prepared: PreparedUI, warnings_list: list[warnings.WarningMessage] | None = None)

Bases: PySide6.QtWidgets.QMainWindow

project_file_name

warnings_list

warnings_shown = False

mesh_viewer

tool_manager

color_scale

app_toolbar

updateCurrentLayer(layer_name: str) → None

Update the window title to show the current layer.

updateMousePosition(world_point: padne.mesh.Point, value)

Update status bar with mouse position and value.

showEvent(event: PySide6.QtGui.QShowEvent) → None

Override showEvent to display warnings after window is visible.

padne.ui.configure_opengl() → None

Configure OpenGL settings for the application.

padne.ui.main(prepared: PreparedUI, warnings_list: list[warnings.WarningMessage] | None = None) → int

Main entry point for the UI application.

prepared is the result of prepare_ui_data, which the caller runs (and times) before the window is created.