public HRegion Extract(HImage image)
{
var domain = image.GetDomain();
var offsetRow1 = domain.GetRow1();
var offsetColumn1 = domain.GetColumn1();
var croppedImage = image.CropDomain();
var swThresholdImageFilter = new NotifyStopwatch("DynThresholdCroppedRegionExtractor.ThresholdImageFilter");
HImage thresholdImage = ThresholdImageFilter.Process(croppedImage);
swThresholdImageFilter.Dispose();
var swDynThreshold = new NotifyStopwatch("DynThresholdCroppedRegionExtractor.DynThreshold");
HRegion region = croppedImage.DynThreshold(
thresholdImage,
Offset,
LightDark.ToHalconString());
swDynThreshold.Dispose();
var movedRegion = region.MoveRegion(offsetRow1, offsetColumn1);
croppedImage.Dispose();
thresholdImage.Dispose();
region.Dispose();
return(movedRegion);
}
// public IList<PartSearchingResult> SearchParts(HImage image, IList<PartSearchingDefinition> definitions)
public PartSearchingResult SearchPart(HImage image, PartSearchingDefinition definition)
{
var swSearchPart = new NotifyStopwatch("SearchPart: " + definition.Name);
int offsetX = 0;
int offsetY = 0;
HRegion domain;
var result = new PartSearchingResult()
{
Definition = definition.DeepClone(),
};
var reducedImage = HDevelopExport.Singletone.ChangeDomainForRectangle(
image,
line: definition.RoiLine,
halfWidth: definition.RoiHalfWidth,
margin: 0.5);
if (definition.Domain_SaveCacheImageEnabled)
{
reducedImage.CropDomain()
.ToBitmapSource()
.SaveToTiff(_cacheImageDir + "\\PartInspector_" + definition.Name + "_1_Domain.tif");
}
domain = reducedImage.GetDomain();
offsetX = domain.GetColumn1();
offsetY = domain.GetRow1();
var croppedImage = reducedImage.CropDomain();
var region = definition.PartExtractor.Extract(croppedImage);
var countObj = region.CountObj();
if (countObj == 0)
{
}
else
{
var movedRegion = region.MoveRegion(offsetY, offsetX);
var rect2 = movedRegion.GetSmallestHRectangle2();
var line = rect2.GetRoiLineFromRectangle2Phi();
result.PartLine = line;
result.PartHalfWidth = rect2.Length2;
result.PartRegion = movedRegion;
}
swSearchPart.Dispose();
return(result);
}
public HRegion Extract(HImage image)
{
HImage preprocessImage;
if (PreprocessFilter != null)
{
preprocessImage = PreprocessFilter.Process(image);
}
else
{
preprocessImage = image;
}
HImage thresholdImage;
if (SeparateFilter)
{
var swThresholdImageFilter = new NotifyStopwatch("DynThresholdRegionExtractor.ThresholdImageFilter");
thresholdImage = ThresholdImageFilter.Process(image);
swThresholdImageFilter.Dispose();
}
else
{
var swThresholdImageFilter = new NotifyStopwatch("DynThresholdRegionExtractor.ThresholdImageFilter");
thresholdImage = ThresholdImageFilter.Process(preprocessImage);
swThresholdImageFilter.Dispose();
}
var swDynThreshold = new NotifyStopwatch("DynThresholdRegionExtractor.DynThreshold");
HRegion region = preprocessImage.DynThreshold(
thresholdImage,
Offset,
LightDark.ToHalconString());
swDynThreshold.Dispose();
preprocessImage.Dispose();
thresholdImage.Dispose();
return(region);
}
public HImage CalibrateImage(HImage originalImage, Interpolation interpolation)
{
var cameraParamsFileName = "camera_params.cal";
var cameraPoseFileName = "camera_pose.dat";
HImage hImage;
var sw2 = new NotifyStopwatch("HalconImageCalibrator.Calibrate()");
hImage = originalImage.Calibrate(cameraParamsFileName, cameraPoseFileName, interpolation);
sw2.Stop();
sw2.Dispose();
var sw = new NotifyStopwatch("HalconImageCalibrator.MirrorImage()");
var mirroredImage = hImage.MirrorImage("row");
mirroredImage = mirroredImage.MirrorImage("column");
sw.Stop();
sw.Dispose();
return(mirroredImage);
}
private void Inspect(InspectionSchema schema)
{
//IndicatorViewer.Loaded += (sender, args) => IndicatorViewer.ZoomFit();
// IndicatorViewer.Loaded += (sender, args) => IndicatorViewer.ZoomOut();
RegionIndicators.Clear();
LineIndicators.Clear();
CircleIndicators.Clear();
DefectIndicators.Clear();
ObjectIndicators.Clear();
BitmapSource bs;
try
{
bs = new BitmapImage(new Uri(schema.TestImageFilePath, UriKind.RelativeOrAbsolute));
}
catch (FileNotFoundException e)
{
throw new HalconInspectorException("Image file not exist", e);
}
if (Math.Abs(bs.DpiX - 96) > 0.00001 || Math.Abs(bs.DpiY - 96) > 0.00001)
{
var sw1 = new NotifyStopwatch("BitmapSource convert to Dpi96");
BitmapSourceInfo bsi = bs.ToGray8BppBitmapSourceInfo();
bsi.DpiX = 96;
bsi.DpiY = 96;
var bitmapSourceDpi96 = bsi.GetBitmapSource();
bs = bitmapSourceDpi96;
sw1.Stop();
sw1.Dispose();
}
IndicatorViewer.BitmapSource = bs;
var sw2 = new NotifyStopwatch("BitmapSource.ToHImage()");
var hImage = bs.ToHImage();
sw2.Stop();
sw2.Dispose();
try
{
var sw = new NotifyStopwatch("InspectionController.Inspect()");
InspectionController
.SetInspectionSchema()
.SetImage(hImage)
.CreateCoordinate()
.Inspect()
;
sw.Stop();
sw.Dispose();
// CoordinateCircles
Show_CircleSearchingDefinitions(
InspectionController.InspectionResult.GetCoordinateCircleSearchingDefinitions());
Show_CircleSearchingResults(InspectionController.InspectionResult.CoordinateCircles);
// Circles
Show_CircleSearchingDefinitions(
InspectionController.InspectionResult.GetCircleSearchingDefinitions(), Brushes.Orange);
Show_CircleSearchingResults(InspectionController.InspectionResult.Circles, Brushes.DodgerBlue);
// CoordinateEdges
Show_EdgeSearchingDefinitions(InspectionController.InspectionResult.GetCoordinateEdges());
Show_EdgeSearchingResults(InspectionController.InspectionResult.CoordinateEdges);
// Edges
Show_EdgeSearchingDefinitions(InspectionController.InspectionResult.GetEdgeSearchingDefinitions());
Show_EdgeSearchingResults(InspectionController.InspectionResult.Edges);
// DistanceBetweenPoints
Show_DistanceBetweenPointsResults(InspectionController.InspectionResult.DistanceBetweenPointsResults);
// Defects
Show_DefectResults(InspectionController.InspectionResult.RegionDefectResults);
// Parts
Show_PartSearchingDefinitions(InspectionController.InspectionResult.GetPartSearchingDefinitions());
Show_PartSearchingResults(InspectionController.InspectionResult.Parts);
// RegionTargets
Show_RegionTargetDefinitions(InspectionController.InspectionResult.GetRegionTargetDefinitions());
Show_RegionTargetResults(InspectionController.InspectionResult.RegionTargets);
}
catch (CreateCoordinateFailedException e)
{
Show_CircleSearchingDefinitions(
InspectionController.InspectionResult.GetCoordinateCircleSearchingDefinitions());
Show_CircleSearchingResults(InspectionController.InspectionResult.CoordinateCircles);
Show_EdgeSearchingDefinitions(InspectionController.InspectionResult.GetCoordinateEdges());
Show_EdgeSearchingResults(InspectionController.InspectionResult.CoordinateEdges);
MessageBox.Show(e.Message);
}
}
public SurfaceResult SearchSurface(HImage image, SurfaceDefinition definition)
{
var swSearchSurface = new NotifyStopwatch("SearchSurface: " + definition.Name);
if (definition.SaveAllCacheImageEnabled)
{
// definition.SaveCacheImageEnabled = true;
foreach (var part in definition.ExcludeParts)
{
part.SaveCacheImageEnabled = true;
}
foreach (var part in definition.IncludeParts)
{
part.SaveCacheImageEnabled = true;
}
}
var surfaceResult = new SurfaceResult()
{
Definition = definition.DeepClone(),
};
var unionIncludeRegion = new HRegion();
var unionIncludeDomain = new HRegion();
unionIncludeRegion.GenEmptyRegion();
unionIncludeDomain.GenEmptyRegion();
var unionExcludeRegion = new HRegion();
var unionExcludeDomain = new HRegion();
unionExcludeRegion.GenEmptyRegion();
unionExcludeDomain.GenEmptyRegion();
foreach (var excludeRegion in definition.ExcludeParts)
{
var sw = new NotifyStopwatch("excludeRegion.Process: " + excludeRegion.Name);
HRegion region = excludeRegion.Extract(image);
sw.Dispose();
var domain = excludeRegion.Domain;
unionExcludeRegion = unionExcludeRegion.Union2(region);
unionExcludeDomain = unionExcludeDomain.Union2(domain);
if (excludeRegion.SaveCacheImageEnabled)
{
var fileName = "SurfaceDefinition_" + definition.Name + "_Exclude_" + excludeRegion.Name;
image.SaveCacheImagesForRegion(domain, region, fileName);
}
surfaceResult.ExcludeRegionResults.Add(new RegionResult()
{
SurfaceGroupName = definition.GroupName,
SurfaceName = definition.Name,
RegionName = excludeRegion.Name,
Domain = domain,
Region = region,
});
// region.Dispose();
// domain.Dispose();
}
foreach (var includeRegion in definition.IncludeParts)
{
var domain = includeRegion.Domain;
unionIncludeDomain = unionIncludeDomain.Union2(domain);
var remainDomain = domain.Difference(unionExcludeRegion);
var reducedImage = image.ChangeDomain(remainDomain);
HRegion region;
using (new NotifyStopwatch("includeRegion.Process: " + includeRegion.Name))
region = includeRegion.Extract(reducedImage);
var remainRegion = region.Difference(unionExcludeRegion);
unionIncludeRegion = unionIncludeRegion.Union2(remainRegion);
if (includeRegion.SaveCacheImageEnabled)
{
var fileName = "SurfaceDefinition_" + definition.Name + "_Include_" + includeRegion.Name;
// _hDevelopExportHelper.HImage.SaveCacheImagesForRegion(domain, remainRegion, fileName);
image.SaveCacheImagesForRegion(domain, remainRegion, unionExcludeRegion,
fileName);
}
surfaceResult.IncludeRegionResults.Add(new RegionResult()
{
SurfaceGroupName = definition.GroupName,
SurfaceName = definition.Name,
RegionName = includeRegion.Name,
Domain = domain,
Region = remainRegion,
});
}
if (definition.SaveCacheImageEnabled && definition.IncludeParts.Any())
{
var fileName = "SurfaceDefinition_" + definition.Name + "_Include";
image.SaveCacheImagesForRegion(unionIncludeDomain, unionIncludeRegion,
unionExcludeRegion, fileName);
}
if (definition.SaveCacheImageEnabled && definition.ExcludeParts.Any())
{
var fileName = "SurfaceDefinition_" + definition.Name + "_Exclude";
image.SaveCacheImagesForRegion(unionExcludeDomain, unionExcludeRegion,
fileName);
}
surfaceResult.ExcludeRegion = unionExcludeRegion;
surfaceResult.IncludeRegion = unionIncludeRegion;
swSearchSurface.Dispose();
return(surfaceResult);
}
public IList <RegionDefectResult> SearchDefects(HImage image, DefectDefinition definition,
IList <SurfaceResult> surfaceResults)
{
var swSearchDefects = new NotifyStopwatch("SearchDefects: " + definition.Name);
var rdrs = new List <RegionDefectResult>();
foreach (var refer in definition.References)
{
var regionResult = surfaceResults.GetRegionResult(refer.SurfaceName, refer.RegionName);
if (regionResult == null)
{
continue;
}
var regionDefectResult = new RegionDefectResult {
RegionResult = regionResult
};
var changeDomainImage = image.ChangeDomain(regionResult.Region);
HImage filterImage;
if (definition.ImageFilter != null)
{
filterImage = definition.ImageFilter.Process(changeDomainImage);
changeDomainImage.Dispose();
}
else
{
filterImage = changeDomainImage;
}
var blob = definition.RegionExtractor.Extract(filterImage);
HRegion finalBlob;
if (definition.RegionProcessor != null)
{
finalBlob = definition.RegionProcessor.Process(blob);
blob.Dispose();
}
else
{
finalBlob = blob;
}
if (definition.SaveCacheImageEnabled)
{
var image2 = image.ChangeDomain(regionResult.Region);
if (finalBlob.CountObj() > 0)
{
var paintImage = image2.PaintRegion(finalBlob, 222.0, "fill");
paintImage.WriteImageOfTiffLzwOfCropDomain(_cacheImageDir + "\\SearchCircles_" + definition.Name +
"_1_Domain.tif");
}
else
{
image2.WriteImageOfTiffLzwOfCropDomain(_cacheImageDir + "\\SearchCircles_" + definition.Name +
"_1_Domain.tif");
}
}
var blobs = finalBlob.ToList();
int index = 0;
foreach (var hRegion in blobs)
{
var dr = new DefectResult
{
Index = index,
X = hRegion.GetColumn(),
Y = hRegion.GetRow(),
Width = hRegion.GetWidth(),
Height = hRegion.GetHeight(),
Name = definition.Name,
};
regionDefectResult.DefectResults.Add(dr);
index++;
}
rdrs.Add(regionDefectResult);
}
swSearchDefects.Dispose();
return(rdrs);
}
public IInspectionController Inspect()
{
var sw2 = new NotifyStopwatch("IInspectionController.Inspect()");
var inspectionSchema = _inspectionSchema;
if (inspectionSchema.RegionTargetDefinitions.Any())
{
var inspector = new RegionTargetInspector();
var results = inspector.SearchRegionTargets(_image, inspectionSchema.RegionTargetDefinitions);
_inspectionResult.RegionTargets = results;
}
if (inspectionSchema.PartSearchingDefinitions.Any())
{
var partInspector = new PartInspector();
var results = partInspector.SearchParts(_image, inspectionSchema.PartSearchingDefinitions);
_inspectionResult.Parts = results;
}
if (inspectionSchema.CircleSearchingDefinitions.Any())
{
var sw = new NotifyStopwatch("SearchCircles()");
var circles = InspectorFactory
.CreateCircleInspector(inspectionSchema.CircleSearching_InspectorName)
.SearchCircles(_image, inspectionSchema.CircleSearchingDefinitions);
sw.Dispose();
_inspectionResult.Circles = new CircleSearchingResultCollection(circles);
}
if (inspectionSchema.SurfaceDefinitions.Any())
{
IList <SurfaceResult> regionResults = null;
using (new NotifyStopwatch("SearchSurfaces()"))
regionResults = InspectorFactory
.CreateSurfaceInspector(inspectionSchema.Surfaces_InspectorName)
.SearchSurfaces(_image, inspectionSchema.SurfaceDefinitions);
// IList<DefectResult> defectResultCollection = null;
if (inspectionSchema.DefectDefinitions.Any())
{
var defectInspector = InspectorFactory.CreateDefectInspector(inspectionSchema.Defects_InspectorName);
var defectResultCollection = defectInspector.SearchDefects(_image, inspectionSchema.DefectDefinitions,
regionResults);
_inspectionResult.RegionDefectResults = defectResultCollection;
// inspectionResult.ClosedRegionResults = regionResults;
}
}
if (inspectionSchema.EdgeSearchingDefinitions.Any())
{
if (inspectionSchema.EdgeSearching_SaveCacheImage_Disabled)
{
foreach (var def in inspectionSchema.EdgeSearchingDefinitions)
{
def.Domain_SaveCacheImageEnabled = false;
def.RegionExtractor_Disabled = false;
def.ImageFilter_SaveCacheImageEnabled = false;
}
}
var finalEdges = InspectorFactory
.CreateEdgeInspector(inspectionSchema.EdgeSearching_InspectorName)
.SearchEdges(_image, inspectionSchema.EdgeSearchingDefinitions);
_inspectionResult.Edges = new EdgeSearchingResultCollection(finalEdges);
int i = 0;
foreach (var def in inspectionSchema.DistanceBetweenIntersectionPointsDefinitions)
{
var line1 = finalEdges.Single(x => x.Name == def.Line1Name);
var line2 = finalEdges.Single(x => x.Name == def.Line2Name);
var line1Center = line1.Definition.Line.GetCenterPoint();
var line2Center = line2.Definition.Line.GetCenterPoint();
var linkLine = new Line(line1Center, line2Center);
var intersection1 = line1.EdgeLine.IntersectionWith(linkLine);
var intersection2 = line2.EdgeLine.IntersectionWith(linkLine);
if (Math.Abs(intersection1.X) < 0.00001 ||
Math.Abs(intersection2.X) < 0.00001)
{
Debug.WriteLine(@"DistanceBetweenIntersectionPointsDefinitions failed: {0}", def.Name);
}
//var distance = t1.ToVector() - t2.ToVector();
var distance = (intersection1 - intersection2).Length;
// Debug.WriteLine("Distance {0}: {1}\t", def.Name, distance);
var distanceBetweenPointsResult = new DistanceBetweenPointsResult()
{
Definition = def.DeepClone(),
Index = i,
Name = def.Name,
Point1 = intersection1,
Point2 = intersection2,
DistanceInPixel = (intersection1 - intersection2).Length,
DistanceInWorld =
(intersection1 - intersection2).Length
.ToMillimeterFromPixel(16),
};
_inspectionResult.DistanceBetweenPointsResults.Add(distanceBetweenPointsResult);
i++;
}
}
sw2.Dispose();
return(this);
}
public InspectionController CreateCoordinate()
{
var sw = new NotifyStopwatch("InspectionController.CreateCoordinate.Inspect()");
try
{
switch (_inspectionSchema.CoordinateType)
{
case CoordinateType.Baseline:
var origin = _inspectionResult.CoordinateCircles[0];
var refCircle = _inspectionResult.CoordinateCircles[1];
_coordinate = new RelativeCoordinate(
origin.Circle.GetCenterPoint(),
refCircle.Circle.GetCenterPoint(),
refCircle.Definition.BaselineAngle);
break;
case CoordinateType.VectorsCenter:
var inspector =
InspectorFactory.CreateCircleInspector(_inspectionSchema.CircleSearching_InspectorName);
var searchCoordinateCircles = inspector.SearchCircles(_image, _inspectionSchema.CoordinateCircles);
_inspectionResult.CoordinateCircles = new CircleSearchingResultCollection(searchCoordinateCircles);
_coordinate = RelativeCoordinateFactory.CreateCoordinate(_inspectionResult.CoordinateCircles);
break;
case CoordinateType.NearOrigin:
throw new NotSupportedException("CoordinateType does not implement!");
break;
case CoordinateType.Boarder:
var inspector2 = InspectorFactory.CreateEdgeInspector(_inspectionSchema.EdgeSearching_InspectorName);
var searchCoordinateEdges = inspector2.SearchEdges(_image, _inspectionSchema.CoordinateEdges);
_inspectionResult.CoordinateEdges = new EdgeSearchingResultCollection(searchCoordinateEdges);
_coordinate =
RelativeCoordinateFactory.CreateCoordinateUsingBorder(_inspectionResult.CoordinateEdges);
break;
default:
throw new NotSupportedException("CoordinateType does not support!");
}
}
catch (CreateCoordinateFailedException e)
{
// _inspectionResult
throw;
}
if (_inspectionSchema.CoordinateOriginOffsetEnable)
{
_coordinate.OriginOffset = new Vector(_inspectionSchema.CoordinateOriginOffsetX,
_inspectionSchema.CoordinateOriginOffsetY);
}
_inspectionResult.CoordinateCircles.UpdateRelativeCoordinate(_coordinate);
//
_inspectionSchema.CoordinateCircles.UpdateRelativeCoordinate(_coordinate);
_inspectionSchema.CoordinateEdges.UpdateRelativeCoordinate(_coordinate);
_inspectionSchema.CircleSearchingDefinitions.UpdateRelativeCoordinate(_coordinate);
_inspectionSchema.EdgeSearchingDefinitions.UpdateRelativeCoordinate(_coordinate);
_inspectionSchema.PartSearchingDefinitions.UpdateRelativeCoordinate(_coordinate);
_inspectionSchema.SurfaceDefinitions.UpdateRelativeCoordinate(_coordinate);
_inspectionSchema.RegionTargetDefinitions.UpdateRelativeCoordinate(_coordinate);
sw.Dispose();
return(this);
}
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 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);
}
public RegionTargetResult SearchRegionTarget(HImage image, RegionTargetDefinition definition)
{
var swSearchRegionTarget = new NotifyStopwatch("SearchRegionTarget: " + definition.Name);
var result = new RegionTargetResult
{
Definition = definition.DeepClone(),
};
var roiImage = HDevelopExport.Singletone.ChangeDomainForRectangle(
image,
definition.RoiActualLine,
definition.RoiHalfWidth);
if (definition.Domain_SaveCacheImageEnabled)
{
roiImage.WriteImageOfTiffLzwOfCropDomain(
_cacheImageDir + "\\SearchRegionTarget_" + definition.Name + "_1_Domain_Cropped.tif");
}
// Around
HImage aroundFilterImage;
if (definition.AroundImageFilter != null)
{
var swAroundImageFilter = new NotifyStopwatch("RegionTargetInspector.AroundImageFilter: " + definition.Name);
aroundFilterImage = definition.AroundImageFilter.Process(roiImage);
swAroundImageFilter.Dispose();
}
else
{
aroundFilterImage = roiImage;
}
HRegion aroundRegion;
if (definition.AroundRegionExtractor != null)
{
var swAroundRegionExtractor = new NotifyStopwatch("RegionTargetInspector.AroundRegionExtractor: " + definition.Name);
aroundRegion = definition.AroundRegionExtractor.Extract(aroundFilterImage);
swAroundRegionExtractor.Dispose();
}
else
{
aroundRegion = aroundFilterImage.GetDomain();
}
if (definition.AroundRegionExtractor_SaveCacheImageEnabled)
{
// var reducedImage = image.ChangeDomain(aroundRegion.Union1());
// reducedImage.WriteImageOfTiffLzwOfCropDomain(
// _cacheImageDir + "\\SearchRegionTarget_" + definition.Name + "_1_AroundRegionExtractor.tif");
// reducedImage.Dispose();
image.WriteImageOfTiffLzwOfCropDomain(aroundRegion,
_cacheImageDir + "\\SearchRegionTarget_" + definition.Name + "_1_AroundRegionExtractor.tif");
}
HRegion aroundProcessedRegion;
if (definition.AroundRegionProcessor != null)
{
var swAroundRegionProcessor = new NotifyStopwatch("RegionTargetInspector.AroundRegionProcessor: " + definition.Name);
aroundProcessedRegion = definition.AroundRegionProcessor.Process(aroundRegion);
swAroundRegionProcessor.Dispose();
}
else
{
aroundProcessedRegion = aroundRegion;
}
HImage aroundImage = image.ChangeDomain(aroundProcessedRegion);
if (definition.AroundRegionProcessor_SaveCacheImageEnabled)
{
aroundImage.WriteImageOfTiffLzwOfCropDomain(
_cacheImageDir + "\\SearchRegionTarget_" + definition.Name + "_1_Around_Cropped.tif");
}
aroundProcessedRegion.Dispose();
aroundFilterImage.Dispose();
aroundRegion.Dispose();
// Target
HImage targetFilterImage;
if (definition.TargetImageFilter != null)
{
var swTargetImageFilter = new NotifyStopwatch("RegionTargetInspector.TargetImageFilter: " + definition.Name);
targetFilterImage = definition.TargetImageFilter.Process(aroundImage);
swTargetImageFilter.Dispose();
}
else
{
targetFilterImage = aroundImage;
}
if (definition.TargetImageFilter_SaveCacheImageEnabled)
{
targetFilterImage.WriteImageOfTiffLzwOfCropDomain(
_cacheImageDir + "\\SearchRegionTarget_" + definition.Name + "_1_TargetImageFilter_Cropped.tif");
}
HRegion targetRegion;
if (definition.TargetRegionExtractor != null)
{
var swTargetRegionExtractor = new NotifyStopwatch("RegionTargetInspector.TargetRegionExtractor: " + definition.Name);
targetRegion = definition.TargetRegionExtractor.Extract(targetFilterImage);
swTargetRegionExtractor.Dispose();
}
else
{
targetRegion = targetFilterImage.GetDomain();
}
HRegion targetProcessedRegion;
if (definition.TargetRegionProcessor != null)
{
var swTargetRegionProcessor = new NotifyStopwatch("RegionTargetInspector.TargetRegionProcessor: " + definition.Name);
targetProcessedRegion = definition.TargetRegionProcessor.Process(targetRegion);
swTargetRegionProcessor.Dispose();
}
else
{
targetProcessedRegion = targetRegion;
}
targetFilterImage.Dispose();
roiImage.Dispose();
result.TargetRegion = targetProcessedRegion;
if (targetProcessedRegion.CountObj() == 0)
{
result.HasError = true;
}
swSearchRegionTarget.Dispose();
return(result);
}
private EdgeSearchingResult CropDomain(HImage image, EdgeSearchingDefinition definition)
{
var swSearchEdge = new NotifyStopwatch("SearchEdge: " + definition.Name);
var esr = new EdgeSearchingResult
{
Definition = definition.DeepClone(),
Name = definition.Name
};
var rectImage = image.ChangeDomainForRoiRectangle(definition.Line, definition.ROIWidth);
var rectDomain = rectImage.GetDomain();
var rectDomainRect1 = rectDomain.GetSmallestRectangle1();
var rectCroppedImage = rectImage.CropDomain();
if (definition.Domain_SaveCacheImageEnabled)
{
rectCroppedImage.WriteImageOfTiffLzw(
_cacheImageDir + "\\SearchEdges_" + definition.Name + "_1_Domain_Cropped.tif");
}
// RegionExtractor
HRegion roiDomain;
if (esr.Definition.RegionExtractor != null)
{
var croppedRoiDomain = esr.Definition.RegionExtractor.Extract(rectCroppedImage);
roiDomain = croppedRoiDomain.MoveRegion(rectDomainRect1.Row1, rectDomainRect1.Column1);
}
else
{
roiDomain = rectDomain;
}
var roiDomainRect1 = roiDomain.GetSmallestRectangle1();
HImage roiCroppedImage = image.CropRectangle1(roiDomainRect1);
// ImageFilter
HImage filterImage = null;
if (esr.Definition.ImageFilter != null)
{
var sw = new NotifyStopwatch("ImageFilter");
filterImage = esr.Definition.ImageFilter.Process(roiCroppedImage);
sw.Dispose();
if (definition.ImageFilter_SaveCacheImageEnabled)
{
var cropDomain = filterImage.CropDomain();
cropDomain.WriteImageOfTiffLzw(_cacheImageDir + "\\SearchEdges_" + definition.Name +
"_3_ImageFilter_Cropped.tif");
cropDomain.Dispose();
// var paintedImage = filterImage.PaintGrayOffset(image, offsetY, offsetX);
// paintedImage.WriteImageOfJpeg(_cacheImageDir + "\\SearchEdges_" + definition.Name +
// "_3_ImageFilter_PaintGrayOffset.jpg");
// paintedImage.Dispose();
}
}
else
{
filterImage = roiCroppedImage;
}
Line offsetLine = new Line(esr.Definition.Line.X1 - roiDomainRect1.Column1,
esr.Definition.Line.Y1 - roiDomainRect1.Row1, esr.Definition.Line.X2 - roiDomainRect1.Column1,
esr.Definition.Line.Y2 - roiDomainRect1.Row1);
var line = esr.Definition.LineExtractor.FindLine(filterImage, offsetLine);
var translatedLine = new Line(line.X1 + roiDomainRect1.Column1,
line.Y1 + roiDomainRect1.Row1, line.X2 + roiDomainRect1.Column1,
line.Y2 + roiDomainRect1.Row1);
esr.EdgeLine = translatedLine;
if (line.IsEmpty)
{
esr.IsNotFound = true;
Debug.WriteLine("Edge not found: " + esr.Name);
}
swSearchEdge.Dispose();
return(esr);
}
private EdgeSearchingResult NoCropDomain(HImage image, EdgeSearchingDefinition definition)
{
var swSearchEdge = new NotifyStopwatch("SearchEdge: " + definition.Name);
var esr = new EdgeSearchingResult
{
Definition = definition.DeepClone(),
Name = definition.Name
};
if (esr.Definition.ImageFilter_Disabled)
{
esr.Definition.ImageFilter = null;
}
if (esr.Definition.RegionExtractor_Disabled)
{
esr.Definition.RegionExtractor = null;
}
var rectImage = HDevelopExport.Singletone.ChangeDomainForRectangle(
image,
definition.Line,
definition.ROIWidth);
if (definition.Domain_SaveCacheImageEnabled)
{
rectImage.WriteImageOfTiffLzwOfCropDomain(
_cacheImageDir + "\\SearchEdges_" + definition.Name + "_1_Domain_Cropped.tif");
}
// RegionExtractor
HImage roiImage = null;
if (esr.Definition.RegionExtractor != null)
{
var rectDomain = rectImage.GetDomain();
HRegion roiDomain;
if (!esr.Definition.RegionExtractor_CropDomainEnabled)
{
var swRegionExtractor = new NotifyStopwatch("EdgeInspector.RegionExtractor: " + definition.Name);
roiDomain = esr.Definition.RegionExtractor.Extract(rectImage);
swRegionExtractor.Dispose();
if (definition.RegionExtractor_SaveCacheImageEnabled)
{
rectImage.WriteImageOfTiffLzwOfCropDomain(roiDomain,
_cacheImageDir + "\\SearchEdges_" + definition.Name + "_2_ROI.tif");
}
roiImage = rectImage.ReduceDomain(roiDomain);
rectImage.Dispose();
}
else
{
throw new NotImplementedException();
var domainOffsetRow1 = rectDomain.GetRow1();
var domainOffsetColumn1 = rectDomain.GetColumn1();
var croppedRectImage = rectImage.CropDomain();
var croppedRoiDomain = esr.Definition.RegionExtractor.Extract(croppedRectImage);
roiDomain = croppedRoiDomain.MoveRegion(domainOffsetRow1, domainOffsetColumn1);
throw new NotImplementedException();
}
}
else
{
roiImage = rectImage;
}
// ImageFilter
HImage filterImage = null;
if (esr.Definition.ImageFilter != null)
{
if (!esr.Definition.ImageFilter_CropDomainEnabled)
{
var swImageFilter = new NotifyStopwatch("EdgeInspector.ImageFilter: " + definition.Name);
filterImage = esr.Definition.ImageFilter.Process(roiImage);
swImageFilter.Dispose();
roiImage.Dispose();
if (definition.ImageFilter_SaveCacheImageEnabled)
{
var filterImageDomain = filterImage.GetDomain();
var offsetRow = filterImageDomain.GetRow1();
var offsetColumn = filterImageDomain.GetColumn1();
var cropDomain = filterImage.CropDomain();
cropDomain.WriteImageOfTiffLzw(_cacheImageDir + "\\SearchEdges_" + definition.Name +
"_3_ImageFilter_Cropped.tif");
var paintedImage = cropDomain.PaintGrayOffset(image, offsetRow, offsetColumn);
paintedImage.WriteImageOfJpeg(_cacheImageDir + "\\SearchEdges_" + definition.Name +
"_3_ImageFilter_PaintGrayOffset.jpg");
cropDomain.Dispose();
paintedImage.Dispose();
}
}
else
{
throw new NotImplementedException();
var roiDomain = roiImage.GetDomain();
int offsetX = 0;
int offsetY = 0;
offsetX = roiDomain.GetColumn1();
offsetY = roiDomain.GetRow1();
var croppedImage = roiImage.CropDomain();
var sw = new NotifyStopwatch("ImageFilter");
filterImage = esr.Definition.ImageFilter.Process(croppedImage);
sw.Dispose();
if (definition.ImageFilter_SaveCacheImageEnabled)
{
var cropDomain = filterImage.CropDomain();
cropDomain.WriteImageOfTiffLzw(_cacheImageDir + "\\SearchEdges_" + definition.Name +
"_3_ImageFilter_Cropped.tif");
cropDomain.Dispose();
var paintedImage = filterImage.PaintGrayOffset(image, offsetY, offsetX);
paintedImage.WriteImageOfJpeg(_cacheImageDir + "\\SearchEdges_" + definition.Name +
"_3_ImageFilter_PaintGrayOffset.jpg");
paintedImage.Dispose();
}
/* Line offsetLine = new Line(esd.Line.X1 - offsetX,
* esd.Line.Y1 - offsetY, esd.Line.X2 - offsetX,
* esd.Line.Y2 - offsetY);
*
* var line = esd.LineExtractor.FindLine(filterImage, offsetLine);
*
* var translatedLine = new Line(line.X1 + offsetX,
* line.Y1 + offsetY, line.X2 + offsetX,
* line.Y2 + offsetY);
*
* esr.EdgeLine = translatedLine;
*
* if (line.IsEmpty)
* {
* esr.IsNotFound = true;
* Debug.WriteLine("Edge not found: " + esr.Name);
* }*/
throw new NotImplementedException();
}
}
else
{
filterImage = roiImage;
}
var swLineExtractor = new NotifyStopwatch("EdgeInspector.LineExtractor: " + definition.Name);
var line = definition.LineExtractor.FindLine(filterImage, definition.Line);
swLineExtractor.Dispose();
if (line.IsEmpty)
{
esr.IsNotFound = true;
Debug.WriteLine("Edge not found: " + esr.Name);
}
esr.EdgeLine = line;
swSearchEdge.Dispose();
return(esr);
}
public CircleSearchingResult SearchCircle(HImage image, CircleSearchingDefinition definition)
{
var swSearchCircle = new NotifyStopwatch("SearchCircle: " + definition.Name);
var circleSearchingResult = new CircleSearchingResult
{
Definition = definition.DeepClone(),
Name = definition.Name,
// Index = index
};
if (definition.ImageFilter_Disabled)
{
definition.ImageFilter = null;
}
// if (circleDefinition.RegionExtractor_Disabled)
// circleDefinition.RegionExtractor = null;
var topLeftX = definition.CenterX - definition.OuterRadius;
var topLeftY = definition.CenterY - definition.OuterRadius;
var bottomRightX = definition.CenterX + definition.OuterRadius;
var bottomRightY = definition.CenterY + definition.OuterRadius;
var reg = new HRegion();
reg.GenRectangle1(topLeftY, topLeftX, bottomRightY, bottomRightX);
var reducedImage = image.ReduceDomain(reg);
reg.Dispose();
if (definition.Domain_SaveCacheImageEnabled)
{
reducedImage.WriteImageOfTiffLzwOfCropDomain(
_cacheImageDir + "\\SearchCircles_" + definition.Name + "_1_Domain.tif");
}
/* HRegion domain;
* if (circleDefinition.RegionExtractor != null)
* {
* throw new NotImplementedException();
* var oldDomain = reducedImage.GetDomain();
* domain = circleDefinition.RegionExtractor.Process(reducedImage);
* oldDomain.Dispose();
*
* if (circleDefinition.ImageFilter_SaveCacheImageEnabled)
* reducedImage
* .ReduceDomain(domain)
* .CropDomain()
* .ToBitmapSource()
* .SaveToTiff(_cacheImageDir + "\\SearchCircles_" + circleDefinition.Name + "_2_ROI.tif");
* }
* else
* {
* domain = reducedImage.GetDomain();
* }*/
HRegion domain = reducedImage.GetDomain();
int offsetX = domain.GetColumn1();
int offsetY = domain.GetRow1();
var roiImage = reducedImage.CropDomain();
HImage filterImage = null;
if (definition.ImageFilter != null)
{
var swImageFilter = new NotifyStopwatch("CircleInspector.ImageFilter: " + definition.Name);
filterImage = definition.ImageFilter.Process(roiImage);
swImageFilter.Dispose();
if (definition.ImageFilter_SaveCacheImageEnabled)
{
filterImage.WriteImageOfTiffLzwOfCropDomain(
_cacheImageDir + "\\SearchCircles_" + definition.Name + "_3_ImageFilter.tif");
//
var paintedImage = filterImage.PaintGrayOffset(image, offsetY, offsetX);
paintedImage.WriteImageOfJpeg(_cacheImageDir + "\\SearchCircles_" + definition.Name +
"_3_ImageFilter_PaintGrayOffset.jpg");
paintedImage.Dispose();
}
}
else
{
filterImage = roiImage;
}
var offsetCenterX = definition.CenterX - offsetX;
var offsetCenterY = definition.CenterY - offsetY;
var swFindCircle = new NotifyStopwatch("CircleInspector.FindCircle: " + definition.Name);
var circle = definition.CircleExtractor.FindCircle(filterImage,
offsetCenterX, offsetCenterY, definition.InnerRadius, definition.OuterRadius);
swFindCircle.Dispose();
if (circle.IsEmpty)
{
circleSearchingResult.HasError = true;
circleSearchingResult.IsNotFound = true;
// circleSearchingResult.Circle = new Circle(circleDefinition.CenterX, circleDefinition.CenterY);
}
else
{
var newCircle = new Circle(circle.CenterX + offsetX, circle.CenterY + offsetY, circle.Radius);
circleSearchingResult.Circle = newCircle;
}
swSearchCircle.Dispose();
return(circleSearchingResult);
}
