"

 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.

"

!

version

!

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.

"

! !

!Depth8Image class methodsFor:'queries'!

imageDepth

    ^ 8

! !

!Depth8Image ignoredMethodsFor:'queries'!

bitsPerSample

    "return the number of bits per sample.

     The return value is an array of bits-per-plane."

    ^ #(8)

!

samplesPerPixel

    "return the number of samples per pixel in the image."

    ^ 1

! !

!Depth8Image methodsFor:'queries'!

bitsPerPixel

    "return the number of bits per pixel"

    ^ 8

!

bitsPerRow

    "return the number of bits in one scanline of the image"

    ^  width * 8

!

bytesPerRow

    "return the number of bytes in one scanline of the image"

    ^ width

!

usedValues

    "return a collection of color values used in the receiver."

    ^ bytes usedValues

! !

!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 grey:100 - (100 / 255 * value)

    ].

    photometric == #blackIs0 ifTrue:[

	^ Color grey:(100 / 255 * value)

    ].

    photometric ~~ #palette ifTrue:[

	self error:'format not supported'.

	^ nil

    ].

    index := value + 1.

    ^ colorMap at:index

!

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.

!

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.

! !

!Depth8Image methodsFor:'enumerating'!

valueAtY:y from:xLow to:xHigh do:aBlock

    "perform aBlock for each pixelValue from x1 to x2 in row y.

     The block is passed the pixelValue at each pixel.

     This method allows slighly faster processing of an

     image than using valueAtX:y:, since some processing can be

     avoided when going from pixel to pixel. However, for

     real image processing, specialized methods should be written."

    |srcIndex   "{ Class: SmallInteger }"

     pixelValue "{ Class: SmallInteger }"

     x1         "{ Class: SmallInteger }"

     x2         "{ Class: SmallInteger }"|

    x1 := xLow.

    x2 := xHigh.

    srcIndex := (width * y) + 1 + x1.

    x1 to:x2 do:[:x |

	pixelValue := bytes at:srcIndex.

	srcIndex := srcIndex + 1.

	aBlock value:x value:pixelValue 

    ]

!

atY:y from:xLow to:xHigh do:aBlock

    "perform aBlock for each pixel from x1 to x2 in row y.

     The block is passed the color at each pixel.

     This method allows slighly faster processing of an

     image than using atX:y:, since some processing can be

     avoided when going from pixel to pixel. However, for

     real image processing, specialized methods should be written."

    |srcIndex "{ Class: SmallInteger }"

     index    "{ Class: SmallInteger }"

     value    "{ Class: SmallInteger }"

     x1       "{ Class: SmallInteger }"

     x2       "{ Class: SmallInteger }"

     color colors last|

    photometric == #palette ifTrue:[

	colors := colorMap.

    ] ifFalse:[

	colors := Array new:256.

    ].

    x1 := xLow.

    x2 := xHigh.

    srcIndex := (width * y) + 1 + x1.

    x1 to:x2 do:[:x |

	value := bytes at:srcIndex.

	srcIndex := srcIndex + 1.

	value ~~ last ifTrue:[

	    last := value.

	    index := value + 1.

	    color := colors at:index.

	    color isNil ifTrue:[

		photometric == #whiteIs0 ifTrue:[

		    color := (Color grey:100 - (100 * value / 255))

		] ifFalse:[

		    photometric == #blackIs0 ifTrue:[

			color := (Color grey:(100 * value / 255))

		    ] ifFalse:[

			photometric ~~ #palette ifTrue:[

			    self error:'format not supported'.

			    ^ nil

			]

		    ]

		].

		colors at:index put:color

	    ]

	].

	aBlock value:x value:color

    ]

! !

!Depth8Image methodsFor:'private'!

dither1PlaneUsingMap:map on:aDevice

    "a helper for dithering palette and greyscale images"

    |f

     patterns formBytes

     pixel0bytes pixel1bytes

     clr ditherPattern

     nColors       "{Class: SmallInteger }"

     w             "{Class: SmallInteger }"

     h             "{Class: SmallInteger }"|

    nColors := map size.

    w := width.

    h := height.

    formBytes := ByteArray uninitializedNew:(w + 7 // 8) * h.

    patterns := Array new:nColors.

    pixel0bytes := ByteArray uninitializedNew:nColors.

    pixel1bytes := ByteArray uninitializedNew:nColors.

    "

     extract dither patterns and values to use for 1/0 bits

     in those from the dithercolors

    "

    1 to:nColors do:[:i |

	clr := (map at:i) on:aDevice.

	ditherPattern := clr ditherForm.

	ditherPattern isNil ifTrue:[

	    patterns at:i put:#[2r11111111

				2r11111111

				2r11111111

				2r11111111

				2r11111111

				2r11111111

				2r11111111

				2r11111111].

	    pixel0bytes at:i put:clr colorId.

	    pixel1bytes at:i put:clr colorId

	] ifFalse:[

	    patterns at:i put:(ditherPattern bits).

	    pixel0bytes at:i put:(ditherPattern colorMap at:1) colorId.

	    pixel1bytes at:i put:(ditherPattern colorMap at:2) colorId.

	].

    ].

%{

    unsigned char *_srcP, *_dstP;

    OBJ _patternBytes;

    unsigned char _mask = 0x80;

    unsigned char _outBits = 0;

    unsigned char _last, _v, _patternBits, _p0, _p1;

    int _h, _w;

    int _patternOffset = 0;

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

    _dstP = _ByteArrayInstPtr(formBytes)->ba_element;

    for (_h = _intVal(h); _h; _h--) {

	_last = -1;

	for (_w = _intVal(w); _w; _w--) {

	    _v = *_srcP++;

	    if (_v != _last) {

		_patternBytes = _ArrayInstPtr(patterns)->a_element[_v];

		if (__isByteArray(_patternBytes)) {

		    _patternBits = _ByteArrayInstPtr(_patternBytes)->ba_element[_patternOffset];

		} else if (__isArray(_patternBytes)) {

		    _patternBits = _intVal(_ArrayInstPtr(_patternBytes)->a_element[_patternOffset]);

		}

		_p0 = _ByteArrayInstPtr(pixel0bytes)->ba_element[_v];

		_p1 = _ByteArrayInstPtr(pixel1bytes)->ba_element[_v];

		_last = _v;

	    }

	    _outBits <<= 1;

	    if (_patternBits & _mask)

		_outBits |= _p1;

	    else

		_outBits |= _p0;

	    _mask >>= 1;

	    if (_mask == 0) {

		_mask = 0x80;

		*_dstP++ = _outBits;

		_outBits = 0;

	    }

	}

	if (_mask != 0x80) {

	    while (_mask != 0) {

		_outBits <<= 1;

		_mask >>= 1;

	    }

	    *_dstP++ = _outBits;

	    _mask = 0x80;

	    _outBits = 0;

	}

	_patternOffset++;

	if (_patternOffset == 8)

	    _patternOffset = 0;

    }

%}

.

    f := Form width:w height:h fromArray:formBytes.

    ^ f

!

dither2PlaneUsingMap:map on:aDevice

    "a helper for dithering palette and greyscale images"

    |f

     patterns formBytes

     pixel0bytes pixel1bytes

     clr ditherPattern

     nColors       "{Class: SmallInteger }"

     w             "{Class: SmallInteger }"

     h             "{Class: SmallInteger }"|

    nColors := map size.

    w := width.

    h := height.

    formBytes := ByteArray uninitializedNew:(w * 2 + 7 // 8) * h.

    patterns := Array new:nColors.

    pixel0bytes := ByteArray uninitializedNew:nColors.

    pixel1bytes := ByteArray uninitializedNew:nColors.

    "extract dither patterns and values to use for 1/0 bits

     in those from the dithercolors"

    1 to:nColors do:[:i |

	clr := (map at:i) on:aDevice.

	ditherPattern := clr ditherForm.

	ditherPattern isNil ifTrue:[

	    patterns at:i put:#[2r11111111

				2r11111111

				2r11111111

				2r11111111

				2r11111111

				2r11111111

				2r11111111

				2r11111111].

	    pixel0bytes at:i put:clr colorId.

	    pixel1bytes at:i put:clr colorId

	] ifFalse:[

	    patterns at:i put:(ditherPattern bits).

	    pixel0bytes at:i put:(ditherPattern colorMap at:1) colorId.

	    pixel1bytes at:i put:(ditherPattern colorMap at:2) colorId.

	].

    ].

%{

    unsigned char *_srcP, *_dstP;

    OBJ _patternBytes;

    unsigned char _mask = 0x80;

    unsigned char _outBits = 0;

    unsigned char _last, _v, _patternBits, _p0, _p1;

    int _h, _w;

    int _patternOffset = 0;

    int _outCount;

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

    _dstP = _ByteArrayInstPtr(formBytes)->ba_element;

    for (_h = _intVal(h); _h; _h--) {

	_last = -1;

	_outCount = 0;

	for (_w = _intVal(w); _w; _w--) {

	    _v = *_srcP++;

	    if (_v != _last) {

		_patternBytes = _ArrayInstPtr(patterns)->a_element[_v];

		if (__isByteArray(_patternBytes)) {

		    _patternBits = _ByteArrayInstPtr(_patternBytes)->ba_element[_patternOffset];

		} else if (__isArray(_patternBytes)) {

		    _patternBits = _intVal(_ArrayInstPtr(_patternBytes)->a_element[_patternOffset]);

		}

		_p0 = _ByteArrayInstPtr(pixel0bytes)->ba_element[_v];

		_p1 = _ByteArrayInstPtr(pixel1bytes)->ba_element[_v];

		_last = _v;

	    }

	    _outBits <<= 2;

	    if (_patternBits & _mask)

		_outBits |= _p1;

	    else

		_outBits |= _p0;

	    _mask >>= 1;

	    _outCount++;

	    if (_outCount == 4) {

		*_dstP++ = _outBits;

		_outCount = 0;

		if (_mask == 0) {

		    _mask = 0x80;

		}

	    }

	}

	if (_outCount) {

	    do {

		_outBits <<= 2;

	    } while (++_outCount != 4);

	    *_dstP++ = _outBits;

	}

	_mask = 0x80;

	_outBits = 0;

	_patternOffset++;

	if (_patternOffset == 8)

	    _patternOffset = 0;

    }

%}

.

    f := Form width:w height:h depth:2.

    f initGC.

    f device drawBits:formBytes depth:2 width:w height:h x:0 y:0

		 into:f id x:0 y:0 width:w height:h with:f gcId.

    ^ f

! !

!Depth8Image methodsFor:'converting palette images'!

paletteImageAsMonoFormOn:aDevice

    "return a 1-bit monoForm from the palette picture -

     the result is a thresholded form, with white for

     brightness values above 50%, black below"

    |monoBits f

     map

     failed

     w        "{ Class: SmallInteger }"

     h        "{ Class: SmallInteger }"

"/     v        "{ Class: SmallInteger }"

"/     bitCount "{ Class: SmallInteger }"

"/     bits     "{ Class: SmallInteger }"

"/     srcIndex "{ Class: SmallInteger }"

"/     dstIndex "{ Class: SmallInteger }"

     mapSize  "{ Class: SmallInteger }"|

    w := width.

    h := height.

    monoBits := ByteArray uninitializedNew:(((w + 7) // 8) * h).

    map := ByteArray uninitializedNew:256.

    mapSize := colorMap size.

    "

     map entries: 0 for dark entries, 1 for bright entries

    "

    1 to:mapSize do:[:i |

	map at:i put:(colorMap at:i) brightness rounded

    ].

    failed := true.

%{

    register unsigned char *srcPtr, *dstPtr, *mapPtr;

    register __v, __bits, __bitCount;

    register j;

    register i;

    extern OBJ ByteArray;

    if (__isByteArray(_INST(bytes))

     && __isByteArray(map)

     && __isByteArray(monoBits)) {

	failed = false;

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

	dstPtr = _ByteArrayInstPtr(monoBits)->ba_element;

	mapPtr = _ByteArrayInstPtr(map)->ba_element;

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

	    __bitCount = 0;

	    __bits = 0;

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

		__v = mapPtr[*srcPtr++];

		__bits = (__bits<<1) | __v; 

		__bitCount++;

		if (__bitCount == 8) {

		    *dstPtr++ = __bits;

		    __bits = 0;

		    __bitCount = 0;

		}

	    }

	    if (__bitCount != 0) {

		*dstPtr++ = __bits;

	    }

	}

    }

%}

.