cnr-isti-vclab / meshlabjs Goto Github PK

On OSX it works regularly on firefox and safari but gives the following compilation error on chrome:

THREE.WebGLShader: Shader couldn't compile.
THREE.WebGLShader: gl.getShaderInfoLog() ERROR: 0:73: '=' : global variable initializers must be constant expressions 
WARNING: 0:79: '=' : global variable initializers should be constant expressions (uniforms and globals are allowed in global initializers for legacy compatibility) 

THREE.WebGLShader: gl.getShaderInfoLog() WARNING: 0:41: '
' : extension directive must occur before any non-preprocessor tokens 

THREE.WebGLProgram: shader error: 0 gl.VALIDATE_STATUS
THREE.WebGLProgram: gl.getProgramInfoLog()invalid shaders
 exectution time 167 ms

ThreeJS has a small stat showing library for showing fps etc...
Not sure if we should use that or just the fps number

Add a parameter widget for giving in input a 3D point or a 3D vector.
It should be able to offer the possibility to choose:

• the position of a point over the surface (by picking)
• the normal of a point over the surface (by picking)
• the current viewing direction

Currently phong shader is a dump of the threejs phong shader. It is huge...
It should be reduced to the barely needed functionalities in the beloved spirit of reducing the code...

We should definitely have it.

In the Color dialog of the rendering tab there should be something to show the name of the file of the texture and the possibility to use the texture as base albedo color (togheter with uniform/pervertex/perface)

As a dedicated 2D ui space for viewing images and parametrizations we use one other tab called "texture" where we show the texture(s) of the current mesh. there is a button to show the parametrization in the image space.
There are Rulers on the side of the image (for uv coord) and the image is draggable and zoomable

Optionally we need a space to list all the textures associated with a mesh
it could be a combobox in this tab or a subtree element in the layer list.

e.g. searching for Loop should return refine filter

The technique is used a lot by meshlab users and it is illustrated in practice in this video:
https://www.youtube.com/watch?v=eFIff7H7Ams

The technique is described in this paper:
https://hal.inria.fr/inria-00449828/PDF/RadianceScaling.pdf

Code examples can be found in the meshlab repository:
https://github.com/svn2github/meshlab/tree/master/meshlab/src/meshlabplugins/render_radiance_scaling

and here:
http://manao.inria.fr/demos/radiancescaling_demo/

Add a parameter widget to choose one of the available layers as a input parameter for a filter.
This is fundamental for algorithms that take in input two meshes and make something (like computing the Hausdorff distance)

We need a way to reset the trackball to the initial position

Still to be implemented

Someone should fill these two sections of the js/mlj/Readme.md

Development Environment
Javascript & C++ Interaction

There is the need of having filters that allows the inclusion of simple formulas like the "geometric function" of MeshLab that allow you to change x,y,z according to a given expression.

http://muparser.beltoforion.de/ is the best candidate.

Loop and butterfly are missing...

As an option wireframe should be shaded too.

It would be nice to have a simple way to open a mesh already on the web. e.g. if I drag a http address on the window or write it somewhere it should download and open it directly.

Optionally it should also work with zip files
http://gildas-lormeau.github.io/zip.js/

When a point cloud is added to the scene the default rendering mode should be Points and not filled.
Another (Much BETTER!) possibility could be that we have a clear api to turn on/off a rendering pass for a given mesh from inside the a filter. E.g. from the sampling filter when we have just created the newmesh we turn on the "Points" rendering pass for it.

As an option Small Particles (spheres) should be used to render the vertexes.

In the rendering tab once you have opened the parameter for a given rendering pass (.e.g wire) it is no more clear to what rendering pass this parameters refer to...
Some visual cues should be added to maintain the relation between these parameters and the originating rendering pass.

It would be useful if the widget when the slider is dragged could emit the change signal continuously and not only on mouse release.
It should be optional (with default = true).

Very bumpy zooming. If you rotate the wheel slowly, most of the notches do nothing...
Rotation and panning is smooth

Add a link to the generated code documentation from somewhere.

It has to be implemented in a robust and complete way.

We store a DAG (direct aciclic graph) storing the dataflow representing all the actions done over our document (set of meshes).
each action can involve none, one or more current layers and it is stored togheter with its parameters
for each step we memorize a copy of the changed nodes.

Visualizing this dataflow graph could be useful (but left to future). We just need the possibility of navigating it back and forth.

Probably getVertexVector and getFaceVector method should be removed and
buildMeshGeometry should try to access directly to the cpp mesh object.
In any case MeshLabJS.should go away.

Quite similar to the MeshLab one: A bounding box of the current mesh that is also quoted, e.g. it has the coords values shown on the axes.
There are two tricky parts:

• Choosing the right edge where to display the numbers. It is a view dependent choice that should choose the best (out of the possible 4) edge, i.e. the most external one.
• Pretty format the numbers. Choose the right amount of numbers to be shown, again it is a view dependent choice, and it is a bit tricky (you have to choose the right subdivision for ticks so that nice numbers are always shown. It should be better than the meshlab one:
  • number could be rotated in 2D in the best way (perpendicular to the axis)
  • numbers could be fully 3D (lying in the plane of the right bbox face)

create a sphere, cluster and then try to refine....

An overlay that show on the 3D screen geometric info on the mesh (bbox size, volume, surface area, center of mass)

Use the tooltip text to automatically generate a (static) HTML page with all the available filters. This should be added to the pipeline of generating stuff (compiling cpp, compiling doc, compiling filter list)

all invert none dilate erode

Still to be implemented

Delete Layer
Duplicate Layer
Flatten Layer

implemented as filters.

The system should be able to load multiple files simultaneously.
Connected to the need of matrix44 for each mesh.

Add the possibility of rendering per vertex and per face color in the filled rendering mode.

Like in meshlab we need a way to input a number that can be easily inserted as a percentage of the bbox of the scene

Like in the above example the two edit field are connected and continuously updated: the left editbox contain the value in world unit (as common float parameter input) and the right one contains the same value expressed as a percentage of the diagonal of the boundingbox of the scene. When the user change one value the other one is updated accordingly.
The widget returns the value in world unit

When specified we imagine something like that

vertRatioWidget = builder.RelativeFloat({
            defperc=1.0,
            label: "Vertex Ratio",
            tooltip: "Probability that a vertex is randomly selected"
        });

where defperc is the default percentage shown in the widget at the start

In firefox and safary on osx the lower left log window use only the first two lines
(and also the font is different...)

http://stackoverflow.com/questions/7091538/is-it-possible-to-disable-ctrl-f-of-find-in-page

There is another class of plugins that should be added with its own tab: Tools

'Tools' are pieces of functionality that include direct interaction with the mesh itself by mean of mouse actions:

• Selection Tool
• Inspection tool
• Measuring tool
• Moving tool
• Painting
• Fixing/Smoothing

Each tool plugin should manage mouse input,
Should have a clear start/stop
The tool tab contains an icon for each tool.
The first icon is a trackball and it allow to return to the standard browsing mode. The space below the trackball is used for tool parameter.
Somewhere on the screen there should be a remainder of what tool mode the system is.

To allow a robust way of implementing undo each tool can modify the mesh(es) only by mean of c++ functions that take in input a mesh and some parameters like camera and finalized mouse input (e.g. the selection tool works by calling a c++ function that take in input the view parameters and the on screen rectangle given by the user).

Hole filling:
Following the basic pieces in library provide a filter that fills a hole and, after the closure of the hole
it performs some remeshing in order to improve the generated triangulation.
Remeshing should be done by iterating refinement, smoothing and edge-flipping until certain conditions on the generated triangles are met.
Eventually at the end displace the vertex of the surface in order to ensure better boundary continuity.

When called from a filter to remove a layer it fails on trying to remove file reference

Rendering that shows the selected elements
Parameters are:

• color (default red)
• float transparency
• face boolean (default: true)
• vert boolean (default: true)
• vert size (size of the dot used to show selected vertices)

It is implemented using two auxiliary cpp functions that builds geometries that will be added to the threejs scene.

Just like in MeshLab and in SketchFab doubleclick shoudl move trackball origin into the clicked point

Try to re-use the same geometry for different rendering plugins to avoid useless memory duplication