public static string GetCoveredVolumeAtDose(StructureSet structureSet, PlanningItemViewModel planningItem, StructureViewModel evalStructure, MatchCollection testMatch, Group evalunit)
{
try
{
var structure = structureSet.Structures.FirstOrDefault(x => x.Id == evalStructure.StructureName);
//check for sufficient sampling and dose coverage
DVHData dvh = planningItem.PlanningItemObject.GetDVHCumulativeData(structure, DoseValuePresentation.Absolute, VolumePresentation.Relative, 0.1);
if ((dvh.SamplingCoverage < 0.9) || (dvh.Coverage < 0.9))
{
return("Unable to calculate - insufficient dose or sampling coverage");
}
Group eval = testMatch[0].Groups["evalpt"];
Group unit = testMatch[0].Groups["unit"];
DoseValue.DoseUnit du = (unit.Value.CompareTo("%") == 0) ? DoseValue.DoseUnit.Percent :
(unit.Value.CompareTo("cGy") == 0) ? DoseValue.DoseUnit.cGy : DoseValue.DoseUnit.Unknown;
VolumePresentation vp = (unit.Value.CompareTo("%") == 0) ? VolumePresentation.Relative : VolumePresentation.AbsoluteCm3;
DoseValue dv = new DoseValue(double.Parse(eval.Value), du);
double volume = double.Parse(eval.Value);
VolumePresentation vpFinal = (evalunit.Value.CompareTo("%") == 0) ? VolumePresentation.Relative : VolumePresentation.AbsoluteCm3;
DoseValuePresentation dvpFinal = (evalunit.Value.CompareTo("%") == 0) ? DoseValuePresentation.Relative : DoseValuePresentation.Absolute;
double volumeAchieved = planningItem.PlanningItemObject.GetVolumeAtDose(structure, dv, vpFinal);
double organVolume = Convert.ToDouble(evalStructure.VolumeValue);
double coveredVolume = organVolume - volumeAchieved;
return(string.Format("{0:0.00} {1}", coveredVolume, evalunit.Value)); // todo: better formatting based on VolumePresentation
}
catch (NullReferenceException)
{
return("Unable to calculate - DVH is not valid");
}
}
public static string GetVolumeAtDose(StructureSet structureSet, PlanningItem planningItem, Structure evalStructure, MatchCollection testMatch, Group evalunit)
{
//check for sufficient sampling and dose coverage
DVHData dvh = planningItem.GetDVHCumulativeData(evalStructure, DoseValuePresentation.Absolute, VolumePresentation.Relative, 0.1);
//MessageBox.Show(evalStructure.Id + "- Eval unit: " + evalunit.Value.ToString() + "Achieved unit: " + dvAchieved.UnitAsString + " - Sampling coverage: " + dvh.SamplingCoverage.ToString() + " Coverage: " + dvh.Coverage.ToString());
if ((dvh.SamplingCoverage < 0.9) || (dvh.Coverage < 0.9))
{
return("Unable to calculate - insufficient dose or sampling coverage");
}
Group eval = testMatch[0].Groups["evalpt"];
Group unit = testMatch[0].Groups["unit"];
DoseValue.DoseUnit du = (unit.Value.CompareTo("%") == 0) ? DoseValue.DoseUnit.Percent :
(unit.Value.CompareTo("cGy") == 0) ? DoseValue.DoseUnit.cGy : DoseValue.DoseUnit.Unknown;
VolumePresentation vp = (unit.Value.CompareTo("%") == 0) ? VolumePresentation.Relative : VolumePresentation.AbsoluteCm3;
DoseValue dv = new DoseValue(double.Parse(eval.Value), du);
double volume = double.Parse(eval.Value);
VolumePresentation vpFinal = (evalunit.Value.CompareTo("%") == 0) ? VolumePresentation.Relative : VolumePresentation.AbsoluteCm3;
DoseValuePresentation dvpFinal = (evalunit.Value.CompareTo("%") == 0) ? DoseValuePresentation.Relative : DoseValuePresentation.Absolute;
double volumeAchieved = planningItem.GetVolumeAtDose(evalStructure, dv, vpFinal);
return(string.Format("{0:0.00} {1}", volumeAchieved, evalunit.Value)); // todo: better formatting based on VolumePresentation
//#if false
// string message = string.Format("{0} - Dose unit = {1}, Volume Presentation = {2}, vpFinal = {3}, dvpFinal ={4}",
// objective.DVHObjective, du.ToString(), vp.ToString(), vpFinal.ToString(), dvpFinal.ToString());
// MessageBox.Show(message);
//#endif
}
/// <summary>
/// Finds the dose at a certain volume input of a structure
/// </summary>
/// <param name="i">the planning item</param>
/// <param name="ss">the structure to analyze (will be merged into one dvh)</param>
/// <param name="volume">the volume to sample (units are in the vPres variable)</param>
/// <param name="vPres">the units of the input volume</param>
/// <param name="dPres">the dose value presentation you want returned</param>
/// <returns></returns>
public static DoseValue GetDoseAtVolume(this PlanningItem pi, IEnumerable <Structure> ss, double volume,
VolumePresentation vPres, DoseValuePresentation dPres)
{
var dvh = pi.GetComplexDVH(ss, vPres, dPres);
return(dvh.GetDoseAtVolume(volume));
}
public double GetDoseAtVolumeForUncertainties(curve DVH, double Volume, VolumePresentation VolPres, DoseValuePresentation RequestedDosePresentation)
{
double dose;
if (DVH.VolumePresentation == VolumePresentation.AbsoluteCm3 && VolPres == VolumePresentation.Relative)
{
Volume = Volume * DVH.AbsoluteStructureVolume / 100.0;
}
if (DVH.VolumePresentation == VolumePresentation.Relative && VolPres == VolumePresentation.AbsoluteCm3)
{
Volume = Volume / DVH.AbsoluteStructureVolume * 100.0;
}
int ind1 = DVH.CurveData.Select(x => x.Volume).Count() - DVH.CurveData.Where(x => x.Volume < Volume).Select(x => x.Volume).Count() - 1;
int ind2 = DVH.CurveData.Select(x => x.Volume).Count() - DVH.CurveData.Where(x => x.Volume < Volume).Select(x => x.Volume).Count();
DVHPoint DVP1 = DVH.CurveData.ElementAt(ind1);
DVHPoint DVP2 = DVH.CurveData.ElementAt(ind2);
dose = Interpolate(DVP1.Volume, DVP2.Volume, DVP1.DoseValue.Dose, DVP2.DoseValue.Dose, Volume);
if (DVH.DoseValuePresentation == DoseValuePresentation.Absolute && RequestedDosePresentation == DoseValuePresentation.Relative)
{
dose = dose / DVH.PrescribedDose * 100.0;
}
if (DVH.DoseValuePresentation == DoseValuePresentation.Relative && RequestedDosePresentation == DoseValuePresentation.Absolute)
{
dose = dose * DVH.PrescribedDose / 100.0;
}
return(dose);
}
/// <summary>
/// Returns the sum of the volumes across the input structures at a given input dose
/// </summary>
/// <param name="pi">the current planning item</param>
/// <param name="ss">the structures to query</param>
/// <param name="dv">the dose value to query</param>
/// <param name="vPres">the volume presentation to return</param>
/// <returns>the volume at the requested presentation</returns>
public static double GetVolumeAtDose(this PlanningItem pi, IEnumerable <Structure> ss, DoseValue dv,
VolumePresentation vPres)
{
dv = dv.ConvertToSystemUnits(pi);
var vol = ss.Sum(s => pi.GetVolumeAtDose(s, dv, VolumePresentation.AbsoluteCm3));
return(vPres == VolumePresentation.AbsoluteCm3 ? vol : vol / ss.Sum(s => s.Volume) * 100);
}
/// Enables a shorter method for doing a common task (getting the DVH from a structure). Requires only a structure id, Contains default values.
/// </summary>
public static DVHData GetDefaultDVHCumulativeData(this PlanningItem plan, string structureId,
DoseValuePresentation dvp = DoseValuePresentation.Absolute,
VolumePresentation vp = VolumePresentation.Relative, double binWidth = 0.1)
{
var s = plan.GetStructure(structureId);
return(s != null?plan.GetDVHCumulativeData(s, dvp, vp, binWidth) : null);
}
/// <summary>
/// Returns the compliment volume of the input structure at a given input dose
/// </summary>
/// <param name="pi">the current planning item</param>
/// <param name="s">the structure to query</param>
/// <param name="dv">the dose value to query</param>
/// <param name="vPres">the volume presentation to return</param>
/// <returns>the volume at the requested presentation</returns>
public static double GetComplimentVolumeAtDose(this PlanningItem pi, Structure s, DoseValue dv,
VolumePresentation vPres)
{
var dPres = dv.GetPresentation();
var dvhCurve = pi.GetComplexDVH(new List <Structure> {
s
}, vPres, dPres);
return(dvhCurve.GetComplimentVolumeAtDose(dv));
}
public VolumeAtDose(string name_, DoseValue doseValue, double volConstraint, double upperLimitTol,
VolumePresentation vpp = VolumePresentation.Relative, PQMUtilities.LimitType lt_ = PQMUtilities.LimitType.upper)
{
volumeConstraint = volConstraint;
upperLimit = upperLimitTol;
vp = vpp;
dv = doseValue;
name = name_;
lt = lt_;
}
public double GetVolumeAtDose(Structure structure, DoseValue dose,
VolumePresentation requestedVolumePresentation)
{
var local = this;
var retVal = X.Instance.CurrentContext.GetValue(sc =>
{
return(local._client.GetVolumeAtDose(structure._client, dose, requestedVolumePresentation));
});
return(retVal);
}
public DoseValue GetDoseAtVolume(Structure structure, double volume, VolumePresentation volumePresentation,
DoseValuePresentation requestedDosePresentation)
{
var local = this;
var retVal = X.Instance.CurrentContext.GetValue(sc =>
{
return(local._client.GetDoseAtVolume(structure._client, volume, volumePresentation,
requestedDosePresentation));
});
return(retVal);
}
public DVHData GetDVHCumulativeData(Structure structure, DoseValuePresentation dosePresentation,
VolumePresentation volumePresentation, double binWidth)
{
var local = this;
var retVal = X.Instance.CurrentContext.GetValue(sc =>
{
return(new DVHData(local._client.GetDVHCumulativeData(structure._client, dosePresentation,
volumePresentation, binWidth)));
});
return(retVal);
}
public DoseAtVolume(string name_, double volumeValue, DoseValue doseLimit, double upperLimitTol,
VolumePresentation vpp = VolumePresentation.Relative,
DoseValuePresentation dvp_ = DoseValuePresentation.Absolute,
PQMUtilities.LimitType lt_ = PQMUtilities.LimitType.upper)
{
name = name_;
volume = volumeValue;
upperLimit = upperLimitTol;
vp = vpp;
doseConstraint = doseLimit;
dvp = dvp_;
lt = lt_;
}
/// <summary>
/// Return the Complement dose (coldspot) for a given volume. This is equivalent to taking the total volume of the
/// object and subtracting the input volume
/// </summary>
/// <param name="i">the current planning item</param>
/// <param name="ss">the input structures (will be merged into one dvh)</param>
/// <param name="volume">the volume to query</param>
/// <param name="vPres">the volume presentation of the input volume</param>
/// <param name="dPres">the dose presentation to return</param>
/// <returns>Return the coldspot dose for a given volume.</returns>
public static DoseValue GetDoseComplementAtVolume(this PlanningItem i, IEnumerable <Structure> ss, double volume,
VolumePresentation vPres, DoseValuePresentation dPres)
{
if (i is PlanSetup)
{
var plan = i as PlanSetup;
var dvh = plan.GetComplexDVH(ss, vPres, dPres);
return(dvh.GetDoseComplement(volume));
}
else
{
var plan = i as PlanSum;
var dvh = plan.GetComplexDVH(ss, vPres, dPres);
return(dvh.GetDoseComplement(volume));
}
}
//D{Vol_Metric [%,cm3]}[Gy,%] <= Dose_Metric [Unit of dose defined in Dose_Metric]
// Volume units defined by Vol_repr=0 => Relative [%] Vol_repr=1 => Absolute [cm3] using VolumePresentation Type.
public static Tuple <DoseValue, Boolean> D_X_less_than(PlanningItem my_plan, Structure structure,
Double Vol_Metric, VolumePresentation Vol_repr, DoseValue Dose_Goal)
{
DoseValue Dose_Metric = new DoseValue(0.0, Dose_Goal.Unit);
Boolean test = new Boolean();
DoseValuePresentation Dose_present = DoseValuePresentation.Absolute;
if (Dose_Goal.UnitAsString == "%")
{
Dose_present = DoseValuePresentation.Relative;
}
Dose_Metric = my_plan.GetDoseAtVolume(structure, Vol_Metric, Vol_repr, Dose_present);
test = (Dose_Metric.Dose <= Dose_Goal.Dose);
return(Tuple.Create(Dose_Metric, test));
}
public static string GetConformationNumber(StructureSet structureSet, PlanningItemViewModel planningItem, StructureViewModel evalStructure, MatchCollection testMatch, Group evalunit)
{
try
{
var structure = structureSet.Structures.FirstOrDefault(x => x.Id == evalStructure.StructureName);
DVHData dvh = planningItem.PlanningItemObject.GetDVHCumulativeData(structure, DoseValuePresentation.Absolute, VolumePresentation.Relative, 0.1);
DoseValue prescribedDose;
double planDoseDouble = 0;
if ((dvh.SamplingCoverage < 0.9) || (dvh.Coverage < 0.9))
{
return("Unable to calculate - insufficient dose or sampling coverage");
}
if (planningItem.PlanningItemObject is PlanSum)
{
PlanSum planSum = (PlanSum)planningItem.PlanningItemObject;
foreach (PlanSetup planSetup in planSum.PlanSetups)
{
planDoseDouble += planSetup.TotalDose.Dose;
}
}
if (planningItem.PlanningItemObject is PlanSetup)
{
PlanSetup planSetup = (PlanSetup)planningItem.PlanningItemObject;
planDoseDouble = planSetup.TotalDose.Dose;
}
prescribedDose = new DoseValue(planDoseDouble, DoseValue.DoseUnit.cGy);
Group eval = testMatch[0].Groups["evalpt"];
Group unit = testMatch[0].Groups["unit"];
DoseValue.DoseUnit du = (unit.Value.CompareTo("%") == 0) ? DoseValue.DoseUnit.Percent :
(unit.Value.CompareTo("cGy") == 0) ? DoseValue.DoseUnit.cGy : DoseValue.DoseUnit.Unknown;
var body = structureSet.Structures.Where(x => x.Id.Contains("BODY")).First();
//VolumePresentation vpFinal = (evalunit.Value.CompareTo("%") == 0) ? VolumePresentation.Relative : VolumePresentation.AbsoluteCm3;
VolumePresentation vpFinal = VolumePresentation.AbsoluteCm3;
DoseValuePresentation dvpFinal = (evalunit.Value.CompareTo("%") == 0) ? DoseValuePresentation.Relative : DoseValuePresentation.Absolute;
DoseValue dv = new DoseValue(double.Parse(eval.Value) / 100 * prescribedDose.Dose, DoseValue.DoseUnit.cGy);
double bodyWithPrescribedDoseVolume = planningItem.PlanningItemObject.GetVolumeAtDose(body, prescribedDose, vpFinal);
double targetWithPrescribedDoseVolume = planningItem.PlanningItemObject.GetVolumeAtDose(structure, dv, vpFinal);
double targetVolume = Convert.ToDouble(evalStructure.VolumeValue);
var cn = (targetWithPrescribedDoseVolume / targetVolume) * (targetWithPrescribedDoseVolume / bodyWithPrescribedDoseVolume);
return(string.Format("{0:0.0}", cn));
}
catch (NullReferenceException)
{
return("Unable to calculate - DVH is not valid");
}
}
private void PerformTest(Structure st, PlanMets x)
{
Double.TryParse(x.input_st, out dose);
Double.TryParse(x.outMax_st, out result);
volPres = x.outUnit == "cc" ? VolumePresentation.AbsoluteCm3 : VolumePresentation.Relative;
DoseValue doseVal = new DoseValue(100 * dose, doseUnit);
volume = Math.Round(plan.GetVolumeAtDose(st, doseVal, volPres), 2);
volume2 = Math.Round(plan.GetVolumeAtDose(st, new DoseValue(0, doseUnit), volPres), 2);
if (x.conType == "Vmin")
{
testResult = volume2 - volume <= result ? "PASS" : "FAIL";
teststring = String.Format("V0 Gy - V{0} Gy < {1} {2} ", x.input_st, x.outMax_st, x.outUnit);
pmdata.Add(new PlanMetData
{
Structure = st.Id,
Test = teststring,
Value = (volume2 - volume).ToString() + " " + x.outUnit,
TestResult = testResult,
TRColor = testResult == "PASS" ? new SolidColorBrush(Colors.LightGreen) : new SolidColorBrush(Colors.Red)
});
}
else if (x.conType == "Vmax")
{
testResult = volume <= result ? "PASS" : "FAIL";
teststring = String.Format("V{0} Gy < {1} {2} ", x.input_st, x.outMax_st, x.outUnit);
pmdata.Add(new PlanMetData
{
Structure = st.Id,
Test = teststring,
Value = volume.ToString() + " " + x.outUnit,
TestResult = testResult,
TRColor = testResult == "PASS" ? new SolidColorBrush(Colors.LightGreen) : new SolidColorBrush(Colors.Red)
});
}
}
public Task <double> GetVolumeAtDose(string StructureId, DoseValue Dose, VolumePresentation VP)
{
switch (PlanType)
{
case ComponentTypes.Plan:
return(A.ExecuteAsync(new Func <PlanSetup, double>((p) =>
{
return (p.GetVolumeAtDose(_Structures[StructureId], Dose, VP));
}), p));
case ComponentTypes.Sum:
return(A.ExecuteAsync(new Func <PlanSum, double>((ps) =>
{
return (ps.GetVolumeAtDose(_Structures[StructureId], Dose, VP));
}), ps));
default:
return(null);
}
}
public static string GetDoseAtVolume(StructureSet structureSet, PlanningItemViewModel planningItem, StructureViewModel evalStructure, MatchCollection testMatch, Group evalunit)
{
//check for sufficient dose and sampling coverage
DVHData dvh = planningItem.PlanningItemObject.GetDVHCumulativeData(evalStructure.Structure, DoseValuePresentation.Absolute, VolumePresentation.Relative, 0.1);
if (dvh != null)
{
if ((dvh.SamplingCoverage < 0.9) || (dvh.Coverage < 0.9))
{
return("Unable to calculate - insufficient dose or sampling coverage");
}
Group eval = testMatch[0].Groups["evalpt"];
Group unit = testMatch[0].Groups["unit"];
DoseValue.DoseUnit du = (unit.Value.CompareTo("%") == 0) ? DoseValue.DoseUnit.Percent :
(unit.Value.CompareTo("cGy") == 0) ? DoseValue.DoseUnit.cGy : DoseValue.DoseUnit.Unknown;
VolumePresentation vp = (unit.Value.CompareTo("%") == 0) ? VolumePresentation.Relative : VolumePresentation.AbsoluteCm3;
DoseValue dv = new DoseValue(double.Parse(eval.Value), du);
double volume = double.Parse(eval.Value);
VolumePresentation vpFinal = (evalunit.Value.CompareTo("%") == 0) ? VolumePresentation.Relative : VolumePresentation.AbsoluteCm3;
DoseValuePresentation dvpFinal = (evalunit.Value.CompareTo("%") == 0) ? DoseValuePresentation.Relative : DoseValuePresentation.Absolute;
DoseValue dvAchieved = planningItem.PlanningItemObject.GetDoseAtVolume(evalStructure.Structure, volume, vp, dvpFinal);
//checking dose output unit and adapting to template
if (dvAchieved.UnitAsString.CompareTo(evalunit.Value.ToString()) != 0)
{
if ((evalunit.Value.CompareTo("cGy") == 0) && (dvAchieved.Unit.CompareTo(DoseValue.DoseUnit.cGy) == 0))
{
dvAchieved = new DoseValue(dvAchieved.Dose / 100, DoseValue.DoseUnit.cGy);
}
else
{
return("Unable to calculate");
}
}
return(dvAchieved.ToString());
}
else
{
return("Unable to calculate - structure is empty");
}
}
public static string GetVolumeAtDose(StructureSet structureSet, PlanningItemViewModel planningItem, StructureViewModel evalStructure, MatchCollection testMatch, Group evalunit)
{
try
{
var structure = structureSet.Structures.FirstOrDefault(x => x.Id == evalStructure.StructureName);
//check for sufficient sampling and dose coverage
DVHData dvh = planningItem.PlanningItemObject.GetDVHCumulativeData(structure, DoseValuePresentation.Absolute, VolumePresentation.Relative, 0.1);
//MessageBox.Show(evalStructure.Id + "- Eval unit: " + evalunit.Value.ToString() + "Achieved unit: " + dvAchieved.UnitAsString + " - Sampling coverage: " + dvh.SamplingCoverage.ToString() + " Coverage: " + dvh.Coverage.ToString());
if ((dvh.SamplingCoverage < 0.9) || (dvh.Coverage < 0.9))
{
return("Unable to calculate - insufficient dose or sampling coverage");
}
Group eval = testMatch[0].Groups["evalpt"];
Group unit = testMatch[0].Groups["unit"];
DoseValue.DoseUnit du = (unit.Value.CompareTo("%") == 0) ? DoseValue.DoseUnit.Percent :
(unit.Value.CompareTo("cGy") == 0) ? DoseValue.DoseUnit.cGy : DoseValue.DoseUnit.Unknown;
VolumePresentation vp = (unit.Value.CompareTo("%") == 0) ? VolumePresentation.Relative : VolumePresentation.AbsoluteCm3;
DoseValue dv = new DoseValue(double.Parse(eval.Value), du);
double volume = double.Parse(eval.Value);
VolumePresentation vpFinal = (evalunit.Value.CompareTo("%") == 0) ? VolumePresentation.Relative : VolumePresentation.AbsoluteCm3;
DoseValuePresentation dvpFinal = (evalunit.Value.CompareTo("%") == 0) ? DoseValuePresentation.Relative : DoseValuePresentation.Absolute;
if (planningItem.PlanningItemObject is PlanSum)
{
double planDoseDouble = 0;
PlanSum planSum = (PlanSum)planningItem.PlanningItemObject;
foreach (PlanSetup planSetup in planSum.PlanSetups)
{
planDoseDouble += planSetup.TotalDose.Dose;
}
dv = new DoseValue(planDoseDouble, DoseValue.DoseUnit.cGy);
}
double volumeAchieved = planningItem.PlanningItemObject.GetVolumeAtDose(structure, dv, vpFinal);
return(string.Format("{0:0.00} {1}", volumeAchieved, evalunit.Value)); // todo: better formatting based on VolumePresentation
}
catch (NullReferenceException)
{
return("Unable to calculate - DVH is not valid");
}
}
public static string GetGradientIndex(StructureSet structureSet, PlanningItemViewModel planningItem, Structure evalStructure, MatchCollection testMatch, Group evalunit)
{
// we have Gradient Index pattern
DVHData dvh = planningItem.PlanningItemObject.GetDVHCumulativeData(evalStructure, DoseValuePresentation.Absolute, VolumePresentation.Relative, 0.1);
if ((dvh.SamplingCoverage < 0.9) || (dvh.Coverage < 0.9))
{
return("Unable to calculate - insufficient dose or sampling coverage");
}
Group eval = testMatch[0].Groups["evalpt"];
Group unit = testMatch[0].Groups["unit"];
DoseValue prescribedDose;
double planDoseDouble = 0;
DoseValue.DoseUnit du = (unit.Value.CompareTo("%") == 0) ? DoseValue.DoseUnit.Percent :
(unit.Value.CompareTo("cGy") == 0) ? DoseValue.DoseUnit.cGy : DoseValue.DoseUnit.Unknown;
if (planningItem.PlanningItemObject is PlanSum)
{
PlanSum planSum = (PlanSum)planningItem.PlanningItemObject;
foreach (PlanSetup planSetup in planSum.PlanSetups)
{
planDoseDouble += planSetup.TotalDose.Dose;
}
}
if (planningItem.PlanningItemObject is PlanSetup)
{
PlanSetup planSetup = (PlanSetup)planningItem.PlanningItemObject;
planDoseDouble = planSetup.TotalDose.Dose;
}
prescribedDose = new DoseValue(planDoseDouble, DoseValue.DoseUnit.cGy);
//var body = structureSet.Structures.Where(x => x.Id.Contains("BODY")).First();
VolumePresentation vpFinal = VolumePresentation.AbsoluteCm3;
DoseValuePresentation dvpFinal = (evalunit.Value.CompareTo("%") == 0) ? DoseValuePresentation.Relative : DoseValuePresentation.Absolute;
DoseValue dv = new DoseValue(double.Parse(eval.Value) / 100 * prescribedDose.Dose, DoseValue.DoseUnit.cGy);
double bodyWithPrescribedDoseVolume = planningItem.PlanningItemObject.GetVolumeAtDose(evalStructure, prescribedDose, vpFinal);
double bodyWithEvalDoseVolume = planningItem.PlanningItemObject.GetVolumeAtDose(evalStructure, dv, vpFinal);
var gi = bodyWithEvalDoseVolume / bodyWithPrescribedDoseVolume;
return(string.Format("{0:0.0}", gi));
}
/// <summary>
/// The "complex" dvh in this case, is 1. Allows for plan sums to have relative dose, by adding prescriptions to
/// determine a
/// guessed prescribed dose value. (It is up to the user to determine if this is appropriate). 2). Allows for multiple
/// structures
/// to be merged into a single dvh by summing volumes as each dose value
/// </summary>
/// <param name="pi">the planning item containing the dose and the structures</param>
/// <param name="ss">the structures to merge into one DVH (useful for multiple volume queries from parallel organs)</param>
/// <param name="vPres">the volume presentation requested</param>
/// <param name="dPres">the dose presentation requested</param>
/// <param name="binWidth">the bin width to use when sampling the DVH</param>
/// <returns></returns>
public static DVHPoint[] GetComplexDVH(this PlanningItem pi, IEnumerable <Structure> ss,
VolumePresentation vPres, DoseValuePresentation dPres, double binWidth = 0.1)
{
IEnumerable <DVHPoint[]> dvhs;
if (pi is PlanSum && dPres == DoseValuePresentation.Relative)
{
dvhs =
ss.Select(
s => (pi as PlanSum).GetRelativeDVHCumulativeData(s, VolumePresentation.AbsoluteCm3, binWidth));
}
else
{
dvhs = ss.Select(s => pi.GetDVHCumulativeData(s, dPres, VolumePresentation.AbsoluteCm3, binWidth)
.CurveData);
}
var mergedDVH = dvhs.MergeDVHs();
if (vPres == VolumePresentation.Relative)
{
mergedDVH = mergedDVH.ConvertToRelativeVolume();
}
return(mergedDVH);
}
public Task <double> GetMeanDose(string StructureId, VolumePresentation VP, DoseValuePresentation DVP, double binwidth)
{
switch (PlanType)
{
case ComponentTypes.Plan:
return(A.ExecuteAsync(new Func <PlanSetup, double>((p) =>
{
DVHData dvh = p.GetDVHCumulativeData(_Structures[StructureId], DVP, VP, binwidth);
if (!ReferenceEquals(null, dvh))
{
return dvh.MeanDose.Dose;
}
else
{
return -1;
}
}), p));
case ComponentTypes.Sum:
return(A.ExecuteAsync(new Func <PlanSum, double>((ps) =>
{
DVHData dvh = ps.GetDVHCumulativeData(_Structures[StructureId], DVP, VP, binwidth);
if (!ReferenceEquals(null, dvh))
{
return dvh.MeanDose.Dose;
}
else
{
return -1;
}
}), ps));
default:
return(null);
}
}
public static double GetVolumeAtDose(this PlanningItem pitem, Structure structure, DoseValue dose, VolumePresentation requestedVolumePresentation)
{
if (pitem is PlanSetup)
{
return(((PlanSetup)pitem).GetVolumeAtDose(structure, dose, requestedVolumePresentation));
}
else
{
DVHData dvh = pitem.GetDVHCumulativeData(structure, DoseValuePresentation.Absolute, requestedVolumePresentation, 0.001);
return(DVHExtensions.VolumeAtDose(dvh, dose.Dose));
}
}
public static DoseValue GetDoseAtVolume(this PlanningItem pitem, Structure structure, double volume, VolumePresentation volumePresentation, DoseValuePresentation requestedDosePresentation)
{
if (pitem is PlanSetup)
{
return(((PlanSetup)pitem).GetDoseAtVolume(structure, volume, volumePresentation, requestedDosePresentation));
}
else
{
if (requestedDosePresentation != DoseValuePresentation.Absolute)
{
throw new ApplicationException("Only absolute dose supported for Plan Sums");
}
DVHData dvh = pitem.GetDVHCumulativeData(structure, DoseValuePresentation.Absolute, volumePresentation, 0.001);
return(DVHExtensions.DoseAtVolume(dvh, volume));
}
}
/// <summary>
/// Returns the sum of the volumes across the input structures at a given input dose
/// </summary>
/// <param name="pi">the current planning item</param>
/// <param name="ss">the structures to query</param>
/// <param name="dv">the dose value to query</param>
/// <param name="vPres">the volume presentation to return</param>
/// <returns>the volume at the requested presentation</returns>
public static double GetVolumeAtDose(this PlanningItem pi, IEnumerable <Structure> ss, DoseValue dv, VolumePresentation vPres)
{
return(ss.Sum(s => pi.GetVolumeAtDose(s, dv, vPres)));
}
/// <summary>
/// Returns the volume of the input structure at a given input dose
/// </summary>
/// <param name="pi">the current planning item</param>
/// <param name="ss">the structure to query</param>
/// <param name="dv">the dose value to query</param>
/// <param name="vPres">the volume presentation to return</param>
/// <returns>the volume at the requested presentation</returns>
public static double GetVolumeAtDose(this PlanningItem pi, Structure s, DoseValue dv, VolumePresentation vPres)
{
var dpres = dv.GetPresentation();
return(pi
.GetDVHCumulativeData(s, dpres, vPres, 0.1)
.CurveData
.GetVolumeAtDose(dv));
}
/// <summary>
/// Return the coldspot dose for a given volume. This is equivalent to taking the total volume of the object and subtracting the input volume
/// </summary>
/// <param name="i">the current planning item</param>
/// <param name="s">the input structure</param>
/// <param name="volume">the volume to query</param>
/// <param name="vPres">the volume presentation of the input volume</param>
/// <param name="dPres">the dose presentation to return</param>
/// <returns>Return the coldspot dose for a given volume.</returns>
public static DoseValue GetColdspotAtVolume(this PlanningItem i, Structure s, double volume, VolumePresentation vPres, DoseValuePresentation dPres)
{
if (i is PlanSetup)
{
var plan = i as PlanSetup;
var dvh = plan.GetDefaultDVHCumulativeData(s, dPres, vPres);
return(dvh.CurveData.GetColdspot(volume));
}
else
{
var plan = i as PlanSum;
var dvh = plan.GetDefaultDVHCumulativeData(s, dPres, vPres);
return(dvh.CurveData.GetColdspot(volume));
}
}
/// <summary>
/// Finds the dose at a certain volume input of a structure
/// </summary>
/// <param name="i">the planning item</param>
/// <param name="s">the structure to analyze</param>
/// <param name="volume">the volume to sample (units are in the vPres variable)</param>
/// <param name="vPres">the units of the input volume</param>
/// <param name="dPres">the dose value presentation you want returned</param>
/// <returns></returns>
public static DoseValue GetDoseAtVolume(this PlanningItem pi, IEnumerable <Structure> ss, double volume, VolumePresentation vPres, DoseValuePresentation dPres)
{
var dvhs = ss.Select(s => pi.GetDVHCumulativeData(s, dPres, VolumePresentation.AbsoluteCm3, 0.1));
var mergedDVH = dvhs.MergeDVHs();
if (vPres == VolumePresentation.Relative)
{
mergedDVH = mergedDVH.ConvertToRelativeVolume();
}
return(mergedDVH.GetDoseAtVolume(volume));
}
/// <summary>
/// Finds the dose at a certain volume input of a structure
/// </summary>
/// <param name="i">the planning item</param>
/// <param name="s">the structure to analyze</param>
/// <param name="volume">the volume to sample (units are in the vPres variable)</param>
/// <param name="vPres">the units of the input volume</param>
/// <param name="dPres">the dose value presentation you want returned</param>
/// <returns></returns>
public static DoseValue GetDoseAtVolume(this PlanningItem i, Structure s, double volume, VolumePresentation vPres, DoseValuePresentation dPres)
{
var dvh = i.GetDVHCumulativeData(s, dPres, vPres, 0.1);
var curve = dvh.CurveData;
var point = dvh.MaxDose;
//Max vol scenario
if ((s.Volume == volume && vPres == VolumePresentation.AbsoluteCm3) || (vPres == VolumePresentation.Relative && volume == 100.0))
{
return(dvh.MinDose);
}
//Min vol scenario
if ((s.Volume == 0.0))
{
return(dvh.MaxDose);
}
//Overvolume scenario
if ((s.Volume < volume && vPres == VolumePresentation.AbsoluteCm3) || (vPres == VolumePresentation.Relative && volume > 100.0))
{
return(new DoseValue(double.NaN, point.Unit));
}
else
{
//Interpolate
var higherPoints = curve.Where(p => p.Volume > volume);
var lowerPoints = curve.Where(p => p.Volume <= volume);
var point1 = higherPoints.Last();
var point2 = lowerPoints.First();
var doseAtPoint = Interpolate(point1.Volume, point2.Volume, point1.DoseValue.Dose, point2.DoseValue.Dose, volume);
return(new DoseValue(doseAtPoint, point.Unit));
}
}
/// <summary>
/// Enables a shorter method for doing a common task (getting the DVH from a structure). Contains default values.
/// </summary>
public static DVHData GetDefaultDVHCumulativeData(this PlanningItem plan, Structure s, DoseValuePresentation dvp = DoseValuePresentation.Absolute, VolumePresentation vp = VolumePresentation.Relative, double binWidth = 0.1)
{
return(plan.GetDVHCumulativeData(s, dvp, vp, binWidth));
}
