/**********************************************************************
BondCentricTool - Bond Centric Manipulation Tool for Avogadro
Copyright (C) 2007 by Shahzad Ali
Copyright (C) 2007 by Ross Braithwaite
Copyright (C) 2007 by James Bunt
This file is part of the Avogadro molecular editor project.
For more information, see
Avogadro 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.
Avogadro 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 "skeletontree.h"
#include
#include
#include
using namespace Eigen;
using namespace std;
namespace Avogadro {
// ################################## Node #####################################
// ########## Constructor ##########
Node::Node(Atom *atom)
{
m_atom = atom;
}
// ########## Destructor ##########
Node::~Node() {}
// ########## atom ##########
Atom* Node::atom()
{
return m_atom;
}
// ########## nodes ##########
QList *Node::nodes()
{
return &m_nodes;
}
// ########## isLeaf ##########
bool Node::isLeaf()
{
return m_nodes.isEmpty();
}
// ########## containsAtom ##########
bool Node::containsAtom(Atom* atom)
{
//"atom" exist in the children and grandchildren... of this node.?
bool exists = false;
if (m_atom == atom) {
return true;
}
for (int i = 0; i < m_nodes.size(); i++)
{
Node* n = m_nodes.at(i);
if (n->containsAtom(atom))
{
exists = true;
break;
}
}
return exists;
}
// ########## addNode ##########
void Node::addNode(Node* node)
{
m_nodes.append(node);
}
// ########## removeNode ##########
void Node::removeNode(Node* node)
{
int i = m_nodes.indexOf(node);
if (i != -1) {
m_nodes.removeAt(i);
}
}
// ############################## SkeletonTree #################################
// ########## Constructor ##########
SkeletonTree::SkeletonTree() {}
// ########## Destructor ##########
SkeletonTree::~SkeletonTree()
{
delete m_rootNode;
}
// ########## rootAtom ##########
Atom* SkeletonTree::rootAtom()
{
return m_rootNode->atom();
}
// ########## rootBond ##########
Bond* SkeletonTree::rootBond()
{
return m_rootBond;
}
// ########## populate ##########
void SkeletonTree::populate(Atom *rootAtom, Bond *rootBond, Molecule* molecule)
{
if (!m_rootNode) {
delete m_rootNode;
}
m_rootNode = new Node(rootAtom);
m_rootBond = rootBond;
Atom* bAtom = m_rootBond->beginAtom();
Atom* eAtom = m_rootBond->endAtom();
if (bAtom != m_rootNode->atom() && eAtom != m_rootNode->atom()) {
return;
}
Atom* diffAtom = (bAtom == m_rootNode->atom()) ? eAtom : bAtom;
//A temproray tree to find loops
m_endNode = new Node(diffAtom);
//Recursively go through molecule and make a temproray tree.
//starting from m_endNode
recursivePopulate(molecule, m_endNode, m_rootBond);
//Recursively go through molecule and make the tree.
//starting from m_rootNode
recursivePopulate(molecule, m_rootNode, m_rootBond);
//delete the temporary tree
delete m_endNode;
//for debugging puposes
//printSkeleton(m_rootNode);
}
// ########## recursivePopulate ##########
void SkeletonTree::recursivePopulate(Molecule* mol, Node* node, Bond* bond)
{
Atom* atom = node->atom();
int found = 0;
for (unsigned int i=0; i < mol->numBonds(); i++) {
Bond* b = mol->bond(i);
Atom* bAtom = b->beginAtom();
Atom* eAtom = b->endAtom();
if ((b != bond) && ((bAtom == atom) || (eAtom == atom))) {
Atom* diffAtom = (bAtom == atom) ? eAtom : bAtom;
//Check if this atom already exists, so not to form loops
if ((!m_endNode->containsAtom(diffAtom)) &&
(!m_rootNode->containsAtom(diffAtom))) {
Node* newNode = new Node(diffAtom);
node -> addNode(newNode);
found++;
recursivePopulate(mol, newNode, b);
}
}
}
}
// ########## skeletonTranslate ##########
void SkeletonTree::skeletonTranslate(double dx, double dy, double dz)
{
if (m_rootNode) {
//Translate skeleton
recursiveTranslate(m_rootNode, dx, dy, dz);
}
}
// ########## skeletonRotate ##########
void SkeletonTree::skeletonRotate(double angle, Eigen::Vector3d rotationVector,
Eigen::Vector3d centerVector)
{
if (m_rootNode) {
//Rotate skeleton
Quaternion qLeft = Quaternion::createRotationLeftHalf(angle, rotationVector);
Quaternion qRight = qLeft.multiplicitiveInverse();
recursiveRotate(m_rootNode, qLeft, qRight, centerVector);
}
}
// ########## recursiveTranslate ##########
void SkeletonTree::recursiveTranslate(Node* n, double x, double y, double z)
{
QList* listNodes = n->nodes();
Atom* a = n->atom();
a->setPos(Vector3d(a->pos()->x() + x, a->pos()->y() + y, a->pos()->z() + z));
a->update();
for (int i = 0; i < listNodes->size(); i++) {
Node* node = listNodes->at(i);
recursiveTranslate(node, x, y, z);
}
}
// ########## recursiveRotate ##########
void SkeletonTree::recursiveRotate(Node* n, Quaternion left, Quaternion right,
Eigen::Vector3d centerVector)
{
QList* listNodes = n->nodes();
Atom* a = n->atom();
Vector3d final = performRotation(left, right, centerVector, *a->pos());
a->setPos(final);
a->update();
for (int i = 0; i < listNodes->size(); i++)
{
Node* node = listNodes->at(i);
recursiveRotate(node, left, right, centerVector);
}
}
// ########## printSkeleton ##########
void SkeletonTree::printSkeleton(Node* n)
{
QList* listNodes = n->nodes();
for (int i = 0; i < listNodes->size(); i++)
{
Node* n = listNodes->at(i);
printSkeleton(n);
}
Atom* a = n->atom();
cout << a->pos()->x() << "," << a->pos()->y()<< ","<pos()->z() << endl;
if (!n->isLeaf()) {
cout << "-------------" << endl;
}
}
// ########## containsAtom ##########
bool SkeletonTree::containsAtom(Atom *atom)
{
return m_rootNode ? m_rootNode->containsAtom(atom) : false;
}
// ########## performRotation ##########
Eigen::Vector3d SkeletonTree::performRotation(Quaternion left, Quaternion right,
Eigen::Vector3d centerVector,
Eigen::Vector3d positionVector)
{
return Quaternion::performRotationMultiplication(left, positionVector -
centerVector, right) + centerVector;
}
}
#include "skeletontree.moc"