render.c

seismic software,very useful

                 v0 - 1 - attr->skew * (MapSize(hmap) + 1), DRAW);
        DrawLine(h0 - 1, v0 + MapSize(vmap) + 1, h0 + MapSize(hmap),
                 v0 + MapSize(vmap) + 1 - attr->skew * (MapSize(hmap) + 1),
                 DRAW);
        DrawLine(h0 - 1, v0, h0 - 1, v0 + MapSize(vmap), DRAW);
        DrawLine(h0 + MapSize(hmap), v0 + 1 - attr->skew * MapSize(hmap),
                 h0 + MapSize(hmap),
                 v0 + 1 + MapSize(vmap) - attr->skew * MapSize(hmap), DRAW);
    }

    /* draw picks */
    if (attr->pick ){
        PickDraw(PickFind(CORD3), DRAW);
    }

    /* left tics */
    if (attr->axes & AXIS_LEFT ){
        for( tic = MapTic0(vmap); tic <= MapTic2(vmap) + .5 * MapDtic(vmap);
             tic += MapDtic(vmap) ){
            y = v0 + MapIndex(vmap, tic);
            x = h0;
            sprintf(label, MapFormat(hmap), tic);
            DrawText(x - TIC_LENGTH, y - 5, TEXT_V0 | TEXT_H100, label);
            DrawLine(x - TIC_LENGTH, y, x, y, DRAW);
        }
        /* label */
        if (MapNtic(vmap) == 1 ){
            x = h0 - margins[MARGIN_LEFT];
            y = v0 + MapSize(vmap) / 2;
        } else {
            tic = (MapTic0(vmap) + MapTic2(vmap) +
                   (MapNtic(vmap) % 2) * MapDtic(vmap)) / 2;
            y = v0 + MapIndex(vmap, tic);
            x = h0 + -margins[MARGIN_LEFT];
        }
        DrawText(x, y, TEXT_V50 | TEXT_H0, AxisLabel(MapAxis(vmap)));
        /* border line */
        DrawLine(h0 - 1, v0, h0 - 1, v0 + MapSize(vmap), DRAW);
    }

    /* base tics */
    if (attr->axes & AXIS_BASE ){
        for( tic = MapTic0(hmap); tic <= MapTic2(hmap) + .5 * MapDtic(hmap);
             tic += MapDtic(hmap) ){
            x = h0 + MapSize(hmap) - MapIndex(hmap, tic);
            y = v0 + MapSize(vmap) - attr->skew * (MapSize(hmap) -
                                                   MapIndex(hmap, tic));
            sprintf(label, MapFormat(hmap), tic);
            if (attr->skew ){
                DrawText(x + TIC_LENGTH + 1, y, TEXT_V50 | TEXT_H0, label);
                DrawLine(x, y, x + TIC_LENGTH, y, DRAW);
            } else {
                DrawText(x - 10, y + TIC_LENGTH, TEXT_V0 | TEXT_H0, label);
                DrawLine(x, y, x, y + TIC_LENGTH, DRAW);
            }
        }
        /* label */
        if (MapNtic(hmap) == 1 ){
            x = h0 + MapSize(hmap) / 2;
            y = v0 + (attr->skew > 0 ? 0 : 1) * margins[MARGIN_BASE] +
                MapSize(vmap) - attr->skew * MapSize(hmap) / 2;
        } else {
            tic = (MapTic0(hmap) + MapTic2(hmap) +
                   (MapNtic(hmap) % 2) * MapDtic(hmap)) / 2;
            x = h0 + MapSize(hmap) - MapIndex(hmap, tic);
            y = v0 + MapSize(vmap) + (attr->skew > 0 ? 0 : 1) *
                margins[MARGIN_BASE] - attr->skew * (MapSize(hmap) -
                                                     MapIndex(hmap, tic));
        }
        if (attr->skew ){
            DrawText(x, y + TIC_LENGTH, TEXT_V0 | TEXT_H0,
                     AxisLabel(MapAxis(hmap)));
        }else{
            DrawText(x, y, TEXT_V100 | TEXT_H50, AxisLabel(MapAxis(hmap)));
        }
        /* border line */
        DrawLine(h0, v0 + MapSize(vmap), h0 + MapSize(hmap),
                 v0 + MapSize(vmap) - attr->skew * MapSize(hmap), DRAW);
    }
}

/* extract plane along pick line */
void RenderDeep(Data data, Map hmap, Map vmap, Map zmap, Map map4, Map map5, int h0,
           int v0, Render render, int *margins, RenderAttr attr)
{
    Map_     hmap1, vmap1, zmap1;
    extern PickLine lastpick;
    int      ipick, idim, rmap;
    float    arclen = 0;
    float  darc, dlen, dseg, seglen[NPICK], interp;
    extern double sqrt(double);

    if (!lastpick || PickCount(lastpick) < 2 ){
        return; /* no active pick */
    }
    /* compute new map maps based on supplied maps */
    /* hmap is zmap resized into zmap */
    /* vmap is replaced by pick map */
    /* zmap is inactive */
    hmap1 = *zmap;
    vmap1 = *vmap;
    zmap1 = *zmap;

    if (vmap1.map ){
        free(vmap1.map);
        vmap1.map = 0;
        if (memwatch ){
            printf("free %s\n", "var");
        }
    };
    {   extern int _alloc;

        vmap1.map = (Vec) malloc((MapSize(&vmap1)) * sizeof(vmap1.map[0]));
        _alloc += (MapSize(&vmap1)) * sizeof(vmap1.map[0]);
        if (vmap1.map == 0 ){
            err("cant allocate %d bytes for var; %d already allocated",
                (MapSize(&vmap1)) * sizeof(vmap1.map[0]), _alloc);
        }
        if (memwatch ){
            (void) printf("malloc %s=%d\n", "var",
                          (MapSize(&vmap1)) * sizeof(vmap1.map[0]));
        }
    };
    hmap1.map = 0;
    MapSetSize(&hmap1, MapSize(&zmap1));
    zmap1.frame = 0;

    /* compute pick segment length in samples */
    for( ipick = 1; ipick < PickCount(lastpick) - 1; ipick++ ){
        for( seglen[ipick] = 0, idim = 0; idim < 3; idim++ ){
            seglen[ipick] += (PickIndex(lastpick, ipick, idim) -
                              PickIndex(lastpick, ipick + 1, idim)) *
                (PickIndex(lastpick, ipick, idim) -
                 PickIndex(lastpick, ipick - 1, idim));
        }
        seglen[ipick] = sqrt(seglen[ipick]);
        arclen += seglen[ipick];
    }
    /* compute interpolation axis */
    dlen = arclen / MapSize(&vmap1);
    for( darc = 0, dseg = 0, rmap = 0, ipick = 0; rmap < MapSize(&vmap1);
         rmap++, dseg += dlen ){
        /* check to see if in new segment of arc */
        if (dseg >= darc ){
            darc += seglen[ipick];
            ipick++;
        }
        /* interption along current arc segment */
        interp = (darc - dseg) / seglen[ipick - 1];
        vmap1.map[rmap] = 0;
        /* add up interptional data offsets of two pick dimensions */
        for( idim = 1; idim < 4; idim++ ){
            /* skip perpendicular dimension */
            if (idim != PickDir(lastpick) ){
                vmap1.map[rmap] += (int) (interp *
                                          PickIndex(lastpick, ipick, idim) +
                                          (1. - interp) * PickIndex(lastpick,
                                                                    ipick - 1,
                                                                    idim)) *
                    AxisStride(DataAxis(data, idim));
            }
        }
    }
    /* plot it */
    attr->orient = RENDER_DEEP;

    RenderHorz(data, &hmap1, &vmap1, &zmap1, map4, map5, h0, v0, render,
               margins, attr);

/*--------------------------------------------------------------------*\

int RenderHorz(
     Data data 
    ,Map hmap 
    ,Map vmap 
    ,Map zmap 
    ,Map map4 
    ,Map map5 
    ,int h0 
    ,int v0 
    ,Render render 
    ,int margins[] 
    ,RenderAttr attr
);
\*--------------------------------------------------------------------*/

/*      (attr)  0,0,1,AXIS_BASE,1,1,1,0,margins*/
}

/* return buffer value */
int RenderBufferValue(Render render, int x, int y)
{
    if (!render ){
        return (0);
    }

    return (render->image[render->wide * y + x]);
}

/* return shadow value */
int RenderShadowValue(Render render, int x, int y)
{
    if (!render ){
        return (NO_INDEX);
    }

    if (x < 0 || x >= render->wide || y < 0 || y >= render->hite ){
        return (NO_INDEX);
    }
    return (render->shadow[render->wide * y + x]);
}

/* return buffer */
Buffer   RenderBuffer(Render render)
{

    if (!render ){
        return (0);
    }
    return (render->image);
}

/* draw render */
void RenderDraw(void)
{
    extern Render render;

    if (!render || UIFirst() ){
        return;
    }
    DrawMask(254);
    if (MovieRun() ){
        DrawImage(render, render->h0, render->v0, render->nh, render->nv);
    } else {
        DrawImage(render, 0, 0, render->wide, render->hite);
    }
}

/* print render information */
void RenderInfo(Render render)
{
    Message  message;

    if (!render ){
        return;
    }
    sprintf(message,
            "Render: wide=%d hite=%d interpolate=%d fence_transp=%d low_transp=%d high_transp=%d vol_transp=%d",
            render->wide, render->hite, render->interp, render->fence_transp,
            render->low_transp, render->high_transp, render->vol_transp);
    UIMessage(message);
}

/* save render parameters */
void RenderSavePar(void)
{
    Message  message;
    extern Render render;

    if (!render ){
        return;
    }
    sprintf(message,
            "Render: wide=%d hite=%d interpolate=%d fence_transp=%d low_transp=%d high_transp=%d vol_transp=%d",
            render->wide, render->hite, render->interp, render->fence_transp,
            render->low_transp, render->high_transp, render->vol_transp);
    UISaveMessage(message);
}

/* rasterize overlay line; OBSELETE */
void RenderLine(Render render, int x0, int y0, int x1, int y1, int color)
{
    register Buffer bp, be;
    register int inc;

    if (!render ){
        return;
    }
    if (y0 == y1 ){     /* horzontal line */
        bp = render->image + render->wide * y0 + (x0 < x1 ? x0 : x1);
        be = render->image + render->wide * y0 + (x0 > x1 ? x0 : x1);
        inc = 1;
    } else if (x0 == x1 ){      /* vertical line */
        bp = render->image + render->wide * (y0 < y1 ? y0 : y1) + x0;
        be = render->image + render->wide * (y0 > y1 ? y0 : y1) + x0;
        inc = render->wide;
    } else {    /* diagonal line */
        if (y1 < y0 ){
            inc = y0;
            y0 = y1;
            y1 = inc;
            inc = x0;
            x0 = x1;
            x1 = inc;
        }
        bp = render->image + render->wide * y0 + x0;
        be = render->image + render->wide * y1 + x1;
        inc = render->wide + (x1 > x0 ? 1 : -1);
    }
    if (!color ){       /* erase */
        for( ; bp < be; bp += inc ){
            *bp &= 254;
        }
    } else {    /* draw */
        for( ; bp < be; bp += inc ){
            *bp |= 1;
        }
    }
}

void RenderSetInterp(int mode)
{
    extern Render render;

    if (!render ){
        return;
    }
    render->interp = mode;
}

/* set color mapping polarity */
void RenderTogglePolarity(void)
{
    extern Render render;

    if (!render ){
        return;
    }
    render->polarity *= -1;
    RenderMap(render);
    ViewDrawAll();
}

/* toggle interpolation state */
void RenderToggleInterp(void)
{
    extern Render render;

    if (!render ){
        return;
    }
    render->interp = 1 - render->interp;
}

/* set fence transparency cutoff value */
void RenderSetFenceTransp(int transparency)
{
    extern Render render;

    if (!render ){
        return;
    }
    render->fence_transp = transparency;
}

/* set volume transp low */
void RenderSetLow(int low)
{
    extern Render render;

    if (!render ){
        return;
    }
    render->low_transp = low;
    RenderMap(render);
}

/* set volume transp high */
void RenderSetHigh(int high)
{
    extern Render render;

    if (!render ){
        return;
    }
    render->high_transp = high;
    RenderMap(render);
}

/* set volume transp vol_transp */
void RenderSetGradient(int vol_transp)
{
    extern Render render;

    if (!render ){
        return;
    }
    render->vol_transp = vol_transp;
    RenderMap(render);
}

/* clean render buffers */
void RenderClear(void)
{
    extern Render render;
    register Shadow sp, se;
    register back;

    back = ColorBackground();






    {register byte bp, be; for( bp=(byte) render->image , be=bp+(  render->wide * render->hite )*sizeof( render->image [0]); bp<be;) *bp++ =   back ;} ;
    {register byte bp, be; for( bp=(byte) render->zbuffer , be=bp+(  render->wide * render->hite )*sizeof( render->zbuffer [0]); bp<be;) *bp++ =   0 ;} ;
    if (!MovieRun() ){
        for( sp = render->shadow, se = sp + render->wide * render->hite;
             sp < se; ){
            *sp++ = NO_INDEX;
        }
    }
}

/* build lookup map for render compositing */
void RenderMap(Render render)
{
    int      cbase, csize, cback, cmark, im, id, value, dbase, dsize, id1, im1;
    double   pow(double, double), power;
    extern Data data;

    cback = ColorBackground();
    cbase = ColorBase();
    csize = ColorSize();
    cmark = ColorMark();
    dbase = DataValueBase(data);
    dsize = DataValueSize(data);
    /* opaque color map */
    for( id = 0; id < dsize; id++ ){
        value = (id * csize) / dsize;
        if (render->polarity < 0 ){
            value = csize - value - 1;
        }
        /* leave odd colors free for overlay */
        render->cmap[id + dbase] = cbase + (value / 2) * 2;
    }
    for( id = 0; id < dbase; id++ ){
        render->cmap[id] = cback;
    }
    for( id = dbase + dsize; id < 128; id++ ){
        render->cmap[id] = cback;
    }
    for( id = 128; id < 256; id++ ){
        render->cmap[id] = cmark;