Conformal Flattening ITK Filter

Please use this identifier to cite or link to this publication: http://hdl.handle.net/1926/225
This paper describes the Insight Toolkit (ITK) Conformal Flattening filter: itkConformalFlatteningFilter.
This ITK filter is an implementation of a paper by Sigurd Angenent, et al., “On the Laplace-Beltrami
Operator and Brain Surface Flattening”. This filter performs an angle preserving map of any genus
zero (i.e. no handles) triangulated mesh to the sphere or, alternatively, to the plane. In other words,
any given triangle in the resulting sphere will have the same angles as the corresponding triangle in the
original mesh, though their areas may differ. In this paper, we describe our code and provide the user
with enough details to reproduce the results which we present in this paper. This filter has a variety of
applications including the flattening of brain surfaces, which was the initial motivation for this work.
Data
minus 3 Files (9Mb)
Code
minus Automatic Testing Results by Insight-Journal Dashboard on Fri Aug 18 15:25:13 2006 for revision #3
starstarstarstarstar expertise: 5 sensitivity: 4.7
yellow This project was submitted with no test cases.
Click here for more details.

Go here to access the main testing dashboard.
plus Automatic Testing Results by Insight-Journal Dashboard on Wed Jul 19 13:54:48 2006 for revision #2
starstarstarstarstar expertise: 5 sensitivity: 5
plus Automatic Testing Results by Insight-Journal Dashboard on Mon Jul 10 23:47:48 2006 for revision #1
starstarstarstarstar expertise: 5 sensitivity: 5

Reviews
minus Useful class for triangle meshes, working fine off the shelf by Sylvain Jaume on 10-10-2006 for revision #3
starstarstarstarstar expertise: 3 sensitivity: 4.7
yellow
Summary:
The paper describes an implementation of the paper about conformal flattening of triangle surfaces by Angenent et al. 1999.
The code uses VTK and ITK, and includes a new ITK class, three applications, and two example surfaces.

Hypothesis:
The paper addresses the flattening of *triangle* surfaces, typically obtained with the Marching Cubes algorithm. The implementation applies to surfaces of genus zero with no boundaries, i.e. closed surfaces with no handles.
A triangle surface can be mapped on a 2D parameterization under one of two constraints: to preserve the area of the triangles (authalic flattening), or to preserve the angles of the triangles (conformal flattening).
The authors take the conformal flattening approach.

Evidence:
Two example applications are included: one with a synthetic surface and one brain surface.
The quality of the results is only reported for the synthetic surface. Besides it would be interesting to visualize the angle ratios computed in anglePreserveCheck.
Finally a scalar bar with a title and units would make the figures more informative.

Open Science:
The authors provide everything to reproduce the results in the paper. However they do not give some information that the user needs to reproduce similar results with her/his own data.
The way the triangle meshes were created and the quality of the triangles may dramatically impact the results of the flattening. How the example surfaces were created, and what are the equations or input images?
Which tools were used, in which order? What are the parameters? What are the potential issues and workarounds (e.g. increasing the value of one parameter)?

Reproducibility:
The code compiles like a charm on VS8 and is straightforward to use (one input and one output). I got exactly the results reported in the paper.
To take advantage of the IJ testing facility, the authors may want to add a test in the CMakeLists.txt.

Use of Open Source Software:
The authors mention that they use 'open-source tools', but these tools require manual editing. More information about this editing would help potential users.

Open Source Contributions:
The three applications are easy to compile, to run and to understand.
Their code only differs in the visualization parameters of their Display method. Would it make more sense to factorize the surface flattening in a single application and the visualization in another?
This second application could have two sets of parameters: one for nice.vtk and one for brain.vtk.

Code Quality:
I noticed major VTK memory leaks. For instance instances of vtkIdList are created and never deleted.
To be consistent with the ITK style, the underscore at the begining of variable names could be removed.
For the same reason, the name of the class methods could start with a capital letter: setPointP, mapToSphere, mapToPlane, setScale.
As for the documentation of the methods, it is preferred to write the comments before the method signature.
Future users of this code would aprreciate if all methods were documented.

As it is, the code may cause runtime errors. Calls to 'return' are missing after every itkExceptionMacro.
It is recommended to insert filter->Update() in a try/catch block.
Why setting point P to -100000 in brainTest.cxx and itkConformalFlatteningFilterTest.cxx?
vtkPolyDataNormals may create some problems since it may duplicate points. In any case, it does not seem to improve the rendering.

Applicability to other problems:
The numerous problems that require a 2D parameterization could benefit from this implementation.

Suggestions for future work:
The authors may be interested in using the topology correction code OpenTopology published in the InsightJournal.

Requests for additional information from authors:
The implementation could be explained further in the paper (matrix construction, solver for the equation system, vnl functions called, etc.).
How the equations of section 1 (that can be found in Angenent et al. paper) map to the actual code that the authors contributed?
Only two sentences at the end of section 1 offer some information about the implementation.

Additional Comments:
The information that anglePreserveCheck writes to the standard output needs some revisions: the file is named angleRatioDiff.txt and it contains the ratios for the angles around every node.
minus conformal flattening filter by Xiaoning Qian on 09-02-2006 for revision #3
starstarstarstarstar expertise: 3 sensitivity: 4.3
yellow
Summary:
This paper describes the implementation of an angle preserving flattening
algorithm. The algorithm provides one alternative for the brain study after
the conformal flattening map.

Hypothesis:
The implemented algorithm preserves relative angles and guarantees a
bijective map and the original structure can be recovered by inverse
map. ( The later is not shown as the main point though. )


Evidence:
The authors only provide the results for one synthetic and one brain. They
look good and the mean and s.t.d. of angle ratios for the brain is valid.
But as the authors noted, they could not get more brain surface as the
current segmentation algorithms are not able to give them genus zero
surfaces.


Open Science:
The source codes and data for the algorithm used in the experiments is
provided. The authors follow the standards of open source.

Reproducibility:
I haven't run the algorithm or tests the authors provided.

Use of Open Source Software:
The codes are based on ITK.

Code Quality:
I haven't looked at the source codes carefully at this time.

Applicability to other problems:
The statistical study for any genus zero surface.

Suggestions for future work:
The work probably needs more data for testing.

Additional Comments:
There are some typos in the paper. (for example, in pape 2)
And also, it seems to me that the authors directly took the mathematical
part for the reference [1]. I think that some intuitive introduction of the
algorithm would be better.

Comment by Yi Gao: yellow
Reviewer's Comment:
it seems to me that the authors directly took the mathematical part for the reference [1].

Author's Response:
Yes you are correct. However, the purpose of this paper is to implement an existing algorithm into ITK, rather than to discuss, interpret, modify or improve the algorithm itself.

---------------------------------------

Reviewer's Comment:
they could not get more brain surface as the current segmentation algorithms are not able to give them genus zero surfaces.

Author's Response:
This is true. Since the ITK tend to separate different task in different class and this one is only focusing on the flattening function given the input as a genus zero surface, we did not put more emphasis on the segmentation part for outputting a genus zero surface.
Actually, to my knowledge, to generate a genus zero surface from 3D image data is not a trivial task itself.

---------------------------------------
Reviewer's Comment:
The implemented algorithm preserves relative angles and guarantees a bijective map and the original structure can be recovered by inverse map. (The later is not shown as the main point though. )

Author's Response:
Yes this is a good point. Actually we have considered the necessity of this function:
1. If you are talking about the mathematical proof of this mapping being bijective, although this paper is not concerning with mathematical part, it can be seen that since the mapping is given as one-to-one projection, the bijectivity is obvious.

2. If you are suggesting implementation an inverse mapping filter:
If the algorithm is an iterative method and the bijectivity is not that clear, to show the result of inverse mapping is a good support for the inevitability of the algorithm. However in this case, the mapping is given as an one-point-to-one-point mapping. It's not that necessary for doing this.

That's the reason we didn't include inverse mapping in it.
Add a new review
Quick Comments


Resources
backyellow
Download All

Statistics more
backyellow
Global rating: starstarstarstarstar
Review rating: starstarstarstarstar [review]
Code rating: starstarstarstarstar
Paper Quality: plus minus

Information more
backyellow
Keywords: Conformal Flattening, Brain, Mesh, ITK, VTK, Angle-preserving
Toolkits: ITK (moved into the sandbox)
Export citation:

Share
backyellow
Share

Linked Publications more
backyellow
Anisotropic Fast Marching in ITK Anisotropic Fast Marching in ITK
by Mirebeau J.
Diffeomorphic Demons Using ITK's Finite Difference Solver Hierarchy Diffeomorphic Demons Using ITK's Finite Difference Solver Hierarchy
by Vercauteren T., Pennec X., Perchant A., Ayache N.

View license
Loading license...

Send a message to the author
main_flat
Powered by Midas