-
sparker
thiago
Manta Interactive Ray Tracer Development Mailing List
Text archives Help
[MANTA] r514 - in branches/AFR/Engine: Control ImageTraversers ImageTraversers/AFR
Chronological Thread
- From: abhinav@sci.utah.edu
- To: manta@sci.utah.edu
- Subject: [MANTA] r514 - in branches/AFR/Engine: Control ImageTraversers ImageTraversers/AFR
- Date: Mon, 29 Aug 2005 22:24:16 -0600 (MDT)
Author: abhinav
Date: Mon Aug 29 22:24:13 2005
New Revision: 514
Modified:
branches/AFR/Engine/Control/AFRPipeline.cc
branches/AFR/Engine/Control/AFRPipeline.h
branches/AFR/Engine/ImageTraversers/AFImageTraverser.cc
branches/AFR/Engine/ImageTraversers/AFImageTraverser.h
branches/AFR/Engine/ImageTraversers/AFR/CQ.h
branches/AFR/Engine/ImageTraversers/AFR/kdtree.cc
branches/AFR/Engine/ImageTraversers/AFR/kdtree.h
branches/AFR/Engine/ImageTraversers/AFR/sample.h
branches/AFR/Engine/ImageTraversers/AFR/stats.cc
branches/AFR/Engine/ImageTraversers/AFR/stats.h
branches/AFR/Engine/ImageTraversers/AFR/tiles.cc
branches/AFR/Engine/ImageTraversers/AFR/tiles.h
Log:
corrected tile response for realtime settings. For higher sampling rates
response is much better than for lower sampling rates. still testing stuff
disabled undersampling, since it is havving lots of noise that is leading to
more than necessary merging/splitting leading to overhead and spoiling the
tiling also. Although we might need to revisit once we get recon done.
kdtree updates are being done by adding sample to leaf, current tile and its
parent. when splits are done the values for new node are re-evaluated from
the leaves in its subtree that contain latest information. This has little
performance overhead. with higher sampling rates it doesnt matter actually
but with lower sampling rates it seems to give better tiling. We m might want
to share same tree since then we will have higher sampling rate.
reduced some varaibels by creating two versions of stats, one for variance
and one for mean.
corrected some bugs in pipeline where wrong sampling rate was being sent to
the imagetraverser
M Engine/Control/AFRPipeline.cc
M Engine/Control/AFRPipeline.h
M Engine/ImageTraversers/AFR/kdtree.cc
M Engine/ImageTraversers/AFR/stats.cc
M Engine/ImageTraversers/AFR/kdtree.h
M Engine/ImageTraversers/AFR/stats.h
M Engine/ImageTraversers/AFR/tiles.cc
M Engine/ImageTraversers/AFR/tiles.h
M Engine/ImageTraversers/AFR/sample.h
M Engine/ImageTraversers/AFR/CQ.h
M Engine/ImageTraversers/AFImageTraverser.cc
M Engine/ImageTraversers/AFImageTraverser.h
Modified: branches/AFR/Engine/Control/AFRPipeline.cc
==============================================================================
--- branches/AFR/Engine/Control/AFRPipeline.cc (original)
+++ branches/AFR/Engine/Control/AFRPipeline.cc Mon Aug 29 22:24:13 2005
@@ -412,7 +412,9 @@
Real current_samples =
currentImageTraverser->getSamplesDone();
Real delta_samples = (current_samples-last_samples);
- Real delta_time = SCIRun::Time::currentSeconds() -
last_display_time;
+ Real currenttime = SCIRun::Time::currentSeconds();
+ Real delta_time = currenttime - last_display_time;
+ last_display_time = currenttime;
Real sampling_rate = delta_samples / delta_time;
Modified: branches/AFR/Engine/Control/AFRPipeline.h
==============================================================================
--- branches/AFR/Engine/Control/AFRPipeline.h (original)
+++ branches/AFR/Engine/Control/AFRPipeline.h Mon Aug 29 22:24:13 2005
@@ -78,7 +78,7 @@
bool
changePipeline);
// Image Traversers
- virtual ImageTraverser *getImageTraverser() { return
currentImageTraverser; };
+ virtual ImageTraverser *getImageTraverser() { return (ImageTraverser
*)currentImageTraverser; };
virtual bool selectImageTraverser(const string& spec);
virtual void registerComponent(const string& name,
ImageTraverserCreator creator);
virtual listType listImageTraversers() const;
Modified: branches/AFR/Engine/ImageTraversers/AFImageTraverser.cc
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFImageTraverser.cc (original)
+++ branches/AFR/Engine/ImageTraversers/AFImageTraverser.cc Mon Aug 29
22:24:13 2005
@@ -51,7 +51,9 @@
chunk_size( 256 ),
debug_window( false ),
samplingrate( 400000 ),
- displayClientId( 0 )
+ displayClientId( 0 ),
+ visScale( 1.0 ),
+ tmode(SOLID)
{
for (int i=0;i<args.size();++i) {
@@ -222,7 +224,7 @@
__FILE__, __LINE__);
glClearColor(.05, .1, .2, 0);
glClear(GL_COLOR_BUFFER_BIT);
- kdtree[displayClientId].displayTiles(tmode,
chunkTimeStamp[displayClientId], visScale);
+ kdtree[displayClientId].displayTiles(tmode,
chunkTimeStamp[displayClientId], visScale, samplingrate);
// Figure out how wide the string is
int width = XHelper::calc_width(fontInfo, text);
// Now we want to draw a gray box beneth the font using blending. :)
@@ -325,6 +327,7 @@
// this will change when we can actually simulate
context.getResolution(stereo, xres, yres);
+ cout << "context resolution is: " << xres << ", " << yres << endl;
//---------------------------------------------------------
// initialize random number generators for each thread.
//---------------------------------------------------------
@@ -346,7 +349,7 @@
initpass[i] = false;
chunkTimeStamp[i] = 0.0;
- kdtree[i].setAB(xres, yres);
+ kdtree[i].setAB(samplingrate);
int numlevels = kdtree[i].init(xres, yres, samplingrate); // initialize
the tree
// set a mean number of tiles, i.e. cut at middle of tree
@@ -354,7 +357,7 @@
}
// chunk_size = 256; // this is a fixed number as of now
- int qSize = (int)(samplingrate*0.1); // temporal queue size
+ maxQSize = qSize = (int)(samplingrate*0.1); // temporal queue size
temporalQ = new CQ<Sample>[num_clients];
// Initialize
@@ -435,7 +438,7 @@
ss.set( i, sx, sy, t, p.x(), p.y(), p.z(),tempcol.r(), tempcol.g(),
tempcol.b() );
- image->set( (int)sx+offset[i][0], (int)sy+offset[i][1], color[i] );
+ image->set( (int)(sx+offset[i][0]), (int)(sy+offset[i][1]), color[i] );
}
//cout << "computing gradients" << endl;
@@ -463,6 +466,13 @@
int myID = context.proc;
int fsize = chunk_size;
+ 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];
@@ -585,6 +595,7 @@
image->getResolution(stereo, xres, yres);
int myID = context.proc;
Sample s;
+ kdtree[myID].setAB(samplingrate);
// render the chunk
renderChunk(context, image, xres, yres);
@@ -595,7 +606,8 @@
int i;
Sample *sp;
//cout << "now making xhairs" << endl;
- for(i=0; i<chunk_size; i++) {
+ int fsize = (chunk_size>(temporalQ[myID].getN()-qSize))? chunk_size :
temporalQ[myID].getN()-qSize;
+ for(i=0; i<fsize; i++) {
sp = temporalQ[myID].seekLast();
if(sp!=NULL) {
@@ -624,6 +636,7 @@
&& sp->viewCoord[2]<=1.0)
renderCrossHair(context, myID, image, xres, yres, sp);
}
+ else break;
}
}
}
@@ -636,7 +649,7 @@
{
float minError, maxError;
int count;
- int required_tiles = 2048;
+ int required_tiles = kdtree[id].getMaxTiles();
if(kdtree[id].number_of_tiles()!=required_tiles)
{
do
@@ -652,7 +665,7 @@
}
while(kdtree[id].number_of_tiles()!=required_tiles);
}
-
+
minError = kdtree[id].getminError();
maxError = kdtree[id].getmaxError();
//cout << "minError = " << minError << ", maxError = " << maxError <<
endl;
Modified: branches/AFR/Engine/ImageTraversers/AFImageTraverser.h
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFImageTraverser.h (original)
+++ branches/AFR/Engine/ImageTraversers/AFImageTraverser.h Mon Aug 29
22:24:13 2005
@@ -60,7 +60,18 @@
void toggleTileDisplayMode();
inline int setSamplingRate(unsigned int srate)
{
- samplingrate = (unsigned
int)((float)srate/(float)num_clients);
+ static int numUpdates=0;
+ //cout << "srate = " << srate << endl;
+ float rate = (float)srate/(float)num_clients;
+ if(numUpdates==0)
+ samplingrate = (int)rate;
+ else
+ {
+ samplingrate =
(int)(((float)samplingrate*numUpdates + rate)/(float)(numUpdates+1));
+ }
+ numUpdates++;
+ qSize = (int)(samplingrate*0.1);
+ if(qSize>maxQSize) qSize = maxQSize;
}
static ImageTraverser* create(const vector<string>&
args);
@@ -70,7 +81,7 @@
// Image kd-tree. per thread
KDTree *kdtree;
-
+ int qSize, maxQSize;
// number of fragments a chunk is divided into. It is
divided equally amongst all clients
int numFragments;
Modified: branches/AFR/Engine/ImageTraversers/AFR/CQ.h
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFR/CQ.h (original)
+++ branches/AFR/Engine/ImageTraversers/AFR/CQ.h Mon Aug 29 22:24:13
2005
@@ -47,9 +47,9 @@
{
bool ret = true;
- qlock.lock( );
+ //qlock.lock( );
ret = (getN_help()==1);
- qlock.unlock( );
+ //qlock.unlock( );
return( ret );
}
@@ -57,9 +57,9 @@
{
bool ret = true;
- qlock.lock( );
+ //qlock.lock( );
ret = (getN_help()==(max_n-1));
- qlock.unlock( );
+ //qlock.unlock( );
return( ret );
}
@@ -67,65 +67,69 @@
{
T *ret = NULL;
- qlock.lock( );
+ //qlock.lock( );
if(start==end) {
- qlock.unlock( );
+ //qlock.unlock( );
return NULL;
}
ret = &item[end];
- qlock.unlock( );
+ //qlock.unlock( );
return( ret );
}
void qInsert(T *newItem)
{
- qlock.lock( );
+ //qlock.lock( );
item[start] = *newItem;
start = (start+1)%max_n;
if(start==end)
end = (end+1)%max_n;
- qlock.unlock( );
+ //qlock.unlock( );
}
void qDelete()
{
- qlock.lock( );
+ //qlock.lock( );
if(start==end) {
- qlock.unlock( );
+ //qlock.unlock( );
return;
}
end = (end+1)%max_n;
- qlock.unlock( );
+ //qlock.unlock( );
}
T* getKthItem(int k)
{
T *ret = NULL;
- qlock.lock( );
+ //qlock.lock( );
if(k>getN_help()) {
- qlock.unlock( );
+ //qlock.unlock( );
return NULL;
}
ret = &item[(max_n+start-k)%max_n];
- qlock.unlock( );
+ //qlock.unlock( );
return( ret );
}
void print()
{
- qlock.lock( );
+ //qlock.lock( );
if(getN_help()>0)
item[(max_n+start-1)%max_n].print();
- qlock.unlock( );
+ //qlock.unlock( );
+ }
+ inline int getMaxSize()
+ {
+ return max_n;
}
- int getN()
+ inline int getN()
{
int ret = 0;
- qlock.lock( );
+ //qlock.lock( );
ret = getN_help( );
- qlock.unlock( );
+ //qlock.unlock( );
return( ret );
}
Modified: branches/AFR/Engine/ImageTraversers/AFR/kdtree.cc
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFR/kdtree.cc (original)
+++ branches/AFR/Engine/ImageTraversers/AFR/kdtree.cc Mon Aug 29 22:24:13
2005
@@ -18,12 +18,14 @@
}
// initialize a kdtree with width x height leaf nodes
-void KDTree::setAB(int width, int height)
+void KDTree::setAB(int samplingrate)
{
A = 1.0;
- // B is calculated such that the oldest sample after 2/3rd sec
weight >=0.1
- //B = -1.0*log(0.1)/(2.0/3.0);
- B = -1.0*log(0.01)/(2.0/3.0);
+ // B is calculated such that the oldest sample after 2/3rd sec
weight >=0.01
+ float decaytime = 400000.0*1.0/((float)samplingrate*3.0);
+ B = -1.0*log(0.01)/decaytime;
+ //cout << "samplingrate = " << samplingrate << endl;
+ //B = -1.0*log(0.01)/(2.0/3.0);
}
int KDTree::init(int width, int height, unsigned int samplingrate)
@@ -66,7 +68,7 @@
Tile::max_tile_area *= 2;
minTiles = Tile::max_tile_area;
- maxTiles = minTiles*16;
+ maxTiles = minTiles*8;
setTileCut(Tile::meanLevel, 0, samplingrate);
cout << "meanLevel = " << Tile::meanLevel << endl;
@@ -199,7 +201,8 @@
tile[index*2].setValidTile();
tile[index*2].setTimeLastDerivativeSet(currenttime);
#ifdef ONLY_NODE_UPDATE
- tile[index*2].copystats(tile[index]);
+ //tile[index*2].copystats(tile[index]);
+ tile[index*2].recomputeStats(tile);
#endif
tile[index*2].updateCommon(currenttime, tile, numTiles, samplingrate);
// insert right child in the random list; we do it first because we
do not want it to be valid yet
@@ -208,7 +211,8 @@
tile[index*2+1].setValidTile();
tile[index*2+1].setTimeLastDerivativeSet(currenttime);
#ifdef ONLY_NODE_UPDATE
- tile[index*2+1].copystats(tile[index]);
+ //tile[index*2+1].copystats(tile[index]);
+ tile[index*2+1].recomputeStats(tile);
#endif
tile[index*2+1].updateCommon(currenttime, tile, numTiles,
samplingrate);
numTiles+=2; // update valid tile counter
@@ -267,6 +271,9 @@
insertRandom(index);
// set parent as a valid tile
tile[index].setValidTile();
+#ifdef ONLY_NODE_UPDATE
+ tile[index/2].recomputeStats(tile);
+#endif
tile[index].setTimeLastDerivativeSet(currenttime);
// increment valid tile counter
numTiles++;
@@ -489,6 +496,12 @@
else
updateMinMax(vtileindex);
#else
+ int x, y;
+ x = (int)newsampleset->viewX;
+ y = (int)newsampleset->viewY;
+ int index = Tile::leafMapping[x/2][y/2];
+ if(!tile[index].checkBounds(x,y)) return;
+ tile[index].updateStatsAddSampleSet(newsampleset, currenttime, A, B,
tile, numTiles, samplingrate);
tile[newsampleset->tileindex].updateStatsAddSampleSet(newsampleset,
currenttime, A, B, tile, numTiles, samplingrate);
tile[newsampleset->tileindex/2].updateStatsAddSampleSet(newsampleset,
currenttime, A, B, tile, numTiles, samplingrate);
updateMinMax(newsampleset->tileindex);
@@ -498,8 +511,8 @@
void KDTree::updateStatsAddSample(Sample *newsample, Timestamp currenttime,
float tgrad, bool occ, unsigned int
samplingrate)
{
- int x, y;
#ifndef ONLY_NODE_UPDATE
+ int x, y;
x = (int)newsample->viewCoord[0];
y = (int)newsample->viewCoord[1];
int index = Tile::leafMapping[x/2][y/2];
@@ -519,6 +532,13 @@
else
updateMinMax(vtileindex);
#else
+ int x, y;
+ x = (int)newsample->viewCoord[0];
+ y = (int)newsample->viewCoord[1];
+ int index = Tile::leafMapping[x/2][y/2];
+ if(!tile[index].checkBounds(x,y)) return;
+ tile[index].updateStatsAddSample(newsample, currenttime, A, B, tile,
+ numTiles, tgrad, occ, samplingrate);
tile[newsample->tileindex].updateStatsAddSample(newsample,
currenttime, A, B, tile, numTiles, tgrad, occ, samplingrate);
tile[newsample->tileindex/2].updateStatsAddSample(newsample,
currenttime, A, B, tile, numTiles, tgrad, occ, samplingrate);
updateMinMax(newsample->tileindex);
@@ -559,23 +579,7 @@
return tile[1].tGrad();
}
-float KDTree::getUndersampling(float x, float y, Timestamp currenttime)
-{
- int index = getTileforXY(x,y);
- return tile[index].getAverageAgeMeasure(tile[1], currenttime, 0.33);
-}
-
-int KDTree::isUsampledOrOccluded(float x, float y, Timestamp currenttime)
-{
- int index = getTileforXY(x,y);
- int retval = 0;
- if((tile[index].getAverageAgeMeasure(tile[1], currenttime, 0.33)>0))
retval=1;
- if(tile[index].getOcclusionMeasure(tile, numTiles)>0) retval = 2;
- return retval;
-}
-
-
-void KDTree::displayTiles(TileDisplayMode displaymode, Timestamp
currenttime, float visScale)
+void KDTree::displayTiles(TileDisplayMode displaymode, Timestamp
currenttime, float visScale, int samplingrate)
{
if(displaymode==INDIVIDUAL_SAMPLES) return;
int tile_to_display, start;
@@ -587,11 +591,9 @@
if(tile_to_display!=0)
{
count++;
- tile[tile_to_display].display(displaymode, numTiles,
tile, currenttime, A, B, visScale);
+ tile[tile_to_display].display(displaymode, numTiles,
tile, samplingrate, currenttime, A, B, visScale);
}
tile_to_display = tile[tile_to_display].getNextRandomTile();
}
while(tile_to_display!=start);
- //cout << "count = " << count << ", numTiles = " << numTiles << endl;
- //assert(count==numTiles);
}
Modified: branches/AFR/Engine/ImageTraversers/AFR/kdtree.h
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFR/kdtree.h (original)
+++ branches/AFR/Engine/ImageTraversers/AFR/kdtree.h Mon Aug 29 22:24:13
2005
@@ -43,9 +43,10 @@
public:
KDTree();
- void setAB(int width, int height);
+ void setAB(int samplingrate);
int init(int width, int height, unsigned int samplingrate); //
initialize the tree for max width x height tiles
void buildtree(int level, int index, int left, int bottom, int right,
int top);
+ inline int getMaxTiles() { return maxTiles; };
bool setTileCut(int level, Timestamp currenttime, unsigned int
samplingrate);
bool isLeftChild(int index); // is the tile labeled index left
child of its parent
bool isRightChild(int index); // is the tile labeled index right
child of its parent
@@ -90,15 +91,9 @@
return numLevels;
}
inline float getB() { return B; };
- float getUndersampling(float x, float y, Timestamp currenttime);
- inline float getOcclusionMeasure(int index)
- {
- return tile[index].getOcclusionMeasure(tile, numTiles);
- }
- int isUsampledOrOccluded(float x, float y, Timestamp currenttime);
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);
+ void displayTiles(TileDisplayMode displaymode, Timestamp currenttime,
float visScale, int samplingrate);
};
} // end namespace Afr
} // emd namespace Manta
Modified: branches/AFR/Engine/ImageTraversers/AFR/sample.h
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFR/sample.h (original)
+++ branches/AFR/Engine/ImageTraversers/AFR/sample.h Mon Aug 29 22:24:13
2005
@@ -287,7 +287,7 @@
float getIntensity(CrosshairSampleLoc
sloc) { return sample[sloc].intensity(); }
Timestamp
getSampleTimeStamp(CrosshairSampleLoc sloc) { return sample[sloc].t; }
inline bool isOccluded() {
- const static float epsilon = 0.001;
+ const static float epsilon = 0.01;
if(fabsf(sample[TEMPORAL_SAMPLE].worldCoord[0]-sample[CENTER_SAMPLE].worldCoord[0])>
epsilon
||
fabsf(sample[TEMPORAL_SAMPLE].worldCoord[1]-sample[CENTER_SAMPLE].worldCoord[1])>
epsilon
||
fabsf(sample[TEMPORAL_SAMPLE].worldCoord[2]-sample[CENTER_SAMPLE].worldCoord[2])>
epsilon )
Modified: branches/AFR/Engine/ImageTraversers/AFR/stats.cc
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFR/stats.cc (original)
+++ branches/AFR/Engine/ImageTraversers/AFR/stats.cc Mon Aug 29 22:24:13
2005
@@ -19,10 +19,7 @@
void Stats::addElement(float xi, float wi, float uniform_decrease)
{
n++;
- //assert(xi>=0);
- assert(wi>0);
- // assert(uniform_decrease>0);
- if (uniform_decrease > 0)
+ if (uniform_decrease <= 0 || wi<=0)
return;
sigma_wi *= uniform_decrease;
@@ -113,6 +110,14 @@
return s;
}
+void Stats::operator+=(Stats &a)
+{
+ n += a.n;
+ sigma_wi += a.sigma_wi;
+ sigma_xi_wi += a.sigma_xi_wi;
+ sigma_xi_wi_sqr += a.sigma_xi_wi_sqr;
+}
+
Stats Stats::operator-(Stats &a)
{
Stats s;
@@ -137,5 +142,108 @@
void Stats::print()
{
- //cout << n << ", " << sigma_wi << ", " << sigma_xi_wi << ", " <<
sigma_xi_wi_sqr << endl;
+ cout << n << ", " << sigma_wi << ", " << sigma_xi_wi << ", " <<
sigma_xi_wi_sqr << endl;
+}
+
+
+Stats2::Stats2()
+{
+ reset();
+}
+
+void Stats2::reset()
+{
+ n = 0;
+ sigma_wi = sigma_xi_wi = 0.0;
+}
+
+void Stats2::addElement(float xi, float wi, float uniform_decrease)
+{
+ n++;
+ if (uniform_decrease <= 0 || wi<=0)
+ return;
+
+ sigma_wi *= uniform_decrease;
+ sigma_xi_wi *= uniform_decrease;
+
+ sigma_wi += wi;
+ sigma_xi_wi += wi*xi;
+}
+
+void Stats2::deleteElement(float xi, float wi, float uniform_decrease)
+{
+ n--;
+ sigma_wi *= uniform_decrease;
+ sigma_xi_wi *= uniform_decrease;
+
+ sigma_wi -= wi;
+ sigma_xi_wi -= wi*xi;
+
+ if(n==0)
+ reset();
+}
+
+void Stats2::uniformDecrease(float ratio)
+{
+ sigma_wi *= ratio;
+ sigma_xi_wi *= ratio;
+}
+
+float Stats2::getMean()
+{
+ if(n<=0) //if(fabsf(sigma_wi)<EPSILON)
+ {
+ reset();
+ return 0.0;
+ }
+ return (sigma_wi>0.0001)?(sigma_xi_wi/sigma_wi):0.0;
+}
+
+void Stats2::sum(Stats2 &a, Stats2 &b, float adec, float bdec)
+{
+ n = a.n + b.n;
+ sigma_wi = a.sigma_wi*adec + b.sigma_wi*bdec;
+ sigma_xi_wi = a.sigma_xi_wi*adec + b.sigma_xi_wi*bdec;
+}
+
+
+Stats2 Stats2::operator+(Stats2 &a)
+{
+ Stats2 s;
+ s.n = n + a.n;
+ s.sigma_wi = sigma_wi + a.sigma_wi;
+ s.sigma_xi_wi = sigma_xi_wi + a.sigma_xi_wi;
+ return s;
+}
+
+void Stats2::operator+=(Stats2 &a)
+{
+ n += a.n;
+ sigma_wi += a.sigma_wi;
+ sigma_xi_wi += a.sigma_xi_wi;
+}
+
+Stats2 Stats2::operator-(Stats2 &a)
+{
+ Stats2 s;
+ s.n = n - a.n;
+ s.sigma_wi = sigma_wi - a.sigma_wi;
+ s.sigma_xi_wi = sigma_xi_wi - a.sigma_xi_wi;
+ return s;
+}
+
+Stats2 Stats2::operator/(float denom)
+{
+ Stats2 s;
+ assert(denom>0);
+ s.n = static_cast<int>(n/denom);
+ s.sigma_wi = sigma_wi/denom;
+ s.sigma_xi_wi = sigma_xi_wi/denom;
+
+ return s;
+}
+
+void Stats2::print()
+{
+ cout << n << ", " << sigma_wi << ", " << sigma_xi_wi << endl;
}
Modified: branches/AFR/Engine/ImageTraversers/AFR/stats.h
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFR/stats.h (original)
+++ branches/AFR/Engine/ImageTraversers/AFR/stats.h Mon Aug 29 22:24:13
2005
@@ -1,12 +1,12 @@
#ifndef _STATS_H
#define _STATS_H
-
+#include <iostream>
namespace Manta {
namespace Afr {
+using namespace std;
class Stats
{
private:
- Stats(const Stats&);
int n;
float sigma_wi, sigma_xi_wi, sigma_xi_wi_sqr;
public:
@@ -22,8 +22,31 @@
inline float getSumWeights() { return sigma_wi; };
float getMean();
Stats operator+(Stats &a);
+ void operator+=(Stats &a);
Stats operator-(Stats &a);
Stats operator/(float denom);
+ void print();
+ };
+ class Stats2
+ {
+ private:
+ int n;
+ float sigma_wi, sigma_xi_wi;
+ public:
+ Stats2();
+ void reset();
+ void uniformDecrease(float ratio);
+ void sum(Stats2 &a, Stats2 &b, float adec, float bdec);
+ void addElement(float xi, float wi=1.0, float uniform_decrease=1.0);
+ void deleteElement(float xi, float wi=1.0, float uniform_decrease=1.0);
+ inline float getWeightedSum() { return sigma_xi_wi; };
+ inline int getN() { return n; };
+ inline float getSumWeights() { return sigma_wi; };
+ float getMean();
+ Stats2 operator+(Stats2 &a);
+ void operator+=(Stats2 &a);
+ Stats2 operator-(Stats2 &a);
+ Stats2 operator/(float denom);
void print();
};
} // end namespace Afr
Modified: branches/AFR/Engine/ImageTraversers/AFR/tiles.cc
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFR/tiles.cc (original)
+++ branches/AFR/Engine/ImageTraversers/AFR/tiles.cc Mon Aug 29 22:24:13
2005
@@ -73,16 +73,6 @@
}
-float Tile::getAverageAgeMeasure(Tile &roottile, Timestamp currenttime,
float gvisScale)
-{
- float retval=0.0;
- float mean_age = fabsf(currenttime - sum_tstamps.getMean());
- float mean_age_overall = 0.1651225;//fabsf(currenttime -
roottile.sum_tstamps.getMean());
- retval = gvisScale*mean_age/mean_age_overall;
- retval -= 1.0;
- if(retval<0.0) retval = 0.0;
- return retval;
-}
// returns the next pseudo random sample.
void Tile::getNextSample(int &x, int &y, MT_RNG &myRandomNumber)
@@ -122,19 +112,23 @@
}
}
-void Tile::setError(Tile *tree, int nTiles, Timestamp currenttime, unsigned
int samplingrate)
+float Tile::getUnderSampling(float currenttime, int samplingrate, Tile *tree)
{
- // now we add some monitoring factor so that variance 0 does not mean
a single tile
-
- float verror = intensity.getVariance()+AMBIENT_ERROR;
- unsigned int numPixels = (tree[1].right - tree[1].left)*(tree[1].top
- tree[1].bottom);
- float meanGlobalAge = 0.5*(float)numPixels/(float)samplingrate;
- float uerror = (currenttime -
sum_tstamps.getMean())*0.33/meanGlobalAge - 1.0;
+ float meanGlobalAge =
0.5*(float)tree[1].num_pixels/(float)samplingrate;
+ float uerror = (currenttime -
sum_tstamps.getMean())*0.16/meanGlobalAge - 1.0;
if(uerror>1.0) uerror = 1.0;
if(uerror<0.0) uerror = 0.0;
- float oerror = getOcclusionMeasure(tree, nTiles);
- if(oerror>1.0) oerror = 1.0;
- error = (verror+0.25*uerror)*num_pixels;//(0.25*(uerror) +
2.0*(verror) +0.25*(oerror))*num_pixels ;
+ return uerror;
+}
+
+void Tile::setError(Tile *tree, int nTiles, Timestamp currenttime, unsigned
int samplingrate)
+{
+ //error = (0.25*getUnderSampling(currenttime, samplingrate)
+ // + 2.0*(intensity.getVariance()+AMBIENT_ERROR)
+ // +0.25*getOcclusionMeasure(tree, nTiles))*num_pixels ;
+ error = 2.0*(intensity.getVariance()+AMBIENT_ERROR)*num_pixels;
+ //error += 0.25*getUnderSampling(currenttime, samplingrate,
tree)*num_pixels;
+ error += 0.25*getOcclusionMeasure(tree, nTiles)*num_pixels;
}
void Tile::setTotalError(Tile *tree, Timestamp currenttime, int nTiles,
unsigned int samplingrate)
@@ -144,6 +138,7 @@
// well what about the derivative
setDerivative(currenttime);
total_error = KOEFF*(error) + (1.0-KOEFF)*derivative;
+ //total_error =error;
time_last_updated = currenttime;
}
@@ -158,6 +153,27 @@
if(min_size_violation) max_error = 0;
}
+void Tile::recomputeStats(Tile *tree)
+{
+ int lindex, rindex;
+ // find the left leaf index
+ lindex = index;
+ while(!tree[lindex].isLeaf()) lindex*=2;
+ // find the right leaf index
+ rindex = index+1;
+ while(!tree[rindex].isLeaf()) rindex*=2;
+
+ for(int i=lindex; i<rindex; i++)
+ {
+ intensity += tree[i].intensity;
+ xGradient += tree[i].xGradient;
+ yGradient += tree[i].yGradient;
+ tGradient += tree[i].tGradient;
+ occlusion += tree[i].occlusion;
+ sum_tstamps += tree[i].sum_tstamps;
+ }
+}
+
void Tile::updateStatsAddSampleSet(SampleSet *newsampleset, Timestamp
currenttime, float A, float B,
Tile *tree, int nTiles, unsigned int samplingrate)
{
@@ -165,6 +181,7 @@
float ratio = getWeight(A, B, (currenttime - time_last_updated));
float temptime = newsampleset->getSampleTimeStamp(TEMPORAL_SAMPLE);
float stime = newsampleset->timestamp;
+
intensity.addElement(newsampleset->getIntensity(CENTER_SAMPLE),
wt_new, ratio);
intensity.addElement(newsampleset->getIntensity(TOP_SAMPLE), wt_new,
1.0);
intensity.addElement(newsampleset->getIntensity(BOTTOM_SAMPLE),
wt_new, 1.0);
@@ -173,20 +190,14 @@
xGradient.addElement(newsampleset->xgrad, wt_new, ratio);
yGradient.addElement(newsampleset->ygrad, wt_new, ratio);
+ tGradient.addElement(newsampleset->tgrad, wt_new, ratio);
sum_tstamps.addElement(stime, wt_new, ratio);
- sum_tstamps.addElement(stime, wt_new, 1.0);
- sum_tstamps.addElement(stime, wt_new, 1.0);
- sum_tstamps.addElement(stime, wt_new, 1.0);
- sum_tstamps.addElement(stime, wt_new, 1.0);
+ sum_tstamps.addElement(4.0*stime, wt_new, 1.0);
float occ = (newsampleset->isOccluded())? 1.0 : 0.0;
- float denom = 1.0 - occlusion.getMean();
- if(denom<0.1) denom = 0.1;
-
- float tgradRatio = ratio;//getWeight(A, B/denom, (currenttime -
time_last_updated));
- tGradient.addElement(newsampleset->tgrad, wt_new, tgradRatio);
- occlusion.addElement(occ, wt_new, tgradRatio);
+ occlusion.addElement(occ, wt_new, ratio);
+
updateCommon(currenttime, tree, nTiles, samplingrate);
}
@@ -196,18 +207,13 @@
float wt_new = 1.0;
float ratio = getWeight(A, B, (currenttime - time_last_updated));
intensity.addElement(newsample->intensity(), wt_new, ratio);
+ //sum_tstamps.addElement(newsample->t, wt_new, ratio);
sum_tstamps.uniformDecrease(ratio);
xGradient.uniformDecrease(ratio);
yGradient.uniformDecrease(ratio);
- //occlusion.addElement(1.0, wt_new, getWeight(A, 4.0*B, (currenttime
- time_last_updated)));
- float denom = 1.0 - occlusion.getMean();
- if(denom<0.1) denom = 0.1;
- float tgradRatio = ratio;//getWeight(A, B/denom, (currenttime -
time_last_updated));
- tGradient.addElement(tgrad, wt_new, tgradRatio);
- if(occ)
- occlusion.addElement(1.0, wt_new, tgradRatio);
- else
- occlusion.addElement(0.0, wt_new, tgradRatio);
+ tGradient.uniformDecrease(ratio);
+ occlusion.uniformDecrease(ratio);
+
updateCommon(currenttime, tree, nTiles, samplingrate);
}
@@ -362,12 +368,13 @@
float Tile::getOcclusionMeasure(Tile *tree, int nTiles)
{
- int p = index/TG_FILTER_WIDTH; if(p<1) p = 1;
- while(tree[p].level < meanLevel)
- {
- p*=2;
- }
- float retval = tree[p].occlusion.getMean();
+ // Note that it might be needed to blur the occlusion measure
+ // we used to update up the tree and use higher levels, but now it
wont work, we
+ // will either have to average neighbors or specifically update the
occlusion
+ // in that level of parent. left as it is now.
+ //float retval = tree[index/2].occlusion.getMean();
+ float retval = occlusion.getMean();
+ if(retval>1.0) retval = 1.0;
return retval;
}
@@ -378,8 +385,8 @@
float Manta::Afr::getWeight(float A, float B, float age)
{
- return (A*invexp(B*age));
- //return (A*expf(-B*age));
+ //return (A*invexp(B*age));
+ return (A*expf(-B*age));
}
bool Tile::checkBounds(int x, int y)
@@ -396,7 +403,7 @@
void Tile::display(TileDisplayMode displaymode, int nTiles, Tile *tree,
- Timestamp currenttime, float A, float B,
float visScale)
+ int samplingrate, Timestamp currenttime, float A, float B,
float visScale)
{
float gvisScale;
gvisScale = 0.33;
@@ -419,6 +426,7 @@
break;
case DERIVATIVE:
{
+ glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
float dcol=0.0;
dcol = visScale*derivative/10.0;
glColor3f(dcol*0.8, dcol*0.8, dcol*0.4);
@@ -428,7 +436,7 @@
case AVERAGE_AGE:
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
- float dcol= (currenttime -
sum_tstamps.getMean())*0.33/0.1651225 - 1.0;
+ float dcol= getUnderSampling(currenttime,
samplingrate, tree);
dcol *= visScale;
glColor3f(0.6*dcol, 0.3*dcol, 0.9*dcol);
}
Modified: branches/AFR/Engine/ImageTraversers/AFR/tiles.h
==============================================================================
--- branches/AFR/Engine/ImageTraversers/AFR/tiles.h (original)
+++ branches/AFR/Engine/ImageTraversers/AFR/tiles.h Mon Aug 29 22:24:13
2005
@@ -58,8 +58,9 @@
* lastSampleIndex = index of the last sample that was
samples from this tile
*/
- Stats xGradient, yGradient, tGradient,
- intensity, sum_tstamps, occlusion;
+ Stats2 xGradient, yGradient, tGradient,
+ sum_tstamps, occlusion;
+ Stats intensity;
float error, previous_error, total_error;
Timestamp time_last_derivative_set, time_last_updated;
int derivative_gap_count;
@@ -135,6 +136,7 @@
void updateCommon(Timestamp currenttime, Tile *tree, int
nTiles, unsigned int samplingrate);
void updateStatsAddSampleSet(SampleSet *newsampleset,
Timestamp currenttime, float A, float B,
Tile *tree, int nTiles, unsigned int
samplingrate);
+ void recomputeStats(Tile *tree);
void updateStatsAddSample(Sample *newsample, Timestamp
currenttime, float A, float B,
Tile *tree, int nTiles, float tgrad, bool occ,
unsigned int samplingrate);
void updateMinMax(Tile *tree);
@@ -173,18 +175,18 @@
}
inline bool isLeaf()
{
- return (num_pixels==1);
+ return (num_pixels<=MIN_VALID_TILE_AREA);
}
void print_to_file(FILE *fp, Tile *tree, int nTiles,
Timestamp currenttime);
inline bool isZeroGrad()
{
return (xGradient.getMean()<MIN_GRAD &&
yGradient.getMean()<MIN_GRAD && tGradient.getMean()<MIN_GRAD);
}
- float getAverageAgeMeasure(Tile &roottile, Timestamp
currenttime, float gvisScale);
+ float getUnderSampling(float currenttime, int samplingrate,
Tile *tree);
float getOcclusionMeasure(Tile *tree, int nTiles);
bool checkBounds(int x, int y);
void display(TileDisplayMode displaymode, int nTiles, Tile *tree,
- Timestamp currenttime, float A, float B,
float visScale);
+ int samplingrate, Timestamp currenttime, float A, float B,
float visScale);
};
- [MANTA] r514 - in branches/AFR/Engine: Control ImageTraversers ImageTraversers/AFR, abhinav, 08/29/2005
Archive powered by MHonArc 2.6.16.
