public async void InspectImageFile(int surfaceTypeIndex, string fileName)
{
Task.Run(() => _calibrationStartedEvent.OnNext(surfaceTypeIndex));
var sw = new NotifyStopwatch("InspectImageFile: new BitmapImage(fileName)");
BitmapImage bi = new BitmapImage(new Uri(fileName, UriKind.RelativeOrAbsolute));
sw.Dispose();
var sw1 = new NotifyStopwatch("InspectImageFile: BitmapImage.ToImageInfoWith8Bpp()");
Hdc.Mv.ImageInfo imageInfo = bi.ToImageInfoWith8Bpp();
sw1.Dispose();
imageInfo.Index = 0;
imageInfo.SurfaceTypeIndex = surfaceTypeIndex;
ImageInfo imageInfoEntity = imageInfo.ToEntity();
await Task.Run(() => _calibrationCompletedEvent.OnNext(imageInfoEntity));
Task.Run(() => _inspectionStartedEvent.OnNext(surfaceTypeIndex));
await Task.Run(
() =>
{
var sw4 = new NotifyStopwatch("imageInfo.To8BppHImage()");
var to8BppHImage = imageInfo.To8BppHImage();
sw4.Dispose();
InspectInfo inspectionInfo;
if (MachineConfigProvider.MachineConfig.MV_SimulationInspectorEnabled)
{
inspectionInfo = new InspectInfo();
}
else
{
var sw3 = new NotifyStopwatch("inspector.Inspect()");
inspectionInfo = _inspectionController
.SetInspectionSchema()
.SetImage(to8BppHImage)
.CreateCoordinate()
.Inspect()
.GetInspectionInfo()
;
sw3.Dispose();
}
var surfaceInspectInfo = new SurfaceInspectInfo()
{
SurfaceTypeIndex = surfaceTypeIndex,
BitmapSource = bi,
InspectInfo = inspectionInfo,
WorkpieceIndex =
_inspectCounter /
MachineConfigProvider.MachineConfig
.MV_AcquisitionCountPerWorkpiece
};
Task.Run(() => _inspectionCompletedEvent.OnNext(surfaceInspectInfo));
HandleInspect(surfaceInspectInfo);
});
}
public static InspectInfo GetInspectionInfo(this InspectionResult inspectionResult, IRelativeCoordinate coordinate)
{
var inspectionInfo = new InspectInfo();
Debug.WriteLine("GetInspectionInfo().Start");
for (int i = 0; i < inspectionResult.DistanceBetweenPointsResults.Count; i++)
{
var result = inspectionResult.DistanceBetweenPointsResults[i];
if (result.HasError)
{
var measurement2 = new MeasurementInfo {
HasError = true
};
inspectionInfo.MeasurementInfos.Add(measurement2);
continue;
}
;
var line = new Line(result.Point1, result.Point2);
var measurement = line.GetMeasurementInfo(coordinate);
measurement.Index = i;
measurement.GroupName = result.Definition.GroupName;
measurement.TypeCode = 100 + i;
measurement.Name = result.Definition.Name;
measurement.DisplayName = result.Definition.DisplayName;
measurement.ExpectValue = result.Definition.ExpectValue;
inspectionInfo.MeasurementInfos.Add(measurement);
}
Debug.WriteLine("GetInspectionInfo().DistanceBetweenPointsResults");
for (int i = 0; i < inspectionResult.RegionTargets.Count; i++)
{
var result = inspectionResult.RegionTargets[i];
if (!result.Definition.Rect2Len2Line_DisplayEnabled &&
!result.Definition.Rect2Len1Line_DisplayEnabled)
{
continue;
}
if (result.HasError)
{
var measurement = new MeasurementInfo {
HasError = true
};
inspectionInfo.MeasurementInfos.Add(measurement);
continue;
}
;
var rect2 = result.TargetRegion.GetSmallestHRectangle2();
var roiRect = rect2.GetRoiRectangle();
if (result.Definition.Rect2Len2Line_DisplayEnabled)
{
var line = roiRect.GetWidthLine();
var measurement = line.GetMeasurementInfo(coordinate);
measurement.DisplayName = result.Definition.Rect2Len2Line_DisplayName;
measurement.GroupName = result.Definition.Rect2Len2Line_GroupName;
measurement.ExpectValue = result.Definition.Rect2Len2Line_ExpectValue;
inspectionInfo.MeasurementInfos.Add(measurement);
}
if (result.Definition.Rect2Len1Line_DisplayEnabled)
{
var line = roiRect.GetLine();
var measurement = line.GetMeasurementInfo(coordinate);
measurement.DisplayName = result.Definition.Rect2Len1Line_DisplayName;
measurement.GroupName = result.Definition.Rect2Len1Line_GroupName;
measurement.ExpectValue = result.Definition.Rect2Len1Line_ExpectValue;
inspectionInfo.MeasurementInfos.Add(measurement);
}
}
Debug.WriteLine("GetInspectionInfo().RegionTargets");
for (int i = 0; i < inspectionResult.Circles.Count; i++)
{
var result = inspectionResult.Circles[i];
if (!result.Definition.Diameter_DisplayEnabled)
{
continue;
}
if (result.HasError)
{
var measurement2 = new MeasurementInfo {
HasError = true
};
inspectionInfo.MeasurementInfos.Add(measurement2);
continue;
}
;
var line = result.Circle.GetLine(-45);
var measurement = line.GetMeasurementInfo(coordinate);
measurement.DisplayName = result.Definition.Diameter_DisplayName;
measurement.GroupName = result.Definition.Diameter_GroupName;
measurement.ExpectValue = result.Definition.Diameter_ExpectValue;
inspectionInfo.MeasurementInfos.Add(measurement);
}
Debug.WriteLine("GetInspectionInfo().Circles");
for (int i = 0; i < inspectionResult.Parts.Count; i++)
{
var part = inspectionResult.Parts[i];
if (part.PartRegion == null)
{
Debug.WriteLine("GetInspectionInfo().Parts: PartRegion == null");
continue;
}
if (part.PartRegion.CountObj() == 0)
{
Debug.WriteLine("GetInspectionInfo().Parts: PartRegion.CountObj == 0");
continue;
}
if (part.PartRegion.GetArea() < 1)
{
Debug.WriteLine("GetInspectionInfo().Parts: PartRegion.GetArea() < 1");
continue;
}
var partRegion = part.PartRegion;
var centerX = partRegion.GetColumn();
var centerY = partRegion.GetRow();
var x = partRegion.GetColumn1();
var y = partRegion.GetRow1();
var width = partRegion.GetWidth();
var height = partRegion.GetHeight();
var area = partRegion.GetArea();
var relativeCenter = coordinate.GetRelativeVector(new Vector(centerX, centerY));
var di = new DefectInfo
{
Index = i,
X = x,
Y = y,
Width = width,
Height = height,
TypeCode = (int)DefectType.PartExist,
Size = area,
XActualValue = relativeCenter.X.ToMillimeterFromPixel(16),
YActualValue = relativeCenter.Y.ToMillimeterFromPixel(16),
WidthActualValue = ((double)width).ToMillimeterFromPixel(16),
HeightActualValue = ((double)height).ToMillimeterFromPixel(16),
SizeActualValue = area * 256.0 / 1000000.0
};
inspectionInfo.DefectInfos.Add(di);
}
Debug.WriteLine("GetInspectionInfo().Parts");
var drs = inspectionResult.RegionDefectResults.SelectMany(x => x.DefectResults).ToList();
for (int i = 0; i < drs.Count; i++)
{
var dr = drs[i];
var relPoint = coordinate.GetRelativeVector(new Vector(dr.X - dr.Width / 2.0, dr.Y - dr.Height / 2.0));
var di = new DefectInfo
{
Index = i,
X = dr.X - dr.Width / 2.0,
Y = dr.Y - dr.Height / 2.0,
Width = dr.Width,
Height = dr.Height,
TypeCode = dr.TypeCode,
Size = dr.Size * 256.0 / 1000000.0,
XActualValue = relPoint.X.ToMillimeterFromPixel(16),
YActualValue = relPoint.Y.ToMillimeterFromPixel(16),
WidthActualValue = dr.Width.ToMillimeterFromPixel(16),
HeightActualValue = dr.Height.ToMillimeterFromPixel(16),
SizeActualValue = dr.Size * 256.0 / 1000000.0
};
inspectionInfo.DefectInfos.Add(di);
}
Debug.WriteLine("GetInspectionInfo().RegionDefectResults");
return(inspectionInfo);
}
public async Task <int> AcquisitionAndInspectAsync(int surfaceTypeIndex)
{
// Acquisition
Task.Run(() => _acquisitionStartedEvent.OnNext(surfaceTypeIndex));
var imageInfo = await _camera.AcquisitionAsync();
switch (surfaceTypeIndex)
{
case 0:
Machine.Inspection_SurfaceFront_GrabFinishedPcEventDevice.WriteTrue();
break;
case 1:
Machine.Inspection_SurfaceBack_GrabFinishedPcEventDevice.WriteTrue();
break;
}
Task.Run(() =>
{
_acquisitionCompletedEvent.OnNext(imageInfo.ToEntity());
_calibrationStartedEvent.OnNext(surfaceTypeIndex);
});
// Calibration
HImage calibImage;
if (MachineConfig.MV_SimulationCalibrationEnabled)
{
calibImage = imageInfo.To8BppHImage();
}
else
{
var swOriToHImageInfo = new NotifyStopwatch("imageInfo.To8BppHImage()");
HImage oriImage = imageInfo.To8BppHImage();
swOriToHImageInfo.Dispose();
// HImage reducedImage = oriImage.Rectangle1Domain(2000, 2000, 5000, 5000);
var calib = new HalconImageCalibrator();
var swCalib = new NotifyStopwatch("AcquisitionAndInspectAsync.CalibrateImage(imageInfo)");
calibImage = calib.CalibrateImage(oriImage, MachineConfig.MV_CalibrationInterpolation);
swCalib.Dispose();
oriImage.Dispose();
}
var swCalibToImageInfo = new NotifyStopwatch("calibImage.ToImageInfo()");
var calibImageInfo = calibImage.ToImageInfo();
swCalibToImageInfo.Dispose();
calibImageInfo.SurfaceTypeIndex = surfaceTypeIndex;
Debug.WriteLine("SurfaceType " + surfaceTypeIndex + ": StartGrabAsync() Finished");
Task.Run(() =>
{
_calibrationCompletedEvent.OnNext(calibImageInfo.ToEntity());
_inspectionStartedEvent.OnNext(surfaceTypeIndex);
});
Task.Run(
() =>
{
InspectInfo inspectionInfo;
if (MachineConfigProvider.MachineConfig.MV_SimulationInspectorEnabled)
{
inspectionInfo = new InspectInfo();
calibImage.Dispose();
}
else
{
InspectionResult inspectionResult;
try
{
Debug.WriteLine("_inspectionController.Inspect() start");
var sw3 = new NotifyStopwatch("_inspectionController.Inspect()");
_inspectionController
.SetInspectionSchema(_inspectionSchema.DeepClone())
.SetImage(calibImage)
.CreateCoordinate()
.Inspect();
Debug.WriteLine("_inspectionController.Inspect() OK");
sw3.Dispose();
calibImage.Dispose();
inspectionResult = _inspectionController.InspectionResult;
}
catch (Exception e)
{
MessageBox.Show("_inspectionController error.\n\n" + e.Message + "\n\n" +
e.InnerException.Message);
Debug.WriteLine("_inspectionController error.\n\n" + e.Message + "\n\n" +
e.InnerException.Message);
inspectionResult = new InspectionResult();
}
Debug.WriteLine("_inspectionController.GetInspectionInfo() Start");
inspectionInfo = inspectionResult.GetInspectionInfo(_inspectionController.Coordinate);
Debug.WriteLine("_inspectionController.GetInspectionInfo() OK");
}
var surfaceInspectInfo = new SurfaceInspectInfo()
{
SurfaceTypeIndex = surfaceTypeIndex,
ImageInfo = calibImageInfo.ToEntity(),
InspectInfo = inspectionInfo,
WorkpieceIndex =
_inspectCounter /
MachineConfigProvider.MachineConfig
.MV_AcquisitionCountPerWorkpiece
};
Task.Run(() => _inspectionCompletedEvent.OnNext(surfaceInspectInfo));
Debug.WriteLine("AcquisitionAndInspectAsync.HandleInspect() above");
HandleInspect(surfaceInspectInfo);
});
return(calibImageInfo.Index);
}
