wolfhece.PyDraw

Author: HECE - University of Liege, Pierre Archambeau Date: 2024

Copyright (c) 2024 University of Liege. All rights reserved.

This script and its content are protected by copyright law. Unauthorized copying or distribution of this file, via any medium, is strictly prohibited.

Module Contents

wolfhece.PyDraw.msg

wolfhece.PyDraw.WOLFPYDIKE_AVAILABLE = True

wolfhece.PyDraw.THROTTLING_FREQUENCY = 10

wolfhece.PyDraw.THROTTLING_FREQUENCY_SCROLL = 30

wolfhece.PyDraw.ID_SELECTCS = 1000

wolfhece.PyDraw.ID_SORTALONG = 1001

wolfhece.PyDraw.ID_LOCMINMAX = 1002

wolfhece.PyDraw.ID_PLOTCS = 1003

wolfhece.PyDraw.LIST_1TO9

wolfhece.PyDraw.PROJECT_ACTION = 'action'

wolfhece.PyDraw.PROJECT_CS = 'cross_sections'

wolfhece.PyDraw.PROJECT_VECTOR = 'vector'

wolfhece.PyDraw.PROJECT_ARRAY = 'array'

wolfhece.PyDraw.PROJECT_TILES = 'tiles'

wolfhece.PyDraw.PROJECT_LAZ = 'laz_grid'

wolfhece.PyDraw.PROJECT_CLOUD = 'cloud'

wolfhece.PyDraw.PROJECT_WOLF2D = 'wolf2d'

wolfhece.PyDraw.PROJECT_GPU2D = 'gpu2d'

wolfhece.PyDraw.PROJECT_PALETTE = 'palette'

wolfhece.PyDraw.PROJECT_PALETTE_ARRAY = 'palette-array'

wolfhece.PyDraw.PROJECT_LINK_CS = 'cross_sections_link'

wolfhece.PyDraw.PROJECT_LINK_VEC_ARRAY = 'vector_array_link'

wolfhece.PyDraw.PROJECT_GROUP_KEYS

class wolfhece.PyDraw.MplFigViewer(layout=None, idx: str = '', mapviewer: WolfMapViewer = None, caption: str = '', size: tuple = (800, 600), style: int = wx.DEFAULT_FRAME_STYLE ^ wx.RESIZE_BORDER)

Bases: wolfhece.matplotlib_fig.Matplotlib_Figure

Matplotlib Figure with wx Frame

_mapviewer = None

_idx = ''

OnClose(event)

Close the window

property mapviewer

property idx

class wolfhece.PyDraw.Memory_View(screen_width, screen_height, xmin, xmax, ymin, ymax)

Memory view

screen_width

screen_height

xmin

xmax

ymin

ymax

property width

Width of the view

property height

Height of the view

serialize()

Serialize the view

static deserialize(data: dict)

Deserialize the view

class wolfhece.PyDraw.Memory_View_encoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Bases: json.JSONEncoder

Memory view encoder

default(o)

Default method

class wolfhece.PyDraw.Memory_View_decoder(*args, **kwargs)

Bases: json.JSONDecoder

Memory view decoder

object_hook(obj)

Decode the object

class wolfhece.PyDraw.Memory_Views

Memory views

views: dict[str, Memory_View]

add_view(name: str, screen_width: int, screen_height: int, xmin: float, xmax: float, ymin: float, ymax: float)

Add a new view to the memory views

remove_view(name: str)

Remove a view from the memory views

reset()

Reset the memory views

zoom_on(name: str, mapviewer: WolfMapViewer)

Zoom on a view

save(filename: str)

Save the memory views

load(filename: str)

Load the memory views

class wolfhece.PyDraw.Memory_Views_GUI(parent, title, memory_views: Memory_Views, mapviewer: WolfMapViewer)

Bases: wx.dataview.wx.Frame

Memory views GUI

mapviewer

_memory_views

_views

_cmdZoom

_cmdAdd

_cmdDelete

_cmdReset

_label_xmin

_xmin

_label_xmax

_xmax

_label_ymin

_ymin

_label_ymax

_ymax

_label_canvas_height

_canvas_height

_cmdGet

_cmdApply

_cmdSave

_cmdLoad

OnSave(event)

Save the memory views

OnLoad(event)

Load the memory views

OnClose(event)

Close the memory views GUI

OnSelectView(event)

Select a view

OnZoom(event)

Zoom on the current view

OnAdd(event)

Add a view

OnDelete(event)

Delete a view

OnReset(event)

Reset the views

OnApply(event)

Apply the changes

OnGet(event)

Get the values

class wolfhece.PyDraw.draw_type(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

>>> Color.RED
<Color.RED: 1>

• value lookup:

>>> Color(1)
<Color.RED: 1>

• name lookup:

>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

ARRAYS = 'arrays'

BRIDGES = 'bridges'

WEIRS = 'weirs'

VECTORS = 'vectors'

CLOUD = 'clouds'

TRIANGULATION = 'triangulations'

PARTICLE_SYSTEM = 'particle systems'

CROSS_SECTIONS = 'cross_sections'

OTHER = 'others'

VIEWS = 'views'

RES2D = 'wolf2d'

WMSBACK = 'wms-background'

WMSFORE = 'wms-foreground'

TILES = 'tiles'

IMAGESTILES = 'imagestiles'

LAZ = 'laz'

DROWNING = 'drowning'

DIKE = 'dike'

PICTURECOLLECTION = 'picture_collection'

INJECTOR = 'injector'

class wolfhece.PyDraw.Colors_1to9(parent)

Bases: wx.dataview.wx.Frame

_parent

colors1to9 = [(0, 0, 255, 255), (0, 255, 0, 255), (0, 128, 255, 255), (255, 255, 0, 255), (255, 165, 0, 255),...

property directory

property file

change_colors(e)

Apply()

OnOK(event)

OnCancel(event)

OnSetDefault(event)

OnSave(event)

OnLoad(event)

class wolfhece.PyDraw.DragdropFileTarget(window: WolfMapViewer)

Bases: wx.dataview.wx.FileDropTarget

window

OnDropFiles(x, y, filenames)

class wolfhece.PyDraw.Sim_Explorer(parent, title, mapviewer: WolfMapViewer, sim: wolfhece.wolfresults_2D.Wolfresults_2D)

Bases: wx.dataview.wx.Frame

_panel

mapviewer

active_res2d: wolfhece.wolfresults_2D.Wolfresults_2D

_all_times_steps

_slider_steps

_label_idx

_step_idx

_label_time

_starting_date

_texttime

_step_time

_label_steps

_step_num

_cmd_apply

_cmd_update

_cmd_plot

_cmd_next

_cmd_prev

_mode

_interval

MinSize = (450, 500)

OnPlot(event)

Create a scatter plot of all steps.

Major x_axis is time in seconds, Minor X-axis is time by date.

Plots:

• Computation time step (Dt)

• Computation steps (N)

• Clock time (s)

• Mostly dry mesh (N)

OnInterval(event)

Change the interval

_find_next(idx: int)

Find the next step based on the mode and interval

_find_prev(idx: int)

Find the previous step based on the mode and interval

OnNext(event)

Go to the next step

OnPrev(event)

Go to the previous step

OnTextTime(event)

OnClose(event)

Close the simulation explorer

OnUpdate(event)

OnApply(event)

_set_all(idx: int)

Refresh(idx: int)

OnSliderSteps(event)

OnSelectCurTime(event)

OnSelectNumStep(event)

OnSelectIdxStep(event)

_update()

class wolfhece.PyDraw.Sim_VideoCreation(parent, title, mapviewer: WolfMapViewer, sim: wolfhece.wolfresults_2D.Wolfresults_2D)

Bases: wx.dataview.wx.Dialog

mapviewer

active_res2d: wolfhece.wolfresults_2D.Wolfresults_2D

_framerate = 25

_start_step = 1

_end_step

_interval = 1

_fn = ''

_tz_ref

_tz_plot

_date_ref

_fontsize = 16

_fontcolor = (255, 255, 255, 255)

_timeposition = 'top-left'

tc1

btn_browse

tc2

tc3

tc4

tc5

tc7

tc8

tc9

btn1

btn2

check_date

calendar

timezone_ref

timezone_plot

OnBrowse(event)

Browse a file name to save the video

get_values()

Return the values set in the dialog

OnValidate(event)

Validate the text controls to be sure that the values are correct

OnOk(event)

Create the video file

OnCancel(event)

Cancel the video creation

class wolfhece.PyDraw.Drowning_Explorer(parent, title, mapviewer: any, sim: wolfhece.drowning_victims.drowning_class.Drowning_victim_Viewer)

Bases: wx.dataview.wx.Frame

_panel

mapviewer

active_drowning: wolfhece.drowning_victims.drowning_class.Drowning_victim_Viewer

_all_times_steps

_slider_steps

_time_drowning

_label_time

_starting_date

_texttime

_step_time

_step_idx

_cmd_apply

_cmd_next

_cmd_prev

MinSize = (450, 500)

_find_next(idx: int)

Find the next step based on the mode and interval

_find_prev(idx: int)

Find the previous step based on the mode and interval

OnNext(event)

Go to the next step

OnTextTime(event)

OnPrev(event)

Go to the previous step

OnClose(event)

Close the simulation explorer

OnUpdate(event)

OnApply(event)

_set_all(idx: int)

Refresh(idx: int)

OnSliderSteps(event)

OnSelectNumStep(event)

OnSelectIdxStep(event)

_update()

class wolfhece.PyDraw.Select_Begin_end_interval_step(parent, title, sim: wolfhece.wolfresults_2D.Wolfresults_2D, checkbox: bool = False)

Bases: wx.dataview.wx.Dialog

wx.frame to select the begin and end of the interval to extract

_panel

begin = 1

end

step = 1

check_all = True

check_violin = False

_slider_begin

_slider_end

_label_range

_text_range

_slider_step

_label_step

_text_step

_cmd_apply

_cmd_ok

_cmd_cancel

OnCheckAll(event)

OnCheckViolin(event)

OnSliderBegin(event)

OnSliderEnd(event)

OnSliderStep(event)

OnApply(event)

OnOK(event)

OnCancel(event)

class wolfhece.PyDraw.PrecomputedDEM_DTM(*args, **kwds)

Bases: enum.Enum

Enum for Precomputed DEM/DTM array

DEMDTM_50cm = 'AllData.vrt'

DEMDTM_1m_average = 'Combine_1m_average.vrt'

DEMDTM_1m_min = 'Combine_1m_minimum.vrt'

DEMDTM_1m_max = 'Combine_1m_maximum.vrt'

DEMDTM_2m_average = 'Combine_2m_average.vrt'

DEMDTM_2m_min = 'Combine_2m_minimum.vrt'

DEMDTM_2m_max = 'Combine_2m_maximum.vrt'

DEMDTM_5m_average = 'Combine_5m_average.vrt'

DEMDTM_5m_min = 'Combine_5m_minimum.vrt'

DEMDTM_5m_max = 'Combine_5m_maximum.vrt'

DEMDTM_10m_average = 'Combine_10m_average.vrt'

DEMDTM_10m_min = 'Combine_10m_minimum.vrt'

DEMDTM_10m_max = 'Combine_10m_maximum.vrt'

class wolfhece.PyDraw.Precomputed_DEM_DTM_Dialog(parent, title, directory: pathlib.Path | str, mapviewer: WolfMapViewer)

Bases: wx.dataview.wx.Dialog

wx.Dialog to select Precomputed DEM/DTM array

Resolutions are 50cm, 1m, 2m, 5m, 10m Operators are average, min, max

_dir

_header = None

_vrt = None

_mapviewer

_panel

_res = ['50cm', '1m', '2m', '5m', '10m']

_ops = ['average', 'minimum', 'maximum']

_resolution

_operations

_cmd_sameactive

_cmd_sameas

_cmd_zoom

OnSameAs(event)

Set the Precomputed DEM/DTM array to the same bounds as an existing array

OnSameActive(event)

Set the Precomputed DEM/DTM array to the same bounds as the active array

OnZoom(event)

Set the Precomputed DEM/DTM array to the current zoom

property selected_vrt

add_array()

Add a new array to the viewer

OnSelectResolution(event)

Select the resolution

available_vrt()

List all available vrt files in the directory

class wolfhece.PyDraw.GlobalAnimationClock(mapviewer: WolfMapViewer)

Global animation clock manager for all zones with animations.

Replaces per-zone wx.Timer instances with a single centralized timer. This avoids flooding the wxPython event queue with redundant refresh events when dozens of zones are animated simultaneously.

Features: - Single ~30 fps timer for the entire WolfMapViewer - Zones register/unregister their animation needs - Adaptive throttling based on total animation load - On each tick, updates a shared time base and requests one redraw - Automatically stops the timer when no animations are active

_FPS_STEPS

mapviewer

timer: wx.dataview.wx.Timer | None = None

subscribed_zones: dict[int, int]

current_time: float = 0.0

_timer_start_time: float | None = None

_interval_ms: int | None = None

property total_load: int

Return the total declared animation load across all zones.

subscribe(zone, load: int = 1)

Register a zone as animated with its estimated rendering load.

Automatically starts the timer if this is the first subscription.

unsubscribe(zone)

Unregister a zone from animation.

Automatically stops the timer if this was the last subscription.

_get_target_interval_ms() → int

Return the timer interval based on the current animation load.

_ensure_timer_state()

Start, stop, or retune the timer according to current load.

_start_timer(interval_ms: int)

Start the global animation timer.

_stop_timer()

Stop the global animation timer.

_on_timer_tick(event)

Handle timer tick: update time and request canvas refresh.

get_phase(anim_speed: float = 1.0) → float

Compute animation phase for a given speed.

Parameters:

anim_speed – Animation speed multiplier (default 1.0).

Returns:

Phase in range [0, 1), cycling at rate = anim_speed.

destroy()

Clean up the timer and disconnect.

class wolfhece.PyDraw.WolfMapViewer(wxparent=None, title: str = _('Default Wolf Map Viewer'), w: int = 500, h: int = 500, treewidth: int = 200, wolfparent=None, wxlogging=None, enable_async_background_updates: bool = False)

Bases: wx.dataview.wx.Frame

Fenêtre de visualisation de données WOLF grâce aux WxWidgets

TIMER_ID = 100

mybc: list[wolfhece.mesh2d.bc_manager.BcManager]

myarrays: list

myvectors: list[wolfhece.PyVertexvectors.Zones]

myclouds: list[wolfhece.PyVertexvectors.cloud_vertices, wolfhece.PyVertex.cloud_of_clouds]

mytri: list[wolfhece.PyVertexvectors.Triangulation]

myothers: list

myviews: list[wolfhece.wolfresults_2D.views_2D]

mywmsback: list

mywmsfore: list

myres2D: list

mytiles: list[wolfhece.wolf_tiles.Tiles]

myimagestiles: list[wolfhece.images_tiles.ImagesTiles]

mypartsystems: list[wolfhece.lagrangian.particle_system_ui.Particle_system_to_draw]

myviewers3d: list[wolfhece.opengl.py3d.Wolf_Viewer3D]

mylazdata: list[wolfhece.lazviewer.laz_viewer.Wolf_LAZ_Data]

mydrownings: list[wolfhece.drowning_victims.drowning_class.Drowning_victim_Viewer]

mypicturecollections: list[wolfhece.PyPictures.PictureCollection]

mydikes: list[wolfhece.dike.DikeWolf]

mymplfigs: list[MplFigViewer]

sim_explorers: dict[Wolfresults_2D:Sim_Explorer]

canvas: wx.glcanvas.GLCanvas

context: wx.glcanvas.GLContext

mytooltip: wolfhece.PyParams.Wolf_Param

treelist: wx.dataview.TreeListCtrl

_lbl_selecteditem: wx.core.StaticText

leftbox: wx.core.BoxSizer

active_vector: wolfhece.PyVertexvectors.vector

active_zone: wolfhece.PyVertexvectors.zone

active_zones: wolfhece.PyVertexvectors.Zones

active_array: wolfhece.wolf_array.WolfArray

active_bc: wolfhece.mesh2d.bc_manager.BcManager

active_view: wolfhece.pyviews.WolfViews

active_vertex: wolfhece.PyVertexvectors.wolfvertex

active_cs: wolfhece.PyCrosssections.crosssections

active_tri: wolfhece.PyVertexvectors.Triangulation

active_tile: wolfhece.wolf_tiles.Tiles

active_imagestiles: wolfhece.images_tiles.ImagesTiles

active_particle_system: wolfhece.lagrangian.particle_system_ui.Particle_system_to_draw

active_viewer3d: wolfhece.opengl.py3d.Wolf_Viewer3D

active_viewerlaz: wolfhece.lazviewer.laz_viewer.viewer

active_bridges: wolfhece.pybridges.Bridges

active_bridge: wolfhece.pybridges.Bridge

active_weirs: wolfhece.pybridges.Weirs

active_weir: wolfhece.pybridges.Weir

active_laz: wolfhece.lazviewer.laz_viewer.Wolf_LAZ_Data

active_drowning: wolfhece.drowning_victims.drowning_class.Drowning_victim_Viewer

active_lidaxe

active_dike: wolfhece.dike.DikeWolf

active_picturecollection: wolfhece.PyPictures.PictureCollection

active_alaro: wolfhece.irm_alaro.IRM_Alaro

active_fig: MplFigViewer

alaro_navigator: wolfhece.PyWMS.Alaro_Navigator

_last_paint_bounds = None

_last_async_background_update_time = None

_last_bounds_change_time = None

enable_async_background_updates = False

_show_dialog_wx = True

treewidth = 200

_wxlogging = None

action = None

update_absolute_minmax = False

copyfrom = None

wolfparent = None

regular = True

sx = 1

sy = 1

samescale = True

dynapar_dist = 1.0

xmin = 0.0

ymin = 0.0

xmax = 40.0

ymax = 40.0

width

height

canvaswidth = 100

canvasheight = 100

mousex

mousey

_last_mouse_pos = (0, 0, (0, 0))

_asset_transform_controller = None

_asset_transform_editor = None

_asset_transform_drag_handle = None

_asset_transform_drag_start_xy = None

_asset_transform_drag_start_bounds = None

_asset_transform_cursor_key = None

_asset_transform_direct_pan = False

_asset_transform_editor_refresh_pending = False

_snap_grid_unit = 0.01

_snap_grid_round_base = 1000.0

_snap_grid_origin = None

_snap_grid_origin_signature = None

bordersize = 0

titlesize = 0

backcolor

mousedown

oneclick = True

linked = False

link_shareopsvect = True

linkedList = None

link_params = None

project_pal = None

forcemimic = True

currently_readresults = False

mylazgrid: wolfhece.lazviewer.laz_viewer.xyz_laz_grids = None

colors1to9

_dragdrop

popupmenu

menubar

menuwolf2d = None

menu_landmap = None

menu_bridge = None

menu_weir = None

menu2d_cache_setup = None

menuparticlesystem = None

menu2dGPU = None

menuLandUseLandCover = None

timer_ps = None

anim_clock

menusim2D = None

menusim2D_GPU = None

menulaz = None

menutiles = None

menuimagestiles = None

menudrowning = None

menudike = None

menupicturecollections = None

menuqdfidf = None

menualaro = None

menulidaxe = None

filemenu

menugltf

menu_sim2d

menu_sim2d_cpu

menu_sim2d_gpu

menu_sim1d

menu_hydrology

menucreateobj

menuaddobj

precomputed_menu = None

tools_menu

menu_contour_from_arrays

menu_calculator

menu_views

menu_pie

menu_pie_create

menu_pie_edit

menu_pie_load_json

menu_bar

menu_bar_create

menu_bar_edit

menu_bar_load_json

menu_curve

menu_curve_create

menu_curve_edit

menu_curve_load_json

menu_distances

menu_distances_add

menu_digitizer

calculator = None

memory_views = None

_memory_views_gui = None

cs_menu

link_cs_zones

sortalong

select_cs

plot_cs

menumanagebanks

menucreatenewbanks

renamecs

menutrianglecs

menuexportgltfonebyone

menupontgltfonebyone

menuviewerinterpcs = None

menuinterpcs = None

minmaxmenu

locminmax

analyzemenu

analyzeplot

analyzeexport

analyzeinpaint

analyzesimsheet

tools

active_cloud = None

active_profile = None

active_res2d = None

active_landmap: wolfhece.wolf_zi_db.PlansTerrier = None

selected_treeitem = None

selected_object = None

active_injector = None

active_qdfidf = None

active_cloud_vertex_id = None

helpmenu

mybackisloaded = False

myfrontisloaded = False

root

myitemsarray

myitemsvector

myitemscloud

myitemslaz

myitemstri

myitemsres2d

myitemsps

myitemsothers

myitemsviews

myitemswmsback

myitemswmsfore

myitemsdrowning

myitemsdike

myitemsinjector

myitemspictcollection

_tooltip_ctrl_active = False

_oldpos_tooltip = None

_current_mouse_pos

_overlay_xy_text_renderer = None

_overlay_xy_text_atlas = None

notebookcs = None

notebookprof = None

notebookbanks = None

myaxcs = None

myaxprof = None

myfigcs = None

myfigprof = None

cloudmenu = None

trianglesmenu = None

_configuration = None

compare_results = None

_tmp_vector_distance = None

_distances

_check_id_for_fig(idx: str)

Check if an ID is already used for a figure

_create_id_for_fig()

_validate_id_for_fig(idx: str)

Validate an ID for a figure

new_fig(caption: str, idx: str = None, layout=PRESET_LAYOUTS.DEFAULT, size=(800, 600), show: bool = True) → MplFigViewer

Create a new figure

destroy_fig_by_id(idx: str) → bool

Destroy a figure by its ID

get_fig(idx: str) → MplFigViewer

Get a figure by its ID

list_ids_figs() → list[str]

List all IDs of figures

property viewer_name

property wxlogging

check_logging()

Check if logging window is shown

check_tooltip()

Check if tooltip window is shown

open_hydrological_model()

Open a hydrological model

create_2D_MB_model()

Create a 2D model

create_2D_GPU_model()

Create a 2D GPU model

check_2D_MB_headers()

Check headers of a 2D simulation without opening viewer

get_mapviewer()

Retourne une instance WolfMapViewer

do_quit()

create_triangles_menu()

Menu for triangulations

create_cloud_menu()

Menu for cloud points

add_points_to_cloud()

Add points to cloud

move_point_in_cloud()

Interactive move of one cloud point preserving row id.

_cloud_move_pick_tolerance(pixel_tol: float = 40.0) → float

Convert a pixel tolerance to map units for nearest-point picking.

_snap_xy_on_grid(x: float, y: float, do_snap: bool = True) → tuple[float, float]

Snap point coordinates using the grid.

_overlay_xy_for_mouse(x: float, y: float, altdown: bool) → tuple[float, float]

Return XY used by OpenGL overlay, with snap when interaction supports it.

split_cloud_by_vector()

Split cloud by vector

get_choices_arrays()

Boîte de dialogue permettant de choisir une ou plusieurs matrices parmi celles chargées

menu_tiles()

Menu for tiles

pîck_image_tile(event: wx.dataview.wx.Event)

menu_pictcollection()

Menu for picture collections

menu_qdfidf()

Menu for QDF/IDF files

action_qdfidf(event: wx.dataview.wx.Event)

Action for QDF/IDF files

action_pictcollections(event: wx.dataview.wx.Event)

Action for picture collections

menu_imagestiles()

Menu for image tiles

pick_tile(event: wx.dataview.wx.Event)

create_data_from_tiles_activevec(event: wx.dataview.wx.Event)

_create_data_from_tiles_common()

create_data_from_tiles_tmpvec(event: wx.dataview.wx.Event)

menu_laz()

Menu for LAZ Data

menu_wolf2d()

menu_alaro_forecasts()

Menu for Alaro forecasts

Onmenualaro(event: wx.dataview.wx.Event)

Action for Alaro forecasts

menu_landuse_landcover()

menu_drowning()

menu_dike()

get_canvas_bounds(gridsize: float = None)

Retourne les limites de la zone d’affichage

Returns:

[xmin, ymin, xmax, ymax]

get_bounds(gridsize: float = None) → tuple

Retourne les limites de la zone d’affichage, voir aussi get_canvas_bounds

Returns:

([xmin, xmax], [ymin, ymax])

get_bounds_as_polygon(gridsize: float = None) → wolfhece.PyVertexvectors.vector

Retourne les limites de la zone d’affichage sous forme de polygone :return: vector

Onmenu_landuse_landcover_importfromfile(event: wx.dataview.wx.MenuEvent)

Handle the Landuse/Landcover import from file menu events

Onmenuwalous_ocs(event: wx.dataview.wx.MenuEvent)

Handle the Walous OCS menu events

Onmenuwalous_uts(event: wx.dataview.wx.MenuEvent)

Handle the Walous UTS menu events

_add_sim_explorer(which: wolfhece.wolfresults_2D.Wolfresults_2D)

Add a step chooser

_pop_sim_explorer(which: wolfhece.wolfresults_2D.Wolfresults_2D)

Pop a step chooser

_update_sim_explorer(which: wolfhece.wolfresults_2D.Wolfresults_2D = None)

Onmenudrowning(event: wx.dataview.wx.MenuEvent)

Onmenudike(event: wx.dataview.wx.MenuEvent)

Onmenuwolf2d(event: wx.dataview.wx.MenuEvent)

menu_2dgpu()

menu_landmaps()

change_transparent_color_landmap(event: wx.dataview.wx.Event)

set_tolerance_landmap(event: wx.dataview.wx.Event)

change_colors_landmap(event: wx.dataview.wx.Event)

pick_landmap_full(event: wx.dataview.wx.Event)

pick_landmap_low(event: wx.dataview.wx.Event)

menu_particlesystem()

action_menu_particlesystem(event: wx.dataview.wx.Event)

Action to perform when the timer is triggered

update_particlesystem(event: wx.dataview.wx.Event)

Animation of the particle system

menu_sim2D()

Menu for 2D simulations

menu_sim2DGPU()

Menu for 2D GPU simulations

Onmenusim2DGPU(event: wx.dataview.wx.MenuEvent)

Action to perform when menu 2D GPU entry is selected

Onmenusim2D(event: wx.dataview.wx.MenuEvent)

Action to perform when menu 2D entry is selected

get_configuration() → OpenGL.GLUT.Union[wolfhece.PyConfig.WolfConfiguration, None]

Get global configuration parameters

property epsg: int

Return the EPSG code from configs

property active_vector_color: list[int]

Return the active vector color from configs

property active_vector_square_size: list[int]

Return the active vector square size from configs

property default_dem: pathlib.Path

Return the default DEM file from configs

property default_dtm: pathlib.Path

Return the default DTM file from configs

property default_laz

Return the default LAZ file from configs

property default_hece_database: pathlib.Path

Return the default HECE database file from configs

property bkg_color

Return the background color from configs

property ticks_size: float

Return the ticks spacing from configs

property ticks_xrotation: float

Return the ticks x rotation from configs

property ticks_fontsize: int

Return the ticks font size from configs

property overlay_xy_font_name: str

Return font name used by OpenGL XY overlay text.

property overlay_xy_font_size: int

Return font size in pixels used by OpenGL XY overlay text.

property snap_grid_unit: float

Return the base snap grid unit [m].

property snap_grid_round_base: float

Return the coarse base used to align the snap origin [m].

property assembly_mode: str

Return the assembly mode from configs

property ticks_bounds: bool

Return the ticks bounds from configs

property palette_for_copy: wolfhece.PyVertexvectors.wolfpalette

Return the palette for copy from configs

GlobalOptionsDialog(event)

triangulate_cs()

Triangulate the active cross sections

set_interp_cs(obj: wolfhece.PyCrosssections.Interpolators, add_zones: bool = True)

Set the active cross-sections interpolator

interpolate_cloud()

Interpolation d’un nuage de point sur une matrice

Il est possible d’utiliser une autre valeur que la coordonnées Z des vertices

interpolate_cs()

Interpolate the active cross sections by interpolators

interpolate_triangulation(keep: Literal['all', 'above', 'below'] = 'all')

Alias to interpolate on triangulation

Parameters:

keep – ‘all’ to keep all points, ‘above’ to keep only points above the current array’s value, ‘below’ to keep only points below the current array’s value

compare_cloud2array()

Compare the active cloud points to the active array

compare_tri2array()

move_triangles()

Move the active triangles

rotate_triangles()

Rotate the active triangles

display_canvasogl(mpl=True, ds=0.0, fig: wolfhece.tools_mpl.Figure = None, ax: wolfhece.tools_mpl.Axes = None, clear=True, redraw=True, palette=False, title='')

This method takes a matplotlib figure and axe and, returns a clear screenshot of the information displayed in the wolfpy GUI.

get_mpl_plot(center=[0.0, 0.0], width=500.0, height=500.0, title='', toshow=True) → tuple[wolfhece.tools_mpl.Figure, wolfhece.tools_mpl.Axes]

Récupère un graphique matplotlib sur base de la fenêtre OpenGL et de la palette de la matrice/résultat actif.

create_video(fn: str = '', framerate: int = 0, start_step: int = 0, end_step: int = 0, every: int = 0)

Création d’une vidéo sur base des résultats

get_canvas_as_image() → PIL.Image.Image

Récupère la fenêtre OpenGL sous forme d’image

copy_canvasogl(mpl: bool = True, ds: float = 0.0, figsizes=[10.0, 10.0], palette: wolfhece.PyVertexvectors.wolfpalette = None)

Generate image based on UI context and copy to the Clipboard

Parameters:

mpl (bool, optional) – Using Matplolib as renderer. Defaults to True.

Parem ds:

Ticks size. Defaults to 0..

Parem figsizes:

fig size in inches

save_canvasogl(fn: str = '', mpl: bool = True, ds: float = 0.0, dpi: int = 300, add_title: bool = False, figsizes=[10.0, 10.0], arrayid_as_title: bool = False, resid_as_title: bool = False)

Sauvegarde de la fenêtre d’affichage dans un fichier

Parameters:

• fn – File name (.png or .jpg file)

• mpl – Using Matplotlib as renderer

• ds – Ticks interval

reporting(dir='')

First attempt to create a reporting. !! Must be improved !!

InitUI()

Initialisation de l’interface utilisateur

OnChangeTitle(e)

Change the title of the window

OnSize(e)

Redimensionnement de la fenêtre

ManageActions(id)

Gestion des actions via les menus

TODO : A généraliser?

center_view_on(cx, cy)

Center the view on the point of (map) coordinates (x,y)

setbounds(updatescale=True)

Calcule les limites visibles de la fenêtre graphique sur base des facteurs d’échelle courants

setsizecanvas(width, height)

Redimensionne la fenêtre graphique

updatescalefactors()

Mise à jour des facteurs d’échelle This one updates the scale factors based on the relative sizes of the GLCanvas and the footprint that should fit in it.

add_viewer_and_link()

Ajout d’une nouvelle fenêtre de visualisation et liaison avec la fenêtre courante

add_grid()

Ajout d’une grille

add_WMS()

Ajout de couches WMS

set_compare(ListArrays: list[wolfhece.wolf_array.WolfArray] = None, share_colormap: bool = True)

Comparison of 2 arrays

Parameters:

• ListArrays – List of 2 arrays to compare

• share_colormap – Share the colormap between the 2 arrays

set_compare_all(ListArrays=None, names: WolfMapViewer.set_compare_all.list[str] = None)

Comparison of 2 or 3 arrays

set_blender_sculpting()

Mise en place de la structure nécessaire pour comparer la donnée de base avec la donnée sculptée sous Blender

La donnée de base est la matrice contenue dans la fenêtre actuelle

Fenêtres additionnelles :

• information sur les volumes de déblai/remblai et bilan

• matrice sculptée

• différentiel entre scultage - source

• gradient

• laplacien

• masque de modification

update_blender_sculpting()

Mise à jour des fenêtres de visualisation pour la comparaison avec Blender

zoomon_activevector(size: float = 500.0, forceupdate: bool = True)

Zoom on active vector

Parameters:

• size – size of the zoomed window

• forceupdate – force the update of the window

zoomon_active_vertex(size: float = 20, forceupdate: bool = True)

Zoom on active vertex.

Parameters:

• size – size of the zoomed window

• forceupdate – force the update of the window

zoom_on_id(id: str, drawtype: draw_type = draw_type.ARRAYS, forceupdate=True, canvas_height=1024)

Zoom on id

Parameters:

• id – id of the object to zoom on

• drawtype – type of object to zoom on - Different types elements can have the same id

zoom_on_array(array: wolfhece.wolf_array.WolfArray, forceupdate=True, canvas_height=1024)

Zoom on array

zoom_on_vector(vector: WolfMapViewer.zoom_on_vector.vector, forceupdate=True, canvas_height=1024)

Zoom on vector

create_Zones_from_arrays(arrays: list[wolfhece.wolf_array.WolfArray], id: str = None, add_legend: bool = True) → wolfhece.PyVertexvectors.Zones

Create a Zones instance from list of WolfArrays

One zone per array.

One vector per zone with the masked contour.

Parameters:

• arrays – list of WolfArrays

• id – id of the Zones instance

• add_legend – add legend to the vector – centroid of the contour

zoom_on(zoom_dict=None, width=500, height=500, center=None, xll=None, yll=None, forceupdate=True, canvas_height=1024)

Zoom on a specific area

It is possible to zoom on a specific area by providing the zoom parameters in :

• a dictionnary

• width and height of the zoomed window and the lower left corner coordinates

• width and height of the zoomed window and the center coordinates

Parameters:

• zoom_dict – dictionnary containing the zoom parameters - possible keys : ‘width’, ‘height’, ‘center’, ‘xmin’, ‘ymin’, ‘xmax’, ‘ymax’

• width – width of the zoomed window [m]

• height – height of the zoomed window [m]

• center – center of the zoomed window [m] - tuple (x,y)

• xll – lower left X coordinate of the zoomed window [m]

• yll – lower left Y coordinate of the zoomed window [m]

• forceupdate – force the update of the window

• canvas_height – height of the canvas [pixels]

Examples :

• zoom_on(zoom_dict = {‘center’:(500,500), ‘width’:1000, ‘height’:1000})

• zoom_on(width = 1000, height = 1000, xll = 500, yll = 500)

• zoom_on(width = 1000, height = 1000, center = (500,500))

zoom_on_active_profile(size: float = 500.0, forceupdate: bool = True)

Zoom on active profile

read_project(fn)

Projet WOLF GUI

Fichier de paramètres contenant les types et chemins d’accès aux données à ajouter

A compléter…

save_project(fn, absolute: bool = True)

Save project file

help_project()

Help for project file.

Define which elements can be saved in a project file.

plot_laz_around_active_vec()

Plot laz data around active vector

clip_laz_gridded()

Clip laz grid on current zoom

filter_active_laz()

Filter active laz data

descimate_laz_data(factor: int = 10)

Descimate data

select_active_array_from_laz(array: wolfhece.wolf_array.WolfArray = None, used_codes: list = None, chunk_size: float = 500.0)

select some nodes from laz data

Parameters:

• array – array to fill

• used_codes – codes to use

fill_active_array_from_laz(array: wolfhece.wolf_array.WolfArray = None, used_codes: list = [], operator: int = -1, chunk_size: float = 500.0)

Fill active array with laz data

Parameters:

• array – array to fill

• used_codes – codes to use

• operator – operator to use

count_active_array_from_laz(array: wolfhece.wolf_array.WolfArray = None, used_codes: list = [], chunk_size: float = 500.0)

Fill active array with laz data

Parameters:

• array – array to fill

• used_codes – codes to use

• operator – operator to use

init_laz_from_lazlasnpz(fn=None)

Read LAZ data stored in one file

Parameters:

fn – filename (extension .laz, .las, .npz)

_choice_laz_classification()

init_laz_from_gridinfos(dirlaz: str = None, classification: Literal['SPW-Geofit 2023', 'SPW 2013-2014', 'SPW 2021-2022'] = 'SPW-Geofit 2023')

managebanks()

_set_fn_fnpos_gltf()

Définition du nom de fichier GLTF/GLB à lire pour réaliser la comparaison Utilisation d’une fenêtre de dialogue WX

Cette fonction n’est a priori appelée que depuis set_fn_fnpos_gltf

set_fn_fnpos_gltf()

Définition ou récupération du nom de fichier GLTF/GLB à lire pour réaliser la comparaison

Le nom de fichier est stocké dans la liste des paramètres partagés de façon à ce que l’appel de mise à jour puisse s’effectuer dans n’importe quel frame

read_last_result()

Lecture du dernier résultat pour les modèles ajoutés et plottés

read_one_result(which: int)

Lecture d’un résultat spécific pour les modèles ajoutés et plottés

Parameters:

which – result index (0-based) – -1 for last result

0 = first result

simul_previous_step()

Mise à jour au pas précédent

particle_next_step()

Mise à jour au pas suivant

particle_previous_step()

Mise à jour au pas précédent

simul_next_step()

Mise à jour au pas suivant

OnMenuHighlight(event: wx.dataview.wx.MenuEvent)

_select_laz_source()

Select laz source

_choice_laz_colormap() → int

newdrowning(itemlabel)

add_lidaxe()

menu_lidaxe()

Onmenulidaxe(event)

new_dike(itemlabel)

Called when ‘Create dike…’ or ‘Add dike…’ are selected in the viewer

_run_compare_arrays(dlg)

Run the comparison of two arrays

_compare_arrays()

Compare two arrays

OnMenubar(event: wx.dataview.wx.MenuEvent)

Gestion des clicks sur le menu quel que soit le niveau

Idée générale :

• récupérer le label du menu sur base de l’id de l’event WX passé en argument –> itemlabel

• tester le label du menu sur base de la chaîne traduite

• a priori appeler une autre routine spécifique au traitement choisi

• éviter autant que possible de coder des fonctions directement dans cette routine ce qui la rendrait complexe à lire

AUTRE POSSIBILITE:

• mettre en place un dictionnaire avec key==label, value==action qui se contenterait de tester la présence du label dans les clés et d’appeler l’action

• dans ce dernier cas, il faudrait que les routines possèdent idéalement une interface unique

pop_boundary_manager(which: wolfhece.mesh2d.bc_manager.BcManager)

Pop a boundary condition manager after Destroying

get_boundary_manager(which: wolfhece.wolf_array.WolfArray)

Get a boundary manager

uniquecolormap(loadfromfile=False)

Compute unique colormap from all (arrays, 2D results) and apply it to all

loadnap_and_apply()

uniforminparts_all(TrueOrFalse: bool)

filter_inundation()

export_results_as(which: Literal['geotiff', 'shape', 'numpy'] = None, multiband: bool = None)

Export des résultats WOLF2D vers différents formats. Au moins un résultat doit être chargé pour pouvoir être exporté.

export_shape(outdir: str = '', fn: str = '', myarrays: list[wolfhece.wolf_array.WolfArray] = [], descr: list[str] = [], mask: wolfhece.wolf_array.WolfArray = None)

Export multiple arrays to shapefile

Parameters:

• outdir – output directory

• fn – filename – .shp will be added if not present

• myarrays – list of Wolfarrays to export

• descr – list of descriptions

• mask – mask array – export only where mask > 0

export_geotif(outdir: str = '', fn: str = '', myarrays: list[wolfhece.wolf_array.WolfArray] = [], descr: list[str] = [], multiband: bool = True)

Export multiple arrays to geotiff

Parameters:

• outdir – output directory

• fn – filename – .tif will be added if not present

• myarrays – list of Wolfarrays to export

• descr – list of descriptions – Bands names

get_linked_arrays(linked: bool = True) → dict

Get all arrays in the viewer and linked viewers

save_linked_canvas(fn: str, mpl: bool = True, ds: float = 0.0, add_title: bool = True) → tuple[str, float, str]

Save canvas of all linked viewers

Parameters:

• fn – filename without extension – ‘.png’ will be added

• mpl – save as matplotlib image

• ds – Ticks size for matplotlib image

Returns:

list of tuple ((filename, ds), viewer_name)

save_arrays_indep(fn: str, mpl: bool = True, ds: float = 0.0, add_title: bool = True) → tuple[str, float, str]

Save each array in a separate file

Parameters:

• fn – filename without extension – ‘.png’ will be added

• mpl – save as matplotlib image

• ds – Ticks size for matplotlib image

Returns:

list of tuple ((filename, ds), viewer_name)

assembly_images(all_images, mode: Literal['horizontal', 'vertical', 'square'] = 'square')

Assembly images

Every image has the same size (width, height)

Parameters:

• all_images – list of tuple (filename, viewer_name)

• mode – ‘horizontal’, ‘vertical’, ‘square’

thread_update_blender()

add_object(which: Literal['array', 'array_lidar_first', 'array_lidar_second', 'array_xyz', 'array_tiles', 'bridges', 'weirs', 'vector', 'tiles', 'tilescompcloud', 'laz', 'clouds', 'triangulation', 'cross_sections', 'other', 'views', 'res2d', 'res2d_gpu', 'particlesystem', 'wmsback', 'wmsfore', 'drowning', 'imagestiles', 'dike', 'injector', 'picture_collection'] = 'array', filename='', newobj=None, ToCheck=True, id='')

Add object to current Frame/Drawing area

add_pie_asset(values: Sequence[float], x: float, y: float, radius: float, id: str = 'pie_chart', labels: Sequence[str] = None, colors: Sequence[tuple[int, int, int] | tuple[int, int, int, int]] = None, ToCheck: bool = True, return_controller: bool = False, open_editor: bool = False, **kwargs) → wolfhece.PyVertexvectors.Zones | wolfhece.assets.pie.PieZonesController

Create and add a world-space pie chart with persistent controller.

The pie is generated as native Zones and managed by a PieZonesController that can rebuild geometry dynamically.

Parameters:

• return_controller – if True, return the controller instead of Zones.

• open_editor – if True, open the dedicated wx editor window.

_bind_pie_controller_to_zones(controller: wolfhece.assets.pie.PieZonesController, zones: wolfhece.PyVertexvectors.Zones | None) → None

Attach pie controller metadata directly to the vector object (Zones).

_iter_pie_controllers() → list[wolfhece.assets.pie.PieZonesController]

Collect pie controllers from native vector objects.

_get_pie_controller(pie_id: str) → wolfhece.assets.pie.PieZonesController | None

OnCreatePieChart(event: wx.dataview.wx.Event)

Create a new editable pie chart and open the full wx editor.

OnEditPieChart(event: wx.dataview.wx.Event)

Open pie editor for an existing controller.

OnLoadPieChartJSON(event: wx.dataview.wx.Event)

Load an editable pie chart from JSON and attach it to this viewer.

add_bar_asset(values: Sequence[float], x: float, y: float, width: float, height: float, id: str = 'bar_chart', labels: Sequence[str] = None, colors: Sequence[tuple[int, int, int] | tuple[int, int, int, int]] = None, orientation: str = 'horizontal', ToCheck: bool = True, return_controller: bool = False, open_editor: bool = False, **kwargs) → wolfhece.PyVertexvectors.Zones | wolfhece.assets.bar.BarZonesController

Create and add a world-space bar chart with persistent controller.

The bar chart is generated as native Zones and managed by a BarZonesController that can rebuild geometry dynamically.

Parameters:

• orientation – ‘horizontal’ or ‘vertical’

• return_controller – if True, return the controller instead of Zones.

• open_editor – if True, open the dedicated wx editor window.

_bind_bar_controller_to_zones(controller: wolfhece.assets.bar.BarZonesController, zones: wolfhece.PyVertexvectors.Zones | None) → None

Attach bar controller metadata directly to the vector object (Zones).

_iter_bar_controllers() → list[wolfhece.assets.bar.BarZonesController]

Collect bar controllers from native vector objects.

_get_bar_controller(bar_id: str) → wolfhece.assets.bar.BarZonesController | None

OnCreateBarChart(event: wx.dataview.wx.Event)

Create a new editable bar chart and open the full wx editor.

OnEditBarChart(event: wx.dataview.wx.Event)

Open bar editor for an existing controller.

OnLoadBarChartJSON(event: wx.dataview.wx.Event)

Load an editable bar chart from JSON and attach it to this viewer.

add_curve_asset(curves: Sequence[Sequence[tuple[float, float]]], id: str = 'curve_plot', labels: Sequence[str] = None, colors: Sequence[tuple[int, int, int] | tuple[int, int, int, int]] = None, canvas_origin: tuple[float, float] = (0.0, 0.0), canvas_size: tuple[float, float] = (100.0, 100.0), area_fraction: tuple[float, float, float, float] = (0.1, 0.1, 0.8, 0.3), ToCheck: bool = True, return_controller: bool = False, open_editor: bool = False, **kwargs) → wolfhece.PyVertexvectors.Zones | wolfhece.assets.curve.CurveZonesController

Create and add a world-space curve chart with persistent controller.

_bind_curve_controller_to_zones(controller: wolfhece.assets.curve.CurveZonesController, zones: wolfhece.PyVertexvectors.Zones | None) → None

Attach curve controller metadata directly to the vector object (Zones).

_iter_curve_controllers() → list[wolfhece.assets.curve.CurveZonesController]

Collect curve controllers from native vector objects.

_get_curve_controller(curve_id: str) → wolfhece.assets.curve.CurveZonesController | None

OnCreateCurveChart(event: wx.dataview.wx.Event)

Create a new editable curve chart and open the full wx editor.

OnEditCurveChart(event: wx.dataview.wx.Event)

Open curve editor for an existing controller.

OnLoadCurveChartJSON(event: wx.dataview.wx.Event)

Load an editable curve chart from JSON and attach it to this viewer.

replace_object(id: str, newobj, drawing_type: draw_type = None)

Replace an object in the list of objects of type drawing_type

get_obj_from_treeitem(treeitem)

Find the object associated with treeitem

get_treeitem_from_id(id: str, drawing_type: draw_type = None)

Find the tree item associated with id

get_treeitem_from_obj(obj)

Find the tree item associated with obj.

Alias for “gettreeitem”.

getobj_from_id(id: str, drawing_type: draw_type = None)

Find the object associated with id

get_obj_from_id(id: str, drawing_type: draw_type = None)

Find the object associated with id in a specifid drawtype

If you want to search in all drawtypes, use getobj_from_id instead.

Parameters:

• id – str : id of the object

• drawtype – draw_type : type of object to search

_get_list(drawing_type: draw_type = None)

return the list of objects of type drawing_type

get_list_keys(drawing_type: draw_type = None, checked_state: bool = True)

Create a list of keys of type draw_type.

Return a list of keys (idx) in LOWER CASE of objects of type draw_type.

Parameters:

• drawing_type – type of object to search - If None, return all objects

• checked_state – if True/False, return only keys of objects that are plotted or not. None return all objects.

get_list_ids(drawing_type: draw_type = None, checked_state: bool = True)

Alias for get_list_keys

get_list_objects(drawing_type: draw_type = None, checked_state: bool = True)

Create a list of objects of type draw_type.

Return a list of keys (idx) in LOWER CASE of objects of type draw_type.

Parameters:

• drawing_type – type of object to search – If None, return all objects.

• checked_state – if True/False, return only objects that are plotted or not. None return all objects.

single_choice_key(draw_type: WolfMapViewer.single_choice_key.draw_type, checked_state: bool = True, message: str = _('Make a choice'), title: str = _('Choice'))

Create wx dialog to choose a key object of type draw_type

single_choice_object(draw_type: WolfMapViewer.single_choice_object.draw_type, checked_state: bool = True, message: str = _('Make a choice'), title: str = _('Choice'))

Create wx dialog to choose an object of type draw_type

multiple_choice_key(draw_type: WolfMapViewer.multiple_choice_key.draw_type, checked_state: bool = True, message: str = _('Make a choice'), title: str = _('Choice'))

Create wx dialog to choose multiple keys object of type draw_type

multiple_choice_object(draw_type: WolfMapViewer.multiple_choice_object.draw_type, checked_state: bool = True, message: str = _('Make a choice'), title: str = _('Choice'))

Create wx dialog to choose multiple objects of type draw_type

iterator_over_objects(drawing_type: draw_type, checked_state: bool = True)

Create iterator over objects of type draw_type

gettreeitem(obj)

Find the tree item associated with obj

removeobj()

Remove selected item from general tree

checkuncheckobj()

Check/uncheck selected item from general tree

removeobj_from_id(id: str, draw_type: WolfMapViewer.removeobj_from_id.draw_type = None)

Remove object from id

_tree_drag_active: bool = False

_tree_drag_source_item = None

_tree_drag_source_obj = None

_tree_drag_start_pos = None

_tree_drag_drop_before: bool = False

_tree_drag_overlay = None

_TREE_DRAG_THRESHOLD: int = 6

_tree_drag_init()

Bind mouse events on the DataView’s main window for DnD.

_on_tree_left_down(e: wx.dataview.wx.MouseEvent)

Record potential drag start position.

_on_tree_motion(e: wx.dataview.wx.MouseEvent)

Detect drag start, update cursor and draw drop indicator.

_on_tree_left_up(e: wx.dataview.wx.MouseEvent)

Perform drop if drag was active.

_tree_drag_cancel()

Reset drag state, cursor and overlay.

_move_obj_to(src_item, src_obj, target_item, before=False)

Move src_item before or after target_item in the tree and lists.

Both items must share the same parent (category).

upobj()

Up selected item into general tree

downobj()

Down selected item into general tree

OnShowPopup(event)

OnPopupItemSelected(event)

Action to do when an item is selected in the popup menu

OnClose(event)

Close the application

OnSelectItem(event)

Select the item in the tree list

OnCheckItem(event: TreeListEvent)

Check the item in the tree list

_alaro_update_time()

Update the time of the alaro navigator

_alaro_legends()

Show images of the checked alaro layers

getXY(pospix)

OnZoomGesture(e)

OnLeave(e)

get_cross_sections()

Récupération du premier objet crosssections disponible

set_active_profile(active_profile: wolfhece.PyCrosssections.profile)

This method sets the active profile in Pydraw (useful for interfaces communication).

set_active_vector(active_vector: wolfhece.PyVertexvectors.vector)

This method sets the active vector in Pydraw (useful for interfaces communication).

get_active_profile()

This methods returns the active profile in pydraw (useful for interfaces communication).

plot_cross(x: float, y: float)

On_Mouse_Right_Down(e: wx.dataview.wx.MouseEvent)

Event when the right button of the mouse is pressed.

We use this event to manage “action” set by others objects.

On_Mouse_Right_Up(e)

On_Mouse_Button(e: wx.dataview.wx.MouseEvent)

On_Right_Double_Clicks(e)

On_Left_Double_Clicks(e: wx.dataview.wx.MouseEvent)

On_Mouse_Left_Down(e)

Event when the left button of the mouse is pressed

On_Mouse_Left_Up(e)

Event when the left button of the mouse is released

_active_clip_slider = None

_iter_clip_sliders()

Yield all (clip_zone, slider) from checked arrays.

_get_nearest_clip_slider(world_x: float, world_y: float)

Return the nearest slider label if cursor is close, else ‘’.

_try_start_clip_slider_drag(world_x: float, world_y: float) → bool

If a slider bar is under the cursor, start dragging it.

Returns:

True if a drag was started (caller should skip normal handling).

_update_clip_slider_drag(world_x: float, world_y: float) → bool

Update the active slider position during a drag.

Returns:

True if a drag is in progress.

_end_clip_slider_drag()

Finish any active slider drag.

_get_asset_transform_bounds()

static _compute_asset_handles(bounds)

_asset_handle_hit_test(x: float, y: float)

static _cursor_for_asset_handle(handle: str | None) → int

_set_asset_transform_cursor(handle: str | None) → None

static _nice_step(raw_step: float) → float

Round a raw spacing to a readable 1-2-5 x 10^n step.

_ensure_snap_grid_origin() → tuple[float, float]

Return a stable world origin for snapping, initialized once.

The origin is rounded on a coarse base to keep values readable while remaining invariant across zoom changes.

_adaptive_snap_step_from_span(span: float, target_divisions: float = 20.0) → float

Compute zoom-adaptive step as power-of-two multiple of base unit.

Using powers of two guarantees hierarchical nesting: every coarser grid line remains compatible with all finer levels.

_asset_transform_snap_steps() → tuple[float, float]

Return adaptive grid steps as nested multiples of base snap unit.

_asset_transform_snap_origin() → tuple[float, float]

Return stable world origin shared by all snap operations.

static _snap_value(v: float, step: float, origin: float = 0.0) → float

_apply_asset_transform_drag(x: float, y: float, *, keep_ratio: bool = False, resize_from_center: bool = False, do_snap: bool = True)

_plot_grid_transform_overlay()

_is_heavy_gl_action_active() → bool

Return True when an interaction is likely to stress OpenGL drawing.

_plot_mouse_xy_overlay() → None

Draw current world XY near the cursor directly on the OpenGL canvas.

_update_asset_transform_cursor(x: float, y: float)

_set_active_bc()

Search and activate BCManager according to active_array

set_statusbar_text(txt: str)

Set the status bar text

set_label_selecteditem(nameitem: str)

Set the label of the selected item in the tree list

get_label_selecteditem()

Get the label of the selected item in the tree list

OnActivateTreeElem(e)

Activate the selected item in the tree list

SetActiveCloud(cloud: wolfhece.PyVertexvectors.cloud_vertices | None)

Set the active cloud of vertices, and update the tooltip if needed

_update_mytooltip()

Update the tooltip with the values of the active arrays and results at position x,y

On_Mouse_Motion(e: wx.dataview.wx.MouseEvent)

Mouse move event

Autoscale(update_backfore=True)

Redimensionnement de la fenêtre pour afficher tous les objets

_endactions()

End of actions

Call when the user double click on the right button of the mouse or press return.

Depending on the action, the method will call differnt routines and refresh the figure.

Each action must call self.end_action() to nullify the action and print a message.

print_About()

Print the About window

check_for_updates()

Check for updates

print_shortcuts(inframe: bool = None)

Print the list of shortcuts into logging

msg_action(which: int = 0)

Message to end action

start_action(action: str, message: str = '')

Message to start action

end_action(message: str = '')

Message to end action

distance_by_multiple_clicks()

Distance between multiple clicks

toggle_automatic_background()

Toggle automatic background update mode

OnHotKey(e: wx.dataview.wx.KeyEvent)

Gestion des touches clavier – see print_shortcuts for more details

paste_values(fromarray: wolfhece.wolf_array.WolfArray)

Paste selected values from a WolfArray to the active array

paste_selxy(fromarray: wolfhece.wolf_array.WolfArray)

Paste selected nodes from a WolfArray to the active array

OntreeRight(e: wx.dataview.wx.MouseEvent)

Gestion du menu contextuel sur l’arbre des objets

zoom_on_whole_walonia()

Zoom on the whole Walonia

_update_background()

Update background (synchronous - blocking)

_update_background_async()

Trigger asynchronous background image updates.

This method is called when viewport bounds change (during panning/zooming). It triggers non-blocking image loads in the background via the AsyncImageLoader. The textures are updated as images are loaded, without blocking the UI.

_update_foreground()

Update foreground (synchronous - blocking)

update()

Update backgournd et foreground elements and arrays if local minmax is checked.

_plotting(drawing_type: draw_type, checked_state: bool = True)

Drawing objets on canvas

_tracking_label_zones: set

set_tracking_label(zone_id: int, active: bool)

Register or unregister a zone as having active tracking labels.

Parameters:

• zone_id – id(zone) of the calling zone.

• active – True to register, False to unregister.

property has_tracking_labels: bool

Return True if at least one zone has active tracking labels.

get_MVP_Viewport_matrix()

Get the modelview projection matrix

get_ortho_mvp_c_contiguous() → numpy.ndarray | None

Build a 2D orthographic MVP in C-contiguous layout.

Returns:

np.ndarray shape (4, 4), dtype float32, C-contiguous, or None if current view bounds are degenerate.

property mvp

Return model-view-projection matrix in float32 C-contiguous layout.

property sunposition

property sunintensity

SetCurrentContext()

Set the current OGL context if exists otherwise return False

_set_gl_projection_matrix()

Paint()

Plotting elements on canvas

OnPaint(e)

event handler for paint event

findminmax(force=False)

Find min/max of all objects

resizeFrame(w: int, h: int)

Resize the frame

Parameters:

• w – width in pixels

• h – height in pixels

mimicme()

Report des caractéristiques de la fenêtre sur les autres éléments liés

mimicme_copyfrom()

Active_vector(vect)

Active un vecteur et sa zone parent si existante

Active_zone(zone: WolfMapViewer.Active_zone.zone)

Active une zone et son parent si existant

list_background()

list_foreground()

check_id(id=str, gridsize=100.0)

Check an element from its id

uncheck_id(id=str, unload=True, forceresetOGL=True, askquestion=False)

Uncheck an element from its id

get_current_zoom()

Get the current zoom

Returns:

dict with keys ‘center’, ‘xmin’, ‘xmax’, ‘ymin’, ‘ymax’, ‘width’, ‘height’

save_current_zoom(filepath)

Save the current zoom in a json file

read_current_zoom(filepath)

Read the current zoom from a json file

menu_bridges()

OnAddBridge(e)

Add a bridge

OnEditBridge(e)

Edit a bridge

OnFindBridge(e)

Find the nearest bridge

pick_bridge(x: float, y: float)

Find the nearest bridge

menu_weirs()

OnAddWeir(e)

Add a weir

OnEditWeir(e)

Edit a weir

OnFindWeir(e)

Find the nearest weir

pick_weir(x: float, y: float)

Find the nearest weir

class wolfhece.PyDraw.Comp_Type(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

>>> Color.RED
<Color.RED: 1>

• value lookup:

>>> Color(1)
<Color.RED: 1>

• name lookup:

>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

ARRAYS = 1

ARRAYS_MB = 2

RES2D = 3

RES2D_GPU = 4

class wolfhece.PyDraw.Compare_Arrays_Results(parent: WolfMapViewer = None, share_cmap_array: bool = False, share_cmap_diff: bool = False)

parent = None

paths = []

elements = []

linked_elts = []

diff = []

mapviewers = []

mapviewers_diff = []

times = None

share_cmap_array = False

share_cmap_diff = False

type

_initialized_viewers = False

independent = True

_check_type(file: pathlib.Path)

Check the type of the file/directory

If it is a file and suffix is empty, it is considered as RES2D. If it is a directory and contains a simul_gpu_results, it is considered as RES2D_GPU. If it is a file and suffix is not empty, it is considered as ARRAYS. A check is done to see if it is a multi-block array.

add(file_or_dir: OpenGL.GLUT.Union[str, pathlib.Path] = None)

check()

Check the consystency of the elements to compare

update_comp(idx=list[int])

Update Arrays from 2D modellings

Parameters:

idx – indexes of the time step to update –> steps to read

update_type_result(newtype)

Update the result type for each element

set_elements()

Set the elements to compare with the right type

set_diff()

Set the differential between the elements and the first one, which is the reference

set_viewers(independent: bool = None)

Set viewers

set_shields_param(diamsize: float = 0.001, graindensity: float = 2.65)

Set the parameters for the shields diagram

update_viewers()

Update the viewers with the new elements

bake()

class wolfhece.PyDraw.InPaint_waterlevel(parent, title: str = _('Inpainting'), size: tuple[int, int] = (400, 400), mapviewer: WolfMapViewer = None, **kwargs)

Bases: wx.dataview.wx.Dialog

_array: wolfhece.wolf_array.WolfArray = None

_dem: wolfhece.wolf_array.WolfArray = None

_dtm: wolfhece.wolf_array.WolfArray = None

_mapviewer = None

_init_UI()

Create 2 listboxes for the arrays and the masks

OnUpdateIDs(e)

Update the list of arrays/mask/dtm

OnSelectArray(e)

Select an array

OnSelectMask(e)

Select a mask

OnSelectDTM(e)

Select a DTM

OnInpaint(e)

Inpaint the array with the mask

OnSelectHoles(e)

Select the holes in the array

OnCreateMask(e)

Create a mask from the array

class wolfhece.PyDraw.InPaint_array(parent, title: str = _('Inpainting'), size: tuple[int, int] = (400, 400), mapviewer: WolfMapViewer = None, **kwargs)

Bases: wx.dataview.wx.Dialog

_array: wolfhece.wolf_array.WolfArray = None

_mask: wolfhece.wolf_array.WolfArray = None

_test: wolfhece.wolf_array.WolfArray = None

_mapviewer = None

_init_UI()

Create 2 listboxes for the arrays and the masks

OnUpdateIDs(e)

Update the list of arrays/mask/dtm

OnSelectArray(e)

Select an array

OnSelectMask(e)

Select a mask

OnSelectTest(e)

Select a DTM

OnInpaint(e)

Inpaint the array with the mask

OnSelectHoles(e)

Select the holes in the array

OnCreateMask(e)

Create a mask from the array