rleccube.c File Reference

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

Include dependency graph for rleccube.c:

Go to the source code of this file.

Functions
void	main (int argc, char **argv)

Variables
char	rcsid [] = "$Header: /l/spencer/src/urt/tools/RCS/rleccube.c,v 3.0.1.1 1992/04/30 14:11:53 spencer Exp $"

Function Documentation

void main	(	int	argc,
		char **	argv
	)

Definition at line 70 of file rleccube.c.

{
    int     wflag = 0,
        squares_wide = 8;   /* Default squares/row. */
    int     cube_side = 64;     /* Default size of cube is 64x64x64. */
    double  step = 255. / 63.;  /* Corresponding step size. */
    int     oflag = 0;
    int     pflag = 0;
    int     nbits = 6;      /* 64 = 2^6 */
    char       *ofname = NULL;
    int r = 0, g, b;
    int x, y;
    rle_pixel **rows;
    
    if ( scanargs( argc, argv,
           "% p%- w%-squares-wide!d o%-outfile!s cube-side%d",
           &pflag, &wflag, &squares_wide,
           &oflag, &ofname, &cube_side ) == 0 )
    exit( 1 );

    if ( cube_side != 64 )
    {
    /* Error check. */
    if ( cube_side < 2 || cube_side > 256 )
    {
        fprintf( stderr,
             "%s: cube_side (%d given) must be >=2 and <= 256.\n",
             cmd_name( argv ), cube_side );
        exit( 1 );
    }
    /* Peano curve must have power of 2. */
    if ( pflag )
    {
        register int i;

        if ( cube_side > 64 )
        {
        fprintf( stderr,
     "%s: cube_side (%d given) must be <= 64 for Peano curve display.\n",
             cmd_name( argv ), cube_side );
        exit( 1 );
        }
        for ( nbits = 0, i = 1; i < cube_side; i <<= 1, nbits += 1 )
        ;
        if ( cube_side != i )
        fprintf( stderr,
     "%s: cube_side (%d given) adjusted to %d for Peano curve display.\n",
             cmd_name( argv ), cube_side, i );
        cube_side = i;
        if ( wflag )
        {
        fprintf( stderr,
     "%s: squares_wide (%d given) ignored for Peano curve display.\n",
             cmd_name( argv ), squares_wide );
        wflag = 0;
        }
    }
    /* Recompute step and squares_wide. */
    step = 255. / (cube_side - 1);
    if ( !wflag )
    {
        squares_wide = (int)sqrt((double)cube_side);

        /* If cube_side isn't an exact square, search for a larger
         * divisor of cube_side.
         */
        while ( cube_side % squares_wide != 0 )
        squares_wide++;
    }
    }

    /* Error check. */
    if ( wflag )
    {
    if ( squares_wide < 1 || squares_wide > cube_side )
    {
        fprintf( stderr,
             "%s: squares_wide (%d given) must be >= 1 and <= %d.",
             cmd_name( argv ), squares_wide, cube_side );
        exit( 1 );
    }
    if ( pflag )
    {
        fprintf( stderr,
         "%s: squares_wide (%d given) ignored for Peano curve display.\n",
             cmd_name( argv ), squares_wide );
        /* Note: only get here if cube_side was NOT given, so it's
         * safe to reset squares_wide to its default.
         */
        squares_wide = 8;
    }
    }

    /* Set up the output. */
    rle_dflt_hdr.xmin = rle_dflt_hdr.ymin = 0;
    rle_dflt_hdr.xmax = cube_side * squares_wide - 1;
    rle_dflt_hdr.ymax =
    cube_side * ((cube_side + squares_wide - 1) / squares_wide) - 1;
    rle_addhist( argv, NULL, &rle_dflt_hdr );
    rle_dflt_hdr.rle_file = rle_open_f( cmd_name( argv ), ofname, "w" );
    /* The other default values should be ok. */

    rle_put_setup( &rle_dflt_hdr );
    
    /* Allocate scanline memory. */
    if ( rle_row_alloc( &rle_dflt_hdr, &rows ) < 0 )
    RLE_CHECK_ALLOC( cmd_name( argv ), 0, 0 );

    for ( y = 0; y <= rle_dflt_hdr.ymax; y++ )
    {
    if ( !pflag )
    {
        /* Green is constant per scanline. */
        g = (int)(step * (y % cube_side));
        for ( x = 0; x <= rle_dflt_hdr.xmax; x++ )
        rows[1][x] = g;

        /* If first scanline of a new row, recompute red and blue. */
        if ( g == 0 )
        for ( x = 0; x <= rle_dflt_hdr.xmax; x++ )
        {
            b = (int)(step * (x % cube_side));
            if ( b == 0 )
            r = (int)(step * (x / cube_side +
                      squares_wide * y / cube_side));

            rows[0][x] = r;
            rows[2][x] = b;
        }
    }
    else
    {
        long int r;
        int a[2], c[3];
        int two_d_bits = (nbits * 3 / 2),
            two_d_max = 1 << two_d_bits,
            max_r = 1 << (3 * nbits);

        /* For each pixel on the scan-line, find its peano index
         * and get the corresponding color.
         */
        a[1] = y;
        for ( x = 0; x <= rle_dflt_hdr.xmax; x++ )
        {
        if ( x < two_d_max )
            a[0] = x;
        else
            a[0] = 2 * two_d_max - x - 1;
        hilbert_c2i( 2, nbits * 3 / 2, a, &r );
        if ( x >= two_d_max )
            r = max_r - r - 1;
        hilbert_i2c( 3, nbits, r, c );
        rows[0][x] = c[0] << (8 - nbits);
        rows[1][x] = c[1] << (8 - nbits);
        rows[2][x] = c[2] << (8 - nbits);
        }
    }
    
    rle_putrow( rows, squares_wide * cube_side, &rle_dflt_hdr );
    }

    /* All done. */
    rle_puteof( &rle_dflt_hdr );
    exit( 0 );
}

Variable Documentation

char rcsid[] = "$Header: /l/spencer/src/urt/tools/RCS/rleccube.c,v 3.0.1.1 1992/04/30 14:11:53 spencer Exp $"

Definition at line 28 of file rleccube.c.