pca.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Authors:     Jorge Garcia de la Nava Ruiz (gdl@ac.uma.es)
 *              Carlos Oscar Sanchez Sorzano
 *              Alberto Pascual Montano (pascual@cnb.csic.es)
 *
 * Departamento de Arquitectura de Computadores, Universidad de Malaga
 *
 * Copyright (c) 2001 , CSIC/UMA.
 *
 * Permission is granted to copy and distribute this file, for noncommercial
 * use, provided (a) this copyright notice is preserved, (b) no attempt
 * is made to restrict redistribution of this file, and (c) this file is
 * restricted by a compilation copyright.
 *
 *  All comments concerning this program package may be sent to the
 *  e-mail address 'pascual@cnb.csic.es'
 *
 *****************************************************************************/

#ifndef XMIPPPC_H
#define XMIPPPC_H

#include "base_algorithm.h"
#include "data_types.h"
#include "training_vector.h"

#include <core/xmipp_funcs.h>
#include <core/matrix2d.h>
#include <core/multidim_array.h>

class PCAAnalyzer
{
public:
    PCAAnalyzer(void)
    {}

    PCAAnalyzer(ClassicTrainingVectors const &ts)
    {
        reset(ts);
    }

    PCAAnalyzer(ClassicTrainingVectors const &ts, std::vector<unsigned> const & idx)
    {
        reset(ts, idx);
    }

    void reset(ClassicTrainingVectors const &ts);

    void reset(ClassicTrainingVectors const &ts, std::vector<unsigned> const & idx);

    std::vector<FeatureVector> eigenvec;

    FeatureVector eigenval;

    FeatureVector mean;

    int D;

    double prod_mean_mean;

    std::vector<double> prod_ei_mean;

    std::vector<double> prod_ei_ei;

    double avg_mean;

    std::vector<double> avg_ei;
#ifdef UNUSED // detected as unused 29.6.2018

    void setIdentity(int n);
#endif

    void clear();

#ifdef UNUSED // detected as unused 29.6.2018

    void prepare_for_correlation();
#endif

    void set_Dimension(int _D)
    {
        D = _D;
    }

    int get_Dimension() const
    {
        return D;
    }

    int get_eigenDimension() const
    {
        if (eigenvec.size() > 1)
            return eigenvec[0].size();
        else
            return 0;
    }

#ifdef UNUSED // detected as unused 29.6.2018

    int Dimension_for_variance(double th_var);

    void Project(FeatureVector &input, FeatureVector &output);
#endif

    void setListener(BaseListener* _listener)
    {
        listener = _listener;
    };

    friend std::ostream& operator << (std::ostream &out, const PCAAnalyzer &PC);

    friend std::istream& operator >> (std::istream &in, PCAAnalyzer &PC);

private:

    BaseListener* listener;   // Listener class


};

class PCA_set
{
public:
    std::vector<PCAAnalyzer> PCA;

#ifdef UNUSED // detected as unused 29.6.2018

    int create_empty_PCA(int n = 1);
#endif

    int PCANo() const
    {
        return PCA.size();
    }

    const PCAAnalyzer * operator()(int i) const
    {
        return &(PCA[i]);
    }

    friend std::ostream& operator << (std::ostream &out, const PCA_set &PS);

    friend std::istream& operator >> (std::istream &in, PCA_set &PS);
};

class Running_PCA
{
public:
    int J;

    int d;

    Matrix1D<double> current_sample_mean;

    long n;

    Matrix2D<double> eigenvectors;

    Running_PCA(int _J, int _d);

#ifdef UNUSED // detected as unused 29.6.2018

    void new_sample(const Matrix1D<double> &sample);
#endif

    void project(const Matrix1D<double> &input, Matrix1D<double> &output) const;

    void get_eigenvector(int j, Matrix1D<double> &result) const
    {
        eigenvectors.getCol(j, result);
    }

    double get_eigenvector_variance(int j) const
    {
        if (n <= j)
            return 0.0;
        double mean_proj = sum_proj(j) / n;
        return sum_proj2(j) / n - mean_proj*mean_proj;
    }
public:
    // Sum of all samples so far
    Matrix1D<double> sum_all_samples;

    // Sum of all projections so far
    Matrix1D<double> sum_proj;

    // Sum of all projections squared so far
    Matrix1D<double> sum_proj2;
};

#endif