public List <Dose> GetDoses()
{
List <Dose> doseList = new List <Dose>();
SqlConnection connection = new SqlConnection(connectionstring);
string query = "SELECT * FROM Table_Dose";
SqlCommand command = new SqlCommand(query, connection);
connection.Open();
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
Dose dose = new Dose();
dose.Id = int.Parse(reader["dose_Id"].ToString());
dose.Name = reader["dose_Name"].ToString();
doseList.Add(dose);
}
reader.Close();
connection.Close();
return(doseList);
}
public async Task <Dose> CreateDose(Dose dose)
{
_dbContext.Doses.Add(dose);
await _dbContext.SaveChangesAsync();
return(_dbContext.Doses.Where(u => u.Id == dose.Id).FirstOrDefault());
}
public List <Dose> listDose()
{
List <Dose> lDose = new List <Dose>();
try
{
this.conn.openConnection();
SqlCommand cmd = new SqlCommand();
cmd.CommandText = "Select id,medida, dosagem , numero from dose";
cmd.Connection = this.conn.SqlConn;
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
Dose dose = new Dose();
dose.Id = reader.GetInt32(reader.GetOrdinal("id"));
dose.Dosagem = reader.GetFloat(reader.GetOrdinal("dosagem"));
dose.Numero = reader.GetInt32(reader.GetOrdinal("numero"));
dose.Medida = reader.GetString(reader.GetOrdinal("medida"));
lDose.Add(dose);
}
this.conn.closeConnection();
}
catch (SqlException ce)
{
throw new DaoException("Erro ao listar Doses :" + ce.Message);
}
return(lDose);
}
/// <summary>
/// Serialize to a JSON object
/// </summary>
public new void SerializeJson(Utf8JsonWriter writer, JsonSerializerOptions options, bool includeStartObject = true)
{
if (includeStartObject)
{
writer.WriteStartObject();
}
((fhirCsR4.Models.BackboneElement) this).SerializeJson(writer, options, false);
if (!string.IsNullOrEmpty(Text))
{
writer.WriteString("text", (string)Text !);
}
if (_Text != null)
{
writer.WritePropertyName("_text");
_Text.SerializeJson(writer, options);
}
if (Site != null)
{
writer.WritePropertyName("site");
Site.SerializeJson(writer, options);
}
if (Route != null)
{
writer.WritePropertyName("route");
Route.SerializeJson(writer, options);
}
if (Method != null)
{
writer.WritePropertyName("method");
Method.SerializeJson(writer, options);
}
if (Dose != null)
{
writer.WritePropertyName("dose");
Dose.SerializeJson(writer, options);
}
if (RateRatio != null)
{
writer.WritePropertyName("rateRatio");
RateRatio.SerializeJson(writer, options);
}
if (RateQuantity != null)
{
writer.WritePropertyName("rateQuantity");
RateQuantity.SerializeJson(writer, options);
}
if (includeStartObject)
{
writer.WriteEndObject();
}
}
public static DoseValue CalculateMeanDose(PlanSetup plan, Structure structure)
{
Dose dose = plan.Dose;
if (dose == null)
{
return(new DoseValue(Double.NaN, DoseValue.DoseUnit.Unknown));
}
plan.DoseValuePresentation = DoseValuePresentation.Absolute;
double sum = 0.0;
int count = 0;
double xres = 2.5;
double yres = 2.5;
double zres = 2.5;
int xcount = (int)((dose.XRes * dose.XSize) / xres);
System.Collections.BitArray segmentStride = new System.Collections.BitArray(xcount);
double[] doseArray = new double[xcount];
DoseValue.DoseUnit doseUnit = dose.DoseMax3D.Unit;
for (double z = 0; z < dose.ZSize * dose.ZRes; z += zres)
{
for (double y = 0; y < dose.YSize * dose.YRes; y += yres)
{
VVector start = dose.Origin +
dose.YDirection * y +
dose.ZDirection * z;
VVector end = start + dose.XDirection * dose.XRes * dose.XSize;
SegmentProfile segmentProfile = structure.GetSegmentProfile(start, end, segmentStride);
DoseProfile doseProfile = null;
for (int i = 0; i < segmentProfile.Count; i++)
{
if (segmentStride[i])
{
if (doseProfile == null)
{
doseProfile = dose.GetDoseProfile(start, end, doseArray);
}
double doseValue = doseProfile[i].Value;
if (!Double.IsNaN(doseValue))
{
sum += doseProfile[i].Value;
count++;
}
}
}
doseProfile = null;
}
}
double mean = sum / ((double)count);
return(new DoseValue(mean, doseUnit));
}
public async Task <IActionResult> PutDose([FromRoute] int id, [FromBody] Dose dose)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != dose.ID)
{
return(BadRequest());
}
_context.Entry(dose).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DoseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
//---------------------------------------------------------------------------------------------
/// <summary>
/// This method finds the maximum vocel value of the dose matrix
/// </summary>
/// <param name="dose">Dose</param>
/// <returns>Maximum value</returns>
//---------------------------------------------------------------------------------------------
static int FindMaxValue(Dose dose)
{
int maxValue = 0;
int[,] buffer = new int[dose.XSize, dose.YSize];
if (dose != null)
{
for (int z = 0; z < dose.ZSize; z++)
{
dose.GetVoxels(z, buffer);
for (int y = 0; y < dose.YSize; y++)
{
for (int x = 0; x < dose.XSize; x++)
{
int value = buffer[x, y];
if (value > maxValue)
{
maxValue = value;
}
}
}
}
}
return(maxValue);
}
protected void btnAdd_Click(object sender, EventArgs e)
{
try
{
if (Page.IsValid)
{
int userId = CurrentEnvironment.LoggedUser.Id;
if (Exists(int.Parse(ddlScheduledVaccination.SelectedValue), int.Parse(txtDoseNumber.Text)))
{
return;
}
if (NameExists(txtFullname.Text.Replace("'", @"''")))
{
return;
}
Dose o = new Dose();
o.ScheduledVaccinationId = int.Parse(ddlScheduledVaccination.SelectedValue);
o.AgeDefinitionId = int.Parse(ddlAgeDefinition.SelectedValue);
o.DoseNumber = int.Parse(txtDoseNumber.Text);
o.Fullname = txtFullname.Text.Replace("'", @"''");
o.Notes = txtNotes.Text.Replace("'", @"''");
o.IsActive = bool.Parse(rblIsActive.SelectedValue);
o.ModifiedOn = DateTime.Now;
o.ModifiedBy = userId;
if (ddlFromAgeDef.SelectedIndex > 0)
{
o.FromAgeDefinitionId = int.Parse(ddlFromAgeDef.SelectedValue);
}
if (ddlToAgeDef.SelectedIndex > 0)
{
o.ToAgeDefinitionId = int.Parse(ddlToAgeDef.SelectedValue);
}
int i = Dose.Insert(o);
if (i > 0)
{
lblSuccess.Visible = true;
lblWarning.Visible = false;
lblError.Visible = false;
gridview_Databind(i);
ClearControls(this);
}
else
{
lblSuccess.Visible = false;
lblWarning.Visible = false;
lblError.Visible = true;
}
}
}
catch (Exception ex)
{
lblSuccess.Visible = false;
lblWarning.Visible = false;
lblError.Visible = true;
}
}
public static double[,,] EsapiDoseToDose3dArray(Dose doseEsapi)
{
int xSize = doseEsapi.XSize;
int ySize = doseEsapi.YSize;
int zSize = doseEsapi.ZSize;
double[,,] dose3dArray = new double[zSize, ySize, xSize];
int[,] voxelValuesInPlane = new int[xSize, ySize];
for (int i = 0; i < zSize; i++)
{
doseEsapi.GetVoxels(i, voxelValuesInPlane);
for (int j = 0; j < ySize; j++)
{
for (int k = 0; k < xSize; k++)
{
int voxelValue = voxelValuesInPlane[k, j];
var doseValue = doseEsapi.VoxelToDoseValue(voxelValue);
dose3dArray[i, j, k] = doseValue.Dose;
}
}
}
return(dose3dArray);
}
protected void btnRemove_Click(object sender, EventArgs e)
{
try
{
int id = -1;
string _id = Request.QueryString["id"].ToString();
int.TryParse(_id, out id);
int userId = CurrentEnvironment.LoggedUser.Id;
int i = Dose.Remove(id);
if (i > 0)
{
lblSuccess.Visible = true;
lblWarning.Visible = false;
lblError.Visible = false;
gridview_Databind(id);
ClearControls(this);
}
else
{
lblSuccess.Visible = false;
lblWarning.Visible = true;
lblError.Visible = false;
}
}
catch (Exception ex)
{
lblSuccess.Visible = false;
lblWarning.Visible = false;
lblError.Visible = true;
}
}
public void TestComparisons(double doseGy1, double doseGy2, string comparison, bool expectedResult)
{
// Set to a large tolerance to make the tests more obvious
Dose.Tolerance = new Dose(0.5, DoseUnit.Gy);
var dose1 = new Dose(doseGy1, DoseUnit.Gy);
var dose2 = new Dose(doseGy2, DoseUnit.Gy);
bool result;
switch (comparison)
{
case "==": result = dose1 == dose2; break;
case "!=": result = dose1 != dose2; break;
case "<": result = dose1 < dose2; break;
case ">": result = dose1 > dose2; break;
case "<=": result = dose1 <= dose2; break;
case ">=": result = dose1 >= dose2; break;
default: throw new ArgumentException("Unknown comparison");
}
Assert.That(result, Is.EqualTo(expectedResult));
}
public void TryParse_Validdose_ReturnsTrueAndParsedDose(string doseStr, double expectedDoseValue, DoseUnit expectedDoseUnit)
{
var parsed = Dose.TryParse(doseStr, out var dose);
Assert.That(parsed, Is.True);
Assert.That(dose, Is.EqualTo(new Dose(expectedDoseValue, expectedDoseUnit)));
}
public async Task <int> EditTreatment(
int treatmentId,
int beehiveId,
DateTime dateOfTreatment,
string name,
string note,
string disease,
string medication,
InputAs inputAs,
double quantity,
Dose dose)
{
var treatment = this.treatmentRepository
.All()
.FirstOrDefault(t => t.Id == treatmentId);
treatment.DateOfTreatment = dateOfTreatment;
treatment.Name = name;
treatment.Note = note;
treatment.Disease = disease;
treatment.Medication = medication;
treatment.InputAs = inputAs;
treatment.Quantity = quantity;
treatment.Dose = dose;
await this.treatmentRepository.SaveChangesAsync();
return(treatmentId);
}
public void Run(User user,
Patient patient,
Image image,
StructureSet structureSet,
PlanSetup planSetup,
IEnumerable <PlanSetup> planSetups,
IEnumerable <PlanSum> planSums,
Window window)
{
//
//Dose profiles
//
var prof = Profile.getBeamDoseProfile(planSetup.Beams.First(), new VVector(1.0, 0, 0), distanceFromIsocenterTowardSourceInmm: 30);
Helpers.DumpIntoMatlab(prof.Select(val => double.IsNaN(val.Value) ? 0 : val.Value).ToArray(), new int[] { prof.Count }, "orthogonalDoseProfile");
var dprof = Profile.getBeamDepthDoseProfileAlongBeamAxis(structureSet.Structures.Single(st => st.Id == "BODY"), planSetup.Beams.ToArray()[4]);
Helpers.DumpIntoMatlab(dprof.Select(val => double.IsNaN(val.Value) ? 0 : val.Value).ToArray(), new int[] { dprof.Count }, "depthdoseProfile");
var dprof2 = Profile.getBeamDoseProfile(planSetup.Beams.First(), new VVector(0, -1.0, 0));
Helpers.DumpIntoMatlab(dprof2.Select(val => double.IsNaN(val.Value) ? 0 : val.Value).ToArray(), new int[] { dprof2.Count }, "depthdoseProfile2");
//
// Dose plane
//
var plane = Plane.OrthogonalDoseCrossSection(planSetup.Beams.ToArray()[4]);
var planeAsArray = new double[plane.Length];
Buffer.BlockCopy(plane, 0, planeAsArray, 0, plane.Length * sizeof(double));
Helpers.DumpIntoMatlab(planeAsArray, new int[] { plane.GetLength(1), plane.GetLength(0) }, "orthogonalPlane");
//
// Image profiles
//
var(xProf, yProf, zProf) = Profile.getImageProfilesThroughIsocenter(planSetup);
Helpers.DumpIntoMatlab(xProf.Select(val => double.IsNaN(val.Value) ? 0 : val.Value).ToArray(), new int[] { xProf.Count }, "XProfile");
Helpers.DumpIntoMatlab(xProf.Select(val => double.IsNaN(val.Value) ? 0 : val.Value).ToArray(), new int[] { xProf.Count }, "XProfile");
Helpers.DumpIntoMatlab(zProf.Select(val => double.IsNaN(val.Value) ? 0 : val.Value).ToArray(), new int[] { zProf.Count }, "ZProfile");
//
// DVH with dose profiles.
//
planSetup.DoseValuePresentation = DoseValuePresentation.Absolute;
var p2 = patient.Courses.Single(cr => cr.Id == planSetup.Course.Id).PlanSetups.Single(pl => pl.Id == "Plan2");
p2.DoseValuePresentation = DoseValuePresentation.Absolute;
var doses = new Dose[] {
planSetup.Dose
//p2.Dose
};
var(cDVH, dDVH, sampleCoverage) = DVH.StructureDVH(doses, structureSet.Structures.Single(st => st.Id == "CTV"), new DVH.NoConversion());
Helpers.DumpIntoMatlab(Helpers.into1DArray(dDVH.Select(val => new double[] { val.doseValue, val.Volume }).ToArray()), new int[] { 2, dDVH.Length }, "dDVH");
Helpers.DumpIntoMatlab(Helpers.into1DArray(cDVH.Select(val => new double[] { val.doseValue, val.Volume }).ToArray()), new int[] { 2, cDVH.Length }, "cDVH");
return;
}
private void button1_Click(object sender, EventArgs e)
{
abrirPaciente(textBox1.Text);
plan = paciente.Courses.First().PlanSetups.First();
VMS.TPS.Common.Model.API.Image imagen = plan.StructureSet.Image;
var isoc = imagen.DicomToUser(imagen.Origin, plan);
Beam campo = plan.Beams.First();
//VVector iso = campo.IsocenterPosition.;
foreach (Structure estructura in plan.StructureSet.Structures)
{
for (int z = 0; z < 120; z++)
{
var contorno = estructura.GetContoursOnImagePlane(35);
/*if (contorno.Count()>0)
* {
* MessageBox.Show(z.ToString() + estructura.Id);
* }*/
}
}
Dose dose = plan.Dose;
IEnumerable <Isodose> isodosis = dose.Isodoses;
foreach (Isodose iso in isodosis)
{
var mesh = iso.MeshGeometry;
}
//plan = paciente.Courses.First().PlanSetups.Where(p => p.Id == "Plan2 #").FirstOrDefault();
Imagen(paciente, plan);
}
private void setup()
{
IQueryable <Dose> doses = new Dose[]
{
new Dose
{
Id = 1,
Type = "Milk",
IsBadge = true,
IsMug = true,
CreatedAt = Convert.ToDateTime("2021-04-09 11:04:09.940"),
User = "******"
},
new Dose
{
Id = 1,
Type = "Tea",
IsBadge = true,
IsMug = true,
CreatedAt = Convert.ToDateTime("2021-04-09 12:04:09.940"),
User = "******"
},
new Dose
{
Id = 1,
Type = "Milk",
IsBadge = true,
IsMug = true,
CreatedAt = Convert.ToDateTime("2021-04-09 13:04:09.940"),
User = "******"
}
}.AsQueryable();
}
public void Equals_ReturnsTrue_IfBothDosesAreNull()
{
Dose dose1 = null;
var result = dose1 == null;
Assert.That(result, Is.True);
}
/// <summary> Checks if the calc factor variance is valid based on previous acceptances. </summary>
/// <param name="context"></param>
protected override void DoWork(CodeActivityContext context)
{
int drgId = DrgId.Get(context);
double dose = Dose.Get(context);
var ext = context.GetExtension <IOrderApprovalExtension>();
Result.Set(context, ext.IsDoseAccepted(drgId, dose));
}
public void DivideByScalar_ReturnsDoseDividedByScalar()
{
var dose = new Dose(10, DoseUnit.Gy);
var result = dose / 10;
Assert.That(result.Gy, Is.EqualTo(1));
}
public void Negative_ReturnsNegativeDose()
{
var dose = new Dose(10, DoseUnit.Gy);
var result = -dose;
Assert.That(result.Gy, Is.EqualTo(-10));
}
public List <DoseVacina> getDoseVacina(Vacinacao vacinacao)
{
try
{
this.conn.openConnection();
//cmd.CommandText =
List <DoseVacina> lDoseVacina = new List <DoseVacina>();
SqlCommand cmd = new SqlCommand();
string sql = " SELECT dv.id, dv.dose_id ,dv.vacina_id , dv.data_proxima_aplicacao , dv.data_aplicacao ";
sql += " , d.dosagem , d.numero ,d.medida ,d.data_cadastro as dose_data_cadastro, v.nome , v.descricao ";
sql += " FROM dose_vacina dv INNER JOIN dose d ON dv.dose_id = d.id ";
sql += " INNER JOIN vacina v ON dv.vacina_id = v.id WHERE vacinacao_id = @vacinacao";
cmd.CommandText = sql;
cmd.Connection = this.conn.SqlConn;
cmd.Parameters.AddWithValue("@vacinacao", vacinacao.Id);
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
DoseVacina doseVacina = new DoseVacina();
// dose
Dose dose = new Dose();
dose.Id = reader.GetInt32(reader.GetOrdinal("dose_id"));
dose.Dosagem = (float)reader.GetDouble(reader.GetOrdinal("dosagem"));
dose.Numero = reader.GetInt32(reader.GetOrdinal("numero"));
dose.Medida = reader.GetString(reader.GetOrdinal("medida"));
dose.DataCadastro = reader.GetDateTime(reader.GetOrdinal("dose_data_cadastro"));
doseVacina.Dose = dose;
// vacina
Vacina vacina = new Vacina();
vacina.Id = reader.GetInt32(reader.GetOrdinal("vacina_id"));
vacina.Nome = reader.GetString(reader.GetOrdinal("nome"));
vacina.Descricao = reader.GetString(reader.GetOrdinal("descricao"));
doseVacina.Vacina = vacina;
doseVacina.DataAplicacao = reader.GetDateTime(reader.GetOrdinal("data_aplicacao"));
doseVacina.ProximaAplicacao = reader.GetDateTime(reader.GetOrdinal("data_proxima_aplicacao"));
lDoseVacina.Add(doseVacina);
}
this.conn.closeConnection();
return(lDoseVacina);
}
catch (SqlException ce)
{
throw new DaoException("Erro ao listar Dose vacina :" + ce.Message);
}
}
public void Execute(ScriptContext context)
{
// Check for patient loaded
if (context.Patient == null)
{
MessageBox.Show("Shucks: No patient selected! :(");
return;
}
// Check for patient plan loaded
PlanSetup plan = context.PlanSetup;
if (plan == null)
{
MessageBox.Show("Darn: No plan loaded! :( ");
return;
}
//Is there a structure set?
if (context.StructureSet == null)
{
MessageBox.Show("Oh No!: no structure set found! :(");
}
Patient testPatient = context.Patient;
PlanSetup plan1 = context.PlanSetup;
Image image = context.Image;
Dose dose = plan1.Dose;
plan.DoseValuePresentation = DoseValuePresentation.Absolute;
//Get the structures:
StructureSet structureSet = context.StructureSet;
//Make A list for structure names, and a list for structure mean doses
double[] organDoses = new double[19];
string[] organNames = new string[19];
organNames[0] = ("stem"); //0
organNames[1] = ("stemPRV"); //1
organNames[2] = ("cord"); //2
organNames[3] = ("cordPRV"); //3
organNames[4] = ("PTV70"); //4
organNames[5] = ("PTV66");
organNames[6] = ("PTV63"); //5
organNames[7] = ("PTV60"); //6
organNames[8] = ("PTV56"); //7
organNames[9] = ("PTV54"); //8
organNames[10] = ("PTV50"); //9
organNames[11] = ("PTV45"); //10
organNames[12] = ("PTV35"); //11
organNames[13] = ("RPar"); //12
organNames[14] = ("LPar"); //13
organNames[15] = ("RSub"); //14
organNames[16] = ("LSub"); //15
organNames[17] = ("OCav"); //16
organNames[18] = ("Lar"); //17
//Make the CSV:
DoseExporter(structureSet, organDoses, organNames, plan1, testPatient);
}
public static double EsapiDoseZIndexToDicomCoodinate(int i, Dose doseEsapi)
{
double zRes = doseEsapi.ZRes;
double zOrigin = doseEsapi.Origin[2];
double z = EsapiIndexToCoordinate(i, zOrigin, zRes);
return(z);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="planSetup">ESAPI PlanSetup.</param>
public DoseVoxel(PlanSetup planSetup)
{
PlanSetup = planSetup;
Dose doseEsapi = planSetup.Dose;
var doseValues = EsapiHelpers.EsapiDoseToDose3dArray(doseEsapi);
Voxel = new VolumeAverage.Voxel(doseEsapi.XSize, doseEsapi.YSize, doseEsapi.ZSize,
doseEsapi.Origin.x, doseEsapi.Origin.y, doseEsapi.Origin.z, doseEsapi.XRes, doseEsapi.YRes, doseEsapi.ZRes, doseValues);
}
public static double EsapiDoseYIndexToDicomCoodinate(int i, Dose doseEsapi)
{
double yRes = doseEsapi.YRes;
double yOrigin = doseEsapi.Origin[1];
double y = EsapiIndexToCoordinate(i, yOrigin, yRes);
return(y);
}
public static double EsapiDoseXIndexToDicomCoodinate(int i, Dose doseEsapi)
{
double xRes = doseEsapi.XRes;
double xOrigin = doseEsapi.Origin[0];
double x = EsapiIndexToCoordinate(i, xOrigin, xRes);
return(x);
}
public void Add_ReturnsSumOfDoses()
{
var dose1 = new Dose(10, DoseUnit.Gy);
var dose2 = new Dose(100, DoseUnit.CGy);
var result = dose1 + dose2;
Assert.That(result.Gy, Is.EqualTo(11));
}
public void Subtract_ReturnsSubtractionOfDoses()
{
var dose1 = new Dose(100, DoseUnit.Gy);
var dose2 = new Dose(1000, DoseUnit.CGy);
var result = dose1 - dose2;
Assert.That(result.Gy, Is.EqualTo(90));
}
public void Divide_ReturnsRatioOfDoses()
{
var dose1 = new Dose(100, DoseUnit.Gy);
var dose2 = new Dose(1000, DoseUnit.CGy);
var result = dose1 / dose2;
Assert.That(result.Gy, Is.EqualTo(10));
}
private void ResetFormControls()
{
Id = 0;
textBox1.Clear();
textBox2.Clear();
Dose.Clear();
Price.Clear();
textBox1.Focus();
}
