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);
}
