main page namespaces classes files
BIU home

src/biu/LatticeFrame.cc

Go to the documentation of this file.

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

namespace biu
{


    LatticeFrame::LatticeFrame( const LatticeDescriptor* const latDescriptor, 
                                const unsigned int frameSize_)
        :   LatticeModel(latDescriptor), 
            frameSize(frameSize_), 
            frameSizeP2(frameSize*frameSize)
    {
        assertbiu(INT_MAX >= (frameSize*frameSize*frameSize), 
            "the frame size is to big to assure a one-to-one indexing");
    }

    LatticeFrame::LatticeFrame(const LatticeFrame& toCopy)
        :   LatticeModel(toCopy.latDescriptor), 
            frameSize(toCopy.frameSize), 
            frameSizeP2(toCopy.frameSizeP2)
    {
    }
    
    LatticeFrame::~LatticeFrame()
    {
    }
    
    void 
    LatticeFrame::setFrameSize(const unsigned int frameSize_) {
        frameSize = frameSize_; 
        frameSizeP2 = frameSize*frameSize;
        assertbiu(INT_MAX >= (frameSize*frameSize*frameSize), 
            "the frame size is to big to assure a one-to-one indexing");
    }   
    
    bool 
    LatticeFrame::isInFrame(const IntPoint& point) const {
        return     point.getX() >= 0 && (unsigned int)point.getX() < frameSize 
                && point.getY() >= 0 && (unsigned int)point.getY() < frameSize
                && point.getZ() >= 0 && (unsigned int)point.getZ() < frameSize;
    }
        
    LatticeFrame::index_type 
    LatticeFrame::getIndex(const IntPoint& point) const {
        return point.getX() + point.getY()*frameSize + point.getZ()*frameSizeP2;
    }
    
    IntPoint 
    LatticeFrame::getPoint(const index_type& index) const {
        return IntPoint(    index%frameSize, 
                            (index/frameSize)%frameSize, 
                            (index/frameSizeP2)%frameSize);
    }


    bool    
    LatticeFrame::operator== (const LatticeFrame &lf2) const {
        bool retVal = true;
            retVal &= latDescriptor == lf2.latDescriptor;
            retVal &= frameSize == lf2.frameSize;
        return retVal;
    }
    
    bool    
    LatticeFrame::operator!= (const LatticeFrame &lf2) const {
        return latDescriptor != lf2.latDescriptor || frameSize != lf2.frameSize;
    }
    
    std::vector<LatticeFrame::index_type>
    LatticeFrame::getIndexedNeighborhood() const {
        std::vector<index_type> nInd(latDescriptor->getNeighborhood().size());
        LatticeNeighborhood::const_iterator it = latDescriptor->getNeighborhood().begin();
        for(size_t i = 0; it != latDescriptor->getNeighborhood().end(); it++)
            nInd[i++] = getIndex(*it); 
        return nInd;
    }
    
    MoveSequence 
    LatticeFrame::indicesToAbsMoves(const std::vector<index_type> indVec) const{
        IPointVec points;
        for (std::vector<index_type>::const_iterator it = indVec.begin();
                it != indVec.end(); it++) {
            points.push_back(getPoint(*it));
        }
        return this->pointsToAbsMoves(points);
    }   
    
    std::ostream & operator <<(std::ostream &os, IndexSet &x) {
        os <<"( ";
        for (IndexSet::const_iterator it = x.begin(); it != x.end(); it++)
            os <<*it <<", ";
        os <<")";
        return os;
    }
        
    std::ostream & operator <<(std::ostream &os, IndexVec &x) {
        os <<"( ";
        for (IndexVec::const_iterator it = x.begin(); it != x.end(); it++)
            os <<*it <<", ";
        os <<")";
        return os;
    }
        
} // namespace biu