Summary:

Summary:
A heuristic method is presented that converts SpatialObjects into image masks. It is shown that the by downsampling and using a mask that significant time savings can be acheived for
fast conversions.


Hypothesis:
Converting from SpatialObjects to image binary representations is an important and time critical task. By downsampling and masking a smaller area of interest, much of the un-interesting
part of the image do not need to be accessed or analyzed.

Evidence:
Several synthetic and real world examples were given to demonstrate that the proposed algorithm performs much faster than the existing SpatialObject to image conversion algorithms.

Open Science:
The source code, data, and scripts necessary to replicate the findings are available.

Reproducibility:
I did not complie and run the source code, but I did review the automated dashboard builds.


Use of Open Source Software:
ITK software coding paradigms were used, and a description of how to integrate with existing code base was given. Additional information regarding modification of existing code base
could better support integration of the new methods was also discussed.

Open Source Contributions:
Yes.

Code Quality:
The code is well documented, and conforms to the ITK coding standards.

Applicability to other problems:
This is a specialized function that is only intended for this single purpose. The concept of reducing scale size for efficient computation is common in many image processing applications.

Suggestions for future work:


The documentation demonstrates that the algorithm is much faster, but also alludes to the fact that the results are "nearly identical". It would be nice to have a classification of where the
types of problems were this algorithm is appropriate, and where it would be necessary to expend the extra computational time to get an exact result. How does the MaskDilationSize affect
the speed and accuracy?

It seems to me that even a very large MaskDilationSize may not produce an accurate result compared to the original implementation. Is this correct?

Summary:
A new filter for faster conversion of sparse itk::SpatialObjects to itk::Image is presented. First, a mask covering the relevant (non-zero) parts of the spatial object is computed at a low resolution; the sampling at the full resolution of the image is then done within the masked region only.

Evidence:
Results of the speed-up are presented for artificial and real-world examples.

Open Science:
Images, source code and test programs are included in the package.

Reproducibility:
Did you reproduce the authors’ work? Yes.
Did you download their code? Did you compile it? Did you run it? Yes.
Did you managed to get the same results that they reported? Yes, except I did not try to verify the time measurements.

Use of Open Source Software:
ITK is used.

Open Source Contributions:
Do the author’s provide their source code? Yes.
Is it in a form that is usable? Yes.
Do they describe clearly how to use of the code? Yes.
How long did it take you to use that code? It is very easy to use, since the filter is a replacement of itk::SpatialObjectToImageFilter with a few additional parameters (e.g., size of the mask).

Code Quality:
The code is well documented, multi-platform, and written in ITK style.

Additional Comments:
Due to a configuration problem (which was obviously my fault) I found a minor issue in the tests: argv[XXX] is used with XXX up to 10 before a check whether that much parameters are provided (abort if argc < XXX+1). Of course, it should be the other way round.

Summary:
This paper proposed a filter to reduce the computational time to convert spatial objects to an image.

Hypothesis:
Not applicable.

Evidence:
Not applicable.

Open Science:
Do the authors provide the source code of the programs used in their experiments? Yes.
Do the authors provide the input images that they used? Yes.
Or are those images publicly available? Yes.
Do the authors provide the output images that they show in the paper? Yes.
Do the authors provide enough details for you to be able to replicate their work? Yes

Reproducibility:

Did you download their code? Did you compile it? Did you run it? Yes.
Were there information missing from the paper, that was necessary for you to reproduce the work? Yes.

Use of Open Source Software:
ITK

Open Source Contributions:
Do the author’s provide their source code? Yes
Is it in a form that is usable? Yes
Do they describe clearly how to use of the code? Yes
How long did it take you to use that code? a moment

Code Quality:
If the authors provided their source code: Was the code easy to read? Yes
Did they use a modern coding style? Yes

Summary:
This paper presents a way to increase the speed of the Spatial Object to Image conversion.

Hypothesis:
Time difference is relevant for SOs which occupy less volume than the total output.

Evidence:
Tests and computational time graphs show the performance of the filter.

Open Science:
This paper adheres to the concept of Open Science: images, source code and test programs are included in the package.

Reproducibility:
The code was downloaded and compiled without pb in Windows XP with VC .NET 7.1 compiler.
The test were run correctly.
However when setting an origin different of [0,0,0] the present code won\'t work. An insight into Author\'s code confirms that (\"TODO: make work for origin not [0,0,0]\").
I wanted to test the code on my own Spatial Object and image where I need to set origin of output image to a non zero origin.
I modify simply the code by adding in the GenerateMask() function these two lines:

after the loop \"for (unsigned int dim=0; dim < OutputImageDimension; dim++)\" I added the line: filterConvertMask->SetOrigin( m_Origin );
Then in the similar way in the next loop \"for (unsigned int dim=0; dim < OutputImageDimension; dim++)\" I replace the line
finalMaskOrigin[dim] = 0.0; //TODO: make work for origin not [0,0,0]
by
finalMaskOrigin[dim] = m_Origin[dim];

It test it on a few SO, it seems to work, however the author should examine these modifications carefully.

Use of Open Source Software:
Yes, the code is 100% ITK.

Open Source Contributions:
The code is clear and easy to use. The usage being similar to SpatialObjectToImageFilter, no difficulties were encountered.

Code Quality:
The code quality is good and the code is well commented.

Applicability to other problems:
Could inspire a fast IsInside test for SOs in case they are not moving. A coarse image mask can be generated and used. If the IsInside test of SO is expensive, an image test can be then cheaper.

Suggestions for future work:
Add in the test procedure a subtraction phase that compares the result of the class SOToImageFilter and the new proposed one. This will ensure that the 2 filters produce the same output.

Requests for additional information from authors:
Just by curiosity, how the vessels extraction of the proposed SO as data test had been performed?

Comments

One thing should be precised in the following filter: because a coarser version of the output image is used, the result shoud not be as accurate and expected in case of conversion to image with preservation of the Spatial object values. In fact the spatial object ValueAt() function returns the spatial object value at a specified position. Even if in most case this information is not relevant, for some spatial object the value is important, such as GaussianSpatialObject or ImageSpatialObject. The consequence of the usage of the coarse mask is that the output image will be a coarse version of the values of the spatial object.

In most case however, when binary output is produced, this is not an issue.

The current implementation is still very usefull and is very fast compared to the original version.