wolfhece.wolf_array

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.wolf_array.msg

wolfhece.wolf_array.msg

wolfhece.wolf_array.WOLF_ARRAY_HILLSHAPE

wolfhece.wolf_array.WOLF_ARRAY_FULL_SINGLE = 1

wolfhece.wolf_array.WOLF_ARRAY_FULL_DOUBLE = 2

wolfhece.wolf_array.WOLF_ARRAY_SYM_DOUBLE = 12

wolfhece.wolf_array.WOLF_ARRAY_FULL_LOGICAL = 4

wolfhece.wolf_array.WOLF_ARRAY_CSR_DOUBLE = 5

wolfhece.wolf_array.WOLF_ARRAY_FULL_INTEGER = 6

wolfhece.wolf_array.WOLF_ARRAY_FULL_SINGLE_3D = 7

wolfhece.wolf_array.WOLF_ARRAY_FULL_INTEGER8 = 8

wolfhece.wolf_array.WOLF_ARRAY_MB_SINGLE = 3

wolfhece.wolf_array.WOLF_ARRAY_MB_INTEGER = 9

wolfhece.wolf_array.WOLF_ARRAY_FULL_INTEGER16_2 = 0

wolfhece.wolf_array.WOLF_ARRAY_FULL_INTEGER16 = 11

wolfhece.wolf_array.WOLF_ARRAY_MNAP_INTEGER = 20

wolfhece.wolf_array.WOLF_ARRAY_MB

wolfhece.wolf_array.VERSION_RGB = 3

wolfhece.wolf_array.custom_gradient(array: numpy.ndarray)

Calculate the gradient manually

wolfhece.wolf_array.hillshade(array: numpy.ndarray, azimuth: float, angle_altitude: float) → numpy.ndarray

Create a hillshade array

class wolfhece.wolf_array.Rebin_Ops

Bases: enum.Enum

Generic enumeration.

Derive from this class to define new enumerations.

MIN = 0

MEAN = 1

MAX = 2

SUM = 3

MEDIAN = 4

classmethod get_numpy_ops()

Return a list of numpy functions corresponding to the enum values

classmethod get_ops(name: str)

Return the numpy function corresponding to a string

wolfhece.wolf_array.getkeyblock(i, addone=True) → str

Name/Key of a block in the dictionnary of a WolfArrayMB instance

For Fortran compatibility, addone is True by default so first block is “block1” and not “block0”

wolfhece.wolf_array.decodekeyblock(key, addone=True) → int

Decode key of a block in the dictionnary of a WolfArrayMB instance

For Fortran compatibility, addone is True by default so first block is “block1” and not “block0”

class wolfhece.wolf_array.header_wolf

Header of WolfArray

In case of a mutliblock, the header have informations about all the blocks in head_blocks dictionnary. Block keys are generated by “getkeyblock” function

property nullvalue

property nbdims

property shape

property nb_blocks

head_blocks: dict[str, header_wolf]

set_origin(x: float, y: float, z: float)

Set origin

:param x = origin along X :param y = origin along Y :param z = origin along Z

set_translation(tr_x: float, tr_y: float, tr_z: float)

Set translation

Parameters:

• tr_x – translation along X

• tr_y – translation along Y

• tr_z – translation along Z

get_bounds(abs=True)

Return bounds in coordinates

:param abs = if True, add translation to (x, y) (coordinate to global space) :return : tuple of two lists of two floats - ([xmin, xmax],[ymin, ymax])

get_bounds_ij(abs=False)

Return bounds in indices

Firstly, get_bounds is called to get bounds in coordinates and then get_ij_from_xy is called to get bounds in indices.

:param abs = if True, add translation to (x, y) (coordinate to global space)

get_ij_from_xy(x: float, y: float, z: float = 0.0, scale: float = 1.0, aswolf: bool = False, abs: bool = True, forcedims2: bool = False) → tuple[numpy.int32, numpy.int32] | tuple[numpy.int32, numpy.int32, numpy.int32]

Get indices from coordinates

:param x = X coordinate :param y = Y coordinate :param z = Z coordinate (optional) :param scale = scaling of the spatial resolution (dx,dy,[dz]) :param aswolf = if True, return if one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard) :param abs = if True, remove translation from (x, y, [z]) (coordinate from global space) :param forcedims2 = if True, force to return only 2 indices even if z is supplied

get_ij_from_xy_array(xy: numpy.ndarray, scale: float = 1.0, aswolf: bool = False, abs: bool = True, forcedims2: bool = False) → numpy.ndarray

Get indices from coordinates

:param xy = numpy array containing (x, y, [z]) coordinates - shape (n, 2) or (n, 3) :param scale = scaling of the spatial resolution (dx,dy,[dz]) :param aswolf = if True, return if one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard) :param abs = if True, remove translation from (x, y, [z]) (coordinate from global space) :param forcedims2 = if True, force to return only 2 indices even if z is supplied

:return : numpy array containing (i, j, [k]) indices - shape (n, 2) or (n, 3)

get_xy_from_ij(i: int, j: int, k: int = 0, scale: float = 1.0, aswolf: bool = False, abs: bool = True) → tuple[numpy.float64, numpy.float64] | tuple[numpy.float64, numpy.float64, numpy.float64]

Get coordinates from indices

:param i = index along X coordinate :param j = index along Y coordinate :param k = index along Z coordinate (optional) :param scale = scaling of the spatial resolution (dx,dy,[dz]) :param aswolf = if True, input is one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard) :param abs = if True, add translation to results (x, y, [z]) (coordinate to global space)

get_xy_from_ij_array(ij: numpy.ndarray, scale: float = 1.0, aswolf: bool = False, abs: bool = True) → numpy.ndarray

Converts array coordinates (numpy cells) to this array’s world coodinates.

:param ij = numpy array containing (i, j, [k]) indices - shape (n, 2) or (n, 3) :param scale = scaling of the spatial resolution (dx,dy,[dz]) :param aswolf = if True, input is one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard) :param abs = if True, add translation to results (x, y, [z]) (coordinate to global space)

..warning: ‘ij’ is not the result of np.where() but if you want to use np.where() you can use the following code: ` np.vstack((ij[0], ij[1])).T `

ij2xy(i: int, j: int, k: int = 0, scale: float = 1.0, aswolf: bool = False, abs: bool = True) → tuple[numpy.float64, numpy.float64] | tuple[numpy.float64, numpy.float64, numpy.float64]

alias for get_xy_from_ij

ij2xy_np(ij: numpy.ndarray, scale: float = 1.0, aswolf: bool = False, abs: bool = True) → numpy.ndarray

alias for get_xy_from_ij_array

:param ij = numpy array containing (i, j, [k]) indices :param scale = scaling of the spatial resolution (dx,dy,[dz]) :param aswolf = if True, input is one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard) :param abs = if True, add translation to results (x, y, [z]) (coordinate to global space)

..warning: ‘ij’ is not the result of np.where() but if you want to use np.where() you can use the following code: ` np.vstack((ij[0], ij[1])).T `

:return : numpy array containing (x, y, [z]) coordinates - shape (n, 2) or (n, 3)

xy2ij(x: float, y: float, z: float = 0.0, scale: float = 1.0, aswolf: bool = False, abs: bool = True, forcedims2: bool = False) → tuple[numpy.int32, numpy.int32] | tuple[numpy.int32, numpy.int32, numpy.int32]

alias for get_ij_from_xy

xy2ij_np(xy: numpy.ndarray, scale: float = 1.0, aswolf: bool = False, abs: bool = True) → numpy.ndarray

alias for get_ij_from_xy_array

:param xy = numpy array containing (x, y, [z]) coordinates - shape (n, 2) or (n, 3) :param scale = scaling of the spatial resolution (dx,dy,[dz]) :param aswolf = if True, return if one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard) :param abs = if True, remove translation from (x, y, [z]) (coordinate from global space) :param forcedims2 = if True, force to return only 2 indices even if z is supplied

:return : numpy array containing (i, j, [k]) indices - shape (n, 2) or (n, 3)

xyz2ijk_np(xyz: numpy.ndarray, scale: float = 1.0, aswolf: bool = False, abs: bool = True) → numpy.ndarray

alias for get_xy_from_ij_array

ijk2xyz_np(ijk: numpy.ndarray, scale: float = 1.0, aswolf: bool = False, abs: bool = True) → numpy.ndarray

alias for get_xy_from_ij_array

find_intersection(other: header_wolf, ij: bool = False) → tuple[list[float], list[float]] | tuple[list[list[float]], list[list[float]]]

Find the intersection of two header

@arg other: other header @arg ij: if True, return indices instead of coordinates

Returns:

None or tuple of two lists of two floats - ([xmin, xmax],[ymin, ymax]) or indices in each header (if ij=True) [[imin1, imax1], [jmin1, jmax1]], [[imin2, imax2], [jmin2, jmax2]]

find_union(other: header_wolf | list[header_wolf]) → tuple[list[float], list[float]]

Find the union of two header

Returns:

tuple of two lists of two floats - ([xmin, xmax],[ymin, ymax])

read_txt_header(filename: str)

Read informations from header .txt

:param filename : path and filename of the basefile

If filename is a Path object, it is converted to a string If filename ends with ‘.tif’, nothing is done because infos are in the .tif file If filename ends with ‘.flt’, a .hdr file must be present and it will be read Otherwise, a filename.txt file must be present

write_txt_header(filename: str, wolftype: int, forceupdate: bool = False)

Writing the header to a text file

Nullvalue is not written

:param filename : path and filename with ‘.txt’ extension, which will NOT be automatically added :param wolftype : type of the WOLF_ARRAY_* array :param forceupdate : if True, the file is rewritten even if it already exists

is_like(other: header_wolf, check_mb: bool = False) → bool

Comparison of two headers

:param other : other header to compare :param check_mb : if True, the comparison is done on the blocks too

The nullvalue is not taken into account

align2grid(x1: float, y1: float, eps: float = 0.0001) → tuple[float, float]

Align coordinates to nearest grid point where the grid is defined by the borders of the array.

_rasterize_segment(x1: float, y1: float, x2: float, y2: float, xstart: float = None, ystart: float = None) → list[list[float]]

Rasterize a segment according to the grid where the grid is defined by the borders of the array.

Parameters:

• x1 – x coordinate of the first point

• y1 – y coordinate of the first point

• x2 – x coordinate of the second point

• y2 – y coordinate of the second point

• xstart – x coordinate of the starting point

• ystart – y coordinate of the starting point

Returns:

numpy array of the rasterized segment

rasterize_vector(vector2raster: wolfhece.PyVertexvectors.vector, outformat: numpy.ndarray | wolfhece.PyVertexvectors.vector = vector) → numpy.ndarray | wolfhece.PyVertexvectors.vector

Rasterize a vector according to the grid

Parameters:

• vector2raster – vector to rasterize

• outformat – output format (np.ndarray or vector)

get_xy_infootprint_vect(myvect: wolfhece.PyVertexvectors.vector | shapely.geometry.Polygon, eps: float = 0.0) → tuple[numpy.ndarray, numpy.ndarray]

Return the coordinates of the cells in the footprint of a vector

:param myvect = target vector :return: tuple of two numpy arrays - (coordinates, indices)

get_ij_infootprint_vect(myvect: wolfhece.PyVertexvectors.vector | shapely.geometry.Polygon, eps: float = 0.0) → numpy.ndarray

Return the indices of the cells in the footprint of a vector

:param myvect = target vector :return : numpy array of indices

convert_xy2ij_np(xy)

Convert XY coordinates to IJ indices (0-based) with Numpy without any check/options

:param xy = numpy array of shape (n,2) with XY coordinates

convert_ij2xy_np(ij)

Convert IJ indices (0-based) to XY coordinates with Numpy without any check/options

:param ij = numpy array of shape (n,2) with IJ indices

class wolfhece.wolf_array.NewArray(parent)

Bases: wx.Dialog

wx GUI interaction to create a new WolfArray

Once filled, user/__init__ must call “init_from_new”

class wolfhece.wolf_array.CropDialog(parent)

Bases: wx.Dialog

wx GUI interaction to crop 2D array’s data

Used in “read_data” of a WolfArray

get_header()

Return a header_wolf object with the values of the dialog

class wolfhece.wolf_array.IntValidator

Bases: wx.Validator

Validates data as it is entered into the text controls.

Clone()

Required Validator method

Validate(win)

TransferToWindow()

TransferFromWindow()

OnChar(event)

class wolfhece.wolf_array.Ops_Array(parentarray: WolfArray, mapviewer=None)

Bases: wx.Frame

Operations wx.Frame on WolfArray class

This class is used to perform operations on a WolfArray

property idx

Return the idx of the parentarray

property is_shared

Check if the vector manager is shared

get_mapviewer()

Retourne l’instance WolfMapViewer

get_linked_arrays()

Pour compatibilité avec la gestion de vecteur et WolfMapViewer

set_GUI()

Set the wx GUI

OnBlockSelect(event)

Select block

interpolation2D(event: wx.MouseEvent)

calling Interpolation 2D

Unmaskall(event: wx.MouseEvent)

Unmask all values in the current array @author Pierre Archambeau

Unmasksel(event: wx.MouseEvent)

Enlève le masque des éléments sélectionnés @author Pierre Archambeau

InvertMask(event: wx.MouseEvent)

Invert mask

interp2Dpolygons(event: wx.MouseEvent)

Bouton d’interpolation sous tous les polygones d’une zone cf WolfArray.interp2Dpolygon

interp2Dpolygon(event: wx.MouseEvent)

Bouton d’interpolation sous un polygone cf WolfArray.interp2Dpolygon

interp2Dpolylines(event: wx.MouseEvent)

Bouton d’interpolation sous toutes les polylignes de la zone cf parent.interp2Dpolyline

interp2Dpolyline(event: wx.MouseEvent)

Bouton d’interpolation sous la polyligne active cf parent.interp2Dpolyline

volumesurface(event)

Click on evaluation of stage-storage-surface relation

OnAllSelect(event)

Select all –> just put “all” in “myselection”

OnReselectMemory(event)

Reselect from memory

OnMoveSelect(event)

Transfert de la sélection courante dans un dictionnaire

OnContractSelection(event)

Contract selection

OnExpandSelection(event)

Expand selection

OnExpandUnselectInterior(event)

Expand contour

OnUnselectInterior(event)

Contract contour

reset_selection()

Reset of current selection

reset_all_selection()

Reset of current selection and stored ones

OnResetSelect(event)

Click on Reset of current selection

OnResetAllSelect(event)

Click on reset all

OnSaveSelection(event)

Save the current selection

OnLoadSelection(event)

Load a selection

OnToClipboardStr(event)

Copy the current selection to the clipboard as a string

OnApplyOpSelect(event)

Select nodes based on condition

OnApplyNullvalue(event: wx.MouseEvent)

Apply null value to the array

refresh_array()

Force refresh of the parent array

OnNullBorder(event: wx.MouseEvent)

Nullify the border of the array

OnFilterZone(event: wx.MouseEvent)

Filter the array based on contiguous zones

OnLabelling(event: wx.MouseEvent)

Labelling of contiguous zones

OnExtractSelection(event: wx.MouseEvent)

Extract the current selection

OnApplyOpMath(event: wx.MouseEvent)

Apply math operator to the array

Onmask(event: wx.MouseEvent)

Mask nodes based on condition

OnManageVectors(event: wx.MouseEvent)

Open vector manager

show_structure_OpsVectors()

Show the structure of the vector manager

hide_properties()

Hide the properties panel

_get_comp_elts_diff()

Get the elements and the differences of the linked arrays

_link_zones()

Link the same vector manager to all the linked arrays

OnLoadvec(event: wx.MouseEvent)

Load vector file

OnSaveasvec(event: wx.MouseEvent)

Save vector file

OnSavevec(event: wx.MouseEvent)

Save vector file

select_node_by_node()

Select nodes by individual clicks

Set the right action in the mapviewer who will attend the clicks

select_zone_inside_manager()

Select nodes inside the active zone (manager)

select_vector_inside_manager()

Select nodes inside the active vector (manager)

_select_vector_inside_manager(vect: wolfhece.PyVertexvectors.vector)

Select nodes inside a vector or set action to add vertices to a vector by clicks

select_zone_under_manager()

Select nodes along the active zone (manager)

select_vector_under_manager()

Select nodes along the active vector (manager)

_select_vector_under_manager(vect: wolfhece.PyVertexvectors.vector)

Select nodes along a vector or set action to add vertices to a vector by clicks

select_vector_inside_tmp()

Select nodes inside the temporary vector

select_vector_under_tmp()

Select nodes along the temporary vector

OnLaunchSelect(event: wx.MouseEvent)

Action button

onclose(event: wx.MouseEvent)

Hide the window

onshow(event: wx.MouseEvent)

Show the window - set string with null value and update palette

Active_vector(vect: wolfhece.PyVertexvectors.vector, copyall: bool = True)

Set the active vector to vect and forward to mapviewer

Active_zone(target_zone: wolfhece.PyVertexvectors.zone)

Set the active zone to target_zone and forward to mapviewer

update_palette()

Update palette

Redraw the palette with Matplotlib and fill the grid with the values and RGB components

Onsavepal(event: wx.MouseEvent)

Save palette to file

Onloadpal(event: wx.MouseEvent)

Load palette from file

Onloaddefaultpal(event: wx.MouseEvent)

Load default palette

Onpalimage(event: wx.MouseEvent)

Create image from palette

Onpaldistribute(event: wx.MouseEvent)

Evenly spaced values in palette

Onupdatepal(event: wx.MouseEvent)

Apply options to palette

OnClickHistoUpdate(event: wx.Event)

Create a histogram of the current array

OnClickColorPal(event: wx.Event)

Edit color of a palette item

class wolfhece.wolf_array.SelectionData(parent: WolfArray)

User-selected data in a WolfArray

Contains two storage elements :

• myselection (list): Current selection which will be lost in the event of a reset

• selections( dict): Stored selection(s) to be used, for example, in a spatial interpolation operation.

  These selections are only lost in the event of a general reset.

The selected nodes are stored using their “world” spatial coordinates so that they can be easily transferred to other objects.

property dx: float

Resolution in x

property dy: float

Resolution in y

property nb: int

Number of selected nodes

myselection: list[tuple[float, float]]

selections: dict[str:dict['select':list[tuple[float, float]], 'idgllist':int, 'color':list[float]]]

set_selection_from_list_xy(xylist: list[tuple[float, float]])

Set the current selection from a list of (x, y) coordinates

Unmasksel(resetplot: bool = True)

Unmask selection

reset()

Reset the selection

reset_all()

Reset the selection

get_string(which: str = None, all_memories: bool = False) → str

Get string of the current selection or of a stored one

get_script(which: int = None) → str

Get script of the current selection or of a stored one

copy_to_clipboard(which: int = None, typestr: Literal[string, script] = 'string')

Copy current selection to clipboard

reselect_from_memory(idx: list[str] = None)

Reselect a stored selection

Parameters:

idx – id/key of the selection

move_selectionto(idx: str, color: list[float], resetplot: bool = True)

Transfer current selection to dictionary

Parameters:

• idx – id/key of the selection

• color – color of the selection - list of 4 integers between 0 and 255

plot_selection()

Plot current selection and stored selections

_plot_selection(curlist: list[float], color: list[float], loclist: int = 0)

Plot a selection

Parameters:

• curlist – list of selected nodes – list of tuples (x,y)

• color – color of the selection - list of 3 floats between 0 and 1

• loclist – index of OpenGL list

add_node_to_selection(x: float, y: float, verif: bool = True)

Add one coordinate to the selection

Parameters:

• x – x coordinate

• y – y coordinate

• verif – if True, the coordinates are checked to avoid duplicates

add_nodes_to_selection(xy: list[float], verif: bool = True)

Add multiple coordinates to the selection

Parameters:

• xy – list of coordinates

• verif – if True, the coordinates are checked to avoid duplicates

_add_node_to_selectionij(i: int, j: int, verif=True)

Add one ij coordinate to the selection

Parameters:

• i – i coordinate

• j – j coordinate

• verif – if True, the coordinates are checked to avoid duplicates

_add_nodes_to_selectionij(ij: list[tuple[float, float]], verif: bool = True)

Add multiple ij coordinates to the selection

Parameters:

• ij – list of ij coordinates

• verif – if True, the coordinates are checked to avoid duplicates

select_insidepoly(myvect: wolfhece.PyVertexvectors.vector)

Select nodes inside a polygon

select_underpoly(myvect: wolfhece.PyVertexvectors.vector)

Select nodes along a polyline

dilate_selection(nb_iterations: int, use_mask: bool = True, structure: numpy.ndarray = None)

Extend the selection

erode_selection(nb_iterations: int, use_mask: bool = True, structure: numpy.ndarray = None)

Reduce the selection

dilate_contour_selection(nbiter: int = 1, use_mask: bool = True, structure: numpy.ndarray = np.ones((3, 3)))

Dilate the contour of the selection

erode_contour_selection()

Erode the contour of the selection

save_selection(filename: str = None)

Save the selection to a file

load_selection(filename: str = None)

Load a selection from a file

update_nb_nodes_selection()

Update the number of selected nodes

condition_select(cond, condval, condval2=0, usemask=False)

treat_select(op, cond, opval, condval)

refresh_parantarray()

Refresh the parent array after a selection

mask_condition(op, cond, opval, condval)

get_values_sel()

_get_header()

Header corresponding to the selection

get_newarray()

Create a new array from the selection

select_all()

Select all nodes

interp2Dpolygons(working_zone: wolfhece.PyVertexvectors.zone, method: Literal[nearest, linear, cubic] = None, resetplot: bool = True)

Interpolation sous tous les polygones d’une zone cf parent.interp2Dpolygon

interp2Dpolygon(working_vector: wolfhece.PyVertexvectors.vector, method: Literal[nearest, linear, cubic] = None, resetplot: bool = True)

Interpolation sous un polygone cf parent.interp2Dpolygon

interp2Dpolylines(working_zone: wolfhece.PyVertexvectors.zone, resetplot: bool = True)

Interpolation sous toutes les polylignes de la zone cf parent.interp2Dpolyline

interp2Dpolyline(working_vector: wolfhece.PyVertexvectors.vector, resetplot: bool = True)

Interpolation sous la polyligne active cf parent.interp2Dpolyline

copy(source: SelectionData)

volumesurface(show=True)

Evaluation of stage-storage-surface relation

class wolfhece.wolf_array.SelectionDataMB(parent: WolfArrayMB)

Bases: SelectionData

Extension of SelectionData to manage multiple blocks

property nb

Number of selected nodes

Unmasksel()

Unmask selection

reset()

Reset the selection

select_all()

Select all nodes

reset_all()

Reset the selection

get_string(which: str = None) → str

Get string of the current selection or of a stored one

save_selection(filename: str = None, which: str = None)

Save the selection to a file

load_selection(filename: str = None, which: str = None)

Load a selection from a file

get_script(which: int = None) → str

Get script of the current selection or of a stored one

get_newarray()

Create a new array from the selection

add_node_to_selection(x: float, y: float, verif: bool = True)

Add a node to the selection

add_nodes_to_selection(xy: list[float], verif: bool = True)

Add nodes to the selection

select_insidepoly(myvect: wolfhece.PyVertexvectors.vector)

Select nodes inside a polygon

select_underpoly(myvect: wolfhece.PyVertexvectors.vector)

Select nodes along a polyline

dilate_selection(nb_iterations: int, use_mask: bool = True, structure: numpy.ndarray = None)

Extend the selection

erode_selection(nb_iterations: int, use_mask: bool = True, structure: numpy.ndarray = None)

Reduce the selection

update_nb_nodes_selection()

Update the number of nodes selected

condition_select(cond, condval, condval2=0, usemask=False)

treat_select(op, cond, opval, condval)

mask_condition(op, cond, opval, condval)

plot_selection()

Plot current selection and stored selections

move_selectionto(idx: str, color: list[float])

Transfer current selection to dictionary

Parameters:

• idx – id/key of the selection

• color – color of the selection - list of 4 integers between 0 and 255

copy_to_clipboard(which: int = None, typestr: Literal[string, script] = 'string')

Copy current selection to clipboard

interp2Dpolygons(working_zone: wolfhece.PyVertexvectors.zone, method: Literal[nearest, linear, cubic] = None)

Interpolation sous tous les polygones d’une zone cf parent.interp2Dpolygon

interp2Dpolygon(working_vector: wolfhece.PyVertexvectors.vector, method: Literal[nearest, linear, cubic] = None)

Interpolation sous un polygone cf parent.interp2Dpolygon

interp2Dpolylines(working_zone: wolfhece.PyVertexvectors.zone, resetplot: bool = True)

Interpolation sous toutes les polylignes de la zone cf parent.interp2Dpolyline

interp2Dpolyline(working_vector: wolfhece.PyVertexvectors.vector, resetplot: bool = True)

Interpolation sous la polyligne active cf parent.interp2Dpolyline

volumesurface(show=True)

Evaluation of stage-storage-surface relation

class wolfhece.wolf_array.WolfArray(fname: str = None, mold: WolfArray = None, masknull: bool = True, crop: list[list[float], list[float]] = None, whichtype=WOLF_ARRAY_FULL_SINGLE, preload: bool = True, create: bool = False, mapviewer=None, nullvalue: float = 0.0, srcheader: header_wolf = None, idx: str = '', plotted: bool = False, need_for_wx: bool = False, mask_source: numpy.ndarray = None)

Bases: wolfhece.drawing_obj.Element_To_Draw, header_wolf

Classe pour l’importation de WOLF arrays

simple précision, double précision, entier…

property memory_usage

Return the memory usage of the header

property memory_usage_mask

Return the memory usage of the mask

property nullvalue: float

Return the null value

property nodata: float

alias for nullvalue

property SelectionData: SelectionData

Return the data of the selection

property Operations: Ops_Array

Return the operations on the array

property active_blocks: list[WolfArray]

Return the active blocks

property dtype

Return the numpy dtype corresponding to the WOLF type

Pay ettention to the difference between :

• LOGICAL : Fortran and VB6

• Bool : Python

In VB6, logical is stored as int16 In Fortran, there are Logical*1, Logical*2, Logical*4, Logical*8 In Python, bool is one byte In Numpy, np.bool_ is one byte

property dtype_str

Return the numpy dtype corresponding to the WOLF type, as a string

Pay ettention to the difference between :

• LOGICAL : Fortran and VB6

• Bool : Python

In VB6, logical is stored as int16 In Fortran, there are Logical*1, Logical*2, Logical*4, Logical*8 In Python, bool is one byte In Numpy, np.bool_ is one byte

array: numpy.ma.masked_array

mygrid: dict

linkedvec: wolfhece.PyVertexvectors.vector

linkedarrays: list[WolfArray]

origx: float

origy: float

origz: float

translx: float

transly: float

translz: float

myops: Ops_Array

set_opacity(alpha: float)

Set the transparency of the array

extract_selection()

Extract the current selection

crop_array(bbox: list[list[float], list[float]]) → WolfArray

Crop the data based on the bounding box

get_centers(usenap: bool = True)

Get the centers of the cells

prepare_3D()

Prepare the array for 3D display

check_bounds_ij(i: int, j: int)

Check if i and j are inside the array bounds

check_bounds_xy(x: float, y: float)

Check if i and j are inside the array bounds

show_properties()

Affichage des propriétés de la matrice dans une fenêtre wxPython

hide_properties()

Hide the properties window

loadnap_and_apply()

Load a mask file (aka nap) and apply it to the array;

The mask values are set to the nullvalue.

The mask file must have the same name as the array file, with the extension .napbin. It is useful for 2D WOLF simulations.

add_crosslinked_array(newlink: WolfArray)

Ajout d’une matrice liée croisée

share_palette()

Partage de la palette de couleurs entre matrices liées

filter_inundation(epsilon: float = None, mask: numpy.ndarray = None)

Apply filter on array :

• mask data below eps

• mask data outisde linkedvec

Parameters:

• epsilon – value under which data are masked

• mask – mask to apply if eps is None

If all params are None, the function will mask NaN values

filter_independent_zones(n_largest: int = 1, reset_plot: bool = True)

Filtre des zones indépendantes et conservation des n plus grandes

filter_zone(set_null: bool = False, reset_plot: bool = True)

Filtre des zones et conservation de celles pour lesquelles des mailles sont sélectionnées

labelling(reset_plot: bool = True)

Labelling of the array using Scipy

export_geotif(outdir='', extent='', EPSG: int = 31370)

Export de la matrice au format Geotiff (Lambert 72 - EPSG:31370)

Formats supportés :

• Int32

• Float32

• Float64

Parameters:

• outdir – directory

• extent – suffix to add to the filename before the extension ‘.tif’

• EPSG – EPSG code, by default 31370 (Lambert 72)

_import_npy(fn: str = '', crop: list[float] = None)

Import a numpy file.

Must be called after the header is initialized, e.g. read_txt_header.

Parameters:

• fn – filename

• crop – crop the data - [xmin, xmax, ymin, ymax]

import_geotif(fn: str = '', which: int = None, crop: list[float] = None)

Import de la matrice au format Geotiff

Formats supportés :

• Int32

• Float32

• Float64

Parameters:

• fn – filename

• which – band to import

• crop – crop the data - [xmin, xmax, ymin, ymax]

add_ops_sel()

Adding selection manager and operations array

• Ops_Array (GUI) if mapviewer is not None

• create SelectionData (Selection manager) if None

change_gui(newparentgui)

Move GUI to another instance

Parameters:

newparentgui – WolfMapViewer instance

compare_cloud(mycloud: wolfhece.PyVertex.cloud_vertices, delta: list[float] = [0.15, 0.5, 1.0])

Graphique de comparaison des valeurs d’un nuage de points et des valeurs de la matrice sous les mêmes positions

Parameters:

• mycloud – cloud_vertices

• delta – list of tolerance for the comparison

compare_tri(mytri: wolfhece.PyVertexvectors.Triangulation)

Graphique de comparaison des valeurs d’un nuage de points et des valeurs de la matrice sous les mêmes positions

interpolate_on_polygon(working_vector: wolfhece.PyVertexvectors.vector, method: Literal[nearest, linear, cubic] = 'linear')

Interpolation sous un polygone

L’interpolation a lieu :

• uniquement dans les mailles sélectionnées si elles existent

• dans les mailles contenues dans le polygone sinon

On utilise ensuite “griddata” pour interpoler les altitudes des mailles depuis les vertices 3D du polygone

interpolate_on_polygons(working_zone: wolfhece.PyVertexvectors.zone, method: Literal[nearest, linear, cubic] = 'linear')

Interpolation sous plusieurs polygones d’une même zone

interpolate_on_polyline(working_vector: wolfhece.PyVertexvectors.vector, usemask=True)

Interpolation sous une polyligne

L’interpolation a lieu :

• uniquement dans les mailles sélectionnées si elles existent

• dans les mailles sous la polyligne sinon

On utilise ensuite “interpolate” de shapely pour interpoler les altitudes des mailles depuis les vertices 3D de la polyligne

interpolate_on_polylines(working_zone: wolfhece.PyVertexvectors.zone, usemask=True)

interpolate_on_cloud(xy: numpy.ndarray, z: numpy.ndarray, method='linear')

See : https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html

method == nearest, linear or cubic

interpolate_on_triangulation(coords, triangles, grid_x=None, grid_y=None, mask_tri=None, interp_method='matplotlib')

import_from_gltf(fn: str = '', fnpos: str = '', interp_method: Literal[matplotlib, numpy] = 'matplotlib')

interp_method == ‘matplotlib’ or ‘griddata’

export_to_gltf(bounds: list[float] = None, fn: str = '')

Export to GLTF/GLB format

Parameters:

• bounds – [[xmin,xmax],[ymin,ymax]]

• fn – filename

get_triangulation(bounds: list[float] = None)

Traingulation of the array

Parameters:

bounds – [[xmin,xmax],[ymin,ymax]]

hillshade(azimuth: float, angle_altitude: float)

Create a hillshade array – see “hillshade” function accelerated by JIT

get_gradient_norm()

Compute and return the norm of the gradient

get_laplace()

Compute and return the laplacian

volume_estimation(axs=None)

Estimation of the volume of the selected zone

paste_all(fromarray: WolfArray, mask_after: bool = True)

Paste all the values from another WolfArray

set_values_sel(xy: list[float], z: list[float], update: bool = True)

Set values at the selected positions

Parameters:

• xy – [[x1,y1],[x2,y2],…]

• z – [z1,z2,…]

• update – update the plot

init_from_new(dlg: NewArray)

Initialize the array properties from the NewArray dialog

init_from_header(myhead: header_wolf, dtype: numpy.dtype = None, force_type_from_header: bool = False)

Initialize the array properties from a header_wolf object

Parameters:

• myhead – header_wolf object

• dtype – numpy dtype

• force_type_from_header – force the type from the header passed as argument

interpolation2D(key: str = '1')

Interpolation 2D basde on selected points in key 1

copy_mask(source: WolfArray, forcenullvalue: bool = False, link: bool = True)

Copy/Link the mask from another WolfArray

Parameters:

• source – WolfArray source

• forcenullvalue – force nullvalue in the masked zone

• link – link the mask if True (default), copy it otherwise

mask_union(source: WolfArray, link: bool = True)

Union of the mask with another WolfArray

Parameters:

• source – WolfArray source

• link – link the mask if True (default), copy it otherwise

mask_unions(sources: list[WolfArray], link: bool = True)

Union of the mask with another WolfArrays

Parameters:

• source – list of WolfArray sourceq

• link – link the mask if True (default), copy it otherwise

copy_mask_log(mask: numpy.ndarray, link: bool = True)

Copy the mask from a numpy array

Parameters:

• mask – numpy array

• link – link the mask if True (default), copy it otherwise

check_plot()

Make sure the array is plotted

uncheck_plot(unload: bool = True, forceresetOGL: bool = False, askquestion: bool = True)

Make sure the array is not plotted

Parameters:

• unload – unload the data if True (default), keep it otherwise

• forceresetOGL – force the reset of the OpenGL lists

• askquestion – ask the question if True and a wx App is running (default), don’t ask it otherwise

get_header(abs: bool = True) → header_wolf

Return a header_wolf object - different from the self object header

Parameters:

abs – if True (default), return an absolute header (shifted origin) and translation set to 0.

set_header(header: header_wolf)

Set the header from a header_wolf object

concatenate(list_arr: list[WolfArray], nullvalue: float = 0.0)

Concatenate the values from another WolfArrays into a new one

Parameters:

list_arr – list of WolfArray objects

Returns:

a new WolfArray

Return_type:

WolfArray

mask_outsidepoly(myvect: wolfhece.PyVertexvectors.vector, eps: float = 0.0)

Mask nodes outside a polygon and set values to nullvalue

Parameters:

myvect – target vector in global coordinates

mask_insidepoly(myvect: wolfhece.PyVertexvectors.vector, eps: float = 0.0)

Mask nodes inside a polygon and set values to nullvalue

Parameters:

myvect – target vector in global coordinates

get_xy_inside_polygon(myvect: wolfhece.PyVertexvectors.vector | shapely.geometry.Polygon, usemask: bool = True)

Return the coordinates inside a polygon

:param myvect : target vector :param usemask : limit potential nodes to unmaksed nodes

get_xy_inside_polygon_shapely(myvect: wolfhece.PyVertexvectors.vector | shapely.geometry.Polygon, usemask: bool = True)

Return the coordinates inside a polygon

:param myvect : target vector :param usemask : limit potential nodes to unmaksed nodes

get_xy_under_polyline(myvect: wolfhece.PyVertexvectors.vector, usemask: bool = True)

Return the coordinates along a polyline

:param myvect : target vector :param usemask : limit potential nodes to unmaksed nodes

get_ij_inside_polygon(myvect: wolfhece.PyVertexvectors.vector, usemask: bool = True, eps: float = 0.0)

Return the indices inside a polygon

:param myvect : target vector :param usemask : limit potential nodes to unmaksed nodes

intersects_polygon(myvect: wolfhece.PyVertexvectors.vector | shapely.geometry.Polygon, usemask: bool = True)

Return True if the array intersects the polygon

:param myvect : target vector :param usemask : limit potential nodes to unmaksed nodes

intersects_polygon_shapely(myvect: wolfhece.PyVertexvectors.vector | shapely.geometry.Polygon, eps: float = 0.0, usemask: bool = True)

Return True if the array intersects the polygon

:param myvect : target vector :param usemask : limit potential nodes to unmaksed nodes

get_ij_under_polyline(myvect: wolfhece.PyVertexvectors.vector, usemask: bool = True)

Return the indices along a polyline

:param myvect = target vector :param usedmask = limit potential nodes to unmaksed nodes

get_values_insidepoly(myvect: wolfhece.PyVertexvectors.vector, usemask: bool = True, getxy: bool = False)

Récupération des valeurs contenues dans un polygone

:param usemask : (optional) restreint les éléments aux éléments non masqués de la matrice :param getxy : (optional) retourne en plus les coordonnées des points

get_values_underpoly(myvect: wolfhece.PyVertexvectors.vector, usemask: bool = True, getxy: bool = False)

Récupération des valeurs contenues sous une polyligne

:param usemask : (optional) restreint les éléments aux éléments non masqués de la matrice :param getxy : (optional) retourne en plus les coordonnées des points

get_all_values_insidepoly(myvect: wolfhece.PyVertexvectors.vector, usemask: bool = True, getxy: bool = False)

Récupération de toutes les valeurs contenues dans un polygone

:param usemask : (optional) restreint les éléments aux éléments non masqués de la matrice :param getxy : (optional) retourne en plus les coordonnées des points

ICI on retourne le résultat de get_values_insidepoly, car une seule matrice, mais une autre classe pourrait vouloir faure autre chose

C’est le cas notamment de Wolfresults_2D

get_all_values_underpoly(myvect: wolfhece.PyVertexvectors.vector, usemask: bool = True, getxy: bool = False)

Récupération de toutes les valeurs sous la polyligne

:param usemask : (optional) restreint les éléments aux éléments non masqués de la matrice :param getxy : (optional) retourne en plus les coordonnées des points

ICI on retourne le résultat de get_values_underpoly, car une seule matrice, mais une autre classe pourrait vouloir faure autre chose

C’est le cas notamment de Wolfresults_2D

reset()

Reset the array to nullvalue

allocate_ressources()

Memory Allocation according to dtype/wolftype

read_all(which_band=None)

Lecture d’un Wolf aray depuis le nom de fichier

write_all(newpath: str = None, EPSG: int = 31370)

Ecriture de tous les fichiers d’un Wolf array

Parameters:

• newpath – new path and filename with extension – if None, use the current filename

• EPSG – EPSG code for geotiff

get_rebin_shape_size(factor: float) → tuple[tuple[int, int], tuple[float, float]]

Return the new shape after rebinning.

newdx = dx * factor newdy = dy * factor

The shape is adjusted to be a multiple of the factor.

Parameters:

factor (float) – factor of resolution change – > 1.0 : decrease resolution, < 1.0 : increase resolution

Returns:

new shape

Return type:

Tuple[int, int]

get_rebin_header(factor: float) → header_wolf

Return a new header after rebinning.

Parameters:

factor (float) – factor of resolution change – > 1.0 : decrease resolution, < 1.0 : increase resolution

Returns:

new header

Return type:

header_wolf

rebin(factor: float, operation: Literal[mean, sum, min, max, median] = 'mean', operation_matrix: WolfArray = None) → None

Change resolution - in place.

If you want to keep current data, copy the WolfArray into a new variable -> newWA = Wolfarray(mold=curWA).

Parameters:

• factor (float) – factor of resolution change – > 1.0 : decrease resolution, < 1.0 : increase resolution

• operation (str, Rebin_Ops) – operation to apply on the blocks (‘mean’, ‘sum’, ‘min’, ‘max’, ‘median’)

• operation_matrix (WolfArray) – operation matrix to apply on the blocks – see the Enum “Rebin_Ops” for more infos. The matrix must have the same shape as the new array

read_txt_header()

Read header from txt file Supercharged by WolfArray to avoid explicit call to read_txt_header with parameters

write_txt_header()

Write header to txt file Supercharged by WolfArray to avoid explicit call to write_txt_header with parameters

read_data()

Opération de lecture des données depuis le fichier connu

_read_binary_data(f, seek=0)

Read binary data from file

write_array()

Ecriture du tableau en binaire

write_xyz(fname: str)

Ecriture d un fichier xyz avec toutes les données du Wolf Array

get_xyz(which='all') → numpy.ndarray

Return an array of xyz coordinates and values

set_general_frame_from_xyz(fname: str, dx: float, dy: float, border_size: int = 5)

Lecture d’un fichier texte xyz et initialisation des données de base

Parameters:

• fname – nom du fichier xyz

• dx – pas en x

• dy – pas en y

• border_size – nombre de mailles de bordure en plus de l’extension spatiale du fichier

fillin_from_xyz(xyz: numpy.ndarray)

Remplissage du tableau à partir d’un tableau xyz

fillin_from_ijz(ijz: numpy.ndarray)

Remplissage du tableau à partir d’un tableau ijz

mask_force_null()

Force to unmask all and mask null value

unmask()

alias to mask_reset

mask_clear()

alias to mask_reset

mask_reset()

Unmask everything

count()

Count the number of not masked values

mask_data(value)

Mask cell where values are equal to value

mask_lower(value)

Mask cell where values are strictly lower than value

mask_lowerequal(value)

Mask cell where values are lower or equal than value

mask_greater(value)

Mask cell where values are strictly greater than value

mask_greaterequal(value)

Mask cell where values are greater or equal than value

set_nullvalue_in_mask()

Set nullvalue in masked cells

reset_plot(whichpal=0, mimic=True)

Reset plot of the array

mask_allexceptdata(value)

Mask cell where values are different from value

mask_invert()

Invert the mask

meshgrid(mode: Literal[gc, borders] = 'gc')

Création d’un maillage 2D

Parameters:

mode – ‘gc’ pour les centres de mailles, ‘borders’ pour les bords de mailles

crop_masked_at_edges()

Crop the array to remove masked cells at the edges of the array :return: cropped array, WolfArray instance

crop(i_start: int, j_start: int, nbx: int, nby: int, k_start: int = 1, nbz: int = 1)

Crop the array

Parameters:

• i_start – start index in x

• j_start – start index in y

• nbx – number of cells in x

• nby – number of cells in y

• k_start – start index in z

• nbz – number of cells in z

Returns:

cropped array, WolfArray instance

extend(x_ext: int, y_ext: int)

Extend the array

Crop is the opposite

extremum(which: Literal[min, max] = 'min')

Return the extremum value

get_value(x: float, y: float, z: float = 0.0, nullvalue: float = -99999)

Return the value at given coordinates

Parameters:

• x – x coordinate

• y – y coordinate

• z – z coordinate

• nullvalue – value to return if the point is outside the array

get_xlim(window_x: float, window_y: float)

Return the limits in x for a given window size

Parameters:

• window_x – window size in x

• window_y – window size in y

get_ylim(window_x: float, window_y: float)

Retrun the limits in y for a given window size

Parameters:

• window_x – window size in x

• window_y – window size in y

get_working_array(onzoom: list[float] = [])

Return the part of the array in the zoom window

Parameters:

onzoom – zoom window – [xmin, xmax, ymin, ymax]

updatepalette(which: int = 0, onzoom=[])

Update the palette/colormap

Parameters:

• which – which palette to update

• onzoom – zoom window – [xmin, xmax, ymin, ymax]

plot(sx: float = None, sy: float = None, xmin: float = None, ymin: float = None, xmax: float = None, ymax: float = None, size: float = None)

Plot the array - OpenGL

Parameters:

• sx – scale along X

• sy – scale along Y

• xmin – Lower-Left coordinates in X

• ymin – Lower-Left coordinates in Y

• xmax – Upper-Right coordinates in X

• ymax – Upper-Right coordinates in Y

• size – size of the window (not used here but necessary for compatibility with Element_To_Draw)

delete_lists()

Delete OpenGL lists

plot_matplotlib()

Plot the array - Matplotlib version

Using imshow and RGB array

fillonecellgrid(curscale, loci, locj, force=False)

Fill one cell of the plotted grid

suxsuy_contour(filename: str = '', abs: bool = False, one_vec_if_ml: bool = True) → tuple[list[int, int], list[int, int], wolfhece.PyVertexvectors.vector | wolfhece.PyVertexvectors.zone, bool]

The borders are computed on basis of the current mask

:param filename : if provided, write ‘sux’, ‘sux’ and ‘xy’ files :param abs : add translation coordinates (Global World Coordinates)

:return indicesX, indicesY, contourgen, interior

indicesX : list of coupled indices along X - vertical border - 1-based like Fortran indicesY : list of coupled indices along Y - horizontal border - 1-based like Fortran contourgen : external contour interior : if False, contour is unique ; if True, interior contours exist -> interior parts are merged

imshow(figax: tuple[matplotlib.figure.Figure, matplotlib.axis.Axis] = None, cmap: matplotlib.colors.Colormap = None, step_ticks=100.0) → tuple[matplotlib.figure.Figure, matplotlib.axis.Axis]

Create Matplotlib image from WolfArray

set_array_from_numpy(array: numpy.ndarray, nullvalue: float = None)

Set array from numpy array

nullify_border(width: int = 1)

Set border to nullvalue

as_WolfArray(abs: bool = True) → WolfArray

Return a WolfArray object from this WolfArray

get_unique_values()

Return unique values in the array

map_values(keys_vals: dict, default: float = None)

Mapping array values to new values defined by a dictionnary.

First, check if all values are in keys_vals. If not, set to default. If default is None, set to nullvalue.

Parameters:

• keys_vals – dictionary of values to map

• default – default value if key not found

classmethod from_other_epsg_coo(input_raster_path: str, input_srs='EPSG:3812', output_srs='EPSG:31370', resampling_method=gdal.GRA_Bilinear, xRes: float = 0.5, yRes: float = 0.5)

Reprojects and resamples a raster file from an other EPSG coordinates and return it as a WolfArray.

Parameters:

• input_raster_path (str) – The path to the input raster file.

• input_srs (str) – The input spatial reference system (SRS) in the format ‘EPSG:XXXX’. Defaults to Lambert 2008 ‘EPSG:3812’.

• output_srs (str) – The output spatial reference system (SRS) in the format ‘EPSG:XXXX’. Defaults to Belgian Lambert 72 ‘EPSG:31370’.

• resampling_method – The resampling method to use. Defaults to gdal.GRA_Bilinear. Resampling method can be chosen among the gdal GRA_*

constants (gdal.GRA_Average; gdal.GRA_Bilinear; gdal.GRA_Cubic; gdal.GRA_CubicSpline; gdal.GRA_Lanczos; gdal.GRA_Mode; gdal.GRA_NearestNeighbour) :type resampling_method: int :param xRes: The desired output resolution in the x direction. Defaults to 0.5. :type xRes (float): float :param yRes: The desired output resolution in the y direction. Defaults to 0.5. :type yRes (float): float

Raises:

• AssertionError – If the input or output raster file is not a GeoTIFF file.

• RuntimeError – If the input raster file cannot be opened.

• PermissionError – If there is a permission error while trying to delete the output raster file.

• Exception – If an unexpected error occurs while trying to delete the output raster file.

• RuntimeError – If the reprojection fails for the input raster file.

Returns:

WolfArray

class wolfhece.wolf_array.WolfArrayMB(fname=None, mold=None, masknull=True, crop=None, whichtype=WOLF_ARRAY_MB_SINGLE, preload=True, create=False, mapviewer=None, nullvalue=0, srcheader=None)

Bases: WolfArray

Matrice multiblocks

Les blocs (objets WolfArray) sont stockés dans un dictionnaire “myblocks”

property nullvalue: float

Return the null value

myblocks: dict[str, WolfArray]

extract_selection()

Extract the current selection

add_ops_sel()

Add operations and selection manager to all blocks

filter_zone(set_null: bool = False)

Filtre des zones et conservation de celles pour lesquelles des mailles sont sélectionnées

labelling()

Labelling of the array using Scipy

interpolate_on_polygon(working_vector: wolfhece.PyVertexvectors.vector, method: Literal[nearest, linear, cubic] = 'linear')

Interpolation sous un polygone

L’interpolation a lieu :

• uniquement dans les mailles sélectionnées si elles existent

• dans les mailles contenues dans le polygone sinon

On utilise ensuite “griddata” pour interpoler les altitudes des mailles depuis les vertices 3D du polygone

interpolate_on_polygons(working_zone: wolfhece.PyVertexvectors.zone, method: Literal[nearest, linear, cubic] = 'linear')

Interpolation sous plusieurs polygones d’une même zone

interpolate_on_polyline(working_vector: wolfhece.PyVertexvectors.vector, usemask=True)

Interpolation sous une polyligne

L’interpolation a lieu :

• uniquement dans les mailles sélectionnées si elles existent

• dans les mailles sous la polyligne sinon

On utilise ensuite “interpolate” de shapely pour interpoler les altitudes des mailles depuis les vertices 3D de la polyligne

interpolate_on_polylines(working_zone: wolfhece.PyVertexvectors.zone, usemask=True)

Interpolation sous les polylignes d’une même zone

check_bounds_ij(i: int, j: int)

Check if i and j are inside the array bounds

check_bounds_xy(x: float, y: float)

Check if i and j are inside the array bounds

add_block(arr: WolfArray, force_idx: bool = False, copyarray=False)

Adds a properly configured block this multiblock.

Parameters:

• arr – The block to add.

• force_idx – If True, the index/key will be set on arr. If False, the index/key must already be set on arr.

share_palette()

Partage de la palette de couleurs entre matrices liées

copy_mask(source: WolfArrayMB, forcenullvalue: bool = False)

Copy the mask of two arrays

count()

Count the number of not null cells

check_plot()

Check plot and apply to each block

uncheck_plot(unload: bool = True, forceresetOGL: bool = False, askquestion: bool = True)

Uncheck plot and apply to each block

mask_data(value)

Mask cells where values are equal to value

mask_union(source: WolfArrayMB)

Union of the masks of two arrays

Applying for each block iteratively.

read_data()

Lecture du tableau en binaire

write_array()

Ecriture du tableau en binaire

get_ij_from_xy(x: float, y: float, z: float = 0.0, scale: float = 1.0, aswolf: bool = False, abs: bool = True, which_block: int = 1)

alias for get_ij_from_xy for the block `which_block

Parameters:

• x – x coordinate

• y – y coordinate

• z – z coordinate

• scale – scale factor

• aswolf – if True, then the indices are 1-based like Fortran, otherwise 0-based like Python

• abs – if True, then the translation is taken into account

• which_block – block index 1-based

get_values_as_wolf(i: int, j: int, which_block: int = 1)

Return the value at indices (i,j) of the block `which_block.

Parameters:

• i – i index

• j – j index

• which_block – block index 1-based

get_value(x: float, y: float, abs: bool = True)

Read the value at world coordinate (x,y). if abs is given, then the translation is is taken into account.

If no block covers the coordinate, then np.NaN is returned If several blocks cover the given coordinate then the first match is returned (and thus, the others are ignored).

Parameters:

• x – x coordinate

• y – y coordinate

• abs – if True, then the translation is taken into account

Returns:

the value at (x,y) or np.NaN if no block covers the coordinate

get_xy_from_ij(i: int, j: int, which_block: int, aswolf: bool = False, abs: bool = True)

Return the world coordinates (x,y) of the indices (i,j) of the block `which_block.

Parameters:

• i – i index – 1-based like Fortran or 0-based like Python, see ‘aswolf’ parameter

• j – j index – 1-based like Fortran or 0-based like Python, see ‘aswolf’ parameter

• which_block – block index 1-based

• aswolf – if True, (i,j) are 1-based like Fortran, otherwise 0-based like Python

• abs – if True, then the translation is taken into account

get_blockij_from_xy(x: float, y: float, abs: bool = True)

Return the block indices (i,j) of the block covering the world coordinate (x,y)

Parameters:

• x – x coordinate

• y – y coordinate

• abs – if True, then the translation is taken into account

Returns:

the block indices (i,j,[k]) or (-1,-1,-1) if no block covers the coordinate

link_palette()

Lier les palettes des blocs à la palette de l’objet parent

updatepalette(which: int = 0, onzoom: list[float] = [])

Update the palette/colormap of the array

Parameters:

• which – which colormap to use

• onzoom – if not empty, then only the values within the zoom are used to update the palette – [xmin,xmax,ymin,ymax]

delete_lists()

Delete OpenGL lists

mimic_plotdata()

Copy plot flags to children

plot(sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None)

Plot the array

fillonecellgrid(curscale, loci, locj, force=False)

Fill one cell of the plotted grid

check_consistency(other)

Vérifie la cohérence entre deux matrices

reset()

Reset each block

mask_reset()

Reset mask – mask = False everywhere

mask_lower(value)

Mask cell where values are strictly lower than value

imshow(figax: tuple[matplotlib.figure.Figure, matplotlib.axis.Axis] = None, cmap: matplotlib.colors.Colormap = None, step_ticks=100.0) → tuple[matplotlib.figure.Figure, matplotlib.axis.Axis]

Create Matplotlib image from MultiBlock array

allocate_ressources()

Allocate memory ressources

set_header_from_added_blocks()

Set header from blocks

as_WolfArray(abs: bool = True, forced_header: header_wolf = None) → WolfArray

Convert to WolfArray

Rebin blocks if necessary

class wolfhece.wolf_array.WolfArrayMNAP(fname=None, mold=None, masknull=True, crop=None)

Bases: WolfArrayMB

Matrice MNAP d’une modélisation WOLF2D

Elle contient toutes les informations de maillage en Multi-blocks ainsi que les relations de voisinage de blocs.

Surcharge de WolfArrayMB avec modification des opérations de lecture/écriture car le fichier est au format TEXTE/ASCII et d’une structure spécifique.

contour: wolfhece.PyVertexvectors.Zones

write_all()

Ecriture de tous les fichiers d’un Wolf array

Parameters:

• newpath – new path and filename with extension – if None, use the current filename

• EPSG – EPSG code for geotiff

read_data()

Lecture du tableau en binaire

read_txt_header()

Surcharge de la lecture du header

Il n’y a pas en tant que tel de header d’un fichier MNAP.

Les informations de translation sont dans le fichier “.trl”.

Les informations de tailles de maille ‘fines’, Nbx, Nby et coordonnées d’origine sont dans le fichier “.par”

get_one_mask(which: int | str)

Return the mask of the block which

get_all_masks()

Return all masks