List of Filters¶
Here are listed all the filter names that can be given as a parameter 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 amin
and amax
value; an outofbounds 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 thepmeshlab.Percentage
for further info;pmeshlab.AbsoluteValue
: the parameter will be treated as absolute value; see the documentation of thepmeshlab.AbsoluteValue
for further info; Enum: represents a parameter that can accept just one of a limited set of possible values. These values type can be
int
orstr
; 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 thepmeshlab.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 theid
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.
Filter documentation¶

apply_cameras_extrinsics_transformation
¶ 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'
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'
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 selectedtoall : bool = False
Apply to all active Raster and visible Mesh layers: Apply the same scaling to all the layers, including any visible 3D layer

apply_cameras_rotation
¶ 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'
rotaxis : str = 'X axis' (or int = 0)
Possible enum values:
'X axis'
'Y axis'
'Z axis'
'custom axis'
rotcenter : str = 'origin' (or int = 0)
Possible enum values:
'origin'
'camera viewpoint'
'custom point'
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 valuecustomaxis : 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 selectedtoall : bool = False
Apply to all active Raster and visible Mesh layers: Apply the same scaling to all the layers, including any visible 3D layer

apply_cameras_scaling
¶ 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'
scalecenter : str = 'origin' (or int = 0)
Possible enum values:
'origin'
'camera viewpoint'
'custom point'
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 cameratoallraster : 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 selectedtoall : bool = False
Apply to all active Raster and visible Mesh layers: Apply the same scaling to all the layers, including any visible 3D layer

apply_cameras_translation
¶ 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'
axisx : float (bounded) = 0 [min: 1000; max: 1000]
X Axis: Absolute translation amount along the X axisaxisy : float (bounded) = 0 [min: 1000; max: 1000]
Y Axis: Absolute translation amount along the Y axisaxisz : float (bounded) = 0 [min: 1000; max: 1000]
Z Axis: Absolute translation amount along the Z axiscenterflag : bool = False
translate viewpoint position to the origin: If selected, the camera viewpoint is translated to the origintoallraster : 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 selectedtoall : bool = False
Apply to all active Raster and Mesh layers: Apply the same scaling to all the layers, including any visible 3D layer

apply_color_brightness_contrast_gamma_per_vertex
¶ 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

apply_color_desaturation_per_vertex
¶ 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'
Luminosity is computed as 0.212*r + 0.715*g + 0.072*b
Average is computed as (r+g+b)/3onselected : bool = False
Only on selection: If checked, only affects selected vertices

apply_color_equalization_per_vertex
¶ 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

apply_color_intensity_colourisation_per_vertex
¶ 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

apply_color_inverse_per_vertex
¶ 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

apply_color_laplacian_smoothing_per_face
¶ MeshLab filter name: ‘Smooth: Laplacian Face Color’
Laplacian Smooth Face ColorParameters:
iteration : int = 1
Iteration: the number of iteration of the smoothing algorithm

apply_color_laplacian_smoothing_per_vertex
¶ MeshLab filter name: ‘Smooth: Laplacian Vertex Color’
Laplacian Smooth Vertex ColorParameters:
iteration : int = 1
Iteration: the number of iteration of the smoothing algorithm

apply_color_level_adjustment_per_vertex
¶ 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 verticesapply_to_all : bool = False
All visible layers: if true, apply to all visible layers

apply_color_noising_per_vertex
¶ 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

apply_color_thresholding_per_vertex
¶ 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

apply_color_unsharp_mask_per_vertex
¶ MeshLab filter name: ‘UnSharp Mask Color’
Apply Unsharp filter to the vertex color, putting in more evidence color variations.
See Unsharp MaskingParameters:
weight : float = 0.3
Unsharp Weight: the unsharp weight w_{u} in the unsharp mask equation:
w_{o}orig + 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

apply_color_white_balance_per_vertex
¶ 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

apply_coord_craters_from_point_cloud
¶ 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.
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'
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 "impacteffect".blend : str = 'f3 blending' (or int = 3)
Possible enum values:
'Exponential blending'
'Linear blending'
'Gaussian blending'
'f3 blending'
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 impacteffects 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.

apply_coord_depth_smoothing
¶ 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

apply_coord_directional_preservation
¶ MeshLab filter name: ‘Directional Geometry Preservation’
Blend through a given direction the geometry previously stored in a per vertex custom point attribute with the current geometry. 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,y accuracy but suffer of greater depth errors.Parameters:
attr_name : str = ''
Custom attribute name: The name of the per vertex custom point attribute that contains the previous geometry.viewpoint : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]
Viewpoint: The position of the view point that is used to get the constraint direction.

apply_coord_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'
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.

apply_coord_hc_laplacian_smoothing
¶ 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, 131138.
doi:10.1111/14678659.00334

apply_coord_laplacian_smoothing
¶ 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.20051044Parameters:
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

apply_coord_laplacian_smoothing_scale_dependent
¶ 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.311576Parameters:
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

apply_coord_laplacian_smoothing_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 surfaceParameters:
selection : bool = False
Update selection: Apply laplacian smooth on selected faces onlyangledeg : float = 0.5
Max Normal Dev (deg): maximum mean normal angle displacement (degrees) from old to new facesiterations : int = 1
Iterations: number of laplacian smooth iterations in every run

apply_coord_point_cloud_movement_over_mesh
¶ MeshLab filter name: ‘Points Cloud Movement’
Simulate the movement of a point cloud over a meshParameters:
point_cloud : int = 0
Point cloud: The point cloud that will be moved over the target mesh.target_mesh : int = 0
Target mesh: Target mesh on which the point cloud will be moved.gravity_dir : numpy.ndarray[numpy.float64[3]] = [0, 1, 0]
g: Direction of gravityforce_dir : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]
force: Direction of the force acting on the points cloudsteps : int = 1
s: Simulation Stepsadhesion : float (bounded) = 1 [min: 0; max: 1]
adhesion: Factor to model the general adhesion.velocity : float = 0
v: Initial velocity of the particlemass : float = 1
m: Mass of the particlecolorize_mesh : bool = False
Map to Color: Color the mesh with colors based on the movement of the particle

apply_coord_random_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

apply_coord_taubin_smoothing
¶ MeshLab filter name: ‘Taubin Smooth’
The λμ Taubin smoothing, combines two steps of lowpass 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.218473Parameters:
lambda_ : float = 0.5
Lambda: The lambda parameter of the Taubin Smoothing algorithmmu : float = 0.53
mu: The mu parameter of the Taubin Smoothing algorithmstepsmoothnum : 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 laplacianselected : bool = False
Affect only selected faces: If checked the filter is performed only on the selected faces

apply_coord_two_steps_smoothing
¶ 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.
publicationParameters:
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 smoothedstepnormalnum : 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

apply_coord_unsharp_mask
¶ MeshLab filter name: ‘UnSharp Mask Geometry’
Apply Unsharp filter to geometric shape, putting in more evidence ridges and valleys variations.
Unsharp MaskingParameters:
weight : float = 0.3
Unsharp Weight: the unsharp weight w_{u} in the unsharp mask equation:
w_{o}orig + 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

apply_matrix_flip_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 planeflipy : bool = False
Flip Y axis: If selected the axis will be swapped (mesh mirrored along the XZ planeflipz : bool = False
Flip Z axis: If selected the axis will be swapped (mesh mirrored along the XY planeswapxy : bool = False
Swap XY axis: If selected the two axis will be swapped. All the swaps are performed in this orderswapxz : bool = False
Swap XZ axis: If selected the two axis will be swapped. All the swaps are performed in this orderswapyz : bool = False
Swap YZ axis: If selected the two axis will be swapped. All the swaps are performed in this orderfreeze : bool = True
Freeze Matrix: The transformation is explicitly applied, and the vertex coordinates are actually changedalllayers : bool = False
Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

apply_matrix_freeze
¶ 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

apply_matrix_inverse
¶ 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 changedalllayers : bool = False
Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

apply_normal_normalization_per_face
¶ MeshLab filter name: ‘Normalize Face Normals’
Normalize Face Normal Lengths to unit vectors.

apply_normal_normalization_per_vertex
¶ MeshLab filter name: ‘Normalize Vertex Normals’
Normalize Vertex Normal Lengths to unit vectors.

apply_normal_point_cloud_smoothing
¶ MeshLab filter name: ‘Smooth normals on point sets’
Smooth the normals of the vertices of a mesh without exploiting the triangle connectivity, useful for dataset with no facesParameters:
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

apply_normal_smoothing_per_face
¶ MeshLab filter name: ‘Smooth Face Normals’
Laplacian smooth of the face normals, without touching the position of the vertices.

apply_normal_unsharp_mask_per_vertex
¶ 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 nonphotorealistic renderings by Cignoni, Scopigno and Tarini, Comput Graph, 29 (1) (2005)
doi:10.1016/j.cag.2004.11.012Parameters:
recalc : bool = False
Recompute Normals: Recompute normals from scratch before the unsharp maskingweight : float = 0.3
Unsharp Weight: the unsharp weight w_{u} in the unsharp mask equation:
w_{o}orig + 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

apply_scalar_clamping_per_vertex
¶ MeshLab filter name: ‘Clamp Vertex Quality’
Clamp vertex quality values to a given range according to specific values or to percentilesParameters:
minval : float = 0
Min: The value that will be mapped with the lower end of the scale (red)maxval : float = 0
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)

apply_scalar_saturation_per_vertex
¶ 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

apply_scalar_smoothing_per_vertex
¶ MeshLab filter name: ‘Smooth Vertex Quality’
Laplacian smooth of the quality per vertex values.

apply_scalar_unsharp_mask_per_vertex
¶ MeshLab filter name: ‘UnSharp Mask Quality’
Apply Unsharp filter to values of quality per vertex.
See Unsharp MaskingParameters:
weight : float = 0.3
Unsharp Weight: the unsharp weight w_{u} in the unsharp mask equation:
w_{o}orig + 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

apply_selection_by_same_connected_component
¶ 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.

apply_selection_dilatation
¶ MeshLab filter name: ‘Dilate Selection’
Dilate (expand) the current set of selected faces.

apply_selection_erosion
¶ MeshLab filter name: ‘Erode Selection’
Erode (reduce) the current set of selected faces.

apply_selection_inverse
¶ 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.

apply_texcoord_merge_per_wedge
¶ MeshLab filter name: ‘Merge Wedge Texture Coord’
Merge together perwedge 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 perwedge 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, 1e4, corresponds to one texel on a 10kx10x texture)

apply_texmap_defragmentation
¶ MeshLab filter name: ‘Texture Map Defragmentation’
Reduces the texture fragmentation by merging atlas charts. The used algorithm is:
Texture Defragmentation for PhotoReconstructed 3D Models
Andrea Maggiordomo, Paolo Cignoni and Marco Tarini
Eurographics 2021Parameters:
matchingthreshold : float = 2
Matching Error Threshold: Threshold on the seam alignment error. Using a higher threshold can reduce the fragmentation but increase runtime and distortion.boundarytolerance : float = 0.2
Seam to chartboundarylength tolerance: Cutoff on the minimum fractional seam length. Seams with lower fractional length (relative to the chart perimeter) are not merged to keep the chart borders compact.distortiontolerance : float = 0.5
Local ARAP distortion tolerance: Local UVoptimization distortion tolerance when merging a seam. If the local energy is higher than this value, the operation is reverted.globaldistortiontolerance : float = 0.025
Global ARAP distortion tolerance: Global ARAP distortion tolerance when merging a seam. If the global atlas energy is higher than this value, the operation is reverted.uvreductionlimit : float (bounded) = 0 [min: 0; max: 100]
UV Length Target (percentage): Target UV length as percentage of the input length. The algorithm halts if the target UV length has be en reached, or if no further seams can be merged.offsetfactor : float = 5
Local expansion coefficient: Coefficient used to control the extension of the UVoptimization area. Larger values can increase the efficacy of the defragmentation, but increase the cost of the geometric optimization and the algorithm runtime.timelimit : float = 0
Time limit (seconds): Time limit for the defragmentation process (zero means unlimited).

compute_color_and_texture_from_active_rasters_projection
¶ MeshLab filter name: ‘Project active rasters color to current mesh, filling the texture’
Color information from all the active rasters is perspectiveprojected on the current mesh, filling the texture, using basic weightingParameters:
textname : str = '_color.png'
Texture file: The texture file to be createdtexsize : 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 2dorefill : bool = True
fill atlas gaps: If true, unfilled areas of the mesh are interpolated, to avoid visible seams while mipmappingdeptheta : 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 verticesuseangle : bool = True
use angle weight: If true, color contribution is weighted by pixel view angleusedistance : bool = True
use distance weight: If true, color contribution is weighted by pixel view distanceuseborders : bool = True
use image borders weight: If true, color contribution is weighted by pixel distance from image boundariesusesilhouettes : 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 maskout 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

compute_color_by_conntected_component_per_face
¶ MeshLab filter name: ‘Random Component Color’
Colorize each connected component randomly.

compute_color_by_function_per_face
¶ 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 perface 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, vi0, vi1, vi2 for vertex indices, q0,q1,q2 for vertex quality, wtu0,wtv0 wtu1,wtv1 wtu2,wtv2 for perwedge texture coords, ti for face texture index, vsel0,vsel1,vsel2 for vertex selection (1 yes, 0 no) fi for face index, 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 0255g : str = '0'
func g = : function to generate Green component. Expected Range 0255b : str = '255'
func b = : function to generate Blue component. Expected Range 0255a : str = '255'
func alpha = : function to generate Alpha component. Expected Range 0255onselected : bool = False
only on selection: if checked, only affects selected faces

compute_color_by_function_per_vertex
¶ 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 pervertex 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 0255y : str = '255'
func g = : function to generate Green component. Expected Range 0255z : str = '0'
func b = : function to generate Blue component. Expected Range 0255a : str = '255'
func alpha = : function to generate Alpha component. Expected Range 0255onselected : bool = False
only on selection: if checked, only affects selected vertices

compute_color_by_point_cloud_voronoi_projection
¶ 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.

compute_color_from_active_rasters_projection
¶ MeshLab filter name: ‘Project active rasters color to current mesh’
Color information from all the active rasters is perspectiveprojected on the current mesh using basic weightingParameters:
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 verticesuseangle : bool = True
use angle weight: If true, color contribution is weighted by pixel view angleusedistance : bool = True
use distance weight: If true, color contribution is weighted by pixel view distanceuseborders : bool = True
use image borders weight: If true, color contribution is weighted by pixel distance from image boundariesusesilhouettes : 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 maskout 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 imagesblankcolor : 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

compute_color_from_current_raster_projection
¶ MeshLab filter name: ‘Project current raster color to current mesh’
Color information from the current raster is perspectiveprojected on the current meshParameters:
usedepth : bool = True
Use depth for projection: If true, depth is used to restrict projection on visible facesdeptheta : 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 verticesblankcolor : 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

compute_color_from_scalar_per_face
¶ MeshLab filter name: ‘Colorize by face Quality’
Color faces depending on their quality field (manually equalized).Parameters:
minval : float = 0
Min: The value that will be mapped with the lower end of the scale (red)maxval : float = 0
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)

compute_color_from_scalar_per_vertex
¶ MeshLab filter name: ‘Colorize by vertex Quality’
Color vertices depending on their quality field (manually equalized).Parameters:
minval : float = 0
Min: The value that will be mapped with the lower end of the scale (red)maxval : float = 0
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)

compute_color_from_scalar_using_transfer_function_per_vertex
¶ 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 mappingParameters:
minqualityval : float = 0
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 = 0
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 meshtfslist : 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'
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

compute_color_from_texture_per_vertex
¶ MeshLab filter name: ‘Transfer Color: Texture to Vertex’
Texture to Vertex color transfer

compute_color_perlin_noise_per_vertex
¶ 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

compute_color_random_per_face
¶ MeshLab filter name: ‘Random Face Color’
Colorize Faces randomly. If internal edges are present they are used. Useful for quads.

compute_color_scattering_per_mesh
¶ 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)

compute_color_transfer_face_to_vertex
¶ MeshLab filter name: ‘Transfer Color: Face to Vertex’
Face to Vertex color transfer

compute_color_transfer_mesh_to_face
¶ MeshLab filter name: ‘Transfer Color: Mesh to Face’
Mesh to Face color transferParameters:
allvisiblemesh : bool = False
Apply to all Meshes: If true the color mapping is applied to all the meshes.

compute_color_transfer_vertex_to_face
¶ MeshLab filter name: ‘Transfer Color: Vertex to Face’
Vertex to Face color transfer

compute_coord_by_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 pervertex 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 xy : str = 'y'
func y = : insert function to generate new coord for yz : str = 'sin(x+y)'
func z = : insert function to generate new coord for zonselected : bool = False
only on selection: if checked, only affects selected vertices

compute_coord_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}
Threedimensional metamorphosis: a survey
by F. Lazarus and A. Verroust, Visual Computer, 1998
doi:10.1007/s003710050149Parameters:
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

compute_curvature_and_color_apss_per_vertex
¶ 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 2008Parameters:
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 !selectiononly : bool = False
Selection only: If checked, only selected vertices will be projected.curvaturetype : str = 'Mean' (or int = 0)
Possible enum values:
'Mean'
'Gauss'
'K1'
'K2'
'ApproxMean'
ApproxMean uses the radius of the fitted sphere as an approximation of the mean curvature.

compute_curvature_and_color_rimls_per_vertex
¶ 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 NonLinear 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)selectiononly : bool = False
Selection only: If checked, only selected vertices will be projected.curvaturetype : str = 'Mean' (or int = 0)
Possible enum values:
'Mean'
'Gauss'
'K1'
'K2'

compute_curvature_principal_directions_per_vertex
¶ MeshLab filter name: ‘Compute curvature principal directions’
Compute the principal directions of curvature with different algorithmsParameters:
method : str = 'Quadric Fitting' (or int = 3)
Possible enum values:
'Taubin approximation'
'Principal Component Analysis'
'Normal Cycles'
'Quadric Fitting'
'Scale Dependent Quadric Fitting'
curvcolormethod : str = 'Mean Curvature' (or int = 0)
Possible enum values:
'Mean Curvature'
'Gaussian Curvature'
'Min Curvature'
'Max Curvature'
'Shape Index'
'CurvedNess'
'None'
scale : Percentage = 10%
Curvature Scale: This parameter is used only for scale dependent methods: 'Scale Dependent Quadric Fitting' and 'PCA'. It specifies the scale at which the curvature is computed. e.g. for SDQF it specify how large is the patch where we fit the quadric used to compute curvature dirs.autoclean : bool = True
Remove Unreferenced Vertices: If selected, before starting the filter will remove any unreference vertex (for which curvature values are not defined)

compute_custom_radius_scalar_attribute_per_vertex
¶ 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.

compute_iso_parametrization
¶ MeshLab filter name: ‘Iso Parametrization: Main’
The filter builds the abstract domain mesh representing the Isoparameterization of a watertight twomanifold 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, 2010Parameters:
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'
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 Effconvergencespeed : 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 resultsdoublestep : 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.

compute_matrix_by_fitting_to_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'
rotaxis : str = 'any axis' (or int = 0)
Possible enum values:
'any axis'
'X axis'
'Y axis'
'Z axis'
toorigin : bool = True
Move to Origin: Also apply a translation, such that the centroid of selection rests on the Originfreeze : bool = True
Freeze Matrix: The transformation is explicitly applied, and the vertex coordinates are actually changedalllayers : bool = False
Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

compute_matrix_by_icp_between_meshes
¶ MeshLab filter name: ‘ICP Between Meshes’
Perform the ICP algorithm to minimize the difference between two cloud of points.Parameters:
referencemesh : int = 0
Reference Mesh: The Reference Mesh is the point cloud kept fixed during the ICP process.sourcemesh : int = 1
Source Mesh: The Source Mesh is the point cloud which will be rototranslated to match the Reference Mesh.samplenum : int = 2000
Sample Number: Number of samples that we try to choose at each ICP iterationmindistabs : float = 10
Minimal Starting Distance: For all the chosen sample on one mesh we consider for ICP only the samples nearer than this value.If MSD is too large outliers could be included, if it is too small convergence will be very slow. A good guess is needed here, suggested values are in the range of 10100 times of the device scanning error.This value is also dynamically changed by the 'Reduce Distance Factor'trgdistabs : float = 0.005
Target Distance: When 50% of the chosen samples are below this distance we consider the two mesh aligned. Usually it should be a value lower than the error of the scanning device.maxiternum : int = 75
Max Iteration Num: The maximum number of iteration that the ICP is allowed to perform.samplemode : bool = True
Normal Equalized Sampling: if true (default) the sample points of icp are chosen with a distribution uniform with respect to the normals of the surface. Otherwise they are distributed in a spatially uniform way.reducefactorperc : float = 0.8
MSD Reduce Factor: At each ICP iteration the Minimal Starting Distance is reduced to be 5 times thepercentile of the sample distances (e.g. if RF is 0.9 the new Minimal Starting Distance is 5 times the value such that 90% of the sample lies at a distance lower than . passhifilter : float = 0.75
Sample Cut High: At each ICP iteration all the sample that are farther than thepercentile are discarded ( In practice we use only the best results ). matchmode : bool = True
Rigid matching: If true the ICP is constrained to perform matching only through rototranslations (no scaling allowed). If false a more relaxed transformation matrix is allowed (scaling and shearing can appear).savelastiteration : bool = False
Save Last Iteration: Toggle this checkbox in order to save the last iteration points in two layers.

compute_matrix_by_mesh_global_alignment
¶ MeshLab filter name: ‘Global Align Meshes’
Perform the global alignment process to align a set of visible meshes together. The alignment algorithm is implemented over the idea written by Kari Pulli in his paper: "Multiview Registration for Large Data Sets"Parameters:
basemesh : int = 0
Base Mesh: The base mesh is the one who will stay fixed during the alignment process.onlyvisiblemeshes : bool = False
Only visible meshes: Apply the global alignment only to the visible meshesogsize : int = 50000
Occupancy Grid Size: To compute the overlap between range maps we discretize them into voxel and count them (both for area and overlap); This parameter affect the resolution of the voxelization process. Using a too fine voxelization can...arcthreshold : float = 0.3
Arc Area Thr.: We run ICP on every pair of mesh with a relative overlap greater than this threshold. The relative overlap is computed as overlapArea / min(area1,area2)recalcthreshold : float = 0.1
Recalc Fraction: Every time we start process we discard thefraction of all the arcs in order to recompute them and hopefully improve the final result. It corresponds to iteratively recalc the bad arcs. samplenum : int = 2000
Sample Number: Number of samples that we try to choose at each ICP iterationmindistabs : float = 10
Minimal Starting Distance: For all the chosen sample on one mesh we consider for ICP only the samples nearer than this value.If MSD is too large outliers could be included, if it is too small convergence will be very slow. A good guess is needed here, suggested values are in the range of 10100 times of the device scanning error.This value is also dynamically changed by the 'Reduce Distance Factor'trgdistabs : float = 0.005
Target Distance: When 50% of the chosen samples are below this distance we consider the two mesh aligned. Usually it should be a value lower than the error of the scanning device.maxiternum : int = 75
Max Iteration Num: The maximum number of iteration that the ICP is allowed to perform.samplemode : bool = True
Normal Equalized Sampling: if true (default) the sample points of icp are chosen with a distribution uniform with respect to the normals of the surface. Otherwise they are distributed in a spatially uniform way.reducefactorperc : float = 0.8
MSD Reduce Factor: At each ICP iteration the Minimal Starting Distance is reduced to be 5 times thepercentile of the sample distances (e.g. if RF is 0.9 the new Minimal Starting Distance is 5 times the value such that 90% of the sample lies at a distance lower than . passhifilter : float = 0.75
Sample Cut High: At each ICP iteration all the sample that are farther than thepercentile are discarded ( In practice we use only the best results ). matchmode : bool = True
Rigid matching: If true the ICP is constrained to perform matching only through rototranslations (no scaling allowed). If false a more relaxed transformation matrix is allowed (scaling and shearing can appear).

compute_matrix_by_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 meshesfreeze : bool = True
Freeze Matrix: The transformation is explicitly applied, and the vertex coordinates are actually changedalllayers : bool = False
Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

compute_matrix_from_rotation
¶ 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'
rotcenter : str = 'origin' (or int = 0)
Possible enum values:
'origin'
'barycenter'
'custom point'
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 valuecustomaxis : 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 changedalllayers : bool = False
Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

compute_matrix_from_scaling_or_normalization
¶ 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: Scalingaxisy : float = 1
Y Axis: Scalingaxisz : float = 1
Z Axis: Scalinguniformflag : 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'
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 lengthfreeze : bool = True
Freeze Matrix: The transformation is explicitly applied, and the vertex coordinates are actually changedalllayers : bool = False
Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

compute_matrix_from_translation
¶ 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'
axisx : float (bounded) = 0 [min: 8.66025; max: 8.66025]
X Axis: when using [XYZ translation], amount of translation along the X axis (in model units)axisy : float (bounded) = 0 [min: 8.66025; max: 8.66025]
Y Axis: when using [XYZ translation], amount of translation along the Y axis (in model units)axisz : float (bounded) = 0 [min: 8.66025; max: 8.66025]
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 changedalllayers : bool = False
Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

compute_matrix_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 axistranslationy : float = 0
Y Translation: Translation factor on Y axistranslationz : float = 0
Z Translation: Translation factor on Z axisrotationx : float = 0
X Rotation: Rotation angle on X axisrotationy : float = 0
Y Rotation: Rotation angle on Y axisrotationz : float = 0
Z Rotation: Rotation angle on Z axisscalex : float = 1
X Scale: Scaling factor on X axisscaley : float = 1
Y Scale: Scaling factor on Y axisscalez : float = 1
Z Scale: Scaling factor on Z axiscompose : 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 changedalllayers : bool = False
Apply to all visible Layers: If selected the filter will be applied to all visible mesh layers

compute_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 2008Parameters:
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.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.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.

compute_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 NonLinear 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.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.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)

compute_new_custom_point_attribute_per_face
¶ MeshLab filter name: ‘Define New Per Face Custom Point Attribute’
Add a new PerFace custom point attribute to current mesh.
You can specify custom name and a function to generate attribute's values
It's possible to use perface variables in the expression:
It's possible to use the following perface 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, vi0, vi1, vi2 for vertex indices, q0,q1,q2 for vertex quality, wtu0,wtv0 wtu1,wtv1 wtu2,wtv2 for perwedge texture coords, ti for face texture index, vsel0,vsel1,vsel2 for vertex selection (1 yes, 0 no) fi for face index, 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 functionParameters:
name : str = 'Custom Attr Name'
Name: the name of new attribute. you can access attribute in other filters through this namex_expr : str = 'x0'
x coord function =: function to calculate custom x coord of the point attribute value for each facey_expr : str = 'y0'
y coord function =: function to calculate custom y coord of the point attribute value for each facez_expr : str = 'z0'
z coord function =: function to calculate custom z coord of the point attribute value for each face

compute_new_custom_point_attribute_per_vertex
¶ MeshLab filter name: ‘Define New Per Vertex Custom Point Attribute’
Add a new PerVertex custom point 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 pervertex 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 = 'Custom Attr Name'
Name: the name of new attribute. you can access attribute in other filters through this namex_expr : str = 'x'
x coord function =: function to calculate custom x coord of the point attribute value for each vertexy_expr : str = 'y'
y coord function =: function to calculate custom y coord of the point attribute value for each vertexz_expr : str = 'z'
z coord function =: function to calculate custom z coord of the point attribute value for each vertex

compute_new_custom_scalar_attribute_per_face
¶ MeshLab filter name: ‘Define New Per Face Custom Scalar Attribute’
Add a new PerFace custom scalar attribute to current mesh.
You can specify custom name and a function to generate attribute's values
It's possible to use perface variables in the expression:
It's possible to use the following perface 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, vi0, vi1, vi2 for vertex indices, q0,q1,q2 for vertex quality, wtu0,wtv0 wtu1,wtv1 wtu2,wtv2 for perwedge texture coords, ti for face texture index, vsel0,vsel1,vsel2 for vertex selection (1 yes, 0 no) fi for face index, 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 functionParameters:
name : str = 'Custom Attr Name'
Name: the name of new attribute. you can access attribute in other filters through this nameexpr : str = 'fi'
Scalar function =: function to calculate custom scalar attribute value for each face

compute_new_custom_scalar_attribute_per_vertex
¶ MeshLab filter name: ‘Define New Per Vertex Custom Scalar Attribute’
Add a new PerVertex custom 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 pervertex 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 = 'Custom Attr Name'
Name: the name of new attribute. you can access attribute in other filters through this nameexpr : str = 'x'
Scalar function =: function to calculate custom scalar attribute value for each vertex

compute_normal_by_function_per_vertex
¶ 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 pervertex 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 normaly : str = 'ny'
func ny = : insert function to generate new y for the normalz : str = 'nz'
func nz = : insert function to generate new z for the normalonselected : bool = False
only on selection: if checked, only affects selected vertices

compute_normal_for_point_clouds
¶ 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 facesParameters:
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_normal_from_cameras_per_vertex
¶ MeshLab filter name: ‘ReOrient 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)

compute_normal_per_face
¶ MeshLab filter name: ‘ReCompute Face Normals’
Recompute face normals as the normal of the plane of the face.
See How to find surface normal of a triangle

compute_normal_per_vertex
¶ MeshLab filter name: ‘ReCompute 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 allpurpose 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.10487501Parameters:
weightmode : str = 'Simple Average' (or int = 0)
Possible enum values:
'Simple Average'
'By Area'
'By Angle'
'As defined by N. Max'

compute_normal_polygon_mesh_per_face
¶ MeshLab filter name: ‘ReCompute PerPolygon 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.

compute_scalar_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 = 'perVertex' (or int = 0)
Possible enum values:
'perVertex'
'perFace (deprecated)'
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 directionsreqviews : int = 128
Requested views: Number of different views uniformly placed around the mesh. More views means better accuracy at the cost of increased calculation timeconedir : 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 timeconeangle : float = 30
Cone amplitude: Number of different views uniformly placed around the mesh. More views means better accuracy at the cost of increased calculation timeusegpu : bool = False
Use GPU acceleration: Only works for pervertex AO. In order to use GPUMode, your hardware must support FBOs, FP32 Textures and Shaders. Normally increases the performance by a factor of 4x5xdepthtexsize : 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

compute_scalar_by_aspect_ratio_per_face
¶ 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)'

compute_scalar_by_border_distance_per_vertex
¶ MeshLab filter name: ‘Colorize by border distance’
Store in the quality field the geodesic distance from borders and color the mesh accordingly.

compute_scalar_by_discrete_curvature_per_vertex
¶ MeshLab filter name: ‘Discrete Curvatures’
Colorize according to various discrete curvature computed as described in:
'Discrete DifferentialGeometry Operators for Triangulated 2Manifolds'
M. Meyer, M. Desbrun, P. Schroder, A. H. BarrParameters:
curvaturetype : str = 'Mean Curvature' (or int = 0)
Possible enum values:
'Mean Curvature'
'Gaussian Curvature'
'RMS Curvature'
'ABS Curvature'
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 3dimensional meshes by S. Pulla, A. Razdan, G. Farin.

compute_scalar_by_distance_from_another_mesh_per_vertex
¶ 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].

compute_scalar_by_distance_from_point_cloud_per_vertex
¶ 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.173205 [min: 0; max: 0.57735]
Radius: the radius of the spheres centered in the VertexMesh seedssampleradius : 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 resultsapproximategeodetic : 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.

compute_scalar_by_function_per_face
¶ 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 perface 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, vi0, vi1, vi2 for vertex indices, q0,q1,q2 for vertex quality, wtu0,wtv0 wtu1,wtv1 wtu2,wtv2 for perwedge texture coords, ti for face texture index, vsel0,vsel1,vsel2 for vertex selection (1 yes, 0 no) fi for face index, 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 facenormalize : 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 pervertex coloronselected : bool = False
only on selection: if checked, only affects selected faces

compute_scalar_by_function_per_vertex
¶ 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 pervertex 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 vertexnormalize : 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 pervertex coloronselected : bool = False
only on selection: if checked, only affects selected vertices

compute_scalar_by_geodesic_distance_from_given_point_per_vertex
¶ 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]] = [0.5, 0.5, 0.5]
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.

compute_scalar_by_geodesic_distance_from_selection_per_vertex
¶ 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.

compute_scalar_by_scalar_harmonic_field_per_vertex
¶ 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 CohenOr, Yueshan Xionga. Computers & Graphics, 2009
doi:10.1016/j.cag.2009.03.022Parameters:
point1 : numpy.ndarray[numpy.float64[3]] = [0.5, 0.5, 0.5]
Point 1: A vertex on the mesh that represent one harmonic field boundary condition.point2 : numpy.ndarray[numpy.float64[3]] = [0.5, 0.5, 0.5]
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.

compute_scalar_by_shape_diameter_function_per_vertex
¶ 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 inwardnormal, 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 CohenOr,
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'
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 = 1e07
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 pointoforigin(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.

compute_scalar_by_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 2003Parameters:
onprimitive : str = 'On vertices' (or int = 0)
Possible enum values:
'On vertices'
'On Faces'
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 = 1e07
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)

compute_scalar_from_camera_per_vertex
¶ MeshLab filter name: ‘Vertex Quality from Camera’
Compute vertex quality using the camera definition, according to viewing angle or distanceParameters:
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 pervertex color

compute_scalar_from_raster_coverage_per_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]

compute_scalar_from_raster_coverage_per_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]

compute_scalar_transfer_face_to_vertex
¶ MeshLab filter name: ‘Transfer Quality: Face to Vertex’
Face to Vertex quality transferParameters:
areaweight : bool = True
Area Weighted: If true the vertex quality is computed according to the surface of the involved faces.

compute_scalar_transfer_vertex_to_face
¶ MeshLab filter name: ‘Transfer Quality: Vertex to Face’
Vertex to Face quality transfer

compute_selection_bad_faces
¶ MeshLab filter name: ‘Select ‘problematic’ faces’
Select faces with 'problems', like normal inverted w.r.t the surrounding areas, extremely elongated or folded.Parameters:
usear : bool = True
Select by Aspect Ratio: if true, faces with aspect ratio below the limit will be selectedaratio : 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 thresholdusenf : bool = False
Select by Normal Angle: if true, adjacent faces with normals forming an angle above the limit will be selectednfratio : float (bounded) = 60 [min: 0; max: 180]
Angle flip: angle between the adjacent faces: face will be selected if ABOVE this thresholdselect_folded_faces : bool = False
Select folded faces: If true, folded faces created by the Quadric Edge Collapse decimation will be selected. 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.folded_faces_angle_threshold : float (bounded) = 160 [min: 90; max: 180]
Folded Faces 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.

compute_selection_by_angle_with_direction_per_face
¶ 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 selectedusecamera : 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 occursviewpoint : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]
ViewPoint: if UseCamera is true, this value is ignored

compute_selection_by_color_per_face
¶ 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'
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.

compute_selection_by_condition_per_face
¶ 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 perface 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, vi0, vi1, vi2 for vertex indices, q0,q1,q2 for vertex quality, wtu0,wtv0 wtu1,wtv1 wtu2,wtv2 for perwedge texture coords, ti for face texture index, vsel0,vsel1,vsel2 for vertex selection (1 yes, 0 no) fi for face index, 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

compute_selection_by_condition_per_vertex
¶ 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 pervertex 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)

compute_selection_by_edge_length
¶ 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.00866025 [min: 0; max: 0.866025]
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.

compute_selection_by_non_manifold_edges_per_face
¶ 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.

compute_selection_by_non_manifold_per_vertex
¶ 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.

compute_selection_by_scalar_per_face
¶ MeshLab filter name: ‘Select by Face Quality’
Select all the faces/vertices with within the specified face quality range.Parameters:
minq : float (bounded) = 0 [min: 0; max: 0]
Min Quality: Minimum acceptable quality valuemaxq : float (bounded) = 0 [min: 0; max: 0]
Max Quality: Maximum acceptable quality valueinclusive : 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.

compute_selection_by_scalar_per_vertex
¶ MeshLab filter name: ‘Select by Vertex Quality’
Select all the faces/vertices within the specified vertex quality range.Parameters:
minq : float (bounded) = 0 [min: 0; max: 0]
Min Quality: Minimum acceptable quality valuemaxq : float (bounded) = 0 [min: 0; max: 0]
Max Quality: Maximum acceptable quality valueinclusive : 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.

compute_selection_by_self_intersections_per_face
¶ MeshLab filter name: ‘Select Self Intersecting Faces’
Select only self intersecting faces.

compute_selection_by_small_disconnected_components_per_face
¶ 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:nbneighbors : int = 16
Number of neighbors: Number of neighbors used to estimate the local density. Larger values lead to smoother variations.

compute_selection_by_texture_seams_per_vertex
¶ MeshLab filter name: ‘Select Vertex Texture Seams’
Colorize only border edges.

compute_selection_crease_per_edge
¶ 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.

compute_selection_from_mesh_border
¶ MeshLab filter name: ‘Select Border’
Select vertices and faces on the boundary.

compute_selection_of_visible_convex_hull_per_vertex
¶ MeshLab filter name: ‘Select Convex Hull Visible Points’
Select the visible points in the convex hull of 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 occursviewpoint : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]
ViewPoint: if UseCamera is true, this value is ignoredconvex_hullfp : bool = False
Show Partial Convex Hull of flipped points: Show Partial Convex Hull of the transformed point cloudtriangvp : bool = False
Show a triangulation of the visible points: Show a triangulation of the visible points

compute_selection_point_cloud_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 2009Parameters:
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

compute_selection_transfer_face_to_vertex
¶ 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.

compute_selection_transfer_vertex_to_face
¶ 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.

compute_texcoord_by_function_per_vertex
¶ 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 pervertex 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 01v : str = 'y'
func v = : function to generate v texture coord. Expected Range 01onselected : bool = False
only on selection: if checked, only affects selected vertices

compute_texcoord_by_function_per_wedge
¶ 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 perface 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, vi0, vi1, vi2 for vertex indices, q0,q1,q2 for vertex quality, wtu0,wtv0 wtu1,wtv1 wtu2,wtv2 for perwedge texture coords, ti for face texture index, vsel0,vsel1,vsel2 for vertex selection (1 yes, 0 no) fi for face index, 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 01v0 : str = 'y0'
func v0 = : function to generate v texture coord. of wedge 0. Expected Range 01u1 : str = 'x1'
func u1 = : function to generate u texture coord. of wedge 1. Expected Range 01v1 : str = 'y1'
func v1 = : function to generate v texture coord. of wedge 1. Expected Range 01u2 : str = 'x2'
func u2 = : function to generate u texture coord. of wedge 2. Expected Range 01v2 : str = 'y2'
func v2 = : function to generate v texture coord. of wedge 2. Expected Range 01onselected : bool = False
only on selection: if checked, only affects selected faces

compute_texcoord_parametrization_and_texture_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 texturetexturename : str = 'texture.png'
Texture name: Specifies the name of the file into which the texture image will be savedcolorcorrection : bool = True
Color correction: If true, the final texture is corrected so as to ensure seamless transitionscolorcorrectionfiltersize : 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 imagetogeometry misalignmentsusedistanceweight : bool = True
Use distance weight: Includes a weight accounting for the distance to the camera during the computation of reference imagesuseimgborderweight : bool = True
Use image border weight: Includes a weight accounting for the distance to the image border during the computation of reference imagesusealphaweight : 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 maskout 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 imagescleanisolatedtriangles : bool = True
Clean isolated triangles: Remove all patches compound of a single triangle by aggregating them to adjacent patchesstretchingallowed : bool = False
UV stretching: If true, texture coordinates are stretched so as to cover the full interval [0,1] for both directionstexturegutter : int = 4
Texture gutter: Extra boundary to add to each patch before packing in texture space (in pixels)

compute_texcoord_parametrization_flat_plane_per_wedge
¶ MeshLab filter name: ‘Parametrization: Flat Plane’
Builds a trivial flatplane parametrization.Parameters:
projectionplane : str = 'XY' (or int = 0)
Possible enum values:
'XY'
'XZ'
'YZ'
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 spacesidegutter : 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].

compute_texcoord_parametrization_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 imagesuseimgborderweight : bool = True
Use image border weight: Includes a weight accounting for the distance to the image border during the computation of reference imagesusealphaweight : 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 maskout 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 imagescleanisolatedtriangles : bool = True
Clean isolated triangles: Remove all patches compound of a single triangle by aggregating them to adjacent patchesstretchingallowed : bool = False
UV stretching: If true, texture coordinates are stretched so as to cover the full interval [0,1] for both directionstexturegutter : int = 4
Texture gutter: Extra boundary to add to each patch before packing in texture space (in pixels)

compute_texcoord_parametrization_triangle_trivial_per_wedge
¶ MeshLab filter name: ‘Parametrization: Trivial PerTriangle’
Builds a trivial trianglebytriangle parametrization.
Two methods are provided, the first 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 calculationtextdim : int = 1024
Texture Dimension (px): Gives an indication on how big the texture isborder : int = 2
InterTriangle border (px): Specifies how many pixels to be left between triangles in parametrization domainmethod : str = 'Spaceoptimizing' (or int = 1)
Possible enum values:
'Basic'
'Spaceoptimizing'

compute_texcoord_transfer_vertex_to_wedge
¶ 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...

compute_texcoord_transfer_wedge_to_vertex
¶ 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.

compute_texmap_from_color
¶ MeshLab filter name: ‘Transfer: Vertex Color to Texture’
Fills the specified texture using pervertex color data of the mesh.Parameters:
textname : str = ''
Texture name: The name of the texture to be createdtextw : int = 1024
Texture width (px): The texture widthtexth : int = 1024
Texture height (px): The texture heightoverwrite : bool = False
Overwrite texture: if current mesh has a texture will be overwritten (with provided texture dimension)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

create_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 annulusexternalradius : float = 1
External Radius: Externale Radius of the annulussides : int = 32
Sides: Number of the sides of the poligonal approximation of the annulus

create_cone
¶ MeshLab filter name: ‘Cone’
Create a ConeParameters:
r0 : float = 1
Radius 1: Radius of the bottom circumferencer1 : float = 2
Radius 2: Radius of the top circumferenceh : float = 3
Height: Height of the Conesubdiv : int = 36
Side: Number of sides of the polygonal approximation of the cone

create_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

create_dodecahedron
¶ MeshLab filter name: ‘Dodecahedron’
Create an Dodecahedron

create_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'
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.

create_grid
¶ 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 positivenumverty : int = 10
num vertices on y: number of vertices on y. it must be positiveabsscalex : 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)

create_icosahedron
¶ MeshLab filter name: ‘Icosahedron’
Create an Icosahedron

create_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 expressionParameters:
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 sampledminy : float = 1
Min Y: Range where the field is sampledminz : float = 1
Min Z: Range where the field is sampledmaxx : float = 1
Max X: Range where the field is sampledmaxy : float = 1
Max Y: Range where the field is sampledmaxz : float = 1
Max Z: Range where the field is sampledexpr : str = 'x*x+y*y+z*z0.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.

create_mesh_by_grammar
¶ MeshLab filter name: ‘Structure Synth Mesh Creation’
Structure Synth mesh creation based on Eisen Script.
For further instruction visit http://structuresynth.sourceforge.net/reference.phpParameters:
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 triangleseed : int = 1
seed for random construction: Seed needed to build the meshsphereres : 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

create_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

create_octahedron
¶ MeshLab filter name: ‘Octahedron’
Create an Octahedron

create_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 spheresubdiv : 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)

create_sphere_cap
¶ MeshLab filter name: ‘Sphere Cap’
Create a Sphere Cap, or spherical dome, subtended by a cone of given angleParameters:
angle : float = 60
Angle: Angle of the cone subtending the cap. It must be < 180subdiv : 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)

create_sphere_points
¶ 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'
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 .

create_tetrahedron
¶ MeshLab filter name: ‘Tetrahedron’
Create a Tetrahedron

create_torus
¶ MeshLab filter name: ‘Torus’
Create a TorusParameters:
hradius : float = 3
Horizontal Radius: Radius of the whole horizontal ring of the torusvradius : float = 1
Vertical Radius: Radius of the vertical section of the ringhsubdiv : int = 24
Horizontal Subdivision: Subdivision step of the ringvsubdiv : int = 12
Vertical Subdivision: Number of sides of the polygonal approximation of the torus section

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_non_active_rasters
¶ MeshLab filter name: ‘Delete all Non Selected Rasters’
All non selected raster layers are deleted

delete_non_visible_meshes
¶ MeshLab filter name: ‘Delete all non visible Mesh Layers’
All the non visible mesh layers are deleted

export_mesh_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'
SketchFab Account API token: The API token of the account on which to upload the model.
You can find it by going on Settings > Password and API > API token.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.

generate_alpha_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 bboxfiltering : str = 'Alpha Complex' (or int = 0)
Possible enum values:
'Alpha Complex'
'Alpha Shape'

generate_boolean_difference
¶ MeshLab filter name: ‘Mesh Boolean: Difference’
This filter extecutes an exact boolean difference between two meshes.
The filter uses the original code provided in the libigl library.
The implementation refers to the following paper:
Qingnan Zhou, Eitan Grinspun, Denis Zorin, Alec Jacobson,
"Mesh Arrangements for Solid Geometry"Parameters:
first_mesh : int = 0
First Mesh: The first operand of the boolean operationsecond_mesh : int = 0
Second Mesh: The second operand of the boolean operationtransfer_face_color : bool = False
Transfer face color: Save the color of the birth face to the faces of resulting mesh.transfer_face_quality : bool = False
Transfer face quality: Save the quality of the birth face to the faces of resulting mesh.transfer_vert_color : bool = False
Transfer vertex color: Save the color of the birth vertex to the faces of resulting mesh. For newly created vertices, a simple average of the neighbours is computed.transfer_vert_quality : bool = False
Transfer vertex quality: Save the quality of the birth vertex to the faces of resulting mesh. For newly created vertices, a simple average of the neighbours is computed.

generate_boolean_intersection
¶ MeshLab filter name: ‘Mesh Boolean: Intersection’
This filter extecutes an exact boolean intersection between two meshes.
The filter uses the original code provided in the libigl library.
The implementation refers to the following paper:
Qingnan Zhou, Eitan Grinspun, Denis Zorin, Alec Jacobson,
"Mesh Arrangements for Solid Geometry"Parameters:
first_mesh : int = 0
First Mesh: The first operand of the boolean operationsecond_mesh : int = 0
Second Mesh: The second operand of the boolean operationtransfer_face_color : bool = False
Transfer face color: Save the color of the birth face to the faces of resulting mesh.transfer_face_quality : bool = False
Transfer face quality: Save the quality of the birth face to the faces of resulting mesh.transfer_vert_color : bool = False
Transfer vertex color: Save the color of the birth vertex to the faces of resulting mesh. For newly created vertices, a simple average of the neighbours is computed.transfer_vert_quality : bool = False
Transfer vertex quality: Save the quality of the birth vertex to the faces of resulting mesh. For newly created vertices, a simple average of the neighbours is computed.

generate_boolean_union
¶ MeshLab filter name: ‘Mesh Boolean: Union’
This filter extecutes an exact boolean union between two meshes.
The filter uses the original code provided in the libigl library.
The implementation refers to the following paper:
Qingnan Zhou, Eitan Grinspun, Denis Zorin, Alec Jacobson,
"Mesh Arrangements for Solid Geometry"Parameters:
first_mesh : int = 0
First Mesh: The first operand of the boolean operationsecond_mesh : int = 0
Second Mesh: The second operand of the boolean operationtransfer_face_color : bool = False
Transfer face color: Save the color of the birth face to the faces of resulting mesh.transfer_face_quality : bool = False
Transfer face quality: Save the quality of the birth face to the faces of resulting mesh.transfer_vert_color : bool = False
Transfer vertex color: Save the color of the birth vertex to the faces of resulting mesh. For newly created vertices, a simple average of the neighbours is computed.transfer_vert_quality : bool = False
Transfer vertex quality: Save the quality of the birth vertex to the faces of resulting mesh. For newly created vertices, a simple average of the neighbours is computed.

generate_boolean_xor
¶ MeshLab filter name: ‘Mesh Boolean: Symmetric Difference (XOR)’
This filter extecutes an exact boolean symmetric difference (XOR) between two meshes.
The filter uses the original code provided in the libigl library.
The implementation refers to the following paper:
Qingnan Zhou, Eitan Grinspun, Denis Zorin, Alec Jacobson,
"Mesh Arrangements for Solid Geometry"Parameters:
first_mesh : int = 0
First Mesh: The first operand of the boolean operationsecond_mesh : int = 0
Second Mesh: The second operand of the boolean operationtransfer_face_color : bool = False
Transfer face color: Save the color of the birth face to the faces of resulting mesh.transfer_face_quality : bool = False
Transfer face quality: Save the quality of the birth face to the faces of resulting mesh.transfer_vert_color : bool = False
Transfer vertex color: Save the color of the birth vertex to the faces of resulting mesh. For newly created vertices, a simple average of the neighbours is computed.transfer_vert_quality : bool = False
Transfer vertex quality: Save the quality of the birth vertex to the faces of resulting mesh. For newly created vertices, a simple average of the neighbours is computed.

generate_by_merging_visible_meshes
¶ 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 deletedParameters:
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 = True
Keep unreferenced vertices: Do not discard unreferenced vertices from source layers
Necessary for pointcloud layers.

generate_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 nonempty finite set of points.

generate_copy_of_current_mesh
¶ MeshLab filter name: ‘Duplicate Current layer’
Create a new layer containing the same model as the current one

generate_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 shaperadius : 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.

generate_dust_accumulation_point_cloud
¶ MeshLab filter name: ‘Dust Accumulation’
Simulate dust accumulation over the mesh generating a cloud of points lying on the current meshParameters:
dust_dir : numpy.ndarray[numpy.float64[3]] = [0, 1, 0]
Direction: Direction of the dust sourcenparticles : int = 3
max particles x face: Max Number of Dust Particles to Generate Per Faceslippiness : float = 1
s: The surface slippines(large s means less sticky)adhesion : float = 0.2
k: Factor to model the general adhesiondraw_texture : bool = False
Draw Dust: create a new texture saved in dirt_texture.png

generate_from_selected_faces
¶ MeshLab filter name: ‘Move selected faces to another layer’
Selected faces are moved (or duplicated) in a new layer. Warning! pervertex and perface 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.

generate_from_selected_vertices
¶ MeshLab filter name: ‘Move selected vertices to another layer’
Selected vertices are moved (or duplicated) in a new layer. Warning! pervertex 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.

generate_iso_parametrization_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, 2010Parameters:
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).

generate_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, 2010Parameters:
samplingrate : int = 10
Sampling Rate: This specify the sampling rate for remeshing. Must be greater than 2

generate_marching_cubes_apss
¶ MeshLab filter name: ‘Marching Cubes (APSS)’
Extract the isosurface (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 2008Parameters:
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.

generate_marching_cubes_rimls
¶ MeshLab filter name: ‘Marching Cubes (RIMLS)’
Extract the isosurface (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 NonLinear 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.

generate_plane_fitting_to_selection
¶ MeshLab filter name: ‘Fit a plane to selection’
Create a quad on the plane fitting the selectionParameters:
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 selectionsubdiv : int = 3
Plane XY subivisions: Subdivision steps of plane bordershasuv : bool = False
UV parametrized: The created plane has an UV parametrizationorientation : str = 'quasiStraight Fit' (or int = 0)
Possible enum values:
'quasiStraight Fit'
'Best Fit'
'XZ Parallel'
'YZ Parallel'
'YX Parallel'
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.

generate_polyline_from_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 savedParameters:
planeaxis : str = 'X Axis' (or int = 0)
Possible enum values:
'X Axis'
'Y Axis'
'Z Axis'
'Custom 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 Customplaneoffset : float = 0
Cross plane offset: Specify an offset of the crossplane. 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'
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 closedsplitsurfacewithsection : 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.

generate_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

generate_polyline_from_selection_perimeter
¶ MeshLab filter name: ‘Create Selection Perimeter Polyline’
Create a new Layer with the perimeter polyline(s) of the selection borders

generate_resampled_uniform_mesh
¶ 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 coincidentdiscretize : 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
Multisample: 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 convert thin floating surfaces into solid, thick meshes.. t

generate_sampling_clustered_vertex
¶ 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 onepergridded 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'
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.

generate_sampling_element
¶ 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'
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.

generate_sampling_montecarlo
¶ 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 pervertex quality values of the mesh.Parameters:
samplenum : int = 8
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
PerFace 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 Samplingexactnum : 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 Poissondistributed 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.

generate_sampling_poisson_disk
¶ MeshLab filter name: ‘Poissondisk Sampling’
Create a new layer populated with a point sampling of the current mesh;samples are generated according to a Poissondisk 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 2012Parameters:
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 specificationmontecarlorate : int = 20
MonterCarlo OverSampling: The oversampling 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 Poissondisk 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

generate_sampling_regular_recursive
¶ MeshLab filter name: ‘Regular Recursive Sampling’
The bounding box is recursively partitioned in a octree style, center of bbox are considered, when the center is nearer to the surface than a given threshold 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.

generate_sampling_stratified_triangle
¶ 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'
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 nonfaux 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.

generate_sampling_texel
¶ 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 generatedParameters:
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

generate_sampling_volumetric
¶ 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.

generate_sampling_voronoi
¶ MeshLab filter name: ‘Voronoi Sampling’
Compute a sampling over a mesh and perform a Lloyd relaxation.Parameters:
iternum : int = 10
Iteration: number of iterationssamplenum : int = 10
Sample Num.: Number of samplesradiusvariance : 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'
distancetype : str = 'Euclidean' (or int = 0)
Possible enum values:
'Euclidean'
'Quality Weighted'
'Anisotropic'
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'
 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. Reassociation to vertex is done at the end..

generate_simplified_point_cloud
¶ MeshLab filter name: ‘Point Cloud Simplification’
Create a new layer populated with a simplified version of the current point cloud. The simplification is performed by subsampling the original point cloud using a Poisson Disk strategy.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 specificationbestsampleflag : 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.

generate_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 substituted 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 NonFaux edges will be considered for conversion.cylindersidenum : int = 16
Cylinder Side: Number of sides of the cylinder (both edge and vertex).

generate_splitting_by_connected_components
¶ MeshLab filter name: ‘Split in Connected Components’
Split current Layer into many layers, one for each connected componentsParameters:
delete_source_mesh : bool = False
Delete source mesh: Deletes the source mesh after all the connected component meshes are generated.

generate_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 edges until 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 ballpivoting algorithm for surface reconstruction.
IEEE TVCG 1999Parameters:
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 rollingdeletefaces : 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.

generate_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 conjugategradients solver will be used to solve the linear system. Beyond this depth GaussSeidel 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 noisefree 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, noisereduced, 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
GaussSeidel Relaxations: This integer value specifies the number of GaussSeidel 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 unitlength prior to reconstruction.preclean : bool = False
PreClean: Enabling this flag force a cleaning prepass on the data removing all unreferenced vertices or vertices with null normals.

generate_surface_reconstruction_vcg
¶ MeshLab filter name: ‘Surface Reconstruction: VCG’
The surface reconstrction algorithm that have been used for a long time inside the ISTIVisual 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: VoxelSidesubdiv : 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 directorysmoothnum : int = 1
Volume Laplacian iter: How many volume smoothing step are performed to clean out the eventually noisy borderswidenum : int = 3
Widening: How many voxel the field is expanded. Larger this value more holes will be filledmergecolor : 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.

generate_voronoi_atlas_parametrization
¶ 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

generate_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.

generate_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'

get_area_and_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.

get_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'
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 = 1e07
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.

get_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 qualityweighted barycenter (pointcloud only), surface area (mesh only), volume (closed mesh) and Inertia tensor Matrix (closed mesh). Open the layer dialog to see the results.

get_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. Distance is stored in vertex quality of the sampled 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 = 8
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.

get_overlapping_meshes_graph
¶ MeshLab filter name: ‘Overlapping Meshes’
Use an occupancy grid to see which meshes overlap between themselves.Parameters:
ogsize : int = 50000
Occupancy Grid Size: To compute the overlap between range maps we discretize them into voxel and count them (both for area and overlap); This parameter affect the resolution of the voxelization process. Using a too fine voxelization can...

get_scalar_histogram_per_face
¶ MeshLab filter name: ‘Per Face Quality Histogram’
Compute an histogram of the values of the perface quality.Parameters:
histmin : float = 0
Hist Min: The faces are displaced of a vector whose norm is bounded by this valuehistmax : float = 0
Hist Max: The faces are displaced of a vector whose norm is bounded by this valueareaweighted : 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.

get_scalar_histogram_per_vertex
¶ MeshLab filter name: ‘Per Vertex Quality Histogram’
Compute an histogram of the values of the pervertex 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 = 0
Hist Min: The vertex are displaced of a vector whose norm is bounded by this valuehistmax : float = 0
Hist Max: The vertex are displaced of a vector whose norm is bounded by this valueareaweighted : 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.

get_scalar_statistics_per_face
¶ MeshLab filter name: ‘Per Face Quality Stat’
Compute some aggregate statistics over the per vertex quality, like Min, Max, Average, StdDev and Variance.

get_scalar_statistics_per_vertex
¶ MeshLab filter name: ‘Per Vertex Quality Stat’
Compute some aggregate statistics over the per vertex quality, like Min, Max, Average, StdDev and Variance.

get_topological_measures
¶ MeshLab filter name: ‘Compute Topological Measures’
Compute a set of topological measures over a mesh.

get_topological_measures_from_quad_mesh
¶ MeshLab filter name: ‘Compute Topological Measures for Quad Meshes’
Compute a set of topological measures over a quad mesh.

load_active_raster_cameras
¶ MeshLab filter name: ‘Import cameras for active rasters from file’
Import cameras for active rasters from .out or Agisoft .xml formatsParameters:
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.

meshing_close_holes
¶ MeshLab filter name: ‘Close Holes’
Close holes smaller than a given thresholdParameters:
maxholesize : int = 30
Max size to be closed : The size is expressed as number of edges composing the hole boundaryselected : bool = False
Close holes with selected faces: Only the holes with at least one of the boundary faces selected are closednewfaceselected : 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 NPcomplete.

meshing_cut_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.

meshing_decimation_clustering
¶ 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 gridParameters:
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

meshing_decimation_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.

meshing_decimation_quadric_edge_collapse
¶ MeshLab filter name: ‘Simplification: Quadric Edge Collapse Decimation’
Simplify a mesh using a quadric based edgecollapse strategy. A variant of the well known Garland and Heckbert simplification algorithm with different weighting schemes to better cope with aspect ration andd planar/degenerate quadrics areas.
See:
M. Garland and P. Heckbert.
Surface Simplification Using Quadric Error Metrics (pdf)
In Proceedings of SIGGRAPH 97.Parameters:
targetfacenum : int = 6
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 shapepreserveboundary : bool = False
Preserve Boundary of the mesh: The simplification process tries to do not affect mesh boundaries during simplificationboundaryweight : 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 surfacepreservetopology : 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 PerVertex 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
Postsimplification 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!

meshing_decimation_quadric_edge_collapse_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. Inspired in the QSLIM surface simplification algorithm by Michael Garland, which turned into the industry standar method for mesh simplification.
See:
M. Garland and P. Heckbert.
Simplifying Surfaces with Color and Texture using Quadric Error Metrics (pdf)
In Proceedings of IEEE Visualization 98.Parameters:
targetfacenum : int = 6
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 shapeextratcoordw : float = 1
Texture Weight: Additional weight for each extra Texture Coordinates for every (selected) vertexpreserveboundary : bool = False
Preserve Boundary of the mesh: The simplification process tries not to destroy mesh boundariesboundaryweight : 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 surfaceplanarquadric : 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!

meshing_edge_flip_by_curvature_optimization
¶ MeshLab filter name: ‘Curvature flipping optimization’
Mesh optimization by edge flipping, to improve local mesh curvatureParameters:
selection : bool = False
Update selection: Apply edge flip optimization on selected faces onlypthreshold : 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'
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)

meshing_edge_flip_by_planar_optimization
¶ MeshLab filter name: ‘Planar flipping optimization’
Mesh optimization by edge flipping, to improve local triangle qualityParameters:
selection : bool = False
Update selection: Apply edge flip optimization on selected faces onlypthreshold : 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'
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 topologyiterations : int = 1
Post optimization relax iter: number of a planar laplacian smooth iterations that have to be performed after every run

meshing_invert_face_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 outsideonlyselected : bool = False
Flip only selected faces: If selected, only selected faces will be affected

meshing_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 operations to regularize size and aspect ration of the triangular meshing. Loosely inspired to:
Hugues Hoppe, Tony DeRose, Tom Duchamp, John McDonald, and Werner Stuetzle.
Mesh optimization
(SIGGRAPH '93). ACM, New York, NY, USA, 19–26. DOIParameters:
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 operationsplitflag : 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
EdgeSwap Step: If checked the remeshing operations will include a edgeswap 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.

meshing_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.

meshing_poly_to_tri
¶ MeshLab filter name: ‘Turn into a PureTriangular mesh’
Convert into a trimesh by splitting any polygonal face.

meshing_re_orient_faces_coherentely
¶ MeshLab filter name: ‘ReOrient all faces coherentely’
Reorient 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.

meshing_refine_by_function
¶ MeshLab filter name: ‘Refine UserDefined’
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 perface 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, vi0, vi1, vi2 for vertex indices, q0,q1,q2 for vertex quality, wtu0,wtv0 wtu1,wtv1 wtu2,wtv2 for perwedge texture coords, ti for face texture index, vsel0,vsel1,vsel2 for vertex selection (1 yes, 0 no) fi for face index, 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 edgex : str = '(x0+x1)/2'
x =: function to generate x coord of new vertex in [x0,x1].
For example (x0+x1)/2y : str = '(y0+y1)/2'
y =: function to generate x coord of new vertex in [y0,y1].
For example (y0+y1)/2z : str = '(z0+z1)/2'
z =: function to generate x coord of new vertex in [z0,z1].
For example (z0+z1)/2

meshing_remove_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.

meshing_remove_connected_component_by_diameter
¶ MeshLab filter name: ‘Remove Isolated pieces (wrt Diameter)’
Delete isolated connected components whose diameter is smaller than the specified constantParameters:
mincomponentdiag : Percentage = 10%
Enter max diameter of isolated pieces: Delete all the connected components (floating pieces) with a diameter smaller than the specified oneremoveunref : bool = True
Remove unfreferenced vertices: if true, the unreferenced vertices remaining after the face deletion are removed.

meshing_remove_connected_component_by_face_number
¶ MeshLab filter name: ‘Remove Isolated pieces (wrt Face Num.)’
Delete isolated connected components composed by a limited number of trianglesParameters:
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 oneremoveunref : bool = True
Remove unfreferenced vertices: if true, the unreferenced vertices remaining after the face deletion are removed.

meshing_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.

meshing_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.

meshing_remove_folded_faces
¶ 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

meshing_remove_null_faces
¶ MeshLab filter name: ‘Remove Zero Area Faces’
Remove null faces (the one with area equal to zero)

meshing_remove_selected_faces
¶ MeshLab filter name: ‘Delete Selected Faces’
Delete the current set of selected faces, vertices that remains unreferenced are not deleted.

meshing_remove_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.

meshing_remove_selected_vertices_and_faces
¶ MeshLab filter name: ‘Delete Selected Faces and Vertices’
Delete the current set of selected faces and all the vertices surrounded by that faces.

meshing_remove_t_vertices
¶ MeshLab filter name: ‘Remove TVertices’
Delete tvertices from the mesh by edge collapse (collapsing the shortest of the incident edges) or edge flip (flipping the opposite edge on the degenerate face if the triangulation quality improves).Parameters:
method : str = 'Edge Collapse' (or int = 0)
Possible enum values:
'Edge Collapse'
'Edge Flip'
threshold : float = 40
Ratio: Detects faces where the base/height ratio is lower than this valuerepeat : bool = True
Iterate until convergence: Iterates the algorithm until it reaches convergence

meshing_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

meshing_remove_vertices_by_scalar
¶ MeshLab filter name: ‘Remove Vertices wrt Quality’
Delete all the vertices with a quality lower smaller than the specified constantParameters:
maxqualitythr : Percentage = inf%
Delete all vertices with quality under::

meshing_repair_non_manifold_edges
¶ MeshLab filter name: ‘Repair non Manifold Edges’
Remove nonmanifold edges by removing faces (for each non Manifold edge it iteratively deletes the smallest area face until it becomes 2Manifold) or by splitting vertices (each non manifold edges chain will become a border).Parameters:
method : str = 'Remove Faces' (or int = 0)
Possible enum values:
'Remove Faces'
'Split Vertices'

meshing_repair_non_manifold_vertices
¶ MeshLab filter name: ‘Repair non Manifold Vertices by splitting’
Split non Manifold vertices until it becomes 2Manifold.Parameters:
vertdispratio : float = 0
Vertex Displacement Ratio: This parameter denote the ratio ⍺ of displacement of a vertex. When a vertex v is split, it is moved towards the barycenter b of the FF connected faces sharing it of a (vb)*⍺. When ⍺ is zero vertex is not displaced. When ⍺ is 0.5 the new vertex is half away toward the barycenter of the face. Reasonable values are in the [0 .. 0.1] range.

meshing_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.

meshing_surface_subdivision_butterfly
¶ 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 meshesParameters:
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

meshing_surface_subdivision_catmull_clark
¶ MeshLab filter name: ‘Subdivision Surfaces: CatmullClark’
Apply the CatmullClark 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 fauxedge bits

meshing_surface_subdivision_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'
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

meshing_surface_subdivision_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, 561583.
The current implementation of these schemes don't handle vertices of valence > 12Parameters:
loopweight : str = 'Loop' (or int = 0)
Possible enum values:
'Loop'
'Enhance regularity'
'Enhance continuity'
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

meshing_surface_subdivision_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

meshing_tri_to_quad_by_4_8_subdivision
¶ MeshLab filter name: ‘Tri to Quad by 48 Subdivision’
Convert a tri mesh into a quad mesh by applying a 48 subdivision scheme.It introduces less overhead than the plain CatmullClark Subdivision Surfaces(it adds only a single vertex for each triangle instead of four).
See:
48 Subdivision
Luiz Velho, Denis Zorin
CAGD, volume 18, Issue 5, Pages 397427.

meshing_tri_to_quad_by_smart_triangle_pairing
¶ MeshLab filter name: ‘Tri to Quad by smart triangle pairing’
Convert a trimesh into a quad mesh by pairing triangles.

meshing_tri_to_quad_dominant
¶ MeshLab filter name: ‘Turn into QuadDominant mesh’
Convert a trimesh into a quaddominant mesh by pairing suitable triangles.Parameters:
level : str = 'Fewest triangles' (or int = 0)
Possible enum values:
'Fewest triangles'
'(in between)'
'Better quad shape'

meshing_vertex_attribute_seam
¶ MeshLab filter name: ‘Vertex Attribute Seam’
Make all selected vertex attributes connectivityindependent:
vertices are duplicated whenever two or more selected wedge or face attributes do not match.
This is particularly useful for GPUfriendly 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'
colormode : str = 'None' (or int = 0)
Possible enum values:
'None'
'Vertex'
'Wedge'
'Face'
texcoordmode : str = 'None' (or int = 0)
Possible enum values:
'None'
'Vertex'
'Wedge'

nxs_build
¶ MeshLab filter name: ‘NXS Build’
Nexus is a collection of tools for streaming visualization of large 3D models in OpenGL.
This filter is the equivalent of calling nxsbuild: it creates a nxs file starting from a obj, ply or stl.Parameters:
input_file : str = ''
Input File: The input file from which create the .nxs file.output_file : str = ''
Output File: The name of the output nxs file.node_faces : int = 32768
Node faces: Number of faces per patch, (min ~1000, max 32768)
This parameter controls the granularity of the multiresolution: smaller values result in smaller changes (less 'pop').Small nodes are less efficient in rendering and compression.
Meshes with very large textures and few vertices benefit from small nodes.top_node_faces : int = 4096
Top node faces: Number of triangles in the top node. Controls the size of the smallest LOD. Higher values will delay the first rendering but with higher quality.tex_quality : int = 95
JPEG texture quality [0100]: jpg texture qualityram : int = 2000
Ram buffer: Max ram used in MegaBytes (WARNING: just an approximation)skiplevels : int = 0
Skip levels: Decimation skipped for n levels. Use for meshes with large textures and very few vertices.origin : numpy.ndarray[numpy.float64[3]] = [0, 0, 0]
Origin: new origin for the modelcenter : bool = False
Center: Set origin in the bounding box centerpow_2_textures : bool = False
Pow 2 textures: Create textures to be power of 2deepzoom : bool = False
Deepzoom: Save each node and texture to a separated file. Used for server which do not support http range requests (206). Will generate MANY files.adaptive : float (bounded) = 0.333 [min: 0; max: 1]
Adaptive: Split nodes adaptively. Different settings might help with very uneven distribution of geometry.

nxs_compress
¶ MeshLab filter name: ‘NXS Compress’
Nexus is a collection of tools for streaming visualization of large 3D models in OpenGL.
This filter is the equivalent of calling nxscompress, whichcreates a nxz (compressed nexus) file starting from a nxs.Parameters:
input_file : str = ''
Input File: The input nxs file to compress into an nxz file.output_file : str = ''
Output File: The name of the output nxz file.nxz_vertex_quantization : float = 0
NXZ Vertex quantization: absolute side of quantization grid (uses quantization factor, instead)vertex_bits : int = 0
Vertex bits: number of bits in vertex coordinates when compressing (uses quantization factor, instead)quantization_factor : float = 0.1
Quantization factor: Quantization as a factor of errorluma_bits : int = 6
Luma bits: Quantization of luma channelchroma_bits : int = 6
Chroma bits: Quantization of chroma channelalpha_bits : int = 5
Alpha bits: Quantization of alpha channelnormal_bits : int = 10
Normal bits: Quantization of normalstextures_precision : float = 0.25
Textures precision: Quantization of textures, precision in pixels per unit

raster_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. 'Imagetogeometry registration: a mutual information method exploiting illuminationrelated geometric properties', 2009, Get linkParameters:
rendering_mode : str = 'Combined' (or int = 0)
Possible enum values:
'Combined'
'Normal map'
'Color per vertex'
'Specular'
'Silhouette'
'Specular combined'
shot : Shotf [still unsupported] = None
Starting shot: If the point of view has been set by hand, it must be retrieved from current trackballestimate_focal : bool = False
Estimate focal length: Estimate focal length: if not checked, only extrinsic parameters are estimatedfine : bool = True
Fine Alignment: Fine alignment: the perturbations applied to reach the alignment are smallernumofiterations : int = 100
Max iterations: Maximum number of iterationstolerance : float = 0.1
Tolerance: Threshold to stop convergenceexpectedvariance : float = 2
Expected Variance: Expected Variancebackgroundweight : int = 2
Background Weight: Weight of background pixels (1, as all the other pixels; 2, one half of the other pixels etc etc)

raster_global_refinement_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 nonactive ones will be used but not refined. This filter is an implementation of Dellepiane et al. 'Global refinement of imagetogeometry 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'
max_number_of_refinement_steps : int = 5
Maximum number of minimizations step: Maximum number of minimizations step on the global graphthreshold_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 refinementpre_alignment : bool = False
Prealignment step: Prealignment stepestimate_focal : bool = True
Estimate focal length: Estimate focal lengthfine : bool = True
Fine Alignment: Fine alignment

save_active_raster_cameras
¶ MeshLab filter name: ‘Export active rasters cameras to file’
Export active cameras to file, in the .out or Agisoft .xml formatsParameters:
exportfile : str = 'Bundler .out' (or int = 0)
Possible enum values:
'Bundler .out'
'Agisoft xml'
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.

save_snapshot
¶ 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.

set_camera_per_mesh
¶ MeshLab filter name: ‘Set Mesh Camera’
This filter allows one to set a shot for the current meshParameters:
shot : Shotf [still unsupported] = None
New shot: This filter allows one to set a shot for the current mesh.

set_camera_per_raster
¶ MeshLab filter name: ‘Set Raster Camera’
This filter allows one to set a shot for the current meshParameters:
shot : Shotf [still unsupported] = None
New shot: This filter allows one to set a shot for the current raster.

set_color_per_vertex
¶ 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

set_matrix
¶ 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 changedalllayers : bool = False
Apply to all visible Layers: If selected, the filter will be applied to all visible mesh layers

set_matrix_identity
¶ 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

set_mesh_name
¶ MeshLab filter name: ‘Rename Current Mesh’
Explicitly change the label shown for a given meshParameters:
newname : str = 'cube'
New Label: New Label for the mesh.

set_raster_name
¶ MeshLab filter name: ‘Rename Current Raster’
Explicitly change the label shown for a given rasterParameters:
newname : str = ''
New Label: New Label for the raster.

set_selection_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.

set_selection_none
¶ MeshLab filter name: ‘Select None’
Clear the current set of selected faces/vertices.Parameters:
allfaces : bool = True
Deselect all Faces: If true the filter will deselect all the faces.allverts : bool = True
Deselect all Vertices: If true the filter will deselect all the vertices.

set_texture_per_mesh
¶ 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 the filter will fail with no further actions.Parameters:
textname : str = ''
Texture file: Sets the given input image as unique texture of the mesh.

transfer_attributes_per_vertex
¶ MeshLab filter name: ‘Vertex Attribute Transfer’
Transfer the chosen pervertex 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 meshnormaltransfer : 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 meshcolortransfer : 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 meshqualitytransfer : 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 meshselectiontransfer : 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 facequalitydistance : bool = False
Store dist. as quality: if enabled, we store the distance of the transferred value as in the vertex qualityupperbound : 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

transfer_attributes_to_texture_per_vertex
¶ 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 transfertargetmesh : int = 0
Target Mesh: The mesh whose texture will be filled according to source mesh dataattributeenum : str = 'Vertex Color' (or int = 0)
Possible enum values:
'Vertex Color'
'Vertex Normal'
'Vertex Quality'
'Texture Color'
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 datatextname : str = 'texture.png'
Texture file: The texture file to be createdtextw : int = 1024
Texture width (px): The texture widthtexth : int = 1024
Texture height (px): The texture heightoverwrite : bool = False
Overwrite Target Mesh Texture: if target mesh has a texture will be overwritten (with provided texture dimension)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_iso_parametrization_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, 2010Parameters:
sourcemesh : int = 0
Source Mesh: The mesh already having an Isoparameterizationtargetmesh : int = 0
Target Mesh: The mesh to be Isoparameterized

transfer_texture_to_color_per_vertex
¶ 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 fromtargetmesh : int = 0
Target Mesh: The mesh whose vertex color will be filled according to source mesh textureupperbound : 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