wolfhece.PyVertex

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

wolfhece.PyVertex.getRGBfromI(rgbint: int)

Convert integer to RGB

wolfhece.PyVertex.getIfromRGB(rgb: list | tuple)

Convert RGB to integer

wolfhece.PyVertex.circle(x: float, y: float, r: float, numseg: int = 20)

wolfhece.PyVertex.cross(x: float, y: float, r: float)

wolfhece.PyVertex.quad(x: float, y: float, r: float)

class wolfhece.PyVertex.Cloud_Styles(*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.

POINT = 0

CIRCLE = 1

CROSS = 2

QUAD = 3

class wolfhece.PyVertex.wolfvertex(x: float, y: float, z: float = -99999.0)

Vertex WOLF - 3 coordonnées + valeurs associées dans un dictionnaire

x: float

y: float

z: float

values: dict = None

in_use = True

rotate(angle: float, center: tuple)

Rotate the vertex

Parameters:

• angle – angle in radians (positive for counterclockwise)

• center – center of the rotation (x, y)

as_shapelypoint()

Return a shapely Point

copy()

Return a copy of the vertex

getcoords()

Return the coordinates as a numpy array

dist3D(v: wolfvertex) → float

Return the 3D distance to another vertex

Parameters:

v – vertex to compare

dist2D(v: wolfvertex) → float

Return the 2D distance to another vertex

Parameters:

v – vertex to compare

addvalue(id, value)

Add a value to the vertex

Parameters:

• id – key of the value

• value – value to add

add_value(id, value)

Add a set of values to the vertex

Parameters:

• id – key of the value

• value – value to add

add_values(values: dict)

Add a set of values to the vertex

Parameters:

values – dictionary of values to add

getvalue(id)

Return a value from the vertex

Parameters:

id – key of the value

get_value(id)

Return a set of values from the vertex

Parameters:

id – key of the value

get_values(ids: list) → dict

Return a set of values from the vertex

limit2bounds(bounds=None)

Limit the vertex to a set of bounds

Parameters:

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

is_like(v: wolfvertex, tol: float = 1e-06)

Return True if the vertex is close to another one

Parameters:

• v – vertex to compare

• tol – tolerance

class wolfhece.PyVertex.cloudproperties(lines=[], parent: cloud_vertices = None)

Properties of a cloud of vertices

used: bool

color: int

width: int

style: int

alpha: int

filled: bool

legendvisible: bool

transparent: bool

flash: bool

legendtext: str

legendrelpos: int

legendx: float

legendy: float

legendbold: bool

legenditalic: bool

legendunderlined: bool

legendfontname

legendfontsize: int

legendcolor: int

legendpriority: int

legendorientation: int

legendwidth: int

legendheight: int

extrude: bool = False

myprops: wolfhece.PyParams.Wolf_Param = None

parent = None

fill_property()

defaultprop()

Default properties

destroyprop()

show()

class wolfhece.PyVertex.cloud_vertices(fname: str | pathlib.Path = '', fromxls: str = '', header: bool = False, toload=True, idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False, bbox: shapely.geometry.Polygon = None, dxf_imported_elts=['MTEXT', 'INSERT'])

Bases: wolfhece.drawing_obj.Element_To_Draw

Scatter points with associated values

Accepted formats : dxf, ascii

Ascii separator : tabulation ‘ ‘, semicolon ‘;’

‘dxf’ type is automatically finded based on file extension otherwise, ascii file is supposed.

If header exists in the first line of the file, you have to mention it by header=True in initialization.

Total number of columns (nb) is important :

• if nb >3 : the file must contain a header

• if header[2].lower() == ‘z’, the file contains XYZ coordinates, otherwise all columns >1 are interpreted as values associated to XY

Number os values = nb - (2 or 3) depending if Z coordinate exists

Data are stored in Python dictionnary :

• ‘vertex’ : XY or XYZ

Each value is accessible through its headname as key :

• ‘headname1’ : value with headname1

• ‘headname2’ : value with headname2

• ‘headnamen’ : value with headnamen

For more information, see ‘readfile’ or ‘import_from_dxf’

filename: str

myvertices: dict[int, dict['vertex':wolfvertex, str:float]]

xbounds: tuple

ybounds: tuple

zbounds: tuple

myprop: cloudproperties

mytree: scipy.spatial.KDTree

loaded = False

_header = False

gllist = 0

forceupdategl = False

ongoing = False

create_kdtree()

Set a Scipy KDTree structure based on a copy of the vertices

find_nearest(xyz: numpy.ndarray | list, nb: int = 1)

Find nearest neighbors from Scipy KDTree structure based on a copy of the vertices.

See : https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.KDTree.query.html

Parameters:

• xyz – coordinates to find nearest neighbors – shape (n, m) - where m is the number of coordinates (2 or 3)

• nb – number of nearest neighbors to find

Returns:

list of distances, list of “Wolfvertex”, list of elements stored in self.myvertices - or list of lists if xyz is a list of coordinates

init_from_nparray(array: numpy.ndarray)

Fill-in from nparray – shape (n,3)

check_plot()

The cloud is plotted – useful for mapviewer

uncheck_plot(unload=True)

The cloud is not plotted – useful for mapviewer

readfile(fname: str = '', header: bool = False)

Reading an ascii file with or without header

Parameters:

• fname – (str) file name

• header – (bool) header in file (first line with column names)

The separator is automatically detected among : tabulation, semicolon, space, comma.

The file must contain at least 2 columns (X, Y) and may contain a third one (Z) and more (values). If values are present, they are stored in the dictionnary with their header name as key.

import_from_dxf(fn: str = '', imported_elts=['MTEXT', 'INSERT'])

Importing DXF file using ezdxf library

Parameters:

fn – file name (*.dxf)

import_from_shapefile(fn: str = '', targetcolumn: str = 'X1_Y1_Z1', bbox: shapely.geometry.Polygon = None)

Importing Shapefile using geopandas library

Parameters:

• fn – file name

• targetcolumn – column name to be used for XYZ coordinates – ‘X1_Y1_Z1’ is used by SPW-ARNE-DCENN

add_vertex(vertextoadd: wolfvertex = None, id=None, cloud: dict = None)

Add a vertex to the cloud

Parameters:

• vertextoadd – vertex to add

• id – id of the vertex – if None, the id is the length of the cloud

• cloud – cloud of vertices to add – wolfvertex instances are pointed not copied

add_vertices(vertices: list[wolfvertex])

Add a list of vertices to the cloud

get_vertices()

Return the vertices as a list

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

Plot OpenGL

Legend is an image texture

FIXME : to be improved

plot(update: bool = False, *args, **kwargs)

OpenGL plot of the cloud of vertices

FIXME : to be improved

show_properties()

Show properties of the cloud

_updatebounds(newvert: wolfvertex = None, newcloud: dict = None)

Update the bounds of the cloud

:param newvert : (optional) vertex added to the cloud :param newcloud: (optional) cloud added to the cloud

‘newvert’ or ‘newcloud’ can be passed as argument during add_vertex operation. In this way, the bounds are updated without going through all the vertices -> expected more rapid.

find_minmax(force=False)

Find the bounds of the cloud

Parameters:

force – force the computation of the bounds

get_xyz(key='vertex') → numpy.ndarray

Return the vertices as numpy array

Parameters:

key – key to be used for the third column (Z) – ‘vertex’ or any key in the dictionnary – if ‘vertex’’, [[X,Y,Z]] are returned

property has_values: bool

Check if the cloud has values (other than X,Y,Z)

property header: list[str]

Return the headers of the cloud

add_values_by_id_list(id: str, values: list[float])

Add values to the cloud

Parameters:

• id – use as key for the values

• values – list of values to be added - must be the same length as number of vertices

property xyz: numpy.ndarray

Alias for get_xyz method

property nbvertices: int

Number of vertices in the cloud

interp_on_array(myarray, key: str = 'vertex', method: Literal['linear', 'nearest', 'cubic'] = 'linear')

Interpolation of the cloud on a 2D array

Parameters:

• myarray – WolfArray instance

• key – key to be used for the third column (Z) – ‘vertex’ or any key in the dictionnary

• method – interpolation method – ‘linear’, ‘nearest’, ‘cubic’

see interpolate_on_cloud method of WolfArray for more information

iter_on_vertices()

Iteration on vertices

get_multipoint()

Return the cloud as a Shapely MultiPoint

projectontrace(trace, return_cloud: bool = True, proximity: float = 99999.0)

Project the cloud onto a trace (type ‘vector’)

Parameters:

• trace – vector class

• return_cloud – return a cloud or the lists [s],[z]

• proximity – search distance for projection

Returns:

New cloud containing the position information on the trace and altitude (s,z) else:

s,z: 2 lists of floats

Return type:

if return_cloud

plot_matplotlib(ax=None, **kwargs)

Plot the cloud using matplotlib

Parameters:

• ax – axis to plot on – if None, a new figure is created

• kwargs – additional arguments for matplotlib