void BcMat4d::scale( const BcVec4d& Scale ) { row0( BcVec4d( Scale.x(), 0.0f, 0.0f, 0.0f ) ); row1( BcVec4d( 0.0f, Scale.y(), 0.0f, 0.0f ) ); row2( BcVec4d( 0.0f, 0.0f, Scale.z(), 0.0f ) ); row3( BcVec4d( 0.0f, 0.0f, 0.0f, Scale.w() ) ); }
virtual void fillCommonFields(file_status_results_t& statusResult) { if (statusResult.size() == 0) { srmlogit(STORM_LOG_ERROR, "storm::file_status::fillCommonFields()", "Received an empty query result\n"); throw std::logic_error("Received an empty query result"); } file_status_result_t row0(statusResult.at(0)); if (row0["client_dn"].empty()) { srmlogit(STORM_LOG_ERROR, "storm::file_status::fillCommonFields()", "No client_dn available in the query result\n"); throw std::logic_error("No client_dn available in the query result"); } m_storedClientDN = row0["client_dn"]; if(row0["status"].empty()) { srmlogit(STORM_LOG_ERROR, "storm::file_status::fillCommonFields()", "No request status available in the query result\n"); throw std::logic_error("No request status available in the query result"); } m_status = static_cast<ns1__TStatusCode> (atoi(row0["status"].c_str())); m_explanation = row0["errstring"]; if(!row0["remainingTotalTime"].empty()) { m_remainingTotalRequestTime = atoi(row0["remainingTotalTime"].c_str()); } }
AglQuaternion AglMatrix::GetRotation() const { AglVector3 row0(data[0], data[1], data[2]); AglVector3 row1(data[4], data[5], data[6]); AglVector3 row2(data[8], data[9], data[10]); float lrow0 = AglVector3::length(row0); float lrow1 = AglVector3::length(row1); float lrow2 = AglVector3::length(row2); row0 *= (1/lrow0); row1 *= (1/lrow1); row2 *= (1/lrow2); //Find the largest factor. float qx, qy, qz, qw; if (row0[0] + row1[1] + row2[2] > 0.0f) //Use w { float t = row0[0] + row1[1] + row2[2] + data[15]; float s = 0.5f / sqrt(t); qw = s * t; qz = (row0[1] - row1[0]) * s; qy = (row2[0] - row0[2]) * s; qx = (row1[2] - row2[1]) * s; } else if (row0[0] > row1[1] && row0[0] > row2[2]) //Use x { float t = row0[0] - row1[1] - row2[2] + data[15]; float s = 0.5f / sqrt(t); qx = s * t; qy = (row0[1] + row1[0]) * s; qz = (row2[0] + row0[2]) * s; qw = (row1[2] - row2[1]) * s; } else if (row1[1] > row2[2]) //Use y { float t = -row0[0] + row1[1] - row2[2] + data[15]; float s = 0.5f / sqrt(t); qy = s * t; qx = (row0[1] + row1[0]) * s; qw = (row2[0] - row0[2]) * s; qz = (row1[2] + row2[1]) * s; } else //Use z { float t = -row0[0] - row1[1] + row2[2] + data[15]; float s = 0.5f / sqrt(t); qz = s * t; qw = (row0[1] - row1[0]) * s; qx = (row2[0] + row0[2]) * s; qy = (row1[2] + row2[1]) * s; } return AglQuaternion(qx, qy, qz, qw); }
inline mat4 inverse(mat4 const& m) { float coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; float coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3]; float coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3]; float coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; float coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; float coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3]; float coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; float coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2]; float coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2]; float coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; float coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3]; float coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3]; float coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; float coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2]; float coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2]; float coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; float coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; float coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; vec4 fac0(coef00, coef00, coef02, coef03); vec4 fac1(coef04, coef04, coef06, coef07); vec4 fac2(coef08, coef08, coef10, coef11); vec4 fac3(coef12, coef12, coef14, coef15); vec4 fac4(coef16, coef16, coef18, coef19); vec4 fac5(coef20, coef20, coef22, coef23); vec4 v0(m[1][0], m[0][0], m[0][0], m[0][0]); vec4 v1(m[1][1], m[0][1], m[0][1], m[0][1]); vec4 v2(m[1][2], m[0][2], m[0][2], m[0][2]); vec4 v3(m[1][3], m[0][3], m[0][3], m[0][3]); vec4 inv0(v1 * fac0 - v2 * fac1 + v3 * fac2); vec4 inv1(v0 * fac0 - v2 * fac3 + v3 * fac4); vec4 inv2(v0 * fac1 - v1 * fac3 + v3 * fac5); vec4 inv3(v0 * fac2 - v1 * fac4 + v2 * fac5); vec4 signA(+1, -1, +1, -1); vec4 signB(-1, +1, -1, +1); mat4 inv(inv0 * signA, inv1 * signB, inv2 * signA, inv3 * signB); vec4 row0(inv[0][0], inv[1][0], inv[2][0], inv[3][0]); vec4 dot0(m[0] * row0); float dot1 = (dot0.x + dot0.y) + (dot0.z + dot0.w); float one_over_det = 1.f / dot1; return inv * one_over_det; }
// Print a matrix33 to a file void matrix33::fprint(FILE* file, char * str) const { fprintf(file, "%smatrix33:\n", str); vector3 row0(col[0][0], col[1][0], col[2][0]); row0.fprint(file, "\t"); vector3 row1(col[0][1], col[1][1], col[2][1]); row1.fprint(file, "\t"); vector3 row2(col[0][2], col[1][2], col[2][2]); row2.fprint(file, "\t"); }
AglVector3 AglMatrix::GetScale() const { AglVector3 row0(data[0], data[1], data[2]); AglVector3 row1(data[4], data[5], data[6]); AglVector3 row2(data[8], data[9], data[10]); float lrow0 = AglVector3::length(row0); float lrow1 = AglVector3::length(row1); float lrow2 = AglVector3::length(row2); return AglVector3(lrow0, lrow1, lrow2); }
// --[ Method ]--------------------------------------------------------------- // // - Class : CMatrix // // - prototype : CMatrix Inverse() // // - Purpose : Returns the inverse transformation matrix. // // - Note : IMPORTANT: Algorithm only valid for orthogonal matrices! // // ----------------------------------------------------------------------------- CMatrix CMatrix::Inverse() const { CMatrix result; // Transpose rotation submatrix CVector3 row0(m_fM[0][0], m_fM[1][0], m_fM[2][0]); CVector3 row1(m_fM[0][1], m_fM[1][1], m_fM[2][1]); CVector3 row2(m_fM[0][2], m_fM[1][2], m_fM[2][2]); CVector3 position(m_fM[0][3], m_fM[1][3], m_fM[2][3]); CVector3 invPosition; // Solve ecuation system invPosition.SetX((-row0) * position); invPosition.SetY((-row1) * position); invPosition.SetZ((-row2) * position); // Get scale values CVector3 scale = Scale(); float sqrSclX = scale.X(); sqrSclX *= sqrSclX; float sqrSclY = scale.Y(); sqrSclY *= sqrSclY; float sqrSclZ = scale.Z(); sqrSclZ *= sqrSclZ; // Shouldn't happen: assert(!IS_ZERO(sqrSclX)); assert(!IS_ZERO(sqrSclY)); assert(!IS_ZERO(sqrSclZ)); // Normalize axis and multiply by the inverse scale. row0 = row0 / sqrSclX; row1 = row1 / sqrSclY; row2 = row2 / sqrSclZ; // Insert values result.SetRow0(row0.X(), row0.Y(), row0.Z(), invPosition.X()); result.SetRow1(row1.X(), row1.Y(), row1.Z(), invPosition.Y()); result.SetRow2(row2.X(), row2.Y(), row2.Z(), invPosition.Z()); result.SetRow3( 0.0f, 0.0f, 0.0f, 1.0f); return result; }
//---------------------------------------------------------------------- void CondProbTableTest::RunTests() { // Our 4 rows vector<vector<Real> > rows; rows.resize(numRows()); rows[0] = makeRow((Real)0.0, (Real)0.4, (Real)0.0); rows[1] = makeRow((Real)1.0, (Real)0.0, (Real)0.0); rows[2] = makeRow((Real)0.0, (Real)0.0, (Real)0.6); rows[3] = makeRow((Real)0.0, (Real)0.6, (Real)0.4); // Test constructing without # of columns { CondProbTable table; // Add the 4 rows for (Size i=0; i<numRows(); i++) table.updateRow((UInt)i, rows[i]); // Test it testTable ("Dynamic columns:", table, rows); } // Test constructing and growing the columns dynamically { CondProbTable table; // Add the 2nd row first which has just 1 column vector<Real> row1(1); row1[0] = rows[1][0]; table.updateRow(1, row1); // Add the first row first with just 2 columns vector<Real> row0(2); row0[0] = rows[0][0]; row0[1] = rows[0][1]; table.updateRow(0, row0); for (Size i=2; i<numRows(); i++) table.updateRow((UInt)i, rows[i]); // Test it testTable ("Growing columns:", table, rows); } // Make a table with 3 columns { CondProbTable table((UInt)numCols()); // Add the 4 rows for (Size i=0; i<numRows(); i++) table.updateRow((UInt)i, rows[i]); // Test it testTable ("Fixed columns:", table, rows); } // Make a table, save to stream, then reload and test { CondProbTable table((UInt)numCols()); // Add the 4 rows for (Size i=0; i<numRows(); i++) table.updateRow((UInt)i, rows[i]); // Save it stringstream state; table.saveState (state); CondProbTable newTable; newTable.readState (state); testTable ("Restored from state:", newTable, rows); } // Test saving an empty table { CondProbTable table; // Save it stringstream state; table.saveState (state); // Read it in CondProbTable newTable; newTable.readState (state); // Add the 4 rows for (Size i=0; i<numRows(); i++) newTable.updateRow((UInt)i, rows[i]); // Test it testTable ("Restored from empty state:", newTable, rows); } }
void AglMatrix::matrixToComponents(AglMatrix pMatrix, AglVector3& pScale, AglQuaternion& pQuaternion, AglVector3& pTranslation) { // http://software.intel.com/sites/default/files/m/d/4/1/d/8/293748.pdf // Real-Time Rendering //Scale AglVector3 row0(pMatrix[0], pMatrix[1], pMatrix[2]); AglVector3 row1(pMatrix[4], pMatrix[5], pMatrix[6]); AglVector3 row2(pMatrix[8], pMatrix[9], pMatrix[10]); float lrow0 = AglVector3::length(row0); float lrow1 = AglVector3::length(row1); float lrow2 = AglVector3::length(row2); pScale[0] = lrow0; pScale[1] = lrow1; pScale[2] = lrow2; row0 *= (1/lrow0); row1 *= (1/lrow1); row2 *= (1/lrow2); //Translation pTranslation[0] = pMatrix[12]; pTranslation[1] = pMatrix[13]; pTranslation[2] = pMatrix[14]; //Rotation //Find the largest factor. float qx, qy, qz, qw; if (row0[0] + row1[1] + row2[2] > 0.0f) //Use w { float t = row0[0] + row1[1] + row2[2] + pMatrix[15]; float s = 0.5f / sqrt(t); qw = s * t; qz = (row0[1] - row1[0]) * s; qy = (row2[0] - row0[2]) * s; qx = (row1[2] - row2[1]) * s; } else if (row0[0] > row1[1] && row0[0] > row2[2]) //Use x { float t = row0[0] - row1[1] - row2[2] + pMatrix[15]; float s = 0.5f / sqrt(t); qx = s * t; qy = (row0[1] + row1[0]) * s; qz = (row2[0] + row0[2]) * s; qw = (row1[2] - row2[1]) * s; } else if (row1[1] > row2[2]) //Use y { float t = -row0[0] + row1[1] - row2[2] + pMatrix[15]; float s = 0.5f / sqrt(t); qy = s * t; qx = (row0[1] + row1[0]) * s; qw = (row2[0] - row0[2]) * s; qz = (row1[2] + row2[1]) * s; } else //Use z { float t = -row0[0] - row1[1] + row2[2] + pMatrix[15]; float s = 0.5f / sqrt(t); qz = s * t; qw = (row0[1] - row1[0]) * s; qx = (row2[0] + row0[2]) * s; qy = (row1[2] + row2[1]) * s; } pQuaternion = AglQuaternion(qx, qy, qz, qw); }