EventMap.h

Go to the documentation of this file.

/******************************************************************************
 *
 *  Copyright (C) 2008 Boris Iven, Max Hermann
 *
 *  This file is part of the "CEDRIC Event Display" application.
 *
 *****************************************************************************/

#ifndef EVENTMAP_H
#define EVENTMAP_H

#include <Redukt/CMDS.h>
#include <Redukt/EarthMoversDistance.h>

#include <Util/ProgressIndicator.h>

#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/vector.hpp>

#include <map>
#include <vector>

#include <iomanip>
#include <iostream>
#include <fstream>

#include "EventGroundDistances.h"



namespace ublas = boost::numeric::ublas;


class EventMap;
class SignaturePivotSample;
class SignatureRandomSample;



class EventMap
{
public: 
        typedef ublas::matrix<double> Matrix;
        typedef ublas::vector<double> Vector;
        typedef EarthMoversDistance< EventSignature, EventFeature >  EMD;

        struct SignatureSampler
        {
                virtual void operator () ( EventSignatureSet& in, EventSignatureSet& out )=0;
        };
        
        struct Coordinate
        {
                Coordinate() {}
                Coordinate( double x_, double y_ ): x(x_), y(y_) {}
                double x, y;
        };
        
        enum Progress {
                        STEP_INITIAL     =   0,
                        STEP_SUBSET      =  10,
                        STEP_DIST_MATRIX =  70,
                        STEP_MDS         =  95,
                        STEP_STRESS      = 100,
                        NUM_STEPS = 100
                };
                
        void print( Matrix A, std::ostream& os = std::cout )
        {
                unsigned int n = (unsigned int)A.size1(),
                                         m = (unsigned int)A.size2();
                for( unsigned int i=0; i < n; ++i )
                {
                        for( unsigned int j=0; j < m; ++j )
                        {
                                os << std::setw(12) << A(i,j);
                        }
                        os << std::endl;
                }
        }               
        
public:
        EventMap( const GroundDistance<EventFeature>& gd )
                : m_grounddistance( gd ),
                  m_progressIndicator( 0 )
        {}
                
        EventMap( EventMap& other );
        
        void create( EventSignatureSet& signatures, SignatureSampler& sel );    
        
        void setProgressIndicator( ProgressIndicator* pi )
        {
                m_progressIndicator = pi;
        }

        bool wasCanceled() const
        { 
                if( m_progressIndicator )
                        return m_progressIndicator->wasCanceled();
                return false;
        }
        
        int numCoordinates() const
        {
                return m_points.size1();
        }
        
        int phast2mapIndex( unsigned int phastIndex ) const
        {
                //### replace with std::find()
                for( unsigned int i=0; i < m_indexmap.size(); ++i )
                        if( m_indexmap[i] == (int)phastIndex )
                                return i;
                
                return -1; // not found
        }
        
        int getIndex( unsigned int i ) const
        {
                assert( i < m_indexmap.size() );
                return m_indexmap[i];
        }
        
        Coordinate getCoordinate( unsigned int i ) const
        {
                assert( i < m_points.size1() );
                
                const Vector& row = ublas::row( m_points, i );
                
                return Coordinate(row[0],row[1]);               
        }
        
        
        double getDissimilarity( unsigned int i, unsigned int j ) const
        {
                assert( (i < m_delta.size1()) && (j < m_delta.size2()) );
                
                return m_delta(i,j);
        }
        
        double getRawStress( unsigned int i )
        {
                assert( (int)i < numCoordinates() );
                return m_rawStress[i];
        }
        
        double getKruskalPointStress( unsigned int i )
        {
                assert( (int)i < numCoordinates() );
                return m_kruskalPointStress[i];         
        }
        
        double stressMean() const { return m_stressMean; }
        double stressVar()  const { return m_stressVar; }
        double stressNorm() const { return m_stressNorm; }
        
        double stressKruskal() const { return m_kruskalStress; }
                
        double minRawStress();
        double maxRawStress();
        
        /*### OBSOLETE ?
        double getNormStress(int index)
        {
                assert(index < numCoordinates());
                return m_normStress[index];
        }
        */
        
        //const Matrix& distanceMatrix() const { return m_delta; }
        Matrix& distanceMatrix() { return m_delta; }
        
        double dist(Coordinate c1, Coordinate c2) const
        {
                return sqrt((c1.x - c2.x) * (c1.x - c2.x) + (c1.y - c2.y) * (c1.y - c2.y));
        }
        
        
protected:
        
        enum PointStressType { BortStress, KruskalStress };

        bool progress( int step );

        void calculateStress();

        double calculateKruskalStress() const;

        double calculatePointStress(int index,PointStressType type) const;      
        
private:
        // copy assignment not possible because const referenced members exist
        EventMap& operator = ( EventMap& ) { return *this; }

        std::vector<int>        m_indexmap;   
        EventSignatureSet       m_subset;
        Matrix                  m_delta;      
        Matrix                  m_points;     

        //~ enum PointStressType { PointStressKruskal, PointStressBort };       
        //~ std::map<PointStressType,std::vector<double> > m_pointStress;
        
        std::vector<double>     m_rawStress;  
        std::vector<double> m_kruskalPointStress; 

        double              m_kruskalStress; 
        
        double                          m_stressNorm; 
        double                      m_stressMean; 
        double                          m_stressVar;  

        //### OBSOLETE ?
        //std::vector<double> m_normStress; ///> unit variance normalized stress per point
        //double              m_stressVar;  ///> for stress normalization

        const GroundDistance<EventFeature>& m_grounddistance;  

        ProgressIndicator* m_progressIndicator; 
};


class SignatureRandomSample: public EventMap::SignatureSampler
{
public:
        SignatureRandomSample( unsigned int sampleSize ): m_sampleSize(sampleSize) {}
        
        void operator () ( EventSignatureSet& in, EventSignatureSet& out );
        
private:
        unsigned int m_sampleSize;
};



class SignaturePivotSample: public EventMap::SignatureSampler
{
public:
        SignaturePivotSample( unsigned int k, double radius=0.0 )
        : m_k(k), 
          m_radius(radius),
          m_sizeOut(-1),
          m_sizeIn(-1)
        {}
                
        void operator () ( EventSignatureSet& in, EventSignatureSet& out );
        
        float fractionVisible() const { return m_fractionVisible; }
        
        double radius() const { return m_radius; }
        
        int sizeOut() const { return m_sizeOut; }
        int sizeIn()  const { return m_sizeIn; }
        
private:
        unsigned int m_k;
        double m_radius;
        float  m_fractionVisible;
        int m_sizeOut, m_sizeIn;
};

#endif // EVENTMAP_H