void roiTimingTest() {
using namespace FCam::F2;
using namespace std;
char buf[256];
FILE *fp;
printf("roiTimingTest: Tabulating frame time changes with ROI\n"
"-------------------------------------------\n");
fp = fopen("roiTiming.csv", "w");
if (fp == NULL) {
printf("Unable to open stats file roiTiming.csv, exiting\n");
return;
}
int e[] = {1000,5000,10000,20000,40000,80000};
vector<int> exposures(e, e + sizeof(e)/sizeof(int));
int ft[] = {15000,20000,40000,80000};
vector<int> frameTimes(ft, ft + sizeof(ft)/sizeof(int));
// RowSkip::e rs[] = { RowSkip::none, RowSkip::x2, RowSkip::x3, RowSkip::x4,
// RowSkip::x5, RowSkip::x6, RowSkip::x7, RowSkip::x8 };
RowSkip::e rs[] = { RowSkip::none, RowSkip::x2, RowSkip::x4};
vector<RowSkip::e> rowSkips(rs, rs + 3);
// ColSkip::e cs[] = { ColSkip::none, ColSkip::x2, ColSkip::x3, ColSkip::x4,
// ColSkip::x5, ColSkip::x6, ColSkip::x7 };
ColSkip::e cs[] = { ColSkip::none, ColSkip::x2, ColSkip::x4};
vector<ColSkip::e> colSkips(cs, cs + 3);
// RowBin::e rb[] = { RowBin::none, RowBin::x2, RowBin::x3, RowBin::x4 };
RowBin::e rb[] = { RowBin::none, RowBin::x2, RowBin::x4 };
vector<RowBin::e> rowBins(rb, rb + 3);
ColBin::e cb[] = { ColBin::none, ColBin::x2, ColBin::x4 };
vector<ColBin::e> colBins(cb, cb + 3);
vector<bool> changeRoiXY(2);
changeRoiXY[0] = false;
changeRoiXY[1] = true;
int roiXstd = 0;
int roiYstd = 0;
int roiXchg = 500;
int roiYchg = 500;
int dstRealFT, srcRealFT;
int dstRealExp, srcRealExp;
Shot srcShot, dstShot;
srcShot.gain = 8;
srcShot.image = FCam::Image(640,480,FCam::UYVY, FCam::Image::Discard);
dstShot = srcShot;
Sensor sensor;
unsigned int burstCount = 10;
unsigned int n = 6;
snprintf(buf, 256, "sExp(ms), sFT(ms), sRS, sCS, sRB, sCB, sSX, sSY, dExp(ms), dFT(ms), dRS, dCS, dRB, dCB, dSX, dSY");
printf(buf); fprintf(fp, buf);
for (unsigned int k=0; k <n ; k++) {
snprintf(buf, 256, ", exp_ms[%d], ft_ms[%d], avg_dT_ms[%d], std_dT_us[%d], cnt[%d]", k,k,k,k,k);
printf(buf); fprintf(fp, buf);
}
snprintf(buf, 256, "\n");
printf(buf); fprintf(fp,buf);
for (vector<int>::iterator fTime = frameTimes.begin(); fTime != frameTimes.end(); fTime++) {
for (vector<int>::iterator exp = exposures.begin(); exp != exposures.end(); exp++) {
// for (vector<bool>::iterator rXY = changeRoiXY.begin(); rXY != changeRoiXY.end(); rXY++) {
for (int sb=0; sb < 3; sb++) {
srcShot.roiStartX = roiXstd;
srcShot.roiStartY = roiYstd;
srcShot.rowSkip = rowSkips[sb]; srcShot.colSkip = colSkips[sb];
srcShot.rowBin = rowBins[sb]; srcShot.colBin = colBins[sb];
srcShot.frameTime = *fTime;
srcShot.exposure = *exp;
for (vector<int>::iterator fTime2 = frameTimes.begin(); fTime2 != frameTimes.end(); fTime2++) {
for (vector<int>::iterator exp2 = exposures.begin(); exp2 != exposures.end(); exp2++) {
for (int sb2 =0; sb2< 3; sb2++) {
dstShot.roiStartX = roiXstd; //*rXY ? roiXchg : roiXstd;
dstShot.roiStartY = roiYstd; //*rXY ? roiYchg : roiYstd;
dstShot.rowSkip = rowSkips[sb2]; dstShot.colSkip = colSkips[sb2];
dstShot.rowBin = rowBins[sb2]; dstShot.colBin = colBins[sb2];
dstShot.frameTime = *fTime2;
dstShot.exposure = *exp2;
std::vector<Shot> testBurst(n);
unsigned int i=0;
for (; i < n/2; i++) {
testBurst[i] = srcShot;
}
for (; i < n; i++) {
testBurst[i] = dstShot;
}
int chgIndex = n/2;
sensor.debugTiming(true);
sensor.capture(dstShot); // Extra frame to allow for nice deltaTs
for (unsigned int i=0; i< burstCount; i++) sensor.capture(testBurst);
FCam::Time prevT;
{
Frame::Ptr f = sensor.getF2Frame();
prevT = f->processingDoneTime;
}
vector<float> dT[n];
float driverExp[n], driverFT[n];
for (unsigned int i=0;i<n;i++) driverExp[i] = driverFT[i] = 0;
int testFrames = burstCount * n;
int index = 0;
while (testFrames-- > 0) {
Frame::Ptr f = sensor.getF2Frame();
float deltaT = (f->processingDoneTime - prevT) / 1000.0;
prevT = f->processingDoneTime;
dT[index].push_back(deltaT);
driverExp[index] += f->exposure;
driverFT[index] += f->frameTime;
index = (index + 1) % n;
}
float avg[n];
float std[n];
for (unsigned int k=0;k<n;k++) {
avg[k] = 0;
for (unsigned int i=0; i < dT[k].size(); i++)
avg[k] += dT[k][i];
avg[k] /= dT[k].size();
std[k] = 0;
for (unsigned int i=0; i < dT[k].size(); i++)
std[k] += (dT[k][i] - avg[k])*(dT[k][i] - avg[k]);
std[k] = sqrt( std[k] / dT[k].size());
}
snprintf(buf,256, "%.2f, %.2f, %d, %d, %d, %d, %d, %d, ",
srcShot.exposure/1000.f, srcShot.frameTime/1000.f,
srcShot.rowSkip, srcShot.colSkip, srcShot.rowBin, srcShot.colBin,
srcShot.roiStartX, srcShot.roiStartY);
printf(buf); fprintf(fp, buf);
snprintf(buf,256, "%.2f, %.2f, %d, %d, %d, %d, %d, %d",
dstShot.exposure/1000.f, dstShot.frameTime/1000.f,
dstShot.rowSkip, dstShot.colSkip, dstShot.rowBin, dstShot.colBin,
dstShot.roiStartX, dstShot.roiStartY);
printf(buf); fprintf(fp, buf);
for (unsigned int k=0; k < n; k++) {
if ( k % 3 == 0) printf("\n\t");
snprintf(buf,256, ", %.1f, %.1f, %.2f, %.1f, %d",
driverExp[k]/dT[k].size()/1000, driverFT[k]/dT[k].size()/1000,
avg[k], std[k]*1000, dT[k].size());
printf(buf); fprintf(fp, buf);
}
snprintf(buf,256,"\n");
printf(buf); fprintf(fp,buf);
fflush(fp);
if (sensor.framesPending()) {
printf("!! Still got frames, that's not good\n");
}
}
}
}
}
}
// }
}
}
