void normalizeLineSet(lineSet & lineSet, ofPolyline & input){
ofPolyline output = input;
vector< float > x;
vector< float > y;
for (int i = 0; i < output.getVertices().size(); i++){
x.push_back(output[i].x);
y.push_back(output[i].y);
}
float sumx, meanx, varx, devx, skewx, kurtx;
float sumy, meany, vary, devy, skewy, kurty;
computeStats(x.begin( ), x.end( ), sumx, meanx, varx, devx, skewx, kurtx);
computeStats(y.begin( ), y.end( ), sumy, meany, vary, devy, skewy, kurty);
float stdDev = sqrt(devx*devx + devy*devy);
ofPoint midPt (meanx, meany);
ofPoint dev (stdDev, stdDev);
ofMatrix4x4 mat;
mat.makeTranslationMatrix(-midPt.x, -midPt.y, 0);
ofMatrix4x4 mat2;
mat2.makeScaleMatrix(100.0/dev.x, 100.0/dev.y, 1.0);
lineSet.normalizeLines = lineSet.lines;
for (int i = 0; i < lineSet.normalizeLines.size(); i++){
for (int j = 0; j < lineSet.normalizeLines[i].size(); j++){
lineSet.normalizeLines[i][j] = lineSet.normalizeLines[i][j] * mat * mat2;
}
}
}
void TestQuadrantAlign()
{
QTrkSettings cfg;
cfg.width = cfg.height = 60;
cfg.numThreads=1;
// auto locMode = (LocMode_t)(LT_ZLUTAlign | LT_NormalizeProfile | LT_LocalizeZ);
// auto resultsCOM = RunTracker<QueuedCPUTracker> ("lut000.jpg", &cfg, false, "com-zlutalign", locMode, 100 );
const float NF=10;
#ifdef _DEBUG
int N=1;
cfg.numThreads=1;
#else
int N=2000;
#endif
auto locModeQI = (LocMode_t)(LT_QI | LT_NormalizeProfile | LT_LocalizeZ);
auto resultsQI = RunTracker<QueuedCPUTracker> ("lut000.jpg", &cfg, false, "qa", locModeQI, N, NF);
auto locMode = (LocMode_t)(LT_QI | LT_ZLUTAlign | LT_NormalizeProfile | LT_LocalizeZ);
auto resultsZA = RunTracker<QueuedCPUTracker> ("lut000.jpg", &cfg, false, "qa-qalign", locMode, N, NF );
resultsZA.computeStats();
resultsQI.computeStats();
dbgprintf("QuadrantAlign: X= %f. stdev: %f\tZ=%f, stdev: %f\n", resultsZA.meanErr.x, resultsZA.stdev.x, resultsZA.meanErr.z, resultsZA.stdev.z);
dbgprintf("Only QI: X= %f. stdev: %f\tZ=%f, stdev: %f\n", resultsQI.meanErr.x, resultsQI.stdev.x, resultsQI.meanErr.z, resultsQI.stdev.z);
}
transformation normalizeLineSetGetTrans (ofPolyline & input){
transformation t;
ofPolyline output = input;
vector< float > x;
vector< float > y;
for (int i = 0; i < output.getVertices().size(); i++){
x.push_back(output[i].x);
y.push_back(output[i].y);
}
float sumx, meanx, varx, devx, skewx, kurtx;
float sumy, meany, vary, devy, skewy, kurty;
computeStats(x.begin( ), x.end( ), sumx, meanx, varx, devx, skewx, kurtx);
computeStats(y.begin( ), y.end( ), sumy, meany, vary, devy, skewy, kurty);
float stdDev = sqrt(devx*devx + devy*devy);
ofPoint midPt (meanx, meany);
ofPoint dev (stdDev, stdDev);
//ofMatrix4x4 mat;
t.mat.makeTranslationMatrix(-midPt.x, -midPt.y, 0);
//ofMatrix4x4 mat2;
t.mat2.makeScaleMatrix(100.0/dev.x, 100.0/dev.y, 1.0);
return t;
}
void TestFourierLUT()
{
QTrkSettings cfg;
cfg.width = cfg.height = 60;
cfg.zlut_minradius=3;
cfg.zlut_roi_coverage=1;
// auto locMode = (LocMode_t)(LT_ZLUTAlign | LT_NormalizeProfile | LT_LocalizeZ);
// auto resultsCOM = RunTracker<QueuedCPUTracker> ("lut000.jpg", &cfg, false, "com-zlutalign", locMode, 100 );
const float NF=28;
float zpos=10;
auto locMode = (LocMode_t)(LT_QI | LT_FourierLUT | LT_NormalizeProfile | LT_LocalizeZ);
auto resultsZA = RunTracker<QueuedCPUTracker> ("lut000.jpg", &cfg, false, "qi-fourierlut", locMode, 200, NF,zpos);
auto locModeQI = (LocMode_t)(LT_QI | LT_NormalizeProfile | LT_LocalizeZ);
auto resultsQI = RunTracker<QueuedCPUTracker> ("lut000.jpg", &cfg, false, "qi", locModeQI, 200, NF, zpos);
resultsZA.computeStats();
resultsQI.computeStats();
dbgprintf("FourierLUT: X= %f. stdev: %f\tZ=%f, stdev: %f\n", resultsZA.meanErr.x, resultsZA.stdev.x, resultsZA.meanErr.z, resultsZA.stdev.z);
dbgprintf("Only QI: X= %f. stdev: %f\tZ=%f, stdev: %f\n", resultsQI.meanErr.x, resultsQI.stdev.x, resultsQI.meanErr.z, resultsQI.stdev.z);
}
ofPolyline returnNormalizedLine (ofPolyline & input){
ofPolyline output = input;
vector< float > x;
vector< float > y;
for (int i = 0; i < output.getVertices().size(); i++){
x.push_back(output[i].x);
y.push_back(output[i].y);
}
float sumx, meanx, varx, devx, skewx, kurtx;
float sumy, meany, vary, devy, skewy, kurty;
computeStats(x.begin( ), x.end( ), sumx, meanx, varx, devx, skewx, kurtx);
computeStats(y.begin( ), y.end( ), sumy, meany, vary, devy, skewy, kurty);
float stdDev = sqrt(devx*devx + devy*devy);
ofPoint midPt (meanx, meany);
ofPoint dev (stdDev, stdDev);
ofMatrix4x4 mat;
mat.makeTranslationMatrix(-midPt.x, -midPt.y, 0);
ofMatrix4x4 mat2;
mat2.makeScaleMatrix(100.0/dev.x, 100.0/dev.y, 1.0);
// mat.scale(100,100,1.0);
//mat *= mat2;
for (int i = 0; i < output.getVertices().size(); i++){
ofPoint input = output[i];
output[i] -= midPt;
output[i] /= dev;
output[i]*= 100.0;
// cout << output[i] << endl;
// cout << "--> " << input << endl;
// cout << input * mat * mat2 << endl;
// cout << "--> " << (input * mat * mat2) * mat2.getInverse() * mat.getInverse() << endl;
}
// ofRectangle boxOrig = input.getBoundingBox();
// ofRectangle box = boxOrig;
// ofRectangle outputBox(-100,-100,200,200);
// box.scaleTo(outputBox);
//
// for (int i = 0; i < output.getVertices().size(); i++){
// output.getVertices()[i].x = ofMap( output.getVertices()[i].x, boxOrig.position.x, boxOrig.position.x + boxOrig.width,
// box.position.x, box.x + box.width);
// output.getVertices()[i].y = ofMap( output.getVertices()[i].y, boxOrig.position.y, boxOrig.position.y + boxOrig.height,
// box.position.x, box.y + box.height);
//
// }
return output;
}
/**
* computes a (reasonably) pretty printed portion of that part of this object
* that deals with the computed statistics
* @returns a string suitable for direct display as plain text
*/
static char *statsToString(Timings *t) {
computeStats(t);
if (t->iterations == 1) (char *)calloc(1, sizeof(char)); /* in case some twit tries to free this */
else {
char *answer = calloc(500+ 8*128*t->iterations, sizeof(char));
int leaderSize = 0;
int n, length, delta, descSize;
int cursor;
for(n = 0; n<t->phases; n++) {
length = strlen(t->phaseDescriptions[n]);
if (length>leaderSize) leaderSize = length;
}
delta = leaderSize%4 != 0 ? 4-leaderSize%4 : 0;
for(n=0; n<leaderSize+delta; n++) answer[n] = ' ';
strcat(answer, " Min Mean Median Max Sigma\r\n");
for(n= 0; n<t->phases; n++) {
strcat(answer, t->phaseDescriptions[n]);
cursor = strlen(answer);
descSize = strlen(t->phaseDescriptions[n]);
while(descSize++<leaderSize) answer[cursor++] = ' ';
catPaddedInt(answer, t->maxs[n]);
catPaddedInt(answer, t->means[n]);
catPaddedInt(answer, t->medians[n]);
catPaddedInt(answer, t->mins[n]);
catPaddedInt(answer, floor(t->sigmas[n]));
strcat(answer, "\r\n");
}
return answer;
}
}
void Report::end()
{
if (!initialized || written)
return;
// Make report iff (#mismatches>0) || (#fuzzymatches>0) || (#errors>0 && settings say report errors)
bool doReport = (numMismatches > 0);
if (!doReport) {
bool reportErrors = settings->value("ReportMissingResults").toBool();
computeStats();
foreach (const QString &func, itemLists.keys()) {
FuncStats stat = stats.value(func);
if (stat.value(ImageItem::FuzzyMatch) > 0) {
doReport = true;
break;
}
foreach (const ImageItem &item, itemLists.value(func)) {
if (reportErrors && item.status == ImageItem::Error) {
doReport = true;
break;
}
}
if (doReport)
break;
}
}
u_int DTree::stat_getNbLeavesTarget()
{
if(stats.bLeavesTarget == false)
computeStats(root);
return stats.nbLeavesTarget;
}
/* ********************************************************
* Gives the number of level in the tree structure. This method automatically call the computeStats method if it has not been done before.
*/
u_int DTree::stat_getNbLevels()
{
if(stats.bLevels == false)
computeStats(root);
return stats.nbLevels;
}
u_int DTree::stat_getNbLeavesOutlier()
{
if(stats.bLeavesOutlier == false)
computeStats(root);
return stats.nbLeavesOutlier;
}
/* ********************************************************
* Gives the number of nodes in the tree. This method automatically call the computeStats method if it has not been done before.
*/
u_int DTree::stat_getNbNodes()
{
if(stats.bNodes == false)
computeStats(root);
return stats.nbNodes;
}
/* ********************************************************
* Recursive method that allow to compute the statistics of the tree structure after it has already been built
* param
* node: the current node, reached during the recursive process
*/
void DTree::computeStats(Node * node)
{
stats.nbNodes++;
if(node->is_leaf()) {
stats.nbLeaves++;
u_int c=node->getPrediction();
if(c==1) stats.nbLeavesOutlier++;
if(c==0) stats.nbLeavesTarget++;
//cerr<<"node is leaf:"<<node->getId()<<"/"<<stats.nbLeaves<<"/"<<stats.nbLeavesTarget<<"/"<<stats.nbLeavesOutlier<<endl;
}
if(stats.nbLevels <= node->getLvl()) stats.nbLevels = node->getLvl()+1;
for(u_int i=0;i<node->getNbChildren();i++)
computeStats(node->getChild(i));
stats.bNodes = true;
stats.bLeaves = true;
stats.bLeavesTarget = true;
stats.bLeavesOutlier = true;
stats.bLevels = true;
}
/* ********************************************************
* Gives a printable string of tree structure. If the number of nodes is more than 30, only statistics are returned in the string.
*/
string DTree::toString()
{
string out = "";
if(!stats.bLevels || !stats.bLeaves || !stats.bNodes) computeStats(root);
if(stats.nbNodes < 30) out += (*root).toString();
out += statsToString();
return out;
}
/* ********************************************************
* Gives a printable string of the statistics of the tree.
*/
string DTree::statsToString()
{
if(!stats.bLevels || !stats.bLeaves || !stats.bNodes) computeStats(root);
string out;
out += "\n Arbre de Décision construit en "; out += Utils::to_string((double) stats.timeTrain); out += " secondes";
out += " \n Description : \n";
out += "\t "; out += Utils::to_string((int)stats.nbNodes); out += " nodes \n";
out += "\t "; out += Utils::to_string((int)stats.nbLeaves); out += " leaves \n";
out += "\t "; out += Utils::to_string((int)stats.nbLevels); out += " levels \n";
out += "\n\t for a training set of " ; out += Utils::to_string((int) trainSet->w_size()); out += " instances\n";
return out;
}
void TestZLUTAlign()
{
QTrkSettings cfg;
cfg.width = cfg.height = 60;
// auto locMode = (LocMode_t)(LT_ZLUTAlign | LT_NormalizeProfile | LT_LocalizeZ);
// auto resultsCOM = RunTracker<QueuedCPUTracker> ("lut000.jpg", &cfg, false, "com-zlutalign", locMode, 100 );
const float NF=28;
auto locModeQI = (LocMode_t)(LT_QI | LT_NormalizeProfile | LT_LocalizeZ);
auto resultsQI = RunTracker<QueuedCPUTracker> ("lut000.jpg", &cfg, false, "qi", locModeQI, 200, NF);
auto locMode = (LocMode_t)(LT_QI | LT_ZLUTAlign | LT_NormalizeProfile | LT_LocalizeZ);
auto resultsZA = RunTracker<QueuedCPUTracker> ("lut000.jpg", &cfg, false, "qi-zlutalign", locMode, 200, NF );
resultsZA.computeStats();
resultsQI.computeStats();
dbgprintf("ZLUTAlign: X= %f. stdev: %f\tZ=%f, stdev: %f\n", resultsZA.meanErr.x, resultsZA.stdev.x, resultsZA.meanErr.z, resultsZA.stdev.z);
dbgprintf("Only QI: X= %f. stdev: %f\tZ=%f, stdev: %f\n", resultsQI.meanErr.x, resultsQI.stdev.x, resultsQI.meanErr.z, resultsQI.stdev.z);
}
void SimpleTest()
{
QTrkSettings cfg;
cfg.qi_minradius=0;
cfg.zlut_minradius = 0;
cfg.width = cfg.height = 30;
auto locModeQI = (LocMode_t)(LT_QI | LT_NormalizeProfile | LT_LocalizeZ);
auto results = RunTracker<QueuedCPUTracker> ("lut000.jpg", &cfg, false, "qi", locModeQI, 1000, 10000/255 );
results.computeStats();
dbgprintf("X= %f. stdev: %f\tZ=%f, stdev: %f\n",
results.meanErr.x, results.stdev.x, results.meanErr.z, results.stdev.z);
}
HLayeredBlWStructure::HLayeredBlWStructure( const double *m_vec,
size_t q, size_t n, const double *w_vec ) : myQ(q), myN(n), mySA(NULL) {
mySA = new Layer[myQ];
for (size_t l_1 = 0; l_1 < myQ; ++l_1) {
mySA[l_1].blocks_in_row = m_vec[l_1];
if (w_vec != NULL && !(w_vec[l_1] > 0)) {
throw new Exception("This value of weight is not supported: %lf\n", w_vec[l_1]);
}
mySA[l_1].inv_w = (w_vec != NULL) ? (1 / w_vec[l_1]) : 1.0;
}
computeStats();
computeVkParams();
}
