Changeset 3877


Ignore:
Timestamp:
Aug 21, 2013 10:52:23 AM (7 years ago)
Author:
ldelgass
Message:

Merge from trunk

Location:
branches/1.3
Files:
27 edited
6 copied

Legend:

Unmodified
Added
Removed
  • branches/1.3

  • branches/1.3/gui/scripts/drawing.tcl

    r3864 r3877  
    117117                    }
    118118                    set contents [Rappture::PdbToVtk $pdbdata]
    119                     if 0 {
     119                    if 1 {
    120120                        set f [open /tmp/convertedpdb.vtk "w"]
    121121                        puts $f $contents
  • branches/1.3/gui/scripts/field.tcl

    r3807 r3877  
    868868            # off to the NanoVis visualizer.
    869869            #
    870             set _viewer "nanovis"
     870            set _viewer "nanovis"
    871871            set _dim 3
    872             set _type "dx"
    873872            set _comp2dims($cname) "3D"
    874             set contents [$_field get -decode no $cname.$type]
    875             if { $contents == "" } {
    876                 puts stderr "WARNING: no data for \"$_path.$cname.$type\""
    877                 continue;               # Ignore this component
    878             }
    879             set _comp2dx($cname) $contents
    880873            if 0 {
    881                 set hdr "@@RP-ENC:zb64\n"
    882                 set data  [$_field get -decode no $cname.$type]
    883                 set data "$hdr$data"
    884                 set data  [Rappture::encoding::decode $data]
    885                 set data  [Rappture::DxToVtk $data]
    886                 set f [open /tmp/$_path.$cname.vtk "w"]
    887                 puts $f $data
    888                 close $f
     874                set vtkdata  [$_field get -decode yes $cname.$type]
     875                if { $vtkdata == "" } {
     876                    puts stderr "WARNING: no data for \"$_path.$cname.$type\""
     877                    continue;               # Ignore this component
     878                }
     879                set vtkdata  [Rappture::DxToVtk $vtkdata]
     880                if 0 {
     881                    set f [open /tmp/$_path.$cname.vtk "w"]
     882                    puts $f $vtkdata
     883                    close $f
     884                }
     885                ReadVtkDataSet $cname $vtkdata
     886                set _type "vtk"
     887                set _comp2vtk($cname) $vtkdata
     888            } else {
     889                set contents [$_field get -decode no $cname.$type]
     890                if { $contents == "" } {
     891                    puts stderr "WARNING: no data for \"$_path.$cname.$type\""
     892                    continue;               # Ignore this component
     893                }
     894                set _type "dx"
     895                set _comp2dx($cname) $contents
     896            }
     897            set viewer [$_field get "about.view"]
     898            if { $viewer != "" } {
     899                set _viewer $viewer
    889900            }
    890901            set _comp2style($cname) [$_field get $cname.style]
     
    15081519    }
    15091520    if { ![$mesh isvalid] } {
     1521        puts stderr "Mesh is invalid"
    15101522        return 0
    15111523    }
    15121524    set _dim [$mesh dimensions]
     1525    if { $_dim == 3 } {
     1526        set dim 0
     1527        foreach axis {x y z} {
     1528            foreach {min max} [$mesh limits $axis] {
     1529                if { $min < $max } {
     1530                    incr dim
     1531                }
     1532            }
     1533        }
     1534        if { $dim  != 3 } {
     1535            set _dim $dim
     1536        }
     1537    }
     1538       
    15131539    if {$_dim == 1} {
    15141540        # 1D data: Create vectors for graph widget.
  • branches/1.3/gui/scripts/vtkviewer.tcl

    r3863 r3877  
    267267        molecule-atomscale      0.3
    268268        molecule-bondscale      0.075
     269        molecule-bondstyle      "cylinder"
    269270        molecule-atoms-visible  1
    270271        molecule-bonds-visible  1
     
    10761077    }
    10771078
    1078     SendCmd "dataset maprange visible"
    1079 
    10801079    if { $_haveMolecules } {
    10811080        #FixSettings molecule-representation
     
    14591458                    set _settings(molecule-atoms-visible) 1
    14601459                    set _settings(molecule-bonds-visible) 1
    1461                     set bstyle cylinder
     1460                    set _settings(molecule-bondstyle) cylinder
    14621461                    set _settings(molecule-atomscale) 0.3
    14631462                    set _settings(molecule-bondscale) 0.075
     
    14671466                    set _settings(molecule-atoms-visible) 1
    14681467                    set _settings(molecule-bonds-visible) 0
    1469                     set bstyle cylinder
     1468                    set _settings(molecule-bondstyle) cylinder
    14701469                    set _settings(molecule-atomscale) 0.3
    14711470                    set _settings(molecule-bondscale) 0.075
     
    14751474                    set _settings(molecule-atoms-visible) 1
    14761475                    set _settings(molecule-bonds-visible) 1
    1477                     set bstyle cylinder
     1476                    set _settings(molecule-bondstyle) cylinder
    14781477                    set _settings(molecule-atomscale) 0.075
    14791478                    set _settings(molecule-bondscale) 0.075
     
    14831482                    set _settings(molecule-atoms-visible) 1
    14841483                    set _settings(molecule-bonds-visible) 0
    1485                     set bstyle cylinder
     1484                    set _settings(molecule-bondstyle) cylinder
    14861485                    set _settings(molecule-atomscale) 1.0
    14871486                    set _settings(molecule-bondscale) 0.075
     
    14911490                    set _settings(molecule-atoms-visible) 1
    14921491                    set _settings(molecule-bonds-visible) 1
    1493                     set bstyle cylinder
     1492                    set _settings(molecule-bondstyle) cylinder
    14941493                    set _settings(molecule-atomscale) 0.1
    14951494                    set _settings(molecule-bondscale) 0.1
     
    14991498                    set _settings(molecule-atoms-visible) 0
    15001499                    set _settings(molecule-bonds-visible) 1
    1501                     set bstyle line
     1500                    set _settings(molecule-bondstyle) cylinder
    15021501                    set _settings(molecule-atomscale) 1.0
    15031502                    set _settings(molecule-bondscale) 1.0
     
    15161515                }
    15171516            }
    1518             foreach dataset [CurrentDatasets -visible $_first] {
     1517            foreach dataset [CurrentDatasets -all] {
    15191518                foreach {dataobj comp} [split $dataset -] break
    15201519                set type [$dataobj type $comp]
     
    15231522molecule ascale $_settings(molecule-atomscale) $dataset
    15241523molecule bscale $_settings(molecule-bondscale) $dataset
    1525 molecule bstyle $bstyle $dataset
     1524molecule bstyle $_settings(molecule-bondstyle) $dataset
    15261525molecule atoms $_settings(molecule-atoms-visible) $dataset
    15271526molecule bonds $_settings(molecule-bonds-visible) $dataset}]
     
    24772476        "molecule" {
    24782477            SendCmd "molecule add $tag"
     2478            SendCmd "molecule ascale $_settings(molecule-atomscale) $tag"
     2479            SendCmd "molecule bscale $_settings(molecule-bondscale) $tag"
     2480            SendCmd "molecule bstyle $_settings(molecule-bondstyle) $tag"
     2481            SendCmd "molecule atoms $_settings(molecule-atoms-visible) $tag"
     2482            SendCmd "molecule bonds $_settings(molecule-bonds-visible) $tag"
    24792483            set _haveMolecules 1
    24802484        }
  • branches/1.3/gui/src/RpDxToVtk.c

    r3844 r3877  
    1212 * ======================================================================
    1313 */
     14#include <stdio.h>
    1415#include <string.h>
    1516#include <stdlib.h>
     17#include <sys/types.h>
     18#include <unistd.h>
    1619#include <ctype.h>
    1720#include <math.h>
     
    1922#include <float.h>
    2023#include "tcl.h"
     24
     25#define DO_WEDGES
    2126
    2227static INLINE char *
     
    109114
    110115static int
     116GetStructuredGridFieldValues(Tcl_Interp *interp, int nPoints, char **stringPtr,
     117                             const char *endPtr, Tcl_Obj *objPtr)
     118{
     119    int i;
     120    const char *p;
     121    char mesg[2000];
     122    double *array, scale, vmin, vmax;
     123
     124    p = *stringPtr;
     125    array = malloc(sizeof(double) * nPoints);
     126    if (array == NULL) {
     127        return TCL_ERROR;
     128    }
     129    vmin = DBL_MAX, vmax = -DBL_MAX;
     130    for (i = 0; i < nPoints; i++) {
     131        double value;
     132        char *nextPtr;
     133
     134        if (p >= endPtr) {
     135            Tcl_AppendResult(interp, "unexpected EOF in reading points",
     136                             (char *)NULL);
     137            return TCL_ERROR;
     138        }
     139        value = strtod(p, &nextPtr);
     140        if (nextPtr == p) {
     141            Tcl_AppendResult(interp, "bad value found in reading points",
     142                             (char *)NULL);
     143            return TCL_ERROR;
     144        }
     145        p = nextPtr;
     146        array[i] = value;
     147        if (value < vmin) {
     148            vmin = value;
     149        }
     150        if (value > vmax) {
     151            vmax = value;
     152        }
     153    }
     154    scale = 1.0 / (vmax - vmin);
     155    for (i = 0; i < nPoints; i++) {
     156#ifdef notdef
     157        sprintf(mesg, "%g\n", (array[i] - vmin) * scale);
     158#endif
     159        sprintf(mesg, "%g\n", array[i]);
     160        Tcl_AppendToObj(objPtr, mesg, -1);
     161    }
     162    free(array);
     163    *stringPtr = (char *)p;
     164    return TCL_OK;
     165}
     166
     167static int
    111168GetCloudFieldValues(Tcl_Interp *interp, int nXYPoints, int nZPoints, char **stringPtr,
    112169                    const char *endPtr, Tcl_Obj *objPtr)
     
    183240    }
    184241    for (i = 0; i < nXYPoints; i++) {
    185         double x, y, z;
     242        double x, y;
    186243        char *nextPtr;
    187244
     
    205262        }
    206263        p = nextPtr;
    207         z = strtod(p, &nextPtr);
     264        /* z is unused */
     265        strtod(p, &nextPtr);
    208266        if (nextPtr == p) {
    209267            Tcl_AppendResult(interp, "bad value found in reading points",
     
    219277    *stringPtr = (char *)p;
    220278    return TCL_OK;
     279}
     280
     281static void
     282Normalize(double v[3])
     283{
     284    double len = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
     285    v[0] /= len;
     286    v[1] /= len;
     287    v[2] /= len;
     288}
     289
     290static double
     291Dot(double v1[3], double v2[3])
     292{
     293    return (v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2]);
     294}
     295
     296static void
     297Cross(double v1[3], double v2[3], double vout[3])
     298{
     299    vout[0] = v1[1]*v2[2] - v1[2]*v2[1];
     300    vout[1] = v1[2]*v2[0] - v1[0]*v2[2];
     301    vout[2] = v1[0]*v2[1] - v1[1]*v2[0];
    221302}
    222303
     
    240321{
    241322    double *points;
    242     Tcl_Obj *objPtr, *pointsObjPtr, *fieldObjPtr;
     323    Tcl_Obj *objPtr, *pointsObjPtr, *fieldObjPtr, *cellsObjPtr;
    243324    char *p, *pend;
    244325    char *string;
    245326    char mesg[2000];
     327    double dv0[3], dv1[3], dv2[3];
    246328    double dx, dy, dz;
    247329    double origin[3];
    248330    int count[3];
    249     int length, nAxes, nPoints, nXYPoints;
     331    int length, nAxes, nPoints, nXYPoints, nCells;
    250332    char *name;
    251333    int isUniform;
    252     int i, iz;
    253 
    254     name = "myScalars";
    255     nAxes = nPoints = nXYPoints = 0;
     334    int isStructuredGrid;
     335    int i, ix, iy, iz;
     336
     337    name = "component";
     338    points = NULL;
     339    nAxes = nPoints = nXYPoints = nCells = 0;
    256340    dx = dy = dz = 0.0; /* Suppress compiler warning. */
    257341    origin[0] = origin[1] = origin[2] = 0.0; /* May not have an origin line. */
     342    dv0[0] = dv0[1] = dv0[2] = 0.0;
     343    dv1[0] = dv1[1] = dv1[2] = 0.0;
     344    dv2[0] = dv2[1] = dv2[2] = 0.0;
    258345    count[0] = count[1] = count[2] = 0; /* Suppress compiler warning. */
    259346    isUniform = 1; /* Default to expecting uniform grid */
    260    
     347    isStructuredGrid = 0;
     348
    261349    if (objc != 2) {
    262350        Tcl_AppendResult(interp, "wrong # arguments: should be \"",
     
    270358    }
    271359    pointsObjPtr = Tcl_NewStringObj("", -1);
     360    cellsObjPtr = Tcl_NewStringObj("", -1);
    272361    fieldObjPtr = Tcl_NewStringObj("", -1);
    273362    for (p = string, pend = p + length; p < pend; /*empty*/) {
     
    308397                return TCL_ERROR;
    309398            }
     399            switch (nAxes) {
     400            case 0:
     401                dv0[0] = ddx;
     402                dv0[1] = ddy;
     403                dv0[2] = ddz;
     404                break;
     405            case 1:
     406                dv1[0] = ddx;
     407                dv1[1] = ddy;
     408                dv1[2] = ddz;
     409                break;
     410            case 2:
     411                dv2[0] = ddx;
     412                dv2[1] = ddy;
     413                dv2[2] = ddz;
     414                break;
     415            default:
     416                break;
     417            }
     418
    310419            if (ddx != 0.0) {
    311420                if (ddy != 0.0 || ddz != 0.0) {
    312                     Tcl_AppendResult(interp, "invalid delta statement",
    313                                      (char *)NULL);
    314                     return TCL_ERROR;
     421                    /* Not axis aligned or skewed grid */
     422                    isUniform = 0;
     423                    isStructuredGrid = 1;
    315424                }
    316425                dx = ddx;
    317426            } else if (ddy != 0.0) {
    318427                if (ddx != 0.0 || ddz != 0.0) {
    319                     Tcl_AppendResult(interp, "invalid delta statement",
    320                                      (char *)NULL);
    321                     return TCL_ERROR;
     428                    /* Not axis aligned or skewed grid */
     429                    isUniform = 0;
     430                    isStructuredGrid = 1;
    322431                }
    323432                dy = ddy;
    324433            } else if (ddz != 0.0) {
    325434                if (ddx != 0.0 || ddy != 0.0) {
    326                     Tcl_AppendResult(interp, "invalid delta statement",
    327                                      (char *)NULL);
    328                     return TCL_ERROR;
     435                    /* Not axis aligned or skewed grid */
     436                    isUniform = 0;
     437                    isStructuredGrid = 1;
    329438                }
    330439                dz = ddz;
     
    360469                nPoints);
    361470#endif
    362             if (isUniform && nPoints != count[0]*count[1]*count[2]) {
     471            if ((isUniform || isStructuredGrid) &&
     472                nPoints != count[0]*count[1]*count[2]) {
    363473                sprintf(mesg, "inconsistent data: expected %d points"
    364474                        " but found %d points", count[0]*count[1]*count[2],
     
    366476                Tcl_AppendResult(interp, mesg, (char *)NULL);
    367477                return TCL_ERROR;
    368             } else if (!isUniform && nPoints != nXYPoints * count[2]) {
     478            } else if (!(isUniform || isStructuredGrid) &&
     479                       nPoints != nXYPoints * count[2]) {
    369480                sprintf(mesg, "inconsistent data: expected %d points"
    370481                        " but found %d points", nXYPoints * count[2],
     
    375486            if (isUniform) {
    376487                if (GetUniformFieldValues(interp, nPoints, count, &p, pend, fieldObjPtr)
     488                    != TCL_OK) {
     489                    return TCL_ERROR;
     490                }
     491            } else if (isStructuredGrid) {
     492                if (GetStructuredGridFieldValues(interp, nPoints, &p, pend, fieldObjPtr)
    377493                    != TCL_OK) {
    378494                    return TCL_ERROR;
     
    402518        sprintf(mesg, "SPACING %g %g %g\n", dx, dy, dz);
    403519        Tcl_AppendToObj(objPtr, mesg, -1);
     520        sprintf(mesg, "POINT_DATA %d\n", nPoints);
     521        Tcl_AppendToObj(objPtr, mesg, -1);
     522        sprintf(mesg, "SCALARS %s double 1\n", name);
     523        Tcl_AppendToObj(objPtr, mesg, -1);
     524        sprintf(mesg, "LOOKUP_TABLE default\n");
     525        Tcl_AppendToObj(objPtr, mesg, -1);
     526        Tcl_AppendObjToObj(objPtr, fieldObjPtr);
     527    } else if (isStructuredGrid) {
     528#ifdef notdef
     529        fprintf(stderr, "dv0 %g %g %g\n", dv0[0], dv0[1], dv0[2]);
     530        fprintf(stderr, "dv1 %g %g %g\n", dv1[0], dv1[1], dv1[2]);
     531        fprintf(stderr, "dv2 %g %g %g\n", dv2[0], dv2[1], dv2[2]);
     532#endif
     533        objPtr = Tcl_NewStringObj("# vtk DataFile Version 2.0\n", -1);
     534        Tcl_AppendToObj(objPtr, "Converted from DX file\n", -1);
     535        Tcl_AppendToObj(objPtr, "ASCII\n", -1);
     536        Tcl_AppendToObj(objPtr, "DATASET STRUCTURED_GRID\n", -1);
     537        sprintf(mesg, "DIMENSIONS %d %d %d\n", count[0], count[1], count[2]);
     538        Tcl_AppendToObj(objPtr, mesg, -1);
     539        for (iz = 0; iz < count[2]; iz++) {
     540            for (iy = 0; iy < count[1]; iy++) {
     541                for (ix = 0; ix < count[0]; ix++) {
     542                    double x, y, z;
     543                    x = origin[0] + dv2[0] * iz + dv1[0] * iy + dv0[0] * ix;
     544                    y = origin[1] + dv2[1] * iz + dv1[1] * iy + dv0[1] * ix;
     545                    z = origin[2] + dv2[2] * iz + dv1[2] * iy + dv0[2] * ix;
     546                    sprintf(mesg, "%g %g %g\n", x, y, z);
     547                    Tcl_AppendToObj(pointsObjPtr, mesg, -1);
     548                }
     549            }
     550        }
     551        sprintf(mesg, "POINTS %d double\n", nPoints);
     552        Tcl_AppendToObj(objPtr, mesg, -1);
     553        Tcl_AppendObjToObj(objPtr, pointsObjPtr);
    404554        sprintf(mesg, "POINT_DATA %d\n", nPoints);
    405555        Tcl_AppendToObj(objPtr, mesg, -1);
     
    419569            }
    420570        }
    421         free(points);
    422571
    423572        objPtr = Tcl_NewStringObj("# vtk DataFile Version 2.0\n", -1);
     
    428577        Tcl_AppendToObj(objPtr, mesg, -1);
    429578        Tcl_AppendObjToObj(objPtr, pointsObjPtr);
     579#ifdef DO_WEDGES
     580        {
     581            double xmin, xmax, ymin, ymax;
     582            xmin = xmax = points[0];
     583            ymin = ymax = points[1];
     584            for (i = 1; i < nXYPoints; i++) {
     585                double x, y;
     586                x = points[i*2];
     587                y = points[i*2+1];
     588                if (x < xmin) xmin = x;
     589                if (x > xmax) xmax = x;
     590                if (y < ymin) ymin = y;
     591                if (y > ymax) ymax = y;
     592            }
     593
     594            char fpts[128];
     595            sprintf(fpts, "/tmp/tmppts%d", getpid());
     596            char fcells[128];
     597            sprintf(fcells, "/tmp/tmpcells%d", getpid());
     598
     599            FILE *ftmp = fopen(fpts, "w");
     600            // save corners of bounding box first, to work around meshing
     601            // problems in voronoi utility
     602            int numBoundaryPoints = 4;
     603
     604            // Bump out the bounds by an epsilon to avoid problem when
     605            // corner points are already nodes
     606            double XEPS = (xmax - xmin) / 10.0f;
     607            double YEPS = (ymax - ymin) / 10.0f;
     608
     609            fprintf(ftmp, "%g %g\n", xmin - XEPS, ymin - YEPS);
     610            fprintf(ftmp, "%g %g\n", xmax + XEPS, ymin - YEPS);
     611            fprintf(ftmp, "%g %g\n", xmax + XEPS, ymax + YEPS);
     612            fprintf(ftmp, "%g %g\n", xmin - XEPS, ymax + YEPS);
     613
     614            for (i = 0; i < nXYPoints; i++) {
     615                fprintf(ftmp, "%g %g\n", points[i*2], points[i*2+1]);
     616            }
     617            fclose(ftmp);
     618#ifdef notdef
     619            double normal[3];
     620            normal[0] = normal[1] = 0.0;
     621            if (dx >= 0) {
     622                normal[2] = 1.0;
     623            } else {
     624                normal[2] = -1.0;
     625            }
     626#endif
     627            char cmdstr[512];
     628            sprintf(cmdstr, "voronoi -t < %s > %s", fpts, fcells);
     629            if (system(cmdstr) == 0) {
     630                int c0, c1, c2;
     631                ftmp = fopen(fcells, "r");
     632                while (!feof(ftmp)) {
     633                    if (fscanf(ftmp, "%d %d %d", &c0, &c1, &c2) == 3) {
     634                        c0 -= numBoundaryPoints;
     635                        c1 -= numBoundaryPoints;
     636                        c2 -= numBoundaryPoints;
     637                        // skip boundary points we added
     638                        if (c0 >= 0 && c1 >= 0 && c2 >= 0) {
     639#ifdef notdef
     640                            /* Winding of base triangle should point to
     641                               outside of cell using right hand rule */
     642                            double v1[3], v2[3], c[3];
     643                            v1[0] = points[c1*2] - points[c0*2];
     644                            v1[1] = points[c1*2+1] - points[c0*2+1];
     645                            v1[2] = 0;
     646                            v2[0] = points[c2*2] - points[c0*2];
     647                            v2[1] = points[c2*2+1] - points[c0*2+1];
     648                            v2[2] = 0;
     649                            Cross(v1, v2, c);
     650                            if (Dot(normal, c) > 0) {
     651                                int tmp = c0;
     652                                c0 = c2;
     653                                c2 = tmp;
     654                            }
     655#endif
     656                            for (iz = 0; iz < count[2] - 1; iz++) {
     657                                int base = nXYPoints * iz;
     658                                int top = base + nXYPoints;
     659                                nCells++;
     660                                sprintf(mesg, "%d %d %d %d %d %d %d\n", 6,
     661                                        base + c0, base + c1, base + c2,
     662                                        top + c0, top + c1, top + c2);
     663                                Tcl_AppendToObj(cellsObjPtr, mesg, -1);
     664                            }
     665                        }
     666                    } else {
     667                        break;
     668                    }
     669                }
     670                fclose(ftmp);
     671             } else {
     672                fprintf(stderr, "voronoi mesher failed");
     673            }
     674            unlink(fpts);
     675            unlink(fcells);
     676        }
     677        free(points);
     678        sprintf(mesg, "CELLS %d %d\n", nCells, 7*nCells);
     679        Tcl_AppendToObj(objPtr, mesg, -1);
     680        Tcl_AppendObjToObj(objPtr, cellsObjPtr);
     681        sprintf(mesg, "CELL_TYPES %d\n", nCells);
     682        Tcl_AppendToObj(objPtr, mesg, -1);
     683        sprintf(mesg, "%d\n", 13);
     684        for (i = 0; i < nCells; i++) {
     685            Tcl_AppendToObj(objPtr, mesg, -1);
     686        }
     687#endif
    430688        sprintf(mesg, "POINT_DATA %d\n", nPoints);
    431689        Tcl_AppendToObj(objPtr, mesg, -1);
     
    438696
    439697    Tcl_DecrRefCount(pointsObjPtr);
     698    Tcl_DecrRefCount(cellsObjPtr);
    440699    Tcl_DecrRefCount(fieldObjPtr);
    441700    Tcl_SetObjResult(interp, objPtr);
  • branches/1.3/gui/src/RpPdbToVtk.c

    r3786 r3877  
    1 
    21
    32/*
     
    2120#include "tcl.h"
    2221
    23 
    24 static INLINE char *
    25 SkipSpaces(char *string)
     22#define BOND_NONE       (0)
     23#define BOND_CONECT     (1<<0)
     24#define BOND_COMPUTE    (1<<1)
     25#define BOND_BOTH       (BOND_CONECT|BOND_COMPUTE)
     26
     27typedef struct {
     28    int from, to;
     29} ConnectKey;
     30
     31typedef struct {
     32    double x, y, z;                     /* Coordinates of atom. */
     33    int number;                         /* Atomic number */
     34    int ordinal;                        /* Index of the atom in VTK. */
     35    int numConnections;                 /*  */
     36} PdbAtom;
     37
     38typedef struct {
     39    const char *symbol;                 /* Atom symbol. */
     40    float radius;                       /* Covalent radius of atom. */
     41} PeriodicElement;
     42
     43static PeriodicElement elements[] = {
     44    {    "X",       0.1f,       },      /* 0 */
     45    {    "H",       0.32f,      },      /* 1 */         
     46    {    "He",      0.93f,      },      /* 2 */         
     47    {    "Li",      1.23f,      },      /* 3 */         
     48    {    "Be",      0.90f,      },      /* 4 */         
     49    {    "B",       0.82f,      },      /* 5 */         
     50    {    "C",       0.77f,      },      /* 6 */         
     51    {    "N",       0.75f,      },      /* 7 */         
     52    {    "O",       0.73f,      },      /* 8 */         
     53    {    "F",       0.72f,      },      /* 9 */         
     54    {    "Ne",      0.71f,      },      /* 10 */       
     55    {    "Na",      1.54f,      },      /* 11 */       
     56    {    "Mg",      1.36f,      },      /* 12 */       
     57    {    "Al",      1.18f,      },      /* 13 */       
     58    {    "Si",      1.11f,      },      /* 14 */       
     59    {    "P",       1.06f,      },      /* 15 */       
     60    {    "S",       1.02f,      },      /* 16 */       
     61    {    "Cl",      0.99f,      },      /* 17 */       
     62    {    "Ar",      0.98f,      },      /* 18 */       
     63    {    "K",       2.03f,      },      /* 19 */       
     64    {    "Ca",      1.74f,      },      /* 20 */       
     65    {    "Sc",      1.44f,      },      /* 21 */       
     66    {    "Ti",      1.32f,      },      /* 22 */       
     67    {    "V",       1.22f,      },      /* 23 */       
     68    {    "Cr",      1.18f,      },      /* 24 */       
     69    {    "Mn",      1.17f,      },      /* 25 */       
     70    {    "Fe",      1.17f,      },      /* 26 */       
     71    {    "Co",      1.16f,      },      /* 27 */       
     72    {    "Ni",      1.15f,      },      /* 28 */       
     73    {    "Cu",      1.17f,      },      /* 29 */       
     74    {    "Zn",      1.25f,      },      /* 30 */       
     75    {    "Ga",      1.26f,      },      /* 31 */       
     76    {    "Ge",      1.22f,      },      /* 32 */       
     77    {    "As",      1.20f,      },      /* 33 */       
     78    {    "Se",      1.16f,      },      /* 34 */       
     79    {    "Br",      1.14f,      },      /* 35 */       
     80    {    "Kr",      1.12f,      },      /* 36 */       
     81    {    "Rb",      2.16f,      },      /* 37 */       
     82    {    "Sr",      1.91f,      },      /* 38 */       
     83    {    "Y",       1.62f,      },      /* 39 */       
     84    {    "Zr",      1.45f,      },      /* 40 */       
     85    {    "Nb",      1.34f,      },      /* 41 */       
     86    {    "Mo",      1.30f,      },      /* 42 */       
     87    {    "Tc",      1.27f,      },      /* 43 */       
     88    {    "Ru",      1.25f,      },      /* 44 */       
     89    {    "Rh",      1.25f,      },      /* 45 */       
     90    {    "Pd",      1.28f,      },      /* 46 */       
     91    {    "Ag",      1.34f,      },      /* 47 */       
     92    {    "Cd",      1.48f,      },      /* 48 */       
     93    {    "In",      1.44f,      },      /* 49 */       
     94    {    "Sn",      1.41f,      },      /* 50 */       
     95    {    "Sb",      1.40f,      },      /* 51 */       
     96    {    "Te",      1.36f,      },      /* 52 */       
     97    {    "I",       1.33f,      },      /* 53 */       
     98    {    "Xe",      1.31f,      },      /* 54 */       
     99    {    "Cs",      2.35f,      },      /* 55 */       
     100    {    "Ba",      1.98f,      },      /* 56 */       
     101    {    "La",      1.69f,      },      /* 57 */       
     102    {    "Ce",      1.65f,      },      /* 58 */       
     103    {    "Pr",      1.65f,      },      /* 59 */       
     104    {    "Nd",      1.64f,      },      /* 60 */       
     105    {    "Pm",      1.63f,      },      /* 61 */       
     106    {    "Sm",      1.62f,      },      /* 62 */       
     107    {    "Eu",      1.85f,      },      /* 63 */       
     108    {    "Gd",      1.61f,      },      /* 64 */       
     109    {    "Tb",      1.59f,      },      /* 65 */       
     110    {    "Dy",      1.59f,      },      /* 66 */       
     111    {    "Ho",      1.58f,      },      /* 67 */       
     112    {    "Er",      1.57f,      },      /* 68 */       
     113    {    "Tm",      1.56f,      },      /* 69 */       
     114    {    "Yb",      1.74f,      },      /* 70 */       
     115    {    "Lu",      1.56f,      },      /* 71 */       
     116    {    "Hf",      1.44f,      },      /* 72 */       
     117    {    "Ta",      1.34f,      },      /* 73 */       
     118    {    "W",       1.30f,      },      /* 74 */       
     119    {    "Re",      1.28f,      },      /* 75 */       
     120    {    "Os",      1.26f,      },      /* 76 */       
     121    {    "Ir",      1.27f,      },      /* 77 */       
     122    {    "Pt",      1.30f,      },      /* 78 */       
     123    {    "Au",      1.34f,      },      /* 79 */       
     124    {    "Hg",      1.49f,      },      /* 80 */       
     125    {    "Tl",      1.48f,      },      /* 81 */       
     126    {    "Pb",      1.47f,      },      /* 82 */       
     127    {    "Bi",      1.46f,      },      /* 83 */       
     128    {    "Po",      1.46f,      },      /* 84 */       
     129    {    "At",      1.45f,      },      /* 85 */       
     130    {    "Rn",      1.50f,      },      /* 86 */       
     131    {    "Fr",      2.60f,      },      /* 87 */       
     132    {    "Ra",      2.21f,      },      /* 88 */       
     133    {    "Ac",      2.15f,      },      /* 89 */       
     134    {    "Th",      2.06f,      },      /* 90 */       
     135    {    "Pa",      2.00f,      },      /* 91 */       
     136    {    "U",       1.96f,      },      /* 92 */       
     137    {    "Np",      1.90f,      },      /* 93 */       
     138    {    "Pu",      1.87f,      },      /* 94 */       
     139    {    "Am",      1.80f,      },      /* 95 */       
     140    {    "Cm",      1.69f,      },      /* 96 */       
     141    {    "Bk",      0.1f,       },      /* 97 */       
     142    {    "Cf",      0.1f,       },      /* 98 */       
     143    {    "Es",      0.1f,       },      /* 99 */       
     144    {    "Fm",      0.1f,       },      /* 100 */       
     145    {    "Md",      0.1f,       },      /* 101 */       
     146    {    "No",      0.1f,       },      /* 102 */       
     147    {    "Lr",      0.1f,       },      /* 103 */       
     148    {    "Rf",      0.1f,       },      /* 104 */       
     149    {    "Db",      0.1f,       },      /* 105 */       
     150    {    "Sg",      0.1f,       },      /* 106 */       
     151    {    "Bh",      0.1f,       },      /* 107 */       
     152    {    "Hs",      0.1f,       },      /* 108 */       
     153    {    "Mt",      0.1f,       },      /* 109 */       
     154    {    "Ds",      0.1f,       },      /* 110 */       
     155    {    "Rg",      0.1f,       },      /* 111 */       
     156    {    "Cn",      0.1f,       },      /* 112 */       
     157    {    "Uut",     0.1f,       },      /* 113 */       
     158    {    "Fl",      0.1f,       },      /* 114 */       
     159    {    "Uup",     0.1f,       },      /* 115 */       
     160    {    "Lv",      0.1f,       },      /* 116 */       
     161    {    "Uus",     0.1f,       },      /* 117 */       
     162    {    "Uuo",     0.1f,       }       /* 118 */       
     163};
     164
     165static int numPeriodicElements = sizeof(elements) / sizeof(PeriodicElement);
     166
     167static int lineNum = 0;
     168
     169static const char *
     170Itoa(int number)
     171{
     172    static char buf[200];
     173    sprintf(buf, "%d", number);
     174    return buf;
     175}
     176
     177static void
     178ComputeBonds(Tcl_HashTable *atomTablePtr, Tcl_HashTable *conectTablePtr)
     179{
     180    PdbAtom **array;
     181    int i;
     182    Tcl_HashEntry *hPtr;
     183    Tcl_HashSearch iter;
     184
     185#define TOLERANCE 0.45                  /* Fuzz factor for comparing distances
     186                                         * (in angstroms) */
     187    array = calloc(atomTablePtr->numEntries, sizeof(PdbAtom *));
     188    if (array == NULL) {
     189        return;
     190    }
     191    for (i = 0, hPtr = Tcl_FirstHashEntry(atomTablePtr, &iter); hPtr != NULL;
     192         hPtr = Tcl_NextHashEntry(&iter), i++) {
     193        PdbAtom *atomPtr;
     194
     195        atomPtr = Tcl_GetHashValue(hPtr);
     196        array[i] = atomPtr;
     197    }
     198    for (i = 0; i < atomTablePtr->numEntries; i++) {
     199        PdbAtom *atom1Ptr;
     200        double r1;
     201        int j;
     202
     203        atom1Ptr = array[i];
     204        r1 = elements[atom1Ptr->number].radius;
     205        for (j = i+1; j < atomTablePtr->numEntries; j++) {
     206            PdbAtom *atom2Ptr;
     207            double ds2, cut;
     208            double r2;
     209
     210            atom2Ptr  = array[j];
     211            if ((atom2Ptr->number == 1) && (atom1Ptr->number == 1)) {
     212                continue;
     213            }
     214            r2 = elements[atom2Ptr->number].radius;
     215            cut = (r1 + r2 + TOLERANCE);
     216            ds2 = (((atom1Ptr->x - atom2Ptr->x) * (atom1Ptr->x - atom2Ptr->x)) +
     217                   ((atom1Ptr->y - atom2Ptr->y) * (atom1Ptr->y - atom2Ptr->y)) +
     218                   ((atom1Ptr->z - atom2Ptr->z) * (atom1Ptr->z - atom2Ptr->z)));
     219
     220            // perform distance test, but ignore pairs between atoms
     221            // with nearly identical coords
     222            if (ds2 < 0.16) {
     223                continue;
     224            }
     225            if (ds2 < (cut*cut)) {
     226                ConnectKey key;
     227                int isNew;
     228
     229                if (atom1Ptr->ordinal > atom2Ptr->ordinal) {
     230                    key.from = atom2Ptr->ordinal;
     231                    key.to = atom1Ptr->ordinal;
     232                } else {
     233                    key.from = atom1Ptr->ordinal;
     234                    key.to = atom2Ptr->ordinal;
     235                }
     236                Tcl_CreateHashEntry(conectTablePtr, (char *)&key, &isNew);
     237                if (isNew) {
     238                    atom1Ptr->numConnections++;
     239                    atom2Ptr->numConnections++;
     240                }
     241            }
     242        }
     243    }
     244    free(array);
     245}
     246
     247int
     248GetAtomicNumber(Tcl_Interp *interp, PdbAtom *atomPtr, const char *atomName,
     249                const char *symbolName, const char *residueName)
     250{
     251    char name[5], *namePtr;
     252    int elemIndex, symbolIndex;
     253    int count;
     254    const char *p;
     255
     256    symbolIndex = elemIndex = -1;
     257
     258    /*
     259     * The atomic symbol may be found the atom name in various locations
     260     *  "C   "
     261     *  " C  "
     262     *  "  C "
     263     "  "   C"
     264     "  "C 12"
     265     "  " C12"
     266     */
     267    count = 0;
     268    for (p = atomName; *p != '\0'; p++) {
     269        if (isspace(*p) || isdigit(*p)) {
     270            continue;
     271        }
     272        name[count] = *p;
     273        count++;
     274    }
     275    name[count] = '\0';
     276    if (count > 0) {
     277        int i;
     278
     279        namePtr = name;
     280        if (name[0] == ' ') {
     281            namePtr++;
     282        }
     283        if (name[1] == ' ') {
     284            name[1] = '\0';
     285        }
     286        for (i = 0; i < numPeriodicElements; i++) {
     287            if (strcasecmp(namePtr, elements[i].symbol) == 0) {
     288                elemIndex = i;
     289                break;
     290            }
     291        }
     292        if ((elemIndex == -1) && (count > 1)) {
     293            name[1] = '\0';
     294            for (i = 0; i < numPeriodicElements; i++) {
     295                if (strcasecmp(namePtr, elements[i].symbol) == 0) {
     296                    elemIndex = i;
     297                    break;
     298                }
     299            }
     300        }
     301    }
     302    name[0] = symbolName[0];
     303    name[1] = symbolName[1];
     304    name[2] = '\0';
     305    if (isdigit(name[1])) {
     306        sscanf(name, "%d", &atomPtr->number);
     307        return TCL_OK;
     308    }
     309    if ((name[0] != ' ') || (name[1] != ' ')) {
     310        int i;
     311
     312        namePtr = name;
     313        if (name[0] == ' ') {
     314            namePtr++;
     315        }
     316        if (name[1] == ' ') {
     317            name[1] = '\0';
     318        }
     319        for (i = 0; i < numPeriodicElements; i++) {
     320            if (strcasecmp(namePtr, elements[i].symbol) == 0) {
     321                symbolIndex = i;
     322                break;
     323            }
     324        }
     325    }
     326    if (symbolIndex > 0) {
     327        if (elemIndex < 0) {
     328            atomPtr->number = symbolIndex;
     329            return TCL_OK;
     330        }
     331        if (symbolIndex != elemIndex) {
     332            fprintf(stderr, "atomName %s and symbolName %s don't match\n",
     333                    atomName, symbolName);
     334            atomPtr->number = symbolIndex;
     335            return TCL_OK;
     336        }
     337        atomPtr->number = elemIndex;
     338        return TCL_OK;
     339    } else if (elemIndex > 0) {
     340        atomPtr->number = elemIndex;
     341        return TCL_OK;
     342    }
     343    Tcl_AppendResult(interp, "line ", Itoa(lineNum), ": bad atom \"",
     344                     atomName, "\" or element \"",
     345                     symbolName, "\"", (char *)NULL);
     346    return TCL_ERROR;
     347}
     348
     349static PdbAtom *
     350NewAtom(Tcl_Interp *interp, int ordinal, const char *line, int lineLength)
     351{
     352    PdbAtom *atomPtr;
     353    char buf[200];
     354    char atomName[6];                   /* Atom name.  */
     355    char symbolName[3];                 /* Symbol name.  */
     356    char residueName[4];                /* Residue name. */
     357    double value;
     358
     359    atomPtr = calloc(1, sizeof(PdbAtom));
     360    if (atomPtr == NULL) {
     361        return NULL;
     362    }
     363    atomPtr->ordinal = ordinal;
     364    strncpy(atomName, line + 12, 4);
     365    atomName[4] = '\0';
     366    strncpy(residueName, line + 17, 3);
     367    residueName[3] = '\0';
     368
     369    strncpy(buf, line + 30, 8);
     370    buf[8] = '\0';
     371    if (Tcl_GetDouble(interp, buf, &value) != TCL_OK) {
     372        Tcl_AppendResult(interp, "bad x-coordinate \"", buf,
     373                         "\"", (char *)NULL);
     374        return NULL;
     375    }
     376    atomPtr->x = value;
     377    strncpy(buf, line + 38, 8);
     378    buf[8] = '\0';
     379    if (Tcl_GetDouble(interp, buf, &value) != TCL_OK) {
     380        Tcl_AppendResult(interp, "bad y-coordinate \"", buf,
     381                         "\"", (char *)NULL);
     382        return NULL;
     383    }
     384    atomPtr->y = value;
     385    strncpy(buf, line + 46, 8);
     386    buf[8] = '\0';
     387    if (Tcl_GetDouble(interp, buf, &value) != TCL_OK) {
     388        Tcl_AppendResult(interp, "bad z-coordinate \"", buf,
     389                         "\"", (char *)NULL);
     390        return NULL;
     391    }
     392    atomPtr->z = value;
     393    symbolName[2] = symbolName[1]  = symbolName[0] = '\0';
     394    if (lineLength >= 77) {
     395        symbolName[0] = line[76];
     396        symbolName[1] = line[77];
     397        symbolName[2] = '\0';
     398    }
     399    if (GetAtomicNumber(interp, atomPtr, atomName, symbolName, residueName)
     400        != TCL_OK) {
     401        return NULL;
     402    }
     403    return atomPtr;
     404}
     405
     406static void
     407FreeAtoms(Tcl_HashTable *tablePtr)
     408{
     409    Tcl_HashEntry *hPtr;
     410    Tcl_HashSearch iter;
     411
     412    for (hPtr = Tcl_FirstHashEntry(tablePtr, &iter); hPtr != NULL;
     413         hPtr = Tcl_NextHashEntry(&iter)) {
     414        PdbAtom *atomPtr;
     415       
     416        atomPtr = Tcl_GetHashValue(hPtr);
     417        free(atomPtr);
     418    }
     419    Tcl_DeleteHashTable(tablePtr);
     420}
     421
     422
     423static INLINE const char *
     424SkipSpaces(const char *string)
    26425{
    27426    while (isspace(*string)) {
     
    31430}
    32431
    33 static INLINE char *
    34 GetLine(char **stringPtr, const char *endPtr, int *lengthPtr)
    35 {
    36     char *line, *p;
     432static int
     433IsSpaces(const char *string)
     434{
     435    const char *p;
     436    for (p = string; *p != '\0'; p++) {
     437        if (!isspace(*p)) {
     438            return 0;
     439        }
     440    }
     441    return 1;
     442}
     443
     444static INLINE const char *
     445GetLine(const char **stringPtr, const char *endPtr, int *lengthPtr)
     446{
     447    const char *line;
     448    const char *p;
    37449
    38450    line = SkipSpaces(*stringPtr);
     
    44456        }
    45457    }
     458    *lengthPtr = (p - line) - 1;
    46459    *stringPtr = p;
    47460    return line;
    48461}
    49462
    50 static const char *elemNames[] = {
    51     "Hydrogen",                         /* 1 */         
    52     "Helium",                           /* 2 */         
    53     "Lithium",                          /* 3 */         
    54     "Beryllium",                        /* 4 */         
    55     "Boron",                            /* 5 */         
    56     "Carbon",                           /* 6 */         
    57     "Nitrogen",                         /* 7 */         
    58     "Oxygen",                           /* 8 */         
    59     "Fluorine",                         /* 9 */         
    60     "Neon",                             /* 10 */       
    61     "Sodium",                           /* 11 */       
    62     "Magnesium",                        /* 12 */       
    63     "Aluminium",                        /* 13 */       
    64     "Silicon",                          /* 14 */       
    65     "Phosphorus",                       /* 15 */       
    66     "Sulfur",                           /* 16 */       
    67     "Chlorine",                         /* 17 */       
    68     "Argon",                            /* 18 */       
    69     "Potassium",                        /* 19 */       
    70     "Calcium",                          /* 20 */       
    71     "Scandium",                         /* 21 */       
    72     "Titanium",                         /* 22 */       
    73     "Vanadium",                         /* 23 */       
    74     "Chromium",                         /* 24 */       
    75     "Manganese",                        /* 25 */       
    76     "Iron",                             /* 26 */       
    77     "Cobalt",                           /* 27 */       
    78     "Nickel",                           /* 28 */       
    79     "Copper",                           /* 29 */       
    80     "Zinc",                             /* 30 */       
    81     "Gallium",                          /* 31 */       
    82     "Germanium",                /* 32 */       
    83     "Arsenic",          /* 33 */       
    84     "Selenium",         /* 34 */       
    85     "Bromine",          /* 35 */       
    86     "Krypton",          /* 36 */       
    87     "Rubidium",         /* 37 */       
    88     "Strontium",                /* 38 */       
    89     "Yttrium",          /* 39 */       
    90     "Zirconium",                /* 40 */       
    91     "Niobium",          /* 41 */       
    92     "Molybdenum",               /* 42 */       
    93     "Technetium",               /* 43 */       
    94     "Ruthenium",                /* 44 */       
    95     "Rhodium",          /* 45 */       
    96     "Palladium",                /* 46 */       
    97     "Silver",           /* 47 */       
    98     "Cadmium",          /* 48 */       
    99     "Indium",           /* 49 */       
    100     "Tin",                      /* 50 */       
    101     "Antimony",         /* 51 */       
    102     "Tellurium",                /* 52 */       
    103     "Iodine",           /* 53 */       
    104     "Xenon",            /* 54 */       
    105     "Cesium",           /* 55 */       
    106     "Barium",           /* 56 */       
    107     "Lanthanum",                /* 57 */       
    108     "Cerium",           /* 58 */       
    109     "Praseodymium",             /* 59 */       
    110     "Neodymium",                /* 60 */       
    111     "Promethium",               /* 61 */       
    112     "Samarium",         /* 62 */       
    113     "Europium",         /* 63 */       
    114     "Gadolinium",               /* 64 */       
    115     "Terbium",          /* 65 */       
    116     "Dysprosium",               /* 66 */       
    117     "Holmium",          /* 67 */       
    118     "Erbium",           /* 68 */       
    119     "Thulium",          /* 69 */       
    120     "Ytterbium",                /* 70 */       
    121     "Lutetium",         /* 71 */       
    122     "Hafnium",          /* 72 */       
    123     "Tantalum",         /* 73 */       
    124     "Tungsten",         /* 74 */       
    125     "Rhenium",          /* 75 */       
    126     "Osmium",           /* 76 */       
    127     "Iridium",          /* 77 */       
    128     "Platinum",         /* 78 */       
    129     "Gold",                     /* 79 */       
    130     "Mercury",          /* 80 */       
    131     "Thallium",         /* 81 */       
    132     "Lead",                     /* 82 */       
    133     "Bismuth",          /* 83 */       
    134     "Polonium",         /* 84 */       
    135     "Astatine",         /* 85 */       
    136     "Radon",            /* 86 */       
    137     "Francium",         /* 87 */       
    138     "Radium",           /* 88 */       
    139     "Actinium",         /* 89 */       
    140     "Thorium",          /* 90 */       
    141     "Protactinium",             /* 91 */       
    142     "Uranium",          /* 92 */       
    143     "Neptunium",                /* 93 */       
    144     "Plutonium",                /* 94 */       
    145     "Americium",                /* 95 */       
    146     "Curium",           /* 96 */       
    147     "Berkelium",                /* 97 */       
    148     "Californium",              /* 98 */       
    149     "Einsteinium",              /* 99 */       
    150     "Fermium",          /* 100 */       
    151     "Mendelevium",              /* 101 */       
    152     "Nobelium",         /* 102 */       
    153     "Lawrencium",               /* 103 */       
    154     "Rutherfordium",    /* 104 */       
    155     "Dubnium",          /* 105 */       
    156     "Seaborgium",               /* 106 */       
    157     "Bohrium",          /* 107 */       
    158     "Hassium",          /* 108 */       
    159     "Meitnerium",               /* 109 */       
    160     "Darmstadtium",             /* 110 */       
    161     "Roentgenium",              /* 111 */       
    162     "Copernicium",              /* 112 */       
    163     "Ununtrium",                /* 113 */       
    164     "Flerovium",                /* 114 */       
    165     "Ununpentium",              /* 115 */       
    166     "Livermorium",              /* 116 */       
    167     "Ununseptium",              /* 117 */       
    168     "Ununoctium",               /* 118 */       
    169     NULL
    170 };
    171 
    172 static const char *symbolNames[] = {
    173     "H",                        /* 1 */         
    174     "He",                       /* 2 */         
    175     "Li",                       /* 3 */         
    176     "Be",                       /* 4 */         
    177     "B",                        /* 5 */         
    178     "C",                        /* 6 */         
    179     "N",                        /* 7 */         
    180     "O",                        /* 8 */         
    181     "F",                        /* 9 */         
    182     "Ne",                       /* 10 */       
    183     "Na",                       /* 11 */       
    184     "Mg",                       /* 12 */       
    185     "Al",                       /* 13 */       
    186     "Si",                       /* 14 */       
    187     "P",                        /* 15 */       
    188     "S",                        /* 16 */       
    189     "Cl",                       /* 17 */       
    190     "Ar",                       /* 18 */       
    191     "K",                        /* 19 */       
    192     "Ca",                       /* 20 */       
    193     "Sc",                       /* 21 */       
    194     "Ti",                       /* 22 */       
    195     "V",                        /* 23 */       
    196     "Cr",                       /* 24 */       
    197     "Mn",                       /* 25 */       
    198     "Fe",                       /* 26 */       
    199     "Co",                       /* 27 */       
    200     "Ni",                       /* 28 */       
    201     "Cu",                       /* 29 */       
    202     "Zn",                       /* 30 */       
    203     "Ga",                       /* 31 */       
    204     "Ge",                       /* 32 */       
    205     "As",                       /* 33 */       
    206     "Se",                       /* 34 */       
    207     "Br",                       /* 35 */       
    208     "Kr",                       /* 36 */       
    209     "Rb",                       /* 37 */       
    210     "Sr",                       /* 38 */       
    211     "Y",                        /* 39 */       
    212     "Zr",                       /* 40 */       
    213     "Nb",                       /* 41 */       
    214     "Mo",                       /* 42 */       
    215     "Tc",                       /* 43 */       
    216     "Ru",                       /* 44 */       
    217     "Rh",                       /* 45 */       
    218     "Pd",                       /* 46 */       
    219     "Ag",                       /* 47 */       
    220     "Cd",                       /* 48 */       
    221     "In",                       /* 49 */       
    222     "Sn",                       /* 50 */       
    223     "Sb",                       /* 51 */       
    224     "Te",                       /* 52 */       
    225     "I",                        /* 53 */       
    226     "Xe",                       /* 54 */       
    227     "Cs",                       /* 55 */       
    228     "Ba",                       /* 56 */       
    229     "La",                       /* 57 */       
    230     "Ce",                       /* 58 */       
    231     "Pr",                       /* 59 */       
    232     "Nd",                       /* 60 */       
    233     "Pm",                       /* 61 */       
    234     "Sm",                       /* 62 */       
    235     "Eu",                       /* 63 */       
    236     "Gd",                       /* 64 */       
    237     "Tb",                       /* 65 */       
    238     "Dy",                       /* 66 */       
    239     "Ho",                       /* 67 */       
    240     "Er",                       /* 68 */       
    241     "Tm",                       /* 69 */       
    242     "Yb",                       /* 70 */       
    243     "Lu",                       /* 71 */       
    244     "Hf",                       /* 72 */       
    245     "Ta",                       /* 73 */       
    246     "W",                        /* 74 */       
    247     "Re",                       /* 75 */       
    248     "Os",                       /* 76 */       
    249     "Ir",                       /* 77 */       
    250     "Pt",                       /* 78 */       
    251     "Au",                       /* 79 */       
    252     "Hg",                       /* 80 */       
    253     "Tl",                       /* 81 */       
    254     "Pb",                       /* 82 */       
    255     "Bi",                       /* 83 */       
    256     "Po",                       /* 84 */       
    257     "At",                       /* 85 */       
    258     "Rn",                       /* 86 */       
    259     "Fr",                       /* 87 */       
    260     "Ra",                       /* 88 */       
    261     "Ac",                       /* 89 */       
    262     "Th",                       /* 90 */       
    263     "Pa",                       /* 91 */       
    264     "U",                        /* 92 */       
    265     "Np",                       /* 93 */       
    266     "Pu",                       /* 94 */       
    267     "Am",                       /* 95 */       
    268     "Cm",                       /* 96 */       
    269     "Bk",                       /* 97 */       
    270     "Cf",                       /* 98 */       
    271     "Es",                       /* 99 */       
    272     "Fm",                       /* 100 */       
    273     "Md",                       /* 101 */       
    274     "No",                       /* 102 */       
    275     "Lr",                       /* 103 */       
    276     "Rf",                       /* 104 */       
    277     "Db",                       /* 105 */       
    278     "Sg",                       /* 106 */       
    279     "Bh",                       /* 107 */       
    280     "Hs",                       /* 108 */       
    281     "Mt",                       /* 109 */       
    282     "Ds",                       /* 110 */       
    283     "Rg",                       /* 111 */       
    284     "Cn",                       /* 112 */       
    285     "Uut",                      /* 113 */       
    286     "Fl",                       /* 114 */       
    287     "Uup",                      /* 115 */       
    288     "Lv",                       /* 116 */       
    289     "Uus",                      /* 117 */       
    290     "Uuo",                      /* 118 */       
    291     NULL
    292 };
    293 
    294 int
    295 VerifyElement(const char *elemName, const char *symbolName)
    296 {
    297     const char **p;
    298     int elemIndex, symbolIndex;
    299 
    300     symbolIndex = elemIndex = -1;
    301     elemName = SkipSpaces(elemName);
    302     for (p = symbolNames; *p != NULL; p++) {
    303         if (strcasecmp(elemName, *p) == 0) {
    304             elemIndex = (p - symbolNames) + 1;
    305             break;
    306         }
    307     }
    308     symbolName = SkipSpaces(symbolName);
    309     for (p = symbolNames; *p != NULL; p++) {
    310         if (strcasecmp(symbolName, *p) == 0) {
    311             symbolIndex = (p - symbolNames) + 1;
    312             break;
    313         }
    314     }
    315     if (symbolIndex > 0) {
    316         if (elemIndex < 0) {
    317             return symbolIndex;
    318         }
    319         if (symbolIndex != elemIndex) {
    320             return -1;
    321         }
    322         return elemIndex;
    323     } else if (elemIndex > 0) {
    324         return elemIndex;
    325     }
    326     return -1;
     463
     464static int
     465SerialToAtom(Tcl_Interp *interp, Tcl_HashTable *tablePtr, const char *string,
     466                PdbAtom **atomPtrPtr)
     467{
     468    int serial;
     469    long lserial;
     470    Tcl_HashEntry *hPtr;
     471
     472    string = SkipSpaces(string);
     473    if (Tcl_GetInt(interp, string, &serial) != TCL_OK) {
     474        Tcl_AppendResult(interp, ": line ", Itoa(lineNum),
     475                ": invalid serial number \"", string,
     476                "\" in CONECT record", (char *)NULL);
     477        return TCL_ERROR;
     478    }
     479    lserial = (long)serial;
     480    hPtr = Tcl_FindHashEntry(tablePtr, (char *)lserial);
     481    if (hPtr == NULL) {
     482        Tcl_AppendResult(interp, "serial number \"", string,
     483                         "\" not found in table", (char *)NULL);
     484        return TCL_ERROR;
     485    }
     486    *atomPtrPtr = Tcl_GetHashValue(hPtr);
     487    return TCL_OK;
    327488}
    328489
    329490/*
    330  *  PdbToVtk string
     491 *  PdbToVtk string ?-bonds none|both|auto|conect?
    331492 */
    332 
    333493static int
    334494PdbToVtkCmd(ClientData clientData, Tcl_Interp *interp, int objc,
    335495           Tcl_Obj *const *objv)
    336496{
    337     Tcl_Obj *objPtr, *pointsObjPtr, *atomsObjPtr, *verticesObjPtr;
    338     char *p, *pend;
    339     char *string;
     497    Tcl_Obj *objPtr, *pointsObjPtr, *atomsObjPtr;
     498    const char *p, *pend;
     499    const char *string;
    340500    char mesg[2000];
    341     int length, numAtoms, numConnections;
    342     Tcl_HashTable serialTable;
    343     int i;
     501    int length, nextOrdinal;
     502    Tcl_HashTable atomTable, conectTable;
    344503    Tcl_HashEntry *hPtr;
    345504    Tcl_HashSearch iter;
    346505    int isNew;
    347 
    348     numConnections = numAtoms = 0;
    349     if (objc != 2) {
     506    int bondFlags;
     507
     508    bondFlags = BOND_BOTH;
     509    lineNum = nextOrdinal = 0;
     510    if ((objc != 2) && (objc != 4)) {
    350511        Tcl_AppendResult(interp, "wrong # arguments: should be \"",
    351                          Tcl_GetString(objv[0]), " string\"", (char *)NULL);
     512                Tcl_GetString(objv[0]),
     513                " string ?-bonds none|both|auto|conect\"", (char *)NULL);
    352514        return TCL_ERROR;
    353515    }
    354     Tcl_InitHashTable(&serialTable, TCL_ONE_WORD_KEYS);
     516    if (objc == 4) {
     517        const char *string;
     518        char c;
     519
     520        string = Tcl_GetString(objv[2]);
     521        if ((string[0] != '-') || (strcmp(string, "-bonds") != 0)) {
     522            Tcl_AppendResult(interp, "bad switch \"", string,
     523                             "\": should be \"-bonds\"", (char *)NULL);
     524            return TCL_ERROR;
     525        }
     526        string = Tcl_GetString(objv[3]);
     527        c = string[0];
     528        if ((c == 'n') && (strcmp(string, "none") == 0)) {
     529            bondFlags = BOND_NONE;
     530        } else if ((c == 'b') && (strcmp(string, "both") == 0)) {
     531            bondFlags = BOND_BOTH;
     532        } else if ((c == 'a') && (strcmp(string, "auto") == 0)) {
     533            bondFlags = BOND_COMPUTE;
     534        } else if ((c == 'c') && (strcmp(string, "conect") == 0)) {
     535            bondFlags = BOND_CONECT;
     536        } else {
     537            Tcl_AppendResult(interp, "bad value \"", string,
     538                "\" for -bonds switch: should be none, both, manual, or auto",
     539                (char *)NULL);
     540            return TCL_ERROR;
     541        }
     542    }
     543    Tcl_InitHashTable(&atomTable, TCL_ONE_WORD_KEYS);
     544    Tcl_InitHashTable(&conectTable, sizeof(ConnectKey) / sizeof(int));
    355545    string = Tcl_GetStringFromObj(objv[1], &length);
    356546    pointsObjPtr = Tcl_NewStringObj("", -1);
    357547    atomsObjPtr = Tcl_NewStringObj("", -1);
    358     verticesObjPtr = Tcl_NewStringObj("", -1);
    359548    Tcl_IncrRefCount(pointsObjPtr);
    360549    Tcl_IncrRefCount(atomsObjPtr);
    361     Tcl_IncrRefCount(verticesObjPtr);
    362550    objPtr = NULL;
    363551    for (p = string, pend = p + length; p < pend; /*empty*/) {
    364         char *line, *q;
     552        const char *line;
    365553        char c;
    366554        int lineLength;
    367555
     556        lineLength = 0;                 /* Suppress compiler warning. */
     557        lineNum++;
    368558        line = GetLine(&p, pend, &lineLength);
    369559        if (line >= pend) {
     
    374564        }
    375565        c = line[0];
    376        
    377566        if (((c == 'A') && (strncmp(line, "ATOM  ", 6) == 0)) ||
    378567            ((c == 'H') && (strncmp(line, "HETATM", 6) == 0))) {
    379568            char buf[200];
    380             char atomName[6];
    381             char symbolName[3];
    382             int serial;
    383             double x, y, z;
    384             int atom;
     569            int serialNum;
     570            long lserial;
     571            PdbAtom *atomPtr;
    385572
    386573            if (lineLength < 47) {
    387                 Tcl_AppendResult(interp, "short ATOM line \"", line, "\"",
    388                         (char *)NULL);
    389                 goto error;
     574                char *msg;
     575
     576                msg = (char *)line;
     577                msg[lineLength] = '\0';
     578                Tcl_AppendResult(interp, "line ", Itoa(lineNum),
     579                        " short ATOM line \"", line, "\"", (char *)NULL);
     580                return TCL_ERROR;
    390581            }           
    391582            strncpy(buf, line + 6, 5);
    392583            buf[5] = '\0';
    393             if (Tcl_GetInt(interp, buf, &serial) != TCL_OK) {
    394                 Tcl_AppendResult(interp, "bad serial number \"", buf,
    395                                 "\"", (char *)NULL);
     584            if (Tcl_GetInt(interp, buf, &serialNum) != TCL_OK) {
     585                Tcl_AppendResult(interp, "line ", Itoa(lineNum),
     586                        ": bad serial number \"", buf, "\"", (char *)NULL);
    396587                goto error;
    397588            }
    398             hPtr = Tcl_CreateHashEntry(&serialTable, (char *)serial, &isNew);
     589            lserial = (long)serialNum;
     590            hPtr = Tcl_CreateHashEntry(&atomTable, (char *)lserial, &isNew);
    399591            if (!isNew) {
    400                 Tcl_AppendResult(interp, "serial number \"", buf,
    401                                  "\" found more than once", (char *)NULL);
     592                Tcl_AppendResult(interp, "line ", Itoa(lineNum),
     593                        ": serial number \"", buf, "\" found more than once",
     594                        (char *)NULL);
    402595                goto error;
    403596            }
    404             Tcl_SetHashValue(hPtr, numAtoms);
    405             Tcl_ListObjAppendElement(interp, verticesObjPtr,
    406                                      Tcl_NewIntObj(1));
    407             Tcl_ListObjAppendElement(interp, verticesObjPtr,
    408                                      Tcl_NewIntObj(serial));
    409 
    410             strncpy(atomName, line + 12, 4);
    411             atomName[4] = '\0';
    412            
    413             strncpy(buf, line + 30, 8);
    414             buf[8] = '\0';
    415             if (Tcl_GetDouble(interp, buf, &x) != TCL_OK) {
    416                 Tcl_AppendResult(interp, "bad x-coordinate \"", buf,
    417                                  "\"", (char *)NULL);
     597            atomPtr = NewAtom(interp, nextOrdinal, line, lineLength);
     598            if (atomPtr == NULL) {
    418599                goto error;
    419600            }
    420             Tcl_ListObjAppendElement(interp, pointsObjPtr, Tcl_NewDoubleObj(x));
    421             strncpy(buf, line + 38, 8);
    422             buf[8] = '\0';
    423             if (Tcl_GetDouble(interp, buf, &y) != TCL_OK) {
    424                 Tcl_AppendResult(interp, "bad y-coordinate \"", buf,
    425                                  "\"", (char *)NULL);
     601            Tcl_SetHashValue(hPtr, atomPtr);
     602            Tcl_ListObjAppendElement(interp, pointsObjPtr,
     603                                     Tcl_NewDoubleObj(atomPtr->x));
     604            Tcl_ListObjAppendElement(interp, pointsObjPtr,
     605                                     Tcl_NewDoubleObj(atomPtr->y));
     606            Tcl_ListObjAppendElement(interp, pointsObjPtr,
     607                                     Tcl_NewDoubleObj(atomPtr->z));
     608            Tcl_ListObjAppendElement(interp, atomsObjPtr,
     609                                     Tcl_NewIntObj(atomPtr->number));
     610            nextOrdinal++;
     611        } else if ((c == 'C') && (strncmp(line, "CONECT", 6) == 0)) {
     612            PdbAtom *atom1Ptr;
     613            int i, n;
     614            char buf[200];
     615
     616            if ((bondFlags & BOND_CONECT) == 0) {
     617                continue;
     618            }
     619            strncpy(buf, line + 6, 5);
     620            buf[5] = '\0';
     621            if (lineLength < 11) {
     622                char *msg;
     623
     624                msg = (char *)line;
     625                msg[lineLength] = '\0';
     626                Tcl_AppendResult(interp, "line ", Itoa(lineNum),
     627                        ": bad CONECT record \"", msg, "\"",
     628                        (char *)NULL);
    426629                goto error;
    427630            }
    428             Tcl_ListObjAppendElement(interp, pointsObjPtr, Tcl_NewDoubleObj(y));
    429             strncpy(buf, line + 46, 8);
    430             buf[8] = '\0';
    431             if (Tcl_GetDouble(interp, buf, &z) != TCL_OK) {
    432                 Tcl_AppendResult(interp, "bad z-coordinate \"", buf,
    433                                  "\"", (char *)NULL);
     631            if (SerialToAtom(interp, &atomTable, buf, &atom1Ptr) != TCL_OK) {
    434632                goto error;
    435633            }
    436             Tcl_ListObjAppendElement(interp, pointsObjPtr, Tcl_NewDoubleObj(z));
    437             symbolName[0] = '\0';
    438             if (lineLength >= 78) {
    439                 symbolName[0] = line[76];
    440                 symbolName[1] = line[77];
    441                 symbolName[2] = '\0';
    442             }
    443             atom = VerifyElement(SkipSpaces(atomName), SkipSpaces(symbolName));
    444             if (atom < 0) {
    445                 Tcl_AppendResult(interp, "bad atom \"", atomName,
    446                         "\" or element \"", symbolName, "\"", (char *)NULL);
    447                 goto error;
    448             }
    449             Tcl_ListObjAppendElement(interp, atomsObjPtr, Tcl_NewIntObj(atom));
    450             numAtoms++;
    451         } else if ((c == 'C') && (strncmp(line, "CONECT", 6) == 0)) {
    452             numConnections++;
    453         }
     634            /* Allow basic maximum of 4 connections. */
     635            for (n = 11, i = 0; i < 4; i++, n += 5) {
     636                ConnectKey key;
     637                PdbAtom *atom2Ptr;
     638
     639                if (n >= lineLength) {
     640                    break;             
     641                }
     642                strncpy(buf, line + n, 5);
     643                buf[5] = '\0';
     644                if (IsSpaces(buf)) {
     645                    break;              /* No more entries */
     646                }
     647                if (SerialToAtom(interp, &atomTable, buf, &atom2Ptr) !=TCL_OK) {
     648                    goto error;
     649                }
     650                if (atom1Ptr->ordinal > atom2Ptr->ordinal) {
     651                    key.from = atom2Ptr->ordinal;
     652                    key.to = atom1Ptr->ordinal;
     653                } else {
     654                    key.from = atom1Ptr->ordinal;
     655                    key.to = atom2Ptr->ordinal;
     656                }
     657                Tcl_CreateHashEntry(&conectTable, (char *)&key, &isNew);
     658                if (isNew) {
     659                    atom1Ptr->numConnections++;
     660                    atom2Ptr->numConnections++;
     661                }
     662            }
     663        }
     664    }
     665    if (bondFlags & BOND_COMPUTE) {
     666        ComputeBonds(&atomTable, &conectTable);
    454667    }
    455668    objPtr = Tcl_NewStringObj("# vtk DataFile Version 2.0\n", -1);
    456     Tcl_AppendToObj(objPtr, "Converted from PDB file\n", -1);
     669    Tcl_AppendToObj(objPtr, "Converted from PDB format\n", -1);
    457670    Tcl_AppendToObj(objPtr, "ASCII\n", -1);
    458671    Tcl_AppendToObj(objPtr, "DATASET POLYDATA\n", -1);
    459     sprintf(mesg, "POINTS %d float\n", numAtoms);
     672    sprintf(mesg, "POINTS %d float\n", atomTable.numEntries);
    460673    Tcl_AppendToObj(objPtr, mesg, -1);
    461674    Tcl_AppendObjToObj(objPtr, pointsObjPtr);
     
    463676    Tcl_AppendToObj(objPtr, mesg, -1);
    464677
    465 #ifdef notdef
    466     if (numConnections > 0) {
    467         sprintf(mesg, "LINES %d %d\n", numConnections, numConnections * 3);
     678    if (conectTable.numEntries > 0) {
     679        sprintf(mesg, "LINES %d %d\n", conectTable.numEntries,
     680                conectTable.numEntries * 3);
    468681        Tcl_AppendToObj(objPtr, mesg, -1);
    469         for (hPtr = Tcl_FirstHashEntry(&connectTable, &iter); hPtr != NULL;
     682        for (hPtr = Tcl_FirstHashEntry(&conectTable, &iter); hPtr != NULL;
    470683             hPtr = Tcl_NextHashEntry(&iter)) {
    471             connectPtr = Tcl_GetHashEntry(hPtr);
    472             sprintf(mesg, "2 %d %d\n", connectPtr->from, connectPtr->to);
    473         }
    474     }
    475     Tcl_AppendObjToObj(objPtr, linesObjPtr);
    476     sprintf(mesg, "\n");
    477     Tcl_AppendToObj(objPtr, mesg, -1);
    478 #endif
    479    
    480     sprintf(mesg, "VERTICES %d %d\n", numAtoms, numAtoms * 2);
    481     Tcl_AppendToObj(objPtr, mesg, -1);
    482     for (i = 0; i < numAtoms; i++) {
    483         sprintf(mesg, " 1 %d\n", i);
     684            ConnectKey *keyPtr;
     685
     686            keyPtr = (ConnectKey *)Tcl_GetHashKey(&conectTable, hPtr);
     687            sprintf(mesg, "2 %d %d\n", keyPtr->from, keyPtr->to);
     688            Tcl_AppendToObj(objPtr, mesg, -1);
     689        }
     690        sprintf(mesg, "\n");
    484691        Tcl_AppendToObj(objPtr, mesg, -1);
    485692    }
    486     sprintf(mesg, "POINT_DATA %d\n", numAtoms);
     693    for (hPtr = Tcl_FirstHashEntry(&atomTable, &iter); hPtr != NULL;
     694         hPtr = Tcl_NextHashEntry(&iter)) {
     695        PdbAtom *atomPtr;
     696
     697        atomPtr = Tcl_GetHashValue(hPtr);
     698        fprintf(stderr, "%d %s %d connections\n", atomPtr->ordinal,
     699                elements[atomPtr->number].symbol, atomPtr->numConnections);
     700    }
     701    sprintf(mesg, "POINT_DATA %d\n", atomTable.numEntries);
    487702    Tcl_AppendToObj(objPtr, mesg, -1);
    488703    sprintf(mesg, "SCALARS element int\n");
     
    491706    Tcl_AppendToObj(objPtr, mesg, -1);
    492707    Tcl_AppendObjToObj(objPtr, atomsObjPtr);
    493     Tcl_DeleteHashTable(&serialTable);
     708    FreeAtoms(&atomTable);
     709    Tcl_DeleteHashTable(&conectTable);
    494710    Tcl_DecrRefCount(pointsObjPtr);
    495711    Tcl_DecrRefCount(atomsObjPtr);
    496     Tcl_DecrRefCount(verticesObjPtr);
    497712    if (objPtr != NULL) {
    498713        Tcl_SetObjResult(interp, objPtr);
     
    500715    return TCL_OK;
    501716 error:
    502     Tcl_DeleteHashTable(&serialTable);
     717    Tcl_DeleteHashTable(&conectTable);
     718    FreeAtoms(&atomTable);
    503719    Tcl_DecrRefCount(pointsObjPtr);
    504720    Tcl_DecrRefCount(atomsObjPtr);
    505     Tcl_DecrRefCount(verticesObjPtr);
    506721    return TCL_ERROR;
    507722}
  • branches/1.3/packages/vizservers/nanovis/Command.cpp

    r3630 r3877  
    5555#include "FlowCmd.h"
    5656#include "dxReader.h"
     57#ifdef USE_VTK
     58#include "VtkDataSetReader.h"
     59#endif
    5760#include "VtkReader.h"
    5861#include "BMPWriter.h"
     
    12731276    } else if ((nBytes > 14) && (strncmp(bytes, "# vtk DataFile", 14) == 0)) {
    12741277        TRACE("VTK loading...");
    1275         std::stringstream fdata;
    1276         fdata.write(bytes, nBytes);
    12771278        if (nBytes <= 0) {
    12781279            ERROR("data buffer is empty");
     
    12801281        }
    12811282        Rappture::Outcome context;
     1283#ifdef USE_VTK
     1284        volume = load_vtk_volume_stream(context, tag, bytes, nBytes);
     1285#else
     1286        std::stringstream fdata;
     1287        fdata.write(bytes, nBytes);
    12821288        volume = load_vtk_volume_stream(context, tag, fdata);
     1289#endif
    12831290        if (volume == NULL) {
    12841291            Tcl_AppendResult(interp, context.remark(), (char*)NULL);
     
    12921299        }
    12931300        TRACE("DX loading...");
    1294         std::stringstream fdata;
    1295         fdata.write(bytes, nBytes);
    12961301        if (nBytes <= 0) {
    12971302            ERROR("data buffer is empty");
    12981303            abort();
    12991304        }
     1305        std::stringstream fdata;
     1306        fdata.write(bytes, nBytes);
    13001307        Rappture::Outcome context;
    13011308        volume = load_dx_volume_stream(context, tag, fdata);
  • branches/1.3/packages/vizservers/nanovis/Makefile.in

    r3630 r3877  
    33USE_POINTSET_RENDERER   = #yes
    44USE_PARTICLE_SYSTEM     = #yes
     5USE_VTK                 = yes
    56
    67SHELL = /bin/sh
     
    5354VRMATH_LIB_SPEC = $(VRMATH_LIB)
    5455
     56VTK_LIB_DIR     = @VTK_LIB_DIR@
     57VTK_INC_SPEC    = @VTK_INC_SPEC@
     58VTK_LIB_SPEC    = \
     59                -lvtkIOCore-6.0 \
     60                -lvtkIOLegacy-6.0 \
     61                -lvtkFiltersCore-6.0 \
     62                -lvtkImagingHybrid-6.0 \
     63                -lvtkImagingCore-6.0 \
     64                -lvtkCommonCore-6.0 \
     65                -lvtkCommonDataModel-6.0 \
     66                -lvtkCommonExecutionModel-6.0  \
     67                -lvtkCommonMisc-6.0  \
     68                -lvtkCommonSystem-6.0 \
     69                -lvtkCommonTransforms-6.0 \
     70                -lvtkCommonMath-6.0
     71
    5572EXTRA_LIBS      = -lm -lpthread
    5673RP_DIR          =  @RP_DIR@
     
    7390                $(UTIL_LIB_SPEC) \
    7491                $(VRMATH_LIB_SPEC) \
     92                $(VTK_LIB_SPEC) \
    7593                $(TCL_LIB_SPEC) \
    7694                $(CG_LIB_SPEC) \
     
    85103                $(MAT_INC_SPEC) \
    86104                $(VRMATH_INC_SPEC) \
     105                $(VTK_INC_SPEC) \
    87106                $(TCL_INC_SPEC) \
    88107                $(CG_INC_SPEC) \
     
    103122ifdef USE_POINTSET_RENDERER
    104123DEFINES         += -DUSE_POINTSET_RENDERER
     124endif
     125ifdef USE_VTK
     126DEFINES         += -DUSE_VTK
    105127endif
    106128CXX_SWITCHES    = $(CFLAGS) $(EXTRA_CFLAGS) $(DEFINES) $(INCLUDES)
     
    204226endif
    205227
     228ifdef USE_VTK
     229OBJS +=         DataSetResample.o \
     230                VtkDataSetReader.o
     231endif
     232
    206233.PHONY: all install install-resources install-shaders install-nanovis docs clean-docs clean distclean graphics imgloaders newmat11 util vrmath
    207234
     
    287314ContourLineFilter.o: ContourLineFilter.cpp ContourLineFilter.h
    288315ConvexPolygon.o: ConvexPolygon.cpp ConvexPolygon.h $(VRMATH_DIR)/include/vrmath/Vector4f.h $(VRMATH_DIR)/include/vrmath/Matrix4x4d.h Plane.h
     316DataSetResample.o: DataSetResample.cpp DataSetResample.h
    289317Flow.o: Flow.cpp Flow.h FlowCmd.h FlowTypes.h FlowBox.h FlowParticles.h LIC.h VelocityArrowsSlice.h Switch.h Unirect.h Volume.h TransferFunction.h Trace.h
    290318FlowBox.o: FlowBox.cpp FlowBox.h FlowTypes.h Switch.h Trace.h Volume.h $(VRMATH_DIR)/include/vrmath/Vector3f.h $(VRMATH_DIR)/include/vrmath/Vector4f.h $(VRMATH_DIR)/include/vrmath/Matrix4x4d.h
     
    293321GradientFilter.o: GradientFilter.cpp GradientFilter.h
    294322Grid.o: Grid.cpp Grid.h Axis.h Chain.h $(UTIL_DIR)/Fonts.h $(VRMATH_DIR)/include/vrmath/Color4f.h $(VRMATH_DIR)/include/vrmath/Vector4f.h
    295 HeightMap.o: HeightMap.cpp HeightMap.h
    296 LIC.o: LIC.cpp LIC.h
     323HeightMap.o: HeightMap.cpp HeightMap.h Shader.h
     324LIC.o: LIC.cpp LIC.h Shader.h
    297325OrientationIndicator.o: OrientationIndicator.cpp OrientationIndicator.h
    298326ParticleAdvectionShader.o: ParticleAdvectionShader.cpp ParticleAdvectionShader.h Shader.h
     
    312340RegularVolumeShader.o: RegularVolumeShader.cpp RegularVolumeShader.h VolumeShader.h Shader.h
    313341RenderVertexArray.o: RenderVertexArray.cpp RenderVertexArray.h
    314 Shader.o: Shader.cpp Shader.h
     342Shader.o: Shader.cpp Shader.h config.h
    315343ShaderGL.o: ShaderGL.cpp ShaderGL.h
    316344StdVertexShader.o: StdVertexShader.cpp StdVertexShader.h Shader.h
     
    327355VolumeRenderer.o: VolumeRenderer.cpp VolumeRenderer.h ConvexPolygon.h Volume.h nanovis.h Trace.h Plane.h StdVertexShader.h Shader.h
    328356VolumeShader.o: VolumeShader.cpp VolumeShader.h Shader.h
    329 VtkReader.o: VtkReader.h Trace.h Volume.h $(VRMATH_DIR)/include/vrmath/Vector3f.h ReaderCommon.h nanovis.h
     357VtkDataSetReader.o: VtkDataSetReader.cpp VtkDataSetReader.h DataSetResample.h $(VRMATH_DIR)/include/vrmath/Vector3f.h ReaderCommon.h Trace.h Volume.h nanovis.h config.h
     358VtkReader.o: VtkReader.h Trace.h Volume.h $(VRMATH_DIR)/include/vrmath/Vector3f.h ReaderCommon.h nanovis.h config.h
    330359ZincBlendeReconstructor.o: ZincBlendeReconstructor.cpp ZincBlendeReconstructor.h ZincBlendeVolume.h Volume.h $(VRMATH_DIR)/include/vrmath/Vector3f.h
    331360ZincBlendeVolume.o: ZincBlendeVolume.cpp ZincBlendeVolume.h config.h define.h
  • branches/1.3/packages/vizservers/nanovis/Shader.cpp

    r3630 r3877  
    1212#include <util/FilePath.h>
    1313
     14#include "config.h"
    1415#include "Shader.h"
    1516#include "Trace.h"
     
    1819using namespace nv::util;
    1920
     21/**
     22 * These correspond to NV_vertex_program3 and NV_fragment_program2:
     23 * CG_PROFILE_VP40
     24 * CG_PROFILE_FP40
     25 *
     26 * These correspond to ARB_vertex_program and ARB_fragment_program:
     27 * CG_PROFILE_ARBVP1
     28 * CG_PROFILE_ARBFP1
     29 *
     30 * Generic GLSL targets:
     31 * CG_PROFILE_GLSLV
     32 * CG_PROFILE_GLSLF
     33 */
     34#ifdef USE_ARB_PROGRAMS
     35CGprofile Shader::_defaultVertexProfile = CG_PROFILE_ARBVP1;
     36CGprofile Shader::_defaultFragmentProfile = CG_PROFILE_ARBFP1;
     37#else
    2038CGprofile Shader::_defaultVertexProfile = CG_PROFILE_VP40;
    2139CGprofile Shader::_defaultFragmentProfile = CG_PROFILE_FP40;
     40#endif
    2241CGcontext Shader::_cgContext = NULL;
    2342
  • branches/1.3/packages/vizservers/nanovis/Shader.h

    r3630 r3877  
    4949    void loadFragmentProgram(const char *fileName);
    5050
     51    bool isVertexProgramLoaded()
     52    {
     53        return (getVP() == NULL);
     54    }
     55
     56    bool isFragmentProgramLoaded()
     57    {
     58        return (getFP() == NULL);
     59    }
     60
    5161    void setVPParameter1f(const char *name, float val)
    5262    {
     
    284294    void resetPrograms();
    285295
    286 
    287296    CGprogram getVP()
    288297    {
  • branches/1.3/packages/vizservers/nanovis/VelocityArrowsSlice.cpp

    r3630 r3877  
    6565    _queryVelocityFP.loadFragmentProgram("queryvelocity.cg");
    6666
    67     _particleShader.loadVertexProgram("velocityslicevp.cg");
    68     _particleShader.loadFragmentProgram("velocityslicefp.cg");
     67    // Delay loading of shaders only required for glyph style rendering
     68    if (_renderMode == GLYPHS) {
     69        _particleShader.loadVertexProgram("velocityslicevp.cg");
     70        _particleShader.loadFragmentProgram("velocityslicefp.cg");
     71    }
    6972
    7073    createRenderTarget();
     
    362365                    continue;
    363366                }
    364                 if (length > 1.0e-6) {
     367                if (length > 0.0) {
    365368                    Vector3f vnorm = vel.normalize();
    366369                    Vector3f rotationAxis = refVec.cross(vnorm);
     
    414417        glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
    415418
     419        // FIXME: This vertex shader won't compile with ARB_vertex_program,
     420        // so it should use GLSL
     421        if (!_particleShader.isVertexProgramLoaded()) {
     422            _particleShader.loadVertexProgram("velocityslicevp.cg");
     423        }
     424        if (!_particleShader.isFragmentProgramLoaded()) {
     425            _particleShader.loadFragmentProgram("velocityslicefp.cg");
     426        }
     427
    416428        _particleShader.bind();
    417429        _particleShader.setVPTextureParameter("vfield", _vectorFieldGraphicsID);
     
    458470    Vector3f bmin, bmax;
    459471    volume->getBounds(bmin, bmax);
    460     _origin = bmin;
     472    _origin.set(bmin.x, bmin.y, bmin.z);
    461473    _scale.set(bmax.x-bmin.x, bmax.y-bmin.y, bmax.z-bmin.z);
    462474
  • branches/1.3/packages/vizservers/nanovis/VtkReader.cpp

    r3630 r3877  
    1616#include "ReaderCommon.h"
    1717
     18#include "config.h"
    1819#include "nanovis.h"
    1920#include "VtkReader.h"
  • branches/1.3/packages/vizservers/nanovis/config.h

    r3599 r3877  
    3838
    3939/*
     40 * If defined, use ARB_vertex_program and ARB_fragment_program as Cg
     41 * profile target, otherwise NV_vertex_program3 and NV_fragment_program2
     42 * are required
     43 */
     44//#define USE_ARB_PROGRAMS
     45
     46/*
    4047 * Keep statistics
    4148 */
  • branches/1.3/packages/vizservers/nanovis/dxReader.cpp

    r3630 r3877  
    211211    }
    212212
    213     TRACE("found nx=%d ny=%d nxy=%d nz=%d\ndx=%f dy=%f dz=%f\nx0=%f y0=%f z0=%f",
     213    TRACE("found nx=%d ny=%d nxy=%d nz=%d\ndx=%g dy=%g dz=%g\nx0=%g y0=%g z0=%g",
    214214          nx, ny, nxy, nz, dx, dy, dz, x0, y0, z0);
    215215
  • branches/1.3/packages/vizservers/nanovis/nanovis.cpp

    r3630 r3877  
    504504    }
    505505#endif
    506     // FIXME: should use ARB programs or (preferably) a GLSL profile for portability
     506    // FIXME: should use GLSL for portability
     507#ifdef USE_ARB_PROGRAMS
     508    if (!GLEW_ARB_vertex_program ||
     509        !GLEW_ARB_fragment_program) {
     510        ERROR("ARB_vertex_program and ARB_fragment_program extensions are required");
     511        return false;
     512    }
     513#else
    507514    if (!GLEW_NV_vertex_program3 ||
    508515        !GLEW_NV_fragment_program2) {
     
    510517        return false;
    511518    }
     519#endif
    512520
    513521    if (!FilePath::getInstance()->setPath(path)) {
  • branches/1.3/packages/vizservers/nanovis/vrmath/include/vrmath/Vector2f.h

    r3628 r3877  
    4040    void set(const Vector2f& v);
    4141
    42     float dot() const;
     42    double dot() const;
    4343
    4444    double length() const;
     
    6767}
    6868
    69 inline float Vector2f::dot() const
     69inline double Vector2f::dot() const
    7070{
    7171    return (x * x + y * y);
  • branches/1.3/packages/vizservers/nanovis/vrmath/include/vrmath/Vector3f.h

    r3628 r3877  
    5858    Vector3f scale(const Vector3f& scale) const;
    5959
    60     Vector3f scale(float scale) const;
     60    Vector3f scale(double scale) const;
    6161
    6262    bool operator==(const Vector3f& v) const;
     
    6767
    6868    // scalar ops
    69     Vector3f operator+(float scalar) const;
    70     Vector3f operator-(float scalar) const;
    71     Vector3f operator*(float scalar) const;
    72     Vector3f operator/(float scalar) const;
    73     Vector3f& operator*=(float scalar);
     69    Vector3f operator+(double scalar) const;
     70    Vector3f operator-(double scalar) const;
     71    Vector3f operator*(double scalar) const;
     72    Vector3f operator/(double scalar) const;
     73    Vector3f& operator*=(double scalar);
    7474
    7575    // vector ops
     
    113113}
    114114
    115 inline Vector3f Vector3f::operator+(float scalar) const
     115inline Vector3f Vector3f::operator+(double scalar) const
    116116{
    117117    return Vector3f(x + scalar, y + scalar, z + scalar);
    118118}
    119119
    120 inline Vector3f Vector3f::operator-(float scalar) const
     120inline Vector3f Vector3f::operator-(double scalar) const
    121121{
    122122    return Vector3f(x - scalar, y - scalar, z - scalar);
    123123}
    124124
    125 inline Vector3f Vector3f::operator*(float scalar) const
     125inline Vector3f Vector3f::operator*(double scalar) const
    126126{
    127127    return Vector3f(x * scalar, y * scalar, z * scalar);
    128128}
    129129
    130 inline Vector3f Vector3f::operator/(float scalar) const
     130inline Vector3f Vector3f::operator/(double scalar) const
    131131{
    132132    return Vector3f(x / scalar, y / scalar, z / scalar);
    133133}
    134134
    135 inline Vector3f& Vector3f::operator*=(float scalar)
     135inline Vector3f& Vector3f::operator*=(double scalar)
    136136{
    137137    x *= scalar;
     
    168168
    169169#if 0
    170 inline Vector3f operator*(float scale, const Vector3f& value)
     170inline Vector3f operator*(double scale, const Vector3f& value)
    171171{
    172172    return Vector3f(value.x * scale, value.y * scale, value.z * scale);
     
    231231inline Vector3f Vector3f::normalize() const
    232232{
    233     float len = length();
    234     if (len > 1.0e-6) {
     233    double len = length();
     234    if (len > 0.0) {
    235235        return Vector3f(x / len, y / len, z / len);
    236236    } else {
     
    239239}
    240240
    241 inline Vector3f Vector3f::scale(float scale) const
     241inline Vector3f Vector3f::scale(double scale) const
    242242{
    243243    return Vector3f(x * scale, y * scale, z * scale);
  • branches/1.3/packages/vizservers/nanovis/vrmath/include/vrmath/Vector4f.h

    r3628 r3877  
    6666    }
    6767
    68     Vector4f operator*(float op2) const
     68    Vector4f operator*(double op2) const
    6969    {
    7070        return Vector4f(x * op2, y * op2, z * op2, w * op2);
    7171    }
    7272
    73     Vector4f operator/(float op2) const
     73    Vector4f operator/(double op2) const
    7474    {
    7575        return Vector4f(x / op2, y / op2, z / op2, w / op2);
     
    7878    void divideByW();
    7979
    80     float dot(const Vector4f& vec) const;
     80    double dot(const Vector4f& vec) const;
    8181
    8282    union {
     
    122122}
    123123
    124 inline float Vector4f::dot(const Vector4f& v) const
     124inline double Vector4f::dot(const Vector4f& v) const
    125125{
    126     return (x * v.x + y * v.y + z * v.z + w * v.w);
     126    return ((double)x * v.x + (double)y * v.y + (double)z * v.z + (double)w * v.w);
    127127}
    128128
  • branches/1.3/packages/vizservers/vtkvis/DataSet.cpp

    r3844 r3877  
    164164        return false;
    165165
    166     if (vtkUnstructuredGrid::SafeDownCast(_dataSet) != NULL) {
     166    if (vtkUnstructuredGrid::SafeDownCast(_dataSet) != NULL && !isCloud()) {
    167167        vtkSmartPointer<vtkExtractUnstructuredGrid> filter = vtkSmartPointer<vtkExtractUnstructuredGrid>::New();
    168168#ifdef USE_VTK6
  • branches/1.3/packages/vizservers/vtkvis/Makefile.in

    r3863 r3877  
    147147                Molecule.cpp \
    148148                Outline.cpp \
     149                Parallelepiped.cpp \
    149150                PolyData.cpp \
    150151                Polygon.cpp \
     
    230231Molecule.o: Molecule.h MoleculeData.h GraphicsObject.h DataSet.h Renderer.h ColorMap.h Trace.h
    231232Outline.o: Outline.h GraphicsObject.h DataSet.h Trace.h
     233Parallelepiped.o: Parallelepiped.h Shape.h GraphicsObject.h DataSet.h Renderer.h Trace.h
    232234PolyData.o: PolyData.h GraphicsObject.h DataSet.h Renderer.h Trace.h
    233235Polygon.o: Polygon.h Shape.h GraphicsObject.h DataSet.h Renderer.h Trace.h
     
    235237PseudoColor.o: PseudoColor.h GraphicsObject.h DataSet.h Renderer.h ColorMap.h Trace.h
    236238ReadBuffer.o: ReadBuffer.h Trace.h
    237 Renderer.o: Renderer.h RendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h Math.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h Trace.h
    238 RendererCmd.o: Renderer.h RendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h ReadBuffer.h ResponseQueue.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
    239 RendererGraphicsObjs.o: Renderer.h RendererGraphicsObjs.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h Trace.h
     239Renderer.o: Renderer.h RendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h Math.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h Parallelepiped.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h Trace.h
     240RendererCmd.o: Renderer.h RendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h Parallelepiped.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h ReadBuffer.h ResponseQueue.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
     241RendererGraphicsObjs.o: Renderer.h RendererGraphicsObjs.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h Parallelepiped.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h Trace.h
    240242RenderServer.o: RenderServer.h RendererCmd.h Renderer.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h ReadBuffer.h ResponseQueue.h Trace.h PPMWriter.h TGAWriter.h
    241243ResponseQueue.o: ResponseQueue.h Trace.h
  • branches/1.3/packages/vizservers/vtkvis/RenderServer.h

    r3844 r3877  
    1616class Renderer;
    1717
    18 #define VTKVIS_VERSION_STRING "1.5"
     18#define VTKVIS_VERSION_STRING "1.6"
    1919
    2020#define MSECS_ELAPSED(t1, t2) \
  • branches/1.3/packages/vizservers/vtkvis/Renderer.cpp

    r3844 r3877  
    197197    deleteAllGraphicsObjects<Molecule>();
    198198    deleteAllGraphicsObjects<Outline>();
     199    deleteAllGraphicsObjects<Parallelepiped>();
    199200    deleteAllGraphicsObjects<PolyData>();
    200201    deleteAllGraphicsObjects<Polygon>();
     
    24362437    setGraphicsObjectAspect<Molecule>(aspectRatio);
    24372438    setGraphicsObjectAspect<Outline>(aspectRatio);
     2439    setGraphicsObjectAspect<Parallelepiped>(aspectRatio);
    24382440    setGraphicsObjectAspect<PolyData>(aspectRatio);
    24392441    setGraphicsObjectAspect<Polygon>(aspectRatio);
     
    33573359    mergeGraphicsObjectBounds<Molecule>(bounds, onlyVisible);
    33583360    mergeGraphicsObjectBounds<Outline>(bounds, onlyVisible);
     3361    mergeGraphicsObjectBounds<Parallelepiped>(bounds, onlyVisible);
    33593362    mergeGraphicsObjectBounds<PolyData>(bounds, onlyVisible);
    33603363    mergeGraphicsObjectBounds<Polygon>(bounds, onlyVisible);
     
    34293432    mergeGraphicsObjectUnscaledBounds<Outline>(bounds, onlyVisible);
    34303433    mergeGraphicsObjectUnscaledBounds<PolyData>(bounds, onlyVisible);
     3434    mergeGraphicsObjectUnscaledBounds<Parallelepiped>(bounds, onlyVisible);
    34313435    mergeGraphicsObjectUnscaledBounds<Polygon>(bounds, onlyVisible);
    34323436    mergeGraphicsObjectUnscaledBounds<PseudoColor>(bounds, onlyVisible);
     
    45774581    setGraphicsObjectClippingPlanes<Molecule>(_activeClipPlanes);
    45784582    setGraphicsObjectClippingPlanes<Outline>(_activeClipPlanes);
     4583    setGraphicsObjectClippingPlanes<Parallelepiped>(_activeClipPlanes);
    45794584    setGraphicsObjectClippingPlanes<PolyData>(_activeClipPlanes);
    45804585    setGraphicsObjectClippingPlanes<Polygon>(_activeClipPlanes);
  • branches/1.3/packages/vizservers/vtkvis/Renderer.h

    r3844 r3877  
    4545#include "Molecule.h"
    4646#include "Outline.h"
     47#include "Parallelepiped.h"
    4748#include "PolyData.h"
    4849#include "Polygon.h"
     
    809810                              const char *name, double range[2] = NULL);
    810811
    811     // N-sided Regular Polygons
    812 
    813     bool addPolygon(const DataSetId& id, int numSides, double center[3], double normal[3], double radius);
     812    // Parallelepipeds
     813
     814    bool addParallelepiped(const DataSetId& id, double vec1[3], double vec2[3], double vec3[3],
     815                           bool flipNormals = false);
    814816
    815817    // PolyData meshes
     
    826828                              DataSet::DataAttributeType type,
    827829                              const char *name, double range[2] = NULL);
     830
     831    // N-sided Regular Polygons
     832
     833    bool addPolygon(const DataSetId& id, int numSides, double center[3], double normal[3], double radius);
    828834
    829835    // Color-mapped surfaces
     
    975981    typedef std::tr1::unordered_map<DataSetId, Molecule *> MoleculeHashmap;
    976982    typedef std::tr1::unordered_map<DataSetId, Outline *> OutlineHashmap;
     983    typedef std::tr1::unordered_map<DataSetId, Parallelepiped *> ParallelepipedHashmap;
    977984    typedef std::tr1::unordered_map<DataSetId, PolyData *> PolyDataHashmap;
    978985    typedef std::tr1::unordered_map<DataSetId, Polygon *> PolygonHashmap;
     
    11141121    MoleculeHashmap _molecules;
    11151122    OutlineHashmap _outlines;
     1123    ParallelepipedHashmap _parallelepipeds;
    11161124    PolyDataHashmap _polyDatas;
    11171125    PolygonHashmap _polygons;
  • branches/1.3/packages/vizservers/vtkvis/RendererCmd.cpp

    r3844 r3877  
    85598559
    85608560static int
     8561ParallelepipedAddOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8562                    Tcl_Obj *const *objv)
     8563{
     8564    double vec1[3], vec2[3], vec3[3];
     8565    if (Tcl_GetDoubleFromObj(interp, objv[2], &vec1[0]) != TCL_OK ||
     8566        Tcl_GetDoubleFromObj(interp, objv[3], &vec1[1]) != TCL_OK ||
     8567        Tcl_GetDoubleFromObj(interp, objv[4], &vec1[2]) != TCL_OK ||
     8568        Tcl_GetDoubleFromObj(interp, objv[5], &vec2[0]) != TCL_OK ||
     8569        Tcl_GetDoubleFromObj(interp, objv[6], &vec2[1]) != TCL_OK ||
     8570        Tcl_GetDoubleFromObj(interp, objv[7], &vec2[2]) != TCL_OK ||
     8571        Tcl_GetDoubleFromObj(interp, objv[8], &vec3[0]) != TCL_OK ||
     8572        Tcl_GetDoubleFromObj(interp, objv[9], &vec3[1]) != TCL_OK ||
     8573        Tcl_GetDoubleFromObj(interp, objv[10], &vec3[2]) != TCL_OK) {
     8574        return TCL_ERROR;
     8575    }
     8576    const char *name = Tcl_GetString(objv[11]);
     8577    if (!g_renderer->addParallelepiped(name, vec1, vec2, vec3)) {
     8578        Tcl_AppendResult(interp, "Failed to create parallelepiped", (char*)NULL);
     8579        return TCL_ERROR;
     8580    }
     8581    return TCL_OK;
     8582}
     8583
     8584static int
     8585ParallelepipedDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8586                       Tcl_Obj *const *objv)
     8587{
     8588    if (objc == 3) {
     8589        const char *name = Tcl_GetString(objv[2]);
     8590        g_renderer->deleteGraphicsObject<Parallelepiped>(name);
     8591    } else {
     8592        g_renderer->deleteGraphicsObject<Parallelepiped>("all");
     8593    }
     8594    return TCL_OK;
     8595}
     8596
     8597static int
     8598ParallelepipedColorOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8599                      Tcl_Obj *const *objv)
     8600{
     8601    float color[3];
     8602    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
     8603        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
     8604        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
     8605        return TCL_ERROR;
     8606    }
     8607    if (objc == 6) {
     8608        const char *name = Tcl_GetString(objv[5]);
     8609        g_renderer->setGraphicsObjectColor<Parallelepiped>(name, color);
     8610    } else {
     8611        g_renderer->setGraphicsObjectColor<Parallelepiped>("all", color);
     8612    }
     8613    return TCL_OK;
     8614}
     8615
     8616static int
     8617ParallelepipedCullingOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8618                        Tcl_Obj *const *objv)
     8619{
     8620    bool state;
     8621    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     8622        return TCL_ERROR;
     8623    }
     8624    if (objc == 4) {
     8625        const char *name = Tcl_GetString(objv[3]);
     8626        g_renderer->setGraphicsObjectCulling<Parallelepiped>(name, state);
     8627    } else {
     8628        g_renderer->setGraphicsObjectCulling<Parallelepiped>("all", state);
     8629    }
     8630    return TCL_OK;
     8631}
     8632
     8633static int
     8634ParallelepipedEdgeVisibilityOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8635                               Tcl_Obj *const *objv)
     8636{
     8637    bool state;
     8638    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     8639        return TCL_ERROR;
     8640    }
     8641    if (objc == 4) {
     8642        const char *name = Tcl_GetString(objv[3]);
     8643        g_renderer->setGraphicsObjectEdgeVisibility<Parallelepiped>(name, state);
     8644    } else {
     8645        g_renderer->setGraphicsObjectEdgeVisibility<Parallelepiped>("all", state);
     8646    }
     8647    return TCL_OK;
     8648}
     8649
     8650static int
     8651ParallelepipedFlipNormalsOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8652                            Tcl_Obj *const *objv)
     8653{
     8654    bool state;
     8655    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     8656        return TCL_ERROR;
     8657    }
     8658    if (objc == 4) {
     8659        const char *name = Tcl_GetString(objv[3]);
     8660        g_renderer->setGraphicsObjectFlipNormals<Parallelepiped>(name, state);
     8661    } else {
     8662        g_renderer->setGraphicsObjectFlipNormals<Parallelepiped>("all", state);
     8663    }
     8664    return TCL_OK;
     8665}
     8666
     8667static int
     8668ParallelepipedLightingOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8669                         Tcl_Obj *const *objv)
     8670{
     8671    bool state;
     8672    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     8673        return TCL_ERROR;
     8674    }
     8675    if (objc == 4) {
     8676        const char *name = Tcl_GetString(objv[3]);
     8677        g_renderer->setGraphicsObjectLighting<Parallelepiped>(name, state);
     8678    } else {
     8679        g_renderer->setGraphicsObjectLighting<Parallelepiped>("all", state);
     8680    }
     8681    return TCL_OK;
     8682}
     8683
     8684static int
     8685ParallelepipedLineColorOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8686                          Tcl_Obj *const *objv)
     8687{
     8688    float color[3];
     8689    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
     8690        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
     8691        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
     8692        return TCL_ERROR;
     8693    }
     8694    if (objc == 6) {
     8695        const char *name = Tcl_GetString(objv[5]);
     8696        g_renderer->setGraphicsObjectEdgeColor<Parallelepiped>(name, color);
     8697    } else {
     8698        g_renderer->setGraphicsObjectEdgeColor<Parallelepiped>("all", color);
     8699    }
     8700    return TCL_OK;
     8701}
     8702
     8703static int
     8704ParallelepipedLineWidthOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8705                          Tcl_Obj *const *objv)
     8706{
     8707    float width;
     8708    if (GetFloatFromObj(interp, objv[2], &width) != TCL_OK) {
     8709        return TCL_ERROR;
     8710    }
     8711    if (objc == 4) {
     8712        const char *name = Tcl_GetString(objv[3]);
     8713        g_renderer->setGraphicsObjectEdgeWidth<Parallelepiped>(name, width);
     8714    } else {
     8715        g_renderer->setGraphicsObjectEdgeWidth<Parallelepiped>("all", width);
     8716    }
     8717    return TCL_OK;
     8718}
     8719
     8720static int
     8721ParallelepipedMaterialOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8722                         Tcl_Obj *const *objv)
     8723{
     8724    double ambient, diffuse, specCoeff, specPower;
     8725    if (Tcl_GetDoubleFromObj(interp, objv[2], &ambient) != TCL_OK ||
     8726        Tcl_GetDoubleFromObj(interp, objv[3], &diffuse) != TCL_OK ||
     8727        Tcl_GetDoubleFromObj(interp, objv[4], &specCoeff) != TCL_OK ||
     8728        Tcl_GetDoubleFromObj(interp, objv[5], &specPower) != TCL_OK) {
     8729        return TCL_ERROR;
     8730    }
     8731
     8732    if (objc == 7) {
     8733        const char *name = Tcl_GetString(objv[6]);
     8734        g_renderer->setGraphicsObjectAmbient<Parallelepiped>(name, ambient);
     8735        g_renderer->setGraphicsObjectDiffuse<Parallelepiped>(name, diffuse);
     8736        g_renderer->setGraphicsObjectSpecular<Parallelepiped>(name, specCoeff, specPower);
     8737    } else {
     8738        g_renderer->setGraphicsObjectAmbient<Parallelepiped>("all", ambient);
     8739        g_renderer->setGraphicsObjectDiffuse<Parallelepiped>("all", diffuse);
     8740        g_renderer->setGraphicsObjectSpecular<Parallelepiped>("all", specCoeff, specPower);
     8741    }
     8742    return TCL_OK;
     8743}
     8744
     8745static int
     8746ParallelepipedOpacityOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8747                        Tcl_Obj *const *objv)
     8748{
     8749    double opacity;
     8750    if (Tcl_GetDoubleFromObj(interp, objv[2], &opacity) != TCL_OK) {
     8751        return TCL_ERROR;
     8752    }
     8753    if (objc == 4) {
     8754        const char *name = Tcl_GetString(objv[3]);
     8755        g_renderer->setGraphicsObjectOpacity<Parallelepiped>(name, opacity);
     8756    } else {
     8757        g_renderer->setGraphicsObjectOpacity<Parallelepiped>("all", opacity);
     8758    }
     8759    return TCL_OK;
     8760}
     8761
     8762static int
     8763ParallelepipedOrientOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8764                       Tcl_Obj *const *objv)
     8765{
     8766    double quat[4];
     8767    if (Tcl_GetDoubleFromObj(interp, objv[2], &quat[0]) != TCL_OK ||
     8768        Tcl_GetDoubleFromObj(interp, objv[3], &quat[1]) != TCL_OK ||
     8769        Tcl_GetDoubleFromObj(interp, objv[4], &quat[2]) != TCL_OK ||
     8770        Tcl_GetDoubleFromObj(interp, objv[5], &quat[3]) != TCL_OK) {
     8771        return TCL_ERROR;
     8772    }
     8773    if (objc == 7) {
     8774        const char *name = Tcl_GetString(objv[6]);
     8775        g_renderer->setGraphicsObjectOrientation<Parallelepiped>(name, quat);
     8776    } else {
     8777        g_renderer->setGraphicsObjectOrientation<Parallelepiped>("all", quat);
     8778    }
     8779    return TCL_OK;
     8780}
     8781
     8782static int
     8783ParallelepipedOriginOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8784                       Tcl_Obj *const *objv)
     8785{
     8786    double origin[3];
     8787    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
     8788        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
     8789        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
     8790        return TCL_ERROR;
     8791    }
     8792    if (objc == 6) {
     8793        const char *name = Tcl_GetString(objv[5]);
     8794        g_renderer->setGraphicsObjectOrigin<Parallelepiped>(name, origin);
     8795    } else {
     8796        g_renderer->setGraphicsObjectOrigin<Parallelepiped>("all", origin);
     8797    }
     8798    return TCL_OK;
     8799}
     8800
     8801static int
     8802ParallelepipedPositionOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8803                         Tcl_Obj *const *objv)
     8804{
     8805    double pos[3];
     8806    if (Tcl_GetDoubleFromObj(interp, objv[2], &pos[0]) != TCL_OK ||
     8807        Tcl_GetDoubleFromObj(interp, objv[3], &pos[1]) != TCL_OK ||
     8808        Tcl_GetDoubleFromObj(interp, objv[4], &pos[2]) != TCL_OK) {
     8809        return TCL_ERROR;
     8810    }
     8811    if (objc == 6) {
     8812        const char *name = Tcl_GetString(objv[5]);
     8813        g_renderer->setGraphicsObjectPosition<Parallelepiped>(name, pos);
     8814    } else {
     8815        g_renderer->setGraphicsObjectPosition<Parallelepiped>("all", pos);
     8816    }
     8817    return TCL_OK;
     8818}
     8819
     8820static int
     8821ParallelepipedScaleOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8822                      Tcl_Obj *const *objv)
     8823{
     8824    double scale[3];
     8825    if (Tcl_GetDoubleFromObj(interp, objv[2], &scale[0]) != TCL_OK ||
     8826        Tcl_GetDoubleFromObj(interp, objv[3], &scale[1]) != TCL_OK ||
     8827        Tcl_GetDoubleFromObj(interp, objv[4], &scale[2]) != TCL_OK) {
     8828        return TCL_ERROR;
     8829    }
     8830    if (objc == 6) {
     8831        const char *name = Tcl_GetString(objv[5]);
     8832        g_renderer->setGraphicsObjectScale<Parallelepiped>(name, scale);
     8833    } else {
     8834        g_renderer->setGraphicsObjectScale<Parallelepiped>("all", scale);
     8835    }
     8836    return TCL_OK;
     8837}
     8838
     8839static int
     8840ParallelepipedShadingOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8841                        Tcl_Obj *const *objv)
     8842{
     8843    GraphicsObject::ShadingModel shadeModel;
     8844    const char *str = Tcl_GetString(objv[2]);
     8845    if (str[0] == 'f' && strcmp(str, "flat") == 0) {
     8846        shadeModel = GraphicsObject::SHADE_FLAT;
     8847    } else if (str[0] == 's' && strcmp(str, "smooth") == 0) {
     8848        shadeModel = GraphicsObject::SHADE_GOURAUD;
     8849    } else {
     8850         Tcl_AppendResult(interp, "bad shading option \"", str,
     8851                         "\": should be one of: 'flat', 'smooth'", (char*)NULL);
     8852        return TCL_ERROR;
     8853    }
     8854    if (objc == 4) {
     8855        const char *name = Tcl_GetString(objv[3]);
     8856        g_renderer->setGraphicsObjectShadingModel<Parallelepiped>(name, shadeModel);
     8857    } else {
     8858        g_renderer->setGraphicsObjectShadingModel<Parallelepiped>("all", shadeModel);
     8859    }
     8860    return TCL_OK;
     8861}
     8862
     8863static int
     8864ParallelepipedVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8865                        Tcl_Obj *const *objv)
     8866{
     8867    bool state;
     8868    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     8869        return TCL_ERROR;
     8870    }
     8871    if (objc == 4) {
     8872        const char *name = Tcl_GetString(objv[3]);
     8873        g_renderer->setGraphicsObjectVisibility<Parallelepiped>(name, state);
     8874    } else {
     8875        g_renderer->setGraphicsObjectVisibility<Parallelepiped>("all", state);
     8876    }
     8877    return TCL_OK;
     8878}
     8879
     8880static int
     8881ParallelepipedWireframeOp(ClientData clientData, Tcl_Interp *interp, int objc,
     8882                          Tcl_Obj *const *objv)
     8883{
     8884    bool state;
     8885    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     8886        return TCL_ERROR;
     8887    }
     8888    if (objc == 4) {
     8889        const char *name = Tcl_GetString(objv[3]);
     8890        g_renderer->setGraphicsObjectWireframe<Parallelepiped>(name, state);
     8891    } else {
     8892        g_renderer->setGraphicsObjectWireframe<Parallelepiped>("all", state);
     8893    }
     8894    return TCL_OK;
     8895}
     8896
     8897static Rappture::CmdSpec parallelepipedOps[] = {
     8898    {"add",       1, ParallelepipedAddOp, 12, 12, "v0x v0y v0z v1x v1y v1z v2x v2y v2z name"},
     8899    {"color",     2, ParallelepipedColorOp, 5, 6, "r g b ?name?"},
     8900    {"culling",   2, ParallelepipedCullingOp, 3, 4, "bool ?name?"},
     8901    {"delete",    1, ParallelepipedDeleteOp, 2, 3, "?name?"},
     8902    {"edges",     1, ParallelepipedEdgeVisibilityOp, 3, 4, "bool ?name?"},
     8903    {"flipnorms", 1, ParallelepipedFlipNormalsOp, 3, 4, "bool ?name?"},
     8904    {"lighting",  3, ParallelepipedLightingOp, 3, 4, "bool ?name?"},
     8905    {"linecolor", 5, ParallelepipedLineColorOp, 5, 6, "r g b ?name?"},
     8906    {"linewidth", 5, ParallelepipedLineWidthOp, 3, 4, "width ?name?"},
     8907    {"material",  1, ParallelepipedMaterialOp, 6, 7, "ambientCoeff diffuseCoeff specularCoeff specularPower ?name?"},
     8908    {"opacity",   2, ParallelepipedOpacityOp, 3, 4, "value ?name?"},
     8909    {"orient",    4, ParallelepipedOrientOp, 6, 7, "qw qx qy qz ?name?"},
     8910    {"origin",    4, ParallelepipedOriginOp, 5, 6, "x y z ?name?"},
     8911    {"pos",       1, ParallelepipedPositionOp, 5, 6, "x y z ?name?"},
     8912    {"scale",     2, ParallelepipedScaleOp, 5, 6, "sx sy sz ?name?"},
     8913    {"shading",   2, ParallelepipedShadingOp, 3, 4, "val ?name?"},
     8914    {"visible",   1, ParallelepipedVisibleOp, 3, 4, "bool ?name?"},
     8915    {"wireframe", 1, ParallelepipedWireframeOp, 3, 4, "bool ?name?"}
     8916};
     8917static int nParallelepipedOps = NumCmdSpecs(parallelepipedOps);
     8918
     8919static int
     8920ParallelepipedCmd(ClientData clientData, Tcl_Interp *interp, int objc,
     8921       Tcl_Obj *const *objv)
     8922{
     8923    Tcl_ObjCmdProc *proc;
     8924
     8925    proc = Rappture::GetOpFromObj(interp, nParallelepipedOps, parallelepipedOps,
     8926                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
     8927    if (proc == NULL) {
     8928        return TCL_ERROR;
     8929    }
     8930    return (*proc) (clientData, interp, objc, objv);
     8931}
     8932
     8933static int
    85618934PolyDataAddOp(ClientData clientData, Tcl_Interp *interp, int objc,
    85628935              Tcl_Obj *const *objv)
     
    1222812601{
    1222912602    Tcl_MakeSafe(interp);
    12230     Tcl_CreateObjCommand(interp, "arc",         ArcCmd,         clientData, NULL);
    12231     Tcl_CreateObjCommand(interp, "arrow",       ArrowCmd,       clientData, NULL);
    12232     Tcl_CreateObjCommand(interp, "axis",        AxisCmd,        clientData, NULL);
    12233     Tcl_CreateObjCommand(interp, "box",         BoxCmd,         clientData, NULL);
    12234     Tcl_CreateObjCommand(interp, "camera",      CameraCmd,      clientData, NULL);
    12235     Tcl_CreateObjCommand(interp, "clientinfo",  ClientInfoCmd,  clientData, NULL);
    12236     Tcl_CreateObjCommand(interp, "colormap",    ColorMapCmd,    clientData, NULL);
    12237     Tcl_CreateObjCommand(interp, "cone",        ConeCmd,        clientData, NULL);
    12238     Tcl_CreateObjCommand(interp, "contour2d",   Contour2DCmd,   clientData, NULL);
    12239     Tcl_CreateObjCommand(interp, "contour3d",   Contour3DCmd,   clientData, NULL);
    12240     Tcl_CreateObjCommand(interp, "cutplane",    CutplaneCmd,    clientData, NULL);
    12241     Tcl_CreateObjCommand(interp, "cylinder",    CylinderCmd,    clientData, NULL);
    12242     Tcl_CreateObjCommand(interp, "dataset",     DataSetCmd,     clientData, NULL);
    12243     Tcl_CreateObjCommand(interp, "disk",        DiskCmd,        clientData, NULL);
    12244     Tcl_CreateObjCommand(interp, "glyphs",      GlyphsCmd,      clientData, NULL);
    12245     Tcl_CreateObjCommand(interp, "group",       GroupCmd,       clientData, NULL);
    12246     Tcl_CreateObjCommand(interp, "heightmap",   HeightMapCmd,   clientData, NULL);
    12247     Tcl_CreateObjCommand(interp, "image",       ImageCmd,       clientData, NULL);
    12248     Tcl_CreateObjCommand(interp, "imgflush",    ImageFlushCmd,  clientData, NULL);
    12249     Tcl_CreateObjCommand(interp, "legend",      LegendCmd,      clientData, NULL);
    12250     Tcl_CreateObjCommand(interp, "legend2",     LegendSimpleCmd,clientData, NULL);
    12251     Tcl_CreateObjCommand(interp, "lic",         LICCmd,         clientData, NULL);
    12252     Tcl_CreateObjCommand(interp, "line",        LineCmd,        clientData, NULL);
    12253     Tcl_CreateObjCommand(interp, "molecule",    MoleculeCmd,    clientData, NULL);
    12254     Tcl_CreateObjCommand(interp, "outline",     OutlineCmd,     clientData, NULL);
    12255     Tcl_CreateObjCommand(interp, "polydata",    PolyDataCmd,    clientData, NULL);
    12256     Tcl_CreateObjCommand(interp, "polygon",     PolygonCmd,     clientData, NULL);
    12257     Tcl_CreateObjCommand(interp, "pseudocolor", PseudoColorCmd, clientData, NULL);
    12258     Tcl_CreateObjCommand(interp, "renderer",    RendererCmd,    clientData, NULL);
    12259     Tcl_CreateObjCommand(interp, "screen",      ScreenCmd,      clientData, NULL);
    12260     Tcl_CreateObjCommand(interp, "sphere",      SphereCmd,      clientData, NULL);
    12261     Tcl_CreateObjCommand(interp, "streamlines", StreamlinesCmd, clientData, NULL);
    12262     Tcl_CreateObjCommand(interp, "text3d",      Text3DCmd,      clientData, NULL);
    12263     Tcl_CreateObjCommand(interp, "volume",      VolumeCmd,      clientData, NULL);
    12264     Tcl_CreateObjCommand(interp, "warp",        WarpCmd,        clientData, NULL);
     12603    Tcl_CreateObjCommand(interp, "arc",            ArcCmd,            clientData, NULL);
     12604    Tcl_CreateObjCommand(interp, "arrow",          ArrowCmd,          clientData, NULL);
     12605    Tcl_CreateObjCommand(interp, "axis",           AxisCmd,           clientData, NULL);
     12606    Tcl_CreateObjCommand(interp, "box",            BoxCmd,            clientData, NULL);
     12607    Tcl_CreateObjCommand(interp, "camera",         CameraCmd,         clientData, NULL);
     12608    Tcl_CreateObjCommand(interp, "clientinfo",     ClientInfoCmd,     clientData, NULL);
     12609    Tcl_CreateObjCommand(interp, "colormap",       ColorMapCmd,       clientData, NULL);
     12610    Tcl_CreateObjCommand(interp, "cone",           ConeCmd,           clientData, NULL);
     12611    Tcl_CreateObjCommand(interp, "contour2d",      Contour2DCmd,      clientData, NULL);
     12612    Tcl_CreateObjCommand(interp, "contour3d",      Contour3DCmd,      clientData, NULL);
     12613    Tcl_CreateObjCommand(interp, "cutplane",       CutplaneCmd,       clientData, NULL);
     12614    Tcl_CreateObjCommand(interp, "cylinder",       CylinderCmd,       clientData, NULL);
     12615    Tcl_CreateObjCommand(interp, "dataset",        DataSetCmd,        clientData, NULL);
     12616    Tcl_CreateObjCommand(interp, "disk",           DiskCmd,           clientData, NULL);
     12617    Tcl_CreateObjCommand(interp, "glyphs",         GlyphsCmd,         clientData, NULL);
     12618    Tcl_CreateObjCommand(interp, "group",          GroupCmd,          clientData, NULL);
     12619    Tcl_CreateObjCommand(interp, "heightmap",      HeightMapCmd,      clientData, NULL);
     12620    Tcl_CreateObjCommand(interp, "image",          ImageCmd,          clientData, NULL);
     12621    Tcl_CreateObjCommand(interp, "imgflush",       ImageFlushCmd,     clientData, NULL);
     12622    Tcl_CreateObjCommand(interp, "legend",         LegendCmd,         clientData, NULL);
     12623    Tcl_CreateObjCommand(interp, "legend2",        LegendSimpleCmd,   clientData, NULL);
     12624    Tcl_CreateObjCommand(interp, "lic",            LICCmd,            clientData, NULL);
     12625    Tcl_CreateObjCommand(interp, "line",           LineCmd,           clientData, NULL);
     12626    Tcl_CreateObjCommand(interp, "molecule",       MoleculeCmd,       clientData, NULL);
     12627    Tcl_CreateObjCommand(interp, "outline",        OutlineCmd,        clientData, NULL);
     12628    Tcl_CreateObjCommand(interp, "parallelepiped", ParallelepipedCmd, clientData, NULL);
     12629    Tcl_CreateObjCommand(interp, "polydata",       PolyDataCmd,       clientData, NULL);
     12630    Tcl_CreateObjCommand(interp, "polygon",        PolygonCmd,        clientData, NULL);
     12631    Tcl_CreateObjCommand(interp, "pseudocolor",    PseudoColorCmd,    clientData, NULL);
     12632    Tcl_CreateObjCommand(interp, "renderer",       RendererCmd,       clientData, NULL);
     12633    Tcl_CreateObjCommand(interp, "screen",         ScreenCmd,         clientData, NULL);
     12634    Tcl_CreateObjCommand(interp, "sphere",         SphereCmd,         clientData, NULL);
     12635    Tcl_CreateObjCommand(interp, "streamlines",    StreamlinesCmd,    clientData, NULL);
     12636    Tcl_CreateObjCommand(interp, "text3d",         Text3DCmd,         clientData, NULL);
     12637    Tcl_CreateObjCommand(interp, "volume",         VolumeCmd,         clientData, NULL);
     12638    Tcl_CreateObjCommand(interp, "warp",           WarpCmd,           clientData, NULL);
    1226512639}
    1226612640
     
    1229512669    Tcl_DeleteCommand(interp, "molecule");
    1229612670    Tcl_DeleteCommand(interp, "outline");
     12671    Tcl_DeleteCommand(interp, "parallelepiped");
    1229712672    Tcl_DeleteCommand(interp, "polydata");
    1229812673    Tcl_DeleteCommand(interp, "polygon");
  • branches/1.3/packages/vizservers/vtkvis/RendererGraphicsObjs.cpp

    r3844 r3877  
    2828#include "Line.h"
    2929#include "Molecule.h"
     30#include "Parallelepiped.h"
    3031#include "PolyData.h"
    3132#include "PseudoColor.h"
     
    123124Renderer::getGraphicsObjectHashmap<Outline>()
    124125{ return _outlines; }
     126
     127template<>
     128Renderer::ParallelepipedHashmap &
     129Renderer::getGraphicsObjectHashmap<Parallelepiped>()
     130{ return _parallelepipeds; }
    125131
    126132template<>
     
    173179template Group *Renderer::getGraphicsObject(const DataSetId&);
    174180template Line *Renderer::getGraphicsObject(const DataSetId&);
     181template Parallelepiped *Renderer::getGraphicsObject(const DataSetId&);
    175182template Polygon *Renderer::getGraphicsObject(const DataSetId&);
    176183template Sphere *Renderer::getGraphicsObject(const DataSetId&);
     
    287294    }
    288295    if ((gobj = getGraphicsObject<Line>(id)) != NULL) {
     296        return gobj;
     297    }
     298    if ((gobj = getGraphicsObject<Parallelepiped>(id)) != NULL) {
    289299        return gobj;
    290300    }
     
    29382948
    29392949/**
     2950 * \brief Create a new Parallelepiped and associate it with an ID
     2951 */
     2952bool Renderer::addParallelepiped(const DataSetId& id,
     2953                                 double vec1[3], double vec2[3], double vec3[3],
     2954                                 bool flipNormals)
     2955{
     2956    Parallelepiped *gobj;
     2957    if ((gobj = getGraphicsObject<Parallelepiped>(id)) != NULL) {
     2958        WARN("Replacing existing %s %s", gobj->getClassName(), id.c_str());
     2959        deleteGraphicsObject<Parallelepiped>(id);
     2960    }
     2961
     2962    gobj = new Parallelepiped();
     2963 
     2964    gobj->setDataSet(NULL, this);
     2965
     2966    if (gobj->getProp() == NULL &&
     2967        gobj->getOverlayProp() == NULL) {
     2968        delete gobj;
     2969        return false;
     2970    } else {
     2971        if (gobj->getProp())
     2972            _renderer->AddViewProp(gobj->getProp());
     2973        if (gobj->getOverlayProp())
     2974            _renderer->AddViewProp(gobj->getOverlayProp());
     2975    }
     2976
     2977    gobj->setVectors(vec1, vec2, vec3);
     2978    if (flipNormals)
     2979        gobj->flipNormals(flipNormals);
     2980
     2981    getGraphicsObjectHashmap<Parallelepiped>()[id] = gobj;
     2982
     2983    sceneBoundsChanged();
     2984    _needsRedraw = true;
     2985    return true;
     2986}
     2987
     2988/**
    29402989 * \brief Create a new n-sided regular Polygon and associate it with an ID
    29412990 */
  • branches/1.3/packages/vizservers/vtkvis/Volume.cpp

    r3844 r3877  
    1414#include <vtkGPUVolumeRayCastMapper.h>
    1515#include <vtkVolumeTextureMapper3D.h>
     16#include <vtkRectilinearGrid.h>
     17#include <vtkStructuredGrid.h>
    1618#include <vtkUnstructuredGrid.h>
    1719#include <vtkPolyData.h>
     
    121123#endif
    122124        vtkVolumeMapper::SafeDownCast(_volumeMapper)->SetBlendModeToComposite();
    123     } else if (_dataSet->isCloud()) {
    124         // DataSet is a 3D point cloud
     125    } else if (_dataSet->isCloud() ||
     126               vtkUnstructuredGrid::SafeDownCast(ds) == NULL) {
     127        // DataSet is a 3D point cloud, rectilinear grid or structured grid
    125128        vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
    126129#ifdef USE_VTK6
     
    131134        int dims[3];
    132135        dims[0] = dims[1] = dims[2] = 64;
    133         TRACE("Generating volume with dims (%d,%d,%d) from point cloud",
    134               dims[0], dims[1], dims[2]);
     136        if (vtkStructuredGrid::SafeDownCast(ds) != NULL) {
     137            vtkStructuredGrid::SafeDownCast(ds)->GetDimensions(dims);
     138        } else if (vtkRectilinearGrid::SafeDownCast(ds) != NULL) {
     139            vtkRectilinearGrid::SafeDownCast(ds)->GetDimensions(dims);
     140        }
     141        TRACE("Generating volume with dims (%d,%d,%d) from %d points",
     142              dims[0], dims[1], dims[2], ds->GetNumberOfPoints());
    135143        splatter->SetSampleDimensions(dims);
    136144        splatter->Update();
     
    144152        _volumeMapper->SetInputConnection(splatter->GetOutputPort());
    145153        vtkVolumeMapper::SafeDownCast(_volumeMapper)->SetBlendModeToComposite();
    146     } else if (vtkUnstructuredGrid::SafeDownCast(ds) != NULL) {
     154    } else {
    147155        // Unstructured grid with cells (not a cloud)
    148156        vtkUnstructuredGrid *ugrid = vtkUnstructuredGrid::SafeDownCast(ds);
     157        assert(ugrid != NULL);
    149158        // DataSet is unstructured grid
    150159        // Only works if cells are all tetrahedra
     
    177186        vtkUnstructuredGridVolumeMapper::SafeDownCast(_volumeMapper)->
    178187            SetBlendModeToComposite();
    179     } else {
    180         ERROR("Unsupported DataSet type: %s", _dataSet->getVtkType());
    181         _dataSet = NULL;
    182         return;
    183188    }
    184189
  • branches/1.3/packages/vizservers/vtkvis/protocol.txt

    r3844 r3877  
    685685outline scale <sx> <sy> <sz> <?datasetName?>
    686686outline visible <bool> <?datasetName?>
     687
     688parallelepiped add <v0x> <v0y> <v0z> <v1x> <v1y> <v1z> <v2x> <v2y> <v2z> <name>
     689               Specify parallelepiped using 3 basis vectors.  The 3 vectors should
     690               be given in order to create a right-handed coordinate system, i.e.
     691               (v0 cross v1) dot v2 should be positive.
     692parallelepiped color <r> <g> <b> <?name?>
     693parallelepiped culling <bool> <?name?>
     694parallelepiped delete <?name?>
     695parallelepiped edges <bool> <?name?>
     696parallelepiped flipnorm <bool> <?name?>
     697parallelepiped lighting <bool> <?name?>
     698parallelepiped linecolor <r> <g> <b> <?name?>
     699parallelepiped linewidth <val> <?name?>
     700parallelepiped material <ambientCoeff> <diffuseCoeff> <specularCoeff> <specularExp> <?name?>
     701parallelepiped opacity <val> <?name?>
     702parallelepiped orient <qw> <qx> <qy> <qz> <?name?>
     703parallelepiped origin <x> <y> <z> <?name?>
     704parallelepiped pos <x> <y> <z> <?name?>
     705parallelepiped scale <sx> <sy> <sz> <?name?>
     706parallelepiped shading <val> <?name?>
     707               val = flat|smooth
     708parallelepiped visible <bool> <?name?>
     709parallelepiped wireframe <bool> <?name?>
    687710
    688711polydata add <?datasetName?>
Note: See TracChangeset for help on using the changeset viewer.