Changeset 897a01 for src/UIElements/Views

Timestamp:

Apr 11, 2018, 6:29:56 AM (7 years ago)

Author:

Frederik Heber <frederik.heber@…>

Branches:

Candidate_v1.6.1, ChemicalSpaceEvaluator, Gui_displays_atomic_force_velocity, PythonUI_with_named_parameters, TremoloParser_IncreasedPrecision

Children:

8ac6d0e

Parents:

8450da

git-author:

Frederik Heber <frederik.heber@…> (08/08/17 21:26:57)

git-committer:

Frederik Heber <frederik.heber@…> (04/11/18 06:29:56)

Message:

Arrows display velocity and force of each atom.

Location:

src/UIElements/Views/Qt4

Files:

• Qt3D/GLMoleculeObject.cpp (modified) (2 diffs)
• Qt3D/GLMoleculeObject.hpp (modified) (2 diffs)
• Qt3D/GLMoleculeObject_atom.cpp (modified) (7 diffs)
• Qt3D/GLMoleculeObject_atom.hpp (modified) (3 diffs)
• Qt3D/GLWorldScene.cpp (modified) (3 diffs)
• QtInfoBox.cpp (modified) (2 diffs)

src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.cpp

@@ -61 +61 @@
 QGLMaterial *GLMoleculeObject::m_selectionMaterial = NULL;
 QGLMaterial *GLMoleculeObject::m_selectionBoxMaterial = NULL;
+QGLMaterial *GLMoleculeObject::m_velocityMaterial = NULL;
+QGLMaterial *GLMoleculeObject::m_forceMaterial = NULL;
 
 QGLSceneNode *GLMoleculeObject::meshEmpty[GLMoleculeObject::DETAILTYPES_MAX];
 QGLSceneNode *GLMoleculeObject::meshSphere[GLMoleculeObject::DETAILTYPES_MAX];
 QGLSceneNode *GLMoleculeObject::meshCylinder[GLMoleculeObject::DETAILTYPES_MAX];
+QGLSceneNode *GLMoleculeObject::meshArrow[GLMoleculeObject::DETAILTYPES_MAX];
 
 double GLMoleculeObject::detailMinDistance[GLMoleculeObject::DETAILTYPES_MAX] = {0, 15, 30, 42};
@@ -309 +312 @@
     m_selectionBoxMaterial->setEmittedLight( QColor(155, 50, 50) );
   }
+  if (!m_velocityMaterial){
+    m_velocityMaterial = new QGLMaterial(NULL);
+    QColor colorvelocity(50,50,255,255);
+    m_velocityMaterial->setColor(colorvelocity);
+  }
+  if (!m_forceMaterial){
+    m_forceMaterial = new QGLMaterial(NULL);
+    QColor colorforce(50,255,50,255);
+    m_forceMaterial->setColor(colorforce);
+  }
 }
 

src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp

@@ -108 +108 @@
    static QGLSceneNode *meshSphere[DETAILTYPES_MAX];
    static QGLSceneNode *meshCylinder[DETAILTYPES_MAX];
+   static QGLSceneNode *meshArrow[DETAILTYPES_MAX];
 
 protected:
@@ -130 +131 @@
    static QGLMaterial *m_selectionMaterial;
    static QGLMaterial *m_selectionBoxMaterial;
+   static QGLMaterial *m_velocityMaterial;
+   static QGLMaterial *m_forceMaterial;
    QGLAbstractEffect *m_effect;
    int m_objectId;

src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp

@@ -50 +50 @@
 #include "Element/element.hpp"
 #include "Element/periodentafel.hpp"
+#include "LinearAlgebra/Line.hpp"
 #include "LinearAlgebra/Vector.hpp"
 #include "UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp"
@@ -57 +58 @@
 GLMoleculeObject_atom::GLMoleculeObject_atom(
     QGLSceneNode *mesh[],
+    QGLSceneNode *mesharrow[],
     QObject *parent,
     QtObservedAtom::ptr &_ObservedAtom) :
   GLMoleculeObject(mesh, parent),
+  GLMoleculeObjectVelocity(mesharrow, this),
+  GLMoleculeObjectForce(mesharrow, this),
   ObservedAtom(_ObservedAtom)
 {
@@ -69 +73 @@
   setObjectId(_id);
   resetPosition();
+  resetVelocity();
+  resetForce();
   resetElement();
+
+  GLMoleculeObjectVelocity.setMaterial(GLMoleculeObject::m_velocityMaterial);
+  GLMoleculeObjectForce.setMaterial(GLMoleculeObject::m_forceMaterial);
 
   m_selected = ObservedAtom->getAtomSelected();
@@ -77 +86 @@
   connect( ObservedAtom.get(), SIGNAL(elementChanged()), this, SLOT(resetElement()));
   connect( ObservedAtom.get(), SIGNAL(positionChanged()), this, SLOT(resetPosition()));
+  connect( ObservedAtom.get(), SIGNAL(velocityChanged()), this, SLOT(resetVelocity()));
+  connect( ObservedAtom.get(), SIGNAL(forceChanged()), this, SLOT(resetForce()));
   connect( ObservedAtom.get(), SIGNAL(selectedChanged()), this, SLOT(resetSelected()));
 }
@@ -95 +106 @@
 }
 
+static void setArrow(
+    const Vector &_position,
+    const Vector &_arrow,
+    const double _offset,
+    GLMoleculeObject &_obj)
+{
+  // set position (cylinder offset is in its barymetric center)
+  Vector OneFourth(_position + (_offset/_arrow.Norm()+.75) * _arrow);
+  _obj.setPosition(QVector3D(OneFourth[0], OneFourth[1], OneFourth[2]));
+}
+
 void GLMoleculeObject_atom::resetPosition()
 {
@@ -100 +122 @@
   LOG(4, "INFO: GLMoleculeObject_atom::resetPosition() - new position is "+toString(Position)+".");
   setPosition(QVector3D(Position[0], Position[1], Position[2]));
+  setArrow(Position, 10.*ObservedAtom->getAtomVelocity(), scaleX(), GLMoleculeObjectVelocity);
+  setArrow(Position, 10.*ObservedAtom->getAtomForce(), scaleX(), GLMoleculeObjectForce);
+}
+
+static void alignArrow(
+    const Vector &_arrow,
+    GLMoleculeObject &_obj)
+{
+  if (_arrow.IsZero()) {
+    _obj.setScaleZ(0.);
+    return;
+  }
+  // calculate position
+  Vector Z(unitVec[2]); // cylinder are initially aligned along the Z axis
+  Vector b;
+  Vector OtherAxis;
+  double alpha;
+  // construct rotation axis
+  b = -1.*_arrow;
+  b.VectorProduct(Z);
+  Line axis(zeroVec, b);
+  // calculate rotation angle
+  alpha = _arrow.Angle(Z);
+  // construct other axis to check right-hand rule
+  OtherAxis = b;
+  OtherAxis.VectorProduct(Z);
+  // assure right-hand rule for the rotation
+  if (_arrow.ScalarProduct(OtherAxis) < MYEPSILON)
+    alpha = M_PI-alpha;
+  // check
+  Vector a_rotated = axis.rotateVector(_arrow, alpha);
+  LOG(5, "DEBUG: Aligning arrow " << _arrow << " to " << a_rotated
+      << " around " << b << " by " << alpha/M_PI*180. << ".");
+
+  _obj.setScaleZ(10.*_arrow.Norm());
+  _obj.setRotationVector(QVector3D(b[0], b[1], b[2]));
+  _obj.setRotationAngle(alpha/M_PI*180.);
+}
+
+void GLMoleculeObject_atom::resetVelocity()
+{
+  const Vector Velocity = ObservedAtom->getAtomVelocity();
+  LOG(4, "INFO: GLMoleculeObject_atom::resetVelocity() - new velocity is "+toString(Velocity)+".");
+  alignArrow(Velocity, GLMoleculeObjectVelocity);
+//  GLMoleculeObjectForce.setScaleZ(Velocity.Norm());
+}
+
+void GLMoleculeObject_atom::resetForce()
+{
+  const Vector Force = ObservedAtom->getAtomForce();
+  LOG(4, "INFO: GLMoleculeObject_atom::resetForce() - new force is "+toString(Force)+".");
+  alignArrow(Force, GLMoleculeObjectForce);
+//  GLMoleculeObjectForce.setScaleZ(Force.Norm());
 }
 
@@ -144 +219 @@
   // call old hook to do the actual paining
   GLMoleculeObject::draw(painter, cameraPlane);
+  GLMoleculeObjectVelocity.draw(painter, cameraPlane);
+  GLMoleculeObjectForce.draw(painter, cameraPlane);
 }
 

src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp

@@ -34 +34 @@
   GLMoleculeObject_atom(
       QGLSceneNode *mesh[],
+      QGLSceneNode *mesharrow[],
       QObject *parent,
       QtObservedAtom::ptr &_ObservedAtom
@@ -46 +47 @@
   void resetElement();
   void resetPosition();
+  void resetVelocity();
+  void resetForce();
   void resetSelected();
 
@@ -58 +61 @@
 
 private:
+  //!> internal GLMoleculeObject to represent the atom's velocity as an arrow
+  GLMoleculeObject GLMoleculeObjectVelocity;
+  //!> internal GLMoleculeObject to represent the atom's force as an arrow
+  GLMoleculeObject GLMoleculeObjectForce;
+
   //!> current list of bonds to compare new onw against for changes
   QtObservedAtom::ListOfBonds_t ListOfBonds;

src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp

@@ -154 +154 @@
   int sphereDetails[] = {5, 3, 2, 0};
   int cylinderDetails[] = {16, 8, 6, 3};
+  int arrowDetails[] = {8, 5, 3, 0};
   for (int i=0;i<GLMoleculeObject::DETAILTYPES_MAX;i++){
     QGLBuilder emptyBuilder;
@@ -165 +166 @@
     GLMoleculeObject::meshCylinder[i] = cylinderBuilder.finalizedSceneNode();
     GLMoleculeObject::meshCylinder[i]->setOption(QGLSceneNode::CullBoundingBox, true);
+    {
+      QGLBuilder builderCyl;
+      builderCyl << QGLCylinder(.15,.15,1.6,arrowDetails[i]);
+      QGLSceneNode *cyl = builderCyl.finalizedSceneNode();
+      QGLBuilder builderCone;
+      builderCone << QGLCylinder(0,.4,0.4,arrowDetails[i]);
+      QGLSceneNode *cone = builderCone.finalizedSceneNode();
+      {
+        QMatrix4x4 mat;
+        mat.translate(0.0f, 0.0f, 1.0f);
+        cone->setLocalTransform(mat);
+      }
+      GLMoleculeObject::meshArrow[i] = new QGLSceneNode(this);
+      GLMoleculeObject::meshArrow[i]->addNode(cyl);
+      GLMoleculeObject::meshArrow[i]->addNode(cone);
+    }
+    GLMoleculeObject::meshArrow[i]->setOption(QGLSceneNode::CullBoundingBox, true);
   }
   connect(board, SIGNAL(moleculeInserted(QtObservedMolecule::ptr)),
@@ -279 +297 @@
     atomObject = new GLMoleculeObject_atom(
             GLMoleculeObject::meshSphere,
+            GLMoleculeObject::meshArrow,
             parent,
             _atom);

src/UIElements/Views/Qt4/QtInfoBox.cpp

@@ -65 +65 @@
 
   setMinimumWidth(200);
-  setMinimumHeight(220);
+  setMinimumHeight(350);
 
   connect(timer, SIGNAL(timeout()), this, SLOT(timerTimeout()));
@@ -220 +220 @@
   addInfo(this, "Position y", QString(toString(atomRef->getAtomPosition()[1]).c_str()));
   addInfo(this, "Position z", QString(toString(atomRef->getAtomPosition()[2]).c_str()));
+  addInfo(this, "Velocity x", QString(toString(atomRef->getAtomVelocity()[0]).c_str()));
+  addInfo(this, "Velocity y", QString(toString(atomRef->getAtomVelocity()[1]).c_str()));
+  addInfo(this, "Velocity z", QString(toString(atomRef->getAtomVelocity()[2]).c_str()));
+  addInfo(this, "Force x", QString(toString(atomRef->getAtomForce()[0]).c_str()));
+  addInfo(this, "Force y", QString(toString(atomRef->getAtomForce()[1]).c_str()));
+  addInfo(this, "Force z", QString(toString(atomRef->getAtomForce()[2]).c_str()));
 }