"

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

orderedDitheredBitsWithDitherMatrix:ditherMatrix ditherWidth:dW depth:depth

    "return the bitmap for a dithered depth-bitmap from the image;

     with a constant ditherMatrix, this can be used for thresholding.

     Redefined to make use of knowing that pixels are 8-bit values."

    |dH nDither   

     greyLevels greyMap1 greyMap2

     bytesPerRow  "{Class: SmallInteger }"

     bytesPerOutRow  "{Class: SmallInteger }"

     pixelsPerByte   "{Class: SmallInteger }"

     outBits

     w               "{Class: SmallInteger }"

     h               "{Class: SmallInteger }" |

    nDither := ditherMatrix size.

    dH := nDither / dW.

    w := width.

    h := height.

    greyLevels := 1 bitShift:depth.

    pixelsPerByte := 8 / depth.

    bytesPerRow := self bytesPerRow.

    bytesPerOutRow := (w * depth + 7) // 8.

    outBits := ByteArray uninitializedNew:(bytesPerOutRow * h).

    (outBits isNil or:[bytes isNil]) ifTrue:[

        ^ nil

    ].

    greyMap1 := self greyMapForRange:(greyLevels-1).                    "/ the pixels

    greyMap1 := (greyMap1 collect:[:b | b isNil ifTrue:[

                                            0

                                        ] ifFalse:[

                                            b truncated

                                        ]

                                  ]) asByteArray.      

    greyMap2 := self greyMapForRange:(greyLevels-1).

    greyMap2 := (greyMap2 collect:[:el | 

                                        el isNil ifTrue:[

                                            0

                                        ] ifFalse:[

                                            ((el - el truncated)  "/ the error (0..1)

                                            * nDither) rounded

                                        ]]) asByteArray.

%{

    int __dW = __intVal(dW);

    int __dH = __intVal(dH);

    int __byte;

    int __dT, __dO;

    int __dstIdx = 0;

    int __srcIdx = 0;

    int __bitCnt;

    int __grey, __pixel;

    int __w = __intVal(w);

    int __h = __intVal(h);

    int __x;

    int __y;

    int __oX, __oY, __dY;

    int __nextDst;

    int __nextSrc;

    int __bytesPerRow = __intVal(bytesPerRow);

    int __bytesPerOutRow = __intVal(bytesPerOutRow);

    char *__outBits = __ByteArrayInstPtr(outBits)->ba_element;

    char *__ditherMatrix = __ByteArrayInstPtr(ditherMatrix)->ba_element;

    unsigned char *__bytes = __ByteArrayInstPtr(__INST(bytes))->ba_element;

    unsigned char *__greyMap1 = __ByteArrayInstPtr(greyMap1)->ba_element;

    unsigned char *__greyMap2 = __ByteArrayInstPtr(greyMap2)->ba_element;

    __oY = __dY = 0;

    for (__y=0; __y<__h; __y++) {

        __nextDst = __dstIdx + __bytesPerOutRow;

        __nextSrc = __srcIdx + __bytesPerRow;

        __byte = 0;

        __bitCnt = 8;

        __oX = 0;

        for (__x=0; __x<__w; __x++) {

            __grey = __bytes[__srcIdx++];            /* 0..255 */

            __pixel = __greyMap1[__grey];            /* 0..(greyLevels-1) */

            __dO    = __greyMap2[__grey];            /* 0.. nDither-1) */

            __dT = __ditherMatrix[__dY + __oX];

                __pixel++;

            __oX++;

            if (__oX == __dW) __oX = 0;

            if (__bitCnt == 0) {

                __outBits[__dstIdx] = __byte;

                __dstIdx++;

                __byte = 0;

                __bitCnt = 8;

            }

        }

        if (__bitCnt != 8) {

            __byte = __byte << __bitCnt;

            __outBits[__dstIdx] = __byte;

        }

        __oY++; __dY += __dW;

        if (__oY == __dH) {

            __oY = 0;

            __dY = 0;

        }

        __srcIdx = __nextSrc;

        __dstIdx = __nextDst;

    }

%}.

    ^ outBits

!

orderedDitheredMonochromeBitsWithDitherMatrix:ditherMatrix ditherWidth:dW

    "return the dithered monochrome bits for the receiver image;

     with a constant ditherMatrix, this can be used for thresholding.

     Redefined to make use of knowing that pixels are 8-bit values."

    |f dH nDither   

     greyMap monoBits

     bytesPerMonoRow "{Class: SmallInteger }"

     bytesPerRow     "{Class: SmallInteger }"

     w               "{Class: SmallInteger }"

     h               "{Class: SmallInteger }"|

    nDither := ditherMatrix size.

    dH := nDither / dW.

    w := width.

    h := height.

    bytesPerRow := self bytesPerRow.

    bytesPerMonoRow := w + 7 // 8.

    monoBits := ByteArray uninitializedNew:(bytesPerMonoRow * h).

    (monoBits isNil or:[bytes isNil]) ifTrue:[

        ^ nil

    ].

    greyMap := self greyByteMapForRange:nDither.

%{

    int __dW = __intVal(dW);

    int __dH = __intVal(dH);

    int __byte;

    int __dT;

    int __dstIdx = 0;

    int __srcIdx = 0;

    int __bitCnt;

    int __grey;

    int __w = __intVal(w);

    int __h = __intVal(h);

    int __x;

    int __y;

    int __oX, __oY, __dY;

    int __nextDst;

    int __nextSrc;

    int __bytesPerRow = __intVal(bytesPerRow);

    int __bytesPerMonoRow = __intVal(bytesPerMonoRow);

    char *__monoBits = __ByteArrayInstPtr(monoBits)->ba_element;

    char *__ditherMatrix = __ByteArrayInstPtr(ditherMatrix)->ba_element;

    unsigned char *__bytes = __ByteArrayInstPtr(__INST(bytes))->ba_element;

    unsigned char *__greyMap = __ByteArrayInstPtr(greyMap)->ba_element;

    __oY = __dY = 0;

    for (__y=0; __y<__h; __y++) {

        __nextDst = __dstIdx + __bytesPerMonoRow;

        __nextSrc = __srcIdx + __bytesPerRow;

        __byte = 0;

        __bitCnt = 8;

        __oX = 0;

        for (__x=0; __x<__w; __x++) {

            __grey = __bytes[__srcIdx];   /* 0..255 */

            __srcIdx++;

            __grey = __greyMap[__grey];

            __dT = __ditherMatrix[__dY + __oX];

            __oX++;

            if (__oX == __dW) __oX = 0;

            __byte = __byte << 1;

            if (__grey > __dT) {

                __byte = __byte | 1;           /* white */

            }

            __bitCnt--;

            if (__bitCnt == 0) {

                __monoBits[__dstIdx] = __byte;

                __dstIdx++;

                __byte = 0;

                __bitCnt = 8;

            }

        }

        if (__bitCnt != 8) {

            __byte = __byte << __bitCnt;

            __monoBits[__dstIdx] = __byte;

        }

        __oY++; __dY += __dW;

        if (__oY == __dH) {

            __oY = 0;

            __dY = 0;

        }

        __srcIdx = __nextSrc;

        __dstIdx = __nextDst;

    }

%}.

    ^ monoBits

    "

     |i f|

     i := Image fromFile:'bitmaps/claus.gif'.

     f := i asOrderedDitheredMonochromeFormOn:Display.

     |i f|

     i := Image fromFile:'bitmaps/garfield.gif'.

     f := i asOrderedDitheredMonochromeFormOn:Display.

     |i f|

     i := (Image fromFile:'bitmaps/PasteButton.tiff') magnifiedBy:10.

     f := i asOrderedDitheredMonochromeFormOn:Display.

     |i f|

     i := (Image fromFile:'bitmaps/blue-ball.gif') magnifiedBy:1.

     f := i asOrderedDitheredMonochromeFormOn:Display.

    "

    "Created: 7.6.1996 / 10:48:06 / cg"

    "Modified: 7.6.1996 / 11:08:50 / cg"

! !

!Depth8Image methodsFor:'converting greyscale images'!

greyImageAsMonoFormOn:aDevice

    "return a (thresholded) monochrome Form from the picture."

    |bytesPerRow

     bytesPerMonoRow monoData

     pixel       "{Class: SmallInteger }"

     byte        "{Class: SmallInteger }"

     mask        "{Class: SmallInteger }"

     srcIndex    "{Class: SmallInteger }"

     dstIndex    "{Class: SmallInteger }"

     nextSrc     "{Class: SmallInteger }"

     nextDst     "{Class: SmallInteger }"

     bitNumber   "{Class: SmallInteger }"

     w           "{Class: SmallInteger }"

     h           "{Class: SmallInteger }" |

    w := width.

    h := height.

    bytesPerRow := self bytesPerRow.

    bytesPerMonoRow := w // 8.

    ((w \\ 8) ~~ 0) ifTrue:[

	bytesPerMonoRow := bytesPerMonoRow + 1

    ].

    monoData := ByteArray uninitializedNew:(bytesPerMonoRow * h).

    "8 bit -> 1 bit extract; take most significant bit"

    srcIndex := 1.

    dstIndex := 1.

    1 to:h do:[:count |

	nextSrc := srcIndex + bytesPerRow.

	nextDst := dstIndex + bytesPerMonoRow.

	bitNumber := 1.

	mask := 2r10000000.

	[bitNumber <= w] whileTrue:[

	    byte := 0.

	    pixel := bytes at:srcIndex.

	    srcIndex := srcIndex + 1.

	    ((pixel bitAnd:2r10000000) ~~ 0) ifTrue:[

		byte := byte bitOr:mask

	    ].

	    mask := mask bitShift: -1.

	    (mask == 0) ifTrue:[

		monoData at:dstIndex put:byte.

		dstIndex := dstIndex + 1.

		byte := 0.

		mask := 2r10000000

	    ].

	    bitNumber := bitNumber + 1

	].

	(mask == 2r10000000) ifFalse:[

	    monoData at:dstIndex put:byte.

	    dstIndex := dstIndex + 1

	].

	srcIndex := nextSrc.

	dstIndex := nextDst

    ].

    ^ Form width:w height:h fromArray:monoData on:aDevice

!

greyImageAsPatternDitheredGreyFormForDepth:depth on:aDevice

    "return a dithered greyForm from the grey picture.

     Works for any destination depth.

     Used to reduce the number of grey levels."

    |f

     map

     last ditherColors nDither first delta 

     w             "{Class: SmallInteger }"

     h             "{Class: SmallInteger }"

     v             "{Class: SmallInteger }"

     run           "{Class: SmallInteger }"

     srcIndex      "{Class: SmallInteger }"

    |

"/    Transcript showCR:'dithering ..'. Transcript endEntry.

    nDither := NumberOfDitherColors.

    ditherColors := Array new:nDither.

    first := (100 / nDither / 2).

    delta := 100 / nDither.

    0 to:nDither-1 do:[:i |

        ditherColors at:i+1 put:(Color gray:(i * delta + first)).

    ].

    map := Array new:256.

    1 to:256 do:[:i |

        v := i - 1.

        v := (v * (nDither - 1) // 255) rounded.

        " v is now 0 .. nDither-1 "

        map at:i put:(ditherColors at:(v + 1))

    ].

    "tuning (general code is too slow)

     get the patterns, fill form bytes here"

    w := width.

    h := height.

    depth == 1 ifTrue:[

        ^ self dither1PlaneUsingMap:map on:aDevice.

    ].

    depth == 2 ifTrue:[

        ^ self dither2PlaneUsingMap:map on:aDevice.

    ].

    "draw each pixel using dither color (let others do the dithering)

     although the code is simple, its very slow"

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

    f isNil ifTrue:[^ nil].

    f initGC.

    srcIndex := 1.

    1 to:h do:[:dstY |