
This is a little description of all functions contains into
the LUG Library. There are more functions but aren't 
significatives for you as user.


CONVERT
=======

  gif.c:
	read_gif_file( char *file_name, bitmap_hdr *bitmap )
	read_gif( FILE *handle, bitmap_hdr *bitmap )
	write_gif_file( char *file_name, bitmap_hdr *bitmap )
	write_gif( FILE *handle, bitmap_hdr *bitmap )

  hf.c:
	write_hf_file( char *file_name, bitmap_hdr *bitmap )       
	write_hf( FILE *handle, bitmap_hdr *bitmap )            

  jpeg.c:
        write_jpeg_file( char *name, bitmap_hdr *bitmap )
        write_jpeg( FILE *handle, bitmap_hdr *bitmap )
        read_jpeg_file( char *name, bitmap_hdr *bitmap )
        read_jpeg( FILE *handle, bitmap_hdr *bitmap )

  pbm.c:
	read_pbm_file( char *file_name, bitmap_hdr *bitmap )
	read_pbm( FILE *handle, bitmap_hdr *bitmap )
	write_pbm_file( char *file_name, bitmap_hdr *bitmap )
	write_pbm( FILE *handle, bitmap_hdr *bitmap )

  pcx.c:
	read_pcx_file( char *file_name, bitmap_hdr *bitmap )       
	read_pcx( FILE *handle, bitmap_hdr *bitmap )            
	write_pcx_file( char *file_name, bitmap_hdr *bitmap )      
	write_pcx( FILE *handle, bitmap_hdr *bitmap )           

  pix.c:
	read_alias_file( char *file_name, bitmap_hdr *bitmap )     
	read_alias( FILE *handle, bitmap_hdr *bitmap )          
	write_alias_file( char *file_name, bitmap_hdr *bitmap )    
	write_alias( FILE *handle, bitmap_hdr *bitmap )         

  ps.c:
        write_ps_file( char *name, bitmap_hdr *image )
        write_ps_file_dimensions( char *name, bitmap_hdr *image, double width_cms, double length_cms )

  raw.c:
	read24bitmap( char *file_name, bitmap_hdr *bitmap )        
	read8bitmap( FILE *handle, bitmap_hdr *bitmap )         
	write24bitmap( char *file_name, bitmap_hdr *bitmap )       
	write8bitmap( FILE *handle, bitmap_hdr *bitmap )        

  rgb.c:
        read_rgb_file( char *name, bitmap_hdr *bitmap, int xsize, int ysize )
        read_rgb( FILE *handle, bitmap_hdr *bitmap, int xsize, int ysize )
        write_rgb_file( char *name, bitmap_hdr *image )
        write_rgb( FILE *handle, bitmap_hdr *bitmap )

  rla.c:
	read_rla_file( char *file_name, bitmap_hdr *bitmap )       
	read_rla( FILE *handle, bitmap_hdr *bitmap )            
	write_rla_file( char *file_name, bitmap_hdr *bitmap )      
	write_rla( FILE *handle, bitmap_hdr *bitmap )           

  rle.c:
	read_rle_file( char *file_name, bitmap_hdr *bitmap )       
	read_rle( FILE *handle, bitmap_hdr *bitmap )            
	write_rle_file( char *file_name, bitmap_hdr *bitmap )       
	write_rle( FILE *handle, bitmap_hdr *bitmap )            

  sgi.c:
	read_sgi_file( char *file_name, bitmap_hdr *bitmap )        
	write_sgi_file( char *file_name, bitmap_hdr *bitmap )       

  tga.c:
	read_tga_file( char *file_name, bitmap_hdr *bitmap )        
	read_tga( FILE *handle, bitmap_hdr *bitmap )             
	write_tga_file( char *file_name, bitmap_hdr *bitmap )       
	write_tga( FILE *handle, bitmap_hdr *bitmap )            
        write_tga_rle( FILE *handle, bitmap_hdr *bitmap )

  tiff.c:
	read_tiff_file( char *file_name, bitmap_hdr *bitmap )       
	write_tiff_file( char *file_name, bitmap_hdr *bitmap )




INTERNAL LIBRARY
================

  bitmap.c:
	allocatebitmap( bitmap_hdr *image, int xsize, int ysize, int depth, int colors )
	freebitmap( bitmap_hdr *image )
	copy_bitmap( bitmap_hdr *source, bitmap_hdr *target )  

  general.c:
	int no_bits( int colors )
	char *basename( char *string ) 
	short *bytetoshort( byte *source, short *target, int size )
	byte *shorttobyte( short *source, byte *target, int size )
	byte *floattobyte( float *source, byte *target, int size )
	float *bytetofloat( byte *source, float *target, int size )
	int Atoi( char *string )
	double Atod( char *string )
	isnumber( char *string )
	Uncompress( char *name, char *tmp_file_name )
	Compress( char *name )
	compute_levels( int colors )

  in_out.c:
	FILE *Fopen( char *name, char *mode )
	Fclose( FILE *handle )
	rm_compress()
	char *read_file( FILE *handle, int *lenght )
	long filelen( FILE *handle )

  memory.c:
	char *Malloc( int size )
	Free( void *ptr )




VIEWERS
=======

  hp.c:
	show_bitmap( char *name, bitmap_hdr *bitmap, int ditherflag )

  linux.c:
	show_bitmap( char *name, bitmap_hdr *bitmap, int ditherflag )

  pc.c:
	show_bitmap( char *name, bitmap_hdr *bitmap, int ditherflag )

  sgi.c:
	show_bitmap( char *name, bitmap_hdr *bitmap, int ditherflag )

  vfr.c: ( SGI )
	write_vfr( bitmap_hdr *bitmap, resetVFR, char *VFRbuffername )

  x11.c:
	show_bitmap_x11( char *name, bitmap_hdr *bitmap )




UTILITIES
=========


  adjust.c:
	adjust_bitmap( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap, int newx, int newy, int noblur )

  blur.c:
	blur_bitmap( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap )

  change.c:
	changecolor( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap, int cR, int cG, int cB, int nR, int nG, int nB, int distance )

  chroma.c:
	chroma_bitmaps( bitmap_hdr *basebitmap, bitmap_hdr *superbitmap, bitmap_hdr *outbitmap )
	chroma( bitmap_hdr *base, bitmap_hdr *super )

  cut.c:
	cut_bitmap( bitmap_hdr *outbitmap, bitmap_hdr *inbitmap, int xini, int yini, int xsize, int ysize )

  dither.c:
	dither_image( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap, int levels, int gamma )

  flip.c:
	flip_image( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap )

  gamma.c:
	gamma_correction( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap, double gamma )

  histoequal.c:
	histogram_equalization( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap )

  hsl.c:
	hsl_to_rgb_buffer( double *h, double *s, double *l, byte *r, byte *g, byte *b, int size )
	rgb_to_hsl_buffer( byte *r, byte *g, byte *b, double *h, double *s, double *l, size )
	RGB_to_HSL( byte r, byte g, byte b, double *h, double *s, double *l )  
	HSL_to_RGB( double h, double s, double l, byte *r, byte *g, byte *b )

  mask.c:
	chroma_mask( bitmap_hdr *base, bitmap_hdr *mask, bitmap_hdr *super, bitmap_hdr *outbitmap )
	chroma_shadow_mask( bitmap_hdr *base, bitmap_hdr *mask, bitmap_hdr *super, bitmap_hdr *outbitmap )
	mask_change_color( bitmap_hdr *base, bitmap_hdr *mask, bitmap_hdr *outbitmap, newr, newg, newb )
	mask_change_to_bw( bitmap_hdr *base, bitmap_hdr *mask, bitmap_hdr *outbitmap )
        mask_darken_color( bitmap_hdr *base, bitmap_hdr *mask, bitmap_hdr *outbitmap )
        fade_mask( bitmap_hdr *base, bitmap_hdr *super, bitmap_hdr *mask, bitmap_hdr *out )

  medianfilter.c:
	medianfilter( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap )

  mirror.c:
	mirror_image( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap )

  paste.c:
	paste( bitmap_hdr *base, bitmap_hdr *super, int xpos, int ypos )
	center_image( bitmap_hdr *base, bitmap_hdr *super )

  quantize.c:
	quantize( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap, int no_colors )

  rotate.c:
	rotate_bitmap( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap, double degrees )
	rotate90_image( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap )

  sharpen.c:
	sharpen_bitmap( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap )

  solid.c:
	create_solid_image( bitmap_hdr *image, int xsize, int ysize, int r, int g, int b )

  to24.c:
	to24( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap )

  tobw.c:
	tobw( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap )
	byte *create_bw_pallete()
	byte *cmap_to_bw( bitmap_hdr *image )
	rgbtobw( r, g, b, position, size )

  tohalftone.c:
	tohalftone( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap )
	bw_to_halftone( int x, int y, int position )

  toinverse.c:
	toinverse( bitmap_hdr *inbitmap, bitmap_hdr *outbitmap )
	byte *cmap_to_inverse( bitmap_hdr *image )


-----

I don't know if I'll update this file in upcoming releases. Now, there
is a manual (wow!) so ... read it!, please.

If you get some bug, have some sugestion or you add new functions,
please contact with me.


Cheers.


--

                     ===================================
                                 Raul Rivero
                        Vicerrectorado de Estudiantes
                            Universidad de Oviedo
                              Arguelles, 39, 2o.
                                33003 - Oviedo
                                    Spain
                      ---------------------------------
                          rivero@pinon.ccu.uniovi.es
                      ---------------------------------
                        "Es muy duro ser romantica  y
                         ninfomana a la vez", Ariadna
                         Gil en el corto El Columpio.
                     ===================================
