yade-dev team mailing list archive

Thread
Date
"Yade does not render custom shape after integration step"

To: yade-dev@xxxxxxxxxxxxxxxxxxx
From: Burak Er <burak.er@xxxxxxxxxx>
Date: Tue, 17 Sep 2013 13:36:11 +0300 (EEST)
In-reply-to: <488241786.126374.1379413844961.JavaMail.root@btu.edu.tr>
Thread-index: ZeASyWLZb1fRp8nfG+wxc7Gg+O5M1A==
Thread-topic: "Yade does not render custom shape after integration step"
Dear Yade Developers, 

I am trying to create an element interface for yade(finite element). In this interface, 
The nodes and the triangles are held within the structure. The structures that I created as follows, 

DeformableElement-> derived from Shape 
Gl1_DeformableElement->derived from GlShapeFunctor 

Every time in a step drawing of the element is not realized after NewtonIntegrator step. 
Initially all faces of the element is drawn in ::go function of the Gl1_DeformableElement 
but after one step it is not drawn. What is the reason for this behaviour? Here is the screenshots, 

before integration 
<a href="http://tinypic.com?ref=2eauds1"; target="_blank"><img src="http://i42.tinypic.com/2eauds1.png"; border="0" alt="Image and video hosting by TinyPic"></a> 

after integration 
<a href="http://tinypic.com?ref=280qckp"; target="_blank"><img src="http://i44.tinypic.com/280qckp.png"; border="0" alt="Image and video hosting by TinyPic"></a> 

The classes are as follows 

******************************Gl1_DeformableElement.hpp**************************************** 
#pragma once 

#include<yade/pkg/common/GLDrawFunctors.hpp> 
#include<yade/pkg/dem/deformablecohesive/DeformableElement.hpp> 

class Gl1_DeformableElement : public GlShapeFunctor 
{ 
public: 
virtual void go(const shared_ptr<Shape>&, const shared_ptr<State>&,bool,const GLViewInfo&); 
YADE_CLASS_BASE_DOC(Gl1_DeformableElement,GlShapeFunctor,"Renders :yref:`Node` object" 
); 
RENDERS(DeformableElement); 
}; 

REGISTER_SERIALIZABLE(Gl1_DeformableElement); 

***********************************************Gl1_DeformableElement.cpp**************************************** 

/************************************************************************* 
* Copyright (C) 2008 by Sergei Dorofeenko * 
* sega@xxxxxxxxxxxxxxxx * 
* * 
* This program is free software; it is licensed under the terms of the * 
* GNU General Public License v2 or later. See file LICENSE for details. * 
*************************************************************************/ 

#ifdef YADE_OPENGL 

#include<yade/pkg/dem/deformablecohesive/Gl1_DeformableElement.hpp> 
#include<yade/pkg/dem/deformablecohesive/DeformableElement.hpp> 
#include<yade/lib/opengl/OpenGLWrapper.hpp> 

typedef DeformableElement::NodeMap NodeMap; 
void Gl1_DeformableElement::go(const shared_ptr<Shape>& cm, const shared_ptr<State>& ,bool wire,const GLViewInfo&) 
{ 


DeformableElement* element = static_cast<DeformableElement*>(cm.get()); 
std::vector<Vector3r> triangles = element->faces; 
Vector3r elempos=element->frame_get().position; 

Scene* scene(Omega::instance().getScene().get()); // get scene 


// if(!normals) return; 
// // DeformableElement's normal 
// glBegin(GL_LINES); 
// glColor3(0.0,0.0,1.0); 
// glVertex3(0.0,0.0,0.0); 
// glVertex3v(DeformableElement->normal); 
// glEnd(); 
// // normal of edges 
// glColor3(0.0,0.0,1.0); 
// glBegin(GL_LINES); 
// glVertex3(0.0,0.0,0.0); glVertex3v(Vector3r(icr*ne[0])); 
// glVertex3(0.0,0.0,0.0); glVertex3v(Vector3r(icr*ne[1])); 
// glVertex3(0.0,0.0,0.0); glVertex3v(Vector3r(icr*ne[2])); 
// glEnd(); 

if(!(cm->wire || wire)){ 
glDisable(GL_CULL_FACE); 
//Vector3r normal=(facet->vertices[1]-facet->vertices[0]).cross(facet->vertices[2]-facet->vertices[1]); normal.normalize(); 
glColor3v(cm->color); 
glBegin(GL_TRIANGLES); 

FOREACH(Vector3r vertices,triangles){ 
NodeMap::iterator i1(element->localmap.begin()); 
NodeMap::iterator i2(i1); 
NodeMap::iterator i3(i1); 

std::advance(i1,vertices[0]); 
std::advance(i2,vertices[1]); 
std::advance(i3,vertices[2]); 

const shared_ptr<Body>& member1=Body::byId(i1->first,scene); 
const shared_ptr<Body>& member2=Body::byId(i2->first,scene); 
const shared_ptr<Body>& member3=Body::byId(i3->first,scene); 

Vector3r pos1=member1->state->pos; 
Vector3r pos2=member2->state->pos; 
Vector3r pos3=member3->state->pos; 

cout<<"Pos1"<<pos1<<"\n"; 
cout<<"Pos2"<<pos2<<"\n"; 
cout<<"Pos3"<<pos3<<"\n"; 


glVertex3v(pos1); 
glVertex3v(pos2); 
glVertex3v(pos3); 

} 
} 
glEnd(); 

glBegin(GL_LINE_LOOP); 
glColor3v(Vector3r(0,0,0)); 
FOREACH(Vector3r vertices,triangles){ 
NodeMap::iterator i1(element->localmap.begin()); 
NodeMap::iterator i2(i1); 
NodeMap::iterator i3(i1); 

std::advance(i1,vertices[0]); 
std::advance(i2,vertices[1]); 
std::advance(i3,vertices[2]); 

const shared_ptr<Body>& member1=Body::byId(i1->first,scene); 
const shared_ptr<Body>& member2=Body::byId(i2->first,scene); 
const shared_ptr<Body>& member3=Body::byId(i3->first,scene); 

Vector3r pos1=member1->state->pos; 
Vector3r pos2=member2->state->pos; 
Vector3r pos3=member3->state->pos; 

glVertex3v(pos1); 
glVertex3v(pos2); 
glVertex3v(pos3); 
} 

glEnd(); 

} 

YADE_PLUGIN((Gl1_DeformableElement)); 

#endif /* YADE_OPENGL */ 

AND 


*****************************************************DeformableElement.hpp*************************************** 
/************************************************************************* 
* Copyright (C) 2013 by Burak ER * 
* * 
* * 
* This program is free software; it is licensed under the terms of the * 
* GNU General Public License v2 or later. See file LICENSE for details. * 
*************************************************************************/ 

#pragma once 

#include<vector> 
#include<map> 
#include<stdexcept> 
#include<yade/core/Body.hpp> 
#include<yade/lib/base/Logging.hpp> 
#include<yade/lib/base/Math.hpp> 
#include<yade/core/PartialEngine.hpp> 

//#include<yade/trunk/pkg/dem/deformablecohesive/Node.hpp> //Node shape 

/* Before starting the implementation of the deformable element, I am really dissappointed that deformableelement's algorithm relies on its shape. 
Shape means "shape" and I think it should not contain any other physical meaning or anything else. Therefore, DeformableElement like 
deformable element structure is not used. 

With respect to this view; The deformable element class is derived from the body and knows the information of 
its members that are node shaped bodies. 

*/ 

class NewtonIntegrator; 

namespace yade{ 

class DeformableElement: public Shape { 
public: 

typedef std::map<Body::id_t,Se3r> NodeMap; 
typedef std::vector<Vector3r> Triangles; // Used for drawing the element 

virtual ~DeformableElement (); 
void addNode(const shared_ptr<Body>& subBody); 
void delNode(const shared_ptr<Body>& subBody); 

void addFace(Vector3r&); 
void removeLastFace(void); 
//! Recalculate physical properties of DeformableElement. 

Se3r frame_get(); 
void frame_set(Se3r); 

//! update member positions after deformableelement being moved by mouse (in case simulation is paused and engines will not do that). 
//void userForcedDisplacementRedrawHook(){ throw runtime_error("DeformableElement::userForcedDisplacementRedrawHook not yet implemented (with DeformableElement as subclass of Shape).");} 

python::dict localmap_get(); 

YADE_CLASS_BASE_DOC_ATTRS_INIT_CTOR_PY(DeformableElement,Shape,"Deformable aggregate of nodes", 
((NodeMap,localmap,,,"Ids and relative positions+orientations of members of the deformable element (should not be accessed directly)")) 
((Se3r,elementframe,,,"Position and orientation of the element frame")) 
((Triangles,faces,,,"Faces of the element for drawing")), 
, 
createIndex(); /*ctor*/ 
, 
/*py*/ 
YADE_PY_TOPINDEXABLE(DeformableElement) 
.add_property("elementframe",&DeformableElement::frame_get) 
.def("addNode",&DeformableElement::addNode,"Add a node shared_pt<:yref:'Body'>& as into the element") 
.def("delNode",&DeformableElement::delNode,"Remove a node shared_pt<:yref:'Body'>& from the element") 
.def("addFace",&DeformableElement::addFace,"Add a face into the element") 
.def("removeLastFace",&DeformableElement::removeLastFace,"Remove a face from the element") 

); 
DECLARE_LOGGER; 

REGISTER_CLASS_INDEX(DeformableElement,Shape); 

}; 
} 
// necessary 
using namespace yade; 
REGISTER_SERIALIZABLE(DeformableElement); 




*****************************************************DeformableElement.cpp*************************************** 


// (c) 2007-2010 Vaclav Smilauer <eudoxos@xxxxxxxx> 

#include<yade/pkg/dem/deformablecohesive/DeformableElement.hpp> 
#include<algorithm> 
#include<yade/core/Scene.hpp> 
#include<yade/core/BodyContainer.hpp> 
#include<yade/core/State.hpp> 
#include<yade/pkg/common/Sphere.hpp> 
#include<yade/pkg/dem/deformablecohesive/Node.hpp> 


YADE_PLUGIN((DeformableElement)); 
CREATE_LOGGER(DeformableElement); 

python::dict DeformableElement::localmap_get(){ 
python::dict ret; 
FOREACH(NodeMap::value_type& b, localmap){ 
ret[b.first]=python::make_tuple(b.second.position,b.second.orientation); 
} 
return ret; 
} 
void DeformableElement::addFace(Vector3r& indexes){ 

faces.push_back(indexes); 

} 

DeformableElement::~DeformableElement(){ 

} 

void DeformableElement::removeLastFace(void){ 

faces.pop_back(); 

} 

void DeformableElement::addNode(const shared_ptr<Body>& nodeBody){ 

const shared_ptr<Node> node=YADE_PTR_CAST<Node>(nodeBody->shape);//Should be checked dynamically otherwise it will always cast: every shape is castable to Node shape 

Body::id_t subId=nodeBody->getId(); 

if(node){} else{ throw std::invalid_argument(("The body that is given #"+lexical_cast<string>(subId)+" is not a Node therefore cannot be added to the deformable element "));} 

if(subId<0){throw std::invalid_argument(("The Node that is given is not a member of the scene therefore it has no state, not adding exiting"));} 

if(this->localmap.count(subId)!=0) throw std::invalid_argument(("Node that has Body id #"+lexical_cast<string>(subId)+" is already part of this deformable element")); 

// Add body to localmap 
this->localmap[subId]=Se3r();// meaningful values will be put in by DeformableElement::updateProperties 

// Get first node 
Scene* scene(Omega::instance().getScene().get()); // get scene 
const shared_ptr<Body>& member=Body::byId(localmap.begin()->first,scene); 

//Substract from the current node, therefore find the local value, 
localmap[subId].position=nodeBody->state->pos-member->state->pos; 
//localmap[subId].orientation=nodeBody->state->ori; 

//this->setBounded(false); // disallow collisions with the element itself 

//If we have more than three nodes define a local triad that is clumped on the first node and initially parallel to the global frame 
if(this->localmap.size()>=3) 
{ 
//define a local triad if needed 
} 

return; 
} 

void DeformableElement::delNode(const shared_ptr<Body>& subBody){ 
// erase the subBody; removing body that is not part of the element throws 
if(this->localmap.erase(subBody->id)!=1) throw std::invalid_argument(("Node #"+lexical_cast<string>(subBody->id)+" not a part of the deformable element, not removing...").c_str()); 
LOG_DEBUG("Removed node #"<<subBody->id); 
} 

Se3r DeformableElement::frame_get() const 
{ 
Scene* scene(Omega::instance().getScene().get()); // get scene 
const shared_ptr<Body>& member=Body::byId(localmap.begin()->first,scene); 
return member->state->se3; 
} 

void DeformableElement::frame_set(Se3r) const 
{ 
// Scene* scene(Omega::instance().getScene().get()); // get scene 
// NodeMap::iterator i=localmap.begin(); 
// const shared_ptr<Body>& member=Body::byId(i->first,scene); 
return; 
}
Follow ups

Re: "Yade does not render custom shape after integration step"
From: Bruno Chareyre, 2013-09-17