public static float[] Extract(float[] volume, int3 dimsvolume, int3 centerextract, int3 dimsextract)
{
int3 Origin = new int3(centerextract.X - dimsextract.X / 2,
centerextract.Y - dimsextract.Y / 2,
centerextract.Z - dimsextract.Z / 2);
float[] Extracted = new float[dimsextract.Elements()];
unsafe
{
fixed (float* volumePtr = volume)
fixed (float* ExtractedPtr = Extracted)
for (int z = 0; z < dimsextract.Z; z++)
for (int y = 0; y < dimsextract.Y; y++)
for (int x = 0; x < dimsextract.X; x++)
{
int3 Pos = new int3((Origin.X + x + dimsvolume.X) % dimsvolume.X,
(Origin.Y + y + dimsvolume.Y) % dimsvolume.Y,
(Origin.Z + z + dimsvolume.Z) % dimsvolume.Z);
float Val = volumePtr[(Pos.Z * dimsvolume.Y + Pos.Y) * dimsvolume.X + Pos.X];
ExtractedPtr[(z * dimsextract.Y + y) * dimsextract.X + x] = Val;
}
}
return Extracted;
}
public MainWindow()
{
try
{
Options.DeviceCount = GPU.GetDeviceCount();
if (Options.DeviceCount <= 0)
throw new Exception();
}
catch (Exception)
{
MessageBox.Show("No CUDA devices found, shutting down.");
Close();
}
GPU.MemoryChanged += () => Options.UpdateGPUStats();
DataContext = Options;
Options.PropertyChanged += Options_PropertyChanged;
Closing += MainWindow_Closing;
InitializeComponent();
DisableWhenRunning = new List<UIElement>
{
GridOptionsIO,
GridOptionsPreprocessing,
GridOptionsParticles,
GridOptionsCTF,
GridOptionsMovement,
GridOptionsGrids,
GridOptionsPostprocessing
};
if (File.Exists("Previous.settings"))
Options.Load("Previous.settings");
for (int i = 0; i < GPU.GetDeviceCount(); i++)
{
GPU.SetDevice(i);
Console.WriteLine($"Device {i}:");
Console.WriteLine($"Free memory: {GPU.GetFreeMemory(i)} MB");
Console.WriteLine($"Total memory: {GPU.GetTotalMemory(i)} MB");
}
GPU.SetDevice(0);
Options.UpdateGPUStats();
// Create mockup
{
float2[] SplinePoints = { new float2(0f, 0f), new float2(1f / 3f, 1f)};//, new float2(2f / 3f, 0f)};//, new float2(1f, 1f) };
Cubic1D ReferenceSpline = new Cubic1D(SplinePoints);
Cubic1DShort ShortSpline = Cubic1DShort.GetInterpolator(SplinePoints);
for (float i = -1f; i < 2f; i += 0.01f)
{
float Reference = ReferenceSpline.Interp(i);
float Test = ShortSpline.Interp(i);
if (Math.Abs(Reference - Test) > 1e-6f)
throw new Exception();
}
Random Rnd = new Random(123);
int3 GridDim = new int3(1, 1, 1);
float[] GridValues = new float[GridDim.Elements()];
for (int i = 0; i < GridValues.Length; i++)
GridValues[i] = (float)Rnd.NextDouble();
CubicGrid CGrid = new CubicGrid(GridDim, GridValues);
float[] Managed = CGrid.GetInterpolated(new int3(16, 16, 16), new float3(0, 0, 0));
float[] Native = CGrid.GetInterpolatedNative(new int3(16, 16, 16), new float3(0, 0, 0));
for (int i = 0; i < Managed.Length; i++)
if (Math.Abs(Managed[i] - Native[i]) > 1e-6f)
throw new Exception();
Matrix3 A = new Matrix3(1, 2, 3, 4, 5, 6, 7, 8, 9);
Matrix3 B = new Matrix3(11, 12, 13, 14, 15, 16, 17, 18, 19);
Matrix3 C = A * B;
// Euler matrix
{
Matrix3 E = Matrix3.Euler(0 * Helper.ToRad, 20 * Helper.ToRad, 0 * Helper.ToRad);
float3 EE = Matrix3.EulerFromMatrix(E.Transposed()) * Helper.ToDeg;
float3 Transformed = E * new float3(1, 0, 0);
Transformed.Y = 0;
}
//float3[] HealpixAngles = Helper.GetHealpixAngles(3, "D4");
// Deconvolve reconstructions using a separate CTF
//{
// for (int i = 1; i <= 24; i++)
// {
// Image Map = StageDataLoad.LoadMap($"F:\\stefanribo\\vlion\\warped_{i}.mrc", new int2(1, 1), 0, typeof(float));
// Image MapFT = Map.AsFFT(true);
// Map.Dispose();
// Image CTF = StageDataLoad.LoadMap($"F:\\stefanribo\\vlion\\warped_ctf_{i}.mrc", new int2(1, 1), 0, typeof(float));
// foreach (var slice in CTF.GetHost(Intent.ReadWrite))
// for (int s = 0; s < slice.Length; s++)
// slice[s] = Math.Max(1e-3f, slice[s]);
// MapFT.Divide(CTF);
// Map = MapFT.AsIFFT(true);
// MapFT.Dispose();
// Map.WriteMRC($"F:\\stefanribo\\vlion\\warped_deconv_{i}.mrc");
// Map.Dispose();
// }
//}
//{
// Image SumFT = new Image(new int3(220, 220, 220), true, true);
// Image SumWeights = new Image(new int3(220, 220, 220), true);
// int read = 0;
// foreach (var tomoPath in Directory.EnumerateFiles("F:\\stefanribo\\oridata\\particles", "tomo*.mrc"))
// {
// FileInfo Info = new FileInfo(tomoPath);
// Image Tomo = StageDataLoad.LoadMap(tomoPath, new int2(1, 1), 0, typeof(float));
// Image TomoFT = Tomo.AsFFT(true);
// Tomo.Dispose();
// Image TomoWeights = StageDataLoad.LoadMap("F:\\stefanribo\\oridata\\particlectf\\" + Info.Name, new int2(1, 1), 0, typeof(float));
// TomoFT.Multiply(TomoWeights);
// TomoWeights.Multiply(TomoWeights);
// SumFT.Add(TomoFT);
// SumWeights.Add(TomoWeights);
// TomoFT.Dispose();
// TomoWeights.Dispose();
// Debug.WriteLine(read++);
// }
// foreach (var slice in SumWeights.GetHost(Intent.ReadWrite))
// {
// for (int i = 0; i < slice.Length; i++)
// {
// slice[i] = Math.Max(1e-3f, slice[i]);
// }
// }
// SumFT.Divide(SumWeights);
// Image Sum = SumFT.AsIFFT(true);
// Sum.WriteMRC("F:\\stefanribo\\oridata\\particles\\weightedaverage.mrc");
// SumFT.Dispose();
// SumWeights.Dispose();
// Sum.Dispose();
//}
//{
// Image Subtrahend = StageDataLoad.LoadMap("E:\\martinsried\\stefan\\membranebound\\vlion\\relion_subtrahend.mrc", new int2(1, 1), 0, typeof(float));
// Image SubtrahendFT = Subtrahend.AsFFT(true);
// int read = 0;
// foreach (var tomoPath in Directory.EnumerateFiles("E:\\martinsried\\stefan\\membranebound\\oridata\\particles", "tomo*.mrc"))
// {
// FileInfo Info = new FileInfo(tomoPath);
// Image Tomo = StageDataLoad.LoadMap(tomoPath, new int2(1, 1), 0, typeof(float));
// Image TomoFT = Tomo.AsFFT(true);
// Tomo.Dispose();
// Image TomoWeights = StageDataLoad.LoadMap("E:\\martinsried\\stefan\\membranebound\\oridata\\particlectf\\" + Info.Name, new int2(1, 1), 0, typeof(float));
// Image SubtrahendFTMult = new Image(SubtrahendFT.GetDevice(Intent.Read), SubtrahendFT.Dims, true, true);
// SubtrahendFTMult.Multiply(TomoWeights);
// TomoFT.Subtract(SubtrahendFTMult);
// Tomo = TomoFT.AsIFFT(true);
// Tomo.WriteMRC("D:\\stefanribo\\particles\\" + Info.Name);
// Tomo.Dispose();
// TomoFT.Dispose();
// SubtrahendFTMult.Dispose();
// TomoWeights.Dispose();
// Debug.WriteLine(read++);
// }
//}
//{
// Image SubtRef1 = StageDataLoad.LoadMap("E:\\martinsried\\stefan\\membranebound\\vlion\\warp_subtrahend.mrc", new int2(1, 1), 0, typeof(float));
// Projector Subt = new Projector(SubtRef1, 2);
// SubtRef1.Dispose();
// Image ProjFT = Subt.Project(new int2(220, 220), new[] { new float3(0, 0, 0) }, 110);
// Image Proj = ProjFT.AsIFFT();
// Proj.RemapFromFT();
// Proj.WriteMRC("d_testproj.mrc");
//}
// Projector
/*{
Image MapForProjector = StageDataLoad.LoadMap("E:\\youwei\\run36_half1_class001_unfil.mrc", new int2(1, 1), 0, typeof (float));
Projector Proj = new Projector(MapForProjector, 2);
Image Projected = Proj.Project(new int2(240, 240), new[] { new float3(0, 0, 0) }, 120);
Projected = Projected.AsIFFT();
Projected.RemapFromFT();
Projected.WriteMRC("d_projected.mrc");
}*/
// Backprojector
/*{
Image Dot = new Image(new int3(32, 32, 360));
for (int a = 0; a < 360; a++)
Dot.GetHost(Intent.Write)[a][0] = 1;
Dot = Dot.AsFFT();
Dot.AsAmplitudes().WriteMRC("d_dot.mrc");
Image DotWeights = new Image(new int3(32, 32, 360), true);
for (int a = 0; a < 360; a++)
for (int i = 0; i < DotWeights.ElementsSliceReal; i++)
DotWeights.GetHost(Intent.Write)[a][i] = 1;
float3[] Angles = new float3[360];
for (int a = 0; a < 360; a++)
Angles[a] = new float3(0, a * Helper.ToRad * 0.05f, 0);
Projector Proj = new Projector(new int3(32, 32, 32), 2);
Proj.BackProject(Dot, DotWeights, Angles);
Proj.Weights.WriteMRC("d_weights.mrc");
//Image Re = Proj.Data.AsImaginary();
//Re.WriteMRC("d_projdata.mrc");
Image Rec = Proj.Reconstruct(true);
Rec.WriteMRC("d_rec.mrc");
}*/
//Star Models = new Star("D:\\rado27\\Refine3D\\run1_ct5_it005_half1_model.star", "data_model_group_2");
//Debug.WriteLine(Models.GetRow(0)[0]);
/*Image Volume = StageDataLoad.LoadMap("F:\\carragher20s\\ref256.mrc", new int2(1, 1), 0, typeof (float));
Image VolumePadded = Volume.AsPadded(new int3(512, 512, 512));
VolumePadded.WriteMRC("d_padded.mrc");
Volume.Dispose();
VolumePadded.RemapToFT(true);
Image VolumeFT = VolumePadded.AsFFT(true);
VolumePadded.Dispose();
Image VolumeProjFT = VolumeFT.AsProjections(new[] { new float3(Helper.ToRad * 0, Helper.ToRad * 0, Helper.ToRad * 0) }, new int2(256, 256), 2f);
Image VolumeProj = VolumeProjFT.AsIFFT();
VolumeProjFT.Dispose();
VolumeProj.RemapFromFT();
VolumeProj.WriteMRC("d_proj.mrc");
VolumeProj.Dispose();*/
/*Options.Movies.Add(new Movie(@"D:\Dev\warp\May19_21.44.54.mrc"));
Options.Movies.Add(new Movie(@"D:\Dev\warp\May19_21.49.06.mrc"));
Options.Movies.Add(new Movie(@"D:\Dev\warp\May19_21.50.48.mrc"));
Options.Movies.Add(new Movie(@"D:\Dev\warp\May19_21.52.16.mrc"));
Options.Movies.Add(new Movie(@"D:\Dev\warp\May19_21.53.43.mrc"));
CTFDisplay.PS2D = new BitmapImage();*/
/*float2[] SimCoords = new float2[512 * 512];
for (int y = 0; y < 512; y++)
for (int x = 0; x < 512; x++)
{
int xcoord = x - 512, ycoord = y - 512;
SimCoords[y * 512 + x] = new float2((float) Math.Sqrt(xcoord * xcoord + ycoord * ycoord),
(float) Math.Atan2(ycoord, xcoord));
}
float[] Sim2D = new CTF {Defocus = -2M}.Get2D(SimCoords, 512, true);
byte[] Sim2DBytes = new byte[Sim2D.Length];
for (int i = 0; i < 512 * 512; i++)
Sim2DBytes[i] = (byte) (Sim2D[i] * 255f);
BitmapSource Sim2DSource = BitmapSource.Create(512, 512, 96, 96, PixelFormats.Indexed8, BitmapPalettes.Gray256, Sim2DBytes, 512);
CTFDisplay.Simulated2D = Sim2DSource;*/
/*float2[] PointsPS1D = new float2[512];
for (int i = 0; i < PointsPS1D.Length; i++)
PointsPS1D[i] = new float2(i, (float) Math.Exp(-i / 300f));
CTFDisplay.PS1D = PointsPS1D;
float[] SimCTF = new CTF { Defocus = -2M }.Get1D(512, true);
float2[] PointsSim1D = new float2[SimCTF.Length];
for (int i = 0; i < SimCTF.Length; i++)
PointsSim1D[i] = new float2(i, SimCTF[i] * (float)Math.Exp(-i / 100f) + (float)Math.Exp(-i / 300f));
CTFDisplay.Simulated1D = PointsSim1D;*/
/*CubicGrid Grid = new CubicGrid(new int3(5, 5, 5), 0, 0, Dimension.X);
Grid.Values[2, 2, 2] = 1f;
float[] Data = new float[11 * 11 * 11];
int i = 0;
for (float z = 0f; z < 1.05f; z += 0.1f)
for (float y = 0f; y < 1.05f; y += 0.1f)
for (float x = 0f; x < 1.05f; x += 0.1f)
Data[i++] = Grid.GetInterpolated(new float3(x, y, z));
Image DataImage = new Image(Data, new int3(11, 11, 11));
DataImage.WriteMRC("bla.mrc");
Image GPUImage = new Image(DataImage.GetDevice(Intent.Read), new int3(11, 11, 11));
GPUImage.WriteMRC("gpu.mrc");*/
/*CubicGrid WiggleGrid = new CubicGrid(new int3(2, 2, 1));
float[][] WiggleWeights = WiggleGrid.GetWiggleWeights(new int3(3, 3, 1));*/
}
}
public CubicGrid Resize(int3 newSize)
{
float[] Result = new float[newSize.Elements()];
float StepX = 1f / Math.Max(1, newSize.X - 1);
float StepY = 1f / Math.Max(1, newSize.Y - 1);
float StepZ = 1f / Math.Max(1, newSize.Z - 1);
for (int z = 0, i = 0; z < newSize.Z; z++)
for (int y = 0; y < newSize.Y; y++)
for (int x = 0; x < newSize.X; x++, i++)
Result[i] = GetInterpolated(new float3(x * StepX, y * StepY, z * StepZ));
return new CubicGrid(newSize, Result);
}
public float[] GetInterpolatedNative(int3 valueGrid, float3 border)
{
float[] Result = new float[valueGrid.Elements()];
float StepX = (1f - border.X * 2) / Math.Max(1, valueGrid.X - 1);
float OffsetX = border.X;
float StepY = (1f - border.Y * 2) / Math.Max(1, valueGrid.Y - 1);
float OffsetY = border.Y;
float StepZ = (1f - border.Z * 2) / Math.Max(valueGrid.Z - 1, 1);
float OffsetZ = valueGrid.Z == 1 ? 0.5f : border.Z;
CPU.CubicInterpOnGrid(Dimensions, FlatValues, Spacing, valueGrid, new float3(StepX, StepY, StepZ), new float3(OffsetX, OffsetY, OffsetZ), Result);
return Result;
}
public float[] GetInterpolated(int3 valueGrid, float3 border)
{
float[] Result = new float[valueGrid.Elements()];
float StepX = (1f - border.X * 2) / Math.Max(1, valueGrid.X - 1);
float OffsetX = border.X;
float StepY = (1f - border.Y * 2) / Math.Max(1, valueGrid.Y - 1);
float OffsetY = border.Y;
float StepZ = (1f - border.Z * 2) / Math.Max(valueGrid.Z - 1, 1);
float OffsetZ = valueGrid.Z == 1 ? 0.5f : border.Z;
for (int z = 0, i = 0; z < valueGrid.Z; z++)
for (int y = 0; y < valueGrid.Y; y++)
for (int x = 0; x < valueGrid.X; x++, i++)
Result[i] = GetInterpolated(new float3(x * StepX + OffsetX, y * StepY + OffsetY, z * StepZ + OffsetZ));
return Result;
}
public void Correlate(Image tiltStack, Image reference, int size, float lowpassAngstrom, float highpassAngstrom, int3 volumeDimensions, int healpixOrder, string symmetry = "C1")
{
if (!Directory.Exists(CorrelationDir))
Directory.CreateDirectory(CorrelationDir);
float DownscaleFactor = lowpassAngstrom / (float)(CTF.PixelSize * 2);
Image DownscaledStack = tiltStack.AsScaledMassive(new int2(tiltStack.Dims) / DownscaleFactor / 2 * 2);
tiltStack.FreeDevice();
float HighpassNyquist = (float)(CTF.PixelSize * 2) * DownscaleFactor / highpassAngstrom;
DownscaledStack.Bandpass(HighpassNyquist, 1, false);
Image ScaledReference = reference.AsScaled(reference.Dims / DownscaleFactor / 2 * 2);
reference.FreeDevice();
Image PaddedReference = ScaledReference.AsPadded(new int3(size, size, size));
ScaledReference.Dispose();
PaddedReference.Bandpass(HighpassNyquist, 1, true);
Projector ProjectorReference = new Projector(PaddedReference, 2);
PaddedReference.Dispose();
VolumeDimensions = volumeDimensions / DownscaleFactor / 2 * 2;
int SizeCropped = size / 2;
int3 Grid = (VolumeDimensions + SizeCropped - 1) / SizeCropped;
List<float3> GridCoords = new List<float3>();
for (int z = 0; z < Grid.Z; z++)
for (int y = 0; y < Grid.Y; y++)
for (int x = 0; x < Grid.X; x++)
GridCoords.Add(new float3(x * SizeCropped + SizeCropped / 2,
y * SizeCropped + SizeCropped / 2,
z * SizeCropped + SizeCropped / 2));
float3[] HealpixAngles = Helper.GetHealpixAngles(healpixOrder, symmetry).Select(a => a * Helper.ToRad).ToArray();
Image CTFCoords = GetCTFCoords(size, (int)(size * DownscaleFactor));
float[] OutputCorr = new float[VolumeDimensions.Elements()];
int PlanForw, PlanBack, PlanForwCTF;
Projector.GetPlans(new int3(size, size, size), 2, out PlanForw, out PlanBack, out PlanForwCTF);
int BatchSize = 16;
for (int b = 0; b < GridCoords.Count; b += BatchSize)
{
int CurBatch = Math.Min(BatchSize, GridCoords.Count - b);
Image Subtomos = new Image(IntPtr.Zero, new int3(size, size, size * CurBatch), true, true);
Image SubtomoCTFs = new Image(IntPtr.Zero, new int3(size, size, size * CurBatch), true);
for (int st = 0; st < CurBatch; st++)
{
Image ImagesFT = GetSubtomoImages(DownscaledStack, size, GridCoords[b + st], true);
Image CTFs = GetSubtomoCTFs(GridCoords[b + st], CTFCoords);
//Image CTFWeights = GetSubtomoCTFs(GridCoords[b + st], CTFCoords, true, true);
ImagesFT.Multiply(CTFs); // Weight and phase-flip image FTs by CTF, which still has its sign here
//ImagesFT.Multiply(CTFWeights);
CTFs.Abs(); // CTF has to be positive from here on since image FT phases are now flipped
// CTF has to be converted to complex numbers with imag = 0, and weighted by itself
float2[] CTFsComplexData = new float2[CTFs.ElementsComplex];
float[] CTFsContinuousData = CTFs.GetHostContinuousCopy();
for (int i = 0; i < CTFsComplexData.Length; i++)
CTFsComplexData[i] = new float2(CTFsContinuousData[i] * CTFsContinuousData[i], 0);
Image CTFsComplex = new Image(CTFsComplexData, CTFs.Dims, true);
Projector ProjSubtomo = new Projector(new int3(size, size, size), 2);
lock (GPU.Sync)
ProjSubtomo.BackProject(ImagesFT, CTFs, GetAngleInImages(GridCoords[b + st]));
Image Subtomo = ProjSubtomo.Reconstruct(false, PlanForw, PlanBack, PlanForwCTF);
ProjSubtomo.Dispose();
/*Image CroppedSubtomo = Subtomo.AsPadded(new int3(SizeCropped, SizeCropped, SizeCropped));
CroppedSubtomo.WriteMRC(ParticlesDir + RootName + "_" + (b + st).ToString("D5") + ".mrc");
CroppedSubtomo.Dispose();*/
Projector ProjCTF = new Projector(new int3(size, size, size), 2);
lock (GPU.Sync)
ProjCTF.BackProject(CTFsComplex, CTFs, GetAngleInImages(GridCoords[b + st]));
Image SubtomoCTF = ProjCTF.Reconstruct(true, PlanForw, PlanBack, PlanForwCTF);
ProjCTF.Dispose();
GPU.FFT(Subtomo.GetDevice(Intent.Read), Subtomos.GetDeviceSlice(size * st, Intent.Write), Subtomo.Dims, 1);
GPU.CopyDeviceToDevice(SubtomoCTF.GetDevice(Intent.Read), SubtomoCTFs.GetDeviceSlice(size * st, Intent.Write), SubtomoCTF.ElementsReal);
ImagesFT.Dispose();
CTFs.Dispose();
//CTFWeights.Dispose();
CTFsComplex.Dispose();
Subtomo.Dispose();
SubtomoCTF.Dispose();
}
Image BestCorrelation = new Image(IntPtr.Zero, new int3(size, size, size * CurBatch));
Image BestRot = new Image(IntPtr.Zero, new int3(size, size, size * CurBatch));
Image BestTilt = new Image(IntPtr.Zero, new int3(size, size, size * CurBatch));
Image BestPsi = new Image(IntPtr.Zero, new int3(size, size, size * CurBatch));
GPU.CorrelateSubTomos(ProjectorReference.Data.GetDevice(Intent.Read),
ProjectorReference.Oversampling,
ProjectorReference.Data.Dims,
Subtomos.GetDevice(Intent.Read),
SubtomoCTFs.GetDevice(Intent.Read),
new int3(size, size, size),
(uint)CurBatch,
Helper.ToInterleaved(HealpixAngles),
(uint)HealpixAngles.Length,
MainWindow.Options.ExportParticleRadius / ((float)CTF.PixelSize * DownscaleFactor),
BestCorrelation.GetDevice(Intent.Write),
BestRot.GetDevice(Intent.Write),
BestTilt.GetDevice(Intent.Write),
BestPsi.GetDevice(Intent.Write));
for (int st = 0; st < CurBatch; st++)
{
Image ThisCorrelation = new Image(BestCorrelation.GetDeviceSlice(size * st, Intent.Read), new int3(size, size, size));
Image CroppedCorrelation = ThisCorrelation.AsPadded(new int3(SizeCropped, SizeCropped, SizeCropped));
//CroppedCorrelation.WriteMRC(CorrelationDir + RootName + "_" + (b + st).ToString("D5") + ".mrc");
float[] SubCorr = CroppedCorrelation.GetHostContinuousCopy();
int3 Origin = new int3(GridCoords[b + st]) - SizeCropped / 2;
for (int z = 0; z < SizeCropped; z++)
{
int zVol = Origin.Z + z;
if (zVol >= VolumeDimensions.Z)
continue;
for (int y = 0; y < SizeCropped; y++)
{
int yVol = Origin.Y + y;
if (yVol >= VolumeDimensions.Y)
continue;
for (int x = 0; x < SizeCropped; x++)
{
int xVol = Origin.X + x;
if (xVol >= VolumeDimensions.X)
continue;
OutputCorr[(zVol * VolumeDimensions.Y + yVol) * VolumeDimensions.X + xVol] = SubCorr[(z * SizeCropped + y) * SizeCropped + x];
}
}
}
CroppedCorrelation.Dispose();
ThisCorrelation.Dispose();
}
Subtomos.Dispose();
SubtomoCTFs.Dispose();
BestCorrelation.Dispose();
BestRot.Dispose();
BestTilt.Dispose();
BestPsi.Dispose();
}
GPU.DestroyFFTPlan(PlanForw);
GPU.DestroyFFTPlan(PlanBack);
GPU.DestroyFFTPlan(PlanForwCTF);
CTFCoords.Dispose();
ProjectorReference.Dispose();
DownscaledStack.Dispose();
Image OutputCorrImage = new Image(OutputCorr, VolumeDimensions);
OutputCorrImage.WriteMRC(CorrelationDir + RootName + ".mrc");
OutputCorrImage.Dispose();
}
public void ProcessCTFOneAngle(Image angleImage,
float angle,
bool fromScratch,
bool fixAstigmatism,
float2 astigmatism,
CTF previousCTF,
CubicGrid previousGrid,
Cubic1D previousBackground,
Cubic1D previousScale,
out CTF thisCTF,
out CubicGrid thisGrid,
out float2[] thisPS1D,
out Cubic1D thisBackground,
out Cubic1D thisScale,
out Image thisPS2D)
{
CTF TempCTF = previousCTF != null ? previousCTF.GetCopy() : new CTF();
float2[] TempPS1D = null;
Cubic1D TempBackground = null, TempScale = null;
CubicGrid TempGrid = null;
#region Dimensions and grids
int NFrames = angleImage.Dims.Z;
int2 DimsImage = angleImage.DimsSlice;
int2 DimsRegion = new int2(MainWindow.Options.CTFWindow, MainWindow.Options.CTFWindow);
float OverlapFraction = 0.5f;
int2 DimsPositionGrid;
int3[] PositionGrid = Helper.GetEqualGridSpacing(DimsImage, new int2(DimsRegion.X, DimsRegion.Y), OverlapFraction, out DimsPositionGrid);
int NPositions = (int)DimsPositionGrid.Elements();
if (previousGrid == null)
TempGrid = new CubicGrid(new int3(2, 2, 1));
else
TempGrid = new CubicGrid(new int3(2, 2, 1), previousGrid.FlatValues);
bool CTFSpace = true;
bool CTFTime = false;
int3 CTFSpectraGrid = new int3(DimsPositionGrid.X, DimsPositionGrid.Y, 1);
int MinFreqInclusive = (int)(MainWindow.Options.CTFRangeMin * DimsRegion.X / 2);
int MaxFreqExclusive = (int)(MainWindow.Options.CTFRangeMax * DimsRegion.X / 2);
int NFreq = MaxFreqExclusive - MinFreqInclusive;
#endregion
#region Allocate GPU memory
Image CTFSpectra = new Image(IntPtr.Zero, new int3(DimsRegion.X, DimsRegion.X, (int)CTFSpectraGrid.Elements()), true);
Image CTFMean = new Image(IntPtr.Zero, new int3(DimsRegion), true);
Image CTFCoordsCart = new Image(new int3(DimsRegion), true, true);
Image CTFCoordsPolarTrimmed = new Image(new int3(NFreq, DimsRegion.X, 1), false, true);
#endregion
// Extract movie regions, create individual spectra in Cartesian coordinates and their mean.
#region Create spectra
GPU.CreateSpectra(angleImage.GetDevice(Intent.Read),
DimsImage,
NFrames,
PositionGrid,
NPositions,
DimsRegion,
CTFSpectraGrid,
CTFSpectra.GetDevice(Intent.Write),
CTFMean.GetDevice(Intent.Write));
angleImage.FreeDevice(); // Won't need it in this method anymore.
#endregion
// Populate address arrays for later.
#region Init addresses
{
float2[] CoordsData = new float2[CTFCoordsCart.ElementsSliceComplex];
Helper.ForEachElementFT(DimsRegion, (x, y, xx, yy, r, a) => CoordsData[y * (DimsRegion.X / 2 + 1) + x] = new float2(r, a));
CTFCoordsCart.UpdateHostWithComplex(new[] { CoordsData });
CoordsData = new float2[NFreq * DimsRegion.X];
Helper.ForEachElement(CTFCoordsPolarTrimmed.DimsSlice, (x, y) =>
{
float Angle = ((float)y / DimsRegion.X + 0.5f) * (float)Math.PI;
float Ny = 1f / DimsRegion.X;
CoordsData[y * NFreq + x] = new float2((x + MinFreqInclusive) * Ny, Angle);
});
CTFCoordsPolarTrimmed.UpdateHostWithComplex(new[] { CoordsData });
}
#endregion
// Retrieve average 1D spectrum from CTFMean (not corrected for astigmatism yet).
#region Initial 1D spectrum
{
Image CTFAverage1D = new Image(IntPtr.Zero, new int3(DimsRegion.X / 2, 1, 1));
GPU.CTFMakeAverage(CTFMean.GetDevice(Intent.Read),
CTFCoordsCart.GetDevice(Intent.Read),
(uint)CTFMean.ElementsSliceReal,
(uint)DimsRegion.X,
new[] { new CTF().ToStruct() },
new CTF().ToStruct(),
0,
(uint)DimsRegion.X / 2,
null,
1,
CTFAverage1D.GetDevice(Intent.Write));
//CTFAverage1D.WriteMRC("CTFAverage1D.mrc");
float[] CTFAverage1DData = CTFAverage1D.GetHost(Intent.Read)[0];
float2[] ForPS1D = new float2[DimsRegion.X / 2];
for (int i = 0; i < ForPS1D.Length; i++)
ForPS1D[i] = new float2((float)i / DimsRegion.X, (float)Math.Round(CTFAverage1DData[i], 4));
TempPS1D = ForPS1D;
CTFAverage1D.Dispose();
}
#endregion
#region Background fitting methods
Action UpdateBackgroundFit = () =>
{
float2[] ForPS1D = TempPS1D.Skip(Math.Max(5, MinFreqInclusive / 2)).ToArray();
Cubic1D.FitCTF(ForPS1D,
v => v.Select(x => TempCTF.Get1D(x / (float)TempCTF.PixelSize, true)).ToArray(),
TempCTF.GetZeros(),
TempCTF.GetPeaks(),
out TempBackground,
out TempScale);
};
Action<bool> UpdateRotationalAverage = keepbackground =>
{
float[] MeanData = CTFMean.GetHost(Intent.Read)[0];
Image CTFMeanCorrected = new Image(new int3(DimsRegion), true);
float[] MeanCorrectedData = CTFMeanCorrected.GetHost(Intent.Write)[0];
// Subtract current background estimate from spectra, populate coords.
Helper.ForEachElementFT(DimsRegion,
(x, y, xx, yy, r, a) =>
{
int i = y * (DimsRegion.X / 2 + 1) + x;
MeanCorrectedData[i] = MeanData[i] - TempBackground.Interp(r / DimsRegion.X);
});
Image CTFAverage1D = new Image(IntPtr.Zero, new int3(DimsRegion.X / 2, 1, 1));
GPU.CTFMakeAverage(CTFMeanCorrected.GetDevice(Intent.Read),
CTFCoordsCart.GetDevice(Intent.Read),
(uint)CTFMeanCorrected.DimsEffective.ElementsSlice(),
(uint)DimsRegion.X,
new[] { TempCTF.ToStruct() },
TempCTF.ToStruct(),
0,
(uint)DimsRegion.X / 2,
null,
1,
CTFAverage1D.GetDevice(Intent.Write));
//CTFAverage1D.WriteMRC("CTFAverage1D.mrc");
float[] RotationalAverageData = CTFAverage1D.GetHost(Intent.Read)[0];
float2[] ForPS1D = new float2[TempPS1D.Length];
if (keepbackground)
for (int i = 0; i < ForPS1D.Length; i++)
ForPS1D[i] = new float2((float)i / DimsRegion.X, RotationalAverageData[i] + TempBackground.Interp((float)i / DimsRegion.X));
else
for (int i = 0; i < ForPS1D.Length; i++)
ForPS1D[i] = new float2((float)i / DimsRegion.X, RotationalAverageData[i]);
MathHelper.UnNaN(ForPS1D);
TempPS1D = ForPS1D;
CTFMeanCorrected.Dispose();
CTFAverage1D.Dispose();
};
#endregion
// Fit background to currently best average (not corrected for astigmatism yet).
{
float2[] ForPS1D = TempPS1D.Skip(MinFreqInclusive).Take(Math.Max(2, NFreq / 2)).ToArray();
float[] CurrentBackground;
//if (previousBackground == null)
{
int NumNodes = Math.Max(3, (int)((MainWindow.Options.CTFRangeMax - MainWindow.Options.CTFRangeMin) * 5M));
TempBackground = Cubic1D.Fit(ForPS1D, NumNodes); // This won't fit falloff and scale, because approx function is 0
CurrentBackground = TempBackground.Interp(TempPS1D.Select(p => p.X).ToArray()).Skip(MinFreqInclusive).Take(NFreq / 2).ToArray();
}
/*else
{
CurrentBackground = previousBackground.Interp(TempPS1D.Select(p => p.X).ToArray()).Skip(MinFreqInclusive).Take(NFreq / 2).ToArray();
TempBackground = new Cubic1D(previousBackground.Data);
}*/
float[] Subtracted1D = new float[ForPS1D.Length];
for (int i = 0; i < ForPS1D.Length; i++)
Subtracted1D[i] = ForPS1D[i].Y - CurrentBackground[i];
MathHelper.NormalizeInPlace(Subtracted1D);
float ZMin = (float)MainWindow.Options.CTFZMin;
float ZMax = (float)MainWindow.Options.CTFZMax;
float PhaseMin = 0f;
float PhaseMax = MainWindow.Options.CTFDoPhase ? 1f : 0f;
if (previousCTF != null)
{
ZMin = (float)previousCTF.Defocus - 0.5f;
ZMax = (float)previousCTF.Defocus + 0.5f;
if (PhaseMax > 0)
{
PhaseMin = (float)previousCTF.PhaseShift - 0.3f;
PhaseMax = (float)previousCTF.PhaseShift + 0.3f;
}
}
float ZStep = (ZMax - ZMin) / 100f;
float BestZ = 0, BestPhase = 0, BestScore = -999;
for (float z = ZMin; z <= ZMax + 1e-5f; z += ZStep)
{
for (float p = PhaseMin; p <= PhaseMax; p += 0.01f)
{
CTF CurrentParams = new CTF
{
PixelSize = (MainWindow.Options.CTFPixelMin + MainWindow.Options.CTFPixelMax) * 0.5M,
Defocus = (decimal)z,
PhaseShift = (decimal)p,
Cs = MainWindow.Options.CTFCs,
Voltage = MainWindow.Options.CTFVoltage,
Amplitude = MainWindow.Options.CTFAmplitude
};
float[] SimulatedCTF = CurrentParams.Get1D(TempPS1D.Length, true).Skip(MinFreqInclusive).Take(Math.Max(2, NFreq / 2)).ToArray();
MathHelper.NormalizeInPlace(SimulatedCTF);
float Score = MathHelper.CrossCorrelate(Subtracted1D, SimulatedCTF);
if (Score > BestScore)
{
BestScore = Score;
BestZ = z;
BestPhase = p;
}
}
}
TempCTF = new CTF
{
PixelSize = (MainWindow.Options.CTFPixelMin + MainWindow.Options.CTFPixelMax) * 0.5M,
Defocus = (decimal)BestZ,
PhaseShift = (decimal)BestPhase,
Cs = MainWindow.Options.CTFCs,
Voltage = MainWindow.Options.CTFVoltage,
Amplitude = MainWindow.Options.CTFAmplitude
};
UpdateRotationalAverage(true); // This doesn't have a nice background yet.
UpdateBackgroundFit(); // Now get a reasonably nice background.
}
// Fit defocus, (phase shift), (astigmatism) to average background-subtracted spectrum,
// which is in polar coords at this point (for equal weighting of all frequencies).
#region Grid search
if (fromScratch)
{
Image CTFMeanPolarTrimmed = CTFMean.AsPolar((uint)MinFreqInclusive, (uint)(MinFreqInclusive + NFreq / 1));
// Subtract current background.
Image CurrentBackground = new Image(TempBackground.Interp(TempPS1D.Select(p => p.X).ToArray()).Skip(MinFreqInclusive).Take(NFreq / 1).ToArray());
CTFMeanPolarTrimmed.SubtractFromLines(CurrentBackground);
CurrentBackground.Dispose();
// Normalize for CC (not strictly needed, but it's converted for fp16 later, so let's be on the safe side of the fp16 range.
GPU.Normalize(CTFMeanPolarTrimmed.GetDevice(Intent.Read), CTFMeanPolarTrimmed.GetDevice(Intent.Write), (uint)CTFMeanPolarTrimmed.ElementsReal, 1);
//CTFMeanPolarTrimmed.WriteMRC("ctfmeanpolartrimmed.mrc");
CTF StartParams = new CTF
{
PixelSize = (MainWindow.Options.CTFPixelMin + MainWindow.Options.CTFPixelMax) * 0.5M,
PixelSizeDelta = Math.Abs(MainWindow.Options.CTFPixelMax - MainWindow.Options.CTFPixelMin),
PixelSizeAngle = MainWindow.Options.CTFPixelAngle,
Defocus = TempCTF.Defocus, // (MainWindow.Options.CTFZMin + MainWindow.Options.CTFZMax) * 0.5M,
DefocusDelta = 0,
DefocusAngle = 0,
PhaseShift = TempCTF.PhaseShift,
Cs = MainWindow.Options.CTFCs,
Voltage = MainWindow.Options.CTFVoltage,
Amplitude = MainWindow.Options.CTFAmplitude
};
CTFFitStruct FitParams = new CTFFitStruct
{
Defocus = new float3(-0.4e-6f,
0.4e-6f,
0.025e-6f),
Defocusdelta = new float3(0, 0.8e-6f, 0.02e-6f),
Astigmatismangle = new float3(0, 2 * (float)Math.PI, 1 * (float)Math.PI / 18),
Phaseshift = MainWindow.Options.CTFDoPhase ? new float3(-0.2f * (float)Math.PI, 0.2f * (float)Math.PI, 0.025f * (float)Math.PI) : new float3(0, 0, 0)
};
CTFStruct ResultStruct = GPU.CTFFitMean(CTFMeanPolarTrimmed.GetDevice(Intent.Read),
CTFCoordsPolarTrimmed.GetDevice(Intent.Read),
CTFMeanPolarTrimmed.DimsSlice,
StartParams.ToStruct(),
FitParams,
true);
TempCTF.FromStruct(ResultStruct);
TempCTF.Defocus = Math.Max(TempCTF.Defocus, MainWindow.Options.CTFZMin);
CTFMeanPolarTrimmed.Dispose();
UpdateRotationalAverage(true); // This doesn't have a nice background yet.
UpdateBackgroundFit(); // Now get a reasonably nice background.
UpdateRotationalAverage(true); // This time, with the nice background.
UpdateBackgroundFit(); // Make the background even nicer!
}
else if (previousCTF != null)
{
TempCTF.DefocusDelta = previousCTF.DefocusDelta;
TempCTF.DefocusAngle = previousCTF.DefocusAngle;
}
if (fixAstigmatism)
{
TempCTF.DefocusDelta = (decimal)astigmatism.X;
TempCTF.DefocusAngle = (decimal)astigmatism.Y;
}
#endregion
if (previousGrid == null)
TempGrid = new CubicGrid(TempGrid.Dimensions, (float)TempCTF.Defocus, (float)TempCTF.Defocus, Dimension.X);
// Do BFGS optimization of defocus, astigmatism and phase shift,
// using 2D simulation for comparison
#region BFGS
bool[] CTFSpectraConsider = new bool[CTFSpectraGrid.Elements()];
for (int i = 0; i < CTFSpectraConsider.Length; i++)
CTFSpectraConsider[i] = true;
int NCTFSpectraConsider = CTFSpectraConsider.Length;
{
Image CTFSpectraPolarTrimmed = CTFSpectra.AsPolar((uint)MinFreqInclusive, (uint)(MinFreqInclusive + NFreq));
CTFSpectra.FreeDevice(); // This will only be needed again for the final PS1D.
#region Create background and scale
float[] CurrentScale = TempScale.Interp(TempPS1D.Select(p => p.X).ToArray());
Image CTFSpectraScale = new Image(new int3(NFreq, DimsRegion.X, 1));
float[] CTFSpectraScaleData = CTFSpectraScale.GetHost(Intent.Write)[0];
// Trim polar to relevant frequencies, and populate coordinates.
Parallel.For(0, DimsRegion.X, y =>
{
for (int x = 0; x < NFreq; x++)
CTFSpectraScaleData[y * NFreq + x] = CurrentScale[x + MinFreqInclusive];
});
//CTFSpectraScale.WriteMRC("ctfspectrascale.mrc");
// Background is just 1 line since we're in polar.
Image CurrentBackground = new Image(TempBackground.Interp(TempPS1D.Select(p => p.X).ToArray()).Skip(MinFreqInclusive).Take(NFreq).ToArray());
#endregion
CTFSpectraPolarTrimmed.SubtractFromLines(CurrentBackground);
CurrentBackground.Dispose();
// Normalize background-subtracted spectra.
GPU.Normalize(CTFSpectraPolarTrimmed.GetDevice(Intent.Read),
CTFSpectraPolarTrimmed.GetDevice(Intent.Write),
(uint)CTFSpectraPolarTrimmed.ElementsSliceReal,
(uint)CTFSpectraGrid.Elements());
//CTFSpectraPolarTrimmed.WriteMRC("ctfspectrapolartrimmed.mrc");
#region Convert to fp16
Image CTFSpectraPolarTrimmedHalf = CTFSpectraPolarTrimmed.AsHalf();
CTFSpectraPolarTrimmed.Dispose();
Image CTFSpectraScaleHalf = CTFSpectraScale.AsHalf();
CTFSpectraScale.Dispose();
Image CTFCoordsPolarTrimmedHalf = CTFCoordsPolarTrimmed.AsHalf();
#endregion
// Wiggle weights show how the defocus on the spectra grid is altered
// by changes in individual anchor points of the spline grid.
// They are used later to compute the dScore/dDefocus values for each spectrum
// only once, and derive the values for each anchor point from them.
float[][] WiggleWeights = TempGrid.GetWiggleWeights(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0));
// Helper method for getting CTFStructs for the entire spectra grid.
Func<double[], CTF, float[], CTFStruct[]> EvalGetCTF = (input, ctf, defocusValues) =>
{
decimal AlteredPhase = MainWindow.Options.CTFDoPhase ? (decimal)input[input.Length - 3] : 0;
decimal AlteredDelta = (decimal)input[input.Length - 2];
decimal AlteredAngle = (decimal)(input[input.Length - 1] * 20 / (Math.PI / 180));
CTF Local = ctf.GetCopy();
Local.PhaseShift = AlteredPhase;
Local.DefocusDelta = AlteredDelta;
Local.DefocusAngle = AlteredAngle;
CTFStruct LocalStruct = Local.ToStruct();
CTFStruct[] LocalParams = new CTFStruct[defocusValues.Length];
for (int i = 0; i < LocalParams.Length; i++)
{
LocalParams[i] = LocalStruct;
LocalParams[i].Defocus = defocusValues[i] * -1e-6f;
}
return LocalParams;
};
// Simulate with adjusted CTF, compare to originals
#region Eval and Gradient methods
Func<double[], double> Eval = input =>
{
CubicGrid Altered = new CubicGrid(TempGrid.Dimensions, input.Take((int)TempGrid.Dimensions.Elements()).Select(v => (float)v).ToArray());
float[] DefocusValues = Altered.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0));
CTFStruct[] LocalParams = EvalGetCTF(input, TempCTF, DefocusValues);
float[] Result = new float[LocalParams.Length];
GPU.CTFCompareToSim(CTFSpectraPolarTrimmedHalf.GetDevice(Intent.Read),
CTFCoordsPolarTrimmedHalf.GetDevice(Intent.Read),
CTFSpectraScaleHalf.GetDevice(Intent.Read),
(uint)CTFSpectraPolarTrimmedHalf.ElementsSliceReal,
LocalParams,
Result,
(uint)LocalParams.Length);
float Score = 0;
for (int i = 0; i < Result.Length; i++)
if (CTFSpectraConsider[i])
Score += Result[i];
Score /= NCTFSpectraConsider;
if (float.IsNaN(Score) || float.IsInfinity(Score))
throw new Exception("Bad score.");
return (1.0 - Score) * 1000.0;
};
Func<double[], double[]> Gradient = input =>
{
const float Step = 0.005f;
double[] Result = new double[input.Length];
// In 0D grid case, just get gradient for all 4 parameters.
// In 1+D grid case, do simple gradient for astigmatism and phase...
int StartComponent = input.Length - 3;
//int StartComponent = 0;
for (int i = StartComponent; i < input.Length; i++)
{
if (fixAstigmatism && i > StartComponent)
continue;
double[] UpperInput = new double[input.Length];
input.CopyTo(UpperInput, 0);
UpperInput[i] += Step;
double UpperValue = Eval(UpperInput);
double[] LowerInput = new double[input.Length];
input.CopyTo(LowerInput, 0);
LowerInput[i] -= Step;
double LowerValue = Eval(LowerInput);
Result[i] = (UpperValue - LowerValue) / (2f * Step);
}
float[] ResultPlus = new float[CTFSpectraGrid.Elements()];
float[] ResultMinus = new float[CTFSpectraGrid.Elements()];
// ..., take shortcut for defoci...
{
{
CubicGrid AlteredPlus = new CubicGrid(TempGrid.Dimensions, input.Take((int)TempGrid.Dimensions.Elements()).Select(v => (float)v + Step).ToArray());
float[] DefocusValues = AlteredPlus.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0));
CTFStruct[] LocalParams = EvalGetCTF(input, TempCTF, DefocusValues);
GPU.CTFCompareToSim(CTFSpectraPolarTrimmedHalf.GetDevice(Intent.Read),
CTFCoordsPolarTrimmedHalf.GetDevice(Intent.Read),
CTFSpectraScaleHalf.GetDevice(Intent.Read),
(uint)CTFSpectraPolarTrimmedHalf.ElementsSliceReal,
LocalParams,
ResultPlus,
(uint)LocalParams.Length);
}
{
CubicGrid AlteredMinus = new CubicGrid(TempGrid.Dimensions, input.Take((int)TempGrid.Dimensions.Elements()).Select(v => (float)v - Step).ToArray());
float[] DefocusValues = AlteredMinus.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0));
CTFStruct[] LocalParams = EvalGetCTF(input, TempCTF, DefocusValues);
GPU.CTFCompareToSim(CTFSpectraPolarTrimmedHalf.GetDevice(Intent.Read),
CTFCoordsPolarTrimmedHalf.GetDevice(Intent.Read),
CTFSpectraScaleHalf.GetDevice(Intent.Read),
(uint)CTFSpectraPolarTrimmedHalf.ElementsSliceReal,
LocalParams,
ResultMinus,
(uint)LocalParams.Length);
}
float[] LocalGradients = new float[ResultPlus.Length];
for (int i = 0; i < LocalGradients.Length; i++)
LocalGradients[i] = ResultMinus[i] - ResultPlus[i];
// Now compute gradients per grid anchor point using the precomputed individual gradients and wiggle factors.
Parallel.For(0, TempGrid.Dimensions.Elements(), i => Result[i] = MathHelper.ReduceWeighted(LocalGradients, WiggleWeights[i]) / LocalGradients.Length / (2f * Step) * 1000f);
}
foreach (var i in Result)
if (double.IsNaN(i) || double.IsInfinity(i))
throw new Exception("Bad score.");
return Result;
};
#endregion
#region Minimize first time with potential outpiers
double[] StartParams = new double[TempGrid.Dimensions.Elements() + 3];
for (int i = 0; i < TempGrid.Dimensions.Elements(); i++)
StartParams[i] = TempGrid.FlatValues[i];
StartParams[StartParams.Length - 3] = (double)TempCTF.PhaseShift;
StartParams[StartParams.Length - 2] = (double)TempCTF.DefocusDelta;
StartParams[StartParams.Length - 1] = (double)TempCTF.DefocusAngle / 20 * (Math.PI / 180);
// Compute correlation for individual spectra, and throw away those that are >.75 sigma worse than mean.
BroydenFletcherGoldfarbShanno Optimizer = new BroydenFletcherGoldfarbShanno(StartParams.Length, Eval, Gradient)
{
Past = 1,
Delta = 1e-6,
MaxLineSearch = 15,
Corrections = 20
};
Optimizer.Minimize(StartParams);
#endregion
#region Retrieve parameters
TempCTF.Defocus = (decimal)MathHelper.Mean(Optimizer.Solution.Take((int)TempGrid.Dimensions.Elements()).Select(v => (float)v));
TempCTF.PhaseShift = (decimal)Optimizer.Solution[StartParams.Length - 3];
TempCTF.DefocusDelta = (decimal)Optimizer.Solution[StartParams.Length - 2];
TempCTF.DefocusAngle = (decimal)(Optimizer.Solution[StartParams.Length - 1] * 20 / (Math.PI / 180));
if (TempCTF.DefocusDelta < 0)
{
TempCTF.DefocusAngle += 90;
TempCTF.DefocusDelta *= -1;
}
TempCTF.DefocusAngle = ((int)TempCTF.DefocusAngle + 180 * 99) % 180;
TempGrid = new CubicGrid(TempGrid.Dimensions, Optimizer.Solution.Take((int)TempGrid.Dimensions.Elements()).Select(v => (float)v).ToArray());
#endregion
// Dispose GPU resources manually because GC can't be bothered to do it in time.
CTFSpectraPolarTrimmedHalf.Dispose();
CTFCoordsPolarTrimmedHalf.Dispose();
CTFSpectraScaleHalf.Dispose();
#region Get nicer envelope fit
{
{
Image CTFSpectraBackground = new Image(new int3(DimsRegion), true);
float[] CTFSpectraBackgroundData = CTFSpectraBackground.GetHost(Intent.Write)[0];
// Construct background in Cartesian coordinates.
Helper.ForEachElementFT(DimsRegion, (x, y, xx, yy, r, a) =>
{
CTFSpectraBackgroundData[y * CTFSpectraBackground.DimsEffective.X + x] = TempBackground.Interp(r / DimsRegion.X);
});
CTFSpectra.SubtractFromSlices(CTFSpectraBackground);
float[] DefocusValues = TempGrid.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0));
CTFStruct[] LocalParams = DefocusValues.Select(v =>
{
CTF Local = TempCTF.GetCopy();
Local.Defocus = (decimal)v + 0.0M;
return Local.ToStruct();
}).ToArray();
Image CTFAverage1D = new Image(IntPtr.Zero, new int3(DimsRegion.X / 2, 1, 1));
CTF CTFAug = TempCTF.GetCopy();
CTFAug.Defocus += 0.0M;
GPU.CTFMakeAverage(CTFSpectra.GetDevice(Intent.Read),
CTFCoordsCart.GetDevice(Intent.Read),
(uint)CTFSpectra.ElementsSliceReal,
(uint)DimsRegion.X,
LocalParams,
CTFAug.ToStruct(),
0,
(uint)DimsRegion.X / 2,
CTFSpectraConsider.Select(v => v ? 1 : 0).ToArray(),
(uint)CTFSpectraGrid.Elements(),
CTFAverage1D.GetDevice(Intent.Write));
CTFSpectra.AddToSlices(CTFSpectraBackground);
float[] RotationalAverageData = CTFAverage1D.GetHost(Intent.Read)[0];
float2[] ForPS1D = new float2[TempPS1D.Length];
for (int i = 0; i < ForPS1D.Length; i++)
ForPS1D[i] = new float2((float)i / DimsRegion.X, (float)Math.Round(RotationalAverageData[i], 4) + TempBackground.Interp((float)i / DimsRegion.X));
MathHelper.UnNaN(ForPS1D);
TempPS1D = ForPS1D;
CTFSpectraBackground.Dispose();
CTFAverage1D.Dispose();
CTFSpectra.FreeDevice();
}
TempCTF.Defocus = Math.Max(TempCTF.Defocus, MainWindow.Options.CTFZMin);
UpdateBackgroundFit();
}
#endregion
}
#endregion
// Subtract background from 2D average and write it to disk.
// This image is used for quick visualization purposes only.
#region PS2D update
{
int3 DimsAverage = new int3(DimsRegion.X, DimsRegion.X / 2, 1);
float[] Average2DData = new float[DimsAverage.Elements()];
float[] OriginalAverageData = CTFMean.GetHost(Intent.Read)[0];
for (int y = 0; y < DimsAverage.Y; y++)
{
int yy = y * y;
for (int x = 0; x < DimsAverage.Y; x++)
{
int xx = DimsRegion.X / 2 - x - 1;
xx *= xx;
float r = (float)Math.Sqrt(xx + yy) / DimsRegion.X;
Average2DData[y * DimsAverage.X + x] = OriginalAverageData[(y + DimsRegion.X / 2) * (DimsRegion.X / 2 + 1) + x] - TempBackground.Interp(r);
}
for (int x = 0; x < DimsRegion.X / 2; x++)
{
int xx = x * x;
float r = (float)Math.Sqrt(xx + yy) / DimsRegion.X;
Average2DData[y * DimsAverage.X + x + DimsRegion.X / 2] = OriginalAverageData[(DimsRegion.X / 2 - y) * (DimsRegion.X / 2 + 1) + (DimsRegion.X / 2 - 1 - x)] - TempBackground.Interp(r);
}
}
thisPS2D = new Image(Average2DData, DimsAverage);
}
#endregion
for (int i = 0; i < TempPS1D.Length; i++)
TempPS1D[i].Y -= TempBackground.Interp(TempPS1D[i].X);
CTFSpectra.Dispose();
CTFMean.Dispose();
CTFCoordsCart.Dispose();
CTFCoordsPolarTrimmed.Dispose();
thisPS1D = TempPS1D;
thisBackground = TempBackground;
thisScale = TempScale;
thisCTF = TempCTF;
thisGrid = TempGrid;
}
public static Image GetVolumeFromAtoms(float3[] atoms, int3 dims, float sigma, float[] weights = null, float blobRadius = 1.0f, float blobAlpha = 6f)
{
if (weights == null)
{
weights = atoms.Select(v => 1f).ToArray();
}
float BlobRadius = blobRadius * (sigma / 0.5f);
float BlobAlpha = blobAlpha;
int BlobOrder = 0;
KaiserTable KaiserT = new KaiserTable(1000, BlobRadius, BlobAlpha, BlobOrder);
int SigmaExtent = (int)Math.Ceiling(BlobRadius);
float[] VolumeData = new float[dims.Elements()];
sigma = 2 * sigma * sigma;
float[][] ParallelVolumes = new float[10][];
for (int i = 0; i < ParallelVolumes.Length; i++)
{
ParallelVolumes[i] = new float[VolumeData.Length];
}
Parallel.For(0, 10, p =>
{
for (int a = p; a < atoms.Length; a += 10)
{
float3 atom = atoms[a];
float weight = weights[a];
int3 IAtom = new int3(atom);
int StartZ = Math.Max(0, IAtom.Z - SigmaExtent);
int EndZ = Math.Min(dims.Z - 1, IAtom.Z + SigmaExtent);
for (int z = StartZ; z <= EndZ; z++)
{
int StartY = Math.Max(0, IAtom.Y - SigmaExtent);
int EndY = Math.Min(dims.Y - 1, IAtom.Y + SigmaExtent);
for (int y = StartY; y <= EndY; y++)
{
int StartX = Math.Max(0, IAtom.X - SigmaExtent);
int EndX = Math.Min(dims.X - 1, IAtom.X + SigmaExtent);
for (int x = StartX; x <= EndX; x++)
{
float3 Pos = new float3(x, y, z);
//ParallelVolumes[p][(z * dims.Y + y) * dims.X + x] += (float)Math.Exp(-(Pos - atom).LengthSq() / sigma) * weight;
ParallelVolumes[p][(z * dims.Y + y) * dims.X + x] += KaiserT.GetValue((Pos - atom).Length()) * weight;
}
}
}
}
});
for (int p = 0; p < ParallelVolumes.Length; p++)
{
for (int i = 0; i < VolumeData.Length; i++)
{
VolumeData[i] += ParallelVolumes[p][i];
}
}
return(new Image(VolumeData, dims));
}
public static float3[] FillWithEquidistantPoints(Image mask, int n, out float R)
{
float3 MaskCenter = mask.AsCenterOfMass();
float[] MaskData = mask.GetHostContinuousCopy();
int3 Dims = mask.Dims;
float3[] BestSolution = null;
float a = 0, b = Dims.X / 2;
R = (a + b) / 2;
float3 Offset = new float3(0, 0, 0);
for (int o = 0; o < 2; o++)
{
for (int i = 0; i < 10; i++)
{
R = (a + b) / 2;
float Root3 = (float)Math.Sqrt(3);
float ZTerm = (float)(2 * Math.Sqrt(6) / 3);
float SpacingX = R * 2;
float SpacingY = Root3 * R;
float SpacingZ = ZTerm * R;
int3 DimsSphere = new int3(Math.Min(512, (int)Math.Ceiling(Dims.X / SpacingX)),
Math.Min(512, (int)Math.Ceiling(Dims.Y / SpacingX)),
Math.Min(512, (int)Math.Ceiling(Dims.Z / SpacingX)));
BestSolution = new float3[DimsSphere.Elements()];
for (int z = 0; z < DimsSphere.Z; z++)
{
for (int y = 0; y < DimsSphere.Y; y++)
{
for (int x = 0; x < DimsSphere.X; x++)
{
BestSolution[DimsSphere.ElementFromPosition(x, y, z)] = new float3(2 * x + (y + z) % 2,
Root3 * (y + 1 / 3f * (z % 2)),
ZTerm * z) * R + Offset;
}
}
}
List <float3> InsideMask = BestSolution.Where(p =>
{
int3 ip = new int3(p);
if (ip.X >= 0 && ip.X < Dims.X && ip.Y >= 0 && ip.Y < Dims.Y && ip.Z >= 0 && ip.Z < Dims.Z)
{
return(MaskData[Dims.ElementFromPosition(new int3(p))] == 1);
}
return(false);
}).ToList();
BestSolution = InsideMask.ToArray();
if (BestSolution.Length == n)
{
break;
}
else if (BestSolution.Length < n)
{
b = R;
}
else
{
a = R;
}
}
float3 CenterOfPoints = MathHelper.Mean(BestSolution);
Offset = MaskCenter - CenterOfPoints;
a = 0.8f * R;
b = 1.2f * R;
}
BestSolution = BestSolution.Select(v => v + Offset).ToArray();
return(BestSolution);
}
public virtual void ProcessCTF(MapHeader originalHeader, Image originalStack, bool doastigmatism, decimal scaleFactor)
{
if (!Directory.Exists(PowerSpectrumDir))
Directory.CreateDirectory(PowerSpectrumDir);
//CTF = new CTF();
PS1D = null;
_SimulatedBackground = null;
_SimulatedScale = new Cubic1D(new[] { new float2(0, 1), new float2(1, 1) });
#region Dimensions and grids
int NFrames = originalHeader.Dimensions.Z;
int2 DimsImage = new int2(originalHeader.Dimensions);
int2 DimsRegion = new int2(MainWindow.Options.CTFWindow, MainWindow.Options.CTFWindow);
float OverlapFraction = 0.5f;
int2 DimsPositionGrid;
int3[] PositionGrid = Helper.GetEqualGridSpacing(DimsImage, new int2(DimsRegion.X / 1, DimsRegion.Y / 1), OverlapFraction, out DimsPositionGrid);
int NPositions = (int)DimsPositionGrid.Elements();
int CTFGridX = Math.Min(DimsPositionGrid.X, MainWindow.Options.GridCTFX);
int CTFGridY = Math.Min(DimsPositionGrid.Y, MainWindow.Options.GridCTFY);
int CTFGridZ = Math.Min(NFrames, MainWindow.Options.GridCTFZ);
GridCTF = new CubicGrid(new int3(CTFGridX, CTFGridY, CTFGridZ));
GridCTFPhase = new CubicGrid(new int3(1, 1, CTFGridZ));
bool CTFSpace = CTFGridX * CTFGridY > 1;
bool CTFTime = CTFGridZ > 1;
int3 CTFSpectraGrid = new int3(CTFSpace ? DimsPositionGrid.X : 1,
CTFSpace ? DimsPositionGrid.Y : 1,
CTFTime ? CTFGridZ : 1);
int MinFreqInclusive = (int)(MainWindow.Options.CTFRangeMin * DimsRegion.X / 2);
int MaxFreqExclusive = (int)(MainWindow.Options.CTFRangeMax * DimsRegion.X / 2);
int NFreq = MaxFreqExclusive - MinFreqInclusive;
float PixelSize = (float)(MainWindow.Options.CTFPixelMin + MainWindow.Options.CTFPixelMax) * 0.5f;
float PixelDelta = (float)(MainWindow.Options.CTFPixelMax - MainWindow.Options.CTFPixelMin) * 0.5f;
float PixelAngle = (float)MainWindow.Options.CTFPixelAngle / 180f * (float)Math.PI;
#endregion
#region Allocate GPU memory
Image CTFSpectra = new Image(IntPtr.Zero, new int3(DimsRegion.X, DimsRegion.X, (int)CTFSpectraGrid.Elements()), true);
Image CTFMean = new Image(IntPtr.Zero, new int3(DimsRegion), true);
Image CTFCoordsCart = new Image(new int3(DimsRegion), true, true);
Image CTFCoordsPolarTrimmed = new Image(new int3(NFreq, DimsRegion.X, 1), false, true);
#endregion
// Extract movie regions, create individual spectra in Cartesian coordinates and their mean.
#region Create spectra
GPU.CreateSpectra(originalStack.GetDevice(Intent.Read),
DimsImage,
NFrames,
PositionGrid,
NPositions,
DimsRegion,
CTFSpectraGrid,
CTFSpectra.GetDevice(Intent.Write),
CTFMean.GetDevice(Intent.Write));
originalStack.FreeDevice(); // Won't need it in this method anymore.
#endregion
// Populate address arrays for later.
#region Init addresses
{
float2[] CoordsData = new float2[CTFCoordsCart.ElementsSliceComplex];
Helper.ForEachElementFT(DimsRegion, (x, y, xx, yy, r, a) => CoordsData[y * (DimsRegion.X / 2 + 1) + x] = new float2(r, a));
CTFCoordsCart.UpdateHostWithComplex(new[] { CoordsData });
CoordsData = new float2[NFreq * DimsRegion.X];
Helper.ForEachElement(CTFCoordsPolarTrimmed.DimsSlice, (x, y) =>
{
float Angle = ((float)y / DimsRegion.X + 0.5f) * (float)Math.PI;
float Ny = 1f / DimsRegion.X;
CoordsData[y * NFreq + x] = new float2((x + MinFreqInclusive) * Ny, Angle);
});
CTFCoordsPolarTrimmed.UpdateHostWithComplex(new[] { CoordsData });
}
#endregion
// Retrieve average 1D spectrum from CTFMean (not corrected for astigmatism yet).
#region Initial 1D spectrum
{
Image CTFAverage1D = new Image(IntPtr.Zero, new int3(DimsRegion.X / 2, 1, 1));
GPU.CTFMakeAverage(CTFMean.GetDevice(Intent.Read),
CTFCoordsCart.GetDevice(Intent.Read),
(uint)CTFMean.ElementsSliceReal,
(uint)DimsRegion.X,
new[] { new CTF().ToStruct() },
new CTF().ToStruct(),
0,
(uint)DimsRegion.X / 2,
null,
1,
CTFAverage1D.GetDevice(Intent.Write));
//CTFAverage1D.WriteMRC("CTFAverage1D.mrc");
float[] CTFAverage1DData = CTFAverage1D.GetHost(Intent.Read)[0];
float2[] ForPS1D = new float2[DimsRegion.X / 2];
for (int i = 0; i < ForPS1D.Length; i++)
ForPS1D[i] = new float2((float)i / DimsRegion.X, (float)Math.Round(CTFAverage1DData[i], 4));
_PS1D = ForPS1D;
CTFAverage1D.Dispose();
}
#endregion
#region Background fitting methods
Action UpdateBackgroundFit = () =>
{
float2[] ForPS1D = PS1D.Skip(Math.Max(5, MinFreqInclusive / 2)).ToArray();
Cubic1D.FitCTF(ForPS1D,
v => v.Select(x => CTF.Get1D(x / (float)CTF.PixelSize, true)).ToArray(),
CTF.GetZeros(),
CTF.GetPeaks(),
out _SimulatedBackground,
out _SimulatedScale);
};
Action<bool> UpdateRotationalAverage = keepbackground =>
{
float[] MeanData = CTFMean.GetHost(Intent.Read)[0];
Image CTFMeanCorrected = new Image(new int3(DimsRegion), true);
float[] MeanCorrectedData = CTFMeanCorrected.GetHost(Intent.Write)[0];
// Subtract current background estimate from spectra, populate coords.
Helper.ForEachElementFT(DimsRegion,
(x, y, xx, yy, r, a) =>
{
int i = y * (DimsRegion.X / 2 + 1) + x;
MeanCorrectedData[i] = MeanData[i] - _SimulatedBackground.Interp(r / DimsRegion.X);
});
Image CTFAverage1D = new Image(IntPtr.Zero, new int3(DimsRegion.X / 2, 1, 1));
GPU.CTFMakeAverage(CTFMeanCorrected.GetDevice(Intent.Read),
CTFCoordsCart.GetDevice(Intent.Read),
(uint)CTFMeanCorrected.DimsEffective.ElementsSlice(),
(uint)DimsRegion.X,
new[] { CTF.ToStruct() },
CTF.ToStruct(),
0,
(uint)DimsRegion.X / 2,
null,
1,
CTFAverage1D.GetDevice(Intent.Write));
//CTFAverage1D.WriteMRC("CTFAverage1D.mrc");
float[] RotationalAverageData = CTFAverage1D.GetHost(Intent.Read)[0];
float2[] ForPS1D = new float2[PS1D.Length];
if (keepbackground)
for (int i = 0; i < ForPS1D.Length; i++)
ForPS1D[i] = new float2((float)i / DimsRegion.X, RotationalAverageData[i] + _SimulatedBackground.Interp((float)i / DimsRegion.X));
else
for (int i = 0; i < ForPS1D.Length; i++)
ForPS1D[i] = new float2((float)i / DimsRegion.X, RotationalAverageData[i]);
MathHelper.UnNaN(ForPS1D);
_PS1D = ForPS1D;
CTFMeanCorrected.Dispose();
CTFAverage1D.Dispose();
};
#endregion
// Fit background to currently best average (not corrected for astigmatism yet).
{
float2[] ForPS1D = PS1D.Skip(MinFreqInclusive).Take(Math.Max(2, NFreq / 2)).ToArray();
int NumNodes = Math.Max(3, (int)((MainWindow.Options.CTFRangeMax - MainWindow.Options.CTFRangeMin) * 5M));
_SimulatedBackground = Cubic1D.Fit(ForPS1D, NumNodes); // This won't fit falloff and scale, because approx function is 0
float[] CurrentBackground = _SimulatedBackground.Interp(PS1D.Select(p => p.X).ToArray()).Skip(MinFreqInclusive).Take(NFreq / 2).ToArray();
float[] Subtracted1D = new float[ForPS1D.Length];
for (int i = 0; i < ForPS1D.Length; i++)
Subtracted1D[i] = ForPS1D[i].Y - CurrentBackground[i];
MathHelper.NormalizeInPlace(Subtracted1D);
float ZMin = (float)MainWindow.Options.CTFZMin;
float ZMax = (float)MainWindow.Options.CTFZMax;
float ZStep = (ZMax - ZMin) / 100f;
float BestZ = 0, BestPhase = 0, BestScore = -999;
for (float z = ZMin; z <= ZMax + 1e-5f; z += ZStep)
{
for (float p = 0; p <= (MainWindow.Options.CTFDoPhase ? 1f : 0f); p += 0.01f)
{
CTF CurrentParams = new CTF
{
PixelSize = (MainWindow.Options.CTFPixelMin + MainWindow.Options.CTFPixelMax) * 0.5M,
Defocus = (decimal)z,
PhaseShift = (decimal)p,
Cs = MainWindow.Options.CTFCs,
Voltage = MainWindow.Options.CTFVoltage,
Amplitude = MainWindow.Options.CTFAmplitude
};
float[] SimulatedCTF = CurrentParams.Get1D(PS1D.Length, true).Skip(MinFreqInclusive).Take(Math.Max(2, NFreq / 2)).ToArray();
MathHelper.NormalizeInPlace(SimulatedCTF);
float Score = MathHelper.CrossCorrelate(Subtracted1D, SimulatedCTF);
if (Score > BestScore)
{
BestScore = Score;
BestZ = z;
BestPhase = p;
}
}
}
CTF = new CTF
{
PixelSize = (MainWindow.Options.CTFPixelMin + MainWindow.Options.CTFPixelMax) * 0.5M,
Defocus = (decimal)BestZ,
PhaseShift = (decimal)BestPhase,
Cs = MainWindow.Options.CTFCs,
Voltage = MainWindow.Options.CTFVoltage,
Amplitude = MainWindow.Options.CTFAmplitude
};
UpdateRotationalAverage(true); // This doesn't have a nice background yet.
UpdateBackgroundFit(); // Now get a reasonably nice background.
}
// Fit defocus, (phase shift), (astigmatism) to average background-subtracted spectrum,
// which is in polar coords at this point (for equal weighting of all frequencies).
#region Grid search
{
Image CTFMeanPolarTrimmed = CTFMean.AsPolar((uint)MinFreqInclusive, (uint)(MinFreqInclusive + NFreq / 1));
// Subtract current background.
Image CurrentBackground = new Image(_SimulatedBackground.Interp(PS1D.Select(p => p.X).ToArray()).Skip(MinFreqInclusive).Take(NFreq / 1).ToArray());
CTFMeanPolarTrimmed.SubtractFromLines(CurrentBackground);
CurrentBackground.Dispose();
/*Image WaterMask = new Image(new int3(NFreq, 1, 1));
float[] WaterData = WaterMask.GetHost(Intent.Write)[0];
for (int i = 0; i < NFreq; i++)
{
float f = (i + MinFreqInclusive) / (float)DimsRegion.X * 2f;
WaterData[i] = f > 0.2f && f < 0.6f ? 0f : 1f;
}
//CTFMeanPolarTrimmed.MultiplyLines(WaterMask);
WaterMask.Dispose();*/
// Normalize for CC (not strictly needed, but it's converted for fp16 later, so let's be on the safe side of the fp16 range.
GPU.Normalize(CTFMeanPolarTrimmed.GetDevice(Intent.Read), CTFMeanPolarTrimmed.GetDevice(Intent.Write), (uint)CTFMeanPolarTrimmed.ElementsReal, 1);
//CTFMeanPolarTrimmed.WriteMRC("ctfmeanpolartrimmed.mrc");
CTF StartParams = new CTF
{
PixelSize = (MainWindow.Options.CTFPixelMin + MainWindow.Options.CTFPixelMax) * 0.5M,
PixelSizeDelta = Math.Abs(MainWindow.Options.CTFPixelMax - MainWindow.Options.CTFPixelMin),
PixelSizeAngle = MainWindow.Options.CTFPixelAngle,
Defocus = CTF.Defocus,// (MainWindow.Options.CTFZMin + MainWindow.Options.CTFZMax) * 0.5M,
DefocusDelta = doastigmatism ? 0 : MainWindow.Options.CTFAstigmatism,
DefocusAngle = doastigmatism ? 0 : MainWindow.Options.CTFAstigmatismAngle,
Cs = MainWindow.Options.CTFCs,
Voltage = MainWindow.Options.CTFVoltage,
Amplitude = MainWindow.Options.CTFAmplitude
};
CTFFitStruct FitParams = new CTFFitStruct
{
//Pixelsize = new float3(-0.02e-10f, 0.02e-10f, 0.01e-10f),
//Pixeldelta = new float3(0.0f, 0.02e-10f, 0.01e-10f),
//Pixelangle = new float3(0, 2 * (float)Math.PI, 1 * (float)Math.PI / 18),
//Defocus = new float3((float)(MainWindow.Options.CTFZMin - StartParams.Defocus) * 1e-6f,
// (float)(MainWindow.Options.CTFZMax - StartParams.Defocus) * 1e-6f,
// 0.025e-6f),
Defocus = new float3(-0.4e-6f,
0.4e-6f,
0.025e-6f),
Defocusdelta = doastigmatism ? new float3(0, 0.8e-6f, 0.02e-6f) : new float3(0, 0, 0),
Astigmatismangle = doastigmatism ? new float3(0, 2 * (float)Math.PI, 1 * (float)Math.PI / 18) : new float3(0, 0, 0),
Phaseshift = MainWindow.Options.CTFDoPhase ? new float3(0, (float)Math.PI, 0.025f * (float)Math.PI) : new float3(0, 0, 0)
};
CTFStruct ResultStruct = GPU.CTFFitMean(CTFMeanPolarTrimmed.GetDevice(Intent.Read),
CTFCoordsPolarTrimmed.GetDevice(Intent.Read),
CTFMeanPolarTrimmed.DimsSlice,
StartParams.ToStruct(),
FitParams,
doastigmatism);
CTF.FromStruct(ResultStruct);
CTF.Defocus = Math.Max(CTF.Defocus, MainWindow.Options.CTFZMin);
CTFMeanPolarTrimmed.Dispose();
UpdateRotationalAverage(true); // This doesn't have a nice background yet.
UpdateBackgroundFit(); // Now get a reasonably nice background.
UpdateRotationalAverage(true); // This time, with the nice background.
UpdateBackgroundFit(); // Make the background even nicer!
}
#endregion
/*for (int i = 0; i < PS1D.Length; i++)
PS1D[i].Y -= SimulatedBackground.Interp(PS1D[i].X);
SimulatedBackground = new Cubic1D(SimulatedBackground.Data.Select(v => new float2(v.X, 0f)).ToArray());
OnPropertyChanged("PS1D");
CTFSpectra.Dispose();
CTFMean.Dispose();
CTFCoordsCart.Dispose();
CTFCoordsPolarTrimmed.Dispose();
Simulated1D = GetSimulated1D();
CTFQuality = GetCTFQuality();
return;*/
// Do BFGS optimization of defocus, astigmatism and phase shift,
// using 2D simulation for comparison
#region BFGS
bool[] CTFSpectraConsider = new bool[CTFSpectraGrid.Elements()];
for (int i = 0; i < CTFSpectraConsider.Length; i++)
CTFSpectraConsider[i] = true;
int NCTFSpectraConsider = CTFSpectraConsider.Length;
GridCTF = new CubicGrid(GridCTF.Dimensions, (float)CTF.Defocus, (float)CTF.Defocus, Dimension.X);
GridCTFPhase = new CubicGrid(GridCTFPhase.Dimensions, (float)CTF.PhaseShift, (float)CTF.PhaseShift, Dimension.X);
for (int preciseFit = 2; preciseFit < 3; preciseFit++)
{
NFreq = (MaxFreqExclusive - MinFreqInclusive) * (preciseFit + 1) / 3;
//if (preciseFit >= 2)
// NFreq = MaxFreqExclusive - MinFreqInclusive;
Image CTFSpectraPolarTrimmed = CTFSpectra.AsPolar((uint)MinFreqInclusive, (uint)(MinFreqInclusive + NFreq));
CTFSpectra.FreeDevice(); // This will only be needed again for the final PS1D.
#region Create background and scale
float[] CurrentScale = _SimulatedScale.Interp(PS1D.Select(p => p.X).ToArray());
Image CTFSpectraScale = new Image(new int3(NFreq, DimsRegion.X, 1));
float[] CTFSpectraScaleData = CTFSpectraScale.GetHost(Intent.Write)[0];
// Trim polar to relevant frequencies, and populate coordinates.
Parallel.For(0, DimsRegion.X, y =>
{
float Angle = ((float)y / DimsRegion.X + 0.5f) * (float)Math.PI;
for (int x = 0; x < NFreq; x++)
CTFSpectraScaleData[y * NFreq + x] = CurrentScale[x + MinFreqInclusive];
});
//CTFSpectraScale.WriteMRC("ctfspectrascale.mrc");
// Background is just 1 line since we're in polar.
Image CurrentBackground = new Image(_SimulatedBackground.Interp(PS1D.Select(p => p.X).ToArray()).Skip(MinFreqInclusive).Take(NFreq).ToArray());
#endregion
CTFSpectraPolarTrimmed.SubtractFromLines(CurrentBackground);
CurrentBackground.Dispose();
// Normalize background-subtracted spectra.
GPU.Normalize(CTFSpectraPolarTrimmed.GetDevice(Intent.Read),
CTFSpectraPolarTrimmed.GetDevice(Intent.Write),
(uint)CTFSpectraPolarTrimmed.ElementsSliceReal,
(uint)CTFSpectraGrid.Elements());
//CTFSpectraPolarTrimmed.WriteMRC("ctfspectrapolartrimmed.mrc");
#region Convert to fp16
Image CTFSpectraPolarTrimmedHalf = CTFSpectraPolarTrimmed.AsHalf();
CTFSpectraPolarTrimmed.Dispose();
Image CTFSpectraScaleHalf = CTFSpectraScale.AsHalf();
CTFSpectraScale.Dispose();
Image CTFCoordsPolarTrimmedHalf = CTFCoordsPolarTrimmed.AsHalf();
#endregion
// Wiggle weights show how the defocus on the spectra grid is altered
// by changes in individual anchor points of the spline grid.
// They are used later to compute the dScore/dDefocus values for each spectrum
// only once, and derive the values for each anchor point from them.
float[][] WiggleWeights = GridCTF.GetWiggleWeights(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 1f / (CTFGridZ + 1)));
float[][] WiggleWeightsPhase = GridCTFPhase.GetWiggleWeights(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 1f / (CTFGridZ + 1)));
// Helper method for getting CTFStructs for the entire spectra grid.
Func<double[], CTF, float[], float[], CTFStruct[]> EvalGetCTF = (input, ctf, defocusValues, phaseValues) =>
{
decimal AlteredDelta = (decimal)input[input.Length - 2];
decimal AlteredAngle = (decimal)(input[input.Length - 1] * 20 / (Math.PI / 180));
CTF Local = ctf.GetCopy();
Local.DefocusDelta = AlteredDelta;
Local.DefocusAngle = AlteredAngle;
CTFStruct LocalStruct = Local.ToStruct();
CTFStruct[] LocalParams = new CTFStruct[defocusValues.Length];
for (int i = 0; i < LocalParams.Length; i++)
{
LocalParams[i] = LocalStruct;
LocalParams[i].Defocus = defocusValues[i] * -1e-6f;
LocalParams[i].PhaseShift = phaseValues[i] * (float)Math.PI;
}
return LocalParams;
};
// Simulate with adjusted CTF, compare to originals
#region Eval and Gradient methods
float BorderZ = 0.5f / CTFGridZ;
Func<double[], double> Eval = input =>
{
CubicGrid Altered = new CubicGrid(GridCTF.Dimensions, input.Take((int)GridCTF.Dimensions.Elements()).Select(v => (float)v).ToArray());
float[] DefocusValues = Altered.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, BorderZ));
CubicGrid AlteredPhase = new CubicGrid(GridCTFPhase.Dimensions, input.Skip((int)GridCTF.Dimensions.Elements()).Take((int)GridCTFPhase.Dimensions.Elements()).Select(v => (float)v).ToArray());
float[] PhaseValues = AlteredPhase.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, BorderZ));
CTFStruct[] LocalParams = EvalGetCTF(input, CTF, DefocusValues, PhaseValues);
float[] Result = new float[LocalParams.Length];
GPU.CTFCompareToSim(CTFSpectraPolarTrimmedHalf.GetDevice(Intent.Read),
CTFCoordsPolarTrimmedHalf.GetDevice(Intent.Read),
CTFSpectraScaleHalf.GetDevice(Intent.Read),
(uint)CTFSpectraPolarTrimmedHalf.ElementsSliceReal,
LocalParams,
Result,
(uint)LocalParams.Length);
float Score = 0;
for (int i = 0; i < Result.Length; i++)
if (CTFSpectraConsider[i])
Score += Result[i];
Score /= NCTFSpectraConsider;
if (float.IsNaN(Score) || float.IsInfinity(Score))
throw new Exception("Bad score.");
return (1.0 - Score) * 1000.0;
};
Func<double[], double[]> Gradient = input =>
{
const float Step = 0.005f;
double[] Result = new double[input.Length];
// In 0D grid case, just get gradient for all 4 parameters.
// In 1+D grid case, do simple gradient for astigmatism and phase...
int StartComponent = input.Length - 2;
//int StartComponent = 0;
for (int i = StartComponent; i < input.Length; i++)
{
double[] UpperInput = new double[input.Length];
input.CopyTo(UpperInput, 0);
UpperInput[i] += Step;
double UpperValue = Eval(UpperInput);
double[] LowerInput = new double[input.Length];
input.CopyTo(LowerInput, 0);
LowerInput[i] -= Step;
double LowerValue = Eval(LowerInput);
Result[i] = (UpperValue - LowerValue) / (2f * Step);
}
float[] ResultPlus = new float[CTFSpectraGrid.Elements()];
float[] ResultMinus = new float[CTFSpectraGrid.Elements()];
// ..., take shortcut for defoci...
{
CubicGrid AlteredPhase = new CubicGrid(GridCTFPhase.Dimensions, input.Skip((int)GridCTF.Dimensions.Elements()).Take((int)GridCTFPhase.Dimensions.Elements()).Select(v => (float)v).ToArray());
float[] PhaseValues = AlteredPhase.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, BorderZ));
{
CubicGrid AlteredPlus = new CubicGrid(GridCTF.Dimensions, input.Take((int)GridCTF.Dimensions.Elements()).Select(v => (float)v + Step).ToArray());
float[] DefocusValues = AlteredPlus.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, BorderZ));
CTFStruct[] LocalParams = EvalGetCTF(input, CTF, DefocusValues, PhaseValues);
GPU.CTFCompareToSim(CTFSpectraPolarTrimmedHalf.GetDevice(Intent.Read),
CTFCoordsPolarTrimmedHalf.GetDevice(Intent.Read),
CTFSpectraScaleHalf.GetDevice(Intent.Read),
(uint)CTFSpectraPolarTrimmedHalf.ElementsSliceReal,
LocalParams,
ResultPlus,
(uint)LocalParams.Length);
}
{
CubicGrid AlteredMinus = new CubicGrid(GridCTF.Dimensions, input.Take((int)GridCTF.Dimensions.Elements()).Select(v => (float)v - Step).ToArray());
float[] DefocusValues = AlteredMinus.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, BorderZ));
CTFStruct[] LocalParams = EvalGetCTF(input, CTF, DefocusValues, PhaseValues);
GPU.CTFCompareToSim(CTFSpectraPolarTrimmedHalf.GetDevice(Intent.Read),
CTFCoordsPolarTrimmedHalf.GetDevice(Intent.Read),
CTFSpectraScaleHalf.GetDevice(Intent.Read),
(uint)CTFSpectraPolarTrimmedHalf.ElementsSliceReal,
LocalParams,
ResultMinus,
(uint)LocalParams.Length);
}
float[] LocalGradients = new float[ResultPlus.Length];
for (int i = 0; i < LocalGradients.Length; i++)
LocalGradients[i] = ResultMinus[i] - ResultPlus[i];
// Now compute gradients per grid anchor point using the precomputed individual gradients and wiggle factors.
Parallel.For(0, GridCTF.Dimensions.Elements(), i => Result[i] = MathHelper.ReduceWeighted(LocalGradients, WiggleWeights[i]) / LocalGradients.Length / (2f * Step) * 1000f);
}
// ..., and take shortcut for phases.
if (MainWindow.Options.CTFDoPhase)
{
CubicGrid AlteredPlus = new CubicGrid(GridCTF.Dimensions, input.Take((int)GridCTF.Dimensions.Elements()).Select(v => (float)v).ToArray());
float[] DefocusValues = AlteredPlus.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, BorderZ));
{
CubicGrid AlteredPhasePlus = new CubicGrid(GridCTFPhase.Dimensions, input.Skip((int)GridCTF.Dimensions.Elements()).Take((int)GridCTFPhase.Dimensions.Elements()).Select(v => (float)v + Step).ToArray());
float[] PhaseValues = AlteredPhasePlus.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, BorderZ));
CTFStruct[] LocalParams = EvalGetCTF(input, CTF, DefocusValues, PhaseValues);
GPU.CTFCompareToSim(CTFSpectraPolarTrimmedHalf.GetDevice(Intent.Read),
CTFCoordsPolarTrimmedHalf.GetDevice(Intent.Read),
CTFSpectraScaleHalf.GetDevice(Intent.Read),
(uint)CTFSpectraPolarTrimmedHalf.ElementsSliceReal,
LocalParams,
ResultPlus,
(uint)LocalParams.Length);
}
{
CubicGrid AlteredPhaseMinus = new CubicGrid(GridCTFPhase.Dimensions, input.Skip((int)GridCTF.Dimensions.Elements()).Take((int)GridCTFPhase.Dimensions.Elements()).Select(v => (float)v - Step).ToArray());
float[] PhaseValues = AlteredPhaseMinus.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, BorderZ));
CTFStruct[] LocalParams = EvalGetCTF(input, CTF, DefocusValues, PhaseValues);
GPU.CTFCompareToSim(CTFSpectraPolarTrimmedHalf.GetDevice(Intent.Read),
CTFCoordsPolarTrimmedHalf.GetDevice(Intent.Read),
CTFSpectraScaleHalf.GetDevice(Intent.Read),
(uint)CTFSpectraPolarTrimmedHalf.ElementsSliceReal,
LocalParams,
ResultMinus,
(uint)LocalParams.Length);
}
float[] LocalGradients = new float[ResultPlus.Length];
for (int i = 0; i < LocalGradients.Length; i++)
LocalGradients[i] = ResultMinus[i] - ResultPlus[i];
// Now compute gradients per grid anchor point using the precomputed individual gradients and wiggle factors.
Parallel.For(0, GridCTFPhase.Dimensions.Elements(), i => Result[i + GridCTF.Dimensions.Elements()] = MathHelper.ReduceWeighted(LocalGradients, WiggleWeightsPhase[i]) / LocalGradients.Length / (2f * Step) * 1000f);
}
foreach (var i in Result)
if (double.IsNaN(i) || double.IsInfinity(i))
throw new Exception("Bad score.");
return Result;
};
#endregion
#region Minimize first time with potential outpiers
double[] StartParams = new double[GridCTF.Dimensions.Elements() + GridCTFPhase.Dimensions.Elements() + 2];
for (int i = 0; i < GridCTF.Dimensions.Elements(); i++)
StartParams[i] = GridCTF.FlatValues[i];
for (int i = 0; i < GridCTFPhase.Dimensions.Elements(); i++)
StartParams[i + GridCTF.Dimensions.Elements()] = GridCTFPhase.FlatValues[i];
StartParams[StartParams.Length - 2] = (double)CTF.DefocusDelta;
StartParams[StartParams.Length - 1] = (double)CTF.DefocusAngle / 20 * (Math.PI / 180);
// Compute correlation for individual spectra, and throw away those that are >.75 sigma worse than mean.
#region Discard outliers
if (CTFSpace || CTFTime)
{
CubicGrid Altered = new CubicGrid(GridCTF.Dimensions, StartParams.Take((int)GridCTF.Dimensions.Elements()).Select(v => (float)v).ToArray());
float[] DefocusValues = Altered.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, BorderZ));
CubicGrid AlteredPhase = new CubicGrid(GridCTFPhase.Dimensions, StartParams.Skip((int)GridCTF.Dimensions.Elements()).Take((int)GridCTFPhase.Dimensions.Elements()).Select(v => (float)v).ToArray());
float[] PhaseValues = AlteredPhase.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, BorderZ));
CTFStruct[] LocalParams = EvalGetCTF(StartParams, CTF, DefocusValues, PhaseValues);
float[] Result = new float[LocalParams.Length];
GPU.CTFCompareToSim(CTFSpectraPolarTrimmedHalf.GetDevice(Intent.Read),
CTFCoordsPolarTrimmedHalf.GetDevice(Intent.Read),
CTFSpectraScaleHalf.GetDevice(Intent.Read),
(uint)CTFSpectraPolarTrimmedHalf.ElementsSliceReal,
LocalParams,
Result,
(uint)LocalParams.Length);
float MeanResult = MathHelper.Mean(Result);
float StdResult = MathHelper.StdDev(Result);
CTFSpectraConsider = new bool[CTFSpectraGrid.Elements()];
Parallel.For(0, CTFSpectraConsider.Length, i =>
{
//if (Result[i] > MeanResult - StdResult * 1.5f)
CTFSpectraConsider[i] = true;
/*else
{
CTFSpectraConsider[i] = false;
for (int j = 0; j < WiggleWeights.Length; j++)
// Make sure the spectrum's gradient doesn't affect the overall gradient.
WiggleWeights[j][i] = 0;
}*/
});
NCTFSpectraConsider = CTFSpectraConsider.Where(v => v).Count();
}
#endregion
BroydenFletcherGoldfarbShanno Optimizer = new BroydenFletcherGoldfarbShanno(StartParams.Length, Eval, Gradient)
{
Past = 1,
Delta = 1e-6,
MaxLineSearch = 15,
Corrections = 20
};
Optimizer.Minimize(StartParams);
#endregion
#region Retrieve parameters
CTF.Defocus = (decimal)MathHelper.Mean(Optimizer.Solution.Take((int)GridCTF.Dimensions.Elements()).Select(v => (float)v));
CTF.DefocusDelta = (decimal)Optimizer.Solution[StartParams.Length - 2];
CTF.DefocusAngle = (decimal)(Optimizer.Solution[StartParams.Length - 1] * 20 / (Math.PI / 180));
CTF.PhaseShift = (decimal)MathHelper.Mean(Optimizer.Solution.Skip((int)GridCTF.Dimensions.Elements()).Take((int)GridCTFPhase.Dimensions.Elements()).Select(v => (float)v));
if (CTF.DefocusDelta < 0)
{
CTF.DefocusAngle += 90;
CTF.DefocusDelta *= -1;
}
CTF.DefocusAngle = ((int)CTF.DefocusAngle + 180 * 99) % 180;
GridCTF = new CubicGrid(GridCTF.Dimensions, Optimizer.Solution.Take((int)GridCTF.Dimensions.Elements()).Select(v => (float)v).ToArray());
GridCTFPhase = new CubicGrid(GridCTFPhase.Dimensions, Optimizer.Solution.Skip((int)GridCTF.Dimensions.Elements()).Take((int)GridCTFPhase.Dimensions.Elements()).Select(v => (float)v).ToArray());
#endregion
// Dispose GPU resources manually because GC can't be bothered to do it in time.
CTFSpectraPolarTrimmedHalf.Dispose();
CTFCoordsPolarTrimmedHalf.Dispose();
CTFSpectraScaleHalf.Dispose();
#region Get nicer envelope fit
if (preciseFit >= 2)
{
if (!CTFSpace && !CTFTime)
{
UpdateRotationalAverage(true);
}
else
{
Image CTFSpectraBackground = new Image(new int3(DimsRegion), true);
float[] CTFSpectraBackgroundData = CTFSpectraBackground.GetHost(Intent.Write)[0];
// Construct background in Cartesian coordinates.
Helper.ForEachElementFT(DimsRegion, (x, y, xx, yy, r, a) =>
{
CTFSpectraBackgroundData[y * CTFSpectraBackground.DimsEffective.X + x] = _SimulatedBackground.Interp(r / DimsRegion.X);
});
CTFSpectra.SubtractFromSlices(CTFSpectraBackground);
float[] DefocusValues = GridCTF.GetInterpolatedNative(CTFSpectraGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, BorderZ));
CTFStruct[] LocalParams = DefocusValues.Select(v =>
{
CTF Local = CTF.GetCopy();
Local.Defocus = (decimal)v + 0.0M;
return Local.ToStruct();
}).ToArray();
Image CTFAverage1D = new Image(IntPtr.Zero, new int3(DimsRegion.X / 2, 1, 1));
CTF CTFAug = CTF.GetCopy();
CTFAug.Defocus += 0.0M;
GPU.CTFMakeAverage(CTFSpectra.GetDevice(Intent.Read),
CTFCoordsCart.GetDevice(Intent.Read),
(uint)CTFSpectra.ElementsSliceReal,
(uint)DimsRegion.X,
LocalParams,
CTFAug.ToStruct(),
0,
(uint)DimsRegion.X / 2,
CTFSpectraConsider.Select(v => v ? 1 : 0).ToArray(),
(uint)CTFSpectraGrid.Elements(),
CTFAverage1D.GetDevice(Intent.Write));
CTFSpectra.AddToSlices(CTFSpectraBackground);
float[] RotationalAverageData = CTFAverage1D.GetHost(Intent.Read)[0];
float2[] ForPS1D = new float2[PS1D.Length];
for (int i = 0; i < ForPS1D.Length; i++)
ForPS1D[i] = new float2((float)i / DimsRegion.X, (float)Math.Round(RotationalAverageData[i], 4) + _SimulatedBackground.Interp((float)i / DimsRegion.X));
MathHelper.UnNaN(ForPS1D);
_PS1D = ForPS1D;
CTFSpectraBackground.Dispose();
CTFAverage1D.Dispose();
CTFSpectra.FreeDevice();
}
CTF.Defocus = Math.Max(CTF.Defocus, MainWindow.Options.CTFZMin);
UpdateBackgroundFit();
}
#endregion
}
#endregion
// Subtract background from 2D average and write it to disk.
// This image is used for quick visualization purposes only.
#region PS2D update
{
int3 DimsAverage = new int3(DimsRegion.X, DimsRegion.X / 2, 1);
float[] Average2DData = new float[DimsAverage.Elements()];
float[] OriginalAverageData = CTFMean.GetHost(Intent.Read)[0];
for (int y = 0; y < DimsAverage.Y; y++)
{
int yy = y * y;
for (int x = 0; x < DimsAverage.Y; x++)
{
int xx = DimsRegion.X / 2 - x - 1;
xx *= xx;
float r = (float)Math.Sqrt(xx + yy) / DimsRegion.X;
Average2DData[y * DimsAverage.X + x] = OriginalAverageData[(y + DimsRegion.X / 2) * (DimsRegion.X / 2 + 1) + x] - SimulatedBackground.Interp(r);
}
for (int x = 0; x < DimsRegion.X / 2; x++)
{
int xx = x * x;
float r = (float)Math.Sqrt(xx + yy) / DimsRegion.X;
Average2DData[y * DimsAverage.X + x + DimsRegion.X / 2] = OriginalAverageData[(DimsRegion.X / 2 - y) * (DimsRegion.X / 2 + 1) + (DimsRegion.X / 2 - 1 - x)] - SimulatedBackground.Interp(r);
}
}
IOHelper.WriteMapFloat(PowerSpectrumPath,
new HeaderMRC
{
Dimensions = DimsAverage,
MinValue = MathHelper.Min(Average2DData),
MaxValue = MathHelper.Max(Average2DData)
},
Average2DData);
PS2DTemp = null;
OnPropertyChanged("PS2D");
}
#endregion
for (int i = 0; i < PS1D.Length; i++)
PS1D[i].Y -= SimulatedBackground.Interp(PS1D[i].X);
SimulatedBackground = new Cubic1D(SimulatedBackground.Data.Select(v => new float2(v.X, 0f)).ToArray());
OnPropertyChanged("PS1D");
CTFSpectra.Dispose();
CTFMean.Dispose();
CTFCoordsCart.Dispose();
CTFCoordsPolarTrimmed.Dispose();
Simulated1D = GetSimulated1D();
CTFQuality = GetCTFQuality();
SaveMeta();
}
public void ProcessShift(MapHeader originalHeader, Image originalStack, decimal scaleFactor)
{
// Deal with dimensions and grids.
int NFrames = originalHeader.Dimensions.Z;
int2 DimsImage = new int2(originalHeader.Dimensions);
int2 DimsRegion = new int2(768, 768);
float OverlapFraction = 0.0f;
int2 DimsPositionGrid;
int3[] PositionGrid = Helper.GetEqualGridSpacing(DimsImage, DimsRegion, OverlapFraction, out DimsPositionGrid);
//PositionGrid = new[] { new int3(0, 0, 0) };
//DimsPositionGrid = new int2(1, 1);
int NPositions = PositionGrid.Length;
int ShiftGridX = 1;
int ShiftGridY = 1;
int ShiftGridZ = Math.Min(NFrames, MainWindow.Options.GridMoveZ);
GridMovementX = new CubicGrid(new int3(ShiftGridX, ShiftGridY, ShiftGridZ));
GridMovementY = new CubicGrid(new int3(ShiftGridX, ShiftGridY, ShiftGridZ));
int LocalGridX = Math.Min(DimsPositionGrid.X, MainWindow.Options.GridMoveX);
int LocalGridY = Math.Min(DimsPositionGrid.Y, MainWindow.Options.GridMoveY);
int LocalGridZ = Math.Min(2, NFrames);
GridLocalX = new CubicGrid(new int3(LocalGridX, LocalGridY, LocalGridZ));
GridLocalY = new CubicGrid(new int3(LocalGridX, LocalGridY, LocalGridZ));
int3 ShiftGrid = new int3(DimsPositionGrid.X, DimsPositionGrid.Y, NFrames);
int MinFreqInclusive = (int)(MainWindow.Options.MovementRangeMin * DimsRegion.X / 2);
int MaxFreqExclusive = (int)(MainWindow.Options.MovementRangeMax * DimsRegion.X / 2);
int NFreq = MaxFreqExclusive - MinFreqInclusive;
int CentralFrame = NFrames / 2;
int MaskExpansions = Math.Max(1, ShiftGridZ / 3);
int[] MaskSizes = new int[MaskExpansions];
// Allocate memory and create all prerequisites:
int MaskLength;
Image ShiftFactors;
Image Phases;
Image PhasesAverage;
Image Shifts;
{
List<long> Positions = new List<long>();
List<float2> Factors = new List<float2>();
List<float2> Freq = new List<float2>();
int Min2 = MinFreqInclusive * MinFreqInclusive;
int Max2 = MaxFreqExclusive * MaxFreqExclusive;
float PixelSize = (float)(MainWindow.Options.CTFPixelMin + MainWindow.Options.CTFPixelMax) * 0.5f;
float PixelDelta = (float)(MainWindow.Options.CTFPixelMax - MainWindow.Options.CTFPixelMin) * 0.5f;
float PixelAngle = (float)MainWindow.Options.CTFPixelAngle;
for (int y = 0; y < DimsRegion.Y; y++)
{
int yy = y - DimsRegion.X / 2;
for (int x = 0; x < DimsRegion.X / 2 + 1; x++)
{
int xx = x - DimsRegion.X / 2;
int r2 = xx * xx + yy * yy;
if (r2 >= Min2 && r2 < Max2)
{
Positions.Add(y * (DimsRegion.X / 2 + 1) + x);
Factors.Add(new float2((float)xx / DimsRegion.X * 2f * (float)Math.PI,
(float)yy / DimsRegion.X * 2f * (float)Math.PI));
float Angle = (float)Math.Atan2(yy, xx);
float r = (float)Math.Sqrt(r2);
Freq.Add(new float2(r, Angle));
}
}
}
// Sort everyone with ascending distance from center.
List<KeyValuePair<float, int>> FreqIndices = Freq.Select((v, i) => new KeyValuePair<float, int>(v.X, i)).ToList();
FreqIndices.Sort((a, b) => a.Key.CompareTo(b.Key));
int[] SortedIndices = FreqIndices.Select(v => v.Value).ToArray();
Helper.Reorder(Positions, SortedIndices);
Helper.Reorder(Factors, SortedIndices);
Helper.Reorder(Freq, SortedIndices);
float Bfac = (float)MainWindow.Options.MovementBfactor * 0.25f / PixelSize / DimsRegion.X;
float2[] BfacWeightsData = Freq.Select(v => (float)Math.Exp(v.X * Bfac)).Select(v => new float2(v, v)).ToArray();
Image BfacWeights = new Image(Helper.ToInterleaved(BfacWeightsData), false, false, false);
long[] RelevantMask = Positions.ToArray();
ShiftFactors = new Image(Helper.ToInterleaved(Factors.ToArray()));
MaskLength = RelevantMask.Length;
// Get mask sizes for different expansion steps.
for (int i = 0; i < MaskExpansions; i++)
{
float CurrentMaxFreq = MinFreqInclusive + (MaxFreqExclusive - MinFreqInclusive) / (float)MaskExpansions * (i + 1);
MaskSizes[i] = Freq.Count(v => v.X * v.X < CurrentMaxFreq * CurrentMaxFreq);
}
Phases = new Image(IntPtr.Zero, new int3(MaskLength * 2, DimsPositionGrid.X * DimsPositionGrid.Y, NFrames), false, false, false);
GPU.CreateShift(originalStack.GetDevice(Intent.Read),
new int2(originalHeader.Dimensions),
originalHeader.Dimensions.Z,
PositionGrid,
PositionGrid.Length,
DimsRegion,
RelevantMask,
(uint)MaskLength,
Phases.GetDevice(Intent.Write));
Phases.MultiplyLines(BfacWeights);
BfacWeights.Dispose();
originalStack.FreeDevice();
PhasesAverage = new Image(IntPtr.Zero, new int3(MaskLength, NPositions, 1), false, true, false);
Shifts = new Image(new float[NPositions * NFrames * 2]);
}
#region Fit global movement
{
int MinXSteps = 1, MinYSteps = 1;
int MinZSteps = Math.Min(NFrames, 3);
int3 ExpansionGridSize = new int3(MinXSteps, MinYSteps, MinZSteps);
float[][] WiggleWeights = new CubicGrid(ExpansionGridSize).GetWiggleWeights(ShiftGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0f));
double[] StartParams = new double[ExpansionGridSize.Elements() * 2];
for (int m = 0; m < MaskExpansions; m++)
{
double[] LastAverage = null;
Action<double[]> SetPositions = input =>
{
// Construct CubicGrids and get interpolated shift values.
CubicGrid AlteredGridX = new CubicGrid(ExpansionGridSize, input.Where((v, i) => i % 2 == 0).Select(v => (float)v).ToArray());
float[] AlteredX = AlteredGridX.GetInterpolatedNative(new int3(DimsPositionGrid.X, DimsPositionGrid.Y, NFrames),
new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0f));
CubicGrid AlteredGridY = new CubicGrid(ExpansionGridSize, input.Where((v, i) => i % 2 == 1).Select(v => (float)v).ToArray());
float[] AlteredY = AlteredGridY.GetInterpolatedNative(new int3(DimsPositionGrid.X, DimsPositionGrid.Y, NFrames),
new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0f));
// Let movement start at 0 in the central frame.
/*float2[] CenterFrameOffsets = new float2[NPositions];
for (int i = 0; i < NPositions; i++)
CenterFrameOffsets[i] = new float2(AlteredX[CentralFrame * NPositions + i], AlteredY[CentralFrame * NPositions + i]);*/
// Finally, set the shift values in the device array.
float[] ShiftData = Shifts.GetHost(Intent.Write)[0];
Parallel.For(0, AlteredX.Length, i =>
{
ShiftData[i * 2] = AlteredX[i];// - CenterFrameOffsets[i % NPositions].X;
ShiftData[i * 2 + 1] = AlteredY[i];// - CenterFrameOffsets[i % NPositions].Y;
});
};
Action<double[]> DoAverage = input =>
{
if (LastAverage == null || input.Where((t, i) => t != LastAverage[i]).Any())
{
SetPositions(input);
GPU.ShiftGetAverage(Phases.GetDevice(Intent.Read),
PhasesAverage.GetDevice(Intent.Write),
ShiftFactors.GetDevice(Intent.Read),
(uint)MaskLength,
(uint)MaskSizes[m],
Shifts.GetDevice(Intent.Read),
(uint)NPositions,
(uint)NFrames);
if (LastAverage == null)
LastAverage = new double[input.Length];
Array.Copy(input, LastAverage, input.Length);
}
};
Func<double[], double> Eval = input =>
{
DoAverage(input);
float[] Diff = new float[NPositions * NFrames];
GPU.ShiftGetDiff(Phases.GetDevice(Intent.Read),
PhasesAverage.GetDevice(Intent.Read),
ShiftFactors.GetDevice(Intent.Read),
(uint)MaskLength,
(uint)MaskSizes[m],
Shifts.GetDevice(Intent.Read),
Diff,
(uint)NPositions,
(uint)NFrames);
for (int i = 0; i < Diff.Length; i++)
Diff[i] = Diff[i];// * 100f;
return Diff.Sum();
};
Func<double[], double[]> Grad = input =>
{
DoAverage(input);
float[] GradX = new float[NPositions * NFrames], GradY = new float[NPositions * NFrames];
float[] Diff = new float[NPositions * NFrames * 2];
GPU.ShiftGetGrad(Phases.GetDevice(Intent.Read),
PhasesAverage.GetDevice(Intent.Read),
ShiftFactors.GetDevice(Intent.Read),
(uint)MaskLength,
(uint)MaskSizes[m],
Shifts.GetDevice(Intent.Read),
Diff,
(uint)NPositions,
(uint)NFrames);
//for (int i = 0; i < Diff.Length; i++)
//Diff[i] = Diff[i] * 100f;
for (int i = 0; i < GradX.Length; i++)
{
GradX[i] = Diff[i * 2];
GradY[i] = Diff[i * 2 + 1];
}
double[] Result = new double[input.Length];
Parallel.For(0, input.Length / 2, i =>
{
Result[i * 2] = MathHelper.ReduceWeighted(GradX, WiggleWeights[i]);
Result[i * 2 + 1] = MathHelper.ReduceWeighted(GradY, WiggleWeights[i]);
});
return Result;
};
/*Func<double[], double[]> Grad = input =>
{
DoAverage(input);
float[] GradX = new float[NPositions * NFrames], GradY = new float[NPositions * NFrames];
float Step = 0.002f;
{
double[] InputXP = new double[input.Length];
for (int i = 0; i < input.Length; i++)
if (i % 2 == 0)
InputXP[i] = input[i] + Step;
else
InputXP[i] = input[i];
SetPositions(InputXP);
float[] DiffXP = new float[NPositions * NFrames];
GPU.ShiftGetDiff(Phases.GetDevice(Intent.Read),
PhasesAverage.GetDevice(Intent.Read),
ShiftFactors.GetDevice(Intent.Read),
(uint)MaskLength,
(uint)MaskSizes[m],
Shifts.GetDevice(Intent.Read),
DiffXP,
(uint)NPositions,
(uint)NFrames);
double[] InputXM = new double[input.Length];
for (int i = 0; i < input.Length; i++)
if (i % 2 == 0)
InputXM[i] = input[i] - Step;
else
InputXM[i] = input[i];
SetPositions(InputXM);
float[] DiffXM = new float[NPositions * NFrames];
GPU.ShiftGetDiff(Phases.GetDevice(Intent.Read),
PhasesAverage.GetDevice(Intent.Read),
ShiftFactors.GetDevice(Intent.Read),
(uint)MaskLength,
(uint)MaskSizes[m],
Shifts.GetDevice(Intent.Read),
DiffXM,
(uint)NPositions,
(uint)NFrames);
for (int i = 0; i < GradX.Length; i++)
GradX[i] = (DiffXP[i] - DiffXM[i]) / (Step * 2);
}
{
double[] InputYP = new double[input.Length];
for (int i = 0; i < input.Length; i++)
if (i % 2 == 1)
InputYP[i] = input[i] + Step;
else
InputYP[i] = input[i];
SetPositions(InputYP);
float[] DiffYP = new float[NPositions * NFrames];
GPU.ShiftGetDiff(Phases.GetDevice(Intent.Read),
PhasesAverage.GetDevice(Intent.Read),
ShiftFactors.GetDevice(Intent.Read),
(uint)MaskLength,
(uint)MaskSizes[m],
Shifts.GetDevice(Intent.Read),
DiffYP,
(uint)NPositions,
(uint)NFrames);
double[] InputYM = new double[input.Length];
for (int i = 0; i < input.Length; i++)
if (i % 2 == 1)
InputYM[i] = input[i] - Step;
else
InputYM[i] = input[i];
SetPositions(InputYM);
float[] DiffYM = new float[NPositions * NFrames];
GPU.ShiftGetDiff(Phases.GetDevice(Intent.Read),
PhasesAverage.GetDevice(Intent.Read),
ShiftFactors.GetDevice(Intent.Read),
(uint)MaskLength,
(uint)MaskSizes[m],
Shifts.GetDevice(Intent.Read),
DiffYM,
(uint)NPositions,
(uint)NFrames);
for (int i = 0; i < GradY.Length; i++)
GradY[i] = (DiffYP[i] - DiffYM[i]) / (Step * 2);
}
double[] Result = new double[input.Length];
Parallel.For(0, input.Length / 2, i =>
{
Result[i * 2] = MathHelper.ReduceWeighted(GradX, WiggleWeights[i]);
Result[i * 2 + 1] = MathHelper.ReduceWeighted(GradY, WiggleWeights[i]);
});
return Result;
};*/
BroydenFletcherGoldfarbShanno Optimizer = new BroydenFletcherGoldfarbShanno(StartParams.Length, Eval, Grad);
Optimizer.Corrections = 20;
Optimizer.Minimize(StartParams);
float MeanX = MathHelper.Mean(Optimizer.Solution.Where((v, i) => i % 2 == 0).Select(v => (float)v));
float MeanY = MathHelper.Mean(Optimizer.Solution.Where((v, i) => i % 2 == 1).Select(v => (float)v));
for (int i = 0; i < ExpansionGridSize.Elements(); i++)
{
Optimizer.Solution[i * 2] -= MeanX;
Optimizer.Solution[i * 2 + 1] -= MeanY;
}
// Store coarse values in grids.
GridMovementX = new CubicGrid(ExpansionGridSize, Optimizer.Solution.Where((v, i) => i % 2 == 0).Select(v => (float)v).ToArray());
GridMovementY = new CubicGrid(ExpansionGridSize, Optimizer.Solution.Where((v, i) => i % 2 == 1).Select(v => (float)v).ToArray());
if (m < MaskExpansions - 1)
{
// Refine sampling.
ExpansionGridSize = new int3((int)Math.Round((float)(ShiftGridX - MinXSteps) / (MaskExpansions - 1) * (m + 1) + MinXSteps),
(int)Math.Round((float)(ShiftGridY - MinYSteps) / (MaskExpansions - 1) * (m + 1) + MinYSteps),
(int)Math.Round((float)(ShiftGridZ - MinZSteps) / (MaskExpansions - 1) * (m + 1) + MinZSteps));
WiggleWeights = new CubicGrid(ExpansionGridSize).GetWiggleWeights(ShiftGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0f));
// Resize the grids to account for finer sampling.
GridMovementX = GridMovementX.Resize(ExpansionGridSize);
GridMovementY = GridMovementY.Resize(ExpansionGridSize);
// Construct start parameters for next optimization iteration.
StartParams = new double[ExpansionGridSize.Elements() * 2];
for (int i = 0; i < ExpansionGridSize.Elements(); i++)
{
StartParams[i * 2] = GridMovementX.FlatValues[i];
StartParams[i * 2 + 1] = GridMovementY.FlatValues[i];
}
}
}
}
#endregion
// Center the global shifts
/*{
float2[] AverageShifts = new float2[ShiftGridZ];
for (int i = 0; i < AverageShifts.Length; i++)
AverageShifts[i] = new float2(MathHelper.Mean(GridMovementX.GetSliceXY(i)),
MathHelper.Mean(GridMovementY.GetSliceXY(i)));
float2 CenterShift = MathHelper.Mean(AverageShifts);
GridMovementX = new CubicGrid(GridMovementX.Dimensions, GridMovementX.FlatValues.Select(v => v - CenterShift.X).ToArray());
GridMovementY = new CubicGrid(GridMovementY.Dimensions, GridMovementY.FlatValues.Select(v => v - CenterShift.Y).ToArray());
}*/
#region Fit local movement
/*{
int MinXSteps = LocalGridX, MinYSteps = LocalGridY;
int MinZSteps = LocalGridZ;
int3 ExpansionGridSize = new int3(MinXSteps, MinYSteps, MinZSteps);
float[][] WiggleWeights = new CubicGrid(ExpansionGridSize).GetWiggleWeights(ShiftGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0f));
double[] StartParams = new double[ExpansionGridSize.Elements() * 2];
for (int m = MaskExpansions - 1; m < MaskExpansions; m++)
{
double[] LastAverage = null;
Action<double[]> SetPositions = input =>
{
// Construct CubicGrids and get interpolated shift values.
float[] GlobalX = GridMovementX.GetInterpolatedNative(new int3(DimsPositionGrid.X, DimsPositionGrid.Y, NFrames),
new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0f));
CubicGrid AlteredGridX = new CubicGrid(ExpansionGridSize, input.Where((v, i) => i % 2 == 0).Select(v => (float)v).ToArray());
float[] AlteredX = AlteredGridX.GetInterpolatedNative(new int3(DimsPositionGrid.X, DimsPositionGrid.Y, NFrames),
new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0f));
AlteredX = MathHelper.Plus(GlobalX, AlteredX);
float[] GlobalY = GridMovementY.GetInterpolatedNative(new int3(DimsPositionGrid.X, DimsPositionGrid.Y, NFrames),
new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0f));
CubicGrid AlteredGridY = new CubicGrid(ExpansionGridSize, input.Where((v, i) => i % 2 == 1).Select(v => (float)v).ToArray());
float[] AlteredY = AlteredGridY.GetInterpolatedNative(new int3(DimsPositionGrid.X, DimsPositionGrid.Y, NFrames),
new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0f));
AlteredY = MathHelper.Plus(GlobalY, AlteredY);
// Let movement start at 0 in the central frame.
float2[] CenterFrameOffsets = new float2[NPositions];
for (int i = 0; i < NPositions; i++)
CenterFrameOffsets[i] = new float2(AlteredX[CentralFrame * NPositions + i], AlteredY[CentralFrame * NPositions + i]);
// Finally, set the shift values in the device array.
float[] ShiftData = Shifts.GetHost(Intent.Write)[0];
Parallel.For(0, AlteredX.Length, i =>
{
ShiftData[i * 2] = AlteredX[i] - CenterFrameOffsets[i % NPositions].X;
ShiftData[i * 2 + 1] = AlteredY[i] - CenterFrameOffsets[i % NPositions].Y;
});
};
Action<double[]> DoAverage = input =>
{
if (LastAverage == null || input.Where((t, i) => t != LastAverage[i]).Any())
{
SetPositions(input);
GPU.ShiftGetAverage(Phases.GetDevice(Intent.Read),
PhasesAverage.GetDevice(Intent.Write),
ShiftFactors.GetDevice(Intent.Read),
(uint)MaskLength,
(uint)MaskSizes[m],
Shifts.GetDevice(Intent.Read),
(uint)NPositions,
(uint)NFrames);
if (LastAverage == null)
LastAverage = new double[input.Length];
Array.Copy(input, LastAverage, input.Length);
}
};
Func<double[], double> Eval = input =>
{
DoAverage(input);
float[] Diff = new float[NPositions * NFrames];
GPU.ShiftGetDiff(Phases.GetDevice(Intent.Read),
PhasesAverage.GetDevice(Intent.Read),
ShiftFactors.GetDevice(Intent.Read),
(uint)MaskLength,
(uint)MaskSizes[m],
Shifts.GetDevice(Intent.Read),
Diff,
(uint)NPositions,
(uint)NFrames);
for (int i = 0; i < Diff.Length; i++)
Diff[i] = Diff[i] * 100f;
return MathHelper.Mean(Diff);
};
Func<double[], double[]> Grad = input =>
{
DoAverage(input);
float[] Diff = new float[NPositions * NFrames * 2];
GPU.ShiftGetGrad(Phases.GetDevice(Intent.Read),
PhasesAverage.GetDevice(Intent.Read),
ShiftFactors.GetDevice(Intent.Read),
(uint)MaskLength,
(uint)MaskSizes[m],
Shifts.GetDevice(Intent.Read),
Diff,
(uint)NPositions,
(uint)NFrames);
for (int i = 0; i < Diff.Length; i++)
Diff[i] = Diff[i] * 100f;
float[] DiffX = new float[NPositions * NFrames], DiffY = new float[NPositions * NFrames];
for (int i = 0; i < DiffX.Length; i++)
{
DiffX[i] = Diff[i * 2];
DiffY[i] = Diff[i * 2 + 1];
}
double[] Result = new double[input.Length];
Parallel.For(0, input.Length / 2, i =>
{
Result[i * 2] = MathHelper.ReduceWeighted(DiffX, WiggleWeights[i]);
Result[i * 2 + 1] = MathHelper.ReduceWeighted(DiffY, WiggleWeights[i]);
});
return Result;
};
BroydenFletcherGoldfarbShanno Optimizer = new BroydenFletcherGoldfarbShanno(StartParams.Length, Eval, Grad);
Optimizer.Corrections = 20;
Optimizer.Minimize(StartParams);
float MeanX = MathHelper.Mean(Optimizer.Solution.Where((v, i) => i % 2 == 0).Select(v => (float)v));
float MeanY = MathHelper.Mean(Optimizer.Solution.Where((v, i) => i % 2 == 1).Select(v => (float)v));
for (int i = 0; i < ExpansionGridSize.Elements(); i++)
{
Optimizer.Solution[i * 2] -= MeanX;
Optimizer.Solution[i * 2 + 1] -= MeanY;
}
// Store coarse values in grids.
GridLocalX = new CubicGrid(ExpansionGridSize, Optimizer.Solution.Where((v, i) => i % 2 == 0).Select(v => (float)v).ToArray());
GridLocalY = new CubicGrid(ExpansionGridSize, Optimizer.Solution.Where((v, i) => i % 2 == 1).Select(v => (float)v).ToArray());
if (m < MaskExpansions - 1)
{
// Refine sampling.
ExpansionGridSize = new int3((int)Math.Round((float)(LocalGridX - MinXSteps) / (MaskExpansions - 1) * (m + 1) + MinXSteps),
(int)Math.Round((float)(LocalGridY - MinYSteps) / (MaskExpansions - 1) * (m + 1) + MinYSteps),
(int)Math.Round((float)(LocalGridZ - MinZSteps) / (MaskExpansions - 1) * (m + 1) + MinZSteps));
WiggleWeights = new CubicGrid(ExpansionGridSize).GetWiggleWeights(ShiftGrid, new float3(DimsRegion.X / 2f / DimsImage.X, DimsRegion.Y / 2f / DimsImage.Y, 0f));
// Resize the grids to account for finer sampling.
GridLocalX = GridLocalX.Resize(ExpansionGridSize);
GridLocalY = GridLocalY.Resize(ExpansionGridSize);
// Construct start parameters for next optimization iteration.
StartParams = new double[ExpansionGridSize.Elements() * 2];
for (int i = 0; i < ExpansionGridSize.Elements(); i++)
{
StartParams[i * 2] = GridLocalX.FlatValues[i];
StartParams[i * 2 + 1] = GridLocalY.FlatValues[i];
}
}
}
}*/
#endregion
ShiftFactors.Dispose();
Phases.Dispose();
PhasesAverage.Dispose();
Shifts.Dispose();
// Center the local shifts
/*{
float2[] AverageShifts = new float2[LocalGridZ];
for (int i = 0; i < AverageShifts.Length; i++)
AverageShifts[i] = new float2(MathHelper.Mean(GridLocalX.GetSliceXY(i)),
MathHelper.Mean(GridLocalY.GetSliceXY(i)));
float2 CenterShift = MathHelper.Mean(AverageShifts);
GridLocalX = new CubicGrid(GridLocalX.Dimensions, GridLocalX.FlatValues.Select(v => v - CenterShift.X).ToArray());
GridLocalY = new CubicGrid(GridLocalY.Dimensions, GridLocalY.FlatValues.Select(v => v - CenterShift.Y).ToArray());
}*/
SaveMeta();
}