/// <summary> /// Normalizes the data to a Z-Value /// </summary> /// <param name="input"></param> /// <param name="backgroundThreshold"></param> /// <returns></returns> public static INifti <float> ZNormalize(INifti <float> input, float backgroundThreshold = 10) { dynamic output = input.DeepCopy(); // We take the mean and standard deviation ignoring background. var currentMean = input.Voxels.Where(val => val > backgroundThreshold).Mean(); var currentStdDev = input.Voxels.Where(val => val > backgroundThreshold).StandardDeviation(); for (var i = 0; i < output.Voxels.Length; i++) { output.Voxels[i] = (float)((output.Voxels[i] - currentMean) / currentStdDev); } output.RecalcHeaderMinMax(); //update display range return(output); }
public static INifti <float> ANTSRegistration(INifti <float> floating, INifti <float> reference, DataReceivedEventHandler updates = null) { // Setup our temp file names. string niftiInPath = Path.GetFullPath(Tools.TEMPDIR + floating.GetHashCode() + ".antsrego.in.nii"); string niftiRefPath = Path.GetFullPath(Tools.TEMPDIR + floating.GetHashCode() + ".antsrego.ref.nii"); floating.WriteNifti(niftiInPath); reference.WriteNifti(niftiRefPath); string niftiOutPath = Path.GetFullPath(ANTSRegistration(niftiInPath, niftiRefPath, updates)); var output = floating.DeepCopy(); output = output.ReadNifti(niftiOutPath); return(output); }
/// <summary> /// Shifts the ditribution to be within the given range. Default is 0-1. /// </summary> /// <param name="input"></param> /// <param name="rangeStart"></param> /// <param name="rangeEnd"></param> /// <returns></returns> public static INifti <float> RangeNormalize(INifti <float> input, float rangeStart = 0, float rangeEnd = 1) { if (rangeEnd <= rangeStart) { throw new ArgumentException("Start of range cannot be greater than end of range."); } var min = input.Voxels.Min(); var range = input.Voxels.Max() - input.Voxels.Min(); var output = input.DeepCopy(); for (int i = 0; i < output.Voxels.Length; ++i) { output.Voxels[i] = ((output.Voxels[i] - min) / range) * (rangeEnd - rangeStart) + rangeStart; } return(output); }
/// <summary> /// Uses the BrainSuite BSE tool to extract the brain from a given INifti. /// </summary> /// <param name="input">Nifti which contains the brain to be extracted</param> /// <param name="updates">Data handler for updates from the BSE tool.</param> /// <returns>The INifti containing the extracted brain.</returns> public static INifti <float> BrainSuiteBSE(INifti <float> input, DataReceivedEventHandler updates = null) { // Setup our temp file names. string niftiInPath = Path.GetFullPath(Tools.TEMPDIR + input.GetHashCode() + ".bse.in.nii"); string niftiOutPath = Path.GetFullPath(Tools.TEMPDIR + input.GetHashCode() + ".bse.out.nii"); // Write nifti to temp directory. input.WriteNifti(niftiInPath); var args = $"--auto --trim -i \"{niftiInPath}\" -o \"{niftiOutPath}\""; ProcessBuilder.CallExecutableFile(CapiConfig.GetConfig().Binaries.bse, args, outputDataReceived: updates); var output = input.DeepCopy(); // Sometimes this messes with the header and gives us a 4-up??? output.ReadNifti(niftiOutPath); return(output); }
/// <summary> /// Uses the ANTS implementation of the N4 bias correction algorithm. /// </summary> /// <param name="input">The input nifti to be corrected</param> /// <param name="updates">Event handler for updates from the process</param> /// <returns>New, corrected nifti</returns> public static INifti <float> AntsN4(INifti <float> input, DataReceivedEventHandler updates = null) { // Setup our temp file names. string niftiInPath = Path.GetFullPath(Tools.TEMPDIR + input.GetHashCode() + ".antsN4.in.nii"); string niftiOutPath = Path.GetFullPath(Tools.TEMPDIR + input.GetHashCode() + ".antsN4.out.nii"); // Write nifti to temp directory. input.WriteNifti(niftiInPath); var args = $"-i \"{niftiInPath}\" -o \"{niftiOutPath}\""; ProcessBuilder.CallExecutableFile(CapiConfig.GetConfig().Binaries.N4BiasFieldCorrection, args, outputDataReceived: updates); var output = input.DeepCopy(); output.ReadNifti(niftiOutPath); output.RecalcHeaderMinMax(); return(output); }
private void CheckBrainExtractionMatch( INifti <float> currentNifti, INifti <float> priorNifti, INifti <float> currentNiftiWithSkull, INifti <float> priorNiftiWithSkull, MSMetrics qaResults) { var volCurrent = 0d; var volPrior = 0d; var volWSkullCurrent = 0; var volWSkullPrior = 0; for (int i = 0; i < currentNifti.Voxels.Length; ++i) { if (currentNifti.Voxels[i] > 0) { volCurrent++; } if (currentNiftiWithSkull.Voxels[i] > 30) { volWSkullCurrent++; } if (priorNifti.Voxels[i] > 0) { volPrior++; } if (priorNiftiWithSkull.Voxels[i] > 30) { volWSkullPrior++; } } var match = Math.Min(volPrior, volCurrent) / Math.Max(volPrior, volCurrent); // Add results to QA list qaResults.VoxelVolPrior = volPrior; qaResults.VoxelVolCurrent = volCurrent; qaResults.BrainMatch = match; _log.Info($@"Percentage of current volume that's brain: {(int)(volCurrent / volWSkullCurrent * 100d)}%"); _log.Info($@"Percentage of prior volume that's brain: {(int)(volPrior / volWSkullPrior * 100d)}%"); _log.Info($@"Brain extraction match: {(int)(match * 100)}%"); // If the match is sub-80% it's probably because one of the brains didn't extract so // the compare operation will automatically use the intersection of the two. On the // other hand if we're above 80% but less than 95% one of the extractions probably cut // out a chunk of brain. So we'll make a mask of the union and apply it to both sides. if (match > 0.7 && match < 0.95) { _log.Info($@"Brain extraction match not good enough, taking the union..."); // Let's try to make the brain mask an OR of the two. var mask = currentNifti.DeepCopy(); for (int i = 0; i < mask.Voxels.Length; ++i) { if (currentNifti.Voxels[i] != 0 || priorNifti.Voxels[i] != 0) { mask.Voxels[i] = 1; } else { mask.Voxels[i] = 0; } } currentNifti = currentNiftiWithSkull.DeepCopy(); priorNifti = priorNiftiWithSkull.DeepCopy(); for (int i = 0; i < currentNifti.Voxels.Length; ++i) { currentNifti.Voxels[i] = currentNifti.Voxels[i] * mask.Voxels[i]; priorNifti.Voxels[i] = priorNifti.Voxels[i] * mask.Voxels[i]; } currentNifti.RecalcHeaderMinMax(); priorNifti.RecalcHeaderMinMax(); // Check brain extraction match again... volCurrent = 0d; volPrior = 0d; for (int i = 0; i < currentNifti.Voxels.Length; ++i) { if (currentNifti.Voxels[i] > 0) { volCurrent++; } if (priorNifti.Voxels[i] > 0) { volPrior++; } } match = Math.Min(volPrior, volCurrent) / Math.Max(volPrior, volCurrent); _log.Info($@"Brain extraction match after mask: {(int)(match * 100)}%"); } else if (match < 0.7) { qaResults.Passed = false; } // In theory this should stop the skull highlights darkening the output images... priorNifti.RecalcHeaderMinMax(); currentNifti.RecalcHeaderMinMax(); priorNiftiWithSkull.Header.cal_max = priorNifti.Header.cal_max; currentNiftiWithSkull.Header.cal_max = currentNifti.Header.cal_max; }
/// <summary> /// Compares the meaningful change in value between the reference Nifti (prior) and the input Nifti (current). /// This function also allows significant fine-tuning of the cut-off values. /// </summary> /// <param name="input">Current Nifti</param> /// <param name="reference">Prior Nifti</param> /// <param name="backgroundThreshold">Absolute value of background threashold. Any voxels with a value less than this are considered background and ignored.</param> /// <param name="minRelevantStd">Minimum relevant value in number of standard deviations from the mean. e.g. a value of -1 will mean that the minimum relevant value will be the mean - 1 standard deviation. Voxels below this threashold are ignored.</param> /// <param name="maxRelevantStd">Maximum relevant value in number of standard deviations from the mean. e.g. a value of 3 will mean that the maximum relevant value will be the mean + 3 standard deviations. Voxels above this threashold are ignored.</param> /// <param name="minChange">Minimum difference to be considered significant (e.g. noise threshold). Value is given in multiples of the standard deviation for the input voxels (ignoring background).</param> /// <param name="maxChange">Maximum difference to be considered significant. Value is given in multiples of the standard deviation for the input voxels (ignoring background).</param> /// <returns>INifti object which contains the relevant difference between the reference nifti and the input nifti.</returns> public static INifti <float> GatedSubract(INifti <float> input, INifti <float> reference, float backgroundThreshold = 10, float minRelevantStd = -1, float maxRelevantStd = 5, float minChange = 0.8f, float maxChange = 5) { INifti <float> output = input.DeepCopy(); //var mean = (float)input.Voxels.Where(val => val > backgroundThreshold).MeanStandardDeviation(); var meanstddev = input.Voxels.Where(val => val > backgroundThreshold).MeanStandardDeviation(); var mean = meanstddev.Item1; var stdDev = meanstddev.Item2; //(Not sure why decompose stopped working here). //float range = input.voxels.Max() - input.voxels.Min(); // Values from trial and error.... float minRelevantValue = (float)(mean + (minRelevantStd * stdDev)); float maxRelevantValue = (float)(mean + (maxRelevantStd * stdDev)); if (input.Voxels.Length != reference.Voxels.Length) { throw new Exception("Input and reference don't match size"); } for (int i = 0; i < input.Voxels.Length; ++i) { output.Voxels[i] = input.Voxels[i] - reference.Voxels[i]; // We want to ignore changes below the minimum relevant value. if (input.Voxels[i] < minRelevantValue) { output.Voxels[i] = 0; } if (reference.Voxels[i] < minRelevantValue) { output.Voxels[i] = 0; } // And above the maximum relevant value. if (input.Voxels[i] > maxRelevantValue) { output.Voxels[i] = 0; } if (reference.Voxels[i] > maxRelevantValue) { output.Voxels[i] = 0; } // If we haven't changed by at least 1 stdDev we're not significant if (Math.Abs(output.Voxels[i]) < Math.Abs(minChange * stdDev)) { output.Voxels[i] = 0; } if (Math.Abs(output.Voxels[i]) > Math.Abs(maxChange * stdDev)) { output.Voxels[i] = 0; } if (reference.Voxels[i] < backgroundThreshold) { output.Voxels[i] = 0; } if (input.Voxels[i] < backgroundThreshold) { output.Voxels[i] = 0; } } for (int i = 1; i < output.Voxels.Length - 1; ++i) { if (output.Voxels[i - 1] == 0 && output.Voxels[i + 1] == 0) { output.Voxels[i] = 0; } } output.RecalcHeaderMinMax(); // Update header range. var stdDv = output.Voxels.StandardDeviation(); var mean2 = output.Voxels.Where(val => val > 0).Mean(); System.Console.WriteLine($"Compared. Mean={mean2}, stdDv={stdDv}, size={output.Voxels.Where(val => val > 0).Count()}"); return(output); }