"

 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:#Depth24Image

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'Graphics-Images'

!

!Depth24Image 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 true-color (24 bit / pixel) images.

    It mainly consists of methods already implemented in Image,

    reimplemented here for more performance.

    Only the #rgb format is supported here.

    [author:]

	Claus Gittinger

    [see also:]

	Depth1Image Depth2Image Depth4Image Depth8Image Depth16Image

	ImageReader

"

! !

!Depth24Image class methodsFor:'queries'!

defaultPhotometric

    "return the default photometric pixel interpretation"

    ^ #rgb

    "Created: 10.6.1996 / 18:08:25 / cg"

!

imageDepth

    "return the depth of images represented by instances of

     this class - here we return 24"

    ^ 24

    "Modified: 20.4.1996 / 23:39:50 / cg"

! !

!Depth24Image methodsFor:'accessing - pixels'!

colorAtX: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"

    |index "{ Class: SmallInteger }"

     rVal gVal bVal|

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

    rVal := bytes at:(index).

    gVal := bytes at:(index + 1).

    bVal := bytes at:(index + 2).

    photometric ~~ #rgb ifTrue:[

	^ super colorAtX:x y:y

    ].

    ^ Color redByte:rVal greenByte:gVal blueByte:bVal

    "Created: 24.4.1997 / 17:32:47 / cg"

    "Modified: 24.4.1997 / 21:32:37 / cg"

!

colorAtX:x y:y put:aColor

    "set the pixel at x/y to aColor.

     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 := 1 + (((width * y) + x) * 3).

    bytes at:(index) put:(aColor redByte).

    bytes at:(index + 1) put:(aColor greenByte).

    bytes at:(index + 2) put:(aColor blueByte).

    "Created: 24.4.1997 / 17:32:59 / cg"

!

pixelAtX: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"

    |index "{ Class: SmallInteger }"

     rVal  "{ Class: SmallInteger }"

     gVal  "{ Class: SmallInteger }"

     bVal  "{ Class: SmallInteger }"|

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

    rVal := bytes at:(index).

    gVal := bytes at:(index + 1).

    bVal := bytes at:(index + 2).

    ^ (((rVal bitShift:8) bitOr:gVal) bitShift:8) bitOr:bVal

    "Created: 24.4.1997 / 16:06:34 / cg"

!

pixelAtX:x y:y put:aPixelValue

    "set a pixel at x/y to aPixelValue, which is 24 bits RGB.

     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 }"

     val   "{ Class: SmallInteger }" |

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

    val := aPixelValue.

    bytes at:(index + 2) put:(val bitAnd:16rFF).

    val := val bitShift:-8.

    bytes at:(index + 1) put:(val bitAnd:16rFF).

    val := val bitShift:-8.

    bytes at:(index) put:val.

    "Created: 24.4.1997 / 17:06:33 / cg"

!

rowAt:rowIndex putAll:pixelArray

    "replace a single rows bits from bits in the pixelArray argument;

     Notice: row indexing starts at 0."

    |dstIdx pixel|

    dstIdx := (rowIndex * self bytesPerRow) + 1.

    1 to:width do:[:col |

	pixel := pixelArray at:col.

	bytes at:dstIdx put:((pixel bitShift:-16) bitAnd:16rFF).

	bytes at:dstIdx+1 put:((pixel bitShift:-8) bitAnd:16rFF).

	bytes at:dstIdx+2 put:(pixel bitAnd:16rFF).

	dstIdx := dstIdx + 3.

    ].

    ^ pixelArray

    "Created: 24.4.1997 / 15:43:08 / cg"

!

rowAt:rowIndex putAll:pixelArray startingAt:startIndex

    "store a single rows bits from bits in the pixelArray argument;

     Return the pixelArray.

     Notice: row indexing starts at 0."

    |dstIdx pixel|

    dstIdx := (rowIndex * self bytesPerRow) + 1.

    1 to:width do:[:col |

	pixel := pixelArray at:(startIndex + col).

	bytes at:dstIdx put:((pixel bitShift:-16) bitAnd:16rFF).

	bytes at:dstIdx+1 put:((pixel bitShift:-8) bitAnd:16rFF).

	bytes at:dstIdx+2 put:(pixel bitAnd:16rFF).

	dstIdx := dstIdx + 3.

    ].

    ^ pixelArray

    "Created: 24.4.1997 / 15:50:27 / cg"

! !

!Depth24Image methodsFor:'converting rgb images'!

asGrayFormOn:aDevice

    "return a grey form from the receiver.

     Redefined to use special code when converting to 8-bit

     greyScale displays."

    (aDevice visualType == #StaticGray) ifTrue:[

	aDevice depth == 8 ifTrue:[

	    ^ self makeDeviceGrayPixmapOn:aDevice depth:aDevice depth fromArray:(self threshold8BitGrayBits)

	].

    ].

    ^ super asGrayFormOn:aDevice

    "Created: 10.6.1996 / 19:00:45 / cg"

    "Modified: 10.6.1996 / 20:10:19 / cg"

!

asThresholdGrayImageDepth:depth

    "return an 8-bit grey image from the rgb picture.

     Pixel values are reduced to a 0..255 grey level."

    depth == 8 ifTrue:[

	photometric == #rgb ifTrue:[

	    ^ Depth8Image

		width:width

		height:height

		fromArray:(self threshold8BitGrayBits)

	]

    ].

    ^ super asThresholdGrayImageDepth:depth

    "

     |i|

     i := Image fromFile:'bitmaps/granite.tiff'.

     (i asThresholdGrayImageDepth:8) inspect.

     (i asThresholdGrayImageDepth:4) inspect.

     (i asThresholdGrayImageDepth:2) inspect.

     (i asThresholdGrayImageDepth:1) inspect.

    "

    "

     |i|

     i := Image fromFile:'bitmaps/granite.tiff'.

     ((i asThresholdGrayImageDepth:8) asOrderedDitheredGrayImageDepth:2) inspect

    "

    "

     |i|

     i := Image fromFile:'bitmaps/granite.tiff'.

     ((i asThresholdGrayImageDepth:8) asOrderedDitheredGrayImageDepth:4) inspect

    "

    "

     |i|

     i := Image fromFile:'bitmaps/granite.tiff'.

     (i asThresholdGrayImageDepth:8) asOrderedDitheredMonochromeImage inspect

    "

    "Created: 8.6.1996 / 13:58:46 / cg"

    "Modified: 10.6.1996 / 19:11:18 / cg"

!

rgbImageAsDitheredPseudoFormOn:aDevice

    "return a dithered pseudocolor form from the rgb-picture.

     This method depends on fixColors being allocated (see Color>>getColors*)"

    |ditherColors|

    (ditherColors := aDevice fixColors) notNil ifTrue:[

	^ self 

		rgbImageAsDitheredPseudoFormOn:aDevice

		colors:ditherColors

		nRed:aDevice numFixRed

		nGreen:aDevice numFixGreen

		nBlue:aDevice numFixBlue

    ].

    ditherColors := Set new.

    ditherColors addAll:(aDevice ditherColors).

    ditherColors addAll:(aDevice deviceColors).

    ditherColors := ditherColors asArray.

    ^ self 

	rgbImageAsDitheredPseudoFormOn:aDevice 

	colors:ditherColors.

    "Modified: 22.4.1997 / 11:59:44 / cg"

!

rgbImageAsDitheredPseudoFormOn:aDevice colors:fixColors

    "return a dithered 8-bit pseudocolor form from the rgb-picture, using

     arbitrary fix colors in fixColors."

    |pseudoBits f

     h        "{ Class: SmallInteger }"

     w        "{ Class: SmallInteger }"

     numFix   "{Class: SmallInteger }"

     srcIndex "{ Class: SmallInteger }"

     dstIndex "{ Class: SmallInteger }"

     deviceDepth

     fixIds fixRed fixGreen fixBlue failed cache idsUsed usedColors

     fixColorArray|

    numFix := fixColors size.

    numFix == 256 ifTrue:[

        "/ algorithm below only handles 255 colors.

        numFix := 255.

    ].

    fixColorArray := fixColors asArray.

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

    fixRed := (fixColorArray collect:[:clr | clr redByte]) asByteArray.

    fixGreen := (fixColorArray collect:[:clr | clr greenByte]) asByteArray.

    fixBlue := (fixColorArray collect:[:clr | clr blueByte]) asByteArray.

    cache := ByteArray new:(1 bitShift:14).

    cache atAllPut:16rFF.

    deviceDepth := aDevice depth.

    deviceDepth == 8 ifFalse:[

        (aDevice supportedImageFormatForDepth:8) isNil ifTrue:[

            ^ nil

        ]

    ].

    idsUsed := ByteArray new:(fixIds size).

    'Depth24Image [info]: dithering ...' infoPrintCR.

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

    h := height.

    w := width.

%{

    int __x, __y, __numFix;

    int __eR, __eG, __eB;

    unsigned char *srcP, *dstP;

    int pix;

    unsigned char *idP, *usedIdP, *redP, *greenP, *blueP, *cacheP;

    int __w = __intVal(w);

    if (__isByteArray(__INST(bytes))

     && __isSmallInteger(numFix)

     && __isByteArray(pseudoBits)

     && __isByteArray(cache)

     && __isByteArray(fixIds)

     && __isByteArray(idsUsed)

     && __isByteArray(fixRed)

     && __isByteArray(fixGreen)

     && __isByteArray(fixBlue) ) {

        failed = false;

        srcP = __ByteArrayInstPtr(__INST(bytes))->ba_element;

        dstP = __ByteArrayInstPtr(pseudoBits)->ba_element;

        idP = __ByteArrayInstPtr(fixIds)->ba_element;

        usedIdP = __ByteArrayInstPtr(idsUsed)->ba_element;

        redP = __ByteArrayInstPtr(fixRed)->ba_element;

        greenP = __ByteArrayInstPtr(fixGreen)->ba_element;

        blueP = __ByteArrayInstPtr(fixBlue)->ba_element;

        cacheP = __ByteArrayInstPtr(cache)->ba_element;

        __numFix = __intVal(numFix);

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

            __eR = __eG = __eB = 0;

            for (__x=__w; __x>0; __x--) {

                int cacheIdx, clrIdx;

                int __wantR, __wantG, __wantB;

                __wantR = srcP[0] + __eR;

                if (__wantR > 255) __wantR = 255;

                else if (__wantR < 0) __wantR = 0;

                __wantG = srcP[1] + __eG;

                if (__wantG > 255) __wantG = 255;

                else if (__wantG < 0) __wantG = 0;

                __wantB = srcP[2] + __eB;

                if (__wantB > 255) __wantB = 255;

                else if (__wantB < 0) __wantB = 0;

                /*

                 * compute cache index

                 */

                cacheIdx = ((__wantR & 0xF8) >> 3);

                cacheIdx = (cacheIdx << 5) | ((__wantG & 0xF8) >> 3);

                cacheIdx = (cacheIdx << 4) | ((__wantB & 0xF0) >> 4);

                clrIdx = cacheP[cacheIdx];

                if (clrIdx == 0xFF) {   /* invalid slot */

                    unsigned minErr, minIdx;

                    int i;

                    /*

                     * must search ...

                     */

                    minErr = 0x7FFFFFF; minIdx = 0;

                    for (i=0; i<__numFix; i++) {

                        unsigned cR, cG, cB, e;

                        int eR, eG, eB;

                        cR = redP[i]; cG = greenP[i]; cB = blueP[i];

                        eR = cR - __wantR;

                        if (eR < 0) eR = -eR;

                        eG = cG - __wantG;

                        if (eG < 0) eG = -eG;

                        eB = cB - __wantB;

                        if (eB < 0) eB = -eB;

                        e = eR + eG + eB;

                        if (e < minErr) {

                            minErr = e;

                            minIdx = i;

                            if (e < 7) {

                                break;

                            }

                        }

                    }

                    /*

                     * minIdx is now index into fixColors

                     */

                    cacheP[cacheIdx] = clrIdx = minIdx;

/*

printf("want %d/%d/%d best: %d [%d/%d/%d]\n", __wantR, __wantG, __wantB, clrIdx, redP[clrIdx], greenP[clrIdx], blueP[clrIdx]);

*/

                }

                /*

                 * store the corresponding dither colorId

                 */

                *dstP++ = idP[clrIdx];

                usedIdP[clrIdx] = 1;

                srcP += 3;

                /*

                 * the new error:

                 */

                __eR = __wantR - redP[clrIdx]; 

                __eG = __wantG - greenP[clrIdx]; 

                __eB = __wantB - blueP[clrIdx]; 

            }

        }

    }

%}.

    failed ifTrue:[

        self primitiveFailed.

        ^ nil

    ].

    "/ not all colors may be really in use ...

    usedColors := fixColors copy.

    idsUsed keysAndValuesDo:[:idx :flag |

        flag == 0 ifTrue:[

            usedColors at:idx put:nil

        ]

    ].

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

    f isNil ifTrue:[^ nil].

    f colorMap:usedColors.

    f initGC.

    aDevice 

        drawBits:pseudoBits 

        bitsPerPixel:8 

        depth:aDevice depth

        padding:8

        width:width height:height

        x:0 y:0

        into:(f id) 

        x:0 y:0 

        width:width height:height 

        with:(f gcId).

    ^ f

!

rgbImageAsDitheredPseudoFormOn:aDevice colors:fixColors nRed:nRed nGreen:nGreen nBlue:nBlue

    "return a dithered pseudocolor form from the rgb-picture,

     using colors from a colorCube for dithering."

    |pseudoBits f

     h        "{ Class: SmallInteger }"

     w        "{ Class: SmallInteger }"

"/     eR    "{Class: SmallInteger }"

"/     eG    "{Class: SmallInteger }"

"/     eB    "{Class: SmallInteger }"

"/     wantR "{Class: SmallInteger }"

"/     wantG "{Class: SmallInteger }"

"/     wantB "{Class: SmallInteger }"

     fixR  "{Class: SmallInteger }"

     fixG  "{Class: SmallInteger }"

     fixB  "{Class: SmallInteger }"

     srcIndex "{ Class: SmallInteger }"