Text archives Help

---

Author: abhinav
Date: Thu May 12 16:55:11 2005
New Revision: 297

Added:
   trunk/Engine/ImageTraversers/FramelessImageTraverser.cc
   trunk/Engine/ImageTraversers/FramelessImageTraverser.h
Modified:
   trunk/Engine/Control/RTRT_register.cc
   trunk/Engine/ImageTraversers/CMakeLists.txt
   trunk/Image/SimpleImage.h
   trunk/Interface/Fragment.h
   trunk/Interface/RTRTInterface.h
Log:
SimpleImage - fixed the consecutiveX flag
RTRTInterface.h added FixedSamplingRate to TimeMode (not yet used)
Fragment.h: added empty constructor and a frameless fragment of rendomply 
placed samples in a tile.
RTRT_register.cc: registered framelessImageTraverser

FramelessImageTraveser.cc/.h: implements a traditional frameless renderer by 
a fixed amount of random samples per frame.  Still need to fix the display 
which seems double buffered.
CMakeLists.txt; added the new files for compilation.

- Abhinav



Modified: trunk/Engine/Control/RTRT_register.cc
==============================================================================
--- trunk/Engine/Control/RTRT_register.cc       (original)
+++ trunk/Engine/Control/RTRT_register.cc       Thu May 12 16:55:11 2005
@@ -4,6 +4,7 @@
 #include <Engine/IdleModes/ZoomIdleMode.h>
 #include <Engine/ImageTraversers/NullImageTraverser.h>
 #include <Engine/ImageTraversers/TiledImageTraverser.h>
+#include <Engine/ImageTraversers/FramelessImageTraverser.h>
 #include <Engine/LoadBalancers/CyclicLoadBalancer.h>
 #include <Engine/LoadBalancers/SimpleLoadBalancer.h>
 #include <Engine/LoadBalancers/WQLoadBalancer.h>
@@ -43,6 +44,8 @@
     rtrt->registerComponent("null", &NullImageTraverser::create);
    
     rtrt->registerComponent("tiled", &TiledImageTraverser::create);
+         
+    rtrt->registerComponent("frameless", &FramelessImageTraverser::create);
 
     // Register image types
     rtrt->registerComponent("null", &NullImage::create);

Modified: trunk/Engine/ImageTraversers/CMakeLists.txt
==============================================================================
--- trunk/Engine/ImageTraversers/CMakeLists.txt (original)
+++ trunk/Engine/ImageTraversers/CMakeLists.txt Thu May 12 16:55:11 2005
@@ -2,4 +2,5 @@
 SET (Manta_ImageTraversers_SRCS
      ImageTraversers/NullImageTraverser.cc
      ImageTraversers/TiledImageTraverser.cc
+     ImageTraversers/FramelessImageTraverser.cc
      )

Added: trunk/Engine/ImageTraversers/FramelessImageTraverser.cc
==============================================================================
--- (empty file)
+++ trunk/Engine/ImageTraversers/FramelessImageTraverser.cc     Thu May 12 
16:55:11 2005
@@ -0,0 +1,182 @@
+
+#include <Engine/ImageTraversers/FramelessImageTraverser.h>
+#include <Interface/RayPacket.h>
+#include <Interface/Renderer.h>
+#include <Core/Exceptions/IllegalArgument.h>
+#include <Core/Util/Args.h>
+#include <Interface/Context.h>
+#include <Interface/Fragment.h>
+#include <Interface/Image.h>
+#include <Interface/LoadBalancer.h>
+#include <Interface/PixelSampler.h>
+#include <Core/Thread/Mutex.h>
+#include <Core/Util/NotFinished.h>
+
+using namespace Manta;
+
+// args are the command line options, if the user wants to pas to th eimage 
traverser
+// look in TiledimageTraverser.cc for usage
+ImageTraverser* FramelessImageTraverser::create(const vector<string>& args)
+{
+  return new FramelessImageTraverser(args);
+}
+
+FramelessImageTraverser::FramelessImageTraverser(const vector<string>& args)
+{
+  xtilesize = 16; // should be a decent tile, not very big and not very small
+  ytilesize = 16;
+  shuffledTiles = NULL;
+  myRandomNumber = NULL;
+  int argc = static_cast<int>(args.size());
+  for(int i = 0; i<argc;i++){
+    string arg = args[i];
+    if(arg == "-tilesize"){
+      if(!getResolutionArg(i, args, xtilesize, ytilesize))
+       throw IllegalArgument("FramelessImageTraverser -tilesize", i, args);
+    } else {
+      throw IllegalArgument("FramelessImageTraverser", i, args);
+    }
+  }
+}
+
+FramelessImageTraverser::~FramelessImageTraverser()
+{
+  //TODO
+  if(myRandomNumber!=NULL) delete [] myRandomNumber;
+  if(shuffledTiles!=NULL) delete [] shuffledTiles;
+}
+
+void FramelessImageTraverser::setupBegin(const SetupContext& context, int 
numChannels)
+{
+  //context.constrainPipelineDepth(1,1);
+  context.loadBalancer->setupBegin(context, numChannels);
+  // do not need a pixelSampler since we directly access renderer here
+  //context.pixelSampler->setupBegin(context, numChannels);
+}
+
+// shuffles the uniformly row ordered 2D tiles
+void FramelessImageTraverser::shuffleMyTiles()
+{
+       int i,j,k;
+       UniformTiles temp;
+       
+       for(i=0; i<xtiles*ytiles*2; i++)
+       {
+               j = (int)(myRandomNumber[0].genfrand()*(xtiles*ytiles-1));
+               k = (int)(myRandomNumber[0].genfrand()*(xtiles*ytiles-1));
+    ASSERT(j<xtiles*ytiles);
+    ASSERT(k<xtiles*ytiles);
+               temp = shuffledTiles[j];
+               shuffledTiles[j] = shuffledTiles[k];
+               shuffledTiles[k] = temp;
+       }
+}
+
+void FramelessImageTraverser::setupDisplayChannel(const SetupContext& 
context)
+{
+  bool stereo; // get whether it is stereo, (shoot two rays for left and 
right eye)
+  int i, j, k;
+  int xres,yres;
+  context.getResolution(stereo, xres, yres);
+  myRandomNumber = new MT_RNG[context.numProcs];
+  for(i=0; i<context.numProcs; i++)
+       myRandomNumber[i].seed_rng(1234); // just to begin give a simple seed
+  xtiles = (xres + xtilesize-1)/xtilesize;
+  ytiles = (yres + ytilesize-1)/ytilesize;
+       
+  // allocate unifrom row ordered tiles
+  shuffledTiles = new UniformTiles[xtiles*ytiles];
+  for(i=0; i<xtiles*ytiles; i++)
+  {
+         j = i%ytiles;
+         k = i/ytiles;
+         shuffledTiles[i].xstart = j*xtilesize;
+         shuffledTiles[i].xend = (j+1)*xtilesize;
+         shuffledTiles[i].ystart = k*ytilesize;
+         shuffledTiles[i].yend = (k+1)*ytilesize;
+         if(shuffledTiles[i].xend>xres)
+                 shuffledTiles[i].xend = xres;
+         if(shuffledTiles[i].yend>yres)
+                 shuffledTiles[i].yend = yres;  
+  }
+  
+  shuffleMyTiles(); // shuffle them up
+  
+  int numAssignments = xtiles * ytiles;        // these will be the number 
of assignments to make to threads
+  context.loadBalancer->setupDisplayChannel(context, numAssignments);
+  //context.pixelSampler->setupDisplayChannel(context);
+}
+
+void FramelessImageTraverser::setupFrame(const RenderContext& context)
+{
+  context.loadBalancer->setupFrame(context);
+  //context.pixelSampler->setupFrame(context); // we dont need a pixel 
sampler, we will access renderer directly
+}
+
+void FramelessImageTraverser::renderFragment(const RenderContext& context,
+                                  Fragment& fragment, int xres, int yres)
+{
+  int flags = RayPacket::HaveImageCoordinates;
+       
+  if(fragment.getFlags() & Fragment::ConstantEye)
+    flags |= RayPacket::ConstantEye;
+  
+  for(int f=0;f<fragment.getSize();f+=RayPacket::MaxSize)
+  {
+    int size = RayPacket::MaxSize;
+         if(size<fragment.getSize()) size = fragment.getSize();
+    if(size >= fragment.getSize()-f)
+      size = fragment.getSize()-f;
+    // Create a ray packet
+    int depth = 0;
+    RayPacketData raydata;
+    RayPacket rays(raydata, size, depth, flags);
+
+    for(int i=0;i<size;i++)
+       {
+               Fragment::Element& fe = fragment.get(f+i);
+               double px = (double)(-1.0 + 
2.0*(double)(fe.x+0.5)/(double)xres); // normalized
+               double py = (double)(-1.0 + 
2.0*(double)(fe.y+0.5)/(double)yres);
+    //printf("%f, %f\n", (float)px, (float)py);
+               rays.setPixel(i, 0, px, py, &fe.color);
+    }
+
+       // Trace the rays.  The results will automatically go into the 
fragment  
+       context.renderer->traceEyeRays(context, rays);
+  }
+}
+
+void FramelessImageTraverser::renderImage(const RenderContext& context, 
Image* image)
+{
+       /*
+       basically do the following, for every tile select some samples 
randomly
+       and ray trace them directly, thats all.
+       */
+       
+  bool stereo;
+  int xres, yres;
+  image->getResolution(stereo, xres, yres);
+  int s,e;
+// this is what every thread does: gets the next assignment and render it.
+  while(context.loadBalancer->getNextAssignment(context, s, e))
+  {
+    for(int assignment = s; assignment < e; assignment++)
+       {
+               int size = 8;
+               Fragment fragment;
+               fragment.createRandom(size, shuffledTiles[assignment].xstart, 
shuffledTiles[assignment].ystart,
+                                                       
shuffledTiles[assignment].xend, shuffledTiles[assignment].yend, 
+                                                       0, 
myRandomNumber[context.proc]);
+               renderFragment(context, fragment, xres, yres);
+    /*for(int i = 0; i < fragment.getSize(); i++) {
+      Fragment::Element& e = fragment.get(i);
+      //printf("%d,%d\n", e.x, e.y);
+      float val = ((float)e.x/xres)*((float)e.y/yres);
+      e.color = Color(GrayColor(val));
+    }*/
+               image->set(fragment);
+       }
+  }
+  if(context.proc == 0)
+    image->setValid(true);
+}

Added: trunk/Engine/ImageTraversers/FramelessImageTraverser.h
==============================================================================
--- (empty file)
+++ trunk/Engine/ImageTraversers/FramelessImageTraverser.h      Thu May 12 
16:55:11 2005
@@ -0,0 +1,39 @@
+
+#ifndef Manta_Engine_FramelessImageTraverser_h
+#define Manta_Engine_FramelessImageTraverser_h
+
+#include <Interface/ImageTraverser.h>
+#include <Interface/Fragment.h>
+#include <sgi_stl_warnings_off.h>
+#include <string>
+#include <vector>
+#include <sgi_stl_warnings_on.h>
+
+namespace Manta {
+  using namespace std;
+  struct UniformTiles
+  {
+         int xstart, ystart, xend, yend;
+  };
+  class FramelessImageTraverser : public ImageTraverser {
+  public:
+    FramelessImageTraverser(const vector<string>& args);
+    virtual ~FramelessImageTraverser();
+    virtual void setupBegin(const SetupContext&, int numChannels);
+    virtual void setupDisplayChannel(const SetupContext&);
+    virtual void setupFrame(const RenderContext& context);
+    virtual void renderImage(const RenderContext& context, Image* image);
+       void shuffleMyTiles();
+    void renderFragment(const RenderContext& context, Fragment& fragment, 
int xres, int yres);
+    static ImageTraverser* create(const vector<string>& args);
+  private:
+    FramelessImageTraverser(const FramelessImageTraverser&);
+    FramelessImageTraverser& operator=(const FramelessImageTraverser&);
+       int xtilesize, ytilesize;
+       UniformTiles *shuffledTiles;
+    int xtiles,ytiles;
+       MT_RNG *myRandomNumber;
+  };
+}
+
+#endif

Modified: trunk/Image/SimpleImage.h
==============================================================================
--- trunk/Image/SimpleImage.h   (original)
+++ trunk/Image/SimpleImage.h   Thu May 12 16:55:11 2005
@@ -104,7 +104,8 @@
   template<class Pixel>
   void SimpleImage<Pixel>::set(const Fragment& fragment)
   {
-    if(fragment.getFlags() & (Fragment::ConsecutiveX|Fragment::ConstantEye)){
+    if(fragment.getFlags() & (Fragment::ConsecutiveX|Fragment::ConstantEye) 
+         == (Fragment::ConsecutiveX|Fragment::ConstantEye)){
       int nf = fragment.getSize();
       Pixel* pix = 
eyeStart[fragment.get(0).which_eye][fragment.get(0).y]+fragment.get(0).x;
       for(int i=0;i<nf;i++)

Modified: trunk/Interface/Fragment.h
==============================================================================
--- trunk/Interface/Fragment.h  (original)
+++ trunk/Interface/Fragment.h  Thu May 12 16:55:11 2005
@@ -18,6 +18,7 @@
 
 #include <Core/Color/Color.h>
 #include <Core/Util/FancyAssert.h>
+#include <Core/Math/MT_RNG.h>
 
 // TODO:
 //
@@ -34,6 +35,7 @@
     static const int ConsecutiveX    = 0x01;  // Implies a constant Y:
     static const int ConstantEye = 0x02;
 
+       Fragment() {} // empty constructor
     // Creates a "Scan-line" fragment.
     Fragment(int which_eye, int xstart, int xend, int y) {
       ASSERTRANGE(xend-xstart, 0, MaxFragmentSize+1);
@@ -46,9 +48,25 @@
       flags = ConsecutiveX|ConstantEye;
       size = nx;
     }
+       
     ~Fragment() {
     }
-    
+       
+    void createRandom(int numElements, int xstart, int ystart, int xend, int 
yend, int which_eye, MT_RNG &myRandomNumber)
+       {
+               size = numElements;
+               flags = ConstantEye;
+               for(int i=0;i<size;i++)
+               {
+                       data[i].x = 
(int)(xstart+myRandomNumber.genfrand()*(xend - xstart));
+                       data[i].y = 
(int)(ystart+myRandomNumber.genfrand()*(yend - ystart));
+      //data[i].x = (int)(xstart+0.5*(xend - xstart));
+                       //data[i].y = (int)(ystart+0.5*(yend - ystart));
+      //printf("%d,%d\n", data[i].x, data[i].y);
+                       data[i].which_eye = which_eye;
+               }
+       }
+       
     int getFlags() const {
       return flags;
     }
@@ -65,7 +83,8 @@
 
     // Represents a Pixel
     struct Element {
-      int x, y;      // Pixel position in image space
+         // Pixel position in image space
+         int x, y;
       int which_eye; // monocular: always 0, stereo: 0=left, 1=right
       Color color;   // Final result
     };

Modified: trunk/Interface/RTRTInterface.h
==============================================================================
--- trunk/Interface/RTRTInterface.h     (original)
+++ trunk/Interface/RTRTInterface.h     Thu May 12 16:55:11 2005
@@ -120,7 +120,7 @@
     
     // Settings
     enum TimeMode {
-      RealTime, FixedRate, Static
+      RealTime, FixedRate, Static, FixedSamplingRate
     };
     virtual void setTimeMode(TimeMode tm, double rate) = 0;
 

---

• [MANTA] r297 - in trunk: Engine/Control Engine/ImageTraversers Image Interface, abhinav, 05/12/2005

---

Archive powered by MHonArc 2.6.16.