main page namespaces classes files
CPSP home

src/cpsp/HCore.hh

Go to the documentation of this file.

/*
 *  Main authors:
 *     Martin Mann 
 *
 *  Contributing authors:
 *     Sebastian Will 
 *
 *  Copyright:
 *     Martin Mann, 2007
 *
 *  This file is part of the CPSP-tools package:
 *     http://www.bioinf.uni-freiburg.de/sw/cpsp/
 *
 *  See the file "LICENSE" for information on usage and
 *  redistribution of this file, and for a
 *     DISCLAIMER OF ALL WARRANTIES.
 *
 */

#ifndef HCORE_HH_
#define HCORE_HH_


#include <algorithm>            // fuer min / max
#include <set>
#include <vector>
#include <limits.h>

#include <biu/Point.hh>
#include <biu/LatticeFrame.hh>

namespace cpsp
{
    
    class HCore
    {
    public:
        typedef biu::IntPoint CorePoint;
        typedef std::set<CorePoint> CPointSet;
    
    protected:
    
        class CoreFrame {
        public:
            int minX, minY, minZ;
            int maxX, maxY, maxZ;
            
            void reset() { 
                minX = minY = minZ = INT_MAX; 
                maxX = maxY = maxZ = 0; 
            }
            void resize(const biu::IntPoint& p) {
                minX = std::min( minX, p.getX() );
                minY = std::min( minY, p.getY() );
                minZ = std::min( minZ, p.getZ() );
                maxX = std::max( maxX, p.getX() );
                maxY = std::max( maxY, p.getY() );
                maxZ = std::max( maxZ, p.getZ() );
            }
            biu::IntPoint getCenter() const { 
                return biu::IntPoint(   minX + ((maxX-minX)/2), 
                                        minY + ((maxY-minY)/2), 
                                        minZ + ((maxZ-minZ)/2)); 
            }
            
            biu::IntPoint getMinCorner() const {
                return biu::IntPoint( minX, minY, minZ );
            }
            
            biu::IntPoint getMaxCorner() const {
                return biu::IntPoint( maxX, maxY, maxZ );
            }
            
            int getMaxDimension() const {
                return  std::max(   maxX-minX, 
                                    std::max(   maxY-minY,
                                                maxZ-minZ))
                        + 1 ;
            }
        };
        
        typedef std::vector<biu::IndexSet> IndSetVec;
        
        unsigned int    contacts;
        unsigned int    size;    
        
        CPointSet       points;         
        
        int             numOfPSinglets; 
        int             numOfHSinglets; 

        CoreFrame       coreFrame;      

        unsigned int actFrameSize;
        
        IndSetVec       hull;
        
        biu::IndexSet           pSinglets;
        biu::IndexSet           hSinglets;
    
        void indexHulls(const biu::LatticeFrame* latFrame, 
                        const unsigned int maxHullLevel);
                        
        unsigned int    evenPositions;

    public:
        
        HCore();
        HCore(const unsigned int contacts, const unsigned int size);
        virtual ~HCore();
        
        const CoreFrame * const
        getCoreFrame() const { return &coreFrame; }
        
        unsigned int 
        getSize() const { return size; }
        
        unsigned int 
        getContacts() const { return contacts; }
        
        bool 
        isValid() const { return size == points.size(); }
        
        const biu::IPointSet& 
        getPoints() const { return points; }
        
        void 
        reset(const unsigned int contacts, const unsigned int size);
        
        void 
        addPoint(const CorePoint& toAdd);
        
        biu::IntPoint 
        getCenter() const { return coreFrame.getCenter(); }
        
        const biu::IndexSet& 
        getIndexedHull( const biu::LatticeFrame* latFrame,
                                        const unsigned int hullLevel);
                                        
        int 
        getMaxDimension() const { return coreFrame.getMaxDimension(); }
        
        int 
        getNumOfPSinglets(const biu::LatticeFrame* latFrame);

        int 
        getNumOfHSinglets(const biu::LatticeFrame* latFrame);
        
        const biu::IndexSet& 
        getIndexedPSinglets(const biu::LatticeFrame* latFrame);

        const biu::IndexSet& 
        getIndexedHSinglets(const biu::LatticeFrame* latFrame);
        
        unsigned int 
        getMinEvenOdd(void);
    };

} // namespace cpsp

#endif /*HCORE_HH_*/