"

 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'!

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"

    |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 atX:x y:y

    ].

    ^ Color redByte:rVal greenByte:gVal blueByte:bVal

!

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

     val   "{ Class: SmallInteger }" |

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

    val := (aColor red / 100 * 255) rounded.

    bytes at:(index) put:val.

    val := (aColor green / 100 * 255) rounded.

    bytes at:(index + 1) put:val.

    val := (aColor blue / 100 * 255) rounded.

    bytes at:(index + 2) put:val.

!

atX:x y:y putValue: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.

!

valueAtX: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

! !

!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*)"

    ^ self rgbImageAsDitheredPseudoFormOn:aDevice

                                   colors:aDevice fixColors

                                     nRed:aDevice numFixRed

                                     nGreen:aDevice numFixGreen

                                     nBlue:aDevice numFixBlue

    "Modified: 11.7.1996 / 18:24:27 / cg"

!

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

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

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

     dstIndex "{ Class: SmallInteger }"

     deviceDepth has8BitImage 

     fixIds failed|

    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].

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

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

    h := height.

    w := width.

%{

    int __x, __y;

    int __eR, __eG, __eB;

    int __wantR, __wantG, __wantB;

    unsigned char *srcP, *dstP;

    unsigned char *redP, *greenP, *blueP;

    int pix;

    unsigned char *idP;

    int __fR, __fG, __fB;

    int iR, iG, iB;

    int idx;

    int __w = __intVal(w);

    if (__isByteArray(__INST(bytes))

     && __isByteArray(pseudoBits)

     && __isByteArray(fixIds)

     && __bothSmallInteger(fixR, fixG)

     && __isSmallInteger(fixB)) {

        failed = false;

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

        dstP = __ByteArrayInstPtr(pseudoBits)->ba_element;

        idP = __ByteArrayInstPtr(fixIds)->ba_element;

        __fR = __intVal(fixR)-1;

        __fG = __intVal(fixG)-1;

        __fB = __intVal(fixB)-1;

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

            __eR = __eG = __eB = 0;

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

                int __want;

                /*

                 * 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

                 */

                __wantR = __want = srcP[0] + __eR;

                if (__want > 255) __want = 255;

                else if (__want < 0) __want = 0;

                iR = __want * __fR / 128;

                iR = (iR / 2) + (iR & 1);

                __wantG = __want = srcP[1] + __eG;

                if (__want > 255) __want = 255;

                else if (__want < 0) __want = 0;

                iG = __want * __fG / 128;

                iG = (iG / 2) + (iG & 1);

                __wantB = __want = srcP[2] + __eB;

                if (__want > 255) __want = 255;

                else if (__want < 0) __want = 0;

                iB = __want * __fB / 128;

                iB = (iB / 2) + (iB & 1);

                idx = iR * (__fG+1);

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

                idx = idx + iB;

                /*

                 * store the corresponding dither colorId

                 */

                *dstP++ = idP[idx];

                srcP += 3;

                /*

                 * the new error:

                 */

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

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

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

            }

        }

    }

%}.

    failed ifTrue:[

        self primitiveFailed.

        ^ nil

"/ for non-C programmers:

"/     the above code is (roughly) equivalent to:

"/     (but it is just as ugly looking as the above ;-)

"/

"/    srcIndex := 1.

"/    dstIndex := 1.

"/    1 to:h do:[:y |

"/        eR := eG := eB := 0.

"/        1 to:w do:[:x |

"/            |pixel "{ Class: SmallInteger }"

"/             clr 

"/             idx   "{ Class: SmallInteger }"

"/             iR    "{ Class: SmallInteger }"

"/             iG    "{ Class: SmallInteger }"

"/             iB    "{ Class: SmallInteger }"

"/             wR    "{ Class: SmallInteger }"

"/             wG    "{ Class: SmallInteger }"

"/             wB    "{ Class: SmallInteger }" |

"/

"/            wantR := ((bytes at:srcIndex) + eR). srcIndex := srcIndex + 1.

"/            wantG := ((bytes at:srcIndex) + eG). srcIndex := srcIndex + 1.

"/            wantB := ((bytes at:srcIndex) + eB). srcIndex := srcIndex + 1.

"/            wR := wantR.

"/            wR > 255 ifTrue:[wR := 255] ifFalse:[wR < 0 ifTrue:[wR := 0]].

"/            wG := wantG.

"/            wG > 255 ifTrue:[wG := 255] ifFalse:[wG < 0 ifTrue:[wG := 0]].

"/            wB := wantB.

"/            wB > 255 ifTrue:[wB := 255] ifFalse:[wB < 0 ifTrue:[wB := 0]].

"/

"/            iR := wR * (fixR-1) // 128.

"/            iR := (iR // 2) + (iR bitAnd:1).

"/            iG := wG * (fixG-1) // 128.

"/            iG := (iG // 2) + (iG bitAnd:1).

"/            iB := wB * (fixB-1) // 128.

"/            iB := (iB // 2) + (iB bitAnd:1).

"/            idx := (iR * fixR + iG) * fixB + iB + 1.

"/

"/            clr := fixColors at:idx.

"/

"/            eR := wantR - (clr red * 2) asInteger.

"/            eG := wantG - (clr green * 2) asInteger.

"/            eB := wantB - (clr blue * 2) asInteger.

"/

"/            pixel := clr colorId.

"/            pseudoBits at:dstIndex put:pixel.

"/

"/            dstIndex := dstIndex + 1

"/        ].

    ].

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

    f isNil ifTrue:[^ nil].

    f colorMap:fixColors.

    f initGC.

    aDevice drawBits:pseudoBits bitsPerPixel:8 depth:aDevice depth

               width:width height:height

                   x:0 y:0

                into:(f id) x:0 y:0 width:width height:height with:(f gcId).

    ^ f

!

rgbImageAsPseudoFormOn:aDevice

    "return a pseudocolor form from the rgb-picture"

    |pseudoBits f

     r        "{ Class: SmallInteger }"

     g        "{ Class: SmallInteger }"

     b        "{ Class: SmallInteger }"

     srcIndex "{ Class: SmallInteger }"

     dstIndex "{ Class: SmallInteger }"

     rMask    "{ Class: SmallInteger }"

     gMask    "{ Class: SmallInteger }"

     bMask    "{ Class: SmallInteger }"

     redArray greenArray blueArray

     dataSize "{ Class: SmallInteger }"

     nColors  "{ Class: SmallInteger }"

     fit fitMap colors color 

     fast

     colorIndex "{ Class: SmallInteger }"

     depth nColorCells deep|

    aDevice fixColors notNil ifTrue:[

        f := self rgbImageAsDitheredPseudoFormOn:aDevice.

        f notNil ifTrue:[^ f].

    ].

    "find used colors; build color-tree"

    fit := false.                       

    fitMap := false.

    depth := aDevice depth.

    nColorCells := aDevice ncells.

    deep := (depth > 8).

    rMask := 2r11111111.

    gMask := 2r11111111.

    bMask := 2r11111111.

    'Depth24Image [info]: allocating colors ...' infoPrintCR.

    [fit] whileFalse:[

        [fitMap] whileFalse:[

            srcIndex := 1.

            redArray := Array new:256.

            "

             find used colors, build [r][g][b] 3-dimensional array

             containing true for used colors

            "

            nColors := 0.

            srcIndex := 1.

            dataSize := bytes size.

            [srcIndex < dataSize] whileTrue:[

%{

                if (__isByteArray(_INST(bytes))) {

                    int sI = _intVal(srcIndex);

                    unsigned char *cp = _ByteArrayInstPtr(_INST(bytes))->ba_element;

                    r = __MKSMALLINT((cp[sI - 1] & _intVal(rMask)) + 1);

                    g = __MKSMALLINT((cp[sI]     & _intVal(gMask)) + 1);

                    b = __MKSMALLINT((cp[sI + 1] & _intVal(bMask)) + 1);

                    srcIndex = __MKSMALLINT(sI + 3);

                    fast = true;

                } else {

                    fast = false;

                }

%}

.

                fast ifFalse:[