Given the human visual systems "preference" for luminance information, one can design an image compression system around YCC colour space. Consider an RGB image with Nx horizontal pixels and Ny vertical pixels. If each pixel is represented as one byte the the image size in bytes is Nx Ny 3. Consider storing the image in YCC space where the luminance channel Y is stored as one byte for each pixel but the two chrominance channels are only stored for each block of say 4x4 pixels. The resulting image would be Nx Ny + 2 (Nx/4 + Ny/4), this is an image 2 and 2/3rds smaller. Put another way, instead of using on average 3 bytes (24 bits) per pixel we would only be using 9 bits per pixel.

Note the chrominance is averaged over each 4x4 block. There is nothing particularly special about a 4x4 block instead of a 3x3 or 5x5 or other sizes. A 2x2 by two results in a factor 2 saving, a 3x3 grid results in a saving of 2.45. Larger grids give ever decreasing rates of return and soon impact on the image quality.

   Y  =  0.2989 R + 0.5866 G + 0.1145 B
   Cb = -0.1687 R - 0.3312 G + 0.5000 B
   Cr =  0.5000 R - 0.4183 G - 0.0816 B

RGB values are normally on the scale of 0 to 1, or since they are stored as unsigned single bytes, 0 to 255. The resulting luminance value is also on the scale of 0 to 255, the chrominance values need 127.5 added to them so they can saved in an unsigned byte.

Of course when the YCC values are turned back into RGB, then 127.5 must be first subtracted from the two chrominance values. The reverse transform is

   R = Y             + 1.4022 Cr
   G = Y - 0.3456 Cb - 0.7145 Cr
   B = Y + 1.7710 Cb

The full chrominance range of +-0.5 maps into a larger colour space than supported by RGB. The above equations can yield RGB values outside the 0 to 255 (or 0 to 1) range, these typically relate to very light or dark colours. The RGB values should be clipped so they lie within the allowed range after the transform from YCC to RGB is calculated.

An image compressed this way is obviously degraded but could one tell the difference? Below are two images, the one on the left uses 24 bits per pixel and the one on the right uses 9 bits per pixel as described above.

Before The above is the original image that is used as an example in what follows. It was captured as a single from a digital movie camera.

After The above is the image that results from a 1 byte Y channel and 4x4 subsampled Cr, Cc channels.

Y channel

First C channel (Cr)

Second C channel (Cb)

The compression scheme above is most noticeable when there are rapid changes in hue but little change in luminance, in this case the 4x4 subsampling of the Cr and Cb channels is most noticeable. For images of real world scenes this happens surprisingly rarely, in the before and after example above it is virtually impossible to zoom in and find examples of the 4x4 subsampling. Similarly one would not generally use this sort of compression for low colour images, in that case other compression techniques are available.

RGB -> CIE XYZitu (D65) X = 0.431 R + 0.342 G + 0.178 B Y = 0.222 R + 0.707 G + 0.071 B Z = 0.020 R + 0.130 G + 0.939 B

CIE XYZitu (D65) -> RGB R = 3.063 X - 1.393 Y - 0.476 Z G = -0.969 X + 1.876 Y + 0.042 Z B = 0.068 X - 0.229 Y + 1.069 Z

RGB -> CIE XYZrec601-1 (C illuminant) X = 0.607 R + 0.174 G + 0.200 B Y = 0.299 R + 0.587 G + 0.114 B Z = 0.000 R + 0.066 G + 1.116 B

CIE XYZrec601-1 (C illuminant) -> RGB R = 1.910 X - 0.532 Y - 0.288 Z G = -0.985 X + 1.999 Y - 0.028 Z B = 0.058 X - 0.118 Y + 0.898 Z

RGB -> CIE XYZccir709 (D65) X = 0.412 R + 0.358 G + 0.180 B Y = 0.213 R + 0.715 G + 0.072 B Z = 0.019 R + 0.119 G + 0.950 B

CIE XYZccir709 (D65) -> RGB R = 3.241 X - 1.537 Y - 0.499 Z G = -0.969 X + 1.876 Y + 0.042 Z B = 0.056 X - 0.204 Y + 1.057 Z

PAL television standard

RGB -> YUV Y = 0.299 R + 0.587 G + 0.114 B U = -0.147 R - 0.289 G + 0.436 B V = 0.615 R - 0.515 G - 0.100 B

YUV -> RGB R = Y + 0.000 U + 1.140 V G = Y - 0.396 U - 0.581 V B = Y + 2.029 U + 0.000 V

NTSC television standard

RGB -> YIQ Y = 0.299 R + 0.587 G + 0.114 B I = 0.596 R - 0.274 G - 0.322 B Q = 0.212 R - 0.523 G + 0.311 B

YIQ -> RGB R = Y + 0.956 I + 0.621 Q G = Y - 0.272 I - 0.647 Q B = Y - 1.105 I + 1.702 Q

References

Color Monitor Colorimetry. SMPTE Recommended Practice RP 145-1987

CIE Colorimetry. Official recommendations of the International Commission on Illumination, Publication 15.2 1986

Effective Color Displays. Theory and Practice. D. Travis, Academic Press, 1991. ISBN 0-12-697690-2

Measuring Colour (Second edition). R.W.G. Hunt, Ellis Horwood 1991, ISBN 0-13-567686-x

Precision requirements for digital colour reproduction. M. Stokes, M.D. Fairchild, R.S. Berns, ACM Transactions on graphics, v11 n4 1992

The Reproduction of Colour in Photography, Printing and Television. R.W.G. Hunt, Fountain Press, Tolworth, England, 1987

This note introduces the most commonly used colour ramps for mapping colours onto a range of scalar values as is often required in data visualisation. The colour space will be based upon the RGB system.

The most basic mapping of some scalar value to a colour ramp is to use either an intensity ramp from black to a single colour or use the grey scale ramp from black to white. Black normally being the low end of the range of values, and white the high end. On the colour cube this is a diagonal line between the two opposite corners, the red, green, blue components are all the same.

The map from black to white is usually just a linear ramp, for a value (v) which varies from vmin to vmax, the colour is
red = green = blue = (v - vmin) / (vmax - vmin)

The most commonly used colour ramp is often refer to as the "hot- to-cold" colour ramp. Blue is chosen for the low values, green for middle values, and red for the high as these seem "intuitive" bounds. One could ramp between these points on the colour cube but this involves moving diagonally across the faces of the cube. Instead we add the colours cyan and yellow so that the colour ramp only moves along the edges of the colour cube from blue to red. This not only makes the mapping easier and faster but introduces more colour variation. The following illustrates the path on the colour cube.

The colour ramp is shown below along with the transition values.

Again there is a linear relationship of the scalar value with colour within each of the 4 colour bands. In some applications the variable being represented with the colour map is circular in nature in which case a cyclic colour map is desirable. The above can be simply modified to pass through magenta to yield one of many possible circular colour maps.

A more general case ramps between N colours, each colour has a corresponding value within the range of values of the variable being mapped. The points within the colour cube can be linearly ramped between the points or the transition can be smoothed by some interpolation function such a bezier curve. For example a 3 colour ramp for terrain visualisation might choose 3 heights and three corresponding colours.

Displayed as a colour ramp

The resulting terrain map

C Source for the "standard" hot-to-cold colour ramp.

/*
   Return a RGB colour value given a scalar v in the range [vmin,vmax]
   In this case each colour component ranges from 0 (no contribution) to
   1 (fully saturated), modifications for other ranges is trivial.
   The colour is clipped at the end of the scales if v is outside
   the range [vmin,vmax]
   typedef struct {
      double r,g,b;
   } COLOUR;
*/
COLOUR GetColour(double v,double vmin,double vmax)
{
   COLOUR c = {1.0,1.0,1.0}; // white
   double dv;

   if (v < vmin)
      v = vmin;
   if (v > vmax)
      v = vmax;
   dv = vmax - vmin;

   if (v < (vmin + 0.25 * dv)) {
      c.r = 0;
      c.g = 4 * (v - vmin) / dv;
   } else if (v < (vmin + 0.5 * dv)) {
      c.r = 0;
      c.b = 1 + 4 * (vmin + 0.25 * dv - v) / dv;
   } else if (v < (vmin + 0.75 * dv)) {
      c.r = 4 * (v - vmin - 0.5 * dv) / dv;
      c.b = 0;
   } else {
      c.g = 1 + 4 * (vmin + 0.75 * dv - v) / dv;
      c.b = 0;
   }

   return(c);
}

Note about gamma

Please note that the above are not corrected for the gamma of the display device. As such the colours may indeed appear different on different displays. The gamma of displays can be adjusted and typically have a power relationship, that is, if (r,g,b) is the colour being displayed, it will appear as (r^G,g^G,b^G). In order to achieve a display colour or (r,g,b) the inverse of the gamma function needs to be created, namely (r^1/G,g^1/G,b^1/G). Note also that the gamma value G is not necessarily the same for each (r,g,b) component.

Many applications in computer graphics use colour and/or opacity ramps, in particular, visualisation using volume rendering. In this and other cases one often just requires colour and opacity index tables for 256 states. The following is a straightforward approach to storing such index colour maps, it has been adopted from the OGLE volume rendering software, at least this means there is one other piece of software that uses the format rather than dreaming up an entirely new format.

This is the standard blue to green to red colour map. The columns are the index value followed by the red, green, blue values ranging from 0 (no contribution) to 255 (full contribution).

   0   0   0 255     64   0 255 254    128   1 255   0    192 255 252   0   
   1   0   3 255     65   0 255 249    129   5 255   0    193 255 247   0   
   2   0   7 255     66   0 255 246    130   9 255   0    194 255 244   0   
   3   0  11 255     67   0 255 241    131  13 255   0    195 255 239   0   
   4   0  15 255     68   0 255 238    132  17 255   0    196 255 236   0   
   5   0  19 255     69   0 255 233    133  21 255   0    197 255 231   0   
   6   0  23 255     70   0 255 230    134  25 255   0    198 255 228   0   
   7   0  27 255     71   0 255 225    135  29 255   0    199 255 223   0   
   8   0  31 255     72   0 255 222    136  33 255   0    200 255 220   0   
   9   0  35 255     73   0 255 217    137  37 255   0    201 255 215   0   
  10   0  39 255     74   0 255 214    138  41 255   0    202 255 212   0   
  11   0  43 255     75   0 255 209    139  45 255   0    203 255 207   0   
  12   0  47 255     76   0 255 206    140  49 255   0    204 255 204   0   
  13   0  51 255     77   0 255 201    141  53 255   0    205 255 199   0   
  14   0  55 255     78   0 255 198    142  57 255   0    206 255 196   0   
  15   0  59 255     79   0 255 193    143  61 255   0    207 255 191   0   
  16   0  63 255     80   0 255 190    144  66 255   0    208 255 188   0   
  17   0  67 255     81   0 255 185    145  70 255   0    209 255 183   0   
  18   0  71 255     82   0 255 182    146  74 255   0    210 255 180   0   
  19   0  75 255     83   0 255 177    147  78 255   0    211 255 175   0   
  20   0  79 255     84   0 255 174    148  82 255   0    212 255 172   0   
  21   0  83 255     85   0 255 169    149  86 255   0    213 255 167   0   
  22   0  87 255     86   0 255 166    150  90 255   0    214 255 164   0   
  23   0  91 255     87   0 255 161    151  94 255   0    215 255 159   0   
  24   0  95 255     88   0 255 158    152  98 255   0    216 255 156   0   
  25   0  99 255     89   0 255 153    153 102 255   0    217 255 151   0   
  26   0 103 255     90   0 255 150    154 106 255   0    218 255 148   0   
  27   0 107 255     91   0 255 145    155 110 255   0    219 255 143   0   
  28   0 111 255     92   0 255 142    156 114 255   0    220 255 140   0   
  29   0 115 255     93   0 255 137    157 118 255   0    221 255 135   0   
  30   0 119 255     94   0 255 134    158 122 255   0    222 255 132   0   
  31   0 123 255     95   0 255 129    159 126 255   0    223 255 127   0   
  32   0 127 255     96   0 255 126    160 129 255   0    224 255 123   0   
  33   0 132 255     97   0 255 122    161 134 255   0    225 255 119   0   
  34   0 135 255     98   0 255 118    162 137 255   0    226 255 115   0   
  35   0 140 255     99   0 255 114    163 142 255   0    227 255 111   0   
  36   0 143 255    100   0 255 110    164 145 255   0    228 255 107   0   
  37   0 148 255    101   0 255 106    165 150 255   0    229 255 103   0   
  38   0 151 255    102   0 255 102    166 153 255   0    230 255  99   0   
  39   0 156 255    103   0 255  98    167 158 255   0    231 255  95   0   
  40   0 159 255    104   0 255  94    168 161 255   0    232 255  91   0   
  41   0 164 255    105   0 255  90    169 166 255   0    233 255  87   0   
  42   0 167 255    106   0 255  86    170 169 255   0    234 255  83   0   
  43   0 172 255    107   0 255  82    171 174 255   0    235 255  79   0   
  44   0 175 255    108   0 255  78    172 177 255   0    236 255  75   0   
  45   0 180 255    109   0 255  74    173 182 255   0    237 255  71   0   
  46   0 183 255    110   0 255  70    174 185 255   0    238 255  67   0   
  47   0 188 255    111   0 255  66    175 190 255   0    239 255  63   0   
  48   0 191 255    112   0 255  61    176 193 255   0    240 255  59   0   
  49   0 196 255    113   0 255  57    177 198 255   0    241 255  55   0   
  50   0 199 255    114   0 255  53    178 201 255   0    242 255  51   0   
  51   0 204 255    115   0 255  49    179 206 255   0    243 255  47   0   
  52   0 207 255    116   0 255  45    180 209 255   0    244 255  43   0   
  53   0 212 255    117   0 255  41    181 214 255   0    245 255  39   0   
  54   0 215 255    118   0 255  37    182 217 255   0    246 255  35   0   
  55   0 220 255    119   0 255  33    183 222 255   0    247 255  31   0   
  56   0 223 255    120   0 255  29    184 225 255   0    248 255  27   0   
  57   0 228 255    121   0 255  25    185 230 255   0    249 255  23   0   
  58   0 231 255    122   0 255  21    186 233 255   0    250 255  19   0   
  59   0 236 255    123   0 255  17    187 238 255   0    251 255  15   0   
  60   0 239 255    124   0 255  13    188 241 255   0    252 255  11   0   
  61   0 244 255    125   0 255   9    189 246 255   0    253 255   7   0   
  62   0 247 255    126   0 255   5    190 249 255   0    254 255   3   0   
  63   0 252 255    127   0 255   1    191 254 255   0    255 255   0   0   

Opacity maps are stored in the same way even though the RGB colour information is usually redundant (r == g == b). Having the opacity map separate from the colour map allows one to use them interchangeably, if the RGB values of a map used as an opacity map are not equal then the application can choose how to derive the single opacity value (eg: use the red channel, use the magnitude of the colour....).

	01.dat		02.dat
	03.dat		04.dat
	05.dat		06.dat
	07.dat		08.dat
	09.dat		10.dat
	11.dat		12.dat
	13.dat		14.dat
	15.dat		16.dat
	17.dat		18.dat
	19.dat		20.dat
	21.dat		22.dat

A useful colour picker interface is often based upon the HSV colour system, sometimes the HSL. The layout of the colour table is often as follows although there is some variation in the functions used for saturation and value. All the colours in RGB space lie on the surface of the colour cube.

Example

As a web based paint selection interface, note the extra bar for grey scale selection.

Index colour systems are still prevalent in many graphical computer systems. An index colour system is one in which colour is specified by an integer normally from 0 up to the number of colours in the colour table. Each entry in the colour table gives the red, green, blue components for that particular index.

In such colour systems the colour table is sometimes fixed. In these cases you can only use the preset colours. When a particular colour is required which isn't in the table the closest may be used or a number of colours that are in the table may be dithered in order to approximate the desired colour.

A more common situation is when the colour table is of a fixed size but the actual RGB values at each position in the table can be changed. Therefore, if you require a wide range of a particular hue you can load up the colour table accordingly. It also leads to situations where one might want to optimise the colour table to best represent a particular image. For example if an image only contains 100 different colours then irrespective of what these colours are, a colour table containing these colours will allow the image to be represented exactly. A much more common situation is when the colour table isn't large enough to hold all the different colours desired, in these cases one might engage in a process called "colour table optimisation" where one attempts to load the colour table with colours so that the image can be best represented.

In yet other systems the colour table can be made as large as desired. One often then wants to create a colour table for a particular task. The remained of this document will describe the most unbiased method of creating a colour table in cases where you don't know what colours will be required and thus want an equal sampling of the RGB colour space

There are two processes involved. The first is creating the entries in the colour table, the second is given an RGB value determining the index of its closest representation in the table. In what follows, an RGB triple will be floating point numbers in the inclusive range [0,1]. If your colour space uses different ranges then simple scaling converts one range to the [0,1] range used here.

To create a n sampling along each r,g,b axis will result in n³ colour values. Converting from (r,g,b) triples into the colour index is

Source Code

Some examples of colour tables are illustrated below. The index ranges from 0 top left, increasing left to right - top to bottom. The index in the bottom right cell is n³-1.

4x4x4 sampling

5x5x5 sampling

6x6x6 sampling

Finding the index of the colour closest to a particular (r,g,b) triple is accomplished as follows

where nint(x) is the nearest integer to x.

Note

• If an odd sampling is used then the colour table will have a sampling of grey values (the diagonal of the colour cube where r = g = b)

• Many colour tables are restricted to one byte for the index, that is, up to 256 entries. It is common in these cases to use a 6x6x6 sampling and fill in the remaining 40 colour table entries with red, blue, green, and grey 10 sample ramps.

• Strictly speaking the samples generated as above are not all equally distributed, the 8 vertices of the colour cube are less likely than colours along the 12 edges which in turn are less likely than points lying near the 6 planes which are less likely that interior points.

The Macintosh 256 Colour Palette The following shows the RGB value of each colour in the default 256 Macintosh palette. The first column is the index, column 2 to 4 are the RGB values in the range 0 to 65535, columns 5 to 7 are the RGB values in the range of 0 to 1. The palette is arranged as follows: there are 256 colours to allocate, an even distribution of colours through the colour cube might be desirable but 256 is not the cube of an integer. 6x6x6 is 216 and so the first 216 colours are an equal 6x6x6 sampling of the colour cube. This leaves 40 colours to allocate, this has been done by choosing a ramp of 10 shades each for red, green, blue and grey.

The table

The following is the C code that created the above colour table. Source code

PhotoShop Index Colour Table Files

Performing colour remapping with indexed colour images in PhotoShop is particularly straightforward mainly because the colour table files are so easy to generate. The colour table files (which can be loaded into PhotoShop) consist of 256 RGB colour entries, each RGB colour component is stored as 1 byte. Each colour component ranges from 0 to 255. As such they are straightforward to generate mathematically with a programming language.

Example 1 The following short piece of C will generate a blue to red ramp. Of course this can be created manually in PhotoShop itself but this example illustrates the principle by which more complicated colour tables could be automatically generated. On the Macintosh the file creator will need to be set to 8BIM and the file type to 8BCT int main(int argc,char **argv) { int i; for (i=0;i<256;i++) { putchar(i); putchar(0); putchar(255-i); } }

Example 2 A circular red -> yellow -> green -> cyan -> blue -> magenta -> red colour table file in hexadecimal and the map shown visually in PhotoShop are illustrated below Address Hexadecimal data, 16 bytes per line ------- --------------------------------------- 0000000 ff00 00ff 0600 ff0c 00ff 1200 ff18 00ff 0000020 1e00 ff24 00ff 2a00 ff30 00ff 3600 ff3c 0000040 00ff 4200 ff48 00ff 4e00 ff54 00ff 5a00 0000060 ff60 00ff 6600 ff6c 00ff 7200 ff78 00ff 0000100 7e00 ff84 00ff 8a00 ff90 00ff 9600 ff9c 0000120 00ff a200 ffa8 00ff ae00 ffb4 00ff ba00 0000140 ffc0 00ff c600 ffcc 00ff d200 ffd8 00ff 0000160 de00 ffe4 00ff ea00 fff0 00ff f600 fffc 0000200 00fc ff00 f6ff 00f0 ff00 eaff 00e4 ff00 0000220 deff 00d8 ff00 d2ff 00cc ff00 c6ff 00c0 0000240 ff00 baff 00b3 ff00 aeff 00a8 ff00 a2ff 0000260 009c ff00 96ff 0090 ff00 8aff 0083 ff00 0000300 7eff 0078 ff00 71ff 006c ff00 66ff 0060 0000320 ff00 59ff 0054 ff00 4eff 0048 ff00 41ff 0000340 003c ff00 36ff 0030 ff00 29ff 0024 ff00 0000360 1eff 0018 ff00 11ff 000c ff00 06ff 0000 0000400 ff00 00ff 0600 ff0c 00ff 1200 ff18 00ff 0000420 1e00 ff24 00ff 2a00 ff30 00ff 3600 ff3c 0000440 00ff 4200 ff48 00ff 4e00 ff54 00ff 5a00 0000460 ff60 00ff 6600 ff6c 00ff 7200 ff78 00ff 0000500 7e00 ff84 00ff 8a00 ff90 00ff 9600 ff9c 0000520 00ff a200 ffa8 00ff ae00 ffb4 00ff ba00 0000540 ffc0 00ff c600 ffcc 00ff d200 ffd8 00ff 0000560 de00 ffe4 00ff ea00 fff0 00ff f600 fffc 0000600 00fc ff00 f6ff 00f0 ff00 eaff 00e4 ff00 0000620 deff 00d8 ff00 d2ff 00cc ff00 c6ff 00c0 0000640 ff00 baff 00b3 ff00 aeff 00a8 ff00 a2ff 0000660 009c ff00 96ff 0090 ff00 8aff 0083 ff00 0000700 7eff 0078 ff00 71ff 006c ff00 66ff 0060 0000720 ff00 59ff 0054 ff00 4eff 0048 ff00 41ff 0000740 003c ff00 36ff 0030 ff00 29ff 0024 ff00 0000760 1eff 0018 ff00 11ff 000c ff00 06ff 0000 0001000 ff06 00ff 0c00 ff12 00ff 1800 ff1e 00ff 0001020 2400 ff2a 00ff 3000 ff36 00ff 3c00 ff42 0001040 00ff 4800 ff4e 00ff 5400 ff5a 00ff 6000 0001060 ff66 00ff 6c00 ff72 00ff 7800 ff7e 00ff 0001100 8400 ff8a 00ff 9000 ff96 00ff 9c00 ffa2 0001120 00ff a800 ffae 00ff b400 ffba 00ff c000 0001140 ffc6 00ff cc00 ffd2 00ff d800 ffde 00ff 0001160 e400 ffea 00ff f000 fff6 00ff fc00 ffff 0001200 00fc ff00 f6ff 00f0 ff00 eaff 00e4 ff00 0001220 deff 00d8 ff00 d2ff 00cc ff00 c6ff 00c0 0001240 ff00 baff 00b3 ff00 aeff 00a8 ff00 a2ff 0001260 009c ff00 96ff 0090 ff00 8aff 0083 ff00 0001300 7eff 0078 ff00 71ff 006c ff00 66ff 0060 0001320 ff00 59ff 0054 ff00 4eff 0048 ff00 41ff 0001340 003c ff00 36ff 0030 ff00 29ff 0024 ff00 0001360 1eff 0018 ff00 11ff 000c ff00 06ff 0000

Example 3 Double (circular) grep ramp.

The phosphors on the face of the monitor tube luminesce (or some other computer projection device) when struck by the beam generated by the electron gun sweeping out the scanlines. By increasing the intensity of the beam, the phosphor dot luminesces more brightly, and by reducing the intensity of the beam, the phosphor glows less brightly. The output of the phosphor is not directly proportional to electron beam strength. The response of the phosphors usually looks something like this:

where the dotted line shows ideal linear response, and the solid line approximates the observed response of a normal phosphor. This response characteristic is due to physical phenomena and can be described via a function of the form

Typically monitors have a gamma from anything between 1.5 and 2.8

Subjectively, this causes the colors on the screen to appear darker than expected. Based on this behaviour, an inverse gamma correction function can be applied to compensate for this non-linear response:

Here, the solid line again represents the uncorrected phosphor response, the large dotted line is the inverse gamma function, and the fine dotted line is the resultant, linearized color response.

Most computer systems now days have standard interfaces/utilities for determining and setting the gamma value. For example the Macintosh has a control panel with the OS, SGI machines come with a utility called "gamma" which both reports and sets the gamma value.

The following chart can be used to determine the combined gamma value for your system.

Setting the gamma value

To adjust the gamma value "roughly", set the contrast and brightness of your monitor to your preferred/comfortable level and use whatever gamma software comes with your hardware.

In the absence of other information it is usual to set the effective gamma to 2.2, this is the standard employed for PhotoCD's. On SGI machines this normally means setting a "gamma" value of around 1.2, this is because SGI's are normally configured with a natural gamma of 2.6, the combined gamma value is 2.6 divided by this number.

All well written image viewers should provide options for controlling the gamma or they should get the value from the system being used. For example on UNIX machine, the xv viewer can be called with the option -gamma 2.2. Unfortunately at the time of writing none of the two main WEB browsers support gamma correction for images in WWW pages, as a result the images tend to look dark on uncorrected monitors. This is a major problem when it comes to distributing images on a wide variety of systems. Fortunately the PNG format does support the specification of a colourmetric model and will go a long way to providing consistent image appearance across monitor hardware.

The following present functions to convert to and from sRGB and LAB colour, in both cases going through XYZ as an intermediate stage. While presented as JavaScript, it does still uniquely define the transformations and should be easy to transcribe into other languages. Note the XYZ mappings require a reference illuminate white point, for example D65.

function (__structure xyzcolour) main(__number rgbcolour[4])
{
   var result = new Object();
   result.xyzcolour = new Array();
   var R = new Object();
   var g = new Object();
   var B = new Object();

   if (rgbcolour[0] > 0.04045 ) 
      R = Math.pow( ( (rgbcolour[0] + 0.055 ) / 1.055 ),2.4);
   else 
      R = rgbcolour[0] / 12.92;
   if (rgbcolour[1] > 0.04045 ) 
      G = Math.pow( ( (rgbcolour[1] + 0.055 ) / 1.055 ),2.4);   
   else                   
      G = rgbcolour[1] / 12.92;
   if (rgbcolour[2] > 0.04045 ) 
      B = Math.pow( ( (rgbcolour[2] + 0.055 ) / 1.055 ),2.4);
   else                   
      B = rgbcolour[2] / 12.92;
      
   R = R * 100;
   G = G * 100;
   B = B * 100;
   
   result.xyzcolour[0] = R * 0.4124 + G * 0.3576 + B * 0.1805;
   result.xyzcolour[1] = R * 0.2126 + G * 0.7152 + B * 0.0722;
   result.xyzcolour[2] = R * 0.0193 + G * 0.1192 + B * 0.9505;
   result.xyzcolour[3] = rgbcolour[3];
            
   return result;
}

function (__structure labcolour) main(__number xyzcolour[4],__number xyzref[3])
{
   var result = new Object();
   result.labcolour = new Array();
   var X = new Object();
   var Y = new Object();
   var Z = new Object();
            
   X = xyzcolour[0] / xyzref[0];
   Y = xyzcolour[1] / xyzref[1];
   Z = xyzcolour[2] / xyzref[2];

   if ( X > 0.008856 ) 
      X = Math.pow( X , 1/3.0 );
   else                    
      X = ( 903.3 * X + 16.0 ) / 116.0;
   if ( Y > 0.008856 ) 
      Y = Math.pow( Y, 1/3.0 );
   else                    
      Y = ( 903.3 * Y + 16.0) / 116.0;
   if ( Z > 0.008856 ) 
      Z = Math.pow( Z, 1/3.0 );
   else                   
      Z = ( 903.3 * Z + 16.0) / 116.0;

   result.labcolour[0] = ( 116 * Y ) - 16;
   result.labcolour[1] = 500 * ( X - Y );
   result.labcolour[2] = 200 * ( Y - Z );
   result.labcolour[3] = xyzcolour[3];
            
   return result;
}

function (__structure xyzcolour) main(__number labcolour[4],__number xyzref[3])
{
   var result = new Object();
   result.xyzcolour = new Array();
   var X = new Object();
   var Y = new Object();
   var Z = new Object();

   Y = (labcolour[0] + 16.0) / 116.0;
   X = labcolour[1] / 500.0 + Y;
   Z = Y - labcolour[2] / 200.0;
   
   Y = Adjust(Y);
   X = Adjust(X);
   Z = Adjust(Z);
               
   result.xyzcolour[0] = X * xyzref[0];
   result.xyzcolour[1] = Y * xyzref[1];
   result.xyzcolour[2] = Z * xyzref[2];
   result.xyzcolour[3] = labcolour[3];
            
   return result;
}

function Adjust(a) {
   if (Math.pow(a,3.0) > 0.008856)
      return(Math.pow(a,3.0));
   else
      return((a - 16.0/116.0) / 7.787);
}

function (__structure rgbcolour) main(__number xyzcolour[4])
{
   var result = new Object();
   result.rgbcolour = new Array();
   var R = new Object();
   var G = new Object();
   var B = new Object();
   var X = new Object();
   var Y = new Object();
   var Z = new Object();

   X = xyzcolour[0] / 100.0;
   Y = xyzcolour[1] / 100.0;
   Z = xyzcolour[2] / 100.0;
   
   R = X * 3.2406 + Y * (-1.5372) + Z * (-0.4986);
   G = X * (-0.9689) + Y *  1.8758 + Z * 0.0415;
   B = X * 0.0557 + Y * (-0.2040) + Z * 1.0570;

   R = Adjust(R);
   G = Adjust(G);
   B = Adjust(B);

   R = Clip(R);
   G = Clip(G);
   B = Clip(B);
         
   result.rgbcolour[0] = R * 255.0;
   result.rgbcolour[1] = G * 255.0;
   result.rgbcolour[2] = B * 255.0;
   result.rgbcolour[3] = xyzcolour[3];
            
   return result;
}

function Adjust(a) {
   if (a > 0.0031308)
      return(1.055*Math.pow(a,1.0/2.4)-0.055);
   else
      return(12.92*a);
}

function Clip(a) {
   if (a > 1)
      return(1);
   else if (a < 0)
      return(0);
   else
      return(a);
}