Monash Image Library Documentation

Topics

index | userguide | full | arithmetic | basic | binary | blocks | colour | compress | display | docs | fft | hist | image | io | makefile | masks | memory | misc | morph | pixel | rgb | stats | transform | error | mapping

Functions

i24to8

Function:IMAGE *i_24to8(IMAGE *redpic, IMAGE *greenpic, IMAGE *bluepic)
Command:i24to8 red green blue out[.fmt]
Description:Merges three bands into one 8 bpp colour image

iCIE_XYZtoRGB

Function:void i_CIE_XYZtoRGB(double X,double Y,double Z,double *R,double *G,double *B)
Command:iCIE_XYZtoRGB not useful as an executable
Description:Converts a CIE XYZ pixel to a RGB pixel

iCMYtoRGB

Function:void i_CMYtoRGB (double C, double M, double Y, double *R, double *G, double *B)
Command:iCMYtoRGB not useful as an executable
Description:Converts a CMY pixel to a RGB pixel

iHSLtoRGB

Function:void i_HSLtoRGB(double h,double s,double l,double *R,double *G,double *B)
Command:iHSLtoRGB not useful as an executable
Description:Converts a HSL pixel to a RGB pixel

iHSVtoRGB

Function:void i_HSVtoRGB(double H,double S,double V,double *R,double *G,double *B)
Command:iHSVtoRGB not useful as an executable
Description:Converts a HSV pixel to a RGB pixel

iLabtoXYZ

Function:void i_LabtoXYZ(double L,double a,double b,double *X,double *Y,double *Z)
Command:iLabtoXYZ not useful as an executable
Description:Converts a L*a*b* pixel to a XYZ pixel

iLuvtoXYZ

Function:void i_LuvtoXYZ(double L,double u,double v,double *X,double *Y,double *Z)
Command:iLuvtoXYZ not useful as an executable
Description:Converts a L*u*v* pixel to a XYZ pixel

iNTSC_XYZtoRGB

Function:void i_NTSC_XYZtoRGB(double X,double Y,double Z,double *R,double *G,double *B)
Command:iNTSC_XYZtoRGB not useful as an executable
Description:Converts a NTSC XYZ pixel to a RGB pixel

iRGBtoCIE_XYZ

Function:void i_RGBtoCIE_XYZ(double R, double G, double B, double *X, double *Y, double *Z)
Command:iRGBtoCIE_XYZ not useful as an executable
Description:Converts a RGB pixel to a CIE XYZ pixel

iRGBtoCMY

Function:void i_RGBtoCMY (double R, double G, double B, double *C, double *M, double *Y)
Command:iRGBtoCMY not useful as an executable
Description:Converts a RGB pixel to a CMY pixel

iRGBtoHSL

Function:void i_RGBtoHSL(double R,double G,double B,double *h,double *s,double *l)
Command:iRGBtoHSL not useful as an executable
Description:Converts a RGB pixel to a HSL pixel

iRGBtoHSV

Function:void i_RGBtoHSV(double R,double G,double B,double *H,double *S,double *V)
Command:iRGBtoHSV not useful as an executable
Description:Converts a RGB pixel to a HSV pixel

iRGBtoNTSC_XYZ

Function:void i_RGBtoNTSC_XYZ(double R, double G, double B, double *X, double *Y, double *Z)
Command:iRGBtoNTSC_XYZ not useful as an executable
Description:Converts a RGB pixel to a NTSC XYZ pixel

iRGBtoYCbCr10

Function:void i_RGBtoYCbCr10 (double R, double G, double B, double *Y, double *Cb, double *Cr)
Command:iRGBtoYCbCr10 not useful as an executable
Description:Converts a RGB pixel to a YCbCr10 (lossless) pixel

iRGBtoYCbCr8

Function:void i_RGBtoYCbCr8 (double R, double G, double B, double *Y, double *Cb, double *Cr)
Command:iRGBtoYCbCr8 not useful as an executable
Description:Converts a RGB pixel to a YCbCr8 (lossy) pixel

iRGBtoYIQ

Function:void i_RGBtoYIQ (double R, double G, double B, double *Y, double *I, double *Q)
Command:iRGBtoYIQ not useful as an executable
Description:Converts a RGB pixel to a YIQ pixel

iStWtoXYZ

Function:void i_StWtoXYZ(double S,double t,double W,double *X,double *Y,double *Z)
Command:iStWtoXYZ not useful as an executable
Description:Converts a StW pixel to a XYZ pixel

iUVWstoXYZ

Function:void i_UVWstoXYZ(double U,double V,double W,double *X,double *Y,double *Z)
Command:iUVWstoXYZ not useful as an executable
Description:Converts a U*V*W* pixel to a XYZ pixel

iXYZtoLab

Function:void i_XYZtoLab(double X,double Y,double Z,double *L,double *a,double *b)
Command:iXYZtoLab not useful as an executable
Description:Converts a XYZ pixel to a L*a*b* pixel

iXYZtoLuv

Function:void i_XYZtoLuv(double X,double Y,double Z,double *L,double *u,double *v)
Command:iXYZtoLuv not useful as an executable
Description:Converts a XYZ pixel to a L*u*v* pixel

iXYZtoStW

Function:void i_XYZtoStW(double X,double Y,double Z,double *S,double *t,double *W)
Command:iXYZtoStW not useful as an executable
Description:Converts a XYZ pixel to a StW pixel

iXYZtoUVWs

Function:void i_XYZtoUVWs(double X,double Y,double Z,double *U,double *V,double *W)
Command:iXYZtoUVWs not useful as an executable
Description:Converts a XYZ pixel to a U*V*W* pixel

iXYZtouvY

Function:void i_XYZtouvY(double X,double Y,double Z,double *u,double *v,double *y)
Command:iXYZtouvY not useful as an executable
Description:Converts a XYZ pixel to a uvY pixel

iYCbCr10toRGB

Function:void i_YCbCr10toRGB (double Y, double Cb, double Cr, double *R, double *G, double *B)
Command:iYCbCr10toRGB not useful as an executable
Description:Converts a YCbCr10 (lossless) pixel to a RGB pixel

iYCbCr8toRGB

Function:void i_YCbCr8toRGB (double Y, double Cb, double Cr, double *R, double *G, double *B)
Command:iYCbCr8toRGB not useful as an executable
Description:Converts a YCbCr8 (lossy) pixel to a RGB pixel

iYIQtoRGB

Function:void i_YIQtoRGB (double Y, double I, double Q, double *R, double *G, double *B)
Command:iYIQtoRGB not useful as an executable
Description:Converts a YIQ pixel to a RGB pixel

iaddscalar

Function:void i_addscalar(IMAGE *image, int n)
Command:iaddscalar [-b{123a}] in out[.fmt] n
Description:Increment all pixels by n

iascii

Function:void i_ascii(IMAGE *image, char *textfile)
Command:iascii [-b{123a}] in textfilename
Description:Dump image as ascii numbers to outfile

ibinary

Function:void i_binary(IMAGE *image, int threshold)
Command:ibinary [-b{123a}] in out[.fmt] threshold
Description:Threshold binary image setting all pixels below threshold to 0 and all equal to or above to 1.

ibmedialzxis

Function:IMAGE *i_bmedialaxis(IMAGE *src, char *elementstring)
Command:ibmedialzxis [-b{123a}] in out[.fmt] elementstring
Description:Returns binary medial axis transform of in

icast

Function:void i_cast(IMAGE *image, int newbpp)
Command:icast [-b{123a}] in out[.fmt] newBPP
Description:Convert image to newBPP Bits Per Pixel

icedge

Function:void i_cedge(IMAGE *image)
Command:icedge [-b{123a}] in
Description:Executes Colour Edge Detection GUI (under X).

ichain

Function:void i_chain(IMAGE *image, char *outfile, int ndirs, char *outfmt)
Command:ichain [-b{123a}] in textfilename {4 6 8} {abs rel pic}
Description:Chain code a contoured binary image to text file

iclose

Function:void i_close(IMAGE *image)
Command:iclose not useful as an executable
Description:Releases all memory allocated to the image

icontour

Function:IMAGE *i_contour(IMAGE *image)
Command:icontour [-b{123a}] in out[.fmt]
Description:Contour binary image

iconvolve

Function:IMAGE *i_convolve(IMAGE *image, char *maskstring, int divideby)
Command:iconvolve [-b{123a}] in out[.fmt] maskstring divideby
Description:Convolve image with maskstring. E.g. '1 0 1, -1 0 -1, 1 0 1'

icopy

Function:void i_copy(IMAGE *src, IMAGE *dest)
Command:icopy not useful as an executable
Description:Copy src image to dest image

icorrelate

Function:IMAGE *i_correlate(IMAGE *image, IMAGE *mask)
Command:icorrelate [-b{123a}] in maskimage out[.fmt]
Description:Convolve image using maskimage

icscast

Function:IMAGE *i_cscast(IMAGE *im, int bpp, int normalise)
Command:icscast in out[.fmt] bitsperpixel {0 1}
Description:Casts a 3 band image to bpp and may either normalise(=1) to [0..255] for 8, 24, 32, 48, 96 bpp images, or [0..1] for 192 and 384 bpp images. or it will standardise(=0) to the original colour space values (only on 192 and 384 bpp images).

icsconvert

Function:IMAGE *i_csconvert(IMAGE *im, int cs, int xyz)
Command:icsconvert in out[.fmt] colour_space {0 1}
Description:Converts an image from one colour space to another. You may specify either NTSC(=0) or CIE(=1) XYZ conversion Always returns a 192 bpp standardised image

icsdtoi

Function:IMAGE *i_csdtoi(IMAGE *im, int bpp)
Command:icsdtoi in out[.fmt] {24 48 96}
Description:Converts 192 bpp image into 24, 48 or 96 bpp by scaling.

icsedge

Function:IMAGE *i_csedge(IMAGE *im)
Command:icsedge in out[.fmt]
Description:Performs uniform colour space edge detection upon image

icsgetpixel

Function:void i_csgetpixel(IMAGE *im, int row, int col, int cs, int xyz, double *t1, double *t2, double *t3)
Command:icsgetpixel not useful as an executable
Description:Returns the pixel values for the cs using NTSC=0 or XYZ=1 xyz

icshist

Function:IMAGE *i_cshist(IMAGE *image)
Command:icshist in out[.fmt]
Description:Produce intensity histograms for 3 band images. These are layed out on one image.

icsitod

Function:IMAGE *i_csitod(IMAGE *im, int bpp)
Command:icsitod in out[.fmt] {24 36 48 96}
Description:Converts 24, 36, 48 or 96 bpp image to 192 bpp by scaling.

icsmktemp

Function:IMAGE *i_csmktemp(int rows, int cols, int bpp, int cs)
Command:icsmktemp out[.fmt] rows cols bitsperpixel colour_space
Description:Creates a 3 band image of the colour space specified

icsnormalise

Function:void i_csnormalise(IMAGE *im)
Command:icsnormalise in out[.fmt]
Description:Normalises 192 bpp to a range of 0..1 in all three bands. Warning, colour spaces generally lose any properties after this operation (ie. psuedo-colour).

icspixdtoi

Function:void i_cspixdtoi(double d1, double d2, double d3, int cs, int xyz, long *l1, long *l2, long *l3, int bpp, int normalise)
Command:icspixdtoi not useful as an executable
Description:Converts 3-band double pixel into 3-band long pixel by scaling. When normalise = 1, it will assume the data is in [0..1]

icspixel

Function:void i_cspixel(double f1, double f2, double f3, int cs_from, int xyz_from, double *t1, double *t2, double *t3, int cs_to, int xyz_to)
Command:icspixel not useful as an executable
Description:Converts three band pixel from one colour space to another

icspixitod

Function:void i_cspixitod(long l1, long l2, long l3, int cs, int xyz, double *d1, double *d2, double *d3, int bpp, int normalise)
Command:icspixitod not useful as an executable
Description:Scales 3-band long pixel into a 3-band double pixel. Set normalise to 1 if original data was in [0..1]

icspixnorm

Function:void i_cspixnorm(double f1, double f2, double f3, int cs, int xyz, double *t1, double *t2, double *t3)
Command:icspixnorm not useful as an executable
Description:Normalise three values for the colour space cs

icspixrange

Function:int i_cspixrange(double *p1, double *p2, double *p3, int cs)
Command:icspixrange not useful as an executable
Description:Adjusts pixel values if beyond colour space range. Returns 1 if a value was changed else 0.

icspixstand

Function:void i_cspixstand(double f1, double f2, double f3, int cs, int xyz, double *t1, double *t2, double *t3)
Command:icspixstand not useful as an executable
Description:Standardise three pixel values to the range of the colour space

icsputpixel

Function:void i_csputpixel(IMAGE *im, int row, int col, int cs, int xyz, double t1, double t2, double t3)
Command:icsputpixel not useful as an executable
Description:Sets the pixel at row, col to the values of the cs specified

icsstandard

Function:void i_csstandard(IMAGE *im)
Command:icsstandard in out[.fmt]
Description:Scales 192 bpp back to original colour space range

icut

Function:IMAGE *i_cut(IMAGE *image, int row, int col, int rows, int cols)
Command:icut [-b{123a}] in out[.fmt] row col rows cols
Description:Cut out part of an image

idct

Function:IMAGE *i_dct(IMAGE *image)
Command:idct [-b{123a}] in out[.smg]
Description:8x8 Discrete Cosine Transform (result is 16 bpp)

idctinverse

Function:IMAGE *i_dctinverse(IMAGE *image)
Command:idctinverse [-b{123a}] in out[.smg]
Description:8x8 Inverse Discrete Cosine Transform (result 16 bpp)

idecode

Function:int i_decode(int bpp, uchar *context, int observations, FILE *inf)
Command:idecode not useful as an executable
Description:Bitplane arithmetic decoding. bpp, context and observations are as per iencode. The file to be decoded is inf. i_update should be called after i_decode. i_decode returns the decoded bits.

idefcolour

Function:void i_defcolour(IMAGE *image)
Command:idefcolour in out[.fmt]
Description:Set monash default colour map

idivscalar

Function:void i_divscalar(IMAGE *image, int n)
Command:idivscalar [-b{123a}] in out[.fmt] n
Description:Divide all pixels by n

idouble

Function:IMAGE *i_double(IMAGE *im)
Command:idouble [-b{123a}] in out[.fmt]
Description:Doubles the size of the image

idpe

Function:IMAGE *i_dpe(IMAGE *image, char *predictor)
Command:idpe [-b{123a}] in out[.fmt] {mean plane north west northwest}
Description:Inverse prediction error transform for 8 and 16 bpp images

idpe12

Function:IMAGE *i_dpe12(IMAGE *image, char *predictor)
Command:idpe12 [-b{123a}] in out[.fmt] {mean plane north west northwest aver4}
Description:Inverse prediction error transform for 12 bpp images

idrawline

Function:void i_drawline(IMAGE *image, int row, int col, int torow, int tocol, int colour)
Command:idrawline [-b{123a}] in out[.fmt] row col torow tocol colour
Description:Draw a line from row,col torow,tocol in colour

idrl

Function:IMAGE *i_drl(char *fname, int nrows, int ncols)
Command:idrl out[.fmt] infile rows cols
Description:Loads a run length encoded image of rowsxcols

idump

Function:void i_dump(IMAGE *image, char *basename, char *fmt)
Command:idump [-b{123a}] in basename fmt
Description:Dump image called basename.fmt, fmt: img smg lmg dmg cmg xbm rgb sgi gif ps cps bps cif pbm pgm ppm pnm. N.B. this separation of basename and format arguments non standard, the rest of the image library commands use a combined file name.

idumpbps

Function:void i_dumpps(IMAGE *image, double scale, char *outputfile)
Command:idumpbps [-b{123a}] in scale textfilename
Description:Dump a binary image as a monochrome postscript file

idumpcps

Function:void i_dumpcps(IMAGE *image, double scale, char *outputfile)
Command:idumpcps [-b{123a}] in scale textfilename
Description:Dump an image as a colour postscript file

idumppbm

Function:void i_dumppbm(IMAGE *im, char *filename, int type)
Command:idumppbm not useful as an executable
Description:Dump image to pbm (1 or 4), pgm (2 or 5) or ppm (3 or 6) file. Both ASCII (1, 2, 3) and raw (4, 5, 6) formats are supported

idumpps

Function:void i_dumpps(IMAGE *image, double scale, char *outputfile)
Command:idumpps [-b{123a}] in scale textfilename
Description:Dump a greyscale image as a dithered postscript file

idup

Function:IMAGE *i_dup(IMAGE *image)
Command:idup not useful as an executable
Description:Duplicate image

iencode

Function:int i_encode(int bpp, int bits, uchar *context, int observations, int final, FILE *outf)
Command:iencode not useful as an executable
Description:Bitplane arithmetic encoding. bpp is the number of bits you are encoding. bits is the actual symbol to be encoded. The context array should be bpp long, and initialised to 1's unless more information is known. observations should be set to 2. Final should always be 0 until the last symbol is reached. The result will be placed in outf. After i_encode is called, i_update should be called to modify the contexts and observation counts. i_encode returns the number of bits encoded.

ientropy

Function:double i_entropy(IMAGE *im, int min, int max)
Command:ientropy not useful as an executable
Description:Calculate the entropy of an image

iequalize

Function:void i_equalize(IMAGE *image)
Command:iequalize [-b{123a}] in out[.fmt]
Description:Apply gamma for image (and reset gamma to linear)

ierode

Function:int i_erode(IMAGE *src, IMAGE *dest, int noffsets, int offsets[2][64])
Command:ierode not useful as an executable
Description:Erosion morphological operator, use i_structelem to create offsets. This function returns 0 if erosion fails, else 1

ierror

Function:void i_error(LEVEL, format, ...)
Command:ierror not useful as an executable
Description:Indicates an error level and error message. Note that the function prototype below is a psuedo prototype. The LEVEL argument is a macro defined in image.h which must be one of I_INFORM, I_WARNING, I_FATAL, I_PANIC, I_FATALSYS or I_PANICSYS. The format and other arguments are as for printf.

iexpand

Function:void i_expand(IMAGE *src, IMAGE *dest, int noffsets, int offsets[2][64])
Command:iexpand not useful as an executable
Description:Expansion morphological operator, use i_structelem to create offsets

ifchen

Function:IMAGE *i_fchen(IMAGE *image)
Command:ifchen [-b{123a}] in out[.fmt]
Description:Frei-Chen transform

ifft

Function:IMAGE *i_fft(IMAGE *image)
Command:ifft [-b{123a}] in out[.cmg]
Description:Fft transform (returns 128 bpp COMPLEX image)

ifftfilter

Function:IMAGE *i_fftfilter(IMAGE *image, int orow, int ocol, int inner, int outer, char *cmd)
Command:ifftfilter [-b{123a}] in out[.fmt] orow ocol inner outer {highideal highramp highnotch lowideal lowramp lownotch}
Description:Fft noise filter

ifftinverse

Function:IMAGE *i_fftinverse(IMAGE *image, int bpp)
Command:ifftinverse [-b{123a}] in out[.fmt] bpp
Description:Inverse fft transform, (result is bpp bits per pixel)

ifftloglogspectrum

Function:IMAGE *i_fftloglogspectrum(IMAGE *image)
Command:ifftloglogspectrum [-b{123a}] in out[.fmt]
Description:Log of the log spectrum of fft transform

ifftlogspectrum

Function:IMAGE *i_fftlogspectrum(IMAGE *image)
Command:ifftlogspectrum [-b{123a}] in out[.fmt]
Description:Log spectrum of fft transform

ifftphase

Function:IMAGE *i_fftphase(IMAGE *image)
Command:ifftphase [-b{123a}] in out[.fmt]
Description:Phase of fft transform

ifftspectrum

Function:IMAGE *i_fftspectrum(IMAGE *image)
Command:ifftspectrum [-b{123a}] in out[.fmt]
Description:Spectrum of fft transform

iflip

Function:void i_flip(IMAGE *image)
Command:iflip [-b{123a}] in out[.fmt]
Description:Turn upside down

igamma

Function:void i_gamma(IMAGE *image, char *gamma)
Command:igamma [-b{123a}] in out[.fmt] {uniform stretch inverse}
Description:Set gamma for image (apply with iequalize)

iget_mapping

Function:int i_get_mapping(void)
Command:iget_mapping not useful as an executable
Description:Returns true (i.e. non-zero) if image is mapped.

iget_mapping_flags

Function:int i_get_mapping_flags(void)
Command:iget_mapping_flags not useful as an executable
Description:Returns the current mapping mode (i.e. one of I_RDONLY, I_PRIVATE or I_RDWR).

iget_mapping_prelude

Function:int i_get_mapping_prelude(void)
Command:iget_mapping_prelude not useful as an executable
Description:Get the current mapping prelude.

iget_mapping_span

Function:int i_get_mapping_span(void)
Command:iget_mapping_span not useful as an executable
Description:Get the current mapping span.

igetany

Function:double i_getany(IMAGE *image, int row, int col)
Command:igetany not useful as an executable
Description:Return double pixel in image at row,col of 8, 16, 32 or 64 bpp

igetblue

Function:int i_getblue(IMAGE *image, int row, int col)
Command:igetblue not useful as an executable
Description:Return blue component of coloured pixel in image at row,col

igetcblue

Function:COMPLEX i_getcblue(IMAGE *im, int row, int col)
Command:igetcblue not useful as an executable
Description:Get blue component value from 384 bpp images

igetcgreen

Function:COMPLEX i_getcgreen(IMAGE *im, int row, int col)
Command:igetcgreen not useful as an executable
Description:Get green component value from 384 bpp images

igetcomplex

Function:COMPLEX i_getcomplex(IMAGE *image, int row, int col)
Command:igetcomplex not useful as an executable
Description:Return 128 bit COMPLEX pixel value (using struct assignments)

igetcred

Function:COMPLEX i_getcred(IMAGE *im, int row, int col)
Command:igetcred not useful as an executable
Description:Get red component value from 384 bpp images

igetdblue

Function:double i_getdblue(IMAGE *im, int row, int col)
Command:igetdblue not useful as an executable
Description:Get blue component value from 8,24,32,48,96, 192 bpp images

igetdgreen

Function:double i_getdgreen(IMAGE *im, int row, int col)
Command:igetdgreen not useful as an executable
Description:Get green component value from 8,24,32,48,96, 192 bpp images

igetdouble

Function:double i_getdouble(IMAGE *image, int row, int col)
Command:igetdouble not useful as an executable
Description:Return 64 bit double floating point pixel value

igetdred

Function:double i_getdred(IMAGE *im, int row, int col)
Command:igetdred not useful as an executable
Description:Get red component value from 8,24,32,48,96, 192 bpp images

igetdrgb

Function:void i_getdrgb(IMAGE *im, int row, int col, double *t1, double *t2, double *t3)
Command:igetdrgb not useful as an executable
Description:Get red,green & blue values from 8,24,32,48,96 or 192 bpp image

igetgreen

Function:int i_getgreen(IMAGE *image, int row, int col)
Command:igetgreen not useful as an executable
Description:Return green component of colougreen pixel in image at row,col

igetlong

Function:long i_getlong(IMAGE *image, int row, int col)
Command:igetlong not useful as an executable
Description:Return 32 bit long pixel value

igetmaskany

Function:double i_getmaskany(IMAGE *im)
Command:igetmaskany not useful as an executable
Description:Returns the value (double) at the position in a mask

igetmaskbpp

Function:long i_getmaskbpp(IMAGE *i)
Command:igetmaskbpp is a macro which can be found in image.h
Description:Returns the bits per pixel of the value in the IMASK structure.

igetmaskchar

Function:char i_getmaskchar(IMAGE *i)
Command:igetmaskchar is a macro which can be found in image.h
Description:Returns the value (as a char) at the current position in the mask.

igetmaskcol

Function:long i_getmaskcol(IMAGE *i)
Command:igetmaskcol is a macro which can be found in image.h
Description:Returns the offset column at the current position in the mask.

igetmaskdouble

Function:char i_getmaskdouble(IMAGE *i)
Command:igetmaskdouble is a macro which can be found in image.h
Description:Returns the value (as a double) at the current position in the mask.

igetmasklength

Function:long i_getmasklength(IMAGE *i)
Command:igetmasklength is a macro which can be found in image.h
Description:Returns the number of elements in the mask.

igetmasklong

Function:long i_getmaskchar(IMAGE *i)
Command:igetmasklong is a macro which can be found in image.h
Description:Returns the value (as a long) at the current position in the mask.

igetmaskpix

Function:int i_getmaskpix(IMAGE *im)
Command:igetmaskpix not useful as an executable
Description:Returns the value (int) at the position in a mask

igetmaskpos

Function:long i_getmaskpos(IMAGE *i)
Command:igetmaskpos is a macro which can be found in image.h
Description:Returns the current position in the mask [0..nelems-1].

igetmaskptr

Function:IMASK *i_getmaskptr(IMAGE *i)
Command:igetmaskptr is a macro which can be found in image.h
Description:Returns a pointer to the current IMASK structure.

igetmaskrow

Function:long i_getmaskrow(IMAGE *i)
Command:igetmaskrow is a macro which can be found in image.h
Description:Returns the offset row at the current position in the mask.

igetmaskshort

Function:short i_getmaskchar(IMAGE *i)
Command:igetmaskshort is a macro which can be found in image.h
Description:Returns the value (as a short) at the current position in the mask.

igetpix

Function:int i_getpix(IMAGE *image, int row, int col)
Command:igetpix not useful as an executable
Description:Return integer pixel in image at row,col

igetred

Function:int i_getred(IMAGE *image, int row, int col)
Command:igetred not useful as an executable
Description:Return red component of coloured pixel in image at row,col

igetrgb

Function:void i_getrgb(IMAGE *im, int row, int col, int *red, int *green, int *blue)
Command:igetrgb not useful as an executable
Description:Get red, green & green values from 8,24,32,48 or 96 bpp image

igetshort

Function:short i_getshort(IMAGE *image, int row, int col)
Command:igetshort not useful as an executable
Description:Return 16 bit short pixel value

igetuchar

Function:uchar i_getuchar(IMAGE *image, int row, int col)
Command:igetuchar not useful as an executable
Description:Return 8 bit unsigned pixel value

igrad

Function:IMAGE *i_grad(IMAGE *image)
Command:igrad [-b{123a}] in out[.fmt]
Description:Gradient edge detection

igraydecode

Function:void i_graydecode(IMAGE *image)
Command:igraydecode [-b{123a}] in out[.fmt]
Description:Convert image using Gray decoding (to correlate bit planes)

igrayencode

Function:void i_grayencode(IMAGE *image)
Command:igrayencode [-b{123a}] in out[.fmt]
Description:Convert image using Gray encoding (to correlate bit planes)

igreyramp

Function:void i_greyramp(IMAGE *image)
Command:igreyramp in out[.fmt]
Description:Linear grey scale colour map

ihalf

Function:IMAGE *i_half(IMAGE *image)
Command:ihalf [-b{123a}] in out[.fmt]
Description:Shear 50% both dimensions

ihist

Function:IMAGE *i_hist(IMAGE *image)
Command:ihist [-b{123a}] in out[.fmt]
Description:Produce an intensity histogram (as an image)

ihistcmd

Function:IMAGE *i_histcmd(IMAGE *image, char *cmd)
Command:ihistcmd [-b{123a}] in out[.fmt] {rel abs cum}
Description:Intensity histogram showing relative, absolute or cummulative intensity distribution

ihistrgb

Function:IMAGE *i_histrgb(IMAGE *image)
Command:ihistrgb in out[.fmt]
Description:Produce an RGB intensity histogram (as an image)

ihistscale

Function:IMAGE *i_histscale(IMAGE *image, double min, double max, int height, int width, char *cmd)
Command:ihistscale [-b{123a}] in out[.fmt] min max height width {rel cum abs}
Description:Draws an intensity histogram for an image. You can control the minimum and maximum value of the histogram. If min is greater than the actual minimum value, it is reduced to the actual minimum. Likewise with the max parameter. If min >= max then the actual minimum and maximum values are used. The height and width parameters cotrol the size of the actual histogram. These are normally set at 255. This enable histograms of images of any bpp to be displayed. The histogram may either be relative, cumulative or absolute. Frequencies are always calculated discretely.

iimtomask

Function:IMAGE *i_imtomask(IMAGE *im, int orig_row, int orig_col)
Command:iimtomask [-b{123a}] in out[.fmt] orig_row orig_col
Description:Converts an image (array) into a mask (sparse). orig_row and orig_col indicate the origin's position.

iinfo

Function:void i_info(IMAGE *im, char *cmd)
Command:iinfo [-b{123a}] in {basic full}
Description:Displays information about an image to stderr. Full info includes statistical information (See istats)

iinvert

Function:void i_invert(IMAGE *im)
Command:iinvert [-b{123a}] in out[.fmt]
Description:Invert a 8, 16 or 32 bpp image

iis1band

Function:int i_is1band(IMAGE *image)
Command:iis1band not useful as an executable
Description:Returns 1 if bpp = 8, 16, 32 or 64

iis3band

Function:int i_is3band(IMAGE *image)
Command:iis3band not useful as an executable
Description:Returns 1 if bpp = 8, 24, 32, 48, 96 or 192 bpp

ilap

Function:IMAGE *i_lap(IMAGE *image)
Command:ilap [-b{123a}] in out[.fmt]
Description:Laplacian transform

ilshift

Function:void i_lshift(IMAGE *image)
Command:ilshift [-b{123a}] in out[.fmt]
Description:Multiply all pixels by two

imagnify

Function:IMAGE *i_magnify(IMAGE *image, double magrows, double magcols, char *cmd)
Command:imagnify [-b{123a}] in out[.fmt] magrows magcols {linear quadratic}
Description:Magnification of the image, may not work on binary images.

imalloc

Function:i_malloc(var,TYPE,n)
Command:imalloc is a macro which can be found in image.h
Description:Allocates n x sizeof(TYPE) bytes of memory to var, checks if memory is allocated

imap

Function:IMAGE *i_map(char *fname, int flags, int rows, int cols, int bpp)
Command:imap not useful as an executable
Description:Map a raw format image file into virtual memory. The fname argument must supply the full path and filename. The flags argument must be one of I_RDONLY, I_PRIVATE or I_RDWR.

imapimg

Function:IMAGE *i_mapimg(char *fullname, int bpp, int flags)
Command:imapimg not useful as an executable
Description:Map a raw format image file into virtual memory. The fullname argument must supply the full path and filename. The flags argument must be one of I_RDONLY, I_PRIVATE or I_RDWR.

imapped_readonly

Function:int i_mapped_readonly(IMAGE *im)
Command:imapped_readonly not useful as an executable
Description:Returns true (i.e. non-zero) if image is mapped and mapped for read only access.

imapping

Function:void i_mapping(int flags)
Command:imapping not useful as an executable
Description:Turn mapping on and override the default mapping mode. The flags argument must be one of I_RDONLY, I_PRIVATE or I_RDWR.

imask

Function:void i_mask(IMAGE *image, char *op, int value)
Command:imask [-b{123a}] in out[.fmt] op value
Description:Applies a scalar values to each pixel in the image using the given operator (= and or xor mean min max sub over lshift rshift rand diff)

imasknext

Function:int i_masknext(IMAGE *i)
Command:imasknext is a macro which can be found in image.h
Description:Increments pointer and counter to next element in mask. Returns 0 if at the end of the mask

imaskprev

Function:int i_maskprev(IMAGE *i)
Command:imaskprev is a macro which can be found in image.h
Description:Decrements pointer and counter to prev element in mask. Returns 0 if at the start of the mask

imaskref

Function:int i_maskref(IMAGE *i, int p)
Command:imaskref is a macro which can be found in image.h
Description:Sets position and pointer to the position p. Returns 0 if it fails.

imaskstart

Function:void i_maskstart(IMAGE *i)
Command:imaskstart is a macro which can be found in image.h
Description:Adjusts pointer and counter to start of mask

imasktoim

Function:IMAGE *i_masktoim(IMAGE *mask)
Command:imasktoim [-b{123a}] in out[.fmt]
Description:Converts a mask (sparse) into an image (array).

imatch

Function:IMAGE *i_match(IMAGE *image, char *maskstring)
Command:imatch [-b{123a}] in out[.fmt] maskstring
Description:Difference convolution -> sum of differences between two images

imax

Function:void i_max(IMAGE *in, IMAGE *out, char *elementstring, int include_origin)
Command:imax [-b{123a}] in out[.fmt] elementstring include_origin
Description:Max morphological operator, include_origin: 1 -> yes, 0 -> no

imaxvalue

Function:double i_maxvalue(IMAGE *im)
Command:imaxvalue not useful as an executable
Description:Calculate the maximum value of the image

imean

Function:double i_mean(IMAGE *im)
Command:imean not useful as an executable
Description:Calculate the mean of the image

imedialaxis

Function:IMAGE *i_medialaxis(IMAGE *src, char *elementstring, int method, int thresh)
Command:imedialaxis [-b{123a}] in out[.fmt] elementstring method thresh
Description:Returns grey scale medial axis transform: 0->max or 1->sum

imin

Function:void i_min(IMAGE *in, IMAGE *out, char *elementstring, int include_origin)
Command:imin [-b{123a}] in out[.fmt] elementstring include_origin
Description:Min morphological operator, include_origin: 1 -> yes, 0 -> no

iminmaxmed

Function:IMAGE *i_minmaxmed(IMAGE *image, int blocksize, char *cmd)
Command:iminmaxmed [-b{123a}] in out[.fmt] blocksize {min max med}
Description:Simple noise filter

iminvalue

Function:double i_minvalue(IMAGE *im)
Command:iminvalue not useful as an executable
Description:Calculate the minimum value of the image

imkblock

Function:IMAGE *i_mkblock(IMAGE *image, int row, int col, int rows, int cols)
Command:imkblock not useful as an executable
Description:Create indirect sub-image

imkicon

Function:IMAGE *i_mkicon(IMAGE *image)
Command:imkicon [-b{123a}] in out[.fmt]
Description:Scale -> binarize -> X11 bitmap ICON

imkmask

Function:IMAGE *i_mkmask(int nelems, int bpp)
Command:imkmask out[.fmt] nelems bitsperpixel
Description:Create a new mask

imktemp

Function:IMAGE *i_mktemp(int rows, int cols, int bpp)
Command:imktemp out[.fmt] rows cols {8 16 24 32 48 64 96 128 192 384}
Description:Creates new image, pixels are not zerod

imorfchen1

Function:IMAGE *i_morfchen1(IMAGE *image)
Command:imorfchen1 [-b{123a}] in out[.fmt]
Description:Morphological frei-chen transform method 1

imorfchen2

Function:IMAGE *i_morfchen2(IMAGE *image)
Command:imorfchen2 [-b{123a}] in out[.fmt]
Description:Morphological frei-chen transform method 2

imorfchen3

Function:IMAGE *i_morfchen3(IMAGE *image)
Command:imorfchen3 [-b{123a}] in out[.fmt]
Description:Morphological frei-chen transform method 3

imorgrad1

Function:IMAGE *i_morgrad1(IMAGE *image)
Command:imorgrad1 [-b{123a}] in out[.fmt]
Description:Morphological gradient edge detection method 1

imorgrad2

Function:IMAGE *i_morgrad2(IMAGE *image)
Command:imorgrad2 [-b{123a}] in out[.fmt]
Description:Morphological gradient edge detection method 2

imorlap

Function:IMAGE *i_morlap(IMAGE *image)
Command:imorlap [-b{123a}] in out[.fmt]
Description:Morphological laplacian transform

imorrob

Function:IMAGE *i_morrob(IMAGE *image)
Command:imorrob [-b{123a}] in out[.fmt]
Description:Morphological roberts transform

imorsob1

Function:IMAGE *i_morsob1(IMAGE *image)
Command:imorsob1 [-b{123a}] in out[.fmt]
Description:Morphological sobel transform method 1

imorsob2

Function:IMAGE *i_morsob2(IMAGE *image)
Command:imorsob2 [-b{123a}] in out[.fmt]
Description:Morphological sobel transform method 2

imuldtoi

Function:void i_muldtoi(double mul[3], int cs, int bpp, int normalise)
Command:imuldtoi not useful as an executable
Description:Returns multipliers for scaling 192 bpp to 24, 48 or 96 bpp. If normalise = 1, it will assume the data is in [0..1]

imulitod

Function:void i_mulitod(double mul[3], int cs, int bpp, int normalise)
Command:imulitod not useful as an executable
Description:Returns multipliers for scaling 24, 48 or 96 bpp to 192 bpp. Set normalise to 1 if original data was in [0..1]

imulscalar

Function:void i_mulscalar(IMAGE *image, int n)
Command:imulscalar [-b{123a}] in out[.fmt] n
Description:Multiply all pixels by n. Does not check for overflow.

imvblock

Function:void i_mvblock(IMAGE *block, int row, int col)
Command:imvblock not useful as an executable
Description:Move the origin of indirect sub-image

imxv

Function:void i_mxv(IMAGE **images, int numImages, char *options)
Command:imxv not useful as an executable
Description:Multiple image display with xv

iname

Function:void i_name(IMAGE *image, char *newname)
Command:iname [-b{123a}] in out[.fmt] newname
Description:Set the name of an image for display. Note that functions that return a new image do not in general copy the name of the target image.

ino_mapping

Function:void i_no_mapping(void)
Command:ino_mapping not useful as an executable
Description:Turn mapping off.

inoise

Function:void i_noise(IMAGE *im, int noise)
Command:inoise [-b{123a}] in out[.fmt] noise
Description:Changes 1/noise of the pixels to (255 - pixel)

ion_error

Function:void i_on_error(enum i_warn_level w, void handler(int))
Command:ion_error not useful as an executable
Description:Register an error handler for error level.

iopen

Function:IMAGE *i_open(char *imagename)
Command:iopen not useful as an executable
Description:Find image using paths in the IMAGES enviroment variable and load into memory

ipaste

Function:void i_paste(IMAGE *fg, IMAGE *bg, int row, int col)
Command:ipaste [-b{123a}] foreground background out[.fmt] row col
Description:Overlay foreground at row,col on background

ipasteop

Function:void i_pasteop(IMAGE *fg, IMAGE *bg, int row, int col, char *op)
Command:ipasteop [-b{123a}] fg bg out[.fmt] row col op
Description:Applies bg image at row, col on fg image using the given operator (= and or xor mean min max sub over lshift rshift rand diff). ie out = fg op bg.

ipe

Function:IMAGE *i_pe(IMAGE *image, char *predictor)
Command:ipe [-b{123a}] in out[.fmt] {mean plane north west northwest}
Description:Prediction error transform for 8 and 16 bpp images

ipe12

Function:IMAGE *i_pe12(IMAGE *image, char *predictor)
Command:ipe12 [-b{123a}] in out[.fmt] {mean plane north west northwest aver4}
Description:Prediction error transform for 12 bpp images

iputany

Function:double i_putany(IMAGE *image, int row, int col, double pixel)
Command:iputany not useful as an executable
Description:Put double pixel in image at row,col of 8, 16, 32 or 64 bpp

iputblue

Function:int i_putblue(IMAGE *image, int row, int col, int bluevalue)
Command:iputblue not useful as an executable
Description:Put blue component of coloured pixel in image at row,col

iputcblue

Function:COMPLEX i_putcblue(IMAGE *im, int row, int col, COMPLEX pixel)
Command:iputcblue not useful as an executable
Description:Put blue component value into 384 bpp image

iputcgreen

Function:COMPLEX i_putcgreen(IMAGE *im, int row, int col, COMPLEX pixel)
Command:iputcgreen not useful as an executable
Description:Put green component value into 384 bpp image

iputcomplex

Function:COMPLEX i_putcomplex(IMAGE *image, int row, int col, COMPLEX pixel)
Command:iputcomplex not useful as an executable
Description:Put 128 bit COMPLEX pixel value, using struct assignments

iputcred

Function:COMPLEX i_putcred(IMAGE *im, int row, int col, COMPLEX pixel)
Command:iputcred not useful as an executable
Description:Put red component value into 384 bpp image

iputdblue

Function:double i_putdblue(IMAGE *im, int row, int col, double pixel)
Command:iputdblue not useful as an executable
Description:Put blue component value into 8,24,32,48,96 or 192 bpp image

iputdgreen

Function:double i_putdgreen(IMAGE *im, int row, int col, double pixel)
Command:iputdgreen not useful as an executable
Description:Put green component value into 8,24,32,48,96, or 192 bpp image

iputdouble

Function:double i_putdouble(IMAGE *image, int row, int col, double pixel)
Command:iputdouble not useful as an executable
Description:Put 64 bit double floating point pixel value

iputdred

Function:double i_putdred(IMAGE *im, int row, int col, double pixel)
Command:iputdred not useful as an executable
Description:Put red component value into 8,24,32,48,96, or 192 bpp image

iputdrgb

Function:void i_putdrgb(IMAGE *im, int row, int col, double red, double green, double blue)
Command:iputdrgb not useful as an executable
Description:Put red, green & blue values in 8,24,32,48,96 or 192 bpp image

iputgreen

Function:int i_putgreen(IMAGE *image, int row, int col, int greenvalue)
Command:iputgreen not useful as an executable
Description:Put green component of coloured pixel in image at row,col

iputlong

Function:long i_putlong(IMAGE *image, int row, int col, long pixel)
Command:iputlong not useful as an executable
Description:Put 32 bit long pixel value

iputmaskany

Function:void i_putmaskany(IMAGE *im, long row, long col, double value)
Command:iputmaskany not useful as an executable
Description:Places row and col offsets, and the value at the current position.

iputmaskchar

Function:void i_putmaskchar(IMAGE *i, long r, long c, char v)
Command:iputmaskchar is a macro which can be found in image.h
Description:Sets the row and col offsets, and the char value at the current position.

iputmaskdouble

Function:void i_putmaskdouble(IMAGE *i, long r, long c, double v)
Command:iputmaskdouble is a macro which can be found in image.h
Description:Sets the row and col offsets, and the double value at the current position.

iputmasklong

Function:void i_putmasklong(IMAGE *i, long r, long c, long v)
Command:iputmasklong is a macro which can be found in image.h
Description:Sets the row and col offsets, and the long value at the current position.

iputmaskpix

Function:void i_putmaskpix(IMAGE *im, long orw, long col, long value)
Command:iputmaskpix not useful as an executable
Description:Places row and col offsets, and the value at the current position.

iputmaskshort

Function:void i_putmaskshort(IMAGE *i, long r, long c, short v)
Command:iputmaskshort is a macro which can be found in image.h
Description:Sets the row and col offsets, and the short value at the current position.

iputpix

Function:int i_putpix(IMAGE *image, int row, int col, int pixel)
Command:iputpix not useful as an executable
Description:Put integer pixel in image at row,col of 8, 16 or 32 bpp image

iputred

Function:int i_putred(IMAGE *image, int row, int col, int redvalue)
Command:iputred not useful as an executable
Description:Put red component of coloured pixel in image at row,col

iputrgb

Function:void i_putrgb(IMAGE *im, int row, int col, int red, int green, int blue)
Command:iputrgb not useful as an executable
Description:Put red, green & blue values into 8,24,32,48 or 96 bpp image

iputshort

Function:short i_putshort(IMAGE *image, int row, int col, short pixel)
Command:iputshort not useful as an executable
Description:Put 16 bit short pixel value

iputuchar

Function:uchar i_putuchar(IMAGE *image, int row, int col, uchar pixel)
Command:iputuchar not useful as an executable
Description:Put 8 bit unsigned pixel value

iremap

Function:int i_remap(IMAGE *im, int row)
Command:iremap not useful as an executable
Description:Remap slice of mapped image to include specified row. Returns the number of times i_remap has been called for that image.

iresize

Function:IMAGE *i_resize(IMAGE *image, int newrows, int newcols, char *cmd)
Command:iresize [-b{123a}] in out[.fmt] newrows newcols {linear quadratic}
Description:Arbitrary resize of an image, may not work on binary images.

irgbcorrelate

Function:double *i_rgbcorrelate(IMAGE *im)
Command:irgbcorrelate not useful as an executable
Description:Calcuate the correlation coeficients between the bands of a three band image. Returns an array of three doubles as there are three combinations of coefficients eg Red-Green, Red-Blue and Green-Blue.

irgbextract

Function:IMAGE *i_rgbextract(IMAGE *image, IMAGE **red, IMAGE **green, IMAGE **blue)
Command:irgbextract not useful as an executable
Description:Extract all three bands from an rgb image

irgbmerge

Function:IMAGE *i_rgbmerge(IMAGE *red, IMAGE *green, IMAGE *blue)
Command:irgbmerge red green blue out[.rgb]
Description:Merge 3 images -> single 24bit rgb format image

irgbsplit

Function:IMAGE *i_rgbsplit(IMAGE *image, char *band)
Command:irgbsplit in out[.fmt] {red green blue}
Description:Extract red, green or blue band from a colour image

irgbto8

Function:IMAGE *i_rgbto8(IMAGE *image)
Command:irgbto8 in out[.fmt]
Description:Median split rgb 24bit -> colour mapped 8 bit

irgbtogrey

Function:IMAGE *i_rgbtogrey(IMAGE *image)
Command:irgbtogrey in out[.fmt]
Description:Convert from rgb to grey (NTSC luminance)

irl

Function:void i_rl(IMAGE *image, char *fname)
Command:irl [-b{123a}] in outfile
Description:Saves the image using rul length encoding to outfile

irob

Function:IMAGE *i_rob(IMAGE *image)
Command:irob [-b{123a}] in out[.fmt]
Description:Roberts transform

irotangle

Function:IMAGE *i_rotangle(IMAGE *image, int angle)
Command:irotangle [-b{123a}] in out[.fmt] degrees
Description:Rotate image degrees clockwise

irotate

Function:IMAGE *i_rotate(IMAGE *image)
Command:irotate [-b{123a}] in out[.fmt]
Description:Rotate 90 degrees clockwise

irshift

Function:void i_rshift(IMAGE *image)
Command:irshift [-b{123a}] in out[.fmt]
Description:Divide all pixels by two

iscalepix

Function:void i_scalepix(IMAGE *image, int maximum)
Command:iscalepix [-b{123a}] in out[.fmt] maximum
Description:Scale pixels to <= maximum

isegment

Function:IMAGE *i_segment(IMAGE *image)
Command:isegment [-b{123a}] in out[.fmt]
Description:Segment binary image

iset_mapping_prelude

Function:void i_set_mapping_prelude(int span)
Command:iset_mapping_prelude not useful as an executable
Description:Override the default mapping prelude.

iset_mapping_span

Function:void i_set_mapping_span(int span)
Command:iset_mapping_span not useful as an executable
Description:Override the default mapping span.

isob

Function:IMAGE *i_sob(IMAGE *image)
Command:isob [-b{123a}] in out[.fmt]
Description:Sobel transformation

istats

Function:ISTATS *i_stats(IMAGE *im)
Command:istats not useful as an executable
Description:Calculate the mean, min, max, standard deviation and entropy of the image.

istddev

Function:double i_stddev(IMAGE *im, double mean)
Command:istddev not useful as an executable
Description:Calculate the standard deviation of an image

istrtomask

Function:IMAGE *i_strtomask(char *elem)
Command:istrtomask out[.fmt] elem
Description:Converts the string elem into a sparse mask space or _ indicates new row. 0 and 1 indicate values in the mask. i indicates active origin, o for a non-active origin.

istructelem

Function:int i_structelem(char *elementstring, int offsets[2][64])
Command:istructelem not useful as an executable
Description:Returns number of offsets and adjusts the offsets array for the element string. The offset array represents the rows and columns of the template. For example "010 1o1 010" is a 3x3 template with the origin at 'o'

itee

Function:void i_tee(IMAGE *image, char *filename, char *cmd)
Command:itee [-b{123a}] in out[.fmt] imagefile[.fmt] {error force}
Description:Tee pipe fitting (force overwrite or error)

itext

Function:void i_text(IMAGE *image, int row, int col, char *text, int colour)
Command:itext [-b{123a}] in out[.fmt] row col "text string" colour
Description:Write text (16x8 font)

itexture

Function:IMAGE *i_texture(IMAGE *image, int blocksize, char *cmd)
Command:itexture [-b{123a}] in out[.dmg] blocksize cmd
Description:Compute texture as an image (out is 64 bpp) cmd: mean,variance,entropy,maximality,uniformity,contrast

itr

Function:void i_tr(IMAGE *image, int lo, int hi, int newval)
Command:itr [-b{123a}] in out[.fmt] lo hi newval
Description:Translate pixels between lo and hi inclusive to newval

itranspose

Function:void i_transpose(IMAGE *image)
Command:itranspose [-b{123a}] in out[.fmt]
Description:Transpose (reflect leading diagonal)

iunchain

Function:IMAGE *i_unchain(char *textfile, char *mode)
Command:iunchain out[.fmt] textfilename {region boundary}
Description:Convert from chain code text file into image

iunmap

Function:void i_unmap(IMAGE *im)
Command:iunmap not useful as an executable
Description:Unmap a mapped image.

iupdate

Function:void i_update(int bpp, int bits, uchar *context, int *observations)
Command:iupdate not useful as an executable
Description:Update bitplane context. This should be called after i_encode and i_decode.

iuvYtoXYZ

Function:void i_uvYtoXYZ(double u,double v,double Y,double *X,double *Y2,double *Z)
Command:iuvYtoXYZ not useful as an executable
Description:Converts a uvY pixel to a XYZ pixel

iwh

Function:IMAGE *i_wh(IMAGE *image)
Command:iwh [-b{123a}] in out[.smg]
Description:8x8 Walsh-Hadamard Transform (out is 16 bpp)

iwh4

Function:IMAGE *i_wh4(IMAGE *image)
Command:iwh4 [-b{123a}] in out[.smg]
Description:4x4 Walsh-Hadamard Transform (out is 16 bpp)

iwh4inverse

Function:IMAGE *i_wh4inverse(IMAGE *image)
Command:iwh4inverse [-b{123a}] in out[.smg]
Description:Inverse 4x4 Walsh-Hadamard Transform (out is 16 bpp)

iwhinverse

Function:IMAGE *i_whinverse(IMAGE *image)
Command:iwhinverse [-b{123a}] in out[.smg]
Description:Inverse Walsh-Hadamard Transform (out is 16 bpp)

ixv

Function:void i_xv(IMAGE *image)
Command:ixv [-b{123a}] in
Description:Display image using xv as a forked child process

izero

Function:void i_zero(IMAGE *image)
Command:izero [-b{123a}] in out[.fmt]
Description:Zero all pixels

index | userguide | full | arithmetic | basic | binary | blocks | colour | compress | display | docs | fft | hist | image | io | makefile | masks | memory | misc | morph | pixel | rgb | stats | transform | error | mapping