LDA.hh

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef __LDA_hh__
#define __LDA_hh__

#include <bias_config.h>

#include <Base/Debug/Debug.hh>
#include <vector>
#include <Base/Math/Vector.hh>
#include <Base/Math/Matrix.hh>

#define LDAType float


namespace BIAS { 

  /** @class LDA
      @brief linear discriminant analysis on a set of classes of vectors
      LDA is a approach for dimension-reduction of vector-classes while keeping
      class-separability
      @author haertel 01/06
  */
  class BIASMathAlgo_EXPORT LDA : public BIAS::Debug {
  
    public:

    LDA(bool equalClassWeights=true):equalClassWeights_(equalClassWeights){}
    
    /** @brief Computes a reduction-matrix
        the first dimension of the matrix is taken out of the first vector
        @param vec the input: a vector of classes of vectors
        @param matrix the matrix returned
        @param reductionSize the second dimension of the matrix
        @param covs pass vector of correct size to retrieve class covs, leave
        zero size vector to save memory and destroy covs after usage
    */
    void ComputeReductionMatrix(const std::vector<std::vector<
                                BIAS::Vector<LDAType> > > &vec, 
                                BIAS::Matrix<LDAType> &matrix, 
                                int reductionSize=-1,
                                std::vector<BIAS::Matrix<LDAType> > *covs = 
                                NULL);

    /** @brief computes reduction, given average within class cov and 
        inter-class cov matrix */
    void ComputeReductionMatrix(BIAS::Matrix<LDAType>& classCov,
                                BIAS::Matrix<LDAType>& cov,
                                BIAS::Matrix<LDAType> &matrix, 
                                int reductionSize);

    /** @brief given mean and scatter of each class, compute
        scatter between class means and average class shape */
    void ComputeWithinAndInterClassCovs(const std::vector<BIAS::Vector<LDAType> 
                                        >& classmeans,
                                        const std::vector<BIAS::Matrix<LDAType> 
                                        >& covs,
                                        BIAS::Matrix<LDAType>& withinClassCov,
                                        BIAS::Matrix<LDAType>& interClassCov);


    /** @brief Computes a reduction-matrix for features of
        n sets (e.g. n images), whose class relations (correspondence) are 
        anonymous
        @param vec the input: a vector (one entry for each image) of vectors
        of features
        @param matrix the matrix returned
        @param reductionSize the second dimension of the matrix
        @param covs vector of covs for each feature in vec
    */
    void ComputeAnonymousReduction(const std::vector<std::vector<
                                   BIAS::Vector<LDAType> > > &vec, 
                                   BIAS::Matrix<LDAType> &matrix, 
                                   int reductionSize=-1,
                                   const std::vector< std::vector<BIAS::
                                   Matrix<LDAType> > >*covs = NULL);


    /** @brief get mean of input
        get results with methods down under
    */
    void ComputeMeans(const std::vector<std::vector<BIAS::Vector<LDAType> > > 
                      &vec);
    
    /** @brief get a mean vector of all vectors
        ComputeReductionMatrix or ComputeMeans has to be called first
    */
    void GetMean(BIAS::Vector<LDAType> &mean);
    
    /** @brief get mean vector for each class
        ComputeReductionMatrix or ComputeMeans has to be called first
    */
    void GetClassMeans(std::vector<BIAS::Vector<LDAType> > &means);
    
    ///reduction size can be set here
    void SetReductionSize(int size);
    
    /** @brief Generates random classes of vectors
    
        @param vectorSize dimensionality
        @param numberOfClasses how many classes should be generated (number of mean-vectors)
        @param classSizeMin how many vectors should at least be in every class
        @param classSizeMax how many vectors should at most be in every class
        @param vectorEntryMin the min-value of every vectors component
        @param vectorEntryMax the max-value of every vectors component
        @param stdDeviation Standard-Deviation of how a vector is distributed around it's class mean
        @param mainDirectionStdDeviation Standard-Deviation of the same main-direction of all classes
        @param vec returns a vector of classes, every class is a vector of vectors
        @param means returns the original mean-vectors used for each class-generation
        @param Normalize should descriptors be normalized?
    */
    void GenerateRandomTestData(int vectorSize, int numberOfClasses, 
      int classSizeMin, int classSizeMax, int vectorEntryMin, int vectorEntryMax,
      double stdDeviation, double mainDirectionStdDeviation, 
      std::vector<std::vector<BIAS::Vector<LDAType> > > &vec,
      std::vector<BIAS::Vector<LDAType> > &means, bool Normalize);
      
    /** @brief Ouput statistical-data of input-data
    
        @param vec the input data
    */
    
    void AnalyzeData(const std::vector<std::vector<BIAS::Vector<LDAType> > > &vec);

    protected:

    /// mean vector for each class
    std::vector<BIAS::Vector<LDAType> > classMeans_;
    /// mean of all vectors
    BIAS::Vector<LDAType> mean_;
    ///reduction size
    int reductionSize_;
    int allCount_;
    bool equalClassWeights_;
  };
  
}

#endif