text: #line 124 "/home/qiang/src/splash2/splash2-master/codes/null_macros/c.m4.null.POSIX_sel4"
  
  #line 1 "huprn.C"
  /*************************************************************************/
  /*                                                                       */
  /*  Copyright (c) 1994 Stanford University                               */
  /*                                                                       */
  /*  All rights reserved.                                                 */
  /*                                                                       */
  /*  Permission is given to use, copy, and modify this software for any   */
  /*  non-commercial purpose as long as this copyright notice is not       */
  /*  removed.  All other uses, including redistribution in whole or in    */
  /*  part, are forbidden without prior written permission.                */
  /*                                                                       */
  /*  This software is provided with absolutely no warranty and no         */
  /*  support.                                                             */
  /*                                                                       */
  /*************************************************************************/
  
  
  /*
   * NAME
   *	huprn.c
   *
   * DESCRIPTION
   *	This file contains routines that walk and print most all data
   *	structures relating to the HU grid.
   */
  
  
  #include <stdio.h>
  #include <math.h>
  #include "rt.h"
  
  VOID	prn_voxel(VOXEL *v)
  	{
  	ELEMENT *pe, **pepa;
  	GRID	*g;
  	INT	i;
  
  	fprintf(stderr, "    Print Voxel  id = %ld \n", v->id);
  	fprintf(stderr, "        celltype %d \n", v->celltype);
  
  	if (v->celltype == GSM_VOXEL)
  		{
  		fprintf(stderr, "        gsm_voxel \n");
  		fprintf(stderr, "        primElement index list:\n");
  
  		pepa = (ELEMENT**)v->cell;
  
  
  		for (i=0; i < v->numelements; i++)
  			{
  			pe = pepa[i];
  			fprintf(stderr, "            %ld \n", pe->index);
  			}
  		}
  
  	if (v->celltype == GSM_GRID)
  		{
  		g = (GRID *)v->cell;
  		prn_grid(g);
  		fprintf(stderr, "        gsm_grid id %ld \n", g->id);
  		}
  
  	fprintf(stderr, "    End Voxel \n");
  	}
  
  
  
  VOID	prn_grid(GRID *g)
  	{
  	INT	i;
  	INT	n;
  	GRID	*ng;
  	VOXEL	*v;
  
  	fprintf(stderr, "    Print  Grid %ld \n",                      g->id);
  	fprintf(stderr, "        num_prims = %ld \n",                  g->num_prims);
  	fprintf(stderr, "        indx_inc[0,1,2] = %ld, %ld, %ld \n",  g->indx_inc[0], g->indx_inc[1], g->indx_inc[2]);
  	fprintf(stderr, "        num_buckets = %ld \n",                g->num_buckets);
  	fprintf(stderr, "        min[0,1,2] = %lf, %lf, %lf \n",       g->min[0], g->min[1], g->min[2] );
  	fprintf(stderr, "        cellsize[0,1,2] = %lf, %lf, %lf \n",  g->cellsize[0], g->cellsize[1], g->cellsize[2]);
  	fprintf(stderr, "        subdiv_level = %ld \n",               g->subdiv_level);
  
  	if (g->next != NULL)
  		{
  		ng = g->next;
  		fprintf(stderr, "        next grid id %ld \n", ng->id);
  		}
  	else
  		fprintf(stderr, "        next grid id NULL \n");
  
  	fprintf(stderr, "    Voxel List \n");
  
  	n = g->indx_inc[1] * g->indx_inc[2];
  
  	for (i = 0; i < n; i++)
  		{
  		if (lookup_emptycells(i, g) == EMPTY)
  			fprintf(stderr, "        Voxel %ld is empty. \n", i);
  		else
  			{
  			v = lookup_hashtable(i, g);
  			prn_voxel(v);
  			}
  		}
  
  
  	fprintf(stderr, "    End Grid \n");
  	}
  
  
  
  VOID	prn_ray(RAY *r)
  	{
  	RAYINFO *ri;
  	GRID	*g;
  
  	fprintf(stderr, "    Print Ray  id %ld \n",                             r->id );
  	fprintf(stderr, "        origin:        ( %lf, %lf, %lf ) \n",          r->P[0], r->P[1], r->P[2]);
  	fprintf(stderr, "        direction:     ( %lf, %lf, %lf ) \n",          r->D[0], r->D[1], r->D[2] );
  	fprintf(stderr, "        indx_inc3D[0,1,2] = [ %ld, %ld, %ld ] \n",     r->indx_inc3D[0],r->indx_inc3D[1],r->indx_inc3D[2] );
  	fprintf(stderr, "        ri_indx = %ld \n",                             r->ri_indx);
  	fprintf(stderr, "        rayinfo: \n");
  
  	ri = r->ri;
  	g  = ri->grid;
  
  	fprintf(stderr, "            ray is in grid %ld \n",                    g->id );
  	fprintf(stderr, "            d[0,1,2] = [ %lf, %lf, %lf ] \n",          ri->d[0], ri->d[1], ri->d[2]);
  	fprintf(stderr, "            entry_plane %ld \n",                       ri->entry_plane );
  	fprintf(stderr, "            t_in = %lf \n",                            ri->t_in );
  	fprintf(stderr, "            exit_plane %ld \n",                        ri->exit_plane );
  	fprintf(stderr, "            t_out = %lf \n",                           ri->t_out );
  	fprintf(stderr, "            delta[0,1,2] = [ %lf, %lf, %lf ] \n",      ri->delta[0], ri->delta[1], ri->delta[2]);
  	fprintf(stderr, "            index3D[0,1,2] = [ %ld, %ld, %ld ] \n",    ri->index3D[0], ri->index3D[1], ri->index3D[2]);
  	fprintf(stderr, "            index1D = %ld \n",                         ri->index1D );
  	fprintf(stderr, "            indx_inc1D[0,1,2] = [ %ld, %ld, %ld ] \n", ri->indx_inc1D[0], ri->indx_inc1D[1], ri->indx_inc1D[2]);
  	fprintf(stderr, "    End Ray \n");
  	}
  
  
  
  VOID	prn_PrimElem(ELEMENT *p)
  	{
  	BBOX	b;
  
  	if (p == NULL)
  		{
  		fprintf(stderr, "%s: prn_PrimElem: Null pointer.\n", ProgName);
  		exit(-1);
  		}
  
  	fprintf(stderr, "PrimElem: index %ld  ptr %p, PrimObj index %ld ptr %p \n",
  		p->index, p,  p->parent->index,   p->parent);
  
  	b = p->bv;
  
  	fprintf(stderr, "   BBox: ( %lf, %lf, %lf ) -> \n         ( %lf, %lf, %lf ) \n",
  		b.dnear[0],b.dnear[1],b.dnear[2],b.dfar[0],b.dfar[1],b.dfar[2] );
  	}
  
  
  
  VOID	prn_bintree_node(BTNODE *b)
  	{
  	INT	i;
  
  	fprintf(stderr, "Bintree node: \n");
  	fprintf(stderr, "    indecies of cell: ( %ld, %ld, %ld ) \n",           b->i[0], b->i[1], b->i[2]);
  	fprintf(stderr, "    gridsizes: ( %ld, %ld, %ld ) \n",                  b->n[0], b->n[1], b->n[2]);
  	fprintf(stderr, "    minimum point ( %lf, %lf, %lf ) \n",               b->p[0], b->p[1], b->p[2]);
  	fprintf(stderr, "    subdiv axis %ld \n",                               b->axis);
  	fprintf(stderr, "    number of primitives %ld \n",                      b->nprims);
  	fprintf(stderr, "    Primitive element list: \n");
  
  	if (b->nprims > 0)
  		for (i = 0; i < b->nprims; i++)
  			{
  			fprintf(stderr, "  %ld", b->pe[i]->index);
  
  			if (i % 8 == 7)
  				fprintf(stderr, "\n");
  			}
  
  	fprintf(stderr, "\n    End of bintree node \n");
  	}
  
  
  
  
  VOID	prn_bintree_leaves(BTNODE *root)
  	{
  	BTNODE	*b;
  
  	b = root;
  	if (b->axis == -1)
  		prn_bintree_node(b);
  	else
  		{
  		prn_bintree_leaves(b->btn[0]);
  		prn_bintree_leaves(b->btn[1]);
  		}
  	}
  
  
  VOID	prn_pepa_prim_list(ELEMENT **pepa, INT nprims)
  	{
  	INT	i;
  
  	if (nprims > 0)
  		{
  		for (i = 0; i < nprims; i++)
  			{
  			fprintf(stderr, "  %ld", pepa[i]->index);
  
  			if (i % 8 == 7)
  				fprintf(stderr, "\n");
  			}
  		}
  	}
  