src.acoustools.Mesh.Cut

 1import vedo
 2
 3from vedo import Mesh
 4
 5from acoustools.Mesh.Load import calculate_features, scatterer_file_name
 6from acoustools.Mesh.Transform import translate
 7from acoustools.Mesh.Features import get_centre_of_mass_as_points 
 8
 9
10def cut_mesh_to_walls(scatterer:Mesh, layer_z:float, layer_normal:tuple[float] = (0,0,-1.0), wall_thickness = 0.001) -> Mesh:
11    '''
12    Cuts a mesh with a given plane and then converts the result to have walls of a certain thickness \n
13    :param scatterer: Mesh to use
14    :param layer_z: coordinate of layer
15    :param layer_normal: Normal to layer (if not +- (0,0,1) then layer_z will not refer to a z coordinate)
16    :param wall_thickness: Thickness of the walls to returns
17    :return: Cut mesh with walls
18    '''
19
20    xmin,xmax, ymin,ymax, zmin,zmax = scatterer.bounds()
21    dx = xmax-xmin
22    dy = ymax-ymin
23
24    scale_x = (dx-2*wall_thickness) / dx
25    scale_y = (dy-2*wall_thickness) / dy
26
27    outler_layer = scatterer.cut_with_plane((0,0,layer_z),layer_normal)
28    inner_layer = outler_layer.clone()
29    inner_layer.scale((scale_x,scale_y,1), origin=False)
30
31    com_outer = get_centre_of_mass_as_points(outler_layer)
32    com_inner = get_centre_of_mass_as_points(inner_layer)
33
34    d_com = (com_outer - com_inner).squeeze()
35
36    translate(inner_layer, *d_com)
37
38    walls = vedo.merge(outler_layer, inner_layer)
39
40
41    boundaries_outer = outler_layer.boundaries()
42    boundaries_inner = inner_layer.boundaries()
43
44    strips = boundaries_outer.join_with_strips(boundaries_inner).triangulate()
45    
46
47    walls = vedo.merge(walls,strips)
48    
49    calculate_features(walls)
50    scatterer_file_name(walls)
51
52    return walls.clean()
53
54def cut_closed_scatterer(scatterer:Mesh,layer_z:float, normals=[(0,0,1)]):
55    '''
56    Cuts a scatterer across a z-plane\\
57    :param scatterer: Mesh
58    :param layer_z: height to cute
59    :param normals: Which way is up 
60    '''
61    origins=[(0,0,layer_z)]
62    closed_scatterer = scatterer.cut_closed_surface(origins=origins, normals=normals)
63    return closed_scatterer
def cut_mesh_to_walls( scatterer: vedo.mesh.core.Mesh, layer_z: float, layer_normal: tuple[float] = (0, 0, -1.0), wall_thickness=0.001) -> vedo.mesh.core.Mesh:
14def cut_mesh_to_walls(scatterer:Mesh, layer_z:float, layer_normal:tuple[float] = (0,0,-1.0), wall_thickness = 0.001) -> Mesh:
15    '''
16    Cuts a mesh with a given plane and then converts the result to have walls of a certain thickness \n
17    :param scatterer: Mesh to use
18    :param layer_z: coordinate of layer
19    :param layer_normal: Normal to layer (if not +- (0,0,1) then layer_z will not refer to a z coordinate)
20    :param wall_thickness: Thickness of the walls to returns
21    :return: Cut mesh with walls
22    '''
23
24    xmin,xmax, ymin,ymax, zmin,zmax = scatterer.bounds()
25    dx = xmax-xmin
26    dy = ymax-ymin
27
28    scale_x = (dx-2*wall_thickness) / dx
29    scale_y = (dy-2*wall_thickness) / dy
30
31    outler_layer = scatterer.cut_with_plane((0,0,layer_z),layer_normal)
32    inner_layer = outler_layer.clone()
33    inner_layer.scale((scale_x,scale_y,1), origin=False)
34
35    com_outer = get_centre_of_mass_as_points(outler_layer)
36    com_inner = get_centre_of_mass_as_points(inner_layer)
37
38    d_com = (com_outer - com_inner).squeeze()
39
40    translate(inner_layer, *d_com)
41
42    walls = vedo.merge(outler_layer, inner_layer)
43
44
45    boundaries_outer = outler_layer.boundaries()
46    boundaries_inner = inner_layer.boundaries()
47
48    strips = boundaries_outer.join_with_strips(boundaries_inner).triangulate()
49    
50
51    walls = vedo.merge(walls,strips)
52    
53    calculate_features(walls)
54    scatterer_file_name(walls)
55
56    return walls.clean()

Cuts a mesh with a given plane and then converts the result to have walls of a certain thickness

Parameters
  • scatterer: Mesh to use
  • layer_z: coordinate of layer
  • layer_normal: Normal to layer (if not +- (0,0,1) then layer_z will not refer to a z coordinate)
  • wall_thickness: Thickness of the walls to returns
Returns

Cut mesh with walls

def cut_closed_scatterer(scatterer: vedo.mesh.core.Mesh, layer_z: float, normals=[(0, 0, 1)]):
58def cut_closed_scatterer(scatterer:Mesh,layer_z:float, normals=[(0,0,1)]):
59    '''
60    Cuts a scatterer across a z-plane\\
61    :param scatterer: Mesh
62    :param layer_z: height to cute
63    :param normals: Which way is up 
64    '''
65    origins=[(0,0,layer_z)]
66    closed_scatterer = scatterer.cut_closed_surface(origins=origins, normals=normals)
67    return closed_scatterer

Cuts a scatterer across a z-plane\

Parameters
  • scatterer: Mesh
  • layer_z: height to cute
  • normals: Which way is up