bool OBRing::findCenterAndNormal(vector3 & center, vector3 &norm1, vector3 &norm2) { OBMol *mol= this->_parent; int j= 0; const int nA= this->_path.size(); vector3 tmp; center.Set(0.0,0.0,0.0); norm1.Set(0.0,0.0,0.0); norm2.Set(0.0,0.0,0.0); for (j = 0; j != nA; ++j) { center += (mol->GetAtom(_path[j]))->GetVector(); } center/= double(nA); for (j = 0; j != nA; ++j) { vector3 v1= (mol->GetAtom(_path[j]))->GetVector() - center; vector3 v2= (mol->GetAtom(_path[j+1==nA?0:j+1]))->GetVector() - center; tmp= cross(v1,v2); norm1+= tmp; } norm1/= double(nA); norm1.normalize(); norm2= norm1; norm2 *= -1.0; return(true); }
//for only world void UITextBox::setFace(vector3 right, vector3 down){ right.normalize(); down.normalize(); direction = right; this->down = down; }
Camera(vector3 p, vector3 d, vector3 u) { position = p; direction = d.normalized(); up = u.normalized(); up = (u - direction.projected(u)).normalized(); right = (direction ^ up).normalized(); }
EwaldPeriodic(const matrix3<>& R, int nAtoms) : R(R), G((2*M_PI)*inv(R)), RTR((~R)*R), GGT(G*(~G)) { logPrintf("\n---------- Setting up ewald sum ----------\n"); //Determine optimum gaussian width for Ewald sums: // From below, the number of reciprocal cells ~ Prod_k |R.column[k]| // and number of real space cells ~ Prod_k |G.row[k]| // including the fact that the real space cost ~ Natoms^2/cell // and the reciprocal space cost ~ Natoms/cell sigma = 1.; for(int k=0; k<3; k++) sigma *= R.column(k).length() / G.row(k).length(); sigma = pow(sigma/std::max(1,nAtoms), 1./6); logPrintf("Optimum gaussian width for ewald sums = %lf bohr.\n", sigma); //Carry real space sums to Rmax = 10 sigma and Gmax = 10/sigma //This leads to relative errors ~ 1e-22 in both sums, well within double precision limits for(int k=0; k<3; k++) { Nreal[k] = 1+ceil(CoulombKernel::nSigmasPerWidth * G.row(k).length() * sigma / (2*M_PI)); Nrecip[k] = 1+ceil(CoulombKernel::nSigmasPerWidth * R.column(k).length() / (2*M_PI*sigma)); } logPrintf("Real space sum over %d unit cells with max indices ", (2*Nreal[0]+1)*(2*Nreal[1]+1)*(2*Nreal[2]+1)); Nreal.print(globalLog, " %d "); logPrintf("Reciprocal space sum over %d terms with max indices ", (2*Nrecip[0]+1)*(2*Nrecip[1]+1)*(2*Nrecip[2]+1)); Nrecip.print(globalLog, " %d "); }
matrix4x4 translation_matrix(vector3 const& v) { return matrix4x4 (1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, v.x(), v.y(), v.z(), 1); }
const vector3 vector3::operator / (const vector3 &v2) const { vector3 r; r.x() = x() / v2.x(); r.y() = y() / v2.y(); r.z() = z() / v2.z(); return r; }
float vector3::AngleBetweenVectors(const vector3& v0, const vector3& v1) { float d = v0.Dot(v1); if ( d >= -1.f && d <= 1.f ) { return acosf( d / ( v0.Length() * v1.Length() ) ); } return 0.f; }
vector3<float> get_rotation_axis(vector3<float> u, vector3<float> v) { u.normalize(); v.normalize(); // fix linear case if (u == v || u == -v) { v[0] += 0.1; v[1] += 0.0; v[2] += 0.1; v.normalize(); } return u.cross(v); }
vector3 vector3::Transform(const vector3& v, const matrix& m) { vector3 result = vector3( (v.x() * m(0,0)) + (v.x() * m(1,0)) + (v.x() * m(2,0)) + m(3,0), (v.y() * m(0,1)) + (v.y() * m(1,1)) + (v.y() * m(2,1)) + m(3,1), (v.z() * m(0,2)) + (v.z() * m(1,2)) + (v.z() * m(2,2) ) + m(3,2)); return result; }
//! Implements <a href="http://qsar.sourceforge.net/dicts/blue-obelisk/index.xhtml#calculateOrthogonalisationMatrix">blue-obelisk:calculateOrthogonalisationMatrix</a> void OBUnitCell::SetData(const vector3 v1, const vector3 v2, const vector3 v3) { matrix3x3 m (v1, v2, v3); _mOrtho.FillOrth(vectorAngle(v2,v3), // alpha vectorAngle(v1,v3), // beta vectorAngle(v1,v2), // gamma v1.length(), // a v2.length(), // b v3.length()); // c _mOrient = m.transpose() * _mOrtho.inverse(); _spaceGroup = NULL; _spaceGroupName = ""; _lattice = OBUnitCell::Undefined; }
double get_rotation_angle(vector3<float> u, vector3<float> v) { u.normalize(); v.normalize(); double cosine_theta = u.dot(v); // domain of arccosine is [-1, 1] if (cosine_theta > 1) { cosine_theta = 1; } if (cosine_theta < -1) { cosine_theta = -1; } double angle = acos(cosine_theta); return angle; }
/// // FacePlane() // // Which of the six face-plane(s) is point P outside of? // static int FacePlane(const vector3& p) { int outcode; outcode = 0; if (p.x() > .5) outcode |= 0x01; if (p.x() < -.5) outcode |= 0x02; if (p.y() > .5) outcode |= 0x04; if (p.y() < -.5) outcode |= 0x08; if (p.z() > .5) outcode |= 0x10; if (p.z() < -.5) outcode |= 0x20; return(outcode); }
//Return size of stabilizer group of a Cartesian displacement (given Cartesian symmetry rotations) inline int nStabilizer(const vector3<>& n, const std::vector< matrix3<> >& symCart) { int nStab = 0; for(const matrix3<>& m: symCart) if((n - m * n).length_squared() < symmThresholdSq * n.length_squared()) nStab++; return nStab; }
void matrix::setrot(vector3 p1,vector3 p2) { vector3 _ax=p1*p2; _ax.selfnormalize(); double _th=p1.angle(p2); setrot(_th,_ax); }
void moon::display(const vector3 &moon_pos, const vector3 &sun_pos, double max_view_dist) const { vector3 moon_dir = moon_pos.normal(); double moon_size = max_view_dist/20; float moon_azimuth = atan2(-moon_dir.y, moon_dir.x); float moon_elevation = asin(moon_dir.z); glsl_moon->use(); glsl_moon->set_gl_texture(*map_diffuse, loc_diffcol, 0); glsl_moon->set_gl_texture(*map_normal, loc_nrml, 1); // transform light into object space matrix4 roth = matrix4::rot_z(-RAD_TO_DEG(moon_azimuth)); matrix4 rotv = matrix4::rot_y(-RAD_TO_DEG(moon_elevation)); matrix4 model_mat = roth*rotv; vector3 l = model_mat.inverse() * sun_pos; vector3 nl = vector3(-l.y, l.z, -l.x).normal(); // OpenGL coordinates glsl_moon->set_uniform(loc_lightdir, nl); // render moon glPushMatrix(); model_mat.multiply_gl(); glTranslated(0.95*max_view_dist, 0, 0); primitives::textured_quad(vector3f( 0, moon_size, moon_size), vector3f( 0, -moon_size, moon_size), vector3f( 0, -moon_size, -moon_size), vector3f( 0, moon_size, -moon_size), *map_diffuse).render_plain(); glPopMatrix(); }
double controller::ray_traverse(vector3 const & direction) const { float coords[4]; direction.getAs4Values(coords); vector3 dir(coords[0] * cos(-rotation) - coords[2] * sin(-rotation), coords[1], coords[0] * sin(-rotation) + coords[2] * cos(-rotation)); boost::lock_guard<boost::mutex> lock(mutex_); core::line3d<f32> ray; ray.start = position_ + vector3(0, 5, 0); ray.end = position_ + vector3(0, 5, 0) + dir * 1000.0f; core::vector3df intersection; core::triangle3df hitTriangle; scene::ISceneNode * selectedSceneNode = collision_manager_->getSceneNodeAndCollisionPointFromRay( ray, intersection, // This will be the position of the collision hitTriangle, // This will be the triangle hit in the collision 0, //IDFlag_IsPickable, // This ensures that only nodes that we have // set up to be pickable are considered 0); // Check return (intersection - position_).getLength(); }
bool operator()(OBAtom *l, OBAtom *r) const { double ld = ref.distSq(l->GetVector()); double rd = ref.distSq(r->GetVector()); return ld < rd; }
quat rotation_quat(vector3 const& axe, real const& angle ) { // create (sin(a/2)*axis, cos(a/2)) quaternion // which rotates the point a radians around "axis" quat res; vector4 u = vector4(axe.x(), axe.y(), axe.z(), 0); u.normalize(); real sina2 = sin(angle/2); real cosa2 = cos(angle/2); res.qx() = sina2 * u.x(); res.qy() = sina2 * u.y(); res.qz() = sina2 * u.z(); res.qw() = cosa2; return res; }
/*! This method employs the static method matrix3x3::jacobi(...) to find the eigenvalues and eigenvectors of a symmetric matrix. On entry it is checked if the matrix really is symmetric: if isSymmetric() returns 'false', an OBError is thrown. \note The jacobi algorithm is should work great for all symmetric 3x3 matrices. If you need to find the eigenvectors of a non-symmetric matrix, you might want to resort to the sophisticated routines of LAPACK. @param eigenvals a reference to a vector3 where the eigenvalues will be stored. The eigenvalues are ordered so that eigenvals[0] <= eigenvals[1] <= eigenvals[2]. @return an orthogonal matrix whose ith column is an eigenvector for the eigenvalue eigenvals[i]. Here 'orthogonal' means that all eigenvectors have length one and are mutually orthogonal. The ith eigenvector can thus be conveniently accessed by the GetColumn() method, as in the following example. \code // Calculate eigenvectors and -values vector3 eigenvals; matrix3x3 eigenmatrix = somematrix.findEigenvectorsIfSymmetric(eigenvals); // Print the 2nd eigenvector cout << eigenmatrix.GetColumn(1) << endl; \endcode With these conventions, a matrix is diagonalized in the following way: \code // Diagonalize the matrix matrix3x3 diagonalMatrix = eigenmatrix.inverse() * somematrix * eigenmatrix; \endcode */ matrix3x3 matrix3x3::findEigenvectorsIfSymmetric(vector3 &eigenvals) const #ifdef OB_OLD_MATH_CHECKS throw(OBError) #endif { matrix3x3 result; #ifdef OB_OLD_MATH_CHECKS if (!isSymmetric()) { OBError er("matrix3x3::findEigenvectorsIfSymmetric(vector3 &eigenvals) const throw(OBError)", "The method was called on a matrix that was not symmetric, i.e. where isSymetric() == false.", "This is a runtime or a programming error in your application."); throw er; } #endif double d[3]; matrix3x3 copyOfThis = *this; jacobi(3, copyOfThis.ele[0], d, result.ele[0]); eigenvals.Set(d); return result; }
BOHGE_FORCEINLINE void RotateAxis(const vector3<T>& axis, T r ) { //T sa, ca; //Math::SinCos(r * T(0.5), sa, ca); T sc[2]; Math::SinCos( r * T(0.5), sc ); if ( Math::isEqual( axis.Length(), T(0.0) ) ) { m_x = sc[0]; m_y = sc[0]; m_z = sc[0]; m_w = sc[1]; } else { vector3<T> temp = axis; temp.NormalizeSelf(); temp *= sc[0]; //*this = Quaternion<T>( temp * sc[0], sc[1] ); m_x = temp.m_x; m_y = temp.m_y; m_z = temp.m_z; m_w = sc[1]; } }
void uvaxes::uv2axes( vector3 & u, vector3 &v, vector3 &e1, vector3 &e2, vector3 &e3 ){ e2 = u^v; double au = u.mod(); double av = v.mod(); double ae2 = e2.mod(); if (myequal(au,0.0) || myequal(av,0.0)){ cerr << "Error: zero vector not usable for uvaxes"; exit(1); } if (myequal(ae2,0.0)){ cerr << "Error: colinear vectors not usable for uvaxes"; exit(1); } e1 = u/au; e2 = e2 / ae2; e3 = e1^e2; return; }
static vector3 slerp(vector3 start, vector3 end, T percent) { T dot = start.dot(end); dot = vector3::clamp(dot, -1.0f, 1.0f); T theta = acos(dot) * percent; vector3 relative = end - start*dot; relative.normalize(); return ((start * cos(theta)) + (relative*sin(theta))); }
inline bool computeSDFNormal(const UT_VoxelArrayF *g_col, int iX, int iY, int iZ, vector3 &norm){ //Make sure this is a border cell????? if (g_col->getValue(iX, iY, iZ) <= 0) return false; norm[0] = g_col->getValue(iX-1,iY,iZ) - g_col->getValue(iX+1,iY,iZ); norm[1] = g_col->getValue(iX,iY-1,iZ) - g_col->getValue(iX,iY+1,iZ); norm[2] = g_col->getValue(iX,iY,iZ-1) - g_col->getValue(iX,iY,iZ+1); norm.normalize(); return true; }
Scanline::Scanline(const vector3& origin, const vector3& direction, const vector3& lateral_dir, float timestamp) : origin(origin), direction(direction), lateral_dir(lateral_dir), timestamp(timestamp) { elevational_dir = lateral_dir.cross(direction); // TODO: Should all vectors be normalized here? if (!is_orthogonal()) throw std::runtime_error("Invalid Scanline: Not orthogonal unit vectors"); if (!is_normalized()) throw std::runtime_error("Invalid Scanline: Not unit length vectors"); }
void matrix3x3::SetColumn(int col, const vector3 &v) #ifdef OB_OLD_MATH_CHECKS throw(OBError) #endif { #ifdef OB_OLD_MATH_CHECKS if (col > 2) { OBError er("matrix3x3::SetColumn(int col, const vector3 &v)", "The method was called with col > 2.", "This is a programming error in your application."); throw er; } #endif ele[0][col] = v.x(); ele[1][col] = v.y(); ele[2][col] = v.z(); }
void matrix3x3::SetRow(int row, const vector3 &v) #ifdef OB_OLD_MATH_CHECKS throw(OBError) #endif { #ifdef OB_OLD_MATH_CHECKS if (row > 2) { OBError er("matrix3x3::SetRow(int row, const vector3 &v)", "The method was called with row > 2.", "This is a programming error in your application."); throw er; } #endif ele[row][0] = v.x(); ele[row][1] = v.y(); ele[row][2] = v.z(); }
int CalculateNormalNoNormalize(vector3& vNormOut, Grid& grid, Edge* e, Grid::VertexAttachmentAccessor<APosition>& aaPos, Grid::FaceAttachmentAccessor<ANormal>* paaNormFACE) { Face* f[2]; int numFaces = GetAssociatedFaces(f, grid, e, 2); switch(numFaces){ case 0:{ // if there are no associated faces. // we'll assume that the edge lies in the xy plane and return its normal vector3 dir; VecSubtract(dir, aaPos[e->vertex(1)], aaPos[e->vertex(0)]); vNormOut.x() = dir.y(); vNormOut.y() = -dir.x(); vNormOut.z() = 0; }break; case 1: // if there is one face, the normal will be set to the faces normal if(paaNormFACE) vNormOut = (*paaNormFACE)[f[0]]; else{ CalculateNormalNoNormalize(vNormOut, f[0], aaPos); } break; default: // there are at least 2 associated faces if(paaNormFACE) VecAdd(vNormOut, (*paaNormFACE)[f[0]], (*paaNormFACE)[f[1]]); else{ vector3 fn0, fn1; CalculateNormalNoNormalize(fn0, f[0], aaPos); CalculateNormalNoNormalize(fn1, f[1], aaPos); VecAdd(vNormOut, fn0, fn1); VecScale(vNormOut, vNormOut, 0.5); } VecNormalize(vNormOut, vNormOut); break; } return numFaces; }
vector3 OBUnitCell::WrapFractionalCoordinate(vector3 frac) const { double x = fmod(frac.x(), 1); double y = fmod(frac.y(), 1); double z = fmod(frac.z(), 1); if (x < 0) x += 1; if (y < 0) y += 1; if (z < 0) z += 1; #define LIMIT 0.999999 if (x > LIMIT) x -= 1; if (y > LIMIT) y -= 1; if (z > LIMIT) z -= 1; #undef LIMIT return vector3(x, y, z); }
void matrix4::initialize_camera(vector3 forward, vector3 up) { forward.normalize(); vector3 f = forward; up.normalize(); vector3 r = up; r.normalize(); r.cross_product(f); vector3 u = f; u.cross_product(r); initialize_identity(); set_at(0, 0, r.get_x()); set_at(0, 1, r.get_y()); set_at(0, 2, r.get_z()); set_at(1, 0, u.get_x()); set_at(1, 1, u.get_y()); set_at(1, 2, u.get_z()); set_at(2, 0, f.get_x()); set_at(2, 1, f.get_y()); set_at(2, 2, f.get_z()); }
vector2 sphere::texture_at(ray_point const& rp) const { // We'll use the equations suggested at // http://en.wikipedia.org/wiki/UV_mapping : // // atan(d.z / d.x) // u = 0.5 + --------------- // 2 pi // // asin(d.y) // v = 0.5 - --------- // pi vector3 const d = -normal_at(rp).get(); double const u = 0.5 + atan2(d.z(), d.x()) / (2 * PI); double const v = 0.5 - asin(d.y()) / PI; assert(0.0 <= u && u <= 1.0); assert(0.0 <= v && v <= 1.0); return {u, v}; }