Insight Journal - Alternative Memory Models for ITK Images

Alternative Memory Models for ITK Images

Mueller D.

Philips Healthcare

Please use this identifier to cite or link to this publication: http://hdl.handle.net/10380/3068

Published in The Insight Journal - 2009 July-December.

Submitted by Dan Mueller on 07-03-2009.

By default ITK images use a contiguous memory model. This means pixel elements are stored in a single 1-D array, where each element is adjacent in memory to the previous element. However in some situations it is not desirable to use this memory model. This document describes three alternative memory models: slice contiguous, sparse, and single-bit binary images. Slice contiguous images are three-dimensional images, in which each slice is stored in a contiguous 1-D array, but the slices are not necessarily adjacent in memory. Slice contiguous images are well suited for interoperability with applications representing images using DICOM. Sparse images are n-dimensional images, in which each pixel is stored in a hash table data structure. This memory model is well suited for images with very large dimensions, but few pixels which are actually relevant. Single-bit binary images internally represent each pixel as a single-bit, in contrast to eight-bits required to represent a boolean. Single-bit binary images allow very compact representations for on-off masks. Source code, tests, and examples are provided to allow easy reproduction and use.

Code

Automatic Testing Results by Insight-Journal Dashboard on Fri Jul 10 00:58:01 2009 for revision #4

expertise: 5 sensitivity: 5

Automatic Testing Results by Insight-Journal Dashboard on Thu Jul 9 14:30:48 2009 for revision #3

expertise: 5 sensitivity: 5

Reviews

Excellent contribution. Very useful for application development by Ivan Macia on 2009-07-07 11:32:32 for revision #2

expertise: 4 sensitivity: 5

Summary:

The author propose some alternative memory models for ITK images. Currently only a contiguous memory model is used in the toolkit. The author proposes three alternative models: slice contiguous, for blocks of memory representing slices, sparse, for sparse images with only a set of pixels different from background value and single-bit binary images.

Hypothesis:

The author hypothesis is that the described memory models can be implemented by creating subclasses of image with corresponding pixel containers. All the filters and processing classes that access the images through PixelAccesors should continue to work.

Evidence:

A set of tests, one for each image memory model is provided. A performance benchmark is also provided.

Open Science:

Source code is provided, input images are generated as well as output images.

Reproducibility:

Code compiles cleanly. Tests run ok.

However there are problems running the performance benchmark. The program runs out of memory during the first iteration loop for sparse images. An std::bad_alloc is thrown after reaching a memory usage of 2.078.188 Kb. and m_PixelMap with 24061408 elements.

Use of Open Source Software:

N/A

Open source Contributions:

Usage of code is clearly described in the tests.

Code Quality :

Code seems to conform to the ITK quality standards. Code was tested on an Intel Core 2 Quad 6600 2,4Ghz CPU, with 3 Gb. RAM, WinXP, VS2008.

Quality of the data :

N/A

Interest:

In the future it would be particularly interesting to extend the slice memory model to be an on-demand cache memory model that loads the images as they are needed for processing, visualization etc. This would be very interesting for processing very large images with the current filters. Maybe this could be coupled with the streaming capabilities of the readers. We have already worked on this but with custom code and standard 2D images and readers.

Free comment :

Page 4, paragraph 1 seems to be incomplete.

Would be nice to have an example with an iterator in the article itself.

I do not totally agree with proposing the SliceContiguousImage class as not having a Dimension argument. 4D images are stored as slices too!

Comment by Dan Mueller: Good suggestions

Hi Ivan,

Thanks for your review.

> There are problems running the performance benchmark. The program runs out of memory during the first iteration loop for sparse images.
I have not encountered this. I will investigate further.

> Page 4, paragraph 1 seems to be incomplete.
I have repaired this in revision 3.

> Would be nice to have an example with an iterator in the article itself.
Good suggestion. I will do this in the next revision.

> I do not totally agree with proposing the SliceContiguousImage class as not having a Dimension argument.
Fair enough. It makes things trickier though... I might try and tackle this, but I doubt I will be able to find the time.

> In the future it would be particularly interesting to extend the slice memory model to be an on-demand cache memory model.
I agree, this could be of interest. I already have other software which does this, so I will not add it to my todo list, but perhaps someone else will have the motivation...

Add a new review

Statistics


Global rating:
Review rating:	[review]
Code rating:
Views:	1641
Downloads:	512

Send a message to the author

Information


Paper Id:	646
Categories:	DICOM, Image, Images
Keywords:	ITK, image, memory, sparse, binary image, slice contiguous,
Toolkit:	CMake, ITK
Revision:	5 (11-14-2009)
See revision:
Status:	Open for public review
View license Loading license...

Data


Full download:	.zip
Paper:	view, .pdf
Source code :	Download

Share

Associated Publications


A Framework for Algorithm Evaluation and Clinical Application Prototyping using ITK
The MITK Approach
User-Guided Level Set Segmentation of Anatomical Structures with ITK-SNAP