/// <summary>
/// Gets a 2D slice from the 3D data.
/// </summary>
/// <param name="volume">Full 3D data.</param>
/// <param name="sliceN">Number of slice to be selected.</param>
/// <param name="axis">Axis on which selection will be made.</param>
/// <returns></returns>
public static vtkImageData volumeSlicer(vtkImageData volume, int[] sliceN, int axis)
{
//Initialize VOI extractor and permuter.
//Permuter will correct the orientation of the output image
vtkExtractVOI slicer = vtkExtractVOI.New();
vtkImagePermute permuter = vtkImagePermute.New();
//Connect data to slicer
slicer.SetInput(volume);
slicer.Update();
//Get data dimensions
int[] dims = slicer.GetOutput().GetExtent();
//Get slice
//Coronal plane
if (axis == 0)
{
//Set VOI
slicer.SetVOI(sliceN[0] - 1, sliceN[0], dims[2], dims[3], dims[4], dims[5]);
slicer.Update();
//Permute image (not necessary here)
permuter.SetInputConnection(slicer.GetOutputPort());
permuter.SetFilteredAxes(1, 2, 0);
permuter.Update();
}
//Transverse plane YZ
if (axis == 1)
{
//Set VOI
slicer.SetVOI(dims[0], dims[1], sliceN[1] - 1, sliceN[1], dims[4], dims[5]);
slicer.Update();
//Permute image
permuter.SetInputConnection(slicer.GetOutputPort());
permuter.SetFilteredAxes(0, 2, 1);
permuter.Update();
}
//Transverse plane, XZ
if (axis == 2)
{
//Set VOI
slicer.SetVOI(dims[0], dims[1], dims[2], dims[3], sliceN[2] - 1, sliceN[2]);
slicer.Update();
//Permute image
permuter.SetInputConnection(slicer.GetOutputPort());
permuter.SetFilteredAxes(0, 1, 2);
permuter.Update();
}
//slicer.Update();
//Return copy of the slice
return(permuter.GetOutput());
}
/// <summary>
/// Function for removing sample edges.
/// </summary>
/// <param name="stack"></param>
/// <param name="side"></param>
/// <param name="get_center"></param>
/// <returns></returns>
public static vtkImageData center_crop(vtkImageData stack, int side = 400, bool get_center = true)
{
//Get input dimensions
int[] dims = stack.GetExtent();
//Find the center of the sample
int x1; int x2; int y1; int y2;
int[] center = find_center(stack, 70, new int[] { 0, (dims[5] - dims[4] + 1) / 3 });//GetCenter(bytedata,80);
//Compute new volume sides
y2 = Math.Min(center[0] + (side / 2), dims[1]);
y1 = Math.Max(y2 - side + 1, dims[0]);
x2 = Math.Min(center[1] + (side / 2), dims[3]);
x1 = Math.Max(x2 - side + 1, dims[2]);
//Create VOI extractor
vtkExtractVOI cropper = vtkExtractVOI.New();
cropper.SetVOI(y1, y2, x1, x2, dims[4], dims[5]);
cropper.SetInput(stack);
cropper.Update();
return(cropper.GetOutput());
}
/// <summary>
/// Scans the input mask slice by slice and selects the largest binary component of each slice.
/// Return cleaned mask as vtkImageData
/// </summary>
/// <param name="input"></param>
/// <param name="extent"></param>
/// <param name="threshold"></param>
/// <param name="axes"></param>
/// <returns></returns>
public static vtkImageData FalsePositiveSuppresion(vtkImageData input, int[] extent, double threshold, int axis, double scale = 1.0)
{
//Slice extractor
vtkExtractVOI slicer = vtkExtractVOI.New();
//Permuter
vtkImagePermute permuter = vtkImagePermute.New();
//List of outputs
List <byte[, , ]> outputs = new List <byte[, , ]>();
//List of output orientations
List <int[]> orientations = new List <int[]>();
//vtkImageData size
int[] full_extent = input.GetExtent();
//Set range for slices
int start = 0, stop = 0;
int[] size = new int[2];
int[] outextent = new int[4];
if (axis == 0)
{
start = extent[0];
stop = extent[1];
size = new int[] { extent[3] - extent[2] + 1, extent[5] - extent[4] + 1 };
outextent = new int[] { extent[2], extent[3] + 1, extent[4], extent[5] + 1 };
}
if (axis == 1)
{
start = extent[2];
stop = extent[3];
size = new int[] { extent[1] - extent[0] + 1, extent[5] - extent[4] + 1 };
outextent = new int[] { extent[0], extent[1] + 1, extent[4], extent[5] + 1 };
}
if (axis == 2)
{
start = extent[4];
stop = extent[5];
size = new int[] { extent[1] - extent[0] + 1, extent[3] - extent[2] + 1 };
outextent = new int[] { extent[0], extent[1] + 1, extent[2], extent[3] + 1 };
}
//Temporary array for output
byte[,,] output = new byte[full_extent[1] + 1, full_extent[3] + 1, full_extent[5] + 1];
int[] outsize = new int[] { size[0], size[1], stop - start + 1 };
//Loop over current axis
for (int k = start; k < stop; k++)
{
byte[] bytedata = new byte[size[0] * size[1]];
//Select slice
if (axis == 0)
{
slicer.Dispose();
slicer = vtkExtractVOI.New();
slicer.SetInput(input);
slicer.SetVOI(k, k, extent[2], extent[3], extent[4], extent[5]);
slicer.Update();
permuter.Dispose();
permuter = vtkImagePermute.New();
permuter.SetInput(slicer.GetOutput());
permuter.SetFilteredAxes(1, 2, 0);
permuter.Update();
}
if (axis == 1)
{
slicer.Dispose();
slicer = vtkExtractVOI.New();
slicer.SetInput(input);
slicer.SetVOI(extent[0], extent[1], k, k, extent[4], extent[5]);
slicer.Update();
permuter.Dispose();
permuter = vtkImagePermute.New();
permuter.SetInput(slicer.GetOutput());
permuter.SetFilteredAxes(0, 2, 1);
permuter.Update();
}
if (axis == 2)
{
slicer.Dispose();
slicer = vtkExtractVOI.New();
slicer.SetInput(input);
slicer.SetVOI(extent[0], extent[1], extent[2], extent[3], k, k);
slicer.Update();
permuter.Dispose();
permuter = vtkImagePermute.New();
permuter.SetInput(slicer.GetOutput());
permuter.SetFilteredAxes(0, 1, 2);
permuter.Update();
}
//Convert data to byte
bytedata = DataTypes.vtkToByte(permuter.GetOutput());
slicer.Dispose();
permuter.Dispose();
//convert data to Mat
Mat image = new Mat(size[1], size[0], MatType.CV_8UC1, bytedata);
//Get largest binary object
Mat bw = Processing.LargestBWObject(image, 0.7 * 255.0);
//Set slice to byte array
if (bw.Sum().Val0 > 0)
{
output = DataTypes.setByteSlice(output, bw, outextent, axis, k);
}
}
return(DataTypes.byteToVTK(output));
}