public LayersTableSource(StructureTableViewController viewController)
{
this.viewController = viewController;
viewModel = viewController.ViewModel;
viewModel.Layers.CollectionChanged += (sender, e) => viewController.TableView.ReloadData();
}
public ActionResult Edit(Guid id)
{
var viewModel = new StructureViewModel();
var model = structureRepository.Get(id);
viewModel.Id = id;
viewModel.Name = model.Name;
return(View("Create", viewModel));
}
public ActionResult Edit(Guid id)
{
var viewModel = new StructureViewModel();
var model = _structureService.GetById(id);
viewModel.Id = id;
viewModel.Name = model.Name;
return(View("Create", viewModel));
}
public ActionResult Structure(int?idPlanCadre)
{
if (idPlanCadre == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var structureViewModel = new StructureViewModel();
var planCadre = db.PlanCadre.Find(idPlanCadre);
structureViewModel.PlanCadre = planCadre;
structureViewModel.ElementEnoncePlanCadres = new List <ElementEnoncePlanCadre>();
var enonces = from enonce in db.EnonceCompetence
join planCadreCompetence in db.PlanCadreCompetence on enonce.IdCompetence equals planCadreCompetence
.IdCompetence
where planCadreCompetence.IdPlanCadre == planCadre.IdPlanCadre
select enonce;
foreach (var enonce in enonces)
{
var elements =
from element in db.ElementCompetence
join planCadreElement in db.PlanCadreElement
on element.IdElement equals planCadreElement.IdElement
join planCadreCompetence in db.PlanCadreCompetence
on planCadreElement.IdPlanCadreCompetence equals planCadreCompetence.IdPlanCadreCompetence
where planCadreCompetence.IdCompetence == enonce.IdCompetence &&
planCadreCompetence.IdPlanCadre == idPlanCadre
select element;
IEnumerable <ElementCompetence> elementCompetences = elements;
var idPlanCadreCompetences = from planCadreCompetence in db.PlanCadreCompetence
where planCadreCompetence.IdPlanCadre == planCadre.IdPlanCadre &&
planCadreCompetence.IdCompetence == enonce.IdCompetence
select planCadreCompetence.IdPlanCadreCompetence;
var idPlanCadreCompetence = idPlanCadreCompetences.First();
structureViewModel.ElementEnoncePlanCadres.Add(new ElementEnoncePlanCadre
{
EnonceCompetence = enonce,
ElementCompetences = elementCompetences,
IdPlanCadreCompetence = idPlanCadreCompetence
});
}
return(View(structureViewModel));
}
public StructureViewModel Build(StructureRenderingParameters args)
{
var model = new StructureViewModel
{
CssClass = args.CssClass,
RenderingUniqueId = args.RenderingUniqueId
};
if (args.ColorScheme != null)
{
model.BackgroundColor = args.ColorScheme[ColorSchemeFieldNames.BackgroundColor];
model.ForegroundColor = args.ColorScheme[ColorSchemeFieldNames.ForegroundColor];
}
return(model);
}
public StructureDialog(FieldNotes inDetailViewModel, bool isQuickStructure)
{
parentViewModel = inDetailViewModel;
isAQuickStructure = isQuickStructure;
this.InitializeComponent();
strucViewModel = new StructureViewModel(inDetailViewModel);
this.Loading += StructureDialog_Loading;
this.structSaveButton.GotFocus += StructSaveButton_GotFocus;
SolidColorBrush defaultBorderBrush = this.strucType.BorderBrush as SolidColorBrush;
defaultBorderColor = defaultBorderBrush.Color;
//testing = 75;
}
public ActionResult Save(StructureViewModel viewModel)
{
if (ModelState.IsValid)
{
if (viewModel.Id == Guid.Empty)
{
var model = new Structure();
model.Id = Guid.NewGuid();
model.Name = viewModel.Name;
structureRepository.Create(model);
}
else
{
var model = structureRepository.Get(viewModel.Id);
model.Name = viewModel.Name;
structureRepository.Update(model);
}
return(RedirectToAction("Index"));
}
return(View("Create", viewModel));
}
public static Tuple <SolidColorBrush, double> GetAchievedRatio(StructureViewModel structure, string goal, string DVHObjective, string Achieved)
{
var achievedColor = new SolidColorBrush();
double achievedDouble;
double achievedRatio = 0;
try
{
achievedColor = (SolidColorBrush)(new BrushConverter().ConvertFrom("#FFA7F3A4")); //green
achievedDouble = Convert.ToDouble(Regex.Match(Achieved.ToString(), @"\d+").Value);
}
catch (FormatException)
{
achievedColor = (SolidColorBrush)(new BrushConverter().ConvertFrom("#FF2B2B2B")); //black
achievedDouble = 0;
}
if (structure == null)
{
achievedColor = (SolidColorBrush)(new BrushConverter().ConvertFrom("#FF2B2B2B")); //black
achievedDouble = 0;
return(Tuple.Create(achievedColor, achievedRatio));
}
double goalDouble = Convert.ToDouble(Regex.Match(goal.ToString(), @"(\d+(\.\d+)?)|(\.\d+)").Value);
achievedRatio = achievedDouble / goalDouble;
if (goal.Contains("<")) //D at V, V at D, serial tissue
{
achievedColor = GetDoseVolumeSolidColorBrush(achievedRatio);
}
if (goal.Contains(">") && DVHObjective.ToString().Contains("CV")) //CV parallel tissue
{
achievedColor = GetCriticalVolumeSolidColorBrush(achievedRatio);
}
else if (goal.ToString().Contains(">")) //Target
{
achievedColor = GetTargetSolidColorBrush(achievedRatio);
}
return(Tuple.Create(achievedColor, achievedRatio));
}
public static void FindBorderNodePositions(StructureViewModel structureViewModel, out SMRect leftRect, out SMRect rightRect)
{
var view = structureViewModel.View;
double top = 0;
#if FALSE
var contextMenuInfo = parameter.QueryService <ContextMenuInfo>().FirstOrDefault();
if (contextMenuInfo != null && !view.IsEmpty)
{
top = contextMenuInfo.ClickPosition.GetPosition(view).Y;
}
#endif
Structure model = (Structure)structureViewModel.Model;
top -= (top - model.OuterBorderThickness.Top) % StockDiagramGeometries.GridSize;
top = Math.Max(top, model.OuterBorderThickness.Top);
top = Math.Min(top, model.Height - model.OuterBorderThickness.Bottom - StockDiagramGeometries.StandardTunnelHeight);
SMRect l = new SMRect(-StockDiagramGeometries.StandardTunnelOffsetForStructures, top, StockDiagramGeometries.StandardTunnelWidth,
StockDiagramGeometries.StandardTunnelHeight);
SMRect r = new SMRect(model.Width - StockDiagramGeometries.StandardTunnelWidth + StockDiagramGeometries.StandardTunnelOffsetForStructures, top,
StockDiagramGeometries.StandardTerminalWidth, StockDiagramGeometries.StandardTunnelHeight);
while (
model.BorderNodes.Any(
node => node.Bounds.Overlaps(l) || node.Bounds.Overlaps(r)))
{
l.Y += StockDiagramGeometries.GridSize;
r.Y += StockDiagramGeometries.GridSize;
}
// If we ran out of room looking for a place to put Shift Register, we need to grow our Loop
if (l.Bottom > model.Height - model.OuterBorderThickness.Bottom)
{
model.Height = l.Bottom + StockDiagramGeometries.StandardTunnelHeight;
}
leftRect = l;
rightRect = r;
}
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 GetMinMaxMean(StructureSet structureSet, PlanningItemViewModel planningItem, StructureViewModel evalStructure, MatchCollection testMatch, Group evalunit, Group type)
{
try
{
var structure = structureSet.Structures.FirstOrDefault(x => x.Id == evalStructure.StructureName);
if (type.Value.CompareTo("Volume") == 0)
{
return(string.Format("{0:0.00} {1}", evalStructure.VolumeValue, evalunit.Value));
}
else
{
double planSumRxDose = 0;
DVHData dvh;
DoseValuePresentation dvp = (evalunit.Value.CompareTo("%") == 0) ? DoseValuePresentation.Relative : DoseValuePresentation.Absolute;
if (dvp == DoseValuePresentation.Relative && planningItem.PlanningItemObject is PlanSum)
{
PlanSum planSum = (PlanSum)planningItem.PlanningItemObject;
foreach (PlanSetup planSetup in planSum.PlanSetups)
{
double planSetupRxDose = planSetup.TotalDose.Dose;
planSumRxDose += planSetupRxDose;
}
dvh = planningItem.PlanningItemObject.GetDVHCumulativeData(structure, DoseValuePresentation.Absolute, VolumePresentation.Relative, 0.1);
}
else
{
dvh = planningItem.PlanningItemObject.GetDVHCumulativeData(structure, dvp, VolumePresentation.Relative, 0.1);
}
if (type.Value.CompareTo("Max") == 0)
{
//checking dose output unit and adapting to template
//Gy to cGy
if ((evalunit.Value.CompareTo("Gy") == 0) && (dvh.MaxDose.Unit.CompareTo(DoseValue.DoseUnit.cGy) == 0))
{
return(new DoseValue(dvh.MaxDose.Dose / 100, DoseValue.DoseUnit.Gy).ToString());
}
//Gy to Gy or % to %
else
{
if (dvp == DoseValuePresentation.Relative && planningItem.PlanningItemObject is PlanSum)
{
double maxDoseDouble = double.Parse(dvh.MaxDose.ValueAsString);
//double
return((maxDoseDouble / planSumRxDose * 100).ToString("0.0") + " " + evalunit.Value);
}
else
{
return(dvh.MaxDose.ToString());
}
}
}
else if (type.Value.CompareTo("Min") == 0)
{
//checking dose output unit and adapting to template
//Gy to cGy
if ((evalunit.Value.CompareTo("Gy") == 0) && (dvh.MinDose.Unit.CompareTo(DoseValue.DoseUnit.cGy) == 0))
{
return(new DoseValue(dvh.MinDose.Dose / 100, DoseValue.DoseUnit.Gy).ToString());
}
//Gy to Gy or % to %
else
{
return(dvh.MinDose.ToString());
}
}
else
{
//checking dose output unit and adapting to template
//Gy to cGy
if ((evalunit.Value.CompareTo("Gy") == 0) && (dvh.MeanDose.Unit.CompareTo(DoseValue.DoseUnit.cGy) == 0))
{
return(new DoseValue(dvh.MeanDose.Dose / 100, DoseValue.DoseUnit.Gy).ToString());
}
//Gy to Gy or % to %
else
{
return(dvh.MeanDose.ToString());
}
}
}
}
catch (NullReferenceException)
{
return("Unable to calculate - DVH is not valid");
}
}
public static string GetCoveredDoseAtVolume(StructureSet structureSet, PlanningItemViewModel planningItem, StructureViewModel evalStructure, MatchCollection testMatch, Group evalunit)
{
System.Console.WriteLine("Covered Dose at Volume");
return("Not supported");
}
public StructureControl()
{
InitializeComponent();
ViewModel = new StructureViewModel();
this.DataContext = ViewModel;
}
public ActionResult Create()
{
var viewModel = new StructureViewModel();
return(View(viewModel));
}
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 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");
}
}
public static string GetDoseAtVolume(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);
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(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());
}
catch (System.NullReferenceException)
{
return("Unable to calculate - DVH is not valid");
}
}
