#include <stdio.h>
#include "rle.h"

Include dependency graph for mcut.c:

Data Structures
struct	_color

struct	_histogram

struct	_bounds

struct	_color_box

Macros
#define	MAX(i, j) ( (i) > (j) ? (i) : (j) )

#define	MIN(i, j) ( (i) < (j) ? (i) : (j) )

#define	TLISTLINKS(type) type * next, * prev

#define	P(node) ((node)->prev)

#define	N(node) ((node)->next)

#define	TRACE(t_var, ini) for((t_var)=(ini);(t_var)!=NULL;(t_var)=N(t_var))

#define	ADD(new, first)

#define	INSERT(new, after)

#define	BLUEMASK(x) ((x) & 0x1f)

#define	GREENMASK(x) (((x)>>5) & 0x1f)

#define	REDMASK(x) (((x)>>10) & 0x1f)

#define	TO_5_BITS(x) (((x)>>3) & 0x1f)

#define	FROM_5_BITS(x) (((x)<<3) & 0xff)

#define	PACK_15(r, g, b) (TO_5_BITS(r)<<10 \| TO_5_BITS(g)<<5 \| TO_5_BITS(b))

#define	FAST_PACK(r, g, b) (((r)&0xf8)<<7 \| ((g)&0xf8)<<2 \| (TO_5_BITS(b)))

#define	DISTANCE(x, y)

Typedefs
typedef struct _color	color_t

typedef struct _color_box	color_box_t

typedef struct _histogram	histogram_t

typedef struct _bounds	bounds_t

Functions
void	subdivide ()

void	sum_hist ()

void	average_colors ()

void	calc_inverse_map ()

void	make_rle_map ()

void	re_expand_map ()

void	quantize_dither_rle ()

void	quantize_rle ()

void	free_hist ()

void	bound_rgb ()

void	set_size_axis ()

int	break_box ()

void	radix_sort ()

void	main (int argc, char **argv)

color_box_t *	split_box (color_box_t *box)

void	quantize_rle (rle_pixel **scan)

void	quantize_dither_rle (rle_pixel **scan)

int	resort_compare (histogram_t c1, histogram_t c2)

void	set_size_axis (color_box_t *cb)

void	bound_rgb (color_box_t *box)

void	radix_sort (color_box_t *bbox, int start_bit, int num_bits)

int	cmp_radices (histogram_t h1, histogram_t h2)

color_box_t *	insert_elt (color_box_t list, color_box_t elt)

Variables
color_box_t *	cb_list

color_box_t *	cb

int	cb_list_size

static unsigned	mask

short	out_map [3][256]

rle_hdr	in_hdr

rle_hdr	out_hdr

int	max_colors = 200

histogram_t *	hist [32768]

int	hist_size

char *	cmd_nm

Macro Definition Documentation

#define ADD	(	new,
		first
	)

Value:

( P(new) = NULL ,N(new) = (first),\
            (  ((first)!=NULL) ? (P(first)=(new), 0) :0 ),\
            first = (new) )

Definition at line 60 of file mcut.c.

#define BLUEMASK ( x ) ((x) & 0x1f)

Definition at line 72 of file mcut.c.

#define DISTANCE	(	x,
		y
	)

Value:

(((x).r-(y).r) * ((x).r-(y).r) + \
               ((x).g-(y).g) * ((x).g-(y).g) + \
               ((x).b-(y).b) * ((x).b-(y).b))

Definition at line 81 of file mcut.c.

#define FAST_PACK	(	r,
		g,
		b
	)	(((r)&0xf8)<<7 \| ((g)&0xf8)<<2 \| (TO_5_BITS(b)))

Definition at line 79 of file mcut.c.

#define FROM_5_BITS ( x ) (((x)<<3) & 0xff)

Definition at line 77 of file mcut.c.

#define GREENMASK ( x ) (((x)>>5) & 0x1f)

Definition at line 73 of file mcut.c.

#define INSERT	(	new,
		after
	)

Value:

( P(new) = (after),N(new) = N(after),\
    ( (N(after)!=NULL) ? (P(N(after))=(new), 0) :0),\
    N(after) = (new) )

Definition at line 64 of file mcut.c.

#define MAX	(	i,
		j
	)	( (i) > (j) ? (i) : (j) )

Definition at line 32 of file mcut.c.

#define MIN	(	i,
		j
	)	( (i) < (j) ? (i) : (j) )

Definition at line 33 of file mcut.c.

#define N ( node ) ((node)->next)

Definition at line 45 of file mcut.c.

#define P ( node ) ((node)->prev)

Definition at line 44 of file mcut.c.

#define PACK_15	(	r,
		g,
		b
	)	(TO_5_BITS(r)<<10 \| TO_5_BITS(g)<<5 \| TO_5_BITS(b))

Definition at line 78 of file mcut.c.

#define REDMASK ( x ) (((x)>>10) & 0x1f)

Definition at line 74 of file mcut.c.

#define TLISTLINKS ( type ) type * next, * prev

Definition at line 39 of file mcut.c.

#define TO_5_BITS ( x ) (((x)>>3) & 0x1f)

Definition at line 76 of file mcut.c.

#define TRACE	(	t_var,
		ini
	)	for((t_var)=(ini);(t_var)!=NULL;(t_var)=N(t_var))

Definition at line 50 of file mcut.c.

Typedef Documentation

typedef struct _bounds bounds_t

Definition at line 119 of file mcut.c.

typedef struct _color_box color_box_t

Definition at line 98 of file mcut.c.

typedef struct _color color_t

Definition at line 91 of file mcut.c.

typedef struct _histogram histogram_t

Definition at line 105 of file mcut.c.

Function Documentation

void average_colors ( )

Definition at line 527 of file mcut.c.

References _color::b, cb_list, _histogram::color, _color_box::color, _color::g, _color_box::hist, _color_box::hsize, _histogram::nsamples, and _color::r.

 {
     color_box_t *cp;
     int i;
     float red, grn, blu, nsamp;
     
     TRACE( cp, cb_list )
     {
     red = grn = blu = nsamp = 0;
     for ( i=0; i<cp->hsize; i++ )
         if ( cp->hist[i] )
         {
         float samp = cp->hist[i]->nsamples * cp->hist[i]->nsamples;
         red += REDMASK(cp->hist[i]->color) * samp;
         grn += GREENMASK(cp->hist[i]->color) * samp;
         blu += BLUEMASK(cp->hist[i]->color) * samp;
         nsamp += samp;
         }
     cp->color.r = (int)(red / nsamp);
     cp->color.g = (int)(grn / nsamp);
     cp->color.b = (int)(blu / nsamp);
     }
 }

void bound_rgb ( )

void bound_rgb ( color_box_t * box )

Definition at line 910 of file mcut.c.

Referenced by sum_hist().

 {
     register int i;
     register histogram_t **hp = box->hist;
     int first_time = 1;
 
     for ( i=0; i<box->hsize; i++, hp++ )
     if ( *hp )
     {
         if ( first_time )
         {
         box->r.min = box->r.max = REDMASK( (*hp)->color );
         box->g.min = box->g.max = GREENMASK( (*hp)->color );
         box->b.min = box->b.max = BLUEMASK( (*hp)->color );
         first_time = 0;
         }
         
         box->r.min = MIN( box->r.min, REDMASK((*hp)->color) );
         box->r.max = MAX( box->r.max, REDMASK((*hp)->color) );
         box->g.min = MIN( box->g.min, GREENMASK((*hp)->color) );
         box->g.max = MAX( box->g.max, GREENMASK((*hp)->color) );
         box->b.min = MIN( box->b.min, BLUEMASK((*hp)->color) );
         box->b.max = MAX( box->b.max, BLUEMASK((*hp)->color) );
     }
 }

Here is the caller graph for this function:

int break_box ( )

Definition at line 433 of file mcut.c.

References _color_box::axis, cb_list, cb_list_size, insert_elt(), radix_sort(), and split_box().

Referenced by subdivide().

 {
     color_box_t *newb, *box = cb_list, *split_box(), *insert_elt();
 
     cb_list = N(cb_list);
     if ( cb_list ) P(cb_list) = NULL;
     N(box) = P(box) = NULL;
 
     switch ( box->axis )
     {
       case RLE_RED:
     radix_sort( box, 0, 5 );
     break;
 
       case RLE_GREEN:
     radix_sort( box, 5, 5 );
     break;
 
       case RLE_BLUE:
     radix_sort( box, 10, 5 );
     }
 
     newb = split_box( box );
     cb_list = insert_elt( cb_list, box );
     
     if ( newb == NULL )
     return 1;
 
     cb_list = insert_elt( cb_list, newb );
     cb_list_size++;
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void calc_inverse_map ( )

Definition at line 565 of file mcut.c.

References _color::b, cb_list, _histogram::color, _color_box::color, _histogram::color_ptr, _color::g, _color_box::hist, _color_box::hsize, and _color::r.

 {
     register color_box_t *cp, *tmp;
     int i, dist;
     color_t ref_col;
 
     TRACE( cp, cb_list )
     for ( i=0; i<cp->hsize; i++ )
         if ( cp->hist[i] )
         {
         ref_col.r = REDMASK( cp->hist[i]->color );
         ref_col.g = GREENMASK( cp->hist[i]->color );
         ref_col.b = BLUEMASK( cp->hist[i]->color );
         dist = DISTANCE( ref_col, cp->color );
         
         TRACE( tmp, cb_list )
         {
             register color_t *newcol = &tmp->color;
             register int newdist = DISTANCE( ref_col, *newcol );
 
             if ( newdist < dist )
             {
             dist = newdist;
             }
         }
         /* Back pointer to 24 bit value */
         cp->hist[i]->color_ptr = cp;
         }
 }

int cmp_radices	(	histogram_t **	h1,
		histogram_t **	h2
	)

Definition at line 963 of file mcut.c.

 {
     register c1 = -1, c2 = -1;
 
     if ( *h1 )
     c1 = (*h1)->color & mask;
     if ( *h2 )
     c2 = (*h2)->color & mask;
 
     return c1>c2 ? 1 : ( c2>c1 ? -1 : 0 );
 }

void free_hist ( )

Definition at line 1035 of file mcut.c.

References cb_list, cb_list_size, and hist.

 {
     register color_box_t *tmp_cb, *next_cb;
     register int i;
 
     for( tmp_cb = cb_list; tmp_cb; tmp_cb = next_cb )
     {
     next_cb = N(tmp_cb);
     free( tmp_cb );
     }
     cb_list = NULL;
     cb_list_size = 0;
 
     for ( i = 0; i < 32768; i++ )
     {
     if ( hist[i] )
         free( hist[i] );
     hist[i] = NULL;
     }
 }

color_box_t* insert_elt	(	color_box_t *	list,
		color_box_t *	elt
	)

Definition at line 983 of file mcut.c.

Referenced by break_box().

 {
     color_box_t *lp, *ll;
 
     /* Special cases: NULL list and one element list. */
     if ( list == NULL )
     list = elt;
     else if ( P(list) == NULL && N(list) == NULL )
     if ( list->size <= elt->size )
         ADD( elt, list );
     else
     {
         ADD( list, elt );
         list = elt;
     }
     else
     {
     /* Search a multi-element list for proper spot to insert. */
     for ( lp = list; N(lp); lp = N(lp) )
         if ( lp->size <= elt->size )
         break;
 
     /*
      * Special cases: insert before beginning, insert after end,
      * insert in middle.
      */
     if ( P(lp) == NULL )
         ADD( elt, list );
     else 
         if ( N(lp) == NULL && elt->size < lp->size )
     {
         /* Append elt to lp */
         for (ll = lp; N(ll) != NULL; ll = N(ll)) ;
         N(ll) = elt;
         P(elt) = ll;
     }
     else
     {
         lp = P(lp);
         INSERT( elt, lp );
     }
     }
 
     return list;
 }

Here is the caller graph for this function:

void main	(	int	argc,
		char **	argv
	)

Definition at line 236 of file mcut.c.

 {
     register rle_pixel *rptr, *gptr, *bptr;
     int tmp, dither = 0, oflag = 0;
     register int i;
     rle_pixel **scan;
     char * infname = NULL, *out_fname = NULL;
     FILE *outfile = stdout;
     char cmap_comment[80];
     int rle_err, rle_cnt;
     long start;
 
     if ( ! scanargs( argc, argv, "% n%-colors!d d%- o%-outfile!s infile!s",
             &tmp, &max_colors, &dither, &oflag, &out_fname, &infname ))
     exit( 1 );
 
     cmd_nm = cmd_name( argv );
 
     in_hdr = *rle_hdr_init( NULL );
     out_hdr = *rle_hdr_init( NULL );
     in_hdr.rle_file = rle_open_f(cmd_nm, infname, "r");
     rle_names( &in_hdr, cmd_nm, infname, 0 );
     rle_names( &out_hdr, in_hdr.cmd, out_fname, 0 );
 
     for ( rle_cnt = 0; ; rle_cnt++ )
     {
     start = ftell( in_hdr.rle_file );
     if ( start < 0 )
     {
         fprintf( stderr, "%s: Sorry, can't accept piped input.\n",
              cmd_nm );
         exit( -1 );
     }
     if ( (rle_err = rle_get_setup( &in_hdr )) != RLE_SUCCESS )
         break;
     /*
      * Setup rle buffers.
      */
 
     if (in_hdr.ncolors != 3)
     {
         fprintf(stderr,
             "%s: input file must be three channel (RGB) image.\n",
             cmd_nm);
         exit(-5);
     }
 
     (void)rle_hdr_cp( &in_hdr, &out_hdr );
     out_hdr.ncolors = 1;    /* Just one chan, the cmap index */
     for (i = 1; i < in_hdr.ncolors; i++)
         RLE_CLR_BIT( out_hdr, i );  /* Kill extra output channels */
     out_hdr.ncmap = 3;
     out_hdr.cmaplen = 8;    /* == 256 entries */
     out_hdr.cmap = (rle_map *) out_map;
 
     if ( rle_cnt == 0 )
         outfile = rle_open_f( cmd_name( argv ), out_fname, "w" );
     out_hdr.rle_file = outfile;
 
     /* getrow and putrow have different origins, this makes them the same */
     in_hdr.xmax -= in_hdr.xmin;
     in_hdr.xmin = 0;
 
     if ( rle_row_alloc( &in_hdr, &scan ) < 0 )
         RLE_CHECK_ALLOC( cmd_nm, 0, "input image data" );
     
     /*
      * Build histogram.
      */
     while ( rle_getrow(&in_hdr,scan) <= in_hdr.ymax )
     {
         rptr = scan[RLE_RED];
         gptr = scan[RLE_GREEN];
         bptr = scan[RLE_BLUE];
 
         for ( i=0; i <= in_hdr.xmax; i++ )
         {
         register int tmp = FAST_PACK( *rptr++, *gptr++, *bptr++ );
         register histogram_t *hp = hist[tmp];
         
         if ( hp == NULL )
         {
             hist[tmp] = hp = (histogram_t *) malloc( sizeof(histogram_t) );
             RLE_CHECK_ALLOC( cmd_nm, hp, "histogram" );
         }
         hp->color = tmp;
         hp->nsamples++;
         }
     }
 
     sum_hist();
     subdivide();
     average_colors();
     calc_inverse_map();
 
     make_rle_map();
     sprintf( cmap_comment, "color_map_length=%d", cb_list_size );
     rle_putcom( cmap_comment, &out_hdr );
     rle_addhist( argv, &in_hdr, &out_hdr );
     rle_put_setup( &out_hdr );
 
     re_expand_map();
 
     /* 
      * Now rewind the input and convert the pixels from RGB to the index.
      */
     fseek( in_hdr.rle_file, start, 0 );
     rle_get_setup_ok( &in_hdr, cmd_nm, infname );
     in_hdr.xmax -= in_hdr.xmin; /* Spencer trick */
     in_hdr.xmin = 0;
 
     if (dither)
         quantize_dither_rle(scan);
     else
         quantize_rle(scan);
 
     rle_row_free( &in_hdr, scan );
     free_hist();
     }
 
     /* Check for an error.  EOF or EMPTY is ok if at least one image
      * has been read.  Otherwise, print an error message.
      */
     if ( rle_cnt == 0 || (rle_err != RLE_EOF && rle_err != RLE_EMPTY) )
     rle_get_error( rle_err, cmd_nm, infname );
 
 
     exit( 0 );
 }

void make_rle_map ( )

Definition at line 602 of file mcut.c.

References _color::b, cb_list, _color_box::cindex, _color_box::color, _color::g, out_map, and _color::r.

 {
     register int index;
     color_box_t * cp;
 
     index = 0;
     TRACE( cp, cb_list )
     {
     out_map[RLE_RED][index]   = FROM_5_BITS(cp->color.r) << 8;
     out_map[RLE_GREEN][index] = FROM_5_BITS(cp->color.g) << 8;
     out_map[RLE_BLUE][index]  = FROM_5_BITS(cp->color.b) << 8;
     cp->cindex = index++;
     }
 }

void quantize_dither_rle ( )

void quantize_dither_rle ( rle_pixel ** scan )

Definition at line 686 of file mcut.c.

 {
     register rle_pixel *rptr, *gptr, *bptr, *optr;
     register int i, j;
     short *thisline, *nextline, *tmpptr ;
     register short *thisptr, *nextptr ;
     int tmp;
     int lastline, lastpixel ;
 
     thisline = (short *) malloc( (in_hdr.xmax + 1) * 3 * sizeof(short));
     RLE_CHECK_ALLOC( cmd_nm, thisline, 0 );
     nextline = (short *) malloc( (in_hdr.xmax + 1) * 3 * sizeof(short));
     RLE_CHECK_ALLOC( cmd_nm, nextline, 0 );
 
     /* Store the first scanline into nextline */
 
     rle_getrow(&in_hdr,scan);
     rptr = scan[RLE_RED];
     gptr = scan[RLE_GREEN];
     bptr = scan[RLE_BLUE];
     nextptr = nextline;
     for (j=0; j <= in_hdr.xmax; j++)
     {
     *nextptr++ = *bptr++ ;
     *nextptr++ = *gptr++ ;
     *nextptr++ = *rptr++ ;
     }
 
     for (i=in_hdr.ymin; i <= in_hdr.ymax; i++)
     {
     /* swap nextline into thisline and read new nextline */
     tmpptr = thisline ;
     thisline = nextline ;
     nextline = tmpptr ;
     lastline = (i == in_hdr.ymax) ;
     if (!lastline)
     {
         rle_getrow(&in_hdr,scan);
         rptr = scan[RLE_RED];
         gptr = scan[RLE_GREEN];
         bptr = scan[RLE_BLUE];
         nextptr = nextline;
         for (j=0; j <= in_hdr.xmax; j++)
         {
         *nextptr++ = *bptr++ ;
         *nextptr++ = *gptr++ ;
         *nextptr++ = *rptr++ ;
         }
     }
 
     optr = scan[RLE_RED];
     thisptr = thisline ;
     nextptr = nextline ;
 
     for(j=0; j <= in_hdr.xmax ; j++)
     {
         int red,green,blue ;
         rle_pixel r2,g2,b2 ;
 
         lastpixel = (j == in_hdr.xmax) ;
 
         blue = *thisptr++ ;
         green = *thisptr++ ;
         red = *thisptr++ ;
 
         /* Current pixel has been accumulating error, it could be
          * out of range.
          */
         if( red < 0 ) red = 0 ;
         else if( red > 255 ) red = 255 ;
         if( green < 0 ) green = 0 ;
         else if( green > 255 ) green = 255 ;
         if( blue < 0 ) blue = 0 ;
         else if( blue > 255 ) blue = 255 ;
 
         r2 = red;
         g2 = green;
         b2 = blue;
 
         tmp = FAST_PACK( r2, g2, b2 );
         if (hist[tmp] == NULL)
         {
         register color_box_t *tmp_cb;
         color_t ref_col;
         int dist;
 
         hist[tmp] = (histogram_t *) malloc( sizeof(histogram_t) );
         RLE_CHECK_ALLOC( cmd_nm, hist[tmp], 0 );
         hist[tmp]->color = tmp;
 
         /* The error propagation has produced a color that was
          * not in the original image (its not in the histogram!).
          * So, we need to find the closest color.
          */
         ref_col.r = TO_5_BITS( r2 );
         ref_col.g = TO_5_BITS( g2 );
         ref_col.b = TO_5_BITS( b2 );
 
         if ( cb_list )
         {
             dist = DISTANCE( ref_col, cb_list->color );
             hist[tmp]->color_ptr = cb_list;
             hist[tmp]->cmap_index = cb_list->cindex;
         
             TRACE( tmp_cb, cb_list )
             {
             register color_t *newcol = &tmp_cb->color;
             register newdist = DISTANCE( ref_col, *newcol );
 
             if ( newdist < dist )
             {
                 dist = newdist;
                 hist[tmp]->color_ptr = tmp_cb;
                 hist[tmp]->cmap_index = tmp_cb->cindex;
             }
             }
         }
         else
             fprintf( stderr, "Color box list is empty.\n" );
         }
         
         *optr++ = hist[tmp]->cmap_index;
         
         red -= FROM_5_BITS(hist[tmp]->color_ptr->color.r);
         green -= FROM_5_BITS(hist[tmp]->color_ptr->color.g);
         blue -= FROM_5_BITS(hist[tmp]->color_ptr->color.b);
 
         if( !lastpixel )
         {
         thisptr[0] += blue * 7 / 16 ;
         thisptr[1] += green * 7 / 16 ;
         thisptr[2] += red * 7 / 16 ;
         }
         if( !lastline )
         {
         if( j != 0 )
         {
             nextptr[-3] += blue * 3 / 16 ;
             nextptr[-2] += green * 3 / 16 ;
             nextptr[-1] += red * 3 / 16 ;
         }
         nextptr[0] += blue * 5 / 16 ;
         nextptr[1] += green * 5 / 16 ;
         nextptr[2] += red * 5 / 16 ;
         if( !lastpixel )
         {
             nextptr[3] += blue / 16 ;
             nextptr[4] += green / 16 ;
             nextptr[5] += red / 16 ;
         }
         nextptr += 3 ;
         }
     }
 
     rle_putrow( scan, in_hdr.xmax + 1, &out_hdr );
     }
     rle_puteof( &out_hdr );
 
     free( thisline );
     free( nextline );
 }

void quantize_rle ( )

void quantize_rle ( rle_pixel ** scan )

Definition at line 653 of file mcut.c.

 {
     register rle_pixel *rptr, *gptr, *bptr, *optr;
     register int i;
     int tmp;
 
     while ( rle_getrow(&in_hdr,scan) <= in_hdr.ymax )
     {
     optr = rptr = scan[RLE_RED];
     gptr = scan[RLE_GREEN];
     bptr = scan[RLE_BLUE];
 
     for ( i=0; i<=in_hdr.xmax; i++ )
     {
         tmp = FAST_PACK( *rptr++, *gptr++, *bptr++ );
         if (hist[tmp] == NULL)
         fprintf(stderr, "bogus hash: %d\n", tmp);
         *optr++ = hist[tmp]->cmap_index;
     }
 
     rle_putrow( scan, in_hdr.xmax + 1, &out_hdr );
     }
     rle_puteof( &out_hdr );
 }

void radix_sort ( )

void radix_sort	(	color_box_t *	bbox,
		int	start_bit,
		int	num_bits
	)

Definition at line 944 of file mcut.c.

Referenced by break_box().

 {
     int cmp_radices();
 
     mask = ~(~0 << num_bits) << start_bit;
 
     qsort( (char *)bbox->hist, bbox->hsize,
        sizeof(histogram_t *), cmp_radices );
 }

Here is the caller graph for this function:

void re_expand_map ( )

Definition at line 626 of file mcut.c.

References _color_box::cindex, _histogram::cmap_index, _histogram::color, _histogram::color_ptr, hist, hist_size, and resort_compare().

 {
     register int i;
     int resort_compare();
     histogram_t *tmp, **hist_ptr;
 
     qsort( hist, hist_size, sizeof( histogram_t * ), resort_compare );
     hist_ptr = &(hist[hist_size-1]);
     for ( i = hist_size-1; i >= 0; i-- )
     {
     (*hist_ptr)->cmap_index = (*hist_ptr)->color_ptr->cindex;
     tmp = *hist_ptr;
     if (tmp->color != i)    /* Don't stomp existing slot. */
     {
         hist[tmp->color] = tmp;
         *hist_ptr = NULL;
     }
     hist_ptr--;
     }
 }

Here is the call graph for this function:

int resort_compare	(	histogram_t **	c1,
		histogram_t **	c2
	)

Definition at line 855 of file mcut.c.

Referenced by re_expand_map().

 {
     return ( (*c1)->color > (*c2)->color );
 }

Here is the caller graph for this function:

void set_size_axis ( )

void set_size_axis ( color_box_t * cb )

Definition at line 868 of file mcut.c.

Referenced by sum_hist().

 {
     int rsize = cb->r.max - cb->r.min,
     gsize = cb->g.max - cb->g.min,
     bsize = cb->b.max - cb->b.min;
 
     if ( rsize > gsize )
     {
     if ( rsize > bsize )
     {
         cb->axis = RLE_RED;
         cb->size = rsize;
     }
     else
     {
         cb->axis = RLE_BLUE;
         cb->size = bsize;
     }
     }
     else
     {
     if ( gsize > bsize )
     {
         cb->axis = RLE_GREEN;
         cb->size = gsize;
     }
     else
     {
         cb->axis = RLE_BLUE;
         cb->size = bsize;
     }
     }
 }    

Here is the caller graph for this function:

color_box_t* split_box ( color_box_t * box )

Definition at line 480 of file mcut.c.

Referenced by break_box().

 {
     int t, i;
     color_box_t *newbox;
 
     if ( box->size <= 0 )
     return NULL;
 
     /* Calculate median of the box. */
     for ( t = 0, i = 0; i < box->hsize; i++ )
     if ( box->hist[i] )
     {
         if ( t+box->hist[i]->nsamples > box->nsamples/2 && t > 0 )
         break;
         t += box->hist[i]->nsamples;
     }
 
     /*
      * Allocate a new box and set the bounding box and histogram
      * stuff.  Note the new box gets the second half of the old box.
      */
     newbox = (color_box_t *) malloc( sizeof(color_box_t) );
     RLE_CHECK_ALLOC( cmd_nm, newbox, 0 );
     bzero( newbox, sizeof( color_box_t ) );
 
     newbox->hist = &box->hist[i];
     newbox->hsize = box->hsize - i;
     newbox->nsamples = box->nsamples - t;
     bound_rgb( newbox );
     set_size_axis( newbox );
     
     box->hsize = box->hsize - newbox->hsize;
     box->nsamples = box->nsamples - newbox->nsamples;
     bound_rgb( box );
     set_size_axis( box );
 
     return newbox;
 }

Here is the caller graph for this function:

void subdivide ( )

Definition at line 416 of file mcut.c.

References break_box(), cb_list_size, and max_colors.

 {
     while ( cb_list_size < max_colors )
     if ( break_box() )
         return;
 }

Here is the call graph for this function:

void sum_hist ( )

Definition at line 376 of file mcut.c.

References bound_rgb(), cb, cb_list, cb_list_size, cmd_nm, _color_box::hist, hist, hist_size, _color_box::hsize, _histogram::nsamples, _color_box::nsamples, and set_size_axis().

 {
     register int oldh, newh, i, total;
 
     /* Get a color box. */
     cb = (color_box_t *) malloc( sizeof( color_box_t ) );
     RLE_CHECK_ALLOC( cmd_nm, cb, 0 );
     bzero( cb, sizeof( color_box_t ) );
 
     /* Compact histogram. */
     for ( oldh = newh = 0; oldh < 32768; oldh++ )
     if ( hist[oldh] )
     {
         hist[newh] = hist[oldh];
         if ( oldh != newh ) hist[oldh] = NULL;
         newh++;
     }
     hist_size = cb->hsize = newh;
 
     /* Calculate total pixels. */
     for ( total = i = 0; i<cb->hsize; i++ )
     if ( hist[i] )
         total += hist[i]->nsamples;
 
     cb->hist = hist;
     cb->nsamples = total;
     bound_rgb( cb );
     set_size_axis( cb );
 
     cb_list = cb;
     cb_list_size = 1;
 }