Changeset 3492 for trunk/packages/vizservers/nanovis/FlowCmd.cpp

Timestamp:

Mar 13, 2013, 9:57:03 AM (12 years ago)

Author:

ldelgass

Message:

Fix camera reset for nanovis. Includes refactoring of vector/matrix classes
in nanovis to consolidate into vrmath library. Also add preliminary canonical
view control to clients for testing.

File:

• trunk/packages/vizservers/nanovis/FlowCmd.cpp (modified) (10 diffs)

trunk/packages/vizservers/nanovis/FlowCmd.cpp

@@ -14 +14 @@
 #include <RpFieldPrism3D.h>
 #include <RpOutcome.h>
+
+#include <vrmath/Vector3f.h>
+#include <vrmath/Vector4f.h>
+#include <vrmath/Matrix4x4d.h>
 
 #include "nvconf.h"
@@ -38 +42 @@
 #define RELPOS 0
 #define ABSPOS 1
+
+using namespace vrmath;
 
 static Rappture::SwitchParseProc AxisSwitchProc;
@@ -170 +176 @@
 {
     _rendererPtr->setPos(FlowCmd::GetRelativePosition(&_sv.position));
-    _rendererPtr->setColor(Vector4(_sv.color.r, _sv.color.g, _sv.color.b, 
-                                   _sv.color.a));
+    _rendererPtr->setColor(Vector4f(_sv.color.r, _sv.color.g, _sv.color.b, 
+                                    _sv.color.a));
     _rendererPtr->particleSize(_sv.particleSize);
     _rendererPtr->setAxis(_sv.position.axis);
@@ -192 +198 @@
 }
 
+void
+FlowBox::getWorldSpaceBounds(Vector3f& bboxMin,
+                             Vector3f& bboxMax,
+                             const Volume *vol) const
+{
+    bboxMin.set(FLT_MAX, FLT_MAX, FLT_MAX);
+    bboxMax.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
+
+    Vector3f origin = vol->location();
+    Vector3f scale = vol->getPhysicalScaling();
+
+    Matrix4x4d mat;
+    mat.makeTranslation(origin);
+    Matrix4x4d mat2;
+    mat2.makeScale(scale);
+
+    mat.multiply(mat2);
+
+    Vector3f min, max;
+    min.x = vol->xAxis.min();
+    min.y = vol->yAxis.min();
+    min.z = vol->zAxis.min();
+    max.x = vol->xAxis.max();
+    max.y = vol->yAxis.max();
+    max.z = vol->zAxis.max();
+
+    float x0, y0, z0, x1, y1, z1;
+    x0 = y0 = z0 = 0.0f;
+    x1 = y1 = z1 = 0.0f;
+    if (max.x > min.x) {
+        x0 = (_sv.corner1.x - min.x) / (max.x - min.x);
+        x1 = (_sv.corner2.x - min.x) / (max.x - min.x);
+    }
+    if (max.y > min.y) {
+        y0 = (_sv.corner1.y - min.y) / (max.y - min.y);
+        y1 = (_sv.corner2.y - min.y) / (max.y - min.y);
+    }
+    if (max.z > min.z) {
+        z0 = (_sv.corner1.z - min.z) / (max.z - min.z);
+        z1 = (_sv.corner2.z - min.z) / (max.z - min.z);
+    }
+
+    TRACE("Box model bounds: (%g,%g,%g) - (%g,%g,%g)", x0, y0, z0, x1, y1, z1);
+
+    Vector3f modelMin(x0, y0, z0);
+    Vector3f modelMax(x1, y1, z1);
+
+    Vector4f bvert[8];
+    bvert[0] = Vector4f(modelMin.x, modelMin.y, modelMin.z, 1);
+    bvert[1] = Vector4f(modelMax.x, modelMin.y, modelMin.z, 1);
+    bvert[2] = Vector4f(modelMin.x, modelMax.y, modelMin.z, 1);
+    bvert[3] = Vector4f(modelMin.x, modelMin.y, modelMax.z, 1);
+    bvert[4] = Vector4f(modelMax.x, modelMax.y, modelMin.z, 1);
+    bvert[5] = Vector4f(modelMax.x, modelMin.y, modelMax.z, 1);
+    bvert[6] = Vector4f(modelMin.x, modelMax.y, modelMax.z, 1);
+    bvert[7] = Vector4f(modelMax.x, modelMax.y, modelMax.z, 1);
+
+    for (int i = 0; i < 8; i++) {
+        Vector4f worldVert = mat.transform(bvert[i]);
+        if (worldVert.x < bboxMin.x) bboxMin.x = worldVert.x;
+        if (worldVert.x > bboxMax.x) bboxMax.x = worldVert.x;
+        if (worldVert.y < bboxMin.y) bboxMin.y = worldVert.y;
+        if (worldVert.y > bboxMax.y) bboxMax.y = worldVert.y;
+        if (worldVert.z < bboxMin.z) bboxMin.z = worldVert.z;
+        if (worldVert.z > bboxMax.z) bboxMax.z = worldVert.z;
+    }
+
+    TRACE("Box world bounds: (%g,%g,%g) - (%g,%g,%g)",
+          bboxMin.x, bboxMin.y, bboxMin.z,
+          bboxMax.x, bboxMax.y, bboxMax.z);
+}
+
 void 
-FlowBox::Render(Volume *volPtr)
+FlowBox::Render(Volume *vol)
 {
     TRACE("Rendering box %s", _name);
@@ -206 +284 @@
     glPushMatrix();
 
-    Vector3 origin = volPtr->location();
+    Vector3f origin = vol->location();
     glTranslatef(origin.x, origin.y, origin.z);
 
-    Vector3 scale = volPtr->getPhysicalScaling();
-    glScaled(scale.x, scale.y, scale.z);
-
-    Vector3 min, max;
-    min.x = volPtr->xAxis.min();
-    min.y = volPtr->yAxis.min();
-    min.z = volPtr->zAxis.min();
-    max.x = volPtr->xAxis.max();
-    max.y = volPtr->yAxis.max();
-    max.z = volPtr->zAxis.max();
+    Vector3f scale = vol->getPhysicalScaling();
+    glScalef(scale.x, scale.y, scale.z);
+
+    Vector3f min, max;
+    min.x = vol->xAxis.min();
+    min.y = vol->yAxis.min();
+    min.z = vol->zAxis.min();
+    max.x = vol->xAxis.max();
+    max.y = vol->yAxis.max();
+    max.z = vol->zAxis.max();
 
     TRACE("box is %g,%g %g,%g %g,%g", 
@@ -557 +635 @@
     }
 
-    Vector3 scale = volPtr->getPhysicalScaling();
-    Vector3 location = _volPtr->location();
+    Vector3f scale = volPtr->getPhysicalScaling();
+    Vector3f location = _volPtr->location();
 
     _fieldPtr->setVectorField(_volPtr,
@@ -688 +766 @@
     volPtr->visible(_sv.showVolume);
 
-    Vector3 volScaling = volPtr->getPhysicalScaling();
-    float dx0 = -0.5 * volScaling.x;
-    float dy0 = -0.5 * volScaling.y;
-    float dz0 = -0.5 * volScaling.z;
-    volPtr->location(Vector3(dx0, dy0, dz0));
+    Vector3f volScaling = volPtr->getPhysicalScaling();
+    Vector3f loc(volScaling);
+    loc *= -0.5;
+    volPtr->location(loc);
 
     Volume::updatePending = true;
@@ -1013 +1090 @@
 {
     flags &= ~MAP_FLOWS;
-    TRACE("MapFlows");
+    TRACE("Enter");
 
     /* 
@@ -1057 +1134 @@
         }
     }
+
     TRACE("MapFlows magMin=%g magMax=%g", NanoVis::magMin, NanoVis::magMax);
 
@@ -1079 +1157 @@
     AdvectFlows();
     return true;
+}
+
+void
+NanoVis::GetFlowBounds(Vector3f& min,
+                       Vector3f& max,
+                       bool onlyVisible)
+{
+    TRACE("Enter");
+
+    min.set(FLT_MAX, FLT_MAX, FLT_MAX);
+    max.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
+
+    FlowCmd *flow;
+    FlowIterator iter;
+    for (flow = FirstFlow(&iter); flow != NULL; 
+         flow = NextFlow(&iter)) {
+        if (onlyVisible && !flow->visible())
+            continue;
+ #if 0  // Using volume bounds instead of these
+        if (flow->isDataLoaded()) {
+            Vector3f umin, umax;
+            Rappture::Unirect3d *unirect = flow->data();
+            unirect->getWorldSpaceBounds(umin, umax);
+            if (min.x > umin.x) {
+                min.x = umin.x;
+            }
+            if (max.x < umax.x) {
+                max.x = umax.x;
+            }
+            if (min.y > umin.y) {
+                min.y = umin.y;
+            }
+            if (max.y < umax.y) {
+                max.y = umax.y;
+            }
+            if (min.z > umin.z) {
+                min.z = umin.z;
+            }
+            if (max.z < umax.z) {
+                max.z = umax.z;
+            }
+        }
+#endif
+        FlowBox *box;
+        FlowBoxIterator iter;
+        for (box = flow->FirstBox(&iter); box != NULL;
+             box = flow->NextBox(&iter)) {
+            TRACE("found box %s", box->name());
+            if (!onlyVisible || box->visible()) {
+                Vector3f fbmin, fbmax;
+                box->getWorldSpaceBounds(fbmin, fbmax,
+                                         flow->getVolume());
+                if (min.x > fbmin.x) {
+                    min.x = fbmin.x;
+                }
+                if (max.x < fbmax.x) {
+                    max.x = fbmax.x;
+                }
+                if (min.y > fbmin.y) {
+                    min.y = fbmin.y;
+                }
+                if (max.y < fbmax.y) {
+                    max.y = fbmax.y;
+                }
+                if (min.z > fbmin.z) {
+                    min.z = fbmin.z;
+                }
+                if (max.z < fbmax.z) {
+                    max.z = fbmax.z;
+                }
+            }
+        }
+    }
 }