Ignore:
Timestamp:
Dec 8, 2010 2:03:02 PM (12 years ago)
Author:
gah
Message:

Clean up debugging/printing traces

Location:
trunk/packages/vizservers/nanovis
Files:
41 edited

Legend:

Unmodified
Added
Removed
  • trunk/packages/vizservers/nanovis/Command.cpp

    r1825 r1984  
    8787// in nanovis.cpp
    8888extern vector<PointSet*> g_pointSet;
    89 extern int debug_flag;
    9089
    9190extern PlaneRenderer* plane_render;
     
    584583    }
    585584    Rappture::Outcome err;
    586     Trace("Checking header[%.13s]\n", buf.bytes());
     585    TRACE("Checking header[%.13s]\n", buf.bytes());
    587586    if (strncmp (buf.bytes(), "@@RP-ENC:", 9) == 0) {
    588587        /* There's a header on the buffer, use it to decode the data. */
     
    10441043
    10451044            fraction = ((float)frame_num) / (total - 1);
    1046             Trace("fraction : %f\n", fraction);
     1045            TRACE("fraction : %f\n", fraction);
    10471046            //interpolator->update(((float)frame_num) / (total - 1));
    10481047            interpolator->update(fraction);
     
    10931092        return TCL_ERROR;
    10941093    }
    1095     Trace("parsing volume data identifier\n");
     1094    TRACE("parsing volume data identifier\n");
    10961095    Tcl_HashSearch iter;
    10971096    Tcl_HashEntry *hPtr;
     
    11341133                    Tcl_Obj *const *objv)
    11351134{
    1136     printf("Data Loading\n");
     1135    TRACE("Data Loading\n");
    11371136    fflush(stdout);
    11381137
     
    11591158    fp = fopen("/home/nanohub/vrinside/nv/data/HOON/GaAs_AlGaAs_2QD_B4.nd_zc_1_wf", "rb");
    11601159    if (fp == NULL) {
    1161         printf("cannot open the file\n");
    1162         fflush(stdout);
     1160        ERROR("cannot open the file\n");
    11631161        return TCL_ERROR;
    11641162    }
     
    11671165    fclose(fp);
    11681166#endif  /*_LOCAL_ZINC_TEST_*/
    1169     Trace("Checking header[%.20s]\n", bytes);
     1167    TRACE("Checking header[%.20s]\n", bytes);
    11701168
    11711169    Volume *volPtr;
     
    11731171   
    11741172    if ((nBytes > 5) && (strncmp(bytes, "<HDR>", 5) == 0)) {
    1175         printf("ZincBlende stream is in\n");
    1176         fflush(stdout);
     1173        TRACE("ZincBlende stream is in\n");
    11771174         //std::stringstream fdata(std::ios_base::out|std::ios_base::in|std::ios_base::binary);
    11781175        //fdata.write(buf.bytes(),buf.size());
     
    11881185            return TCL_ERROR;
    11891186        }
    1190         printf("finish loading\n");
    1191         fflush(stdout);
    1192 
     1187        TRACE("finish loading\n");
    11931188        // INSOO
    11941189        // TBD..
     
    12101205#if __TEST_CODE__
    12111206    } else if ((nBytes > 5) && (strncmp(bytes, "<FET>", 5) == 0)) {
    1212         printf("FET loading...\n");
     1207        TRACE("FET loading...\n");
    12131208        fflush(stdout);
    12141209        std::stringstream fdata;
     
    12221217#endif  /*__TEST_CODE__*/
    12231218    } else if ((nBytes > 5) && (strncmp(bytes, "<ODX>", 5) == 0)) {
    1224         printf("Loading DX using OpenDX library...\n");
     1219        TRACE("Loading DX using OpenDX library...\n");
    12251220        fflush(stdout);
    12261221        Rappture::Outcome context;
     
    12311226        }
    12321227    } else {
    1233         printf("OpenDX loading...\n");
     1228        TRACE("OpenDX loading...\n");
    12341229        fflush(stdout);
    12351230        std::stringstream fdata;
    12361231        fdata.write(bytes, nBytes);
    12371232        if (nBytes <= 0) {
    1238             fprintf(stderr, "data buffer is empty\n");
     1233            ERROR("data buffer is empty\n");
    12391234            abort();
    12401235        }
     
    15071502        return TCL_ERROR;
    15081503    }
    1509     printf("set opacity %f\n", opacity);
     1504    TRACE("set opacity %f\n", opacity);
    15101505    vector<Volume *> ivol;
    15111506    if (GetVolumes(interp, objc - 4, objv + 4, &ivol) != TCL_OK) {
     
    15561551    vector<Volume *>::iterator iter;
    15571552    for (iter = ivol.begin(); iter != ivol.end(); iter++) {
    1558         Trace("setting %s with transfer function %s\n", (*iter)->name(),
    1559               tfPtr->name());
     1553        TRACE("setting %s with transfer function %s\n", (*iter)->name(),
     1554               tfPtr->name());
    15601555        (*iter)->transferFunction(tfPtr);
    15611556#ifdef POINTSET
     
    17411736        hmPtr = (HeightMap *)Tcl_GetHashValue(hPtr);
    17421737    }
     1738    TRACE("Number of heightmaps=%d\n", NanoVis::heightmapTable.numEntries);
    17431739    // Must set units before the heights.
    17441740    hmPtr->xAxis.units(data.xUnits());
     
    17471743    hmPtr->wAxis.units(data.yUnits());
    17481744    hmPtr->setHeight(data.xMin(), data.yMin(), data.xMax(), data.yMax(),
    1749                      data.xNum(), data.yNum(), data.acceptValues());
     1745                     data.xNum(), data.yNum(), data.transferValues());
    17501746    hmPtr->transferFunction(NanoVis::get_transfunc("default"));
    17511747    hmPtr->setVisible(true);
    17521748    hmPtr->setLineContourVisible(true);
     1749    NanoVis::EventuallyRedraw();
    17531750    return TCL_OK;
    17541751}
     
    17701767        (*iter)->setVisible(visible);
    17711768    }
     1769    NanoVis::EventuallyRedraw();
    17721770    return TCL_OK;
    17731771}
     
    18101808        (*iter)->setLineContourColor(rgb);
    18111809    }
     1810    NanoVis::EventuallyRedraw();
    18121811    return TCL_OK;
    18131812}
     
    18291828        (*iter)->setLineContourVisible(visible);
    18301829    }
     1830    NanoVis::EventuallyRedraw();
    18311831    return TCL_OK;
    18321832}
     
    18611861    }
    18621862    NanoVis::renderContext->setCullMode(mode);
     1863    NanoVis::EventuallyRedraw();
    18631864    return TCL_OK;
    18641865}
     
    18861887    Tcl_SetHashValue(hPtr, hmPtr);
    18871888    Tcl_SetStringObj(Tcl_GetObjResult(interp), tag, -1);;
     1889    NanoVis::EventuallyRedraw();
     1890    TRACE("Number of heightmaps=%d\n", NanoVis::heightmapTable.numEntries);
    18881891    return TCL_OK;
    18891892}
     
    19281931    }
    19291932    NanoVis::renderContext->setPolygonMode(mode);
     1933    NanoVis::EventuallyRedraw();
    19301934    return TCL_OK;
    19311935}
     
    19401944    }
    19411945    NanoVis::renderContext->setShadingModel(model);
     1946    NanoVis::EventuallyRedraw();
    19421947    return TCL_OK;
    19431948}
     
    19581963
    19591964    NanoVis::render_2d_contour(heightmap, image_width, image_height);
    1960 
     1965    NanoVis::EventuallyRedraw();
    19611966    return TCL_OK;
    19621967}
     
    20302035        (*iter)->transferFunction(tfPtr);
    20312036    }
     2037    NanoVis::EventuallyRedraw();
    20322038    return TCL_OK;
    20332039}
     
    20502056        (*iter)->opacity(opacity);
    20512057    }
     2058    NanoVis::EventuallyRedraw();
    20522059    return TCL_OK;
    20532060}
     
    22142221           Tcl_Obj *const *objv)
    22152222{
    2216     fprintf(stderr, "load plane for 2D visualization command\n");
     2223    TRACE("load plane for 2D visualization command\n");
     2224
    22172225    int index, w, h;
    22182226    if (objc != 4) {
     
    22542262            Tcl_Obj *const *objv)
    22552263{
    2256     fprintf(stderr, "link the plane to the 2D renderer command\n");
     2264    TRACE("link the plane to the 2D renderer command\n");
    22572265
    22582266    int plane_index, tf_index;
     
    22792287              Tcl_Obj *const *objv)
    22802288{
    2281     fprintf(stderr,"enable a plane so the 2D renderer can render it command\n");
     2289    TRACE("enable a plane so the 2D renderer can render it command\n");
    22822290
    22832291    if (objc != 3) {
     
    24042412    // create a default transfer function
    24052413    if (Tcl_Eval(interp, def_transfunc) != TCL_OK) {
    2406         fprintf(NanoVis::logfile, "WARNING: bad default transfer function\n");
    2407         fprintf(NanoVis::logfile, "%s\n", Tcl_GetStringResult(interp));
     2414        WARN("bad default transfer function\n%s\n",
     2415            Tcl_GetStringResult(interp));
    24082416    }
    24092417    return interp;
  • trunk/packages/vizservers/nanovis/ContourLineFilter.cpp

    r1053 r1984  
    3636   
    3737    float transtion = (max - min) / (linecount + 1);
    38    
    3938    float val;
    40     int totalNumOfPoints = 0, numOfPoints;
     39    int totalPoints = 0, numPoints;
    4140    for (int i = 1; i <= linecount; ++i) {
    4241        val = min + i * transtion;
    4342       
    4443        ContourLine* c = new ContourLine(val);
    45         numOfPoints = c->createLine(width, height, vertices, _top);
    46         if (numOfPoints != 0) {
    47             totalNumOfPoints += numOfPoints;
     44        numPoints = c->createLine(width, height, vertices, _top);
     45        if (numPoints != 0) {
     46            totalPoints += numPoints;
    4847            _lines.push_back(c);
    4948        } else {
     
    5150        }
    5251    }
    53    
    54     Vector3* vertexSet = (Vector3*) malloc(sizeof(Vector3) * totalNumOfPoints);
    55     Vector3* colorSet = 0;
     52    Vector3* vertexSet = (Vector3 *)malloc(sizeof(Vector3) * totalPoints);
     53    Vector3* colorSet = NULL;
    5654    if (_colorMap) {
    57         colorSet = (Vector3*) malloc(sizeof(Vector3) * totalNumOfPoints);
    58     }
    59    
     55        colorSet = (Vector3 *)malloc(sizeof(Vector3) * totalPoints);
     56    }
    6057    ContourLineFilter::ContourLineList::iterator iter;
    6158    unsigned int index = 0, colorIndex = 0;
     
    7269        }
    7370    }
    74    
    7571    R2VertexBuffer* vertexBuffer;
    76     vertexBuffer = new R2VertexBuffer(R2VertexBuffer::POSITION3,
    77                                       totalNumOfPoints,
    78                                       totalNumOfPoints * sizeof(Vector3),
    79                                       vertexSet, false);
    80     R2VertexBuffer* colorBuffer = 0;
    81     R2Geometry* geometry = 0;
     72    vertexBuffer = new R2VertexBuffer(R2VertexBuffer::POSITION3, totalPoints,
     73        totalPoints * sizeof(Vector3), vertexSet, false);
     74    R2VertexBuffer* colorBuffer = NULL;
    8275    if (_colorMap) {
    83         colorBuffer  = new R2VertexBuffer(R2VertexBuffer::COLOR4,
    84                                           totalNumOfPoints,
    85                                           totalNumOfPoints * sizeof(Vector3),
    86                                           colorSet, false);
    87     }
    88 
     76        colorBuffer  = new R2VertexBuffer(R2VertexBuffer::COLOR4, totalPoints,
     77                totalPoints * sizeof(Vector3), colorSet, false);
     78    }
     79    R2Geometry* geometry;
    8980    geometry = new R2Geometry(R2Geometry::LINES, vertexBuffer, colorBuffer, 0);
    9081    clear();
     
    10192
    10293    float val;
    103     int totalNumOfPoints = 0, numOfPoints;
     94    int totalPoints = 0, numPoints;
    10495    for (int i = 1; i <= linecount; ++i) {
    10596        val = min + i * transtion;
    10697       
    10798        ContourLine* c = new ContourLine(val);
    108         numOfPoints = c->createLine(width, height, vertices, _top);
    109         if (numOfPoints != 0) {
    110             totalNumOfPoints += numOfPoints;
     99        numPoints = c->createLine(width, height, vertices, _top);
     100        if (numPoints != 0) {
     101            totalPoints += numPoints;
    111102            _lines.push_back(c);
    112103        } else {
     
    114105        }
    115106    }
    116     Vector3* vertexSet = (Vector3*) malloc(sizeof(Vector3) * totalNumOfPoints);
    117     Vector3* colorSet = (Vector3*) malloc(sizeof(Vector3) * totalNumOfPoints);
     107    Vector3* vertexSet = (Vector3 *)malloc(sizeof(Vector3) * totalPoints);
     108    Vector3* colorSet  = (Vector3 *)malloc(sizeof(Vector3) * totalPoints);
    118109       
    119110    ContourLineFilter::ContourLineList::iterator iter;
     
    133124    }
    134125    R2VertexBuffer* vertexBuffer;
    135     vertexBuffer = new R2VertexBuffer(R2VertexBuffer::POSITION3,
    136                                       totalNumOfPoints,
    137                                       totalNumOfPoints * sizeof(Vector3),
    138                                       vertexSet, false);
     126    vertexBuffer = new R2VertexBuffer(R2VertexBuffer::POSITION3, totalPoints,
     127        totalPoints * sizeof(Vector3), vertexSet, false);
    139128    R2VertexBuffer* colorBuffer;
    140     colorBuffer = new R2VertexBuffer(R2VertexBuffer::COLOR4, totalNumOfPoints,
    141                                      totalNumOfPoints * sizeof(Vector3),
    142                                      colorSet, false);
     129    colorBuffer = new R2VertexBuffer(R2VertexBuffer::COLOR4, totalPoints,
     130        totalPoints * sizeof(Vector3), colorSet, false);
    143131    R2Geometry* geometry;
    144132    geometry = new R2Geometry(R2Geometry::LINES, vertexBuffer, colorBuffer, 0);
     
    224212}
    225213
    226 bool
    227 ContourLineFilter::ContourLine::isValueWithIn(float val1, float Val2)
    228 {
    229     return ((_value >= val1 && _value <= Val2) ||
    230             (_value >= Val2 && _value <= val1));
    231 }
    232214
    233215void
  • trunk/packages/vizservers/nanovis/ContourLineFilter.h

    r1000 r1984  
    1010class ContourLineFilter {
    1111public :
    12         class ContourLine {
    13         public :
    14                 float _value;
    15                 std::list<Vector3> _points;
    16         public :
    17                 ContourLine(float value);
    18 
    19         private :
    20                 bool isValueWithIn(float Val1, float Val2);
    21                 void getContourPoint(int vertexIndex1, int vertexIndex2, Vector3* vertices, int width, bool top);
    22                 void getContourPoint(int vertexIndex1, int vertexIndex2, Vector4* vertices, int width, bool top);
    23         public : 
    24                 /**
    25                  * @brief
    26                  * @ret Returns the number of points
    27                  */
    28                 int createLine(int width, int height, Vector3* vertices, bool top);
    29                 int createLine(int width, int height, Vector4* vertices, bool top);
    30         };
    31 
    32         typedef std::list<ContourLine*> ContourLineList;
    33 
     12    class ContourLine {
     13    public :
     14        float _value;
     15        std::list<Vector3> _points;
     16    public :
     17        ContourLine(float value);
     18       
     19    private :
     20        bool isValueWithIn(float v1, float v2) {
     21            return ((_value >= v1 && _value <= v2) ||
     22                    (_value >= v2 && _value <= v1));
     23        }
     24        void getContourPoint(int vertexIndex1, int vertexIndex2, Vector3* vertices, int width, bool top);
     25        void getContourPoint(int vertexIndex1, int vertexIndex2, Vector4* vertices, int width, bool top);
     26    public : 
     27        /**
     28         * @brief
     29         * @ret Returns the number of points
     30         */
     31        int createLine(int width, int height, Vector3* vertices, bool top);
     32        int createLine(int width, int height, Vector4* vertices, bool top);
     33    };
     34   
     35    typedef std::list<ContourLine*> ContourLineList;
     36   
    3437private :
    35         ContourLineList _lines;
    36         Vector3Array* _colorMap;
     38    ContourLineList _lines;
     39    Vector3Array* _colorMap;
    3740    bool _top;
    3841public :
    39         ContourLineFilter();
    40 
     42    ContourLineFilter();
     43   
    4144private :
    42         void clear();
    43        
     45    void clear();
     46   
    4447public :
    45         R2Geometry* create(float min, float max, int linecount, Vector3* vertices, int width, int height);
    46         R2Geometry* create(float min, float max, int linecount, Vector4* vertices, int width, int height);
    47         void setColorMap(Vector3Array* colorMap);
    48 
     48    R2Geometry* create(float min, float max, int linecount, Vector3* vertices, int width, int height);
     49    R2Geometry* create(float min, float max, int linecount, Vector4* vertices, int width, int height);
     50    void setColorMap(Vector3Array* colorMap);
     51   
    4952    void setHeightTop(bool top)
    5053    {
    51        _top = top;
     54        _top = top;
    5255    }
    5356};
  • trunk/packages/vizservers/nanovis/ConvexPolygon.cpp

    r978 r1984  
    1515 */
    1616#include "ConvexPolygon.h"
     17#include "Trace.h"
    1718#include <GL/gl.h>
    1819#include <assert.h>
     
    5455    if (uDenom == 0){
    5556        //plane parallel to line
    56         fprintf(stderr, "Unexpected code path: ConvexPolygon.cpp\n");
     57        ERROR("Unexpected code path: ConvexPolygon.cpp\n");
    5758        if (uNumer == 0){
    5859            for (int i = 0; i < 4; i++)
     
    9798ConvexPolygon::clip(Plane &clipPlane, bool copy_to_texcoord) {
    9899    if (vertices.size() == 0) {
    99         //fprintf(stderr, "ConvexPolygon: polygon has no vertices\n"); 
     100        //ERROR("ConvexPolygon: polygon has no vertices\n"); 
    100101        return;
    101102    }
     
    172173            }
    173174            glVertex4fv((float *)&(vertices[i]));
    174             /*
    175             //debug
    176             fprintf(stderr, "(%f %f %f %f)",
    177             vertices[i].x,
    178             vertices[i].y,
    179             vertices[i].z,
    180             vertices[i].w );
    181             */
    182175        }
    183176    }
    184     //fprintf(stderr, " ");
    185177}
    186178
  • trunk/packages/vizservers/nanovis/EventPlayer.cpp

    r980 r1984  
    165165  cur_event++;
    166166
    167   fprintf(stderr, "% 6d %.6f\n", len, time_interval);
     167  TRACE("% 6d %.6f\n", len, time_interval);
    168168}
    169169
     
    181181    fscanf(fd, "%d %f %f %f %g\n", &type, param, param+1, param+2, &interval);
    182182    event[i] = new Event(type, param, interval);
    183     //fprintf(stderr, "%d %f %f %f\n", type, param[0], param[1], param[2]);
     183    TRACE("%d %f %f %f\n", type, param[0], param[1], param[2]);
    184184  }
    185185  fclose(fd);
     
    187187  socket_fd = connect_renderer(host, atoi(port), 100);
    188188  if (socket_fd == -1) {
    189      fprintf(stderr, "Could not connect to a server.\n");
    190      return 1;
     189      ERROR("Could not connect to a server.\n");
     190      return 1;
    191191  }
    192192
     
    194194}
    195195
    196 void help(const char *argv0)
    197 {
    198   fprintf(stderr,
    199           "Syntax: %s addr port eventfile\n",
    200           argv0);
    201   exit(1);
     196void
     197help(const char *argv0)
     198{
     199    TRACE("Syntax: %s addr port eventfile\n", argv0);
     200    exit(1);
    202201}
    203202
    204203/* Program entry point */
    205 int main(int argc, char *argv[])
     204int
     205main(int argc, char *argv[])
    206206{
    207207    //parameters: host and port and event file
  • trunk/packages/vizservers/nanovis/FlowCmd.cpp

    r1899 r1984  
    141141FlowParticles::Render(void)
    142142{
    143     Trace("rendering particles %s\n", _name);
    144     Trace("rendering particles %s axis=%d\n", _name, _sv.position.axis);
    145     Trace("rendering particles %s position=%g\n", _name, _sv.position.value);
    146     Trace("rendering particles %s position=%g\n", _name,
    147           FlowCmd::GetRelativePosition(&_sv.position));
     143    TRACE("rendering particles %s\n", _name);
     144    TRACE("rendering particles %s axis=%d\n", _name, _sv.position.axis);
     145    TRACE("rendering particles %s position=%g\n", _name, _sv.position.value);
     146    TRACE("rendering particles %s position=%g\n", _name,
     147           FlowCmd::GetRelativePosition(&_sv.position));
    148148
    149149    _rendererPtr->setPos(FlowCmd::GetRelativePosition(&_sv.position));
     
    183183FlowBox::Render(Volume *volPtr)
    184184{
    185     Trace("Rendering box %s\n", _name);
     185    TRACE("Rendering box %s\n", _name);
    186186    glColor4d(_sv.color.r, _sv.color.g, _sv.color.b, _sv.color.a);
    187187
     
    209209    max = volPtr->getPhysicalBBoxMax();
    210210
    211     Trace("box is %g,%g %g,%g %g,%g\n",
     211    TRACE("box is %g,%g %g,%g %g,%g\n",
    212212          _sv.corner1.x, _sv.corner2.x,
    213213          _sv.corner1.y, _sv.corner2.y,
    214           _sv.corner1.z, _sv.corner2.z);
    215     Trace("world is %g,%g %g,%g %g,%g\n",
    216           min.x, max.x, min.y, max.y, min.z, max.z);
     214           _sv.corner1.z, _sv.corner2.z);
     215    TRACE("world is %g,%g %g,%g %g,%g\n",
     216           min.x, max.x, min.y, max.y, min.z, max.z);
    217217
    218218    float x0, y0, z0, x1, y1, z1;
     
    231231        x1 = (_sv.corner2.x - min.x) / (max.x - min.x);
    232232    }
    233     Trace("rendering box %g,%g %g,%g %g,%g\n", x0, x1, y0, y1, z0, z1);
     233    TRACE("rendering box %g,%g %g,%g %g,%g\n", x0, x1, y0, y1, z0, z1);
    234234
    235235    glLineWidth(_sv.lineWidth);
     
    371371        }
    372372    }
    373     Trace("in Render before boxes %s\n", _name);
     373    TRACE("in Render before boxes %s\n", _name);
    374374    RenderBoxes();
    375375}
     
    522522{
    523523    if (_volPtr != NULL) {
    524         fprintf(stderr, "from ScaleVectorField volId=%s\n", _volPtr->name());
     524        TRACE("from ScaleVectorField volId=%s\n", _volPtr->name());
    525525        NanoVis::remove_volume(_volPtr);
    526526        _volPtr = NULL;
     
    581581            //,volPtr->wAxis.max()
    582582            );
    583         Trace("Arrows enabled set to %d\n", _sv.showArrows);
     583        TRACE("Arrows enabled set to %d\n", _sv.showArrows);
    584584        NanoVis::velocityArrowsSlice->axis(_sv.slicePos.axis);
    585585        NanoVis::velocityArrowsSlice->slicePos(_sv.slicePos.value);
     
    601601    FlowBox *boxPtr;
    602602    for (boxPtr = FirstBox(&iter); boxPtr != NULL; boxPtr = NextBox(&iter)) {
    603         Trace("found box %s\n", boxPtr->name());
     603        TRACE("found box %s\n", boxPtr->name());
    604604        if (boxPtr->visible()) {
    605605            boxPtr->Render(_volPtr);
     
    655655    Vector3 physicalMin(NanoVis::xMin, NanoVis::yMin, NanoVis::zMin);
    656656    Vector3 physicalMax(NanoVis::xMax, NanoVis::yMax, NanoVis::zMax);
    657     Trace("min=%g %g %g max=%g %g %g mag=%g %g\n",
     657    TRACE("min=%g %g %g max=%g %g %g mag=%g %g\n",
    658658            NanoVis::xMin, NanoVis::yMin, NanoVis::zMin,
    659659            NanoVis::xMax, NanoVis::yMax, NanoVis::zMax,
    660             NanoVis::magMin, NanoVis::magMax);
     660           NanoVis::magMin, NanoVis::magMax);
    661661    volPtr->setPhysicalBBox(physicalMin, physicalMax);
    662662    //volPtr->set_n_slice(256 - _volIndex);
     
    677677    volPtr->specular(_sv.specular);
    678678    volPtr->diffuse(_sv.diffuse);
    679     Trace("volume is now %d %d\n", _sv.showVolume, volPtr->visible());
     679    TRACE("volume is now %d %d\n", _sv.showVolume, volPtr->visible());
    680680    volPtr->visible(_sv.showVolume);
    681681    float dx0 = -0.5;
     
    696696    const char *fileName;
    697697    fileName = Tcl_GetString(objv[3]);
    698     Trace("Flow loading data from file %s\n", fileName);
     698    TRACE("Flow loading data from file %s\n", fileName);
    699699
    700700    int nComponents;
     
    740740        delete u2dPtr;
    741741    } else {
    742         fprintf(stderr, "header is %.14s\n", buf.bytes());
     742        TRACE("header is %.14s\n", buf.bytes());
    743743        if (!dataPtr->ImportDx(result, nComponents, length, bytes)) {
    744744            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
     
    767767    Rappture::Outcome result;
    768768
    769     Trace("Flow Data Loading\n");
     769    TRACE("Flow Data Loading\n");
    770770
    771771    int nBytes;
    772772    if (Tcl_GetIntFromObj(interp, objv[3], &nBytes) != TCL_OK) {
    773         Trace("Bad nBytes \"%s\"\n", Tcl_GetString(objv[3]));
     773        ERROR("Bad nBytes \"%s\"\n", Tcl_GetString(objv[3]));
    774774        return TCL_ERROR;
    775775    }
     
    777777        Tcl_AppendResult(interp, "bad # bytes request \"",
    778778                Tcl_GetString(objv[3]), "\" for \"data follows\"", (char *)NULL);
    779         Trace("Bad nbytes %d\n", nBytes);
     779        ERROR("Bad nbytes %d\n", nBytes);
    780780        return TCL_ERROR;
    781781    }
    782782    int nComponents;
    783783    if (Tcl_GetIntFromObj(interp, objv[4], &nComponents) != TCL_OK) {
    784         Trace("Bad # of components \"%s\"\n", Tcl_GetString(objv[4]));
     784        ERROR("Bad # of components \"%s\"\n", Tcl_GetString(objv[4]));
    785785        return TCL_ERROR;
    786786    }
     
    788788        Tcl_AppendResult(interp, "bad # of components request \"",
    789789                Tcl_GetString(objv[4]), "\" for \"data follows\"", (char *)NULL);
    790         Trace("Bad # of components %d\n", nComponents);
     790        ERROR("Bad # of components %d\n", nComponents);
    791791        return TCL_ERROR;
    792792    }
    793793    Rappture::Buffer buf;
    794     Trace("Flow Data Loading %d %d\n", nBytes, nComponents);
     794    TRACE("Flow Data Loading %d %d\n", nBytes, nComponents);
    795795    if (GetDataStream(interp, buf, nBytes) != TCL_OK) {
    796796        return TCL_ERROR;
     
    823823        delete u2dPtr;
    824824    } else {
    825         fprintf(stderr, "header is %.14s\n", buf.bytes());
     825        TRACE("header is %.14s\n", buf.bytes());
    826826        if (!dataPtr->ImportDx(result, nComponents, length, bytes)) {
    827827            Tcl_AppendResult(interp, result.remark(), (char *)NULL);
     
    991991{
    992992    flags &= ~MAP_FLOWS;
    993     Trace("MapFlows\n");
     993    TRACE("MapFlows\n");
    994994
    995995    /*
     
    10361036        }
    10371037    }
    1038     Trace("MapFlows magMin=%g magMax=%g\n", NanoVis::magMin, NanoVis::magMax);
     1038    TRACE("MapFlows magMin=%g magMax=%g\n", NanoVis::magMin, NanoVis::magMax);
    10391039
    10401040    /*
     
    20002000    oldHeight = NanoVis::win_height;
    20012001
    2002     Trace("FLOW started\n");
     2002    TRACE("FLOW started\n");
    20032003
    20042004    Rappture::Outcome context;
     
    20422042    }
    20432043    movie.done(context);
    2044     Trace("FLOW end\n");
     2044    TRACE("FLOW end\n");
    20452045    if (!canceled) {
    20462046        Rappture::Buffer data;
  • trunk/packages/vizservers/nanovis/GradientFilter.cpp

    r1053 r1984  
    66#include <string.h>
    77#include <stdio.h>
     8#include "Trace.h"
    89#include "GradientFilter.h"
    910
     
    3940                                     strlen(floatExt) +
    4041                                     strlen(GRADIENTS_EXT) + 1))) {
    41         fprintf(stderr, "not enough memory for filename\n");
     42        ERROR("not enough memory for filename\n");
    4243        exit(1);
    4344    }
     
    6566    if (fwrite(gradients, 3 * sizes[0] * sizes[1] * sizes[2] * sizeof(float),
    6667               1, fp) != 1) {
    67         fprintf(stderr, "writing float gradients failed\n");
     68        ERROR("writing float gradients failed\n");
    6869        exit(1);
    6970    }
     
    119120            break;
    120121        default:
    121             fprintf(stderr, "Unsupported data type\n");
     122            ERROR("Unsupported data type\n");
    122123            exit(1);
    123124            break;
     
    171172    };
    172173
    173     fprintf(stderr, "computing gradients ... may take a while\n");
     174    TRACE("computing gradients ... may take a while\n");
    174175
    175176    di = 0;
     
    294295    float sum, *filteredGradients, ****filter;
    295296
    296     fprintf(stderr, "filtering gradients ... may also take a while\n");
     297    TRACE("filtering gradients ... may also take a while\n");
    297298
    298299    if (! (filteredGradients = (float *)malloc(sizes[0] * sizes[1] * sizes[2]
    299300                                               * 3 * sizeof(float)))) {
    300         fprintf(stderr, "not enough memory for filtered gradients\n");
     301        ERROR("not enough memory for filtered gradients\n");
    301302        exit(1);
    302303    }
     
    305306    if (! (filter = (float ****)malloc((GRAD_FILTER_SIZE/2 + 1) *
    306307                                       sizeof(float ***)))) {
    307         fprintf(stderr, "failed to allocate gradient filter\n");
     308        ERROR("failed to allocate gradient filter\n");
    308309        exit(1);
    309310    }
     
    312313        if (! (filter[i] = (float ***)malloc((GRAD_FILTER_SIZE) *
    313314                                             sizeof(float **)))) {
    314             fprintf(stderr, "failed to allocate gradient filter\n");
     315            ERROR("failed to allocate gradient filter\n");
    315316            exit(1);
    316317        }
     
    320321            if (! (filter[i][j] = (float **)malloc((GRAD_FILTER_SIZE) *
    321322                                                   sizeof(float *)))) {
    322                 fprintf(stderr, "failed to allocate gradient filter\n");
     323                ERROR("failed to allocate gradient filter\n");
    323324                exit(1);
    324325            }
     
    330331                if (! (filter[i][j][k] = (float *)malloc((GRAD_FILTER_SIZE) *
    331332                                                         sizeof(float)))) {
    332                     fprintf(stderr, "failed to allocate gradient filter\n");
     333                    ERROR("failed to allocate gradient filter\n");
    333334                    exit(1);
    334335                }
     
    509510                    break;
    510511                default:
    511                     fprintf(stderr, "unsupported data type\n");
     512                    ERROR("unsupported data type\n");
    512513                    break;
    513514                }
     
    535536
    536537    if (fwrite(gradients, size, 1, fp) != 1) {
    537         fprintf(stderr, "writing gradients failed\n");
     538         ERROR("writing gradients failed\n");
    538539        exit(1);
    539540    }
  • trunk/packages/vizservers/nanovis/HeightMap.cpp

    r1546 r1984  
    4040    _scale(1.0f, 1.0f, 1.0f),
    4141    _centerPoint(0.0f, 0.0f, 0.0f),
    42     heights_(NULL)
     42    _heights(NULL)
    4343{
    4444    _shader = new NvShader();
     
    5555        delete _shader;
    5656    }
    57 
    58     // TMP
    59     //if (_tfPtr) delete _tfPtr;
    60 }
    61 
    62 void HeightMap::render(graphics::RenderContext* renderContext)
     57    if (_heights != NULL) {
     58        free(_heights);
     59    }
     60}
     61
     62void
     63HeightMap::render(graphics::RenderContext* renderContext)
    6364{
    6465    if (renderContext->getCullMode() == graphics::RenderContext::NO_CULL) {
     
    138139        }
    139140    }
    140    
    141141    glShadeModel(GL_FLAT);
    142142    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
     
    173173    if (_indexBuffer != NULL) {
    174174        delete [] _indexBuffer;
     175        _indexBuffer = NULL;
    175176    }
    176177    _indexCount = (xCount - 1) * (zCount - 1) * 6;
     
    241242    if (_vertexBufferObjectID) {
    242243        glDeleteBuffers(1, &_vertexBufferObjectID);
    243         _vertexBufferObjectID = 0;
     244        _vertexBufferObjectID = NULL;
    244245    }
    245246    if (_textureBufferObjectID) {
    246247        glDeleteBuffers(1, &_textureBufferObjectID);
    247         _textureBufferObjectID = 0;
     248        _textureBufferObjectID = NULL;
    248249    }
    249250    if (_contour != NULL) {
     
    251252        _contour = NULL;
    252253    }
     254    if (_indexBuffer != NULL) {
     255        delete [] _indexBuffer;
     256        _indexBuffer = NULL;
     257    }
    253258}
    254259
     
    259264    reset();
    260265   
    261     heights_ = (float *)heights;
     266    _heights = (float *)heights;
    262267    float min, max;
    263268    min = heights[0].y, max = heights[0].y;
     
    302307    delete [] texcoord;
    303308   
    304    
     309    if (_contour != NULL) {
     310        delete _contour;
     311        _contour = NULL;
     312    }
    305313    ContourLineFilter lineFilter;
    306314    _contour = lineFilter.create(0.0f, 1.0f, 10, heights, xCount, yCount);
     
    319327    //else
    320328    //{
    321     //printf("ERROR - HeightMap::setHeight\n");
     329    //ERROR("HeightMap::setHeight\n");
    322330    //}
    323331}
     
    328336{
    329337    _vertexCount = xNum * yNum;
    330     xNum_ = xNum, yNum_ = yNum;
    331     heights_ = heights;
     338    _xNum = xNum, _yNum = yNum;
     339    _heights = heights;
    332340    reset();
    333341   
     
    377385    }
    378386   
    379     Vector3* heightMap = createHeightVertices(xMin, yMin, xMax, yMax, xNum, yNum, heights);
     387    Vector3* map = createHeightVertices(xMin, yMin, xMax, yMax, xNum, yNum,
     388                                        heights);
    380389   
    381390    glGenBuffers(1, &_vertexBufferObjectID);
    382391    glBindBuffer(GL_ARRAY_BUFFER, _vertexBufferObjectID);
    383     glBufferData(GL_ARRAY_BUFFER, _vertexCount * sizeof( Vector3 ), heightMap,
     392    glBufferData(GL_ARRAY_BUFFER, _vertexCount * sizeof(Vector3), map,
    384393        GL_STATIC_DRAW);
    385394    glGenBuffers(1, &_textureBufferObjectID);
     
    392401   
    393402   
     403    if (_contour != NULL) {
     404        delete _contour;
     405        _contour = NULL;
     406    }
    394407    ContourLineFilter lineFilter;
    395408    //lineFilter.transferFunction(_tfPtr);
    396     _contour = lineFilter.create(0.0f, 1.0f, 10, heightMap, xNum, yNum);
     409    _contour = lineFilter.create(0.0f, 1.0f, 10, map, xNum, yNum);
    397410   
    398411#if TOPCONTOUR
    399412    ContourLineFilter topLineFilter;
    400413    topLineFilter.setHeightTop(true);
    401     _topContour = topLineFilter.create(0.0f, 1.0f, 10, heightMap, xNum, yNum);
    402 #endif
    403 
    404 
    405     //if (heightMap)
    406     //{
    407     //  VertexBuffer* vertexBuffer = new VertexBuffer(VertexBuffer::POSITION3, xNum * yNum,
    408     // sizeof(Vector3) * xNum * yNum, heightMap, false);
    409     if (_indexBuffer != NULL) {
    410         free(_indexBuffer);
    411         _indexBuffer = NULL;
    412     }
     414    _topContour = topLineFilter.create(0.0f, 1.0f, 10, map, xNum, yNum);
     415#endif
    413416    this->createIndexBuffer(xNum, yNum, heights);
    414     //}
    415     //else
    416     //{
    417     //printf("ERROR - HeightMap::setHeight\n");
    418     //}
     417    delete [] map;
    419418#endif
    420419}
     
    424423                                float yMax, int xNum, int yNum, float* height)
    425424{
    426     Vector3* vertices = (Vector3*) malloc(sizeof(Vector3) * xNum * yNum);
     425    Vector3* vertices = new Vector3[xNum * yNum];
    427426
    428427    Vector3* dstDataPtr = vertices;
     
    450449HeightMap::MapToGrid(Grid *gridPtr)
    451450{
    452     int count = xNum_ * yNum_;
     451    int count = _xNum * _yNum;
    453452
    454453    reset();
     
    461460    float *p, *q, *pend;
    462461    float *normHeights = new float[count];
    463     for (p = heights_, pend = p + count, q = normHeights; p < pend; p++, q++) {
     462    for (p = _heights, pend = p + count, q = normHeights; p < pend; p++, q++) {
    464463        *q = (*p - gridPtr->yAxis.min()) * yScale;
    465464    }
     
    484483
    485484    Vector3* vertices;
    486     vertices = createHeightVertices(xMin, zMin, xMax, zMax, xNum_, yNum_,
     485    vertices = createHeightVertices(xMin, zMin, xMax, zMax, _xNum, _yNum,
    487486        normHeights);
    488487   
     
    498497    delete [] texcoord;
    499498
     499    if (_contour != NULL) {
     500        delete _contour;
     501        _contour = NULL;
     502    }
    500503    ContourLineFilter lineFilter;
    501504    //lineFilter.transferFunction(_tfPtr);
    502     _contour = lineFilter.create(0.0f, 1.0f, 10, vertices, xNum_, yNum_);
     505    _contour = lineFilter.create(0.0f, 1.0f, 10, vertices, _xNum, _yNum);
    503506   
    504507#if TOPCONTOUR
    505508    ContourLineFilter topLineFilter;
    506509    topLineFilter.setHeightTop(true);
    507     _topContour = topLineFilter.create(0.0f, 1.0f, 10, vertices, xNum_, yNum_);
    508 #endif
    509     this->createIndexBuffer(xNum_, yNum_, normHeights);
     510    _topContour = topLineFilter.create(0.0f, 1.0f, 10, vertices, _xNum, _yNum);
     511#endif
     512    this->createIndexBuffer(_xNum, _yNum, normHeights);
    510513    delete [] normHeights;
    511 }
    512 
    513 void HeightMap::render_topview(graphics::RenderContext* renderContext, int render_width, int render_height)
     514    delete [] vertices;
     515}
     516
     517void
     518HeightMap::render_topview(graphics::RenderContext* renderContext,
     519                          int render_width, int render_height)
    514520{
    515521   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  • trunk/packages/vizservers/nanovis/HeightMap.h

    r1546 r1984  
    4343    Vector3 _scale;
    4444    Vector3 _centerPoint;
    45     int xNum_, yNum_;           // Number of elements x and y axes in grid.
    46     float *heights_;            // Array of original (unscaled) heights
     45    int _xNum, _yNum;           // Number of elements x and y axes in grid.
     46    float *_heights;            // Array of original (unscaled) heights
    4747                                // (y-values)
    4848public :
     
    5454     *@brief Constructor
    5555     */
    56         HeightMap();
     56    HeightMap();
    5757    /**
    5858     *@brief Destructor
    5959     */
    60         ~HeightMap();
     60    ~HeightMap();
    6161
    6262private :
  • trunk/packages/vizservers/nanovis/Mat4x4.cpp

    r1028 r1984  
    2727void
    2828Mat4x4::print(){
    29     fprintf(stderr, "\n%f %f %f %f\n", m[0], m[1], m[2], m[3]);
    30     fprintf(stderr, "%f %f %f %f\n", m[4], m[5], m[6], m[7]);
    31     fprintf(stderr, "%f %f %f %f\n", m[8], m[9], m[10], m[11]);
    32     fprintf(stderr, "%f %f %f %f\n\n", m[12], m[13], m[14], m[15]);
     29    TRACE("\n%f %f %f %f\n", m[0], m[1], m[2], m[3]);
     30    TRACE("%f %f %f %f\n", m[4], m[5], m[6], m[7]);
     31    TRACE("%f %f %f %f\n", m[8], m[9], m[10], m[11]);
     32    TRACE("%f %f %f %f\n\n", m[12], m[13], m[14], m[15]);
    3333}
    3434
     
    7070
    7171#if 0
    72     fprintf(stderr, "Invert:\n");
    73     fprintf(stderr, "   %12.9f %12.9f %12.9f %12.9f\n", m00, m01, m02, m03);
    74     fprintf(stderr, "   %12.9f %12.9f %12.9f %12.9f\n", m10, m11, m12, m13);
    75     fprintf(stderr, "   %12.9f %12.9f %12.9f %12.9f\n", m20, m21, m22, m23);
    76     fprintf(stderr, "   %12.9f %12.9f %12.9f %12.9f\n", m30, m31, m32, m33);
     72    TRACE("Invert:\n");
     73    TRACE("   %12.9f %12.9f %12.9f %12.9f\n", m00, m01, m02, m03);
     74    TRACE("   %12.9f %12.9f %12.9f %12.9f\n", m10, m11, m12, m13);
     75    TRACE("   %12.9f %12.9f %12.9f %12.9f\n", m20, m21, m22, m23);
     76    TRACE("   %12.9f %12.9f %12.9f %12.9f\n", m30, m31, m32, m33);
    7777#endif
    7878
  • trunk/packages/vizservers/nanovis/NvCamera.cpp

    r1431 r1984  
    1616
    1717#include <stdio.h>
     18#include "Trace.h"
    1819#include <GL/glu.h>
    1920#include "NvCamera.h"
     
    3839NvCamera::initialize()
    3940{
    40     //fprintf(stderr, "camera: %d, %d\n", width, height);
     41    TRACE("camera: %d, %d\n", width_, height_);
    4142    glViewport(startX_, startY_, width_, height_);
    4243    glMatrixMode(GL_PROJECTION);
  • trunk/packages/vizservers/nanovis/NvEventLog.cpp

    r1194 r1984  
    1111#include "nanovis.h"
    1212
    13 
    14 #ifdef XINETD
    15 FILE* xinetd_log;
    16 #endif
    1713
    1814FILE* event_log;
     
    3834    }
    3935
    40     if (!NanoVis::debug_flag) {
    41         //open log and map stderr to log file
    42         xinetd_log = fopen(logName, "w");
    43         close(2);
    44         dup2(fileno(xinetd_log), 2);
    45         dup2(2,1);
    46         //flush junk
    47         fflush(stdout);
    48         fflush(stderr);
    49     }
     36    //open log and map stderr to log file
     37    NanoVis::logfile = fopen(logName, "w");
     38    close(2);
     39    dup2(fileno(NanoVis::logfile), 2);
     40    dup2(2,1);
     41    //flush junk
     42    fflush(stdout);
     43    fflush(stderr);
    5044
    5145    // clean up malloc'd memory
     
    5852{
    5953    //close log file
    60     if (xinetd_log != NULL) {
    61         fclose(xinetd_log);
    62         xinetd_log = NULL;
     54    if (NanoVis::logfile != NULL) {
     55        fclose(NanoVis::logfile);
     56        NanoVis::logfile = NULL;
    6357    }
    6458}
  • trunk/packages/vizservers/nanovis/NvLIC.cpp

    r1515 r1984  
    153153NvLIC::make_patterns()
    154154{
    155     Trace("begin make_patterns\n");
     155    TRACE("begin make_patterns\n");
    156156    if (disListID > 0) {
    157157        glDeleteLists(disListID, Npat);
     
    159159    disListID = glGenLists(Npat);
    160160   
    161     Trace("DisplayList : %d\n", disListID);
     161    TRACE("DisplayList : %d\n", disListID);
    162162   
    163163    int lut[256];
     
    193193    glTexImage2D(GL_TEXTURE_2D, 0, 4, NPN, NPN, 0,
    194194                 GL_RGBA, GL_UNSIGNED_BYTE, pat);
    195     Trace("finish make_patterns\n");
     195    TRACE("finish make_patterns\n");
    196196}
    197197
     
    470470/*
    471471{
    472     //Trace("RENDER LIC\n");
     472    //TRACE("RENDER LIC\n");
    473473   //glBindTexture(GL_TEXTURE_2D, pattern_tex);
    474474   glCallList(1 % Npat + disListID);
     
    505505                      float scaleX, float scaleY, float scaleZ, float max)
    506506{
    507     Trace("NvLIC: vector field is assigned [%d]\n", texID);
     507    TRACE("NvLIC: vector field is assigned [%d]\n", texID);
    508508    _vectorFieldId = texID;
    509509    origin = ori;
     
    524524   int yi = (int) (y*size);
    525525
    526     //Trace("(xi yi) = (%d %d), ", xi, yi);
     526    //TRACE("(xi yi) = (%d %d), ", xi, yi);
    527527   vx = slice_vector[4 * (xi+yi*size)];
    528528   vy = slice_vector[4 * (xi+yi*size)+1];
    529529   r  = vx*vx + vy*vy;
    530530
    531     //Trace("(vx vx) = (%f %f), r=%f, ", vx, vy, r);
     531    //TRACE("(vx vx) = (%f %f), r=%f, ", vx, vy, r);
    532532   if (r > (dmax*dmax)) {
    533533      r  = sqrt(r);
     
    539539   *py = y + vy;
    540540
    541     //Trace("vel %f %f -> %f %f, (dmax = %f)\n", x, y, *px, *py, dmax);
     541    //TRACE("vel %f %f -> %f %f, (dmax = %f)\n", x, y, *px, *py, dmax);
    542542}
    543543
  • trunk/packages/vizservers/nanovis/NvParticleRenderer.cpp

    r1510 r1984  
    233233    glBindTexture(GL_TEXTURE_RECTANGLE_NV, 0);
    234234
    235     //fprintf(stderr, "init particles\n");
     235    TRACE("init particles\n");
    236236}
    237237
  • trunk/packages/vizservers/nanovis/NvShader.cpp

    r1482 r1984  
    4848void NvShader::setErrorCallback(NvCgCallbackFunction callback)
    4949{
    50         printf("NvShader callback\n");
     50    TRACE("NvShader callback\n");
    5151    cgSetErrorCallback(callback);
    5252}
  • trunk/packages/vizservers/nanovis/PerfQuery.h

    r1510 r1984  
    2020
    2121#include <stdio.h>
     22#include "Trace.h"
    2223#include <GL/glew.h>
    2324
     
    3132                    &bitsSupported);
    3233    if(bitsSupported == 0) {
    33         fprintf(stderr, "occlusion query not supported!\n");
     34        TRACE("occlusion query not supported!\n");
    3435        return false;
    3536    } else {
    36         fprintf(stderr, "Occlusion query with %d bits supported\n",
    37                 bitsSupported);
     37        TRACE("Occlusion query with %d bits supported\n", bitsSupported);
    3838        return true;
    3939    }
  • trunk/packages/vizservers/nanovis/PointSetRenderer.cpp

    r1111 r1984  
    1919    const char *path = R2FilePath::getInstance()->getPath("particle2.bmp");
    2020    if (path == NULL) {
    21         fprintf(stderr, "ERROR : pointset file not found - %s\n", path);
    22         fflush(stdout);
     21        ERROR("pointset file not found - %s\n", path);
    2322        return;
    2423    }
     
    4140                                      4, (float*) image->getImageBuffer());
    4241    } else {
    43         printf("fail to load image [%s]\n", "particles2.bmp");
     42        ERROR("fail to load image [%s]\n", "particles2.bmp");
    4443    }
    4544
  • trunk/packages/vizservers/nanovis/RenderVertexArray.cpp

    r979 r1984  
    3636 */
    3737#include "RenderVertexArray.h"
     38#include "Trace.h"
    3839#include <GL/gl.h>
    3940#include <stdio.h>
     
    5354        m_bytes_per_component = sizeof(float); break;
    5455    default:
    55         fprintf(stderr, "Error: unsupported RenderVertexArray type\n");
     56        ERROR("unsupported RenderVertexArray type\n");
    5657        return;
    5758    }
     
    7374        m_format = GL_RGBA; break;
    7475    default:
    75         fprintf(stderr, "Error: unsupported RenderVertexArray size\n");
     76        ERROR("unsupported RenderVertexArray size\n");
    7677        return;
    7778    }
  • trunk/packages/vizservers/nanovis/RpDX.cpp

    r1581 r1984  
    1515 */
    1616#include "RpDX.h"
     17#undef ERROR
     18#include "Trace.h"
    1719#include <math.h>
    1820#include <stdio.h>
     
    237239    }
    238240    if (_nzero_min == FLT_MAX) {
    239         fprintf(stderr, "could not find a positive minimum value\n");
    240         fflush(stderr);
     241        ERROR("could not find a positive minimum value\n");
    241242    }
    242243}
  • trunk/packages/vizservers/nanovis/ScreenSnapper.cpp

    r1510 r1984  
    1818
    1919#include <memory.h>
     20#include "Trace.h"
    2021#include <assert.h>
    2122#include "ScreenSnapper.h"
     
    9899        if(data_type == GL_FLOAT){
    99100            if(n_channels_per_pixel==3)
    100                 fprintf(stderr, "(%f %f %f) ",
    101                         ((float*)data)[3*i],
    102                         ((float*)data)[3*i+1],
    103                         ((float*)data)[3*i+2]);
     101                TRACE("(%f %f %f) ", ((float*)data)[3*i],
     102                       ((float*)data)[3*i+1], ((float*)data)[3*i+2]);
    104103            else if(n_channels_per_pixel==4)
    105                 fprintf(stderr, "(%f %f %f %f) ",
    106                         ((float*)data)[4*i],
    107                         ((float*)data)[4*i+1],
    108                         ((float*)data)[4*i+2],
    109                         ((float*)data)[4*i+3]);
     104                TRACE("(%f %f %f %f) ", ((float*)data)[4*i],
     105                      ((float*)data)[4*i+1],
     106                      ((float*)data)[4*i+2],
     107                       ((float*)data)[4*i+3]);
    110108        }
    111109        else if(data_type == GL_UNSIGNED_BYTE){
    112110            if(n_channels_per_pixel==3)
    113                 fprintf(stderr, "(%d %d %d) ",
     111                TRACE("(%d %d %d) ",
    114112                        ((unsigned char*)data)[3*i],
    115113                        ((unsigned char*)data)[3*i+1],
    116                         ((unsigned char*)data)[3*i+2]);
     114                       ((unsigned char*)data)[3*i+2]);
    117115            else if(n_channels_per_pixel==4)
    118                 fprintf(stderr, "(%d %d %d %d) ",
     116                TRACE("(%d %d %d %d) ",
    119117                        ((unsigned char*)data)[4*i],
    120118                        ((unsigned char*)data)[4*i+1],
    121119                        ((unsigned char*)data)[4*i+2],
    122                         ((unsigned char*)data)[4*i+3]);
     120                       ((unsigned char*)data)[4*i+3]);
    123121        }
    124122    }
  • trunk/packages/vizservers/nanovis/Sphere.h

    r953 r1984  
    1818#define _SPHERE_H_
    1919
     20#include "Trace.h"
    2021#include <GL/glut.h>
    2122
  • trunk/packages/vizservers/nanovis/Texture1D.cpp

    r1053 r1984  
    1616
    1717#include "Texture1D.h"
     18#include "Trace.h"
    1819#include <stdio.h>
    1920#include <assert.h>
     
    9293       
    9394    //printf("%d", glGetError());
    94     fprintf(stderr, "max texture size: %d\n", max);
     95    TRACE("max texture size: %d\n", max);
    9596}
    9697
     
    99100    glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &max);
    100101
    101     fprintf(stderr, "max texture units: %d.\n", max);
     102    TRACE("max texture units: %d.\n", max);
    102103}
  • trunk/packages/vizservers/nanovis/Texture2D.cpp

    r1053 r1984  
    1616
    1717#include "Texture2D.h"
     18#include "Trace.h"
    1819#include <stdio.h>
    1920#include <assert.h>
     
    141142    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max);
    142143       
    143     fprintf(stderr, "max texture size: %d\n", max);
     144    TRACE("max texture size: %d\n", max);
    144145}
    145146
     
    149150    glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &max);
    150151
    151     fprintf(stderr, "max texture units: %d.\n", max);
     152    TRACE("max texture units: %d.\n", max);
    152153}
    153154
  • trunk/packages/vizservers/nanovis/Texture3D.cpp

    r1053 r1984  
    1616
    1717#include "Texture3D.h"
     18#include "Trace.h"
    1819#include <stdio.h>
    1920#include <assert.h>
     
    207208       
    208209    //printf("%d", glGetError());
    209     fprintf(stderr, "max 3d texture size: %d\n", max);
     210    TRACE("max 3d texture size: %d\n", max);
    210211}
    211212
     
    214215    glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &max);
    215216
    216     fprintf(stderr, "max texture units: %d.\n", max);
    217 }
     217    TRACE("max texture units: %d.\n", max);
     218}
  • trunk/packages/vizservers/nanovis/Trace.cpp

    r1526 r1984  
     1#include "nanovis.h"
    12#include <Trace.h>
    23#include <stdio.h>
     
    67#include <GL/glut.h>
    78
    8 static bool trace = true;
     9static bool trace = false;
    910
    1011void
    11 Trace(const char* format, ...)
     12PrintMessage(const char *mesg, const char *fileName, int lineNum,
     13             const char* format, ...)
    1214{
    1315    char buff[1024];
    1416    va_list lst;
    15    
    16     if (trace) {
    17         va_start(lst, format);
    18         vsnprintf(buff, 1023, format, lst);
    19         buff[1023] = '\0';
    20         fprintf(stdout, "%s\n", buff);
    21         fflush(stdout);
     17    FILE *f;
     18
     19    f = NanoVis::logfile;
     20    if (f == NULL) {
     21        f = stderr;
    2222    }
     23    va_start(lst, format);
     24    vsnprintf(buff, 1023, format, lst);
     25    buff[1023] = '\0';
     26    fprintf(f, "%s at line %d of \"%s\": %s\n", mesg, lineNum, fileName, buff);
     27    fflush(f);
    2328}
    2429
     
    5257        mesg = "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT";             break;
    5358    default:
    54         fprintf(stderr, "FB Status: %s: UNKNOWN framebuffer status %u\n",
    55                 prefix, (unsigned int)status);
     59        TRACE("FB Status: %s: UNKNOWN framebuffer status %u\n",
     60               prefix, (unsigned int)status);
    5661        return;
    5762    }
    58     fprintf(stderr, "FB Status: %s: %s\n", prefix, mesg);
     63    TRACE("FB Status: %s: %s\n", prefix, mesg);
    5964}
    6065
     
    8287        mesg = "GL_INVALID_FRAMEBUFFER_OPERATION_EXT";  break;
    8388    default:
    84         fprintf(stderr, "GL Status: %s: Unknown status %d\n", prefix, status);
     89        TRACE("GL Status: %s: Unknown status %d\n", prefix, status);
    8590        return false;
    8691    }
    87     fprintf(stderr, "GL Status: %s: %s\n", prefix, mesg);
     92    TRACE("GL Status: %s: %s\n", prefix, mesg);
    8893    return false;
    8994}
  • trunk/packages/vizservers/nanovis/Trace.h

    r1429 r1984  
    99#define AT __FILE__ ":" NEWSTRING(__LINE__)
    1010
    11 extern void Trace(const char* format, ...);
     11extern void PrintMessage(const char *mesg, const char *fileName, int lineNum,
     12                         const char* format, ...);
     13
     14#define ERROR(...)      PrintMessage("Error", __FILE__, __LINE__, __VA_ARGS__)
     15#ifdef WANT_TRACE
     16#define TRACE(...)      PrintMessage("Trace", __FILE__, __LINE__, __VA_ARGS__)
     17#else
     18#define TRACE(...)
     19#endif
     20#define WARN(...)       PrintMessage("Warning", __FILE__, __LINE__, __VA_ARGS__)
     21#define INFO(...)       PrintMessage("Info", __FILE__, __LINE__, __VA_ARGS__)
     22
     23
    1224extern bool CheckFBO(GLenum *statusPtr);
    1325extern void PrintFBOStatus(GLenum status, const char *prefix);
  • trunk/packages/vizservers/nanovis/Unirect.cpp

    r1529 r1984  
    174174                return TCL_ERROR;
    175175            }
    176             values = new float[nValues];
     176            _values = (float *)realloc(_values, sizeof(float) * nValues);
    177177            int j;
    178178            for (j = 0; j < nValues; j++) {
    179                 if (GetFloatFromObj(interp, vobj[j], values + j)!=TCL_OK) {
     179                if (GetFloatFromObj(interp, vobj[j], _values + j)!=TCL_OK) {
    180180                    return TCL_ERROR;
    181181                }
     
    217217        }
    218218    }
    219     if (values == NULL) {
     219    if (_values == NULL) {
    220220        Tcl_AppendResult(interp, "missing \"values\" key", (char *)NULL);
    221221        return TCL_ERROR;
    222222    }
    223223    if ((size_t)nValues != (num[0] * num[1] * num[2] * _nComponents)) {
    224         Trace("num[0]=%d num[1]=%d num[2]=%d ncomponents=%d nValues=%d\n",
    225               num[0], num[1], num[2], _nComponents, nValues);
     224        TRACE("num[0]=%d num[1]=%d num[2]=%d ncomponents=%d nValues=%d\n",
     225               num[0], num[1], num[2], _nComponents, nValues);
    226226        Tcl_AppendResult(interp,
    227227                "wrong # of values: must be xnum*ynum*znum*extents",
     
    259259    }
    260260#endif
    261     _values = values;
    262261    _nValues = nValues;
    263262    if (units[3] != NULL) {
     263        if (_vUnits != NULL) {
     264            free(_vUnits);
     265        }
    264266        _vUnits = strdup(units[3]);
    265267    }
     
    268270    _xNum = num[axis3];
    269271    if (units[axis3] != NULL) {
     272        if (_xUnits != NULL) {
     273            free(_xUnits);
     274        }
    270275        _xUnits = strdup(units[axis3]);
    271276    }
     
    274279    _yNum = num[axis2];
    275280    if (units[axis2] != NULL) {
     281        if (_yUnits != NULL) {
     282            free(_yUnits);
     283        }
    276284        _yUnits = strdup(units[axis2]);
    277285    }
     
    280288    _zNum = num[axis1];
    281289    if (units[axis1] != NULL) {
     290        if (_zUnits != NULL) {
     291            free(_zUnits);
     292        }
    282293        _zUnits = strdup(units[axis1]);
    283294    }
     
    329340    }
    330341    _xUnits = _yUnits = _vUnits = NULL;
    331     if (_values != NULL) {
    332         delete [] _values;
    333     }
    334     _values = NULL;
     342    _nValues = 0;
    335343
    336344    int i;
     
    387395            int n;
    388396
     397            Tcl_IncrRefCount(objv[i+1]);
    389398            if (Tcl_ListObjGetElements(interp, objv[i+1], &n, &vobj) != TCL_OK){
    390399                return TCL_ERROR;
     
    396405            }
    397406            _nValues = n;
    398             _values = new float[_nValues];
     407            _values = (float *)realloc(_values, sizeof(float) * _nValues);
    399408            size_t j;
    400409            for (j = 0; j < _nValues; j++) {
     
    403412                }
    404413            }
     414            Tcl_DecrRefCount(objv[i+1]);
    405415        } else if ((c == 'u') && (strcmp(string, "units") == 0)) {
    406416            _vUnits = strdup(Tcl_GetString(objv[i+1]));
     
    441451        }
    442452    }
    443     if (_values == NULL) {
     453    if (_nValues == 0) {
    444454        Tcl_AppendResult(interp, "missing \"values\" key", (char *)NULL);
    445455        return TCL_ERROR;
     
    453463   
    454464    if ((axis[0] != 1) || (axis[1] != 0)) {
    455         fprintf(stderr, "reordering data\n");
     465        TRACE("reordering data\n");
    456466        /* Reorder the data into x, y where x varies fastest and so on. */
    457467        size_t y;
    458         float *data, *dp;
    459 
    460         dp = data = new float[_nValues];
     468        float *dp;
     469
     470        dp = _values = (float *)realloc(_values, sizeof(float) * _nValues);
    461471        for (y = 0; y < _yNum; y++) {
    462472            size_t x;
     
    473483            }
    474484        }
    475         delete [] _values;
    476         _values = data;
    477485    }
    478486    _initialized = true;
     
    559567    _nComponents = nComponents;
    560568
    561     if (_values != NULL) {
    562         delete [] _values;
    563     }
    564     _values = new float[npts * _nComponents];
     569    _values = (float *)realloc(_values, sizeof(float) * npts * _nComponents);
    565570    _nValues = 0;
    566571    for (size_t ix = 0; ix < _xNum; ix++) {
     
    605610        result.addError("inconsistent data: expected %d points"
    606611                        " but found %d points", npts, _nValues);
    607         delete []  _values;
     612        free(_values);
    608613        _values = NULL;
    609614        return false;
     
    676681
    677682    size_t n = _nComponents * _xNum * _yNum * _zNum;
    678     float *data = new float[n];
    679     memset(data, 0, sizeof(float) * n);
     683    _values = (float *)realloc(_values, sizeof(float) * n);
     684    memset(_values, 0, sizeof(float) * n);
    680685   
    681686    // Generate the uniformly sampled rectangle that we need for a volume
    682     float *destPtr = data;
     687    float *destPtr = _values;
    683688    for (size_t i = 0; i < _zNum; i++) {
    684689        double z;
     
    699704        }
    700705    }
    701     delete [] _values;
    702     _values = data;
    703706    _nValues = _xNum * _yNum * _zNum * _nComponents;
    704707    return true;
     
    710713{
    711714    assert(_nComponents == 3);
    712     Trace("GetVectorRange\n");
     715    TRACE("GetVectorRange\n");
    713716    _magMax = -DBL_MAX, _magMin = DBL_MAX;
    714717    size_t i;
     
    750753    case 1:
    751754    case 3:
    752         if (_values != NULL) {
    753             delete [] _values;
    754         }
    755         _values = new float[dataPtr->nValues()];
     755        _values = (float *)realloc(_values, sizeof(float) * dataPtr->nValues());
     756        if (_values == NULL) {
     757            return false;
     758        }
    756759        memcpy(_values, dataPtr->values(), dataPtr->nValues());
    757760        _nValues = dataPtr->nValues();
     
    761764        float *values;
    762765        _nValues = 3 * _xNum * _yNum * _zNum;
    763         if (_values != NULL) {
    764             delete [] _values;
    765         }
    766         _values = new float[_nValues];
     766        _values = (float *)realloc(_values, sizeof(float) * _nValues);
    767767        if (_values == NULL) {
    768768            return false;
  • trunk/packages/vizservers/nanovis/Unirect.h

    r1510 r1984  
    6565    ~Unirect3d(void) {
    6666        if (_values != NULL) {
    67             delete [] _values;
     67            free(_values);
    6868        }
    6969        if (_xUnits != NULL) {
     
    147147            GetVectorRange();
    148148        }
    149         Trace("magMin=%g %g\n", _magMin, DBL_MAX);
     149        TRACE("magMin=%g %g\n", _magMin, DBL_MAX);
    150150        return _magMin;
    151151    }
     
    154154            GetVectorRange();
    155155        }
    156         Trace("magMax=%g %g\n", _magMax, -DBL_MAX);
     156        TRACE("magMax=%g %g\n", _magMax, -DBL_MAX);
    157157        return _magMax;
    158158    }
     
    207207    ~Unirect2d(void) {
    208208        if (_values != NULL) {
    209             delete [] _values;
     209            free(_values);
    210210        }
    211211        if (_xUnits != NULL) {
     
    264264        return _nComponents;
    265265    }
    266     float *acceptValues(void) {
     266    float *transferValues(void) {
    267267        float *values;
    268268        values = _values;
  • trunk/packages/vizservers/nanovis/Vector3.cpp

    r819 r1984  
    149149
    150150void Vector3::print(){
    151         fprintf(stderr, "x:%f, y:%f, z:%f\n", x, y, z);
     151    TRACE("x:%f, y:%f, z:%f\n", x, y, z);
    152152}
    153153
  • trunk/packages/vizservers/nanovis/Vector3.h

    r1484 r1984  
    9999    }
    100100    void print(void){
    101         fprintf(stderr, "x:%f, y:%f, z:%f\n", x, y, z);
     101        TRACE("(x:%f, y:%f, z:%f)\n", x, y, z);
    102102    }
    103103    float distance(Vector3 &v) const {
  • trunk/packages/vizservers/nanovis/Vector4.cpp

    r819 r1984  
    2929
    3030void Vector4::print(){
    31         fprintf(stderr, "Vector4: (%.3f, %.3f, %.3f, %.3f)\n", x, y, z, w);
     31    TRACE("Vector4: (%.3f, %.3f, %.3f, %.3f)\n", x, y, z, w);
    3232}
    3333
  • trunk/packages/vizservers/nanovis/Vector4.h

    r1028 r1984  
    1818
    1919#include <stdio.h>
     20#include <Trace.h>
    2021
    2122class Vector4 
     
    3637
    3738    void print(void) {
    38         fprintf(stderr, "Vector4: (%.3f, %.3f, %.3f, %.3f)\n", x, y, z, w);
     39        TRACE("Vector4: (%.3f, %.3f, %.3f, %.3f)\n", x, y, z, w);
    3940    }
    4041
  • trunk/packages/vizservers/nanovis/VelocityArrowsSlice.cpp

    r1493 r1984  
    138138    _arrowColor.set(1, 1, 0);
    139139
    140     printf("test1\n");
     140    TRACE("test1\n");
    141141}
    142142
  • trunk/packages/vizservers/nanovis/Volume.cpp

    r1510 r1984  
    5252    _data = new float[fcount];
    5353    if (data != NULL) {
    54         Trace("data is copied\n");
     54        TRACE("data is copied\n");
    5555        memcpy(_data, data, fcount * sizeof(float));
    5656        _tex->initialize(_data);
    5757    } else {
    58         Trace("data is null\n");
     58        TRACE("data is null\n");
    5959        memset(_data, 0, sizeof(width * height * depth * _n_components *
    6060                                sizeof(float)));
     
    8585    label[2] = "Z Label";
    8686
    87     Trace("End -- Volume constructor\n");
     87    TRACE("End -- Volume constructor\n");
    8888}
    8989
  • trunk/packages/vizservers/nanovis/VolumeInterpolator.cpp

    r1493 r1984  
    2626{
    2727    if (_volumes.size() > 0) {
    28         Trace("\tVolume Interpolation Started\n");
     28        TRACE("\tVolume Interpolation Started\n");
    2929        _started = true;
    3030    } else {
    31         Trace("\tVolume Interpolation did not get started\n");
     31        TRACE("\tVolume Interpolation did not get started\n");
    3232        _started = false;
    3333    }
     
    3535    gettimeofday(&clock, NULL);
    3636    _start_time = clock.tv_sec + clock.tv_usec/1000000.0;
    37     Trace("End Start - VolumeInterpolator\n");
     37    TRACE("End Start - VolumeInterpolator\n");
    3838}
    3939
     
    9999        }
    100100       
    101         Trace("n = %d count = %d\n", n, count);
     101        TRACE("n = %d count = %d\n", n, count);
    102102        if (n >= limit){
    103103            *key1 = *key2 = limit;
     
    157157        _volume->opacity_scale(refPtr->opacity_scale());
    158158        _volume->isosurface(0);
    159         Trace("VOL : location %f %f %f\n\tid : %s\n", loc.x, loc.y, loc.z,
    160                 refPtr->name());
     159        TRACE("VOL : location %f %f %f\n\tid : %s\n", loc.x, loc.y, loc.z,
     160               refPtr->name());
    161161    }
    162162    _volumes.push_back(_volume);
    163     Trace("a Volume[%s] is added to VolumeInterpolator\n", refPtr->name());
     163    TRACE("a Volume[%s] is added to VolumeInterpolator\n", refPtr->name());
    164164}
    165165
  • trunk/packages/vizservers/nanovis/VolumeRenderer.cpp

    r1825 r1984  
    3737    const char *path = R2FilePath::getInstance()->getPath("Font.bmp");
    3838    if (path == NULL) {
    39         fprintf(stderr, "can't find Font.bmp\n");
     39        ERROR("can't find Font.bmp\n");
    4040        assert(path != NULL);
    4141    }
     
    9999        ani_tf = ani_vol->transferFunction();
    100100#endif
    101         Trace("VOLUME INTERPOLATOR IS STARTED ----------------------------");
     101        TRACE("VOLUME INTERPOLATOR IS STARTED ----------------------------");
    102102    }
    103103    // Determine the volumes that are to be rendered.
     
    126126    size_t* actual_slices = new size_t[volumes.size()];
    127127
    128     Trace("start loop %d\n", volumes.size());
     128    TRACE("start loop %d\n", volumes.size());
    129129    for (size_t i = 0; i < volumes.size(); i++) {
    130130        Volume* volPtr;
     
    350350       
    351351    } //iterate all volumes
    352     Trace("end loop\n");
     352    TRACE("end loop\n");
    353353   
    354354    // We sort all the polygons according to their eye-space depth, from
     
    388388       
    389389#ifdef notdef
    390         Trace("shading slice: volume %s addr=%x slice=%d, volume=%d\n",
    391               volPtr->name(), volPtr, slice_index, volume_index);
     390        TRACE("shading slice: volume %s addr=%x slice=%d, volume=%d\n",
     391               volPtr->name(), volPtr, slice_index, volume_index);
    392392#endif
    393393        activate_volume_shader(volPtr, false);
     
    621621    f = fopen(filename, "rb");
    622622    if (f == NULL) {
    623         fprintf(stderr, "can't open font file \"%s\"\n", filename);
     623        ERROR("can't open font file \"%s\"\n", filename);
    624624        return false;
    625625    }
    626626   
    627627    if (fread(&bfType, sizeof(short int), 1, f) != 1) {
    628         fprintf(stderr, "can't read %lu bytes from font file \"%s\"\n",
    629                 (unsigned long)sizeof(short int), filename);
     628        ERROR("can't read %lu bytes from font file \"%s\"\n",
     629               (unsigned long)sizeof(short int), filename);
    630630        goto error;
    631631    }
     
    633633    /* check if file is a bitmap */
    634634    if (bfType != 19778) {
    635         fprintf(stderr, "not a bmp file.\n");
     635        ERROR("not a bmp file.\n");
    636636        goto error;
    637637    }
     
    643643    /* get the position of the actual bitmap data */
    644644    if (fread(&bfOffBits, sizeof(int), 1, f) != 1) {
    645         fprintf(stderr, "error reading file.\n");
     645        ERROR("error reading file.\n");
    646646        goto error;
    647647    }
     
    653653    /* get the width of the bitmap */
    654654    if (fread(&width, sizeof(int), 1, f) != 1) {
    655         fprintf(stderr, "error reading file.\n");
     655        ERROR("error reading file.\n");
    656656        goto error;
    657657    }
     
    660660    /* get the height of the bitmap */
    661661    if (fread(&height, sizeof(int), 1, f) != 1) {
    662         fprintf(stderr, "error reading file.\n");
     662        ERROR("error reading file.\n");
    663663        goto error;
    664664    }
     
    667667    /* get the number of planes (must be set to 1) */
    668668    if (fread(&biPlanes, sizeof(short int), 1, f) != 1) {
    669         fprintf(stderr, "error reading file.\n");
     669        ERROR("error reading file.\n");
    670670        goto error;
    671671    }
    672672    if (biPlanes != 1) {
    673         fprintf(stderr, "Error: number of Planes not 1!\n");
     673        ERROR("number of Planes not 1!\n");
    674674        goto error;
    675675    }
     
    677677    /* get the number of bits per pixel */
    678678    if (fread(&biBitCount, sizeof(short int), 1, f) != 1) {
    679         fprintf(stderr, "error reading file.\n");
     679        ERROR("error reading file.\n");
    680680        goto error;
    681681    }
     
    683683    //printf("Bits per Pixel: %d\n", biBitCount);
    684684    if (biBitCount != 24) {
    685         fprintf(stderr, "Bits per Pixel not 24\n");
     685        ERROR("Bits per Pixel not 24\n");
    686686        goto error;
    687687    }
     
    692692    data = (unsigned char*) malloc(biSizeImage);
    693693    if (data == NULL) {
    694         fprintf(stderr, "Can't allocate memory for image\n");
     694        ERROR("Can't allocate memory for image\n");
    695695        goto error;
    696696    }
     
    699699    fseek(f, bfOffBits, SEEK_SET);
    700700    if (fread(data, biSizeImage, 1, f) != 1) {
    701         fprintf(stderr, "Error loading file!\n");
     701        ERROR("Error loading file!\n");
    702702        goto error;
    703703    }
  • trunk/packages/vizservers/nanovis/define.h

    r1510 r1984  
    2929 GLenum status;  \
    3030 status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);  \
    31  fprintf(stderr, "%x\n", status); \
     31 TRACE("%x\n", status); \
    3232 switch(status) {  \
    3333 case GL_FRAMEBUFFER_COMPLETE_EXT:  \
    34    fprintf(stderr,"framebuffer complete!\n"); \
     34   TRACE("framebuffer complete!\n"); \
    3535   break;  \
    3636 case GL_FRAMEBUFFER_UNSUPPORTED_EXT:  \
    37    fprintf(stderr,"framebuffer GL_FRAMEBUFFER_UNSUPPORTED_EXT\n"); \
     37   TRACE("framebuffer GL_FRAMEBUFFER_UNSUPPORTED_EXT\n"); \
    3838    /* you gotta choose different formats */  \
    3939   assert(0);  \
    4040   break;  \
    4141 case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:  \
    42    fprintf(stderr,"framebuffer INCOMPLETE_ATTACHMENT\n"); \
     42   TRACE("framebuffer INCOMPLETE_ATTACHMENT\n"); \
    4343   break;  \
    4444 case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:  \
    45    fprintf(stderr,"framebuffer FRAMEBUFFER_MISSING_ATTACHMENT\n"); \
     45   TRACE("framebuffer FRAMEBUFFER_MISSING_ATTACHMENT\n"); \
    4646   break;  \
    4747 case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:  \
    48    fprintf(stderr,"framebuffer FRAMEBUFFER_DIMENSIONS\n");\
     48   TRACE("framebuffer FRAMEBUFFER_DIMENSIONS\n");\
    4949   break; \
    5050 case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: \
    51    fprintf(stderr,"framebuffer INCOMPLETE_FORMATS\n");\
     51   TRACE("framebuffer INCOMPLETE_FORMATS\n");\
    5252   break; \
    5353 case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: \
    54    fprintf(stderr,"framebuffer INCOMPLETE_DRAW_BUFFER\n");\
     54   TRACE("framebuffer INCOMPLETE_DRAW_BUFFER\n");\
    5555   break; \
    5656 case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: \
    57    fprintf(stderr,"framebuffer INCOMPLETE_READ_BUFFER\n");\
     57   TRACE("framebuffer INCOMPLETE_READ_BUFFER\n");\
    5858   break; \
    5959 case GL_FRAMEBUFFER_BINDING_EXT: \
    60    fprintf(stderr,"framebuffer BINDING_EXT\n");\
     60   TRACE("framebuffer BINDING_EXT\n");\
    6161   break; \
    6262/*
    6363 *  case GL_FRAMEBUFFER_STATUS_ERROR_EXT: \
    64  *     fprintf(stderr,"framebuffer STATUS_ERROR\n");\
     64 *     TRACE("framebuffer STATUS_ERROR\n");\
    6565 *        break; \
    6666 *        */ \
    6767 default: \
    68    fprintf(stderr,"unknown framebuffer error %d\n", status);\
     68   ERROR("unknown framebuffer error %d\n", status);\
    6969   /* programming error; will fail on all hardware */ \
    7070   assert(0); \
     
    8787      default:                                                \
    8888        /* programming error; will fail on all hardware */    \
    89         fprintf(stderr, "programming error\n");               \
     89        ERROR(stderr, "programming error\n");               \
    9090        assert(0);                                            \
    9191     }                                                        \
  • trunk/packages/vizservers/nanovis/dxReader.cpp

    r1526 r1984  
    168168    } while (!fin.eof());
    169169
    170     fprintf(stderr, "found nx=%d ny=%d, nz=%d, x0=%f, y0=%f, z0=%f\n",
    171             nx, ny, nz, x0, y0, z0);
     170    TRACE("found nx=%d ny=%d, nz=%d, x0=%f, y0=%f, z0=%f\n",
     171           nx, ny, nz, x0, y0, z0);
    172172    // read data points
    173173    if (fin.eof() && (npts > 0)) {
     
    554554                int nindex = iz*nx*ny + iy*nx + ix;
    555555                field.define(nindex, dval[p]);
    556                 fflush(stderr);
    557556                nread++;
    558557                if (++iz >= nz) {
     
    651650#ifdef notdef
    652651        for (int i=0; i<nx*ny*nz; i++) {
    653             fprintf(stderr,"enddata[%i] = %lg\n",i,data[i]);
    654             fflush(stderr);
     652            TRACE("enddata[%i] = %lg\n",i,data[i]);
    655653        }
    656654#endif 
    657         fprintf(stdout,"nx = %i ny = %i nz = %i\n",nx,ny,nz);
    658         fprintf(stdout,"dx = %lg dy = %lg dz = %lg\n",dx,dy,dz);
    659         fprintf(stdout,"dataMin = %lg\tdataMax = %lg\tnzero_min = %lg\n", field.valueMin(),field.valueMax(),nzero_min);
    660         fflush(stdout);
     655        TRACE("nx = %i ny = %i nz = %i\n",nx,ny,nz);
     656        TRACE("dx = %lg dy = %lg dz = %lg\n",dx,dy,dz);
     657        TRACE("dataMin = %lg\tdataMax = %lg\tnzero_min = %lg\n",
     658               field.valueMin(),field.valueMax(),nzero_min);
    661659       
    662660        volPtr = NanoVis::load_volume(tag, nx, ny, nz, 4, data,
     
    985983                int nindex = iz*nx*ny + iy*nx + ix;
    986984                field.define(nindex, dval[p]);
    987                 fprintf(stderr,"nindex = %i\tdval[%i] = %lg\n", nindex, p,
    988                         dval[p]);
    989                 fflush(stderr);
     985                TRACE("nindex = %i\tdval[%i] = %lg\n", nindex, p, dval[p]);
    990986                nread++;
    991987                if (++iz >= nz) {
     
    11221118                                         
    11231119            for (int i=0; i<nx*ny*nz; i++) {
    1124                 fprintf(stderr,"enddata[%i] = %lg\n",i,data[i]);
    1125                 fflush(stderr);
     1120                TRACE("enddata[%i] = %lg\n",i,data[i]);
    11261121            }
    11271122
    1128             fprintf(stdout,"End Data Stats volDataID = %i\n",volDataID);
    1129             fprintf(stdout,"nx = %i ny = %i nz = %i\n",nx,ny,nz);
    1130             fprintf(stdout,"dx = %lg dy = %lg dz = %lg\n",dx,dy,dz);
    1131             fprintf(stdout,"dataMin = %lg\tdataMax = %lg\tnzero_min = %lg\n", field.valueMin(),field.valueMax(),nzero_min);
    1132             fflush(stdout);
     1123            TRACE("End Data Stats volDataID = %i\n",volDataID);
     1124            TRACE("nx = %i ny = %i nz = %i\n",nx,ny,nz);
     1125            TRACE("dx = %lg dy = %lg dz = %lg\n",dx,dy,dz);
     1126            TRACE("dataMin = %lg\tdataMax = %lg\tnzero_min = %lg\n",
     1127            field.valueMin(),field.valueMax(),nzero_min);
    11331128            */
    11341129
  • trunk/packages/vizservers/nanovis/dxReader2.cpp

    r1493 r1984  
    11
    22#include "RpDX.h"
     3#undef ERROR
    34#include "dxReaderCommon.h"
    45
  • trunk/packages/vizservers/nanovis/global.h

    r1196 r1984  
    1919#include <GL/glew.h>
    2020#include <Cg/cgGL.h>
    21 
     21#include <Trace.h>
    2222#include <stdio.h>
    2323
     
    2727 GLenum status; \
    2828 status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT); \
    29  fprintf(stderr, "%x\n", status);\
     29 TRACE("%x\n", status);                    \
    3030 switch(status) { \
    3131 case GL_FRAMEBUFFER_COMPLETE_EXT: \
    32    fprintf(stderr,"framebuffer complete!\n");\
     32     TRACE("framebuffer complete!\n");  \
    3333   break; \
    3434 case GL_FRAMEBUFFER_UNSUPPORTED_EXT: \
    35    fprintf(stderr,"framebuffer GL_FRAMEBUFFER_UNSUPPORTED_EXT\n");\
     35     ERROR("framebuffer GL_FRAMEBUFFER_UNSUPPORTED_EXT\n");     \
    3636    /* you gotta choose different formats */ \
    3737   assert(0); \
    3838   break; \
    39  case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: \
    40    fprintf(stderr,"framebuffer INCOMPLETE_ATTACHMENT\n");\
     39 case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:         \
     40     TRACE("framebuffer INCOMPLETE_ATTACHMENT\n");      \
    4141   break; \
    4242 case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: \
    43    fprintf(stderr,"framebuffer FRAMEBUFFER_MISSING_ATTACHMENT\n");\
     43     TRACE("framebuffer FRAMEBUFFER_MISSING_ATTACHMENT\n");     \
    4444   break; \
    4545 case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: \
    46    fprintf(stderr,"framebuffer FRAMEBUFFER_DIMENSIONS\n");\
     46     TRACE("framebuffer FRAMEBUFFER_DIMENSIONS\n");     \
    4747   break; \
    4848 case GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT: \
    49    fprintf(stderr,"framebuffer INCOMPLETE_DUPLICATE_ATTACHMENT\n");\
     49     TRACE("framebuffer INCOMPLETE_DUPLICATE_ATTACHMENT\n");    \
    5050   break; \
    5151 case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: \
    52    fprintf(stderr,"framebuffer INCOMPLETE_FORMATS\n");\
     52     TRACE("framebuffer INCOMPLETE_FORMATS\n"); \
    5353   break; \
    5454 case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: \
    55    fprintf(stderr,"framebuffer INCOMPLETE_DRAW_BUFFER\n");\
     55     TRACE("framebuffer INCOMPLETE_DRAW_BUFFER\n");     \
    5656   break; \
    5757 case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: \
    58    fprintf(stderr,"framebuffer INCOMPLETE_READ_BUFFER\n");\
     58     TRACE("framebuffer INCOMPLETE_READ_BUFFER\n");     \
    5959   break; \
    6060 case GL_FRAMEBUFFER_BINDING_EXT: \
    61    fprintf(stderr,"framebuffer BINDING_EXT\n");\
     61     TRACE("framebuffer BINDING_EXT\n");        \
    6262   break; \
    6363/*
    6464 *  case GL_FRAMEBUFFER_STATUS_ERROR_EXT: \
    65  *     fprintf(stderr,"framebuffer STATUS_ERROR\n");\
     65 *     TRACE("framebuffer STATUS_ERROR\n");\
    6666 *        break; \
    6767 *        */ \
     
    8080        break;                                                \
    8181      case GL_FRAMEBUFFER_UNSUPPORTED_EXT:                    \
    82         /* choose different formats */                        \
     82~        /* choose different formats */                        \
    8383        break;                                                \
    8484      default:                                                \
    8585        /* programming error; will fail on all hardware */    \
    86         fprintf(stderr, "programming error\n");               \
     86        ERROR("programming error\n");               \
    8787        assert(0);                                            \
    8888     }                                                        \
     
    106106system_info()
    107107{
    108     fprintf(stderr,
    109             "-----------------------------------------------------------\n");
    110     fprintf(stderr, "OpenGL driver: %s %s\n", glGetString(GL_VENDOR),
    111             glGetString(GL_VERSION));
    112     fprintf(stderr, "Graphics hardware: %s\n", glGetString(GL_RENDERER));
    113     fprintf(stderr,
    114             "-----------------------------------------------------------\n");
     108    TRACE("-----------------------------------------------------------\n");
     109    TRACE("OpenGL driver: %s %s\n", glGetString(GL_VENDOR),
     110           glGetString(GL_VERSION));
     111    TRACE("Graphics hardware: %s\n", glGetString(GL_RENDERER));
     112    TRACE("-----------------------------------------------------------\n");
    115113}
    116114
  • trunk/packages/vizservers/nanovis/nanovis.cpp

    r1899 r1984  
    391391DoExit(int code)
    392392{
    393     if (NanoVis::debug_flag) {
    394         fprintf(stderr, "in DoExit\n");
    395     }
     393    TRACE("in DoExit\n");
    396394    removeAllData();
    397395    NvExit();
     
    409407    if(lastError) {
    410408        const char *listing = cgGetLastListing(g_context);
    411         Trace("\n---------------------------------------------------\n");
    412         Trace("%s\n\n", cgGetErrorString(lastError));
    413         Trace("%s\n", listing);
    414         Trace("-----------------------------------------------------\n");
    415         Trace("Cg error, exiting...\n");
     409        ERROR("\n---------------------------------------------------\n");
     410        ERROR("%s\n\n", cgGetErrorString(lastError));
     411        ERROR("%s\n", listing);
     412        ERROR("-----------------------------------------------------\n");
     413        ERROR("Cg error, exiting...\n");
    416414        cgDestroyContext(g_context);
    417415        DoExit(-1);
     
    426424    const char *path = R2FilePath::getInstance()->getPath(fileName);
    427425    if (path == NULL) {
    428         fprintf(stderr, "can't find program \"%s\"\n", fileName);
    429         Trace("can't find program \"%s\"\n", fileName);
    430     }
    431     Trace("cg program compiling: %s\n", path);
     426        ERROR("can't find program \"%s\"\n", fileName);
     427    }
     428    TRACE("cg program compiling: %s\n", path);
    432429    fflush(stdout);
    433430    CGprogram program;
     
    437434    CGerror LastError = cgGetError();
    438435    if (LastError) {
    439         printf("Error message: %s\n", cgGetLastListing(context));
    440         Trace("Error message: %s\n", cgGetLastListing(context));
    441     }
    442     Trace("successfully compiled program: %s\n", path);
     436        ERROR("Error message: %s\n", cgGetLastListing(context));
     437    }
     438    TRACE("successfully compiled program: %s\n", path);
    443439    delete [] path;
    444440    return program;
     
    452448    int result;
    453449
    454 #ifndef notdef
    455     if (NanoVis::debug_flag) {
    456         fprintf(stderr, "in ExecuteCommand(%s)\n", Tcl_DStringValue(dsPtr));
    457     }
    458 #endif
     450    TRACE("in ExecuteCommand(%s)\n", Tcl_DStringValue(dsPtr));
     451
    459452    gettimeofday(&tv, NULL);
    460453    start = CVT2SECS(tv);
    461454
    462     Trace("in ExecuteCommand(%s)\n", Tcl_DStringValue(dsPtr));
    463 #ifndef notdef
    464     if (NanoVis::logfile != NULL) {
    465         fprintf(NanoVis::logfile, "%s", Tcl_DStringValue(dsPtr));
    466         fflush(NanoVis::logfile);
    467     }
    468 #endif
    469455    if (NanoVis::recfile != NULL) {
    470456        fprintf(NanoVis::recfile, "%s", Tcl_DStringValue(dsPtr));
     
    479465    stats.cmdTime += finish - start;
    480466    stats.nCommands++;
    481 #ifndef notdef
    482     if (NanoVis::debug_flag) {
    483         fprintf(stderr, "leaving ExecuteCommand status=%d\n", result);
    484     }
    485 #endif
     467    TRACE("leaving ExecuteCommand status=%d\n", result);
    486468    return result;
    487469}
     
    492474    /* Move the camera and its target by equal amounts along the x and y
    493475     * axes. */
    494     fprintf(stderr, "x=%f, y=%f\n", dx, dy);
     476    TRACE("pan: x=%f, y=%f\n", dx, dy);
    495477
    496478    cam->x(def_eye_x + dx);
    497479    cam->y(def_eye_y + dy);
    498     fprintf(stderr, "set eye to %f %f\n", cam->x(), cam->y());
     480    TRACE("set eye to %f %f\n", cam->x(), cam->y());
    499481
    500482    cam->xAim(def_target_x + dx);
    501483    cam->yAim(def_target_y + dy);
    502     fprintf(stderr, "set aim to %f %f\n", cam->xAim(), cam->yAim());
     484    TRACE("set aim to %f %f\n", cam->xAim(), cam->yAim());
    503485}
    504486
     
    521503    if (hPtr != NULL) {
    522504        Volume *volPtr;
    523         Trace("volume \"%s\" already exists", name);
     505        WARN("volume \"%s\" already exists", name);
    524506        volPtr = (Volume *)Tcl_GetHashValue(hPtr);
    525507        remove_volume(volPtr);
     
    576558                       int width, int height, const char* volArg)
    577559{
    578     if (debug_flag) {
    579         fprintf(stderr, "in render_legend\n");
    580     }
     560    TRACE("in render_legend\n");
     561
    581562    int old_width = win_width;
    582563    int old_height = win_height;
     
    602583    //glReadPixels(0, 0, width, height, GL_BGR, GL_UNSIGNED_BYTE, screen_buffer); // INSOO's
    603584
    604     if (debug_flag) {
    605         fprintf(stderr, "ppm legend image not written (debug mode)\n");
    606     } else {
     585    {
    607586        char prefix[200];
    608587        ssize_t nWritten;
    609588
     589        TRACE("ppm legend image");
    610590        sprintf(prefix, "nv>legend %s %g %g", volArg, min, max);
    611591        ppm_write(prefix);
     
    616596    resize_offscreen_buffer(old_width, old_height);
    617597
    618     if (debug_flag) {
    619         fprintf(stderr, "leaving render_legend\n");
    620     }
     598    TRACE("leaving render_legend\n");
    621599    delete plane[0];
    622600    return TCL_OK;
     
    627605NanoVis::init_offscreen_buffer()
    628606{
    629     if (debug_flag) {
    630         fprintf(stderr, "in init_offscreen_buffer\n");
    631     }
     607    TRACE("in init_offscreen_buffer\n");
    632608    // Initialize a fbo for final display.
    633609    glGenFramebuffersEXT(1, &final_fbo);
     
    665641   
    666642    //assert(glGetError()==0);
    667     if (debug_flag) {
    668         fprintf(stderr, "leaving init_offscreen_buffer\n");
    669     }
     643    TRACE("leaving init_offscreen_buffer\n");
    670644}
    671645
     
    675649NanoVis::resize_offscreen_buffer(int w, int h)
    676650{
    677     Trace("in resize_offscreen_buffer(%d, %d)\n", w, h);
     651    TRACE("in resize_offscreen_buffer(%d, %d)\n", w, h);
    678652    if ((w == win_width) && (h == win_height)) {
    679653        return;
    680654    }
    681     if (debug_flag) {
    682         fprintf(stderr, "in resize_offscreen_buffer(%d, %d)\n", w, h);
    683     }
    684 
    685655    win_width = w;
    686656    win_height = h;
     
    689659        fonts->resize(w, h);
    690660    }
    691     //fprintf(stderr, "screen_buffer size: %d\n", sizeof(screen_buffer));
    692     Trace("screen_buffer size: %d %d\n", w, h);
     661    TRACE("screen_buffer size: %d %d\n", w, h);
    693662   
    694663    if (screen_buffer != NULL) {
     
    705674    glDeleteRenderbuffersEXT(1, &final_depth_rb);
    706675
    707     if (debug_flag) {
    708         fprintf(stderr, "before deleteframebuffers\n");
    709     }
     676    TRACE("before deleteframebuffers\n");
    710677    glDeleteFramebuffersEXT(1, &final_fbo);
    711678
    712     if (debug_flag) {
    713         fprintf(stderr, "reinitialize FBO\n");
    714     }
     679    TRACE("reinitialize FBO\n");
    715680    //Reinitialize final fbo for final display
    716681    glGenFramebuffersEXT(1, &final_fbo);
     
    728693                 GL_RGB, GL_INT, NULL);
    729694#endif
    730     if (debug_flag) {
    731         fprintf(stderr, "before bindframebuffer\n");
    732     }
     695    TRACE("before bindframebuffer\n");
    733696    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, final_fbo);
    734     if (debug_flag) {
    735         fprintf(stderr, "after bindframebuffer\n");
    736     }
     697    TRACE("after bindframebuffer\n");
    737698    glGenRenderbuffersEXT(1, &final_depth_rb);
    738699    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, final_depth_rb);
     
    751712
    752713    //CHECK_FRAMEBUFFER_STATUS();
    753     if (debug_flag) {
    754         fprintf(stderr, "change camera\n");
    755     }
     714    TRACE("change camera\n");
    756715    //change the camera setting
    757716    cam->set_screen_size(0, 0, win_width, win_height);
    758717    plane_render->set_screen_size(win_width, win_height);
    759718
    760     if (debug_flag) {
    761         fprintf(stderr, "leaving resize_offscreen_buffer(%d, %d)\n", w, h);
    762     }
     719    TRACE("leaving resize_offscreen_buffer(%d, %d)\n", w, h);
    763720}
    764721
     
    812769{
    813770    // print system information
    814     fprintf(stderr,
    815             "-----------------------------------------------------------\n");
    816     fprintf(stderr, "OpenGL driver: %s %s\n", glGetString(GL_VENDOR),
    817             glGetString(GL_VERSION));
    818     fprintf(stderr, "Graphics hardware: %s\n", glGetString(GL_RENDERER));
    819     fprintf(stderr,
    820             "-----------------------------------------------------------\n");
     771    TRACE("-----------------------------------------------------------\n");
     772    TRACE("OpenGL driver: %s %s\n", glGetString(GL_VENDOR),
     773           glGetString(GL_VERSION));
     774    TRACE("Graphics hardware: %s\n", glGetString(GL_RENDERER));
     775    TRACE("-----------------------------------------------------------\n");
    821776    if (path == NULL) {
    822         fprintf(stderr, "No path defined for shaders or resources\n");
    823         fflush(stderr);
     777        ERROR("No path defined for shaders or resources\n");
    824778        DoExit(1);
    825779    }
    826780    GLenum err = glewInit();
    827781    if (GLEW_OK != err) {
    828         fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
     782        ERROR("%s\n", glewGetErrorString(err));
    829783        getchar();
    830784        //assert(false);
    831785    }
    832     fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
     786    TRACE("Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
    833787
    834788    if (!R2FilePath::getInstance()->setPath(path)) {
    835         fprintf(stderr, "can't set file path to %s\n", path);
    836         fflush(stderr);
     789        ERROR("can't set file path to %s\n", path);
    837790        DoExit(1);
    838791    }
     
    874827NanoVis::initGL(void)
    875828{
    876     if (debug_flag) {
    877         fprintf(stderr, "in initGL\n");
    878     }
     829    TRACE("in initGL\n");
    879830    //buffer to store data read from the screen
    880831    if (screen_buffer) {
     
    938889    //assert(glGetError()==0);
    939890
    940     if (debug_flag) {
    941         fprintf(stderr, "leaving initGL\n");
    942     }
     891    TRACE("leaving initGL\n");
    943892}
    944893
     
    10731022            sprintf(filename, "/tmp/flow_animation/image%03d.bmp", frame_number);
    10741023
    1075         fprintf(stderr, "Writing %s\n", filename);
     1024        TRACE("Writing %s\n", filename);
    10761025        f = fopen(filename, "wb");
    10771026        if (f == 0) {
    1078             Trace("cannot create file\n");
     1027            ERROR("cannot create file\n");
    10791028        }
    10801029    } else {
    10811030        f = fopen("/tmp/image.bmp", "wb");
    10821031        if (f == 0) {
    1083             Trace("cannot create file\n");
     1032            ERROR("cannot create file\n");
    10841033        }
    10851034    }
    10861035    if (fwrite(header, SIZEOF_BMP_HEADER, 1, f) != 1) {
    1087         Trace("can't write header: short write\n");
     1036        ERROR("can't write header: short write\n");
    10881037    }
    10891038    if (fwrite(screen_buffer, (3*win_width+pad)*win_height, 1, f) != 1) {
    1090         Trace("can't write data: short write\n");
     1039        ERROR("can't write data: short write\n");
    10911040    }
    10921041    fclose(f);
     
    11961145    char header[200];
    11971146
     1147    TRACE("Enter ppm_write (%dx%d)\n", win_width, win_height);
    11981148    // Generate the PPM binary file header
    11991149    sprintf(header, "P6 %d %d %d\n", win_width, win_height, PPM_MAXVAL);
     
    12301180    }
    12311181    if (writev(0, iov, nRecs) < 0) {
    1232         fprintf(stderr, "write failed: %s\n", strerror(errno));
     1182        ERROR("write failed: %s\n", strerror(errno));
    12331183    }
    12341184    free(iov);
    12351185    stats.nFrames++;
    12361186    stats.nBytes += (bytesPerRow * win_height);
     1187    TRACE("Leaving ppm_write (%dx%d)\n", win_width, win_height);
    12371188}
    12381189
     
    12591210    size_t nRecs = 2;
    12601211
    1261     struct iovec *iov;
    1262     iov = (struct iovec *)malloc(sizeof(struct iovec) * nRecs);
     1212    struct iovec *iov = new iovec[nRecs];
    12631213
    12641214    // Write the nanovisviewer command, then the image header and data.
     
    12721222    iov[1].iov_len = dlen;
    12731223    if (writev(0, iov, nRecs) < 0) {
    1274         fprintf(stderr, "write failed: %s\n", strerror(errno));
    1275     }
    1276     free(iov);
     1224        ERROR("write failed: %s\n", strerror(errno));
     1225    }
     1226    delete [] iov;
    12771227    // stats.nFrames++;
    12781228    // stats.nBytes += (bytesPerRow * win_height);
     
    12841234NanoVis::idle()
    12851235{
    1286     if (debug_flag) {
    1287         fprintf(stderr, "in idle()\n");
    1288     }
     1236    TRACE("in idle()\n");
    12891237    glutSetWindow(render_window);
    12901238
     
    12941242    glutPostRedisplay();
    12951243#endif
    1296     if (debug_flag) {
    1297         fprintf(stderr, "leaving idle()\n");
    1298     }
     1244    TRACE("leaving idle()\n");
    12991245}
    13001246
     
    13021248NanoVis::display_offscreen_buffer()
    13031249{
    1304     if (debug_flag) {
    1305         fprintf(stderr, "in display_offscreen_buffer\n");
    1306     }
     1250    TRACE("in display_offscreen_buffer\n");
    13071251    glEnable(GL_TEXTURE_2D);
    13081252    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     
    13251269    }
    13261270    glEnd();
    1327     if (debug_flag) {
    1328         fprintf(stderr, "leaving display_offscreen_buffer\n");
    1329     }
     1271    TRACE("leaving display_offscreen_buffer\n");
    13301272}
    13311273
     
    15141456            vol_renderer->_volumeInterpolator->getStartTime();
    15151457
    1516         Trace("%lf %lf\n", elapsed_time, vol_renderer->_volumeInterpolator->getInterval());
     1458        TRACE("%lf %lf\n", elapsed_time,
     1459               vol_renderer->_volumeInterpolator->getInterval());
    15171460        float fraction;
    15181461        float f;
     
    15241467            fraction = f / vol_renderer->_volumeInterpolator->getInterval();
    15251468        }
    1526         Trace("fraction : %f\n", fraction);
     1469        TRACE("fraction : %f\n", fraction);
    15271470        vol_renderer->_volumeInterpolator->update(fraction);
    15281471    }
     
    15341477    double xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
    15351478
    1536     if (debug_flag) {
    1537         fprintf(stderr, "in SetVolumeRanges\n");
    1538     }
     1479    TRACE("in SetVolumeRanges\n");
    15391480    xMin = yMin = zMin = wMin = FLT_MAX;
    15401481    xMax = yMax = zMax = wMax = -FLT_MAX;
     
    15851526    }
    15861527    Volume::update_pending = false;
    1587     if (debug_flag) {
    1588         fprintf(stderr, "leaving SetVolumeRanges\n");
    1589     }
     1528    TRACE("leaving SetVolumeRanges\n");
    15901529}
    15911530
     
    15951534    double xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
    15961535
    1597     if (debug_flag) {
    1598         fprintf(stderr, "in SetHeightmapRanges\n");
    1599     }
     1536    TRACE("in SetHeightmapRanges\n");
    16001537    xMin = yMin = zMin = wMin = FLT_MAX;
    16011538    xMax = yMax = zMax = wMax = -FLT_MAX;
     
    16511588    }
    16521589    HeightMap::update_pending = false;
    1653     if (debug_flag) {
    1654         fprintf(stderr, "leaving SetHeightmapRanges\n");
    1655     }
     1590    TRACE("leaving SetHeightmapRanges\n");
    16561591}
    16571592
     
    16601595NanoVis::display()
    16611596{
    1662     if (debug_flag) {
    1663         fprintf(stderr, "in display\n");
    1664     }
     1597    TRACE("in display\n");
    16651598#ifdef notdef
    16661599    if (flags & MAP_FLOWS) {
     
    16821615        SetVolumeRanges();
    16831616    }
    1684     if (debug_flag) {
    1685         fprintf(stderr, "in display: glClear\n");
    1686     }
     1617    TRACE("in display: glClear\n");
    16871618    //start final rendering
    16881619    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //clear screen
    16891620
    16901621    if (volume_mode) {
    1691         if (debug_flag) {
    1692             fprintf(stderr, "in display: volume_mode\n");
    1693         }
     1622        TRACE("in display: volume_mode\n");
    16941623        //3D rendering mode
    16951624        // TBD..
     
    17601689        //perf->enable();
    17611690        //perf->disable();
    1762         //fprintf(stderr, "particle pixels: %d\n", perf->get_pixel_count());
     1691        //TRACE("particle pixels: %d\n", perf->get_pixel_count());
    17631692        //perf->reset();
    17641693
     
    17671696        //perf->disable();
    17681697
    1769         if (debug_flag) {
    1770             fprintf(stderr, "in display: render heightmap\n");
    1771         }
     1698        TRACE("in display: render heightmap\n");
    17721699        Tcl_HashEntry *hPtr;
    17731700        Tcl_HashSearch iter;
     
    17871714        perf->disable();
    17881715    }
     1716        TRACE("in display: render heightmap\n");
    17891717    perf->reset();
    1790     if (debug_flag) {
    1791         fprintf(stderr, "leaving display\n");
    1792     }
    1793 
    1794 
     1718    CHECK_FRAMEBUFFER_STATUS();
     1719    TRACE("leaving display\n");
    17951720}
    17961721
     
    18101735        }
    18111736    } else {
    1812         //fprintf(stderr, "right mouse\n");
     1737        //TRACE("right mouse\n");
    18131738
    18141739        if(state==GLUT_DOWN){
    1815             //fprintf(stderr, "right mouse down\n");
     1740            //TRACE("right mouse down\n");
    18161741            right_last_x = x;
    18171742            right_last_y = y;
     
    18191744            right_down = true;
    18201745        } else {
    1821             //fprintf(stderr, "right mouse up\n");
     1746            //TRACE("right mouse up\n");
    18221747            left_down = false;
    18231748            right_down = false;
     
    21482073        update_rot(-delta_y, -delta_x);
    21492074    } else if (right_down){
    2150         //fprintf(stderr, "right mouse motion (%d,%d)\n", x, y);
     2075        //TRACE("right mouse motion (%d,%d)\n", x, y);
    21512076
    21522077        right_last_x = x;
     
    22002125NanoVis::xinetd_listen(void)
    22012126{
    2202     if (debug_flag) {
    2203         fprintf(stderr, "in xinetd_listen\n");
    2204     }
     2127    NanoVis::flags &= ~REDRAW_PENDING;
     2128
     2129    TRACE("Enter xinetd_listen\n");
    22052130    int flags = fcntl(0, F_GETFL, 0);
    22062131    fcntl(0, F_SETFL, flags & ~O_NONBLOCK);
     
    22102135    //  Read and execute as many commands as we can from stdin...
    22112136
     2137    int nCommands = 0;
    22122138    bool isComplete = false;
    22132139    while ((!feof(NanoVis::stdin)) && (status == TCL_OK)) {
     
    22212147        //  here.
    22222148        //
    2223         if (debug_flag) {
    2224             fprintf(stderr, "in xinetd_listen: check eof %d\n",
    2225                     feof(NanoVis::stdin));
    2226         }
     2149        TRACE("in xinetd_listen: EOF=%d\n", feof(NanoVis::stdin));
    22272150        while (!feof(NanoVis::stdin)) {
    22282151            int c = fgetc(NanoVis::stdin);
     
    22542177            fcntl(0, F_SETFL, flags | O_NONBLOCK);
    22552178            isComplete = false;
     2179            nCommands++;
     2180    CHECK_FRAMEBUFFER_STATUS();
    22562181        }
    22572182    }
     
    22632188
    22642189        string = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);
    2265         Trace("errorInfo=(%s)\n", string);
     2190        TRACE("errorInfo=(%s)\n", string);
    22662191        nBytes = strlen(string);
    22672192        struct iovec iov[3];
     
    22732198        iov[2].iov_base = (char *)'\n';
    22742199        if (writev(0, iov, 3) < 0) {
    2275             fprintf(stderr, "write failed: %s\n", strerror(errno));
     2200            ERROR("write failed: %s\n", strerror(errno));
    22762201        }
    2277         if (debug_flag) {
    2278             fprintf(stderr, "leaving xinetd_listen\n");
    2279         }
     2202        TRACE("Leaving xinetd_listen on ERROR\n");
    22802203        return;
    22812204    }
     
    23002223    do_rle();
    23012224    int sizes[2] = {  offsets_size*sizeof(offsets[0]), rle_size };
    2302     fprintf(stderr, "Writing %d,%d\n", sizes[0], sizes[1]); fflush(stderr);
     2225    TRACE("Writing %d,%d\n", sizes[0], sizes[1]);
    23032226    write(0, &sizes, sizeof(sizes));
    23042227    write(0, offsets, offsets_size*sizeof(offsets[0]));
    23052228    write(0, rle, rle_size);    //unsigned byte
    23062229#else
    2307     if (debug_flag) {
    2308         fprintf(stderr, "ppm image not written (debug mode)\n");
    2309         bmp_write_to_file(1, "/tmp");
    2310     } else {
    2311         NanoVis::ppm_write("\nnv>image -type image -bytes");
    2312     }
     2230    NanoVis::ppm_write("\nnv>image -type image -bytes");
    23132231#endif
    23142232    if (feof(NanoVis::stdin)) {
    23152233        DoExit(90);
    23162234    }
    2317     if (debug_flag) {
    2318         fprintf(stderr, "leaving xinetd_listen\n");
    2319     }
     2235    TRACE("Leaving xinetd_listen OK\n");
    23202236}
    23212237
     
    24432359        }
    24442360        if (p == NULL) {
    2445             fprintf(stderr, "path not specified\n");
     2361            TRACE("path not specified\n");
    24462362            return 1;
    24472363        }
Note: See TracChangeset for help on using the changeset viewer.