src/hd/rhcopy.c

#ifndef lint
static const char       RCSid[] = "$Id: rhcopy.c,v 3.33 2019/11/07 23:17:58 greg Exp $";
#endif
/*
 * Copy data into a holodeck file
 */

#include "platform.h"
#include "rterror.h"
#include "holo.h"
#include "view.h"

#ifndef BKBSIZE
#define BKBSIZE         256             /* beam clump size (kilobytes) */
#endif
                                /* possible operations */
#define FROM_HOLO       1               /* copy between holodecks */
#define FROM_PICZ       2               /* copy from HDR + depth to holodeck */
#define FROM_STDIN      3               /* copy from stdin to holodeck */
#define TO_STDOUT       4               /* copy rays from holodeck to stdout */

int     operation = 0;          /* what we are doing */
char    *rspec = "";            /* ray details for i/o */
int     checkdepth = 1;         /* check depth (!-d option)? */
int     checkrepeats = 0;       /* check for repeats (-u option)? */
int     nholosects;             /* number of original holodeck sections */
int     iofmt = 'a';            /* input/output format for rays */

                                /* holodeck flags */
#define H_BADF          01              /* bad format */
#define H_OBST          02              /* OBSTRUCTIONS= True */
#define H_OBSF          04              /* OBSTRUCTIONS= False */
#define H_VDST          010             /* VDISTANCE= True */
#define H_SWAP          020             /* byte order is different */

char    *progname;              /* global argv[0] */

struct phead {
        VIEW    vw;
        double  expos;
        short   gotview;
        short   badfmt;
        short   altprims;
};

typedef struct {
        FVECT   ro;
        FVECT   rd;
        RREAL   d;
        COLR    cv;
} RAYPAR;

static int openholo(char *fname, int append);
static void addray(RAYPAR *rp);
static int readval(RREAL *v, int n, FILE *fp);
static void readrays(FILE *fp);
static int writeval(RREAL *v, int n, FILE *fp);
static int write_ray(RAYPAR *rp, FILE *fp);
static void writerays(FILE *fp);
static gethfunc holheadline;
static int bpcmp(const void *b1p, const void *b2p);
static int addclump(HOLO *hp, int *bq, int nb);
static void addholo(char *hdf);
static gethfunc picheadline;
static void addpicz(char *pcf, char *zbf);


int
main(
        int     argc,
        char    *argv[]
)
{
        int     i;

        progname = argv[0];
        for (i = 2; i < argc && argv[i][0] == '-'; i++)
                switch (argv[i][1]) {
                case 'u':
                        checkrepeats = 1;
                        break;
                case 'd':
                        checkdepth = 0;
                        break;
                case 'f':
                        iofmt = argv[i][2];
                        if (!strchr("afd", iofmt))
                                error(USER, "-f? i/o format must be 'a', 'f', or 'd'");
                        break;
                case 'h':
                        operation = FROM_HOLO;
                        break;
                case 'p':
                        operation = FROM_PICZ;
                        break;
                case 'i':
                        operation = FROM_STDIN;
                        rspec = argv[i]+2;
                        break;
                case 'o':
                        operation = TO_STDOUT;
                        rspec = argv[i]+2;
                        break;
                default:
                        goto userr;
                }
        if (!operation | (i > argc-((operation==FROM_HOLO)|(operation==FROM_PICZ))))
                goto userr;
        if (operation == FROM_PICZ && (argc-i)%2)
                goto userr;
        nholosects = openholo(argv[1], (operation != TO_STDOUT));
                                        /* check requested i/o is compatible */
        if (strchr(rspec, 'l') && !(*(int *)hdlist[0]->priv & H_VDST))
                error(USER, "i/o parameter 'l' incompatible with VDISTANCE=False");
        if (strchr(rspec, 'L') && *(int *)hdlist[0]->priv & H_VDST)
                error(USER, "i/o parameter 'L' incompatible with VDISTANCE=True");

        switch (operation) {            /* perform requested operation */
        case FROM_PICZ:
                for ( ; i < argc; i += 2)
                        addpicz(argv[i], argv[i+1]);
                break;
        case FROM_HOLO:
                if (BKBSIZE*1024*1.5 > hdcachesize)
                        hdcachesize = BKBSIZE*1024*1.5;
                for ( ; i < argc; i++)
                        addholo(argv[i]);
                break;
        case FROM_STDIN:
                readrays(stdin);
                break;
        case TO_STDOUT:
                writerays(stdout);
                break;
        }
        quit(0);
userr:
        fprintf(stderr, "Usage: %s dest.hdk [-u][-d] -h inp1.hdk ..\n",
                        progname);
        fprintf(stderr, "   Or: %s dest.hdk [-u][-d] -p inp1.hdr inp1.zbf ..\n",
                        progname);
        fprintf(stderr, "   Or: %s dest.hdk [-f{a|f|d}][-u][-d] -i[odplLv]\n",
                        progname);
        fprintf(stderr, "   Or: %s src.hdk [-f{a|f|d}] -o[odplLv] ..\n",
                        progname);
        exit(1);
}

static int
holheadline(            /* check holodeck header line */
        char    *s,
        void    *vhf
)
{
        int     be;
        char    fmt[MAXFMTLEN];
        int     *hf = (int *)vhf;

        if (formatval(fmt, s)) {
                if (strcmp(fmt, HOLOFMT))
                        *hf |= H_BADF;
                else
                        *hf &= ~H_BADF;
                return(0);
        }
        if (!strncmp(s, "OBSTRUCTIONS=", 13)) {
                s += 13;
                while (*s == ' ') s++;
                if ((*s == 't') | (*s == 'T'))
                        *hf |= H_OBST;
                else if ((*s == 'f') | (*s == 'F'))
                        *hf |= H_OBSF;
                else
                        error(WARNING, "bad OBSTRUCTIONS value in holodeck");
                return(0);
        }
        if (!strncmp(s, "VDISTANCE=", 10)) {
                s += 10;
                while (*s == ' ') s++;
                if ((*s == 't') | (*s == 'T'))
                        *hf |= H_VDST;
                else if ((*s != 'f') % (*s != 'F'))
                        error(WARNING, "bad VDISTANCE value in holodeck");
                return(0);
        }
        if ((be = isbigendian(s)) >= 0) {
                if (be != nativebigendian())
                        *hf |= H_SWAP;
                return(0);
        }
        return(0);
}

int
openholo(               /* open existing holodeck file for i/o */
        char    *fname,
        int     append
)
{
        FILE    *fp;
        int     fd;
        int     hflags = 0;
        int     *hfstore;
        off_t   nextloc;
        int     n;
                                        /* open holodeck file */
        if ((fp = fopen(fname, append ? "rb+" : "rb")) == NULL) {
                sprintf(errmsg, "cannot open \"%s\" for %s", fname,
                                append ? "appending" : "reading");
                error(SYSTEM, errmsg);
        }
                                        /* check header and magic number */
        if (getheader(fp, holheadline, &hflags) < 0 ||
                        hflags&(H_BADF|H_SWAP) || getw(fp) != HOLOMAGIC) {
                sprintf(errmsg, "holodeck \"%s\" not in expected format", fname);
                error(USER, errmsg);
        }
        fd = dup(fileno(fp));                   /* dup file handle */
        nextloc = ftell(fp);                    /* get stdio position */
        fclose(fp);                             /* done with stdio */
        hfstore = (int *)malloc(sizeof(int));   /* tiny memory leak but who cares? */
        *hfstore = hflags;
        for (n = 0; nextloc > 0L; n++) {        /* initialize each section */
                lseek(fd, nextloc, SEEK_SET);
                read(fd, (char *)&nextloc, sizeof(nextloc));
                hdinit(fd, NULL)->priv = hfstore;
        }
        return(n);
}

void
addray(         /* add a ray to our output holodeck */
        RAYPAR *rp
)
{
        int     sn, bi, n;
        HOLO    *hp;
        GCOORD  gc[2];
        uby8    rr[2][2];
        BEAM    *bp;
        double  d0, d1;
        unsigned        dc;
        RAYVAL  *rv;
                                /* check each output section */
        for (sn = nholosects; sn--; ) {
                hp = hdlist[sn];
                d0 = hdinter(gc, rr, &d1, hp, rp->ro, rp->rd);
                if (rp->d <= d0 || d1 < -0.001)
                        continue;       /* missed section */
                if (checkdepth) {               /* check depth */
                        if (*(int *)hp->priv & H_OBST && d0 < -0.001)
                                continue;       /* ray starts too late */
                        if (*(int *)hp->priv & H_OBSF && rp->d < 0.999*d1)
                                continue;       /* ray ends too soon */
                }
                dc = hdcode(hp, rp->d-d0);
                bi = hdbindex(hp, gc);          /* check for duplicates */
                if (checkrepeats && (bp = hdgetbeam(hp, bi)) != NULL) {
                        for (n = bp->nrm, rv = hdbray(bp); n--; rv++)
                                if ((rv->d == dc || *(int *)hp->priv & (H_OBST|H_OBSF)) &&
                                                rv->r[0][0] == rr[0][0] &&
                                                rv->r[0][1] == rr[0][1] &&
                                                rv->r[1][0] == rr[1][0] &&
                                                rv->r[1][1] == rr[1][1])
                                        break;
                        if (n >= 0)
                                continue;       /* found a matching ray */
                }
                rv = hdnewrays(hp, bi, 1);
                rv->d = dc;
                rv->r[0][0] = rr[0][0]; rv->r[0][1] = rr[0][1];
                rv->r[1][0] = rr[1][0]; rv->r[1][1] = rr[1][1];
                copycolr(rv->v, rp->cv);
        }
}

/* Read n-vector from file stream */
static int
readval(RREAL *v, int n, FILE *fp)
{
        int     i;
#ifdef SMLFLT
        double  vd[3];
        switch (iofmt) {
        case 'f':
                return getbinary(v, sizeof(float), n, fp);
        case 'd':
                n = getbinary(vd, sizeof(double), n, fp);
                for (i = n; i-- > 0; ) v[i] = vd[i];
                return n;
        case 'a':
                for (i = 0; i < n; i++)
                        if (fscanf(fp, "%f ", &v[i]) != 1)
                                break;
                return i;
        }
#else
        float   vf[3];
        switch (iofmt) {
        case 'd':
                return getbinary(v, sizeof(double), n, fp);
        case 'f':
                n = getbinary(vf, sizeof(float), n, fp);
                for (i = n; i-- > 0; ) v[i] = vf[i];
                return n;
        case 'a':
                for (i = 0; i < n; i++)
                        if (fscanf(fp, "%lf ", &v[i]) != 1)
                                break;
                return i;
        }
#endif
        return -1;
}

#define GOT_ORG         0x01
#define GOT_DIR         0x02
#define GOT_LEN         0x04
#define GOT_VAL         0x10
#define ALSO_POS        0x20
#define BAD_DIR         0x40
#define BAD_LEN         0x80

/* Read rays from stream and add to holodeck */
static void
readrays(FILE *fp)
{
        if (iofmt != 'a')
                SET_FILE_BINARY(fp);
#ifdef getc_unlocked
        flockfile(fp);
#endif
        while (!feof(fp)) {             /* read entirety of input */
                RAYPAR  ryp;
                FVECT   pos;
                FVECT   col;
                int     flags = 0;
                int     i;
                for (i = 0; rspec[i]; i++) {
                        switch (rspec[i]) {
                        case 'o':               /* ray origin */
                                if (readval(ryp.ro, 3, fp) < 3)
                                        break;
                                flags |= GOT_ORG;
                                continue;
                        case 'd':               /* ray direction */
                                if (readval(ryp.rd, 3, fp) < 3)
                                        break;
                                if (normalize(ryp.rd) == 0)
                                        flags |= BAD_DIR;
                                else
                                        flags |= GOT_DIR;
                                continue;
                        case 'p':               /* ray intersection */
                                if (readval(pos, 3, fp) < 3)
                                        break;
                                flags |= ALSO_POS;
                                continue;
                        case 'L':               /* ray first length */
                        case 'l':               /* ray virtual length */
                                if (readval(&ryp.d, 1, fp) < 1)
                                        break;
                                if (ryp.d <= FTINY)
                                        flags |= BAD_LEN;
                                else
                                        flags |= GOT_LEN;
                                continue;
                        case 'v':               /* ray value */
                                if (readval(col, 3, fp) < 3)
                                        break;
                                setcolr(ryp.cv, col[0], col[1], col[2]);
                                flags |= GOT_VAL;
                                continue;
                        default:
                                sprintf(errmsg, "unsupported parameter '%c' in -i%s",
                                                rspec[i], rspec);
                                error(USER, errmsg);
                        }
                        if (!flags)     /* got nothing, so may be normal EOF */
                                return;
                }
                if (flags & (BAD_DIR|BAD_LEN))
                        continue;       /* just a bad ray is all -- skip */
                if (!(flags & GOT_VAL))
                        goto missingData;
                if ((flags & (GOT_ORG|GOT_DIR|GOT_LEN)) != (GOT_ORG|GOT_DIR|GOT_LEN)) {
                        if (!(flags & ALSO_POS))
                                goto missingData;
                        if (flags & GOT_ORG) {
                                VSUB(ryp.rd, pos, ryp.ro);
                                ryp.d = normalize(ryp.rd);
                                if (ryp.d == 0)
                                        continue;
                        } else if ((flags & (GOT_DIR|GOT_LEN)) == (GOT_DIR|GOT_LEN)) {
                                VSUM(ryp.ro, pos, ryp.rd, -ryp.d);
                        } else
                                goto missingData;
                }
                addray(&ryp);           /* add our ray to holodeck */
        }
        return;
missingData:
        sprintf(errmsg, "insufficient data in -i%s", rspec);
        error(USER, errmsg);
}

/* Write vector value to file stream */
static int
writeval(RREAL *v, int n, FILE *fp)
{
        int     i;

        if (iofmt == 'a') {
                for (i = 0; i < n; i++)
                        if (fprintf(fp, "\t%.4e", v[i]) < 0)
                                break;
                return i;
        }
#ifdef SMLFLT
        if (iofmt == 'd') {
                double  vd[3];
                for (i = n; i--; ) vd[i] = v[i];
                return putbinary(vd, sizeof(double), n, fp);
        }
#else
        if (iofmt == 'f') {
                float   vf[3];
                for (i = n; i--; ) vf[i] = v[i];
                return putbinary(vf, sizeof(float), n, fp);
        }
#endif
        return putbinary(v, sizeof(*v), n, fp);
}

/* Write out an individual ray as requested */
static int
write_ray(RAYPAR *rp, FILE *fp)
{
        COLOR   cval;
        FVECT   v3;
        char    *typ = rspec;

        for ( ; ; ) {
                switch (*typ++) {
                case 'o':               /* ray origin */
                        if (writeval(rp->ro, 3, fp) < 3)
                                break;
                        continue;
                case 'd':               /* ray direction */
                        if (writeval(rp->rd, 3, fp) < 3)
                                break;
                        continue;
                case 'p':               /* ray intersection */
                        VSUM(v3, rp->ro, rp->rd, rp->d);
                        if (writeval(v3, 3, fp) < 3)
                                break;
                        continue;
                case 'L':               /* ray first length */
                case 'l':               /* ray virtual length */
                        if (writeval(&rp->d, 1, fp) < 1)
                                break;
                        continue;
                case 'v':               /* ray value */
                        colr_color(cval, rp->cv);
                        VCOPY(v3, cval);
                        if (writeval(v3, 3, fp) < 3)
                                break;
                        continue;
                case '\0':              /* end of spec -- success */
                        if (iofmt == 'a')
                                fputc('\n', fp);
                        return(1);
                default:
                        sprintf(errmsg, "unsupported parameter '%c' in -o%s", typ[-1], rspec);
                }
                break;                  /* land here on error */
        }
        return 0;                       /* write error? */
}

/* Write all rays from holodeck to stream */
static void
writerays(FILE *fp)
{
        int     sn, bi, k;
        GCOORD  gc[2];
        RAYVAL  *rv;
        RAYPAR  ryp;

        if (!*rspec) {
                error(WARNING, "empty -o* output spec, quitting");
                return;
        }
        if (iofmt != 'a')
                SET_FILE_BINARY(fp);
#ifdef getc_unlocked
        flockfile(fp);
#endif
        for (sn = 0; sn < nholosects; sn++) {   /* write each holodeck section */
                HOLO    *hp = hdlist[sn];
                for (bi = nbeams(hp); bi > 0; bi--) {
                        BEAM    *bp = hdgetbeam(hp, bi);
                        if (!bp)                /* empty beam? */
                                continue;
                        hdbcoord(gc, hp, bi);   /* else write rays */
                        rv = hdbray(bp);
                        for (k = bp->nrm; k--; rv++) {
                                ryp.d = hdray(ryp.ro, ryp.rd, hp, gc, rv->r);
                                if (*(int *)hp->priv & H_OBSF)
                                        VSUM(ryp.ro, ryp.ro, ryp.rd, ryp.d);
                                else
                                        ryp.d = 0.;
                                ryp.d = hddepth(hp, rv->d) - ryp.d;
                                copycolr(ryp.cv, rv->v);
                                if (!write_ray(&ryp, fp))
                                        goto writError;
                        }
                        hdfreebeam(hp, bi);
                }
        }
        if (fflush(fp) != EOF)
                return;
writError:
        error(SYSTEM, "error writing holodeck rays");
}

static BEAMI    *beamdir;

static int
bpcmp(                  /* compare beam positions on disk */
        const void      *b1p,
        const void      *b2p
)
{
        off_t   pdif = beamdir[*(int*)b1p].fo - beamdir[*(int*)b2p].fo;

        if (pdif > 0L) return(1);
        if (pdif < 0L) return(-1);
        return(0);
}

static int
addclump(               /* transfer the given clump and free */
        HOLO    *hp,
        int     *bq,
        int     nb
)
{
        GCOORD  gc[2];
        RAYPAR  ryp;
        RAYVAL  *rv;
        int     i;
        int     k;
        BEAM    *bp;
                                        /* sort based on file position */
        beamdir = hp->bi;
        qsort((char *)bq, nb, sizeof(*bq), bpcmp);
                                        /* transfer each beam */
        for (i = 0; i < nb; i++) {
                bp = hdgetbeam(hp, bq[i]);
                hdbcoord(gc, hp, bq[i]);
                rv = hdbray(bp);                        /* add each ray to output */
                for (k = bp->nrm; k--; rv++) {
                        ryp.d = hdray(ryp.ro, ryp.rd, hp, gc, rv->r);
                        if (*(int *)hp->priv & H_OBSF)
                                VSUM(ryp.ro, ryp.ro, ryp.rd, ryp.d);
                        else
                                ryp.d = 0.;
                        ryp.d = hddepth(hp, rv->d) - ryp.d;
                        copycolr(ryp.cv, rv->v);
                        addray(&ryp);
                }
                hdfreebeam(hp, bq[i]);          /* free the beam */
        }
        return(0);
}


void
addholo(                        /* add a holodeck file */
        char    *hdf
)
{
        int     fd;
                                        /* open the holodeck for reading */
        openholo(hdf, 0);
        fd = hdlist[nholosects]->fd;    /* remember the file handle */
        while (hdlist[nholosects] != NULL) {    /* load each section */
                                                        /* clump the beams */
                clumpbeams(hdlist[nholosects], 0, BKBSIZE*1024, addclump);
                hddone(hdlist[nholosects]);             /* free the section */
        }
        close(fd);                      /* close input file */
        hdflush(NULL);                  /* flush output */
}


static int
picheadline(            /* process picture header line */
        char    *s,
        void    *vph
)
{
        char    fmt[32];
        struct phead *ph = (struct phead *)vph;

        if (formatval(fmt, s)) {
                ph->badfmt = strcmp(fmt, COLRFMT);
                return(0);
        }
        if (isprims(s)) {
                ph->altprims++;         /* don't want to deal with this */
                return(0);
        }
        if (isexpos(s)) {
                ph->expos *= exposval(s);
                return(0);
        }
        if (isview(s)) {
                ph->gotview += sscanview(&ph->vw, s);
                return(0);
        }
        return(0);
}


void
addpicz(                /* add a picture + depth-buffer */
        char    *pcf,
        char    *zbf
)
{
        FILE    *pfp;
        int     zfd;
        COLR    *cscn;
        float   *zscn;
        struct phead    phd;
        int     eshft;
        double  emult;
        RESOLU  prs;
        RREAL   vl[2];
        RAYPAR  ryp;
        double  aftd;
        int     j, i;
                                /* open picture & get header */
        if ((pfp = fopen(pcf, "rb")) == NULL) {
                sprintf(errmsg, "cannot open picture file \"%s\"", pcf);
                error(SYSTEM, pcf);
        }
        phd.vw = stdview;
        phd.expos = 1.0;
        phd.badfmt = phd.gotview = phd.altprims = 0;
        if (getheader(pfp, picheadline, &phd) < 0 ||
                        phd.badfmt || !fgetsresolu(&prs, pfp)) {
                sprintf(errmsg, "bad format for picture file \"%s\"", pcf);
                error(USER, errmsg);
        }
        if (!phd.gotview || setview(&phd.vw) != NULL) {
                sprintf(errmsg, "missing/illegal view in picture \"%s\"",
                                pcf);
                error(USER, errmsg);
        }
        if (phd.altprims) {
                sprintf(errmsg, "ignoring color primaries in picture \"%s\"",
                                pcf);
                error(WARNING, errmsg);
        }
                                /* open depth buffer */
        if ((zfd = open_float_depth(zbf, prs.xr*prs.yr)) < 0)
                quit(1);
                                /* figure out what to do about exposure */
        if ((phd.expos < 0.99) | (phd.expos > 1.01)) {
                emult = -log(phd.expos)/log(2.);
                eshft = emult >= 0. ? emult+.5 : emult-.5;
                emult -= (double)eshft;
                if ((emult <= 0.01) & (emult >= -0.01))
                        emult = -1.;
                else {
                        emult = 1./phd.expos;
                        eshft = 0;
                }
        } else {
                emult = -1.;
                eshft = 0;
        }
                                /* allocate buffers */
        cscn = (COLR *)malloc(scanlen(&prs)*sizeof(COLR));
        zscn = (float *)malloc(scanlen(&prs)*sizeof(float));
        if ((cscn == NULL) | (zscn == NULL))
                error(SYSTEM, "out of memory in addpicz");
                                /* read and process each scanline */
        for (j = 0; j < numscans(&prs); j++) {
                i = scanlen(&prs);                      /* read colrs */
                if (freadcolrs(cscn, i, pfp) < 0) {
                        sprintf(errmsg, "error reading picture \"%s\"", pcf);
                        error(USER, errmsg);
                }
                if (eshft)                              /* shift exposure */
                        shiftcolrs(cscn, i, eshft);
                                                        /* read depth */
                if (read(zfd, zscn, i*sizeof(float)) != i*sizeof(float)) {
                        sprintf(errmsg, "error reading depth file \"%s\"", zbf);
                        error(USER, errmsg);
                }
                while (i--) {                           /* process each pixel */
                        if (zscn[i] <= 0.0)
                                continue;               /* illegal depth */
                        pix2loc(vl, &prs, i, j);
                        aftd = viewray(ryp.ro, ryp.rd, &phd.vw, vl[0], vl[1]);
                        if (aftd < -FTINY)
                                continue;               /* off view */
                        if (aftd > FTINY && zscn[i] > aftd)
                                continue;               /* aft clipped */
                        ryp.d = (RREAL)zscn[i];
                        copycolr(ryp.cv, cscn[i]);
                        if (emult > 0.) {               /* whatta pain */
                                COLOR   ctmp;
                                colr_color(ctmp, ryp.cv);
                                scalecolor(ctmp, emult);
                                setcolr(ryp.cv, colval(ctmp,RED),
                                        colval(ctmp,GRN), colval(ctmp,BLU));
                        }
                        addray(&ryp);
                }
        }
                                /* write output and free beams */
        hdflush(NULL);
                                /* clean up */
        free((void *)cscn);
        free((void *)zscn);
        fclose(pfp);
        close(zfd);
}


void
eputs(                  /* put error message to stderr */
        char  *s
)
{
        static int  midline = 0;

        if (!*s)
                return;
        if (!midline++) {       /* prepend line with program name */
                fputs(progname, stderr);
                fputs(": ", stderr);
        }
        fputs(s, stderr);
        if (s[strlen(s)-1] == '\n') {
                fflush(stderr);
                midline = 0;
        }
}


void
quit(                   /* exit the program gracefully */
        int     code
)
{
        hdsync(NULL, 1);        /* write out any buffered data */
        exit(code);
}
Revision:	3.34
Committed:	Wed Nov 16 00:12:49 2022 UTC (17 months, 2 weeks ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 3.33:	+374 -72 lines
Log Message:	feat(rhcopy): Added -i* and -o* options for reading and writing rays
#	User	Rev	Content
1	gregl	3.1	#ifndef lint
2	greg	3.34	static const char RCSid[] = "$Id: rhcopy.c,v 3.33 2019/11/07 23:17:58 greg Exp $";
3	gregl	3.1	#endif
4			/*
5			* Copy data into a holodeck file
6			*/
7
8	greg	3.21	#include "platform.h"
9	schorsch	3.22	#include "rterror.h"
10	gregl	3.1	#include "holo.h"
11			#include "view.h"
12
13	gwlarson	3.10	#ifndef BKBSIZE
14			#define BKBSIZE 256 /* beam clump size (kilobytes) */
15	gregl	3.7	#endif
16	greg	3.34	/* possible operations */
17			#define FROM_HOLO 1 /* copy between holodecks */
18			#define FROM_PICZ 2 /* copy from HDR + depth to holodeck */
19			#define FROM_STDIN 3 /* copy from stdin to holodeck */
20			#define TO_STDOUT 4 /* copy rays from holodeck to stdout */
21	gregl	3.7
22	greg	3.34	int operation = 0; /* what we are doing */
23			char rspec = ""; / ray details for i/o */
24	gwlarson	3.14	int checkdepth = 1; /* check depth (!-d option)? */
25			int checkrepeats = 0; /* check for repeats (-u option)? */
26	greg	3.34	int nholosects; /* number of original holodeck sections */
27			int iofmt = 'a'; /* input/output format for rays */
28
29			/* holodeck flags */
30			#define H_BADF 01 /* bad format */
31			#define H_OBST 02 /* OBSTRUCTIONS= True */
32			#define H_OBSF 04 /* OBSTRUCTIONS= False */
33			#define H_VDST 010 /* VDISTANCE= True */
34			#define H_SWAP 020 /* byte order is different */
35	gregl	3.1
36			char progname; / global argv[0] */
37
38	schorsch	3.22	struct phead {
39			VIEW vw;
40			double expos;
41			short gotview;
42			short badfmt;
43			short altprims;
44			};
45	greg	3.34
46			typedef struct {
47			FVECT ro;
48			FVECT rd;
49			RREAL d;
50			COLR cv;
51			} RAYPAR;
52
53	schorsch	3.22	static int openholo(char *fname, int append);
54	greg	3.34	static void addray(RAYPAR *rp);
55			static int readval(RREAL v, int n, FILE fp);
56			static void readrays(FILE *fp);
57			static int writeval(RREAL v, int n, FILE fp);
58			static int write_ray(RAYPAR rp, FILE fp);
59			static void writerays(FILE *fp);
60	schorsch	3.23	static gethfunc holheadline;
61	schorsch	3.22	static int bpcmp(const void b1p, const void b2p);
62			static int addclump(HOLO hp, int bq, int nb);
63			static void addholo(char *hdf);
64	schorsch	3.23	static gethfunc picheadline;
65	schorsch	3.22	static void addpicz(char pcf, char zbf);
66
67
68			int
69			main(
70			int argc,
71			char *argv[]
72			)
73	gregl	3.1	{
74			int i;
75
76			progname = argv[0];
77	gregl	3.5	for (i = 2; i < argc && argv[i][0] == '-'; i++)
78			switch (argv[i][1]) {
79	gregl	3.8	case 'u':
80	gregl	3.5	checkrepeats = 1;
81			break;
82	gregl	3.8	case 'd':
83	gregl	3.5	checkdepth = 0;
84			break;
85	greg	3.34	case 'f':
86			iofmt = argv[i][2];
87			if (!strchr("afd", iofmt))
88			error(USER, "-f? i/o format must be 'a', 'f', or 'd'");
89			break;
90	gregl	3.5	case 'h':
91	greg	3.34	operation = FROM_HOLO;
92	gregl	3.5	break;
93			case 'p':
94	greg	3.34	operation = FROM_PICZ;
95			break;
96			case 'i':
97			operation = FROM_STDIN;
98			rspec = argv[i]+2;
99			break;
100			case 'o':
101			operation = TO_STDOUT;
102			rspec = argv[i]+2;
103	gregl	3.5	break;
104			default:
105			goto userr;
106			}
107	greg	3.34	if (!operation \| (i > argc-((operation==FROM_HOLO)\|(operation==FROM_PICZ))))
108	gregl	3.1	goto userr;
109	greg	3.34	if (operation == FROM_PICZ && (argc-i)%2)
110	gregl	3.1	goto userr;
111	greg	3.34	nholosects = openholo(argv[1], (operation != TO_STDOUT));
112			/* check requested i/o is compatible */
113			if (strchr(rspec, 'l') && !((int )hdlist[0]->priv & H_VDST))
114			error(USER, "i/o parameter 'l' incompatible with VDISTANCE=False");
115			if (strchr(rspec, 'L') && (int )hdlist[0]->priv & H_VDST)
116			error(USER, "i/o parameter 'L' incompatible with VDISTANCE=True");
117
118			switch (operation) { /* perform requested operation */
119			case FROM_PICZ:
120	gregl	3.5	for ( ; i < argc; i += 2)
121	gregl	3.1	addpicz(argv[i], argv[i+1]);
122	greg	3.34	break;
123			case FROM_HOLO:
124	gwlarson	3.10	if (BKBSIZE10241.5 > hdcachesize)
125			hdcachesize = BKBSIZE10241.5;
126	gregl	3.5	for ( ; i < argc; i++)
127	gregl	3.1	addholo(argv[i]);
128	greg	3.34	break;
129			case FROM_STDIN:
130			readrays(stdin);
131			break;
132			case TO_STDOUT:
133			writerays(stdout);
134			break;
135	gwlarson	3.10	}
136	gregl	3.1	quit(0);
137			userr:
138	greg	3.34	fprintf(stderr, "Usage: %s dest.hdk [-u][-d] -h inp1.hdk ..\n",
139	gregl	3.1	progname);
140	greg	3.34	fprintf(stderr, " Or: %s dest.hdk [-u][-d] -p inp1.hdr inp1.zbf ..\n",
141			progname);
142			fprintf(stderr, " Or: %s dest.hdk [-f{a\|f\|d}][-u][-d] -i[odplLv]\n",
143			progname);
144			fprintf(stderr, " Or: %s src.hdk [-f{a\|f\|d}] -o[odplLv] ..\n",
145	gregl	3.5	progname);
146	gregl	3.1	exit(1);
147			}
148
149	schorsch	3.23	static int
150	schorsch	3.22	holheadline( /* check holodeck header line */
151	greg	3.31	char *s,
152	schorsch	3.23	void *vhf
153	schorsch	3.22	)
154	gregl	3.1	{
155	greg	3.33	int be;
156	greg	3.30	char fmt[MAXFMTLEN];
157	greg	3.34	int hf = (int )vhf;
158	gregl	3.1
159			if (formatval(fmt, s)) {
160	gregl	3.2	if (strcmp(fmt, HOLOFMT))
161			*hf \|= H_BADF;
162			else
163			*hf &= ~H_BADF;
164	gwlarson	3.9	return(0);
165	gregl	3.1	}
166			if (!strncmp(s, "OBSTRUCTIONS=", 13)) {
167			s += 13;
168			while (*s == ' ') s++;
169	schorsch	3.19	if ((s == 't') \| (s == 'T'))
170	gregl	3.2	*hf \|= H_OBST;
171	schorsch	3.19	else if ((s == 'f') \| (s == 'F'))
172	gregl	3.2	*hf \|= H_OBSF;
173	gregl	3.1	else
174			error(WARNING, "bad OBSTRUCTIONS value in holodeck");
175	gwlarson	3.9	return(0);
176	gregl	3.1	}
177	greg	3.34	if (!strncmp(s, "VDISTANCE=", 10)) {
178			s += 10;
179			while (*s == ' ') s++;
180			if ((s == 't') \| (s == 'T'))
181			*hf \|= H_VDST;
182			else if ((s != 'f') % (s != 'F'))
183			error(WARNING, "bad VDISTANCE value in holodeck");
184			return(0);
185			}
186	greg	3.33	if ((be = isbigendian(s)) >= 0) {
187			if (be != nativebigendian())
188			*hf \|= H_SWAP;
189	greg	3.34	return(0);
190	greg	3.33	}
191	gwlarson	3.9	return(0);
192	gregl	3.1	}
193
194			int
195	schorsch	3.22	openholo( /* open existing holodeck file for i/o */
196			char *fname,
197			int append
198			)
199	gregl	3.1	{
200			FILE *fp;
201			int fd;
202	gregl	3.2	int hflags = 0;
203	greg	3.34	int *hfstore;
204	greg	3.26	off_t nextloc;
205	gregl	3.1	int n;
206			/* open holodeck file */
207	greg	3.32	if ((fp = fopen(fname, append ? "rb+" : "rb")) == NULL) {
208	gregl	3.1	sprintf(errmsg, "cannot open \"%s\" for %s", fname,
209			append ? "appending" : "reading");
210			error(SYSTEM, errmsg);
211			}
212			/* check header and magic number */
213	schorsch	3.23	if (getheader(fp, holheadline, &hflags) < 0 \|\|
214	greg	3.33	hflags&(H_BADF\|H_SWAP) \|\| getw(fp) != HOLOMAGIC) {
215			sprintf(errmsg, "holodeck \"%s\" not in expected format", fname);
216	gregl	3.1	error(USER, errmsg);
217			}
218			fd = dup(fileno(fp)); /* dup file handle */
219			nextloc = ftell(fp); /* get stdio position */
220			fclose(fp); /* done with stdio */
221	greg	3.34	hfstore = (int )malloc(sizeof(int)); / tiny memory leak but who cares? */
222			*hfstore = hflags;
223	gregl	3.1	for (n = 0; nextloc > 0L; n++) { /* initialize each section */
224	greg	3.26	lseek(fd, nextloc, SEEK_SET);
225	gregl	3.1	read(fd, (char *)&nextloc, sizeof(nextloc));
226	greg	3.34	hdinit(fd, NULL)->priv = hfstore;
227	gregl	3.1	}
228			return(n);
229			}
230
231	schorsch	3.22	void
232			addray( /* add a ray to our output holodeck */
233	greg	3.34	RAYPAR *rp
234	schorsch	3.22	)
235	gregl	3.1	{
236	gregl	3.5	int sn, bi, n;
237	greg	3.31	HOLO *hp;
238	gregl	3.1	GCOORD gc[2];
239	greg	3.27	uby8 rr[2][2];
240	gregl	3.5	BEAM *bp;
241	gregl	3.1	double d0, d1;
242	gregl	3.5	unsigned dc;
243	greg	3.31	RAYVAL *rv;
244	gregl	3.1	/* check each output section */
245	greg	3.34	for (sn = nholosects; sn--; ) {
246	gregl	3.1	hp = hdlist[sn];
247	greg	3.34	d0 = hdinter(gc, rr, &d1, hp, rp->ro, rp->rd);
248			if (rp->d <= d0 \|\| d1 < -0.001)
249	gregl	3.1	continue; /* missed section */
250	gregl	3.5	if (checkdepth) { /* check depth */
251	greg	3.34	if ((int )hp->priv & H_OBST && d0 < -0.001)
252	gregl	3.5	continue; /* ray starts too late */
253	greg	3.34	if ((int )hp->priv & H_OBSF && rp->d < 0.999*d1)
254	gregl	3.5	continue; /* ray ends too soon */
255			}
256	greg	3.34	dc = hdcode(hp, rp->d-d0);
257	gregl	3.5	bi = hdbindex(hp, gc); /* check for duplicates */
258			if (checkrepeats && (bp = hdgetbeam(hp, bi)) != NULL) {
259			for (n = bp->nrm, rv = hdbray(bp); n--; rv++)
260	greg	3.34	if ((rv->d == dc \|\| (int )hp->priv & (H_OBST\|H_OBSF)) &&
261	gregl	3.5	rv->r[0][0] == rr[0][0] &&
262			rv->r[0][1] == rr[0][1] &&
263			rv->r[1][0] == rr[1][0] &&
264			rv->r[1][1] == rr[1][1])
265			break;
266			if (n >= 0)
267			continue; /* found a matching ray */
268			}
269			rv = hdnewrays(hp, bi, 1);
270			rv->d = dc;
271	gregl	3.1	rv->r[0][0] = rr[0][0]; rv->r[0][1] = rr[0][1];
272			rv->r[1][0] = rr[1][0]; rv->r[1][1] = rr[1][1];
273	greg	3.34	copycolr(rv->v, rp->cv);
274			}
275			}
276
277			/* Read n-vector from file stream */
278			static int
279			readval(RREAL v, int n, FILE fp)
280			{
281			int i;
282			#ifdef SMLFLT
283			double vd[3];
284			switch (iofmt) {
285			case 'f':
286			return getbinary(v, sizeof(float), n, fp);
287			case 'd':
288			n = getbinary(vd, sizeof(double), n, fp);
289			for (i = n; i-- > 0; ) v[i] = vd[i];
290			return n;
291			case 'a':
292			for (i = 0; i < n; i++)
293			if (fscanf(fp, "%f ", &v[i]) != 1)
294			break;
295			return i;
296			}
297			#else
298			float vf[3];
299			switch (iofmt) {
300			case 'd':
301			return getbinary(v, sizeof(double), n, fp);
302			case 'f':
303			n = getbinary(vf, sizeof(float), n, fp);
304			for (i = n; i-- > 0; ) v[i] = vf[i];
305			return n;
306			case 'a':
307			for (i = 0; i < n; i++)
308			if (fscanf(fp, "%lf ", &v[i]) != 1)
309			break;
310			return i;
311			}
312			#endif
313			return -1;
314			}
315
316			#define GOT_ORG 0x01
317			#define GOT_DIR 0x02
318			#define GOT_LEN 0x04
319			#define GOT_VAL 0x10
320			#define ALSO_POS 0x20
321			#define BAD_DIR 0x40
322			#define BAD_LEN 0x80
323
324			/* Read rays from stream and add to holodeck */
325			static void
326			readrays(FILE *fp)
327			{
328			if (iofmt != 'a')
329			SET_FILE_BINARY(fp);
330			#ifdef getc_unlocked
331			flockfile(fp);
332			#endif
333			while (!feof(fp)) { /* read entirety of input */
334			RAYPAR ryp;
335			FVECT pos;
336			FVECT col;
337			int flags = 0;
338			int i;
339			for (i = 0; rspec[i]; i++) {
340			switch (rspec[i]) {
341			case 'o': /* ray origin */
342			if (readval(ryp.ro, 3, fp) < 3)
343			break;
344			flags \|= GOT_ORG;
345			continue;
346			case 'd': /* ray direction */
347			if (readval(ryp.rd, 3, fp) < 3)
348			break;
349			if (normalize(ryp.rd) == 0)
350			flags \|= BAD_DIR;
351			else
352			flags \|= GOT_DIR;
353			continue;
354			case 'p': /* ray intersection */
355			if (readval(pos, 3, fp) < 3)
356			break;
357			flags \|= ALSO_POS;
358			continue;
359			case 'L': /* ray first length */
360			case 'l': /* ray virtual length */
361			if (readval(&ryp.d, 1, fp) < 1)
362			break;
363			if (ryp.d <= FTINY)
364			flags \|= BAD_LEN;
365			else
366			flags \|= GOT_LEN;
367			continue;
368			case 'v': /* ray value */
369			if (readval(col, 3, fp) < 3)
370			break;
371			setcolr(ryp.cv, col[0], col[1], col[2]);
372			flags \|= GOT_VAL;
373			continue;
374			default:
375			sprintf(errmsg, "unsupported parameter '%c' in -i%s",
376			rspec[i], rspec);
377			error(USER, errmsg);
378			}
379			if (!flags) /* got nothing, so may be normal EOF */
380			return;
381			}
382			if (flags & (BAD_DIR\|BAD_LEN))
383			continue; /* just a bad ray is all -- skip */
384			if (!(flags & GOT_VAL))
385			goto missingData;
386			if ((flags & (GOT_ORG\|GOT_DIR\|GOT_LEN)) != (GOT_ORG\|GOT_DIR\|GOT_LEN)) {
387			if (!(flags & ALSO_POS))
388			goto missingData;
389			if (flags & GOT_ORG) {
390			VSUB(ryp.rd, pos, ryp.ro);
391			ryp.d = normalize(ryp.rd);
392			if (ryp.d == 0)
393			continue;
394			} else if ((flags & (GOT_DIR\|GOT_LEN)) == (GOT_DIR\|GOT_LEN)) {
395			VSUM(ryp.ro, pos, ryp.rd, -ryp.d);
396			} else
397			goto missingData;
398			}
399			addray(&ryp); /* add our ray to holodeck */
400			}
401			return;
402			missingData:
403			sprintf(errmsg, "insufficient data in -i%s", rspec);
404			error(USER, errmsg);
405			}
406
407			/* Write vector value to file stream */
408			static int
409			writeval(RREAL v, int n, FILE fp)
410			{
411			int i;
412
413			if (iofmt == 'a') {
414			for (i = 0; i < n; i++)
415			if (fprintf(fp, "\t%.4e", v[i]) < 0)
416			break;
417			return i;
418			}
419			#ifdef SMLFLT
420			if (iofmt == 'd') {
421			double vd[3];
422			for (i = n; i--; ) vd[i] = v[i];
423			return putbinary(vd, sizeof(double), n, fp);
424			}
425			#else
426			if (iofmt == 'f') {
427			float vf[3];
428			for (i = n; i--; ) vf[i] = v[i];
429			return putbinary(vf, sizeof(float), n, fp);
430	gregl	3.1	}
431	greg	3.34	#endif
432			return putbinary(v, sizeof(*v), n, fp);
433	gregl	3.1	}
434
435	greg	3.34	/* Write out an individual ray as requested */
436			static int
437			write_ray(RAYPAR rp, FILE fp)
438			{
439			COLOR cval;
440			FVECT v3;
441			char *typ = rspec;
442
443			for ( ; ; ) {
444			switch (*typ++) {
445			case 'o': /* ray origin */
446			if (writeval(rp->ro, 3, fp) < 3)
447			break;
448			continue;
449			case 'd': /* ray direction */
450			if (writeval(rp->rd, 3, fp) < 3)
451			break;
452			continue;
453			case 'p': /* ray intersection */
454			VSUM(v3, rp->ro, rp->rd, rp->d);
455			if (writeval(v3, 3, fp) < 3)
456			break;
457			continue;
458			case 'L': /* ray first length */
459			case 'l': /* ray virtual length */
460			if (writeval(&rp->d, 1, fp) < 1)
461			break;
462			continue;
463			case 'v': /* ray value */
464			colr_color(cval, rp->cv);
465			VCOPY(v3, cval);
466			if (writeval(v3, 3, fp) < 3)
467			break;
468			continue;
469			case '\0': /* end of spec -- success */
470			if (iofmt == 'a')
471			fputc('\n', fp);
472			return(1);
473			default:
474			sprintf(errmsg, "unsupported parameter '%c' in -o%s", typ[-1], rspec);
475			}
476			break; /* land here on error */
477			}
478			return 0; /* write error? */
479			}
480
481			/* Write all rays from holodeck to stream */
482			static void
483			writerays(FILE *fp)
484			{
485			int sn, bi, k;
486			GCOORD gc[2];
487			RAYVAL *rv;
488			RAYPAR ryp;
489
490			if (!*rspec) {
491			error(WARNING, "empty -o* output spec, quitting");
492			return;
493			}
494			if (iofmt != 'a')
495			SET_FILE_BINARY(fp);
496			#ifdef getc_unlocked
497			flockfile(fp);
498			#endif
499			for (sn = 0; sn < nholosects; sn++) { /* write each holodeck section */
500			HOLO *hp = hdlist[sn];
501			for (bi = nbeams(hp); bi > 0; bi--) {
502			BEAM *bp = hdgetbeam(hp, bi);
503			if (!bp) /* empty beam? */
504			continue;
505			hdbcoord(gc, hp, bi); /* else write rays */
506			rv = hdbray(bp);
507			for (k = bp->nrm; k--; rv++) {
508			ryp.d = hdray(ryp.ro, ryp.rd, hp, gc, rv->r);
509			if ((int )hp->priv & H_OBSF)
510			VSUM(ryp.ro, ryp.ro, ryp.rd, ryp.d);
511			else
512			ryp.d = 0.;
513			ryp.d = hddepth(hp, rv->d) - ryp.d;
514			copycolr(ryp.cv, rv->v);
515			if (!write_ray(&ryp, fp))
516			goto writError;
517			}
518			hdfreebeam(hp, bi);
519			}
520			}
521			if (fflush(fp) != EOF)
522			return;
523			writError:
524			error(SYSTEM, "error writing holodeck rays");
525			}
526	gregl	3.1
527	gwlarson	3.11	static BEAMI *beamdir;
528
529			static int
530	schorsch	3.22	bpcmp( /* compare beam positions on disk */
531			const void *b1p,
532			const void *b2p
533			)
534	gregl	3.1	{
535	greg	3.31	off_t pdif = beamdir[(int)b1p].fo - beamdir[(int)b2p].fo;
536	gwlarson	3.11
537			if (pdif > 0L) return(1);
538			if (pdif < 0L) return(-1);
539			return(0);
540			}
541
542			static int
543	schorsch	3.22	addclump( /* transfer the given clump and free */
544			HOLO *hp,
545			int *bq,
546			int nb
547			)
548	gwlarson	3.11	{
549	gregl	3.1	GCOORD gc[2];
550	greg	3.34	RAYPAR ryp;
551			RAYVAL *rv;
552	gwlarson	3.11	int i;
553	greg	3.31	int k;
554			BEAM *bp;
555	gwlarson	3.11	/* sort based on file position */
556			beamdir = hp->bi;
557			qsort((char )bq, nb, sizeof(bq), bpcmp);
558			/* transfer each beam */
559			for (i = 0; i < nb; i++) {
560			bp = hdgetbeam(hp, bq[i]);
561			hdbcoord(gc, hp, bq[i]);
562	greg	3.34	rv = hdbray(bp); /* add each ray to output */
563			for (k = bp->nrm; k--; rv++) {
564			ryp.d = hdray(ryp.ro, ryp.rd, hp, gc, rv->r);
565			if ((int )hp->priv & H_OBSF)
566			VSUM(ryp.ro, ryp.ro, ryp.rd, ryp.d);
567	gwlarson	3.11	else
568	greg	3.34	ryp.d = 0.;
569			ryp.d = hddepth(hp, rv->d) - ryp.d;
570			copycolr(ryp.cv, rv->v);
571			addray(&ryp);
572	gwlarson	3.11	}
573			hdfreebeam(hp, bq[i]); /* free the beam */
574	gwlarson	3.10	}
575	gwlarson	3.11	return(0);
576	gwlarson	3.10	}
577
578	schorsch	3.22
579			void
580			addholo( /* add a holodeck file */
581			char *hdf
582			)
583	gwlarson	3.10	{
584			int fd;
585	gregl	3.4	/* open the holodeck for reading */
586			openholo(hdf, 0);
587	greg	3.34	fd = hdlist[nholosects]->fd; /* remember the file handle */
588			while (hdlist[nholosects] != NULL) { /* load each section */
589	gwlarson	3.10	/* clump the beams */
590	greg	3.34	clumpbeams(hdlist[nholosects], 0, BKBSIZE*1024, addclump);
591			hddone(hdlist[nholosects]); /* free the section */
592	gregl	3.1	}
593	gwlarson	3.10	close(fd); /* close input file */
594	gwlarson	3.13	hdflush(NULL); /* flush output */
595	gregl	3.1	}
596
597
598
599	schorsch	3.23	static int
600	schorsch	3.22	picheadline( /* process picture header line */
601			char *s,
602	schorsch	3.23	void *vph
603	schorsch	3.22	)
604	gregl	3.1	{
605			char fmt[32];
606	greg	3.34	struct phead ph = (struct phead )vph;
607	gregl	3.1
608			if (formatval(fmt, s)) {
609			ph->badfmt = strcmp(fmt, COLRFMT);
610	gwlarson	3.9	return(0);
611	gregl	3.1	}
612			if (isprims(s)) {
613			ph->altprims++; /* don't want to deal with this */
614	gwlarson	3.9	return(0);
615	gregl	3.1	}
616			if (isexpos(s)) {
617			ph->expos *= exposval(s);
618	gwlarson	3.9	return(0);
619	gregl	3.1	}
620			if (isview(s)) {
621			ph->gotview += sscanview(&ph->vw, s);
622	gwlarson	3.9	return(0);
623	gregl	3.1	}
624	gwlarson	3.9	return(0);
625	gregl	3.1	}
626
627
628	schorsch	3.22	void
629			addpicz( /* add a picture + depth-buffer */
630			char *pcf,
631			char *zbf
632			)
633	gregl	3.1	{
634			FILE *pfp;
635			int zfd;
636			COLR *cscn;
637			float *zscn;
638			struct phead phd;
639			int eshft;
640			double emult;
641			RESOLU prs;
642	schorsch	3.17	RREAL vl[2];
643	greg	3.34	RAYPAR ryp;
644	gregl	3.1	double aftd;
645	greg	3.34	int j, i;
646			/* open picture & get header */
647	greg	3.32	if ((pfp = fopen(pcf, "rb")) == NULL) {
648	gregl	3.1	sprintf(errmsg, "cannot open picture file \"%s\"", pcf);
649			error(SYSTEM, pcf);
650			}
651	schorsch	3.18	phd.vw = stdview;
652	gregl	3.1	phd.expos = 1.0;
653			phd.badfmt = phd.gotview = phd.altprims = 0;
654	schorsch	3.23	if (getheader(pfp, picheadline, &phd) < 0 \|\|
655	gregl	3.1	phd.badfmt \|\| !fgetsresolu(&prs, pfp)) {
656			sprintf(errmsg, "bad format for picture file \"%s\"", pcf);
657			error(USER, errmsg);
658			}
659			if (!phd.gotview \|\| setview(&phd.vw) != NULL) {
660			sprintf(errmsg, "missing/illegal view in picture \"%s\"",
661			pcf);
662			error(USER, errmsg);
663			}
664			if (phd.altprims) {
665	greg	3.28	sprintf(errmsg, "ignoring color primaries in picture \"%s\"",
666	gregl	3.1	pcf);
667			error(WARNING, errmsg);
668			}
669	greg	3.34	/* open depth buffer */
670			if ((zfd = open_float_depth(zbf, prs.xr*prs.yr)) < 0)
671			quit(1);
672	gregl	3.1	/* figure out what to do about exposure */
673	schorsch	3.19	if ((phd.expos < 0.99) \| (phd.expos > 1.01)) {
674	gregl	3.1	emult = -log(phd.expos)/log(2.);
675			eshft = emult >= 0. ? emult+.5 : emult-.5;
676			emult -= (double)eshft;
677	schorsch	3.19	if ((emult <= 0.01) & (emult >= -0.01))
678	gregl	3.1	emult = -1.;
679			else {
680			emult = 1./phd.expos;
681			eshft = 0;
682			}
683			} else {
684			emult = -1.;
685			eshft = 0;
686			}
687			/* allocate buffers */
688			cscn = (COLR )malloc(scanlen(&prs)sizeof(COLR));
689			zscn = (float )malloc(scanlen(&prs)sizeof(float));
690	schorsch	3.19	if ((cscn == NULL) \| (zscn == NULL))
691	gregl	3.1	error(SYSTEM, "out of memory in addpicz");
692			/* read and process each scanline */
693			for (j = 0; j < numscans(&prs); j++) {
694			i = scanlen(&prs); /* read colrs */
695			if (freadcolrs(cscn, i, pfp) < 0) {
696			sprintf(errmsg, "error reading picture \"%s\"", pcf);
697			error(USER, errmsg);
698			}
699			if (eshft) /* shift exposure */
700			shiftcolrs(cscn, i, eshft);
701	greg	3.32	/* read depth */
702			if (read(zfd, zscn, isizeof(float)) != isizeof(float)) {
703	gregl	3.1	sprintf(errmsg, "error reading depth file \"%s\"", zbf);
704			error(USER, errmsg);
705			}
706	greg	3.32	while (i--) { /* process each pixel */
707	greg	3.29	if (zscn[i] <= 0.0)
708			continue; /* illegal depth */
709	gregl	3.1	pix2loc(vl, &prs, i, j);
710	greg	3.34	aftd = viewray(ryp.ro, ryp.rd, &phd.vw, vl[0], vl[1]);
711	gregl	3.1	if (aftd < -FTINY)
712			continue; /* off view */
713			if (aftd > FTINY && zscn[i] > aftd)
714			continue; /* aft clipped */
715	greg	3.34	ryp.d = (RREAL)zscn[i];
716			copycolr(ryp.cv, cscn[i]);
717	gregl	3.1	if (emult > 0.) { /* whatta pain */
718	greg	3.34	COLOR ctmp;
719			colr_color(ctmp, ryp.cv);
720	gregl	3.1	scalecolor(ctmp, emult);
721	greg	3.34	setcolr(ryp.cv, colval(ctmp,RED),
722	gregl	3.1	colval(ctmp,GRN), colval(ctmp,BLU));
723			}
724	greg	3.34	addray(&ryp);
725	gregl	3.1	}
726			}
727	gwlarson	3.11	/* write output and free beams */
728			hdflush(NULL);
729	gregl	3.1	/* clean up */
730	greg	3.15	free((void *)cscn);
731			free((void *)zscn);
732	gregl	3.1	fclose(pfp);
733			close(zfd);
734			}
735
736
737	greg	3.15	void
738	schorsch	3.22	eputs( /* put error message to stderr */
739	greg	3.31	char *s
740	schorsch	3.22	)
741	gregl	3.1	{
742			static int midline = 0;
743
744			if (!*s)
745			return;
746			if (!midline++) { /* prepend line with program name */
747			fputs(progname, stderr);
748			fputs(": ", stderr);
749			}
750			fputs(s, stderr);
751			if (s[strlen(s)-1] == '\n') {
752			fflush(stderr);
753			midline = 0;
754			}
755			}
756
757
758	greg	3.15	void
759	schorsch	3.22	quit( /* exit the program gracefully */
760			int code
761			)
762	gregl	3.1	{
763			hdsync(NULL, 1); /* write out any buffered data */
764			exit(code);
765			}