view.c

seismic software,very useful

/*
view object code
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "par.h"

#include "ui_panel.h"
#include "ui_window.h"
#include "ui_canvas.h"
#include "ui_menu.h"

#include "colorbar.h"
#include "main.h"
#include "color.h"
#include "axis.h"
#include "draw.h"
#include "plane.h"
#include "pik.h"
#include "data.h"
#include "map.h"
#include "movie.h"
#include "render.h"
#include "view.h"
#include "pick.h"

/* set rendering attributes for a view */
RenderAttr _attr_;

#define RENDER_ATTR(_transp,_skew,_mark,_zbuffer,_image,_axes,_shadow,_lines,_box,_pick) \
        _attr_->image = (_image);\
        _attr_->shadow = (_shadow);\
        _attr_->zbuffer = (_zbuffer);\
        _attr_->box = (_box);\
        _attr_->axes = (_axes);\
        _attr_->lines = (_lines);\
        _attr_->pick = (_pick);\
        _attr_->skew = (_skew);\
        _attr_->transp = (_transp);\
        _attr_->mark = (_mark);\
     /* printf ("image=%d shadow=%d zbuffer=%d box=%d axes=%d lines=%d
        pick=%d skew=%d transp=%d
        mark=%d\n",_image,_shadow,_zbuffer,_box,_axes,_lines,_pick,_skew,_transp,_mark) 
      */
Message  message;

/* initialize view object */
string   viewnamelist[] = VIEW_NAMELIST;

View     ViewInit(Data data)
{
    View     view;
    cwp_String   option;
    int      i;
    string tmp_str;
    

    {
        extern int _alloc;

        view = (View) malloc((1) * sizeof(view[0]));
        _alloc += (1) * sizeof(view[0]);
        if( view == 0 ){
            err("cant allocate %d bytes for var; %d already allocated",
                (1) * sizeof(view[0]), _alloc);
        }
        if( memwatch ){
            (void) printf("malloc %s=%d\n", "var", (1) * sizeof(view[0]));
        }
    };
    view->margins[MARGIN_LEFT] = LEFT_MARGIN;
    view->margins[MARGIN_RIGHT] = RIGHT_MARGIN;
    view->margins[MARGIN_BASE] = BASE_MARGIN;
    view->margins[MARGIN_TOP] = TOP_MARGIN;
    view->style = VIEW_CUBE;
    if( getparstring("style", &option) ){
        for( view->style = 0;
             view->style < sizeof(viewnamelist) / sizeof(viewnamelist[0]);
             view->style++ ){
            if( !strcmp(viewnamelist[view->style], option) ){
                break;
            }
        }
    } else
        getparint("style", &view->style);
    getparint("wide", &view->wide);
    getparint("hite", &view->hite);
    switch (view->style ){
       case VIEW_TRANSP:
       case VIEW_SIDE:
        view->movie = MOVIE_SIDE;
        break;
       case VIEW_TOP:
        view->movie = MOVIE_TOP;
        break;
       default:
        view->movie = MOVIE_FRONT;
    }
    if( getparstring("movie", &option) ){
        if( !strcmp(option, "in") ){
            view->movie = MOVIE_FRONT;
            MovieSetDir(MOVIE_REVERSE);
            MovieSetRun(1);
        }
        if( !strcmp(option, "out") ){
            view->movie = MOVIE_FRONT;
            MovieSetDir(MOVIE_FORWARD);
            MovieSetRun(1);
        }
        if( !strcmp(option, "left") ){
            view->movie = MOVIE_SIDE;
            MovieSetDir(MOVIE_REVERSE);
            MovieSetRun(1);
        }
        if( !strcmp(option, "right") ){
            view->movie = MOVIE_SIDE;
            MovieSetDir(MOVIE_FORWARD);
            MovieSetRun(1);
        }
        if( !strcmp(option, "up") ){
            view->movie = MOVIE_TOP;
            MovieSetDir(MOVIE_REVERSE);
            MovieSetRun(1);
        }
        if( !strcmp(option, "down") ){
            view->movie = MOVIE_TOP;
            MovieSetDir(MOVIE_REVERSE);
            MovieSetRun(1);
        }
    }
    if( view->style == VIEW_TRANSP ){
        view->shape = SHAPE_PIXEL;
    }else{
        view->shape = SHAPE_FIT;
    }
    if( getparstring("shape", &option) ){
        if( !strcmp(option, "fit") ){
            view->shape = SHAPE_FIT;
        }else if( !strcmp(option, "cube") ){
            view->shape = SHAPE_FIT;
        }else if( !strcmp(option, "0") ){
            view->shape = SHAPE_FIT;
        }else if( !strcmp(option, "true") ){
            view->shape = SHAPE_TRUE;
        }else if( !strcmp(option, "1") ){
            view->shape = SHAPE_TRUE;
        }else if( !strcmp(option, "pixel") ){
            view->shape = SHAPE_PIXEL;
        }else if( !strcmp(option, "2") ){
            view->shape = SHAPE_PIXEL;
        }
    }
    view->showpicks = DRAW;
    getparint("showpicks", &view->showpicks);
    view->nacross = 1;
    getparint("across", &view->nacross);
    view->ndown = 1;
    getparint("down", &view->ndown);
    view->dacross = 1;
    getparint("delta", &view->dacross);
    view->rate = VIEW_RATE_TENTHS;
    getparint("rate", &view->rate);
    view->fence = DRAW_ALL;
    getparint("fence", &view->fence);
    view->map[AXIS_DOWN] =
        MapInit(DataAxis(data, DATA_AXIS1), "DOWN", AXIS_DOWN);
    view->map[AXIS_ACROSS] =
        MapInit(DataAxis(data, DATA_AXIS2), "ACROSS", AXIS_ACROSS);
    view->map[AXIS_DEEP] =
        MapInit(DataAxis(data, DATA_AXIS3), "DEEP", AXIS_DEEP);
    view->map[AXIS_4D] = MapInit(DataAxis(data, DATA_AXIS4), "4D", AXIS_4D);
    view->map[AXIS_5D] = MapInit(DataAxis(data, DATA_AXIS5), "5D", AXIS_5D);
    if( getparstring("orient", &option) ){
        if( !strcmp(option, "side") ){
            MapSwap(view->map[AXIS_ACROSS], view->map[AXIS_DEEP]);
        } else if( !strcmp(option, "top") ){
            MapSwap(view->map[AXIS_DOWN], view->map[AXIS_DEEP]);
        } else if( !strcmp(option, "extra") ){
            MapSwap(view->map[AXIS_4D], view->map[AXIS_DEEP]);
        }
    }
    view->map[AXIS_COLOR] =
        MapInit(DataAxis(data, DATA_VALUE), "COLOR", AXIS_COLOR);
    if( getparstring("origin", &option) ){
        strcpy( tmp_str ,option );
    }else{
        if( view->style == VIEW_FENCE ){
            strcpy(tmp_str, "center");
        }else{
            strcpy(tmp_str, "option");
        }

    }
    if( !strcmp(tmp_str, "center") || !strcmp(tmp_str, "middle") ){
        for( i = 1; i < VIEW_NAXIS; i++ ){
            MapSetFrame(view->map[i], AxisSize(MapAxis(view->map[i])) / 2);
        }
    } 
    if( view->map[AXIS_DEEP]->size == 1 ){
       view->style = VIEW_FRONT;
    }
 
    {
        extern int _alloc;

        _attr_ = (RenderAttr) malloc((1) * sizeof(_attr_[0]));
        _alloc += (1) * sizeof(_attr_[0]);
        if( _attr_ == 0 ){
            err("cant allocate %d bytes for var; %d already allocated",
                (1) * sizeof(_attr_[0]), _alloc);
        }
        if( memwatch ){
            (void) printf("malloc %s=%d\n", "var", (1) * sizeof(_attr_[0]));
        }
    };
    return (view);
}

/* adjust view size: reallocate buffers,adjust map axes */
void ViewSize(View view)
{
    int      wide, hite, size, deep;
    float    fwide, fhite, scale;

    if( !view ){
        return;
    }
    /* get new size */
    UICanvasSize(&wide, &hite);
    RenderSize(wide, hite);
    view->wide = wide;
    view->hite = hite;
    /* adjust axes lengths depending upon shape and style */
    switch (view->style ){
        /* the four cubical views */
       case VIEW_CUBE:
       case VIEW_FENCE:
       case VIEW_THREE:
       case VIEW_TRANSP:
        /* actual real estate */
        wide = view->wide - HMARGIN - GAP;
        hite = view->hite - VMARGIN - GAP;
        switch (view->shape ){
           case SHAPE_FIT:
            deep = (wide < hite ? wide : hite) * (1. - FRAC);
            MapSetSize(view->map[AXIS_DOWN], hite - deep);
            MapSetSize(view->map[AXIS_ACROSS], wide - deep);
            MapSetSize(view->map[AXIS_DEEP], deep);
            break;
           case SHAPE_TRUE:
            fwide = (float) wide / (float) (MapZoom(view->map[AXIS_ACROSS]) +
                                            MapZoom(view->map[AXIS_DEEP]));
            fhite = (float) hite / (float) (MapZoom(view->map[AXIS_DOWN]) +
                                            MapZoom(view->map[AXIS_DEEP]));
            if( fwide < fhite ){
                MapSetSize(view->map[AXIS_DOWN],
                           (int) (fwide * MapZoom(view->map[AXIS_DOWN])));
                MapSetSize(view->map[AXIS_ACROSS],
                           (int) (fwide * MapZoom(view->map[AXIS_ACROSS])));
                MapSetSize(view->map[AXIS_DEEP],
                           (int) (fwide * MapZoom(view->map[AXIS_DEEP])));
            }else{
                MapSetSize(view->map[AXIS_DOWN],
                           (int) (fhite * MapZoom(view->map[AXIS_DOWN])));
                MapSetSize(view->map[AXIS_ACROSS],
                           (int) (fhite * MapZoom(view->map[AXIS_ACROSS])));
                MapSetSize(view->map[AXIS_DEEP],
                           (int) (fhite * MapZoom(view->map[AXIS_DEEP])));
            }
            break;
           case SHAPE_PIXEL:
            fwide = (float) wide / (float) (MapWindow(view->map[AXIS_ACROSS]) +
                                            MapWindow(view->map[AXIS_DEEP]));
            fhite = (float) hite / (float) (MapWindow(view->map[AXIS_DOWN]) +
                                            MapWindow(view->map[AXIS_DEEP]));
            if( fwide < 1.0 ){
                UIMessage("dataset too wide; shrink data or enlarge window");

/*                              ViewSetShape (SHAPE_FIT);*/
                break;
            }
            if( fhite < 1.0 ){
                UIMessage("dataset too high; window data or enlarge window");

/*                              ViewSetShape (SHAPE_FIT);*/
                break;
            }
            MapSetSize(view->map[AXIS_DOWN], MapWindow(view->map[AXIS_DOWN]));
            MapSetSize(view->map[AXIS_ACROSS],
                       MapWindow(view->map[AXIS_ACROSS]));
            MapSetSize(view->map[AXIS_DEEP], MapWindow(view->map[AXIS_DEEP]));
            break;
        }
        break;
       case VIEW_FRONT:
        ViewSingleSize(view->map[AXIS_ACROSS], view->map[AXIS_DOWN],
                       view->map[AXIS_DEEP]);
        break;
       case VIEW_SIDE:
        ViewSingleSize(view->map[AXIS_DEEP], view->map[AXIS_DOWN],
                       view->map[AXIS_ACROSS]);
        break;
       case VIEW_TOP:
        ViewSingleSize(view->map[AXIS_ACROSS], view->map[AXIS_DEEP],
                       view->map[AXIS_DOWN]);
        break;
       case VIEW_XSEC:
        MapSetSize(view->map[AXIS_DOWN], view->hite - VMARGIN);
        MapSetSize(view->map[AXIS_ACROSS], (view->wide - HMARGIN) / 2);
        break;
       case VIEW_ARRAY:
        MapSetSize(view->map[AXIS_ACROSS],
                   (view->wide - (view->nacross - 1) * GAP) / view->nacross);
        MapSetSize(view->map[AXIS_DOWN],
                   (view->hite - (view->ndown - 1) * GAP) / view->ndown);
        break;
    }
    DrawFreePixmaps();
}

/* size for single panel */
void ViewSingleSize(Map hmap, Map vmap, Map zmap)
{
    float    fwide, fhite, scale;
    int      size;
    extern View view;

    switch (view->shape ){
       case SHAPE_FIT:
        MapSetSize(hmap, view->wide - HMARGIN);
        MapSetSize(vmap, view->hite - VMARGIN);
        break;
       case SHAPE_TRUE:
        fwide = (float) (view->wide - HMARGIN) / (float) MapZoom(hmap);
        fhite = (float) (view->hite - VMARGIN) / (float) MapZoom(vmap);
        scale = fwide < fhite ? fwide : fhite;
        MapSetSize(vmap, (int) scale * MapZoom(vmap));
        MapSetSize(hmap, (int) scale * MapZoom(vmap));
        break;
       case SHAPE_PIXEL:
        fwide = (float) (view->wide - HMARGIN) / (float) MapWindow(hmap);
        fhite = (float) (view->hite - VMARGIN) / (float) MapWindow(vmap);
        size = (fhite < 1. ? fhite : 1.) * (MapLast(vmap) - MapFirst(vmap));
        MapSet(vmap,
               MapAxis(vmap),
               size > 0 ? size : -size,
               MapFirst(vmap),
               MapLast(vmap), MapFirst(vmap), MapLast(vmap), MapDmovie(hmap));
        size = (fwide < 1. ? fwide : 1.) * (MapLast(hmap) - MapFirst(hmap));
        MapSet(hmap,
               MapAxis(hmap),
               size > 0 ? size : -size,
               MapFirst(hmap),
               MapLast(hmap), MapFirst(hmap), MapLast(hmap), MapDmovie(hmap));

        break;
    }
}

/* callback for initial view size */
void ViewSize0(void)
{
    extern View view;

    ViewSize(view);
}

/* extract view from data; depends upon movie and view mode */
void ViewDraw(View view, int mode)
{
    extern Data data;
    extern Render render;
    Map      map;
    int      pixels;

    if( UIFirst() ){
        return;
    }
    if( !view || !view->map[AXIS_DEEP] ){
        return;
    }
    pixels = 0;

    if( mode == DRAW_ALL ){
        TymeStart();
        DrawWatch(1);
        if( view->style != VIEW_FENCE ){
            RenderClear();
            DrawClear();
        }
        PlaneReset();
    }
    if( view->showpicks && view->style != VIEW_TRANSP ){
        PikDraw(NO_INDEX, ERASE);
    }
    switch (view->style ){
       case VIEW_CUBE:
        ViewDrawCube(view, mode);
        pixels +=
            MapSize(view->map[AXIS_DOWN]) * MapSize(view->map[AXIS_ACROSS]);
        pixels += MapSize(view->map[AXIS_DEEP]) * MapSize(view->map[AXIS_DOWN]);
        pixels +=
            MapSize(view->map[AXIS_ACROSS]) * MapSize(view->map[AXIS_DEEP]);
        break;
       case VIEW_FENCE:
        ViewDrawFence(view, view->fence);
        if( view->fence & DRAW_FRONT ){
            pixels +=
                MapSize(view->map[AXIS_DOWN]) * MapSize(view->map[AXIS_ACROSS]);
        }
        if( view->fence & DRAW_SIDE ){
            pixels +=
                MapSize(view->map[AXIS_DEEP]) * MapSize(view->map[AXIS_DOWN]);
        }
        if( view->fence & DRAW_TOP ){
            pixels +=
                MapSize(view->map[AXIS_ACROSS]) * MapSize(view->map[AXIS_DEEP]);
        }
        break;
       case VIEW_THREE:
        ViewDrawPlan(view, mode);
        pixels +=
            MapSize(view->map[AXIS_DOWN]) * MapSize(view->map[AXIS_ACROSS]);
        pixels += MapSize(view->map[AXIS_DEEP]) * MapSize(view->map[AXIS_DOWN]);
        pixels +=
            MapSize(view->map[AXIS_ACROSS]) * MapSize(view->map[AXIS_DEEP]);
        break;