Batch.cpp

Go to the documentation of this file.

#include "Batch.h"
#include <iostream>
//#include <dirent.h>
//#include <dir>
#include <cstdlib>
#include <log.h>
#include <time.h>

using namespace std;

int main(int argc,char *argv[]) {
        bool debug = false;
        if(argc==2) {
                if(string(argv[1]) == "debug") debug = true;
        }
        Batch b = Batch(debug);
        b.Init();
        return 0;
}

Batch::Batch() {
        Batch(false);
}

Batch::Batch(bool debug) {
        m_mainErr = "";
        m_subErr = "";
        log::clear();
        log::setDebug(debug);
        log::write("Batch started");
}

void Batch::Init() {
        m_mainRun = true;
        m_subRun = true;


        while(m_mainRun) {
                vector<string> options;
                options.push_back("Import models");
                char* optname = "Analyze models";
                int count = m_inputModels.size();
                if(count>0) {
                        char tmp[100];
                        #ifndef __WINDOWS__
                        sprintf(tmp,"%s (%d)",optname,count);
                        #else
                        sprintf_s(tmp,"%s (%d)",optname,count);
                        #endif
                        optname = tmp;
                }
                string s = string(optname);
                options.push_back(s);
                optname = "Export models";
                count = m_inputModels.size() + m_refModels.size() + m_generatedModels.size();
                if(count>0) {
                        char tmp[100];
                        #ifndef __WINDOWS__
                        sprintf(tmp,"%s (%d)",optname,count);
                        #else
                        sprintf_s(tmp,"%s (%d)",optname,count);
                        #endif
                        optname = tmp;
                }
                s = string(optname);
                options.push_back(s);
                options.push_back("Test");

                renderOptions("PCG",options);
                int o = handleInput();
                switch(o) {
                        case 1: import();break;
                        case 2: analyze(); break;
                        case 3: Export(); break;
                        case 4: Test(); break;
                        default: m_mainErr = "Not a valid option!";break;
                }
        }
}

void Batch::import() {
        m_subRun=true;
        vector<string> options;
        options.push_back("Import a model");
        options.push_back("Import models");
        options.push_back("Import data models");

        while(m_subRun) {
                renderOptions("Import models", options, true);
                int o = handleInput();
                switch(o) {
                        case 1: importModel();break;
                        case 2: importDir(); break;
                        case 3: importData(); break;
                        default: m_subErr = "Not a valid option!";break;
                }
        }
}

void Batch::importModel() {
        ExampleModel* em = new ExampleModel();
        functions::Importer im = functions::Importer();
        string file = "";
        bool run = true;
        renderTitle("Import a model",true);
        while(run) {
                cout << "Enter path to the model file: ";
                cin >> file;
                char temp[100];
                cin.getline(temp, 100);
                run = !im.importModel(file.c_str(),em);
                if(!run) {
                        m_subErr = "Model loaded";
                        m_inputModels.push_back(em);
                }
        }
}

void Batch::importDir() {
/*      DIR *pdir;
        struct dirent *pent;
        string path = "";

        renderTitle("Import a model dir",true);
        cout << "Enter path to the model file: ";
        cin >> path;

        pdir=opendir(path); //"." refers to the current dir
        if (!pdir){
                printf ("opendir() failure; terminating");
        }
        errno=0;
        while ((pent=readdir(pdir))){
                printf("%s", pent->d_name);
        }
        if (errno){
                printf ("readdir() failure; terminating");
                exit(1);
        }
        closedir(pdir);*/
}

void Batch::importData() {
        functions::Importer im = functions::Importer();
        string path = "";
        string name = "";
        string ending = "";
        int rangeStart = 0;
        int rangeEnd = 1;
        char temp[100];
        bool run = true;
        renderTitle("Import data models",true);
        while(run) {
                cout << "Enter path to the data models (../data/): ";
                cin.getline(temp, 100);
                path.assign(temp);
                cout << "Enter start file name (exportFile): ";
                cin.getline(temp, 100);
                name.assign(temp);
                cout << "Enter file ending (.x3d): ";
                cin.getline(temp, 100);
                ending.assign(temp);
                cout << "Enter start range (1): ";
                cin.getline(temp, 100);
                rangeStart=atoi(temp);
                cout << "Enter end range (99): ";
                cin.getline(temp, 100);
                rangeEnd=atoi(temp);
                for(int i=rangeStart;i<=rangeEnd;i++) {
                        std::cout << "Importing model " << i << " of " << rangeEnd << "          \r" << std::flush;
                        ExampleModel* em = new ExampleModel();
                        string filename = path + name;
                        #ifndef __WINDOWS__
                        sprintf(temp,"%d",i);
                        #else
                        sprintf_s(temp,"%d",i);
                        #endif
                        filename.append(string(temp));
                        filename.append(ending);
                        run = !im.importModel(filename.c_str(),em);
                        if(!run) {
                                m_subErr = "Data Models loaded";
                                m_inputModels.push_back(em);
                        }
                }
        }
}

void Batch::analyze() {
        m_subRun=true;
        vector<string> options;
        char tmp[100];
        #ifndef __WINDOWS__
        sprintf(tmp,"Analyze %d models",m_inputModels.size());
        #else
        sprintf_s(tmp,"Analyze %d models",m_inputModels.size());
        #endif
        string s = string(tmp);
        options.push_back(s);
        options.push_back("Get a Model");
        options.push_back("Get random Model");

        while(m_subRun) {
                renderOptions("Analyze models", options, true);
                int o = handleInput();
                switch(o) {
                        case 1: analyzeModel();break;
                        case 2: getModel();break;
                        case 3: getRandomModels();break;
                        default: m_subErr = "Not a valid option!";break;
                }
        }
}

void Batch::analyzeModel() {
        //pca = Analyzer();  
        ReferenceModel refModel = ReferenceModel();
        refModel.setVertexs(m_inputModels[0]->getVertexs());
        refModel.setFaces(m_inputModels[0]->getFaces());
        log::write("*************Starting to Analyze*************");
        printf("start\n");
        pca.mergeData(refModel,m_inputModels);
        printf("mergeData done\n");
        log::write("Calculating mean");
        pca.mean();
        printf("mean done\n");
        log::write("Adjusting data");
        pca.adjust();
        printf("adjust done\n");
        log::write("Finding Covariance");
        pca.covariance();
        printf("covariance done\n");
        log::write("Begin EigenVector calculations");
        log::write("Timer Started");
        clock_t begin = clock();
        pca.findComponents();
        clock_t end = clock();
        log::write("Timer Stopped");
        log::write("Time elapsed in seconds:", difftime(end, begin));
        log::write("Time elapsed in clock cycles:",(int)(end-begin));
        log::write("End EigenVector calculations");
        printf("finding done\n");
        pca.computeEnergy();
        printf("compute energy done\n");
        pca.selectComponents();
        printf("select components done\n");
        pca.transformation();
        m_subErr = "Models analyzed";
        log::write("*************ANALYSIS ENDED*************");
}

void Batch::getModel() {
  renderTitle("Get a model");

}

void Batch::getRandomModels() {
        renderTitle("Generates 10 random models",true);
        int dim = pca.getInputDimension();
        Matrix input(1,dim);
        int lowest=-10, highest=10; 
        int range=(highest-lowest)+1;
        for(int i=0; i<10;i++) {
                if(dim=1) {
                        input(1,1) = i-5;                       
                } else {
                        for(int n=0;n<dim;n++) {
                                input(1,n+1) = lowest+int(range*rand()/(RAND_MAX + 1.0)); 
                        }
                }
                log::write("Batch-Input",input);
                ReferenceModel refModel = pca.getModel(input);
                log::write("ReferenceModel",refModel);
                m_generatedModels.push_back(refModel);
        }
}

void Batch::Export() {
        m_subRun=true;
        vector<string> options;
        options.push_back("Export a model");
        char* optname = "Export all models";
        int count = m_inputModels.size() + m_refModels.size() + m_generatedModels.size();
        if(count>0) {
                char tmp[100];
                #ifndef __WINDOWS__
                sprintf(tmp,"%s (%d)",optname,count);
                #else
                sprintf_s(tmp,"%s (%d)",optname,count);
                #endif
                optname = tmp;
        }
        string s = string(optname);
        options.push_back(s);

        while(m_subRun) {
                renderOptions("Export models", options, true);
                int o = handleInput();
                switch(o) {
                        case 1: ExportModel();break;
                        case 2: ExportModels(); break;
                        default: m_subErr = "Not a valid option!";break;
                }
        }
}

void Batch::ExportModel() {

}

void Batch::ExportModels() {
        log::write("Batch::ExportModels");
        functions::Exporter ex = functions::Exporter();
        char tmp[100];
        log::write("Export Inputmodels");
        for(int i=0; i<m_inputModels.size(); i++) {
                #ifndef __WINDOWS__
                sprintf(tmp,"inputModel%d.x3d",i);
                #else
                sprintf_s(tmp,"inputModel%d.x3d",i);
                #endif  
                ex.exportModel(m_inputModels[i],tmp);
        }
        log::write("Export refModels");
        for(int i=0; i<m_refModels.size(); i++) {
                #ifndef __WINDOWS__
                sprintf(tmp,"referenceModel%d.x3d",i);
                #else
                sprintf_s(tmp,"referenceModel%d.x3d",i);
                #endif  
                
                ex.exportModel(&m_refModels[i],tmp);
        }
        log::write("Export generatedModels");
        for(int i=0; i<m_generatedModels.size(); i++) {
                #ifndef __WINDOWS__
                sprintf(tmp,"generatedModel%d.x3d",i);
                #else
                sprintf_s(tmp,"generatedModel%d.x3d",i);
                #endif  
                ex.exportModel(&m_generatedModels[i],tmp);
        }
        m_subErr = "Models exported";
}



void Batch::Test() {
        m_subRun=true;
        vector<string> options;
        options.push_back("ALL Methods");
        options.push_back("JACOBI Method");
        options.push_back("HOUSEHOLDER Method");
        options.push_back("Time stability");
        options.push_back("All tests");

        while(m_subRun) {
                renderOptions("Test", options, true);
                int o = handleInput();
                switch(o) {
                        case 1: TestSystem(PCA,Analyzer::ALL);break;
                        case 2: TestSystem(PCA,Analyzer::JACOBI); break;
                        case 3: TestSystem(PCA,Analyzer::HOUSEHOLDER); break;
                        case 4: TestSystem(STABILITY); break;
                        case 5: TestSystem(ALLTEST); break;
                        default: m_subErr = "Not a valid option!";break;
                }
        }
}

void Batch::TestSystem(e_TESTMODE mode) {
        TestSystem(mode,Analyzer::ALL);
}

void Batch::TestSystem(e_TESTMODE mode, Analyzer::e_PCAMode method) {
        #ifdef __WINDOWS__
                system("cls");
        #else
                system("clear");
        #endif
        log::clear();
        log::write("TESTING STARTED");
        if(mode == PCA || mode == ALLTEST) {
                log::write("PCA TEST");
                int testRunNumbers[4] = {5,10,50,100};
                if(method == Analyzer::ALL) {
                        for(int i=0; i<4; i++) {
                                TestAnalyzer(Analyzer::JACOBI, testRunNumbers[i]);
                        }
                        for(int i=0; i<4; i++) {
                                TestAnalyzer(Analyzer::HOUSEHOLDER,testRunNumbers[i]);
                        }
                } else {
                        for(int i=0; i<4; i++) {
                                TestAnalyzer(method,testRunNumbers[i]);
                        }
                }
        } else if(mode == STABILITY || mode == ALLTEST) {
                log::write("TIME STABILITY TEST");
                int testRunNumbers[4] = {2,3,4,5};
                for(int i=0;i<4;i++) {
                        for(int n=0;n<100;n++) {
                                log::write("Run nr:",n+1);
                                TestAnalyzer(Analyzer::HOUSEHOLDER,testRunNumbers[i]);
                        }
                }
        }
}

void Batch::TestAnalyzer(Analyzer::e_PCAMode mode, int size) {
        if(mode == Analyzer::JACOBI) {
                printf("Running JACOBI with %d models",size);
        } else if(mode == Analyzer::HOUSEHOLDER) {
                printf("Running HOUSEHOLDER with %d models",size);
        }
        ReferenceModel refModel = ReferenceModel();
        refModel.setVertexs(m_inputModels[0]->getVertexs());
        refModel.setFaces(m_inputModels[0]->getFaces());
        log::write("*************Starting to Analyze*************");
        pca.mergeData(refModel,m_inputModels,size);
        log::write("Calculating mean");
        pca.mean();
        log::write("Adjusting data");
        pca.adjust();
        log::write("Finding Covariance");
        pca.covariance();
        log::write("Begin EigenVector calculations");
        log::write("Timer Started");
        clock_t begin = clock();
        pca.findComponents(mode);
        clock_t end = clock();
        float time = (float)(end - begin)/CLOCKS_PER_SEC;
        printf(" - It took %f seconds\n",time);
        log::write("Timer Stopped");
        log::write("Time elapsed in seconds:", time);
        log::write("Time elapsed in clock cycles:",(int)(end-begin));
        log::write("End EigenVector calculations");
        pca.computeEnergy();
        pca.selectComponents();
        pca.transformation();
        log::write("*************ANALYSIS ENDED*************");
}



void Batch::renderTitle(string title, bool sub) {
        #ifdef __WINDOWS__
                system("cls");
        #else
                system("clear");
        #endif
        string err = m_mainErr;
        if(sub) {
                err = m_subErr;
        }
        cout << err << "\n\n\n";
        cout << "     " << title << "\n\n";
        m_mainErr = "";
        m_subErr = "";
}

void Batch::renderOptions(string title, vector<string> options, bool back) {
        renderTitle(title,back);
        for(int i=0; i<options.size();i++) {
                cout << "        " << i+1 << ") " << options[i] << "\n";
        }
        cout << "\n\n";
        if(back) {
                cout << "        8) Back\n";
        }
        cout << "        9) Quit\n\n";
        cout << "      Select a option: ";

}

int Batch::handleInput() {
        //cout << "handel input\n";
        int opt;
        char temp[100];
        cin.getline(temp, 100);

        opt=atoi(temp);
        if(opt==9) {
                m_mainRun = false;
                m_subRun = false;
        } else if(opt == 8) {
                m_subRun = false;
        }
        //cout << opt << "\n";
        return opt;
}

---