static void
filter_gabor_kernel_2d (const Matrix22 &filter, const Dual2<float> &w, float a,
const Vec2 &omega, const Dual2<float> &phi,
Dual2<float> &w_f, float &a_f,
Vec2 &omega_f, Dual2<float> &phi_f)
{
// Equation 10
Matrix22 Sigma_f = filter;
Dual2<float> c_G = w;
Vec2 mu_G = omega;
Matrix22 Sigma_G = (a * a / float(M_TWO_PI)) * Matrix22();
float c_F = 1.0f / (float(M_TWO_PI) * sqrtf(determinant(Sigma_f)));
Matrix22 Sigma_F = float(1.0 / (4.0 * M_PI * M_PI)) * Sigma_f.inverse();
Matrix22 Sigma_G_Sigma_F = Sigma_G + Sigma_F;
Dual2<float> c_GF = c_F * c_G
* (1.0f / (float(M_TWO_PI) * sqrtf(determinant(Sigma_G_Sigma_F))))
* expf(-0.5f * dot(Sigma_G_Sigma_F.inverse()*mu_G, mu_G));
Matrix22 Sigma_G_i = Sigma_G.inverse();
Matrix22 Sigma_GF = (Sigma_F.inverse() + Sigma_G_i).inverse();
Vec2 mu_GF;
Matrix22 Sigma_GF_Gi = Sigma_GF * Sigma_G_i;
Sigma_GF_Gi.multMatrix (mu_G, mu_GF);
w_f = c_GF;
a_f = sqrtf(M_TWO_PI * sqrtf(determinant(Sigma_GF)));
omega_f = mu_GF;
phi_f = phi;
}
//-----------------------------------------------------------------------------
Matrix22 Matrix22::AsLeftHanded() const
{
DIA_ASSERT(IsOrthogonal(), "Must be orthogonal");
DIA_ASSERT(IsAxisNormal(), "Axis are not normal");
if (IsLeftHanded())
{
return Matrix22(*this);
}
Vector2D xAxis, yAxis;
XAxis(xAxis);
YAxis(yAxis);
Matrix22 m(yAxis, xAxis);
return m;
}
namespace Common {
Matrix22::Matrix22()
{
memset(m, 0, sizeof(m));
m[0] = 1.0f;
m[3] = 1.0f;
}
Matrix22::Matrix22(float a11, float a12,
float a21, float a22)
{
m[0] = a11;
m[1] = a12;
m[2] = a21;
m[3] = a22;
}
Matrix22 Matrix22::operator*(const Matrix22& rhs) const
{
Matrix22 res;
res.m[0] = m[0] * rhs.m[0] + m[1] * rhs.m[2];
res.m[1] = m[0] * rhs.m[1] + m[1] * rhs.m[3];
res.m[2] = m[2] * rhs.m[0] + m[3] * rhs.m[2];
res.m[3] = m[2] * rhs.m[1] + m[3] * rhs.m[3];
return res;
}
Vector2 Matrix22::operator*(const Vector2& rhs) const
{
Vector2 ret;
ret.x = m[0] * rhs.x + m[1] * rhs.y;
ret.y = m[2] * rhs.x + m[3] * rhs.y;
return ret;
}
Matrix22 Matrix22::operator*(float rhs) const
{
Matrix22 ret(*this);
ret.m[0] *= rhs;
ret.m[1] *= rhs;
ret.m[2] *= rhs;
ret.m[3] *= rhs;
return ret;
}
void Matrix22::operator*=(const Matrix22& rhs)
{
Matrix22 res = *this * rhs;
*this = res;
}
Matrix22 Matrix22::transposed() const
{
Matrix22 ret(*this);
ret.m[1] = m[3];
return ret;
}
void Matrix22::transpose()
{
*this = this->transposed();
}
float Matrix22::determinant() const
{
return m[0] * m[3] - m[1] * m[2];
}
Matrix22 Matrix22::inverse() const
{
float det = determinant();
if(!det) {
throw std::runtime_error("Trying to get the inverse of a 2x2 matrix with a zero determinant");
}
Matrix22 ret;
ret.m[0] = m[3];
ret.m[1] = -m[1];
ret.m[2] = -m[2];
ret.m[3] = m[0];
return ret * det;
}
const Matrix22 Matrix22::Identity = Matrix22(1, 0,
0, 1);
}
Matrix22 Matrix22::operator*(const Matrix22 &right) const
{
return Matrix22(matrix_ops::multiply(2,2,m_matrix,2,2,right.m_matrix));
}
Matrix22 Matrix22::operator*(double x) const
{
return Matrix22(matrix_ops::multiply(2,2,m_matrix,x));
}
Transformation::Transformation():
static_params(Vector2(0, 0), 1),
params(std::make_pair(Vector2(0, 0), Matrix22(1, 0, 0, 1)))
{
}
inline Matrix22 extract_matrix(Params p)
{
return Matrix22(p[2], p[3], p[4], p[5]);
}
