/// <summary>
/// Sets standard value for Tube.AlgorithmOption
/// </summary>
public Tube(TubeSize size)
{
this.size = size;
algorithmOption = AlgorithmOptions.Rectangle;
calculateErrors = true;
tubeSuccessful = false;
}
/// <summary>
/// Calculates a lower and an upper tube curve.
/// </summary>
/// <param name="reference">Reference curve with x and y values.</param>
/// <param name="size">Size of tube.</param>
/// <returns>Collection of return values.</returns>
public override TubeReport Calculate(Curve reference, TubeSize size)
{
TubeReport report = new TubeReport();
successful = false;
if (reference != null && size != null)
{
report.Reference = reference;
report.Size = size;
report.Algorithm = AlgorithmOptions.Rectangle;
report.Lower = CalculateLower(reference, size);
report.Upper = CalculateUpper(reference, size);
if (report.Lower.ImportSuccessful && report.Upper.ImportSuccessful)
successful = true;
}
return report;
}
/// <summary>
/// Calculates a lower and an upper tube curve.
/// </summary>
/// <param name="reference">Reference curve with x and y values.</param>
/// <param name="size">Size of tube.</param>
/// <returns>Collection of return values.</returns>
public override TubeReport Calculate(Curve reference, TubeSize size)
{
TubeReport report = new TubeReport();
successful = false;
if (reference != null && size != null)
{
report.Reference = reference;
report.Size = size;
report.Algorithm = AlgorithmOptions.Rectangle;
report.Lower = CalculateLower(reference, size);
report.Upper = CalculateUpper(reference, size);
if (report.Lower.ImportSuccessful && report.Upper.ImportSuccessful)
{
successful = true;
}
}
return(report);
}
/// <summary>
/// Calculates the lower tube curve.
/// </summary>
/// <param name="reference">Reference curve.</param>
/// <param name="size">Tube size.</param>
/// <returns>Lower tube curve.</returns>
private static Curve CalculateLower(Curve reference, TubeSize size)
{
Curve lower; // lower tube curve
List<double> LX = new List<double>(2 * reference.Count); // x-values of lower tube curve
List<double> LY = new List<double>(2 * reference.Count); // y-values of lower tube curve
// -------------------------------------------------------------------------------------------------------------
// ---------------------------------- 1. Add corner points of the rectangle -----------------------------------
// -------------------------------------------------------------------------------------------------------------
double m0, m1; // slopes before and after point i of reference curve
double s0, s1; // signum of slopes of reference curve: 1 - increasing, 0 - constant, -1 - decreasing
// -------------------------------------------------------------------------------------------------------------
// 1.1. Start: Rectangle with center (x,y) = (reference.X[0], reference.Y[0])
// -------------------------------------------------------------------------------------------------------------
// slopes of reference curve (initialization)
s0 = Math.Sign(reference.Y[1] - reference.Y[0]);
if (reference.X[1] != reference.X[0])
m0 = (reference.Y[1] - reference.Y[0]) / (reference.X[1] - reference.X[0]);
else
if (s0 > 0)
m0 = Double.PositiveInfinity;
else
m0 = Double.NegativeInfinity;
// add point down left
LX.Add(reference.X[0] - size.X);
LY.Add(reference.Y[0] - size.Y);
if (s0 == 1)
{
// add point down right
LX.Add(reference.X[0] + size.X);
LY.Add(reference.Y[0] - size.Y);
}
// -------------------------------------------------------------------------------------------------------------
// 1.2. Iteration: Rectangle with center (x,y) = (reference.X[i], reference.Y[i])
// -------------------------------------------------------------------------------------------------------------
for (int i = 1; i < reference.Count - 1; i++)
{
if (reference.X[i] == reference.X[i + 1] && reference.Y[i] == reference.Y[i + 1]) // ignore identical points
continue;
// slopes of reference curve
s1 = Math.Sign(reference.Y[i + 1] - reference.Y[i]);
if (reference.X[i + 1] != reference.X[i])
m1 = (reference.Y[i + 1] - reference.Y[i]) / (reference.X[i + 1] - reference.X[i]);
else
if (s1 > 0)
m1 = Double.PositiveInfinity;
else
m1 = Double.NegativeInfinity;
// add no point for equal slopes of reference curve
if (!(m0 == m1))
{
if ((s0 != -1) && (s1 != -1))
{
// add point down right
LX.Add(reference.X[i] + size.X);
LY.Add(reference.Y[i] - size.Y);
}
else if ((s0 != 1) && (s1 != 1))
{
// add point down left
LX.Add(reference.X[i] - size.X);
LY.Add(reference.Y[i] - size.Y);
}
else if ((s0 == -1) && (s1 == 1))
{
// add point down left
LX.Add(reference.X[i] - size.X);
LY.Add(reference.Y[i] - size.Y);
// add point down right
LX.Add(reference.X[i] + size.X);
LY.Add(reference.Y[i] - size.Y);
}
else if ((s0 == 1) && (s1 == -1))
{
// add point down right
LX.Add(reference.X[i] + size.X);
LY.Add(reference.Y[i] - size.Y);
// add point down left
LX.Add(reference.X[i] - size.X);
LY.Add(reference.Y[i] - size.Y);
}
// remove point for equal slopes equal 0 of tube curve
int last = LY.Count - 1;
if (reference.Y[i + 1] - size.Y == LY[last] && LY[last - 1] == LY[last])
{
LX.RemoveAt(last);
LY.RemoveAt(last);
}
}
s0 = s1;
m0 = m1;
}
// -------------------------------------------------------------------------------------------------------------
// 1.3. End: Rectangle with center (x,y) = (reference.X[reference.Count - 1], reference.Y[reference.Count - 1])
// -------------------------------------------------------------------------------------------------------------
if (s0 == -1)
{
// add point down left
LX.Add(reference.X[reference.Count - 1] - size.X);
LY.Add(reference.Y[reference.Count - 1] - size.Y);
}
// add point down right
LX.Add(reference.X[reference.Count - 1] + size.X);
LY.Add(reference.Y[reference.Count - 1] - size.Y);
// -------------------------------------------------------------------------------------------------------------
// -------------- 2. Remove points and add intersection points in case of backward order -----------------------
// -------------------------------------------------------------------------------------------------------------
removeLoop(LX, LY, true);
lower = new Curve("Lower", LX.ToArray(), LY.ToArray());
return lower;
}
public Report CompareFiles(Log log, CsvFile csvBase, string sReportPath, ref Options options)
{
int iInvalids = 0;
Report rep = new Report(sReportPath);
log.WriteLine("Comparing \"{0}\" to \"{1}\"", _fileName, csvBase.ToString());
rep.BaseFile = csvBase.ToString();
rep.CompareFile = _fileName;
Curve reference = new Curve();
Curve compareCurve = new Curve();
TubeReport tubeReport = new TubeReport();
TubeSize size = null;
Tube tube = new Tube(size);
IOptions tubeOptions = new Options1(_dRangeDelta, Axes.X);
foreach (KeyValuePair<string, List<double>> res in csvBase.Results)
{
if (!this.Results.ContainsKey(res.Key))
log.WriteLine(LogLevel.Warning, "{0} not found in \"{1}\", skipping checks.", res.Key, this._fileName);
else
{
compareCurve = new Curve(res.Key, this.XAxis.ToArray<double>(), this.Results[res.Key].ToArray<double>());
if (res.Value.Count == 0)
{
log.Error("{0} has no y-Values! Maybe error during parsing? Skipping", res.Key);
continue;
}
reference = new Curve("Reference ", csvBase.XAxis.ToArray(), csvBase.Results[res.Key].ToArray());
if (!reference.ImportSuccessful)
{
log.Error("Error in the calculation of the tubes. Skipping {0}", res.Key);
rep.Chart.Add(new Chart() { Title = res.Key, Errors = 1 });
continue;
}
if (reference.X.Length < compareCurve.X.Length)
log.WriteLine(LogLevel.Warning, "The resolution of the base x-axis is smaller than the compare x-axis. The better the base resolution is, the better the validation result will be!");
else
log.WriteLine(LogLevel.Debug, "The resolution of the base x-axis is good.");
size = new TubeSize(reference, true);
size.Calculate(_dRangeDelta, Axes.X, Relativity.Relative);
tube = new Tube(size);
tubeReport = tube.Calculate(reference);
tube.Validate(compareCurve);
if (tubeReport.Valid == Validity.Valid)
log.WriteLine(res.Key + " is valid");
else
{
log.WriteLine(LogLevel.Warning, "{0} is invalid! {1} errors have been found during validation.", res.Key,
(null != tube.Report.Errors && null != tube.Report.Errors.X) ? tube.Report.Errors.X.Length : 0);
iInvalids++;
Environment.ExitCode = 1;
}
}
if (null != tube.Report)//No charts for missing reports
PrepareCharts(reference, compareCurve, tube.Report.Errors, rep, tubeReport, res, options.UseBitmapPlots);
}
rep.Tolerance = _dRangeDelta;
string sResult = "na";
if (rep.TotalErrors == 0)
sResult = "passed";
else
sResult = "failed";
if (options.ComparisonFlag)
using (TextWriter writer = File.CreateText(string.Format("{0}{1}compare_{2}.log", Path.GetDirectoryName(_fileName), Path.DirectorySeparatorChar, sResult)))
{
//Content needs to be defined
writer.WriteLine("CSV Compare Version {0} ({1})", Info.AssemblyVersion, Assembly.GetExecutingAssembly().GetName().ProcessorArchitecture);
writer.WriteLine("Comparison result file for {0}", _fileName);
writer.WriteLine(". Time: {0:o}", DateTime.Now);
writer.WriteLine(". Operation: {0}", options.Mode);
writer.WriteLine(". Tolerance: {0}", options.Tolerance);
writer.WriteLine(". Result: {0}", sResult);
if (rep.TotalErrors > 0)
{
Chart pairMax = rep.Chart.Aggregate((l, r) => l.DeltaError > r.DeltaError ? l : r);
writer.WriteLine(". Biggest error: {0}=>{1}", pairMax.Title, pairMax.DeltaError);
writer.WriteLine(". Failed values:");
foreach (Chart c in (from r in rep.Chart where r.DeltaError > 0 select r).OrderByDescending(er => er.DeltaError))
writer.WriteLine("{0}=>{1}", c.Title, c.DeltaError);
}
}
rep.WriteReport(log, (!string.IsNullOrEmpty(options.ReportDir)) ? options.ReportDir : string.Empty, options);
GC.Collect();//immediately forget big charts and data
return rep;
}
/// <summary>
/// Calculates a lower and an upper tube curve.
/// </summary>
/// <param name="reference">Reference curve with x and y values..</param>
/// <param name="size">Size of tube.</param>
/// <returns>Collection of return values.</returns>
public override TubeReport Calculate(Curve reference, TubeSize size)
{
/*
* ///This method generates tubes around a given curve.
* /// @param x The time values for the base curve
* /// @param y The y values of the base curve
* /// @param x_low An empty, initialized list that is to be filled with the time values for the lower tube curve
* /// @param y_low An empty, initialized list that is to be filled with the y values for the lower tube curve
* /// @param x_high An empty, initialized list that is to be filled with the time values for the upper tube curve
* /// @param y_high An empty, initialized list that is to be filled with the y values for the upper tube curve
* /// @param r relative tolerance argument
* /// @param bAllIntervals used all intervals
* */
double[] x = reference.X.ToArray();
double[] y = reference.Y.ToArray();
_dDelta = size.X;
List <double> xHigh = new List <double>();
List <double> yHigh = new List <double>();
List <double> xLow = new List <double>();
List <double> yLow = new List <double>();
TubeReport report = new TubeReport();
successful = false;
if (reference != null && size != null)
{
report.Reference = reference;
report.Size = size;
report.Algorithm = AlgorithmOptions.Ellipse;
/// SBR: Wir gehen erstmal prinzipiell davon aus das der Algorithmus korrekt verläuft.
//_bAllIntervals = true;
// set tStart and tStop
_dtStart = x[0];
_dtStop = x[x.Length - 1];
_dXMinStep = ((_dtStop - _dtStart) + Math.Abs(_dtStart)) * _dXRelEps;
// Initialize lists (upper tube)
_lmh = new ArrayList(x.Length); // slope in i
_li0h = new ArrayList(x.Length); // i
_li1h = new ArrayList(x.Length); // i - 1
// Initialize lists (lower tube)
_lml = new ArrayList(x.Length); // slope in i
_li0l = new ArrayList(x.Length); // i
_li1l = new ArrayList(x.Length); // i-1
// calculate the tubes delta
//_dDelta = r * (Math.Abs(_dtStop - _dtStart) + Math.Abs(_dtStart));
// calculate S:
double max = y[0];
double min = y[0];
xHigh.Clear();
yHigh.Clear();
xLow.Clear();
yLow.Clear();
if (xHigh.Capacity < x.Length)
{
xHigh.Capacity = x.Length;
}
if (yHigh.Capacity < x.Length)
{
yHigh.Capacity = x.Length;
}
if (xLow.Capacity < x.Length)
{
xLow.Capacity = x.Length;
}
if (yLow.Capacity < x.Length)
{
yLow.Capacity = x.Length;
}
for (int i = 1; i < y.Length; i++)
{
try
{
double Y = y[i];
if (Y > max)
{
max = Y;
}
if (Y < min)
{
min = Y;
}
}
catch (IndexOutOfRangeException) { break; }
}
// _dS = Math.Abs(4 * (max - min) / (Math.Abs(_dtStop - _dtStart)));
_dS = (Math.Abs(max - min) + Math.Abs(min)) / (Math.Abs(_dtStop - _dtStart) + Math.Abs(_dtStart));
if (_dS < 0.0004 / (Math.Abs(_dtStop - _dtStart) + Math.Abs(_dtStart)))
{
_dS = 0.0004 / (Math.Abs(_dtStop - _dtStart) + Math.Abs(_dtStart));
}
bool bJump = false;
// Begin calculation for the tubes
for (int i = 1; i < x.Length; i++)
{
try
{
// get current value
_dX1 = x[i];
_dY1 = y[i];
// get previous value
_dX2 = x[i - 1];
_dY2 = y[i - 1];
}
catch (IndexOutOfRangeException) { break; }
// catch jumps
bJump = false;
if ((_dX1 <= _dX2) && (_dY1 == _dY2) && (xHigh.Count == 0))
{
continue;
}
if ((_dX1 <= _dX2) && (_dY1 == _dY2))
{
_dX1 = Math.Max(x[(int)_li1l[_li1l.Count - 1]] + _dXMinStep, Math.Max(x[(int)_li1h[_li1h.Count - 1]] + _dXMinStep, _dX1));
x.SetValue(_dX1, i);
_dCurrentSlope = (double)_lmh[_lmh.Count - 1];
}
else
{
if (_dX1 <= _dX2)
{
bJump = true;
_dX1 = _dX2 + _dXMinStep;
x.SetValue(_dX1, i);
}
_dCurrentSlope = (_dY1 - _dY2) / (_dX1 - _dX2); // calculate current slope ( 3.2.6.1)
}
// fill lists with new values: values upper tube
_li0h.Add(i);
_li1h.Add(i - 1);
_lmh.Add(_dCurrentSlope);
// fill lists with new values: values lower tube
_li0l.Add(i);
_li1l.Add(i - 1);
if ((_dX1 <= _dX2) && (_dY1 == _dY2))
{
_dCurrentSlope = (double)_lml[_lml.Count - 1];
}
_lml.Add(_dCurrentSlope);
if (xHigh.Count == 0) // 1st interval (3.2.5)
{
if (bJump)
{
// initial values upper tube
_li0h[0] = i - 1;
_lmh[0] = 0.0;
xHigh.Add(_dX2 - _dDelta - _dXMinStep);
yHigh.Add(_dY2 + _dDelta * _dS);
_li0h.Add(i);
_li1h.Add(i - 1);
_lmh.Add(_dCurrentSlope);
xHigh.Add(_dX2 - _dDelta * _dCurrentSlope / (_dS + Math.Sqrt((_dCurrentSlope * _dCurrentSlope) + (_dS * _dS))));
yHigh.Add(_dY2 + _dDelta * _dS);
// initial values lower tube
_li0l[0] = i - 1;
_lml[0] = 0.0;
xLow.Add(_dX2 - _dDelta - _dXMinStep);
yLow.Add(_dY2 - _dDelta * _dS);
_li0l.Add(i);
_li1l.Add(i - 1);
_lml.Add(_dCurrentSlope);
xLow.Add(_dX2 + _dDelta * _dCurrentSlope / (_dS + Math.Sqrt((_dCurrentSlope * _dCurrentSlope) + (_dS * _dS))));
yLow.Add(_dY2 - _dDelta * _dS);
}
else
{ // initial values upper tube
xHigh.Add(_dX2 - _dDelta);
yHigh.Add(_dY2 - _dCurrentSlope * _dDelta + _dDelta * Math.Sqrt((_dCurrentSlope * _dCurrentSlope) + (_dS * _dS)));
// initial values lower tube
xLow.Add(_dX2 - _dDelta);
yLow.Add(_dY2 - _dCurrentSlope * _dDelta - _dDelta * Math.Sqrt((_dCurrentSlope * _dCurrentSlope) + (_dS * _dS)));
}
}
else // if not 1st interval (3.2.6)
{
// fill lists with new values, set X and Y to arbitrary value (3.2.6.1)
xHigh.Add(1);
yHigh.Add(1);
xLow.Add(1);
yLow.Add(1);
// begin procedure for upper tube
GenerateHighTube(x, y, xHigh, yHigh);
// begin procedure for lower tube
GenerateLowTube(x, y, xLow, yLow);
}
}
// calculate terminal value
_dX2 = (double)x.GetValue(x.Length - 1);
if (bJump)
{
_dY2 = (double)y.GetValue(y.Length - 1);
// upper tube
_dCurrentSlope = (double)_lmh[_lmh.Count - 1];
xHigh.Add(_dX2 - _dDelta * _dCurrentSlope / (_dS + Math.Sqrt((_dCurrentSlope * _dCurrentSlope) + (_dS * _dS))));
yHigh.Add(_dY2 + _dDelta * _dS);
xHigh.Add(_dX2 + _dDelta + _dXMinStep);
yHigh.Add(_dY2 + _dDelta * _dS);
// lower tube
_dCurrentSlope = (double)_lml[_lml.Count - 1];
xLow.Add(_dX2 + _dDelta * _dCurrentSlope / (_dS + Math.Sqrt((_dCurrentSlope * _dCurrentSlope) + (_dS * _dS))));
yLow.Add(_dY2 - _dDelta * _dS);
xLow.Add(_dX2 + _dDelta + _dXMinStep);
yLow.Add(_dY2 - _dDelta * _dS);
}
else
{
// upper tube
_dX1 = (double)xHigh[xHigh.Count - 1];
_dY1 = (double)yHigh[yHigh.Count - 1];
_dCurrentSlope = (double)_lmh[_lmh.Count - 1];
xHigh.Add(_dX2 + _dDelta);
yHigh.Add(_dY1 + _dCurrentSlope * (_dX2 + _dDelta - _dX1));
// lower tube
_dX1 = (double)xLow[xLow.Count - 1];
_dY1 = (double)yLow[yLow.Count - 1];
_dCurrentSlope = (double)_lml[_lml.Count - 1];
xLow.Add(_dX2 + _dDelta);
yLow.Add(_dY1 + _dCurrentSlope * (_dX2 + _dDelta - _dX1));
}
report.Lower = new Curve("Lower", xLow.ToArray(), yLow.ToArray());
report.Upper = new Curve("Upper", xHigh.ToArray(), yHigh.ToArray());
if (report.Lower.ImportSuccessful && report.Upper.ImportSuccessful)
{
successful = true;
}
}
return(report);
}
public Report CompareFiles(Log log, CsvFile csvBase, string sReportPath, ref Options options)
{
int iInvalids = 0;
Report rep = new Report(sReportPath);
log.WriteLine("Comparing \"{0}\" to \"{1}\"", _fileName, csvBase.ToString());
rep.BaseFile = csvBase.ToString();
rep.CompareFile = _fileName;
Curve reference = new Curve();
Curve compareCurve = new Curve();
TubeReport tubeReport = new TubeReport();
TubeSize size = null;
Tube tube = new Tube(size);
switch (options.Direction)
{
case ToleranceDirection.X:
userchoice = 1; ///set to 1 for tolerenace in X axis
break;
case ToleranceDirection.Y:
userchoice = 0; ///set to 0 for tolerance in Y-axis
break;
default: //Invalid mode
Console.WriteLine(options.GetUsage());
break;
}
if (userchoice == 1)
{
IOptions tubeOptions = new Options1(_dRangeDelta, Axes.X);
}
else if (userchoice == 0)
{
IOptions tubeOptions = new Options1(_dRangeDelta, Axes.Y);
}
else
{
Console.WriteLine("opted for wrong choice");
Environment.ExitCode = 2;
}
foreach (KeyValuePair <string, List <double> > res in csvBase.Results)
{
if (!this.Results.ContainsKey(res.Key))
{
log.Error("{0} not found in \"{1}\", skipping checks.", res.Key, this._fileName);
rep.Chart.Add(new Chart()
{
Title = res.Key, Errors = 1
});
Environment.ExitCode = 1;
continue;
}
else
{
compareCurve = new Curve(res.Key, this.XAxis.ToArray <double>(), this.Results[res.Key].ToArray <double>());
if (res.Value.Count == 0)
{
log.Error("{0} has no y-Values! Maybe error during parsing? Skipping", res.Key);
continue;
}
reference = new Curve("Reference ", csvBase.XAxis.ToArray(), csvBase.Results[res.Key].ToArray());
if (!reference.ImportSuccessful)
{
log.Error("Error in the calculation of the tubes. Skipping {0}", res.Key);
rep.Chart.Add(new Chart()
{
Title = res.Key, Errors = 1
});
continue;
}
if (reference.X.Length < compareCurve.X.Length)
{
log.WriteLine(LogLevel.Warning, "The resolution of the base x-axis is smaller than the compare x-axis. The better the base resolution is, the better the validation result will be!");
}
else
{
log.WriteLine(LogLevel.Debug, "The resolution of the base x-axis is good.");
}
size = new TubeSize(reference, true);
switch (options.Method)
{
case ExecutionMethod.Relative:
if (userchoice == 1)
{
size.Calculate(_dRangeDelta, Axes.X, Relativity.Relative);
}
else
{
size.Calculate(_dRangeDelta, Axes.Y, Relativity.Relative);
}
break;
case ExecutionMethod.Absolute:
if (userchoice == 1)
{
size.Calculate(_dRangeDelta, Axes.X, Relativity.Absolute);
}
else
{
size.Calculate(_dRangeDelta, Axes.Y, Relativity.Absolute);
}
break;
default: //Invalid mode
Console.WriteLine(options.GetUsage());
break;
}
tube = new Tube(size);
tubeReport = tube.Calculate(reference);
tube.Validate(compareCurve);
if (tubeReport.Valid == Validity.Valid)
{
log.WriteLine(res.Key + " is valid");
}
else
{
log.WriteLine(LogLevel.Warning, "{0} is invalid! {1} errors have been found during validation.", res.Key,
(null != tube.Report.Errors && null != tube.Report.Errors.X) ? tube.Report.Errors.X.Length : 0);
iInvalids++;
Environment.ExitCode = 1;
}
}
if (null != tube.Report)//No charts for missing reports
{
PrepareCharts(reference, compareCurve, tube.Report.Errors, rep, tubeReport, res, options.UseBitmapPlots);
}
}
rep.Tolerance = _dRangeDelta;
string sResult = "na";
if (rep.TotalErrors == 0)
{
sResult = "passed";
}
else
{
sResult = "failed";
}
if (options.ComparisonFlag)
{
using (TextWriter writer = File.CreateText(string.Format("{0}{1}compare_{2}.log", Path.GetDirectoryName(_fileName), Path.DirectorySeparatorChar, sResult)))
{
//Content needs to be defined
writer.WriteLine("CSV Compare Version {0} ({1})", Info.AssemblyVersion, Assembly.GetExecutingAssembly().GetName().ProcessorArchitecture);
writer.WriteLine("Comparison result file for {0}", _fileName);
writer.WriteLine(". Time: {0:o}", DateTime.Now);
writer.WriteLine(". Operation: {0}", options.Mode);
writer.WriteLine(". Tolerance: {0}", options.Tolerance);
writer.WriteLine(". Execution Method: {0}", options.Method);
writer.WriteLine(". Direction of Tolerence: {0}", options.Direction);
writer.WriteLine(". Result: {0}", sResult);
if (rep.TotalErrors > 0)
{
Chart pairMax = rep.Chart.Aggregate((l, r) => l.DeltaError > r.DeltaError ? l : r);
if (pairMax.DeltaError > 0)
{
writer.WriteLine(". Largest error: {0}=>{1}", pairMax.Title, pairMax.DeltaError);
writer.WriteLine(". Failed values:");
foreach (Chart c in (from r in rep.Chart where r.DeltaError > 0 select r).OrderByDescending(er => er.DeltaError))
{
writer.WriteLine("{0}=>{1}", c.Title, c.DeltaError.ToString(CultureInfo.InvariantCulture));
}
}
}
}
}
rep.WriteReport(log, (string.IsNullOrEmpty(options.ReportDir) || options.NoMetaReport) ? string.Empty : options.ReportDir, options);
GC.Collect();//immediately forget big charts and data
return(rep);
}
/// <summary>
/// Calculates a lower and an upper tube curve.
/// </summary>
/// <param name="reference">Reference curve with x and y values.</param>
/// <param name="size">Size of tube.</param>
/// <returns>Collection of return values.</returns>
public virtual TubeReport Calculate(Curve reference, TubeSize size)
{
TubeReport report = new TubeReport();
return(report);
}
/// <summary>
/// Calculates a lower and an upper tube curve.
/// </summary>
/// <param name="reference">Reference curve with x and y values.</param>
/// <param name="size">Size of tube.</param>
/// <returns>Collection of return values.</returns>
public virtual TubeReport Calculate(Curve reference, TubeSize size)
{
TubeReport report = new TubeReport();
return report;
}
/// <summary>
/// Calculates a lower and an upper tube curve.
/// </summary>
/// <param name="reference">Reference curve with x and y values..</param>
/// <param name="size">Size of tube.</param>
/// <returns>Collection of return values.</returns>
public override TubeReport Calculate(Curve reference, TubeSize size)
{
/*
///This method generates tubes around a given curve.
/// @param x The time values for the base curve
/// @param y The y values of the base curve
/// @param x_low An empty, initialized list that is to be filled with the time values for the lower tube curve
/// @param y_low An empty, initialized list that is to be filled with the y values for the lower tube curve
/// @param x_high An empty, initialized list that is to be filled with the time values for the upper tube curve
/// @param y_high An empty, initialized list that is to be filled with the y values for the upper tube curve
/// @param r relative tolerance argument
/// @param bAllIntervals used all intervals
* */
double[] x = reference.X.ToArray();
double[] y = reference.Y.ToArray();
_dDelta = size.X;
List<double> xHigh = new List<double>();
List<double> yHigh = new List<double>();
List<double> xLow = new List<double>();
List<double> yLow = new List<double>();
TubeReport report = new TubeReport();
successful = false;
if (reference != null && size != null)
{
report.Reference = reference;
report.Size = size;
report.Algorithm = AlgorithmOptions.Ellipse;
/// SBR: Wir gehen erstmal prinzipiell davon aus das der Algorithmus korrekt verläuft.
//_bAllIntervals = true;
// set tStart and tStop
_dtStart = x[0];
_dtStop = x[x.Length - 1];
_dXMinStep = ((_dtStop - _dtStart) + Math.Abs(_dtStart)) * _dXRelEps;
// Initialize lists (upper tube)
_lmh = new ArrayList(x.Length); // slope in i
_li0h = new ArrayList(x.Length); // i
_li1h = new ArrayList(x.Length); // i - 1
// Initialize lists (lower tube)
_lml = new ArrayList(x.Length); // slope in i
_li0l = new ArrayList(x.Length); // i
_li1l = new ArrayList(x.Length); // i-1
// calculate the tubes delta
//_dDelta = r * (Math.Abs(_dtStop - _dtStart) + Math.Abs(_dtStart));
// calculate S:
double max = y[0];
double min = y[0];
xHigh.Clear();
yHigh.Clear();
xLow.Clear();
yLow.Clear();
if (xHigh.Capacity < x.Length) xHigh.Capacity = x.Length;
if (yHigh.Capacity < x.Length) yHigh.Capacity = x.Length;
if (xLow.Capacity < x.Length) xLow.Capacity = x.Length;
if (yLow.Capacity < x.Length) yLow.Capacity = x.Length;
for (int i = 1; i < y.Length; i++)
{
try
{
double Y = y[i];
if (Y > max)
{
max = Y;
}
if (Y < min)
{
min = Y;
}
}
catch (IndexOutOfRangeException) { break; }
}
// _dS = Math.Abs(4 * (max - min) / (Math.Abs(_dtStop - _dtStart)));
_dS = (Math.Abs(max - min) + Math.Abs(min)) / (Math.Abs(_dtStop - _dtStart) + Math.Abs(_dtStart));
if (_dS < 0.0004 / (Math.Abs(_dtStop - _dtStart) + Math.Abs(_dtStart)))
{
_dS = 0.0004 / (Math.Abs(_dtStop - _dtStart) + Math.Abs(_dtStart));
}
bool bJump = false;
// Begin calculation for the tubes
for (int i = 1; i < x.Length; i++)
{
try
{
// get current value
_dX1 = x[i];
_dY1 = y[i];
// get previous value
_dX2 = x[i - 1];
_dY2 = y[i - 1];
}
catch (IndexOutOfRangeException) { break; }
// catch jumps
bJump = false;
if ((_dX1 <= _dX2) && (_dY1 == _dY2) && (xHigh.Count == 0))
continue;
if ((_dX1 <= _dX2) && (_dY1 == _dY2))
{
_dX1 = Math.Max(x[(int)_li1l[_li1l.Count - 1]] + _dXMinStep, Math.Max(x[(int)_li1h[_li1h.Count - 1]] + _dXMinStep, _dX1));
x.SetValue(_dX1, i);
_dCurrentSlope = (double)_lmh[_lmh.Count - 1];
}
else
{
if (_dX1 <= _dX2)
{
bJump = true;
_dX1 = _dX2 + _dXMinStep;
x.SetValue(_dX1, i);
}
_dCurrentSlope = (_dY1 - _dY2) / (_dX1 - _dX2); // calculate current slope ( 3.2.6.1)
}
// fill lists with new values: values upper tube
_li0h.Add(i);
_li1h.Add(i - 1);
_lmh.Add(_dCurrentSlope);
// fill lists with new values: values lower tube
_li0l.Add(i);
_li1l.Add(i - 1);
if ((_dX1 <= _dX2) && (_dY1 == _dY2))
_dCurrentSlope = (double)_lml[_lml.Count - 1];
_lml.Add(_dCurrentSlope);
if (xHigh.Count == 0) // 1st interval (3.2.5)
{
if (bJump)
{
// initial values upper tube
_li0h[0] = i - 1;
_lmh[0] = 0.0;
xHigh.Add(_dX2 - _dDelta - _dXMinStep);
yHigh.Add(_dY2 + _dDelta * _dS);
_li0h.Add(i);
_li1h.Add(i - 1);
_lmh.Add(_dCurrentSlope);
xHigh.Add(_dX2 - _dDelta * _dCurrentSlope / (_dS + Math.Sqrt((_dCurrentSlope * _dCurrentSlope) + (_dS * _dS))));
yHigh.Add(_dY2 + _dDelta * _dS);
// initial values lower tube
_li0l[0] = i - 1;
_lml[0] = 0.0;
xLow.Add(_dX2 - _dDelta - _dXMinStep);
yLow.Add(_dY2 - _dDelta * _dS);
_li0l.Add(i);
_li1l.Add(i - 1);
_lml.Add(_dCurrentSlope);
xLow.Add(_dX2 + _dDelta * _dCurrentSlope / (_dS + Math.Sqrt((_dCurrentSlope * _dCurrentSlope) + (_dS * _dS))));
yLow.Add(_dY2 - _dDelta * _dS);
}
else
{ // initial values upper tube
xHigh.Add(_dX2 - _dDelta);
yHigh.Add(_dY2 - _dCurrentSlope * _dDelta + _dDelta * Math.Sqrt((_dCurrentSlope * _dCurrentSlope) + (_dS * _dS)));
// initial values lower tube
xLow.Add(_dX2 - _dDelta);
yLow.Add(_dY2 - _dCurrentSlope * _dDelta - _dDelta * Math.Sqrt((_dCurrentSlope * _dCurrentSlope) + (_dS * _dS)));
}
}
else // if not 1st interval (3.2.6)
{
// fill lists with new values, set X and Y to arbitrary value (3.2.6.1)
xHigh.Add(1);
yHigh.Add(1);
xLow.Add(1);
yLow.Add(1);
// begin procedure for upper tube
GenerateHighTube(x, y, xHigh, yHigh);
// begin procedure for lower tube
GenerateLowTube(x, y, xLow, yLow);
}
}
// calculate terminal value
_dX2 = (double)x.GetValue(x.Length - 1);
if (bJump)
{
_dY2 = (double)y.GetValue(y.Length - 1);
// upper tube
_dCurrentSlope = (double)_lmh[_lmh.Count - 1];
xHigh.Add(_dX2 - _dDelta * _dCurrentSlope / (_dS + Math.Sqrt((_dCurrentSlope * _dCurrentSlope) + (_dS * _dS))));
yHigh.Add(_dY2 + _dDelta * _dS);
xHigh.Add(_dX2 + _dDelta + _dXMinStep);
yHigh.Add(_dY2 + _dDelta * _dS);
// lower tube
_dCurrentSlope = (double)_lml[_lml.Count - 1];
xLow.Add(_dX2 + _dDelta * _dCurrentSlope / (_dS + Math.Sqrt((_dCurrentSlope * _dCurrentSlope) + (_dS * _dS))));
yLow.Add(_dY2 - _dDelta * _dS);
xLow.Add(_dX2 + _dDelta + _dXMinStep);
yLow.Add(_dY2 - _dDelta * _dS);
}
else
{
// upper tube
_dX1 = (double)xHigh[xHigh.Count - 1];
_dY1 = (double)yHigh[yHigh.Count - 1];
_dCurrentSlope = (double)_lmh[_lmh.Count - 1];
xHigh.Add(_dX2 + _dDelta);
yHigh.Add(_dY1 + _dCurrentSlope * (_dX2 + _dDelta - _dX1));
// lower tube
_dX1 = (double)xLow[xLow.Count - 1];
_dY1 = (double)yLow[yLow.Count - 1];
_dCurrentSlope = (double)_lml[_lml.Count - 1];
xLow.Add(_dX2 + _dDelta);
yLow.Add(_dY1 + _dCurrentSlope * (_dX2 + _dDelta - _dX1));
}
report.Lower = new Curve("Lower", xLow.ToArray(), yLow.ToArray());
report.Upper = new Curve("Upper", xHigh.ToArray(), yHigh.ToArray());
if (report.Lower.ImportSuccessful && report.Upper.ImportSuccessful)
successful = true;
}
return report;
}
/// <summary>
/// Compares a test curve with a reference curve. Calculates a tube, if test curve data == null.
/// </summary>
/// <param name="modelName">Model name.</param>
/// <param name="resultName">Result name.</param>
/// <param name="referenceX">x values of reference curve.</param>
/// <param name="referenceY">y values of reference curve.</param>
/// <param name="testX">x values of test curve.</param>
/// <param name="testY">y values of test curve.</param>
/// <param name="options">Options for calculation of tube size, chart and saving.</param>
/// <returns>Tube report.</returns>
public TubeReport Validate(string modelName, string resultName, double[] referenceX, double[] referenceY, double[] testX, double[] testY, IOptions options)
{
TubeReport report = new TubeReport();
Curve refCurve, testCurve;
bool testExists = (testX != null && testY != null && testX.Length > 0 && testY.Length > 0);
#if GUI
bool saveImage = (!String.IsNullOrWhiteSpace(options.ReportFolder) && Directory.Exists(options.ReportFolder));
#endif
string name = modelName + " - " + resultName;
// write log file
if (options.Log != null)
{
options.Log.WriteLine(LogLevel.Done, "----------------------------------------------");
options.Log.WriteLine(LogLevel.Done, "Model: " + modelName);
options.Log.WriteLine(LogLevel.Done, "Result: " + resultName);
}
if (referenceX != null && referenceY != null && referenceX.Length != 0 && referenceY.Length != 0)
{
// Data import: Prepare curve data
refCurve = new Curve("Reference " + name, referenceX, referenceY);
if (testExists)
testCurve = new Curve("Test " + name, testX, testY);
else
testCurve = new Curve();
if (refCurve.ImportSuccessful && (testCurve.ImportSuccessful || !testExists))
{
// Calculate tube size
TubeSize size = new TubeSize(refCurve);
if (!Double.IsNaN(options.BaseX)) // overwrite BaseX just in case it has got a value
size.BaseX = options.BaseX;
if (!Double.IsNaN(options.BaseY))
size.BaseY = options.BaseY;
if (!Double.IsNaN(options.Ratio))
size.Ratio = options.Ratio;
if (options is Options1)
size.Calculate(((Options1)options).Value, ((Options1)options).Axes, options.Relativity);
else if (options is Options2)
size.Calculate(((Options2)options).X, ((Options2)options).Y, options.Relativity);
if (size.Successful)
{
// Calculate tube
Tube tube = new Tube(size);
tube.AlgorithmOption = Algorithms.AlgorithmOptions.Rectangle;
report = tube.Calculate(refCurve);
if (tube.TubeSuccessful)
{
if (testExists)
{
// Validation
report = tube.Validate(testCurve);
if (options.Log != null)
{
options.Log.WriteLine(LogLevel.Done, "Test curve is " + report.Valid.ToString());
options.Log.WriteLine(LogLevel.Done, "Errors (points of test curve outside tube): " + report.Errors.Count.ToString());
}
if (tube.ValidationSuccessful)
report.ErrorStep = Step.None;
// Error: Validation not successful
else
{
report.ErrorStep = Step.Validation;
report.Valid = Validity.Undefined;
if (options.Log != null)
options.Log.WriteLine(LogLevel.Error, "Validation not successful.");
}
}
else
{
report.ErrorStep = Step.Validation;
report.Valid = Validity.Undefined;
if (options.Log != null)
options.Log.WriteLine(LogLevel.Error, "no test curve data.");
}
#if GUI
// Visualization
if (saveImage || options.ShowWindow)
{
ChartControl chartControl = new ChartControl(options.DrawFastAbove, options.DrawPointsBelow, options.DrawLabelNumber);
chartControl.addTitle("Tube size: (" + size.X + "; " + size.Y + ")");
chartControl.AddLine(refCurve.Name, refCurve, Color.FromKnownColor(KnownColor.OrangeRed));
chartControl.AddLine("Upper", report.Upper, Color.FromKnownColor(KnownColor.MediumSpringGreen));
chartControl.AddLine("Lower", report.Lower, Color.FromKnownColor(KnownColor.DeepSkyBlue));
if (testExists)
{
string valid = "";
if (report.Valid == Validity.Valid)
valid = "valid";
else if (report.Valid == Validity.Invalid)
valid = "invalid";
chartControl.AddLine("Test: " + valid, testCurve, Color.FromKnownColor(KnownColor.BlueViolet));
chartControl.AddErrors("Errors " + name, report.Errors);
}
// Visualization: save image
if (saveImage)
chartControl.saveAsImage(options.ReportFolder + resultName + ".png", System.Drawing.Imaging.ImageFormat.Png);
// Visualization: show window with MS Chart Control
if (options.ShowWindow)
if (!testExists || (options.ShowValidity == Validity.All || (options.ShowValidity == Validity.Invalid && report.Valid == Validity.Invalid) || (options.ShowValidity == Validity.Valid && report.Valid == Validity.Valid)))
Application.Run(chartControl);
}
#endif
}
// Error: tube calculation not successful
else
{
report.ErrorStep = Step.Tube;
report.Valid = Validity.Undefined;
if (options.Log != null)
options.Log.WriteLine(LogLevel.Error, "Tube calculation not successful.");
}
if (options.Log != null)
{
options.Log.WriteLine(LogLevel.Done, "Tube calculation algorithm: " + tube.AlgorithmOption.ToString());
}
}
// Error: tube size calculation not successful
else
{
report.ErrorStep = Step.TubeSize;
report.Valid = Validity.Undefined;
if (options.Log != null)
{
options.Log.WriteLine(LogLevel.Error, "TubeSize calculation not successful.");
options.Log.WriteLine(LogLevel.Error, "TubeSize.Ratio: " + size.Ratio);
options.Log.WriteLine(LogLevel.Error, "TubeSize.BaseX: " + size.BaseX);
options.Log.WriteLine(LogLevel.Error, "TubeSize.BaseY: " + size.BaseY);
}
}
report.Size = size;
}
// Error: data import not successful
else
{
report.ErrorStep = Step.DataImport;
report.Valid = Validity.Undefined;
if (options.Log != null)
{
if (!refCurve.ImportSuccessful)
options.Log.WriteLine(LogLevel.Error, "Reference curve: Import not successful.");
if (testExists && !testCurve.ImportSuccessful)
options.Log.WriteLine(LogLevel.Error, "Test curve: Import not successful.");
}
}
report.Reference = refCurve;
report.Test = testCurve;
}
// Error: no data
else
{
report.ErrorStep = Step.DataImport;
report.Valid = Validity.Undefined;
if (options.Log != null)
{
if (referenceX != null || referenceX.Length != 0)
options.Log.WriteLine(LogLevel.Error, "Reference curve: Missing data.");
if (referenceY!= null || referenceY.Length != 0)
options.Log.WriteLine(LogLevel.Error, "Test curve: Missing data.");
}
}
report.ModelName = modelName;
report.ResultName = resultName;
return report;
}
/// <summary>
/// Calculates the lower tube curve.
/// </summary>
/// <param name="reference">Reference curve.</param>
/// <param name="size">Tube size.</param>
/// <returns>Lower tube curve.</returns>
private static Curve CalculateLower(Curve reference, TubeSize size)
{
Curve lower; // lower tube curve
List <double> LX = new List <double>(2 * reference.Count); // x-values of lower tube curve
List <double> LY = new List <double>(2 * reference.Count); // y-values of lower tube curve
// -------------------------------------------------------------------------------------------------------------
// ---------------------------------- 1. Add corner points of the rectangle -----------------------------------
// -------------------------------------------------------------------------------------------------------------
double m0, m1; // slopes before and after point i of reference curve
double s0, s1; // signum of slopes of reference curve: 1 - increasing, 0 - constant, -1 - decreasing
// machine accuracy, the least positive floating point number, with 1 + epsilon > 1, is ~ 2.2e-16
double epsilon = 1e-15;
int b;
// -------------------------------------------------------------------------------------------------------------
// 1.1. Start: Rectangle with center (x,y) = (reference.X[0], reference.Y[0])
// -------------------------------------------------------------------------------------------------------------
// ignore identical point at the beginning
b = 0;
while ((reference.X[b] - reference.X[b + 1] == 0) && (reference.Y[b] - reference.Y[b + 1] == 0))
{
b++;
}
// slopes of reference curve (initialization)
s0 = Math.Sign(reference.Y[b + 1] - reference.Y[b]);
if (reference.X[b + 1] != reference.X[b])
{
m0 = (reference.Y[b + 1] - reference.Y[b]) / (reference.X[b + 1] - reference.X[b]);
}
else
if (s0 > 0)
{
m0 = Double.PositiveInfinity;
}
else
{
m0 = Double.NegativeInfinity;
}
// add point down left
LX.Add(reference.X[b] - size.X);
LY.Add(reference.Y[b] - size.Y);
if (s0 == 1)
{
// add point down right
LX.Add(reference.X[b] + size.X);
LY.Add(reference.Y[b] - size.Y);
}
// -------------------------------------------------------------------------------------------------------------
// 1.2. Iteration: Rectangle with center (x,y) = (reference.X[i], reference.Y[i])
// -------------------------------------------------------------------------------------------------------------
for (int i = b + 1; i < reference.Count - 1; i++)
{
// ignore identical points
if ((reference.X[i] - reference.X[i + 1] == 0) && (reference.Y[i] - reference.Y[i + 1] == 0))
{
continue;
}
// slopes of reference curve
s1 = Math.Sign(reference.Y[i + 1] - reference.Y[i]);
if (reference.X[i + 1] - reference.X[i] != 0)
{
m1 = (reference.Y[i + 1] - reference.Y[i]) / (reference.X[i + 1] - reference.X[i]);
}
else
if (s1 > 0)
{
m1 = Double.PositiveInfinity;
}
else
{
m1 = Double.NegativeInfinity;
}
// add no point for equal slopes of reference curve
if (!(m0 == m1))
{
if ((s0 != -1) && (s1 != -1))
{
// add point down right
LX.Add(reference.X[i] + size.X);
LY.Add(reference.Y[i] - size.Y);
}
else if ((s0 != 1) && (s1 != 1))
{
// add point down left
LX.Add(reference.X[i] - size.X);
LY.Add(reference.Y[i] - size.Y);
}
else if ((s0 == -1) && (s1 == 1))
{
// add point down left
LX.Add(reference.X[i] - size.X);
LY.Add(reference.Y[i] - size.Y);
// add point down right
LX.Add(reference.X[i] + size.X);
LY.Add(reference.Y[i] - size.Y);
}
else if ((s0 == 1) && (s1 == -1))
{
// add point down right
LX.Add(reference.X[i] + size.X);
LY.Add(reference.Y[i] - size.Y);
// add point down left
LX.Add(reference.X[i] - size.X);
LY.Add(reference.Y[i] - size.Y);
}
// remove the last added points in case of equal slopes equal 0 of tube curve
int last = LY.Count - 1;
if (reference.Y[i + 1] - size.Y == LY[last])
{
// remove two points, if two points were added at last
// (last - 2 >= 0, because start point + two added points)
if (s0 * s1 == -1 && LY[last - 2] == LY[last])
{
LX.RemoveAt(last);
LY.RemoveAt(last);
LX.RemoveAt(last - 1);
LY.RemoveAt(last - 1);
}
// remove one point, if one point was added at last
// (last - 1 >= 0, because start point + one added point)
else if (s0 * s1 != -1 && LY[last - 1] == LY[last])
{
LX.RemoveAt(last);
LY.RemoveAt(last);
}
}
}
s0 = s1;
m0 = m1;
}
// -------------------------------------------------------------------------------------------------------------
// 1.3. End: Rectangle with center (x,y) = (reference.X[reference.Count - 1], reference.Y[reference.Count - 1])
// -------------------------------------------------------------------------------------------------------------
if (s0 == -1)
{
// add point down left
LX.Add(reference.X[reference.Count - 1] - size.X);
LY.Add(reference.Y[reference.Count - 1] - size.Y);
}
// add point down right
LX.Add(reference.X[reference.Count - 1] + size.X);
LY.Add(reference.Y[reference.Count - 1] - size.Y);
// -------------------------------------------------------------------------------------------------------------
// -------------- 2. Remove points and add intersection points in case of backward order -----------------------
// -------------------------------------------------------------------------------------------------------------
removeLoop(LX, LY, true);
lower = new Curve("Lower", LX.ToArray(), LY.ToArray());
return(lower);
}
/// <summary>
/// Calculates the lower tube curve.
/// </summary>
/// <param name="reference">Reference curve.</param>
/// <param name="size">Tube size.</param>
/// <returns>Lower tube curve.</returns>
private static Curve CalculateLower(Curve reference, TubeSize size)
{
Curve lower; // lower tube curve
List <double> LX = new List <double>(2 * reference.Count); // x-values of lower tube curve
List <double> LY = new List <double>(2 * reference.Count); // y-values of lower tube curve
// -------------------------------------------------------------------------------------------------------------
// ---------------------------------- 1. Add corner points of the rectangle -----------------------------------
// -------------------------------------------------------------------------------------------------------------
double m0, m1; // slopes before and after point i of reference curve
double s0, s1; // signum of slopes of reference curve: 1 - increasing, 0 - constant, -1 - decreasing
// -------------------------------------------------------------------------------------------------------------
// 1.1. Start: Rectangle with center (x,y) = (reference.X[0], reference.Y[0])
// -------------------------------------------------------------------------------------------------------------
// slopes of reference curve (initialization)
s0 = Math.Sign(reference.Y[1] - reference.Y[0]);
if (reference.X[1] != reference.X[0])
{
m0 = (reference.Y[1] - reference.Y[0]) / (reference.X[1] - reference.X[0]);
}
else
if (s0 > 0)
{
m0 = Double.PositiveInfinity;
}
else
{
m0 = Double.NegativeInfinity;
}
// add point down left
LX.Add(reference.X[0] - size.X);
LY.Add(reference.Y[0] - size.Y);
if (s0 == 1)
{
// add point down right
LX.Add(reference.X[0] + size.X);
LY.Add(reference.Y[0] - size.Y);
}
// -------------------------------------------------------------------------------------------------------------
// 1.2. Iteration: Rectangle with center (x,y) = (reference.X[i], reference.Y[i])
// -------------------------------------------------------------------------------------------------------------
for (int i = 1; i < reference.Count - 1; i++)
{
if (reference.X[i] == reference.X[i + 1] && reference.Y[i] == reference.Y[i + 1]) // ignore identical points
{
continue;
}
// slopes of reference curve
s1 = Math.Sign(reference.Y[i + 1] - reference.Y[i]);
if (reference.X[i + 1] != reference.X[i])
{
m1 = (reference.Y[i + 1] - reference.Y[i]) / (reference.X[i + 1] - reference.X[i]);
}
else
if (s1 > 0)
{
m1 = Double.PositiveInfinity;
}
else
{
m1 = Double.NegativeInfinity;
}
// add no point for equal slopes of reference curve
if (!(m0 == m1))
{
if ((s0 != -1) && (s1 != -1))
{
// add point down right
LX.Add(reference.X[i] + size.X);
LY.Add(reference.Y[i] - size.Y);
}
else if ((s0 != 1) && (s1 != 1))
{
// add point down left
LX.Add(reference.X[i] - size.X);
LY.Add(reference.Y[i] - size.Y);
}
else if ((s0 == -1) && (s1 == 1))
{
// add point down left
LX.Add(reference.X[i] - size.X);
LY.Add(reference.Y[i] - size.Y);
// add point down right
LX.Add(reference.X[i] + size.X);
LY.Add(reference.Y[i] - size.Y);
}
else if ((s0 == 1) && (s1 == -1))
{
// add point down right
LX.Add(reference.X[i] + size.X);
LY.Add(reference.Y[i] - size.Y);
// add point down left
LX.Add(reference.X[i] - size.X);
LY.Add(reference.Y[i] - size.Y);
}
// remove point for equal slopes equal 0 of tube curve
int last = LY.Count - 1;
if (reference.Y[i + 1] - size.Y == LY[last] && LY[last - 1] == LY[last])
{
LX.RemoveAt(last);
LY.RemoveAt(last);
}
}
s0 = s1;
m0 = m1;
}
// -------------------------------------------------------------------------------------------------------------
// 1.3. End: Rectangle with center (x,y) = (reference.X[reference.Count - 1], reference.Y[reference.Count - 1])
// -------------------------------------------------------------------------------------------------------------
if (s0 == -1)
{
// add point down left
LX.Add(reference.X[reference.Count - 1] - size.X);
LY.Add(reference.Y[reference.Count - 1] - size.Y);
}
// add point down right
LX.Add(reference.X[reference.Count - 1] + size.X);
LY.Add(reference.Y[reference.Count - 1] - size.Y);
// -------------------------------------------------------------------------------------------------------------
// -------------- 2. Remove points and add intersection points in case of backward order -----------------------
// -------------------------------------------------------------------------------------------------------------
removeLoop(LX, LY, true);
lower = new Curve("Lower", LX.ToArray(), LY.ToArray());
return(lower);
}
