private static void applyLhs( final float w1, final float[][][] wp, final float[][][] p2, final float[][][] p3, final float[][][] x, final float[][][] y) { final int n3 = x.length; Parallel.loop( 1, n3, 2, new Parallel.LoopInt() { // i3 = 1, 3, 5, ... public void compute(int i3) { applyLhsSlice3(i3, w1, wp, p2, p3, x, y); } }); Parallel.loop( 2, n3, 2, new Parallel.LoopInt() { // i3 = 2, 4, 6, ... public void compute(int i3) { applyLhsSlice3(i3, w1, wp, p2, p3, x, y); } }); }
public static void normalizeErrors( float[][][][] e, final float ignoreMin, final float ignoreMax) { final int nl = e[0][0][0].length; final int n1 = e[0][0].length; final int n2 = e[0].length; final int n3 = e.length; final float[][][][] ef = e; MinMax mm = Parallel.reduce( n3, new Parallel.ReduceInt<MinMax>() { public MinMax compute(int i3) { float emin = Float.MAX_VALUE; float emax = -Float.MAX_VALUE; for (int i2 = 0; i2 < n2; ++i2) { for (int i1 = 0; i1 < n1; ++i1) { for (int il = 0; il < nl; ++il) { float ei = ef[i3][i2][i1][il]; if (ei < emin && ei > ignoreMin) emin = ei; if (ei > emax && ei < ignoreMax) emax = ei; } } } return new MinMax(emin, emax); } public MinMax combine(MinMax mm1, MinMax mm2) { return new MinMax(min(mm1.emin, mm2.emin), max(mm1.emax, mm2.emax)); } }); shiftAndScale(mm.emin, mm.emax, e); }
/** * Applies the shifts {@code u} to the trace {@code g}. * * @param sf the sampling that {@code g} is being warped to. * @param u the shifts to apply to {@code g}. * @param sg the sampling of {@code g}. * @param g the trace to be warped. * @return the warped image. */ public static float[][][] applyShifts( Sampling sf, final float[][][] u, Sampling sg, final float[][][] g) { final int n1 = u[0][0].length; final int n2 = u[0].length; final int n3 = u.length; final int ng = g[0][0].length; final double dg = sg.getDelta(); final double df = sf.getDelta(); final double fg = sg.getDelta(); final double ff = sf.getDelta(); final float[][][] hf = new float[n3][n2][n1]; final SincInterp si = new SincInterp(); int n23 = n3 * n2; Parallel.loop( n23, new Parallel.LoopInt() { public void compute(int i23) { int i2 = i23 % n2; int i3 = i23 / n2; double v = ff; for (int i1 = 0; i1 < n1; i1++, v = ff + i1 * df) { hf[i3][i2][i1] = si.interpolate(ng, dg, fg, g[i3][i2], (float) v + u[i3][i2][i1]); } } }); return hf; }
public float[][][][] flattenWithShifts( final Sampling s1, final float[][][] r, final float[][][] f) { cleanShifts(r); final int n3 = r.length; final int n2 = r[0].length; final int n1 = r[0][0].length; // Compute u1(x1,x2,x3). final double f1 = s1.getFirst(); final double d1 = s1.getDelta(); final float[][][] u1 = r; for (int i3 = 0; i3 < n3; ++i3) { for (int i2 = 0; i2 < n2; ++i2) { for (int i1 = 0; i1 < n1; ++i1) { float x1i = (float) (f1 + i1 * d1); u1[i3][i2][i1] = (float) (x1i + r[i3][i2][i1] * d1); } } } // Compute x1(u1,u2). final float[][][] x1 = new float[n3][n2][n1]; final InverseInterpolator ii = new InverseInterpolator(s1, s1); Parallel.loop( n3, new Parallel.LoopInt() { public void compute(int i3) { for (int i2 = 0; i2 < n2; ++i2) ii.invert(u1[i3][i2], x1[i3][i2]); } }); final SincInterpolator si = new SincInterpolator(); final float[][][] g = new float[n3][n2][n1]; Parallel.loop( n3, new Parallel.LoopInt() { public void compute(int i3) { for (int i2 = 0; i2 < n2; ++i2) si.interpolate(n1, d1, f1, f[i3][i2], n1, x1[i3][i2], g[i3][i2]); } }); return new float[][][][] {g, u1}; }
private static void smooth2(final float sigma, final float[][][] s, final float[][][] x) { final int n3 = x.length; Parallel.loop( n3, new Parallel.LoopInt() { public void compute(int i3) { float[][] s3 = (s != null) ? s[i3] : null; float[][] x3 = x[i3]; smooth2(sigma, s3, x3); } }); }
private void removeAverage(final float[][][] x) { final int n1 = x[0][0].length; Parallel.loop( 1, n1, 2, new Parallel.LoopInt() { // i1 = 1, 3, 5, ... public void compute(int i1) { removeAverage(i1, x); } }); Parallel.loop( 2, n1, 2, new Parallel.LoopInt() { // i1 = 2, 4, 6, ... public void compute(int i1) { removeAverage(i1, x); } }); }
/** * Gets mappings computed from specified slopes and planarities. * * @param s1 sampling of 1st dimension. * @param s2 sampling of 2nd dimension. * @param p2 array of slopes of image features. * @param ep array of planarities of image features. */ public Mappings getMappingsFromSlopes( Sampling s1, Sampling s2, Sampling s3, float[][][] p2, float[][][] p3, float[][][] ep) { // Sampling parameters. final int n1 = s1.getCount(); final int n2 = s2.getCount(); final int n3 = s3.getCount(); float d1 = (float) s1.getDelta(); float d2 = (float) s2.getDelta(); float d3 = (float) s3.getDelta(); float f1 = (float) s1.getFirst(); // If necessary, convert units for slopes to samples per sample. if (d1 != d2) p2 = mul(d2 / d1, p2); if (d1 != d3) p3 = mul(d3 / d1, p3); // Compute shifts r(x1,x2,x3), in samples. float[][][] b = new float[n3][n2][n1]; // right-hand side float[][][] r = new float[n3][n2][n1]; // shifts, in samples VecArrayFloat3 vb = new VecArrayFloat3(b); VecArrayFloat3 vr = new VecArrayFloat3(r); Smoother3 smoother3 = new Smoother3(n1, n2, n3, _sigma1, _sigma2, _sigma3, ep); A3 a3 = new A3(smoother3, _weight1, ep, p2, p3); CgSolver cs = new CgSolver(_small, _niter); makeRhs(ep, p2, p3, b); smoother3.applyTranspose(b); cs.solve(a3, vb, vr); smoother3.apply(r); cleanShifts(r); // Compute u1(x1,x2,x3). final float[][][] u1 = r; for (int i3 = 0; i3 < n3; ++i3) { for (int i2 = 0; i2 < n2; ++i2) { for (int i1 = 0; i1 < n1; ++i1) { float x1i = f1 + i1 * d1; u1[i3][i2][i1] = x1i + r[i3][i2][i1] * d1; } } } // Compute x1(u1,u2). final float[][][] x1 = b; final InverseInterpolator ii = new InverseInterpolator(s1, s1); Parallel.loop( n3, new Parallel.LoopInt() { public void compute(int i3) { for (int i2 = 0; i2 < n2; ++i2) ii.invert(u1[i3][i2], x1[i3][i2]); } }); return new Mappings(s1, s2, s3, u1, x1); }
public static float[][] compositeShifts( final Sampling sf, final float[][] u1, final float[][] u2) { int n2 = u1.length; final float[][] uc = new float[n2][]; Parallel.loop( n2, new Parallel.LoopInt() { public void compute(int i2) { uc[i2] = compositeShifts(sf, u1[i2], u2[i2]); } }); return uc; }
@Deprecated public static float[][][] transposeLag23(final float[][][] e) { final int nl = e[0][0].length; final int n1 = e[0].length; final int n2 = e.length; final float[][][] t = new float[n1][n2][nl]; Parallel.loop( n1, new Parallel.LoopInt() { public void compute(int i1) { for (int i2 = 0; i2 < n2; ++i2) t[i1][i2] = e[i2][i1]; } }); return t; }
@Deprecated public static float[][][] transposeLag12(final float[][][] e) { final int nl = e[0][0].length; final int n1 = e[0].length; final int n2 = e.length; final float[][][] t = new float[n2][nl][n1]; Parallel.loop( n2, new Parallel.LoopInt() { public void compute(int i2) { for (int il = 0; il < nl; ++il) for (int i1 = 0; i1 < n1; ++i1) t[i2][il][i1] = e[i2][i1][il]; } }); return t; }
/* * Solves for times by processing samples in the active list in parallel. */ private void solveParallel( final ActiveList al, final float[][][] t, final int m, final float[][][] times, final int[][][] marks) { int mbmin = 64; // target minimum number of samples per block int nbmax = 256; // maximum number of blocks final float[][] dtask = new float[nbmax][]; final ActiveList[] bltask = new ActiveList[nbmax]; while (!al.isEmpty()) { final int n = al.size(); // number of samples in active (A) list final int mbmax = max(mbmin, 1 + (n - 1) / nbmax); // max samples per block final int nb = 1 + (n - 1) / mbmax; // number of blocks <= nbmax final int mb = 1 + (n - 1) / nb; // evenly distribute samples per block Parallel.loop( nb, new Parallel.LoopInt() { // for all blocks, ... public void compute(int ib) { if (bltask[ib] == null) { // if necessary for this block, make ... dtask[ib] = new float[6]; // work array for tensor coefficients bltask[ib] = new ActiveList(); // and an empty active list } int i = ib * mb; // beginning of block int j = min(i + mb, n); // beginning of next block (or end) for (int k = i; k < j; ++k) { // for each sample in block, ... Sample s = al.get(k); // get k'th sample from A list solveOne(t, m, times, marks, s, bltask[ib], dtask[ib]); // do sample } bltask[ib].setAllAbsent(); // needed when merging B lists below } }); // Merge samples from all B lists to a new A list. All samples // in B lists are currently marked as absent in the A list. As // samples in B lists are appended to the A list, their absent // flags are set to false, so that no sample is appended more // than once to the new A list. al.clear(); for (int ib = 0; ib < nb; ++ib) { if (bltask[ib] != null) { al.appendIfAbsent(bltask[ib]); bltask[ib].clear(); } } } }
// Smoothing for dimension 3. private static void smooth3(final float sigma, final float[][][] s, final float[][][] x) { final int n2 = x[0].length; final int n3 = x.length; Parallel.loop( n2, new Parallel.LoopInt() { public void compute(int i2) { float[][] s2 = (s != null) ? new float[n3][] : null; float[][] x2 = new float[n3][]; for (int i3 = 0; i3 < n3; ++i3) { if (s != null) s2[i3] = s[i3][i2]; x2[i3] = x[i3][i2]; } smooth2(sigma, s2, x2); } }); }
private float[][][] apply(final float[][][] ux, final float[][][] f) { final int n1 = s1.getCount(); final int n2 = s2.getCount(); final int n3 = s3.getCount(); final double d1 = s1.getDelta(); final double f1 = s1.getFirst(); final SincInterpolator si = new SincInterpolator(); final float[][][] g = new float[n3][n2][n1]; Parallel.loop( n3, new Parallel.LoopInt() { public void compute(int i3) { for (int i2 = 0; i2 < n2; ++i2) si.interpolate(n1, d1, f1, f[i3][i2], n1, ux[i3][i2], g[i3][i2]); } }); return g; }
/** * Computes the NRMS value of the warped PS trace {@code h} and the PP trace {@code f}. The NRMS * value is the RMS of the difference between {@code f} and {@code h} divided by the average RMS * of {@code f} and {@code h}. * * @param n1Max the length of {@code f} and {@code h} to use for this computation. * @param f the PP traces. * @param h the warped PS traces. * @return the NRMS value, this measure is between 0.0 and 2.0. */ public static float computeNrms(final int n1Max, final float[][][] f, final float[][][] h) { int n1f = f[0][0].length; int n1h = h[0][0].length; Check.argument(n1Max <= n1f, "n1Max<=n1f"); Check.argument(n1Max <= n1h, "n1Max<=n1h"); final int n3 = f.length; final int n2 = f[0].length; final int n23 = n2 * n3; float scale = 1.0f / (n1Max * n23); float[] rms = Parallel.reduce( n23, new Parallel.ReduceInt<float[]>() { @Override public float[] compute(int i23) { int i2 = i23 % n2; int i3 = i23 / n2; float[] fhdSq = new float[3]; for (int i1 = 0; i1 < n1Max; i1++) { float fv = f[i3][i2][i1]; float hv = h[i3][i2][i1]; fhdSq[0] += fv * fv; fhdSq[1] += hv * hv; fhdSq[2] += (hv - fv) * (hv - fv); } return fhdSq; } @Override public float[] combine(float[] fhdSq1, float[] fhdSq2) { float[] rms = new float[3]; rms[0] = fhdSq1[0] + fhdSq2[0]; rms[1] = fhdSq1[1] + fhdSq2[1]; rms[2] = fhdSq1[2] + fhdSq2[2]; return rms; } }); float frms = sqrt(rms[0] * scale); float hrms = sqrt(rms[1] * scale); float drms = sqrt(rms[2] * scale); float nrms = (2.0f * drms) / (frms + hrms); return nrms; }
public static void normalize(float[][] f, final float nmin, final float nmax) { final int n1 = f[0].length; final int n2 = f.length; final float[][] ff = f; final float vmin = min(f); final float vmax = max(f); final float range = vmax - vmin; final float nrange = nmax - nmin; Parallel.loop( n2, new Parallel.LoopInt() { public void compute(int i2) { for (int i1 = 0; i1 < n1; ++i1) { float vi = ff[i2][i1]; ff[i2][i1] = nrange * (vi - vmin) / range + nmin; } } }); }
private void computeGradientProducts( final float[][][] g1, final float[][][] g2, final float[][][] g3, final float[][][] g11, final float[][][] g12, final float[][][] g13, final float[][][] g22, final float[][][] g23, final float[][][] g33) { final int n1 = g1[0][0].length; final int n2 = g1[0].length; final int n3 = g1.length; Parallel.loop( n3, new Parallel.LoopInt() { public void compute(int i3) { for (int i2 = 0; i2 < n2; ++i2) { float[] g1i = g1[i3][i2]; float[] g2i = g2[i3][i2]; float[] g3i = g3[i3][i2]; float[] g11i = g11[i3][i2]; float[] g12i = g12[i3][i2]; float[] g13i = g13[i3][i2]; float[] g22i = g22[i3][i2]; float[] g23i = g23[i3][i2]; float[] g33i = g33[i3][i2]; for (int i1 = 0; i1 < n1; ++i1) { float g1ii = g1i[i1]; float g2ii = g2i[i1]; float g3ii = g3i[i1]; g11i[i1] = g1ii * g1ii; g22i[i1] = g2ii * g2ii; g33i[i1] = g3ii * g3ii; g12i[i1] = g1ii * g2ii; g13i[i1] = g1ii * g3ii; g23i[i1] = g2ii * g3ii; } } } }); }
/** * Shifts and scales alignment errors to be in range [0,1]. * * @param emin minimum alignment error before normalizing. * @param emax maximum alignment error before normalizing. * @param e input/output array of alignment errors. */ private static void shiftAndScale(float emin, float emax, float[][][] e) { // System.out.println("shiftAndScale: emin="+emin+" emax="+emax); final int nl = e[0][0].length; final int n1 = e[0].length; final int n2 = e.length; final float eshift = emin; final float escale = (emax > emin) ? 1.0f / (emax - emin) : 1.0f; final float[][][] ef = e; Parallel.loop( n2, new Parallel.LoopInt() { public void compute(int i2) { for (int i1 = 0; i1 < n1; ++i1) { for (int il = 0; il < nl; ++il) { ef[i2][i1][il] = (ef[i2][i1][il] - eshift) * escale; } } } }); }
public float[][][] findScreenPoints( final float smin, final float[][][] ss, final float[][][] u1, final float[][][] u2, final float[][][] u3) { final int n3 = ss.length; final int n2 = ss[0].length; final int n1 = ss[0][0].length; final Sampling s1 = new Sampling(n1); final Sampling s2 = new Sampling(n2); final Sampling s3 = new Sampling(n3); final float[][][] mk = new float[n3][n2][n1]; final SincInterpolator si = new SincInterpolator(); si.setExtrapolation(SincInterpolator.Extrapolation.CONSTANT); Parallel.loop( 1, n3 - 1, new Parallel.LoopInt() { public void compute(int i3) { for (int i2 = 1; i2 < n2 - 1; ++i2) { for (int i1 = 1; i1 < n1 - 1; ++i1) { float sxi = ss[i3][i2][i1]; float u1i = u1[i3][i2][i1] * 2f; float u2i = u2[i3][i2][i1] * 2f; float u3i = u3[i3][i2][i1] * 2f; float x1m = i1 - u1i; float x2m = i2 - u2i; float x3m = i3 - u3i; float x1p = i1 + u1i; float x2p = i2 + u2i; float x3p = i3 + u3i; float sxm = si.interpolate(s1, s2, s3, ss, x1m, x2m, x3m); float sxp = si.interpolate(s1, s2, s3, ss, x1p, x2p, x3p); if (sxi > sxm && sxi > sxp && sxi > smin) mk[i3][i2][i1] = sxi; } } } }); return mk; }
public float[][][] scalarFieldM( final int n1, final int n2, final int n3, final FaultCell[] fc, final float[][][] fp, final float[][][] ft) { final int d2 = 10; final int d3 = 10; final int d1 = 10; // final float v = -1.f; final float v = 0.0f; float sigmaNor = 4.0f; float sigmaPhi = 10.0f; float sigmaTheta = 20.0f; final float sw = 1.0f / (sigmaNor * sigmaNor); final float sv = 1.0f / (sigmaPhi * sigmaPhi); final float su = 1.0f / (sigmaTheta * sigmaTheta); int nc = fc.length; final float[] wp = new float[nc]; final float[][] xf = new float[3][nc]; final float[][] xs = new float[nc][3]; final float[][] ws = new float[nc][6]; final float[][] us = new float[nc][6]; final float[][] vs = new float[nc][6]; setKdTreePointsM(fc, xf, xs, ws, us, vs, wp); final int[] bs1 = setBounds(n1, xf[0]); final int[] bs2 = setBounds(n2, xf[1]); final int[] bs3 = setBounds(n3, xf[2]); final KdTree kt = new KdTree(xf); final float[][][] sf = fillfloat(v, n1, n2, n3); final float[][][] fpp = copy(fp); final float[][][] ftp = copy(ft); Parallel.loop( bs3[0], bs3[1], 1, new Parallel.LoopInt() { public void compute(int i3) { float[] xmin = new float[3]; float[] xmax = new float[3]; System.out.println("i3=" + i3); for (int i2 = bs2[0]; i2 < bs2[1]; ++i2) { for (int i1 = bs1[0]; i1 < bs1[1]; ++i1) { float[] y = new float[] {i1, i2, i3}; int ne = kt.findNearest(y); float x1 = xf[0][ne]; float x2 = xf[1][ne]; float x3 = xf[2][ne]; float dd = distance(new float[] {x1, x2, x3}, y); if (dd > 50.0f) { continue; } getRange(d1, d2, d3, i1, i2, i3, n1, n2, n3, xmin, xmax); int[] id = kt.findInRange(xmin, xmax); int nd = id.length; if (nd < 1) { continue; } sf[i3][i2][i1] = 0.0f; float wps = 0.0f; float fpa = 0.0f; float fta = 0.0f; float fps = 0.0f; float fts = 0.0f; for (int ik = 0; ik < nd; ++ik) { int ip = id[ik]; float wpi = pow(wp[ip], 8.0f); float w1s = ws[ip][0]; float w2s = ws[ip][1]; float w3s = ws[ip][2]; float w12 = ws[ip][3]; float w13 = ws[ip][4]; float w23 = ws[ip][5]; float u1s = us[ip][0]; float u2s = us[ip][1]; float u3s = us[ip][2]; float u12 = us[ip][3]; float u13 = us[ip][4]; float u23 = us[ip][5]; float v1s = vs[ip][0]; float v2s = vs[ip][1]; float v3s = vs[ip][2]; float v12 = vs[ip][3]; float v13 = vs[ip][4]; float v23 = vs[ip][5]; float dx1 = i1 - xs[ip][0]; float dx2 = i2 - xs[ip][1]; float dx3 = i3 - xs[ip][2]; float d11 = dx1 * dx1; float d12 = dx1 * dx2; float d13 = dx1 * dx3; float d22 = dx2 * dx2; float d23 = dx2 * dx3; float d33 = dx3 * dx3; float g11 = w1s * d11 + w12 * d12 + w13 * d13; float g12 = u1s * d11 + u12 * d12 + u13 * d13; float g13 = v1s * d11 + v12 * d12 + v13 * d13; float g21 = w12 * d12 + w2s * d22 + w23 * d23; float g22 = u12 * d12 + u2s * d22 + u23 * d23; float g23 = v12 * d12 + v2s * d22 + v23 * d23; float g31 = w13 * d13 + w23 * d23 + w3s * d33; float g32 = u13 * d13 + u23 * d23 + u3s * d33; float g33 = v13 * d13 + v23 * d23 + v3s * d33; float gss = 0.0f; gss += (g11 + g21 + g31) * sw; gss += (g12 + g22 + g32) * su; gss += (g13 + g23 + g33) * sv; float sfi = exp(-gss) * wpi; sf[i3][i2][i1] += sfi; int j1 = fc[ip].i1; int j2 = fc[ip].i2; int j3 = fc[ip].i3; int k1 = fc[ne].i1; int k2 = fc[ne].i2; int k3 = fc[ne].i3; float fpr = fpp[k3][k2][k1]; float fpi = fpp[j3][j2][j1]; if (abs(fpr - fpi) <= 30) { fps += sfi; fpa += fpp[j3][j2][j1] * sfi; } fts += sfi; fta += ftp[j3][j2][j1] * sfi; wps += wpi; } ft[i3][i2][i1] = fta / fts; fp[i3][i2][i1] = fpa / fps; sf[i3][i2][i1] /= wps; } } } }); return sf; }
private void solveEigenproblems( final float[][][] g11, final float[][][] g12, final float[][][] g13, final float[][][] g22, final float[][][] g23, final float[][][] g33, final float[][][] theta, final float[][][] phi, final float[][][] u1, final float[][][] u2, final float[][][] u3, final float[][][] v1, final float[][][] v2, final float[][][] v3, final float[][][] w1, final float[][][] w2, final float[][][] w3, final float[][][] eu, final float[][][] ev, final float[][][] ew, final float[][][] ep, final float[][][] el) { final int n1 = g11[0][0].length; final int n2 = g11[0].length; final int n3 = g11.length; Parallel.loop( n3, new Parallel.LoopInt() { public void compute(int i3) { double[][] a = new double[3][3]; double[][] z = new double[3][3]; double[] e = new double[3]; for (int i2 = 0; i2 < n2; ++i2) { for (int i1 = 0; i1 < n1; ++i1) { a[0][0] = g11[i3][i2][i1]; a[0][1] = g12[i3][i2][i1]; a[0][2] = g13[i3][i2][i1]; a[1][0] = g12[i3][i2][i1]; a[1][1] = g22[i3][i2][i1]; a[1][2] = g23[i3][i2][i1]; a[2][0] = g13[i3][i2][i1]; a[2][1] = g23[i3][i2][i1]; a[2][2] = g33[i3][i2][i1]; Eigen.solveSymmetric33(a, z, e); float u1i = (float) z[0][0]; float u2i = (float) z[0][1]; float u3i = (float) z[0][2]; float v1i = (float) z[1][0]; float v2i = (float) z[1][1]; float v3i = (float) z[1][2]; float w1i = (float) z[2][0]; float w2i = (float) z[2][1]; float w3i = (float) z[2][2]; if (u1i < 0.0f) { u1i = -u1i; u2i = -u2i; u3i = -u3i; } if (v2i < 0.0f) { v1i = -v1i; v2i = -v2i; v3i = -v3i; } if (w3i < 0.0f) { w1i = -w1i; w2i = -w2i; w3i = -w3i; } float eui = (float) e[0]; float evi = (float) e[1]; float ewi = (float) e[2]; if (ewi < 0.0f) ewi = 0.0f; if (evi < ewi) evi = ewi; if (eui < evi) eui = evi; if (theta != null) theta[i3][i2][i1] = acos(u1i); if (phi != null) phi[i3][i2][i1] = atan2(u3i, u2i); if (u1 != null) u1[i3][i2][i1] = u1i; if (u2 != null) u2[i3][i2][i1] = u2i; if (u3 != null) u3[i3][i2][i1] = u3i; if (v1 != null) v1[i3][i2][i1] = v1i; if (v2 != null) v2[i3][i2][i1] = v2i; if (v3 != null) v3[i3][i2][i1] = v3i; if (w1 != null) w1[i3][i2][i1] = w1i; if (w2 != null) w2[i3][i2][i1] = w2i; if (w3 != null) w3[i3][i2][i1] = w3i; if (eu != null) eu[i3][i2][i1] = eui; if (ev != null) ev[i3][i2][i1] = evi; if (ew != null) ew[i3][i2][i1] = ewi; if (ep != null || el != null) { float esi = (eui > 0.0f) ? 1.0f / eui : 1.0f; if (ep != null) ep[i3][i2][i1] = (eui - evi) * esi; if (el != null) el[i3][i2][i1] = (evi - ewi) * esi; } } } } }); }
public float[][][] scalarField(final int n1, final int n2, final int n3, FaultCell[] fc) { final int d2 = 10; final int d3 = 10; final int d1 = 20; final float v = -1.f; float sigmaNor = 4.0f; float sigmaPhi = 6.0f; float sigmaTheta = 20.0f; final float sw = 1.0f / (sigmaNor * sigmaNor); final float sv = 1.0f / (sigmaPhi * sigmaPhi); final float su = 1.0f / (sigmaTheta * sigmaTheta); int nc = fc.length; final float[] wp = new float[nc]; final float[][] xf = new float[3][nc]; final float[][] xs = new float[nc][6]; final float[][] ws = new float[nc][6]; final float[][] us = new float[nc][6]; final float[][] vs = new float[nc][6]; setKdTreePoints(fc, xf, xs, ws, us, vs, wp); final int[] bs1 = setBounds(n1, xf[0]); final int[] bs2 = setBounds(n2, xf[1]); final int[] bs3 = setBounds(n3, xf[2]); final KdTree kt = new KdTree(xf); final float[][][] sf = fillfloat(v, n1, n2, n3); Parallel.loop( bs3[0], bs3[1], 1, new Parallel.LoopInt() { public void compute(int i3) { float[] xmin = new float[3]; float[] xmax = new float[3]; System.out.println("i3=" + i3); for (int i2 = bs2[0]; i2 < bs2[1]; ++i2) { for (int i1 = bs1[0]; i1 < bs1[1]; ++i1) { float[] y = new float[] {i1, i2, i3}; int ne = kt.findNearest(y); float x1 = xf[0][ne]; float x2 = xf[1][ne]; float x3 = xf[2][ne]; float dd = distance(new float[] {x1, x2, x3}, y); if (dd > 16.0f) { continue; } getRange(d1, d2, d3, i1, i2, i3, n1, n2, n3, xmin, xmax); int[] id = kt.findInRange(xmin, xmax); int nd = id.length; if (nd < 50) { continue; } sf[i3][i2][i1] = 0.0f; float wps = 0.0f; for (int ik = 0; ik < nd; ++ik) { int ip = id[ik]; float wpi = pow(wp[ip], 8.0f); float w1s = ws[ip][0]; float w2s = ws[ip][1]; float w3s = ws[ip][2]; float w12 = ws[ip][3]; float w13 = ws[ip][4]; float w23 = ws[ip][5]; float u1s = us[ip][0]; float u2s = us[ip][1]; float u3s = us[ip][2]; float u12 = us[ip][3]; float u13 = us[ip][4]; float u23 = us[ip][5]; float v1s = vs[ip][0]; float v2s = vs[ip][1]; float v3s = vs[ip][2]; float v12 = vs[ip][3]; float v13 = vs[ip][4]; float v23 = vs[ip][5]; float x1m = i1 - xs[ip][0]; float x2m = i2 - xs[ip][1]; float x3m = i3 - xs[ip][2]; float x1p = i1 - xs[ip][3]; float x2p = i2 - xs[ip][4]; float x3p = i3 - xs[ip][5]; float x1sm = x1m * x1m; float x2sm = x2m * x2m; float x3sm = x3m * x3m; float x12m = x1m * x2m; float x13m = x1m * x3m; float x23m = x2m * x3m; float x1sp = x1p * x1p; float x2sp = x2p * x2p; float x3sp = x3p * x3p; float x12p = x1p * x2p; float x13p = x1p * x3p; float x23p = x2p * x3p; float g11m = w1s * x1sm + w12 * x12m + w13 * x13m; float g12m = u1s * x1sm + u12 * x12m + u13 * x13m; float g13m = v1s * x1sm + v12 * x12m + v13 * x13m; float g21m = w12 * x12m + w2s * x2sm + w23 * x23m; float g22m = u12 * x12m + u2s * x2sm + u23 * x23m; float g23m = v12 * x12m + v2s * x2sm + v23 * x23m; float g31m = w13 * x13m + w23 * x23m + w3s * x3sm; float g32m = u13 * x13m + u23 * x23m + u3s * x3sm; float g33m = v13 * x13m + v23 * x23m + v3s * x3sm; float g11p = w1s * x1sp + w12 * x12p + w13 * x13p; float g12p = u1s * x1sp + u12 * x12p + u13 * x13p; float g13p = v1s * x1sp + v12 * x12p + v13 * x13p; float g21p = w12 * x12p + w2s * x2sp + w23 * x23p; float g22p = u12 * x12p + u2s * x2sp + u23 * x23p; float g23p = v12 * x12p + v2s * x2sp + v23 * x23p; float g31p = w13 * x13p + w23 * x23p + w3s * x3sp; float g32p = u13 * x13p + u23 * x23p + u3s * x3sp; float g33p = v13 * x13p + v23 * x23p + v3s * x3sp; float gssm = (g11m + g21m + g31m) * sw + (g12m + g22m + g32m) * su + (g13m + g23m + g33m) * sv; float gssp = (g11p + g21p + g31p) * sw + (g12p + g22p + g32p) * su + (g13p + g23p + g33p) * sv; sf[i3][i2][i1] += (exp(-gssp) - exp(-gssm)) * wpi; wps += wpi; } sf[i3][i2][i1] /= wps; } } } }); return sf; }