Question for RhoSigma

[SMcNeill]

Code: QB64: [Select]

1. DECLARE LIBRARY "QB64GuiTools\dev_framework\GuiAppFrame" 'Do not add .h here !!
2.     FUNCTION FindColor& (BYVAL r&, BYVAL g&, BYVAL b&, BYVAL i&, BYVAL mi&, BYVAL ma&)
3.     'This is a replacement for the _RGB function. It works for upto 8-bit
4.     '(256 colors) images only and needs a valid image. It can limit the
5.     'number of pens to search and uses a better color matching algorithm.
6. END DECLARE
7.  
8.  
9. REDIM SHARED fsNearCol%(&HFFFFFF)
10.  
11. ws = _NEWIMAGE(640, 480, 32) 'A 32 bit screen
12. ts = _NEWIMAGE(640, 480, 256) 'A 256 bit screen to provide the default QB64 palette
13. SCREEN ws
14. FOR i = 1 TO 100 '100 random colors
15.     LINE (RND * 640, RND * 480)-(RND * 640, RND * 480), &HFF000000 + RND * &HFFFFFF, BF
16. NEXT
17.  
18. nh = RemapImageFS&(ws, ts) 'Remap from the 32-bit to the 256 color screen
19. SLEEP 'pause to view original
20. SCREEN nh 'show the remapped 256 color screen
21.  
22. '---------------------------------------------------------------------
23. 'Function: Will remap the colors of any given image to use the palette
24. '          of the given 256 colors (8-bit) destination screen, so that it
25. '          can be displayed on that screen using _PUTIMAGE with as less
26. '          than possible quality loss. For best results this function does
27. '          also apply a Floyd-Steinberg error diffusion matrix on the
28. '          given image to further improve its display quality.
29. '           The original image is not changed, instead the new remapped
30. '          image is returned in a new handle, also _SOURCE & _DEST handles
31. '          are not changed by this function.
32. '           The algorithm is optimized for speed to the fullest extent
33. '          possible on the QB64 language level.
34. '
35. 'Synopsis: rhan& = RemapImageFS& (ohan&, dhan&)
36. '
37. 'Result:   rhan& --> the handle of the new remapped image, check it for
38. '                    validity before use (rhan& < -1, as for any other
39. '                    image handles in QB64)
40. '
41. 'Inputs:   ohan& --> the handle of the original source image to remap,
42. '                    may be an image of any color depth (1-32 bits)
43. '          dhan& --> the handle of the 8-bit destination image, usually
44. '                    the 256 colors screen the image shall be displayed
45. '                    on (for the GuiTools Framework this is "appScreen&"),
46. '                    note that the destinations color palette must already
47. '                    be setup prior calling this function
48. '
49. 'Notes:    For the use of this function a globally shared array must be
50. '          DIMed in an appropriate place: REDIM SHARED fsNearCol%(&HFFFFFF).
51. '          For the GuiTools Framework this is already done within its init
52. '          procedure in file GuiAppFrame.bi.
53. '---------------------------------------------------------------------
54. FUNCTION RemapImageFS& (ohan&, dhan&)
55.     RemapImageFS& = -1 'so far return invalid handle
56.     shan& = ohan& 'avoid side effect on given argument
57.     IF shan& < -1 THEN
58.         '--- check/adjust source image & get new 8-bit image ---
59.         swid% = _WIDTH(shan&): shei% = _HEIGHT(shan&)
60.         IF _PIXELSIZE(shan&) <> 4 THEN
61.             than& = _NEWIMAGE(swid%, shei%, 32)
62.             IF than& >= -1 THEN EXIT FUNCTION
63.             _PUTIMAGE , shan&, than&
64.             shan& = than&
65.         ELSE
66.             than& = -1 'avoid freeing below
67.         END IF
68.         nhan& = _NEWIMAGE(swid%, shei%, 256)
69.         '--- Floyd-Steinberg error distribution arrays ---
70.         rhan& = _NEWIMAGE(swid%, 2, 32) 'these are missused as LONG arrays,
71.         ghan& = _NEWIMAGE(swid%, 2, 32) 'with CHECKING:OFF this is much faster
72.         bhan& = _NEWIMAGE(swid%, 2, 32) 'than real QB64 arrays
73.         '--- curr/next row offsets (for distribution array access) ---
74.         cro% = 0: nro% = swid% * 4 'will be swapped after each pixel row
75.         '--- the matrix values are extended by 16384 to avoid slow floating ---
76.         '--- point ops and to allow for integer storage in the above arrays ---
77.         '--- also it's a power of 2, which may be optimized into a bitshift ---
78.         seven% = (7 / 16) * 16384 'X+1,Y+0 error fraction
79.         three% = (3 / 16) * 16384 'X-1,Y+1 error fraction
80.         five% = (5 / 16) * 16384 'X+0,Y+1 error fraction
81.         one% = (1 / 16) * 16384 'X+1,Y+1 error fraction
82.         '--- if all is good, then start remapping ---
83.         '$CHECKING:OFF
84.         IF nhan& < -1 AND rhan& < -1 AND ghan& < -1 AND bhan& < -1 THEN
85.             _COPYPALETTE dhan&, nhan& 'dest palette to new image
86.             '--- for speed we do direct memory access ---
87.             DIM sbuf AS _MEM: sbuf = _MEMIMAGE(shan&): soff%& = sbuf.OFFSET
88.             DIM nbuf AS _MEM: nbuf = _MEMIMAGE(nhan&): noff%& = nbuf.OFFSET
89.             DIM rbuf AS _MEM: rbuf = _MEMIMAGE(rhan&): roff%& = rbuf.OFFSET
90.             DIM gbuf AS _MEM: gbuf = _MEMIMAGE(ghan&): goff%& = gbuf.OFFSET
91.             DIM bbuf AS _MEM: bbuf = _MEMIMAGE(bhan&): boff%& = bbuf.OFFSET
92.             '--- iterate through pixels ---
93.             FOR y% = 0 TO shei% - 1
94.                 FOR x% = 0 TO swid% - 1
95.                     '--- curr/prev/next pixel offsets ---
96.                     cpo% = x% * 4: ppo% = cpo% - 4: npo% = cpo% + 4
97.                     '--- get pixel ARGB value from source ---
98.                     srgb~& = _MEMGET(sbuf, soff%&, _UNSIGNED LONG)
99.                     '--- add distributed error, shrink by 16384, clear error ---
100.                     '--- current pixel X+0, Y+0 (= cro% (current row offset)) ---
101.                     poff% = cro% + cpo% 'pre-calc full pixel offset
102.                     sr% = ((srgb~& AND &HFF0000~&) \ 65536) + (_MEMGET(rbuf, roff%& + poff%, LONG) \ 16384) 'red
103.                     sg% = ((srgb~& AND &HFF00~&) \ 256) + (_MEMGET(gbuf, goff%& + poff%, LONG) \ 16384) 'green
104.                     sb% = (srgb~& AND &HFF~&) + (_MEMGET(bbuf, boff%& + poff%, LONG) \ 16384) 'blue
105.                     _MEMPUT rbuf, roff%& + poff%, 0 AS LONG 'clearing each single pixel error using _MEMPUT
106.                     _MEMPUT gbuf, goff%& + poff%, 0 AS LONG 'turns out even faster than clearing the entire
107.                     _MEMPUT bbuf, boff%& + poff%, 0 AS LONG 'pixel row using _MEMFILL at the end of the loop
108.                     '--- find nearest color ---
109.                     crgb~& = _RGBA32(sr%, sg%, sb%, 0) 'used for fast value clipping + channel merge
110.                     IF fsNearCol%(crgb~&) > 0 THEN
111.                         npen% = fsNearCol%(crgb~&) - 1 'already known
112.                     ELSE
113.                         npen% = FindColor&(sr%, sg%, sb%, nhan&, 24, 255 - guiReservedPens%) 'not known, find one
114.                         fsNearCol%(crgb~&) = npen% + 1 'save for later use
115.                     END IF
116.                     '--- put colormapped pixel to dest ---
117.                     _MEMPUT nbuf, noff%&, npen% AS _UNSIGNED _BYTE
118.                     '------------------------------------------
119.                     '--- Floyd-Steinberg error distribution ---
120.                     '------------------------------------------
121.                     '--- You may comment this block out, to see the
122.                     '--- result without applied FS matrix.
123.                     '-----
124.                     '--- get dest palette RGB value, calc error to clipped source ---
125.                     nrgb~& = _PALETTECOLOR(npen%, nhan&)
126.                     er% = ((crgb~& AND &HFF0000~&) - (nrgb~& AND &HFF0000~&)) \ 65536
127.                     eg% = ((crgb~& AND &HFF00~&) - (nrgb~& AND &HFF00~&)) \ 256
128.                     eb% = (crgb~& AND &HFF~&) - (nrgb~& AND &HFF~&)
129.                     '--- distribute error according to FS matrix ---
130.                     IF x% > 0 THEN
131.                         '--- X-1, Y+1 (= nro% (next row offset)) ---
132.                         poff% = nro% + ppo% 'pre-calc full pixel offset
133.                         _MEMPUT rbuf, roff%& + poff%, _MEMGET(rbuf, roff%& + poff%, LONG) + (er% * three%) AS LONG 'red
134.                         _MEMPUT gbuf, goff%& + poff%, _MEMGET(gbuf, goff%& + poff%, LONG) + (eg% * three%) AS LONG 'green
135.                         _MEMPUT bbuf, boff%& + poff%, _MEMGET(bbuf, boff%& + poff%, LONG) + (eb% * three%) AS LONG 'blue
136.                     END IF
137.                     '--- X+0, Y+1 (= nro% (next row offset)) ---
138.                     poff% = nro% + cpo% 'pre-calc full pixel offset
139.                     _MEMPUT rbuf, roff%& + poff%, _MEMGET(rbuf, roff%& + poff%, LONG) + (er% * five%) AS LONG 'red
140.                     _MEMPUT gbuf, goff%& + poff%, _MEMGET(gbuf, goff%& + poff%, LONG) + (eg% * five%) AS LONG 'green
141.                     _MEMPUT bbuf, boff%& + poff%, _MEMGET(bbuf, boff%& + poff%, LONG) + (eb% * five%) AS LONG 'blue
142.                     IF x% < (swid% - 1) THEN
143.                         '--- X+1, Y+0 (= cro% (current row offset)) ---
144.                         poff% = cro% + npo% 'pre-calc full pixel offset
145.                         _MEMPUT rbuf, roff%& + poff%, _MEMGET(rbuf, roff%& + poff%, LONG) + (er% * seven%) AS LONG 'red
146.                         _MEMPUT gbuf, goff%& + poff%, _MEMGET(gbuf, goff%& + poff%, LONG) + (eg% * seven%) AS LONG 'green
147.                         _MEMPUT bbuf, boff%& + poff%, _MEMGET(bbuf, boff%& + poff%, LONG) + (eb% * seven%) AS LONG 'blue
148.                         '--- X+1, Y+1 (= nro% (next row offset)) ---
149.                         poff% = nro% + npo% 'pre-calc full pixel offset
150.                         _MEMPUT rbuf, roff%& + poff%, _MEMGET(rbuf, roff%& + poff%, LONG) + (er% * one%) AS LONG 'red
151.                         _MEMPUT gbuf, goff%& + poff%, _MEMGET(gbuf, goff%& + poff%, LONG) + (eg% * one%) AS LONG 'green
152.                         _MEMPUT bbuf, boff%& + poff%, _MEMGET(bbuf, boff%& + poff%, LONG) + (eb% * one%) AS LONG 'blue
153.                     END IF
154.                     '------------------------------------------
155.                     '--- End of FS ----------------------------
156.                     '------------------------------------------
157.                     noff%& = noff%& + 1 'next dest pixel
158.                     soff%& = soff%& + 4 'next source pixel
159.                 NEXT x%
160.                 tmp% = cro%: cro% = nro%: nro% = tmp% 'exchange distribution array row offsets
161.             NEXT y%
162.             '--- memory cleanup ---
163.             _MEMFREE bbuf
164.             _MEMFREE gbuf
165.             _MEMFREE rbuf
166.             _MEMFREE nbuf
167.             _MEMFREE sbuf
168.             '--- set result ---
169.             RemapImageFS& = nhan&
170.             nhan& = -1 'avoid freeing below
171.         END IF
172.         $CHECKING:ON
173.         '--- remapping done or error, cleanup remains ---
174.         IF bhan& < -1 THEN _FREEIMAGE bhan&
175.         IF ghan& < -1 THEN _FREEIMAGE ghan&
176.         IF rhan& < -1 THEN _FREEIMAGE rhan&
177.         IF nhan& < -1 THEN _FREEIMAGE nhan&
178.         IF than& < -1 THEN _FREEIMAGE than&
179.     END IF
180. END FUNCTION
181.  

Playing around a bit with the Floyd-Steinberg color reduction routine from your GUI Framework library, I came up with this little set of code.  (You might want to add a  note that DECLARE LIBRARY is necessary for the FindColor& Function to be found and work properly, since it's called in the subroutine.)

Question: Is there some way to remove those dots that the converted image creates? We're only using 100 colors for the screen palette (101 if we consider 0 red, 0 green, 0 blue, 0 alpha (transparent) as a color).  Shouldn't this convert to the closest palette match without those artifacts?  What's the dots in there for?  And is there a way to remove them?

All I was really looking for, was a simple means to convert 32-bit images down to 256 color images, so that I could then save them in a suitable GIF format.

[SMcNeill]

As long as the total color palette is less than 256 colors, I can use your routine to gather the palette, and then assign the original values to a 256-color image without any stray artifacts being required at all, like so:

Code: QB64: [Select]

1. DECLARE LIBRARY "QB64GuiTools\dev_framework\GuiAppFrame" 'Do not add .h here !!
2.     FUNCTION FindColor& (BYVAL r&, BYVAL g&, BYVAL b&, BYVAL i&, BYVAL mi&, BYVAL ma&)
3.     'This is a replacement for the _RGB function. It works for upto 8-bit
4.     '(256 colors) images only and needs a valid image. It can limit the
5.     'number of pens to search and uses a better color matching algorithm.
6. END DECLARE
7.  
8.  
9. REDIM SHARED fsNearCol%(&HFFFFFF)
10.  
11. ws = _NEWIMAGE(640, 480, 32) 'A 32 bit screen
12. ts = _NEWIMAGE(640, 480, 256) 'A 256 bit screen to provide the default QB64 palette
13. SCREEN ws
14. FOR x = 0 TO 639 STEP 64 '10 steps
15.     FOR y = 0 TO 479 STEP 48 '10 steps = 100 total boxes
16.         LINE (x, y)-STEP(64, 48), &HFF000000 + RND * &HFFFFFF, BF
17.     NEXT
18. NEXT
19. SLEEP 'pause to view original
20.  
21.  
22. nh = RemapImageFS&(ws, ts) 'Remap from the 32-bit to the 256 color screen
23. SCREEN nh 'show the remapped 256 color screen
24. SLEEP 'pause so we can see it
25.  
26. nh2 = Image32To256(ws, nh) 'Remap from the 32-bit to the 256 color screen, using the palette chosen in RemapImageFS
27. SCREEN nh2 'show the remapped 256 color screen
28. SLEEP 'pause so we can see it
29.  
30.  
31. '---------------------------------------------------------------------
32. 'Function: Will remap the colors of any given image to use the palette
33. '          of the given 256 colors (8-bit) destination screen, so that it
34. '          can be displayed on that screen using _PUTIMAGE with as less
35. '          than possible quality loss. For best results this function does
36. '          also apply a Floyd-Steinberg error diffusion matrix on the
37. '          given image to further improve its display quality.
38. '           The original image is not changed, instead the new remapped
39. '          image is returned in a new handle, also _SOURCE & _DEST handles
40. '          are not changed by this function.
41. '           The algorithm is optimized for speed to the fullest extent
42. '          possible on the QB64 language level.
43. '
44. 'Synopsis: rhan& = RemapImageFS& (ohan&, dhan&)
45. '
46. 'Result:   rhan& --> the handle of the new remapped image, check it for
47. '                    validity before use (rhan& < -1, as for any other
48. '                    image handles in QB64)
49. '
50. 'Inputs:   ohan& --> the handle of the original source image to remap,
51. '                    may be an image of any color depth (1-32 bits)
52. '          dhan& --> the handle of the 8-bit destination image, usually
53. '                    the 256 colors screen the image shall be displayed
54. '                    on (for the GuiTools Framework this is "appScreen&"),
55. '                    note that the destinations color palette must already
56. '                    be setup prior calling this function
57. '
58. 'Notes:    For the use of this function a globally shared array must be
59. '          DIMed in an appropriate place: REDIM SHARED fsNearCol%(&HFFFFFF).
60. '          For the GuiTools Framework this is already done within its init
61. '          procedure in file GuiAppFrame.bi.
62. '---------------------------------------------------------------------
63. FUNCTION RemapImageFS& (ohan&, dhan&)
64.     RemapImageFS& = -1 'so far return invalid handle
65.     shan& = ohan& 'avoid side effect on given argument
66.     IF shan& < -1 THEN
67.         '--- check/adjust source image & get new 8-bit image ---
68.         swid% = _WIDTH(shan&): shei% = _HEIGHT(shan&)
69.         IF _PIXELSIZE(shan&) <> 4 THEN
70.             than& = _NEWIMAGE(swid%, shei%, 32)
71.             IF than& >= -1 THEN EXIT FUNCTION
72.             _PUTIMAGE , shan&, than&
73.             shan& = than&
74.         ELSE
75.             than& = -1 'avoid freeing below
76.         END IF
77.         nhan& = _NEWIMAGE(swid%, shei%, 256)
78.         '--- Floyd-Steinberg error distribution arrays ---
79.         rhan& = _NEWIMAGE(swid%, 2, 32) 'these are missused as LONG arrays,
80.         ghan& = _NEWIMAGE(swid%, 2, 32) 'with CHECKING:OFF this is much faster
81.         bhan& = _NEWIMAGE(swid%, 2, 32) 'than real QB64 arrays
82.         '--- curr/next row offsets (for distribution array access) ---
83.         cro% = 0: nro% = swid% * 4 'will be swapped after each pixel row
84.         '--- the matrix values are extended by 16384 to avoid slow floating ---
85.         '--- point ops and to allow for integer storage in the above arrays ---
86.         '--- also it's a power of 2, which may be optimized into a bitshift ---
87.         seven% = (7 / 16) * 16384 'X+1,Y+0 error fraction
88.         three% = (3 / 16) * 16384 'X-1,Y+1 error fraction
89.         five% = (5 / 16) * 16384 'X+0,Y+1 error fraction
90.         one% = (1 / 16) * 16384 'X+1,Y+1 error fraction
91.         '--- if all is good, then start remapping ---
92.         $CHECKING:OFF
93.         IF nhan& < -1 AND rhan& < -1 AND ghan& < -1 AND bhan& < -1 THEN
94.             _COPYPALETTE dhan&, nhan& 'dest palette to new image
95.             '--- for speed we do direct memory access ---
96.             DIM sbuf AS _MEM: sbuf = _MEMIMAGE(shan&): soff%& = sbuf.OFFSET
97.             DIM nbuf AS _MEM: nbuf = _MEMIMAGE(nhan&): noff%& = nbuf.OFFSET
98.             DIM rbuf AS _MEM: rbuf = _MEMIMAGE(rhan&): roff%& = rbuf.OFFSET
99.             DIM gbuf AS _MEM: gbuf = _MEMIMAGE(ghan&): goff%& = gbuf.OFFSET
100.             DIM bbuf AS _MEM: bbuf = _MEMIMAGE(bhan&): boff%& = bbuf.OFFSET
101.             '--- iterate through pixels ---
102.             FOR y% = 0 TO shei% - 1
103.                 FOR x% = 0 TO swid% - 1
104.                     '--- curr/prev/next pixel offsets ---
105.                     cpo% = x% * 4: ppo% = cpo% - 4: npo% = cpo% + 4
106.                     '--- get pixel ARGB value from source ---
107.                     srgb~& = _MEMGET(sbuf, soff%&, _UNSIGNED LONG)
108.                     '--- add distributed error, shrink by 16384, clear error ---
109.                     '--- current pixel X+0, Y+0 (= cro% (current row offset)) ---
110.                     poff% = cro% + cpo% 'pre-calc full pixel offset
111.                     sr% = ((srgb~& AND &HFF0000~&) \ 65536) + (_MEMGET(rbuf, roff%& + poff%, LONG) \ 16384) 'red
112.                     sg% = ((srgb~& AND &HFF00~&) \ 256) + (_MEMGET(gbuf, goff%& + poff%, LONG) \ 16384) 'green
113.                     sb% = (srgb~& AND &HFF~&) + (_MEMGET(bbuf, boff%& + poff%, LONG) \ 16384) 'blue
114.                     _MEMPUT rbuf, roff%& + poff%, 0 AS LONG 'clearing each single pixel error using _MEMPUT
115.                     _MEMPUT gbuf, goff%& + poff%, 0 AS LONG 'turns out even faster than clearing the entire
116.                     _MEMPUT bbuf, boff%& + poff%, 0 AS LONG 'pixel row using _MEMFILL at the end of the loop
117.                     '--- find nearest color ---
118.                     crgb~& = _RGBA32(sr%, sg%, sb%, 0) 'used for fast value clipping + channel merge
119.                     IF fsNearCol%(crgb~&) > 0 THEN
120.                         npen% = fsNearCol%(crgb~&) - 1 'already known
121.                     ELSE
122.                         npen% = FindColor&(sr%, sg%, sb%, nhan&, 24, 255 - guiReservedPens%) 'not known, find one
123.                         fsNearCol%(crgb~&) = npen% + 1 'save for later use
124.                     END IF
125.                     '--- put colormapped pixel to dest ---
126.                     _MEMPUT nbuf, noff%&, npen% AS _UNSIGNED _BYTE
127.                     '------------------------------------------
128.                     '--- Floyd-Steinberg error distribution ---
129.                     '------------------------------------------
130.                     '--- You may comment this block out, to see the
131.                     '--- result without applied FS matrix.
132.                     '-----
133.                     '--- get dest palette RGB value, calc error to clipped source ---
134.                     nrgb~& = _PALETTECOLOR(npen%, nhan&)
135.                     er% = ((crgb~& AND &HFF0000~&) - (nrgb~& AND &HFF0000~&)) \ 65536
136.                     eg% = ((crgb~& AND &HFF00~&) - (nrgb~& AND &HFF00~&)) \ 256
137.                     eb% = (crgb~& AND &HFF~&) - (nrgb~& AND &HFF~&)
138.                     '--- distribute error according to FS matrix ---
139.                     IF x% > 0 THEN
140.                         '--- X-1, Y+1 (= nro% (next row offset)) ---
141.                         poff% = nro% + ppo% 'pre-calc full pixel offset
142.                         _MEMPUT rbuf, roff%& + poff%, _MEMGET(rbuf, roff%& + poff%, LONG) + (er% * three%) AS LONG 'red
143.                         _MEMPUT gbuf, goff%& + poff%, _MEMGET(gbuf, goff%& + poff%, LONG) + (eg% * three%) AS LONG 'green
144.                         _MEMPUT bbuf, boff%& + poff%, _MEMGET(bbuf, boff%& + poff%, LONG) + (eb% * three%) AS LONG 'blue
145.                     END IF
146.                     '--- X+0, Y+1 (= nro% (next row offset)) ---
147.                     poff% = nro% + cpo% 'pre-calc full pixel offset
148.                     _MEMPUT rbuf, roff%& + poff%, _MEMGET(rbuf, roff%& + poff%, LONG) + (er% * five%) AS LONG 'red
149.                     _MEMPUT gbuf, goff%& + poff%, _MEMGET(gbuf, goff%& + poff%, LONG) + (eg% * five%) AS LONG 'green
150.                     _MEMPUT bbuf, boff%& + poff%, _MEMGET(bbuf, boff%& + poff%, LONG) + (eb% * five%) AS LONG 'blue
151.                     IF x% < (swid% - 1) THEN
152.                         '--- X+1, Y+0 (= cro% (current row offset)) ---
153.                         poff% = cro% + npo% 'pre-calc full pixel offset
154.                         _MEMPUT rbuf, roff%& + poff%, _MEMGET(rbuf, roff%& + poff%, LONG) + (er% * seven%) AS LONG 'red
155.                         _MEMPUT gbuf, goff%& + poff%, _MEMGET(gbuf, goff%& + poff%, LONG) + (eg% * seven%) AS LONG 'green
156.                         _MEMPUT bbuf, boff%& + poff%, _MEMGET(bbuf, boff%& + poff%, LONG) + (eb% * seven%) AS LONG 'blue
157.                         '--- X+1, Y+1 (= nro% (next row offset)) ---
158.                         poff% = nro% + npo% 'pre-calc full pixel offset
159.                         _MEMPUT rbuf, roff%& + poff%, _MEMGET(rbuf, roff%& + poff%, LONG) + (er% * one%) AS LONG 'red
160.                         _MEMPUT gbuf, goff%& + poff%, _MEMGET(gbuf, goff%& + poff%, LONG) + (eg% * one%) AS LONG 'green
161.                         _MEMPUT bbuf, boff%& + poff%, _MEMGET(bbuf, boff%& + poff%, LONG) + (eb% * one%) AS LONG 'blue
162.                     END IF
163.                     '------------------------------------------
164.                     '--- End of FS ----------------------------
165.                     '------------------------------------------
166.                     noff%& = noff%& + 1 'next dest pixel
167.                     soff%& = soff%& + 4 'next source pixel
168.                 NEXT x%
169.                 tmp% = cro%: cro% = nro%: nro% = tmp% 'exchange distribution array row offsets
170.             NEXT y%
171.             '--- memory cleanup ---
172.             _MEMFREE bbuf
173.             _MEMFREE gbuf
174.             _MEMFREE rbuf
175.             _MEMFREE nbuf
176.             _MEMFREE sbuf
177.             '--- set result ---
178.             RemapImageFS& = nhan&
179.             nhan& = -1 'avoid freeing below
180.         END IF
181.         $CHECKING:ON
182.         '--- remapping done or error, cleanup remains ---
183.         IF bhan& < -1 THEN _FREEIMAGE bhan&
184.         IF ghan& < -1 THEN _FREEIMAGE ghan&
185.         IF rhan& < -1 THEN _FREEIMAGE rhan&
186.         IF nhan& < -1 THEN _FREEIMAGE nhan&
187.         IF than& < -1 THEN _FREEIMAGE than&
188.     END IF
189. END FUNCTION
190.  
191. FUNCTION Image32To256 (image&, image2&)
192.     DIM o AS _OFFSET
193.     DIM a AS _UNSIGNED _BYTE, r AS _UNSIGNED _BYTE
194.     DIM g AS _UNSIGNED _BYTE, b AS _UNSIGNED _BYTE
195.  
196.     Image32To256 = _NEWIMAGE(_WIDTH(image&), _HEIGHT(image&), 256)
197.     DIM m(1) AS _MEM: m(0) = _MEMIMAGE(image&): m(1) = _MEMIMAGE(Image32To256)
198.     DO
199.         _MEMGET m(0), m(0).OFFSET + o + 3, a
200.         _MEMGET m(0), m(0).OFFSET + o + 2, r
201.         _MEMGET m(0), m(0).OFFSET + o + 1, g
202.         _MEMGET m(0), m(0).OFFSET + o + 0, b
203.         _MEMPUT m(1), m(1).OFFSET + o \ 4, _RGBA(r, g, b, a, image2&) AS _UNSIGNED _BYTE
204.         o = o + 4
205.     LOOP UNTIL o >= m(0).SIZE
206. END FUNCTION

A hybrid of this method for <= 256 colors, and your method if > 256 colors, might end up being the way I go when having to convert a 32-bit screen down to a 256 color image.  ;)

[RhoSigma]

Question: Is there some way to remove those dots that the converted image creates? We're only using 100 colors for the screen palette (101 if we consider 0 red, 0 green, 0 blue, 0 alpha (transparent) as a color).  Shouldn't this convert to the closest palette match without those artifacts?  What's the dots in there for?  And is there a way to remove them?

Those dots are comming from the actual Floyd-Steinberg error distribution. The algorithm uses all allowed colors (see note below) in the target palette and tries to keep the original 32-bit color as close as possible using this dithering effect. This effect mostly comes up for those clipart-like images where large parts have the same color, it's usually not that obvious in real color (digi cam) pictures.

However, if you just want to generate a closest color image, then you may waive to the Floyd-Steinberg dithering simply by commenting (or deleting) lines 118-156.

Note to allowed colors:
here is a better prototype of the FindColor&() function,
  FUNCTION FindColor& (BYVAL red&, BYVAL green&, BYVAL blue&, BYVAL image&, BYVAL minColor&, BYVAL maxColor&)
as you see you've a min/max color parameter to limit the palette entries to search for a match. You can give -1 for unused limits. Set both min & max to -1 will search the entire palette 0-255, hence same as _RGB does.

That's what FindColor&() basically is, it's a copy of the matchcol() function (from libqb), which I've tweaked a bit to allow for the pen limits and using a (IMHO) better color matching method.
So in general, if you don't need the limit parameters, then you may exchange the FindColor&() call by a call to _RGB, then you don't need the DECLARE LIBRARY thing either anymore.

The fsNearCol%() array is mainly for speedup purposes in GuiTools, it saves once found color matches, to save some time when processing additional images, note that this array must be cleared (REDIMed) when the target palette changes. For your purpose you can probably wave to it too, by commenting (deleting) the lines 110-115 except 113 (the FindColor&()/_RGB call).

EDIT: line numbers according to your first post :)

[SMcNeill]

One thing I did notice, which you might consider altering in the routines:

    IF shan& < -1 THEN

I’ve changed those to the following, for my personal needs (and library usage):

    IF shan& < -1 OR shan& = 0 THEN


Reason?

0 is often how we refer to the current view screen.

SCREEN _NEWIMAGE(640,480,32)
...do stuff

NewScreen = RemapImageFS(0, 256ColorIndexScreen)

^ That 0 there will currently skip the routine and return us an invalid handle.  With the change, it’ll make you a 256 color screen of the current display, and then return that new handle back to you.

[RhoSigma]

Yes, that makes sense, will adjust this in GuiTools for the next release...