List of Filters¶

Here are listed all the filter names that can be given as paramter to the function pmeshlab.MeshSet.apply_filter().

Each filter accepts a list of parameters, that can be semantically classified as follows:

Boolean: a classic bool value;

Integer: a classic int value;

String: a classic str value;

Float: a classic float value;

Bounded Float: a classic float that is expected to be bounded between a min and a max value; an out-of-bounds value will raise an exception;

Percentage: represents a parameter that is relative to some other measure, specified in the documentation of the filter. This parameter can be of two different types:

pmeshlab.Percentage (recommended): the parameter will be treated as relative percentage value; see the documentation of the pmeshlab.Percentage for further info;

float (not recommended): the parameter will be treated as absolute value;

Enum: represents a parameter that can accept just one of a limited set of possible values. These values type can be int or str; see the documentation of the specific filter for further info;

Color: represents a color, and the parameter can be of type pmeshlab.Color; see the documentation of the pmeshlab.Color for further info;

3D Point (or 3D Vector): represents a 3D point or vector, and the parameter can be of type numpy.ndarray[numpy.float64[3]] (a numpy array containing three floats);

4x4 Matrix: represents a 4x4 Matrix of floats, and the parameter can be of type numpy.ndarray[numpy.float64[4, 4]] (a 4x4 numpy array of floats);

Mesh: represents a parameter that links to one of the meshes contained in the MeshSet on which the filter is applied. This parameter is of type int, which indicates the id of the mesh in the MeshSet;

File Name: a classic str that represents the path of a file that is going to be saved or loaded by the filter. The string is expected to have at least an extension on its final characters; see the documentation of the specific filter for further info;

Camera: still not supported;

The pmeshlab.MeshSet.apply_filter() returns a dictionary that may contain some values returned by the applied filter. Most of the filters do not return nothing, therefore the dictionary will be empty.

Please note: some filter parameters depend on the mesh(es) used as input of the filter. Default values listed here are computed on a 1x1x1 cube (pymeshlab/tests/sample/cube.obj), but their value will be computed on the input mesh if they are left as default.

apply_filter parameters¶

alpha_complex_shape¶

MeshLab filter name: ‘Alpha Complex/Shape’

Calculate the Alpha Shape of the mesh(Edelsbrunner and P.Mucke 1994) with Qhull library (http://www.qhull.org/).

From a given finite point set in the space it computes 'the shape' of the set.The Alpha Shape is the boundary of the alpha complex, that is a subcomplex of the Delaunay triangulation of the given point set.
For a given value of 'alpha', the alpha complex includes all the simplices in the Delaunay triangulation which have an empty circumsphere with radius equal or smaller than 'alpha'.
The filter inserts the minimum value of alpha (the circumradius of the triangle) in attribute Quality foreach face.

Parameters:

alpha : Percentage = 1%

Alpha value: Compute the alpha value as percentage of the diagonal of the bbox

filtering : str = 'Alpha Complex' (or int = 0)

Possible enum values:

'Alpha Complex'

'Alpha Shape'

Get:: Select the output. The Alpha Shape is the boundary of the Alpha Complex

ambient_occlusion¶

MeshLab filter name: ‘Ambient Occlusion’

Compute ambient occlusions values; it takes a number of well distributed view direction and for point of the surface it computes how many time it is visible from these directions. This value is saved into quality and automatically mapped into a gray shade. The average direction is saved into an attribute named 'BentNormal'

Parameters:

occmode : str = 'per-Vertex' (or int = 0)

Possible enum values:

'per-Vertex'

'per-Face (deprecated)'

Occlusion mode:: Occlusion may be calculated per-vertex or per-face, color and quality will be saved in the chosen component.

dirbias : float = 0

Directional Bias [0..1]: The balance between a uniform and a directionally biased set of lighting direction
: - 0 means light came only uniformly from any direction
- 1 means that all the light cames from the specified cone of directions
- other values mix the two set of lighting directions

reqviews : int = 128

Requested views: Number of different views uniformly placed around the mesh. More views means better accuracy at the cost of increased calculation time

conedir : numpy.ndarray[numpy.float64[3]] = [0, 1, 0]

Lighting Direction: Number of different views placed around the mesh. More views means better accuracy at the cost of increased calculation time

coneangle : float = 30

Cone amplitude: Number of different views uniformly placed around the mesh. More views means better accuracy at the cost of increased calculation time

usegpu : bool = False

Use GPU acceleration: Only works for per-vertex AO. In order to use GPU-Mode, your hardware must support FBOs, FP32 Textures and Shaders. Normally increases the performance by a factor of 4x-5x

depthtexsize : int = 512

Depth texture size(should be 2^n): Defines the depth texture size used to compute occlusion from each point of view. Higher values means better accuracy usually with low impact on performance

annulus¶

MeshLab filter name: ‘Annulus’

Create an Annulus e.g. a flat region bounded by two concentric circles, or a holed disk.

Parameters:

internalradius : float = 0.5

Internal Radius: Internal Radius of the annulus

externalradius : float = 1

External Radius: Externale Radius of the annulus

sides : int = 32

Sides: Number of the sides of the poligonal approximation of the annulus

box_cube¶

MeshLab filter name: ‘Box/Cube’

Create a Box, Cube, Hexahedron. You can specify the side length.

Parameters:

size : float = 1

Scale factor: Scales the new mesh

build_a_polyline_from_selected_edges¶

MeshLab filter name: ‘Build a Polyline from Selected Edges’

Create a new Layer with an edge mesh composed only by the selected edges of the current mesh

change_the_current_layer¶

MeshLab filter name: ‘Change the current layer’

Change the current layer to a chosen one

Parameters:

layer : int = 0

Layer Name: The name of the current layer

change_visibility_of_layers¶

MeshLab filter name: ‘Change Visibility of layer(s)’

Make layer(s) visible/invisible. Useful for scripting.

Parameters:

layer : int = 0

Layer Name: The name of the layer that has to change visibility. If second parameter is not empty, this parameter is ignored

lname : str = ''

Substring match: Apply visibility to all layers with name substring matching the entered string. If not empty, the first parameter is ignored.

ismeshvisible : bool = True

Visible: It makes the selected layer(s) visible or invisible.

clamp_vertex_quality¶

MeshLab filter name: ‘Clamp Vertex Quality’

Clamp vertex quality values to a given range according to specific values or to percentiles

Parameters:

minval : float = inf

Min: The value that will be mapped with the lower end of the scale (red)

maxval : float = -inf

Max: The value that will be mapped with the upper end of the scale (blue)

perc : float (bounded) = 0 [min: 0; max: 100]

Percentile Crop [0..100]: If not zero this value will be used for a percentile cropping of the quality values.
If this parameter is set to a value P then the two values V_min,V_max for which P% of the vertices have a quality lower or greater than V_min,V_max are used as min/max values for clamping.

The automated percentile cropping is very useful for automatically discarding outliers.

zerosym : bool = False

Zero Symmetric: If true the min max range will be enlarged to be symmetric (so that green is always Zero)

close_holes¶

MeshLab filter name: ‘Close Holes’

Close holes smaller than a given threshold

Parameters:

maxholesize : int = 30

Max size to be closed : The size is expressed as number of edges composing the hole boundary

selected : bool = False

Close holes with selected faces: Only the holes with at least one of the boundary faces selected are closed

newfaceselected : bool = True

Select the newly created faces: After closing a hole the faces that have been created are left selected. Any previous selection is lost. Useful for example for smoothing the newly created holes.

selfintersection : bool = True

Prevent creation of selfIntersecting faces: When closing an holes it tries to prevent the creation of faces that intersect faces adjacent to the boundary of the hole. It is an heuristic, non intersetcting hole filling can be NP-complete.

clustered_vertex_sampling¶

MeshLab filter name: ‘Clustered Vertex Sampling’

Create a new layer populated with a subsampling of the vertices of the current mesh; the subsampling is driven by a simple one-per-gridded cell strategy.

Parameters:

threshold : Percentage = 1%

Cell Size: The size of the cell of the clustering grid. Smaller the cell finer the resulting mesh. For obtaining a very coarse mesh use larger values.

sampling : str = 'Closest to center' (or int = 1)

Possible enum values:

'Average'

'Closest to center'

Representative Strategy:: Average: for each cell we take the average of the sample falling into. The resulting point is a new point.
Closest to center: for each cell we take the sample that is closest to the center of the cell. Chosen vertices are a subset of the original ones.

selected : bool = False

Only on Selection: If true only for the filter is applied only on the selected subset of the mesh.

color_noise¶

MeshLab filter name: ‘Color noise’

Adds to the color the requested amount of bits of noise. Bits of noise are added independently for each RGB channel.

Parameters:

noisebits : int = 1

Noise bits:: Bits of noise added to each RGB channel. Example: 3 noise bits adds three random offsets in the [-4,+4] interval to each RGB channels.

onselected : bool = False

Only on selection: If checked, only affects selected vertices

colorize_by_border_distance¶

MeshLab filter name: ‘Colorize by border distance’

Store in the quality field the geodesic distance from borders and color the mesh accordingly.

colorize_by_face_quality¶

MeshLab filter name: ‘Colorize by face Quality’

Color faces depending on their quality field (manually equalized).

Parameters:

minval : float = inf

Min: The value that will be mapped with the lower end of the scale (red)

maxval : float = -inf

Max: The value that will be mapped with the upper end of the scale (blue)

perc : float (bounded) = 0 [min: 0; max: 100]

Percentile Crop [0..100]: If not zero this value will be used for a percentile cropping of the quality values.
If this parameter is set to a value P then the two values V_min,V_max for which P% of the faces have a quality lower or greater than V_min,V_max are used as min/max values for clamping.

The automated percentile cropping is very useful for automatically discarding outliers.

zerosym : bool = False

Zero Symmetric: If true the min max range will be enlarged to be symmetric (so that green is always Zero)

colorize_by_geodesic_distance_from_a_given_point¶

MeshLab filter name: ‘Colorize by geodesic distance from a given point’

Store in the quality field the geodesic distance from a given point on the mesh surface and color the mesh accordingly.

Parameters:

startpoint : numpy.ndarray[numpy.float64[3]] = [1, 1, 1]

Starting point: The starting point from which geodesic distance has to be computed. If it is not a surface vertex, the closest vertex to the specified point is used as starting seed point.

maxdistance : Percentage = 50%

Max Distance: If not zero it indicates a cut off value to be used during geodesic distance computation.

colorize_by_geodesic_distance_from_the_selected_points¶

MeshLab filter name: ‘Colorize by geodesic distance from the selected points’

Store in the quality field the geodesic distance from the selected points on the mesh surface and color the mesh accordingly.

Parameters:

maxdistance : Percentage = 50%

Max Distance: If not zero it indicates a cut off value to be used during geodesic distance computation.

colorize_by_vertex_quality¶

MeshLab filter name: ‘Colorize by vertex Quality’

Color vertices depending on their quality field (manually equalized).

Parameters:

minval : float = inf

Min: The value that will be mapped with the lower end of the scale (red)

maxval : float = -inf

Max: The value that will be mapped with the upper end of the scale (blue)

perc : float (bounded) = 0 [min: 0; max: 100]

Percentile Crop [0..100]: If not zero this value will be used for a percentile cropping of the quality values.
If this parameter is set to a value P then the two values V_min,V_max for which P% of the vertices have a quality lower or greater than V_min,V_max are used as min/max values for clamping.

The automated percentile cropping is very useful for automatically discarding outliers.

zerosym : bool = False

Zero Symmetric: If true the min max range will be enlarged to be symmetric (so that green is always Zero)

colorize_curvature_apss¶

MeshLab filter name: ‘Colorize curvature (APSS)’

Colorize the vertices of a mesh or point set using the curvature of the underlying surface.

This is the algebraic point set surfaces (APSS) variant which is based on the local fitting of algebraic spheres. It requires points equipped with oriented normals.
For all the details about APSS see:
Guennebaud and Gross, 'Algebraic Point Set Surfaces', Siggraph 2007, and
Guennebaud et al., 'Dynamic Sampling and Rendering of APSS', Eurographics 2008

Parameters:

selectiononly : bool = False

Selection only: If checked, only selected vertices will be projected.

filterscale : float = 2

MLS - Filter scale: Scale of the spatial low pass filter.
It is relative to the radius (local point spacing) of the vertices.

projectionaccuracy : float = 0.0001

Projection - Accuracy (adv): Threshold value used to stop the projections.
This value is scaled by the mean point spacing to get the actual threshold.

maxprojectioniters : int = 15

Projection - Max iterations (adv): Max number of iterations for the projection.

sphericalparameter : float = 1

MLS - Spherical parameter: Control the curvature of the fitted spheres: 0 is equivalent to a pure plane fit,1 to a pure spherical fit, values between 0 and 1 gives intermediate results,while other real values might give interesting results, but take care with extremesettings !

curvaturetype : str = 'Mean' (or int = 0)

Possible enum values:

'Mean'

'Gauss'

'K1'

'K2'

'ApproxMean'

Curvature type: The type of the curvature to plot.
ApproxMean uses the radius of the fitted sphere as an approximation of the mean curvature.

colorize_curvature_rimls¶

MeshLab filter name: ‘Colorize curvature (RIMLS)’

Colorize the vertices of a mesh or point set using the curvature of the underlying surface.

This is the Robust Implicit MLS (RIMLS) variant which is an extension of Implicit MLS preserving sharp features using non linear regression. For more details see:
Oztireli, Guennebaud and Gross, 'Feature Preserving Point Set Surfaces based on Non-Linear Kernel Regression' Eurographics 2009.

Parameters:

selectiononly : bool = False

Selection only: If checked, only selected vertices will be projected.

filterscale : float = 2

MLS - Filter scale: Scale of the spatial low pass filter.
It is relative to the radius (local point spacing) of the vertices.

projectionaccuracy : float = 0.0001

Projection - Accuracy (adv): Threshold value used to stop the projections.
This value is scaled by the mean point spacing to get the actual threshold.

maxprojectioniters : int = 15

Projection - Max iterations (adv): Max number of iterations for the projection.

sigman : float = 0.75

MLS - Sharpness: Width of the filter used by the normal refitting weight.This weight function is a Gaussian on the distance between two unit vectors:the current gradient and the input normal. Therefore, typical value range between 0.5 (sharp) to 2 (smooth).

maxrefittingiters : int = 3

MLS - Max fitting iterations: Max number of fitting iterations. (0 or 1 is equivalent to the standard IMLS)

curvaturetype : str = 'Mean' (or int = 0)

Possible enum values:

'Mean'

'Gauss'

'K1'

'K2'

Curvature type: The type of the curvature to plot.

compact_faces¶

MeshLab filter name: ‘Compact faces’

Compact all the faces that have been deleted and put them to the end of the vector

compact_vertices¶

MeshLab filter name: ‘Compact vertices’

Compact all the vertices that have been deleted and put them to the end of the vector

compute_area_perimeter_of_selection¶

MeshLab filter name: ‘Compute Area/Perimeter of selection’

Compute area and perimeter of the FACE selection. Open the layer dialog to see the results.

compute_curvature_principal_directions¶

MeshLab filter name: ‘Compute curvature principal directions’

Compute the principal directions of curvature with several algorithms

Parameters:

method : str = 'Pseudoinverse Quadric Fitting' (or int = 3)

Possible enum values:

'Taubin approximation'

'Principal Component Analysis'

'Normal Cycles'

'Pseudoinverse Quadric Fitting'

Method:: Choose a method

curvcolormethod : str = 'Mean Curvature' (or int = 0)

Possible enum values:

'Mean Curvature'

'Gaussian Curvature'

'Min Curvature'

'Max Curvature'

'Shape Index'

'CurvedNess'

'None'

Quality/Color Mapping: Choose the curvature that is mapped into quality and visualized as per vertex color.

autoclean : bool = True

Remove Unreferenced Vertices: If selected, before starting the filter will remove anyy unreference vertex (for which curvature values are not defined)

compute_geometric_measures¶

MeshLab filter name: ‘Compute Geometric Measures’

Compute a set of geometric measures of a mesh/pointcloud. Bounding box extents and diagonal, principal axis, thin shell barycenter (mesh only), vertex barycenter and quality-weighted barycenter (pointcloud only), surface area (mesh only), volume (closed mesh) and Inertia tensor Matrix (closed mesh). Open the layer dialog to see the results.

compute_normals_for_point_sets¶

MeshLab filter name: ‘Compute normals for point sets’

Compute the normals of the vertices of a mesh without exploiting the triangle connectivity, useful for dataset with no faces

Parameters:

k : int = 10

Neighbour num: The number of neighbors used to estimate normals.

smoothiter : int = 0

Smooth Iteration: The number of smoothing iteration done on the p used to estimate and propagate normals.

flipflag : bool = False

Flip normals w.r.t. viewpoint: If the 'viewpoint' (i.e. scanner position) is known, it can be used to disambiguate normals orientation, so that all the normals will be oriented in the same direction.

viewpos : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

Viewpoint Pos.: The viewpoint position can be set by hand (i.e. getting the current viewpoint) or it can be retrieved from mesh camera, if the viewpoint position is stored there.

compute_planar_section¶

MeshLab filter name: ‘Compute Planar Section’

Compute the polyline representing a planar section (a slice) of a mesh; if the resulting polyline is closed the result is filled and also a triangular mesh representing the section is saved

Parameters:

planeaxis : str = 'X Axis' (or int = 0)

Possible enum values:

'X Axis'

'Y Axis'

'Z Axis'

'Custom Axis'

Plane perpendicular to: The Slicing plane will be done perpendicular to the axis

customaxis : numpy.ndarray[numpy.float64[3]] = [0, 1, 0]

Custom axis: Specify a custom axis, this is only valid if the above parameter is set to Custom

planeoffset : float = 0

Cross plane offset: Specify an offset of the cross-plane. The offset corresponds to the distance from the point specified in the plane reference parameter. By default (Cross plane offset == 0)

relativeto : str = 'Origin' (or int = 2)

Possible enum values:

'Bounding box center'

'Bounding box min'

'Origin'

plane reference: Specify the reference from which the planes are shifted

createsectionsurface : bool = False

Create also section surface: If selected, in addition to a layer with the section polyline, it will be created also a layer with a triangulated version of the section polyline. This only works if the section polyline is closed

splitsurfacewithsection : bool = False

Create also split surfaces: If selected, it will create two layers with the portion of the mesh under and over the section plane. It requires manifoldness of the mesh.

compute_topological_measures¶

MeshLab filter name: ‘Compute Topological Measures’

Compute a set of topological measures over a mesh.

compute_topological_measures_for_quad_meshes¶

MeshLab filter name: ‘Compute Topological Measures for Quad Meshes’

Compute a set of topological measures over a quad mesh.

conditional_face_selection¶

MeshLab filter name: ‘Conditional Face Selection’

Boolean function using muparser lib to perform faces selection over current mesh.

It's possible to use parenthesis (), and predefined operators:
&& (logic and), || (logic or), <, <=, >, >=, != (not equal), == (equal), _?_:_ (c/c++ ternary operator)

It's possible to use the following per-face variables, or variables associated to the three vertex of every face:
x0,y0,z0 for the first vertex position, x1,y1,z1 for the second vertex position, x2,y2,z2 for the third vertex position, nx0,ny0,nz0 nx1,ny1,nz1 nx2,ny2,nz2 for vertex normals, r0,g0,b0,a0 r1,g1,b1,a1 r2,g2,b2,a2 for vertex colors, q0,q1,q2 for vertex quality, wtu0,wtv0 wtu1,wtv1 wtu2,wtv2 for per-wedge texture coords, ti for face texture index, vsel0,vsel1,vsel2 for vertex selection (1 yes, 0 no) fr,fg,fb,fa for face color, fq for face quality, fnx,fny,fnz for face normal, fsel face selection (1 yes, 0 no).

Parameters:

condselect : str = '(fi == 0)'

boolean function: type a boolean function that will be evaluated in order to select a subset of faces

conditional_vertex_selection¶

MeshLab filter name: ‘Conditional Vertex Selection’

Boolean function using muparser lib to perform vertex selection over current mesh.

It's possible to use parenthesis (), and predefined operators:
&& (logic and), || (logic or), <, <=, >, >=, != (not equal), == (equal), _?_:_ (c/c++ ternary operator)

It's possible to use the following per-vertex variables in the expression:
x,y,z (position), nx,ny,nz (normal), r,g,b,a (color), q (quality), rad (radius), vi (vertex index), vtu,vtv,ti (texture coords and texture index), vsel (is the vertex selected? 1 yes, 0 no) and all custom vertex attributes already defined by user.

Parameters:

condselect : str = '(q < 0)'

boolean function: type a boolean function that will be evaluated in order to select a subset of vertices
example: (y > 0) and (ny > 0)

cone¶

MeshLab filter name: ‘Cone’

Create a Cone

Parameters:

r0 : float = 1

Radius 1: Radius of the bottom circumference

r1 : float = 2

Radius 2: Radius of the top circumference

h : float = 3

Height: Height of the Cone

subdiv : int = 36

Side: Number of sides of the polygonal approximation of the cone

convert_pervertex_uv_into_perwedge_uv¶

MeshLab filter name: ‘Convert PerVertex UV into PerWedge UV’

Converts per Vertex Texture Coordinates to per Wedge Texture Coordinates. It does not merge superfluous vertices...

convert_perwedge_uv_into_pervertex_uv¶

MeshLab filter name: ‘Convert PerWedge UV into PerVertex UV’

Converts per Wedge Texture Coordinates to per Vertex Texture Coordinates splitting vertices with not coherent Wedge coordinates.

convex_hull¶

MeshLab filter name: ‘Convex Hull’

Calculate the convex hull with Qhull library (http://www.qhull.org/html/qconvex.htm).

The convex hull of a set of points is the boundary of the minimal convex set containing the given non-empty finite set of points.

craters_generation¶

MeshLab filter name: ‘Craters Generation’

Generates craters onto a mesh using radial functions.
There must be at least two layers to apply this filter:

the layer that contains the target mesh; we assume that this mesh is sufficiently refined;
the layer that contains the samples which represent the central points of craters.

There are three radial functions available to generate craters, two of which are Gaussian and Multiquadric, and the third is a variant of multiquadric. Blending functions are also provided to blend the crater elevation towards the mesh surface. If you want the preview to work, be sure to select the target mesh layer before launching the filter. You can select this layer by clicking on it in the layer dialog.

Parameters:

target_mesh : int = 0

Target mesh:: The mesh on which craters will be generated.

samples_mesh : int = 0

Samples layer:: The samples that represent the central points of craters.

seed : int = 0

Seed:: The seed with which the random number generator is initialized. The random generator generates radius and depth for each crater into the given range.

smoothingsteps : int = 5

Normals smoothing steps:: Vertex normals are smoothed this number of times before generating craters.

rbf : str = 'f2 (Multiquadric)' (or int = 1)

Possible enum values:

'f1 (Gaussian)'

'f2 (Multiquadric)'

'f3'

Radial function:: The radial function used to generate craters.

min_radius : float (bounded) = 0.1 [min: 0; max: 1]

Min crater radius:: Defines the minimum radius of craters in range [0, 1]. Values near 0 mean very small craters.

max_radius : float (bounded) = 0.35 [min: 0; max: 1]

Max crater radius:: Defines the maximum radius of craters in range [0, 1]. Values near 1 mean very large craters.

min_depth : float (bounded) = 0.05 [min: 0; max: 1]

Min crater depth:: Defines the minimum depth of craters in range [0, 1].

max_depth : float (bounded) = 0.15 [min: 0; max: 1]

Max crater depth:: Defines the maximum depth of craters in range [0, 1]. Values near 1 mean very deep craters.

elevation : float (bounded) = 0.4 [min: 0; max: 1]

Elevation:: Defines how much the crater rise itself from the mesh surface, giving an "impact-effect".

blend : str = 'f3 blending' (or int = 3)

Possible enum values:

'Exponential blending'

'Linear blending'

'Gaussian blending'

'f3 blending'

Blending algorithm:: The algorithm that is used to blend the perturbation towards the mesh surface.

blendthreshold : float (bounded) = 0.8 [min: 0; max: 1]

Blending threshold:: The fraction of craters radius beyond which the radial function is replaced with the blending function.

successiveimpacts : bool = True

Successive impacts: If not checked, the impact-effects of generated craters will be superimposed with each other.

ppnoise : bool = True

Postprocessing noise: Slightly perturbates the craters with a noise function.

invert : bool = False

Invert perturbation: If checked, inverts the sign of radial perturbation to create bumps instead of craters.

save_as_quality : bool = False

Save as vertex quality: Saves the perturbation as vertex quality.

create_selection_perimeter_polyline¶

MeshLab filter name: ‘Create Selection Perimeter Polyline’

Create a new Layer with the perimeter polyline(s) of the selection borders

create_solid_wireframe¶

MeshLab filter name: ‘Create Solid Wireframe’

Parameters:

edgecylflag : bool = True

Edge -> Cyl.: If True all the edges are converted into cylinders.

edgecylradius : Percentage = 1%

Edge Cylinder Rad.: The radius of the cylinder replacing each edge.

vertcylflag : bool = False

Vertex -> Cyl.: If True all the vertices are converted into cylinders.

vertcylradius : Percentage = 1%

Vertex Cylinder Rad.: The radius of the cylinder replacing each vertex.

vertsphflag : bool = True

Vertex -> Sph.: If True all the vertices are converted into sphere.

vertsphradius : Percentage = 1%

Vertex Sphere Rad.: The radius of the sphere replacing each vertex.

faceextflag : bool = True

Face -> Prism: If True all the faces are converted into prism.

faceextheight : Percentage = 0.5%

Face Prism Height: The Height of the prism that is substitued with each face.

faceextinset : Percentage = 0.5%

Face Prism Inset: The inset radius of each prism, e.g. how much it is moved toward the inside each vertex on the border of the prism.

edgefauxflag : bool = True

Ignore faux edges: If true only the Non-Faux edges will be considered for conversion.

cylindersidenum : int = 16

Cylinder Side: Number of sides of the cylinder (both edge and vertex).

cross_field_creation¶

MeshLab filter name: ‘Cross Field Creation’

Parameters:

crosstype : str = 'Linear Y' (or int = 0)

Possible enum values:

'Linear Y'

'Radial'

'Curvature'

Cross Type:

csg_operation¶

MeshLab filter name: ‘CSG Operation’

Constructive Solid Geometry operation filter.
For more details see:
C. Rocchini, P. Cignoni, F. Ganovelli, C. Montani, P. Pingi and R.Scopigno,
'Marching Intersections: an Efficient Resampling Algorithm for Surface Management'
In Proceedings of Shape Modeling International (SMI) 2001

Parameters:

firstmesh : int = 0

First Mesh: The first operand of the CSG operation

secondmesh : int = 0

Second Mesh: The second operand of the CSG operation

delta : Percentage = 1%

Spacing between sampling lines: This parameter controls the accuracy of the result and the speed of the computation.The time and memory needed to perform the operation usually scale as the reciprocal square of this value.For optimal results, this value should be at most half the the smallest feature (i.e. the highest frequency) you want to reproduce.

subdelta : int = 32

Discretization points per sample interval: This is the number of points between the sampling lines to which the vertices can be rounded.Increasing this can marginally increase the precision and decrease the speed of the operation.

operator : str = 'Intersection' (or int = 0)

Possible enum values:

'Intersection'

'Union'

'Difference'

Operator: Intersection takes the volume shared between the two meshes; Union takes the volume included in at least one of the two meshes; Difference takes the volume included in the first mesh but not in the second one

curvature_flipping_optimization¶

MeshLab filter name: ‘Curvature flipping optimization’

Mesh optimization by edge flipping, to improve local mesh curvature

Parameters:

selection : bool = False

Update selection: Apply edge flip optimization on selected faces only

pthreshold : float = 1

Angle Thr (deg): To avoid excessive flipping/swapping we consider only couple of faces with a significant diedral angle (e.g. greater than the indicated threshold).

curvtype : str = 'mean' (or int = 0)

Possible enum values:

'mean'

'norm squared'

'absolute'

Curvature metric:
Choose a metric to compute surface curvature on vertices
H = mean curv, K = gaussian curv, A = area per vertex

1: Mean curvature = H
2: Norm squared mean curvature = (H * H) / A
3: Absolute curvature:
if(K >= 0) return 2 * H
else return 2 * sqrt(H ^ 2 - A * K)

cut_mesh_along_crease_edges¶

MeshLab filter name: ‘Cut mesh along crease edges’

Cut the mesh along crease edges, duplicating the vertices as necessary. Crease (or sharp) edges are defined according to the variation of normal of the adjacent faces.

Parameters:

angledeg : float = 90

Crease Angle (degree): If the angle between the normals of two adjacent faces is larger that this threshold the edge is considered a creased and the mesh is cut along it.

define_new_per_face_attribute¶

MeshLab filter name: ‘Define New Per Face Attribute’

Add a new Per-Face attribute to current mesh.
You can specify custom name and a function to generate attribute's value
It's possible to use per-face variables in the expression:
It's possible to use the following per-face variables, or variables associated to the three vertex of every face:
x0,y0,z0 for the first vertex position, x1,y1,z1 for the second vertex position, x2,y2,z2 for the third vertex position, nx0,ny0,nz0 nx1,ny1,nz1 nx2,ny2,nz2 for vertex normals, r0,g0,b0,a0 r1,g1,b1,a1 r2,g2,b2,a2 for vertex colors, q0,q1,q2 for vertex quality, wtu0,wtv0 wtu1,wtv1 wtu2,wtv2 for per-wedge texture coords, ti for face texture index, vsel0,vsel1,vsel2 for vertex selection (1 yes, 0 no) fr,fg,fb,fa for face color, fq for face quality, fnx,fny,fnz for face normal, fsel face selection (1 yes, 0 no).
The attribute name specified below can be used in other filter function

Parameters:

name : str = 'Radiosity'

Name: the name of new attribute. you can access attribute in other filters through this name

expr : str = 'fi'

Function =: function to calculate custom attribute value for each face

define_new_per_vertex_attribute¶

MeshLab filter name: ‘Define New Per Vertex Attribute’

Add a new Per-Vertex scalar attribute to current mesh and fill it with the defined function.
The name specified below can be used in other filter functionIt's possible to use the following per-vertex variables in the expression:
x,y,z (position), nx,ny,nz (normal), r,g,b,a (color), q (quality), rad (radius), vi (vertex index), vtu,vtv,ti (texture coords and texture index), vsel (is the vertex selected? 1 yes, 0 no) and all custom vertex attributes already defined by user.

Parameters:

name : str = 'Radiosity'

Name: the name of new attribute. you can access attribute in other filters through this name

expr : str = 'x'

Function =: function to calculate custom attribute value for each vertex

delaunay_triangulation¶

MeshLab filter name: ‘Delaunay Triangulation’

Calculate the Delaunay triangulation with Qhull library (http://www.qhull.org/html/qdelaun.htm).

The Delaunay triangulation DT(P) of a set of points P in d-dimensional spaces is a triangulation of the convex hull such that no point in P is inside the circum-sphere of any simplex in DT(P).

delete_all_faces¶

MeshLab filter name: ‘Delete ALL Faces’

Delete ALL faces, turning the mesh into a pointcloud. May be applied also to all visible layers.

Parameters:

alllayers : bool = False

Apply to all visible Layers: If selected, the filter will be applied to all visible mesh Layers.

delete_all_non_selected_rasters¶

MeshLab filter name: ‘Delete all Non Selected Rasters’

All non selected raster layers are deleted

delete_all_non_visible_mesh_layers¶

MeshLab filter name: ‘Delete all non visible Mesh Layers’

All the non visible mesh layers are deleted

delete_current_mesh¶

MeshLab filter name: ‘Delete Current Mesh’

The current mesh layer is deleted

delete_current_raster¶

MeshLab filter name: ‘Delete Current Raster’

The current raster layer is deleted

delete_selected_faces¶

MeshLab filter name: ‘Delete Selected Faces’

Delete the current set of selected faces, vertices that remains unreferenced are not deleted.

delete_selected_faces_and_vertices¶

MeshLab filter name: ‘Delete Selected Faces and Vertices’

Delete the current set of selected faces and all the vertices surrounded by that faces.

delete_selected_vertices¶

MeshLab filter name: ‘Delete Selected Vertices’

Delete the current set of selected vertices; faces that share one of the deleted vertices are deleted too.

depth_complexity¶

MeshLab filter name: ‘Depth complexity’

Calculate the depth complexity of the mesh, that is: the maximum number of layers that a ray can hit while traversing the mesh. To have a correct value, you should specify and high value in the peeling iteration parameter. You can read the result in the MeshLab log window. If warnings are not present, you have the exact value, otherwise try increasing the peeling iteration parameter. After having calculated the correct value,you can ignore further warnings that you may get using that value..

Parameters:

onprimitive : str = 'On vertices' (or int = 0)

Possible enum values:

'On vertices'

'On Faces'

Metric:: Choose whether to trace rays from faces or from vertices.

numberrays : int = 128

Number of rays: : The number of rays that will be casted around the normals.

depthtexturesize : int = 512

Depth texture size: Size of the depth texture for depth peeling. Higher resolutions provide better sampling of the mesh, with a small performance penalty.

peelingiteration : int = 10

Peeling Iteration: Number of depth peeling iteration. Actually is the maximum number of layers that a ray can hit while traversing the mesh. For example, in the case of a sphere, you should specify 2 in this parameter. For a torus, specify 4. For more complex geometry you should run the depth complexity filter to know the exact value.

peelingtolerance : float = 1e-07

Peeling Tolerance: Depth tolerance used during depth peeling. This is the threshold used to differentiate layers between each others.Two elements whose distance is below this value will be considered as belonging to the same layer.

depth_smooth¶

MeshLab filter name: ‘Depth Smooth’

A laplacian smooth that is constrained to move vertices only in one given direction (usually the viewer direction).

Parameters:

stepsmoothnum : int = 3

Smoothing steps: The number of times that the whole algorithm (normal smoothing + vertex fitting) is iterated.

viewpoint : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

Viewpoint: The position of the view point that is used to get the constraint direction.

delta : Percentage = 100%

Strength: How much smoothing is applied: 0 (no smooth) e 1 (full smooth)

selected : bool = False

Affect only selection: If checked the filter is performed only on the selected area

dilate_selection¶

MeshLab filter name: ‘Dilate Selection’

Dilate (expand) the current set of selected faces.

directional_geom_preserv¶

MeshLab filter name: ‘Directional Geom. Preserv.’

Store and Blend the current geometry with the result of another previous smoothing processing step. This is useful to limit the influence of any smoothing algorithm along the viewing direction. This is useful to cope with the biased distribution of measuring error in many scanning devices, because TOF scanners usually have very good x,yaccuracy but suffer of greater depth errors.

Parameters:

step : str = 'Store Vertex Position' (or int = 0)

Possible enum values:

'Store Vertex Position'

'Blend Vertex Position'

Step:: The purpose of this filter is to constrain any smoothing algorithm to moving vertices only along a give line of sight.
First you should store current vertex position, than after applying one of the many smoothing algorithms you should re start this filter and blend the original positions with the smoothed results.
Given a view point vp , the smoothed vertex position vs and the original position v, The new vertex position is computed as the projection of vs on the line connecting v and vp.

viewpoint : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

Viewpoint: The position of the view point that is used to get the constraint direction.

selected : bool = False

Affect only selected faces: If checked the filter is performed only on the selected faces

discrete_curvatures¶

MeshLab filter name: ‘Discrete Curvatures’

Colorize according to various discrete curvature computed as described in:
'Discrete Differential-Geometry Operators for Triangulated 2-Manifolds'
M. Meyer, M. Desbrun, P. Schroder, A. H. Barr

Parameters:

curvaturetype : str = 'Mean Curvature' (or int = 0)

Possible enum values:

'Mean Curvature'

'Gaussian Curvature'

'RMS Curvature'

'ABS Curvature'

Type:: Choose the curvature value that you want transferred onto the scalar Quality.Mean (H) and Gaussian (K) curvature are computed according the technique described in the Desbrun et al. paper.
Absolute curvature is defined as |H|+|K| and RMS curvature as sqrt(4* H^2 - 2K) as explained in
Improved curvature estimationfor watershed segmentation of 3-dimensional meshes by S. Pulla, A. Razdan, G. Farin.

disk_vertex_coloring¶

MeshLab filter name: ‘Disk Vertex Coloring’

Given a Mesh M and a Pointset P, The filter project each vertex of P over M and color M according to the Euclidean distance from these projected points. Projection and coloring are done on a per vertex basis.

Parameters:

coloredmesh : int = 0

To be Colored Mesh: The mesh whose surface is colored. For each vertex of this mesh we decide the color according the below parameters.

vertexmesh : int = 0

Vertex Mesh: The mesh whose vertices are used as seed points for the color computation. These seeds point are projected onto the above mesh.

radius : float (bounded) = 0.34641 [min: 0; max: 1.1547]

Radius: the radius of the spheres centered in the VertexMesh seeds

sampleradius : bool = False

Use sample radius: Use the radius that is stored in each sample of the vertex mesh. Useful for displaing the variable disk sampling results

approximategeodetic : bool = False

Use Approximate Geodetic: Use the Approximate Geodetic Metric instead of the Euclidean distance. Approximate geodetic metric uses the normals between the two points to weight the euclidean distance.

distance_from_reference_mesh¶

MeshLab filter name: ‘Distance from Reference Mesh’

Compute the signed/unsigned (per vertex) distance between a mesh/pointcloud and a reference mesh/pointcloud. Distance is stored in vertex quality.

Parameters:

measuremesh : int = 0

Measured Mesh/PointCloud: The Mesh/Pointcloud that is measured, vertex by vertex, computing distance from the REFERENCE mesh/pointcloud.

refmesh : int = 0

Reference Mesh/PointCloud: The Mesh/Pointcloud that is used as a reference, to measure distance from.

signeddist : bool = True

Compute Signed Distance: If TRUE, the distance is signed; if FALSE, it will compute the distance absolute value.

maxdist : Percentage = 100%

Max Distance [abs]: Search is interrupted when nothing is found within this distance range [+maxDistance -maxDistance].

dodecahedron¶

MeshLab filter name: ‘Dodecahedron’

Create an Dodecahedron

duplicate_current_layer¶

MeshLab filter name: ‘Duplicate Current layer’

Create a new layer containing the same model as the current one

dust_accumulation¶

MeshLab filter name: ‘Dust Accumulation’

Simulate dust accumulation over the mesh generating a cloud of points lying on the current mesh

Parameters:

dust_dir : numpy.ndarray[numpy.float64[3]] = [0, 1, 0]

Direction: Direction of the dust source

nparticles : int = 3

max particles x face: Max Number of Dust Particles to Generate Per Face

slippiness : float = 1

s: The surface slippines(large s means less sticky)

adhesion : float = 0.2

k: Factor to model the general adhesion

draw_texture : bool = False

Draw Dust: create a new texture saved in dirt_texture.png

equalize_vertex_color¶

MeshLab filter name: ‘Equalize Vertex Color’

The filter equalizes the colors histogram. It is a kind of automatic regulation of contrast; the colors histogram is expanded to fit all the range of colors.

Parameters:

rch : bool = True

Red Channel:: Select the red channel.

gch : bool = True

Green Channel:: Select the green channel.

bch : bool = True

Blue Channel:: Select the blue channel.

If no channel is selected
filter works on Lightness.

onselected : bool = False

Only on selection: If checked, only affects selected vertices

erode_selection¶

MeshLab filter name: ‘Erode Selection’

Erode (reduce) the current set of selected faces.

estimate_radius_from_density¶

MeshLab filter name: ‘Estimate radius from density’

Estimate the local point spacing (aka radius) around each vertex using a basic estimate of the local density.

Parameters:

nbneighbors : int = 16

Number of neighbors: Number of neighbors used to estimate the local density. Larger values lead to smoother variations.

export_active_rasters_cameras_to_file¶

MeshLab filter name: ‘Export active rasters cameras to file’

Export active cameras to file, in the .out or Agisoft .xml formats

Parameters:

exportfile : str = 'Bundler .out' (or int = 0)

Possible enum values:

'Bundler .out'

'Agisoft xml'

Output format: Choose the output format, The filter enables to export the cameras to both Bundler and Agisoft Photoscan.

newname : str = 'cameras'

Export file name (the right extension will be added at the end): Name of the output file, it will be saved in the same folder as the project file

export_to_sketchfab¶

MeshLab filter name: ‘Export to Sketchfab’

Upload the current layer on Sketchfab. It requires that you have an account and that you set your private API token in the preferences of MeshLab.

Parameters:

sketchfabkeycode : str = '00000000'

Sketch Fab Code: Mandatory.

title : str = 'MeshLabModel'

Title: Mandatory.

description : str = 'A model generated with meshlab'

Description: Mandatory. A short description of the model that is uploaded.

tags : str = 'meshlab'

Tags: Mandatory. Tags must be separated by a space. Typical tags usually used by MeshLab users: scan, photogrammetry.

isprivate : bool = False

Private: This parameter can be true only for PRO account.

ispublished : bool = False

Publish: If true the model will be published immediately.

autorotate : bool = True

Auto Rotate: If true the model rotated by 90 degree on the X axis to maintain similar default orientation.

saveapisetting : bool = False

Save SketchFab Code: Saves the API SketchFab code into the MeshLab settings, allowing to load it as default value every time you run this filter.

fit_a_plane_to_selection¶

MeshLab filter name: ‘Fit a plane to selection’

Create a quad on the plane fitting the selection

Parameters:

extent : float = 1

Extent (with respect to selection): How large is the plane, with respect to the size of the selection: 1.0 means as large as the selection, 1.1 means 10% larger thena the selection

subdiv : int = 3

Plane XY subivisions: Subdivision steps of plane borders

hasuv : bool = False

UV parametrized: The created plane has an UV parametrization

orientation : str = 'quasi-Straight Fit' (or int = 0)

Possible enum values:

'quasi-Straight Fit'

'Best Fit'

'XZ Parallel'

'YZ Parallel'

'YX Parallel'

Plane orientation: Orientation:quasi-Straight Fit: The fitting plane will be oriented (as much as possible) straight with the axeses.
Best Fit: The fitting plane will be oriented and sized trying to best fit to the selected area.
-- Parallel: The fitting plane will be oriented with a side parallel with the chosen plane. WARNING: do not use if the selection is exactly parallel to a plane.

flatten_visible_layers¶

MeshLab filter name: ‘Flatten Visible Layers’

Flatten all or only the visible layers into a single new mesh.
Transformations are preserved. Existing layers can be optionally deleted

Parameters:

mergevisible : bool = True

Merge Only Visible Layers: If true, flatten only visible layers, otherwise, all layers are used

deletelayer : bool = True

Delete Layers : Delete all the layers used as source in flattening.
If all layers are visible only a single layer will remain after the invocation of this filter

mergevertices : bool = True

Merge duplicate vertices: Merge the vertices that are duplicated among different layers.

Very useful when the layers are spliced portions of a single big mesh.

alsounreferenced : bool = False

Keep unreferenced vertices: Do not discard unreferenced vertices from source layers

Necessary for point-cloud layers

fractal_displacement¶

MeshLab filter name: ‘Fractal Displacement’

Generates a fractal terrain perturbation with five different algorithms.
Some good parameter values to start with are:

-	Seed	Octaves	Lacunarity	Fractal increment	Offset	Gain
fBM	1	10	2	1.2	-	-
Standard multifractal	1	8	2	0.9	0.9	-
Heterogeneous multifractal	1	8	3	0.9	0.4	-
Hybrid multifractal	1	8	4	0.1	0.3	-
Ridged multifractal	2	8	4	0.5	0.9	2

Detailed algorithms descriptions can be found in:
Ebert, D.S., Musgrave, F.K., Peachey, D., Perlin, K., and Worley, S.
Texturing and Modeling: A Procedural Approach
Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 2002.

Hint: search a good compromise between offset and height factor parameter.

Parameters:

maxheight : Percentage = 4%

Max height:: Defines the maximum height for the perturbation.

scale : float (bounded) = 1 [min: 0; max: 10]

Scale factor:: Scales the fractal perturbation in and out. Values larger than 1 mean zoom out; values smaller than one mean zoom in.

smoothingsteps : int = 5

Normals smoothing steps:: Face normals will be smoothed to make the perturbation more homogeneous. This parameter represents the number of smoothing steps.

seed : float = 2

Seed:: By varying this seed, the terrain morphology will change.
Don't change the seed if you want to refine the current terrain morphology by changing the other parameters.

algorithm : str = 'Ridged multifractal terrain' (or int = 4)

Possible enum values:

'fBM (fractal Brownian Motion)'

'Standard multifractal'

'Heterogeneous multifractal'

'Hybrid multifractal terrain'

'Ridged multifractal terrain'

Algorithm: The algorithm with which the fractal terrain will be generated.

octaves : float (bounded) = 8 [min: 1; max: 20]

Octaves:: The number of Perlin noise frequencies that will be used to generate the terrain. Reasonable values are in range [2,9].

lacunarity : float = 4

Lacunarity:: The gap between noise frequencies. This parameter is used in conjunction with fractal increment to compute the spectral weights that contribute to the noise in each octave.

fractalincrement : float = 0.2

Fractal increment:: This parameter defines how rough the generated terrain will be. The range of reasonable values changes according to the used algorithm, however you can choose it in range [0.2, 1.5].

offset : float = 0.9

Offset:: This parameter controls the multifractality of the generated terrain. If offset is low, then the terrain will be smooth.

gain : float = 2.5

Gain:: Ignored in all the algorithms except the ridged one. This parameter defines how hard the terrain will be.

saveasquality : bool = False

Save as vertex quality: Saves the perturbation value as vertex quality.

fractal_terrain¶

MeshLab filter name: ‘Fractal Terrain’

Generates a fractal terrain perturbation with five different algorithms.
Some good parameter values to start with are:

-	Seed	Octaves	Lacunarity	Fractal increment	Offset	Gain
fBM	1	10	2	1.2	-	-
Standard multifractal	1	8	2	0.9	0.9	-
Heterogeneous multifractal	1	8	3	0.9	0.4	-
Hybrid multifractal	1	8	4	0.1	0.3	-
Ridged multifractal	2	8	4	0.5	0.9	2

Detailed algorithms descriptions can be found in:
Ebert, D.S., Musgrave, F.K., Peachey, D., Perlin, K., and Worley, S.
Texturing and Modeling: A Procedural Approach
Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 2002.

Parameters:

steps : int = 8

Subdivision steps:: Defines the detail of the generated terrain. Allowed values are in range [2,9]. Use values from 6 to 9 to obtain reasonable results.

maxheight : float (bounded) = 0.2 [min: 0; max: 1]

Max height:: Defines the maximum perturbation height as a fraction of the terrain's side.

scale : float (bounded) = 1 [min: 0; max: 10]

Scale factor:: Scales the fractal perturbation in and out. Values larger than 1 mean zoom out; values smaller than one mean zoom in.

seed : float = 2

Seed:: By varying this seed, the terrain morphology will change.
Don't change the seed if you want to refine the current terrain morphology by changing the other parameters.

algorithm : str = 'Ridged multifractal terrain' (or int = 4)

Possible enum values:

'fBM (fractal Brownian Motion)'

'Standard multifractal'

'Heterogeneous multifractal'

'Hybrid multifractal terrain'

'Ridged multifractal terrain'

Algorithm: The algorithm with which the fractal terrain will be generated.

octaves : float (bounded) = 8 [min: 1; max: 20]

Octaves:: The number of Perlin noise frequencies that will be used to generate the terrain. Reasonable values are in range [2,9].

lacunarity : float = 4

Lacunarity:: The gap between noise frequencies. This parameter is used in conjunction with fractal increment to compute the spectral weights that contribute to the noise in each octave.

fractalincrement : float = 0.5

Fractal increment:: This parameter defines how rough the generated terrain will be. The range of reasonable values changes according to the used algorithm, however you can choose it in range [0.2, 1.5].

offset : float = 0.9

Offset:: This parameter controls the multifractality of the generated terrain. If offset is low, then the terrain will be smooth.

gain : float = 2.5

Gain:: Ignored in all the algorithms except the ridged one. This parameter defines how hard the terrain will be.

saveasquality : bool = False

Save as vertex quality: Saves the perturbation value as vertex quality.

generate_scalar_harmonic_field¶

MeshLab filter name: ‘Generate Scalar Harmonic Field’

Generates a scalar harmonic field over the mesh. Input scalar values must be assigned to two vertices as Dirichlet boundary conditions. Applying the filter, a discrete Laplace operator generates the harmonic field values for all the mesh vertices, which are stored in the quality per vertex attribute of the mesh.
For more details see:Dynamic Harmonic Fields for Surface Processing by Kai Xua, Hao Zhang, Daniel Cohen-Or, Yueshan Xionga. Computers & Graphics, 2009
doi:10.1016/j.cag.2009.03.022

Parameters:

point1 : numpy.ndarray[numpy.float64[3]] = [1, 1, 1]

Point 1: A vertex on the mesh that represent one harmonic field boundary condition.

point2 : numpy.ndarray[numpy.float64[3]] = [-1, -1, -1]

Point 2: A vertex on the mesh that represent one harmonic field boundary condition.

value1 : float (bounded) = 0 [min: 0; max: 1]

value for the 1st point: Harmonic field value for the vertex.

value2 : float (bounded) = 1 [min: 0; max: 1]

value for the 2nd point: Harmonic field value for the vertex.

colorize : bool = True

Colorize: Colorize the mesh to provide an indication of the obtained harmonic field.

geometric_cylindrical_unwrapping¶

MeshLab filter name: ‘Geometric Cylindrical Unwrapping’

Unwrap the geometry of current mesh along a clylindrical equatorial projection. The cylindrical projection axis is centered on the origin and directed along the vertical Y axis.

Parameters:

startangle : float = 0

Start angle (deg): The starting angle of the unrolling process.

endangle : float = 360

End angle (deg): The ending angle of the unrolling process. Quality threshold for penalizing bad shaped faces.
The value is in the range [0..1]
0 accept any kind of face (no penalties),
0.5 penalize faces with quality < 0.5, proportionally to their shape

radius : float = 0

Projection Radius: If non zero, this parameter specifies the desired radius of the reference cylinder used for the projection. Changing this parameter affect the X horizontal scaling of the resulting mesh. If zero (default) the average distance of the mesh from the axis is chosen.

global_registration¶

MeshLab filter name: ‘Global registration’

Compute the rigid transformation aligning two 3d objects.

Parameters:

refmesh : int = 0

Reference Mesh: Reference point-cloud or mesh

targetmesh : int = 0

Target Mesh: Point-cloud or mesh to be aligned to the reference

overlap : Percentage = 50%

Overlap Ratio: Overlap ratio between the two clouds (command line option: -o)

delta : float = 0.1

Registration tolerance: Tolerance value for the congruent set exploration and LCP computation (command line option: -d)

nbsamples : int = 200

Number of samples: Number of samples used in each mesh (command line option: -n)

norm_diff : float = -1

Filter: difference of normal (degrees): Allowed difference of normals allowed between corresponding pairs of points(command line option: -a)

color_diff : float = -1

Filter: difference color: Allowed difference of colors allowed between corresponding pairs of points(command line option: -c)

max_time_seconds : int = 10000

Max. Computation time, in seconds: Stop the computation before the end of the exploration (command line option: -t)

usesuper4pcs : bool = True

Use Super4PCS: When disable, use 4PCS algorithm (command line option: -x

gpu_filter_example_¶

MeshLab filter name: ‘GPU Filter Example ‘

Small useless filter added only to show how to work with a gl render context inside a filter.

Parameters:

imagebackgroundcolor : Color = [50; 50; 50; 255]

Image Background Color: The color used as image background.

imagewidth : int = 512

Image Width: The width in pixels of the produced image.

imageheight : int = 512

Image Height: The height in pixels of the produced image.

imagefilename : str = 'gpu_generated_image.png'

Base Image File Name: The file name used to save the image.

grid_generator¶

MeshLab filter name: ‘Grid Generator’

Generate a new 2D Grid mesh with number of vertices on X and Y axis specified by user with absolute length/height.
It's possible to center Grid on origin.

Parameters:

numvertx : int = 10

num vertices on x: number of vertices on x. it must be positive

numverty : int = 10

num vertices on y: number of vertices on y. it must be positive

absscalex : float = 0.3

x scale: absolute scale on x (float)

absscaley : float = 0.3

y scale: absolute scale on y (float)

center : bool = False

centered on origin: center grid generated by filter on origin.
Grid is first generated and than moved into origin (using muparser lib to perform fast calc on every vertex)

hausdorff_distance¶

MeshLab filter name: ‘Hausdorff Distance’

Compute the Hausdorff Distance between two layers, sampling one of the two and finding for each sample the closest point over the other mesh.

Parameters:

sampledmesh : int = 0

Sampled Mesh: The mesh whose surface is sampled. For each sample we search the closest point on the Target Mesh.

targetmesh : int = 0

Target Mesh: The mesh that is sampled for the comparison.

savesample : bool = False

Save Samples: Save the position and distance of all the used samples on both the two surfaces, creating two new layers with two point clouds representing the used samples.

samplevert : bool = True

Sample Vertices: For the search of maxima it is useful to sample vertices and edges of the mesh with a greater care. It is quite probably the the farthest points falls along edges or on mesh vertices, and with uniform montecarlo sampling approachesthe probability of taking a sample over a vertex or an edge is theoretically null.
On the other hand this kind of sampling could make the overall sampling distribution slightly biased and slightly affects the cumulative results.

sampleedge : bool = False

Sample Edges: See the above comment.

samplefauxedge : bool = False

Sample FauxEdge: See the above comment.

sampleface : bool = False

Sample Faces: See the above comment.

samplenum : int = 0

Number of samples: The desired number of samples. It can be smaller or larger than the mesh size, and according to the chosen sampling strategy it will try to adapt.

maxdist : Percentage = 50%

Max Distance: Sample points for which we do not find anything within this distance are rejected and not considered neither for averaging nor for max.

hc_laplacian_smooth¶

MeshLab filter name: ‘HC Laplacian Smooth’

HC Laplacian Smoothing. Extended version of Laplacian Smoothing based on the article:
Improved Laplacian Smoothing of Noisy Surface Meshes by Vollmer, Mencl and Müller. EUROGRAPHICS Volume 18 (1999), Number 3, 131-138.
doi:10.1111/1467-8659.00334

icosahedron¶

MeshLab filter name: ‘Icosahedron’

Create an Icosahedron

image_alignment_mutual_information¶

MeshLab filter name: ‘Image alignment: Mutual Information’

Register an image on a 3D model using Mutual Information. This filter is an implementation of Corsini et al. 'Image-to-geometry registration: a mutual information method exploiting illumination-related geometric properties', 2009, Get link

Parameters:

rendering_mode : str = 'Combined' (or int = 0)

Possible enum values:

'Combined'

'Normal map'

'Color per vertex'

'Specular'

'Silhouette'

'Specular combined'

Rendering mode:: Rendering modes

shot : Shotf [still unsupported] = None

Starting shot: If the point of view has been set by hand, it must be retrieved from current trackball

estimate_focal : bool = False

Estimate focal length: Estimate focal length: if not checked, only extrinsic parameters are estimated

fine : bool = True

Fine Alignment: Fine alignment: the perturbations applied to reach the alignment are smaller

numofiterations : int = 100

Max iterations: Maximum number of iterations

tolerance : float = 0.1

Tolerance: Threshold to stop convergence

expectedvariance : float = 2

Expected Variance: Expected Variance

backgroundweight : int = 2

Background Weight: Weight of background pixels (1, as all the other pixels; 2, one half of the other pixels etc etc)

image_registration_global_refinement_using_mutual_information¶

MeshLab filter name: ‘Image Registration: Global refinement using Mutual Information’

Calculate a global refinement of image registration, in order to obtain a better alignment of fine detail. It will refine only the shots associated to the active rasters, the non-active ones will be used but not refined. This filter is an implementation of Dellepiane et al. 'Global refinement of image-to-geometry registration for color projection', 2013, and it was used in Corsini et al 'Fully Automatic Registration of Image Sets on Approximate Geometry', 2013. Please cite!

Parameters:

renderingmode : str = 'Combined' (or int = 0)

Possible enum values:

'Combined'

'Normal map'

'Color per vertex'

'Specular'

'Silhouette'

'Specular combined'

Rendering mode:: Rendering modes

max_number_of_refinement_steps : int = 5

Maximum number of minimizations step: Maximum number of minimizations step on the global graph

threshold_for_refinement_convergence : float = 1.2

Threshold for refinement convergence (in pixels): The threshold (average quadratic variation in the projection on image plane of some samples of the mesh before and after each step of refinement) that stops the refinement

pre_alignment : bool = False

Pre-alignment step: Pre-alignment step

estimate_focal : bool = True

Estimate focal length: Estimate focal length

fine : bool = True

Fine Alignment: Fine alignment

implicit_surface¶

MeshLab filter name: ‘Implicit Surface’

Generate a new mesh that corresponds to the 0 valued isosurface defined by the scalar field generated by the given expression

Parameters:

voxelsize : float = 0.05

Size of Voxel: Size of the voxel that is used by for the grid where the field is sampled. Smaller this value, higher precision, but higher processing times.

minx : float = -1

Min X: Range where the field is sampled

miny : float = -1

Min Y: Range where the field is sampled

minz : float = -1

Min Z: Range where the field is sampled

maxx : float = 1

Max X: Range where the field is sampled

maxy : float = 1

Max Y: Range where the field is sampled

maxz : float = 1

Max Z: Range where the field is sampled

expr : str = 'x*x+y*y+z*z-0.5'

Function =: This expression is evaluated for each voxel of the grid. The surface passing through the zero valued points of this field is then extracted using marching cube.

import_cameras_for_active_rasters_from_file¶

MeshLab filter name: ‘Import cameras for active rasters from file’

Import cameras for active rasters from .out or Agisoft .xml formats

Parameters:

importfile : str = ''

Choose the camera file to be imported: It's possible to import both Bundler .out and Agisoft .xml files. In both cases, distortion parameters won't be imported. In the case of Agisoft, it's necessary to undistort the images before exporting the xml file

invert_faces_orientation¶

MeshLab filter name: ‘Invert Faces Orientation’

Invert faces orientation, flipping the normals of the mesh.
If requested, it tries to guess the right orientation; mainly it decide to flip all the faces if the minimum/maximum vertices have not outward point normals for a few directions.
Works well for single component watertight objects.

Parameters:

forceflip : bool = True

Force Flip: If selected, the normals will always be flipped; otherwise, the filter tries to set them outside

onlyselected : bool = False

Flip only selected faces: If selected, only selected faces will be affected

invert_selection¶

MeshLab filter name: ‘Invert Selection’

Invert the current set of selected faces/vertices.

Parameters:

invfaces : bool = False

Invert Faces: If true the filter will invert the set of selected faces.

invverts : bool = False

Invert Vertices: If true the filter will invert the set of selected vertices.

iso_parametrization_build_atlased_mesh¶

MeshLab filter name: ‘Iso Parametrization Build Atlased Mesh’

The filter build a new mesh with a standard atlased per wedge texture. The atlas is simply done by exploiting the low distortion, coarse, regular, mesh of the abstract domain
For more details see:
N. Pietroni, M. Tarini and P. Cignoni,
'Almost isometric mesh parameterization through abstract domains'
IEEE Transaction of Visualization and Computer Graphics, 2010

Parameters:

bordersize : float (bounded) = 0.1 [min: 0.01; max: 0.5]

BorderSize ratio: This parameter controls the amount of space that must be left between each diamond when building the atlas.It directly affects how many triangle are split during this conversion.
In abstract parametrization mesh triangles can naturally cross the triangles of the abstract domain, so when converting to a standard parametrization we must cut all the triangles that protrudes outside each diamond more than the specified threshold.The unit of the threshold is in percentage of the size of the diamond,The bigger the threshold the less triangles are split, but the more UV space is used (wasted).

iso_parametrization_main¶

MeshLab filter name: ‘Iso Parametrization: Main’

The filter builds the abstract domain mesh representing the Isoparameterization of a watertight two-manifold triangular mesh.
This abstract mesh can be used to uniformly remesh the input mesh, or to build a atlased texture parametrization. Abstract Mesh can be also loaded and saved.
In short this filter build a very coarse almost regular triangulation such that original mesh can be reprojected from this abstract mesh with minimal distortion.
For more details see:
N. Pietroni, M. Tarini and P. Cignoni,
'Almost isometric mesh parameterization through abstract domains'
IEEE Transaction of Visualization and Computer Graphics, 2010

Parameters:

targetabstractminfacenum : int = 150

AM Min Size: This number and the following one indicate the range face number of the abstract mesh that is used for the parametrization process.
The algorithm will choose the best abstract mesh with the number of triangles within the specified interval.
If the mesh has a very simple structure this range can be very low and strict;for a roughly spherical object if you can specify a range of [8,8] faces you get a octahedral abstract mesh, e.g. a geometry image.
Large numbers (greater than 400) are usually not of practical use.

targetabstractmaxfacenum : int = 200

AM Max Size: Please notice that a large interval requires huge amount of memory to be allocated, in order save the intermediate results.
An interval of 50 should be fine.

stopcriteria : str = 'Area + Angle' (or int = 1)

Possible enum values:

'Best Heuristic'

'Area + Angle'

'Regularity'

'L2'

Optimization Criteria: Choose a metric to stop the parametrization within the interval
1: Best Heuristic : stop considering both isometry and number of faces of base domain
2: Area + Angle : stop at minimum area and angle distorsion
3: Regularity : stop at minimum number of irregular vertices
4: L2 : stop at minimum OneWay L2 Stretch Eff

convergencespeed : int = 1

Convergence Precision: This parameter controls the convergence speed/precision of the optimization of the texture coordinates. Larger the number slower the processing and ,eventually, slightly better results

doublestep : bool = True

Double Step: Use this bool to divide the parameterization in 2 steps. Double step makes the overall process faster and robust.
Consider to disable this bool in case the object has topologycal noise or small handles.

absloadname : str = ''

Load AM: The filename of the abstract mesh that has to be loaded. If empty, the abstract mesh will be computed according to the above parameters (suggested extension '.abs').

abssavename : str = ''

Save AM: The filename where the computed abstract mesh will be saved. If empty, nothing will be done.

iso_parametrization_remeshing¶

MeshLab filter name: ‘Iso Parametrization Remeshing’

Uniform Remeshing based on Isoparameterization, each triangle of the domain is recursively subdivided.
For more details see:
N. Pietroni, M. Tarini and P. Cignoni,
'Almost isometric mesh parameterization through abstract domains'
IEEE Transaction of Visualization and Computer Graphics, 2010

Parameters:

samplingrate : int = 10

Sampling Rate: This specify the sampling rate for remeshing. Must be greater than 2

iso_parametrization_transfer_between_meshes¶

MeshLab filter name: ‘Iso Parametrization transfer between meshes’

Transfer the Isoparametrization between two meshes, the two meshes must be reasonably similar and well aligned. It is useful to transfer back an isoparam onto the original mesh after having computed it on a dummy, clean watertight model.
For more details see:
N. Pietroni, M. Tarini and P. Cignoni,
'Almost isometric mesh parameterization through abstract domains'
IEEE Transaction of Visualization and Computer Graphics, 2010

Parameters:

sourcemesh : int = 0

Source Mesh: The mesh already having an Isoparameterization

targetmesh : int = 0

Target Mesh: The mesh to be Isoparameterized

laplacian_smooth¶

MeshLab filter name: ‘Laplacian Smooth’

Laplacian smooth. Average each vertex position with weighted positions of neighbour vertices.
Laplacian Mesh Processing by Olga Sorkine. EUROGRAPHICS 2005
doi:10.2312/egst.20051044

Parameters:

stepsmoothnum : int = 3

Smoothing steps: The number of times that the whole algorithm (normal smoothing + vertex fitting) is iterated.

boundary : bool = True

1D Boundary Smoothing: Smooth boundary edges only by themselves (e.g. the polyline forming the boundary of the mesh is independently smoothed). This can reduce the shrinking on the border but can have strange effects on very small boundaries.

cotangentweight : bool = True

Cotangent weighting: Use cotangent weighting scheme for the averaging of the position. Otherwise the simpler umbrella scheme (1 if the edge is present) is used.

selected : bool = False

Affect only selection: If checked the filter is performed only on the selected area

laplacian_smooth_surface_preserving¶

MeshLab filter name: ‘Laplacian Smooth (surface preserving)’

Laplacian smooth with limited surface modification: move each vertex in the average position of neighbors vertices, only if the new position still (almost) lies on original surface

Parameters:

selection : bool = False

Update selection: Apply laplacian smooth on selected faces only

angledeg : float = 0.5

Max Normal Dev (deg): maximum mean normal angle displacement (degrees) from old to new faces

iterations : int = 1

Iterations: number of laplacian smooth iterations in every run

marching_cubes_apss¶

MeshLab filter name: ‘Marching Cubes (APSS)’

Extract the iso-surface (as a mesh) of a MLS surface defined by the current point set (or mesh)using the marching cubes algorithm. The coarse extraction is followed by an accurate projectionstep onto the MLS, and an extra zero removal procedure.

This is the algebraic point set surfaces (APSS) variant which is based on the local fitting of algebraic spheres. It requires points equipped with oriented normals.
For all the details about APSS see:
Guennebaud and Gross, 'Algebraic Point Set Surfaces', Siggraph 2007, and
Guennebaud et al., 'Dynamic Sampling and Rendering of APSS', Eurographics 2008

Parameters:

filterscale : float = 2

MLS - Filter scale: Scale of the spatial low pass filter.
It is relative to the radius (local point spacing) of the vertices.

projectionaccuracy : float = 0.0001

Projection - Accuracy (adv): Threshold value used to stop the projections.
This value is scaled by the mean point spacing to get the actual threshold.

maxprojectioniters : int = 15

Projection - Max iterations (adv): Max number of iterations for the projection.

sphericalparameter : float = 1

MLS - Spherical parameter: Control the curvature of the fitted spheres: 0 is equivalent to a pure plane fit,1 to a pure spherical fit, values between 0 and 1 gives intermediate results,while other real values might give interesting results, but take care with extremesettings !

accuratenormal : bool = True

Accurate normals: If checked, use the accurate MLS gradient instead of the local approximationto compute the normals.

resolution : int = 200

Grid Resolution: The resolution of the grid on which we run the marching cubes.This marching cube is memory friendly, so you can safely set large values up to 1000 or even more.

marching_cubes_rimls¶

MeshLab filter name: ‘Marching Cubes (RIMLS)’

Extract the iso-surface (as a mesh) of a MLS surface defined by the current point set (or mesh)using the marching cubes algorithm. The coarse extraction is followed by an accurate projectionstep onto the MLS, and an extra zero removal procedure.

This is the Robust Implicit MLS (RIMLS) variant which is an extension of Implicit MLS preserving sharp features using non linear regression. For more details see:
Oztireli, Guennebaud and Gross, 'Feature Preserving Point Set Surfaces based on Non-Linear Kernel Regression' Eurographics 2009.

Parameters:

filterscale : float = 2

MLS - Filter scale: Scale of the spatial low pass filter.
It is relative to the radius (local point spacing) of the vertices.

projectionaccuracy : float = 0.0001

Projection - Accuracy (adv): Threshold value used to stop the projections.
This value is scaled by the mean point spacing to get the actual threshold.

maxprojectioniters : int = 15

Projection - Max iterations (adv): Max number of iterations for the projection.

sigman : float = 0.75

MLS - Sharpness: Width of the filter used by the normal refitting weight.This weight function is a Gaussian on the distance between two unit vectors:the current gradient and the input normal. Therefore, typical value range between 0.5 (sharp) to 2 (smooth).

maxrefittingiters : int = 3

MLS - Max fitting iterations: Max number of fitting iterations. (0 or 1 is equivalent to the standard IMLS)

resolution : int = 200

Grid Resolution: The resolution of the grid on which we run the marching cubes.This marching cube is memory friendly, so you can safely set large values up to 1000 or even more.

matrix_freeze_current_matrix¶

MeshLab filter name: ‘Matrix: Freeze Current Matrix’

Freeze the current transformation matrix into the coordinates of the vertices of the mesh (and set this matrix to the identity). In other words it applies in a definetive way the current matrix to the vertex coordinates.

Parameters:

alllayers : bool = False

Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

matrix_invert_current_matrix¶

MeshLab filter name: ‘Matrix: Invert Current Matrix’

Invert the current transformation matrix. The current transformation is reversed, becoming its opposite.

Parameters:

freeze : bool = True

Freeze Matrix: The transformation is explicitly applied, and the vertex coordinates are actually changed

alllayers : bool = False

Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

matrix_reset_current_matrix¶

MeshLab filter name: ‘Matrix: Reset Current Matrix’

Set the current transformation matrix to the Identity.

Parameters:

alllayers : bool = False

Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

matrix_set_copy_transformation¶

MeshLab filter name: ‘Matrix: Set/Copy Transformation’

Set the current transformation matrix by filling it, or copying from another layer.

Parameters:

transformmatrix : numpy.ndarray[numpy.float64[4, 4]] = [[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, 1, 0],[0, 0, 0, 1]]

:

compose : bool = False

Compose with current: If selected, the new matrix will be composed with the current one (matrix=new*old)

freeze : bool = True

Freeze Matrix: The transformation is explicitly applied, and the vertex coordinates are actually changed

alllayers : bool = False

Apply to all visible Layers: If selected, the filter will be applied to all visible mesh layers

matrix_set_from_translation_rotation_scale¶

MeshLab filter name: ‘Matrix: Set from translation/rotation/scale’

Set the current transformation matrix starting from parameters: [XYZ] translation, [XYZ] Euler angles rotation and [XYZ] scaling.

Parameters:

translationx : float = 0

X Translation: Translation factor on X axis

translationy : float = 0

Y Translation: Translation factor on Y axis

translationz : float = 0

Z Translation: Translation factor on Z axis

rotationx : float = 0

X Rotation: Rotation angle on X axis

rotationy : float = 0

Y Rotation: Rotation angle on Y axis

rotationz : float = 0

Z Rotation: Rotation angle on Z axis

scalex : float = 1

X Scale: Scaling factor on X axis

scaley : float = 1

Y Scale: Scaling factor on Y axis

scalez : float = 1

Z Scale: Scaling factor on Z axis

compose : bool = False

Compose with current: If selected, the new matrix will be composed with the current one (matrix=new*old)

freeze : bool = True

Freeze Matrix: The transformation is explicitly applied, and the vertex coordinates are actually changed

alllayers : bool = False

Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

merge_close_vertices¶

MeshLab filter name: ‘Merge Close Vertices’

Merge together all the vertices that are nearer than the specified threshold. Like a unify duplicated vertices but with some tolerance.

Parameters:

threshold : Percentage = 1%

Merging distance: All the vertices that closer than this threshold are merged together. Use very small values, default values is 1/10000 of bounding box diagonal.

merge_wedge_texture_coord¶

MeshLab filter name: ‘Merge Wedge Texture Coord’

Merge together per-wedge texture coords that are very close. Used to correct apparent texture seams that can arise from numerical approximations when saving in ascii formats.

Parameters:

mergethr : float = 0.0001

Merging Threshold: All the per-wedge texture coords that are on the same vertex and are distant less then the given threshold are merged together. It can be used to remove the fake texture seams that arise from error. Distance is in texture space (the default, 1e-4, corresponds to one texel on a 10kx10x texture)

mesh_element_sampling¶

MeshLab filter name: ‘Mesh Element Sampling’

Create a new layer populated with a point sampling of the current mesh; at most one sample for each element of the mesh is created. Samples are taking in a uniform way, one for each element (vertex/edge/face); all the elements have the same probability of being chosen.

Parameters:

sampling : str = 'Vertex' (or int = 0)

Possible enum values:

'Vertex'

'Edge'

'Face'

Element to sample:: Choose what mesh element has to be used for the subsampling. At most one point sample will be added for each one of the chosen elements

samplenum : int = 0

Number of samples: The desired number of elements that must be chosen. Being a subsampling of the original elements if this number should not be larger than the number of elements of the original mesh.

mls_projection_apss¶

MeshLab filter name: ‘MLS projection (APSS)’

Project a mesh (or a point set) onto the MLS surface defined by itself or another point set.

This is the algebraic point set surfaces (APSS) variant which is based on the local fitting of algebraic spheres. It requires points equipped with oriented normals.
For all the details about APSS see:
Guennebaud and Gross, 'Algebraic Point Set Surfaces', Siggraph 2007, and
Guennebaud et al., 'Dynamic Sampling and Rendering of APSS', Eurographics 2008

Parameters:

controlmesh : int = 0

Point set: The point set (or mesh) which defines the MLS surface.

proxymesh : int = 0

Proxy Mesh: The mesh that will be projected/resampled onto the MLS surface.

selectiononly : bool = False

Selection only: If checked, only selected vertices will be projected.

filterscale : float = 2

MLS - Filter scale: Scale of the spatial low pass filter.
It is relative to the radius (local point spacing) of the vertices.

projectionaccuracy : float = 0.0001

Projection - Accuracy (adv): Threshold value used to stop the projections.
This value is scaled by the mean point spacing to get the actual threshold.

maxprojectioniters : int = 15

Projection - Max iterations (adv): Max number of iterations for the projection.

sphericalparameter : float = 1

MLS - Spherical parameter: Control the curvature of the fitted spheres: 0 is equivalent to a pure plane fit,1 to a pure spherical fit, values between 0 and 1 gives intermediate results,while other real values might give interesting results, but take care with extremesettings !

accuratenormal : bool = True

Accurate normals: If checked, use the accurate MLS gradient instead of the local approximationto compute the normals.

maxsubdivisions : int = 0

Refinement - Max subdivisions: Max number of subdivisions.

thangleindegree : float = 2

Refinement - Crease angle (degree): Threshold angle between two faces controlling the refinement.

mls_projection_rimls¶

MeshLab filter name: ‘MLS projection (RIMLS)’

Project a mesh (or a point set) onto the MLS surface defined by itself or another point set.

This is the Robust Implicit MLS (RIMLS) variant which is an extension of Implicit MLS preserving sharp features using non linear regression. For more details see:
Oztireli, Guennebaud and Gross, 'Feature Preserving Point Set Surfaces based on Non-Linear Kernel Regression' Eurographics 2009.

Parameters:

controlmesh : int = 0

Point set: The point set (or mesh) which defines the MLS surface.

proxymesh : int = 0

Proxy Mesh: The mesh that will be projected/resampled onto the MLS surface.

selectiononly : bool = False

Selection only: If checked, only selected vertices will be projected.

filterscale : float = 2

MLS - Filter scale: Scale of the spatial low pass filter.
It is relative to the radius (local point spacing) of the vertices.

projectionaccuracy : float = 0.0001

Projection - Accuracy (adv): Threshold value used to stop the projections.
This value is scaled by the mean point spacing to get the actual threshold.

maxprojectioniters : int = 15

Projection - Max iterations (adv): Max number of iterations for the projection.

sigman : float = 0.75

MLS - Sharpness: Width of the filter used by the normal refitting weight.This weight function is a Gaussian on the distance between two unit vectors:the current gradient and the input normal. Therefore, typical value range between 0.5 (sharp) to 2 (smooth).

maxrefittingiters : int = 3

MLS - Max fitting iterations: Max number of fitting iterations. (0 or 1 is equivalent to the standard IMLS)

maxsubdivisions : int = 0

Refinement - Max subdivisions: Max number of subdivisions.

thangleindegree : float = 2

Refinement - Crease angle (degree): Threshold angle between two faces controlling the refinement.

montecarlo_sampling¶

MeshLab filter name: ‘Montecarlo Sampling’

Create a new layer populated with a point sampling of the current mesh; samples are generated in a randomly uniform way, or with a distribution biased by the per-vertex quality values of the mesh.

Parameters:

samplenum : int = 0

Number of samples: The desired number of samples. It can be smaller or larger than the mesh size, and according to the chosen sampling strategy it will try to adapt.

weighted : bool = False

Quality Weighted Sampling: Use per vertex quality to drive the vertex sampling. The number of samples falling in each face is proportional to the face area multiplied by the average quality of the face vertices.

perfacenormal : bool = False

Per-Face Normal: If true for each sample we take the normal of the sampled face, otherwise the normal interpolated from the vertex normals.

radiusvariance : float = 1

Radius Variance: The radius of the disk is allowed to vary between r/var and r*var. If this parameter is 1 the sampling is the same of the Poisson Disk Sampling

exactnum : bool = True

Exact Sample Number: If the required total number of samples is not a strict exact requirement we can exploit a different algorithmbased on the choice of the number of samples inside each triangle by a random Poisson-distributed number with mean equal to the expected number of samples times the area of the triangle over the surface of the whole mesh.

edgesampling : bool = False

Sample CreaseEdge Only: Restrict the sampling process to the crease edges only. Useful to sample in a more accurate way the feature edges of a mechanical mesh.

move_selected_faces_to_another_layer¶

MeshLab filter name: ‘Move selected faces to another layer’

Selected faces are moved (or duplicated) in a new layer. Warning! per-vertex and per-face user defined attributes will not be transferred.

Parameters:

deleteoriginal : bool = True

Delete original selection: Deletes the original selected faces/vertices, thus splitting the mesh among layers.

if false, the selected faces/vertices are duplicated in the new layer

move_selected_vertices_to_another_layer¶

MeshLab filter name: ‘Move selected vertices to another layer’

Selected vertices are moved (or duplicated) in a new layer. Warning! per-vertex user defined attributes will not be transferred.

Parameters:

deleteoriginal : bool = True

Delete original selection: Deletes the original selected faces/vertices, thus splitting the mesh among layers.

if false, the selected faces/vertices are duplicated in the new layer

noisy_isosurface¶

MeshLab filter name: ‘Noisy Isosurface’

Create a isosurface perturbed by a noisy isosurface.

Parameters:

resolution : int = 64

Grid Resolution: Resolution of the side of the cubic grid used for the volume creation

normalize_face_normals¶

MeshLab filter name: ‘Normalize Face Normals’

Normalize Face Normal Lengths to unit vectors.

normalize_vertex_normals¶

MeshLab filter name: ‘Normalize Vertex Normals’

Normalize Vertex Normal Lengths to unit vectors.

octahedron¶

MeshLab filter name: ‘Octahedron’

Create an Octahedron

parameterization__texturing_from_registered_rasters¶

MeshLab filter name: ‘Parameterization + texturing from registered rasters’

The mesh is parameterized and textured by creating some patches that correspond to projection of portions of surfaces onto the set of registered rasters.

Parameters:

texturesize : int = 1024

Texture size: Specifies the dimension of the generated texture

texturename : str = 'texture.png'

Texture name: Specifies the name of the file into which the texture image will be saved

colorcorrection : bool = True

Color correction: If true, the final texture is corrected so as to ensure seamless transitions

colorcorrectionfiltersize : int = 1

Color correction filter: It is the radius (in pixel) of the kernel that is used to compute the difference between corresponding texels in different rasters. Default is 1 that generate a 3x3 kernel. Highest values increase the robustness of the color correction process in the case of strong image-to-geometry misalignments

usedistanceweight : bool = True

Use distance weight: Includes a weight accounting for the distance to the camera during the computation of reference images

useimgborderweight : bool = True

Use image border weight: Includes a weight accounting for the distance to the image border during the computation of reference images

usealphaweight : bool = False

Use image alpha weight: If true, alpha channel of the image is used as additional weight. In this way it is possible to mask-out parts of the images that should not be projected on the mesh. Please note this is not a transparency effect, but just influences the weigthing between different images

cleanisolatedtriangles : bool = True

Clean isolated triangles: Remove all patches compound of a single triangle by aggregating them to adjacent patches

stretchingallowed : bool = False

UV stretching: If true, texture coordinates are stretched so as to cover the full interval [0,1] for both directions

texturegutter : int = 4

Texture gutter: Extra boundary to add to each patch before packing in texture space (in pixels)

parameterization_from_registered_rasters¶

MeshLab filter name: ‘Parameterization from registered rasters’

The mesh is parameterized by creating some patches that correspond to projection of portions of surfaces onto the set of registered rasters.

Parameters:

usedistanceweight : bool = True

Use distance weight: Includes a weight accounting for the distance to the camera during the computation of reference images

useimgborderweight : bool = True

Use image border weight: Includes a weight accounting for the distance to the image border during the computation of reference images

usealphaweight : bool = False

Use image alpha weight: If true, alpha channel of the image is used as additional weight. In this way it is possible to mask-out parts of the images that should not be projected on the mesh. Please note this is not a transparency effect, but just influences the weigthing between different images

cleanisolatedtriangles : bool = True

Clean isolated triangles: Remove all patches compound of a single triangle by aggregating them to adjacent patches

stretchingallowed : bool = False

UV stretching: If true, texture coordinates are stretched so as to cover the full interval [0,1] for both directions

texturegutter : int = 4

Texture gutter: Extra boundary to add to each patch before packing in texture space (in pixels)

parametrization_flat_plane¶

MeshLab filter name: ‘Parametrization: Flat Plane’

Builds a trivial flat-plane parametrization.

Parameters:

projectionplane : str = 'XY' (or int = 0)

Possible enum values:

'XY'

'XZ'

'YZ'

Projection plane: Choose the projection plane

aspectratio : bool = False

Preserve Ratio: If checked the resulting parametrization will preserve the original apsect ratio of the model otherwise it will fill up the whole 0..1 uv space

sidegutter : float = 0

Side Gutter: Leave an empty space around the parametrization area of the specified size (in texture space); accepted range [0.0 - 0.5].

parametrization_trivial_per_triangle¶

MeshLab filter name: ‘Parametrization: Trivial Per-Triangle’

Builds a trivial triangle-by-triangle parametrization.
Two methods are provided, the first maps maps all triangles into equal sized triangles, while the second one adapt the size of the triangles in texture space to their original size.

Parameters:

sidedim : int = 0

Quads per line: Indicates how many triangles have to be put on each line (every quad contains two triangles)
Leave 0 for automatic calculation

textdim : int = 1024

Texture Dimension (px): Gives an indication on how big the texture is

border : int = 2

Inter-Triangle border (px): Specifies how many pixels to be left between triangles in parametrization domain

method : str = 'Space-optimizing' (or int = 1)

Possible enum values:

'Basic'

'Space-optimizing'

Method: Choose space optimizing to map smaller faces into smaller triangles in parametrizazion domain

parametrization_voronoi_atlas¶

MeshLab filter name: ‘Parametrization: Voronoi Atlas’

Build an atlased parametrization based on a geodesic voronoi partitioning of the surface and parametrizing each region using Harmonic Mapping. For the parametrization of the disk like voronoi regions the used method is:
Ulrich Pinkall, Konrad Polthier
Computing Discrete Minimal Surfaces and Their Conjugates
Experimental Mathematics, Vol 2 (1), 1993
.

Parameters:

regionnum : int = 10

Approx. Region Num: An estimation of the number of regions that must be generated. Smaller regions could lead to parametrizations with smaller distortion.

overlapflag : bool = False

Overlap: If checked the resulting parametrization will be composed by overlapping regions, e.g. the resulting mesh will have duplicated faces: each region will have a ring of ovelapping duplicate faces that will ensure that border regions will be parametrized in the atlas twice. This is quite useful for building mipmap robust atlases

per_face_color_function¶

MeshLab filter name: ‘Per Face Color Function’

Color function using muparser lib to generate new RGBA color for every face
Red, Green, Blue and Alpha channels may be defined specifying a function in their respective fields.
It's possible to use the following per-face variables, or variables associated to the three vertex of every face:
x0,y0,z0 for the first vertex position, x1,y1,z1 for the second vertex position, x2,y2,z2 for the third vertex position, nx0,ny0,nz0 nx1,ny1,nz1 nx2,ny2,nz2 for vertex normals, r0,g0,b0,a0 r1,g1,b1,a1 r2,g2,b2,a2 for vertex colors, q0,q1,q2 for vertex quality, wtu0,wtv0 wtu1,wtv1 wtu2,wtv2 for per-wedge texture coords, ti for face texture index, vsel0,vsel1,vsel2 for vertex selection (1 yes, 0 no) fr,fg,fb,fa for face color, fq for face quality, fnx,fny,fnz for face normal, fsel face selection (1 yes, 0 no).

Parameters:

r : str = '255'

func r = : function to generate Red component. Expected Range 0-255

g : str = '0'

func g = : function to generate Green component. Expected Range 0-255

b : str = '255'

func b = : function to generate Blue component. Expected Range 0-255

a : str = '255'

func alpha = : function to generate Alpha component. Expected Range 0-255

onselected : bool = False

only on selection: if checked, only affects selected faces

per_face_quality_according_to_triangle_shape_and_aspect_ratio¶

MeshLab filter name: ‘Per Face Quality according to Triangle shape and aspect ratio’

Compute a quality and colorize faces depending on triangle shape:

area/max side of triangle
ratio inradius/circumradius (radii of incircle and circumcircle)
Mean ratio of triangle = area/(a*a + b*b + c*c)
Area
Texture Angle Distortion. Difference between angle in 3D space and texture space
Texture Area Distortion. Difference between area in 3D space and texture space
Polygonal Planarity (max distance to support plane)
Polygonal Planarity (relative distance to support plane)

Parameters:

metric : str = 'area/max side' (or int = 0)

Possible enum values:

'area/max side'

'inradius/circumradius'

'Mean ratio'

'Area'

'Texture Angle Distortion'

'Texture Area Distortion'

'Polygonal planarity (max)'

'Polygonal planarity (relative)'

Metric:: Choose a metric to compute triangle quality.

per_face_quality_function¶

MeshLab filter name: ‘Per Face Quality Function’

Quality function using muparser to generate new Quality for every face
Insert three function each one for quality of the three vertex of a face
It's possible to use the following per-face variables, or variables associated to the three vertex of every face:
x0,y0,z0 for the first vertex position, x1,y1,z1 for the second vertex position, x2,y2,z2 for the third vertex position, nx0,ny0,nz0 nx1,ny1,nz1 nx2,ny2,nz2 for vertex normals, r0,g0,b0,a0 r1,g1,b1,a1 r2,g2,b2,a2 for vertex colors, q0,q1,q2 for vertex quality, wtu0,wtv0 wtu1,wtv1 wtu2,wtv2 for per-wedge texture coords, ti for face texture index, vsel0,vsel1,vsel2 for vertex selection (1 yes, 0 no) fr,fg,fb,fa for face color, fq for face quality, fnx,fny,fnz for face normal, fsel face selection (1 yes, 0 no).

Parameters:

q : str = 'x0+y0+z0'

func q0 = : function to generate new Quality foreach face

normalize : bool = False

normalize: if checked normalize all quality values in range [0..1]

map : bool = False

map into color: if checked map quality generated values into per-vertex color

onselected : bool = False

only on selection: if checked, only affects selected faces

per_face_quality_histogram¶

MeshLab filter name: ‘Per Face Quality Histogram’

Compute an histogram of the values of the per-face quality.

Parameters:

histmin : float = inf

Hist Min: The faces are displaced of a vector whose norm is bounded by this value

histmax : float = -inf

Hist Max: The faces are displaced of a vector whose norm is bounded by this value

areaweighted : bool = False

Area Weighted: If false, the histogram will report the number of faces with quality values falling in each bin of the histogram. If true each bin of the histogram will report the approximate area of the mesh with that range of values.

binnum : int = 20

Bin number: The number of bins of the histogram. E.g. the number of intervals in which the min..max range is subdivided into.

per_face_quality_stat¶

MeshLab filter name: ‘Per Face Quality Stat’

Compute some aggregate statistics over the per vertex quality, like Min, Max, Average, StdDev and Variance.

per_vertex_color_function¶

MeshLab filter name: ‘Per Vertex Color Function’

Color function using muparser lib to generate new RGBA color for every vertex
Red, Green, Blue and Alpha channels may be defined specifying a function in their respective fields.
It's possible to use the following per-vertex variables in the expression:
x,y,z (position), nx,ny,nz (normal), r,g,b,a (color), q (quality), rad (radius), vi (vertex index), vtu,vtv,ti (texture coords and texture index), vsel (is the vertex selected? 1 yes, 0 no) and all custom vertex attributes already defined by user.

Parameters:

x : str = '255'

func r = : function to generate Red component. Expected Range 0-255

y : str = '255'

func g = : function to generate Green component. Expected Range 0-255

z : str = '0'

func b = : function to generate Blue component. Expected Range 0-255

a : str = '255'

func alpha = : function to generate Alpha component. Expected Range 0-255

onselected : bool = False

only on selection: if checked, only affects selected vertices

per_vertex_geometric_function¶

MeshLab filter name: ‘Per Vertex Geometric Function’

Geometric function using muparser lib to generate new Coord
You can change x,y,z for every vertex according to the function specified.
It's possible to use the following per-vertex variables in the expression:
x,y,z (position), nx,ny,nz (normal), r,g,b,a (color), q (quality), rad (radius), vi (vertex index), vtu,vtv,ti (texture coords and texture index), vsel (is the vertex selected? 1 yes, 0 no) and all custom vertex attributes already defined by user.

Parameters:

x : str = 'x'

func x = : insert function to generate new coord for x

y : str = 'y'

func y = : insert function to generate new coord for y

z : str = 'sin(x+y)'

func z = : insert function to generate new coord for z

onselected : bool = False

only on selection: if checked, only affects selected vertices

per_vertex_normal_function¶

MeshLab filter name: ‘Per Vertex Normal Function’

Normal function using muparser to generate new Normal for every vertex
It's possible to use the following per-vertex variables in the expression:
x,y,z (position), nx,ny,nz (normal), r,g,b,a (color), q (quality), rad (radius), vi (vertex index), vtu,vtv,ti (texture coords and texture index), vsel (is the vertex selected? 1 yes, 0 no) and all custom vertex attributes already defined by user.

Parameters:

x : str = '-nx'

func nx = : insert function to generate new x for the normal

y : str = '-ny'

func ny = : insert function to generate new y for the normal

z : str = '-nz'

func nz = : insert function to generate new z for the normal

onselected : bool = False

only on selection: if checked, only affects selected vertices

per_vertex_quality_function¶

MeshLab filter name: ‘Per Vertex Quality Function’

Quality function using muparser to generate new Quality for every vertex
It's possible to use the following per-vertex variables in the expression:
x,y,z (position), nx,ny,nz (normal), r,g,b,a (color), q (quality), rad (radius), vi (vertex index), vtu,vtv,ti (texture coords and texture index), vsel (is the vertex selected? 1 yes, 0 no) and all custom vertex attributes already defined by user.

Parameters:

q : str = 'vi'

func q = : function to generate new Quality for every vertex

normalize : bool = False

normalize: if checked normalize all quality values in range [0..1]

map : bool = False

map into color: if checked map quality generated values into per-vertex color

onselected : bool = False

only on selection: if checked, only affects selected vertices

per_vertex_quality_histogram¶

MeshLab filter name: ‘Per Vertex Quality Histogram’

Compute an histogram of the values of the per-vertex quality. It can be useful to evaluate the distribution of the quality value over the surface. It can be discrete (e.g. based on vertex count or area weighted).

Parameters:

histmin : float = inf

Hist Min: The vertex are displaced of a vector whose norm is bounded by this value

histmax : float = -inf

Hist Max: The vertex are displaced of a vector whose norm is bounded by this value

areaweighted : bool = False

Area Weighted: If false, the histogram will report the number of vertices with quality values falling in each bin of the histogram. If true each bin of the histogram will report the approximate area of the mesh with that range of values. Area is computed by assigning to each vertex one third of the area all the incident triangles.

binnum : int = 20

Bin number: The number of bins of the histogram. E.g. the number of intervals in which the min..max range is subdivided into.

per_vertex_quality_stat¶

MeshLab filter name: ‘Per Vertex Quality Stat’

Compute some aggregate statistics over the per vertex quality, like Min, Max, Average, StdDev and Variance.

per_vertex_texture_function¶

MeshLab filter name: ‘Per Vertex Texture Function’

Texture function using muparser to generate new texture coords for every vertex
It's possible to use the following per-vertex variables in the expression:
x,y,z (position), nx,ny,nz (normal), r,g,b,a (color), q (quality), rad (radius), vi (vertex index), vtu,vtv,ti (texture coords and texture index), vsel (is the vertex selected? 1 yes, 0 no) and all custom vertex attributes already defined by user.

Parameters:

u : str = 'x'

func u = : function to generate u texture coord. Expected Range 0-1

v : str = 'y'

func v = : function to generate v texture coord. Expected Range 0-1

onselected : bool = False

only on selection: if checked, only affects selected vertices

per_wedge_texture_function¶

MeshLab filter name: ‘Per Wedge Texture Function’

Texture function using muparser to generate new per wedge tex coords for every face
Insert six functions each u v for each one of the three vertex of a face
It's possible to use the following per-face variables, or variables associated to the three vertex of every face:
x0,y0,z0 for the first vertex position, x1,y1,z1 for the second vertex position, x2,y2,z2 for the third vertex position, nx0,ny0,nz0 nx1,ny1,nz1 nx2,ny2,nz2 for vertex normals, r0,g0,b0,a0 r1,g1,b1,a1 r2,g2,b2,a2 for vertex colors, q0,q1,q2 for vertex quality, wtu0,wtv0 wtu1,wtv1 wtu2,wtv2 for per-wedge texture coords, ti for face texture index, vsel0,vsel1,vsel2 for vertex selection (1 yes, 0 no) fr,fg,fb,fa for face color, fq for face quality, fnx,fny,fnz for face normal, fsel face selection (1 yes, 0 no).

Parameters:

u0 : str = 'x0'

func u0 = : function to generate u texture coord. of wedge 0. Expected Range 0-1

v0 : str = 'y0'

func v0 = : function to generate v texture coord. of wedge 0. Expected Range 0-1

u1 : str = 'x1'

func u1 = : function to generate u texture coord. of wedge 1. Expected Range 0-1

v1 : str = 'y1'

func v1 = : function to generate v texture coord. of wedge 1. Expected Range 0-1

u2 : str = 'x2'

func u2 = : function to generate u texture coord. of wedge 2. Expected Range 0-1

v2 : str = 'y2'

func v2 = : function to generate v texture coord. of wedge 2. Expected Range 0-1

onselected : bool = False

only on selection: if checked, only affects selected faces

perlin_color¶

MeshLab filter name: ‘Perlin color’

Paints the mesh using PerlinColor function. The color assigned to vertices depends on their position in the space; it means that near vertices will be painted with similar colors.

Parameters:

color1 : Color = [0; 0; 0; 255]

Color 1:: Sets the first color to mix with Perlin Noise function.

color2 : Color = [255; 255; 255; 255]

Color 2:: Sets the second color to mix with Perlin Noise function.

freq : float (bounded) = 10 [min: 0.1; max: 100]

Frequency:: Frequency of the Perlin Noise function, expressed as multiples of mesh bbox (frequency 10 means a noise period of bbox diagonal / 10). High frequencies produces many small splashes of colours, while low frequencies produces few big splashes.

offset : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

Offset: This values is the XYZ frequency offset of the Noise function (offset 1 means 1 period shift).

onselected : bool = False

Only on selection: If checked, only affects selected vertices

permesh_color_scattering¶

MeshLab filter name: ‘PerMesh Color Scattering’

Assigns a random color to each visible mesh layer in the document. Colors change every time the filter is executed, but are always chosen so that they differ as much as possible.

Parameters:

seed : int = 0

Seed: Random seed used to generate scattered colors. Zero means totally random (each time the filter is started it generates a different result)

planar_flipping_optimization¶

MeshLab filter name: ‘Planar flipping optimization’

Mesh optimization by edge flipping, to improve local triangle quality

Parameters:

selection : bool = False

Update selection: Apply edge flip optimization on selected faces only

pthreshold : float = 1

Planar threshold (deg): angle threshold for planar faces (degrees)

planartype : str = 'area/max side' (or int = 0)

Possible enum values:

'area/max side'

'inradius/circumradius'

'mean ratio'

'delaunay'

'topology'

Planar metric:
Choose a metric to define the planar flip operation

Triangle quality based
1: minimum ratio height/edge among the edges
2: ratio between radii of incenter and circumcenter
3: 2*sqrt(a, b)/(a+b), a, b the eigenvalues of M^tM,
M transform triangle into equilateral

Others
4: Fix the Delaunay condition between two faces
5: Do the flip to improve local topology

iterations : int = 1

Post optimization relax iter: number of a planar laplacian smooth iterations that have to be performed after every run

point_cloud_simplification¶

MeshLab filter name: ‘Point Cloud Simplification’

Create a new layer populated with a simplified version of the current point cloud.

Parameters:

samplenum : int = 1000

Number of samples: The desired number of samples. The ray of the disk is calculated according to the sampling density.

radius : Percentage = 0%

Explicit Radius: If not zero this parameter override the previous parameter to allow exact radius specification

bestsampleflag : bool = True

Best Sample Heuristic: If true it will use a simple heuristic for choosing the samples. At a small cost (it can slow a bit the process) it usually improve the maximality of the generated sampling.

bestsamplepool : int = 10

Best Sample Pool Size: Used only if the Best Sample Flag is true. It control the number of attempt that it makes to get the best sample. It is reasonable that it is smaller than the Montecarlo oversampling factor.

exactnumflag : bool = False

Exact number of samples: If requested it will try to do a dicotomic search for the best poisson disk radius that will generate the requested number of samples with a tolerance of the 0.5%. Obviously it takes much longer.

points_cloud_movement¶

MeshLab filter name: ‘Points Cloud Movement’

Simulate the movement of a points cloud over a mesh

Parameters:

gravity_dir : numpy.ndarray[numpy.float64[3]] = [0, -1, 0]

g: Direction of gravity

force_dir : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

force: Direction of the force acting on the points cloud

steps : int = 1

s: Simulation Steps

adhesion : float (bounded) = 1 [min: 0; max: 1]

adhesion: Factor to model the general adhesion.

velocity : float = 0

v: Initial velocity of the particle

mass : float = 1

m: Mass of the particle

colorize_mesh : bool = False

Map to Color: Color the mesh with colors based on the movement of the particle

points_on_a_sphere¶

MeshLab filter name: ‘Points on a Sphere’

Create a spherical point cloud, it can be random or regularly distributed.

Parameters:

pointnum : int = 100

Point Num: Number of points (approximate).

spheregentech : str = 'Octahedron' (or int = 3)

Possible enum values:

'Montecarlo'

'Poisson Sampling'

'DiscoBall'

'Octahedron'

'Fibonacci'

Generation Technique:: Generation Technique:Montecarlo: The points are randomly generated with an uniform distribution.
Poisson Disk: The points are to follow a poisson disk distribution.
Disco Ball Dave Rusin's disco ball algorithm for the regular placement of points on a sphere is used.
Recursive Octahedron Points are generated on the vertex of a recursively subdivided octahedron
Fibonacci .

poisson_disk_sampling¶

MeshLab filter name: ‘Poisson-disk Sampling’

Create a new layer populated with a point sampling of the current mesh;samples are generated according to a Poisson-disk distribution, using the algorithm described in:
'Efficient and Flexible Sampling with Blue Noise Properties of Triangular Meshes'
Massimiliano Corsini, Paolo Cignoni, Roberto Scopigno
IEEE TVCG 2012

Parameters:

samplenum : int = 1000

Number of samples: The desired number of samples. The ray of the disk is calculated according to the sampling density.

radius : Percentage = 0%

Explicit Radius: If not zero this parameter override the previous parameter to allow exact radius specification

montecarlorate : int = 20

MonterCarlo OverSampling: The over-sampling rate that is used to generate the initial Montecarlo samples (e.g. if this parameter is K means thatK x poisson sample points will be used). The generated Poisson-disk samples are a subset of these initial Montecarlo samples. Larger this number slows the process but make it a bit more accurate.

savemontecarlo : bool = False

Save Montecarlo: If true, it will generate an additional Layer with the montecarlo sampling that was pruned to build the poisson distribution.

approximategeodesicdistance : bool = False

Approximate Geodesic Distance: If true Poisson Disc distances are computed using an approximate geodesic distance, e.g. an euclidean distance weighted by a function of the difference between the normals of the two points.

subsample : bool = False

Base Mesh Subsampling: If true the original vertices of the base mesh are used as base set of points. In this case the SampleNum should be obviously much smaller than the original vertex number.
Note that this option is very useful in the case you want to subsample a dense point cloud.

refineflag : bool = False

Refine Existing Samples: If true the vertices of the below mesh are used as starting vertices, and they will utterly refined by adding more and more points until possible.

refinemesh : int = 0

Samples to be refined: Used only if the above option is checked.

bestsampleflag : bool = True

Best Sample Heuristic: If true it will use a simple heuristic for choosing the samples. At a small cost (it can slow a bit the process) it usually improve the maximality of the generated sampling.

bestsamplepool : int = 10

Best Sample Pool Size: Used only if the Best Sample Flag is true. It control the number of attempt that it makes to get the best sample. It is reasonable that it is smaller than the Montecarlo oversampling factor.

exactnumflag : bool = False

Exact number of samples: If requested it will try to do a dicotomic search for the best poisson disk radius that will generate the requested number of samples with a tolerance of the 0.5%. Obviously it takes much longer.

radiusvariance : float = 1

Radius Variance: The radius of the disk is allowed to vary between r and r*var. If this parameter is 1 the sampling is the same of the Poisson Disk Sampling

project_active_rasters_color_to_current_mesh¶

MeshLab filter name: ‘Project active rasters color to current mesh’

Color information from all the active rasters is perspective-projected on the current mesh using basic weighting

Parameters:

deptheta : float = 0.5

depth threshold: threshold value for depth buffer projection (shadow buffer)

onselection : bool = False

Only on selection: If true, projection is only done for selected vertices

useangle : bool = True

use angle weight: If true, color contribution is weighted by pixel view angle

usedistance : bool = True

use distance weight: If true, color contribution is weighted by pixel view distance

useborders : bool = True

use image borders weight: If true, color contribution is weighted by pixel distance from image boundaries

usesilhouettes : bool = True

use depth discontinuities weight: If true, color contribution is weighted by pixel distance from depth discontinuities (external and internal silhouettes)

usealpha : bool = False

use image alpha weight: If true, alpha channel of the image is used as additional weight. In this way it is possible to mask-out parts of the images that should not be projected on the mesh. Please note this is not a transparency effect, but just influences the weigthing between different images

blankcolor : Color = [0; 0; 0; 255]

Color for unprojected areas: Areas that cannot be projected willb e filled using this color. If R=0 G=0 B=0 A=0 old color is preserved

project_active_rasters_color_to_current_mesh_filling_the_texture¶

MeshLab filter name: ‘Project active rasters color to current mesh, filling the texture’

Color information from all the active rasters is perspective-projected on the current mesh, filling the texture, using basic weighting

Parameters:

textname : str = 'cube_color.png'

Texture file: The texture file to be created

texsize : int = 1024

pixel size of texture image: pixel size of texture image, the image will be a square tsize X tsize, most applications do require that tsize is a power of 2

dorefill : bool = True

fill atlas gaps: If true, unfilled areas of the mesh are interpolated, to avoid visible seams while mipmapping

deptheta : float = 0.5

depth threshold: threshold value for depth buffer projection (shadow buffer)

onselection : bool = False

Only on selection: If true, projection is only done for selected vertices

useangle : bool = True

use angle weight: If true, color contribution is weighted by pixel view angle

usedistance : bool = True

use distance weight: If true, color contribution is weighted by pixel view distance

useborders : bool = True

use image borders weight: If true, color contribution is weighted by pixel distance from image boundaries

usesilhouettes : bool = True

use depth discontinuities weight: If true, color contribution is weighted by pixel distance from depth discontinuities (external and internal silhouettes)

usealpha : bool = False

use image alpha weight: If true, alpha channel of the image is used as additional weight. In this way it is possible to mask-out parts of the images that should not be projected on the mesh. Please note this is not a transparency effect, but just influences the weigthing between different images

project_current_raster_color_to_current_mesh¶

MeshLab filter name: ‘Project current raster color to current mesh’

Color information from the current raster is perspective-projected on the current mesh

Parameters:

usedepth : bool = True

Use depth for projection: If true, depth is used to restrict projection on visible faces

deptheta : float = 0.5

depth threshold: threshold value for depth buffer projection (shadow buffer)

onselection : bool = False

Only on selection: If true, projection is only done for selected vertices

blankcolor : Color = [0; 0; 0; 255]

Color for unprojected areas: Areas that cannot be projected willb e filled using this color. If R=0 G=0 B=0 A=0 old color is preserved

quality_from_raster_coverage_face¶

MeshLab filter name: ‘Quality from raster coverage (Face)’

Compute a quality value representing the number of images into which each face of the active mesh is visible.

Parameters:

normalizequality : bool = False

Normalize: Rescale quality values to the range [0,1]

quality_from_raster_coverage_vertex¶

MeshLab filter name: ‘Quality from raster coverage (Vertex)’

Compute a quality value representing the number of images into which each vertex of the active mesh is visible.

Parameters:

normalizequality : bool = False

Normalize: Rescale quality values to the range [0,1]

quality_mapper_applier¶

MeshLab filter name: ‘Quality Mapper applier’

The filter maps quality levels into colors using a colorband built from a transfer function (may be loaded from an external file) and colorizes the mesh vertices. The minimum, medium and maximum quality values can be set by user to obtain a custom quality range for mapping

Parameters:

minqualityval : float = inf

Minimum mesh quality: The specified quality value is mapped in the lower end of the chosen color scale. Default value: the minimum quality value found on the mesh.

maxqualityval : float = -inf

Maximum mesh quality: The specified quality value is mapped in the upper end of the chosen color scale. Default value: the maximum quality value found on the mesh.

midhandlepos : float = 50

Gamma biasing (0..100): Defines a gamma compression of the quality values, by setting the position of the middle of the color scale. Value is defined as a percentage (0..100). Default value is 50, that corresponds to a linear mapping.

brightness : float = 1

Mesh brightness: must be between 0 and 2. 0 represents a completely dark mesh, 1 represents a mesh colorized with original colors, 2 represents a completely bright mesh

tfslist : str = 'Meshlab RGB' (or int = 1)

Possible enum values:

'Custom Transfer Function File'

'Meshlab RGB'

'RGB'

'French RGB'

'Red Scale'

'Green Scale'

'Blue Scale'

'Flat'

'Saw 4'

'Saw 8'

'Grey Scale'

Transfer Function type to apply to filter: Choose the Transfer Function to apply to the filter

csvfilename : str = ''

Custom TF Filename: Filename of the transfer function to be loaded, used only if you have chosen the Custom Transfer Function. Write the full path of the qmap file, or save the file in the same folder of the current mesh, and write only the name of the qmap file. Only the RGB mapping will be imported from the qmap file

random_component_color¶

MeshLab filter name: ‘Random Component Color’

Colorize each connected component randomly.

random_face_color¶

MeshLab filter name: ‘Random Face Color’

Colorize Faces randomly. If internal edges are present they are used. Useful for quads.

random_vertex_displacement¶

MeshLab filter name: ‘Random Vertex Displacement’

Move the vertices of the mesh of a random quantity.

Parameters:

updatenormals : bool = True

Recompute normals: Toggle the recomputation of the normals after the random displacement.

If disabled the face normals will remains unchanged resulting in a visually pleasant effect.

displacement : Percentage = 1%

Max displacement: The vertex are displaced of a vector whose norm is bounded by this value

re_compute_face_normals¶

MeshLab filter name: ‘Re-Compute Face Normals’

Recompute face normals as the normal of the plane of the face.
See How to find surface normal of a triangle

re_compute_per_polygon_face_normals¶

MeshLab filter name: ‘Re-Compute Per-Polygon Face Normals’

Recompute face normals as the average of the normals of the triangles that builds a polygon. Useful for showing uniformly shaded quad or polygonal meshes represented using faux edges.

re_compute_vertex_normals¶

MeshLab filter name: ‘Re-Compute Vertex Normals’

Recompute vertex normals according to four different schemes:
1) Simple (no weights) average of normals of the incident faces
2) Area weighted average of normals of the incident faces
3) Angle weighted sum of normals of the incident faces according to the article [1]. Probably this is the best all-purpose choice. It could slightly bias the result for degenerate, fat triangles.
4) Weighted sum of normals of the incident faces, as defined by article [2]. The weight for each wedge is the cross product of the two edges over the product of the square of the two edge lengths.According to the original article it is perfect only for spherical surface, but it should perform well also in practice.
[1]: Computing Vertex Normals from Polygonal Facet by G Thurmer and CA Wuthrich, JGT volume3, num 1. 1998
doi:10.1080/10867651.1998.10487487
[2]: Weights for Computing Vertex Normals from Facet Normals by Nelson Max, JGT vol4, num 2. 1999
doi:10.1080/10867651.1999.10487501

Parameters:

weightmode : str = 'Simple Average' (or int = 0)

Possible enum values:

'Simple Average'

'By Angle'

'By Area'

'As defined by N. Max'

Weighting Mode::

re_orient_all_faces_coherentely¶

MeshLab filter name: ‘Re-Orient all faces coherentely’

Re-orient in a consistent way all the faces of the mesh.
The filter visits a mesh face to face, reorienting any unvisited face so that it is coherent to the already visited faces. If the surface is orientable it will end with a consistent orientation of all the faces. If the surface is not orientable (e.g. it is non manifold or non orientable like a moebius strip) the filter will not build a consistent orientation simply because it is not possible. The filter can end up in a consistent orientation that can be exactly the opposite of the expected one; in that case simply invert the whole mesh orientation.

re_orient_vertex_normals_using_cameras¶

MeshLab filter name: ‘Re-Orient vertex normals using cameras’

Reorient vertex normals using cameras. For this filter to work the mesh needs to have the attribute 'correspondences' which is only created when loading Bundler files (.out projects)

refine_user_defined¶

MeshLab filter name: ‘Refine User-Defined’

Refine current mesh with user defined parameters.
Specify a Boolean Function needed to select which edges will be cut for refinement purpose.
Each edge is identified with first and second vertex.
Arguments accepted are first and second vertex attributes:

It's possible to use parenthesis (), and predefined operators:
&& (logic and), || (logic or), <, <=, >, >=, != (not equal), == (equal), _?_:_ (c/c++ ternary operator)

It's possible to use the following per-face variables, or variables associated to the three vertex of every face:
x0,y0,z0 for the first vertex position, x1,y1,z1 for the second vertex position, x2,y2,z2 for the third vertex position, nx0,ny0,nz0 nx1,ny1,nz1 nx2,ny2,nz2 for vertex normals, r0,g0,b0,a0 r1,g1,b1,a1 r2,g2,b2,a2 for vertex colors, q0,q1,q2 for vertex quality, wtu0,wtv0 wtu1,wtv1 wtu2,wtv2 for per-wedge texture coords, ti for face texture index, vsel0,vsel1,vsel2 for vertex selection (1 yes, 0 no) fr,fg,fb,fa for face color, fq for face quality, fnx,fny,fnz for face normal, fsel face selection (1 yes, 0 no).

Parameters:

condselect : str = '(q0 >= 0 && q1 >= 0)'

boolean function: type a boolean function that will be evaluated on every edge

x : str = '(x0+x1)/2'

x =: function to generate x coord of new vertex in [x0,x1].
For example (x0+x1)/2

y : str = '(y0+y1)/2'

y =: function to generate x coord of new vertex in [y0,y1].
For example (y0+y1)/2

z : str = '(z0+z1)/2'

z =: function to generate x coord of new vertex in [z0,z1].
For example (z0+z1)/2

regular_recursive_sampling¶

MeshLab filter name: ‘Regular Recursive Sampling’

The bbox is recursively partitioned in a octree style, center of bbox are considered, when the center is nearer to the surface than a given thr it is projected on it. It works also for building offsetted samples.

Parameters:

cellsize : Percentage = 2%

Precision: Size of the cell, the default is 1/50 of the box diag. Smaller cells give better precision at a higher computational cost. Remember that halving the cell size means that you build a volume 8 times larger.

offset : Percentage = 50%

Offset: Offset of the created surface (i.e. distance of the created surface from the original one).
If offset is zero, the created surface passes on the original mesh itself. Values greater than zero mean an external surface, and lower than zero mean an internal surface.
In practice this value is the threshold passed to the Marching Cube algorithm to extract the isosurface from the distance field representation.

remeshing_isotropic_explicit_remeshing¶

MeshLab filter name: ‘Remeshing: Isotropic Explicit Remeshing’

Perform a explicit remeshing of a triangular mesh, by repeatedly applying edge flip, collapse, relax and refine to improve aspect ratio (triangle quality) and topological regularity.

Parameters:

iterations : int = 3

Iterations: Number of iterations of the remeshing operations to repeat on the mesh.

adaptive : bool = False

Adaptive remeshing: Toggles adaptive isotropic remeshing.

selectedonly : bool = False

Remesh only selected faces: If checked the remeshing operations will be applied only to the selected faces.

targetlen : Percentage = 1%

Target Length: Sets the target length for the remeshed mesh edges.

featuredeg : float = 30

Crease Angle: Minimum angle between faces of the original to consider the shared edge as a feature to be preserved.

checksurfdist : bool = True

Check Surface Distance: If toggled each local operation must deviate from original mesh by [Max. surface distance]

maxsurfdist : Percentage = 1%

Max. Surface Distance: Maximal surface deviation allowed for each local operation

splitflag : bool = True

Refine Step: If checked the remeshing operations will include a refine step.

collapseflag : bool = True

Collapse Step: If checked the remeshing operations will include a collapse step.

swapflag : bool = True

Edge-Swap Step: If checked the remeshing operations will include a edge-swap step, aimed at improving the vertex valence of the resulting mesh.

smoothflag : bool = True

Smooth Step: If checked the remeshing operations will include a smoothing step, aimed at relaxing the vertex positions in a Laplacian sense.

reprojectflag : bool = True

Reproject Step: If checked the remeshing operations will include a step to reproject the mesh vertices on the original surface.

remove_duplicate_faces¶

MeshLab filter name: ‘Remove Duplicate Faces’

Delete all the duplicate faces. Two faces are considered equal if they are composed by the same set of vertices, regardless of the order of the vertices.

remove_duplicate_vertices¶

MeshLab filter name: ‘Remove Duplicate Vertices’

Check for every vertex on the mesh: if there are two vertices with same coordinates they are merged into a single one.

remove_isolated_folded_faces_by_edge_flip¶

MeshLab filter name: ‘Remove Isolated Folded Faces by Edge Flip’

Delete all the single folded faces. A face is considered folded if its normal is opposite to all the adjacent faces. It is removed by flipping it against the face f adjacent along the edge e such that the vertex opposite to e fall inside f

remove_isolated_pieces_wrt_diameter¶

MeshLab filter name: ‘Remove Isolated pieces (wrt Diameter)’

Delete isolated connected components whose diameter is smaller than the specified constant

Parameters:

mincomponentdiag : Percentage = 10%

Enter max diameter of isolated pieces: Delete all the connected components (floating pieces) with a diameter smaller than the specified one

removeunref : bool = True

Remove unfreferenced vertices: if true, the unreferenced vertices remaining after the face deletion are removed.

remove_isolated_pieces_wrt_face_num¶

MeshLab filter name: ‘Remove Isolated pieces (wrt Face Num.)’

Delete isolated connected components composed by a limited number of triangles

Parameters:

mincomponentsize : int = 25

Enter minimum conn. comp size:: Delete all the connected components (floating pieces) composed by a number of triangles smaller than the specified one

removeunref : bool = True

Remove unfreferenced vertices: if true, the unreferenced vertices remaining after the face deletion are removed.

remove_t_vertices_by_edge_collapse¶

MeshLab filter name: ‘Remove T-Vertices by Edge Collapse’

Delete t-vertices from the mesh by collapsing the shortest of the incident edges

Parameters:

threshold : float = 40

Ratio: Detects faces where the base/height ratio is lower than this value

repeat : bool = True

Iterate until convergence: Iterates the algorithm until it reaches convergence

remove_t_vertices_by_edge_flip¶

MeshLab filter name: ‘Remove T-Vertices by Edge Flip’

Delete t-vertices by flipping the opposite edge on the degenerate face if the triangulation quality improves

Parameters:

threshold : float = 40

Ratio: Detects faces where the base/height ratio is lower than this value

repeat : bool = True

Iterate until convergence: Iterates the algorithm until it reaches convergence

remove_unreferenced_vertices¶

MeshLab filter name: ‘Remove Unreferenced Vertices’

Check for every vertex on the mesh: if it is NOT referenced by a face, removes it

remove_vertices_wrt_quality¶

MeshLab filter name: ‘Remove Vertices wrt Quality’

Delete all the vertices with a quality lower smaller than the specified constant

Parameters:

maxqualitythr : Percentage = -nan%

Delete all vertices with quality under::

remove_zero_area_faces¶

MeshLab filter name: ‘Remove Zero Area Faces’

Remove null faces (the one with area equal to zero)

rename_current_mesh¶

MeshLab filter name: ‘Rename Current Mesh’

Explicitly change the label shown for a given mesh

Parameters:

newname : str = 'cube'

New Label: New Label for the mesh

rename_current_raster¶

MeshLab filter name: ‘Rename Current Raster’

Explicitly change the label shown for a given raster

Parameters:

newname : str = ''

New Label: New Label for the raster

repair_non_manifold_edges_by_removing_faces¶

MeshLab filter name: ‘Repair non Manifold Edges by removing faces’

For each non Manifold edge it iteratively deletes the smallest area face until it becomes 2-Manifold.

repair_non_manifold_edges_by_splitting_vertices¶

MeshLab filter name: ‘Repair non Manifold Edges by splitting vertices’

Remove all non manifold edges splitting vertices. Each non manifold edges chain will become a border

repair_non_manifold_vertices_by_splitting¶

MeshLab filter name: ‘Repair non Manifold Vertices by splitting’

Split non Manifold vertices until it becomes 2-Manifold.

Parameters:

vertdispratio : float = 0

Vertex Displacement Ratio: When a vertex is split it is moved along the average vector going from its position to the baricyenter of the FF connected faces sharing it

saturate_vertex_quality¶

MeshLab filter name: ‘Saturate Vertex Quality’

Saturate vertex quality, so that for each vertex the gradient of the quality is lower than the given threshold value (in absolute value)
The saturation is done in a conservative way (quality is always decreased and never increased)

Parameters:

gradientthr : float = 1

Gradient Threshold: The maximum value admitted for the quality gradient (in absolute value)

updatecolor : bool = False

Update ColorMap: if true the color ramp is computed again

scaledependent_laplacian_smooth¶

MeshLab filter name: ‘ScaleDependent Laplacian Smooth’

Scale Dependent Laplacian Smoothing, extended version of Laplacian Smoothing based on the Fujiwara extended umbrella operator.
Implicit Fairing of Irregular Meshes using Diffusion and Curvature Flow by Desbrun, Meyer, Schroeder and Barr. SIGGRAPH 1999
doi:10.1145/311535.311576

Parameters:

stepsmoothnum : int = 3

Smoothing steps: The number of times that the whole algorithm (normal smoothing + vertex fitting) is iterated.

delta : Percentage = 1%

delta:

selected : bool = False

Affect only selected faces: If checked the filter is performed only on the selected faces

select_all¶

MeshLab filter name: ‘Select All’

Select all the faces/vertices of the current mesh.

Parameters:

allfaces : bool = True

Select all Faces: If true the filter will select all the faces.

allverts : bool = True

Select all Vertices: If true the filter will select all the vertices.

select_border¶

MeshLab filter name: ‘Select Border’

Select vertices and faces on the boundary.

select_by_face_quality¶

MeshLab filter name: ‘Select by Face Quality’

Select all the faces/vertices with within the specified face quality range.

Parameters:

minq : float (bounded) = -nan [min: inf; max: -inf]

Min Quality: Minimum acceptable quality value

maxq : float (bounded) = -nan [min: inf; max: -inf]

Max Quality: Maximum acceptable quality value

inclusive : bool = True

Inclusive Sel.: If true only the vertices with all the adjacent faces within the specified range are selected. Otherwise any vertex with at least one face within the range is selected.

select_by_vertex_quality¶

MeshLab filter name: ‘Select by Vertex Quality’

Select all the faces/vertices within the specified vertex quality range.

Parameters:

minq : float (bounded) = -nan [min: inf; max: -inf]

Min Quality: Minimum acceptable quality value

maxq : float (bounded) = -nan [min: inf; max: -inf]

Max Quality: Maximum acceptable quality value

inclusive : bool = True

Inclusive Sel.: If true only the faces with all the vertices within the specified range are selected. Otherwise any face with at least one vertex within the range is selected.

select_connected_faces¶

MeshLab filter name: ‘Select Connected Faces’

Expand the current face selection so that it includes all the faces in the connected components where there is at least a selected face.

select_crease_edges¶

MeshLab filter name: ‘Select Crease Edges’

It select the crease edges of a mesh according to edge dihedral angle.
Angle between face normal is considered signed according to convexity/concavity.Convex angles are positive and concave are negative.

Parameters:

angledegneg : float = -45

Concave Angle Thr. (deg): Concave Dihedral Angle threshold for considering an edge a crease. If the normals between two faces forms an concave diheadral angle smaller than the threshold the edge is considered a crease.

angledegpos : float = 45

Convex Angle Thr. (deg): The angle threshold for considering an edge a crease. If the normals between two faces forms an angle larger than the threshold the edge is considered a crease.

select_faces_by_color¶

MeshLab filter name: ‘Select Faces by Color’

Select part of the mesh based on its color.

Parameters:

color : Color = [0; 0; 0; 255]

Color To Select: Color that you want to be selected.

colorspace : str = 'HSV' (or int = 0)

Possible enum values:

'HSV'

'RGB'

Pick Color Space: The color space that the sliders will manipulate.

inclusive : bool = True

Inclusive Sel.: If true only the faces with all the vertices within the specified range are selected. Otherwise any face with at least one vertex within the range is selected.

percentrh : float (bounded) = 0.2 [min: 0; max: 1]

Variation from Red or Hue: A float between 0 and 1 that represents the percent variation from this color that will be selected. For example if the R was 200 and you put 0.1 then any color with R 200+-25.5 will be selected.

percentgs : float (bounded) = 0.2 [min: 0; max: 1]

Variation from Green or Saturation: A float between 0 and 1 that represents the percent variation from this color that will be selected. For example if the R was 200 and you put 0.1 then any color with R 200+-25.5 will be selected.

percentbv : float (bounded) = 0.2 [min: 0; max: 1]

Variation from Blue or Value: A float between 0 and 1 that represents the percent variation from this color that will be selected. For example if the R was 200 and you put 0.1 then any color with R 200+-25.5 will be selected.

select_faces_by_view_angle¶

MeshLab filter name: ‘Select Faces by view angle’

Select faces according to the angle between their normal and the view direction. It is used in range map processing to select and delete steep faces parallel to viewdirection.

Parameters:

anglelimit : float (bounded) = 75 [min: 0; max: 180]

angle threshold (deg): faces with normal at higher angle w.r.t. the view direction are selected

usecamera : bool = False

Use ViewPoint from Mesh Camera: Uses the ViewPoint from the camera associated to the current mesh
if there is no camera, an error occurs

viewpoint : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

ViewPoint: if UseCamera is true, this value is ignored

select_faces_from_vertices¶

MeshLab filter name: ‘Select Faces from Vertices’

Select faces from selected vertices.

Parameters:

inclusive : bool = True

Strict Selection: If true only the faces with all selected vertices are selected. Otherwise any face with at least one selected vertex will be selected.

select_faces_with_edges_longer_than¶

MeshLab filter name: ‘Select Faces with edges longer than…’

Select all triangles having an edge with length greater or equal than a given threshold.

Parameters:

threshold : float (bounded) = 0.0173205 [min: 0; max: 1.73205]

Edge Threshold: All the faces with an edge longer than this threshold will be deleted. Useful for removing long skinny faces obtained by bad triangulation of range maps.

select_folded_faces¶

MeshLab filter name: ‘Select Folded Faces’

Select the folded faces created by the Quadric Edge Collapse decimation. The face is selected if the angle between the face normal and the normal of the best fitting plane of the neighbor vertices is above the selected threshold.

Parameters:

anglethreshold : float (bounded) = 160 [min: 90; max: 180]

Angle Threshold: Angle between the face and the best fitting plane of the neighbours vertices. If it is above the threshold the face is selected.

select_non_manifold_edges_¶

MeshLab filter name: ‘Select non Manifold Edges ‘

Select the faces and the vertices incident on non manifold edges (e.g. edges where more than two faces are incident); note that this function select the components that are related to non manifold edges. The case of non manifold vertices is specifically managed by the pertinent filter.

select_non_manifold_vertices¶

MeshLab filter name: ‘Select non Manifold Vertices’

Select the non manifold vertices that do not belong to non manifold edges. For example two cones connected by their apex. Vertices incident on non manifold edges are ignored.

select_none¶

MeshLab filter name: ‘Select None’

Clear the current set of selected faces/vertices.

Parameters:

allfaces : bool = True

De-select all Faces: If true the filter will de-select all the faces.

allverts : bool = True

De-select all Vertices: If true the filter will de-select all the vertices.

select_outliers¶

MeshLab filter name: ‘Select Outliers’

Select the vertex classified as outlier using Local Outlier Propabilty measure described in:
'LoOP: Local Outlier Probabilities' Kriegel et al.
CIKM 2009

Parameters:

propthreshold : float (bounded) = 0.8 [min: 0; max: 1]

Probability: Threshold to select the vertex. The vertex is selected if the LoOP value is above the threshold.

knearest : int = 32

Number of neighbors: Number of neighbours used to compute the LoOP

select_problematic_faces¶

MeshLab filter name: ‘Select ‘problematic’ faces’

Select faces with 'problems', like normal inverted w.r.t the surrounding areas, or extremely elongated

Parameters:

usear : bool = True

select by Aspect Ratio: if true, faces with aspect ratio below the limit will be selected

aratio : float (bounded) = 0.02 [min: 0; max: 1]

Aspect Ratio: Triangle face aspect ratio [1 (equilateral) - 0 (line)]: face will be selected if BELOW this threshold

usenf : bool = False

select by Normal Angle: if true, adjacent faces with normals forming an angle above the limit will be selected

nfratio : float (bounded) = 60 [min: 0; max: 180]

Angle flip: angle between the adjacent faces: face will be selected if ABOVE this threshold

select_self_intersecting_faces¶

MeshLab filter name: ‘Select Self Intersecting Faces’

Select only self intersecting faces.

select_small_disconnected_component¶

MeshLab filter name: ‘Select small disconnected component’

Select the small disconnected components of a mesh.

Parameters:

nbfaceratio : float = 0.1

Small component ratio: This ratio (between 0 and 1) defines the meaning of small as the threshold ratio between the number of facesof the largest component and the other ones. A larger value will select more components.

nonclosedonly : bool = False

Select only non closed components:

select_vertex_texture_seams¶

MeshLab filter name: ‘Select Vertex Texture Seams’

Colorize only border edges.

select_vertices_from_faces¶

MeshLab filter name: ‘Select Vertices from Faces’

Select vertices from selected faces.

Parameters:

inclusive : bool = True

Strict Selection: If true only the vertices with all the incident face selected are selected. Otherwise any vertex with at least one incident selected face will be selected.

select_visible_points¶

MeshLab filter name: ‘Select Visible Points’

Select the visible points in a point cloud, as viewed from a given viewpoint.
It uses the Qhull library (http://www.qhull.org/

The algorithm used (Katz, Tal and Basri 2007) determines visibility without reconstructing a surface or estimating normals.A point is considered visible if its transformed point lies on the convex hull of a transformed points cloud from the original mesh points.

Parameters:

radiusthreshold : float (bounded) = 0 [min: 0; max: 7]

radius threshold : Bounds the radius of the sphere used to select visible points.It is used to adjust the radius of the sphere (calculated as distance between the center and the farthest point from it) according to the following equation:
radius = radius * pow(10,threshold);
As the radius increases more points are marked as visible.Use a big threshold for dense point clouds, a small one for sparse clouds.

usecamera : bool = False

Use ViewPoint from Mesh Camera: Uses the ViewPoint from the camera associated to the current mesh
if there is no camera, an error occurs

viewpoint : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

ViewPoint: if UseCamera is true, this value is ignored

convex_hullfp : bool = False

Show Partial Convex Hull of flipped points: Show Partial Convex Hull of the transformed point cloud

triangvp : bool = False

Show a triangulation of the visible points: Show a triangulation of the visible points

set_mesh_camera¶

MeshLab filter name: ‘Set Mesh Camera’

This filter allows one to set a shot for the current mesh

Parameters:

shot : Shotf [still unsupported] = None

New shot: This filter allows one to set a shot for the current mesh.

set_raster_camera¶

MeshLab filter name: ‘Set Raster Camera’

This filter allows one to set a shot for the current mesh

Parameters:

shot : Shotf [still unsupported] = None

New shot: This filter allows one to set a shot for the current raster.

set_texture¶

MeshLab filter name: ‘Set Texture’

Set a texture associated with current mesh parametrization.
If the texture provided exists, then it will be simply associated to the current mesh; else a dummy texture will be created and saved in the same directory of the mesh if exists, or in the default system picture directory.

Parameters:

textname : str = 'cube.png'

Texture file: If the file exists it will be associated to the mesh else a dummy one will be created

textdim : int = 1024

Texture Dimension (px): If the named texture doesn't exists the dummy one will be squared with this size

shape_diameter_function¶

MeshLab filter name: ‘Shape Diameter Function’

Calculate the SDF (shape diameter function) on the mesh, you can visualize the result colorizing the mesh. The SDF is a scalar function on the mesh surface and represents the neighborhood diameter of the object at each point. Given a point on the mesh surface,several rays are sent inside a cone, centered around the point's inward-normal, to the other side of the mesh. The result is a weighted sum of all rays lengths. For further details, see the reference paper:
Shapira Shamir Cohen-Or,
Consistent Mesh Partitioning and Skeletonisation using the shaper diamter function, Visual Comput. J. (2008)

Parameters:

onprimitive : str = 'On vertices' (or int = 0)

Possible enum values:

'On vertices'

'On Faces'

Metric:: Choose whether to trace rays from faces or from vertices.

numberrays : int = 128

Number of rays: : The number of rays that will be casted around the normals.

depthtexturesize : int = 512

Depth texture size: Size of the depth texture for depth peeling. Higher resolutions provide better sampling of the mesh, with a small performance penalty.

peelingiteration : int = 10

Peeling Iteration: Number of depth peeling iteration. Actually is the maximum number of layers that a ray can hit while traversing the mesh. For example, in the case of a sphere, you should specify 2 in this parameter. For a torus, specify 4. For more complex geometry you should run the depth complexity filter to know the exact value.

peelingtolerance : float = 1e-07

Peeling Tolerance: Depth tolerance used during depth peeling. This is the threshold used to differentiate layers between each others.Two elements whose distance is below this value will be considered as belonging to the same layer.

coneangle : float = 120

Cone amplitude: Cone amplitude around normals in degrees. Rays are traced within this cone.

removefalse : bool = True

Remove false intersections: For eachray we check the normal at the point of intersection,and ignore intersections where the normal at the intersectionpoints is in the same direction as the point-of-origin(the same direction is defined as an angle difference lessthan 90)

removeoutliers : bool = False

Remove outliers: The outliers removal is made on the fly with a supersampling of the depth buffer. For each ray that we trace, we take multiple depth values near the point of intersection and we output only the median of these values. Some mesh can benefit from this additional calculation.

simplification_clustering_decimation¶

MeshLab filter name: ‘Simplification: Clustering Decimation’

Collapse vertices by creating a three dimensional grid enveloping the mesh and discretizes them based on the cells of this grid

Parameters:

threshold : Percentage = 1%

Cell Size: The size of the cell of the clustering grid. Smaller the cell finer the resulting mesh. For obtaining a very coarse mesh use larger values.

selected : bool = False

Affect only selected faces: If selected the filter affect only the selected faces

simplification_edge_collapse_for_marching_cube_meshes¶

MeshLab filter name: ‘Simplification: Edge Collapse for Marching Cube meshes’

A simplification/cleaning algorithm that works ONLY on meshes generated by Marching Cubes algorithm.

simplification_quadric_edge_collapse_decimation¶

MeshLab filter name: ‘Simplification: Quadric Edge Collapse Decimation’

Simplify a mesh using a Quadric based Edge Collapse Strategy; better than clustering but slower

Parameters:

targetfacenum : int = 0

Target number of faces: The desired final number of faces.

targetperc : float = 0

Percentage reduction (0..1): If non zero, this parameter specifies the desired final size of the mesh as a percentage of the initial size.

qualitythr : float = 0.3

Quality threshold: Quality threshold for penalizing bad shaped faces.
The value is in the range [0..1]
0 accept any kind of face (no penalties),
0.5 penalize faces with quality < 0.5, proportionally to their shape

preserveboundary : bool = False

Preserve Boundary of the mesh: The simplification process tries to do not affect mesh boundaries during simplification

boundaryweight : float = 1

Boundary Preserving Weight: The importance of the boundary during simplification. Default (1.0) means that the boundary has the same importance of the rest. Values greater than 1.0 raise boundary importance and has the effect of removing less vertices on the border. Admitted range of values (0,+inf).

preservenormal : bool = False

Preserve Normal: Try to avoid face flipping effects and try to preserve the original orientation of the surface

preservetopology : bool = False

Preserve Topology: Avoid all the collapses that should cause a topology change in the mesh (like closing holes, squeezing handles, etc). If checked the genus of the mesh should stay unchanged.

optimalplacement : bool = True

Optimal position of simplified vertices: Each collapsed vertex is placed in the position minimizing the quadric error.
It can fail (creating bad spikes) in case of very flat areas.
If disabled edges are collapsed onto one of the two original vertices and the final mesh is composed by a subset of the original vertices.

planarquadric : bool = False

Planar Simplification: Add additional simplification constraints that improves the quality of the simplification of the planar portion of the mesh, as a side effect, more triangles will be preserved in flat areas (allowing better shaped triangles).

planarweight : float = 0.001

Planar Simp. Weight: How much we should try to preserve the triangles in the planar regions. If you lower this value planar areas will be simplified more.

qualityweight : bool = False

Weighted Simplification: Use the Per-Vertex quality as a weighting factor for the simplification. The weight is used as a error amplification value, so a vertex with a high quality value will not be simplified and a portion of the mesh with low quality values will be aggressively simplified.

autoclean : bool = True

Post-simplification cleaning: After the simplification an additional set of steps is performed to clean the mesh (unreferenced vertices, bad faces, etc)

selected : bool = False

Simplify only selected faces: The simplification is applied only to the selected set of faces.
Take care of the target number of faces!

simplification_quadric_edge_collapse_decimation_with_texture¶

MeshLab filter name: ‘Simplification: Quadric Edge Collapse Decimation (with texture)’

Simplify a textured mesh using a Quadric based Edge Collapse Strategy preserving UV parametrization; better than clustering but slower

Parameters:

targetfacenum : int = 0

Target number of faces:

targetperc : float = 0

Percentage reduction (0..1): If non zero, this parameter specifies the desired final size of the mesh as a percentage of the initial mesh.

qualitythr : float = 0.3

Quality threshold: Quality threshold for penalizing bad shaped faces.
The value is in the range [0..1]
0 accept any kind of face (no penalties),
0.5 penalize faces with quality < 0.5, proportionally to their shape

extratcoordw : float = 1

Texture Weight: Additional weight for each extra Texture Coordinates for every (selected) vertex

preserveboundary : bool = False

Preserve Boundary of the mesh: The simplification process tries not to destroy mesh boundaries

boundaryweight : float = 1

Boundary Preserving Weight: The importance of the boundary during simplification. Default (1.0) means that the boundary has the same importance of the rest. Values greater than 1.0 raise boundary importance and has the effect of removing less vertices on the border. Admitted range of values (0,+inf).

optimalplacement : bool = True

Optimal position of simplified vertices: Each collapsed vertex is placed in the position minimizing the quadric error.
It can fail (creating bad spikes) in case of very flat areas.
If disabled edges are collapsed onto one of the two original vertices and the final mesh is composed by a subset of the original vertices.

preservenormal : bool = False

Preserve Normal: Try to avoid face flipping effects and try to preserve the original orientation of the surface

planarquadric : bool = False

Planar Simplification: Add additional simplification constraints that improves the quality of the simplification of the planar portion of the mesh.

selected : bool = False

Simplify only selected faces: The simplification is applied only to the selected set of faces.
Take care of the target number of faces!

smooth_face_normals¶

MeshLab filter name: ‘Smooth Face Normals’

Laplacian smooth of the face normals, without touching the position of the vertices.

smooth_laplacian_face_color¶

MeshLab filter name: ‘Smooth: Laplacian Face Color’

Laplacian Smooth Face Color

Parameters:

iteration : int = 1

Iteration: the number of iteration of the smoothing algorithm

smooth_laplacian_vertex_color¶

MeshLab filter name: ‘Smooth: Laplacian Vertex Color’

Laplacian Smooth Vertex Color

Parameters:

iteration : int = 1

Iteration: the number of iteration of the smoothing algorithm

smooth_vertex_quality¶

MeshLab filter name: ‘Smooth Vertex Quality’

Laplacian smooth of the quality per vertex values.

smooths_normals_on_a_point_sets¶

MeshLab filter name: ‘Smooths normals on a point sets’

Smooth the normals of the vertices of a mesh without exploiting the triangle connectivity, useful for dataset with no faces

Parameters:

k : int = 10

Number of neighbors: The number of neighbors used to smooth normals.

usedist : bool = False

Weight using neighbour distance: If selected, the neighbour normals are waighted according to their distance

snap_mismatched_borders¶

MeshLab filter name: ‘Snap Mismatched Borders’

Try to snap together adjacent borders that are slightly mismatched.
This situation can happen on badly triangulated adjacent patches defined by high order surfaces.
For each border vertex the filter snap it onto the closest boundary edge only if it is closest of edge_length*threshold. When vertex is snapped the corresponding face is split and a new vertex is created.

Parameters:

edgedistratio : float = 0.01

Edge Distance Ratio: Collapse edge when the edge / distance ratio is greater than this value. E.g. for default value 1000 two straight border edges are collapsed if the central vertex dist from the straight line composed by the two edges less than a 1/1000 of the sum of the edges length. Larger values enforce that only vertices very close to the line are removed.

unifyvertices : bool = True

UnifyVertices: if true the snap vertices are weld together.

sphere¶

MeshLab filter name: ‘Sphere’

Create a Sphere, whose topology is obtained as regular subdivision of an icosahedron.

Parameters:

radius : float = 1

Radius: Radius of the sphere

subdiv : int = 3

Subdiv. Level: Number of the recursive subdivision of the surface. Default is 3 (a sphere approximation composed by 1280 faces).
Admitted values are in the range 0 (an icosahedron) to 8 (a 1.3 MegaTris approximation of a sphere)

sphere_cap¶

MeshLab filter name: ‘Sphere Cap’

Create a Sphere Cap, or spherical dome, subtended by a cone of given angle

Parameters:

angle : float = 60

Angle: Angle of the cone subtending the cap. It must be < 180

subdiv : int = 3

Subdiv. Level: Number of the recursive subdivision of the surface. Default is 3 (a sphere approximation composed by 1280 faces).
Admitted values are in the range 0 (an icosahedron) to 8 (a 1.3 MegaTris approximation of a sphere)

split_in_connected_components¶

MeshLab filter name: ‘Split in Connected Components’

Split current Layer into many layers, one for each connected components

stratified_triangle_sampling¶

MeshLab filter name: ‘Stratified Triangle Sampling’

Create a new layer populated with a point sampling of the current mesh; to generate multiple samples inside a triangle each triangle is subdivided according to various stratified strategies. Distribution is often biased by triangle shape.

Parameters:

samplenum : int = 100000

Number of samples: The desired number of samples. It can be smaller or larger than the mesh size, and according to the chosen sampling strategy it will try to adapt.

sampling : str = 'Similar Triangle' (or int = 0)

Possible enum values:

'Similar Triangle'

'Dual Similar Triangle'

'Long Edge Subdiv'

'Sample Edges'

'Sample NonFaux Edges'

Element to sample:: Similar Triangle: each triangle is subdivided into similar triangles and the internal vertices of these triangles are considered. This sampling leave space around edges and vertices for separate sampling of these entities.
Dual Similar Triangle: each triangle is subdivided into similar triangles and the internal vertices of these triangles are considered.
Long Edge Subdiv each triangle is recursively subdivided along the longest edge.
Sample Edges Only the edges of the mesh are uniformly sampled.
Sample NonFaux Edges Only the non-faux edges of the mesh are uniformly sampled.

random : bool = False

Random Sampling: if true, for each (virtual) face we draw a random point, otherwise we pick the face midpoint.

structure_synth_mesh_creation¶

MeshLab filter name: ‘Structure Synth Mesh Creation’

Structure Synth mesh creation based on Eisen Script.
For further instruction visit http://structuresynth.sourceforge.net/reference.php

Parameters:

grammar : str = 'set maxdepth 40 R1 R2 rule R1 { { x 1 rz 6 ry 6 s 0.99 } R1 { s 2 } sphere } rule R2 {{ x -1 rz 6 ry 6 s 0.99 } R2 { s 2 } sphere} '

Eisen Script grammar: Write a grammar according to Eisen Script specification and using the primitives box, sphere, mesh, dot and triangle

seed : int = 1

seed for random construction: Seed needed to build the mesh

sphereres : int = 1

set maximum resolution of sphere primitives, it must be included between 1 and 4: increasing the resolution of the spheres will improve the quality of the mesh

subdivision_surfaces_butterfly_subdivision¶

MeshLab filter name: ‘Subdivision Surfaces: Butterfly Subdivision’

Apply Butterfly Subdivision Surface algorithm. It is an interpolated refinement method, defined on arbitrary triangular meshes. The scheme is known to be C1 but not C2 on regular meshes

Parameters:

iterations : int = 3

Iterations: Number of time the model is subdivided.

threshold : Percentage = 1%

Edge Threshold: All the edges longer than this threshold will be refined.
Setting this value to zero will force an uniform refinement.

selected : bool = False

Affect only selected faces: If selected the filter affect only the selected faces

subdivision_surfaces_catmull_clark¶

MeshLab filter name: ‘Subdivision Surfaces: Catmull-Clark’

Apply the Catmull-Clark Subdivision Surfaces. Note that position of the new vertices is simply linearly interpolated. If the mesh is triangle based (no faux edges) it generates a quad mesh, otherwise it honores it the faux-edge bits

subdivision_surfaces_loop¶

MeshLab filter name: ‘Subdivision Surfaces: Loop’

Apply Loop's Subdivision Surface algorithm. It is an approximant refinement method and it works for every triangle and has rules for extraordinary vertices.

Parameters:

loopweight : str = 'Loop' (or int = 0)

Possible enum values:

'Loop'

'Enhance regularity'

'Enhance continuity'

Weighting scheme: Change the weights used. Allows one to optimize some behaviors over others.

iterations : int = 3

Iterations: Number of time the model is subdivided.

threshold : Percentage = 1%

Edge Threshold: All the edges longer than this threshold will be refined.
Setting this value to zero will force an uniform refinement.

selected : bool = False

Affect only selected faces: If selected the filter affect only the selected faces

subdivision_surfaces_ls3_loop¶

MeshLab filter name: ‘Subdivision Surfaces: LS3 Loop’

Apply LS3 Subdivision Surface algorithm using Loop's weights. This refinement method take normals into account.
See:Boye', S. Guennebaud, G. & Schlick, C.
Least squares subdivision surfaces
Computer Graphics Forum, 2010.

Alternatives weighting schemes are based on the paper: Barthe, L. & Kobbelt, L.
Subdivision scheme tuning around extraordinary vertices
Computer Aided Geometric Design, 2004, 21, 561-583.
The current implementation of these schemes don't handle vertices of valence > 12

Parameters:

loopweight : str = 'Loop' (or int = 0)

Possible enum values:

'Loop'

'Enhance regularity'

'Enhance continuity'

Weighting scheme: Change the weights used. Allows one to optimize some behaviors over others.

iterations : int = 3

Iterations: Number of time the model is subdivided.

threshold : Percentage = 1%

Edge Threshold: All the edges longer than this threshold will be refined.
Setting this value to zero will force an uniform refinement.

selected : bool = False

Affect only selected faces: If selected the filter affect only the selected faces

subdivision_surfaces_midpoint¶

MeshLab filter name: ‘Subdivision Surfaces: Midpoint’

Apply a plain subdivision scheme where every edge is split on its midpoint. Useful to uniformly refine a mesh substituting each triangle with four smaller triangles.

Parameters:

iterations : int = 3

Iterations: Number of time the model is subdivided.

threshold : Percentage = 1%

Edge Threshold: All the edges longer than this threshold will be refined.
Setting this value to zero will force an uniform refinement.

selected : bool = False

Affect only selected faces: If selected the filter affect only the selected faces

surface_reconstruction_ball_pivoting¶

MeshLab filter name: ‘Surface Reconstruction: Ball Pivoting’

Given a point cloud with normals it reconstructs a surface using the Ball Pivoting Algorithm.Starting with a seed triangle, the BPA algorithm pivots a ball of the given radius around the already formed edgesuntil it touches another point, forming another triangle. The process continues until all reachable edges have been tried.This surface reconstruction algorithm uses the existing points without creating new ones. Works better with uniformly sampled point clouds. If needed first perform a poisson disk subsampling of the point cloud.
Bernardini F., Mittleman J., Rushmeier H., Silva C., Taubin G.
The ball-pivoting algorithm for surface reconstruction.
IEEE TVCG 1999

Parameters:

ballradius : Percentage = 0%

Pivoting Ball radius (0 autoguess): The radius of the ball pivoting (rolling) over the set of points. Gaps that are larger than the ball radius will not be filled; similarly the small pits that are smaller than the ball radius will be filled.

clustering : float = 20

Clustering radius (% of ball radius): To avoid the creation of too small triangles, if a vertex is found too close to a previous one, it is clustered/merged with it.

creasethr : float = 90

Angle Threshold (degrees): If we encounter a crease angle that is too large we should stop the ball rolling

deletefaces : bool = False

Delete initial set of faces: if true all the initial faces of the mesh are deleted and the whole surface is rebuilt from scratch. Otherwise the current faces are used as a starting point. Useful if you run the algorithm multiple times with an increasing ball radius.

surface_reconstruction_screened_poisson¶

MeshLab filter name: ‘Surface Reconstruction: Screened Poisson’

This surface reconstruction algorithm creates watertight surfaces from oriented point sets.
The filter uses the original code of Michael Kazhdan and Matthew Bolitho implementing the algorithm described in the following paper:
Michael Kazhdan, Hugues Hoppe,
"Screened Poisson surface reconstruction"

Parameters:

visiblelayer : bool = False

Merge all visible layers: Enabling this flag means that all the visible layers will be used for providing the points.

depth : int = 8

Reconstruction Depth: This integer is the maximum depth of the tree that will be used for surface reconstruction. Running at depth d corresponds to solving on a voxel grid whose resolution is no larger than 2^d x 2^d x 2^d. Note that since the reconstructor adapts the octree to the sampling density, the specified reconstruction depth is only an upper bound. The default value for this parameter is 8.

fulldepth : int = 5

Adaptive Octree Depth: This integer specifies the depth beyond depth the octree will be adapted. At coarser depths, the octree will be complete, containing all 2^d x 2^d x 2^d nodes. The default value for this parameter is 5.

cgdepth : int = 0

Conjugate Gradients Depth: This integer is the depth up to which a conjugate-gradients solver will be used to solve the linear system. Beyond this depth Gauss-Seidel relaxation will be used. The default value for this parameter is 0.

scale : float = 1.1

Scale Factor: This floating point value specifies the ratio between the diameter of the cube used for reconstruction and the diameter of the samples' bounding cube. The default value is 1.1.

samplespernode : float = 1.5

Minimum Number of Samples: This floating point value specifies the minimum number of sample points that should fall within an octree node as the octree construction is adapted to sampling density. For noise-free samples, small values in the range [1.0 - 5.0] can be used. For more noisy samples, larger values in the range [15.0 - 20.0] may be needed to provide a smoother, noise-reduced, reconstruction. The default value is 1.5.

pointweight : float = 4

Interpolation Weight: This floating point value specifies the importants that interpolation of the point samples is given in the formulation of the screened Poisson equation. The results of the original (unscreened) Poisson Reconstruction can be obtained by setting this value to 0. The default value for this parameter is 4.

iters : int = 8

Gauss-Seidel Relaxations: This integer value specifies the number of Gauss-Seidel relaxations to be performed at each level of the hierarchy. The default value for this parameter is 8.

confidence : bool = False

Confidence Flag: Enabling this flag tells the reconstructor to use the quality as confidence information; this is done by scaling the unit normals with the quality values. When the flag is not enabled, all normals are normalized to have unit-length prior to reconstruction.

preclean : bool = False

Pre-Clean: Enabling this flag force a cleaning pre-pass on the data removing all unreferenced vertices or vertices with null normals.

surface_reconstruction_vcg¶

MeshLab filter name: ‘Surface Reconstruction: VCG’

The surface reconstrction algorithm that have been used for a long time inside the ISTI-Visual Computer Lab.It is mostly a variant of the Curless et al. e.g. a volumetric approach with some original weighting schemes,a different expansion rule, and another approach to hole filling through volume dilation/relaxations.
The filter is applied to ALL the visible layers. In practice, all the meshes/point clouds that are currently visible are used to build the volumetric distance field.

Parameters:

voxsize : Percentage = 1%

Voxel Side: VoxelSide

subdiv : int = 1

SubVol Splitting: The level of recursive splitting of the subvolume reconstruction process. A value of '3' means that a 3x3x3 regular space subdivision is created and the reconstruction process generate 8 matching meshes. It is useful for reconsruction objects at a very high resolution. Default value (1) means no splitting.

geodesic : float = 2

Geodesic Weighting: The influence of each range map is weighted with its geodesic distance from the borders. In this way when two (or more ) range maps overlaps their contribution blends smoothly hiding possible misalignments.

openresult : bool = True

Show Result: if not checked the result is only saved into the current directory

smoothnum : int = 1

Volume Laplacian iter: How many volume smoothing step are performed to clean out the eventually noisy borders

widenum : int = 3

Widening: How many voxel the field is expanded. Larger this value more holes will be filled

mergecolor : bool = False

Vertex Splatting: This option use a different way to build up the volume, instead of using rasterization of the triangular face it splat the vertices into the grids. It works under the assumption that you have at least one sample for each voxel of your reconstructed volume.

simplification : bool = False

Post Merge simplification: After the merging an automatic simplification step is performed.

normalsmooth : int = 3

PreSmooth iter: How many times, before converting meshes into volume, the normal of the surface are smoothed. It is useful only to get more smooth expansion in case of noisy borders.

taubin_smooth¶

MeshLab filter name: ‘Taubin Smooth’

The λ-μ Taubin smoothing, combines two steps of low-pass filtering for each iteration. Based on the article:
A signal processing approach to fair surface design by Gabriel Taubin, SIGGRAPH 1995
doi:10.1145/218380.218473

Parameters:

lambda_ : float = 0.5

Lambda: The lambda parameter of the Taubin Smoothing algorithm

mu : float = -0.53

mu: The mu parameter of the Taubin Smoothing algorithm

stepsmoothnum : int = 10

Smoothing steps: The number of times that the taubin smoothing is iterated. Usually it requires a larger number of iteration than the classical laplacian

selected : bool = False

Affect only selected faces: If checked the filter is performed only on the selected faces

tetrahedron¶

MeshLab filter name: ‘Tetrahedron’

Create a Tetrahedron

texel_sampling¶

MeshLab filter name: ‘Texel Sampling’

Create a new layer with a point sampling of the current mesh, a sample for each texel of the mesh is generated

Parameters:

texturew : int = 512

Texture Width: A sample for each texel is generated, so the desired texture size is need, only samples for the texels falling inside some faces are generated.
Setting this param to 256 means that you get at most 256x256 = 65536 samples).
If this parameter is 0 the size of the current texture is chosen.

textureh : int = 512

Texture Height: A sample for each texel is generated, so the desired texture size is need, only samples for the texels falling inside some faces are generated.
Setting this param to 256 means that you get at most 256x256 = 65536 samples)

texturespace : bool = False

UV Space Sampling: The generated texel samples have their UV coords as point positions. The resulting point set is has a square domain, the texels/points, even if on a flat domain retain the original vertex normal to help a better perception of the original provenience.

recovercolor : bool = False

RecoverColor: The generated point cloud has the current texture color

torus¶

MeshLab filter name: ‘Torus’

Create a Torus

Parameters:

hradius : float = 3

Horizontal Radius: Radius of the whole horizontal ring of the torus

vradius : float = 1

Vertical Radius: Radius of the vertical section of the ring

hsubdiv : int = 24

Horizontal Subdivision: Subdivision step of the ring

vsubdiv : int = 12

Vertical Subdivision: Number of sides of the polygonal approximation of the torus section

transfer_color_face_to_vertex¶

MeshLab filter name: ‘Transfer Color: Face to Vertex’

Face to Vertex color transfer

transfer_color_mesh_to_face¶

MeshLab filter name: ‘Transfer Color: Mesh to Face’

Mesh to Face color transfer

Parameters:

allvisiblemesh : bool = False

Apply to all Meshes: If true the color mapping is applied to all the meshes.

transfer_color_texture_to_vertex¶

MeshLab filter name: ‘Transfer Color: Texture to Vertex’

Texture to Vertex color transfer

transfer_color_vertex_to_face¶

MeshLab filter name: ‘Transfer Color: Vertex to Face’

Vertex to Face color transfer

transfer_texture_to_vertex_color_1_or_2_meshes¶

MeshLab filter name: ‘Transfer: Texture to Vertex Color (1 or 2 meshes)’

Generates Vertex Color values picking color from a texture (same mesh or another mesh).

Parameters:

sourcemesh : int = 0

Source Mesh: The mesh with associated texture that we want to sample from

targetmesh : int = 0

Target Mesh: The mesh whose vertex color will be filled according to source mesh texture

upperbound : Percentage = 2%

Max Dist Search: Sample points for which we do not find anything within this distance are rejected and not considered for recovering color

transfer_vertex_attributes_to_texture_1_or_2_meshes¶

MeshLab filter name: ‘Transfer: Vertex Attributes to Texture (1 or 2 meshes)’

Transfer texture color, vertex color or normal from one mesh the texture of another mesh. This may be useful to restore detail lost in simplification, or resample a texture in a different parametrization.

Parameters:

sourcemesh : int = 0

Source Mesh: The mesh that contains the source data that we want to transfer

targetmesh : int = 0

Target Mesh: The mesh whose texture will be filled according to source mesh data

attributeenum : str = 'Vertex Color' (or int = 0)

Possible enum values:

'Vertex Color'

'Vertex Normal'

'Vertex Quality'

'Texture Color'

Color Data Source: Choose what attribute has to be transferred onto the target texture. You can choose bettween Per vertex attributes (color,normal,quality) or to transfer color information from source mesh texture

upperbound : Percentage = 2%

Max Dist Search: Sample points for which we do not find anything within this distance are rejected and not considered for recovering data

textname : str = 'cube_tex.png'

Texture file: The texture file to be created

textw : int = 1024

Texture width (px): The texture width

texth : int = 1024

Texture height (px): The texture height

overwrite : bool = False

Overwrite Target Mesh Texture: if target mesh has a texture will be overwritten (with provided texture dimension)

assign : bool = False

Assign Texture: assign the newly created texture to target mesh

pullpush : bool = True

Fill texture: if enabled the unmapped texture space is colored using a pull push filling algorithm, if false is set to black

transfer_vertex_color_to_texture¶

MeshLab filter name: ‘Transfer: Vertex Color to Texture’

Fills the specified texture using per-vertex color data of the mesh.

Parameters:

textname : str = 'cube_tex.png'

Texture file: The texture file to be created

textw : int = 1024

Texture width (px): The texture width

texth : int = 1024

Texture height (px): The texture height

overwrite : bool = False

Overwrite texture: if current mesh has a texture will be overwritten (with provided texture dimension)

assign : bool = False

Assign texture: assign the newly created texture

pullpush : bool = True

Fill texture: if enabled the unmapped texture space is colored using a pull push filling algorithm, if false is set to black

transform_align_to_principal_axis¶

MeshLab filter name: ‘Transform: Align to Principal Axis’

Generate a matrix transformation that rotates the mesh aligning it to its principal axis of inertia.If the mesh is watertight the Itertia tensor is computed assuming the interior of the mesh has a uniform density.In case of an open mesh or a point clouds the inerta tensor is computed assuming each vertex is a constant puntual mass.

Parameters:

pointsflag : bool = True

Use vertex: If selected, only the vertices of the mesh are used to compute the Principal Axis. Mandatory for point clouds or for non water tight meshes

freeze : bool = True

Freeze Matrix: The transformation is explicitly applied, and the vertex coordinates are actually changed

alllayers : bool = False

Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

transform_flip_and_or_swap_axis¶

MeshLab filter name: ‘Transform: Flip and/or swap axis’

Generate a matrix transformation that flips each one of the axis or swaps a couple of axis. The listed transformations are applied in that order. This kind of transformation cannot be applied to set of Raster!

Parameters:

flipx : bool = False

Flip X axis: If selected the axis will be swapped (mesh mirrored along the YZ plane

flipy : bool = False

Flip Y axis: If selected the axis will be swapped (mesh mirrored along the XZ plane

flipz : bool = False

Flip Z axis: If selected the axis will be swapped (mesh mirrored along the XY plane

swapxy : bool = False

Swap X-Y axis: If selected the two axis will be swapped. All the swaps are performed in this order

swapxz : bool = False

Swap X-Z axis: If selected the two axis will be swapped. All the swaps are performed in this order

swapyz : bool = False

Swap Y-Z axis: If selected the two axis will be swapped. All the swaps are performed in this order

freeze : bool = True

Freeze Matrix: The transformation is explicitly applied, and the vertex coordinates are actually changed

alllayers : bool = False

Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

transform_rotate¶

MeshLab filter name: ‘Transform: Rotate’

Generate a matrix transformation that rotates the mesh. The mesh can be rotated around one of the axis or a given axis and w.r.t. to the origin or the baricenter, or a given point.

Parameters:

rotaxis : str = 'X axis' (or int = 0)

Possible enum values:

'X axis'

'Y axis'

'Z axis'

'custom axis'

Rotation on:: Choose a method

rotcenter : str = 'origin' (or int = 0)

Possible enum values:

'origin'

'barycenter'

'custom point'

Center of rotation:: Choose a method

angle : float (bounded) = 0 [min: -360; max: 360]

Rotation Angle: Angle of rotation (in degree). If snapping is enabled this value is rounded according to the snap value

customaxis : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

Custom axis: This rotation axis is used only if the 'custom axis' option is chosen.

customcenter : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

Custom center: This rotation center is used only if the 'custom point' option is chosen.

snapflag : bool = False

Snap angle: If selected, before starting the filter will remove any unreferenced vertex (for which curvature values are not defined)

snapangle : float = 30

Snapping Value: This value is used to snap the rotation angle (i.e. if the snapping value is 30, 227 becomes 210).

freeze : bool = True

Freeze Matrix: The transformation is explicitly applied, and the vertex coordinates are actually changed

alllayers : bool = False

Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

transform_rotate_camera_or_set_of_cameras¶

MeshLab filter name: ‘Transform: Rotate Camera or set of cameras’

Rotate the camera, or all the cameras of the project. The selected raster is the reference if viewpoint rotation is selected.

Parameters:

camera : str = 'Raster Camera' (or int = 0)

Possible enum values:

'Raster Camera'

'Mesh Camera'

Camera type: Choose the camera to scale

rotaxis : str = 'X axis' (or int = 0)

Possible enum values:

'X axis'

'Y axis'

'Z axis'

'custom axis'

Rotation on:: Choose a method

rotcenter : str = 'origin' (or int = 0)

Possible enum values:

'origin'

'camera viewpoint'

'custom point'

Center of rotation:: Choose a method

angle : float (bounded) = 0 [min: -360; max: 360]

Rotation Angle: Angle of rotation (in degree). If snapping is enabled this value is rounded according to the snap value

customaxis : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

Custom axis: This rotation axis is used only if the 'custom axis' option is chosen.

customcenter : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

Custom center: This rotation center is used only if the 'custom point' option is chosen.

toallraster : bool = False

Apply to all active Raster layers: Apply the same scaling to all the active Raster layers: it is taken into account only if 'Raster Camera' is selected

toall : bool = False

Apply to all active Raster and visible Mesh layers: Apply the same scaling to all the layers, including any visible 3D layer

transform_rotate_to_fit_to_a_plane¶

MeshLab filter name: ‘Transform: Rotate to Fit to a plane’

Generate a matrix transformation that rotates the mesh so that the selection fits one of the main planes XY YZ ZX. May also translate such that the selection centroid rest on the origin. It reports on the log the average error of the fitting (in mesh units).

Parameters:

targetplane : str = 'XY plane' (or int = 0)

Possible enum values:

'XY plane'

'YZ plane'

'ZX plane'

Rotate to fit:: Choose the plane where the selection will fit

rotaxis : str = 'any axis' (or int = 0)

Possible enum values:

'any axis'

'X axis'

'Y axis'

'Z axis'

Rotate on:: Choose on which axis do the rotation: 'any axis' guarantee the best fit of the selection to the plane, only use X,Y or Z it if you want to preserve that specific axis.

toorigin : bool = True

Move to Origin: Also apply a translation, such that the centroid of selection rests on the Origin

freeze : bool = True

Freeze Matrix: The transformation is explicitly applied, and the vertex coordinates are actually changed

alllayers : bool = False

Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

transform_scale_camera_or_set_of_cameras¶

MeshLab filter name: ‘Transform: Scale Camera or set of cameras’

Scale the camera, or all the cameras of the project. The selected raster is the reference if viewpoint scaling is selected.

Parameters:

camera : str = 'Raster Camera' (or int = 0)

Possible enum values:

'Raster Camera'

'Mesh Camera'

Camera type: Choose the camera to scale

scalecenter : str = 'origin' (or int = 0)

Possible enum values:

'origin'

'camera viewpoint'

'custom point'

Center of scaling:: Choose a method

customcenter : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

Custom center: This scaling center is used only if the 'custom point' option is chosen.

scale : float = 1

Scale factor: The scale factor that has to be applied to the camera

toallraster : bool = False

Apply to all active Raster layers: Apply the same scaling to all the active Raster layers: it is taken into account only if 'Raster Camera' is selected

toall : bool = False

Apply to all active Raster and visible Mesh layers: Apply the same scaling to all the layers, including any visible 3D layer

transform_scale_normalize¶

MeshLab filter name: ‘Transform: Scale, Normalize’

Generate a matrix transformation that scale the mesh. The mesh can be also automatically scaled to a unit side box.

Parameters:

axisx : float = 1

X Axis: Scaling

axisy : float = 1

Y Axis: Scaling

axisz : float = 1

Z Axis: Scaling

uniformflag : bool = True

Uniform Scaling: If selected an uniform scaling (the same for all the three axis) is applied (the X axis value is used)

scalecenter : str = 'origin' (or int = 0)

Possible enum values:

'origin'

'barycenter'

'custom point'

Center of scaling:: Choose a method

customcenter : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

Custom center: This scaling center is used only if the 'custom point' option is chosen.

unitflag : bool = False

Scale to Unit bbox: If selected, the object is scaled to a box whose sides are at most 1 unit length

freeze : bool = True

Freeze Matrix: The transformation is explicitly applied, and the vertex coordinates are actually changed

alllayers : bool = False

Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

transform_the_camera_extrinsics_or_all_the_cameras_of_the_project¶

MeshLab filter name: ‘Transform the camera extrinsics, or all the cameras of the project.’

Transform the camera extrinsics, or all the cameras of the project.

Parameters:

transformmatrix : numpy.ndarray[numpy.float64[4, 4]] = [[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, 1, 0],[0, 0, 0, 1]]

:

camera : str = 'Raster Camera' (or int = 0)

Possible enum values:

'Raster Camera'

'Mesh Camera'

Camera type: Choose the camera to scale

behaviour : str = 'The matrix is the transformation to apply to the extrinsics' (or int = 0)

Possible enum values:

'The matrix is the transformation to apply to the extrinsics'

'The matrix represent the new extrinsics'

Matrix semantic: What the matrix is used for

toallraster : bool = False

Apply to all active Raster layers: Apply the same scaling to all the active Raster layers: it is taken into account only if 'Raster Camera' is selected

toall : bool = False

Apply to all active Raster and visible Mesh layers: Apply the same scaling to all the layers, including any visible 3D layer

transform_translate_camera_or_set_of_cameras¶

MeshLab filter name: ‘Transform: Translate Camera or set of cameras’

Translate the camera, or all the cameras of the project.

Parameters:

camera : str = 'Raster Camera' (or int = 0)

Possible enum values:

'Raster Camera'

'Mesh Camera'

Camera type: Choose the camera to scale

axisx : float (bounded) = 0 [min: -1000; max: 1000]

X Axis: Absolute translation amount along the X axis

axisy : float (bounded) = 0 [min: -1000; max: 1000]

Y Axis: Absolute translation amount along the Y axis

axisz : float (bounded) = 0 [min: -1000; max: 1000]

Z Axis: Absolute translation amount along the Z axis

centerflag : bool = False

translate viewpoint position to the origin: If selected, the camera viewpoint is translated to the origin

toallraster : bool = False

Apply to all active Raster layers: Apply the same scaling to all the active Raster layers: it is taken into account only if 'Raster Camera' is selected

toall : bool = False

Apply to all active Raster and Mesh layers: Apply the same scaling to all the layers, including any visible 3D layer

transform_translate_center_set_origin¶

MeshLab filter name: ‘Transform: Translate, Center, set Origin’

Generate a matrix transformation that translate the mesh. The mesh can be translated around one of the axis or a given axis and w.r.t. to the origin or the baricenter, or a given point.

Parameters:

traslmethod : str = 'XYZ translation' (or int = 0)

Possible enum values:

'XYZ translation'

'Center on Scene BBox'

'Center on Layer BBox'

'Set new Origin'

Transformation:: [XYZ translation] adds X,Y and Z offset to Layer transformation, [Center on BBox] moves Layer Origin to the Bounding Box center, [Set new Origin] moves Layer Origin to a specific point

axisx : float (bounded) = 0 [min: -17.3205; max: 17.3205]

X Axis: when using [XYZ translation], amount of translation along the X axis (in model units)

axisy : float (bounded) = 0 [min: -17.3205; max: 17.3205]

Y Axis: when using [XYZ translation], amount of translation along the Y axis (in model units)

axisz : float (bounded) = 0 [min: -17.3205; max: 17.3205]

Z Axis: when using [XYZ translation], amount of translation along the Z axis (in model units)

neworigin : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

New Origin:: when using [Set new Origin], this is the location of the new Origin.

freeze : bool = True

Freeze Matrix: The transformation is explicitly applied, and the vertex coordinates are actually changed

alllayers : bool = False

Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

tri_to_quad_by_4_8_subdivision¶

MeshLab filter name: ‘Tri to Quad by 4-8 Subdivision’

Convert a tri mesh into a quad mesh by applying a 4-8 subdivision scheme.It introduces less overhead than the plain Catmull-Clark Subdivision Surfaces(it adds only a single vertex for each triangle instead of four).
See:
4-8 Subdivision
Luiz Velho, Denis Zorin
CAGD, volume 18, Issue 5, Pages 397-427.

tri_to_quad_by_smart_triangle_pairing¶

MeshLab filter name: ‘Tri to Quad by smart triangle pairing’

Convert a tri-mesh into a quad mesh by pairing triangles.

turn_into_a_pure_triangular_mesh¶

MeshLab filter name: ‘Turn into a Pure-Triangular mesh’

Convert into a tri-mesh by splitting any polygonal face.

turn_into_quad_dominant_mesh¶

MeshLab filter name: ‘Turn into Quad-Dominant mesh’

Convert a tri-mesh into a quad-dominant mesh by pairing suitable triangles.

Parameters:

level : str = 'Fewest triangles' (or int = 0)

Possible enum values:

'Fewest triangles'

'(in between)'

'Better quad shape'

Optimize For:: Choose any of three different greedy strategies.

twostep_smooth¶

MeshLab filter name: ‘TwoStep Smooth’

Two Steps Smoothing, a feature preserving/enhancing fairing filter based on two stages:

Normal Smoothing, where similar normals are averaged together.
Vertex reposition, where vertices are moved to fit on the new normals.

A Comparison of Mesh Smoothing Methods by A. Belyaev and Y. Ohtake. Proc. Israel-Korea Bi-National Conf. Geometric Modeling and Computer Graphics, pp. 83-87, 2003.
publication

Parameters:

stepsmoothnum : int = 3

Smoothing steps: The number of times that the whole algorithm (normal smoothing + vertex fitting) is iterated.

normalthr : float = 60

Feature Angle Threshold (deg): Specify a threshold angle (0..90) for features that you want to be preserved.
Features forming angles LARGER than the specified threshold will be preserved.
0 -> no smoothing
90 -> all faces will be smoothed

stepnormalnum : int = 20

Normal Smoothing steps: Number of iterations of normal smoothing step. The larger the better and (the slower)

stepfitnum : int = 20

Vertex Fitting steps: Number of iterations of the vertex fitting procedure.

selected : bool = False

Affect only selected faces: If checked the filter is performed only on the selected faces

uniform_mesh_resampling¶

MeshLab filter name: ‘Uniform Mesh Resampling’

Create a new mesh that is a resampled version of the current one.
The resampling is done by building a uniform volumetric representation where each voxel contains the signed distance from the original surface. The resampled surface is reconstructed using the marching cube algorithm over this volume.

Parameters:

cellsize : Percentage = 2%

Precision: Size of the cell, the default is 1/50 of the box diag. Smaller cells give better precision at a higher computational cost. Remember that halving the cell size means that you build a volume 8 times larger.

offset : Percentage = 50%

Offset: Offset of the created surface (i.e. distance of the created surface from the original one).
If offset is zero, the created surface passes on the original mesh itself. Values greater than zero mean an external surface, and lower than zero mean an internal surface.
In practice this value is the threshold passed to the Marching Cube algorithm to extract the isosurface from the distance field representation.

mergeclosevert : bool = False

Clean Vertices: If true the mesh generated by MC will be cleaned by unifying vertices that are almost coincident

discretize : bool = False

Discretize: If true the position of the intersected edge of the marching cube grid is not computed by linear interpolation, but it is placed in fixed middle position. As a consequence the resampled object will look severely aliased by a stairstep appearance.
Useful only for simulating the output of 3D printing devices.

multisample : bool = False

Multi-sample: If true the distance field is more accurately compute by multisampling the volume (7 sample for each voxel). Much slower but less artifacts.

absdist : bool = False

Absolute Distance: If true a not signed distance field is computed. In this case you have to choose a not zero Offset and a double surface is built around the original surface, inside and outside. Is useful to convrt thin floating surfaces into solid, thick meshes.. t

unsharp_mask_color¶

MeshLab filter name: ‘UnSharp Mask Color’

Apply Unsharp filter to the vertex color, putting in more evidence color variations.
See Unsharp Masking

Parameters:

weight : float = 0.3

Unsharp Weight: the unsharp weight w_u in the unsharp mask equation:
w_oorig + w_u (orig - lowpass)

weightorig : float = 1

Original Color Weight: How much the original signal is used, e.g. the weight w_o in the above unsharp mask equation
Usually you should not need to change the default 1.0 value.

iterations : int = 5

Smooth Iterations: number of iterations of laplacian smooth in every run

unsharp_mask_geometry¶

MeshLab filter name: ‘UnSharp Mask Geometry’

Apply Unsharp filter to geometric shape, putting in more evidence ridges and valleys variations.
Unsharp Masking

Parameters:

weight : float = 0.3

Unsharp Weight: the unsharp weight w_u in the unsharp mask equation:
w_oorig + w_u (orig - lowpass)

weightorig : float = 1

Original Weight: How much the original signal is used, e.g. the weight w_o in the above unsharp mask equation
Usually you should not need to change the default 1.0 value.

iterations : int = 5

Smooth Iterations: number of iterations of laplacian smooth in every run

unsharp_mask_normals¶

MeshLab filter name: ‘UnSharp Mask Normals’

Unsharp mask filtering of the normals per face, putting in more evidence normal variations.
A simple normal enhancement technique for interactive non-photorealistic renderings by Cignoni, Scopigno and Tarini, Comput Graph, 29 (1) (2005)
doi:10.1016/j.cag.2004.11.012

Parameters:

recalc : bool = False

Recompute Normals: Recompute normals from scratch before the unsharp masking

weight : float = 0.3

Unsharp Weight: the unsharp weight w_u in the unsharp mask equation:
w_oorig + w_u (orig - lowpass)

weightorig : float = 1

Original Weight: How much the original signal is used, e.g. the weight w_o in the above unsharp mask equation.
Usually you should not need to change the default 1.0 value.

iterations : int = 5

Smooth Iterations: number of laplacian face smooth iterations in every run

unsharp_mask_quality¶

MeshLab filter name: ‘UnSharp Mask Quality’

Apply Unsharp filter to values of quality per vertex.
See Unsharp Masking

Parameters:

weight : float = 0.3

Unsharp Weight: the unsharp weight w_u in the unsharp mask equation:
w_oorig + w_u (orig - lowpass)

weightorig : float = 1

Original Weight: How much the original signal is used, e.g. the weight w_o in the above unsharp mask equation
Usually you should not need to change the default 1.0 value.

iterations : int = 5

Smooth Iterations: number of iterations of laplacian smooth in every run

vertex_attribute_seam¶

MeshLab filter name: ‘Vertex Attribute Seam’

Make all selected vertex attributes connectivity-independent:
vertices are duplicated whenever two or more selected wedge or face attributes do not match.
This is particularly useful for GPU-friendly mesh layout, where a single index must be used to access all required vertex attributes.

Parameters:

normalmode : str = 'None' (or int = 0)

Possible enum values:

'None'

'Vertex'

'Wedge'

'Face'

Normal Source:: Choose a method

colormode : str = 'None' (or int = 0)

Possible enum values:

'None'

'Vertex'

'Wedge'

'Face'

Color Source:: Choose a method

texcoordmode : str = 'None' (or int = 0)

Possible enum values:

'None'

'Vertex'

'Wedge'

Texcoord Source:: Choose a method

vertex_attribute_transfer¶

MeshLab filter name: ‘Vertex Attribute Transfer’

Transfer the chosen per-vertex attributes from one layer to another. Useful to transfer attributes to different representations of a same object.
For each vertex of the target mesh the closest point (not vertex!) on the source mesh is computed, and the requested interpolated attributes from that source point are copied into the target vertex.
The algorithm assumes that the two meshes are reasonably similar and aligned.

Parameters:

sourcemesh : int = 0

Source Mesh: The mesh that contains the source data that we want to transfer.

targetmesh : int = 0

Target Mesh: The mesh whose vertices will receive the data from the source.

geomtransfer : bool = False

Transfer Geometry: if enabled, the position of each vertex of the target mesh will be snapped onto the corresponding closest point on the source mesh

normaltransfer : bool = False

Transfer Normal: if enabled, the normal of each vertex of the target mesh will get the (interpolated) normal of the corresponding closest point on the source mesh

colortransfer : bool = True

Transfer Color: if enabled, the color of each vertex of the target mesh will become the color of the corresponding closest point on the source mesh

qualitytransfer : bool = False

Transfer quality: if enabled, the quality of each vertex of the target mesh will become the quality of the corresponding closest point on the source mesh

selectiontransfer : bool = False

Transfer Selection: if enabled, each vertex of the target mesh will be selected if the corresponding closest point on the source mesh falls in a selected face

qualitydistance : bool = False

Store dist. as quality: if enabled, we store the distance of the transferred value as in the vertex quality

upperbound : Percentage = 2%

Max Dist Search: Sample points for which we do not find anything within this distance are rejected and not considered for recovering attributes.

onselected : bool = False

Only on selection: If checked, only transfer to selected vertices on TARGET mesh

vertex_color_brightness_contrast_gamma¶

MeshLab filter name: ‘Vertex Color Brightness Contrast Gamma’

Change the color the vertices of the mesh adjusting brightness, contrast and gamma.

Parameters:

brightness : float (bounded) = 0 [min: -255; max: 255]

Brightness:: Sets the amount of brightness that will be added/subtracted to the colors.
Brightness = 255 -> all white;
Brightness = -255 -> all black;

contrast : float (bounded) = 0 [min: -255; max: 255]

Contrast factor:: Sets the amount of contrast of the mesh.

gamma : float (bounded) = 1 [min: 0.1; max: 5]

Gamma:: Sets the values of the exponent gamma.

onselected : bool = False

Only on selection: If checked, only affects selected vertices

vertex_color_colourisation¶

MeshLab filter name: ‘Vertex Color Colourisation’

Allows the application of a color to the mesh. In spite of the Fill operation, the color is blended with the mesh according to a given intensity.

Parameters:

hue : float (bounded) = 0 [min: 0; max: 360]

Hue:: Changes the hue of the mesh.

saturation : float (bounded) = 100 [min: 0; max: 100]

Saturation:: Changes the saturation of the mesh.

luminance : float (bounded) = 50 [min: 0; max: 100]

Luminance:: Changes the luminance of the mesh.

intensity : float (bounded) = 50 [min: 0; max: 100]

Blending:: Sets the blending factor used in adding the new color to the existing one.

onselected : bool = False

Only on selection: If checked, only affects selected vertices

vertex_color_desaturation¶

MeshLab filter name: ‘Vertex Color Desaturation’

The filter desaturates the colors of the mesh. This provides a simple way to convert a mesh in gray tones. The user can choose the desaturation method to apply; they are based on Lightness, Luminosity and Average.

Parameters:

method : str = 'Lightness' (or int = 0)

Possible enum values:

'Lightness'

'Luminosity'

'Average'

Desaturation method:: Lightness is computed as (Max(r,g,b)+Min(r,g,b))/2
Luminosity is computed as 0.212*r + 0.715*g + 0.072*b
Average is computed as (r+g+b)/3

onselected : bool = False

Only on selection: If checked, only affects selected vertices

vertex_color_filling¶

MeshLab filter name: ‘Vertex Color Filling’

Fills the color of the vertices of the mesh with a color chosen by the user.

Parameters:

color1 : Color = [0; 0; 0; 255]

Color:: Sets the color to apply to vertices.

onselected : bool = False

Only on selection: If checked, only affects selected vertices

vertex_color_invert¶

MeshLab filter name: ‘Vertex Color Invert’

Inverts the colors of the vertices of the mesh.

Parameters:

onselected : bool = False

Only on selection: If checked, only affects selected vertices

vertex_color_levels_adjustment¶

MeshLab filter name: ‘Vertex Color Levels Adjustment’

The filter allows adjustment of color levels. It is a custom way to map an interval of color into another one. The user can set the input minimum and maximum levels, gamma and the output minimum and maximum levels (many tools call them respectively input black point, white point, gray point, output black point and white point).

Parameters:

gamma : float (bounded) = 1 [min: 0.1; max: 5]

Gamma::

in_min : float (bounded) = 0 [min: 0; max: 255]

Min input level::

in_max : float (bounded) = 255 [min: 0; max: 255]

Max input level::

out_min : float (bounded) = 0 [min: 0; max: 255]

Min output level::

out_max : float (bounded) = 255 [min: 0; max: 255]

Max output level::

rch : bool = True

Red Channel::

gch : bool = True

Green Channel::

bch : bool = True

Blue Channel::

onselected : bool = False

Only on selection: If checked, only affects selected vertices

apply_to_all : bool = False

All visible layers: if true, apply to all visible layers

vertex_color_noise¶

MeshLab filter name: ‘Vertex Color Noise’

Randomly add a small amount of a random base color to the mesh

Parameters:

basecolor : Color = [0; 0; 0; 255]

BaseColor: The base color that is added to the mesh.

percentage : float (bounded) = 0.5 [min: 0; max: 1]

Alpha: The random color is blended with the current one with the specified alpha

frequency : float (bounded) = 20 [min: 1; max: 200]

Noisy Frequency: The frequency of the Noise on the mesh. Higher numbers means smaller spots.

vertex_color_thresholding¶

MeshLab filter name: ‘Vertex Color Thresholding’

Colors the vertices of the mesh using two colors according to a lightness threshold (on the original color).

Parameters:

color1 : Color = [0; 0; 0; 255]

Color 1:: Sets the color to apply below the threshold.

color2 : Color = [255; 255; 255; 255]

Color 2:: Sets the color to apply above the threshold.

threshold : float (bounded) = 128 [min: 0; max: 255]

Threshold:: Vertices with color above the lightness threshold becomes Color 2, the others Color 1.

onselected : bool = False

Only on selection: If checked, only affects selected vertices

vertex_color_white_balance¶

MeshLab filter name: ‘Vertex Color White Balance’

The filter provides a standard white balance transformation. It is done correcting the RGB channels with a factor such that, the brighter color in the mesh, that is supposed to be white, becomes really white.

Parameters:

color : Color = [255; 255; 255; 255]

Unbalanced white: : The color that is supposed to be white.

onselected : bool = False

Only on selection: If checked, only affects selected vertices

vertex_linear_morphing¶

MeshLab filter name: ‘Vertex Linear Morphing’

Morph deformation of current mesh towards a target mesh with the same number of vertices and same vertex ordering. Each vertex of the source mesh is linearly interpolated towards the corresponding vertex on the target mesh using the formula:

result_i = (1-λ)*source_i + λ*target_i

Three-dimensional metamorphosis: a survey
by F. Lazarus and A. Verroust, Visual Computer, 1998
doi:10.1007/s003710050149

Parameters:

targetmesh : int = 0

Target Mesh: The mesh that is the morph target.

percentmorph : float (bounded) = 0 [min: -150; max: 250]

% Morph: The percent you want to morph towards (or away from) the target.
0 means current mesh
100 means targe mesh
<0 and >100 linearly extrapolate between the two mesh

vertex_quality_from_camera¶

MeshLab filter name: ‘Vertex Quality from Camera’

Compute vertex quality using the camera definition, according to viewing angle or distance

Parameters:

depth : bool = True

Depth: Use depth as a factor.

facing : bool = False

ViewAngle: Use cosine of viewing angle as a factor.

clip : bool = False

Clipping: clip values outside the viewport to zero.

normalize : bool = False

normalize: if checked normalize all quality values in range [0..1]

map : bool = False

map into color: if checked map quality generated values into per-vertex color

volumetric_obscurance¶

MeshLab filter name: ‘Volumetric obscurance’

Calculates obscurance coefficients for the mesh. Obscurance is introduced to avoid the disadvantages of both classical ambient term and ambient occlusion. In ambient occlusion, totally occluded parts of the mesh are black. Instead obscurance, despite still based on a perfectly diffuse light coming from everywhere, accounts for multiple bounces of indirect illumination by means of a function of both the openness of a point and the distance to his occluder (if any). Obscurance is inversely proportional to the number of ray casted from the point that hit an occluder and proportional to the distance a ray travels before hitting the occluder. You can control how much the distance factor influences the final result with the obscurance exponenent (see help below). Obscurance is a value in the range [0,1]. For further details see the reference paper:
Iones Krupkin Sbert Zhukov
Fast, Realistic Lighting for Video Games
IEEECG&A 2003

Parameters:

onprimitive : str = 'On vertices' (or int = 0)

Possible enum values:

'On vertices'

'On Faces'

Metric:: Choose whether to trace rays from faces or from vertices.

numberrays : int = 128

Number of rays: : The number of rays that will be casted around the normals.

depthtexturesize : int = 512

Depth texture size: Size of the depth texture for depth peeling. Higher resolutions provide better sampling of the mesh, with a small performance penalty.

peelingiteration : int = 10

Peeling Iteration: Number of depth peeling iteration. Actually is the maximum number of layers that a ray can hit while traversing the mesh. For example, in the case of a sphere, you should specify 2 in this parameter. For a torus, specify 4. For more complex geometry you should run the depth complexity filter to know the exact value.

peelingtolerance : float = 1e-07

Peeling Tolerance: Depth tolerance used during depth peeling. This is the threshold used to differentiate layers between each others.Two elements whose distance is below this value will be considered as belonging to the same layer.

coneangle : float = 120

Cone amplitude: Cone amplitude around normals in degrees. Rays are traced within this cone.

obscuranceexponent : float = 0.1

Obscurance Exponent: This parameter controls the spatial decay term in the obscurance formula. The greater the exponent, the greater the influence of distance; that is: even if a ray is blocked by an occluder its contribution to the obscurance term is non zero, but proportional to this parameter. It turs out that if you choose a value of zero, you get the standard ambient occlusion term. (In this case, only a value of two, in the peeling iteration parameter, has a sense)

volumetric_sampling¶

MeshLab filter name: ‘Volumetric Sampling’

Compute a volumetric sampling over a watertight mesh.

Parameters:

samplesurfradius : Percentage = 0.2%

Surface Sampling Radius: Surface Sampling is used only as an optimization.

samplevolnum : int = 200000

Volume Sample Num.: Number of volumetric samples scattered inside the mesh and used for choosing the voronoi seeds and performing the Lloyd relaxation for having a centroidal voronoi diagram.

poissonfiltering : bool = True

Poisson Filtering: If true the base montecarlo sampling of the volume is filtered to get a poisson disk volumetric distribution.

poissonradius : Percentage = 1%

Poisson Radius: Number of voxel per side in the volumetric representation.

voronoi_filtering¶

MeshLab filter name: ‘Voronoi Filtering’

Compute a Voronoi filtering (Amenta and Bern 1998) with Qhull library (http://www.qhull.org/).

The algorithm calculates a triangulation of the input point cloud without requiring vertex normals.It uses a subset of the Voronoi vertices to remove triangles from the Delaunay triangulation.
After computing the Voronoi diagram, foreach sample point it chooses the two farthest opposite Voronoi vertices.Then computes a Delaunay triangulation of the sample points and the selected Voronoi vertices, and keep only those triangles in witch all three vertices are sample points.

Parameters:

threshold : float (bounded) = 10 [min: 0; max: 2000]

Pole Discard Thr: Threshold used to discard the Voronoi vertices too far from the origin.We discard vertices are further than this factor times the bbox diagonal
Growing values of this value will add more Voronoi vertices for a better tightier surface reconstruction.On the other hand they will increase processing time and could cause numerical problems to the qhull library.

voronoi_sampling¶

MeshLab filter name: ‘Voronoi Sampling’

Compute a sampling over a mesh and perform a Lloyd relaxation.

Parameters:

iternum : int = 10

Iteration: number of iterations

samplenum : int = 10

Sample Num.: Number of samples

radiusvariance : float = 1

Radius Variance: The distance metric will vary along the surface between 1/x and x, linearly according to the scalar field specified by the quality.

colorstrategy : str = 'Seed Distance' (or int = 1)

Possible enum values:

'None'

'Seed Distance'

'Border Distance'

'Region Area'

Color Strategy:

distancetype : str = 'Euclidean' (or int = 0)

Possible enum values:

'Euclidean'

'Quality Weighted'

'Anisotropic'

Distance Type:

preprocessflag : bool = False

Preprocessing:

refinefactor : int = 10

Refinement Factor: To ensure good convergence the mesh should be more complex than the voronoi partitioning. This number affect how much the mesh is refined according to the required number of samples.

perturbprobability : float = 0

Perturbation Probability: To ensure good convergence the mesh should be more complex than the voronoi partitioning. This number affect how much the mesh is refined according to the required number of samples.

perturbamount : float = 0.001

Perturbation Amount: To ensure good convergence the mesh should be more complex than the voronoi partitioning. This number affect how much the mesh is refined according to the required number of samples.

randomseed : int = 0

Random seed: To ensure repeatability you can specify the random seed used. If 0 the random seed is tied to the current clock.

relaxtype : str = 'Squared Distance' (or int = 1)

Possible enum values:

'Geodesic'

'Squared Distance'

'Restricted'

Relax Type: At each relaxation step we search for each voronoi region the new position of the seed. According to the classical LLoyd relaxation strategy it should have been placed onto the barycenter of the region. Over a surface we have two different strategies:
Geodesic: the seed is placed onto the vertex that maximize the geodesic distance from the border of the region
Squared Distance: the seed is placed in the vertex that minimize the squared sum of the distances from all the pints of the region.
Restricted: the seed is placed in the barycenter of current voronoi region. Even if it is outside the surface. During the relaxation process the seed is free to move off the surface in a continuous way. Re-association to vertex is done at the end..

voronoi_scaffolding¶

MeshLab filter name: ‘Voronoi Scaffolding’

Compute a volumetric sampling over a watertight mesh.

Parameters:

samplesurfradius : Percentage = 1%

Surface Sampling Radius: Surface Sampling is used only as an optimization.

samplevolnum : int = 100000

Volume Sample Num.: Number of volumetric samples scattered inside the mesh and used for choosing the voronoi seeds and performing the Lloyd relaxation for having a centroidal voronoi diagram.

voxelres : int = 50

Volume Side Resolution: Number of voxel per side in the volumetric representation.

isothr : float = 1

Width of the entity (in voxel): Number of voxel per side in the volumetric representation.

smoothstep : int = 3

Smooth Step: Number of voxel per side in the volumetric representation.

relaxstep : int = 5

Lloyd Relax Step: Number of Lloyd relaxation step to get a better distribution of the voronoi seeds.

surfflag : bool = True

Add original surface: Number of voxel per side in the volumetric representation.

elemtype : str = 'Edge' (or int = 1)

Possible enum values:

'Seed'

'Edge'

'Face'

Voronoi Element:

voronoi_vertex_coloring¶

MeshLab filter name: ‘Voronoi Vertex Coloring’

Given a Mesh M and a Pointset P, The filter project each vertex of P over M and color M according to the geodesic distance from these projected points. Projection and coloring are done on a per vertex basis.

Parameters:

coloredmesh : int = 0

To be Colored Mesh: The mesh whose surface is colored. For each vertex of this mesh we decide the color according the below parameters.

vertexmesh : int = 0

Vertex Mesh: The mesh whose vertices are used as seed points for the color computation. These seeds point are projected onto the above mesh.

backward : bool = False

BackDistance: If true the mesh is colored according the distance from the frontier of the voonoi diagram induced by the VertexMesh seeds.

load parameters¶

Here are listed all the file formats that can be loaded usingthe functions pmeshlab.MeshSet.load_new_mesh() and pmeshlab.MeshSet.load_current_mesh(), with all the possible parameters that can be accepted by these functions.

3ds

Load 3ds format.

Parameters:

file_name : str = 'file_name.3ds'

File Name: The name of the file to load

apts

Load apts format.

Parameters:

file_name : str = 'file_name.apts'

File Name: The name of the file to load

asc

Load asc format.

Parameters:

file_name : str = 'file_name.asc'

File Name: The name of the file to load

rowtoskip : int = 0

Header Row to be skipped: The number of lines that must be skipped at the beginning of the file.

triangulate : bool = True

Grid triangulation: if true it assumes that the points are arranged in a complete xy grid and it tries to perform a naive height field triangulation of the input data. Length of the lines is detected automatically by searching x jumps. If the input point cloud data is not arranged as a xy regular height field, no triangles are created.

bre

Load bre format.

Parameters:

file_name : str = 'file_name.bre'

File Name: The name of the file to load

pointsonly : bool = False

only import points: Just import points, without triangulation

unify : bool = True

Unify Duplicated Vertices: The STL format is not an vertex-indexed format. Each triangle is composed by independent vertices, so, usually, duplicated vertices should be unified

ctm

Load ctm format.

Parameters:

file_name : str = 'file_name.ctm'

File Name: The name of the file to load

dae

Load dae format.

Parameters:

file_name : str = 'file_name.dae'

File Name: The name of the file to load

es

Load es format.

Parameters:

file_name : str = 'file_name.es'

File Name: The name of the file to load

seed : int = 1

Seed for random mesh generation: write a seed for the random generation of the mesh

maxrec : int = 0

set the maximum recursion: the mesh is built recursively according to the productions of the grammar, so a limit is needed. If set to 0 meshlab will generate the mesh according to the maximum recursion set in the file

sphereres : int = 1

set maximum resolution of sphere primitives, it must be included between 1 and 4: increasing the resolution of the spheres will improve the quality of the mesh

maxobj : int = 0

set the maximum number of object to be rendered: you can set a limit to the maximum number of primitives rendered. If set to 0 meshlab will generate the mesh according to the input file

fbx

Load fbx format.

Parameters:

file_name : str = 'file_name.fbx'

File Name: The name of the file to load

obj

Load obj format.

Parameters:

file_name : str = 'file_name.obj'

File Name: The name of the file to load

off

Load off format.

Parameters:

file_name : str = 'file_name.off'

File Name: The name of the file to load

pdb

Load pdb format.

Parameters:

file_name : str = 'file_name.pdb'

File Name: The name of the file to load

usecolors : bool = True

Use Atoms colors: Atoms are colored according to atomic type

justpoints : bool = False

SURFACE: Atoms as Points: Atoms are created as points, no surface is built. Overrides all subsequential surface parameters

justspheres : bool = True

SURFACE: Atoms as Spheres: Atoms are created as intersecting spheres, no interpolation surface is built. Overrides all subsequential surface parameters

interpspheres : bool = False

SURFACE: Atoms as Jointed Spheres: Atoms are created as spheres, joining surface is built. Overrides all subsequential surface parameters

metaballs : bool = False

SURFACE: Atoms as Metaballs: Atoms are created as blobby interpolation surface, refer to BLINN Metaballs article. Overrides all subsequential surface parameters

voxelsize : float = 0.25

Surface Resolution: is used by Jointed Spheres and Metaball

blobby : float = 2

Blobbyness factor: is used by Metaball

ply

Load ply format.

Parameters:

file_name : str = 'file_name.ply'

File Name: The name of the file to load

pts

Load pts format.

Parameters:

file_name : str = 'file_name.pts'

File Name: The name of the file to load

ptx

Load ptx format.

Parameters:

file_name : str = 'file_name.ptx'

File Name: The name of the file to load

meshindex : int = 0

Index of Range Map to be Imported: PTX files may contain more than one range map. 0 is the first range map. If the number if higher than the actual mesh number, the import will fail

pointsonly : bool = True

Keep only points: Import points a point cloud only, with radius and normals, no triangulation involved, isolated points and points with normals with steep angles are removed.

usecolor : bool = True

import color: Read color from PTX, if color is not present, uses reflectance instead

flipfaces : bool = False

LEICA: flip normal direction: LEICA PTX exporter goes counterclockwise, FARO PTX exporter goes clockwise

pointcull : bool = True

delete unsampled points: Deletes unsampled points in the grid that are normally located in [0,0,0]

anglecull : bool = True

Cull faces by angle: short

angle : float = 85

Angle limit for face culling: short

qobj

Load qobj format.

Parameters:

file_name : str = 'file_name.qobj'

File Name: The name of the file to load

stl

Load stl format.

Parameters:

file_name : str = 'file_name.stl'

File Name: The name of the file to load

meshlabiostlunifyvertices : bool = True

Unify Duplicated Vertices in STL files: The STL format is not an vertex-indexed format. Each triangle is composed by independent vertices, so, usually, duplicated vertices should be unified

tri

Load tri format.

Parameters:

file_name : str = 'file_name.tri'

File Name: The name of the file to load

txt

Load txt format.

Parameters:

file_name : str = 'file_name.txt'

File Name: The name of the file to load

rowtoskip : int = 0

Header Row to be skipped: The number of lines that must be skipped at the beginning of the file. Generally, these files have one or more 'header' lines, before the point list

strformat : str = 'X Y Z' (or int = 0)

Possible enum values:

'X Y Z'

'X Y Z Reflectance'

'X Y Z Reflectance R G B'

'X Y Z Reflectance Nx Ny Nz'

'X Y Z Reflectance R G B Nx Ny Nz'

'X Y Z Reflectance Nx Ny Nz R G B'

'X Y Z R G B'

'X Y Z R G B Reflectance'

'X Y Z R G B Reflectance Nx Ny Nz'

'X Y Z R G B Nx Ny Nz Reflectance'

'X Y Z Nx Ny Nz'

'X Y Z Nx Ny Nz R G B Reflectance'

'X Y Z Nx Ny Nz Reflectance R G B'

Point format: Which values are specified for each point, and in which order.

separator : str = ';' (or int = 0)

Possible enum values:

';'

','

'SPACE'

Separator: The separator between individual values in the point(s) description.

rgbmode : str = '[0-255]' (or int = 0)

Possible enum values:

'[0-255]'

'[0.0-1.0]'

Color format: Colors may be specified in the [0-255] or [0.0-1.0] interval.

onerror : str = 'skip' (or int = 0)

Possible enum values:

'skip'

'stop'

On Parsing Error: When a line is not properly parsed, it is possible to 'skip' it and continue with the following lines, or 'stop' importing at that point

vmi

Load vmi format.

Parameters:

file_name : str = 'file_name.vmi'

File Name: The name of the file to load

wrl

Load wrl format.

Parameters:

file_name : str = 'file_name.wrl'

File Name: The name of the file to load

x3d

Load x3d format.

Parameters:

file_name : str = 'file_name.x3d'

File Name: The name of the file to load

x3dv

Load x3dv format.

Parameters:

file_name : str = 'file_name.x3dv'

File Name: The name of the file to load

xyz

Load xyz format.

Parameters:

file_name : str = 'file_name.xyz'

File Name: The name of the file to load

save parameters¶

Here are listed all the file formats that can be saved usingthe function pmeshlab.MeshSet.save_current_mesh(), with all the possible parameters that can be accepted by these functions.

3ds

Save 3ds format.

Parameters:

file_name : str = 'file_name.3ds'

File Name: The name of the file to save

save_face_color : bool = True

Save Face Color: Save Face Color

save_face_normal : bool = True

Save Face Normal: Save Face Normal

save_wedge_texcoord : bool = True

Save Wedge TexCoord: Save Wedge TexCoord

save_wedge_normal : bool = True

Save Wedge Normal: Save Wedge Normal

ctm

Save ctm format.

Parameters:

file_name : str = 'file_name.ctm'

File Name: The name of the file to save

lossless : bool = False

LossLess compression: If true it does not apply any lossy compression technique.

relativeprecisionparam : float = 0.0001

Relative Coord Precision: When using a lossy compression this number control the introduced error and hence the compression factor.It is a number relative to the average edge length. (e.g. the default means that the error should be roughly 1/10000 of the average edge length)

save_vertex_quality : bool = True

Save Vertex Quality: Save Vertex Quality

save_vertex_color : bool = True

Save Vertex Color: Save Vertex Color

dae

Save dae format.

Parameters:

file_name : str = 'file_name.dae'

File Name: The name of the file to save

save_vertex_color : bool = True

Save Vertex Color: Save Vertex Color

save_vertex_coord : bool = True

Save Vertex Coord: Save Vertex Coord

save_vertex_normal : bool = True

Save Vertex Normal: Save Vertex Normal

save_wedge_texcoord : bool = True

Save Wedge TexCoord: Save Wedge TexCoord

save_wedge_normal : bool = True

Save Wedge Normal: Save Wedge Normal

dxf

Save dxf format.

Parameters:

file_name : str = 'file_name.dxf'

File Name: The name of the file to save

idtf

Save idtf format.

Parameters:

file_name : str = 'file_name.idtf'

File Name: The name of the file to save

position_val : numpy.ndarray[numpy.float64[3]] = [0, 0, -3.4641]

Camera Position: The position in which the camera is set. The default value is derived by the 3d mesh's bounding box.

target_val : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

Camera target point: The point towards the camera is seeing. The default value is derived by the 3d mesh's bounding box.

fov_val : float = 60

Camera's FOV Angle 0..180: Camera's FOV Angle. The values' range is between 0-180 degree. The default value is 60.

compression_val : int = 500

U3D quality 0..1000: U3D mesh's compression ratio. The values' range is between 0-1000 degree. The default value is 500.

save_vertex_color : bool = False

Save Vertex Color: Save Vertex Color

save_vertex_normal : bool = False

Save Vertex Normal: Save Vertex Normal

save_face_color : bool = False

Save Face Color: Save Face Color

save_wedge_texcoord : bool = True

Save Wedge TexCoord: Save Wedge TexCoord

save_wedge_normal : bool = True

Save Wedge Normal: Save Wedge Normal

json

Save json format.

Parameters:

file_name : str = 'file_name.json'

File Name: The name of the file to save

save_vertex_color : bool = True

Save Vertex Color: Save Vertex Color

save_vertex_coord : bool = True

Save Vertex Coord: Save Vertex Coord

save_vertex_normal : bool = True

Save Vertex Normal: Save Vertex Normal

obj

Save obj format.

Parameters:

file_name : str = 'file_name.obj'

File Name: The name of the file to save

save_vertex_color : bool = True

Save Vertex Color: Save Vertex Color

save_vertex_coord : bool = True

Save Vertex Coord: Save Vertex Coord

save_vertex_normal : bool = True

Save Vertex Normal: Save Vertex Normal

save_face_color : bool = True

Save Face Color: Save Face Color

save_wedge_texcoord : bool = True

Save Wedge TexCoord: Save Wedge TexCoord

save_wedge_normal : bool = True

Save Wedge Normal: Save Wedge Normal

save_polygonal : bool = True

Save Polygonal: Save Polygonal

off

Save off format.

Parameters:

file_name : str = 'file_name.off'

File Name: The name of the file to save

save_vertex_color : bool = True

Save Vertex Color: Save Vertex Color

save_vertex_coord : bool = True

Save Vertex Coord: Save Vertex Coord

save_face_color : bool = True

Save Face Color: Save Face Color

save_polygonal : bool = True

Save Polygonal: Save Polygonal

ply

Save ply format.

Parameters:

file_name : str = 'file_name.ply'

File Name: The name of the file to save

binary : bool = True

Binary encoding: Save the mesh using a binary encoding. If false the mesh is saved in a plain, readable ascii format.

save_vertex_quality : bool = True

Save Vertex Quality: Save Vertex Quality

save_vertex_flag : bool = False

Save Vertex Flag: Save Vertex Flag

save_vertex_color : bool = True

Save Vertex Color: Save Vertex Color

save_vertex_coord : bool = True

Save Vertex Coord: Save Vertex Coord

save_vertex_normal : bool = False

Save Vertex Normal: Save Vertex Normal

save_vertex_radius : bool = True

Save Vertex Radius: Save Vertex Radius

save_face_quality : bool = True

Save Face Quality: Save Face Quality

save_face_flag : bool = False

Save Face Flag: Save Face Flag

save_face_color : bool = True

Save Face Color: Save Face Color

save_wedge_color : bool = True

Save Wedge Color: Save Wedge Color

save_wedge_texcoord : bool = True

Save Wedge TexCoord: Save Wedge TexCoord

save_wedge_normal : bool = True

Save Wedge Normal: Save Wedge Normal

save_polygonal : bool = True

Save Polygonal: Save Polygonal

stl

Save stl format.

Parameters:

file_name : str = 'file_name.stl'

File Name: The name of the file to save

binary : bool = True

Binary encoding: Save the mesh using a binary encoding. If false the mesh is saved in a plain, readable ascii format.

colormode : bool = True

Materialise Color Encoding: Save the color using a binary encoding according to the Materialise's Magic style (e.g. RGB coding instead of BGR coding).

save_face_color : bool = True

Save Face Color: Save Face Color

u3d

Save u3d format.

Parameters:

file_name : str = 'file_name.u3d'

File Name: The name of the file to save

position_val : numpy.ndarray[numpy.float64[3]] = [0, 0, -3.4641]

Camera Position: The position in which the camera is set. The default value is derived by the 3d mesh's bounding box.

target_val : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]

Camera target point: The point towards the camera is seeing. The default value is derived by the 3d mesh's bounding box.

fov_val : float = 60

Camera's FOV Angle 0..180: Camera's FOV Angle. The values' range is between 0-180 degree. The default value is 60.

compression_val : int = 500

U3D quality 0..1000: U3D mesh's compression ratio. The values' range is between 0-1000 degree. The default value is 500.

save_vertex_color : bool = False

Save Vertex Color: Save Vertex Color

save_face_color : bool = False

Save Face Color: Save Face Color

save_wedge_texcoord : bool = True

Save Wedge TexCoord: Save Wedge TexCoord

wrl

Save wrl format.

Parameters:

file_name : str = 'file_name.wrl'

File Name: The name of the file to save

save_vertex_color : bool = True

Save Vertex Color: Save Vertex Color

save_wedge_color : bool = True

Save Wedge Color: Save Wedge Color

save_wedge_texcoord : bool = True

Save Wedge TexCoord: Save Wedge TexCoord

x3d

Save x3d format.

Parameters:

file_name : str = 'file_name.x3d'

File Name: The name of the file to save

save_vertex_color : bool = True

Save Vertex Color: Save Vertex Color

save_vertex_coord : bool = True

Save Vertex Coord: Save Vertex Coord

save_vertex_normal : bool = True

Save Vertex Normal: Save Vertex Normal

save_face_color : bool = False

Save Face Color: Save Face Color

save_face_normal : bool = False

Save Face Normal: Save Face Normal

save_wedge_color : bool = False

Save Wedge Color: Save Wedge Color

save_wedge_texcoord : bool = False

Save Wedge TexCoord: Save Wedge TexCoord

save_wedge_normal : bool = False

Save Wedge Normal: Save Wedge Normal

xyz

Save xyz format.

Parameters:

file_name : str = 'file_name.xyz'

File Name: The name of the file to save

save_vertex_normal : bool = True

Save Vertex Normal: Save Vertex Normal

load raster parameters¶

Here are listed all the raster file formats that can be loaded usingthe functions pmeshlab.MeshSet.load_new_raster().

jpeg

Load jpeg format.

Parameters:

file_name : str = 'file_name.jpeg'

File Name: The name of the file to load

jpg

Load jpg format.

Parameters:

file_name : str = 'file_name.jpg'

File Name: The name of the file to load

png

Load png format.

Parameters:

file_name : str = 'file_name.png'

File Name: The name of the file to load

xpm

Load xpm format.

Parameters:

file_name : str = 'file_name.xpm'

File Name: The name of the file to load