diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Doc/library/imageop.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-2.6.1/Doc/library/imageop.rst	Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,107 @@
+
+:mod:`imageop` --- Manipulate raw image data
+============================================
+
+.. module:: imageop
+   :synopsis: Manipulate raw image data.
+   :deprecated:
+   
+.. deprecated:: 2.6
+    The :mod:`imageop` module has been removed in Python 3.0.
+
+The :mod:`imageop` module contains some useful operations on images. It operates
+on images consisting of 8 or 32 bit pixels stored in Python strings.  This is
+the same format as used by :func:`gl.lrectwrite` and the :mod:`imgfile` module.
+
+The module defines the following variables and functions:
+
+
+.. exception:: error
+
+   This exception is raised on all errors, such as unknown number of bits per
+   pixel, etc.
+
+
+.. function:: crop(image, psize, width, height, x0, y0, x1, y1)
+
+   Return the selected part of *image*, which should be *width* by *height* in size
+   and consist of pixels of *psize* bytes. *x0*, *y0*, *x1* and *y1* are like the
+   :func:`gl.lrectread` parameters, i.e. the boundary is included in the new image.
+   The new boundaries need not be inside the picture.  Pixels that fall outside the
+   old image will have their value set to zero.  If *x0* is bigger than *x1* the
+   new image is mirrored.  The same holds for the y coordinates.
+
+
+.. function:: scale(image, psize, width, height, newwidth, newheight)
+
+   Return *image* scaled to size *newwidth* by *newheight*. No interpolation is
+   done, scaling is done by simple-minded pixel duplication or removal.  Therefore,
+   computer-generated images or dithered images will not look nice after scaling.
+
+
+.. function:: tovideo(image, psize, width, height)
+
+   Run a vertical low-pass filter over an image.  It does so by computing each
+   destination pixel as the average of two vertically-aligned source pixels.  The
+   main use of this routine is to forestall excessive flicker if the image is
+   displayed on a video device that uses interlacing, hence the name.
+
+
+.. function:: grey2mono(image, width, height, threshold)
+
+   Convert a 8-bit deep greyscale image to a 1-bit deep image by thresholding all
+   the pixels.  The resulting image is tightly packed and is probably only useful
+   as an argument to :func:`mono2grey`.
+
+
+.. function:: dither2mono(image, width, height)
+
+   Convert an 8-bit greyscale image to a 1-bit monochrome image using a
+   (simple-minded) dithering algorithm.
+
+
+.. function:: mono2grey(image, width, height, p0, p1)
+
+   Convert a 1-bit monochrome image to an 8 bit greyscale or color image. All
+   pixels that are zero-valued on input get value *p0* on output and all one-value
+   input pixels get value *p1* on output.  To convert a monochrome black-and-white
+   image to greyscale pass the values ``0`` and ``255`` respectively.
+
+
+.. function:: grey2grey4(image, width, height)
+
+   Convert an 8-bit greyscale image to a 4-bit greyscale image without dithering.
+
+
+.. function:: grey2grey2(image, width, height)
+
+   Convert an 8-bit greyscale image to a 2-bit greyscale image without dithering.
+
+
+.. function:: dither2grey2(image, width, height)
+
+   Convert an 8-bit greyscale image to a 2-bit greyscale image with dithering.  As
+   for :func:`dither2mono`, the dithering algorithm is currently very simple.
+
+
+.. function:: grey42grey(image, width, height)
+
+   Convert a 4-bit greyscale image to an 8-bit greyscale image.
+
+
+.. function:: grey22grey(image, width, height)
+
+   Convert a 2-bit greyscale image to an 8-bit greyscale image.
+
+
+.. data:: backward_compatible
+
+   If set to 0, the functions in this module use a non-backward compatible way
+   of representing multi-byte pixels on little-endian systems.  The SGI for
+   which this module was originally written is a big-endian system, so setting
+   this variable will have no effect. However, the code wasn't originally
+   intended to run on anything else, so it made assumptions about byte order
+   which are not universal.  Setting this variable to 0 will cause the byte
+   order to be reversed on little-endian systems, so that it then is the same as
+   on big-endian systems.
+