--- rest25/library/imageop.rst	2008-12-19 16:58:07.000000000 +0900
+++ rest262/library/imageop.rst	2009-04-05 05:02:09.000000000 +0900
@@ -1,36 +1,39 @@
 
 :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 by *width* by *height* in size
+   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.
@@ -44,26 +47,26 @@
    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.
+   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)
 
@@ -84,20 +87,21 @@
 .. 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.
+   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.
 
