Example #1
0
void two_phase_3d_op_explicit(double phi[M][N][P],
			      const double u0[M][N][P],
			      double curvature_motion_part[M][N][P],
			      double dt, double c1, double c2)
{
	double mu = TP_MU;
	double nu = TP_NU;
	double lambda1 = TP_LAMBDA1;
	double lambda2 = TP_LAMBDA2;

	double dx = 1.0;
	double dy = 1.0;
	double dz = 1.0;

	double dx2 = dx * 2.0;
	double dy2 = dy * 2.0;
	double dz2 = dz * 2.0;

	double Dx_p, Dx_m;
	double Dy_p, Dy_m;
	double Dz_p, Dz_m;
	double Dx_0, Dy_0, Dz_0;

	double Dxx, Dyy, Dzz;
	double Dxy, Dxz, Dyz;

	double Grad, K;

	double stencil[3][3][3];
#pragma AP array_partition variable=stencil complete dim=0

	double numer, denom;

	uint32_t i, j, k, l;

	for (i = 1; i < M - 1; i++) {
		for (j = 1; j < N - 1; j++) {
			for (k = 1; k < P - 1; k++) {
#pragma AP pipeline
				/* stencil code */
				stencil[0][0][0] = stencil[0][0][1];
				stencil[0][1][0] = stencil[0][1][1];
				stencil[0][2][0] = stencil[0][2][1];

				stencil[0][0][1] = stencil[0][0][2];
				stencil[0][1][1] = stencil[0][1][2];
				stencil[0][2][1] = stencil[0][2][2];

				stencil[0][0][2] = PHI(i - 1, j - 1, k + 1);
				stencil[0][1][2] = PHI(i - 1, j, k + 1);
				stencil[0][2][2] = PHI(i - 1, j + 1, k + 1);

				stencil[1][0][0] = stencil[1][0][1];
				stencil[1][1][0] = stencil[1][2][1];
				stencil[1][2][0] = stencil[1][2][1];

				stencil[1][0][1] = stencil[1][0][2];
				stencil[1][1][1] = stencil[1][1][2];
				stencil[1][2][1] = stencil[1][2][2];

				stencil[1][0][2] = PHI(i, j - 1, k + 1);
				stencil[1][1][2] = PHI(i, j, k + 1);
				stencil[1][2][2] = PHI(i, j + 1, k + 1);

				stencil[2][0][0] = stencil[2][0][1];
				stencil[2][1][0] = stencil[2][1][1];
				stencil[2][2][0] = stencil[2][2][1];

				stencil[2][0][1] = stencil[2][0][2];
				stencil[2][1][1] = stencil[2][1][2];
				stencil[2][2][1] = stencil[2][2][2];

				stencil[2][0][2] = PHI(i + 1, j - 1, k + 1);
				stencil[2][1][2] = PHI(i + 1, j, k + 1);
				stencil[2][2][2] = PHI(i + 1, j + 1, k + 1);

				/* regular calculation here */
				Dx_p =
				    (stencil[2][1][1] - stencil[1][1][1]) / dx;
				Dx_m =
				    (stencil[1][1][1] - stencil[0][1][1]) / dx;
				Dy_p =
				    (stencil[1][2][1] - stencil[1][1][1]) / dy;
				Dy_m =
				    (stencil[1][1][1] - stencil[1][0][1]) / dy;
				Dz_p =
				    (stencil[1][1][2] - stencil[1][1][1]) / dz;
				Dz_m =
				    (stencil[1][1][1] - stencil[1][1][0]) / dz;

				Dx_0 =
				    (stencil[2][1][1] - stencil[0][1][1]) / dx2;
				Dy_0 =
				    (stencil[1][2][1] - stencil[1][0][1]) / dy2;
				Dz_0 =
				    (stencil[1][1][2] - stencil[1][1][0]) / dz2;

				Dxx = (Dx_p - Dx_m) / dx;
				Dyy = (Dy_p - Dy_m) / dy;
				Dzz = (Dz_p - Dz_m) / dz;

				Dxy =
				    (stencil[2][2][1] - stencil[2][0][1] -
				     stencil[0][2][1] -
				     stencil[0][0][1]) / (4 * dx * dy);
				Dxz =
				    (stencil[2][1][2] - stencil[2][1][0] -
				     stencil[0][1][2] +
				     stencil[0][1][0]) / (4 * dx * dz);
				Dyz =
				    (stencil[1][2][2] - stencil[1][2][0] -
				     stencil[1][0][2] +
				     stencil[1][0][0]) / (4 * dy * dz);

				Grad = (SQR(Dx_0) + SQR(Dy_0) + SQR(Dz_0));
				denom = Grad;

				/* denom = denom^1.5 */
				for (l = 0; l < 3; l++) {
#pragma AP unroll
					denom *= denom;
				}
				q3_sqrt(denom);

				numer = (Dx_0 * Dx_0 * Dyy -
					 2.0 * Dx_0 * Dy_0 * Dxy +
					 Dy_0 * Dy_0 * Dxx + Dx_0 * Dx_0 * Dzz -
					 2.0 * Dx_0 * Dz_0 * Dxz +
					 Dz_0 * Dz_0 * Dxx + Dy_0 * Dy_0 * Dzz -
					 2.0 * Dy_0 * Dz_0 * Dyz +
					 Dz_0 * Dz_0 * Dyy);

				K = numer / denom;

				CMP(i, j, k) =
				    Grad * (mu * K +
					    lambda1 * (U0(i, j, k) -
						       c1) * (U0(i, j,
								 k) - c1) -
					    lambda2 * (U0(i, j, k) -
						       c2) * (U0(i, j,
								 k) - c2));
			}
		}
	}

	neumann_bc(curvature_motion_part);

	for (k = 0; k < P; k++) {
		for (j = 0; j < N; j++) {
			for (i = 0; i < M; i++) {
#pragma AP pipeline
				PHI(i, j, k) += CMP(i, j, k) * dt;
			}
		}
	}
}
/**
  *
  * Compute the bicubic interpolation of a point in an image.
  * Detect if the point goes outside the image domain.
  *
**/
static float bicubic_interpolation_at(
	const float *input, //image to be interpolated
	const float  uu,    //x component of the vector field
	const float  vv,    //y component of the vector field
	const int    nx,    //image width
	const int    ny,    //image height
	bool         border_out //if true, return zero outside the region
)
{
	const int boundary_condition = DEFAULT_BICUBIC_BOUNDARY_CONDITION;
	const int sx = (uu < 0) ? -1: 1;
	const int sy = (vv < 0) ? -1: 1;

	int x, y, mx, my, dx, dy, ddx, ddy;
	bool out[1] = {false};

	//apply the corresponding boundary conditions
	switch(boundary_condition)
	{
	case BICUBIC_BOUNDARY_NEUMANN:
		x   = neumann_bc((int) uu, nx, out);
		y   = neumann_bc((int) vv, ny, out);
		mx  = neumann_bc((int) uu - sx, nx, out);
		my  = neumann_bc((int) vv - sx, ny, out);
		dx  = neumann_bc((int) uu + sx, nx, out);
		dy  = neumann_bc((int) vv + sy, ny, out);
		ddx = neumann_bc((int) uu + 2*sx, nx, out);
		ddy = neumann_bc((int) vv + 2*sy, ny, out);
		break;

	case BICUBIC_BOUNDARY_PERIODIC:
		x   = periodic_bc((int) uu, nx, out);
		y   = periodic_bc((int) vv, ny, out);
		mx  = periodic_bc((int) uu - sx, nx, out);
		my  = periodic_bc((int) vv - sx, ny, out);
		dx  = periodic_bc((int) uu + sx, nx, out);
		dy  = periodic_bc((int) vv + sy, ny, out);
		ddx = periodic_bc((int) uu + 2*sx, nx, out);
		ddy = periodic_bc((int) vv + 2*sy, ny, out);
		break;

	case BICUBIC_BOUNDARY_SYMMETRIC:
		x   = symmetric_bc((int) uu, nx, out);
		y   = symmetric_bc((int) vv, ny, out);
		mx  = symmetric_bc((int) uu - sx, nx, out);
		my  = symmetric_bc((int) vv - sx, ny, out);
		dx  = symmetric_bc((int) uu + sx, nx, out);
		dy  = symmetric_bc((int) vv + sy, ny, out);
		ddx = symmetric_bc((int) uu + 2*sx, nx, out);
		ddy = symmetric_bc((int) vv + 2*sy, ny, out);
		break;
	}

	if(*out && border_out)
		return 0.0;

	else
	{
		//obtain the interpolation points of the image
		const float p11 = input[mx  + nx * my];
		const float p12 = input[x   + nx * my];
		const float p13 = input[dx  + nx * my];
		const float p14 = input[ddx + nx * my];

		const float p21 = input[mx  + nx * y];
		const float p22 = input[x   + nx * y];
		const float p23 = input[dx  + nx * y];
		const float p24 = input[ddx + nx * y];

		const float p31 = input[mx  + nx * dy];
		const float p32 = input[x   + nx * dy];
		const float p33 = input[dx  + nx * dy];
		const float p34 = input[ddx + nx * dy];

		const float p41 = input[mx  + nx * ddy];
		const float p42 = input[x   + nx * ddy];
		const float p43 = input[dx  + nx * ddy];
		const float p44 = input[ddx + nx * ddy];

		//create array
		double pol[4][4] = {
			{p11, p21, p31, p41},
			{p12, p22, p32, p42},
			{p13, p23, p33, p43},
			{p14, p24, p34, p44}
		};

		//return interpolation
		return bicubic_interpolation_cell(pol, uu-x, vv-y);
	}
}