TYGeometryNode.cpp

Go to the documentation of this file.

/*
 * Copyright (C) <2012> <EDF-R&D> <FRANCE>
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

/*
 *
 */


#include "Tympan/core/logging.h"
#include "Tympan/models/common/3d.h"

// Implementation

#include "TYGeometryNode.h"

TYMapPtrGeoNode* TYGeometryNode::_geoNodeMap = NULL;
TYListPtrGeoNode* TYGeometryNode::_geoNodeDoublonsList = NULL;


// acces map like a singleton to avoid bad order in static instantiation
TYMapPtrGeoNode* TYGeometryNode::GetGeoNodeMap()
{
    if (_geoNodeMap)
    {
        return  _geoNodeMap;
    }
    else { return  _geoNodeMap = new TYMapPtrGeoNode(); }
}

TYListPtrGeoNode* TYGeometryNode::GetGeoNodeDoublonsList()
{
    if (_geoNodeDoublonsList)
    {
        return  _geoNodeDoublonsList;
    }
    else { return  _geoNodeDoublonsList = new TYListPtrGeoNode(); }
}

void TYGeometryNode::addToTheMap()
{
    if (NULL == (TYElement*)getElement())
    {
        return;    //ne devrait pas arriver
    }
    //La place est-elle deja prise ?
    TYGeometryNode* pOldGeometryNode = GetGeoNode(getElement());
    if (pOldGeometryNode)
    {
        //oui => memoriser l'ancien geoNode:
        GetGeoNodeDoublonsList()->push_back(pOldGeometryNode);
    }
    (*GetGeoNodeMap())[getElement()] = this;
}

void TYGeometryNode::removeFromTheMap()
{
    if (NULL == (TYElement*)getElement())
    {
        return;    //ne devrait pas arriver
    }
    //1. supprimer toute reference a this dans la map:
    //La place est-elle deja prise ?
    TYGeometryNode* pOldGeometryNode = GetGeoNode(getElement());
    if (pOldGeometryNode)
    {
        //oui => l'enlever de la map:
        GetGeoNodeMap()->erase(getElement());
    }
    //Y a-t-il parmi la liste de doublon un geoNode pointant sur cet element ?
    //Si c'est le cas, on l'ajoute a la map:
    TYListPtrGeoNode::iterator ite;
    for (ite = GetGeoNodeDoublonsList()->begin(); ite != GetGeoNodeDoublonsList()->end(); ite++)
    {
        TYGeometryNode* pCurrentTYGeometryNode = TYGeometryNode::safeDownCast((*ite));
        if (pCurrentTYGeometryNode->getElement() == getElement())
        {
            //Oui
            //on l'enleve de la liste:
            GetGeoNodeDoublonsList()->erase(ite);
            //on l'ajoute a la map:
            pCurrentTYGeometryNode->addToTheMap();
            break;
        }
    }
}

TYGeometryNode::TYGeometryNode()
{
    _name = TYNameManager::get()->generateName(getClassName());

    _hauteur = 0.0; //dt++
    _pElement = NULL;//az++
}

TYGeometryNode::TYGeometryNode(TYElement* pElt , TYElement* pParent /*=NULL*/) :
    TYElement(pParent)
{
    _pElement = pElt;
    addToTheMap();
    _hauteur = 0.0;

    if (pParent && _pElement)
    {
        // On assigne le meme parent a l'element si celui-ci n'est pas null
        _pElement->setParent(pParent);
    }
}

TYGeometryNode::TYGeometryNode(LPTYElement pElt, TYElement* pParent /*=NULL*/) :
    TYElement(pParent)
{
    _pElement = pElt;
    addToTheMap();
    _hauteur = 0.0;

    if (pParent && _pElement)
    {
        // On assigne le meme parent a l'element si celui-ci n'est pas null
        _pElement->setParent(pParent);
    }
}

TYGeometryNode::TYGeometryNode(const TYRepere& repere, TYElement* pElt)
{
    _repere = repere;
    _hauteur = 0.0;

    _pElement = pElt;
    addToTheMap();
}

TYGeometryNode::TYGeometryNode(const TYRepere& repere, LPTYElement pElt)
{
    _repere = repere;
    _hauteur = 0.0;

    _pElement = pElt;
    addToTheMap();
}

TYGeometryNode::TYGeometryNode(TYElement* pElt, const OMatrix& matrix)
    : _repere(matrix)
{
    _hauteur = 0.0;

    _pElement = pElt;
    addToTheMap();
}

TYGeometryNode::TYGeometryNode(LPTYElement pElt, const OMatrix& matrix)
    : _repere(matrix)
{
    _hauteur = 0.0;

    _pElement = pElt;
    addToTheMap();
}

TYGeometryNode::TYGeometryNode(const TYGeometryNode& other)
{
    _pElement = NULL;
    *this = other;
}

TYGeometryNode::~TYGeometryNode()
{
    if (_pElement) //ce test a ete rajoute surtout pour eviter de faire des recherches dans les map & list en fin d'application, car les map & list en static peuvent etre detruites avant le dernier GeoNode !
    {
        //Comme le pointeur this ne sera plus valide, le supprimer de la liste des doublons:
        GetGeoNodeDoublonsList()->remove(this);
        //Enlever toute reference  dans le map:
        removeFromTheMap();
    }
}


DOM_Element TYGeometryNode::toXML(DOM_Element& domElement)
{
    DOM_Element domNewElem = TYElement::toXML(domElement);

    // On sauvegarde la hauteur en premier
    TYXMLTools::addElementStringValue(domNewElem, "hauteur", doubleToStrPre(_hauteur, 3).data());
    // Puis, on sauvegarde le repere
    _repere.toXML(domNewElem);

    if (_pElement)
    {
        _pElement->toXML(domNewElem);
    }

    return domNewElem;
}

int TYGeometryNode::fromXML(DOM_Element domElement)
{
    TYElement::fromXML(domElement);

    int res = -1;
    int retVal;
    bool eltFound = false;
    bool hauteurOk = false;
    double hauteurLue = 0;
    DOM_Element elemCur;
    DOM_Node nodeTmp;
    QString str;

    QDomNodeList childs = domElement.childNodes();

    for (unsigned int i = 0; i < childs.length(); i++)
    {
        retVal = -1;
        elemCur = childs.item(i).toElement();

        // La hauteur doit etre le premier element
        TYXMLTools::getElementDoubleValue(elemCur, "hauteur", hauteurLue, hauteurOk);
        if (hauteurOk)
        {
            _hauteur = hauteurLue;
        }

        // On cherche le repere
        if (_repere.callFromXMLIfEqual(elemCur, &retVal))
        {
            // Fix #115 : Si le Repere est invalide alors on ne lit pas le GeometryNode
            if (retVal == 1)
            {
                // Le prochain child (node et pas '#text')
                // doit etre le noeud de l'element
                nodeTmp = elemCur.nextSibling();

                // problem here with count
                // nodeTmp = nodeTmp.nextSibling();

                // Au cas oi nbChild soit faux (trop grand)
                if (nodeTmp.isNull())
                {
                    break;
                }

                // Ajout du prefixe TY
                str = "TY";
                str += nodeTmp.nodeName();

                // Auto construction a partir du type trouve
                //_pElement = (TYElement *) TYElement::findAndClone((char *)str.data());//az--
                setElement((TYElement*)TYElement::findAndClone((char*)str.toLatin1().data()));  //az++

                // Si la classe a ete trouve (elle doit heriter de TYElement)
                if (_pElement)
                {
                    // Le parent de l'element n'est pas le GeoNode mais son parent
                    // (uniquement si le champs parent du GeoNode est renseigne)
                    if (getParent())
                    {
                        _pElement->setParent(getParent());
                    }

                    // Parsing
                    _pElement->fromXML(*((DOM_Element*)&nodeTmp));

                    // L'element a ete trouve et traite
                    eltFound = true;
                }
            }
        }
    }

    if (eltFound)
    {
        res = 1;
    }

    return res;
}

void TYGeometryNode::getChilds(LPTYElementArray& childs, bool recursif /*=true*/)
{
    TYElement::getChilds(childs, recursif);

    if (_pElement)
    {
        _pElement->getChilds(childs, recursif);
    }
}

void TYGeometryNode::setElement(LPTYElement pElt)
{
    setElement((TYElement*)pElt);
}

void TYGeometryNode::setElement(TYElement* pElt)
{
    removeFromTheMap();
    _pElement = pElt;
    addToTheMap();

    setIsGeometryModified(true);
}


void TYGeometryNode::delElement()
{
    if (_pElement)
    {
        GetGeoNodeMap()->erase(_pElement);
        delete _pElement;
        _pElement = NULL;
    }

    setIsGeometryModified(true);
}


TYGeometryNode& TYGeometryNode::operator=(const TYGeometryNode& other)
{
    if (this != &other)
    {
        TYElement::operator=(other);
        //_pElement = other._pElement;//az--
        setElement(other._pElement);//az++
        _repere = other._repere;
        _hauteur = other._hauteur;
    }
    return *this;
}

bool TYGeometryNode::operator==(const TYGeometryNode& other) const
{
    if (this != &other)
    {
        if (TYElement::operator !=(other)) { return false; }
        if (_pElement != other._pElement) { return false; }
        if (_repere != other._repere) { return false; }
        if (_hauteur != other._hauteur) { return false; }
    }
    return true;
}

bool TYGeometryNode::operator!=(const TYGeometryNode& other) const
{
    return !operator==(other);
}

bool TYGeometryNode::deepCopy(const TYElement* pOther, bool copyId /*=true*/, bool pUseCopyTag /*=false*/)
{
    TYElement::deepCopy(pOther, copyId);
    TYGeometryNode* pOtherGeoNode = NULL;
    if (pOther) { pOtherGeoNode = (TYGeometryNode*) pOther; }
    if (!pOtherGeoNode || !pOtherGeoNode->getElement()) { return false; }

    // Avant de faire la deep copy sur l'element il faut s'assurer
    // qu'ils sont de meme type
    setElement((TYElement*) pOtherGeoNode->getElement()->clone());

    // Deep copy de l'element
    if (!_pElement->deepCopy(pOtherGeoNode->_pElement, copyId, true)) { return false; }

    // Deep copy du repere
    if (!_repere.deepCopy(&pOtherGeoNode->_repere, copyId)) { return false; }

    _hauteur = pOtherGeoNode->_hauteur;

    setIsGeometryModified(true);
    setIsAcousticModified(true);

    return true;
}

// XXX There seems to be excessive complexity around updateMatrix and updateRepere :
// setMAtrix->setPrivateMatrix->updateRepere->_repere.set(_matrix)
    // FIXME Why this double copy of matrices while it looks like
    // _repere.getMatChangeRep(_matrix) would be simpler and more efficient ?
TYGeometryNode* TYGeometryNode::GetGeoNode(TYElement* pElement)
{
    if (GetGeoNodeMap()->find(pElement) != GetGeoNodeMap()->end())
    {
        return ((*GetGeoNodeMap())[pElement]);
    }
    return NULL;
}

TYGeometryNode* TYGeometryNode::GetGeoNodeParent() const
{
    //1. Element pointe par le GeoNode:
    TYElement* pElement = getElement();
    //2. on s'interresse aux parents du cet element
    TYElement* pCurrentParent = pElement->getParent();
    while (pCurrentParent)
    {
        //3. le parent est peut-etre deja un TYGeometryNode ?
        TYGeometryNode* pPotentialGeoNode = TYGeometryNode::safeDownCast(pCurrentParent);
        if (pPotentialGeoNode)
        {
            return pPotentialGeoNode;
        }
        //4. le parent dispose d'un GeoNode
        pPotentialGeoNode = GetGeoNode(pCurrentParent);
        if (pPotentialGeoNode)
        {
            return pPotentialGeoNode;
        }
        //5. examinons le parent du parent...
        pCurrentParent = pCurrentParent->getParent();
    }
    return NULL;
}

void TYGeometryNode::GetGeoNodeParentList(TYListPtrGeoNode& GetGeoNodeParents)
{
    TYGeometryNode* pCurrrentGeoNodeParent = GetGeoNodeParent();
    while (pCurrrentGeoNodeParent)
    {
        GetGeoNodeParents.push_back(pCurrrentGeoNodeParent);
        pCurrrentGeoNodeParent = pCurrrentGeoNodeParent->GetGeoNodeParent();
    }
}

OMatrix TYGeometryNode::localToGlobal() const
{
    TYGeometryNode* pParent = GetGeoNodeParent();
    OMatrix matrix = _repere.asMatrix();

    while (pParent != NULL)
    {
        matrix = pParent->getORepere3D().asMatrix() * matrix;
        pParent = pParent->GetGeoNodeParent();
    }

    return matrix;
}

OMatrix TYGeometryNode::globalToLocal() const
{
    return localToGlobal().getInvert();
}

#if TY_USE_IHM
LPTYElementGraphic TYGeometryNode::getGraphicObject()
{
    if (!_pGraphicObject)
    {
        _pGraphicObject = new TYGeometryNodeGraphic((TYGeometryNode*) this);
    }
    return _pGraphicObject;
}
#endif // TY_USE_IHM

void TYGeometryNode::setMatrix(const OMatrix& matrix)
{
    _repere.set(matrix);
    setIsGeometryModified(true);
}

void TYGeometryNode::setPosition(const OPoint3D& pos)
{
    ORepere3D repere = getORepere3D();
    repere._origin._x = pos._x;
    repere._origin._y = pos._y;
    repere._origin._z = pos._z;
    setRepere(repere);
}

void TYGeometryNode::setRotation(const OPoint3D& rot)
{
    OMatrix tyMat;
    OMatrix tyMatTmpX;
    OMatrix tyMatTmpY;
    OMatrix tyMatTmpZ;
    OMatrix tyMatTmpConcat;

    // On applique la rotation
    double dRotateX = rot._x;
    double dRotateY = rot._y;
    double dRotateZ = rot._z;

    tyMatTmpX.setRotationOx(-DEGTORAD(dRotateX));
    tyMatTmpY.setRotationOy(-DEGTORAD(dRotateY));
    tyMatTmpZ.setRotationOz(DEGTORAD(dRotateZ));

    tyMat = tyMat * tyMatTmpZ * tyMatTmpY * tyMatTmpX * tyMatTmpConcat;

    OPoint3D org = _repere._origin; // On conserve l'origine de depart
    _repere.set(tyMat);
    _repere._origin = org;
}

OPoint3D TYGeometryNode::rotation()
{
    OMatrix mat = getMatrix();
    // Get rotations from transform matrix
    OPoint3D vec;
    vec._x = mat._m[0][1];
    vec._y = mat._m[1][1];
    vec._z = mat._m[2][1];

    // Get X-vector for roll calculation
    OPoint3D xv;
    xv._x = mat._m[0][0];
    xv._y = mat._m[1][0];
    xv._z = mat._m[2][0];

    // Calculate PRH (x = pitch, y = roll, z = heading)
    OPoint3D rotTmp(-atan2(vec._z, sqrt(vec._x * vec._x + vec._y * vec._y)), xv._z, -atan2(-vec._x, vec._y));

    // Set up vars
    double pitch = RADTODEG(rotTmp._x);     // Pitch
    double yaw = -RADTODEG(rotTmp._z);       // Heading
    double roll = RADTODEG(rotTmp._y);      // Roll

    // Affiche la boite de dialogue
    return OPoint3D(pitch, roll, yaw);
}