// Derivative-of-Gaussian (gradient) operator.
cv::Mat ImageFilter::DerivativeOfGaussianOperator::operator()(const cv::Mat& img, const std::size_t apertureSize, const double sigma) const
{
const int halfApertureSize = (int)apertureSize / 2;
#if 0
cv::Mat Gx(apertureSize, apertureSize, CV_64F), Gy(apertureSize, apertureSize, CV_64F);
{
//const double sigma2 = sigma * sigma, _2_sigma2 = 2.0 * sigma2, _2_pi_sigma4 = M_PI * _2_sigma2 * sigma2;
const double sigma2 = sigma * sigma, _2_sigma2 = 2.0 * sigma2;
for (int y = -halfApertureSize, yy = 0; y <= halfApertureSize; ++y, ++yy)
for (int x = -halfApertureSize, xx = 0; x <= halfApertureSize; ++x, ++xx)
{
//const double factor = std::exp(-(double(x)*double(x) + double(y)*double(y)) / _2_sigma2) / _2_pi_sigma4;
const double exp = std::exp(-(double(x)*double(x) + double(y)*double(y)) / _2_sigma2);
// TODO [check] >> x- & y-axis derivative.
//Gx.at<double>(yy, xx) = -double(x) * factor;
//Gy.at<double>(yy, xx) = -double(y) * factor;
Gx.at<double>(yy, xx) = -double(x) * exp;
Gy.at<double>(yy, xx) = -double(y) * exp;
}
// Make sure that the sum (or average) of all elements of the kernel has to be zero (similar to the Laplace kernel) so that the convolution result of a homogeneous regions is always zero.
// REF [site] >> http://fourier.eng.hmc.edu/e161/lectures/gradient/node8.html
Gx -= cv::sum(Gx) / ((double)apertureSize * (double)apertureSize);
Gy -= cv::sum(Gy) / ((double)apertureSize * (double)apertureSize);
}
#else
// If a kernel has the same size in x- and y-directions.
cv::Mat Gx(apertureSize, apertureSize, CV_64F);
{
//const double sigma2 = sigma * sigma, _2_sigma2 = 2.0 * sigma2, _2_pi_sigma4 = M_PI * _2_sigma2 * sigma2;
const double sigma2 = sigma * sigma, _2_sigma2 = 2.0 * sigma2;
for (int y = -halfApertureSize, yy = 0; y <= halfApertureSize; ++y, ++yy)
for (int x = -halfApertureSize, xx = 0; x <= halfApertureSize; ++x, ++xx)
{
//Gx.at<double>(yy, xx) = -double(x) * std::exp(-(double(x)*double(x) + double(y)*double(y)) / _2_sigma2) / _2_pi_sigma4;
Gx.at<double>(yy, xx) = -double(x) * std::exp(-(double(x)*double(x) + double(y)*double(y)) / _2_sigma2);
}
// Make sure that the sum (or average) of all elements of the kernel has to be zero (similar to the Laplace kernel) so that the convolution result of a homogeneous regions is always zero.
// REF [site] >> http://fourier.eng.hmc.edu/e161/lectures/gradient/node8.html
Gx -= cv::sum(Gx) / ((double)apertureSize * (double)apertureSize);
}
cv::Mat Gy;
cv::transpose(Gx, Gy);
#endif
cv::Mat Fx, Fy;
cv::filter2D(img, Fx, CV_64F, Gx, cv::Point(-1, -1), 0, cv::BORDER_DEFAULT);
cv::filter2D(img, Fy, CV_64F, Gy, cv::Point(-1, -1), 0, cv::BORDER_DEFAULT);
cv::Mat gradient;
cv::magnitude(Fx, Fy, gradient);
return gradient;
}
Point calculateBSpline(float t, const Point& p1, const Point& p2, const Point& p3, const Point& p4)
{
Point result;
Vec4f T(t*t*t, t*t, t, 1);
Mat4f M(-1, 3, -3, 1,
3, -6, 3, 0,
-3, 0, 3, 0,
1, 4, 1, 0);
Vec4f Gx(p1.x, p2.x, p3.x, p4.x);
Vec4f Gy(p1.y, p2.y, p3.y, p4.y);
result.x = (T*M)*Gx / 6;
result.y = (T*M)*Gy / 6;
return result;
}
/*static*/ void ImageFilter::computeDerivativesOfImage(const cv::Mat& img, const std::size_t apertureSize, const double sigma, cv::Mat& Fx, cv::Mat& Fy, cv::Mat& Fxx, cv::Mat& Fyy, cv::Mat& Fxy)
{
// Compute derivatives wrt xy-coordinate system.
cv::Mat Gx(apertureSize, apertureSize, CV_64F), Gy(apertureSize, apertureSize, CV_64F);
cv::Mat Gxx(apertureSize, apertureSize, CV_64F), Gyy(apertureSize, apertureSize, CV_64F), Gxy(apertureSize, apertureSize, CV_64F);
DerivativesOfGaussian::getFirstOrderDerivatives(apertureSize, sigma, Gx, Gy);
DerivativesOfGaussian::getSecondOrderDerivatives(apertureSize, sigma, Gxx, Gyy, Gxy);
// Make sure that the sum (or average) of all elements of the kernel has to be zero (similar to the Laplace kernel) so that the convolution result of a homogeneous regions is always zero.
// REF [site] >> http://fourier.eng.hmc.edu/e161/lectures/gradient/node8.html
const double kernelArea = (double)apertureSize * (double)apertureSize;
Gx -= cv::sum(Gx) / kernelArea;
Gy -= cv::sum(Gy) / kernelArea;
Gxx -= cv::sum(Gxx) / kernelArea;
Gyy -= cv::sum(Gyy) / kernelArea;
Gxy -= cv::sum(Gxy) / kernelArea;
// Compute Fx, Fy, Fxx, Fyy, Fxy.
cv::filter2D(img, Fx, CV_64F, Gx, cv::Point(-1, -1), 0, cv::BORDER_DEFAULT);
cv::filter2D(img, Fy, CV_64F, Gy, cv::Point(-1, -1), 0, cv::BORDER_DEFAULT);
cv::filter2D(img, Fxx, CV_64F, Gxx, cv::Point(-1, -1), 0, cv::BORDER_DEFAULT);
cv::filter2D(img, Fyy, CV_64F, Gyy, cv::Point(-1, -1), 0, cv::BORDER_DEFAULT);
cv::filter2D(img, Fxy, CV_64F, Gxy, cv::Point(-1, -1), 0, cv::BORDER_DEFAULT);
}
int
PFEMElement2D::update()
{
// get nodal coordinates
double x[3], y[3];
for(int a=0; a<3; a++) {
const Vector& coord = nodes[2*a]->getCrds();
const Vector& disp = nodes[2*a]->getTrialDisp();
x[a] = coord(0) + disp(0);
y[a] = coord(1) + disp(1);
}
// get c and d
double cc[3], dd[3];
cc[0] = y[1]-y[2];
dd[0] = x[2]-x[1];
cc[1] = y[2]-y[0];
dd[1] = x[0]-x[2];
cc[2] = y[0]-y[1];
dd[2] = x[1]-x[0];
// get Jacobi
double J = cc[0]*dd[1]-dd[0]*cc[1];
if(fabs(J)<1e-15) {
opserr<<"WARNING: element area is nearly zero";
opserr<<" -- PFEMElement2D::update\n";
for (int i=0; i<3; i++) {
opserr<<"node "<<ntags[2*i]<<"\n";
opserr<<"x = "<<x[i]<<" , y = "<<y[i]<<"\n";
}
return -1;
}
// get M
M = rho*J*thickness/6.0;
Mp = (kappa<=0? 0.0 : J*thickness/kappa/24.0);
double Mb = 9.*rho*J*thickness/40.0;
// get Km
Km.Zero();
double fact = mu*thickness/(6.*J);
for (int a=0; a<3; a++) {
for (int b=0; b<3; b++) {
Km(2*a,2*b) = fact*(4*cc[a]*cc[b]+3*dd[a]*dd[b]); // Kxx
Km(2*a,2*b+1) = fact*(3*dd[a]*cc[b]-2*cc[a]*dd[b]); // Kxy
Km(2*a+1,2*b) = fact*(3*cc[a]*dd[b]-2*dd[a]*cc[b]); // Kyx
Km(2*a+1,2*b+1) = fact*(3*cc[a]*cc[b]+4*dd[a]*dd[b]); // Kyy
}
}
// get Kb
Matrix Kb(2,2);
fact = 27.*mu*thickness/(40.*J);
double cc2 = 0., dd2 = 0., cd2 = 0.;
for(int a=0; a<3; a++) {
cc2 += cc[a]*cc[a];
dd2 += dd[a]*dd[a];
cd2 += cc[a]*dd[a];
}
Kb(0,0) = fact*(4*cc2+3*dd2); // Kxx
Kb(0,1) = fact*cd2; // Kxy
Kb(1,0) = fact*cd2; // Kyx
Kb(1,1) = fact*(3*cc2+4*dd2); // Kyy
// get Gx and Gy
Gx.Zero(); Gy.Zero();
fact = thickness/6.0;
for (int a=0; a<3; a++) {
Gx(a) = cc[a]*fact;
Gy(a) = dd[a]*fact;
}
// get Gb
Matrix Gb(2,3);
fact = -9.*thickness/40.0;
for (int a=0; a<3; a++) {
Gb(0,a) = cc[a]*fact;
Gb(1,a) = dd[a]*fact;
}
// get S
S.Zero();
if (ops_Dt > 0) {
Kb(0,0) += Mb/ops_Dt;
Kb(1,1) += Mb/ops_Dt;
}
if (Kb(0,0)!=0 && Kb(1,1)!=0) {
this->inverse(Kb);
}
S.addMatrixTripleProduct(0.0, Gb, Kb, 1);
// get F
F.Zero();
fact = rho*J*thickness/6.0;
F(0) = fact*b1;
F(1) = fact*b2;
// get Fb
Vector Fb(2);
fact = 9.*rho*J*thickness/40.;
Fb(0) = fact*b1;
Fb(1) = fact*b2;
// get Fp
Fp.Zero();
Fp.addMatrixTransposeVector(0.0, Gb, Kb*Fb, -1);
return 0;
}
