Analyzer.cpp

Go to the documentation of this file.

#include "Analyzer.h"
#include <log.h>

using namespace model;

Analyzer::Analyzer()
{
        log::write("Analyzer Init");
}

Analyzer::~Analyzer()
{
        m_ExampleData = 0;
        m_mean = 0;
        m_AdjustedData = 0;
        m_Covariance = 0;
        m_EigenValues = 0;
        m_EigenVectors = 0;
}

void Analyzer::mergeData(ReferenceModel refModel, vector<ExampleModel*> lmodels) {
        mergeData(refModel, lmodels,(int)lmodels.size());
}

void Analyzer::mergeData(ReferenceModel refModel, vector<ExampleModel*> lmodels, int size)
{
        log::write("Analyzer merge data");
        log::write("Number of models",size);
        m_refModel = refModel;
        for(int i=0;i<size;i++) {
                Matrix mv = lmodels[i]->getModelVertexs();
                if(i==0) {
                        m_ExampleData = mv;
                } else {
                        m_ExampleData = m_ExampleData | mv;
                }
        }
        N = m_ExampleData.Ncols();
        M = m_ExampleData.Nrows();
        log::write("N",N);
        log::write("M",M);
        log::write("Example Data",m_ExampleData);
}

void Analyzer::setData(Matrix data)
{
        m_ExampleData = data;
}


void Analyzer::mean()
{
        log::write("Analyzer mean");
        m_mean = Matrix(M,1); //[M x 1]
        for(int i=1;i <= M; i++)
        {
                /*    printf("Integer %d\n", i);
                printf("Cols: %d\n", data.Ncols()); 
                printf("Sum: %f\n", data.Row(i).Sum());*/
                m_mean(i,1) = 1.0/N * m_ExampleData.Row(i).Sum();
        }
        log::write("Mean",m_mean);
}

void Analyzer::adjust()
{
        log::write("Analyzer adjust");
        Matrix h = Matrix(1,N);
        h = 1;
        /*cout << setw(10) << setprecision(5) << m_ExampleData;
        cout << setw(10) << setprecision(5) << m_mean;
        cout << setw(10) << setprecision(5) << h;
        cout << setw(10) << setprecision(5) << (m_mean * h);*/
        m_AdjustedData = m_ExampleData - (m_mean * h);
        log::write("Adjusted Data",m_AdjustedData);
}

void Analyzer::covariance()
{
        log::write("Analyzer covariance");
        m_Covariance = m_AdjustedData/(N-1) * m_AdjustedData.t();
        log::write("Covariance",m_Covariance);
}

void Analyzer::findComponents()
{
  findComponents(JACOBI);
}

void Analyzer::findComponents(e_PCAMode mode)
{
        log::write("Analyzer find components");
        DiagonalMatrix dm(M);
        SymmetricMatrix test;
        test << m_Covariance;
        
        switch (mode)
        {
          case JACOBI:
            log::write("Calculating with Jacobi");
            Jacobi(test, dm, m_EigenVectors);
            break;
          case HOUSEHOLDER:
            log::write("Calculating with Householder");
            EigenValues(test, dm, m_EigenVectors);
            break;
          case OTHER:
            log::write("Calculating with Jacobi (matched OTHER)");
            Jacobi(test, dm, m_EigenVectors);
            break;
          default:
            log::write("Calculating with Jacobi (matched default)");
            Jacobi(test, dm, m_EigenVectors);
            break;
        }
        //Jacobi(test, dm, m_EigenVectors);
        //EigenValues(test, dm, m_EigenVectors);
        m_EigenValues << dm;

        log::write("Eigen Vectors",m_EigenVectors);
        log::write("Eigen Values",m_EigenValues);
}

void Analyzer::computeEnergy()
{
        log::write("Analyzer compute energy");
        //Requires that EigenVectors and Values are sorted pair-wise. Should be done
        //by the matrix library i believe (this should be tested somehow)

        m_TotalEnergy = Matrix(M,1); // [ M x 1 ]
        m_EigenValues = m_EigenValues.Reverse();
        m_TotalEnergy(1,1) = m_EigenValues(1,1);
        for(int i=2;i<=M;i++)
        {
                m_TotalEnergy(i,1) = m_TotalEnergy(i-1,1) + m_EigenValues(i,i);
        }
        log::write("Total Energy",m_TotalEnergy);
}


void Analyzer::selectComponents()
{
        log::write("Analyzer select Components");
        int index = 1;
        float percent = 0.0;

        do
        {
                percent = ((m_TotalEnergy(1,m_TotalEnergy.Ncols()) - m_TotalEnergy(1,index)) * m_TotalEnergy(1,m_TotalEnergy.Ncols()))/100.0;
                log::write("Percent calc",percent);
                index++;
        }
        while(percent <= 90.0 && percent > 0.0);

        m_Components = m_EigenVectors.Reverse().Columns(1,index-1).Reverse();
        log::write("Components",m_Components);
}


void Analyzer::transformation()
{
        log::write("Analyzer Transformation Matrix");
        // m_Covariance should perhaps be normalized - see wikipedia for info.
        m_Transformation = m_Components.t() * m_AdjustedData;
        log::write("Transformation",m_Transformation);
}

ReferenceModel Analyzer::getModel() {
        Matrix h = Matrix(1,N);
        h = 1;
        m_refModel.updateVertices(m_Components*m_Transformation+(m_mean*h));
        return m_refModel;
}

ReferenceModel Analyzer::getModel(Matrix input) {
    log::write("Analyzer::getModel\n");
        Matrix h = Matrix(1,N);
        h = 1;
        Matrix in = m_Components*input+(m_mean * h);
        log::write("Analyzer-in",in);
        m_refModel.updateVertices(in);
        log::write("Analyzer-refModel",m_refModel);
        return m_refModel;
}

int Analyzer::getInputDimension() {
        return m_Components.Ncols();
}

bool Analyzer::save(char* filename) {
        ofstream saveFile(filename);
        if(saveFile.is_open()) {
                saveFile << "Mean Dim\n";
                saveFile << m_mean.Nrows() << "," << m_mean.Ncols() << "\n";
                saveFile << m_mean << "\n";
                saveFile << "Components Dim\n";
                saveFile << m_Components.Nrows() << "," << m_Components.Ncols() << "\n";
                saveFile << m_Components << "\n";
                m_refModel.save(&saveFile);
                saveFile.close();
                return true;
        } else {
                return false;
        }
}

bool Analyzer::load(char* filename) {
        m_mean.CleanUp();
        m_Components.CleanUp();
        m_refModel = model::ReferenceModel();

        string line;
        vector<string> tokens;
        vector<string> coords;

        ifstream loadFile(filename);
        if(loadFile.is_open()) {
                getline(loadFile,line);//Mean Dim
                getline(loadFile,line);//Dim
                tokens.clear();
                Tokenize(line,tokens,",");
                m_mean = Matrix(convertTo<int>(tokens[0]),convertTo<int>(tokens[1]));

                for(int i=0;i<m_mean.Nrows();i++) {
                        getline(loadFile,line);//Data
                        tokens.clear();
                        Tokenize(line,tokens," ");
                        for(int n=0;n<m_mean.Ncols();n++) {
                                m_mean(i+1,n+1) = convertTo<float>(tokens[n]);
                        }
                }

                getline(loadFile,line);//
                getline(loadFile,line);//Components Dim
                getline(loadFile,line);//Dim
                tokens.clear();
                Tokenize(line,tokens,",");
                m_Components = Matrix(convertTo<int>(tokens[0]),convertTo<int>(tokens[1]));

                for(int i=0;i<m_Components.Nrows();i++) {
                        getline(loadFile,line);//Data
                        tokens.clear();
                        Tokenize(line,tokens," ");
                        for(int n=0;n<m_Components.Ncols();n++) {
                                m_Components(i+1,n+1) = convertTo<float>(tokens[n]);
                        }
                }
                
                getline(loadFile,line);//
                m_refModel.load(&loadFile);
                loadFile.close();
                return true;
        } else {
                return false;
        }
}


Analyzer::Analyzer(const Analyzer& other) {
        m_ExampleData = other.m_ExampleData;
        m_mean = other.m_mean;
        m_AdjustedData = other.m_AdjustedData;
        m_Covariance = other.m_Covariance;
        m_EigenValues = other.m_EigenValues;
        m_EigenVectors = other.m_EigenVectors;
        m_TotalEnergy = other.m_TotalEnergy;
        m_Components = other.m_Components;
        m_Transformation = other.m_Transformation;
        N = other.N;
        M = other.M;
        m_refModel = other.m_refModel;
}  


Analyzer& Analyzer::operator=(const Analyzer& other)
{
    // if same object
    if ( this == &other )
        return *this;
        
        m_ExampleData = other.m_ExampleData;
        m_mean = other.m_mean;
        m_AdjustedData = other.m_AdjustedData;
        m_Covariance = other.m_Covariance;
        m_EigenValues = other.m_EigenValues;
        m_EigenVectors = other.m_EigenVectors;
        m_TotalEnergy = other.m_TotalEnergy;
        m_Components = other.m_Components;
        m_Transformation = other.m_Transformation;
        N = other.N;
        M = other.M;
        m_refModel = other.m_refModel;

    return *this;
}
 

---