SDS.cc

Go to the documentation of this file.

#include <esg/spacesorting/SDS.h>

using namespace esg;

void SDS::_duplicate_attributes(const SDS& s)
{
    _delayBuild = s._delayBuild;
}

Matrix4* SDS::multiTrans(const Matrix4* U,
                         const Matrix4* R,
                         Vector3&       scale)
{
    /*
     * Change two transformations to one.
     * To compute distance of objects transformed by Ux+t and Rx+s it is
     * sufficient to compute distance of the first object (non-transformed)
     * and the second object transformed by the rot*x+tra matrix, where
     *
     *       rot   = U^{-1} * R
     *       tra   = scaleU^{-1} * U^{-1} * (s-t)
     *       scale = scaleU^{-1} * rot * scaleR 
     *
     * Where
     *    U^{-1}      = U^T
     *    scaleU^{-1} = (1/scaleU.x, 1/scaleU.y, 1/scaleU.z)
     */

    /*
     * I'm not sure about correctness of this code  - untested !!!
     */

    if (!U && !R) { scale.set(1.0, 1.0, 1.0); return NULL; }

    Vector3  s,t,tra;
    Matrix4* pRet = new Matrix4;
    Matrix3  rotU, rotR;
    Matrix4  auxMat;

    if (!U) { // U = identity
        scale.set(1.0, 1.0, 1.0);
        pRet->set(*R);
        return pRet;
    }

    if (!R) { // R = identity
        U->get(rotU, t, scale);
        scale.x = 1.0 / scale.x;
        scale.y = 1.0 / scale.y;
        scale.z = 1.0 / scale.z;
        rotU.transpose();
        t.negate();
        rotU.transform(t);
        t.x *= scale.x;
        t.y *= scale.y;
        t.z *= scale.z;

        pRet->setIdentity();
        pRet->setElement(0, 0, scale.x);
        pRet->setElement(1, 1, scale.y);
        pRet->setElement(2, 2, scale.z);

        auxMat.set(rotU);
        pRet->mul(auxMat);        // first rotate and then scale
        pRet->setTranslation(t);  // finilly translate
    
        //pRet->set(rotU, t, scale);
        return pRet;
    }

    Vector3 scR;
    U->get(rotU, t, scale);
    R->get(rotR, s, scR);

    scale.x = 1.0 / scale.x;
    scale.y = 1.0 / scale.y;
    scale.z = 1.0 / scale.z;
    
    rotU.transpose();

    // get translation
    s.sub(t);
    rotU.transform(s);
    s.x *= scale.x;
    s.y *= scale.y;
    s.z *= scale.z;

    // initialize to set transformation matrices from left to right
    pRet->setIdentity();

    // S1^-1
    pRet->setElement(0, 0, scale.x);
    pRet->setElement(1, 1, scale.y);
    pRet->setElement(2, 2, scale.z);

    // S1^-1 * (R1^T * R2)
    rotU.mul(rotR);
    auxMat.set(rotU);
    pRet->mul(auxMat);        // first rotate and then scale

    // S1^-1 * (R1^T * R2) * S2
    auxMat.setIdentity();
    auxMat.setElement(0, 0, scR.x);
    auxMat.setElement(1, 1, scR.y);
    auxMat.setElement(2, 2, scR.z);
    pRet->mul(auxMat);

    // finally set translation
    pRet->setTranslation(s); 
    
    //pRet->set(rotU, s, Vector3(scR.x*scale.x, scR.y*scale.y, scR.z*scale.z));

    return pRet;
}

Matrix4* SDS::multiTrans(const Matrix4* U,
                         const Matrix4* R,
                         double&        scale)
{
    /*
     * Change two transformations to one.
     * To compute distance of objects transformed by Ux+t and Rx+s it is
     * sufficient to compute distance of the first object (non-transformed)
     * and the second object transformed by the rot*x+tra matrix, where
     *
     *       rot   = U^{-1} * R
     *       tra   = U^{-1} * (s-t)
     *       scale = scaleU * scaleR 
     *
     * Where
     *    U^{-1} = U^T
     */

    scale = 1.0;
    
    if (!U && !R) return NULL;

    Vector3  s,t,tra;
    Matrix4* pRet = new Matrix4;
    Matrix3  rotU, rotR;

    if (!U) { // U = identity
        pRet->set(*R);
        return pRet;
    }

    if (!R) { // R = identity
        scale = 1.0 / U->get(rotU, t);
        rotU.transpose();
        t.negate();
        t.scale(scale);
        rotU.transform(t);
        pRet->set(rotU, t, scale);
        return pRet;
    }

    scale    = 1.0 / U->get(rotU, t);
    float sR = R->get(rotR, s);

    rotU.transpose();
    s.sub(t);
    s.scale(scale);
    rotU.transform(s);
    rotU.mul(rotR);
    pRet->set(rotU, s, sR * scale);
    
    return pRet;
}

---