init

nv/html/dwv/tests/image/geometry.test.js

@@ -0,0 +1,54 @@
+/**
+ * Tests for the 'image/geometry.js' file.
+ */
+/** @module tests/image */
+// Do not warn if these variables were not defined before.
+/* global QUnit */
+QUnit.module("geometry");
+
+/**
+ * Tests for {@link dwv.image.Size}.
+ * @function module:tests/image~size
+ */
+QUnit.test("Test Size.", function (assert) {
+    var size0 = new dwv.image.Size(2, 3, 4);
+    // test its values
+    assert.equal( size0.getNumberOfColumns(), 2, "getNumberOfColumns" );
+    assert.equal( size0.getNumberOfRows(), 3, "getNumberOfRows" );
+    assert.equal( size0.getNumberOfSlices(), 4, "getNumberOfSlices" );
+    assert.equal( size0.getSliceSize(), 6, "getSliceSize" );
+    assert.equal( size0.getTotalSize(), 24, "getTotalSize" );
+    // defaults
+    var size00 = new dwv.image.Size(2, 3);
+    assert.equal( size00.getNumberOfSlices(), 1, "getNumberOfSlices default" );
+    // equality
+    assert.equal( size0.equals(size0), 1, "equals self true" );
+    var size1 = new dwv.image.Size(2, 3, 4);
+    assert.equal( size0.equals(size1), 1, "equals true" );
+    var size2 = new dwv.image.Size(3, 3, 4);
+    assert.equal( size0.equals(size2), 0, "equals false" );
+    // is in bounds
+    assert.equal( size0.isInBounds(0,0,0), 1, "isInBounds 0,0,0" );
+    assert.equal( size0.isInBounds(0,0), 1, "isInBounds 0,0" );
+    assert.equal( size0.isInBounds(1,2,3), 1, "isInBounds max" );
+    assert.equal( size0.isInBounds(2,3,4), 0, "isInBounds too big" );
+    assert.equal( size0.isInBounds(-1,2,3), 0, "isInBounds too small" );
+});
+
+/**
+ * Tests for {@link dwv.image.Spacing}.
+ * @function module:tests/image~spacing
+ */
+QUnit.test("Test Spacing.", function (assert) {
+    var spacing0 = new dwv.image.Spacing(2, 3, 4);
+    // test its values
+    assert.equal( spacing0.getColumnSpacing(), 2, "getColumnSpacing" );
+    assert.equal( spacing0.getRowSpacing(), 3, "getRowSpacing" );
+    assert.equal( spacing0.getSliceSpacing(), 4, "getSliceSpacing" );
+    // equality
+    assert.equal( spacing0.equals(spacing0), 1, "equals self true" );
+    var spacing1 = new dwv.image.Spacing(2, 3, 4);
+    assert.equal( spacing0.equals(spacing1), 1, "equals true" );
+    var spacing2 = new dwv.image.Spacing(3, 3, 4);
+    assert.equal( spacing0.equals(spacing2), 0, "equals false" );
+});

nv/html/dwv/tests/image/image.test.js

@@ -0,0 +1,319 @@
+/**
+ * Tests for the 'image/image.js' file.
+ */
+// Do not warn if these variables were not defined before.
+/* global QUnit */
+QUnit.module("image");
+
+/**
+ * Tests for {@link dwv.image.Image} getValue.
+ * @function module:tests/image~getvalue
+ */
+QUnit.test("Test Image getValue.", function (assert) {
+    // create a simple image
+    var size0 = 4;
+    var imgSize0 = new dwv.image.Size(size0, size0, 1);
+    var imgSpacing0 = new dwv.image.Spacing(1, 1, 1);
+    var imgOrigin0 = new dwv.math.Point3D(0,0,0);
+    var imgGeometry0 = new dwv.image.Geometry(imgOrigin0, imgSize0, imgSpacing0);
+    var buffer0 = [];
+    for(var i=0; i<size0*size0; ++i) {
+        buffer0[i] = i;
+    }
+    var image0 = new dwv.image.Image(imgGeometry0, [buffer0]);
+    // test its values
+    assert.equal( image0.getValue(0, 0, 0), 0, "Value at 0,0,0" );
+    assert.equal( image0.getValue(1, 0, 0), 1, "Value at 1,0,0" );
+    assert.equal( image0.getValue(1, 1, 0), 1*size0 + 1, "Value at 1,1,0" );
+    assert.equal( image0.getValue(3, 3, 0), 3*size0 + 3, "Value at 3,3,0" );
+    assert.equal( isNaN(image0.getValue(4, 3, 0)), true, "Value outside is NaN" );
+    // TODO: wrong, should not be accessed
+    assert.equal( image0.getValue(5, 0, 0), 1*size0 + 1, "Value at 5,0,0" );
+
+    // image with rescale
+    var image1 = new dwv.image.Image(imgGeometry0, [buffer0]);
+    var slope1 = 2;
+    var intercept1 = 10;
+    var rsi1 = new dwv.image.RescaleSlopeAndIntercept(slope1, intercept1);
+    image1.setRescaleSlopeAndIntercept(rsi1);
+    // test its values
+    assert.equal( image1.getValue(0, 0, 0), 0, "Value at 0,0,0" );
+    assert.equal( image1.getValue(1, 0, 0), 1, "Value at 1,0,0" );
+    assert.equal( image1.getValue(1, 1, 0), 1*size0 + 1, "Value at 1,1,0" );
+    assert.equal( image1.getValue(3, 3, 0), 3*size0 + 3, "Value at 3,3,0" );
+    assert.equal( image1.getRescaledValue(0, 0, 0), 0+intercept1, "Value at 0,0,0" );
+    assert.equal( image1.getRescaledValue(1, 0, 0), 1*slope1+intercept1, "Value at 1,0,0" );
+    assert.equal( image1.getRescaledValue(1, 1, 0), (1*size0 + 1)*slope1+intercept1, "Value at 1,1,0" );
+    assert.equal( image1.getRescaledValue(3, 3, 0), (3*size0 + 3)*slope1+intercept1, "Value at 3,3,0" );
+});
+
+/**
+ * Tests for {@link dwv.image.Image} histogram.
+ * @function module:tests/image~histogram
+ */
+QUnit.test("Test Image histogram.", function (assert) {
+    // create a simple image
+    var size0 = 4;
+    var imgSize0 = new dwv.image.Size(size0, size0, 1);
+    var imgSpacing0 = new dwv.image.Spacing(1, 1, 1);
+    var imgOrigin0 = new dwv.math.Point3D(0,0,0);
+    var imgGeometry0 = new dwv.image.Geometry(imgOrigin0, imgSize0, imgSpacing0);
+    var buffer0 = [];
+    for(var i=0; i<size0*size0; ++i) {
+        buffer0[i] = i;
+    }
+    var image0 = new dwv.image.Image(imgGeometry0, [buffer0]);
+
+    // histogram
+    var histogram = image0.getHistogram();
+    assert.equal( histogram.length, size0*size0, "histogram size" );
+    var histoContentTest = true;
+    for ( var j=0; j<size0*size0; ++j) {
+        if ( histogram[j][0] !== j ) {
+            histoContentTest = false;
+            break;
+        }
+        if ( histogram[j][1] !== 1 ) {
+            histoContentTest = false;
+            break;
+        }
+    }
+    assert.equal( histoContentTest, true, "histogram content" );
+});
+
+/**
+ * Tests for {@link dwv.image.Image} append.
+ * @function module:tests/image~append
+ */
+QUnit.test("Test Image append slice.", function (assert) {
+    var size = 4;
+    var imgSize = new dwv.image.Size(size, size, 2);
+    var imgSizeMinusOne = new dwv.image.Size(size, size, 1);
+    var imgSpacing = new dwv.image.Spacing(1, 1, 1);
+    var imgOrigin = new dwv.math.Point3D(0,0,0);
+    var imgGeometry0 = new dwv.image.Geometry(imgOrigin, imgSizeMinusOne, imgSpacing);
+    imgGeometry0.appendOrigin(new dwv.math.Point3D(0,0,1), 1);
+
+    // slice to append
+    var sliceSize = new dwv.image.Size(size, size, 1);
+    var sliceBuffer = new Int16Array(sliceSize.getTotalSize());
+    for(var i=0; i<size*size; ++i) {
+        sliceBuffer[i] = 2;
+    }
+
+    // image buffer
+    var buffer = new Int16Array(imgSize.getTotalSize());
+    for(var j=0; j<size*size; ++j) {
+        buffer[j] = 0;
+    }
+    for(var k=size*size; k<2*size*size; ++k) {
+        buffer[k] = 1;
+    }
+
+    // image 0
+    var image0 = new dwv.image.Image(imgGeometry0, [buffer]);
+    // append null
+    assert.throws( function () {
+            image0.appendSlice(null);
+        }, new Error("Cannot append null slice"), "append null slice");
+    // real slice
+    var sliceOrigin = new dwv.math.Point3D(0,0,-1);
+    var sliceGeometry = new dwv.image.Geometry(sliceOrigin, sliceSize, imgSpacing);
+    var slice0 = new dwv.image.Image(sliceGeometry, [sliceBuffer]);
+    // append slice before
+    image0.appendSlice(slice0);
+    // test its values
+    assert.equal( image0.getValue(0, 0, 0), 2, "Value at 0,0,0 (append before)" );
+    assert.equal( image0.getValue(3, 3, 0), 2, "Value at 3,3,0 (append before)" );
+    assert.equal( image0.getValue(0, 0, 1), 0, "Value at 0,0,1 (append before)" );
+    assert.equal( image0.getValue(3, 3, 1), 0, "Value at 3,3,1 (append before)" );
+    assert.equal( image0.getValue(0, 0, 2), 1, "Value at 0,0,2 (append before)" );
+    assert.equal( image0.getValue(3, 3, 2), 1, "Value at 3,3,2 (append before)" );
+    // test its positions
+    var sliceOrigins0 = [];
+    sliceOrigins0[0] = new dwv.math.Point3D(0,0,-1);
+    sliceOrigins0[1] = new dwv.math.Point3D(0,0,0);
+    sliceOrigins0[2] = new dwv.math.Point3D(0,0,1);
+    assert.deepEqual( imgGeometry0.getOrigins(), sliceOrigins0, "Slice positions (append before)" );
+
+    // image 1
+    var imgGeometry1 = new dwv.image.Geometry(imgOrigin, imgSizeMinusOne, imgSpacing);
+    imgGeometry1.appendOrigin(new dwv.math.Point3D(0,0,1), 1);
+    var image1 = new dwv.image.Image(imgGeometry1, [buffer]);
+    var sliceOrigin1 = new dwv.math.Point3D(0,0,2);
+    var sliceGeometry1 = new dwv.image.Geometry(sliceOrigin1, sliceSize, imgSpacing);
+    var slice1 = new dwv.image.Image(sliceGeometry1, [sliceBuffer]);
+    // append slice before
+    image1.appendSlice(slice1);
+    // test its values
+    assert.equal( image1.getValue(0, 0, 0), 0, "Value at 0,0,0 (append after)" );
+    assert.equal( image1.getValue(3, 3, 0), 0, "Value at 3,3,0 (append after)" );
+    assert.equal( image1.getValue(0, 0, 1), 1, "Value at 0,0,1 (append after)" );
+    assert.equal( image1.getValue(3, 3, 1), 1, "Value at 3,3,1 (append after)" );
+    assert.equal( image1.getValue(0, 0, 2), 2, "Value at 0,0,2 (append after)" );
+    assert.equal( image1.getValue(3, 3, 2), 2, "Value at 3,3,2 (append after)" );
+    // test its positions
+    var sliceOrigins1 = [];
+    sliceOrigins1[0] = new dwv.math.Point3D(0,0,0);
+    sliceOrigins1[1] = new dwv.math.Point3D(0,0,1);
+    sliceOrigins1[2] = new dwv.math.Point3D(0,0,2);
+    assert.deepEqual( imgGeometry1.getOrigins(), sliceOrigins1, "Slice positions (append after)" );
+
+    // image 2
+    var imgGeometry2 = new dwv.image.Geometry(imgOrigin, imgSizeMinusOne, imgSpacing);
+    imgGeometry2.appendOrigin(new dwv.math.Point3D(0,0,1), 1);
+    var image2 = new dwv.image.Image(imgGeometry2, [buffer]);
+    var sliceOrigin2 = new dwv.math.Point3D(0,0,0.4);
+    var sliceGeometry2 = new dwv.image.Geometry(sliceOrigin2, sliceSize, imgSpacing);
+    var slice2 = new dwv.image.Image(sliceGeometry2, [sliceBuffer]);
+    // append slice before
+    image2.appendSlice(slice2);
+    // test its values
+    assert.equal( image2.getValue(0, 0, 0), 0, "Value at 0,0,0 (append between)" );
+    assert.equal( image2.getValue(3, 3, 0), 0, "Value at 3,3,0 (append between)" );
+    assert.equal( image2.getValue(0, 0, 1), 2, "Value at 0,0,1 (append between)" );
+    assert.equal( image2.getValue(3, 3, 1), 2, "Value at 3,3,1 (append between)" );
+    assert.equal( image2.getValue(0, 0, 2), 1, "Value at 0,0,2 (append between)" );
+    assert.equal( image2.getValue(3, 3, 2), 1, "Value at 3,3,2 (append between)" );
+    // test its positions
+    var sliceOrigins2 = [];
+    sliceOrigins2[0] = new dwv.math.Point3D(0,0,0);
+    sliceOrigins2[1] = new dwv.math.Point3D(0,0,0.4);
+    sliceOrigins2[2] = new dwv.math.Point3D(0,0,1);
+    assert.deepEqual( imgGeometry2.getOrigins(), sliceOrigins2, "Slice positions (append between)" );
+});
+
+/**
+ * Tests for {@link dwv.image.Image} convolute2D.
+ * @function module:tests/image~convolute2D
+ */
+QUnit.test("Test Image convolute2D.", function (assert) {
+    // create a simple image
+    var size0 = 3;
+    var imgSize0 = new dwv.image.Size(size0, size0, 1);
+    var imgSpacing0 = new dwv.image.Spacing(1, 1, 1);
+    var imgOrigin0 = new dwv.math.Point3D(0,0,0);
+    var imgGeometry0 = new dwv.image.Geometry(imgOrigin0, imgSize0, imgSpacing0);
+    var buffer0 = [];
+    for ( var i = 0; i < size0*size0; ++i ) {
+        buffer0[i] = i;
+    }
+    var image0 = new dwv.image.Image(imgGeometry0, [buffer0]);
+    // id convolution
+    var weights0 = [ 0, 0, 0, 0, 1, 0, 0, 0, 0 ];
+    var resImage0 = image0.convolute2D( weights0 );
+    var testContent0 = true;
+    for ( i = 0; i < size0*size0; ++i) {
+        if ( image0.getValueAtOffset(i,0) !== resImage0.getValueAtOffset(i,0) ) {
+            testContent0 = false;
+            break;
+        }
+    }
+    assert.equal( testContent0, true, "convolute2D id" );
+    // blur convolution
+    var weights1 = [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+    var resImage1 = image0.convolute2D( weights1 );
+    var theoResImage1 = [ 12, 18, 24, 30, 36, 42, 48, 54, 60 ];
+    var testContent1 = true;
+    for ( i = 0; i < size0*size0; ++i ) {
+        if ( theoResImage1[i] !== resImage1.getValueAtOffset(i,0) ) {
+            testContent1 = false;
+            break;
+        }
+    }
+    assert.equal( testContent1, true, "convolute2D blur" );
+});
+
+/**
+ * Tests for {@link dwv.image.Image} transform.
+ * @function module:tests/image~transform
+ */
+QUnit.test("Test Image transform.", function (assert) {
+    // create a simple image
+    var size0 = 3;
+    var imgSize0 = new dwv.image.Size(size0, size0, 1);
+    var imgSpacing0 = new dwv.image.Spacing(1, 1, 1);
+    var imgOrigin0 = new dwv.math.Point3D(0,0,0);
+    var imgGeometry0 = new dwv.image.Geometry(imgOrigin0, imgSize0, imgSpacing0);
+    var buffer0 = [];
+    for ( var i = 0; i < size0*size0; ++i ) {
+        buffer0[i] = i;
+    }
+    var image0 = new dwv.image.Image(imgGeometry0, [buffer0]);
+
+    // treshold function
+    var func0 = function ( value ) {
+        if ( value < 3 || value > 5 ) {
+            return 0;
+        }
+        else {
+            return value;
+        }
+    };
+    var resImage0 = image0.transform( func0 );
+    var theoResImage0 = [ 0, 0, 0, 3, 4, 5, 0, 0, 0 ];
+    var testContent0 = true;
+    for ( i = 0; i < size0*size0; ++i) {
+        if ( theoResImage0[i] !== resImage0.getValueAtOffset(i,0) ) {
+            testContent0 = false;
+            break;
+        }
+    }
+    assert.equal( testContent0, true, "transform threshold" );
+
+    // new image
+    image0 = new dwv.image.Image(imgGeometry0, [buffer0]);
+
+    // multiply function
+    var func1 = function ( value ) {
+        return value * 2;
+    };
+    var resImage1 = image0.transform( func1 );
+    var theoResImage1 = [ 0, 2, 4, 6, 8, 10, 12, 14, 16 ];
+    var testContent1 = true;
+    for ( i = 0; i < size0*size0; ++i) {
+        if ( theoResImage1[i] !== resImage1.getValueAtOffset(i,0) ) {
+            testContent1 = false;
+            break;
+        }
+    }
+    assert.equal( testContent1, true, "transform multiply" );
+});
+
+/**
+ * Tests for {@link dwv.image.Image} compose.
+ * @function module:tests/image~compose
+ */
+QUnit.test("Test Image compose.", function (assert) {
+    // create two simple images
+    var size0 = 3;
+    var imgSize0 = new dwv.image.Size(size0, size0, 1);
+    var imgSpacing0 = new dwv.image.Spacing(1, 1, 1);
+    var imgOrigin0 = new dwv.math.Point3D(0,0,0);
+    var imgGeometry0 = new dwv.image.Geometry(imgOrigin0, imgSize0, imgSpacing0);
+    var buffer0 = [];
+    for ( var i = 0; i < size0*size0; ++i ) {
+        buffer0[i] = i;
+    }
+    var image0 = new dwv.image.Image(imgGeometry0, [buffer0]);
+    var buffer1 = [];
+    for ( i = 0; i < size0*size0; ++i ) {
+        buffer1[i] = i;
+    }
+    var image1 = new dwv.image.Image(imgGeometry0, [buffer1]);
+
+    // addition function
+    var func0 = function ( a, b ) {
+        return a + b;
+    };
+    var resImage0 = image0.compose( image1, func0 );
+    var theoResImage0 = [ 0, 2, 4, 6, 8, 10, 12, 14, 16 ];
+    var testContent0 = true;
+    for ( i = 0; i < size0*size0; ++i) {
+        if ( theoResImage0[i] !== resImage0.getValueAtOffset(i,0) ) {
+            testContent0 = false;
+            break;
+        }
+    }
+    assert.equal( testContent0, true, "compose addition" );
+});

nv/html/dwv/tests/image/index.html

@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>DWV Colour Maps</title>
+<meta charset="UTF-8">
+<script type="text/javascript" src="../../src/image/luts.js"></script>
+<script type="text/javascript">
+function createImage(colourMapName, colourMap)
+{
+    // default size
+    var height = 40;
+    var width = 256;
+    // create canvas
+    var canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    var context = canvas.getContext("2d");
+    // fill in the image data
+    var imageData = context.createImageData(canvas.width, canvas.height);
+    var index = 0;
+    for( var j=0; j<canvas.height; ++j ) {
+        for( var i=0; i<canvas.width; ++i ) {
+            index = (i + j * imageData.width) * 4;
+            imageData.data[index] = colourMap.red[i];
+            imageData.data[index+1] = colourMap.green[i];
+            imageData.data[index+2] = colourMap.blue[i];
+            imageData.data[index+3] = 0xff;
+        }
+    }
+    // put the image data in the context
+    context.putImageData(imageData, 0, 0);
+
+    // html
+    var div = document.createElement("div");
+    div.id = colourMapName;
+    var paragraph = document.createElement("p");
+    var link = document.createElement("a");
+    link.href = canvas.toDataURL("image/png");
+    link.appendChild(document.createTextNode(colourMapName));
+    // put all together
+    paragraph.appendChild(link);
+    div.appendChild(paragraph);
+    div.appendChild(canvas);
+    // add to the document
+    document.body.appendChild(div);
+}
+</script>
+<style>
+body { font-family: Arial, Helvetica, sans-serif; }
+</style>
+</head>
+
+<body>
+
+<h1>The DWV colour maps</h1>
+
+<script type="text/javascript">
+window.onload = function() {
+    createImage("Plain", dwv.image.lut.plain);
+    createImage("InvPlain", dwv.image.lut.invPlain);
+    createImage("Rainbow", dwv.image.lut.rainbow);
+    createImage("Hot", dwv.image.lut.hot);
+    createImage("Hot Iron", dwv.image.lut.hot_iron);
+    createImage("Pet", dwv.image.lut.pet);
+    createImage("Hot Metal Blue", dwv.image.lut.hot_metal_blue);
+    createImage("Pet 20 step", dwv.image.lut.pet_20step);
+    createImage("Test", dwv.image.lut.test);
+}
+</script>
+
+</body>
+</html>

nv/html/dwv/tests/image/view.test.js

@@ -0,0 +1,209 @@
+/**
+ * Tests for the 'image/view.js' file.
+ */
+// Do not warn if these variables were not defined before.
+/* global QUnit */
+QUnit.module("view");
+
+/**
+ * Tests for {@link dwv.image.View} listeners.
+ * @function module:tests/image~listeners
+ */
+QUnit.test("Test listeners.", function (assert) {
+    // create an image
+    var size0 = 4;
+    var imgSize0 = new dwv.image.Size(size0, size0, 1);
+    var imgSpacing0 = new dwv.image.Spacing(1, 1, 1);
+    var imgOrigin0 = new dwv.math.Point3D(0,0,0);
+    var imgGeometry0 = new dwv.image.Geometry(imgOrigin0, imgSize0, imgSpacing0);
+    var buffer0 = [];
+    for(var i=0; i<size0*size0; ++i) {
+        buffer0[i] = i;
+    }
+    var image0 = new dwv.image.Image(imgGeometry0, [buffer0]);
+    image0.setMeta( { BitsStored: 8 } );
+    // create a view
+    var view0 = new dwv.image.View(image0);
+
+    // listeners
+    var listener1 = function(event){
+        assert.equal( event.wc, 0, "Expected call to listener1.");
+    };
+    var listener2 = function(event){
+        assert.equal( event.ww, 1, "Expected call to listener2.");
+    };
+    // with two listeners
+    view0.addEventListener("wl-center-change", listener1 );
+    view0.addEventListener("wl-center-change", listener2 );
+    view0.setWindowLevel(0,1);
+    // without listener2
+    view0.removeEventListener("wl-center-change", listener2 );
+    view0.setWindowLevel(0,2);
+    // without listener1
+    view0.removeEventListener("wl-center-change", listener1 );
+    view0.setWindowLevel(1,1);
+});
+
+/**
+ * Tests for {@link dwv.image.View} generateImageData MONO.
+ * @function module:tests/image~generateImageDataMONO
+ */
+QUnit.test("Test generate data MONO.", function (assert) {
+    // create an image
+    var size0 = 2;
+    var imgSize0 = new dwv.image.Size(size0, size0, 1);
+    var imgSpacing0 = new dwv.image.Spacing(1, 1, 1);
+    var imgOrigin0 = new dwv.math.Point3D(0,0,0);
+    var imgGeometry0 = new dwv.image.Geometry(imgOrigin0, imgSize0, imgSpacing0);
+    var buffer0 = [];
+    for ( var i = 0; i < size0 * size0; ++i ) {
+        buffer0[i] = i;
+    }
+    var image0 = new dwv.image.Image(imgGeometry0, [buffer0]);
+    image0.setMeta( { 'BitsStored': 8 } );
+    // create a view
+    var view0 = new dwv.image.View(image0);
+    // create the image data
+    var imageData = {'width': size0, 'height': size0, 'data': new Uint8ClampedArray(size0*size0*4) };
+
+    // default window level
+    view0.setWindowLevelMinMax();
+    // call generate data
+    view0.generateImageData(imageData);
+    // TODO proper data?
+    var theoData0 = [ 0, 0, 0, 255, 127, 127, 127, 255,
+                      255, 255, 255, 255, 255, 255, 255, 255 ];
+    var testContent0 = true;
+    for ( i = 0; i < size0*size0*4; ++i) {
+        if ( theoData0[i] !== imageData.data[i] ) {
+            testContent0 = false;
+            break;
+        }
+    }
+    assert.equal( testContent0, true, "check image data" );
+});
+
+/**
+ * Tests for {@link dwv.image.View} generateImageData RGB.
+ * @function module:tests/image~generateImageDataRGB
+ */
+QUnit.test("Test generate data RGB.", function (assert) {
+    // create an image
+    var size0 = 2;
+    var imgSize0 = new dwv.image.Size(size0, size0, 1);
+    var imgSpacing0 = new dwv.image.Spacing(1, 1, 1);
+    var imgOrigin0 = new dwv.math.Point3D(0,0,0);
+    var imgGeometry0 = new dwv.image.Geometry(imgOrigin0, imgSize0, imgSpacing0);
+    var buffer0 = [];
+    var index = 0;
+    var value = 0;
+    // 0, 85, 170, 255
+    for ( var i = 0; i < size0 * size0; ++i ) {
+        value = i * 255 / ((size0 * size0) - 1);
+        buffer0[index] = value;
+        buffer0[index+1] = value;
+        buffer0[index+2] = value;
+        index += 3;
+    }
+    var image0 = new dwv.image.Image(imgGeometry0, [buffer0]);
+    image0.setPhotometricInterpretation('RGB');
+    image0.setMeta( { 'BitsStored': 8 } );
+    // create a view
+    var view0 = new dwv.image.View(image0);
+    // create the image data
+    var imageData = {'width': size0, 'height': size0, 'data': new Uint8ClampedArray(size0*size0*4) };
+
+    // default window level
+    view0.setWindowLevel(127, 255);
+    // call generate data
+    view0.generateImageData(imageData);
+    // check data content
+    var theoData0 = [ 0, 0, 0, 255, 85, 85, 85, 255,
+                      171, 171, 171, 255, 255, 255, 255, 255 ];
+    var testContent0 = true;
+    for ( i = 0; i < size0*size0*4; ++i) {
+        if ( theoData0[i] !== imageData.data[i] ) {
+            testContent0 = false;
+            break;
+        }
+    }
+    assert.equal( testContent0, true, "check image data non planar" );
+
+    var buffer1 = [];
+    index = 0;
+    // 0, 85, 170, 255
+    for ( i = 0; i < size0 * size0; ++i ) {
+        buffer1[index] = 0;
+        buffer1[index+1] = 85;
+        buffer1[index+2] = 170;
+        buffer1[index+3] = 255;
+        index += 4;
+    }
+    var image1 = new dwv.image.Image(imgGeometry0, [buffer1]);
+    image1.setPhotometricInterpretation('RGB');
+    image1.setPlanarConfiguration(1);
+    image1.setMeta( { 'BitsStored': 8 } );
+    // create a view
+    var view1 = new dwv.image.View(image1);
+
+    // default window level
+    view1.setWindowLevel(127, 255);
+    // call generate data
+    view1.generateImageData(imageData);
+    // check data content
+    var testContent1 = true;
+    for ( i = 0; i < size0*size0*4; ++i) {
+        if ( theoData0[i] !== imageData.data[i] ) {
+            testContent1 = false;
+            break;
+        }
+    }
+    assert.equal( testContent1, true, "check image data planar" );
+});
+
+/**
+ * Tests for {@link dwv.image.View} generateImageData timing.
+ * @function module:tests/image~generateImageDataTiming
+ */
+QUnit.test("Test generate data timing.", function (assert) {
+    // create an image
+    var size0 = 128;
+    var imgSize0 = new dwv.image.Size(size0, size0, 1);
+    var imgSpacing0 = new dwv.image.Spacing(1, 1, 1);
+    var imgOrigin0 = new dwv.math.Point3D(0,0,0);
+    var imgGeometry0 = new dwv.image.Geometry(imgOrigin0, imgSize0, imgSpacing0);
+    var buffer0 = [];
+    for(var i=0; i<size0*size0; ++i) {
+        buffer0[i] = i;
+    }
+    var image0 = new dwv.image.Image(imgGeometry0, [buffer0]);
+    image0.setMeta( { BitsStored: 8 } );
+    // create a view
+    var view0 = new dwv.image.View(image0);
+    // create the image data
+    var imageData = {"width": size0, "height": size0, "data": new Uint8Array(size0*size0*4) };
+
+    // default window level
+    view0.setWindowLevelMinMax();
+
+    // start time
+    var start0 = new Date();
+    // call generate data
+    view0.generateImageData(imageData);
+    // time taken
+    var time0 = (new Date()) - start0;
+    // check time taken
+    assert.ok( time0 < 90, "First generateImageData: "+time0+"ms.");
+
+    // Change the window level
+    view0.setWindowLevel(4000, 200);
+
+    // start time
+    var start1 = (new Date()).getMilliseconds();
+    // call generate data
+    view0.generateImageData(imageData);
+    // time taken
+    var time1 = (new Date()).getMilliseconds() - start1;
+    // check time taken
+    assert.ok( time1 < 90, "Second generateImageData: "+time1+"ms.");
+});