render.c

seismic software,very useful

/*
render object code
draws raster images into various buffers
draws axis and cross-line annotations
contains optimized subroutines for rapid raster rendering
*/

#include <unistd.h>
#include <stdio.h>

#include "par.h"

#include "main.h"
#include "axis.h"
#include "data.h"
#include "color.h"
#include "draw.h"
#include "map.h"
#include "movie.h"
#include "render.h"
#include "plane.h"
#include "view.h"
#include "pick.h"
#include "rargs.h"
#include "ui_menu.h"
#include "ui_window.h"

/* C or FORTRAN renderers */
#ifndef FORTRAN
#define RENDER_BASIC_HORZ       RenderBasicHorz CALLARGS
#define RENDER_BASIC_VERT       RenderBasicVert CALLARGS
#define RENDER_SHADOW_HORZ      RenderShadowHorz CALLARGS
#define RENDER_SHADOW_VERT      RenderShadowVert CALLARGS
#define RENDER_INTERP_HORZ      RenderInterpHorz CALLARGS
#define RENDER_INTERP_VERT      RenderInterpVert CALLARGS
#define RENDER_TRANSP_HORZ      RenderTranspHorz CALLARGS
#define RENDER_TRANSP_VERT      RenderTranspVert CALLARGS
#endif
#ifdef FORTRAN
#define RENDER_BASIC_HORZ       renderbasichorz_ FCALLARGS
#define RENDER_BASIC_VERT       renderbasicvert_ FCALLARGS
#define RENDER_SHADOW_HORZ      rendershadowhorz_ FCALLARGS
#define RENDER_SHADOW_VERT      rendershadowvert_ FCALLARGS
#define RENDER_INTERP_HORZ      renderinterphorz_ FCALLARGS
#define RENDER_INTERP_VERT      renderinterpvert_ FCALLARGS
#define RENDER_TRANSP_HORZ      rendertransphorz_ FCALLARGS
#define RENDER_TRANSP_VERT      rendertranspvert_ FCALLARGS
#endif
#define CORD3   AxisDir(MapAxis(zmap)),MapFrame(zmap),\
                AxisDir(MapAxis(map4)),MapFrame(map4),\
                AxisDir(MapAxis(map5)),MapFrame(map5)
#define CORD3P  AxisDir(MapAxis(zmap)),MapPrev(zmap),\
                AxisDir(MapAxis(map4)),MapFrame(map4),\
                AxisDir(MapAxis(map5)),MapFrame(map5)

/* initialize render object */
Render   RenderInit(void)
{
    Render   render;

    {    extern int _alloc;

        render = (Render) malloc((1) * sizeof(render[0]));
        _alloc += (1) * sizeof(render[0]);
        if (render == 0 ){
            err("cant allocate %d bytes for var; %d already allocated",
                (1) * sizeof(render[0]), _alloc);
        }
        if (memwatch ){
            (void) printf("malloc %s=%d\n", "var", (1) * sizeof(render[0]));
        }
    };
    render->wide = 0;
    render->hite = 0;
    render->interp = 0;
    render->polarity = RENDER_POLARITY;
    render->fence_transp = RENDER_FENCE_TRANSP;
    render->low_transp = RENDER_LOW_TRANSP;
    render->high_transp = RENDER_HIGH_TRANSP;
    render->vol_transp = RENDER_VOL_TRANSP;
    getparint("interpolate", &render->interp);
    getparint("fence_transp", &render->fence_transp);
    getparint("vol_transp", &render->vol_transp);
    render->image = 0;
    render->shadow = 0;
    render->zbuffer = 0;
    return (render);
}

/* adjust render size: reallocate buffers, adjust map axes */
void RenderSize(int wide, int hite)
{
    extern Render render;

    if (!render ){
        return;
    }
    /* reallocate buffers */
    if (wide != render->wide || hite != render->hite ){
        render->wide = wide;
        render->hite = hite;

        if (render->image ){
            free(render->image);
            render->image = 0;
            if (memwatch ){
                printf("free %s\n", "var");
            }
        };
        {   extern int _alloc;

            render->image =
                (Buffer) malloc((render->wide * render->hite) *
                                sizeof(render->image[0]));
            _alloc += (render->wide * render->hite) * sizeof(render->image[0]);
            if (render->image == 0 ){
                err("cant allocate %d bytes for var; %d already allocated",
                    (render->wide * render->hite) * sizeof(render->image[0]),
                    _alloc);
            }
            if (memwatch ){
                (void) printf("malloc %s=%d\n", "var",
                              (render->wide * render->hite) *
                              sizeof(render->image[0]));
            }
        };
        if (render->zbuffer ){
            free(render->zbuffer);
            render->zbuffer = 0;
            if (memwatch ){
                printf("free %s\n", "var");
            }
        };
        {
            extern int _alloc;

            render->zbuffer =
                (Zbuffer) malloc((render->wide * render->hite) *
                                 sizeof(render->zbuffer[0]));
            _alloc +=
                (render->wide * render->hite) * sizeof(render->zbuffer[0]);
            if (render->zbuffer == 0 ){
                err("cant allocate %d bytes for var; %d already allocated",
                    (render->wide * render->hite) * sizeof(render->zbuffer[0]),
                    _alloc);
            }
            if (memwatch ){
                (void) printf("malloc %s=%d\n", "var",
                              (render->wide * render->hite) *
                              sizeof(render->zbuffer[0]));
            }
        };
        if (render->shadow ){
            free(render->shadow);
            render->shadow = 0;
            if (memwatch ){
                printf("free %s\n", "var");
            }
        };
        {   extern int _alloc;

            render->shadow =
                (Shadow) malloc((render->wide * render->hite) *
                                sizeof(render->shadow[0]));
            _alloc += (render->wide * render->hite) * sizeof(render->shadow[0]);
            if (render->shadow == 0 ){
                err("cant allocate %d bytes for var; %d already allocated",
                    (render->wide * render->hite) * sizeof(render->shadow[0]),
                    _alloc);
            }
            if (memwatch ){
                (void) printf("malloc %s=%d\n", "var",
                              (render->wide * render->hite) *
                              sizeof(render->shadow[0]));
            }
        };
    }
    RenderClear();
}

/*--------------------------------------------------------------------*\
   extract plane in horizontal scan mode; given data, render buffers,
   three map attr->axes, origin, options to attr->image attr->skew,
   data, attr->axes, attr->shadow, and line
\*--------------------------------------------------------------------*/

void RenderHorz(Data data, Map hmap, Map vmap, Map zmap, Map map4, Map map5, int h0,
           int v0, Render render, int *margins, RenderAttr attr)
{
    int      x, y, transp;
    float    tic;
    string   label;

    if (!data || !render || !hmap || !hmap->map ){
        return;
    }
    attr->shadow = 1;
    /* clear previous pick */
    if (attr->pick && attr->mark == 0 ){
        PickDraw(PickFind(CORD3P), ERASE);
    }

    /* record plane */
    attr->orient = RENDER_HORZ;
    if (attr->image ){
        render->h0 = h0;
        render->v0 = v0;
        render->nh =
            MapSize(hmap) + attr->skew * (MapSize(vmap) + GAP) +
            attr->transp * MapSize(zmap);
        render->nh =
            render->wide - render->h0 <
            render->nh ? render->wide - render->h0 : render->nh;
        render->nv = MapSize(vmap) + attr->transp * MapSize(zmap);
        render->nv =
            render->hite - render->v0 <
            render->nv ? render->wide - render->v0 : render->nv;
    }
    if (attr->mark ){
        PlaneSet(hmap, vmap, zmap, map4, map5, render->h0, render->v0,
                 render->nh, render->nv, render, margins, attr);
    }else {
        PlaneSetFrame(PlaneFind(CORD3P), MapFrame(zmap));
    }

    /* extract images */
    if (attr->image ){
        /* update window */
        if (attr->zbuffer ){
            if (!strcmp(MapName(zmap), "DEEP") ){
                if (render->interp ){
                    RenderFrontFenceInterpHorz CALLARGS;

                }else{
                    RenderFrontFenceHorz CALLARGS;
                }
            }
            if (!strcmp(MapName(zmap), "DOWN") ){
                if (render->interp ){
                    RenderTopFenceInterpHorz CALLARGS;

                }else{
                    RenderTopFenceHorz CALLARGS;
                }
            }
        } else if (attr->transp ){
            transp = render->fence_transp * DataValueSize(data) * .01;
            RENDER_TRANSP_HORZ;
        } else if (render->interp ){
            RENDER_INTERP_HORZ;
        }else{
            RENDER_BASIC_HORZ;
        }
        if (attr->shadow && !attr->zbuffer ){
            RENDER_SHADOW_HORZ;
        }
    }

    /* draw crosslines */
    if (attr->lines ){
        /* erase horizontal */
        x = h0 + attr->skew * (MapSize(vmap) - MapInverse(vmap, MapPrev(vmap)));
        y = v0 + MapInverse(vmap, MapPrev(vmap));
        DrawLine(x, y, x + MapSize(hmap), y, ERASE);
        /* erase vertical */
        x = h0 + MapInverse(hmap, MapPrev(hmap));
        DrawLine(x + attr->skew * MapSize(vmap), v0, x, v0 + MapSize(vmap),
                 ERASE);
        /* draw horizontal */
        x = h0 + attr->skew * (MapSize(vmap) -
                               MapInverse(vmap, MapFrame(vmap)));
        y = v0 + MapInverse(vmap, MapFrame(vmap));
        DrawLine(x, y, x + MapSize(hmap), y, DRAW);
        /* draw vertical */
        x = h0 + MapInverse(hmap, MapFrame(hmap));
        DrawLine(x + attr->skew * MapSize(vmap), v0, x, v0 + MapSize(vmap),
                 DRAW);
    }

    /* draw box */
    if (attr->box ){
        DrawLine(h0 - 1 + attr->skew * MapSize(vmap), v0 - 1,
                 h0 + MapSize(hmap) + attr->skew * MapSize(vmap), v0 - 1, DRAW);
        DrawLine(h0 - 1, v0 + MapSize(vmap), h0 + MapSize(hmap),
                 v0 + MapSize(vmap), DRAW);
        DrawLine(h0 - 1 + attr->skew * (MapSize(vmap) + 1), v0 - 1, h0 - 1,
                 v0 + MapSize(vmap), DRAW);
        DrawLine(h0 + MapSize(hmap) + attr->skew * (MapSize(vmap) + 1), v0 - 1,
                 h0 + MapSize(hmap), v0 + MapSize(vmap), DRAW);
    }

    /* draw pick */
    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 + attr->skew * (MapSize(vmap) - MapIndex(vmap, tic));
            sprintf(label, MapFormat(vmap), tic);
            DrawText(x - TIC_LENGTH - 1, 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] + attr->skew * MapSize(vmap) / 2;*/
            x = h0 - 5 + attr->skew * MapSize(vmap) / 2;
            y = v0 + MapSize(vmap) / 2;
        } else {
            tic = (MapTic0(vmap) + MapTic2(vmap) +
                   (MapNtic(vmap) % 2) * MapDtic(vmap)) / 2;
            y = v0 + MapIndex(vmap, tic);

/*
                        x = h0 + attr->skew * (MapSize(vmap) -
                                MapIndex(vmap,tic)) - margins[MARGIN_LEFT];
*/
            x = h0 - 5 + attr->skew * (MapSize(vmap) - MapIndex(vmap, tic));
        }
        DrawText(x, y, TEXT_V50 | TEXT_H100, AxisLabel(MapAxis(vmap)));
        /* border line */
        DrawLine(h0 - 1 + attr->skew * MapSize(vmap), 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 + MapIndex(hmap, tic);
            y = v0 + MapSize(vmap);
            sprintf(label, MapFormat(hmap), tic);
            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 + margins[MARGIN_BASE] + MapSize(vmap);
        } else {
            tic = (MapTic0(hmap) + MapTic2(hmap) +
                   (MapNtic(hmap) % 2) * MapDtic(hmap)) / 2;
            x = h0 + MapIndex(hmap, tic);
            y = v0 + MapSize(vmap) + margins[MARGIN_BASE];
        }
        DrawText(x, y, TEXT_V100 | TEXT_H50, AxisLabel(MapAxis(hmap)));
        /* border line */
        DrawLine(h0, v0 + MapSize(vmap), h0 + MapSize(hmap),
                 v0 + MapSize(vmap), DRAW);
    }
}

/* extract panel in vertical scan line mode; permits vertical attr->skewing for side
of cubes */
void RenderVert(Data data, Map hmap, Map vmap, Map zmap, Map map4, Map map5, int h0,
           int v0, Render render, int *margins, RenderAttr attr)
{
    int      x, y, transp;
    float    tic;
    string   label;

    if (!data || !render || !hmap || !hmap->map ){
        return;
    }
    attr->shadow = 1;
    /* clear picks */
    if (attr->pick && attr->mark == 0 ){
        PickDraw(PickFind(CORD3P), ERASE);
    }

    /* record plane */
    attr->orient = RENDER_VERT;
    if (attr->image ){
        render->h0 = h0;
        render->v0 = v0 - attr->skew * (MapSize(hmap) + GAP);
        render->nh = MapSize(hmap) + attr->transp * MapSize(zmap);
        render->nv =
            MapSize(vmap) + attr->skew * (MapSize(hmap) + GAP) +
            attr->transp * MapSize(zmap);
        render->nh =
            render->wide - render->h0 <
            render->nh ? render->wide - render->h0 : render->nh;
        render->nv =
            render->hite - render->v0 <
            render->nv ? render->wide - render->v0 : render->nv;
    }
    if (attr->mark ){
        PlaneSet(hmap, vmap, zmap, map4, map5, render->h0, render->v0,
                 render->nh, render->nv, render, margins, attr);
    }else {
        PlaneSetFrame(PlaneFind(CORD3P), MapFrame(zmap));
    }

    /* extract image */
    if (attr->image ){
        /* update window */
        if (attr->zbuffer ){
            if (!strcmp(MapName(zmap), "ACROSS") ){
                if (render->interp ){
                    RenderSideFenceInterpVert CALLARGS;

                }else{
                    RenderSideFenceVert CALLARGS;
                }
            }
        } else if (attr->transp ){
            transp = render->fence_transp * DataValueSize(data) * .01;
            RENDER_TRANSP_VERT;
        } else if (render->interp ){
            RENDER_INTERP_VERT;
        }else{
            RENDER_BASIC_VERT;
        }
        if (attr->shadow && !attr->zbuffer ){
            RENDER_SHADOW_VERT;
        }
    }

    /* draw cross lines */
    if (attr->lines ){
        /* erase horizontal line */
        y = v0 + MapInverse(vmap, MapPrev(vmap));
        DrawLine(h0, y, h0 + MapSize(hmap), y - attr->skew * MapSize(hmap),
                 ERASE);
        /* erase vertical line */
        x = h0 + MapSize(hmap) - MapInverse(hmap, MapPrev(hmap));
        y = v0 - attr->skew * (x - h0);
        DrawLine(x, y, x, y + MapSize(vmap), ERASE);
        /* draw horizontal line */
        y = v0 + MapInverse(vmap, MapFrame(vmap));
        DrawLine(h0, y, h0 + MapSize(hmap), y - attr->skew * MapSize(hmap),
                 DRAW);
        /* draw vertical line */
        x = h0 + MapSize(hmap) - MapInverse(hmap, MapFrame(hmap));
        y = v0 - attr->skew * (x - h0);
        DrawLine(x, y, x, y + MapSize(vmap), DRAW);
    }

    /* draw box */
    if (attr->box ){
        DrawLine(h0 - 1, v0 - 1, h0 + MapSize(hmap),