/// Creates an instance of a MultiLayerSurfaceFiberTissue
/// </summary>
/// <param name="surfaceFiberRegion">circular surface fiber region and characteristics</param>
/// <param name="layerRegions">list of tissue regions comprising tissue</param>
/// <remarks>air above and below tissue needs to be specified for a slab geometry</remarks>
public MultiLayerWithSurfaceFiberTissue(ITissueRegion surfaceFiberRegion,
IList <ITissueRegion> layerRegions)
: base(layerRegions.Concat(surfaceFiberRegion).ToArray())
{
_layerRegions = layerRegions.Select(region => (LayerTissueRegion)region).ToArray();
_surfaceFiberRegion = surfaceFiberRegion;
}
/// <summary>
/// constructor that load excitation simulation AOfRhoAndZ
/// </summary>
public AOfRhoAndZLoader(string inputFolder, string infile, int fluorescentTissueRegionIndex)
{
if (infile != "")
{
var inputPath = "";
if (inputFolder == "")
{
inputPath = infile;
}
else
{
inputPath = inputFolder + @"/" + infile;
}
var aOfRhoAndZDetector = (AOfRhoAndZDetector) DetectorIO.ReadDetectorFromFile(
"AOfRhoAndZ", inputFolder);
// use DoubleRange X,Y,Z to match detector dimensions
Rho = ((AOfRhoAndZDetector) aOfRhoAndZDetector).Rho;
Z = ((AOfRhoAndZDetector) aOfRhoAndZDetector).Z;
AOfRhoAndZ = ((AOfRhoAndZDetector) aOfRhoAndZDetector).Mean;
var exciteInfile = SimulationInput.FromFile(inputPath);
FluorescentTissueRegion = exciteInfile.TissueInput.Regions[fluorescentTissueRegionIndex];
// separate setup of arrays so can unit test method
InitializeFluorescentRegionArrays();
SetupRegionIndices();
}
else
{
throw new ArgumentException("infile string is empty");
}
}
/// <summary>
/// Creates an instance of a SingleInclusionTissue
/// </summary>
/// <param name="inclusionRegion">The single inclusion (must be contained completely within a layer region)</param>
/// <param name="layerRegions">The tissue layers</param>
public SingleInclusionTissue(
ITissueRegion inclusionRegion,
IList <ITissueRegion> layerRegions)
: base(layerRegions)
{
// overwrite the Regions property in the TissueBase class (will be called last in the most derived class)
Regions = layerRegions.Concat(inclusionRegion).ToArray();
_inclusionRegion = inclusionRegion;
_inclusionRegionIndex = layerRegions.Count; // index is, by convention, after the layer region indices
_layerRegionIndexOfInclusion = Enumerable.Range(0, layerRegions.Count)
.FirstOrDefault(i => ((LayerTissueRegion)layerRegions[i]).ContainsPosition(_inclusionRegion.Center));
}
/// <summary>
/// Creates an instance of a SingleInclusionTissue
/// </summary>
/// <param name="boundingRegion">Tissue region defining later extent of tissue (must span top to bottom of tissue layers)</param>
/// <param name="layerRegions">The tissue layers</param>
public BoundedTissue(
ITissueRegion boundingRegion,
IList <ITissueRegion> layerRegions)
: base(layerRegions)
{
// boundingRegionExteriorIndex is the area *outside* of the bounding region
_boundingRegionExteriorIndex = layerRegions.Count; // index is, by convention, after the layer region indices
// overwrite the Regions property in the TissueBase class (will be called last in the most derived class)
// the concat is with the outside of the bounding region by convention
Regions = layerRegions.Concat(boundingRegion).ToArray();
_layers = layerRegions;
_boundingRegion = boundingRegion;
}
/// <summary>
/// constructor that load excitation simulation AOfXAndYAndZ
/// </summary>
public AOfXAndYAndZLoader(string inputFolder, string infile, int fluorescentTissueRegionIndex)
{
if (infile != "")
{
var inputPath = "";
if (inputFolder == "")
{
inputPath = infile;
}
else
{
inputPath = inputFolder + @"/" + infile;
}
var aOfXAndYAndZDetector = (AOfXAndYAndZDetector)DetectorIO.ReadDetectorFromFile(
"AOfXAndYAndZ", inputFolder);
// use DoubleRange X,Y,Z to match detector dimensions
X = ((AOfXAndYAndZDetector)aOfXAndYAndZDetector).X;
Y = ((AOfXAndYAndZDetector)aOfXAndYAndZDetector).Y;
Z = ((AOfXAndYAndZDetector)aOfXAndYAndZDetector).Z;
AOfXAndYAndZ = ((AOfXAndYAndZDetector)aOfXAndYAndZDetector).Mean;
var exciteInfile = SimulationInput.FromFile(inputPath);
FluorescentTissueRegion = exciteInfile.TissueInput.Regions[fluorescentTissueRegionIndex];
BoundedTissueRegion = null;
// check if tissue bounded CH: can this be made more generic?
if (exciteInfile.TissueInput.TissueType == "BoundingCylinder")
{
var cylinderIndex = exciteInfile.TissueInput.Regions.Length - 1;
CaplessCylinderTissueRegion boundingCylinder =
(CaplessCylinderTissueRegion)exciteInfile.TissueInput.Regions[cylinderIndex];
BoundedTissueRegion = new CaplessCylinderTissueRegion(
boundingCylinder.Center,
boundingCylinder.Radius,
boundingCylinder.Height,
boundingCylinder.RegionOP);
}
// separate setup of arrays so can unit test method
InitializeFluorescentRegionArrays();
SetupRegionIndices();
}
else
{
throw new ArgumentException("infile string is empty");
}
}
/// <summary>
/// diffuse reflectance VB
/// </summary>
/// <param name="tissue">ITissue</param>
/// <param name="detectorController">IDetectorController</param>
/// <param name="name">string name</param>
public BoundingCylinderVirtualBoundary(ITissue tissue, IDetectorController detectorController, string name)
{
_boundingTissueRegion = tissue.Regions[tissue.Regions.Count - 1]; // bounding region always last by convention
_center = _boundingTissueRegion.Center;
_radius = ((CaplessCylinderTissueRegion)_boundingTissueRegion).Radius;
WillHitBoundary = dp =>
dp.StateFlag.HasFlag(PhotonStateType.PseudoBoundingVolumeTissueBoundary) &&
_boundingTissueRegion.ContainsPosition(dp.Position);
VirtualBoundaryType = VirtualBoundaryType.BoundingCylinderVolume;
PhotonStateType = PhotonStateType.PseudoBoundingCylinderVolumeVirtualBoundary;
_detectorController = detectorController;
Name = name;
}
/// <summary>
/// allows definition of tissue bounded by capless cylinder height of tissue
/// </summary>
/// <param name="cylinderRegion">bounding vertical cylinder region specification</param>
/// <param name="layerRegions">tissue layer specification</param>
public BoundingCylinderTissueInput(ITissueRegion caplessCylinderRegion, ITissueRegion[] layerRegions)
{
TissueType = "BoundingCylinder";
_caplessCylinderRegion = (CaplessCylinderTissueRegion)caplessCylinderRegion;
_layerRegions = layerRegions;
}
/// <summary>
/// allows definition of single ellipsoid tissue
/// </summary>
/// <param name="ellipsoidRegion">ellipsoid region specification</param>
/// <param name="layerRegions">tissue layer specification</param>
public SingleEllipsoidTissueInput(ITissueRegion ellipsoidRegion, ITissueRegion[] layerRegions)
{
TissueType = "SingleEllipsoid";
_ellipsoidRegion = ellipsoidRegion;
_layerRegions = layerRegions;
}
/// <summary>
/// allows definition of single infinite cylinder tissue
/// </summary>
/// <param name="infiniteCylinderRegion">infinite cylinder region specification</param>
/// <param name="layerRegions">tissue layer specification</param>
public SingleInfiniteCylinderTissueInput(ITissueRegion infiniteCylinderRegion, ITissueRegion[] layerRegions)
{
TissueType = "SingleInfiniteCylinder";
_infiniteCylinderRegion = infiniteCylinderRegion;
_layerRegions = layerRegions;
}
/// <summary>
/// allows definition of single voxel tissue
/// </summary>
/// <param name="voxelRegion">voxel region specification</param>
/// <param name="layerRegions">tissue layer specification</param>
public SingleVoxelTissueInput(ITissueRegion voxelRegion, ITissueRegion[] layerRegions)
{
TissueType = "SingleVoxel";
_voxelRegion = voxelRegion;
_layerRegions = layerRegions;
}
/// <summary>
/// constructor for Semi-infinite tissue input
/// </summary>
/// <param name="region">tissue region info</param>
public SemiInfiniteTissueInput(ITissueRegion region)
{
TissueType = "SemiInfinite";
_regions = new[] { region };
}
/// <summary>
/// allows definition of single cylinder tissue
/// </summary>
/// <param name="cylinderRegion">cylinder region specification</param>
/// <param name="layerRegions">tissue layer specification</param>
public SingleCylinderTissueInput(ITissueRegion cylinderRegion, ITissueRegion[] layerRegions)
{
TissueType = "SingleCylinder";
_cylinderRegion = cylinderRegion;
_layerRegions = layerRegions;
}
/// <summary>
/// constructor for Multi-layer tissue with surface fiber circle input
/// </summary>
/// <param name="surfaceFiberRegion">surface fiber region defining area and characteristics of detector fiber</param>
/// <param name="layerRegions">list of tissue regions comprising tissue</param>
public MultiLayerWithSurfaceFiberTissueInput(ITissueRegion surfaceFiberRegion, ITissueRegion[] layerRegions)
{
TissueType = "MultiLayerWithSurfaceFiber";
_layerRegions = layerRegions;
_surfaceFiberRegion = surfaceFiberRegion;
}
/// <summary>
/// Method to determine if tissue region is air or not
/// </summary>
/// <param name="region">tissue region</param>
/// <returns>boolean</returns>
public static bool IsAir(this ITissueRegion region)
{
return(region.RegionOP.Mua == 0D && region.RegionOP.Mus <= 1E-10);
}
