private static void GenerateEvoReport(HelixEvoSensor sensor, bool openFolder = false)
{
if (sensor.VDE.CheckComplete() && sensor.RectData.CheckComplete() && sensor.AccuracyResult.CheckComplete())
{
List <string> reportLines = new()
{
"==============================================================================",
"\tSENSOR PERFORMANCE RESULTS",
"\t--------------------------",
$"\tSENSOR PART NUMBER: {sensor.PartNumber}",
$"\tSENSOR REVISION LEVEL: {sensor.SensorRev}",
$"\tLASER CLASS: {sensor.LaserClass}\n",
"------------------------------------------------------------------------------",
$"\tSensor Serial Number: {sensor.SerialNumber}",
$"\tSensor Type: ALS",
$"\tPeceptron Part Number: {sensor.PartNumber}",
$"\tPerceptron Revision: {sensor.SensorRev}",
$"\tRectification Revision: {sensor.RectRev}",
"------------------------------------------------------------------------------",
$"\tTime: {sensor.RectData.Timestamp:M/d/yyyy h:m:s tt}\n",
"VALIDATION DATA:",
"\tResidual Sigma Actual Limit",
"\t-------------- ------ -----",
$"\tMax. Linearity Error (microns) {string.Format("{0,6:F2}", sensor.RectData.ZeroDegreeMaxLinearity)} {sensor.RectData.ZeroDegreeLinearityLimit}",
$"\tMax. Flatness Sigma (microns) {string.Format("{0,6:F2}", sensor.RectData.ZeroDegreeMaxFlatness)} {sensor.RectData.ZeroDegreeFlatnessLimit}\n",
$"\tSensor " +
(sensor.RectData.ZeroDegreeMaxFlatness < sensor.RectData.ZeroDegreeFlatnessLimit &&
sensor.RectData.ZeroDegreeMaxLinearity < sensor.RectData.ZeroDegreeLinearityLimit ? "PASSES" : "FAILS") +
$" Residual Specification\n",
"ACCURACY DATA: B89\n",
$"\tSensor {(sensor.AccuracyResult.ZeroDegree2Rms < sensor.AccuracyResult.ZeroDegree2RmsLimit ? "PASSES" : "FAILS")} 0 Degree De-rectification Test\n\n",
$"ACCURACY DATA: VDE-2634",
"\tVDE-2634 Accuracy Test: Inspection Results\n",
"\tPoint Deviation Statistic: Maximum Average Point-to-Fit Distance",
"\tTest Measured Limit Test",
"\t-------------------------------- --------- ----- ----",
$"\tSphere Spacing Error (SD) {string.Format("{0,6:F2}", (sensor.VDE.SphereSpacingError * 1000f))}" +
$" {sensor.VDE.SphereSpacingErrorLimit * 1000f}" +
$" {(sensor.VDE.SphereSpacingError * 1000f < sensor.VDE.SphereSpacingErrorLimit * 1000f ? "PASS" : "FAIL")}",
$"\tSphere Probing Error - Size (Ps) {string.Format("{0,6:F2}", (sensor.VDE.SphereProbingErrorSize * 1000f))}" +
$" {sensor.VDE.SphereProbingErrorSizeLimit * 1000f}" +
$" {(sensor.VDE.SphereProbingErrorSize * 1000f < sensor.VDE.SphereProbingErrorSizeLimit * 1000f ? "PASS" : "FAIL")}",
$"\tSphere Probing Error - Form (Pf) {string.Format("{0,6:F2}", (sensor.VDE.SphereProbingErrorForm * 1000f))}" +
$" {sensor.VDE.SphereProbingErrorFormLimit * 1000f}" +
$" {(sensor.VDE.SphereProbingErrorForm * 1000f < sensor.VDE.SphereProbingErrorFormLimit * 1000f ? "PASS" : "FAIL")}",
$"\tPlane Probing Error - Form (F) {string.Format("{0,6:F2}", (sensor.VDE.PlaneProbingError * 1000f))}" +
$" {sensor.VDE.PlaneProbingErrorFormLimit * 1000f}" +
$" {(sensor.VDE.PlaneProbingError * 1000f < sensor.VDE.PlaneProbingErrorFormLimit * 1000f ? "PASS" : "FAIL")}"
};
string folder = GetReportResultsFolder(sensor.RectDataFolder);
string file = Path.Join(folder, $"SN{sensor.SerialNumber}.txt");
WriteFile(folder, file, reportLines, openFolder);
}
}
public static void LogTemplateApplication(HelixEvoSensor sensor, int numSensors, int months)
{
List <string> headers = new() { "SerialNumber\tFilter\tDateGenerated\t#SensorsUsed\t#Months" };
string templateLogPath = Path.Join(Config.ResultsDir, "\\TComp_Templates\\Template.log");
if (!File.Exists(templateLogPath))
{
File.WriteAllLines(templateLogPath, headers);
}
File.AppendAllText(templateLogPath,
$"\n{sensor.SerialNumber}\t{sensor.PartNumber.Substring(0,8)}\t{DateTime.Now:yyyy-MM-dd-HH-mm-ss}\t{numSensors}\t{months}");
}
}
public static void ApplyTemplate(string serialNumber, int months)
{
HelixEvoSensor sensor = AllEvoDataSingle(new() { SerialNumber = serialNumber });
Tuple <TCompData, int> templateData = GenerateTemplate(sensor.PartNumber.Substring(0, 8), months); //Only get 920-0201 portion of PN
TCompData template = templateData.Item1;
List <string> lines = template.GetLines();
string snGroupFolder = GetGroupFolder(Config.TcompDir, sensor.SerialNumber);
string tcompPath = Path.Join(snGroupFolder, $"SN{sensor.SerialNumber}.txt");
if (File.Exists(tcompPath))
{
TCompBackup(tcompPath);
}
WriteFile(snGroupFolder, tcompPath, lines, false);
LogTemplateApplication(sensor, templateData.Item2, months);
MessageBox.Show($"Template generated for SN{sensor.SerialNumber}, model {sensor.PartNumber}. Used data from {templateData.Item2} sensors" +
$" from the past {months} months.", "Template Applied", MessageBoxButton.OK, MessageBoxImage.Information);
}
public EvoDataPoint?ConvertNewData(HelixEvoSensor sensor)
{
//Return null if the new data point does not contain all needed values
List <string> data = sensor.GetDataList();
List <double> doubleData = new List <double>();
for (int i = 2; i < Columns.Count; i++)
{
if (data.Count < Columns[i])
{
return(null);
}
if (double.TryParse(data[Columns[i]], out double dataPoint))
{
doubleData.Add(dataPoint);
}
}
if (double.TryParse(data[Columns[1]], out double label))
{
return(new EvoDataPoint(data[Columns[0]], label, doubleData));
}
return(null);
}
public static HelixEvoSensor LinearityFlatnessResultsSingle(HelixEvoSensor sensor)
{
List <HelixEvoSensor> sensors = new() { sensor };
Dictionary <string, List <string> > folders = GetEvoRectDataFolders(ref sensors);
if (sensor.RectDataFolder != "" && folders.ContainsKey(sensor.RectDataFolder))
{
foreach (string folder in folders[sensor.RectDataFolder])
{
if (folder.Contains(sensor.SerialNumber))
{
foreach (string file in Directory.GetFiles(folder))
{
if (file.Contains($"SN{sensor.SerialNumber}.log"))
{
sensor.GetRectData(file);
}
}
}
}
}
return(sensor);
}
public Tuple <EvoDataPoint, List <Tuple <EvoDataPoint, double> > > GetNeighbors(HelixEvoSensor sensor, List <int> colOverride = null)
{
List <Tuple <EvoDataPoint, double> > distanceList = new List <Tuple <EvoDataPoint, double> >();
EvoDataPoint?newData = ConvertNewData(sensor);
if (newData == null)
{
return(new Tuple <EvoDataPoint, List <Tuple <EvoDataPoint, double> > >(new EvoDataPoint(), distanceList));
}
if (Scaled)
{
newData = ScaleNewData((EvoDataPoint)newData);
}
foreach (EvoDataPoint data in DataPoints) //Get minkowski for all data points
{
if (colOverride == null)
{
distanceList.Add(new Tuple <EvoDataPoint, double>(data, GetMinkowski((EvoDataPoint)newData, data)));
}
else
{
distanceList.Add(new Tuple <EvoDataPoint, double>(data, GetMinkowski((EvoDataPoint)newData, data, colOverride)));
}
}
distanceList = SortDistanceList(distanceList);
if (distanceList[0].Item1.Id == sensor.SerialNumber)
{
distanceList.RemoveAt(0);
}
return(new Tuple <EvoDataPoint, List <Tuple <EvoDataPoint, double> > >((EvoDataPoint)newData, distanceList));
}
