"

 COPYRIGHT (c) 1993 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

Image subclass:#Depth8Image

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'Graphics-Images'

!

!Depth8Image class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1993 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    this class represents 256-color (8 bit / pixel) images (palette, greyscale ...).

    It mainly consists of methods already implemented in Image,

    reimplemented here for more performance.

    [author:]

        Claus Gittinger

    [see also:]

        Depth1Image Depth2Image Depth4Image Depth16Image Depth24Image

        ImageReader

"

! !

!Depth8Image class methodsFor:'queries'!

imageDepth

    "return the depth of images represented by instances of

     this class - here we return 8"

    ^ 8

    "Modified: 20.4.1996 / 23:40:22 / cg"

! !

!Depth8Image methodsFor:'accessing'!

atX:x y:y

    "retrieve a pixel at x/y; return a color.

     Pixels start at x=0 , y=0 for upper left pixel, end at

     x = width-1, y=height-1 for lower right pixel"

    |value "{ Class: SmallInteger }"

     index "{ Class: SmallInteger }"|

    index := (width * y) + 1 + x.

    value := bytes at:index.

    photometric == #whiteIs0 ifTrue:[

        ^ Color gray:100 - (100 / 255 * value)

    ].

    photometric == #blackIs0 ifTrue:[

        ^ Color gray:(100 / 255 * value)

    ].

    photometric ~~ #palette ifTrue:[

        ^ self colorFromValue:value

    ].

    index := value + 1.

    ^ colorMap at:index

    "Modified: 8.6.1996 / 10:52:48 / cg"

!

atX:x y:y putValue:aPixelValue

    "set the pixel at x/y to aPixelValue.

     Pixels start at x=0 , y=0 for upper left pixel, end at

     x = width-1, y=height-1 for lower right pixel"

    |index "{ Class: SmallInteger }"|

    index := (width * y) + 1 + x.

    bytes at:index put:aPixelValue.

!

valueAtX:x y:y

    "retrieve a pixel at x/y; return a pixelValue.

     Pixels start at x=0 , y=0 for upper left pixel, end at

     x = width-1, y=height-1 for lower right pixel"

    |index "{ Class: SmallInteger }"|

    index := (width * y) + 1 + x.

    ^ bytes at:index.

! !

!Depth8Image methodsFor:'converting palette images'!

    map := ByteArray uninitializedNew:256.

    ].

"/

!

paletteImageAsDitheredPseudoFormOn:aDevice

    "return a dithered pseudoForm from the palette picture. Depend

     on dither colors being preallocated (see Color>>getColors*)"

    ^ self paletteImageAsDitheredPseudoFormOn:aDevice 

	   colors:Color fixColors 

	   nRed:Color numFixRed

	   nGreen:Color numFixGreen

	   nBlue:Color numFixBlue

!

paletteImageAsDitheredPseudoFormOn:aDevice colors:fixColors nRed:nRed nGreen:nGreen nBlue:nBlue 

    "return a dithered pseudoForm from the palette picture. 

     Use the colors in the fixColors array, which must be fixR x fixG x fixB

     colors assigned to aDevice, such as the preallocated colors of the

     Color class. 

     By passing the ditherColors as extra array, this method can

     also be used to dither an 8bit image into a smaller number of colors,

     for example to create Depth4Images."

    "the code below is a q&d hack - it needs a rewrite to use a

     floyd-steinberg dither (currently, the error is only forwarded

     to the next pixel on the right, which seems ok for photograph-like

     images, but leads to more artifacts with equal colored areas).

    "

    |pseudoBits f has8BitImage deviceDepth

     rgbBytes

     w     "{Class: SmallInteger }"

     h     "{Class: SmallInteger }"

     index "{Class: SmallInteger }"

     fixR  "{Class: SmallInteger }"

     fixG  "{Class: SmallInteger }"

     fixB  "{Class: SmallInteger }"

     fixIds failed map colorMapSize

     error|

    aDevice ~~ Display ifTrue:[^ nil].

    fixR := nRed.

    fixR == 0 ifTrue:[ ^ nil].

    fixG := nGreen.

    fixG == 0 ifTrue:[ ^ nil].

    fixB := nBlue.

    fixB == 0 ifTrue:[ ^ nil].

    "/ simple check

    (fixR * fixG * fixB) ~~ fixColors size ifTrue:[

	self error:'invalid color array passed'.

	^ nil

    ].

    fixIds := (fixColors asArray collect:[:clr | clr colorId]) asByteArray.

    deviceDepth := aDevice depth.

    deviceDepth == 8 ifTrue:[

	has8BitImage := true.

    ] ifFalse:[

	has8BitImage := false.

	aDevice supportedImageFormats do:[:fmt |

	    (fmt at:#bitsPerPixel) == 8 ifTrue:[

		has8BitImage := true.

	    ]

	]

    ].

    has8BitImage ifFalse:[^ nil].

    'D8IMAGE: dithering ...' infoPrintNL.

    "

     collect color components as integer values

     (code below uses components percent * 2.55 asInteger everywhere, to avoid

      float arithmetic, rounding etc. Thus, the range is 0..255 here)

    "

    colorMapSize := colorMap size.

    rgbBytes := ByteArray uninitializedNew:colorMapSize * 3.

    index := 1.

    1 to:colorMapSize do:[:i |

	|clr|

	clr := colorMap at:i.

	rgbBytes at:index put:(clr red * 2.55) asInteger.

	rgbBytes at:index+1 put:(clr green * 2.55) asInteger.

	rgbBytes at:index+2 put:(clr blue * 2.55) asInteger.

	index := index + 3.

    ].

    pseudoBits := ByteArray uninitializedNew:(width * height).

    w := width + 2.

    error := ByteArray new:w*(3*2).

    w := width.

    h := height.

    failed := true.

%{

/*

 * #   define FLOYD_STEINBERG

 */

    int __x, __y;

    int __eR, __eG, __eB;

    unsigned char *srcP, *dstP;

    unsigned char *rgbP;

    unsigned char *idP;

    short *errP, *eP;

    int __fR, __fG, __fB;

    int iR, iG, iB;

    int idx;

    if (__isByteArray(_INST(bytes))

     && __isByteArray(pseudoBits)

     && __isByteArray(rgbBytes)

     && __isByteArray(fixIds)

     && __isByteArray(error)

     && __bothSmallInteger(fixR, fixG)

     && __isSmallInteger(fixB)) {

	failed = false;

	srcP = _ByteArrayInstPtr(_INST(bytes))->ba_element;

	dstP = _ByteArrayInstPtr(pseudoBits)->ba_element;

	rgbP = _ByteArrayInstPtr(rgbBytes)->ba_element;

	idP = _ByteArrayInstPtr(fixIds)->ba_element;

	errP = (short *) _ByteArrayInstPtr(error)->ba_element;

	__fR = _intVal(fixR)-1;

	__fG = _intVal(fixG)-1;

	__fB = _intVal(fixB)-1;

#ifdef FLOYD_STEINBERG

	/*

	 * clear error accumulator

	 */

	eP = errP;

	for (__x=_intVal(w)+1; __x>=0; __x--) {

	    eP[0] = 0; eP[1] = 0; eP[2] = 0;

	    eP += 3;

	}

#endif

	for (__y=_intVal(h); __y>0; __y--) {

	    __eR = __eG = __eB = 0;

#ifdef FLOYD_STEINBERG

	    eP = &(errP[3]);

	    __eR += eP[0];

	    __eG += eP[1];

	    __eB += eP[2];

#endif

	    for (__x=_intVal(w); __x>0; __x--) {

		int __want;

		int pix;

		int __wantR, __wantG, __wantB;

		int idx;

		int tR, tG, tB;

		int nR, nG, nB;

		pix = *srcP++;

		/*

		 * wR, wG and wB is the wanted r/g/b value;

		 * compute the index into the dId table ..

		 * values: 0..255; scale to 0..fR-1, 0..fG-1, 0..fB-1

		 *

		 * bad kludge: knows how to index into FixColor table

		 */

		idx = pix+pix+pix;  /* pix * 3 */

		__wantR = rgbP[idx]   + __eR;

		__wantG = rgbP[idx+1] + __eG;

		__wantB = rgbP[idx+2] + __eB;

		if (__wantR > 255) __want = 255;

		else if (__wantR < 0) __want = 0;

		else __want = __wantR;

		iR = (__want * __fR + 128) / 255; /* red index rounded */

		idx = iR * (__fG+1);

		if (__wantG > 255) __want = 255;

		else if (__wantG < 0) __want = 0;

		else __want = __wantG;

		iG = (__want * __fG + 128) / 255; /* green index rounded */

		idx = (idx + iG) * (__fB+1);

		if (__wantB > 255) __want = 255;

		else if (__wantB < 0) __want = 0;

		else __want = __wantB;

		iB = (__want * __fB + 128) / 255; /* blue index rounded */

		idx = idx + iB;

		/*

		 * store the corresponding dither colors colorId

		 */

		*dstP++ = idP[idx];

		/*

		 * the new error:

		 */

		__eR = __wantR - (iR * 255 / __fR); 

		__eG = __wantG - (iG * 255 / __fG); 

		__eB = __wantB - (iB * 255 / __fB); 

#ifdef FLOYD_STEINBERG

		/*

		 * distribute the error

		 */

		tR = __eR >> 4;  /* 16th of error */

		tG = __eG >> 4;

		tB = __eB >> 4;

		nR = eP[3] + (tR * 7);/* from accu: error for (x+1 / y) */

		nG = eP[4] + (tG * 7);/* plus 7/16'th of this error */

		nB = eP[5] + (tB * 7);

		eP[0] = tR*5;         /* 5/16th for (x / y+1) */

		eP[1] = tG*5;

		eP[2] = tB*5;

		eP[-3] = tR*3;        /* 3/16th for (x-1 / y+1) */

		eP[-2] = tG*3;

		eP[-1] = tB*3;

		eP[3] = __eR - (tR*15);  /* 1/16th for (x+1 / y+1) */

		eP[4] = __eG - (tG*15);

		eP[5] = __eB - (tB*15);

		__eR = nR;

		__eG = nG;

		__eB = nB;

		eP += 3;

#endif

	    }

	}

    }

%}.

    failed ifTrue:[

	self primitiveFailed.

	^ nil

    ].

    f := Form width:width height:height depth:deviceDepth on:aDevice.

    f isNil ifTrue:[^ nil].

    "/

    "/ have to create a funny colorMap, where

    "/ color at:index == color colorId:index

    "/

    map := Array new:256.

    fixColors do:[:clr |

	map at:clr colorId + 1 put:clr

    ].

    f colorMap:map. 

    f initGC.

    f bits:pseudoBits.

    aDevice drawBits:pseudoBits bitsPerPixel:8 depth:deviceDepth  

	       width:width height:height

		   x:0 y:0

		into:(f id) x:0 y:0 

	       width:width height:height with:(f gcId).

    ^ f

    "

     example: 

	color reduction from Depth8 to Depth4 (dithering) can be done by:

     |img8 reducedImg8 img4 map form|

     map := #( 

		  (0     0   0)

		  (0     0 100)

		  (0    50   0)

		  (0    50 100)

		  (0   100   0)

		  (0   100 100)

		  (100   0   0)

		  (100   0 100)

		  (100  50   0)

		  (100  50 100)

		  (100 100   0)

		  (100 100 100)) collect:[:rgb | (Color red:(rgb at:1)

						      green:(rgb at:2)

						       blue:(rgb at:3)) on:Display].

     img8 := Image fromFile:'bitmaps/bf.im8'.

     form := img8 paletteImageAsDitheredPseudoFormOn:Display 

		      colors:map 

			nRed:2

		      nGreen:3

		       nBlue:2.

     img8 := Depth8Image fromForm:form.    'dithered version of original image'.

     img4 := Depth4Image fromImage:img8.

    "

!

paletteImageAsPseudoFormOn:aDevice

    "return a pseudoForm from the palette picture. The main work is

     in color reduction, when not all colors can be aquired."

    |pseudoBits f gcRound has8BitImage deviceDepth

     imgMap newImage pxl

     usedColors usageCounts maxIndex map

     fit scale lastOK error 

     div 

     bitsPerRGB "{Class: SmallInteger }"

     shift      "{Class: SmallInteger }"

     m          "{Class: SmallInteger }" |

    Color fixColors notNil ifTrue:[

	f := self paletteImageAsDitheredPseudoFormOn:aDevice.

	f notNil ifTrue:[^ f].

    ].

    "find used colors"

    usedColors := bytes usedValues.    "gets us an array filled with used values"

				       "(could use bytes asBag)"

    maxIndex := usedColors max + 1.

    usedColors size > 20 ifTrue:[

	('D8IMAGE: allocating ' , usedColors size printString , ' colors ...') infoPrintNL.

    ].

    "sort by usage"

    usageCounts := bytes usageCounts.

    usageCounts := usedColors asArray collect:[:clr | usageCounts at:(clr + 1)].

    usageCounts sort:[:a :b | a > b] with:usedColors.

    "allocate the colors (in order of usage count)"

    imgMap := Array new:maxIndex.