#include "vizual.h"

/********************************  cap_data  **********************************/

void draw_cap_side(D_spec, Headp, G3header, D_Cap, type)
     struct dspec *D_spec;
     file_info *Headp;
     file_info *G3header;
     struct Cap *D_Cap;
     int type;
{
    int t, y, z;
    int xdim, ydim, zdim;
    int xysize;
    FILE *fp;
    float *DB;
    int old = 0;
    int yloop, zloop;
    int ystart, zstart;
    int xrc, yrc, zrc;
    int offset;

    *(D_Cap->D_buff) = '\0';
    fp = G3header->datainfp;

    xdim = G3header->xdim;
    ydim = G3header->ydim;
    zdim = G3header->zdim;
    xysize = xdim * ydim;

    build_thresh_arrays(D_spec, Headp);

    /*
     **      Old DSPF Cubes are 3 less than the number of data points across
     **      in each dimension.  Thus to make Grid3 match up with
     **      Cubes, we have to throw away the outer points of each side 
     **      Check difference in dimensions to see if we have an old 
     **      or new file.
     */


    if ((xdim - Headp->xdim > 1) ||
	(ydim - Headp->ydim > 1) || (zdim - Headp->zdim > 1))
	old = 1;


    if (old) {
	yloop = ydim - 1;
	ystart = 1;
	zloop = zdim - 1;
	zstart = 1;
	xrc = xdim - 2;
	yrc = ydim - 2;
	zrc = zdim - 2;
	offset = 1;
    }
    else {
	yloop = ydim;
	ystart = 0;
	zloop = zdim;
	zstart = 0;
	xrc = xdim;
	yrc = ydim;
	zrc = zdim;
	offset = 0;
    }

    for (t = 0; t < 6; t++) {

	if (!(type & (1 << t)))
	    continue;

	DB = D_Cap->D_buff;
	D_Cap->side = t;

	switch (t) {
	case 0:		/*xyplane  z = zdim */
	    D_Cap->reverse = 1;
	    D_Cap->minx = D_spec->B[X];
	    D_Cap->miny = D_spec->B[Y];
	    D_Cap->maxx = D_spec->E[X];
	    D_Cap->maxy = D_spec->E[Y];

	    D_Cap->z = D_spec->E[Z];

	    D_Cap->Rows = yrc;
	    D_Cap->Cols = xrc;
	    for (y = ystart; y < yloop; y++) {
		G_fseek(fp, D_offset +
		      (xysize * (D_spec->E[Z]) + y * xdim + offset) *
		      sizeof(float), 0);
		fread(DB, xrc, sizeof(float), fp);
		DB += xrc;
	    }
	    break;
	case 1:		/*xyplane z = 0 */
	    D_Cap->reverse = 0;
	    D_Cap->minx = D_spec->B[X];
	    D_Cap->miny = D_spec->B[Y];
	    D_Cap->maxx = D_spec->E[X];
	    D_Cap->maxy = D_spec->E[Y];

	    D_Cap->z = D_spec->B[Z];

	    D_Cap->Rows = yrc;
	    D_Cap->Cols = xrc;
	    for (y = ystart; y < yloop; y++) {
		G_fseek(fp, D_offset +
		      (xysize * (D_spec->B[Z] + offset) + y * xdim + offset) *
		      sizeof(float), 0);
		fread(DB, xrc, sizeof(float), fp);
		DB += xrc;
	    }
	    break;
	case 2:		/*yzplane x=xdim */
	    D_Cap->reverse = 0;
	    D_Cap->minx = D_spec->B[Y];
	    D_Cap->miny = D_spec->B[Z];
	    D_Cap->maxx = D_spec->E[Y];
	    D_Cap->maxy = D_spec->E[Z];

	    D_Cap->z = D_spec->E[X];
	    D_Cap->Rows = zrc;
	    D_Cap->Cols = yrc;

	    for (z = zstart; z < zloop; z++) {
		for (y = ystart; y < yloop; y++) {
		    G_fseek(fp, D_offset +
			  (xysize * z + xdim * y + (D_spec->E[X] + offset)) *
			  sizeof(float), 0);
		    fread(DB++, sizeof(float), 1, fp);
		}
	    }
	    break;
	case 3:		/*yzplane  x = 0 */
	    D_Cap->reverse = 1;
	    D_Cap->minx = D_spec->B[Y];
	    D_Cap->miny = D_spec->B[Z];
	    D_Cap->maxx = D_spec->E[Y];
	    D_Cap->maxy = D_spec->E[Z];

	    D_Cap->z = D_spec->B[X];

	    D_Cap->Rows = zrc;
	    D_Cap->Cols = yrc;

	    for (z = zstart; z < zloop; z++) {
		for (y = ystart; y < yloop; y++) {
		    G_fseek(fp, D_offset +
			  (xysize * z + xdim * y + (D_spec->B[X] + offset)) *
			  sizeof(float), 0);
		    fread(DB++, sizeof(float), 1, fp);
		}
	    }
	    break;
	case 4:		/*xzplane y = ydim */
	    D_Cap->reverse = 0;
	    D_Cap->minx = D_spec->B[X];
	    D_Cap->miny = D_spec->B[Z];
	    D_Cap->maxx = D_spec->E[X];
	    D_Cap->maxy = D_spec->E[Z];
	    D_Cap->z = D_spec->E[Y];
	    D_Cap->Rows = zrc;
	    D_Cap->Cols = xrc;
	    for (z = zstart; z < zloop; z++) {
		/* fill in the buff one line at a time */
		G_fseek(fp, D_offset +
		      (xysize * z + xdim * (D_spec->E[Y] + offset) + offset) *
		      sizeof(float), 0);
		fread(DB, sizeof(float), xrc, fp);
		DB += xrc;
	    }
	    break;
	case 5:		/*xzplane y = 0 */
	    D_Cap->reverse = 1;
	    D_Cap->minx = D_spec->B[X];
	    D_Cap->miny = D_spec->B[Z];
	    D_Cap->maxx = D_spec->E[X];
	    D_Cap->maxy = D_spec->E[Z];
	    D_Cap->z = D_spec->B[Y];
	    D_Cap->Rows = zrc;
	    D_Cap->Cols = xrc;
	    for (z = zstart; z < zloop; z++) {
		/* fill in the buff one line at a time */
		G_fseek(fp, D_offset +
		      (xysize * z + xdim * (D_spec->B[Y] + offset) + offset) *
		      sizeof(float), 0);
		fread(DB, sizeof(float), xrc, fp);

		DB += xrc;
	    }
	    break;

	}
	draw_cap(Headp, D_spec, D_Cap);
    }
}