Text archives Help

---

Author: abhinav
Date: Wed Aug 31 02:14:16 2005
New Revision: 523

Modified:
   branches/AFR/Engine/ImageTraversers/AFImageTraverser.cc
   branches/AFR/Engine/ImageTraversers/AFR/kdtree.cc
   branches/AFR/Engine/ImageTraversers/AFR/kdtree.h
   branches/AFR/Engine/ImageTraversers/AFR/tiles.cc
   branches/AFR/Engine/ImageTraversers/AFR/tiles.h
Log:
few bug fixes
added feature to have a mx_tree_depth of 16 only and max 4096 tiles 
regardless of imagesize.

will be adding a commandline parameter to set this later




Modified: branches/AFR/Engine/ImageTraversers/AFImageTraverser.cc
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFImageTraverser.cc     (original)
+++ branches/AFR/Engine/ImageTraversers/AFImageTraverser.cc     Wed Aug 31 
02:14:16 2005
@@ -498,9 +498,6 @@
     cx = sx+offset[i][0];
     cy = sy+offset[i][1];
 
-    //cout << "raytracing: " << cx << ", " << cy << endl;
-    // we will jitter later, now just add 0.5 <TODO>
-    
     if(xres > yres) // let the smaller dimension be mapped to [-1,1]
     {
       px = (double)(-1.0 + 2.0*cx/(double)yres); 
@@ -560,13 +557,13 @@
   int myID = context.proc;
   int fsize = chunk_size;
   float t = (float)chunkTimeStamp[myID];
-  /*if(initpass[myID])
+  if(initpass[myID])
   {
     fsize = (chunk_size>(qSize-temporalQ[myID].getN()))? chunk_size : 
qSize-temporalQ[myID].getN();
     if((fsize + temporalQ[myID].getN()) > temporalQ[myID].getMaxSize())
        fsize = temporalQ[myID].getMaxSize() - temporalQ[myID].getN() -1;
     //cout << "fsize = " << fsize << endl;
-  }*/
+  }
   Color color[RayPacket::MaxSize];
   //Sample newSample[RayPacket::MaxSize];
   //cout << "fsize = " << fsize << ", myID = " << myID << endl;
@@ -589,32 +586,32 @@
     // Copy samples from the sampleQ into the fragment.
     for(i=0;i<size;i++) {
       kdtree[myID].getRandomSamplefromTile(tindex, cx, cy, 
myRandomNumber[myID]);
+      if(cx<0) cx=0; if(cx>=xres) cx = xres-1;
+      if(cy<0) cy=0; if(cy>=yres) cy = yres-1;
+     
       // cout << "f+i = " << f+i << endl;
-      newSample[myID][f+i].viewCoord[0] = cx;
-      newSample[myID][f+i].viewCoord[1] = cy;
+      double jitterx, jittery;
+      jitterx = myRandomNumber[myID].genfrand();
+      jittery = myRandomNumber[myID].genfrand();
+      newSample[myID][f+i].viewCoord[0] = (float)cx+jitterx;
+      newSample[myID][f+i].viewCoord[1] = (float)cy+jittery;
+      // cout << "raytracing: " << cx << ", " << cy << endl;
       newSample[myID][f+i].tileindex = tindex;
       newSample[myID][f+i].t = t;
       // normalized
       double px, py;
                        
-      // cout << "raytracing: " << cx << ", " << cy << endl;
-      // we will jitter later, now just add 0.5 <TODO>
-      double jitterx, jittery;
-      jitterx = myRandomNumber[myID].genfrand();
-      jittery = myRandomNumber[myID].genfrand();
       if(xres>yres) // let the smaller dimension be mapped to [-1,1]
         {
-          px = (double)(-1.0 + 
2.0*((double)newSample[myID][f+i].viewCoord[0]+jitterx)/(double)yres); 
-          py = (double)(-1.0 + 
2.0*((double)newSample[myID][f+i].viewCoord[1]+jittery)/(double)yres);
+          px = (double)(-1.0 + 
2.0*((double)newSample[myID][f+i].viewCoord[0])/(double)yres); 
+          py = (double)(-1.0 + 
2.0*((double)newSample[myID][f+i].viewCoord[1])/(double)yres);
         }
       else
         {
-          px = (double)(-1.0 + 
2.0*((double)newSample[myID][f+i].viewCoord[0]+jitterx)/(double)xres); 
-          py = (double)(-1.0 + 
2.0*((double)newSample[myID][f+i].viewCoord[1]+jittery)/(double)xres);
+          px = (double)(-1.0 + 
2.0*((double)newSample[myID][f+i].viewCoord[0])/(double)xres); 
+          py = (double)(-1.0 + 
2.0*((double)newSample[myID][f+i].viewCoord[1])/(double)xres);
         }  
                                
-      if(px<-1.0) px = -1.0; if(px>1.0) px = 1.0;
-      if(py<-1.0) py = -1.0; if(py>1.0) py = 1.0;
       // samples_done[context.proc] ++;
       samples_done[context.proc].addOne();
       
@@ -733,7 +730,8 @@
     for(i=0; i<fsize; i++)
       temporalQ[myID].qDelete();
                
-       //cout << "fsize = " << fsize << endl;
+    //cout << "fsize = " << fsize << endl;
+    //if(fsize <= 0)
     for(i=0; i<chunk_size; i++) {
                
       sp = temporalQ[myID].seekLast();

Modified: branches/AFR/Engine/ImageTraversers/AFR/kdtree.cc
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFR/kdtree.cc   (original)
+++ branches/AFR/Engine/ImageTraversers/AFR/kdtree.cc   Wed Aug 31 02:14:16 
2005
@@ -33,9 +33,21 @@
 {
        myRandomNumber.seed_rng(1234); // just to begin give a simple seed
        numLevels = 0;
+       // get nearest power of 2
+       int newwidth=1, newheight=1;
+       while(newwidth<width)
+       {
+         newwidth*=2;
+       }
+       while(newheight<height)
+       {
+         newheight*=2;
+       }
+       
        rootwidth = width;
        rootheight = height;
-       int tsize = width*height;
+
+       int tsize = (newwidth<newheight)? newwidth*newwidth : 
newheight*newheight;
        invexp_init();
        while(tsize!=1)
        {
@@ -43,37 +55,51 @@
                tsize/=2;
        }
        numLevels -= 2;
-       /// cout << "numLevels = " << numLevels << endl;
+       if(Tile::max_tree_depth>numLevels)
+         Tile::max_tree_depth = numLevels;
+       else
+         numLevels = Tile::max_tree_depth;
+
+
+       cout << "numLevels = " << numLevels << endl;
        int i;
-       totalNodes = (int)(pow(2.0, numLevels+1));
-  /// cout << "totalNodes = " << totalNodes << endl;
+       totalNodes = (int)(pow(2.0, Tile::max_tree_depth+1));
+        cout << "totalNodes = " << totalNodes << endl;
        tile = new Tile[totalNodes]; // allocate memory to our array based 
tree
        // now we will assign the indices
 
-       Tile::leafMapping = (int**)malloc((width/2)*sizeof(int*));
-  /// cout << "leafmapping ranges until: " << (width/2) << ", " << 
(height/2) << endl;
-       for(i=0; i<width/2; i++)
+        int leafdim = (int)(pow(2.0,Tile::max_tree_depth/2));
+       cout << "leafdim sqr = " << leafdim*leafdim << ", #leafnodes = " << 
totalNodes - totalNodes/2 << endl;
+       Tile::leafMapping = (int**)malloc(leafdim*sizeof(int*));
+       for(i=0; i<leafdim; i++)
        {
-               Tile::leafMapping[i] = (int*)malloc((height/2)*sizeof(int));
+               Tile::leafMapping[i] = (int*)malloc(leafdim*sizeof(int));
        }
        buildtree(0, 1, 0, 0, width, height);
-       for(i=width*height/4; i<width*height/2; i++)
+       xfac = tile[totalNodes-1].getRight() - tile[totalNodes-1].getLeft();
+        yfac = tile[totalNodes-1].getTop() - tile[totalNodes-1].getBottom(); 
+       for(i=totalNodes/2; i<totalNodes; i++)
        {
                //printf("mapping: %d,%d = %d\n",tile[i].getLeft()/2, 
tile[i].getBottom()/2, i);
-               Tile::leafMapping[tile[i].getLeft()/2][tile[i].getBottom()/2] 
= i;      
+               
Tile::leafMapping[tile[i].getLeft()/xfac][tile[i].getBottom()/yfac] = i;      
  
        }
        //exit(1);
-       Tile::meanLevel = (numLevels/2);
-       Tile::max_tile_area = 1;
+       Tile::meanLevel = Tile::max_tree_depth/2 -1;
+       minTiles = 1;
+       Tile::max_tile_area = width*height;
        for(i=0; i<Tile::meanLevel; i++)
-               Tile::max_tile_area *= 2;
+       {
+         minTiles *= 2;
+         Tile::max_tile_area /= 2;
+       }
 
-       minTiles = Tile::max_tile_area;
-       maxTiles = minTiles*16;
-       setTileCut(Tile::meanLevel, 0, samplingrate);
-       
+       maxTiles = minTiles*32;
+       Tile::min_tile_area = tile[totalNodes-1].getTileSize()*2;
        cout << "meanLevel = " << Tile::meanLevel << endl;
        cout << "max_tile_area = " << Tile::max_tile_area << endl;
+       cout << "min_tile_area = " << Tile::min_tile_area << endl;
+       cout << "mintiles = " << minTiles << ", maxTiles = " << maxTiles << 
endl;
+       setTileCut(Tile::meanLevel, 0, samplingrate);
        return numLevels;
 }
 
@@ -492,7 +518,7 @@
        
        x = (int)newsampleset->viewX;
        y = (int)newsampleset->viewY;
-       int index = Tile::leafMapping[x/2][y/2];
+       int index = Tile::leafMapping[x/xfac][y/yfac];
        if(!tile[index].checkBounds(x,y)) return;
        int vtileindex=-1;
        while(tile[index].getLevel()>0)//=Tile::meanLevel-1)
@@ -512,7 +538,7 @@
        int x, y;
        x = (int)newsampleset->viewX;
        y = (int)newsampleset->viewY;
-       int index = Tile::leafMapping[x/2][y/2];
+       int index = Tile::leafMapping[x/xfac][y/yfac];
         if(!tile[index].checkBounds(x,y)) return;
        tile[index].updateStatsAddSampleSet(newsampleset, currenttime, A, B, 
tile, numTiles, samplingrate);
 #endif
@@ -529,7 +555,7 @@
        int x, y;
        x = (int)newsample->viewCoord[0];
        y = (int)newsample->viewCoord[1];
-       int index = Tile::leafMapping[x/2][y/2];
+       int index = Tile::leafMapping[x/xfac][y/yfac];
        if(!tile[index].checkBounds(x,y)) return;
        int vtileindex=-1;
        while(tile[index].getLevel()>0)//=Tile::meanLevel-1)
@@ -550,7 +576,7 @@
        int x, y;
        x = (int)newsample->viewCoord[0];
        y = (int)newsample->viewCoord[1];
-       int index = Tile::leafMapping[x/2][y/2];
+       int index = Tile::leafMapping[x/xfac][y/yfac];
        if(!tile[index].checkBounds(x,y)) return;
        tile[index].updateStatsAddSample(newsample, currenttime, A, B, tile, 
                                        numTiles, tgrad, occ, samplingrate);

Modified: branches/AFR/Engine/ImageTraversers/AFR/kdtree.h
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFR/kdtree.h    (original)
+++ branches/AFR/Engine/ImageTraversers/AFR/kdtree.h    Wed Aug 31 02:14:16 
2005
@@ -38,6 +38,8 @@
       int rootwidth, rootheight;
       int **samples, **reprojSamples;
       Tile *tile;
+      int xfac, yfac;
+
       float A, B;      // constants for A*exp(-Bt)
       MT_RNG myRandomNumber;
   
@@ -94,6 +96,10 @@
       void updateStatsAddSampleSet(SampleSet *newsampleset, Timestamp 
currenttime, unsigned int samplingrate);
       void updateStatsAddSample(Sample *newsample, Timestamp currenttime, 
float tgrad, bool occ, unsigned int samplingrate);
       void displayTiles(TileDisplayMode displaymode, Timestamp currenttime, 
float visScale, int samplingrate); 
+      inline void setMaxTreeDepth(int m)
+      {
+       Tile::max_tree_depth = m;
+      };
   };
  } // end namespace Afr
 } // emd namespace Manta

Modified: branches/AFR/Engine/ImageTraversers/AFR/tiles.cc
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFR/tiles.cc    (original)
+++ branches/AFR/Engine/ImageTraversers/AFR/tiles.cc    Wed Aug 31 02:14:16 
2005
@@ -26,7 +26,9 @@
 
 int** Tile::leafMapping;
 int Tile::meanLevel=8;
-int Tile::max_tile_area = 256;
+int Tile::max_tile_area = 1024;
+int Tile::min_tile_area = 8;
+int Tile::max_tree_depth = 16;
 
 Tile::Tile()
 {
@@ -54,7 +56,7 @@
        top = tp;
        num_pixels = (right-left)*(top-bottom);
        //if(num_pixels==0) exit(1);
-       if(num_pixels<=MIN_VALID_TILE_AREA) min_size_violation = true;
+       if(num_pixels<=min_tile_area) min_size_violation = true;
        else min_size_violation = false;
        level = currlevel;
        index = address;
@@ -148,7 +150,7 @@
 {
        // set the total error
        setTotalError(tree, currenttime, nTiles, samplingrate);
-       if(num_pixels<=MIN_VALID_TILE_AREA) min_size_violation = true;
+       if(num_pixels<=min_tile_area) min_size_violation = true;
        else min_size_violation = false;
        max_error = min_error = total_error; // check if we need variance here
        max_index = min_index = index;
@@ -160,10 +162,10 @@
   int lindex, rindex;
   // find the left leaf index
   lindex = index;
-  while(!tree[lindex].isLeaf()) lindex*=2;
+  while(tree[lindex].num_pixels >= min_tile_area) lindex*=2;
   // find the right leaf index
   rindex = index+1;
-  while(!tree[rindex].isLeaf()) rindex*=2;
+  while(tree[rindex].num_pixels >= min_tile_area) rindex*=2;
   
   for(int i=lindex; i<rindex; i++)
   {

Modified: branches/AFR/Engine/ImageTraversers/AFR/tiles.h
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFR/tiles.h     (original)
+++ branches/AFR/Engine/ImageTraversers/AFR/tiles.h     Wed Aug 31 02:14:16 
2005
@@ -13,8 +13,6 @@
 #include <Engine/ImageTraversers/AFR/stats.h>
 #include <Core/Math/MT_RNG.h>
 #define JITTER_THRESHOLD 0.005
-#define MIN_GRAD 0.01
-#define MIN_VALID_TILE_AREA 16
 #define DISPLAY_WIDTH 512
 #define DISPLAY_HEIGHT 512
 
@@ -77,7 +75,7 @@
                int index;
     float color[3];
        public:
-               static int **leafMapping, meanLevel, max_tile_area;
+               static int **leafMapping, meanLevel, max_tile_area, 
min_tile_area, max_tree_depth;
                Tile();
                inline void copystats(Tile &t)
                {
@@ -107,7 +105,7 @@
                        isValidTile = true;
                        max_index = min_index = index;
                        max_error = min_error = total_error;    
-                       if(num_pixels <= MIN_VALID_TILE_AREA)
+                       if(num_pixels <= min_tile_area)
                                min_size_violation = true;
                        else
                                min_size_violation = false;                   
          
@@ -115,6 +113,8 @@
                inline int getTileSize() { return num_pixels; }
                inline int getLeft() { return left; };
                inline int getBottom() { return bottom; };
+               inline int getRight() { return right; };
+               inline int getTop() { return top; };
                inline void unsetValidTile() 
                { 
                        isValidTile = false; 
@@ -180,13 +180,9 @@
                }
                inline bool isLeaf()
                {
-                       return (num_pixels<=MIN_VALID_TILE_AREA);
+                       return (num_pixels<min_tile_area);
                }
                void writeToFile(FILE *fp, Tile *tree, int nTiles, Timestamp 
currenttime, int samplingrate);
-               inline bool isZeroGrad()
-               {
-                       return (xGradient.getMean()<MIN_GRAD && 
yGradient.getMean()<MIN_GRAD && tGradient.getMean()<MIN_GRAD);
-               }
                float getUnderSampling(float currenttime, int samplingrate, 
Tile *tree);
                float getOcclusionMeasure(Tile *tree, int nTiles);
                bool checkBounds(int x, int y);

---

• [MANTA] r523 - in branches/AFR/Engine/ImageTraversers: . AFR, abhinav, 08/31/2005

---

Archive powered by MHonArc 2.6.16.