void AReViVocalPlayerWidget::initializeMap()
{
ArRef<XmlParser> parser = XmlParser::NEW();
parser->parseFile("vocalAssistances.xml");
ArRef<AReVi::XmlNode> root_node = parser->getRoot();
ArRef<AReVi::XmlNode> node_Action=root_node->getChild("Action");
while(node_Action!= NULL)
{
string name = node_Action->getProperty("name");
string soundFile = node_Action->getProperty("soundFile");
_soundMap[name]=soundFile;
_accessAssistancesMap[name]=0;
node_Action=node_Action->getNext();
}
ArRef<XmlParser> parser2 = XmlParser::NEW();
parser2->parseFile("iconeAssistances.xml");
ArRef<AReVi::XmlNode> root2_node = parser2->getRoot();
ArRef<AReVi::XmlNode> node2_Action=root2_node->getChild("Action");
while(node2_Action!= NULL)
{
string name2 = node2_Action->getProperty("name");
string iconFile = node2_Action->getProperty("iconFile");
_iconMap[name2]=iconFile;
node2_Action=node2_Action->getNext();
}
}
void
EditorIkSolver::_checkPivotXZ(ArRef<Joint> joint, Vector3d /* requestedTranslation */, Quaterniond requestedRotation) {
double prx, pry, prz;
joint->getDeltaRotation().getEulerAngles(prx, pry, prz);
requestedRotation = joint->getDeltaRotation() * requestedRotation;
double rx, ry, rz;
requestedRotation.getEulerAngles(rx, ry, rz);
double* max[2];
double* min[2];
ar_down_cast<JointConstraint2DOF>(joint->getConstraint())->getLimitValues(min, max);
double xmin = *min[0], xmax = *max[0], zmin = *min[1], zmax = *max[1];
rx = _clampWithPreviousValue(xmin, xmax, prx, rx);
rz = _clampWithPreviousValue(zmin, zmax, prz, rz);
Quaterniond qx(Vector3d(1.0, 0.0, 0.0), rx);
Quaterniond qz(Vector3d(0.0, 0.0, 1.0), rz);
joint->setDeltaRotation(qx * qz);
}
void
UDPKinectSkeleton::initEmitKinect(unsigned int port, int deviceNumber )
{
_kinect = KinectOpenNI2::NEW(deviceNumber);
_skeleton = _kinect->createPlayerSkeleton();
_kinect->setMirror(false);
_kinect->setDebug(false);
_kinect->update();
/*
_kinect->addNewUserCB(thisRef(),&UDPKinectSkeleton::_newUserCB);
_kinect->addLostUserCB(thisRef(),&UDPKinectSkeleton::_lostUserCB);
_kinect->addCalibrationStartedCB(thisRef(),&UDPKinectSkeleton::_calibrationStartedCB);
_kinect->addCalibrationEndedCB(thisRef(),&UDPKinectSkeleton::_calibrationEndedCB);
*/
ArRef<Activity> act = Activity::NEW(1.0/30.0); //30Hz, Kinect
act->setBehavior(thisRef(), &UDPKinectSkeleton::_action);
_udp = UDPTransmitter::NEW(port);
if (_udp->fail())
{
const StlString message = _udp->getErrorMessage();
cerr<<"Error on upd transmitter creation :"<<message<<endl;
_udp = UDPTransmitter::nullRef();
setErrorMessage(message);
}
}
// Save/Load to XML
void
ArTrackOrientation::_writeXML(ArRef<XmlNode> node) const
{
node->setName("TrackOrientation");
node->setPropertyReal("duration",_track->getDuration());
node->setPropertyInteger("degree",_track->getDegree());
node->setPropertyInteger("dimension",4);
ArTrackOrientationInterpolator *track=(ArTrackOrientationInterpolator *)_track;
StlVector<unsigned> keysPositions;
track->getKeysPositions(keysPositions);
VectorN<double,4> key;
for (unsigned i=0;i<keysPositions.size();i++)
{
track->getKeyFrame(keysPositions[i],key );
ArRef<XmlNode> keyFrame=node->addChild("KeyFrameOrientation");
keyFrame->setPropertyInteger("frame",keysPositions[i]);
Quaterniond q(key[0],key[1],key[2],key[3]);
Vector3d axis;
double angle;
q.getAxisAngle(axis,angle);
keyFrame->setPropertyReal("vx",axis.x());
keyFrame->setPropertyReal("vy",axis.y());
keyFrame->setPropertyReal("vz",axis.z());
keyFrame->setPropertyReal("angle",angle);
}
}
ArRef<Transform3D> calculateTransformation(double p, double r, double y){
ArRef<Transform3D> tr = Transform3D::NEW();
tr->prePitch(p);
tr->preRoll(r);
tr->preYaw(y);
return tr;
}
void
UDPKinectSkeleton::_transmitCurrentPoseOSC()
{
if (_udp.valid() && _skeleton.valid())
{
ArConstRef<Joint> torso = _skeleton->findJoint("torso");
ArRef<MemoryBlock> memory = MemoryBlock::NEW();
ArRef<MemoryOStream> stream = MemoryOStream::NEW(memory,0);
_writeStringOSC("/skeleton",stream);
ArRef<MemoryBlock> memory2 = MemoryBlock::NEW();
ArRef<MemoryOStream> stream2 = MemoryOStream::NEW(memory2,0);
_writeStringOSC("/skeleton_local",stream2);
unsigned int nb = _skeleton->getNbJoints();
StlString typeString = ",";
for (size_t i(0);i<nb;++i)
{ typeString+="sfff"; }
_writeStringOSC(typeString,stream);
_writeStringOSC(typeString,stream2);
for (unsigned int i(0);i<nb;++i)
{
ArConstRef<Joint> joint = _skeleton->getJoint(i);
const StlString jointName = joint->getName();
_writeStringOSC(jointName,stream);
_writeStringOSC(jointName,stream2);
double x,y,z;
joint->getPosition(x,y,z);
stream->writeFloat(x);
stream->writeFloat(y);
stream->writeFloat(z);
if ( (torso.valid()) && (joint != torso) )
{ torso->globalToLocalPosition(x,y,z); }
stream2->writeFloat(x);
stream2->writeFloat(y);
stream2->writeFloat(z);
}
for (unsigned int i(0);i<_addresses.size();++i)
{
if (_addresses[i].OSC)
{
_udp->sendBytes(memory,0,memory->getSize(),
_addresses[i].ip,_addresses[i].port);
if (_addresses[i].port2 != 0)
{
_udp->sendBytes(memory2,0,memory2->getSize(),
_addresses[i].ip,_addresses[i].port2);
}
}
}
}
}
void
Axis::removeRenderer(ArRef<Renderer3D> renderer) {
for(size_t i = _renderers.size(); i--;) {
if(renderer == _renderers[i]) {
renderer->addOSD(_axis);
renderer->addOSD(_inOsd);
renderer->addOSD(_outOsd);
StlVectorFastErase(_renderers, i);
return;
}
}
}
// Save/Load to XML
void
ArTrackSpiral::_writeXML(ArRef<XmlNode> node) const
{
ArKeyFrameTrack::_writeXML(node);
node->setName("TrackSpiral");
node->setPropertyReal("vx",_axis.x());
node->setPropertyReal("vy",_axis.y());
node->setPropertyReal("vz",_axis.z());
node->setPropertyReal("ox",_offset.x());
node->setPropertyReal("oy",_offset.y());
node->setPropertyReal("oz",_offset.z());
}
void
Axis::addRenderer(ArRef<Renderer3D> renderer) {
for(size_t i = _renderers.size(); i--;) {
if(renderer == _renderers[i]) {
return;
}
}
_renderers.push_back(renderer);
renderer->addOSD(_axis);
renderer->addOSD(_inOsd);
renderer->addOSD(_outOsd);
}
/*
*interaction sur mouvement de souris -> bouge la KO
*/
void
KeyOrientation::onMotionInteraction(ArRef<AbstractInteractor> source, ArRef<Base3D> newLocation, bool begin, bool end) {
_c3dof->globalToLocalLocation(newLocation);
double x, y, z;
newLocation->getPosition(x, y, z);
Vector3d v(x, y, z);
v.normalize();
v *= _c3dof->getRadius();
newLocation->setPosition(v.x(),v.y(), v.z());
_c3dof->localToGlobalLocation(newLocation);
Object3D::onMotionInteraction(source, ShapePart3D::nullRef(), 0, newLocation, begin, end);
}
void
Skin0::setVisible( ArRef<Scene3D> scene, bool visible)
{
if (_visible && !visible)
{
for (unsigned int i(0);i<_objects.size();++i)
{ scene->removeObject(_objects[i]); }
_visible = false;
}
else if (!_visible && visible)
{
for (unsigned int i(0);i<_objects.size();++i)
{ scene->addObject(_objects[i]); }
_visible = true;
}
}
void
EditorIkSolver::_checkHingeZ(ArRef<Joint> joint, Vector3d /* requestedTranslation */, Quaterniond requestedRotation) {
double prx, pry, prz;
joint->getDeltaRotation().getEulerAngles(prx, pry, prz);
requestedRotation = joint->getDeltaRotation() * requestedRotation;
double rx, ry, rz;
requestedRotation.getEulerAngles(rx, ry, rz);
double min, max;
ar_down_cast<JointConstraint1DOF>(joint->getConstraint())->getLimitValues(min, max);
rz = _clampWithPreviousValue(min, max, prz, rz);
joint->setDeltaRotation(Quaterniond(Vector3d(0.0, 0.0, 1.0), rz));
}
void
UDPKinectSkeleton::_transmitCurrentPose()
{
if (_udp.valid() && _skeleton.valid())
{
ArRef<MemoryBlock> memory = MemoryBlock::NEW();
ArRef<MemoryOStream> stream = MemoryOStream::NEW(memory,0);
unsigned int nb = _skeleton->getNbJoints();
stream->writeUInt(nb);
SerializationDependencies dependencies;
for (unsigned int i(0);i<nb;++i)
{
ArConstRef<Joint> joint = _skeleton->getJoint(i);
joint->serialize(dependencies,stream);
}
stream->writeInt(_confidences.size());
StlMap<StlString,double>::iterator it(_confidences.begin());
while (it != _confidences.end())
{
stream->writeString(it->first);
stream->writeDouble(it->second);
++it;
}
for (unsigned int i(0);i<_addresses.size();++i)
{
if (!_addresses[i].OSC)
{
_udp->sendBytes(memory,0,memory->getSize(),
_addresses[i].ip,_addresses[i].port);
}
}
}
}
void
OSDSelector::addItem(ArRef<OSDSelectorItem> item) {
for(size_t i = _items.size(); i--;) {
if(_items[i] == item) {
return;
}
}
item->resizeWithRenderer(false);
item->setLocation(OSD::LOC_FREE);
_items.push_back(item);
if(_items.size() == 1) {
selectItem(item);
}
_updateItemsSize();
}
KeyOrientation::KeyOrientation(ArCW& arCW, ArRef<C3DOF> c3dof) : Object3D(arCW), _c3dof(c3dof) {
attachTo(_c3dof);
// ArRef<Material3D> mat = new_Material3D();
ArRef<Material3D> mat = Material3D::NEW();
mat->setDiffuseColor(0.0, 0.2, 0.8);
// _sphere = new_Sphere3D();
_sphere = Sphere3D::NEW();
_sphere->setRadius(0.2);
_sphere->writeMaterial(mat);
// ArRef<Shape3D> sh = new_Shape3D();
ArRef<Shape3D> sh = Shape3D::NEW();
sh->addRootPart(_sphere);
setShape(sh);
}
void
UDPKinectSkeleton::_writeStringOSC(const StlString & value,
ArRef<AbstractOStream> stream)
{
unsigned int modulo = 4+4*(value.size()/4)-value.size();
//cout<<"size "<<value.size()<<" Modulo "<<modulo<<endl;
//cout<<"Write string OSC [";
for (unsigned int i(0);i<value.size();++i)
{
stream->writeChar(value[i]);
//cout<<value[i];
}
for (unsigned int i(0);i<modulo;++i)
{
//cout<<"0";
stream->writeChar(0);
}
//cout<<"]"<<endl;
}
AReViVocalPlayerWidget::AReViVocalPlayerWidget(ArCW& arCW, AReViWindow3D* window) :
ArObject(arCW), _viewer(window->getAReViViewer()), _window3D(window)
{
_widgetInteractor = WidgetInteractor::NEW();
_parser = XmlParser::NEW();
_parser->parseFile("vocalPlayerWidget.xml");
/** parse & create widgets */
if(!ArWidgetUtils::readWidgets(_parser->getRoot(),_widgets,_viewer))
{
cerr << "VocalPlayerWidget -- Error reading widgets description" << endl;
exit(1);
}
/** execute */
if (ArWidgetUtils::findWidget("executeButton2",AwWidget::nullRef(),_executeButton))
_executeButton->addClickCB(thisRef(),&AReViVocalPlayerWidget::_onExecuteButtonClick);
ArRef<AwWidget> widgets = _widgets["executeButton2"];
widgets->setPosition(200,960); //crade, recup la taille de la window
initializeMap();
}
bool
ArTrackSpiral::_readXML(ArRef<XmlNode> node)
{
if(!ArKeyFrameTrack::_readXML(node))
return(false);
if (node->getName()=="TrackSpiral")
{
node->getPropertyReal("vx",_axis.accessVector()[0]);
node->getPropertyReal("vy",_axis.accessVector()[1]);
node->getPropertyReal("vz",_axis.accessVector()[2]);
node->getPropertyReal("ox",_offset.accessVector()[0]);
node->getPropertyReal("oy",_offset.accessVector()[1]);
node->getPropertyReal("oz",_offset.accessVector()[2]);
}
else
{
_offset=Vector3d(0,0,0);
_axis=Vector3d(1,0,0);
}
return(true);
}
void
UDPKinectSkeleton::_onPollingUDP(const Scheduler::PollingEvent & event)
{
StlString str;
unsigned int ipAddr;
int port;
ArRef<MemoryBlock> memory = MemoryBlock::NEW();
while(_udp->receiveBytes(memory,ipAddr,port))
{
if (_skeleton.valid())
{
ArRef<MemoryIStream> stream = MemoryIStream::NEW(memory,0);
unsigned int nbJoints;
stream->readUInt(nbJoints);
if (nbJoints != _skeleton->getNbJoints())
{
cerr<<"Reads "<<nbJoints<<" joints but skeleton has "
<<_skeleton->getNbJoints()<<"joints !!! using the min"<<endl; }
SerializationDependencies dependencies;
for (unsigned int i(0); i<std::min(nbJoints,_skeleton->getNbJoints()) ;++i)
{
ArRef<Joint> joint = _skeleton->accessJoint(i);
joint->unserialize(dependencies,stream);
}
int confidencesSize;
stream->readInt(confidencesSize);
for (unsigned int i(0); i<confidencesSize; ++i)
{
StlString name;
stream->readString(name);
double value;
stream->readDouble(value);
_confidences[name] = value;
}
}
}
}
bool
ArTrackOrientation::_readXML(ArRef<XmlNode> node)
{
if (node->getName()!="TrackOrientation")
return(ArKeyFrameTrack::_readXML(node));
double duration;
int degree;
node->getPropertyReal("duration",duration);
node->getPropertyInteger("degree",degree);
_track->setDuration(duration);
_track->setDegree(degree);
int dim;
if (!node->getPropertyInteger("dimension",dim))
{
cerr << "Missing dimensions specification" << endl;
return(false);
}
if (dim!=4)
{
cerr << "Bad track dimension " << dim << "!=4" << endl;
return(false);
}
_track->clearKeyFrames();
ArRef<XmlNode> keyFrame=node->getFirstChild();
while(keyFrame)
{
if (keyFrame->getName()=="KeyFrameOrientation")
{
int frame;
if (!keyFrame->getPropertyInteger("frame",frame))
{
cerr << "Invalid keyFrame misssing frame info"<< endl;
return(false);
}
double angle;
double xx,yy,zz;
bool ok=true;
if(!keyFrame->getPropertyReal("vx",xx))
ok = false;
if(!keyFrame->getPropertyReal("vy",yy))
ok = false;
if(!keyFrame->getPropertyReal("vz",zz))
ok = false;
if(!keyFrame->getPropertyReal("angle",angle))
ok = false;
if(!ok)
{
cerr << "Error reading orientation infos (vx,vy,vz,angle)" << endl;
return(false);
}
Vector3d axis(xx,yy,zz);
/* if (!keyFrame->getPropertyReal("vx",axis.accessVector()[0]) ||
!keyFrame->getPropertyReal("vy",axis.accessVector()[1]) ||
!keyFrame->getPropertyReal("vz",axis.accessVector()[2]) ||
!keyFrame->getPropertyReal("angle",angle))
{
cerr << "Error reading orientation infos (vx,vy,vz,angle)" << endl;
return(false);
}*/
setKeyFrame(frame,axis,angle);
//cerr << "kf=" << frame << " axis=" << axis << " angme=" << angle << endl;
}
keyFrame=keyFrame->getNext();
}
return(true);
}
void
Skin0::createGeometries(ArRef<Skeleton> skeleton)
{
cout<<"Nb joints "<<skeleton->getNbJoints()<<endl;
for (unsigned int i(0);i<skeleton->getNbJoints();++i)
{
ArRef<Joint> joint = skeleton->accessJoint(i);
cout<<"joint "<<joint->getName()<<endl;
ArConstRef<Joint> parent = joint->getParent();
if (parent.valid())
{ cout<<" -> parent is "<<parent->getName()<<endl; }
else
{ cout<<" -> no parent"<<endl; }
ArRef<Object3D> object = Object3D::NEW();
object->setLocation(joint);
object->attachTo(joint);
ArRef<Sphere3D> sphere = Sphere3D::NEW();
sphere->setRadius(0.1);
ArRef<Shape3D> shape = Shape3D::NEW();
shape->addRootPart(sphere);
object->setShape(shape);
_objects.push_back(object);
cout<<"skin New object"<<endl;
}
}
