From Meshlab

This page reports the project ideas that can be implemented by willing developers. Many of the projects will be assigned to the students of the University of Pisa course FGT that will carry out them in the next months as part of their course job. If anyone has some suggestion of desired features can add them here.

I strongly suggest to all the willing developers to look at the Writing Code page, read the various practical advices and, eventually, follow them. Practical hints on how to compile MeshLab can be found here. The vast majority of the projects here presented should be implemented as standard meshlab plugins, and therefore they could be developed in a rather independent way.

The number of asterisks beside to each project is an approximate indication of the complexity of the project. A single star means a rather easy project, four stars hard/very complex.

All questions and discussions about the development to various projects should be sent (in English) to the meshlab-devel mailing list (yes it holds for the FGT students too).

Completed Projects have been moved to their page.

FGT 09/10 Procedural Genration and evolutionary stuff

The idea is to strenghten the capability of meshlab to genereate nice artistic procedural shapes.

Structure Synth support (Gregorio Palmas)

Code will be in:

filter_ssynth

Structure Synth is a very nice and appealing GPL application for creating 3D structures from a set of user specified rules. It would be great to bring its parser in a pluging. The code is rather well structured, so It could be reasonable to get the parser and provide a function that given a grammar build a vcg mesh. Such a piece of code could be integrated in meshlab as a filter: parameters are simply the grammar filename and the very few parameters that the Structure Synth GUI allow to provide (max recursion, random seed, ?). Also an editing plugin could be provided that in this case also offer the possibility of editing the current grammar. The author of Structure Synth knows and supports this integration. It could be integrated in three ways:

• as a filter of class create
• as a IO pluging
• as an edit plugin

Implementation Steps

• Deep look at the structure synth code. Try to understand if the eisenstein engine is something really detatched from the application http://structuresynth.sourceforge.net/development.php
• Contact the author of structure synth querying him with doubts.
• build a minimal filter that get a file parse it and generate the mesh

• write a template that exports in a format that meshlab can easily read (x3d)
• evaluate the possibility of invoking directly structuresynth

Text Generation (Beatrice Bucciarelli)

Code will be in:

filter_text

A filter that given a string of text generate a 3d model of the text with the choosen font. Not quite complex using qt support.

• support for bevel
• solid wireframe

• Get outline from qt

QPainterPath textPath;
QFont timesFont("Times", 50);
timesFont.setStyleStrategy(QFont::ForceOutline);
textPath.addText(10, 70, timesFont, tr("MeshLab"));	
QList<QPolygonF> textPoly = textPath.toFillPolygons();

• fill the path with a triangulation (wrap/gl/glutessellator.h); Note that Qt can perform a basic polygonalization too...
• build a simple extrusion library

Rock/asteroid/mountain generation (Alessandro Giannini)

Code will be in:

filter_fractal

Classical algorithm of recursive subdivide and displace. Could start from basic shapes. Optionally add craters on it. A good review of the classical algorithm for generating fractal terrains can be find in section 6.1 of this thesis.

http://www.vis.uni-stuttgart.de/~dachsbcn/download/thesis.pdf

• adapt the refine class to our need.
• implement basic displacement (and attempt to understand multifractal...)
• exploit perlin noise for placement of the vertices.
• build a filter that works on a generic mesh. Some issues:
  • direction of displacement as vertex normal smoothed.
  • Mesh has to be sufficiently refined (add an option for automatically loop refinement of mesh up to a given threshold)
  • Perturbation should be applied incrementally with 1/nth steps (re evaluating the noise function every step and eventually re-computing the direction of displacement)

• explore other noise functions....

Basic Solid shapes (Pablo Castellano)

Main article: Filters/filter_shape

Code will be in:

filter_shape

• Platonic solids Archimedean solids
• knotted objects http://en.wikipedia.org/wiki/Torus_knot. Add as many params you can imagine. Extend to build gerneric parametric surfaces.
• Height maps from images and isosurface from simple volumes

Implementation Steps

• Reorganize create filter in order to build all the platonic shapes with one single menu entry platonic (leave just create box).
• add an option for triangulating modes (star or minimal) (it is used only for solid that have non triangular faces. In progress...
• add a stellate filter
• Add archimedean solids. In progress...
• add a make dual filter (then catalan solid should came free )
• Knotted objects
• parametric surface plot using muparser (E.g. build a surface defined parametrically)

Filters that modify an existing objet

• Wireframe solid. Take a simple mesh and substitute each edge with a small cylinder.
• procedural retexturing according to the surface using cellular automata.

Breaking an object (Nadia Robertini)

Recursively split a watertight object using a randomly generated surface. Code will be in:

fgt/filter_break

Main idea. I want to break a complex object into pieces. The breaking process is recursive. Start from the whole object break it into two pieces. Repeat. How to break into two pieces. First idea. Define a fractal surface over a grid. Simplifying assumption the fractal surface is a height field over the z axis. build the intersection of the grid with the mesh by walking over the mesh on the grid.

Implementation path

• Build a slicing function.
• Build a grid slicing function (z=0)
• Build a function that build a simple fractal height field grid.
• Build a grid slicing function with the fractal height field.

Physics based stuff (Roberto Agostino Vitillo)

Code will be in:

filter_physics

These filters rely on some OS pysics engines.

• Solid filler. fill an oject with instances of another object (later)

Drop things. randomly drop many copies of an over it.

• build a minimal filter that links with ode
• convert a CMeshO into a ODE mesh
• build a miniamalfilter that use two layers. First layer is the "ground" and the second layer is the "falling object". the filter drops the falling object onto the "ground" using the current starting positions. The filter should check if the falling object miss the ground.
• prepare a simple setup of a plane and a inclined box over it. Check that it falls correctly.

Simple CSG (Andrea Canciani)

We have a more or less working version of a known algorithm to compute CSG operation over many simple objects. To be cleaned and bring into meshlab. It would be very useful for cleaning up the models created by structure synth.

• Rasterization (add intercept)
• Intercept simplification
• surface building
  • marching cube classic
  • extended marching cube

Dust accumulation (Daniele Vitale)

Code will be in:

filter_dirt

The filter should try to simulate the dust accumulation, aging and weathering of a 3D model. This process can be simulated with a varying degree of accuracy. A short list of papers describing the problem can be find here or here or in the following papers

• Hsu et al., "Simulating dust accumulation", IEEE CG&A 1995
• J. Dorsey et al., "Flow and changes in appearance", SIGGRAPH 1996
• J. Dorsey et al., "Modeling and rendering of weathered stone", SIGGRAPH 1999
• S Merillou et al., "Corrosion: simulating and rendering", Graphics Interface 2001

Implementation Steps

The idea is that the set of particles is kept as an additional mesh composed only of vertexes (A point cloud) with some attributes.

• Define a Particle objects that can move over the surface. They should be defined as an user defined attribute that contains a set of info for a generic meshlab vertex: it should contain, speed, face*, barycentric coords, mass. Position is already in the vertex.
• Implement particle surface movement: given current position find new position. Issue: it should stay on surface, e.g. you have to keep track of its movement over the surface.
• color the Destination mesh according final position of the particles
• color the Destination mesh according the movement of the particles.
• implement repulsion for particles to avoid the single point accumulation problem.

THINGS BELOW THIS LINE COULD BE A BIT OUT OF DATE....

Open Projects

Structured information reporting (***)

There is a large number of scalar,integer,boolean synthetic information that can be computed for a mesh, like for example its volume, barycenter, if it is orientable, number of connected components, etc. We already wrote a tools for computing some of these information (TriMeshInfo) and MeshLab lacks a coherent framework for computing and displaying this kind of information. A good extension should be to add a new kind of plugins for this kind of stuff and to begin to write meshlab plugins computing synthetic info about meshes.

Input/Output

While MeshLab support a wide set of 3D formats, there always be some missing formats...

Improvmente of COLLADA format

In order to allow a safe load-modify-save cycle of a single node of a complex collada file.

Support of .m format (*)

the mathematica geometry file, useful for displaying very very small meshes with the LiveGraphics3D applet (an easy way to show 3d into web pages)

Support of .dxf format (*)

only input (eventually limiting to the management of polygonal meshes)

Support of .3DXML format (***)

input and output. Nice just because there exist a free 3D snapshot tool for windows that saves in this format and there are Office plugins for showing this kind of (verbose) format.

Support of .ASE format (**)

A rather verbose ascii format, supported for exchange of 3D data. Originated by 3DSmax as a 'readable' format.

Support of ldraw.org (LEGO) format

A well documented format (http://www.ldraw.org) with a huge library for describing 3D models done by Lego pieces.

Support of .SHP format (**)

ShapeFile, the standard format for gis. Used to describe boundary of buildings, profiles needs to be extruded. Quite useful format to create cities from cadastrial maps.

Offline renderer (*)

Invoke an offline open source renderer (yafray, povray or what you like more) for creating high quality images.

Animated GIF snapshot (***)

This one should not be very difficult if the overall framework would allow timed camera movements and actions, needed for multiple rendering. It can be implemented with various level of complexity, starting from the creation of simple rotating object saved as small gif anims to a complex tools that allow to set a simple camera keypoints and produce a small looping animation of the display object.

Filters

The following ideas should be implemented as unattended filters, with an auto-generated interface, whose functionalities are exposed also in the command line version of MeshLab.

Convex Hull (**)

Integration of the open source QHull package inside meshlab. Filter for building convex hull of meshes. Eventually even Alpha shapes could also be computed. Optional part could be a variant of the edge collapse simplification algorithm that simplify a mesh by choosing new vertex positions such that the simplified mesh is larger than the previous one. In this way you can simplify a convex hull and still obtain a bounding mesh.

Texture Management stuff (**)

Set of filters oriented to texture management.

• Simple Texture coord generation cylindrical and box shaped
  Typical application is the unwrapping of painting over ancient vases where enforcing a cylindrical projection is usually a good solution
• texture to texture: between two different parameterizations of the same object.
• color to texture: also covered in a more general way in the Detail transfer, see below.
• The filter assumes that there are two aligned meshes on two layers represneting the same object at high and low resolution. The low resolution mesh has a good parametrization. The filter compute a detail texture (normal map / displacement map / color map)
• Texture compacting, A filter that take a mesh with multiple textures (e.g. where the faces can refers different textures) and compact it into a single texture mesh by building a bigger texture atlas containing all the submeshes and updating tex coords accordingly. There could be some problems with texture wrapping modes, but they could be detected by looking at the tex coords of the mesh. Eventually these issues could be solved by expanding some textures at the expenses of wasted texture space, or solved by splitting the involved triangles. This filter is already in but needs refactoring.

Stitching

A filter that takes two meshes that lie in the same space with a given overlap and merge them by following, more or less the algorithm described in: G. Turk and M. Levoy, “Zippered polygonal meshes from range images”, Siggraph, 1994

Smoothing

Implementing the bilaplacian smoothing flow smoothing algorithm as described in L. Kobbelt, S. Campagna, J. Vorsatz, and H.-P. Seidel. Interactive multiresolution modeling on arbitrary meshes. In Proceedings of ACM SIGGRAPH 98, pages 105–114, 1998 and described also in

Alexander Belyaev, Yutaka Ohtake, "A Comparison of Mesh Smoothing Methods", Israel-Korea Bi-National Conference on Geometric Modeling and Computer Graphics, 2003

Mesh Optimization

A filter that take a mesh and a point cloud in input and perform a sequence of mesh optimization step like in the Mesh optimization framework.

Authors Hugues Hoppe Tony DeRose Tom Duchamp John McDonald Werner Stuetzle, "Mesh optimization", Siggraph 1993

The optimization steps can be operations of the following type.

• edge collapse
• edge flip
• edge refine

The choice of what step is performed is done using a greedy approach.

Interactive Editing Tools

The following tools should be implemented as 'edit plugins' e.g. plugins with require and manage user interaction over the mesh. Their functionalites may not be exposed in the command line version of meshlab.

Photo Texturing (****)

Allocated to Sebastian Herholz
A tool to align and project one photo onto a mesh. This would include the an (eventually) automated calibration of implicit camera parameters and the recovering of explicit ones by means of user chosen photo-geometry correspondences (using for example the Tsai's Camera Model. Some functionalities of the tool:

• EXIF data recovering through the use of the jead source code http://www.sentex.net/~mwandel/jhead/
• TSAI Calibration
• The tool should allow to load a jpg, read the exif data, show the image in the edit plugin window in a opengl context. The photo shoud be draggablea nd zoomable (same interface of the drag/zoom of the mesh, using the same trackball helper)
• the tool should allow to add/edit/remove (twelve?) labeled correspondences between the photo and the image
• the tool should allow to start a calibration process (try do not integrate it too tightly so that we could add different calibration codes later)
• Allow intrinsic calibration (just in case of missing exif)
• Show the calibration result/error in a friendly way
  • back projection of the mesh in the image window
  • per-correspondence error indication (just find wrongly placed correspondences)
  • camera position in mesh space
• texture coords generation on the mesh.
• optional saving of extrinsic data in some usable (?) format.

Framework Stuff

The projects here require substantial changes to the meshlab framework, and therefore are more complicated and with the possibility of affecting also other existing stuff...

MeshLab Command Line (meshlabserver)

Currently it does work, but many users consider it as a very important feature.

It should be able to process also meshes without the needs of the a little cumbersome filterscript mechanism. allowing to the user to specify the parameters of the filters on the command line. It should also have an automatic mechanism for displaying the list of possible filters, with parameters and explanation of the filter parameters.

Approximate Faster Rendering (****)

When multiple meshes are loaded, using layers, only a small subset of them have to be completely in memory for being processed. Some approximated rendering techniques for having a low resolution simple model should be attempted. Techniques should be fast and require no preprocessing. Requires serious changes to the rendering cycle and to the management of the mesh document itself. Not an harmless modification. Only for the bravest.

New Selection sets (****)

Currently meshlab select only faces, but also vertex and edge (boundaryies) selection could be a nice option for some filters.

Partial Layers (****)

The objective should be to allow the sharing of common data between layers. E.g. imagine to have the same mesh onto two layers but with different colors, or quality, or etc. Or to have the same topology with different vertex coords. Many possibilities here, but difficult to be implemented.

UNDO (***)

Oh well the most requested feature. A good implementation would require that each filter declare exactly what it is changing and what has to be saved.

Already under development projects

Improved Shading support

Allocated to Felice Giovinazzo and Raffaello Brondi Fabio Franconeri

Current support of render monkey shaders should be enhanced by allowing a more tight integration between MeshLab and the shaders. Techniques for declaring "capabilities and needs" of shaders should be added, like for example the need for texture coords. Possibility of passing special named uniforms should be added (like for example the quality, or the radius, or the curvatures). Some advanced shaders should be added.

• Robust Sharp Shadows
• Soft Shadows
• Screen space ambient occlusion.
• quality mapping

A good starting point for documentation on the above shaders is [1] If a third developer join in, a couple of advanced additional shaders should be added

• an as faithful as possible recreation of the nice shading of zbrush.
• a npr shader that exploit curvature direction to create hatching.

Flexible Support of RAW format (***)

Allocated to Davide Sechi (due by 09/2008)
For reverse engineering of unknown but trivial file formats. It would be very useful to have a flexible way to parse any unknown format, allowing the user to set, in a easy and interactive way, how the mesh elements are placed in the file and in what format;

Generative mesh instancing filter

Allocated to Raglianti Marco (due by 06/2008)
This set of filter tools create a mesh out of nothing.

• [ http://en.wikipedia.org/wiki/Archimedean_solid | Platonic solids ]
• Archimedean solids http://en.wikipedia.org/wiki/Archimedean_solid
• knotted objects http://en.wikipedia.org/wiki/Torus_knot
• Height maps from images
• isosurface from simple volumes
• Fractal mountains and planets

Dirty maker filter

Allocated to Luca Bartoletti (due by 02/2008) (due by 07/2008)
The filter should try to simulate the dust accumulation, aging and weathering of a 3D model. This process can be simulated with a varying degree of accuracy. A short list of papers describing the problem can be find here or here or in the following papers

• Hsu et al., "Simulating dust accumulation", IEEE CG&A 1995
• J. Dorsey et al., "Flow and changes in appearance", SIGGRAPH 1996
• J. Dorsey et al., "Modeling and rendering of weathered stone", SIGGRAPH 1999
• S Merillou et al., "Corrosion: simulating and rendering", Graphics Interface 2001

Geometric Processing filters

Allocated to Davide Spano (due by 08/2008)
This is a small set of purely geometric filters.

• edge smoothing. Smooth borders vertices in order to create smoother hole loops.
• border simplification. Collapse edges along the borders only. Again for creating 'simpler hole loops that are easier to be filled.
• T-vertex detection and management (vertex-removal and vertex add strategies)
• Folded triangles correction (initially single triangle folded)
• Non manifold smart management (3: deletion/detach of the least aligned triangle, 4: deletion of double triangle)
• Evalutating of the integration of VRip as a single filter like the poisson surface reconstruction

Other unallocated stuff

• Border Management
  • selection management
  • wrt quality, size, aspect ratio
• refinement and meshing
  • sqrt3
• Smart Non manifold management

Editing Plugins

Improved Slicing Tool

Allocated to Edoardo Pocci (due by 06/2008)
The tool allow a better and finer control on the slicing cross section creation process. A good ispiration could be the cross section tool that is present inside Acrobat Reader. Load this pdf into a recent version of Acrobat Reader and play with the cross section interface (rightmost button in the 3d toolbar).

Required features include:

• preset planes (x y z)
• plane specified by three point selections
• numerical control; the user should be able to numerically set the position and orientation of the planes.
• cut and cap; the slicing tool should be able to actually cut the original mesh into pieces and try fill the created holes (if it does sense e.g. if the boundary of the slice is one or more closed loops).
• opengl preview; a small window with all the slices. Eventually with some interaction (zoom and pan over the slices)