view.c

seismic software,very useful

       case VIEW_FRONT:
       case VIEW_XSEC:
        RENDER_ATTR(0, 0, mode == DRAW_ALL, 0, (mode & DRAW_IMAGE),
                    (AXIS_LEFT | AXIS_BASE) * !MovieRun(), !MovieRun(), 0,
                    !MovieRun(), view->showpicks);
        RenderHorz(data, view->map[AXIS_ACROSS], view->map[AXIS_DOWN],
                   view->map[AXIS_DEEP], view->map[AXIS_4D], view->map[AXIS_5D],
                   view->margins[MARGIN_LEFT], view->margins[MARGIN_TOP],
                   render, view->margins, _attr_);
        pixels +=
            MapSize(view->map[AXIS_DOWN]) * MapSize(view->map[AXIS_ACROSS]);
        break;
       case VIEW_SIDE:
        RENDER_ATTR(0, 0, mode == DRAW_ALL, 0, (mode & DRAW_IMAGE),
                    (AXIS_LEFT | AXIS_BASE) * !MovieRun(), !MovieRun(), 0,
                    !MovieRun(), view->showpicks);
        RenderHorz(data, view->map[AXIS_DEEP], view->map[AXIS_DOWN],
                   view->map[AXIS_ACROSS], view->map[AXIS_4D],
                   view->map[AXIS_5D], view->margins[MARGIN_LEFT],
                   view->margins[MARGIN_TOP], render, view->margins, _attr_);
        pixels += MapSize(view->map[AXIS_DOWN]) * MapSize(view->map[AXIS_DEEP]);
        break;
       case VIEW_TOP:
        RENDER_ATTR(0, 0, mode == DRAW_ALL, 0, (mode & DRAW_IMAGE),
                    (AXIS_LEFT | AXIS_BASE) * !MovieRun(), !MovieRun(), 0,
                    !MovieRun(), view->showpicks);
        RenderHorz(data, view->map[AXIS_ACROSS], view->map[AXIS_DEEP],
                   view->map[AXIS_DOWN], view->map[AXIS_4D], view->map[AXIS_5D],
                   view->margins[MARGIN_LEFT], view->margins[MARGIN_TOP],
                   render, view->margins, _attr_);
        pixels +=
            MapSize(view->map[AXIS_ACROSS]) * MapSize(view->map[AXIS_DEEP]);
        break;
       case VIEW_ARRAY:
        ViewDrawArray(view);
        pixels +=
            MapSize(view->map[AXIS_DOWN]) * MapSize(view->map[AXIS_ACROSS]) *
            view->nacross * view->ndown;
        break;
       case VIEW_TRANSP:
        ViewDrawTransp(view);
        pixels +=
            MapSize(view->map[AXIS_DOWN]) * MapSize(view->map[AXIS_ACROSS]) *
            MapSize(view->map[AXIS_DEEP]);
        break;
    }
    map = ViewMovieMap(view);
    switch (view->style ){
       case VIEW_CUBE:
       case VIEW_FENCE:
       case VIEW_THREE:
        sprintf(message, "%s %s %s %s %s",
                AxisScript(MapAxis(view->map[AXIS_DOWN]),
                           MapFrame(view->map[AXIS_DOWN])),
                AxisScript(MapAxis(view->map[AXIS_ACROSS]),
                           MapFrame(view->map[AXIS_ACROSS])),
                AxisScript(MapAxis(view->map[AXIS_DEEP]),
                           MapFrame(view->map[AXIS_DEEP])),
                AxisScript(MapAxis(view->map[AXIS_4D]),
                           MapFrame(view->map[AXIS_4D])),
                AxisScript(MapAxis(view->map[AXIS_5D]),
                           MapFrame(view->map[AXIS_5D])));
        strcat(message, "                                   ");
        DrawText(view->margins[MARGIN_LEFT], 0, TEXT_H0 | TEXT_V0,
                 DataTitle(data));
        DrawText(view->margins[MARGIN_LEFT], 15, TEXT_H0 | TEXT_V0, message);
        break;
       case VIEW_FRONT:
       case VIEW_SIDE:
       case VIEW_TOP:
        strcpy(message, AxisScript(MapAxis(map), MapFrame(map)));
        strcat(message, "                                   ");
        DrawText(view->margins[MARGIN_LEFT], 0, TEXT_H0 | TEXT_V0,
                 DataTitle(data));
        DrawText(view->margins[MARGIN_LEFT], 15, TEXT_H0 | TEXT_V0, message);
        break;
    }
    if( view->showpicks && view->style != VIEW_TRANSP ){
        PikDraw(NO_INDEX, DRAW);
    }
    if( mode == DRAW_ALL && view->style != VIEW_TRANSP ){
        TymeEnd(pixels);
        DrawWatch(0);
    }
}

/* set array */
void ViewArray(int nacross, int ndown, int across0, int dacross)
{
    extern View view;

    if( !view ){
        return;
    }
    if( view->style != VIEW_ARRAY ){
        view->style = VIEW_ARRAY;
        MapSetFrame(ViewMovieMap(view), 0);
    }
    view->nacross = nacross;
    view->ndown = ndown;
    view->dacross = dacross;
    view->across0 = across0;
    MapSetFrameBounds(view->map[AXIS_DEEP], view->across0,
                      view->across0 +
                      view->nacross * view->ndown * view->dacross);
    ViewSize(view);
    ViewDraw(view, DRAW_ALL);
    RenderDraw();
}

/* draw array */
void ViewDrawArray(View view)
{
    extern Data data;
    extern Render render;
    int      panel, frame, ih, iv, margins[4];
    string   label;
    char    *labelp, labelp1;

    MapSaveFrame(view->map[AXIS_DEEP]);
    for( panel = 0; panel < view->nacross * view->ndown; panel++ ){
        frame = panel * view->dacross + view->across0;
        if( frame >= AxisSize(MapAxis(view->map[AXIS_DEEP])) ){
            break;
        }
        iv = panel / view->nacross;
        ih = panel % view->nacross;
        MapSetFrame(view->map[AXIS_DEEP], frame);
        RENDER_ATTR(0, 0, 1, 0, DRAW_FRONT, 0, 1, 0, 0, view->showpicks);
        RenderHorz(data, view->map[AXIS_ACROSS],
                   view->map[AXIS_DOWN], view->map[AXIS_DEEP],
                   view->map[AXIS_4D], view->map[AXIS_5D], ih =
                   ih * (MapSize(view->map[AXIS_ACROSS]) + GAP), iv =
                   iv * (MapSize(view->map[AXIS_DOWN]) + GAP), render,
                   view->margins, _attr_);
        if( MapSize(view->map[AXIS_ACROSS]) > 100 ){
            DrawText(ih, iv + 2, TEXT_H0 | TEXT_V0,
                     AxisScript(ViewDataAxis(view, AXIS_DEEP), frame));
        }else{
            labelp = AxisScript(ViewDataAxis(view, AXIS_DEEP), frame);
            while (*labelp != '=' && *labelp != '\0' ){
                labelp++;
            }
            if( *labelp == '=' ){
                labelp++;
            }else{
                labelp = AxisScript(ViewDataAxis(view, AXIS_DEEP), frame);
            }
            DrawText(ih, iv, TEXT_H0 | TEXT_V0, labelp);
        }
    }
    MapRestoreFrame(view->map[AXIS_DEEP]);
}

/* draw array of picked renders */
void ViewDrawPicks(View view)
{
    extern Data data;
    extern Render render;
    int      panel, frame, ih, iv, margins[4], save;
    string   label;
    char    *labelp;

    save = MapFrame(view->map[AXIS_DEEP]);
    for( panel = 0; panel < view->nacross * view->ndown; panel++ ){
        if( panel > PickSize() ){
            break;
        }
        frame = PickFrame(panel);
        if( frame == NO_INDEX ||
            frame >= AxisSize(MapAxis(view->map[AXIS_DEEP]))) break;
        iv = panel / view->nacross;
        ih = panel % view->nacross;
        MapSetFrame(view->map[AXIS_DEEP], frame);
        RENDER_ATTR(0, 0, 1, 0, DRAW_FRONT, 0, 1, 0, 0, view->showpicks);
        RenderHorz(data, view->map[AXIS_ACROSS],
                   view->map[AXIS_DOWN], view->map[AXIS_DEEP],
                   view->map[AXIS_4D], view->map[AXIS_5D], ih =
                   ih * (MapSize(view->map[AXIS_ACROSS]) + GAP), iv =
                   iv * (MapSize(view->map[AXIS_DOWN]) + GAP), render,
                   view->margins, _attr_);
        if( MapSize(view->map[AXIS_ACROSS]) > 100 ){
            DrawText(ih, iv, TEXT_H0 | TEXT_V0,
                     AxisScript(ViewDataAxis(view, AXIS_DEEP), frame));
        }else{
            labelp = AxisScript(ViewDataAxis(view, AXIS_DEEP), frame);
            while (*labelp != '=' && *labelp != '\0')
                labelp++;
            if( *labelp == '=' ){
                labelp++;
            }
            else
                labelp = AxisScript(ViewDataAxis(view, AXIS_DEEP), frame);
            DrawText(ih, iv, TEXT_H0 | TEXT_V0, labelp);
        }
    }
    MapSetFrame(view->map[AXIS_DEEP], save);
}

/* cube extracts three panels */
void ViewDrawCube(View view, int mode)
{
    extern Data data;
    extern Render render;

    if( !view ){
        return;
    }

    /* front */
    RENDER_ATTR(0, 0, mode == DRAW_ALL, 0,
                (mode & DRAW_FRONT) * (mode & DRAW_IMAGE),
                (AXIS_LEFT | AXIS_BASE) * !MovieRun(), !MovieRun(), 1,
                !MovieRun(), view->showpicks);
    RenderHorz(data, view->map[AXIS_ACROSS], view->map[AXIS_DOWN],
               view->map[AXIS_DEEP], view->map[AXIS_4D], view->map[AXIS_5D],
               view->margins[MARGIN_LEFT],
               view->margins[MARGIN_TOP] + MapSize(view->map[AXIS_DEEP]) + GAP,
               render, view->margins, _attr_);
    /* side */
    RENDER_ATTR(0, 1, mode == DRAW_ALL, 0,
                (mode & DRAW_SIDE) * (mode & DRAW_IMAGE),
                (AXIS_BASE) * !MovieRun(), !MovieRun(), 1, !MovieRun(),
                view->showpicks);
    RenderVert(data, view->map[AXIS_DEEP], view->map[AXIS_DOWN],
               view->map[AXIS_ACROSS], view->map[AXIS_4D], view->map[AXIS_5D],
               view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_ACROSS]) +
               GAP + 1,
               MapSize(view->map[AXIS_DEEP]) + view->margins[MARGIN_TOP] + GAP,
               render, view->margins, _attr_);
    /* top */
    RENDER_ATTR(0, 1, mode == DRAW_ALL, 0,
                (mode & DRAW_TOP) * (mode & DRAW_IMAGE),
                (AXIS_LEFT) * !MovieRun(), !MovieRun(), 1, !MovieRun(),
                view->showpicks);
    RenderHorz(data, view->map[AXIS_ACROSS], view->map[AXIS_DEEP],
               view->map[AXIS_DOWN], view->map[AXIS_4D], view->map[AXIS_5D],
               view->margins[MARGIN_LEFT], view->margins[MARGIN_TOP], render,
               view->margins, _attr_);
}

/* fence extracts three panels */
void ViewDrawFence(View view, int mode)
{
    extern Data data;
    extern Render render;

    if( !view ){
        return;
    }
    RenderClear();
    DrawClear();
    /* front */
    if( mode & DRAW_FRONT ){
        RENDER_ATTR(0, 0, mode == DRAW_ALL, 1, mode & DRAW_FRONT, 0,
                    !MovieRun(), 0, 0, 0);
        RenderHorz(data, view->map[AXIS_ACROSS], view->map[AXIS_DOWN],
                   view->map[AXIS_DEEP], view->map[AXIS_4D], view->map[AXIS_5D],
                   view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_DEEP]) -
                   MapInverse(view->map[AXIS_DEEP],
                              MapFrame(view->map[AXIS_DEEP])),
                   view->margins[MARGIN_TOP] + MapInverse(view->map[AXIS_DEEP],
                                                          MapFrame(view->map
                                                                   [AXIS_DEEP])),
                   render, view->margins, _attr_);
    }
    RENDER_ATTR(0, 0, mode == DRAW_ALL, 0, 0, (AXIS_LEFT | AXIS_BASE), 0, 0, 0,
                0);
    RenderHorz(data, view->map[AXIS_ACROSS], view->map[AXIS_DOWN],
               view->map[AXIS_DEEP], view->map[AXIS_4D], view->map[AXIS_5D],
               view->margins[MARGIN_LEFT],
               view->margins[MARGIN_TOP] + MapSize(view->map[AXIS_DEEP]),
               render, view->margins, _attr_);
    /* side */
    if( mode & DRAW_SIDE ){
        RENDER_ATTR(0, 1, mode == DRAW_ALL, 1, mode & DRAW_SIDE, 0, !MovieRun(),
                    0, 0, 0);
        RenderVert(data, view->map[AXIS_DEEP], view->map[AXIS_DOWN],
                   view->map[AXIS_ACROSS], view->map[AXIS_4D],
                   view->map[AXIS_5D],
                   view->margins[MARGIN_LEFT] +
                   MapInverse(view->map[AXIS_ACROSS],
                              MapFrame(view->map[AXIS_ACROSS])) - 1,
                   MapSize(view->map[AXIS_DEEP]) + view->margins[MARGIN_TOP],
                   render, view->margins, _attr_);
    }
    RENDER_ATTR(0, 1, mode == DRAW_ALL, 0, 0, (AXIS_BASE), 0, 0, 0, 0);
    RenderVert(data, view->map[AXIS_DEEP], view->map[AXIS_DOWN],
               view->map[AXIS_ACROSS], view->map[AXIS_4D], view->map[AXIS_5D],
               view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_ACROSS]) +
               GAP + 1,
               MapSize(view->map[AXIS_DEEP]) + view->margins[MARGIN_TOP],
               render, view->margins, _attr_);
    /* top */
    if( mode & DRAW_TOP ){
        RENDER_ATTR(0, 1, mode == DRAW_ALL, 1, mode & DRAW_TOP, 0, !MovieRun(),
                    0, 0, 0);
        RenderHorz(data, view->map[AXIS_ACROSS], view->map[AXIS_DEEP],
                   view->map[AXIS_DOWN], view->map[AXIS_4D], view->map[AXIS_5D],
                   view->margins[MARGIN_LEFT],
                   view->margins[MARGIN_TOP] + MapInverse(view->map[AXIS_DOWN],
                                                          MapFrame(view->map
                                                                   [AXIS_DOWN])),
                   render, view->margins, _attr_);
    }
    RENDER_ATTR(0, 1, mode == DRAW_ALL, 0, 0, (AXIS_LEFT), 0, 0, 0, 0);
    RenderHorz(data, view->map[AXIS_ACROSS], view->map[AXIS_DEEP],
               view->map[AXIS_DOWN], view->map[AXIS_4D], view->map[AXIS_5D],
               view->margins[MARGIN_LEFT],
               view->margins[MARGIN_TOP], render, view->margins, _attr_);
}

/* plan view extracts three panels */
void ViewDrawPlan(View view, int mode)
{
    extern Data data;
    extern Render render;

    if( !view ){
        return;
    }

    /* front */
    RENDER_ATTR(0, 0, mode == DRAW_ALL, 0,
                (mode & DRAW_FRONT) * (mode & DRAW_IMAGE),
                (AXIS_LEFT | AXIS_BASE) * !MovieRun(), !MovieRun(), 1,
                !MovieRun(), view->showpicks);
    RenderHorz(data, view->map[AXIS_ACROSS], view->map[AXIS_DOWN],
               view->map[AXIS_DEEP], view->map[AXIS_4D], view->map[AXIS_5D],
               view->margins[MARGIN_LEFT],
               MapSize(view->map[AXIS_DEEP]) + view->margins[MARGIN_TOP] + GAP,
               render, view->margins, _attr_);

    /* side */
    RENDER_ATTR(0, 0, mode == DRAW_ALL, 0,
                (mode & DRAW_SIDE) * (mode & DRAW_IMAGE),
                (AXIS_BASE) * !MovieRun(), !MovieRun(), 1, !MovieRun(),
                view->showpicks);
    RenderVert(data, view->map[AXIS_DEEP], view->map[AXIS_DOWN],
               view->map[AXIS_ACROSS], view->map[AXIS_4D], view->map[AXIS_5D],
               view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_ACROSS]) +
               GAP + 1,
               MapSize(view->map[AXIS_DEEP]) + view->margins[MARGIN_TOP] + GAP,
               render, view->margins, _attr_);

    /* top */
    RENDER_ATTR(0, 0, mode == DRAW_ALL, 0,
                (mode & DRAW_TOP) * (mode & DRAW_IMAGE),
                (AXIS_LEFT) * !MovieRun(), !MovieRun(), 1, !MovieRun(),
                view->showpicks);
    RenderHorz(data, view->map[AXIS_ACROSS], view->map[AXIS_DEEP],
               view->map[AXIS_DOWN], view->map[AXIS_4D], view->map[AXIS_5D],
               view->margins[MARGIN_LEFT], view->margins[MARGIN_TOP], render,
               view->margins, _attr_);

}

/* draw transparent cube */
void ViewDrawTransp(View view)
{
    int      iz, nz;
    extern Data data;
    extern Render render;

    /* draw all axes */
    RENDER_ATTR(0, 0, DRAW_ALL, 0, 0, (AXIS_LEFT | AXIS_BASE), 0, 0, 0, 0);
    RenderHorz(data, view->map[AXIS_ACROSS], view->map[AXIS_DOWN],
               view->map[AXIS_DEEP], view->map[AXIS_4D], view->map[AXIS_5D],
               view->margins[MARGIN_LEFT],
               view->margins[MARGIN_TOP] + MapSize(view->map[AXIS_DEEP]),
               render, view->margins, _attr_);
    RENDER_ATTR(0, 1, DRAW_ALL, 0, 0, (AXIS_BASE), 0, 0, 0, 0);
    RenderVert(data, view->map[AXIS_DEEP], view->map[AXIS_DOWN],
               view->map[AXIS_ACROSS], view->map[AXIS_4D], view->map[AXIS_5D],
               view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_ACROSS]) + 1,
               MapSize(view->map[AXIS_DEEP]) + view->margins[MARGIN_TOP],
               render, view->margins, _attr_);
    RENDER_ATTR(0, 1, DRAW_ALL, 0, 0, (AXIS_LEFT), 0, 0, 0, 0);
    RenderHorz(data, view->map[AXIS_ACROSS], view->map[AXIS_DEEP],
               view->map[AXIS_DOWN], view->map[AXIS_4D], view->map[AXIS_5D],
               view->margins[MARGIN_LEFT],
               view->margins[MARGIN_TOP], render, view->margins, _attr_);
    MapSaveFrame(ViewMovieMap(view));
    switch (view->movie ){
       case MOVIE_FRONT:
        MapSetFrame1(view->map[AXIS_DEEP], 0);
        break;
       case MOVIE_SIDE:
        MapSetFrame1(view->map[AXIS_ACROSS], 0);
        break;
       case MOVIE_TOP:
        MapSetFrame1(view->map[AXIS_DOWN], MapSize(view->map[AXIS_DOWN]) - 1);
        break;
    }
    UITimer(1, ViewDrawTranspCallback);
    DrawLine(view->margins[MARGIN_LEFT],
             view->margins[MARGIN_TOP] + MapSize(view->map[AXIS_DEEP]),
             view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_ACROSS]),
             view->margins[MARGIN_TOP] + MapSize(view->map[AXIS_DEEP]), DRAW);
    DrawLine(view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_ACROSS]) +
             MapSize(view->map[AXIS_DEEP]),
             view->margins[MARGIN_TOP],
             view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_ACROSS]),
             view->margins[MARGIN_TOP] + MapSize(view->map[AXIS_DEEP]), DRAW);
    DrawLine(view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_ACROSS]),
             view->margins[MARGIN_TOP] + MapSize(view->map[AXIS_DOWN]) +
             MapSize(view->map[AXIS_DEEP]),
             view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_ACROSS]),
             view->margins[MARGIN_TOP] + MapSize(view->map[AXIS_DEEP]), DRAW);
    DrawLine(view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_DEEP]),
             view->margins[MARGIN_TOP],
             view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_DEEP]) +
             MapSize(view->map[AXIS_ACROSS]), view->margins[MARGIN_TOP], DRAW);
    DrawLine(view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_ACROSS]) +
             MapSize(view->map[AXIS_DEEP]),
             view->margins[MARGIN_TOP],
             view->margins[MARGIN_LEFT] + MapSize(view->map[AXIS_DEEP]) +
             MapSize(view->map[AXIS_ACROSS]),
             view->margins[MARGIN_TOP] + MapSize(view->map[AXIS_DOWN]), DRAW);
}

/* callback to animate transparent drawing */
void ViewDrawTranspCallback(void)
{
    extern View view;
    extern Render render;
    extern Data data;
    int      block;