public NishitaInterp(Nishita skyColor, double h0, double directLight, double ambiantLight, double maxDist, double latRadMin, double latRadMax, int numLat, double lonRadMin, double lonRadMax, int numLon) { this.skyColor = skyColor; this.h0 = h0; this.directLight = directLight; this.ambientLight = ambiantLight; this.maxDist = maxDist; this.latRadMin = latRadMin; this.latRadMax = latRadMax; this.numLat = numLat; this.lonRadMin = lonRadMin < lonRadMax ? lonRadMin : lonRadMax; this.lonRadMax = lonRadMax > lonRadMin ? lonRadMax : lonRadMin; this.numLon = numLon; this.intType = InterpolatonType.Linear; // Fixup if (this.lonRadMin < 0.0) { this.lonRadMin = 0.0; } inters = new Lazy <TwoDInterpolator[]>(() => GetInters()); aerialPers = new Lazy <AerialPers>(() => GetAerialPers()); }
public TwoDInterpolator(double[] xs, double[] ys, double[][] values, InterpolatonType type) { this.type = type; this.xs = xs; this.ys = ys; if (type == InterpolatonType.Nearest) { this.rawValues = values; if (xs[0] > xs[1]) { xsReversed = true; this.xs = xs.Reverse().ToArray(); } if (ys[0] > ys[1]) { ysReversed = true; this.ys = ys.Reverse().ToArray(); } } else { this.values = new OneDInterpolator[xs.Length]; for (int j = 0; j < xs.Length; j++) { this.values[j] = new OneDInterpolator(ys, values[j], type); } } }
/// <summary> /// Given arrays x[0..n-1] and y[0..n-1] containing a tabulated function, i.e., y[i] = f(x[i]), with /// x sorted, this routine returns an array y2[1..n] that contains /// the second derivatives of the interpolating function at the tabulated points xi.The /// routine is signaled to set the corresponding boundary /// condition for a natural spline, with zero second derivative on that boundary. /// </summary> public OneDInterpolator(double[] x, double[] y, InterpolatonType type) { this.type = type; if (x[0] < x[x.Length - 1]) { xa = x.ToArray(); ya = y.ToArray(); } else { xa = x.Reverse().ToArray(); ya = y.Reverse().ToArray(); } n = xa.Length; delta = Math.Abs(xa[0] - xa[n - 1]) / n; switch (type) { case InterpolatonType.Linear: // Nothing more to do break; case InterpolatonType.Cubic: y2a = new double[n]; // The boundary conditions are set to be “natural” y2a[1] = 0.0; var u = new double[n]; var qn = 0.0; var un = 0.0; for (int i = 1; i <= n - 2; i++) { // This is the decomposition loop of the tridiagonal algorithm. // y2 and u are used for temporary storage of the decomposed factors. var sig = (xa[i] - xa[i - 1]) / (xa[i + 1] - xa[i - 1]); var p = sig * y2a[i - 1] + 2; y2a[i] = (sig - 1) / p; u[i] = (ya[i + 1] - ya[i + 0]) / (xa[i + 1] - xa[i + 0]) - (ya[i + 0] - ya[i - 1]) / (xa[i + 0] - xa[i - 1]); u[i] = (6 * u[i] / (xa[i + 1] - xa[i - 1]) - sig * u[i - 1]) / p; } y2a[n - 1] = (un - qn * u[n - 2]) / (qn * y2a[n - 2] + 1); for (int k = n - 2; k >= 0; k--) { // This is the backsubstitution loop of the tridiagonal algorithm. y2a[k] = y2a[k] * y2a[k + 1] + u[k]; } break; default: throw new ArgumentOutOfRangeException("type"); } }
private InterpolatingChunk <T> ComputeInterpolation( Angle latLo, Angle lonLo, Angle latHi, Angle lonHi, Func <T, double>[] toDouble, Func <double[], T> fromDouble, InterpolatonType interpolatonType) { int iLo = GetLatIndex(latLo) - 2; int iHi = GetLatIndex(latHi) + 2; iLo = iLo < 0 ? 0 : iLo >= LatSteps ? LatSteps - 1 : iLo; iHi = iHi < 0 ? 0 : iHi >= LatSteps ? LatSteps - 1 : iHi; double areaLatLo = GetLat(iLo).DecimalDegree; double areaLatHi = GetLat(iHi).DecimalDegree; int jLo = GetLonIndex(lonHi) - 2; int jHi = GetLonIndex(lonLo) + 2; jLo = jLo < 0 ? 0 : jLo >= LonSteps ? LonSteps - 1 : jLo; jHi = jHi < 0 ? 0 : jHi >= LonSteps ? LonSteps - 1 : jHi; double areaLonLo = GetLon(jHi).DecimalDegree; double areaLonHi = GetLon(jLo).DecimalDegree; double[] lats = new double[iHi - iLo + 1]; for (int i = 0; i < lats.Length; i++) { lats[i] = areaLatLo + i * (areaLatHi - areaLatLo) / (iHi - iLo); } double[] lons = new double[jHi - jLo + 1]; for (int i = 0; i < lons.Length; i++) { lons[i] = areaLonHi + i * (areaLonLo - areaLonHi) / (jHi - jLo); } double[][][] values = new double[toDouble.Length][][]; for (int k = 0; k < toDouble.Length; k++) { values[k] = new double[lats.Length][]; for (int i = 0; i < lats.Length; i++) { values[k][i] = new double[lons.Length]; for (int j = 0; j < lons.Length; j++) { values[k][i][j] = toDouble[k](Data[iLo + i][jLo + j]); } } } return(new InterpolatingChunk <T>(lats, lons, values, fromDouble, interpolatonType)); }
public OneDVectorInterpolator(double[] x, double[][] y, InterpolatonType type) { componentInterp = new OneDInterpolator[y[0].Length]; var tempY = new double[y.Length]; for (int i = 0; i < componentInterp.Length; i++) { for (int j = 0; j < y.Length; j++) { tempY[j] = y[j][i]; } componentInterp[i] = new OneDInterpolator(x, tempY, type); } }
public InterpolatingChunk( double[] lats, double[] lons, double[][][] values, Func <double[], T> fromDouble, InterpolatonType interpolatonType) { this.latLo = lats.Min(); this.lonLo = lons.Min(); this.latHi = lats.Max(); this.lonHi = lons.Max(); this.fromDouble = fromDouble; this.interp = new TwoDInterpolator[values.Length]; for (int i = 0; i < values.Length; i++) { this.interp[i] = new TwoDInterpolator(lats, lons, values[i], interpolatonType); } }
public AerialPers(int numDists, double maxDist, double h0, Nishita skyColor, InterpolatonType intType) { double[] dists = new double[numDists]; for (int x = 0; x < numDists; x++) { dists[x] = maxDist * x / (numDists + -1); } double[][] values = new double[numDists][]; for (int k = 0; k < values.Length; k++) { values[k] = new double[12]; } for (int x = 0; x < dists.Length; x++) { skyColor.SkyColorAtPointComputer( h0, dists[x], out MyDColor attenuation, out MyDColor airColorR, out MyDColor airColorM, out MyDColor directPart); for (int k = 0; k < 3; k++) { values[x][0] = attenuation.R; values[x][1] = attenuation.G; values[x][2] = attenuation.B; values[x][3] = airColorR.R; values[x][4] = airColorR.G; values[x][5] = airColorR.B; values[x][6] = airColorM.R; values[x][7] = airColorM.G; values[x][8] = airColorM.B; values[x][9] = directPart.R; values[x][10] = directPart.G; values[x][11] = directPart.B; } } inters = new OneDVectorInterpolator(dists, values, intType); }
public InterpolatingChunk <T> GetInterpolator(InterpolatonType interpolatonType) { return(ComputeInterpolation(LatLo, LonLo, LatHi, LonHi, toDouble, fromDouble, interpolatonType)); }