/* * Creates a rotation matrix which describes how a point in an auxiliary * coordinate system, whose x axis is desbibed by vec_along_x_axis and has * a point on its xz-plane vec_on_xz_plane, rotates into the real coordinate * system. */ void Cornea::createRotationMatrix(const Eigen::Vector3d &vec_along_x_axis, const Eigen::Vector3d &vec_on_xz_plane, Eigen::Matrix3d &R) { // normalise pw Eigen::Vector3d vec_on_xz_plane_n = vec_on_xz_plane.normalized(); // define helper variables x, y and z // x Eigen::Vector3d xn = vec_along_x_axis.normalized(); // y Eigen::Vector3d tmp = vec_on_xz_plane_n.cross(xn); Eigen::Vector3d yn = tmp.normalized(); // z tmp = xn.cross(yn); Eigen::Vector3d zn = tmp.normalized(); // create the rotation matrix R.col(0) << xn(0), xn(1), xn(2); R.col(1) << yn(0), yn(1), yn(2); R.col(2) << zn(0), zn(1), zn(2); }
Eigen::Vector3d getForcePoint(Eigen::Vector3d & c_current, Eigen::Vector3d & c_previous, const double & ro) { if(c_current.norm()<ro) { Eigen::Vector3d f=kp_mat*(ro-c_current.norm())*c_current.normalized() -kd_mat*(c_current.norm()-c_previous.norm())*c_current.normalized(); return f; } else { return Eigen::Vector3d(0,0,0); } }
void PlanarJoint::setPlane(const Eigen::Vector3d& _rotAxis, const Eigen::Vector3d& _tranAxis1) { mPlaneType = PT_ARBITRARY; // Rotational axis mRotAxis = _rotAxis.normalized(); // Translational axes assert(_rotAxis == _tranAxis1); Eigen::Vector3d unitTA1 = _tranAxis1.normalized(); mTranAxis1 = (unitTA1 - unitTA1.dot(mRotAxis) * mRotAxis).normalized(); mTranAxis2 = (mRotAxis.cross(mTranAxis1)).normalized(); }
//============================================================================== ScrewJointUniqueProperties::ScrewJointUniqueProperties( const Eigen::Vector3d& _axis, double _pitch) : mAxis(_axis.normalized()), mPitch(_pitch) { // Do nothing }
//============================================================================== PlaneShape::PlaneShape(const Eigen::Vector3d& _normal, const Eigen::Vector3d& _point) : Shape(), mNormal(_normal.normalized()), mOffset(mNormal.dot(_point)) { }
/** handleRayPick is called to test whether a visualizer is intersected * by a pick ray. It should be overridden by any pickable visualizer. * * \param pickOrigin origin of the pick ray in local coordinates * \param pickDirection the normalized pick ray direction, in local coordinates * \param pixelAngle angle in radians subtended by one pixel of the viewport */ bool Visualizer::handleRayPick(const Eigen::Vector3d& pickOrigin, const Eigen::Vector3d& pickDirection, double pixelAngle) const { if (!m_geometry.isNull()) { // For geometry with a fixed apparent size, test to see if the pick ray is // within apparent size / 2 pixels of the center. if (m_geometry->hasFixedApparentSize()) { double cosAngle = pickDirection.dot(-pickOrigin.normalized()); if (cosAngle > 0.0) { if (cosAngle >= 1.0 || acos(cosAngle) < m_geometry->apparentSize() / 2.0 * pixelAngle) { return true; } } } } return false; }
//============================================================================== Eigen::Isometry3d State::getCOMFrame() const { Eigen::Isometry3d T = Eigen::Isometry3d::Identity(); // Y-axis Eigen::Vector3d yAxis = Eigen::Vector3d::UnitY(); // X-axis Eigen::Vector3d xAxis = mPelvis->getTransform().linear().col(0); Eigen::Vector3d pelvisXAxis = mPelvis->getTransform().linear().col(0); double mag = yAxis.dot(pelvisXAxis); pelvisXAxis -= mag * yAxis; xAxis = pelvisXAxis.normalized(); // Z-axis Eigen::Vector3d zAxis = xAxis.cross(yAxis); T.translation() = getCOM(); T.linear().col(0) = xAxis; T.linear().col(1) = yAxis; T.linear().col(2) = zAxis; return T; }
mesh_core::Plane::Plane( const Eigen::Vector3d& normal, const Eigen::Vector3d& point_on_plane) : normal_(normal.normalized()) { d_ = -point_on_plane.dot(normal_); }
// return closest point on line segment to the given point, and the distance // betweeen them. double mesh_core::closestPointOnLine( const Eigen::Vector3d& line_a, const Eigen::Vector3d& line_b, const Eigen::Vector3d& point, Eigen::Vector3d& closest_point) { Eigen::Vector3d ab = line_b - line_a; Eigen::Vector3d ab_norm = ab.normalized(); Eigen::Vector3d ap = point - line_a; Eigen::Vector3d closest_point_rel = ab_norm.dot(ap) * ab_norm; double dp = ab.dot(closest_point_rel); if (dp < 0.0) { closest_point = line_a; } else if (dp > ab.squaredNorm()) { closest_point = line_b; } else { closest_point = line_a + closest_point_rel; } return (closest_point - point).norm(); }
void pointAndLineTransform(const Eigen::Vector3d& lineVector, const Eigen::Vector3d& linePoint, Eigen::Matrix4d& transform) { //define a plane containing the line point and with normal vector equal to the line vector pcl::ModelCoefficientsPtr planeCoefficients( new pcl::ModelCoefficients ); planeCoefficients->values.resize(4); Eigen::Vector3d normal; normal = lineVector.normalized(); planeCoefficients->values[0] = normal(0,0); planeCoefficients->values[1] = normal(1,0); planeCoefficients->values[2] = normal(2,0); // Provided the plane explicit equation A·X + B·Y + C·Z + D = 0, define D by // evaluating the equation with the line point: planeCoefficients->values[3] = -( normal(0,0)*linePoint(0,0) + normal(1,0)*linePoint(1,0) + normal(2,0)*linePoint(2,0) ); Eigen::Vector3d origin; origin = linePoint; pal::planeTransform(planeCoefficients, &origin, transform); }
void Camera::updatePrincipleRay() { // XXX Does lens distortion play a role here...? const Eigen::Vector3d tcol = K_.col(2); const Eigen::Vector3d dir = Kinv_ * (tcol / tcol[2]); principleRay_.setSource(C_); principleRay_.setDirection(Rinv_ * dir.normalized()); }
double constraints() { Eigen::Vector3d vec = ((*s2).curPos - (*s1).curPos); double magnitude = vec.norm(); double ext_dist = magnitude - const_dist; // lighter objects move further double weight1 = fmax(1.0 - (*s1).mass/((*s1).mass + (*s2).mass), 1e-5); double weight2 = fmax(1.0 - (*s2).mass/((*s1).mass + (*s2).mass), 1e-5); if (abs(ext_dist) > 1e-5) { Eigen::Vector3d s1s2 = vec.normalized(); Eigen::Vector3d s2s1 = -(vec.normalized()); (*s1).curPos = (*s1).curPos + weight1*ext_dist*s1s2; (*s2).curPos = (*s2).curPos + weight2*ext_dist*s2s1; (*s1).oldPos = (*s1).oldPos + 0.6*weight1*ext_dist*s1s2; (*s2).oldPos = (*s2).oldPos + 0.6*weight2*ext_dist*s2s1; } return ext_dist; }
UniversalJoint::UniversalJoint(const Eigen::Vector3d& _axis0, const Eigen::Vector3d& _axis1, const std::string& _name) : Joint(_name) { mGenCoords.push_back(&mCoordinate[0]); mGenCoords.push_back(&mCoordinate[1]); mS = Eigen::Matrix<double, 6, 2>::Zero(); mdS = Eigen::Matrix<double, 6, 2>::Zero(); mSpringStiffness.resize(2, 0.0); mDampingCoefficient.resize(2, 0.0); mRestPosition.resize(2, 0.0); mAxis[0] = _axis0.normalized(); mAxis[1] = _axis1.normalized(); }
// Set this to a random transformation with bounded rotation and translation. inline void Transformation::setRandom(double translationMaxMeters, double rotationMaxRadians) { // Create a random unit-length axis. Eigen::Vector3d axis = rotationMaxRadians * Eigen::Vector3d::Random(); // Create a random rotation angle in radians. Eigen::Vector3d r = translationMaxMeters * Eigen::Vector3d::Random(); r_ = r; q_ = Eigen::AngleAxisd(axis.norm(), axis.normalized()); updateC(); }
void StateEstimatorKinematic::integrate_angular_velocity(Eigen::Vector3d xyz) { Eigen::Quaterniond m; // m = Eigen::AngleAxisd(timestep,xyz); m = Eigen::AngleAxisd(xyz.norm()*timestep,xyz.normalized()); _q = _q*m; }
/** * @brief set pose based on compact scaled-axis representation * * @param v compact 6 vector [r t], where r is a 3 vector representing * the rotation in scaled axis form, and t is the translation 3 vector. */ void fromVector6d( const Vector6d &v ) { const Eigen::Vector3d saxis = v.head<3>(); if( saxis.norm() > 1e-9 ) orientation = Eigen::AngleAxisd( saxis.norm(), saxis.normalized() ); else orientation = Eigen::Quaterniond::Identity(); position = v.tail<3>(); }
//============================================================================== void TranslationalJoint2DUniqueProperties::setArbitraryPlane( const Eigen::Vector3d& transAxis1, const Eigen::Vector3d& transAxis2) { // Set plane type as arbitrary plane mPlaneType = PlaneType::ARBITRARY; // First translational axis mTransAxes.col(0) = transAxis1.normalized(); // Second translational axis mTransAxes.col(1) = transAxis2.normalized(); // Orthogonalize translational axes const double dotProduct = mTransAxes.col(0).dot(mTransAxes.col(1)); assert(std::abs(dotProduct) < 1.0 - 1e-6); if (std::abs(dotProduct) > 1e-6) mTransAxes.col(1) = (mTransAxes.col(1) - dotProduct * mTransAxes.col(0)).normalized(); }
//============================================================================== void PrismaticJoint::setAxis(const Eigen::Vector3d& _axis) { if(_axis == mAspectProperties.mAxis) return; mAspectProperties.mAxis = _axis.normalized(); Joint::notifyPositionUpdate(); updateLocalJacobian(); Joint::incrementVersion(); }
UniversalJoint::UniversalJoint(BodyNode* _parent, BodyNode* _child, const Eigen::Vector3d& _axis0, const Eigen::Vector3d& _axis1, const std::string& _name) : Joint(_parent, _child, _name) { mJointType = UNIVERSAL; mGenCoords.push_back(&mCoordinate[0]); mGenCoords.push_back(&mCoordinate[1]); mS = Eigen::Matrix<double,6,2>::Zero(); mdS = Eigen::Matrix<double,6,2>::Zero(); mDampingCoefficient.resize(2, 0); mAxis[0] = _axis0.normalized(); mAxis[1] = _axis1.normalized(); }
/** * @function getPlaneTransform * @brief Assumes plane coefficients are of the form ax+by+cz+d=0, normalized */ Eigen::Matrix4d getPlaneTransform ( pcl::ModelCoefficients &coeffs, double up_direction, bool flatten_plane ) { Eigen::Matrix4d tf = Eigen::Matrix4d::Identity(); if( coeffs.values.size() <= 3 ) { std::cout << "[ERROR] Coefficient size less than 3. I will output nonsense values"<<std::endl; return tf; } double a = coeffs.values[0]; double b = coeffs.values[1]; double c = coeffs.values[2]; double d = coeffs.values[3]; //asume plane coefficients are normalized Eigen::Vector3d position(-a*d, -b*d, -c*d); Eigen::Vector3d z(a, b, c); //if we are flattening the plane, make z just be (0,0,up_direction) if(flatten_plane) { z << 0, 0, up_direction; } else { //make sure z points "up" (the plane normal and the table must have a > 90 angle, hence the cosine must be negative) if ( z.dot( Eigen::Vector3d(0, 0, up_direction) ) > 0) { z = -1.0 * z; printf("Changing sign \n"); coeffs.values[0]*= -1; coeffs.values[1]*= -1; coeffs.values[2]*= -1; coeffs.values[3]*= -1; } } //try to align the x axis with the x axis of the original frame //or the y axis if z and x are too close too each other Eigen::Vector3d x; x << 1, 0, 0; if ( fabs(z.dot(x)) > 1.0 - 1.0e-4) x = Eigen::Vector3d(0, 1, 0); Eigen::Vector3d y = z.cross(x); y.normalized(); x = y.cross(z); x.normalized(); Eigen::Matrix3d rotation; rotation.block(0,0,3,1) = x; rotation.block(0,1,3,1) = y; rotation.block(0,2,3,1) = z; Eigen::Quaterniond orientation( rotation ); tf.block(0,0,3,3) = orientation.matrix(); tf.block(0,3,3,1) = position; return tf; }
Eigen::Matrix3d Utility::g2R(const Eigen::Vector3d &g) { Eigen::Matrix3d R0; Eigen::Vector3d ng1 = g.normalized(); Eigen::Vector3d ng2{0, 0, 1.0}; R0 = Eigen::Quaterniond::FromTwoVectors(ng1, ng2).toRotationMatrix(); double yaw = Utility::R2ypr(R0).x(); R0 = Utility::ypr2R(Eigen::Vector3d{-yaw, 0, 0}) * R0; // R0 = Utility::ypr2R(Eigen::Vector3d{-90, 0, 0}) * R0; return R0; }
//============================================================================== void PlanarJoint::UniqueProperties::setArbitraryPlane( const Eigen::Vector3d& _transAxis1, const Eigen::Vector3d& _transAxis2) { // Set plane type as arbitrary plane mPlaneType = PT_ARBITRARY; // First translational axis mTransAxis1 = _transAxis1.normalized(); // Second translational axis mTransAxis2 = _transAxis2.normalized(); // Orthogonalize translational axese double dotProduct = mTransAxis1.dot(mTransAxis2); assert(std::abs(dotProduct) < 1.0 - 1e-6); if (std::abs(dotProduct) > 1e-6) mTransAxis2 = (mTransAxis2 - dotProduct * mTransAxis1).normalized(); // Rotational axis mRotAxis = (mTransAxis1.cross(mTransAxis2)).normalized(); }
void randomize_transform(Eigen::Isometry3d& tf, double translation_limit=100, double rotation_limit=100) { Eigen::Vector3d r = random_vec<3>(translation_limit); Eigen::Vector3d theta = random_vec<3>(rotation_limit); tf.setIdentity(); tf.translate(r); if(theta.norm()>0) tf.rotate(Eigen::AngleAxisd(theta.norm(), theta.normalized())); }
RevoluteJoint::RevoluteJoint(const Eigen::Vector3d& axis, const std::string& _name) : Joint(REVOLUTE, _name), mAxis(axis.normalized()) { mGenCoords.push_back(&mCoordinate); mS = Eigen::Matrix<double, 6, 1>::Zero(); mdS = Eigen::Matrix<double, 6, 1>::Zero(); mSpringStiffness.resize(1, 0.0); mDampingCoefficient.resize(1, 0.0); mRestPosition.resize(1, 0.0); }
// Calculate the fitting error of a plane to certain 3D data double PlaneFit::fitPlaneError(const Points3D& P, const Eigen::Vector3d& normal, Eigen::Vector3d& point) { // Normalise the normal vector (to put the resulting error in units of normal distance to plane) Eigen::Vector3d n = normal.normalized(); // Calculate the average distance to the plane of the data points double err = 0.0; size_t N = P.size(); for(size_t i = 0; i < N; i++) err += fabs(n.dot(P[i] - point))/N; // Return the calculated error return err; }
Eigen::Vector3d Circuit::GetFieldFromPoint( const Eigen::Vector3d& point, const Eigen::Vector3d& segmentCenter, const Eigen::Vector3d& flowDirection, double segmentCoeff ) { Eigen::Vector3d r = segmentCenter.array()-point.array(); double rLengthSquared = r.squaredNorm(); // distance squared. Eigen::Vector3d rUnit = r.normalized(); Eigen::Vector3d Vcrossr = flowDirection.cross(rUnit); Eigen::Vector3d B = segmentCoeff/rLengthSquared*Vcrossr.array(); return B; }
RevoluteJoint::RevoluteJoint(BodyNode* _parent, BodyNode* _child, const Eigen::Vector3d& axis, const std::string& _name) : Joint(_parent, _child, _name), mAxis(axis.normalized()) { mJointType = REVOLUTE; mGenCoords.push_back(&mCoordinate); mS = Eigen::Matrix<double,6,1>::Zero(); mdS = Eigen::Matrix<double,6,1>::Zero(); mDampingCoefficient.resize(1, 0); }
ScrewJoint::ScrewJoint(const Eigen::Vector3d& axis, double _pitch, const std::string& _name) : Joint(SCREW, _name), mAxis(axis.normalized()), mPitch(_pitch) { mGenCoords.push_back(&mCoordinate); mS = Eigen::Matrix<double, 6, 1>::Zero(); mdS = Eigen::Matrix<double, 6, 1>::Zero(); mSpringStiffness.resize(1, 0.0); mDampingCoefficient.resize(1, 0.0); mRestPosition.resize(1, 0.0); }
int main(int , char** ) { for (int k = 0; k < 100000; ++k) { // create a random rotation matrix by sampling a random 3d vector // that will be used in axis-angle representation to create the matrix Eigen::Vector3d rotAxisAngle = Vector3d::Random(); rotAxisAngle += Vector3d::Random(); Eigen::AngleAxisd rotation(rotAxisAngle.norm(), rotAxisAngle.normalized()); Eigen::Matrix3d Re = rotation.toRotationMatrix(); // our analytic function which we want to evaluate Matrix<double, 3 , 9> dq_dR; compute_dq_dR (dq_dR, Re(0,0),Re(1,0),Re(2,0), Re(0,1),Re(1,1),Re(2,1), Re(0,2),Re(1,2),Re(2,2)); // compute the Jacobian using AD Matrix<double, 3 , 9, Eigen::RowMajor> dq_dR_AD; typedef ceres::internal::AutoDiff<RotationMatrix2QuaternionManifold, double, 9> AutoDiff_Dq_DR; double *parameters[] = { Re.data() }; double *jacobians[] = { dq_dR_AD.data() }; double value[3]; RotationMatrix2QuaternionManifold rot2quat; AutoDiff_Dq_DR::Differentiate(rot2quat, parameters, 3, value, jacobians); // compare the two Jacobians const double allowedDifference = 1e-6; for (int i = 0; i < dq_dR.rows(); ++i) { for (int j = 0; j < dq_dR.cols(); ++j) { double d = fabs(dq_dR_AD(i,j) - dq_dR(i,j)); if (d > allowedDifference) { cerr << "\ndetected difference in the Jacobians" << endl; cerr << PVAR(Re) << endl << endl; cerr << PVAR(dq_dR_AD) << endl << endl; cerr << PVAR(dq_dR) << endl << endl; return 1; } } } cerr << "+"; } return 0; }
//not used, using implicit instead vector<Eigen::Vector3d> mySpring::calcSpringForce() {// {S_SCALAR,S_VECTOR, ATTR, SPRING}; vector<Eigen::Vector3d> result(2, Eigen::Vector3d(0, 0, 0)); if (restLen != 0) { //spring with damping force Eigen::Vector3d aMb = (a->getPosition() - b->getPosition()); Eigen::Vector3d lnorm = aMb.normalized();//unitlength vector of sprRestVec Eigen::Vector3d ldot = (a->getPosition() - a->getPosition(1)); //since using verlet, use this for velocity double d = ((a->getPosition(1) - b->getPosition(1)).norm()); double KsTerm = Ks * (d - restLen); double KdTerm = Kd * (ldot.dot(lnorm)); double fp = -1 * (KsTerm + KdTerm); result[0] = (lnorm * fp); result[1] = (lnorm * (-1 * fp)); }//only add force if magnitude of distance vector is not 0 else { cout << "0 restlen spring : " << ID << endl; } return result; }//calcForceOnParticle