void ManualAlignment::setViewingDirections(const Base::Vector3d& view1, const Base::Vector3d& up1,
const Base::Vector3d& view2, const Base::Vector3d& up2)
{
if (myViewer.isNull())
return;
{
SbRotation rot;
rot.setValue(SbVec3f(0.0f, 0.0f, 1.0f), SbVec3f(-view1.x,-view1.y,-view1.z));
SbRotation rot2;
SbVec3f up(0.0f, 1.0f, 0.0f);
rot.multVec(up, up);
rot2.setValue(up, SbVec3f(up1.x, up1.y, up1.z));
myViewer->getViewer(0)->getCamera()->orientation.setValue(rot * rot2);
myViewer->getViewer(0)->viewAll();
}
{
SbRotation rot;
rot.setValue(SbVec3f(0.0f, 0.0f, 1.0f), SbVec3f(-view2.x,-view2.y,-view2.z));
SbRotation rot2;
SbVec3f up(0.0f, 1.0f, 0.0f);
rot.multVec(up, up);
rot2.setValue(up, SbVec3f(up2.x, up2.y, up2.z));
myViewer->getViewer(1)->getCamera()->orientation.setValue(rot * rot2);
myViewer->getViewer(1)->viewAll();
}
}
void
vpSimulator::moveInternalCamera(vpHomogeneousMatrix &cMf)
{
SbMatrix matrix;
SbRotation rotCam;
SbMatrix rotX;
rotX.setRotate (SbRotation (SbVec3f(1.0f, 0.0f, 0.0f), (float)M_PI));
for(unsigned int i=0;i<4;i++)
for(unsigned int j=0;j<4;j++)
matrix[(int)j][(int)i]=(float)cMf[i][j];
matrix= matrix.inverse();
matrix.multLeft (rotX);
rotCam.setValue(matrix);
internalCamera->ref() ;
internalCamera->orientation.setValue(rotCam);
internalCamera->position.setValue(matrix[3][0],matrix[3][1],matrix[3][2]);
internalCamera->unref() ;
rotX.setRotate (SbRotation (SbVec3f(-1.0f, 0.0f, 0.0f), (float)M_PI));
matrix.multLeft (rotX);
rotCam.setValue(matrix);
internalCameraPosition->ref() ;
internalCameraPosition->rotation.setValue(rotCam);
internalCameraPosition->translation.setValue(matrix[3][0],matrix[3][1],matrix[3][2]);
internalCameraPosition->unref() ;
}
void
SoXipOverlayTransformBoxManip::rotate( SoHandleEventAction* action )
{
SbVec3f projPt;
getPoint( action, projPt );
const SbVec3f* point = mControlPointsCoords->point.getValues(0);
SbVec3f center = (point[0] + point[4]) / 2.;
SbVec3f rotateFrom = point[mControlPointId] - center;
SbVec3f rotateTo = projPt - center;
SbVec3f normal = mViewVolume.getPlane(0).getNormal();
SbRotation rotation;
rotation.setValue( normal, angleBetweenVectors( rotateFrom, rotateTo, normal ) );
SbMatrix centerMatrix;
centerMatrix.setTranslate( center );
SbMatrix rotationMatrix;
rotationMatrix.setRotate( rotation );
mTransformationMatrix = centerMatrix.inverse() * rotationMatrix * centerMatrix;
transform( mActionNode );
}
/*! \param rotAxis
* \param rotAngle
*/
void kCamera::rotatePosition(SbVec3f rotAxis, double rotAngle, SbVec3f axisPoint)
{
//Error20051017: Er rotierte immer nur um eine Achse, ohne diese zu verschieben (in den LookAt-Punkt).
//Daher zunächst eine Translation der aktuellen Position um den Rotationspunkt und anschließend wieder zurück
SbVec3f tempPos = currentPosition - axisPoint; //Error20051017
// Position rotieren
SbRotation pointRotation;
pointRotation.setValue(rotAxis,rotAngle);
//pointRotation.multVec(currentPosition, currentPosition);
pointRotation.multVec(tempPos, tempPos); //Error20051017
currentPosition = tempPos + axisPoint; //Error20051017
currentLookDir = currentLookAt-currentPosition;
currentLookDir.normalize();
currentUpVec = calcUpVector(currentLookDir,NormPlump); //! Neuen UpVec ausrechnen - Rotation wird schon in calcUpVector vollzogen
currentUpVec.normalize();
currentOrientation = calcOrientation(currentUpVec,currentLookDir); //! Berechnet neue orientation
// writeOrientation(currentOrientation); //! Schreibt orientation in ObjMgr
// writePosition(currentPosition); //! Schreibt position in ObjMgr
}
/*! \param[in,out] vect vector to rotate
* \param axis
* \param angle
*/
void kCamera::rotateVector(SbVec3f& vect, const SbVec3f axis, const double angle)
{
SbRotation vecRotation;
vecRotation.setValue(axis,angle);
vecRotation.multVec(vect,vect);
vect.normalize();
}
SbRotation
SoBillboard::calculateRotation(SoState *state)
{
SbRotation rot;
#ifdef INVENTORRENDERER
const SbViewVolume &viewVolume = SoViewVolumeElement::get(state);
if (SbVec3f(0.0f, 0.0f, 0.0f) == axis.getValue())
{
rot = viewVolume.getAlignRotation();
}
#else
const SbMatrix &mm = SoModelMatrixElement::get(state);
SbMatrix imm = mm.inverse();
SbVec3f toviewer;
SbVec3f cameray(0.0f, 1.0f, 0.0f);
const SbViewVolume &vv = SoViewVolumeElement::get(state);
toviewer = -vv.getProjectionDirection();
imm.multDirMatrix(toviewer, toviewer);
(void)toviewer.normalize();
SbVec3f rotaxis = this->axis.getValue();
if (rotaxis == SbVec3f(0.0f, 0.0f, 0.0f))
{
// 1. Compute the billboard-to-viewer vector.
// 2. Rotate the Z-axis of the billboard to be collinear with the
// billboard-to-viewer vector and pointing towards the viewer's position.
// 3. Rotate the Y-axis of the billboard to be parallel and oriented in the
// same direction as the Y-axis of the viewer.
rot.setValue(SbVec3f(0.f, 0.0f, 1.0f), toviewer);
SbVec3f viewup = vv.getViewUp();
imm.multDirMatrix(viewup, viewup);
SbVec3f yaxis(0.0f, 1.0f, 0.0f);
rot.multVec(yaxis, yaxis);
SbRotation rot2(yaxis, viewup);
SbVec3f axis;
float angle;
rot.getValue(axis, angle);
rot2.getValue(axis, angle);
rot = rot * rot2;
//SoModelMatrixElement::rotateBy(state, (SoNode*) this, rot);
}
#endif
else
{
fprintf(stderr, "SoBillboard: axis != (0.0, 0.0, 0.0) not implemented\n");
}
return rot;
}
void
vpSimulator::addObject(SoSeparator * object,
const vpHomogeneousMatrix &fMo,
SoSeparator * root)
{
bool identity = true ;
for (unsigned int i=0 ; i <4 ;i++){
for (unsigned int j=0 ; j < 4 ; j++){
if (i==j){
if (fabs(fMo[i][j] -1) > 1e-6) identity=false ;
}
else{
if (fabs(fMo[i][j]) > 1e-6) identity=false ;
}
}
}
if (identity==true)
{
root->addChild (object);
}
else
{
SbMatrix matrix;
SbRotation rotation;
for(unsigned int i=0;i<4;i++)
for(unsigned int j=0;j<4;j++)
matrix[(int)j][(int)i]=(float)fMo[i][j];
// matrix= matrix.inverse();
rotation.setValue(matrix);
SoTransform *displacement = new SoTransform;
SoSeparator *newNode = new SoSeparator;
displacement->rotation.setValue(rotation);
displacement->translation.setValue(matrix[3][0],
matrix[3][1],
matrix[3][2]);
root->addChild (newNode);
newNode->addChild (displacement);
newNode->addChild (object);
}
}
// Read rotation value from input stream, return TRUE if
// successful. Used from SoSFRotation and SoMFRotation.
SbBool
sosfrotation_read_value(SoInput * in, SbRotation & r)
{
float f[4];
for (int i = 0; i < 4; i++) {
if (!in->read(f[i])) return FALSE;
}
SbVec3f axis(f[0], f[1], f[2]);
const float angle = f[3];
// vrml97 identity rotations are often specified with a null vector.
// test for this and just set to z-axis.
if (axis == SbVec3f(0.0f, 0.0f, 0.0f) && angle == 0.0f) {
axis = SbVec3f(0.0f, 0.0f, 1.0f);
}
r.setValue(axis, angle);
return TRUE;
}
// internal callback
void InvPlaneMover::dragFinishCB(void *me, SoDragger *drag)
{
InvPlaneMover *mee = static_cast<InvPlaneMover *>(me);
if (mee->show_)
{
SbVec3f t = ((SoJackDragger *)drag)->translation.getValue();
int i;
for (i = 0; i < 3; ++i)
t[i] *= mee->scale_->scaleFactor.getValue()[i];
SbRotation r = ((SoJackDragger *)drag)->rotation.getValue();
SbVec3f n;
SbVec3f ax;
float angle;
r.getValue(ax, angle);
SbVec3f axN;
mee->fullRot_->rotation.getValue().multVec(ax, axN);
r.setValue(axN, angle);
r.multVec(mee->nnn_, n);
// we have to rotate the translation around the x-axis
// (because we have a y-axis dragger)
SbVec3f tt;
n.normalize();
// snap normal to the closest coordinate axis
// here done by snaping it to the axis with the biggest projection onto it.
if (mee->motionMode_ == InvPlaneMover::SNAP)
{
int axis;
float mmax;
int dir = 1;
SbVec3f nn;
if (n[0] * n[0] < n[1] * n[1])
{
axis = 1;
mmax = n[1];
if (n[1] < 0)
dir = -1;
else
dir = +1;
//dir = (int) copysign(1,n[1]);
}
else
{
axis = 0;
mmax = n[0];
if (n[0] < 0)
dir = -1;
else
dir = +1;
//dir = (int) copysign(1,n[0]);
}
if (mmax * mmax < n[2] * n[2])
{
axis = 2;
if (n[2] < 0)
dir = -1;
else
dir = +1;
//dir = (int) copysign(1,n[2]);
}
switch (axis)
{
case 0:
nn.setValue(1, 0, 0);
break;
case 1:
nn.setValue(0, 1, 0);
break;
case 2:
nn.setValue(0, 0, 1);
break;
}
n = dir * nn;
}
tt = t[1] * n;
float d;
d = n.dot(tt + mee->distOffset_);
float data[4];
data[0] = n[0];
data[1] = n[1];
data[2] = n[2];
data[3] = d;
// send feedback message to contoller
((InvPlaneMover *)me)->sendFeedback(data);
}
}
void
SoXipNeheStarGenerator::GLRender(SoGLRenderAction *action)
{
float yawAngle = 0;
static float spinAngle = 0;
float distance = 0;
float pitchAngle = M_PI /2; // tilt the view
SbRotation pitch(SbVec3f(1, 0, 0), pitchAngle); // rotation around X
SbMatrix pitchM;
pitch.getValue(pitchM);
SbRotation yaw = SbRotation::identity();
SbMatrix yawM = SbMatrix::identity();
SbRotation spin = SbRotation::identity();
SbMatrix spinM = SbMatrix::identity();
for (int i = 0; i < MAX_STARS; i++)
{
SoXipNeheStar* star = static_cast<SoXipNeheStar*>(this->getChild(i));
// spin angle for this star
spin.setValue(SbVec3f(0,0,1), spinAngle); // rotation around Z
spin.getValue(spinM);
// yaw angle for this star
//_starInfos[i].angle += ((float(i)/MAX_STARS) * (180 / M_PI));
yawAngle = _starInfos[i].angle;
yaw.setValue(SbVec3f(0,1,0), yawAngle); // rotation around Y
yaw.getValue(yawM);
// let's compose all matrices once to position each star
SbMatrix transM = SbMatrix::identity();
transM.setTranslate(SbVec3f(_starInfos[i].distance,0,0));
SbMatrix transform = spinM * pitchM.inverse() * yawM.inverse() * transM * yawM * pitchM ;
// position the star
star->trans.setValue(transform);
unsigned int color = convertRGBtoHex(_starInfos[i].r, _starInfos[i].g, _starInfos[i].b);
star->color.set1Value(0, color);
star->color.set1Value(1, color);
star->color.set1Value(2, color);
star->color.set1Value(3, color);
spinAngle += ( 0.01f * (M_PI / 180));
// change setting of all stars except the very first one (index 0)
if (i)
{
_starInfos[i].angle += ((float(i)/MAX_STARS) * ( M_PI / 180));
_starInfos[i].distance -= 0.01f;
if (_starInfos[i].distance < 0.0f)
{
_starInfos[i].distance += 5.0f;
_starInfos[i].r= rand() % 255 + 1 ;
_starInfos[i].g= rand() % 255 + 1;
_starInfos[i].b= rand() % 255 + 1;
}
}
}
SoXipKit::GLRender(action);
}
void METKAutoFading::calcNewPosition()
{
SbVec3f tempPos;
SbVec4f tempOrientVec4;
bool result = false;
if (_UseMETKValues->getBoolValue())
{
result = myObjMgr->getObjAttributeVec3f(_ViewerName->getStringValue(), LAY_VIEWER_CAMERA, INF_VIEWER_CAMERA_POSITION, tempPos);
result = result && myObjMgr->getObjAttributeVec4f(_ViewerName->getStringValue(), LAY_VIEWER_CAMERA, INF_VIEWER_CAMERA_ORIENTATION, tempOrientVec4);
}
else
{
result = true;
tempPos[0] = _camPosition->getVec3fValue()[0]; tempPos[1] = _camPosition->getVec3fValue()[1]; tempPos[2] = _camPosition->getVec3fValue()[2];
tempOrientVec4[0] = _camOrientation->getVec4fValue()[0]; tempOrientVec4[1] = _camOrientation->getVec4fValue()[1]; tempOrientVec4[2] = _camOrientation->getVec4fValue()[2]; tempOrientVec4[3] = _camOrientation->getVec4fValue()[3];
}
if (result)
{
myCamera->setPosition(tempPos);
SbRotation tempOrient;
tempOrient.setValue(SbVec3f(tempOrientVec4[0],tempOrientVec4[1],tempOrientVec4[2]),tempOrientVec4[3]);
myCamera->setOrientation(tempOrient);
SbVec3f lookDir = myCamera->getLookDir();
SbVec3f inverseLookDir = -1.0 * lookDir;
inverseLookDir.normalize();
//SphereCenter
float sphere_x, sphere_y, sphere_z, sphere_radius; int sphere_div;
m_calcVis.getSphereValues(sphere_x, sphere_y, sphere_z, sphere_radius, sphere_div);
SbVec3f spherePoint;
spherePoint[0] = sphere_x + inverseLookDir[0] * sphere_radius;
spherePoint[1] = sphere_y + inverseLookDir[1] * sphere_radius;
spherePoint[2] = sphere_z + inverseLookDir[2] * sphere_radius;
m_calcVis.clearStack(1);
m_calcVis.addPointRegionToStackField(1, spherePoint[0], spherePoint[1], spherePoint[2], 0.1);
SbVec3f similarPosition;
int posID = m_calcVis.getStackMaxPos(1, similarPosition[0], similarPosition[1], similarPosition[2]);
_similarPosition->setVec3fValue(vec3(similarPosition[0],similarPosition[1],similarPosition[2]));
//Alle Occluder an dieser Position für ObOfIn
std::vector<float> visValues;
m_calcVis.getMatrixValues(posID, _CurrentObject->getStringValue(), &visValues);
int objID = m_calcVis.findObjectId(_CurrentObject->getStringValue());
string occluName;
set<string> newFading;
for (int i=0; i<visValues.size()-3; i++)
{
if (visValues[i]!=0 && i!=objID)
{
occluName = m_calcVis.getObjectName(i);
newFading.insert(occluName);
//htNewFading.insert(occluName, occluName);
}
}
//std::cout << "newFading size = " << newFading.size() << std::endl;
//std::cout << "currentFading size = " << currentFading.size() << std::endl;
//Strukturen die neu hinzukommen finden
string objName = "";
Appearance oldValues;
set<string>::iterator iter = newFading.begin();
for (iter=newFading.begin(); iter!=newFading.end(); iter++)
{
objName = *iter;
//if (!htOldValues.find(objName))
if (!findInSet(currentFading, objName) && objName!="")
{
std::cout << "new:" << objName << std::endl;
//Get Old Values
myObjMgr->getObjAttributeFloat(objName,LAY_APPEARANCE, INF_TRANSPARENCY, oldValues.Transparency);
myObjMgr->getObjAttributeVec3f(objName,LAY_APPEARANCE, INF_COLOR, oldValues.Color);
myObjMgr->getObjAttributeVec3f(objName,LAY_APPEARANCE, INF_SILHOUETTECOLOR, oldValues.SilhouetteColor);
myObjMgr->getObjAttributeBool(objName,LAY_APPEARANCE, INF_SILHOUETTE, oldValues.SilhouetteVisible);
myObjMgr->getObjAttributeFloat(objName,LAY_APPEARANCE, INF_SILHOUETTEWIDTH, oldValues.SilhouetteWidth);
htOldValues.insert(objName, oldValues);
currentFading.insert(objName);
//Ausblenden
myObjMgr->setObjAttribute(objName,LAY_APPEARANCE, INF_TRANSPARENCY, new double(0.9), omINFOTYPE_DOUBLE, true, false);
myObjMgr->setObjAttribute(objName,LAY_APPEARANCE, INF_SILHOUETTEWIDTH, new double(2), omINFOTYPE_DOUBLE, true, false);
myObjMgr->setObjAttribute(objName,LAY_APPEARANCE, INF_SILHOUETTECOLOR, new vec3(0,0,0), omINFOTYPE_VEC3, true, false);
myObjMgr->setObjAttribute(objName,LAY_APPEARANCE, INF_SILHOUETTE, new bool(true), omINFOTYPE_BOOL, true, false);
}
}
//Alte Element aus currentFading wieder einblenden mit oldValues, die nicht in newFading drin sind
for (iter=currentFading.begin(); iter!=currentFading.end(); iter++)
{
objName = *iter;
if (!findInSet(newFading,objName) && objName!="")
{
std::cout << "Wiedereinblenden: " << objName << std::endl;
if (htOldValues.find(objName))
{
oldValues = *(htOldValues.find(objName));
myObjMgr->setObjAttribute(objName,LAY_APPEARANCE, INF_TRANSPARENCY, new double(oldValues.Transparency), omINFOTYPE_DOUBLE, true, false);
myObjMgr->setObjAttribute(objName,LAY_APPEARANCE, INF_SILHOUETTEWIDTH, new double(oldValues.SilhouetteWidth), omINFOTYPE_DOUBLE, true, false);
vec3* tempVec3 = new vec3(oldValues.SilhouetteColor[0],oldValues.SilhouetteColor[1],oldValues.SilhouetteColor[2]);
myObjMgr->setObjAttribute(objName,LAY_APPEARANCE, INF_SILHOUETTECOLOR, tempVec3, omINFOTYPE_DOUBLE, true, false);
delete tempVec3;
myObjMgr->setObjAttribute(objName,LAY_APPEARANCE, INF_SILHOUETTE, new bool(oldValues.SilhouetteVisible), omINFOTYPE_BOOL, true, false);
}
else
std::cout << "No oldValues found in Hashtable for " << objName << std::endl;
htOldValues.remove(objName);
}
}
currentFading.clear();
//Umkopieren von newFading in currentFading
for (iter=newFading.begin(); iter!=newFading.end(); iter++)
{
currentFading.insert(*iter);
}
//std::cout << "ende currentFading size = " << currentFading.size() << std::endl;
sendNotification();
}
else
{
std::cout << "Cam Position or Orientation in METK not available" << std::endl;
}
}
