Summary:
Composition of transformations. ITK still does not have any unified means of
transformation composition (or adition), the author tries to fill in this hole.

Hypothesis:
Non Applicable

Evidence:
Non Applicable

Open Science:
All source code and details needed are provided.

Reproducibility:
I have compiled and run the code. It would be fine if there were test images
and transform files prepared from the author to simplify the first testing.

Use of Open Source Software:
Only ITK is used.

Open Source Contributions:
With my setup of ITK (only an ITK build) it was impossible to configure the
project. Provided CMakeLists.txt uses a LOADPACKAGE macro from IJMacros.txt
which fails to include UseITK.cmake correctly. This is caused by the fact
it tries to include ITK_INCLUDE_DIR which points to non-existing directory
and not ITK_USE_FILE. To compile remove first part of the
IF(${Package}_INCLUDE_DIR) block.

Code Quality:
Source code is clear and simple as it should be. The only error, as pointed out
by another reviewer, is that GetJacobian() implementation is incorrect.

Applicability to other problems:
An improved version of this class could be used for many tasks as well as any normal transform.

Suggestions for future work:
This class lacks methods to enable using it with registration which is a major
drawback. Jacobian computation must be corrected and methods to access to
parameters added.

I think the way this class stores transforms (a list of transforms) is better
than in another IJ entry CombineTransform (a pair of transforms). Maybe a
AddTransforms(ListType) method can be added to simplify the usage with
TransformReader.

Requests for additional information from authors:
None.

Additional Comments:
As suggested in itk-users mailing list, a merge of SerialTransform and
CombineTransform classes that removes shortcommings of both CombineTransform
and SerialTransform would be ideal.

An option to specify which parameters are fixed or not, and therefore which can
be optimized would be useful.

Summary:
The paper describes a class that supports the composition of transforms for the image resampling task. It does not support the registration task. It can handle an arbitrarily long chain of transforms.

Evidence:
A program is provided to demonstrate the class. However, no input or expected output was provided.

Open Science:
The paper adheres to the principles of open science.

Reproducibility:
I compiled and ran the code without difficulty. In order to test it, i had to modify the code slightly to register the transforms that i used in my input file with the transform factory. I tried some simple test cases and it worked. I only tried in 2D, as the example program is written for that case.

Use of Open Source Software:
The authors use ITK and CMake

Open Source Contributions:

The contribution is open source.

Code Quality:
The class is somewhat incomplete. Get/Set parameters should be provided, at a minimum. The Get Jacobian method is flawed. No testing code was provided.

Applicability to other problems:
This has wide applicability as compound transforms arise frequently in image processing. Unfortunately, the class is somewhat incomplete, since it does not support the registration framework, or get/set parameters. This limits its usefulness as is.

Suggestions for future work:
Future work could clearly be to combine this with the other paper on this topic, the combination transform. It would be very nice to handle the Jacobian and parameters properly so that it could be used in the registration framework.

Summary:
The paper describes a class to combine Transforms by means of composition. This is useful. The transform is not meant to be used in the registration framework, as a transform that is optimised. It can be used to resample an image for example.

This is my first review for the Insight Journal. I apologise if it doesn't conform to the standards/rules of reviews.

Hypothesis:
Non Applicable

Evidence:
Non Applicable

Open Science:
Non Applicable

Reproducibility:
I did not try to compile or run the code

Use of Open Source Software:
ITK

Open Source Contributions:
All necessary code is provided, along with a clear example of usage.

The paper has quite some overlap with another paper (coauthored by me), 2006-January-June, Combining Transforms in ITK, which describes the CombinationTransform. The advantage of the CombinationTransform is that it supports the registration framework (it implements the Get/SetParameters method) and that it also supports Addition of transforms, instead of Composition. The SerialTransform is however more easy in use, since it accepts more than two transforms. With the CombinationTransform you can set one InitialTransform, which could be again a CombinationTransform; so you need to set the transforms recursively. In the SerialTransform there is simply a list of transforms.

Code Quality:
The code is easy to read. I personally do not like that all function implementations are included the header. I have a few comments:

- The class provides a method to add transforms to the transform list, but not to clean the transform list. A kind of Initialize() method would be useful.

- GetInverse could be implemented.

- The m_TransformList is declared as "private". I would suggest making it protected, which would allow inheriting classes to provide additional methods to set/get the transforms, or implement the Set/GetParameters, or GetInverse() methods.

- The implementation of GetJacobian is incorrect. It seems that the author had the "spatial jacobian" in mind. dT/dx, instead of the derivative with respect to the transform parameters, which it should be. Like this it would probably even result in errors, since at line 137-140 the m_Jacobian element (dim,dim) is accessed, while the size of the m_Jacobian is initialised as (dim,0) in the itk::Transform::constructor. Since the Set/GetParameters are not supported by this class, the GetJacobian is useless, I think.

Applicability to other problems:
Non Applicable

Suggestions for future work:
Combining the CombinationTransform and the SerialTransform in one class that has the advantages of both.

Requests for additional information from authors:
none

Additional Comments:
none