public static void UpdateRelativeCoordinate(this PartSearchingDefinition def,
IRelativeCoordinate relativeCoordinate)
{
var p1 = def.RoiRelativeLine.GetPoint1();
var p2 = def.RoiRelativeLine.GetPoint2();
var actualP1 = relativeCoordinate.GetOriginalPoint(p1);
var actualP2 = relativeCoordinate.GetOriginalPoint(p2);
var roiLine = new Line {
X1 = actualP1.X, Y1 = actualP1.Y, X2 = actualP2.X, Y2 = actualP2.Y
};
def.RoiLine = roiLine;
//
var p1a = def.AreaRelativeLine.GetPoint1();
var p2b = def.AreaRelativeLine.GetPoint2();
var actualP1a = relativeCoordinate.GetOriginalPoint(p1a);
var actualP2b = relativeCoordinate.GetOriginalPoint(p2b);
var areaLine = new Line {
X1 = actualP1a.X, Y1 = actualP1a.Y, X2 = actualP2b.X, Y2 = actualP2b.Y
};
def.AreaLine = areaLine;
}
public static void UpdateRelativeCoordinate(this EdgeSearchingDefinition def,
IRelativeCoordinate relativeCoordinate)
{
if (def.RelativeLine.IsEmpty)
{
return;
}
// if (Math.Abs(def.RelativeLine.X1) < 0.000001 ||
// Math.Abs(def.RelativeLine.Y1) < 0.000001 ||
// Math.Abs(def.RelativeLine.X2) < 0.000001 ||
// Math.Abs(def.RelativeLine.Y2) < 0.000001)
// { return; }
var p1 = def.RelativeLine.GetPoint1();
var p2 = def.RelativeLine.GetPoint2();
var actualP1 = relativeCoordinate.GetOriginalPoint(p1);
var actualP2 = relativeCoordinate.GetOriginalPoint(p2);
def.StartX = actualP1.X;
def.StartY = actualP1.Y;
def.EndX = actualP2.X;
def.EndY = actualP2.Y;
}
public static void UpdateRelativeCoordinate(this IEnumerable <SurfaceDefinition> definitions,
IRelativeCoordinate relativeCoordinate)
{
foreach (var esd in definitions)
{
esd.UpdateRelativeCoordinate(relativeCoordinate);
}
}
public static void UpdateRelativeCoordinate(this CircleSearchingResult circleResult,
IRelativeCoordinate relativeCoordinate)
{
var actualCenterPoint = circleResult.Circle.GetCenterPoint();
var relativePoint = relativeCoordinate.GetRelativePoint(actualCenterPoint);
circleResult.RelativeCircle = new Circle(relativePoint, circleResult.Circle.Radius);
}
public static void UpdateRelativeCoordinate(this IEnumerable <CircleSearchingDefinition> circleResults,
IRelativeCoordinate relativeCoordinate)
{
foreach (var circleResult in circleResults)
{
circleResult.UpdateRelativeCoordinate(relativeCoordinate);
}
}
public static void UpdateRelativeCoordinate(this SurfacePartDefinition def,
IRelativeCoordinate relativeCoordinate)
{
if (def.RoiRelativeRect == null)
{
return;
}
var rect = def.RoiRelativeRect.UpdateRelativeCoordinate(relativeCoordinate);
def.RoiActualRect = rect;
}
public static void UpdateRelativeCoordinate(this RegionTargetDefinition definition,
IRelativeCoordinate relativeCoordinate)
{
if (definition.RoiRelativeLine.IsEmpty)
{
return;
}
var actualLine = definition.RoiRelativeLine.UpdateRelativeCoordinate(relativeCoordinate);
definition.RoiActualLine = actualLine;
}
public static void UpdateRelativeCoordinate(this SurfaceDefinition def,
IRelativeCoordinate relativeCoordinate)
{
foreach (var includeRegion in def.IncludeParts)
{
includeRegion.UpdateRelativeCoordinate(relativeCoordinate);
}
foreach (var excludeRegion in def.ExcludeParts)
{
excludeRegion.UpdateRelativeCoordinate(relativeCoordinate);
}
}
public static Line UpdateRelativeCoordinate(this Line relativeLine,
IRelativeCoordinate relativeCoordinate)
{
var p1 = relativeLine.GetPoint1();
var p2 = relativeLine.GetPoint2();
var actualP1 = relativeCoordinate.GetOriginalPoint(p1);
var actualP2 = relativeCoordinate.GetOriginalPoint(p2);
var actualLine = new Line {
X1 = actualP1.X, Y1 = actualP1.Y, X2 = actualP2.X, Y2 = actualP2.Y
};
return(actualLine);
}
public static void UpdateRelativeCoordinate(this CircleSearchingDefinition csd,
IRelativeCoordinate coordinate)
{
if (csd.BaselineX > 0 || csd.BaselineY > 0)
{
var relativeVector = new Vector(csd.BaselineX * 1000.0 / 16.0, csd.BaselineY * 1000.0 / 16.0);
var originalVector = coordinate.GetOriginalVector(relativeVector);
csd.CenterX = originalVector.X;
csd.CenterY = originalVector.Y;
}
else
{
csd.CenterX = csd.CenterX;
csd.CenterY = csd.CenterY;
}
}
public static IRectangle2 UpdateRelativeCoordinate(this IRectangle2 rectangle2,
IRelativeCoordinate relativeCoordinate)
{
var relativeCenterVector = new Vector(rectangle2.X, rectangle2.Y);
var actualCenterVector = relativeCoordinate.GetOriginalVector(relativeCenterVector);
var relativeRect = new Rectangle2
{
X = actualCenterVector.X,
Y = actualCenterVector.Y,
Angle = relativeCoordinate.GetCoordinateAngle() + rectangle2.Angle,
HalfWidth = rectangle2.HalfWidth,
HalfHeight = rectangle2.HalfHeight
};
return(relativeRect);
}
public static MeasurementInfo GetMeasurementInfo(this Line line, IRelativeCoordinate coordinate)
{
Vector relativeP1 = coordinate.GetRelativeVector(line.GetPoint1().ToVector());
Vector relativeP2 = coordinate.GetRelativeVector(line.GetPoint2().ToVector());
var measurement = new MeasurementInfo
{
StartPointX = line.GetPoint1().X,
StartPointY = line.GetPoint1().Y,
EndPointX = line.GetPoint2().X,
EndPointY = line.GetPoint2().Y,
Value = line.GetLength(),
ValueActualValue = line.GetLength().ToMillimeterFromPixel(16),
StartPointXActualValue = relativeP1.X.ToMillimeterFromPixel(16),
StartPointYActualValue = relativeP1.Y.ToMillimeterFromPixel(16),
EndPointXActualValue = relativeP2.X.ToMillimeterFromPixel(16),
EndPointYActualValue = relativeP2.Y.ToMillimeterFromPixel(16),
};
return(measurement);
}
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 static void ChangeOriginOffsetUsingActual(this IRelativeCoordinate coordinate, Vector actualVector)
{
var relativeVector = coordinate.GetRelativeVector(actualVector);
coordinate.OriginOffset = relativeVector;
}
public static void ChangeOriginOffsetUsingRelative(this IRelativeCoordinate coordinate, Point relativePoint)
{
coordinate.ChangeOriginOffsetUsingRelative(relativePoint.ToVector());
}
public static void ChangeOriginOffsetUsingActual(this IRelativeCoordinate coordinate, Point actualPoint)
{
coordinate.ChangeOriginOffsetUsingActual(actualPoint.ToVector());
}
public static void ChangeOriginOffsetUsingRelative(this IRelativeCoordinate coordinate, Vector relativeVector)
{
coordinate.OriginOffset = relativeVector;
}
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 static Point GetOriginalPoint(this IRelativeCoordinate coordinate, Point relativePoint)
{
return(coordinate.GetOriginalVector(relativePoint.ToVector()).ToPoint());
}
