Gamma error in picture scaling

Introduction

	This was done by MS Paint in Windows XP. Some web browsers do the same. The image could also have been green or checkered green and magenta. In most cases the image will be less blurred than this one. The explanation is that the scaling is not performed by computing out an average of nearby pixels, but just by picking out 1 out of 4 pixels in each 2x2 pixel box. This is the most simple and fast way to scale a picture but it often yields obvious problems. It's "downsampling with no antialias filter".
	This was done by Photoshop (look closely; slight green lines). Recent versions of Firefox do the same. The explanation is that the above technique was used; picking 1 out of 4 pixels, but first applying an antialiasing filter that blurs the image and hence makes an average of nearby pixels. That yields the faint green lines.
	This is what SeaMonkey 1.1.17 yields, under ubuntu Linux 9.04. (If you would like to see how your browser scales the image click here.)

Examples

    

    

           

Fore-explanation

Explanation

Colors

• A number of red, between 0 and 255.
• A number of green, between 0 and 255.
• A number of blue, between 0 and 255.

                  

                      

                      

Brightness, contrast and other filters

Brightness

Contrast

Gamma and Exposure

Others

     

Other kinds of software and output systems

Consequences

Solutions

Send a mail to the authors of your software

Use a correct software

• The Netpbm toolkit for graphic manipulations, provided you use the pamscale command and you don't use the -filter option.
  

• The latest version of Image Analyzer handles the image gamma correctly in some of the common functions: scaling, rotation, smoothing, inverting and grayscale conversion. The gamma can be set by the user but default is 2.2.
  

• The image exporters in Aperture 1.5.6 (but Aperture 3.0 won't scale images down correctly).
  

• Rendera, fromout version 1.5.6 at least (the previews are computed incorrectly).
  

• Adobe Lightroom 1.4.1.
  

• The Preview app in Mac OS X starting from version 10.6.
  

• The Acorn app for Mac OS X, if the Lanczos scaling algorithm is used.
  

• Adobe Photoshop Lightroom 2 and 3.
  

• Quark XPress 7.0 and 8.0.
  

• The Links browser (since 2001...) (it does not scale images down... but it offers full control on the gamma and aspect ratio so pages can be displayed correctly even on rudimentary or exotic displays).
  

• Tux paint (this is a great drawing software for kids, not a photo processing software).
  

• KolourPaint from KDE.
  

• It seems GEGL handles images in 32 bit linear format, which is the ideal solution. It is not yet readily available to end users.
  

• cPicture (minute in size, huge in functionalities).
  

• GraphicConverter (starting from version 6.6.2b35; beta available here: www.lemkesoft.org/beta.html , release planned for March 15 )

Use the software correctly

• Photoshop CS3  and CS4.
  

• Paint Shop Pro X2.
  

• Nip2.
  

• Corel Photo Paint X4 (and maybe CorelDraw).

• 16 bit depth linear encoding per color channel. (Some specialists state that 16 bit is not enough and that you may get artifacts but I never had problems when just using 16 bit depth.)
  

• 32 bit depth linear encoding per color channel.
  

• A floating point linear encoding.
  

• A linear color space, like XYZ (which implies 32 bit depth).

1. Convert to 16 bit/channel mode to minimize rounding errors (optional).
2. Go to "Convert to profile" (in CS3, this is under the Edit menu).
3. Select the current profile for the destination space (so that both the source and destination space are referencing the same color space) *but do not hit OK*. If your document is not yet color managed, sRGB is probably the safest guess. This will pre-populate most of the fields for the next step...
4. Select "Custom RGB" for the destination space. You will get a pop-up window asking for the parameters for your custom color space.
5. In the options for setting up a custom color space, leave everything unchanged except set the gamma to 1.0.
6. Press OK in the Custom RGB dialog box and then press OK on the Convert to Profile dialog box.
7. Resize as normal.
8. Convert to your previous color space.
9. If you converted to 16bit/channel mode, you may want to convert back to 8bit/channel at this point.

Assume a gamma of 2.2

• This is an approximation. Imposing a gamma of 0.454545 is quite close to making an sRGB-encoded image linear. This will do in most cases... It should be perfect for photographs. But keep in mind it is not technically perfectly correct. If you're working for the industry or on scientific data, you may get reproaches.
  

• While you work on the image, if it is displayed, it will be displayed incorrectly; much darker. As a photographer, if you have to make fine tunings, you sure don't want to work that way. (In the VFX industry, the images are kept in linear encoding throughout the processes. Hence the software need no include the gamma in their computations. As the displays use gamma encoding, a LUT is used so the images are displayed correctly.)
  

• For this method to give proper results, the image must first be converted to say 16 bit depth. Almost every software can impose a gamma of 0.454545 to an image and then back a gamma of 2.2. But, if this is done using a depth of 8 bit per channel, the image will simply be massacred. It may survive if it is only made of bright colors. Yet if the image has dark arrays, they will be smashed. The dark image below can be used to check if a software or procedure keeps the data encoded in 8 bit depth when it is linear. The scaling on the left was performed correctly, using at least 16 bit depth. On the right, an example of "massacre" when 8 bit depth linear encoding is used.

  

ImageMagick

• Convert the image to 16 bit format and linear scale with this command. It produces an image named temp1.ppm. The PPM format is used because it allows 16 bits per color channel:
  

• Edit this image temp1.ppm with a software that can operate on 16 bit images, like CinePaint. Possibly combine it with other images you converted the same way to 16 bits and linear scale. One such software you can use is the command "convert" itself, of course. It has many possibilities. See its documentation.
  

• Save the temporary results of your work in files named say temp2.ppm, temp3.ppm... Still being in 16 bits and linear encoding of course.

• Once you have the final image, named say temp7.ppm, and you want to convert it to a compressed and standard format to send it away, use this command:
  

Gimp-gluas

-- Image scaling with correct gamma

tile_x       = 2
tile_y       = 2
gamma        = 2.2

tile_surface = tile_x * tile_y
gamma_invert = 1 / gamma

for y = 0, math.floor (height / tile_y) - 1 do
	for x = 0, math.floor (width / tile_x) - 1 do

		sum_r, sum_g, sum_b = 0, 0, 0

		for ly = 0, tile_y - 1 do
			for lx = 0, tile_x - 1 do

				r, g, b = get_rgb (x * tile_x + lx, y * tile_y + ly)

				real_r = r ^ gamma
				real_g = g ^ gamma
				real_b = b ^ gamma

				sum_r = sum_r + real_r
				sum_g = sum_g + real_g
				sum_b = sum_b + real_b
			end
		end

		real_r = sum_r / tile_surface
		real_g = sum_g / tile_surface
		real_b = sum_b / tile_surface

		r = real_r ^ gamma_invert
		g = real_g ^ gamma_invert
		b = real_b ^ gamma_invert

		set_rgb (x, y, r, g, b)
	end
	progress (y * tile_y / height)
end

Cinepaint

• Increase the image to a higher precision. 32-bit IEEE float is best but maybe a nuke to annoy a mosquito. (Image -> 32-bit IEEE)
  

• Convert the image to a linear scale using the gamma tool. (Image -> Colors -> Gamma-Expose and type 0.454545 as gamma parameter) (1 / 2.2 = 0.454545...)
  

• Apply to the image the filters and operations you intent.
  

• Convert the image back to an (almost) sRGB scale. (Image -> Colors -> Gamma-Expose and type 2.2 as gamma parameter)

Fast calculations

• Use look-up tables.
  

• Use approximative integer polynomials.
  

• Use a graphical or physical co-processor. CinePaint, for example, seems to be capable to perform heavy calculations on images in a flicker because it uses the nVidia graphical co-processor when one is available. (nVidia sells very low-cost supercomputers and add-on calculation expansion cards that are a combination of their graphical processors, together with an adequate compiler.)

PHP

Actually it's even a bit more complicated

Acknowledgments