Using palettes or Indexed color scheme is pretty exotic these days where most of graphic cards, printers and other devices nicely render full pixel formats of 24 bits per pixel or more. So, I'm curious why you may need it. Are you sure you really need it?
If you really need to improve performance of the process you describe, the remedy could be very typical for performance problem of the search. This is using some
redundancy (
http://en.wikipedia.org/wiki/Redundancy_%28engineering%29[
^]) and some
caching algorithm (
http://en.wikipedia.org/wiki/Caching_algorithm[
^]).
You can create some intermediate
lookup table used to narrow down the search in one or two steps. Here is a simple example: you can divide all the RGB color space in smaller cubes. The cube can be positioned using the record
RStart, GStart, BStart, Size; you can make all cubes of the same size, so
Size will be a constant, and the structure will be just index
IndexR, IndexG, IndexB. Each input color can be calculated as belonging to some cube in one step. To find a point in a palette, create a lookup structure in the form of dictionary
System.Collections.Generic.Dictionary<CubeIndex, PalettPointList>, where
CubeIndex is the index if the cube described above; and
PalettPointList = System.Collections.Generic.Dictionary<Color> should list all the palette points getting into the list. You should select the size of the cube the way each cube contained at least one palette point, but not too many palette points in each cube. If the palette is very non-uniform, you can possibly optimize the lookup structure by using non-constant cube size and/or using parallelepipeds instead of cubes or possibly by introducing more them one level of hierarchy.
You need to play with the set of your palettes and the algorithm to figure our the way to get caching mechanism close to the optimum and meed your performance requirements.
—SA
Submit an article or tip