/***************************************************************
* Function: applyEditorInfo()
***************************************************************/
void CAVEGroupEditGeodeWireframe::applyEditorInfo(CAVEGeodeShape::EditorInfo **infoPtr)
{
/* reset root offset only when the shape is moved */
if ((*infoPtr)->getTypeMasking() == CAVEGeodeShape::EditorInfo::MOVE)
{
/* apply translations on 'mAccRootMat' */
const Vec3 offset = (*infoPtr)->getMoveOffset();
Matrixd transMat;
transMat.makeTranslate(offset);
mAccRootMat = mAccRootMat * transMat;
}
else if ((*infoPtr)->getTypeMasking() == CAVEGeodeShape::EditorInfo::ROTATE)
{
/* apply rotations on 'mAccRootMat' */
const float angle = (*infoPtr)->getRotateAngle();
const Vec3 axis = (*infoPtr)->getRotateAxis();
Matrixf rotateMat;
rotateMat.makeRotate(angle, axis);
mAccRootMat = mAccRootMat * rotateMat;
}
else if ((*infoPtr)->getTypeMasking() == CAVEGeodeShape::EditorInfo::SCALE)
{
const Vec3f scaleVect = (*infoPtr)->getScaleVect();
const Vec3f scaleCenter = (*infoPtr)->getScaleCenter();
Matrixd scalingMat, transMat, revTransMat;
scalingMat.makeScale(scaleVect);
transMat.makeTranslate(scaleCenter);
revTransMat.makeTranslate(-scaleCenter);
mAccRootMat = mAccRootMat * scalingMat;
}
}
osg::Matrixd CameraController::calcMatrixBasedOnAxis( const Vec3d& origin, const Vec3d& axisY, const Vec3d& axisZ )
{
Matrixd matTrans;
matTrans.makeTranslate(origin);
Vec3d oldY = Vec3d(0, 1, 0);
Vec3d oldZ = Vec3d(0, 0, 1);
Vec3d newY = axisY;
Vec3d newZ = axisZ;
newY.normalize();
newZ.normalize();
Matrixd mat1;
mat1.makeRotate(oldZ, newZ);
oldY = oldY * mat1;
Matrixd mat2;
mat2.makeRotate(oldY, newY);
Matrixd matFinal = mat1 * mat2 * matTrans;
return matFinal;
}
void CameraController::testSetCameraAtMatrix(const Matrixd& atToWorldMatrix, double distFromEyeToAt,
Vec3d& resEye, Vec3d& resAt, Vec3d& resBase)
{
_testAtToWorldMatrix = atToWorldMatrix;
Vec3d v1 = Vec3d(0, 0, distFromEyeToAt);
Vec3d v2 = Vec3d(0, 0, 0);
v1 = v1 * atToWorldMatrix;
v2 = v2 * atToWorldMatrix;
Matrixd trans;
trans.makeTranslate(v1-v2);
_testEyeToWorldMatrix = _testAtToWorldMatrix * trans;
Matrixd upMatrix = _testEyeToWorldMatrix;
upMatrix.setTrans(Vec3d(0, 0, 0));
_testEye = v1;
_testAt = v2;
_testUp = _initUp * upMatrix;
_testBase = _currBase;
updateBaseToWorldMatrix();
}
void CAVEGeodeIconToolkitManipulate::setMatrixTrans(MatrixTransform *matTrans)
{
Matrixd offsetMat;
offsetMat.makeTranslate(Vec3(mScalingDir.x() * mBoundingVect.x(),
mScalingDir.y() * mBoundingVect.y(),
mScalingDir.z() * mBoundingVect.z()));
matTrans->setMatrix(offsetMat);
}
void CameraController::updateEyeAndAtToWorldMatrix()
{
_testEyeToWorldMatrix = calcMatrixBasedOnAxis(_testEye, _testUp, _testEye - _testAt);
Matrixd mat;
mat.makeTranslate(_testAt - _testEye);
_testAtToWorldMatrix = _testEyeToWorldMatrix * mat;
}
/***************************************************************
* Constructor: CalibrationController()
***************************************************************/
CalibrationController::CalibrationController(Group *rootGroup, const string &datadir): mCaliFlag(false), mPlaybackFlag(false),
mLeftRange(M_PI / 9), mRightRange(M_PI / 9), mUpwardRange(M_PI / 9), mDownwardRange(M_PI / 9),
mMinDepthRange(0.5), mMaxDepthRange(5), mHorFreq(1), mVerFreq(1), mDepFreq(1),
mFieldRight(Vec3(1, 0, 0)), mFieldFront(Vec3(0, 1, 0)), mFieldUp(Vec3(0, 0, 1)), mFieldPos(Vec3(0, 0, 0))
{
mTimer = 0.0;
mViewerAlignmentTrans = new MatrixTransform();
rootGroup->addChild(mViewerAlignmentTrans);
/* apply downwards offset towards nose's position */
mNoseOffsetTrans = new MatrixTransform();
mViewerAlignmentTrans->addChild(mNoseOffsetTrans);
Matrixd noseoffsetMat;
noseoffsetMat.makeTranslate(Vec3(0, 0, gNoseOffset));
mNoseOffsetTrans->setMatrix(noseoffsetMat);
BallHandler::setDataDir(datadir);
mCaliBallHandler = new CaliBallHandler(mNoseOffsetTrans);
mPlaybackBallHandler = new PlaybackBallHandler(mNoseOffsetTrans);
mCaliFieldHandler = new CaliFieldHandler(mNoseOffsetTrans);
mDataDir = datadir;
}
/***************************************************************
* Function: updateGridUnits()
***************************************************************/
void CAVEGroupEditGeodeWireframe::updateGridUnits(const float &gridUnitLegnth,
const float &gridUnitAngle, const float &gridUnitScale)
{
/* update 'Move' matrix transform wireframes */
unsigned int numMoveChildren = mMoveSwitch->getNumChildren();
if (numMoveChildren > 1)
{
Vec3 gridOffsetVect = Vec3(0, 0, 0);
if (mMoveSVect.x() > 0) gridOffsetVect = Vec3(gridUnitLegnth, 0, 0);
else if (mMoveSVect.x() < 0) gridOffsetVect = Vec3(-gridUnitLegnth, 0, 0);
else if (mMoveSVect.y() > 0) gridOffsetVect = Vec3(0, gridUnitLegnth, 0);
else if (mMoveSVect.y() < 0) gridOffsetVect = Vec3(0, -gridUnitLegnth, 0);
else if (mMoveSVect.z() > 0) gridOffsetVect = Vec3(0, 0, gridUnitLegnth);
else if (mMoveSVect.z() < 0) gridOffsetVect = Vec3(0, 0, -gridUnitLegnth);
for (int i = 0; i < numMoveChildren; i++)
{
Matrixd transMat;
transMat.makeTranslate(gridOffsetVect * i);
mMoveMatTransVector[i]->setMatrix(mBoundBoxScaleMat * mAccRootMat * transMat);
}
return;
}
/* update 'Rotate' matrix transform wireframes */
unsigned int numRotateChildren = mRotateSwitch->getNumChildren();
if (numRotateChildren > 1)
{
Vec3 gridRotationAxis = Vec3(0, 0, 1);
if (mRotateSVect.x() > 0) gridRotationAxis = Vec3(1, 0, 0);
else if (mRotateSVect.x() < 0) gridRotationAxis = Vec3(-1, 0, 0);
else if (mRotateSVect.y() > 0) gridRotationAxis = Vec3(0, 1, 0);
else if (mRotateSVect.y() < 0) gridRotationAxis = Vec3(0, -1, 0);
else if (mRotateSVect.z() > 0) gridRotationAxis = Vec3(0, 0, 1);
else if (mRotateSVect.z() < 0) gridRotationAxis = Vec3(0, 0, -1);
for (int i = 0; i < numRotateChildren; i++)
{
Matrixd rotMat;
rotMat.makeRotate(gridUnitAngle * i, gridRotationAxis);
mRotateMatTransVector[i]->setMatrix(mBoundSphereScaleMat * rotMat);
}
return;
}
/* update 'Scale' matrix transform wireframes */
unsigned int numScaleChildren = mManipulateSwitch->getNumChildren();
if (numScaleChildren > 1)
{
/* rewrite scaling vector */
mScaleUnitVect.x() = mScaleUnitVect.x() > 0 ? 1:0;
mScaleUnitVect.y() = mScaleUnitVect.y() > 0 ? 1:0;
mScaleUnitVect.z() = mScaleUnitVect.z() > 0 ? 1:0;
mScaleUnitVect *= gridUnitScale;
for (int i = 0; i < numScaleChildren; i++)
{
/* generate scaling vector with non-negative values */
Vec3 scaleVect = Vec3(1, 1, 1);
if (mScaleNumSegs > 0) scaleVect += mScaleUnitVect * i;
else scaleVect -= mScaleUnitVect * i;
scaleVect.x() = scaleVect.x() > 0 ? scaleVect.x() : 0;
scaleVect.y() = scaleVect.y() > 0 ? scaleVect.y() : 0;
scaleVect.z() = scaleVect.z() > 0 ? scaleVect.z() : 0;
Matrixd scaleMat;
scaleMat.makeScale(scaleVect);
mManipulateMatTransVector[i]->setMatrix(mBoundBoxScaleMat * mAccRootMat * scaleMat);
}
return;
}
}
/***************************************************************
* Function: applyTranslation()
*
* 'gridSVect': number of snapping segments along each direction
* 'gridUnitLegnth': actual length represented by each segment,
* only one component of 'gridSVect' is supposed to be non-zero
*
***************************************************************/
void CAVEGroupEditGeodeWireframe::applyTranslation(const osg::Vec3s &gridSVect, const float &gridUnitLegnth,
const string &gridUnitLegnthInfo)
{
mMoveSwitch->setAllChildrenOn();
/* move to other direction: clear all children of 'mMoveSwitch' except child[0], rebuild offset tree */
if ((mMoveSVect.x() * gridSVect.x() + mMoveSVect.y() * gridSVect.y() + mMoveSVect.z() * gridSVect.z()) <= 0)
{
unsigned int numChildren = mMoveSwitch->getNumChildren();
if (numChildren > 1)
{
mMoveSwitch->removeChildren(1, numChildren - 1);
MatrixTransVector::iterator itrMatTrans = mMoveMatTransVector.begin();
mMoveMatTransVector.erase(itrMatTrans + 1, itrMatTrans + numChildren);
}
mMoveSVect = Vec3s(0, 0, 0);
}
/* decide unit offset vector and start/end index of children under 'mMoveSwitch' */
Vec3 gridOffsetVect;
short idxStart = 0, idxEnd = 0;
if (gridSVect.x() != 0)
{
idxStart = mMoveSVect.x();
idxEnd = gridSVect.x();
if (gridSVect.x() > 0) gridOffsetVect = Vec3(gridUnitLegnth, 0, 0);
else gridOffsetVect = Vec3(-gridUnitLegnth, 0, 0);
}
else if (gridSVect.y() != 0)
{
idxStart = mMoveSVect.y();
idxEnd = gridSVect.y();
if (gridSVect.y() > 0) gridOffsetVect = Vec3(0, gridUnitLegnth, 0);
else gridOffsetVect = Vec3(0, -gridUnitLegnth, 0);
}
else if (gridSVect.z() != 0)
{
idxStart = mMoveSVect.z();
idxEnd = gridSVect.z();
if (gridSVect.z() > 0) gridOffsetVect = Vec3(0, 0, gridUnitLegnth);
else gridOffsetVect = Vec3(0, 0, -gridUnitLegnth);
}
idxStart = idxStart > 0 ? idxStart: -idxStart;
idxEnd = idxEnd > 0 ? idxEnd : -idxEnd;
/* update the first wireframe with global translation and rotation */
if (idxStart == 0) mMoveMatTransVector[0]->setMatrix(mBoundBoxScaleMat * mAccRootMat);
/* create or remove a sequence of extra children under 'mMoveSwitch' */
if (idxStart < idxEnd)
{
for (short i = idxStart + 1; i <= idxEnd; i++)
{
Matrixd transMat;
transMat.makeTranslate(gridOffsetVect * i);
MatrixTransform *moveTrans = new MatrixTransform;
CAVEGeodeEditWireframeMove *moveGeode = new CAVEGeodeEditWireframeMove;
mMoveSwitch->addChild(moveTrans);
mMoveMatTransVector.push_back(moveTrans);
moveTrans->addChild(moveGeode);
moveTrans->setMatrix(mBoundBoxScaleMat * mAccRootMat * transMat);
}
}
else if (idxStart > idxEnd)
{
mMoveSwitch->removeChildren(idxEnd + 1, idxStart - idxEnd);
MatrixTransVector::iterator itrMatTrans = mMoveMatTransVector.begin();
itrMatTrans += idxEnd + 1;
mMoveMatTransVector.erase(itrMatTrans, itrMatTrans + (idxStart - idxEnd));
}
mMoveSVect = gridSVect;
if (!mPrimaryFlag) return;
/* update info text if 'this' wireframe is primary */
mEditInfoTextSwitch->setAllChildrenOn();
char info[128];
sprintf(info, "Offset = %3.2f m\nSnapping = ", gridUnitLegnth * idxEnd);
mEditInfoText->setText(info + gridUnitLegnthInfo);
}
void CameraController::testTranslateCamera(const Vec3d& vec, CoordType coordType, PointType pointType,
Vec3d& resEye, Vec3d& resAt, Vec3d& resBase)
{
assert(_camera != NULL);
_testEye = _currEye;
_testAt = _currAt;
_testBase = _currBase;
_testUp = _currUp;
if (vec.length2() < 1e-10) { return; }
/* 把位移向量转换到世界坐标系下 */
Vec3d tmpVec;
switch (coordType)
{
case COORD_TYPE_WORLD:
tmpVec = vec;
break;
case COORD_TYPE_EYE:
tmpVec = switchCoordinateSystem_vector(vec, _eyeToWorldMatrix, WORLD_MATRIX);
break;
case COORD_TYPE_AT:
tmpVec = switchCoordinateSystem_vector(vec, _atToWorldMatrix, WORLD_MATRIX);
break;
case COORD_TYPE_BASE_EYE:
case COORD_TYPE_BASE_EYE_2:
tmpVec = switchCoordinateSystem_vector(vec, _baseEyeToWorldMatrix, WORLD_MATRIX);
break;
case COORD_TYPE_BASE_AT:
case COORD_TYPE_BASE_AT_2:
tmpVec = switchCoordinateSystem_vector(vec, _baseAtToWorldMatrix, WORLD_MATRIX);
break;
}
/* 移动指定点 */
Matrixd mat;
mat.makeTranslate(tmpVec);
switch (pointType)
{
case EYE_POINT:
_testEye = _currEye * mat;
_testUp = calcUp(_currAt - _currEye, _testAt - _testEye, _currUp);
updateEyeAndAtToWorldMatrix();
updateBaseToWorldMatrix();
break;
case AT_POINT:
_testAt = _currAt * mat;
_testUp = calcUp(_currAt - _currEye, _testAt - _testEye, _currUp);
updateEyeAndAtToWorldMatrix();
updateBaseToWorldMatrix();
break;
case BASE_POINT:
_testBase = _currBase * mat;
updateBaseToWorldMatrix();
break;
case EYE_POINT_AND_AT_POINT:
_testEye = _currEye * mat;
_testAt = _currAt * mat;
_testEyeToWorldMatrix = _eyeToWorldMatrix * mat;
_testAtToWorldMatrix = _atToWorldMatrix * mat;
updateBaseToWorldMatrix();
break;
case ALL_POINTS:
_testEye = _currEye * mat;
_testAt = _currAt * mat;
_testBase = _currBase * mat;
_testEyeToWorldMatrix = _eyeToWorldMatrix * mat;
_testAtToWorldMatrix = _atToWorldMatrix * mat;
_testBaseEyeToWorldMatrix = _baseEyeToWorldMatrix * mat;
_testBaseAtToWorldMatrix = _baseAtToWorldMatrix * mat;
break;
}
resEye = _testEye;
resAt = _testAt;
resBase = _testBase;
}
/***************************************************************
* Function: updateDiagonal()
*
* 'wireFrameVect': Lengths vector of the wire frame, used to
* decide the size of axis system. 'solidShapeVect': Diagonal
* vector of the actual solid shape, used to print out numbers
* of dimentions that showed on each axis.
*
***************************************************************/
void CAVEGroupReferenceAxis::updateDiagonal(const osg::Vec3 &wireFrameVect, const osg::Vec3 &solidShapeVect)
{
/* update axis */
if (wireFrameVect.x() >= 0) mXAxisGeode->setType(CAVEGeodeReferenceAxis::POS_X, &mXDirTrans);
else mXAxisGeode->setType(CAVEGeodeReferenceAxis::NEG_X, &mXDirTrans);
if (wireFrameVect.y() >= 0) mYAxisGeode->setType(CAVEGeodeReferenceAxis::POS_Y, &mYDirTrans);
else mYAxisGeode->setType(CAVEGeodeReferenceAxis::NEG_Y, &mYDirTrans);
if (wireFrameVect.z() >= 0) mZAxisGeode->setType(CAVEGeodeReferenceAxis::POS_Z, &mZDirTrans);
else mZAxisGeode->setType(CAVEGeodeReferenceAxis::NEG_Z, &mZDirTrans);
mXAxisGeode->resize(wireFrameVect.x());
mYAxisGeode->resize(wireFrameVect.y());
mZAxisGeode->resize(wireFrameVect.z());
/* update text */
if (mTextEnabledFlag)
{
char lenstr[64];
const float threshold = CAVEGeodeSnapWireframe::gSnappingUnitDist;
const float lx = solidShapeVect.x() > 0 ? solidShapeVect.x(): -solidShapeVect.x();
const float ly = solidShapeVect.y() > 0 ? solidShapeVect.y(): -solidShapeVect.y();
const float lz = solidShapeVect.z() > 0 ? solidShapeVect.z(): -solidShapeVect.z();
Matrixd rotMat;
rotMat.makeRotate(Vec3(0, 1, 0), gPointerDir);
if (lx >= threshold)
{
sprintf(lenstr, "%3.2f m", lx);
mXAxisText->setText(string(lenstr));
/* apply pointer oriented rotation and offset along the axis */
Matrixd transMat;
transMat.makeTranslate(Vec3(wireFrameVect.x(), 0, gCharSize));
mXAxisTextTrans->setMatrix(rotMat * transMat);
} else mXAxisText->setText("");
if (ly >= threshold)
{
sprintf(lenstr, "%3.2f m", ly);
mYAxisText->setText(string(lenstr));
/* apply pointer oriented rotation and offset along the axis */
Matrixd transMat;
transMat.makeTranslate(Vec3(0, wireFrameVect.y(), gCharSize));
mYAxisTextTrans->setMatrix(rotMat * transMat);
} else mYAxisText->setText("");
if (lz >= threshold)
{
sprintf(lenstr, "%3.2f m", lz);
mZAxisText->setText(string(lenstr));
/* apply pointer oriented rotation and offset along the axis */
Matrixd transMat;
transMat.makeTranslate(Vec3(0, -gCharSize, wireFrameVect.z()));
mZAxisTextTrans->setMatrix(rotMat * transMat);
} else mZAxisText->setText("");
}
}
