|| || || || || || || ||

---

InterestCircle.h

Go to the documentation of this file.

#ifndef Impala_Core_Geometry_InterestCircle_h
#define Impala_Core_Geometry_InterestCircle_h

#include "Core/Geometry/InterestPoint.h"
#include "Core/Vector/VectorTem.h"
#include "Util/StringParser.h"

namespace Impala
{
namespace Core
{
namespace Geometry
{

class InterestCircle : public InterestPoint {
public:

    // inherits: mX, mY, mDescriptor
    Real64 mCornerness;
    Real64 mDetectionScale;
    Real64 mScale;
    Real64 mOrientation;

    InterestCircle() : InterestPoint(), mCornerness(0), mDetectionScale(0), mScale(0), mOrientation(0)
    {
    }

    InterestCircle(Real64 xCoord, Real64 yCoord, Real64 cornerness, Real64 detectionScale=0.0) 
        : InterestPoint(xCoord, yCoord), mCornerness(cornerness), mDetectionScale(detectionScale), mScale(0.0), mOrientation(0.0)
    {
    }

    InterestCircle(CString region, Real64 shiftX=0, Real64 shiftY=0) : InterestPoint(), mDetectionScale(0)
    {
        if(region.substr(0, 8) != "<CIRCLE ") {
            throw "Get your act together: <CIRCLE should be the start!";
        }
        Util::StringParser sp(region);
        std::string temp = sp.GetString(' ');   // ignore <CIRCLE
        mX = sp.GetDouble(' ') - shiftX;
        mY = sp.GetDouble(' ') - shiftY;
        mScale = sp.GetDouble(' ');
        mOrientation = sp.GetDouble(' ');
        mCornerness = sp.GetDouble('>');
    }
    
    InterestCircle(Vector::VectorTem<Real64>& pointVector, Real64 shiftX=0, 
                   Real64 shiftY=0)
        : InterestPoint(), mDetectionScale(0.0), mOrientation(0.0), mCornerness(0.0)
    {
        if(pointVector.Size() < 3)
        {
            std::cerr << "Invalid data for InterestCircle" << std::endl;
            throw "Invalid data";
        }
        mX = pointVector.Elem(0) - shiftX;
        mY = pointVector.Elem(1) - shiftY;
        mScale = pointVector.Elem(2);
        if(pointVector.Size() > 3)
            mOrientation = pointVector.Elem(3);
        if(pointVector.Size() > 4)
            mCornerness = pointVector.Elem(4);
    }
    
    std::string 
    geometryType()
    { 
        return "CircleZ"; 
    }

    std::string
    Serialize(Real64 shiftX=0, Real64 shiftY=0)
    {
        std::ostringstream os;
        os << "<CIRCLE " << mX+shiftX << " " << mY+shiftY << " " << mScale << " " << mOrientation << " " << mCornerness << ">;";
        return os.str();
    }

    Vector::VectorTem<Real64>*
    PointAsVector(Real64 shiftX=0, Real64 shiftY=0)
    {
        Vector::VectorTem<Real64>* temp = new Vector::VectorTem<Real64>(5);
        temp->Elem(0) = mX + shiftX;
        temp->Elem(1) = mY + shiftY;
        temp->Elem(2) = mScale;
        temp->Elem(3) = mOrientation;
        temp->Elem(4) = mCornerness;
        return temp;
    }
};

InterestCircle*
MakeInterestCircle(double x, double y, double scale)
{
    InterestCircle* c = new InterestCircle(x, y, 0);
    c->mScale = scale;
    return c;
}
    
bool 
uniq_InterestCircle (InterestPoint* lhs2, InterestPoint* rhs2)
{ 
    if(lhs2->geometryType() != "CircleZ") return false;
    if(rhs2->geometryType() != "CircleZ") return false;
    InterestCircle* lhs(dynamic_cast<InterestCircle*>(lhs2));
    InterestCircle* rhs(dynamic_cast<InterestCircle*>(rhs2));
    return (abs(lhs->mX-rhs->mX) < 0.000000001) && (abs(lhs->mY-rhs->mY)< 0.000000001) && (abs(lhs->mScale-rhs->mScale) < 0.000000001);
}

bool 
compare_InterestCircle (InterestPoint* lhs2, InterestPoint* rhs2)
{ 
    if((lhs2->geometryType() != "CircleZ") || (rhs2->geometryType() != "CircleZ")) {
        throw "compare_InterestCircle cannot compare these types!";
    }
    InterestCircle* lhs(dynamic_cast<InterestCircle*>(lhs2));
    InterestCircle* rhs(dynamic_cast<InterestCircle*>(rhs2));
    
    if(lhs->mX < rhs->mX) {
        return true;
    } else if(abs(lhs->mX-rhs->mX) < 0.000000001) {
        if(lhs->mY < rhs->mY) {
            return true;
        } else if(abs(lhs->mY-rhs->mY)< 0.000000001) {
            if(lhs->mScale < rhs->mScale) {
                return true;
            } else if(lhs->mScale == rhs->mScale) {
                return false;
            } else {
                return false;
            }
        } else {
            // lhs > rhs
            return false;
        }
    } else {
        // lhs > rhs
        return false;
    }
}

bool 
compare_InterestCircle_cornerness (InterestPoint* lhs2, InterestPoint* rhs2)
{ 
    if((lhs2->geometryType() != "CircleZ") || (rhs2->geometryType() != "CircleZ")) {
        throw "compare_InterestCircle cannot compare these types!";
    }
    InterestCircle* lhs(dynamic_cast<InterestCircle*>(lhs2));
    InterestCircle* rhs(dynamic_cast<InterestCircle*>(rhs2));

    if(lhs->mCornerness > rhs->mCornerness) {
        return true;
    }
    return false;
}

} // namespace Geometry
} // namespace Core
} // namespace Impala

#endif

---