private static ValidationResult ValidateTissueInput(ITissueInput tissueInput)
{
// for all types of tissues, check that OPs are non-negative (g could be neg)
if (tissueInput.Regions.Any(r => r.RegionOP.Mua < 0.0) ||
tissueInput.Regions.Any(r => r.RegionOP.Musp < 0.0) ||
tissueInput.Regions.Any(r => r.RegionOP.N < 0.0))
{
return(new ValidationResult(
false,
"Tissue optical properties mua, mus', n need to be non-negative",
"Please check optical properties"));
}
if (tissueInput is MultiLayerTissueInput)
{
return(MultiLayerTissueInputValidation.ValidateInput(tissueInput));
}
if (tissueInput is SingleEllipsoidTissueInput)
{
return(SingleEllipsoidTissueInputValidation.ValidateInput(tissueInput));
}
if (tissueInput is SingleVoxelTissueInput)
{
return(SingleVoxelTissueInputValidation.ValidateInput(tissueInput));
}
if (tissueInput is BoundingCylinderTissueInput)
{
return(BoundingCylinderTissueInputValidation.ValidateInput(tissueInput));
}
return(new ValidationResult(
true,
"Tissue input must be valid",
"Validation skipped for tissue input " + tissueInput + ". No matching validation rules were found."));
}
/// <summary>
/// Method to validate that the geometry of tissue layers and bounding cylinder agree with capabilities
/// of code.
/// </summary>
/// <param name="layers">list of LayerTissueRegion</param>
/// <param name="boundingCylinder">CylinderTissueRegion</param>
/// <returns>ValidationResult</returns>
private static ValidationResult ValidateGeometry(IList <LayerTissueRegion> layers,
CaplessCylinderTissueRegion boundingCylinder)
{
// check that layer definition is valid
var tempResult = MultiLayerTissueInputValidation.ValidateLayers(layers);
if (!tempResult.IsValid)
{
return(tempResult);
}
// test for air layers and eliminate from list
var tissueLayers = layers.Where(layer => !layer.IsAir());
var layersHeight = tissueLayers.Sum(layer => layer.ZRange.Delta);
if (boundingCylinder.Height != layersHeight)
{
tempResult = new ValidationResult(
false,
"BoundingCylinderTissueInput: bounding cylinder must have same height as tissue",
"BoundingCylinderTissueInput: make sure cylinder Height = depth of tissue");
}
if (!tempResult.IsValid)
{
return(tempResult);
}
// check that there is at least one layer of tissue
if (!tissueLayers.Any())
{
tempResult = new ValidationResult(
false,
"BoundingCylinderTissueInput: tissue layer is assumed to be at least a single layer with air layer above and below",
"BoundingCylinderTissueInput: redefine tissue definition to contain at least a single layer of tissue");
}
if (!tempResult.IsValid)
{
return(tempResult);
}
return(new ValidationResult(
true,
"BoundingCylinderTissueInput: geometry and refractive index settings validated"));
}
private static ValidationResult ValidateTissueInput(ITissueInput tissueInput)
{
if (tissueInput is MultiLayerTissueInput)
{
return(MultiLayerTissueInputValidation.ValidateInput(tissueInput));
}
if (tissueInput is SingleEllipsoidTissueInput)
{
return(SingleEllipsoidTissueInputValidation.ValidateInput(tissueInput));
}
if (tissueInput is SingleVoxelTissueInput)
{
return(SingleVoxelTissueInputValidation.ValidateInput(tissueInput));
}
return(new ValidationResult(
true,
"Tissue input must be valid",
"Validation skipped for tissue input " + tissueInput + ". No matching validation rules were found."));
}
/// <summary>
/// Method to validate that the geometry of tissue layers and Voxel agree with capabilities
/// of code.
/// </summary>
/// <param name="layers">list of LayerTissueRegion</param>
/// <param name="Voxel">VoxelTissueRegion</param>
/// <returns>ValidationResult</returns>
private static ValidationResult ValidateGeometry(IList <LayerTissueRegion> layers, VoxelTissueRegion Voxel)
{
// check that layer definition is valid
var tempResult = MultiLayerTissueInputValidation.ValidateLayers(layers);
if (!tempResult.IsValid)
{
return(tempResult);
}
if ((Voxel.X.Stop - Voxel.X.Start <= 0) || ((Voxel.Y.Stop - Voxel.Y.Start) <= 0) || ((Voxel.Z.Stop - Voxel.Z.Start) <= 0))
{
tempResult = new ValidationResult(
false,
"SingleVoxelTissueInput: Voxel has 0 dimension along at least one side",
"SingleVoxelTissueInput: make sure X.Stop (Y.Stop, Z.Stop) is > X.Start (Y.Stop, Z.Stop)");
}
if (!tempResult.IsValid)
{
return(tempResult);
}
// test for air layers and eliminate from list
var tissueLayers = layers.Where(layer => !layer.IsAir());
// check that there is at least one layer of tissue
if (!tissueLayers.Any())
{
tempResult = new ValidationResult(
false,
"SingleVoxelTissueInput: tissue layer is assumed to be at least a single layer with air layer above and below",
"SingleVoxelTissueInput: redefine tissue definition to contain at least a single layer of tissue");
}
if (!tempResult.IsValid)
{
return(tempResult);
}
// check that Voxel contained within a tissue layer
bool correctlyContainedInLayer = tissueLayers.Any(
layer =>
Voxel.Z.Start > layer.ZRange.Start &&
Voxel.Z.Stop < layer.ZRange.Stop
);
if (!correctlyContainedInLayer)
{
tempResult = new ValidationResult(
false,
"SingleVoxelTissueInput: Voxel must be entirely contained within a tissue layer",
"Redefine Voxel.Z.Start and Voxel.Z.Stop to be entirely within layer.ZRange.Start and Stop");
}
if (!tempResult.IsValid)
{
return(tempResult);
}
return(new ValidationResult(
true,
"SingleVoxelTissueInput: geometry and refractive index settings validated"));
}
/// <summary>
/// Method to validate that the geometry of tissue layers and ellipsoid agree with capabilities
/// of code.
/// </summary>
/// <param name="layers">list of LayerTissueRegion</param>
/// <param name="ellipsoid">EllipsoidTissueRegion</param>
/// <returns>ValidationResult</returns>
private static ValidationResult ValidateGeometry(IList <LayerTissueRegion> layers, EllipsoidTissueRegion ellipsoid)
{
// check that layer definition is valid
var tempResult = MultiLayerTissueInputValidation.ValidateLayers(layers);
if (!tempResult.IsValid)
{
return(tempResult);
}
if ((ellipsoid.Dx == 0) || (ellipsoid.Dy == 0) || (ellipsoid.Dz == 0))
{
tempResult = new ValidationResult(
false,
"SingleEllipsoidTissueInput: ellipsoid has a radial axis equal to 0",
"SingleEllipsoidTissueInput: make sure Dx, Dy, Dz are > 0");
}
if (!tempResult.IsValid)
{
return(tempResult);
}
// test for air layers and eliminate from list
var tissueLayers = layers.Where(layer => !layer.IsAir());
// check that there is at least one layer of tissue
if (!tissueLayers.Any())
{
tempResult = new ValidationResult(
false,
"SingleEllipsoidTissueInput: tissue layer is assumed to be at least a single layer with air layer above and below",
"SingleEllipsoidTissueInput: redefine tissue definition to contain at least a single layer of tissue");
}
if (!tempResult.IsValid)
{
return(tempResult);
}
// check that ellipsoid contained within a tissue layer
bool correctlyContainedInLayer = tissueLayers.Any(
layer =>
layer.ContainsPosition(ellipsoid.Center) &&
ellipsoid.Center.Z + ellipsoid.Dz <= layer.ZRange.Stop &&
ellipsoid.Center.Z - ellipsoid.Dz >= layer.ZRange.Start
);
if (!correctlyContainedInLayer)
{
tempResult = new ValidationResult(
false,
"SingleEllipsoidTissueInput: ellipsoid must be entirely contained within a tissue layer",
"Resize Dz of Ellipsoid dimension so that 2*Dz<layer[1] depth");
}
if (!tempResult.IsValid)
{
return(tempResult);
}
return(new ValidationResult(
true,
"SingleEllipsoidTissueInput: geometry and refractive index settings validated"));
}
