Text archives Help

---

Author: boulos
Date: Fri Nov  2 15:15:32 2007
New Revision: 1804

Modified:
   trunk/Engine/Control/RTRT.cc
   trunk/Engine/ImageTraversers/DeadlineImageTraverser.cc
   trunk/Engine/ImageTraversers/DeadlineImageTraverser.h
   trunk/Engine/PixelSamplers/SingleSampler.cc
   trunk/Engine/PixelSamplers/SingleSampler.h
Log:
Engine/ImageTraversers/DeadlineImageTraverser.cc
Engine/ImageTraversers/DeadlineImageTraverser.h

 DeadlineImageTraverser now swaps out SampleGenerators using
 const_cost evilness. Better pictures result.

Engine/PixelSamplers/SingleSampler.cc
Engine/PixelSamplers/SingleSampler.h

 Updating SingleSampler to compute the region_id as well.


Modified: trunk/Engine/Control/RTRT.cc
==============================================================================
--- trunk/Engine/Control/RTRT.cc        (original)
+++ trunk/Engine/Control/RTRT.cc        Fri Nov  2 15:15:32 2007
@@ -175,7 +175,7 @@
 
   //currentSampleGenerator = new ConstantSampleGenerator(0.f);
   currentSampleGenerator = new UniformRandomGenerator();
-  //currentSampleGenerator = new Stratified2D(64);
+  //currentSampleGenerator = new Stratified2D(81);
 }
 
 RTRT::~RTRT()

Modified: trunk/Engine/ImageTraversers/DeadlineImageTraverser.cc
==============================================================================
--- trunk/Engine/ImageTraversers/DeadlineImageTraverser.cc      (original)
+++ trunk/Engine/ImageTraversers/DeadlineImageTraverser.cc      Fri Nov  2 
15:15:32 2007
@@ -50,6 +50,9 @@
 #include <Interface/PixelSampler.h>
 #include <Engine/PixelSamplers/SingleSampler.h>
 #include <Engine/PixelSamplers/JitterSampler.h>
+#include <Engine/SampleGenerators/ConstantSampleGenerator.h>
+#include <Engine/SampleGenerators/Stratified2D.h>
+#include <Engine/SampleGenerators/UniformRandomGenerator.h>
 #include <Interface/RayPacket.h> // for maxsize
 #include <Core/Util/CPUTime.h>
 #include <MantaSSE.h>
@@ -58,6 +61,9 @@
 
 using namespace Manta;
 
+#define BLEND_OLD_SAMPLES 0
+#define USE_SAMPLE_GEN 1
+
 ImageTraverser* DeadlineImageTraverser::create(const vector<string>& args)
 {
   return new DeadlineImageTraverser(args);
@@ -119,6 +125,8 @@
   singleSampler = new SingleSampler(vector<string>());
 
   jitterSamplers = new JitterSampler*[kNumJitterLevels];
+  sampleGenerators = new SampleGenerator*[kNumJitterLevels + 1];
+  sampleGenerators[0] = new UniformRandomGenerator();
   int num_spp = 4;
   for (int i = 0; i < kNumJitterLevels; i++) {
     vector<string> args;
@@ -129,6 +137,7 @@
     r << num_spp;
     args.push_back(r.str());
     jitterSamplers[i] = new JitterSampler(args);
+    sampleGenerators[i+1] = new Stratified2D(num_spp);
     num_spp *= 4;
   }
 }
@@ -142,6 +151,9 @@
   for (int i = 0; i < kNumJitterLevels; i++) {
     jitterSamplers[i]->setupBegin(context, numChannels);
   }
+  for (int i = 0; i < kNumJitterLevels + 1; i++) {
+    sampleGenerators[i]->setupBegin(context, numChannels);
+  }
   context.loadBalancer->setupBegin(context, numChannels);
   context.pixelSampler->setupBegin(context, numChannels);
 
@@ -209,6 +221,10 @@
   for (int i = 0; i < kNumJitterLevels; i++) {
     jitterSamplers[i]->setupDisplayChannel(context);
   }
+
+  for (int i = 0; i < kNumJitterLevels + 1; i++) {
+    sampleGenerators[i]->setupDisplayChannel(context);
+  }
 }
 
 void DeadlineImageTraverser::setupFrame(const RenderContext& context)
@@ -239,6 +255,9 @@
   for (int i = 0; i < kNumJitterLevels; i++) {
     jitterSamplers[i]->setupFrame(context);
   }
+  for (int i = 0; i < kNumJitterLevels + 1; i++) {
+    sampleGenerators[i]->setupFrame(context);
+  }
   // Determine how long we should render this frame.
   frameEnd = CPUTime::currentSeconds() + frameTime;
   if (context.proc == 0) {
@@ -281,6 +300,11 @@
   image->getResolution(stereo, xres, yres);
   int numEyes = stereo?2:1;
 
+#if USE_SAMPLE_GEN
+  RenderContext& mutable_context = const_cast<RenderContext&>(context);
+  SampleGenerator* original_samplegen = context.sample_generator;
+#endif
+
   // NOTE(boulos): Only the coarse_yres and ytiles variables are being
   // used to determine the xtile and ytile of the assignment.
 
@@ -328,6 +352,9 @@
         }
         frag.setSize(idx);
         if((xcoarsepixelsize | ycoarsepixelsize) > 1){
+#if USE_SAMPLE_GEN
+          mutable_context.sample_generator = sampleGenerators[0];
+#endif
           singleSampler->renderFragment(context, frag);
 
           //Tile* tile = new Tile;
@@ -343,6 +370,9 @@
           computePriority(tile, frag);
           insertIntoQueue(tile, static_cast<size_t>(context.proc));
         } else {
+#if USE_SAMPLE_GEN
+          mutable_context.sample_generator = sampleGenerators[0];
+#endif
           context.pixelSampler->renderFragment(context, frag);
         }
         image->set(frag);
@@ -390,21 +420,36 @@
       case 4:
         //cerr << "Using a 4 spp sampler" << endl;
         jitter_sampler = jitterSamplers[0];
+#if USE_SAMPLE_GEN
+        mutable_context.sample_generator = sampleGenerators[1];
+#endif
         break;
       case 16:
         //cerr << "Using a 16 spp sampler" << endl;
         jitter_sampler = jitterSamplers[1];
+#if USE_SAMPLE_GEN
+        mutable_context.sample_generator = sampleGenerators[2];
+#endif
         break;
       case 64:
         //cerr << "Using a 64 spp sampler" << endl;
         jitter_sampler = jitterSamplers[2];
+#if USE_SAMPLE_GEN
+        mutable_context.sample_generator = sampleGenerators[3];
+#endif
         break;
       case 256:
         //cerr << "Using a 256 spp sampler" << endl;
         jitter_sampler = jitterSamplers[3];
+#if USE_SAMPLE_GEN
+        mutable_context.sample_generator = sampleGenerators[4];
+#endif
         break;
       case 1024:
         jitter_sampler = jitterSamplers[4];
+#if USE_SAMPLE_GEN
+        mutable_context.sample_generator = sampleGenerators[5];
+#endif
         break;
       default:
         throw SCIRun::InternalError("Expected either 4, 16, 64, 256, or 1024 
spp", __FILE__, __LINE__);
@@ -552,6 +597,9 @@
 
           // NOTE(boulos): We know that we don't just stop anymore due
           // to super sampling
+#if USE_SAMPLE_GEN
+          mutable_context.sample_generator = sampleGenerators[0];
+#endif
           singleSampler->renderFragment(context, frag);
           //Tile* childtile = new Tile;
           ASSERT(context.proc < DeadlineImageTraverser::kMaxThreads);
@@ -578,6 +626,9 @@
   // This can potentially happen before the other procesors are finished
   // rendering, but that is okay because it won't get displayed until
   // everyone enters the barrier anyway
+#if USE_SAMPLE_GEN
+  mutable_context.sample_generator = original_samplegen;
+#endif
   if(context.proc == 0)
     image->setValid(true);
 }

Modified: trunk/Engine/ImageTraversers/DeadlineImageTraverser.h
==============================================================================
--- trunk/Engine/ImageTraversers/DeadlineImageTraverser.h       (original)
+++ trunk/Engine/ImageTraversers/DeadlineImageTraverser.h       Fri Nov  2 
15:15:32 2007
@@ -45,6 +45,7 @@
 
 namespace Manta {
   using namespace std;
+  class SampleGenerator;
   class SingleSampler;
   class JitterSampler;
 
@@ -71,6 +72,8 @@
 
     SingleSampler* singleSampler;
     JitterSampler** jitterSamplers; // An array of different jittered 
samplers
+
+    SampleGenerator** sampleGenerators; // An array of sample generators for 
each refinement level
 
     int xpacketsize;
     int ypacketsize;

Modified: trunk/Engine/PixelSamplers/SingleSampler.cc
==============================================================================
--- trunk/Engine/PixelSamplers/SingleSampler.cc (original)
+++ trunk/Engine/PixelSamplers/SingleSampler.cc Fri Nov  2 15:15:32 2007
@@ -31,14 +31,13 @@
 {
   ChannelInfo& ci = channelInfo[context.channelIndex];
   bool stereo;
-  int xres, yres;
-  context.getResolution(stereo, xres, yres);
+  context.getResolution(stereo, ci.xres, ci.yres);
 
   // Set up the scale from -1 to 1
-  ci.xscale = (Real)2/xres;
-  ci.yscale = (Real)2/yres;
-  ci.xoffset = (-xres/(Real)2+(Real)0.5)*ci.xscale; // Offset to pixel center
-  ci.yoffset = (-yres/(Real)2+(Real)0.5)*ci.yscale;
+  ci.xscale = (Real)2/ci.xres;
+  ci.yscale = (Real)2/ci.yres;
+  ci.xoffset = (-ci.xres/(Real)2+(Real)0.5)*ci.xscale; // Offset to pixel 
center
+  ci.yoffset = (-ci.yres/(Real)2+(Real)0.5)*ci.yscale;
   context.renderer->setupDisplayChannel(context);
 }
 
@@ -76,6 +75,7 @@
       Real px = fragment.getX(f)*ci.xscale+ci.xoffset;
       Real py = fragment.getY(f)*ci.yscale+ci.yoffset;
       int eye = fragment.getWhichEye(f);
+      int pixel_id = fragment.getY(f) * ci.xres + fragment.getX(f);
 
 #if MANTA_SSE
       // The code used to load in the values using _mm_set_ps, but
@@ -86,20 +86,24 @@
                                            ci.xscale,
                                            ci.xscale+ci.xscale,
                                            ci.xscale+ci.xscale+ci.xscale};
+      MANTA_ALIGN(16) int pixel_addition[4] = {0, 1, 2, 3};
       __m128 vec_xscale_cascade = _mm_load_ps(cascade4);
       __m128 vec_px = _mm_add_ps(_mm_set1_ps(px), vec_xscale_cascade);
       __m128 vec_py = _mm_set1_ps(py);
       __m128i vec_eye = _mm_set1_epi32(eye);
+      __m128i vec_pixel_id = _mm_add_epi32(_mm_set1_epi32(pixel_id),
+                                           
_mm_load_si128((__m128i*)&pixel_addition));
       RayPacketData* data = rays.data;
       int e = size&(~3);
       __m128 vec_xscale4 = _mm_set1_ps(ci.xscale*4);
       for(int i=0;i<e;i+=4){
         _mm_store_si128((__m128i*)&data->whichEye[i], vec_eye);
         _mm_store_si128((__m128i*)&data->sample_id[i], _mm_set1_epi32(0));
-
+        _mm_store_si128((__m128i*)&data->region_id[i], vec_pixel_id);
         _mm_store_ps(&data->image[0][i], vec_px);
         _mm_store_ps(&data->image[1][i], vec_py);
         vec_px = _mm_add_ps(vec_px, vec_xscale4);
+        vec_pixel_id = _mm_add_epi32(vec_pixel_id, _mm_set1_epi32(4));
       }
       px += e*ci.xscale;
 #else
@@ -108,6 +112,7 @@
       for(int i=e;i<size;i++){
         rays.setPixel(i, eye, px, py);
         rays.data->sample_id[i] = 0;
+        rays.data->region_id[i] = pixel_id + i;
         px += ci.xscale;
       }
     }
@@ -122,6 +127,7 @@
 
         rays.setPixel(i, fragment.getWhichEye(f+i), px, py);
         rays.data->sample_id[i] = 0;
+        rays.data->region_id[i] = fragment.getY(f+i) * ci.xres + 
fragment.getX(f+i);
       }
     }
     // Otherwise, set each pixel individually.
@@ -136,11 +142,14 @@
       for(int i=0;i<e;i+=4) {
         _mm_store_si128((__m128i*)&data->whichEye[i], 
_mm_load_si128((__m128i*)&fragment.whichEye[f+i]));
         _mm_store_si128((__m128i*)&data->sample_id[i], _mm_set1_epi32(0));
-        __m128 fx = 
_mm_cvtepi32_ps(_mm_load_si128((__m128i*)&fragment.pixel[0][f+i]));
+        __m128i x_pixel = _mm_load_si128((__m128i*)&fragment.pixel[0][f+i]);
+        __m128 fx = _mm_cvtepi32_ps(x_pixel);
         _mm_store_ps(&data->image[0][i], _mm_add_ps(_mm_mul_ps(fx, 
vec_xscale), vec_xoffset));
-        __m128 fy = 
_mm_cvtepi32_ps(_mm_load_si128((__m128i*)&fragment.pixel[1][f+i]));
+        __m128i y_pixel = _mm_load_si128((__m128i*)&fragment.pixel[1][f+i]);
+        __m128 fy = _mm_cvtepi32_ps(y_pixel);
         _mm_store_ps(&data->image[1][i], _mm_add_ps(_mm_mul_ps(fy, 
vec_yscale), vec_yoffset));
-
+        __m128i pixel_id = _mm_add_epi32(_mm_mullo_epi32(y_pixel, 
_mm_set1_epi32(ci.xres)), x_pixel);
+        _mm_store_si128((__m128i*)&data->region_id[i], pixel_id);
       }
 #else
       int e = 0;
@@ -150,6 +159,7 @@
         Real py = fragment.getY(f+i)*ci.yscale+ci.yoffset;
         rays.setPixel(i, fragment.getWhichEye(f+i), px, py);
         rays.data->sample_id[i] = 0;
+        rays.data->region_id[i] = fragment.getY(f+i) * ci.xres + 
fragment.getX(f+i);
       }
     }
 

Modified: trunk/Engine/PixelSamplers/SingleSampler.h
==============================================================================
--- trunk/Engine/PixelSamplers/SingleSampler.h  (original)
+++ trunk/Engine/PixelSamplers/SingleSampler.h  Fri Nov  2 15:15:32 2007
@@ -19,7 +19,7 @@
     virtual void setupDisplayChannel(SetupContext&);
     virtual void setupFrame(const RenderContext& context);
     virtual void renderFragment(const RenderContext& context,
-                               Fragment& fragment);
+                                Fragment& fragment);
 
     static PixelSampler* create(const vector<string>& args);
   private:
@@ -31,6 +31,7 @@
       Real xoffset;
       Real yscale;
       Real yoffset;
+      int xres, yres;
     };
     vector<ChannelInfo> channelInfo;
   };

---

• [Manta] r1804 - in trunk/Engine: Control ImageTraversers PixelSamplers, boulos, 11/02/2007

---

Archive powered by MHonArc 2.6.16.