"

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

asGray8FormOn:aDevice

    "return an 8-bit greyForm from the 8-bit receiver image.

     Redefined, since only a translation has to be done here."

    |greyBits map

     mapSize "{ Class: SmallInteger }"|

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

    map := ByteArray uninitializedNew:256.

    1 to:256 do:[:i |

        map at:i put:((self colorFromValue:(i-1)) brightness * 255) rounded

    ].

"/    mapSize := colorMap size.

"/

"/    1 to:mapSize do:[:i |

"/        map at:i put:((colorMap at:i) brightness * 255) rounded

"/    ].

    bytes expandPixels:8         "xlate only"

                width:width 

               height:height

                 into:greyBits

              mapping:map.

    ^ self makeDeviceGrayPixmapOn:aDevice depth:8 fromArray:greyBits

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

    "Created: 14.6.1996 / 15:23:09 / cg"

!

asGrayFormOn:aDevice

    "get a gray device form.

     Redefined, since we can do it with simple translate, 

     if the depth matches my depth."

    (aDevice visualType == #StaticGray) ifTrue:[

        (aDevice depth == 8) ifTrue:[

            ^ self asGray8FormOn:aDevice

        ].

    ].

    ^ super asGrayFormOn:aDevice

    "Created: 10.6.1996 / 18:51:19 / cg"

    "Modified: 10.6.1996 / 18:54:36 / cg"

!

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

               asFloydSteinbergDitheredDepth8FormOn:aDevice 

               colors:Color fixColors 

               nRed:Color numFixRed

               nGreen:Color numFixGreen

               nBlue:Color numFixBlue.

        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.

    "

     first, try to get the exact colors ...

    "

    bitsPerRGB := aDevice bitsPerRGB.

    shift := (8 - bitsPerRGB) negated.

    m := (1 bitShift:bitsPerRGB) - 1.

    div := m asFloat.

    fit := true.

    scale := 100.0 / div.       "to scale 0..255 into 0.0 .. 100.0"

    lastOK := 0.

    gcRound := 0.

    usedColors do:[:aColorIndex |

        |devColor color

         r        "{Class: SmallInteger }"

         g        "{Class: SmallInteger }"

         b        "{Class: SmallInteger }"

        fit ifTrue:[

            mapIndex := aColorIndex + 1.

            color := colorMap at:mapIndex.

                "wow - an immediate hit"

                devColor := color

            ] ifFalse:[

                devColor := color exactOn:aDevice.

                devColor isNil ifTrue:[

                    "

                     could not allocate color - on the first round, do a GC to flush 

                     unused colors - this may help if some colors where locked by 

                     already free images.

                    "

                    gcRound == 0 ifTrue:[

                        ObjectMemory scavenge; finalize.

                        devColor := color exactOn:aDevice.

                        gcRound := 1

                    ].

                    devColor isNil ifTrue:[

                        gcRound == 1 ifTrue:[

                            CollectGarbageWhenRunningOutOfColors ifTrue:[

                                'D8IMAGE: force GC for possible color reclamation.' infoPrintNL.

                                ObjectMemory incrementalGC; finalize.

                                devColor := color exactOn:aDevice.

                            ].    

                            gcRound := 2

                        ]

                    ]

                ].

            ].

            (devColor notNil and:[devColor colorId notNil]) ifTrue:[

                imgMap at:mapIndex put:devColor.

                lastOK := lastOK + 1.

            ] ifFalse:[

                fit := false

            ]

        ]

    ].

    fit ifFalse:[

"/        |tree|

"/

"/        "/ first, create an octTree containing colors which we got ...

"/        tree := ColorOctree new.

"/

"/        usedColors from:1 to:lastOK do:[:aColorIndex |

"/            tree insert:(colorMap at:aColorIndex + 1).

"/        ].

"/

"/        "/ then, remap remaining, using nearest from those already allocated

"/

"/        usedColors from:(lastOK+1) to:(usedColors size) do:[:aColorIndex |      

"/            |mapIndex|

"/

"/            mapIndex := aColorIndex + 1.

"/            imgMap at:mapIndex put:(tree findBest:(colorMap at:mapIndex))

"/        ].

        "

         again, this time allow wrong colors (loop while increasing allowed error)

        "

        [fit] whileFalse:[

            fit := true.

            usedColors from:(lastOK+1) to:(usedColors size) do:[:aColorIndex |

                |devColor color

                 r        "{Class: SmallInteger }"

                 g        "{Class: SmallInteger }"

                 b        "{Class: SmallInteger }"

                 mapIndex "{Class: SmallInteger }"

                 rMask    "{Class: SmallInteger }"

                 gMask    "{Class: SmallInteger }"

                 bMask    "{Class: SmallInteger }"|

                fit ifTrue:[

                    gMask := bMask := rMask := m.

                    mapIndex := aColorIndex + 1.

                    color := colorMap at:mapIndex.

                    color := Color red:((r bitShift:shift) bitAnd:rMask) * scale

                                 green:((g bitShift:shift) bitAnd:gMask) * scale

                                  blue:((b bitShift:shift) bitAnd:bMask) * scale.

                        "wow - an immediate hit"

                    ] ifFalse:[

                        devColor isNil ifTrue:[

                            "

                             no free color - on the first round, do a GC to flush unused

                             colors - this may help if some colors where locked by already

                             free images.

                            "

                            gcRound == 0 ifTrue:[

                                ObjectMemory scavenge; finalize.

                                gcRound := 1

                            ].

                            devColor isNil ifTrue:[

                                gcRound == 1 ifTrue:[

                                    CollectGarbageWhenRunningOutOfColors ifTrue:[

                                        'D8IMAGE: force GC for possible color reclamation.' infoPrintNL.

                                        ObjectMemory incrementalGC; finalize.

                                    ].

                                    gcRound := 2

                                ]

                            ]

                        ].

                    ].

                    (devColor notNil and:[devColor colorId notNil]) ifTrue:[

                        imgMap at:mapIndex put:devColor.

                        lastOK := lastOK + 1.

                    ] ifFalse:[

                        fit := false

                    ]

                ].

            ].

            error := error * 2.

                "

                 break out, if the error becomes too big.

                "

                'D8IMAGE: hard color allocation problem - revert to b&w' infoPrintNL.

                "

                 map to b&w as a last fallback.

                 (should really do a dither here)

                "

                usedColors from:(lastOK+1) to:(usedColors size) do:[:aColorIndex |

                    |color

                     mapIndex "{ Class: SmallInteger }"|

                    mapIndex := aColorIndex + 1.

                    color := colorMap at:mapIndex.

                        color := Color white.

                    ] ifFalse:[

                        color := Color black.

                    ].

                    imgMap at:mapIndex put:(color on:aDevice).

                ].

                fit := true.

            ]

        ].

            'D8IMAGE: not enough colors for a reasonable image' infoPrintNL

        ] ifFalse:[

            'D8IMAGE: not enough colors for exact picture' infoPrintNL.

        ]

    ].

    "

     create translation map (from image colors to allocated colorIds)

    "

    map := ByteArray new:256.

    1 to:imgMap size do:[:i |

        |clr|

        (clr := imgMap at:i) notNil ifTrue:[

            map at:i put:clr colorId

        ]

    ].

    "

     does the device support 8-bit images ?

    "

    deviceDepth := aDevice depth.

    deviceDepth == 8 ifTrue:[

        has8BitImage := true.

    ] ifFalse:[

        has8BitImage := false.

        aDevice supportedImageFormats do:[:fmt |

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

                has8BitImage := true.

            ]

        ]

    ].

    "

     finally, create a form on the device and copy (& translate)

     the pixel values

    "

    has8BitImage ifTrue:[

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

        bytes expandPixels:8         "xlate only"

                    width:width 

                   height:height

                     into:pseudoBits

                  mapping:map.

        map := nil.

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

        f isNil ifTrue:[^ nil].

        f colorMap:imgMap. 

        f initGC.

        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

    ].

    "

     slow fall back: convert into appropriate depth image,

     by looping over each pixel individually

    "

    newImage := (Image implementorForDepth:deviceDepth) new.

    newImage width:width.

    newImage height:height.

    newImage bits:(ByteArray uninitializedNew:(height * newImage bytesPerRow)).

    0 to:height-1 do:[:row |

        0 to:width-1 do:[:col |

            pxl := self valueAtX:col y:row.

            newImage atX:col y:row putValue:(map at:pxl)

        ]

    ].

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

    f isNil ifTrue:[^ nil].

    f colorMap:imgMap. 

    f initGC.

    aDevice drawBits:(newImage bits) 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

! !

!Depth8Image methodsFor:'dither helpers'!

orderedDitheredBitsWithDitherMatrix:ditherMatrix ditherWidth:dW depth:depth

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