render.c

seismic software,very useful

    }
    /* marked data, i.e. > dsize, revert to maximum value */
    for( value = ((cbase + csize) / 2) * 2 + 2; id < 256; id++ ){
        render->cmap[id] = value;
    }
    if (render->vol_transp >= 100 ){
        for( im = 0; im < 256; im++ ){
            im1 = im > cbase ? im : cbase;
            for( id = 0; id < 256; id++ ){
                id1 = render->cmap[id];
                render->tmap[(im << 8) + id] = im1 > id1 ? im1 : id1;
            }
        }
        return;
    } else {
        power = render->vol_transp / 11.0 + 0.5;
        for( id = 0; id < dsize - 1; id++ ){
            render->alpha[id] = pow((1. * id) / dsize, power);
            render->alpha[id] =
                .01 * (render->low_transp +
                       (render->high_transp -
                        render->low_transp) * render->alpha[id]);
        }
        for( ; id < 256; id++ ){
            render->alpha[id] = 1.0;
        }
        /* special case of zero values */
        for( id = 0; id <= dsize; id++ ){
            value = render->cmap[(int) (render->alpha[id] * id)];
            render->tmap[id] = value > cbase ? value : cbase;
        }
        value = ((cbase + csize) / 2) * 2;
        for( ; id < 256; id++ ){
            render->tmap[id] = value;
        }
        for( im = 0; im < 256; im++ ){{
            render->tmap[im << 8] = im > cbase ? im : cbase;
        }
        }
        for( im = 0; im < 256; im++ ){
            im1 = im > cbase ? im : cbase;
            for( id = 0; id < 256; id++ ){
                id1 = render->cmap[id];
                value = (1 - render->alpha[id]) * im1 + render->alpha[id] * id1;
                render->tmap[(im << 8) + id] = value > cbase ? value : cbase;
            }
        }
    }
}

/* write render maps to files for debug purposes */
void RenderMapDump(void)
{
    extern Render render;
    int      fd;

    fd = creat("render.map.256x8", 0664);
    write(fd, render->cmap, 256);
    close(fd);

    fd = creat("render.map.256x256x8", 0664);
    write(fd, render->tmap, 65536);
    close(fd);

    UIMessage("render maps dumped");
}

/* write render images to files for debug purposes */
void RenderImageDump(void)
{
    extern Render render;
    string   filename;
    int      fd;

    sprintf(filename, "render.image.%dx%dx8", render->wide, render->hite);
    fd = creat(filename, 0664);
    write(fd, render->image,
          render->wide * render->hite * sizeof(render->image[0]));
    close(fd);

    sprintf(filename, "render.shadow.%dx%dx32", render->wide, render->hite);
    fd = creat(filename, 0664);
    write(fd, render->shadow,
          render->wide * render->hite * sizeof(render->shadow[0]));
    close(fd);

    sprintf(filename, "render.zbuffer.%dx%dx16", render->wide, render->hite);
    fd = creat(filename, 0664);
    write(fd, render->zbuffer,
          render->wide * render->hite * sizeof(render->zbuffer[0]));
    close(fd);

    UIMessage("render images dumped");
}

/* return last region rendered */
void RenderRect(int *h0, int *v0, int *nh, int *nv)
{
    extern Render render;

    *h0 = NO_INDEX;
    *v0 = NO_INDEX;
    *nh = NO_INDEX;
    *nv = NO_INDEX;
    if (!render ){
        return;
    }
    *h0 = render->h0;
    *v0 = render->v0;
    *nh = render->nh;
    *nv = render->nv;
}

/* optimized rendering routines */

void RenderBasicHorz(Buffer data, Buffer image, Shadow shadow, Zbuffer zbuffer,
                unsigned char *map, unsigned char *tmap, int wide, int hite,
                int v0, int h0, int fence_transp, int hsize, Vec hmap,
                Vec hinterp, int hstride, int vsize, Vec vmap, Vec vinterp,
                int vstride, int zsize, int zframe, int zstride, int zdir,
                int zinv, int frame4, int stride4, int frame5, int stride5,
                int skew)
{
    Buffer   vdata;
    register Buffer hdata;
    Buffer   vimage;
    register Buffer himage;
    register Buffer eimage;
    register Vec hmap0;
    register Vec emap;
    register Buffer cmap;
    int      iv;

    if( ! vmap ){
       return;
    }
    vdata = data + zframe * zstride + frame4 * stride4 + frame5 * stride5;
    vimage = image + wide * v0 + h0 + vsize * skew;
    eimage = image + wide * hite;
    emap = hmap + hsize;
    cmap = map;
    for( iv = 0; iv < vsize; iv++, vmap++ ){
        hdata = vdata + *vmap;
        for( hmap0 = hmap, himage = vimage; hmap0 < emap && himage < eimage; ){
            *himage++ = cmap[hdata[*hmap0++]];
        }
        vimage += wide - skew;
    }
}

void RenderBasicVert(Buffer data, Buffer image, Shadow shadow, Zbuffer zbuffer,
                unsigned char *map, unsigned char *tmap, int wide, int hite,
                int v0, int h0, int fence_transp, int hsize, Vec hmap,
                Vec hinterp, int hstride, int vsize, Vec vmap, Vec vinterp,
                int vstride, int zsize, int zframe, int zstride, int zdir,
                int zinv, int frame4, int stride4, int frame5, int stride5,
                int skew)
{
    register Buffer vdata;
    Buffer   hdata;
    register Buffer vimage;
    Buffer   himage;
    register Buffer eimage;
    register Vec vmap0;
    register Vec emap;
    register Buffer cmap;
    int      ih;
    register int vstep;

    hdata = data + zframe * zstride + frame4 * stride4 + frame5 * stride5;
    himage = image + wide * v0 + h0;
    eimage = image + wide * hite;
    emap = vmap + vsize;
    vstep = wide;
    cmap = map;
    for( ih = 0, hmap += hsize - 1; ih < hsize; ih++, hmap-- ){
        vdata = hdata + *hmap;
        for( vmap0 = vmap, vimage = himage;
             vmap0 < emap && vimage < eimage; vimage += vstep ){
            *vimage = cmap[vdata[*vmap0++]];
        }
        himage += 1 - skew * wide;
    }
}

void RenderShadowHorz(Buffer data, Buffer image, Shadow shadow, Zbuffer zbuffer,
                 unsigned char *map, unsigned char *tmap, int wide, int hite,
                 int v0, int h0, int fence_transp, int hsize, Vec hmap,
                 Vec hinterp, int hstride, int vsize, Vec vmap, Vec vinterp,
                 int vstride, int zsize, int zframe, int zstride, int zdir,
                 int zinv, int frame4, int stride4, int frame5, int stride5,
                 int skew)
{
    int      vindex;
    register int hindex;
    Shadow   vshadow;
    register Shadow hshadow;
    register Shadow eshadow;
    register Vec hmap0;
    register Vec emap;
    int      iv;


    if( ! vmap ){
       return;
    }

    vshadow = shadow + wide * v0 + h0 + vsize * skew;
    eshadow = shadow + wide * hite;
    vindex = zframe * zstride + frame4 * stride4 + frame5 * stride5;
    emap = hmap + hsize;
    for( iv = 0; iv < vsize; iv++, vmap++ ){
        hindex = vindex + *vmap;
        for( hmap0 = hmap, hshadow = vshadow;
             hmap0 < emap && hshadow < eshadow; ){
            *hshadow++ = (hindex + *hmap0++);
        }
        vshadow += wide - skew;
    }
}

void RenderShadowVert(Buffer data, Buffer image, Shadow shadow, Zbuffer zbuffer,
                 unsigned char *map, unsigned char *tmap, int wide, int hite,
                 int v0, int h0, int fence_transp, int hsize, Vec hmap,
                 Vec hinterp, int hstride, int vsize, Vec vmap, Vec vinterp,
                 int vstride, int zsize, int zframe, int zstride, int zdir,
                 int zinv, int frame4, int stride4, int frame5, int stride5,
                 int skew)
{
    register Buffer vdata;
    Buffer   hdata;
    register Buffer vimage;
    Buffer   himage;
    register Buffer eimage;
    register int vindex;
    int      hindex;
    register Shadow vshadow;
    Shadow   hshadow;
    register Shadow eshadow;
    register Zbuffer vzbuffer;
    Zbuffer  hzbuffer;
    register Vec vmap0;
    register Vec emap;
    register Buffer cmap;
    int      ih;
    register int z;
    register Vec vinterp0;
    register int vstep;

    hdata = data + zframe * zstride + frame4 * stride4 + frame5 * stride5;
    himage = image + wide * v0 + h0;
    hshadow = shadow + wide * v0 + h0;
    eshadow = shadow + wide * hite;
    hzbuffer = zbuffer + wide * v0 + h0;
    hindex = zframe * zstride + frame4 * stride4 + frame5 * stride5;
    eimage = image + wide * hite;
    emap = vmap + vsize;
    vstep = wide;
    cmap = map;
    for( ih = 0, hmap += hsize - 1; ih < hsize; ih++, hmap-- ){
        vindex = hindex + *hmap;
        for( vmap0 = vmap, vshadow = hshadow;
             vmap0 < emap && vshadow < eshadow; vshadow += vstep ){
            *vshadow = (vindex + *vmap0++);
        }
        hshadow += 1 - skew * wide;
    }
}

void RenderInterpHorz(Buffer data, Buffer image, Shadow shadow, Zbuffer zbuffer,
                 unsigned char *map, unsigned char *tmap, int wide, int hite,
                 int v0, int h0, int fence_transp, int hsize, Vec hmap,
                 Vec hinterp, int hstride, int vsize, Vec vmap, Vec vinterp,
                 int vstride, int zsize, int zframe, int zstride, int zdir,
                 int zinv, int frame4, int stride4, int frame5, int stride5,
                 int skew)
{
    Buffer   vdata;
    register Buffer hdata;
    Buffer   vimage;
    register Buffer himage;
    register Buffer eimage;
    int      vindex;
    Shadow   vshadow;
    register Shadow eshadow;
    Zbuffer  vzbuffer;
    register Vec hmap0;
    register Vec emap;
    register Buffer cmap;
    int      iv;
    register Vec hinterp0;
    register Buffer hdata11, hdata12, hdata21;
    register int hinterp1, hinterp2, vinterp1, vinterp2;

    vdata = data + zframe * zstride + frame4 * stride4 + frame5 * stride5;
    vimage = image + wide * v0 + h0 + vsize * skew;
    vshadow = shadow + wide * v0 + h0 + vsize * skew;
    eshadow = shadow + wide * hite;
    vzbuffer = zbuffer + wide * v0 + h0 + vsize * skew;
    vindex = zframe * zstride + frame4 * stride4 + frame5 * stride5;
    eimage = image + wide * hite;
    emap = hmap + hsize;
    cmap = map;
    for( iv = 0; iv < vsize; iv++, vmap++ ){
        hdata = vdata + *vmap;
        hdata21 = hdata + hstride;
        hdata12 = hdata + vstride;
        hdata11 = hdata + hstride + vstride;
        vinterp1 = *vinterp++;
        vinterp2 = (MAP_INTERP - vinterp1);
        for( hmap0 = hmap, himage = vimage, hinterp0 = hinterp;
             hmap0 < emap && himage < eimage; hmap0++ ){
            hinterp1 = *hinterp0++;
            hinterp2 = (MAP_INTERP - hinterp1);
            *himage++ = cmap[
                             ((int) hdata[*hmap0] * vinterp2 * hinterp2
                              + (int) hdata21[*hmap0] * vinterp2 * hinterp1
                              + (int) hdata12[*hmap0] * vinterp1 * hinterp2
                              +
                              (int) hdata11[*hmap0] * vinterp1 * hinterp1) /
                             RENDER_INTERP];
        }
        vimage += wide - skew;
    }
}

void RenderInterpVert(Buffer data, Buffer image, Shadow shadow, Zbuffer zbuffer,
                 unsigned char *map, unsigned char *tmap, int wide, int hite,
                 int v0, int h0, int fence_transp, int hsize, Vec hmap,
                 Vec hinterp, int hstride, int vsize, Vec vmap, Vec vinterp,
                 int vstride, int zsize, int zframe, int zstride, int zdir,
                 int zinv, int frame4, int stride4, int frame5, int stride5,
                 int skew)
{
    register Buffer vdata;
    Buffer   hdata;
    register Buffer vimage;
    Buffer   himage;
    register Buffer eimage;
    register int vindex;
    int      hindex;
    register Shadow vshadow;
    Shadow   hshadow;
    register Shadow eshadow;
    register Zbuffer vzbuffer;
    Zbuffer  hzbuffer;
    register Vec vmap0;
    register Vec emap;
    register Buffer cmap;
    int      ih;
    register int z;
    register Vec vinterp0;
    register int vstep;
    register Buffer vdata11, vdata12, vdata21;
    register int hinterp1, hinterp2, vinterp1, vinterp2;

    hdata = data + zframe * zstride + frame4 * stride4 + frame5 * stride5;
    himage = image + wide * v0 + h0;
    hshadow = shadow + wide * v0 + h0;
    eshadow = shadow + wide * hite;
    hzbuffer = zbuffer + wide * v0 + h0;
    hindex = zframe * zstride + frame4 * stride4 + frame5 * stride5;
    eimage = image + wide * hite;
    emap = vmap + vsize;
    vstep = wide;
    cmap = map;
    for( ih = 0, hmap += hsize - 1, hinterp += hsize - 1; ih < hsize;
         ih++, hmap-- ){
        vdata = hdata + *hmap;
        vdata21 = vdata + vstride;
        vdata12 = vdata + hstride;
        vdata11 = vdata + vstride + hstride;
        hinterp1 = *hinterp--;
        hinterp2 = (MAP_INTERP - hinterp1);
        for( vmap0 = vmap, vimage = himage, vinterp0 = vinterp;
             vmap0 < emap && vimage < eimage; vimage += vstep, vmap0++ ){
            vinterp1 = *vinterp0++;
            vinterp2 = (MAP_INTERP - vinterp1);
            *vimage = cmap[
                           ((int) vdata[*vmap0] * hinterp2 * vinterp2
                            + (int) vdata21[*vmap0] * hinterp2 * vinterp1
                            + (int) vdata12[*vmap0] * hinterp1 * vinterp2
                            +
                            (int) vdata11[*vmap0] * hinterp1 * vinterp1) /
                           RENDER_INTERP];
        }
        himage += 1 - skew * wide;
    }
}

void RenderTranspHorz(Buffer data, Buffer image, Shadow shadow, Zbuffer zbuffer,
                 unsigned char *map, unsigned char *tmap, int wide, int hite,
                 int v0, int h0, int fence_transp, int hsize, Vec hmap,
                 Vec hinterp, int hstride, int vsize, Vec vmap, Vec vinterp,
                 int vstride, int zsize, int zframe, int zstride, int zdir,
                 int zinv, int frame4, int stride4, int frame5, int stride5,
                 int skew)
{
    Buffer   vdata;
    register Buffer hdata;
    Buffer   vimage;
    register Buffer himage;
    register Buffer eimage;
    int      vindex;
    register int hindex;
    Shadow   vshadow;
    register Shadow hshadow;
    register Shadow eshadow;
    Zbuffer  vzbuffer;
    register Zbuffer hzbuffer;
    register Vec hmap0;
    register Vec emap;
    register Buffer cmap;
    int      iv;
    register int z;
    register Vec hinterp0;
    register Buffer hdata11, hdata12, hdata21;
    register int hinterp1, hinterp2, vinterp1, vinterp2;

    vdata = data + zframe * zstride + frame4 * stride4 + frame5 * stride5;
    vimage = image + wide * v0 + h0 + vsize * skew;
    vshadow = shadow + wide * v0 + h0 + vsize * skew;
    eshadow = shadow + wide * hite;
    vzbuffer = zbuffer + wide * v0 + h0 + vsize * skew;
    vindex = zframe * zstride + frame4 * stride4 + frame5 * stride5;
    eimage = image + wide * hite;
    emap = hmap + hsize;
    cmap = map;
    for( iv = 0; iv < vsize; iv++, vmap++ ){
        hdata = vdata + *vmap;
        hindex = vindex + *vmap;
        for( hmap0 = hmap, himage = vimage, hshadow = vshadow;
             hmap0 < emap && himage < eimage; hshadow++ ){
            if (hdata[*hmap0] > *himage ){
                *hshadow = hindex + *hmap0;
            }
            *himage++ = *(tmap + (*himage << 8) + hdata[*hmap0++]);
        }
        vimage += wide - skew;
        vshadow += wide - skew;
    }
}

void RenderTranspVert(Buffer data, Buffer image, Shadow shadow, Zbuffer zbuffer,
                 unsigned char *map, unsigned char *tmap, int wide, int hite,