--- a/DisplayImage.c
+++ b/DisplayImage.c
@@ -319,6 +319,7 @@
 
 ImageMap* DisplayImage_ConvertToImageMap(DisplayImage* self)  //// dbl <= float
 {
+    // Lazy man's L1 norm - assumes no negative values
 	ImageMap* result = ImageMap_new(self->width, self->height);
 	if (self->bitsPerPixel == 32) {
 	    LOOP_IMAGE(self,{
@@ -327,10 +328,46 @@
 		});
 	} else if (self->bitsPerPixel == 64) {
 	    LOOP_IMAGE(self,{
-		    unsigned short *udata=(unsigned short *)idata;
 		    /* Data is (alpha,R,G,B) */
+            unsigned short *udata=(unsigned short *)idata;
 		    result->values[x][y] = (float)(((double)udata[1]+udata[2]+udata[3])/(65535 * 3.0));
 		});
+       } else if (self->bitsPerPixel == 128) { // (RGBA) * sizeof( float ) * 8 = 4 & 4 * 8 = 128
+        float temp; 
+        float maxval = 0; 
+        float minval = 3.40282347e+38F; // Assumes 32 bit float, why not?
+        float row, mean;
+        unsigned int x, y;
+        {   int bpp = (self)->bitsPerPixel/8;
+            unsigned char *idata;
+            mean = 0;
+            for ( y=0; y < (self)->height; y++ ){
+                idata = *((self)->data) + y * (self)->bytesPerLine;
+                row = 0;
+                for ( x=0; x<(self)->width; x++, idata += bpp ){
+                    float *fdata=(float *)idata;
+                    result->values[x][y] = temp = fdata[1] + fdata[2] + fdata[3];   // Assume no overflow
+                    row += temp;
+                    if ( temp < minval )
+                        minval = temp;
+                    if ( temp > maxval )
+                        maxval = temp;
+                }
+                mean += row / x;
+            }
+            mean /= y;
+        }
+
+        if (maxval != minval) {
+            maxval -= minval;   // Now scaler
+            row = 2 * mean - minval;
+            if (maxval > row)   // Hueristic to avoid outliers
+                maxval = row;
+        } else if (maxval == 0)
+            maxval = 1;
+        for ( y = 0; y < self->height; y++ )
+            for ( x = 0; x < self->width; x++ )
+                result->values[x][y] = (result->values[x][y] - minval) / maxval;
 	} else {
 	    /* It appears that TIFF library calls used (TIFFReadRGBA), will always return 32 or 64-bit, but just in case... */
 	    FatalError("DisplayImage: Unsupported pixel size");