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

DeferedDict	A dictionary-like object that can hold futures for values,
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
MeshViewer
EditableValueLabel	A QLabel that turns into a QLineEdit on double-click for in-place value editing.
ColorScaleWidget	Widget that displays a color scale with delta and absolute range.
MainWindow

Functions

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.DeferedDict[K, V]

A dictionary-like object that can hold futures for values, unwrapping them when accessed.

is_ready(key: K) → bool

set_future(key: K, future: concurrent.futures.Future[V])

clear()

class padne.ui.BaseSpatialIndex

tree: scipy.spatial.cKDTree | None

values: list[float]

shape: shapely.geometry.MultiPolygon

classmethod from_layer_data(layer: padne.solver.problem.Layer, layer_solution: padne.solver.LayerSolution) → 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

Returns the display name of the tool.

property status_tip: str

Returns the status tip for the tool.

on_activate()

Called when the tool becomes active.

on_deactivate()

Called when the tool becomes inactive.

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 | None

activate_tool(tool_to_activate: BaseTool | None)

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)

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

classmethod prepare_zero_form(msh: padne.mesh.Mesh, values: padne.mesh.ZeroForm) → RenderedMesh

classmethod prepare_two_form(msh: padne.mesh.Mesh, values: padne.mesh.TwoForm) → RenderedMesh

render_triangles()

render_edges()

render_boundary()

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

Create a RenderedMesh from a mesh with zero values. Used for disconnected copper regions that will be rendered in gray.

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.MeshViewer(parent=None)

Bases: PySide6.QtOpenGLWidgets.QOpenGLWidget

class BaseRenderingMode

unit: str

name: str

color_map: padne.colormaps.UniformColorMap

min_value: float = 0.0

max_value: 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]]

autoscale_values(solution: padne.solver.Solution)

Autoscale values for the rendering mode.

abstractmethod set_solution(solution: padne.solver.Solution)

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

valueRangeChanged

currentLayerChanged

availableLayersChanged

currentModeChanged

unitChanged

colorMapChanged

meshClicked

screenDragged

keyPressedInMesh

mousePositionChanged

visibilityChanged

solution: None | padne.solver.Solution = None

rendered_meshes: dict[str, list]

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

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.

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(solution: padne.solver.Solution)

Set the solution for the mesh viewer.

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

switchToNextLayer() → None

Switch to the next layer in the cycle.

switchToPreviousLayer() → None

Switch to the previous layer in the cycle.

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

Widget that displays a color scale with delta and absolute range.

unitChanged

minValueEdited

maxValueEdited

v_min = 0.0

v_max = 1.0

unit = 'V'

color_map

delta_label: PySide6.QtWidgets.QLabel | None = None

max_label: EditableValueLabel | None = None

min_label: EditableValueLabel | None = None

setupUI() → None

Set up the UI components.

setRange(v_min, v_max)

Set the minimum and maximum values for the scale.

setUnit(unit)

Set the unit for the scale.

setColorMap(color_map)

Set the color map for the scale.

updateLabels() → None

Update the delta and range labels.

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

Paint the color gradient scale.

class padne.ui.MainWindow(solution: padne.solver.Solution, warnings_list: list[warnings.WarningMessage] | None = None)

Bases: PySide6.QtWidgets.QMainWindow

projectLoaded

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(solution: padne.solver.Solution, warnings_list: list[warnings.WarningMessage] | None = None) → int

Main entry point for the UI application.