FDH14DistRot.cc

Go to the documentation of this file.

#include <esg/spacesorting/FDH14DistRot.h>

using namespace esg;


/*
 * This macro returns one direction of rotated FDH, it uses "cache" of
 * previously computed values
 */
#define _B(x) ((_set & (1<<(x))) \
               ? (_transf[x]) \
               : ((_set |= (1<<(x))), \
                  ((_pRotInfo) \
                   ? (_transf[x]=FDH14::RotInfo::fast_lp(_pRotInfo->get(x),_orig)) \
                   : (_transf[x]=_orig[x]))))

/*
 * Update current minimal value;
 * in case it drops below "bound" we cannot improve current result;
 * there can be at most one direction from each pair with value below zero
 */
#define _UPDATE(i, x) { \
    register float s=(x); \
    if (s<minim) { if (s<=bound) return MAXFLOAT; minim=s; index=(i); } \
    if (s<0) continue; \
}

double FDH14DistRot::_distance(const FDH14& fdh14, double minD, Vector3* pDir)
{
    register float    minim = FLT_MAX;
    register float    bound = -minD;
    register unsigned index = 0;

    for (register unsigned i = 0; i < FDH14::DIRS; i++) {
        _UPDATE(i, fdh14._values[i]             + _B(i+FDH14::DIRS));
        _UPDATE(i, fdh14._values[i+FDH14::DIRS] + _B(i));
    }

    if (pDir) pDir->set(FDH14::FDHMat[index][0],
                        FDH14::FDHMat[index][1],
                        FDH14::FDHMat[index][2]);

    return ((_scaleRatio == 0.) ? -MAXFLOAT : -minim / _scaleRatio);
}

double FDH14DistRot::_distance(const Geometry& geom, double minD,Vector3* pDir)
{
    register float    minim = FLT_MAX;
    register float    bound = -minD;
    register unsigned index = 0;
    Interval          ext;

    minim = MAXFLOAT;
    bound = -minD;

    for (unsigned i = 0; i < FDH14::DIRS; i++) {
        ext = geom.extent(FDH14::FDHMat[i][0],
                          FDH14::FDHMat[i][1],
                          FDH14::FDHMat[i][2]);
        _UPDATE(i,  ext.max + _B(i+FDH14::DIRS));
        _UPDATE(i, -ext.min + _B(i));
    }

    if (pDir) pDir->set(FDH14::FDHMat[index][0],
                        FDH14::FDHMat[index][1],
                        FDH14::FDHMat[index][2]);

    return ((_scaleRatio == 0.) ? -MAXFLOAT : -minim / _scaleRatio);
}

bool FDH14DistRot::_separation(const FDH14& fdh14)
{
    for (unsigned i = 0; i < FDH14::DIRS; i++) {
        if ((fdh14._values[i]            +_B(i+FDH14::DIRS)) < 0) return true;
        if ((fdh14._values[i+FDH14::DIRS]+_B(i))             < 0) return true;
    }

    return false;
}

bool FDH14DistRot::_separation(const Geometry& geom)
{
    Interval ext;

    for (unsigned i = 0; i < FDH14::DIRS; i++) {
        ext = geom.extent(FDH14::FDHMat[i][0],
                          FDH14::FDHMat[i][1],
                          FDH14::FDHMat[i][2]);
        if (( ext.max + _B(i+FDH14::DIRS)) < 0) return true;
        if ((-ext.min + _B(i))             < 0) return true;
    }

    return false;
}


#undef _B
#undef _UPDATE


FDH14DistRot::FDH14DistRot(float          * fdhValues,
                           FDH14::RotInfo * pRotInfo,
                           double           sr)
    : DistRot(sr)
{
    _orig     = fdhValues;
    _set      = 0;
    _pRotInfo = pRotInfo;
    _transf   = new float [FDH14::SIZE];
}

double FDH14DistRot::distance(Geometry& geom, double minD, Vector3* pDir)
{
    if (!_orig) return MAXFLOAT;

    try {
        FDH14& fdh = dynamic_cast<FDH14&>(geom);
        return _distance(fdh, minD, pDir);
    } catch (bad_cast) { 
        try {
            FDH& fdh = dynamic_cast<FDH&>(geom);
            return _distance(fdh, minD, pDir);
        } catch (bad_cast) { 
            return _distance(geom, minD, pDir);
        }
    }
}

bool FDH14DistRot::separation(Geometry& geom, Vector3* pDir)
{
    // we are able to compute the direction only in distance() method
    if (pDir) return ((distance(geom, FLT_MAX, pDir) > 0.) ? true : false);
    
    if (!_orig) return true;

    try {
        FDH14& fdh = dynamic_cast<FDH14&>(geom);
        return _separation(fdh);
    } catch (bad_cast) { 
        try {
            FDH& fdh = dynamic_cast<FDH&>(geom);
            return _separation(fdh);
        } catch (bad_cast) { 
            return _separation(geom);
        }
    }
}

---