view glib/grey.c @ 0:5242703e91d3 tip

Initial checkin for AIM92 aimR8.2 (last updated May 1997).

/*
    Copyright (c) Applied Psychology Unit, Medical Research Council. 1988, 1989
    ===========================================================================

    Permission to use, copy, modify, and distribute this software without fee 
    is hereby granted for research purposes, provided that this copyright 
    notice appears in all copies and in all supporting documentation, and that 
    the software is not redistributed for any fee (except for a nominal shipping 
    charge). Anyone wanting to incorporate all or part of this software in a
    commercial product must obtain a license from the Medical Research Council.

    The MRC makes no representations about the suitability of this 
    software for any purpose.  It is provided "as is" without express or implied 
    warranty.
 
    THE MRC DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING 
    ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THE
    A.P.U. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY 
    DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN 
    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

/*
    grey.c
    ======

    Greyscale routines for mapping arrays of shorts into
    columns of pixel values (dithered if necessary).


    Copyright (c), 1989  The Medical Research Council, Applied Psychology Unit.


    Author  : John Holdsworth
    Written : 11th May, 1989.

    Edited  :

*/
#if defined( NeXT )
#include <stdlib.h>
#else
#include <malloc.h>
#endif
#include "grey.h"


#ifndef lint
static char *sccs_id = "@(#)grey.c	1.9     J. Holdsworth (MRC-APU)  11/8/90" ;
#endif

/* standard recursive dither patterns for grey scales */

static int dither(n,x,y)
int n,x,y;
{
    static int seed[2][2] = {{ 0, 2 } , { 3, 1 }};

    if( n==2 )
	return ( seed[y][x] ) ;
    else
	return ( dither(n/2,x%(n/2),y%(n/2))*4 + seed[y%n/(n/2)][x%n/(n/2)] );

}

int *DitherLine( size, line, length, min, max )
int size, line, length, min, max ;
{
    int i, *dither_line = (int *) malloc( (unsigned) length * sizeof ( *dither_line ) ) ;

    if( dither_line != (int *) 0 ) {
	for( i=0; i < size && i < length ; i++ )
	    dither_line[ i ] = min + (double) dither( size, i, line ) * ( max - min ) / ( size * size ) + 0.5  ;

	/* repeat for rest of line */

	for( ; i < length ; i++ )
	    dither_line[ i ] = dither_line[ i%size ] ;
    }

    return ( dither_line ) ;
}

int **Dithers( size, length, min, max )
int size, length, min, max ;
{
    int i, **diths = (int **) malloc( (unsigned) size * sizeof ( *diths ) ) ;

    if( diths != (int **) 0 )
	for( i=0 ; i<size ; i++ )
	    diths[i] = DitherLine( size, i, length, min, max ) ;

    return ( diths ) ;
}

void FreeDithers( diths, size )
int **diths, size ;
{
    int i ;

    for( i=0 ; i<size ; i++ )
	free( (char *) diths[i] ) ;

    free( (char *) diths ) ;

    return ;
}

/*

    makeLookup prepares 64k byte lookup table for mapping shorts to pixel values.
    setmap is a routine to be called to locate the window system's color map
    and set it up returning  the number of pixels availiable and allocating an
    array containing these values in order of increasing blackness.

*/

#define GREY_DITHER_SIZE 8

#define PIXEL_TABLE_SIZE ((1l<<16)-1)

struct _lookup *makeLookup( getgreyscale, black, white, height )
char *(*getgreyscale)() ;
int black, white ;
int height ;
{
    register char *tableptr, *end, pixval ;
    char *greyscale  ;
    struct _lookup *lookup ;
    int npixels, pix, min, diff ;

    if( ( lookup = (struct _lookup *) malloc( (unsigned) sizeof (*lookup) ) ) != 0 &&
	( lookup->pixeltable =        malloc( (unsigned) PIXEL_TABLE_SIZE ) ) != 0 &&
	( lookup->output     =        malloc( (unsigned) height + 1       ) ) != 0 ) {

	/* output null terminated for potential printing out */

	lookup->output[height] = '\000' ;

	/* get black to white greyscale */

	greyscale = getgreyscale( &npixels ) ;


	if( black < white ) {
	    min  =         black ;
	    diff = white - black ;
	}
	else {
	    min  =         white ;
	    diff = black - white ;
	}

	lookup->dithers = Dithers( GREY_DITHER_SIZE, height, min, min + diff / ( npixels - 1 ) ) ;

	tableptr = lookup->pixeltable ;

	for( pix=0 ; pix<npixels ; pix++ ) {

	    if( black < white )
		pixval = greyscale[          pix] ;
	    else
		pixval = greyscale[npixels-1-pix] ;

	    if( pix < npixels-1 )
		end = lookup->pixeltable + diff * pix / ( npixels - 1 ) + 1 ;
	    else
		end = lookup->pixeltable + PIXEL_TABLE_SIZE ;

	    while( tableptr < end )
		*tableptr++ = pixval ;
	}

	return ( lookup ) ;
    }

    return ( 0 ) ;
}

/*
    doLookup just performs the lookup of pixel values to convert an
    array of short values into the corresponding pixels for output.
    when few pixel values are availiable dithering is used to make the
    most of them.

*/

char *lookup( col, lookup, input, match, height )
int col ;
struct _lookup *lookup ;
short *input ;
int *match, height ;
{
    register int diff ;
    register int *mptr = match ;
    register int *mend = match + height ;
    register char *dptr = lookup->output ;
    register char *lookuptable = lookup->pixeltable ;
    register int *ditherptr = lookup->dithers[ col%GREY_DITHER_SIZE ] ;

    while( mptr < mend ) {

	diff = input[ *mptr++ ] - *ditherptr++ ;

	if( diff > 0 )
	    *dptr++ = lookuptable[ diff ] ;
	else
	    *dptr++ = lookuptable[   0  ] ;
    }

    return ( lookup->output ) ;
}

void freeLookup( lookup )
struct _lookup *lookup ;
{
    if( lookup != 0 ) {

	free( lookup->pixeltable ) ;

	free( lookup->output ) ;

	FreeDithers( lookup->dithers, GREY_DITHER_SIZE ) ;

	free( (char *) lookup ) ;
    }
}

/* for compattability */

void doLookup( col, lookup, input, match, height, data )
int col ;
struct _lookup *lookup ;
short *input ;
int *match, height ;
char *data ;
{
    register int diff ;
    register int *mptr = match ;
    register int *mend = match + height ;
    register char *dptr = data ;
    register char *lookuptable = lookup->pixeltable ;
    register int *ditherptr = lookup->dithers[ col%GREY_DITHER_SIZE ] ;

    while( mptr < mend ) {

	diff = input[ *mptr++ ] - *ditherptr++ ;

	if( diff > 0 )
	    *dptr++ = lookuptable[ diff ] ;
	else
	    *dptr++ = lookuptable[   0  ] ;
    }

    return ;
}