Summary:
The authors present an ITK implementation of the Quad-Edge data structure proposed by Guilbas and Stolfi. This new data structure is designed to coexist with the itkMesh structure currently in ITK 3.0. The new classes have the advantage to enforce the two manifold property of surfaces and to access neighbor cells in constant time. Some mesh filters in ITK 3.0 can process the new data structure, other filters cannot and need to be rewritten or have a version specific for Quad-Edge.

Evidence:
The paper describes the case of the Simplex Mesh, which is typically built as the dual of a Marching Cubes mesh. Since the new classes encodes the primal-dual relations, building the Simplex Mesh becomes straightforward. The new data structure encodes adjacency information and allows for switching to the dual representation in constant time.

Open Science:
The paper provides two example meshes and the code to compute the shortest path between two arbitrary nodes. A performance measure is also given for the access to neighbors after the modification of the connectivity. It would be interesting to choose a typical filter such as Laplacian smoothing, and to compare the timing in VTK and in itkQE including the construction of the QE data structure.

Reproducibility:
I could reproduce the results presented in the paper without a problem. Both the sample data and the code are provided. The example meshes are in the VTK format and can be read using the ParaView.

Use of Open Source Software:
The code provided use both the VTK and the ITK toolkits. The mesh IO and the visualization are performed with VTK. Some code to convert vtkPolyData and vtkUnstructuredGrid meshes to itkQE for internal processing is also available, although vtkUnstructuredGrid might not be appropriate for two-manifold meshes.

Open Source Contributions:
The authors provide the source code with example data and sample applications under a BSD license. The applications that were used to generate the images in the paper can be found along with the paper. Besides the LaTeX code required to compile the paper is also provided. Hence this contribution is fully Open Source!

Code Quality:
Some variable names do not strictly follow the ITK standards for explicit names. The code style issues need to be fixed before the classes can be integrated into the toolkit. Besides some classes are not described in the paper and their  documentation is missing.

Applicability to other problems:
For examples of medical applications where a mesh data structure is created, the authors might be interested in the following papers published in the Insight Journal: http://hdl.handle.net/1926/50 and http://hdl.handle.net/1926/225.

Suggestions for future work:
It would be interesting to measure the time and memory consumption to convert a regular mesh into a quad-edge data structure. In particular, how the performance for the construction of the quad-edge structure compare to the BuildCellLinks method in ITK?

Requests for additional information from authors:
The caption of the diagrams might give more details about the concepts they illustrate. Besides the definition of the canonical operators might be expanded when they first appear in the paper.

Additional Comments:
For 2D surfaces embedded in 3D, the new data structure proposed in this paper offers a very interesting contribution. For N-dimension meshes, the current ITK mesh data structure must still be used. With the goal of integrating the new data structure into the toolkit, the compatibility of every mesh filter currently in ITK will have to be verified.

Summary:
The authors present implementation of a new data structure for better integration of surface (mesh) based processing algorithms and easier integration/combination of surface and image processing algorithms as well into ITK. Different toolkits are analyzed and compared to the classes/algorithms currently available in ITK. Weaknesses and strengths are discussed and necessity for a better implementation is explained. Next different approaches for surface representation are given and compared with respect to memory usage and computational efficiency for different mesh operations. It is explained why the authors chose to implement a quad-edge representation both from the surface processing view and the image processing view.

Next the authors explain their implementation in detail and give various examples of new applications and also showing how ITK could benefit from the new implementation. For instance mesh modification as adding/removal of faces could speed-up dramatically as the BuildCellLinks() (traversal over the whole map of cells) would not be required anymore. Furthermore topological operators would directly be available with the new implementation, making new mesh filters like decimation, refinement or multi-resolution algortihms easy to implement. Furthermore the new implementation could unify the currently seperated implementation of the simplex meshes into the same framework naturally. The authors also state that implementation of the already existing simplex mesh deformation filters can be simplified.

A new iterator was implemented and is described in detail. It will extract neighboring edges or faces with respect to an arbitrary metric. Many possible applications are named and some are explained in more detail.

Todays itkMesh only supports image processing. For surface processing one would have to use VTK. All the necessary conversions for going from ITK to VTK and maybe back complicate the use of surface-based image processing algorithms. The here presented datastructure would help to unify both and could greatly simplfy programming in the area of image processing.

Hypothesis:
Provide more efficient and easier to use data structures for surface-based image processing.

Evidence:
In their paper the authors give coding examples showing how to use the new data structures. They also analyze the computational costs for removing cells from a mesh and compared it to ITKs current implementation. And give conrecte numbers for the speed-up. They show ease-to-use their implementation. Looking at the code examples I would say the classes might be a usefule extension.

Open Science:
The authors provide a fully 'Open Science compatible' implementation, an extension of ITKs current mesh classses. The source code is provided and is well documented. They reimplemented many of ITKs mesh relevant tests and examples showing how simple their classes can replace the old ones. Input data (surfaces used for the paper) are provided. Results can simply be reproduced by running the example programs.

Reproducibility:
The work is reproducable. I downloaded the code. It compiled, tests and most of the examples ran straight forward. Switching on FLTK did unfortunately result in a CMake crash (cmake 2.4 patch 3, fltk-1.1.x-r5526, Visual Studio 2003) at my machine. I could only run the VTK and command line examples, but they looked fine. Results seem to be correct.

Maybe the authors could give a short code example (just some code snippets) on how to rework the simplex meshes including mesh deformation. Having this it would be much easier to estimate the effort for reimplementing these parts of ITK.

Although I got it running easily, a short section on how to compile, which versions to use etc. might be good.


Use of Open Source Software:

-

Open Source Contributions:
Throughout the whole contribution one can feel it was designed to be put into ITK from the beginning.

I only tried to run the code and did not implement anything new, but looking at the tests and the examples seems to make it not too difficult to start with. Actually there is more examples on how to use the QEMesh then there is for using the current itkMesh. There are also code snippets in the paper.

Code Quality:
Looks ok to me. It might not go with the ITK StyleGuide everywhere.

Applicability to other problems:
There is a number of possible applications most of them dealing with surface processing or image proscessing, e.g. surface-based deformable models or active shape models.

Suggestions for future work:
-

Requests for additional information from authors:
-

Additional Comments:
Concluding I can say that the source code is of good quality. There is only one issue I would like to discuss not only with the authors of the paper but also with other ITK users/developers and maybe the developers of the old mesh classes:

We already have data structures for meshes in ITK. There were alot of flaws in these classes. The authors pointed them out again. Before going through the whole pipeline of putting in the new classes we should re-think the concept to not to forget important features again. From my point of view the implementation presented here looks good. But there might be other developers who might think different and still would not use the new ITK classes for some other reasons or already know about missing features.

Backwards compatibility might be another an issue. Would we have to keep all the old classes, e.g. Simplex Meshes as well? Who would maintain this code or who will rewrite these classes based on the new datastructures?

Also until now using the mesh classes was very complicated. And even though the new approach seems to be much more simple it might still be too difficult for people not familiar with surface representations or surface-based image processing algorithms. The authors should add a section where more basic things about mesh representation, topology changes or time/memory-efficient implementation is explained. This would help to better understand necessity of the whole contribution. I think the authors started one level too high.

Regarding the paper I found a few spelling mistakes. Furthermore sorting of the pages was strange. One figure page was between the bibliography pages.

Figure 10 is hard to read and I would reanmed caption to "... of the itkQE classes and their integration into ITK". I also think you should somehow clarify what each of the colors means and you should put the itkQE namespace into the diagram.

There are a lot of small correctios in the pape I would suggest mostly spelling. I could start correcting this stuff now but wanted to finally send out the general review before.

Summary:

itkQuadEdgeMesh is essentially a new data structure which promises various features which currently do not exist in itkMesh. The one very important feature which is mentioned in the paper and also I have come across a few times writing my own research code, is being able to access the adjacent edges and faces of a particular vertex at any instance. This becomes an issue even more in cases where the original mesh is for instance a platonic solid such as icosahedron at which each vertex has 5-6 neighboring vertices.

My understanding of itkQuadMesh set of classes is simply that they are meant to replace itkMesh. From what I know there are many many classes in itk which either use itkMesh as a super class or class its various methods. Even though the authors claim that the switch from itkMesh to itkQuadMesh should be simple and pain free. I am still not convinced unless I actually do the conversion on the itk tree myself.

In short, even though itkQuadMesh promises very many features that I am sure many people including myself will greatly benefit from, I still believe that itkMesh should be kept and must remain mainly unchanged. My recommendation would be for a mechanism at which itkQuadMesh and itkMesh could coexist within itk tree. This will allow the users to determine the right data structure for their specific purpose.

Hypothesis:

(N/A)

Evidence:

The authors provide various reference at which the data structure and its various features are explained in great detail. I believe there is enough evidence given to support and prove the point they are trying to make.

Open Science:

I believe the entire code is provided as open source. There does not seem to be any license associated with the code so I do not believe there will be any problems if it is added to itk tree.

Reproducibility:

I have managed to download the code and built it as part of my itk tree with the changes which are specified by the authors with minor changes.

I find that the paper lacks explaining some concepts including the very basic ones which are simply referred to the references. I believe specially with topics such as this one which are a bit complicated to grasp, some basic concepts must be explained within the paper itself simply to make sure the readers can understand and follow the paper. For instance, on page (5), it is mentioned that Quad-Edge data structure is presented in detail in reference 16 instead of providing a simple explanation within the paper.

Use of Open Source Software:

(N/A)

Open Source Contributions:

The entire source code is provided along with the contribution. I specifically like the way they have names various directories similar to itk tree structure (i.e., Code/Common) so that the user can simply place the code in the corresponding directory, make the necessary Cmake changes and start building it. Personally, I did not take me long to use the code as I use itk on a regular basis and this is nothing different. However, other people might have a different experience as there is a fair bit of code that needs to be built.

Code Quality:

I looked at various files and they seem to follow the main itk style. Just like any other code contributed to itk, the code needs to be polished. However I am confident that the changes will be minor in this case.

Applicability to other Problems:

As I mentioned before, this data structure will be extremely useful to algorithms which require neighboring faces and edges. Currently, I am writing some brain segmentation code (mouse images) and I think this data structure would be greatly useful to me had it been part of the itk tree.

Suggestions for Future Work:

(N/A)

Requests for Additional Information from Authors:

(N/A)

Additional Comments:

I think this is a great contribution to itk and specifically to open source community.