Changeset 2576 for GTP/trunk/Lib/Vis/Preprocessing/src/QtInterface/QtGlRenderer.cpp

Timestamp:

01/07/08 02:23:52 (16 years ago)

Author:

mattausch

Message:

 

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/QtInterface/QtGlRenderer.cpp (modified) (11 diffs)

GTP/trunk/Lib/Vis/Preprocessing/src/QtInterface/QtGlRenderer.cpp

@@ +1 @@
+#include "glInterface.h"
+#include "QtGlRenderer.h"
 #include "Mesh.h"
-#include "glInterface.h"
 #include "OcclusionQuery.h"
-#include "QtGlRenderer.h"
 #include "ViewCellsManager.h"
 #include "SceneGraph.h"
@@ -1245 +1245 @@
 #endif
 
-void
-QtGlRendererWidget::RenderViewCells()
+
+
+void QtGlRendererWidget::ComputeMaxValues(const ViewCellContainer &viewCells,
+                                                                                  int &maxPvs, 
+                                                                                  int &maxPiercingRays, 
+                                                                                  float &maxRelativeRays, 
+                                                                                  float &maxRcCost)
+{
+        maxPvs = -1;
+        maxPiercingRays = 1; // not zero for savety
+        maxRelativeRays = Limits::Small; // not zero for savety
+        maxRcCost = Limits::Small;
+
+        for (size_t i = 0; i < viewCells.size(); ++ i) 
+        {
+                ViewCell *vc = viewCells[i];
+
+                if (mShowPvsSizes) // pvs size
+                {
+                        //const int p = vc->GetPvs().CountObjectsInPvs();
+                        const int p = vc->GetPvs().GetSize();
+                        if (p > maxPvs)
+                                maxPvs = p;
+                }
+                else if (mShowPiercingRays) // relative number of rays
+                {
+                        const int piercingRays = vc->GetNumPiercingRays();
+
+                        if (piercingRays > maxPiercingRays)
+                                maxPiercingRays = piercingRays;
+                } 
+                else if (mShowWeightedRays)
+                {
+                        const int piercingRays = vc->GetNumPiercingRays();
+
+                        const float relativeArea = 
+                                vc->GetBox().SurfaceArea() / mViewCellsManager->GetViewSpaceBox().SurfaceArea();
+
+                        if ((float)piercingRays / relativeArea > maxRelativeRays)
+                                maxRelativeRays = (float)piercingRays / relativeArea;
+                }
+                else if (mShowWeightedCost)
+                {
+                        const float rcCost = ComputeRenderCost(vc);
+                        mViewCellsManager->UpdateScalarPvsCost(vc, rcCost);
+
+                        if (rcCost > maxRcCost)
+                                maxRcCost = rcCost;
+                }
+        }
+}
+
+
+void QtGlRendererWidget::RenderViewCells()
 {
         mUseFalseColors = true;
@@ -1272 +1324 @@
         ViewCellContainer &viewcells = mViewCellsManager->GetViewCells();
         
-        int maxPvs = -1;
-        int maxPiercingRays = 1; // not zero for savety
-        float maxRelativeRays = Limits::Small; // not zero for savety
-        float maxRcCost = Limits::Small;
-
-        for (i = 0; i < viewcells.size(); ++ i) 
-        {
-                ViewCell *vc = viewcells[i];
-
-                if (mShowPvsSizes) // pvs size
-                {
-                        //const int p = vc->GetPvs().CountObjectsInPvs();
-                        const int p = vc->GetPvs().GetSize();
-                        if (p > maxPvs)
-                                maxPvs = p;
-                }
-                else if (mShowPiercingRays) // relative number of rays
-                {
-                        const int piercingRays = vc->GetNumPiercingRays();
-
-                        if (piercingRays > maxPiercingRays)
-                                maxPiercingRays = piercingRays;
-                } 
-                else if (mShowWeightedRays)
-                {
-                        const int piercingRays = vc->GetNumPiercingRays();
-
-                        const float relativeArea = 
-                                vc->GetBox().SurfaceArea() / mViewCellsManager->GetViewSpaceBox().SurfaceArea();
-
-                        if ((float)piercingRays / relativeArea > maxRelativeRays)
-                                maxRelativeRays = (float)piercingRays / relativeArea;
-                }
-                else if (mShowWeightedCost)
-                {
-                        const float rcCost = ComputeRenderCost(vc);
-                        mViewCellsManager->UpdateScalarPvsCost(vc, rcCost);
-
-                        if (rcCost > maxRcCost)
-                                maxRcCost = rcCost;
-                }
-        }
+        int maxPvs, maxPiercingRays;
+        float maxRelativeRays, maxRcCost;
+
+        ComputeMaxValues(viewcells, maxPvs, maxPiercingRays, maxRelativeRays, maxRcCost);
+
 
         if (!mShowPvsSizes && !mShowPiercingRays && !mShowWeightedRays && !mShowWeightedCost)
@@ -1338 +1353 @@
         else
         {
-                //glDisable(GL_CULL_FACE);
-                //glCullFace(GL_BACK);
-
+                // transparency 
                 if (!mUseTransparency)
                 {
@@ -1365 +1378 @@
                 }
 
-                for (i = 0; i < viewcells.size(); ++ i) 
-                {
-                        RgbColor c;
-            ViewCell *vc = viewcells[i];
-                        
-                        float importance;
-
-                        if (mShowPiercingRays)
-                        {
-                                importance = mTransferFunction *
-                                        ((float)vc->GetNumPiercingRays() / (float)maxPiercingRays);
-                        }
-                        else if (mShowWeightedRays) // relative number of rays
-                        {
-                                float relativeArea = vc->GetBox().SurfaceArea() / mViewCellsManager->GetViewSpaceBox().SurfaceArea();
-
-                                if (relativeArea < Limits::Small)
-                                        relativeArea = Limits::Small;
-
-                                importance = mTransferFunction * ((float)vc->GetNumPiercingRays() / relativeArea) / maxRelativeRays;
-                        }
-                        else if (mShowPvsSizes) // pvs size
-                        {
-                                importance = mTransferFunction *
-                                        ((float)vc->GetPvs().GetSize() / (float)maxPvs);
-                        } // weighted render cost
-                        else if (mShowWeightedCost)
-                        {
-                                const float rcCost = mTransferFunction * ComputeRenderCost(vc);
-                                importance = rcCost / maxRcCost;
-                        }
-
-                        // c = RgbColor(importance, 1.0f - importance, 0.0f);
-                        c = RainbowColorMapping(importance);
-
-                        glColor4f(c.r, c.g, c.b, 1.0f - mTransparency);
-
-                        if (!mHideByCost || (mHidingCost < importance)) 
-                        {
-                                RenderViewCell(vc);
-                        }
-                }
+                ViewCellInfoContainer *infos1 = mCurrentInfos[mCurrentSamples];
+                ViewCellInfoContainer *infos2 = mCompareInfos[mCurrentSamples];
+
+                if (mAssignImportanceByRelativeValue)
+                        AssignImportanceByRelativeValue(viewcells, maxPvs, maxPiercingRays, maxRelativeRays, maxRcCost);
+                else
+                        AssignColorByComparison(viewcells, *infos1, *infos2);
 
                 glEnable(GL_DEPTH_TEST);        
@@ -1423 +1401 @@
 
 
-
-/*********************************************************************/
-/*                   QtGlDebuggerWidget implementation               */
-/*********************************************************************/
-
-
-QtGlDebuggerWidget::QtGlDebuggerWidget(QtGlRendererBuffer *buf, QWidget *parent)
-: QGLWidget(QGLFormat(QGL::SampleBuffers), parent), mRenderBuffer(buf)
-{
-        // create the pbuffer
-        //pbuffer = new QGLPixelBuffer(QSize(512, 512), format(), this);
-        timerId = startTimer(20);
-        setWindowTitle(("OpenGL pbuffers"));
-}
-
-
-QtGlDebuggerWidget::~QtGlDebuggerWidget()
-{
-        mRenderBuffer->releaseFromDynamicTexture();
-        glDeleteTextures(1, &dynamicTexture);
-
-        DEL_PTR(mRenderBuffer);
-}
-
-
+void QtGlRendererWidget::AssignImportanceByRelativeValue(const ViewCellContainer &viewCells,
+                                                                                                                 int &maxPvs, 
+                                                                                                                 int &maxPiercingRays, 
+                                                                                                                 float &maxRelativeRays, 
+                                                                                                                 float &maxRcCost)
+{
+        for (size_t i = 0; i < viewCells.size(); ++ i) 
+        {
+                RgbColor c;
+                ViewCell *vc = viewCells[i];
+
+                float importance;
+
+                if (mShowPiercingRays)
+                {
+                        importance = mTransferFunction *
+                                ((float)vc->GetNumPiercingRays() / (float)maxPiercingRays);
+                }
+                else if (mShowWeightedRays) // relative number of rays
+                {
+                        float relativeArea = vc->GetBox().SurfaceArea() / mViewCellsManager->GetViewSpaceBox().SurfaceArea();
+
+                        if (relativeArea < Limits::Small)
+                                relativeArea = Limits::Small;
+
+                        importance = mTransferFunction * ((float)vc->GetNumPiercingRays() / relativeArea) / maxRelativeRays;
+                }
+                else if (mShowPvsSizes) // pvs size
+                {
+                        importance = mTransferFunction *
+                                ((float)vc->GetPvs().GetSize() / (float)maxPvs);
+                } // weighted render cost
+                else if (mShowWeightedCost)
+                {
+                        const float rcCost = mTransferFunction * ComputeRenderCost(vc);
+                        importance = rcCost / maxRcCost;
+                }
+
+                // c = RgbColor(importance, 1.0f - importance, 0.0f);
+                c = RainbowColorMapping(importance);
+
+                glColor4f(c.r, c.g, c.b, 1.0f - mTransparency);
+
+                if (!mHideByCost || (mHidingCost < importance)) 
+                {
+                        RenderViewCell(vc);
+                }
+        }
+}
+
+
+void QtGlRendererWidget::AssignColorByComparison(const ViewCellContainer &viewcells,
+                                                                                                 const ViewCellInfoContainer &infos1, 
+                                                                                                 const ViewCellInfoContainer &infos2)
+{
+
+        const float maxRatio = 2;
+        const float minRatio = 0.5;
+
+        const float scale = 1.0f / (maxRatio - minRatio);
+
+        for (size_t i = 0; i < viewcells.size(); ++ i) 
+        {
+                RgbColor c;
+                ViewCell *vc = viewcells[i];
+
+                ViewCellInfo vc1Info = infos1[i];
+                ViewCellInfo vc2Info = infos2[i];
+
+                const float vcRatio = vc1Info.mPiercingRays / vc2Info.mPiercingRays + Limits::Small;
+
+                const float importance = (vcRatio - minRatio) * scale;
+
+                // c = RgbColor(importance, 1.0f - importance, 0.0f);
+                c = RainbowColorMapping(importance);
+
+                glColor4f(c.r, c.g, c.b, 1.0f);
+
+                if (1)//!mHideByCost || (mHidingCost < importance)) 
+                {
+                        RenderViewCell(vc);
+                }
+        }
+}
+
+
+
+/**********************************************************************/
+/*              QtRendererControlWidget implementation                */
+/**********************************************************************/
+
+#if 1
 QGroupBox *QtRendererControlWidget::CreateVisualizationPanel(QWidget *parent)
 {
@@ -1527 +1572 @@
 }
 
+
 QtRendererControlWidget::QtRendererControlWidget(QWidget * parent, Qt::WFlags f):
 QWidget(parent, f)
@@ -1843 +1889 @@
 void
 QtRendererControlWidget::FocusNextPvsErrorFrame(void)
-{
-
-
-}
+{}
 
 void
@@ -1865 +1908 @@
 
 
+
+#endif
+
+
+/*********************************************************************/
+/*                   QtGlDebuggerWidget implementation               */
+/*********************************************************************/
+
+
+QtGlDebuggerWidget::QtGlDebuggerWidget(QtGlRendererBuffer *buf, QWidget *parent)
+: QGLWidget(QGLFormat(QGL::SampleBuffers), parent), mRenderBuffer(buf)
+{
+        // create the pbuffer
+        //pbuffer = new QGLPixelBuffer(QSize(512, 512), format(), this);
+        timerId = startTimer(20);
+        setWindowTitle(("OpenGL pbuffers"));
+}
+
+
+QtGlDebuggerWidget::~QtGlDebuggerWidget()
+{
+        mRenderBuffer->releaseFromDynamicTexture();
+        glDeleteTextures(1, &dynamicTexture);
+
+        DEL_PTR(mRenderBuffer);
+}
+
+
 void QtGlDebuggerWidget::initializeGL()
 {
@@ -1945 +2016 @@
 }
 
+
 void QtGlDebuggerWidget::initCommon()
 {
@@ -1954 +2026 @@
 
 
-
-}
+}