• if either width or height is zero, mode is ignored.
  
• mode=0: fit the image into a width by height frame while preserving the aspect ratio
  
• mode=1: scale the image to width by height possibly changing the aspect ratio
  
• mode=2: width and height are interpreted as scaling ratios
  

The sizes of the output image are rounded to nearest integers smaller than the computed sizes, or to 1, whichever is largest.

((-flt-) x1 y1 x2 y2 x3 y3 x4 y4 p1 q1 p3 q3):
((-int-) background mode):
((-idx2- (-ubyte-)) in out):
RETURNS: Null
SIDE EFFECTS: <out>
AUTHOR: Y. LeCun
COMPILABLE: Yes
DESCRIPTION:
warp rgbaimage <in> through a geometric transformation that maps
a quadrilateral into a rectangle (bilinear transform).
The quadrilateral is specified by <x1> <y1> <x2> <y2> <x3> <y3> <x4> <y4>
(points are numbered clockwise starting from upper left).
The rectangle is specified by the upper left and lower right points
which are respectively <p1><q1> and <p3><q3>.
The result is put in <out>.  Clipping is automatically performed.
pixels outside of the bounds of <in> are assumed to have the value
<background> (which must be an idx1 of ubyte of size 4).  
<mode>=0: no antialiasing, <mode>=1: antialiasing with
bilinear interpolation (2 times slower).  

((-idx1- (-ubyte)) background):
((-idx3- (-ubyte-)) in out):
((-idx2- (-int-)) pi pj):
RETURNS: Null
SIDE EFFECTS: <out> 
AUTHOR: Y. LeCun
COMPILABLE: Yes
DESCRIPTION:
Warps an image using <pi> and <pj> as tabulated coordinate transforms.
<in> and <out> are idx2 of ubytes. <background> is the value assumed outside
of the input image. <pi> and <pj> are integers idx whose dimensions must
be identical to the first two dimensions of <out>.
An output pixel at coordinate (x,y) takes the value of the input pixel at
coordinate <pj[x,y]>,<pi[x,y]>. If the values in <pi> and <pj> are non
integers the pixels are computed by bilinearly interpolating the input
image. The <pi> and <pj> matrices contain 32-bit integers which are
interpreted as 16 bit of integer part and 16 bits of fractinal part.
Integers values are assumed to fall in the center of each pixel,
so the upper left-hand corner of an image is at coordinate (-0.5, -0.5).

((-int-) background):
((-idx2- (-ubyte-)) in out):
((-idx2- (-int-)) pi pj):
RETURNS: Null
SIDE EFFECTS: <out>
AUTHOR: Y. LeCun
Warps an image using <pi> and <pj> as tabulated coordinate transforms.
<in> and <out> are idx2 of ubytes. <background> is the value assumed outside
of the input image. <pi> and <pj> are tabulated coordinates 
This is essentially identical to rgbaim-warp, escept no bilinear
interpolation is performed (only a nearest neighbor rule is used).

(let* ((w (idx-dim m 1))
       (h (idx-dim m 0))
       (wh (int-matrix 2))
       (cxcy (float-matrix 2))
       (bg (ubyte-matrix 4)))
   (rgbaim-rotscale-rect w h hotx-src hoty-src angle coeff wh cxcy)
   (let ((z (ubyte-matrix (wh 1) (wh 0) 4)))
     (rgbaim-rotscale m hotx-src hoty-src z (cxcy 0) (cxcy 1) angle coeff bg)))

(-gptr- pin rez background):
(-int-  indimi indimj inmodi inmodj ppi ppj):
SIDE EFFECTS: <rez>
DESCRIPTION:
returns a bilinearly interpolated RGBA pixel value for coordinate
<ppi> <ppj>. The image data is pointed to by <pin>, with 
<indimi> <indimj> <inmodi> <inmodj> being the dimensions and modulos.
This function clips automatically if <ppi> <ppj> are outside of the
bounds by assuming the outside values are equal to <background>.
pixel values are ubytes, while coordinates are 32 bit fixed point
with 16 bit integer part and 16 bit fractional part.
The function does not use floating point arithmetics.