private void ClearPlot(EarType earType)
{
List <LineSeries> lineSeriesList = null;
if (earType == EarType.RightEar)
{
lineSeriesList = RtEarSeriesList;
}
else if (earType == EarType.LeftEar)
{
lineSeriesList = LtEarSeriesList;
}
else
{
throw new InvalidEnumArgumentException();
}
foreach (var lineSeries in lineSeriesList)
{
List <DataPoint> points = lineSeries.Points;
points.Clear();
}
lineSeriesList.Clear();
}
public static ScreenPoint[] CreateCustomMarker(EarType earType, bool isNoResponse, bool addShift)
{
const double lBottomX = 0.5;
const double lTopY = 0.75;
List <ScreenPoint> marker = new List <ScreenPoint>();
ScreenPoint topLeft = new ScreenPoint(-lBottomX, -lTopY);
ScreenPoint bottomLeft = new ScreenPoint(-lBottomX, lTopY);
ScreenPoint bottomRight = new ScreenPoint(lBottomX, lTopY);
marker.Add(bottomRight);
marker.Add(bottomLeft);
marker.Add(topLeft);
marker.Add(bottomLeft);
marker.Add(bottomRight);
if (isNoResponse)
{
ArrowMarker.AddArrowToMarker(marker, earType, bottomRight.X, bottomRight.Y);
}
if (addShift)
{
ShiftMarker.AddShift(marker, earType);
}
return(marker.ToArray());
}
public static ScreenPoint[] CreateCustomMarker(EarType earType, bool isNoResponse)
{
const double topRightX = 0.75;
const double topRightY = -1;
const double topLeftX = -0.25;
const double topLeftY = topRightY;
const double bottomLeftX = topLeftX;
const double bottomLeftY = -topLeftY;
const double bottomRightX = topRightX;
const double bottomRightY = bottomLeftY;
List <ScreenPoint> marker = new List <ScreenPoint>();
if (earType == EarType.RightEar)
{
ScreenPoint topRight = new ScreenPoint(topRightX, topRightY);
ScreenPoint topLeft = new ScreenPoint(topLeftX, topLeftY);
ScreenPoint bottomLeft = new ScreenPoint(bottomLeftX, bottomLeftY);
ScreenPoint bottomRight = new ScreenPoint(bottomRightX, bottomRightY);
marker.Add(bottomLeft);
marker.Add(topLeft);
marker.Add(topRight);
marker.Add(topLeft);
marker.Add(bottomLeft);
marker.Add(bottomRight);
marker.Add(bottomLeft);
if (isNoResponse)
{
ArrowMarker.AddArrowToMarker(marker, earType, bottomLeft.X, bottomLeft.Y);
}
}
else if (earType == EarType.LeftEar)
{
ScreenPoint topLeft = new ScreenPoint(-topRightX, topRightY);
ScreenPoint topRight = new ScreenPoint(-topLeftX, topLeftY);
ScreenPoint bottomRight = new ScreenPoint(-bottomLeftX, bottomLeftY);
ScreenPoint bottomLeft = new ScreenPoint(-bottomRightX, bottomRightY);
marker.Add(bottomRight);
marker.Add(topRight);
marker.Add(topLeft);
marker.Add(topRight);
marker.Add(bottomRight);
marker.Add(bottomLeft);
marker.Add(bottomRight);
if (isNoResponse)
{
ArrowMarker.AddArrowToMarker(marker, earType, bottomRight.X, bottomRight.Y);
}
}
else
{
throw new InvalidEnumArgumentException();
}
return(marker.ToArray());
}
public static void AddShift(List <ScreenPoint> marker, EarType earType)
{
AGPoint shift = GetShift(earType);
for (int i = 0; i < marker.Count; i++)
{
marker[i] = new ScreenPoint(marker[i].X + shift.X, marker[i].Y + shift.Y);
}
}
public static ScreenPoint[] CreateCustomMarker(EarType earType, bool isNoResponse, bool addShift)
{
const double lowerLeftX = -0.75;
const double lowerLeftY = 0.75;
const double upperX = 0;
const double upperY = -0.75;
const double lowerRightX = 0.75;
const double lowerRightY = 0.75;
const double midRightX = 0.375;
const double midRightY = 0;
const double midLeftX = -0.375;
const double midLeftY = 0;
ScreenPoint lowerLeft = new ScreenPoint(lowerLeftX, lowerLeftY);
ScreenPoint upper = new ScreenPoint(upperX, upperY);
ScreenPoint lowerRight = new ScreenPoint(lowerRightX, lowerRightY);
ScreenPoint midRight = new ScreenPoint(midRightX, midRightY);
ScreenPoint midLeft = new ScreenPoint(midLeftX, midLeftY);
List <ScreenPoint> marker = new List <ScreenPoint>();
if (earType == EarType.RightEar)
{
marker.Add(lowerLeft);
marker.Add(upper);
marker.Add(lowerRight);
marker.Add(midRight);
marker.Add(midLeft);
marker.Add(lowerLeft);
}
else if (earType == EarType.LeftEar)
{
marker.Add(lowerRight);
marker.Add(upper);
marker.Add(lowerLeft);
marker.Add(midLeft);
marker.Add(midRight);
marker.Add(lowerRight);
}
else
{
throw new InvalidEnumArgumentException();
}
if (isNoResponse)
{
ArrowMarker.AddArrowToMarker(marker, earType, marker.Last().X, marker.Last().Y);
}
if (addShift)
{
ShiftMarker.AddShift(marker, earType);
}
return(marker.ToArray());
}
protected override LineSeries AddLineSeries(EarType earType, bool isNoResponse)
{
LineSeries lineSeries = new LineSeries();
SetCommonValues(earType, lineSeries);
lineSeries.MarkerType = MarkerType.Custom;
lineSeries.MarkerOutline = ACAidMarker.CreateCustomMarker(earType, isNoResponse, true);
lineSeries.LineStyle = LineStyle.None;
return(lineSeries);
}
public static ScreenPoint[] CreateCustomMarker(EarType earType, bool addArrow)
{
double radius = Math.Sqrt(2);
double angleRad = 7 * Math.PI / 4;
double shift = radius / 2;
double topRightX = radius * Math.Cos(angleRad) - shift;
double topRightY = radius * Math.Sin(angleRad);
double midX = -shift;
double midY = 0;
double bottomRightX = topRightX;
double bottomRightY = -topRightY;
List <ScreenPoint> marker = new List <ScreenPoint>();
if (earType == EarType.RightEar)
{
ScreenPoint bottomRight = new ScreenPoint(bottomRightX, bottomRightY);
ScreenPoint mid = new ScreenPoint(midX, midY);
ScreenPoint topRight = new ScreenPoint(topRightX, topRightY);
marker.Add(bottomRight);
marker.Add(mid);
marker.Add(topRight);
marker.Add(mid);
marker.Add(bottomRight);
if (addArrow)
{
ArrowMarker.AddArrowToMarker(marker, earType, bottomRightX, bottomRightY);
}
}
else if (earType == EarType.LeftEar)
{
ScreenPoint bottomLeft = new ScreenPoint(-bottomRightX, bottomRightY);
ScreenPoint mid = new ScreenPoint(-midX, midY);
ScreenPoint topLeft = new ScreenPoint(-topRightX, topRightY);
marker.Add(bottomLeft);
marker.Add(mid);
marker.Add(topLeft);
marker.Add(mid);
marker.Add(bottomLeft);
if (addArrow)
{
ArrowMarker.AddArrowToMarker(marker, earType, -bottomRightX, bottomRightY);
}
}
else
{
throw new InvalidEnumArgumentException();
}
return(marker.ToArray());
}
public static MarkerType GetDefaultMarker(EarType earType)
{
if (earType == EarType.RightEar)
{
return(MarkerType.Triangle);
}
else if (earType == EarType.LeftEar)
{
return(MarkerType.Square);
}
else
{
throw new InvalidEnumArgumentException();
}
}
public static ScreenPoint[] CreateCustomMarkerWithArrow(EarType earType)
{
List <ScreenPoint> marker = new List <ScreenPoint>();
if (earType == EarType.RightEar)
{
double radius = 1;
double arrowTailAngleRad = Math.PI / 2;
double arrowTailX = radius * Math.Cos(arrowTailAngleRad);
double arrowTailY = radius * Math.Sin(arrowTailAngleRad);
double numOfPoints = 50;
double angleInc = 2 * Math.PI / numOfPoints;
for (int i = 0; i <= numOfPoints; i++)
{
double angleRad = arrowTailAngleRad + (angleInc * i);
marker.Add(new ScreenPoint(radius * Math.Cos(angleRad), radius * Math.Sin(angleRad)));
}
ArrowMarker.AddArrowToMarker(marker, earType, arrowTailX, arrowTailY);
}
else if (earType == EarType.LeftEar)
{
double arrowTailX = 1;
double arrowTailY = 1;
ScreenPoint bottomRight = new ScreenPoint(arrowTailX, arrowTailY);
ScreenPoint center = new ScreenPoint(0, 0);
ScreenPoint topRight = new ScreenPoint(arrowTailX, -arrowTailY);
ScreenPoint bottomLeft = new ScreenPoint(-arrowTailX, arrowTailY);
ScreenPoint topLeft = new ScreenPoint(-arrowTailX, -arrowTailY);
marker.Add(bottomRight);
marker.Add(center);
marker.Add(topRight);
marker.Add(bottomLeft);
marker.Add(center);
marker.Add(topLeft);
marker.Add(bottomRight);
ArrowMarker.AddArrowToMarker(marker, earType, arrowTailX, arrowTailY);
}
else
{
throw new InvalidEnumArgumentException();
}
return(marker.ToArray());
}
protected override LineSeries AddLineSeries(EarType earType, bool isNoResponse)
{
LineSeries lineSeries = new LineSeries();
SetCommonValues(earType, lineSeries);
if (isNoResponse)
{
lineSeries.MarkerType = MarkerType.Custom;
lineSeries.MarkerOutline = ACUmskMarker.CreateCustomMarkerWithArrow(earType);
lineSeries.LineStyle = LineStyle.None;
}
else
{
lineSeries.MarkerType = ACUmskMarker.GetDefaultMarker(earType);
}
return(lineSeries);
}
protected string GetHearingLevel(EarType ear, double freqHz)
{
string hearingLevel = string.Empty;
if (ear == EarType.RightEar)
{
hearingLevel = (HearingLevels.ContainsKey(freqHz)) ? HearingLevels[freqHz].RightEarHLdBStr : String.Empty;
}
else if (ear == EarType.LeftEar)
{
hearingLevel = (HearingLevels.ContainsKey(freqHz)) ? HearingLevels[freqHz].LeftEarHLdBStr : String.Empty;
}
else
{
throw new InvalidEnumArgumentException();
}
return(hearingLevel);
}
public async Task <int> SaveEarType(EarType earType)
{
if (earType.Id != 0)
{
_context.EarTypes.Update(earType);
await _context.SaveChangesAsync();
return(1);
}
else
{
await _context.EarTypes.AddAsync(earType);
await _context.SaveChangesAsync();
return(1);
}
}
public static void AddArrowToMarker(List <ScreenPoint> marker, EarType earType, double arrowTailX, double arrowTailY)
{
const double arrowTailLength = 1.5;
const double arrowTailAngleRad = 45 * Math.PI / 180;
const double arrowEarDistance = 0.75;
const double arrowEarAngleRad = 20 * Math.PI / 180;
if (earType == EarType.RightEar)
{
double arrowTipX = arrowTailX - (arrowTailLength * Math.Cos(arrowTailAngleRad));
double arrowTipY = arrowTailY + (arrowTailLength * Math.Sin(arrowTailAngleRad));
double arrowUpperEarX = arrowTailX - (arrowEarDistance * Math.Cos(arrowEarAngleRad));
double arrowUpperEarY = arrowTailY + (arrowEarDistance * Math.Sin(arrowEarAngleRad));
double arrowLowerEarX = arrowTailX - (arrowEarDistance * Math.Cos(2 * arrowTailAngleRad - arrowEarAngleRad));
double arrowLowerEarY = arrowTailY + (arrowEarDistance * Math.Sin(2 * arrowTailAngleRad - arrowEarAngleRad));
marker.Add(new ScreenPoint(arrowTipX, arrowTipY));
marker.Add(new ScreenPoint(arrowUpperEarX, arrowUpperEarY));
marker.Add(new ScreenPoint(arrowTipX, arrowTipY));
marker.Add(new ScreenPoint(arrowLowerEarX, arrowLowerEarY));
marker.Add(new ScreenPoint(arrowTipX, arrowTipY));
marker.Add(new ScreenPoint(arrowTailX, arrowTailY));
}
else if (earType == EarType.LeftEar)
{
double arrowTipX = arrowTailX + (arrowTailLength * Math.Cos(arrowTailAngleRad));
double arrowTipY = arrowTailY + (arrowTailLength * Math.Sin(arrowTailAngleRad));
double arrowUpperEarX = arrowTailX + (arrowEarDistance * Math.Cos(arrowEarAngleRad));
double arrowUpperEarY = arrowTailY + (arrowEarDistance * Math.Sin(arrowEarAngleRad));
double arrowLowerEarX = arrowTailX + (arrowEarDistance * Math.Cos(2 * arrowTailAngleRad - arrowEarAngleRad));
double arrowLowerEarY = arrowTailY + (arrowEarDistance * Math.Sin(2 * arrowTailAngleRad - arrowEarAngleRad));
marker.Add(new ScreenPoint(arrowTipX, arrowTipY));
marker.Add(new ScreenPoint(arrowUpperEarX, arrowUpperEarY));
marker.Add(new ScreenPoint(arrowTipX, arrowTipY));
marker.Add(new ScreenPoint(arrowLowerEarX, arrowLowerEarY));
marker.Add(new ScreenPoint(arrowTipX, arrowTipY));
marker.Add(new ScreenPoint(arrowTailX, arrowTailY));
}
else
{
throw new InvalidEnumArgumentException();
}
}
private static AGPoint GetShift(EarType earType)
{
const double shiftX = 0.2;
const double shiftY = 0.1;
AGPoint shift = new AGPoint();
if (earType == EarType.RightEar)
{
shift.X = -shiftX;
shift.Y = shiftY;
}
else if (earType == EarType.LeftEar)
{
shift.X = shiftX;
shift.Y = -shiftY;
}
else
{
throw new InvalidEnumArgumentException();
}
return(shift);
}
public static ScreenPoint[] CreateCustomMarkerWithArrow(EarType earType)
{
List <ScreenPoint> marker = new List <ScreenPoint>();
if (earType == EarType.RightEar)
{
double arrowTailX = -1;
double arrowTailY = 0.5;
ScreenPoint left = new ScreenPoint(-1, 0.5);
ScreenPoint right = new ScreenPoint(1, 0.5);
ScreenPoint top = new ScreenPoint(0, -1);
marker.Add(left);
marker.Add(top);
marker.Add(right);
marker.Add(left);
ArrowMarker.AddArrowToMarker(marker, earType, arrowTailX, arrowTailY);
}
else if (earType == EarType.LeftEar)
{
double arrowTailX = 1;
double arrowTailY = 1;
ScreenPoint rightBottom = new ScreenPoint(arrowTailX, arrowTailY);
ScreenPoint rightTop = new ScreenPoint(arrowTailX, -arrowTailY);
ScreenPoint leftTop = new ScreenPoint(-arrowTailX, -arrowTailY);
ScreenPoint leftBottom = new ScreenPoint(-arrowTailX, arrowTailY);
marker.Add(rightBottom);
marker.Add(rightTop);
marker.Add(leftTop);
marker.Add(leftBottom);
marker.Add(rightBottom);
ArrowMarker.AddArrowToMarker(marker, earType, arrowTailX, arrowTailY);
}
else
{
throw new InvalidEnumArgumentException();
}
return(marker.ToArray());
}
protected void SetCommonValues(EarType earType, LineSeries lineSeries)
{
if (earType == EarType.RightEar)
{
RtEarSeriesList.Add(lineSeries);
lineSeries.MarkerStroke = RtEarMarkerColor;
lineSeries.Color = RtEarLineColor;
}
else if (earType == EarType.LeftEar)
{
LtEarSeriesList.Add(lineSeries);
lineSeries.MarkerStroke = LtEarMarkerColor;
lineSeries.Color = LtEarLineColor;
}
else
{
throw new InvalidEnumArgumentException();
}
lineSeries.MarkerStrokeThickness = MarkerStrokeThickness;
lineSeries.MarkerSize = MarkerSize;
PlotModel.Series.Add(lineSeries);
}
private void UpdateAvgSpPercImpairDisability(EarType earType)
{
double?th500;
double?th1000;
double?th2000;
double?th3000;
if (earType == EarType.RightEar)
{
if (HearingLevels.ContainsKey(500) && HearingLevels.ContainsKey(1000) &&
HearingLevels.ContainsKey(2000) && HearingLevels.ContainsKey(3000))
{
th500 = HearingLevels[500].RightEarHLdB;
th1000 = HearingLevels[1000].RightEarHLdB;
th2000 = HearingLevels[2000].RightEarHLdB;
th3000 = HearingLevels[3000].RightEarHLdB;
if (th500 != null && th1000 != null && th2000 != null && th3000 != null)
{
AvgSpPerRtEar = (th500.Value + th1000.Value + th2000.Value + th3000.Value) / 4;
if (AvgSpPerRtEar > 25)
{
ImpairRtEar = (AvgSpPerRtEar - 25) * 1.5;
}
else
{
ImpairRtEar = 0;
}
}
}
}
else if (earType == EarType.LeftEar)
{
if (HearingLevels.ContainsKey(500) && HearingLevels.ContainsKey(1000) &&
HearingLevels.ContainsKey(2000) && HearingLevels.ContainsKey(3000))
{
th500 = HearingLevels[500].LeftEarHLdB;
th1000 = HearingLevels[1000].LeftEarHLdB;
th2000 = HearingLevels[2000].LeftEarHLdB;
th3000 = HearingLevels[3000].LeftEarHLdB;
if (th500 != null && th1000 != null && th2000 != null && th3000 != null)
{
AvgSpPerLtEar = (th500.Value + th1000.Value + th2000.Value + th3000.Value) / 4;
if (AvgSpPerLtEar > 25)
{
ImpairLtEar = (AvgSpPerLtEar - 25) * 1.5;
}
else
{
ImpairLtEar = 0;
}
}
}
}
else
{
throw new NotImplementedException("Unimplemented EarType " + earType.ToString());
}
if (ImpairRtEar < ImpairLtEar)
{
Disability = ((ImpairRtEar * 5) + ImpairLtEar) / 6;
}
else
{
Disability = ((ImpairLtEar * 5) + ImpairRtEar) / 6;
}
}
protected void SetHearingLevel(EarType ear, double freqHz, string hearingLevel)
{
HearingLevelValidation hlValidator = new HearingLevelValidation();
ValidationResult validResult = hlValidator.Validate(hearingLevel, CultureInfo.InvariantCulture);
HLValidationError = validResult.IsValid ? String.Empty : validResult.ErrorContent.ToString();
if (validResult.IsValid)
{
if (HearingLevels.ContainsKey(freqHz))
{
if (ear == EarType.RightEar)
{
HearingLevels[freqHz].RightEarHLdBStr = hearingLevel;
}
else if (ear == EarType.LeftEar)
{
HearingLevels[freqHz].LeftEarHLdBStr = hearingLevel;
}
else
{
throw new InvalidEnumArgumentException();
}
}
else
{
if (ear == EarType.RightEar)
{
HearingLevels.Add(freqHz, new HearingLevel {
RightEarHLdBStr = hearingLevel
});
}
else if (ear == EarType.LeftEar)
{
HearingLevels.Add(freqHz, new HearingLevel {
LeftEarHLdBStr = hearingLevel
});
}
else
{
throw new InvalidEnumArgumentException();
}
}
AudiogramPlot.UpdateEarPlot(ear, HearingLevels, AddBCFreqShift);
if (ear == EarType.RightEar)
{
HasRtEarValidData = HearingLevels.Values.Any(hl => hl.RightEarHLdB != null ||
hl.RightEarHLdBStr == HearingLevelTypes.NoResponse.GetDescription());
}
else if (ear == EarType.LeftEar)
{
HasLtEarValidData = HearingLevels.Values.Any(hl => hl.LeftEarHLdB != null ||
hl.LeftEarHLdBStr == HearingLevelTypes.NoResponse.GetDescription());
}
else
{
throw new InvalidEnumArgumentException();
}
}
}
private async Task ChangeEar(ChangeEventArgs eventArgs)
{
currentEarType = (EarType)(int.Parse(eventArgs.Value.ToString()));
await RefreshDataAsync();
}
public static ScreenPoint[] CreateCustomMarker(EarType earType, bool isNoResponse, bool addShift)
{
const double a = 0.5;
const double b = 0.375;
List <AGPoint> sUpperUpperHalf = new List <AGPoint>();
sUpperUpperHalf.Add(new AGPoint(0.5, 0));
sUpperUpperHalf.Add(new AGPoint(0.3, 0));
sUpperUpperHalf.Add(new AGPoint(0.1, 0));
sUpperUpperHalf.Add(new AGPoint(-0.1, 0));
sUpperUpperHalf.Add(new AGPoint(-0.3, 0));
sUpperUpperHalf.Add(new AGPoint(-0.5, 0));
int i = 0;
for (; i < sUpperUpperHalf.Count; i++)
{
sUpperUpperHalf[i].Y = -b - Math.Sqrt(Math.Pow(b, 2) - Math.Pow((b * sUpperUpperHalf[i].X / a), 2));
}
List <AGPoint> sUpperLowerHalf = new List <AGPoint>();
sUpperLowerHalf.Add(new AGPoint(-0.5, 0));
sUpperLowerHalf.Add(new AGPoint(-0.3, 0));
sUpperLowerHalf.Add(new AGPoint(-0.1, 0));
sUpperLowerHalf.Add(new AGPoint(0, 0));
for (i = 0; i < sUpperLowerHalf.Count; i++)
{
sUpperLowerHalf[i].Y = -b + Math.Sqrt(Math.Pow(b, 2) - Math.Pow((b * sUpperLowerHalf[i].X / a), 2));
}
List <AGPoint> sLowerUpperHalf = new List <AGPoint>();
sLowerUpperHalf.Add(new AGPoint(0.1, 0));
sLowerUpperHalf.Add(new AGPoint(0.3, 0));
sLowerUpperHalf.Add(new AGPoint(0.5, 0));
for (i = 0; i < sLowerUpperHalf.Count; i++)
{
sLowerUpperHalf[i].Y = b - Math.Sqrt(Math.Pow(b, 2) - Math.Pow((b * sLowerUpperHalf[i].X / a), 2));
}
List <AGPoint> sLowerLowerHalf = new List <AGPoint>();
sLowerLowerHalf.Add(new AGPoint(0.5, 0));
sLowerLowerHalf.Add(new AGPoint(0.3, 0));
sLowerLowerHalf.Add(new AGPoint(0.1, 0));
sLowerLowerHalf.Add(new AGPoint(-0.1, 0));
sLowerLowerHalf.Add(new AGPoint(-0.3, 0));
sLowerLowerHalf.Add(new AGPoint(-0.5, 0));
for (i = 0; i < sLowerLowerHalf.Count; i++)
{
sLowerLowerHalf[i].Y = b + Math.Sqrt(Math.Pow(b, 2) - Math.Pow((b * sLowerLowerHalf[i].X / a), 2));
}
List <ScreenPoint> marker = new List <ScreenPoint>();
for (i = sLowerLowerHalf.Count - 2; i >= 0; i--)
{
marker.Add(new ScreenPoint(sLowerLowerHalf[i].X, sLowerLowerHalf[i].Y));
}
for (i = sLowerUpperHalf.Count - 1; i >= 0; i--)
{
marker.Add(new ScreenPoint(sLowerUpperHalf[i].X, sLowerUpperHalf[i].Y));
}
for (i = sUpperLowerHalf.Count - 1; i >= 0; i--)
{
marker.Add(new ScreenPoint(sUpperLowerHalf[i].X, sUpperLowerHalf[i].Y));
}
for (i = sUpperUpperHalf.Count - 1; i >= 0; i--)
{
marker.Add(new ScreenPoint(sUpperUpperHalf[i].X, sUpperUpperHalf[i].Y));
}
for (i = 0; i < sUpperUpperHalf.Count; i++)
{
marker.Add(new ScreenPoint(sUpperUpperHalf[i].X, sUpperUpperHalf[i].Y));
}
for (i = 0; i < sUpperLowerHalf.Count; i++)
{
marker.Add(new ScreenPoint(sUpperLowerHalf[i].X, sUpperLowerHalf[i].Y));
}
for (i = 0; i < sLowerUpperHalf.Count; i++)
{
marker.Add(new ScreenPoint(sLowerUpperHalf[i].X, sLowerUpperHalf[i].Y));
}
for (i = 0; i < sLowerLowerHalf.Count; i++)
{
marker.Add(new ScreenPoint(sLowerLowerHalf[i].X, sLowerLowerHalf[i].Y));
}
if (isNoResponse)
{
ScreenPoint lastPoint = marker.Last();
ArrowMarker.AddArrowToMarker(marker, earType, lastPoint.X, lastPoint.Y);
}
if (addShift)
{
ShiftMarker.AddShift(marker, earType);
}
return(marker.ToArray());
}
public void UpdateEarPlot(EarType earType, SortedDictionary <double, HearingLevel> hearingLevels, bool addBCShift)
{
ClearPlot(earType);
HearingLevelTypes prevSeriesHLType = HearingLevelTypes.InitialEmptyState;
HearingLevelTypes currElementHLType = HearingLevelTypes.InitialEmptyState;
LineSeries lineSeries = null;
for (int i = 0; i < hearingLevels.Count; i++)
{
KeyValuePair <double, HearingLevel> keyValue = hearingLevels.ElementAt(i);
double freqHz = keyValue.Key;
HearingLevel hearingLevel = keyValue.Value;
double? earHearingLevel = null;
string earHearingLevelStr = null;
if (addBCShift)
{
freqHz = FreqAxis.MajorMinorAxisTicks[freqHz];
}
if (earType == EarType.RightEar)
{
earHearingLevel = hearingLevel.RightEarHLdB;
earHearingLevelStr = hearingLevel.RightEarHLdBStr;
}
else if (earType == EarType.LeftEar)
{
earHearingLevel = hearingLevel.LeftEarHLdB;
earHearingLevelStr = hearingLevel.LeftEarHLdBStr;
}
else
{
throw new InvalidEnumArgumentException();
}
if (earHearingLevel != null)
{
currElementHLType = HearingLevelTypes.TestedAndResponded;
}
else if (earHearingLevelStr != null &&
earHearingLevelStr.Equals(HearingLevelTypes.NoResponse.GetDescription(), StringComparison.CurrentCultureIgnoreCase))
{
currElementHLType = HearingLevelTypes.NoResponse;
}
else if (earHearingLevelStr != null &&
earHearingLevelStr.Equals(HearingLevelTypes.NotTested.GetDescription(), StringComparison.CurrentCultureIgnoreCase))
{
currElementHLType = HearingLevelTypes.NotTested;
}
else
{
currElementHLType = HearingLevelTypes.InitialEmptyState;
}
if (currElementHLType != prevSeriesHLType)
{
prevSeriesHLType = currElementHLType;
if (currElementHLType == HearingLevelTypes.TestedAndResponded)
{
lineSeries = AddLineSeries(earType, false);
lineSeries.Points.Add(new DataPoint(freqHz, earHearingLevel.Value));
}
else if (currElementHLType == HearingLevelTypes.NoResponse)
{
lineSeries = AddLineSeries(earType, true);
lineSeries.Points.Add(new DataPoint(freqHz, HearingPowerLimits.MaxHearingLeveldB));
}
}
else
{
if (currElementHLType == HearingLevelTypes.TestedAndResponded)
{
lineSeries.Points.Add(new DataPoint(freqHz, earHearingLevel.Value));
}
else if (currElementHLType == HearingLevelTypes.NoResponse)
{
lineSeries.Points.Add(new DataPoint(freqHz, HearingPowerLimits.MaxHearingLeveldB));
}
}
}
PlotModel.InvalidatePlot(true);
}
protected abstract LineSeries AddLineSeries(EarType earType, bool isNoResponse);
