using HalconDotNet;
|
using Newtonsoft.Json;
|
using Newtonsoft.Json.Linq;
|
using OpenCvSharp;
|
using System;
|
using System.Collections.Generic;
|
using System.Data.Common;
|
using System.Diagnostics;
|
using System.Formats.Asn1;
|
using System.Linq;
|
using System.Text;
|
using System.Threading.Tasks;
|
using static System.Windows.Forms.AxHost;
|
|
namespace LB_VisionControl
|
{
|
public enum RoiType { None, Rectangle2, Circle, Ellipse, Segment };
|
|
public class ROI
|
{
|
// 你可以在父类中定义一些公共属性或方法
|
public string Type = "ROI"; // 类型标识符
|
|
public double Z = 0;
|
|
public double Column = 0;
|
public double X
|
{
|
get { return Column; }
|
set
|
{
|
double result = 0;
|
value = double.TryParse(value.ToString(), out result) ? result : 0;
|
Column = value;
|
}
|
}
|
|
public double Row = 0;
|
public double Y
|
{
|
get { return Row; }
|
set
|
{
|
double result = 0;
|
value = double.TryParse(value.ToString(), out result) ? result : 0;
|
Row = value;
|
}
|
}
|
|
public double Phi = 0;
|
public double Angle
|
{
|
get { return Phi * 180 / Math.PI; }
|
set
|
{
|
double result = 0;
|
value = double.TryParse(value.ToString(), out result) ? result : 0;
|
Phi = (value / 180 * Math.PI);
|
}
|
}
|
public double Rotation
|
{
|
get { return Phi; }
|
set
|
{
|
double result = 0;
|
value = double.TryParse(value.ToString(), out result) ? result : 0;
|
Phi = value;
|
}
|
}
|
|
public object Clone()
|
{ return MemberwiseClone(); }
|
}
|
[Serializable]
|
public class HRectangle2 : ROI
|
{
|
public HRectangle2() { Type = "HRectangle2"; }
|
|
//public HRectangle2(HTuple row, HTuple column, HTuple phi, HTuple length1, HTuple length2)
|
//{
|
// Type = "HRectangle2";
|
// this.Row = row.TupleReal();
|
// this.Column = column.TupleReal();
|
// this.Phi = phi.TupleReal();
|
// this.SemiLength1 = length1.TupleReal();
|
// this.SemiLength2 = length2.TupleReal();
|
//}
|
|
// 带私有参数的构造函数
|
[JsonConstructor] // 标记为用于反序列化
|
public HRectangle2(double X = 0, double Y = 0, double rotation = 0, double width = 800, double height = 800)
|
{
|
Type = "HRectangle2";
|
this.X = X;
|
this.Y = Y;
|
Rotation = rotation;
|
Width = width;
|
Height = height;
|
}
|
|
public HObject GetHObject()
|
{
|
HOperatorSet.GenRectangle2(out HObject hObject, (HTuple)Row, (HTuple)Column, (HTuple)Phi, (HTuple)SemiLength1, (HTuple)SemiLength2);
|
return hObject;
|
}
|
|
/// <summary>
|
/// 矩形宽度的一半
|
/// </summary>
|
public double SemiLength1 = 200;
|
/// <summary>
|
/// 矩形宽度
|
/// </summary>
|
public double Width
|
{
|
get { return SemiLength1 * 2; }
|
set
|
{
|
double result = 0;
|
value = double.TryParse(value.ToString(), out result) ? result : 0;
|
SemiLength1 = (value / 2.0);
|
}
|
}
|
|
/// <summary>
|
/// 矩形高度的一半
|
/// </summary>
|
public double SemiLength2 = 200;
|
public double Height
|
{
|
get { return SemiLength2 * 2; }
|
set
|
{
|
double result = 0;
|
value = double.TryParse(value.ToString(), out result) ? result : 0;
|
SemiLength2 = (value / 2.0);
|
}
|
}
|
|
public HPoint[] Corners
|
{
|
get
|
{
|
// 计算未旋转矩形的角点相对于中心的坐标
|
var corners = new HPoint[]
|
{
|
new HPoint(-Width / 2, -Height / 2), // 左上角
|
new HPoint(Width / 2, -Height / 2), // 右上角
|
new HPoint(Width / 2, Height / 2), // 右下角
|
new HPoint(-Width / 2, Height / 2) // 左下角
|
};
|
|
// 旋转矩形的角点
|
for (int i = 0; i < corners.Length; i++)
|
{
|
double x = corners[i].X;
|
double y = corners[i].Y;
|
|
// 旋转矩阵应用
|
double rotatedX = x * Math.Cos(Rotation) - y * Math.Sin(Rotation);
|
double rotatedY = x * Math.Sin(Rotation) + y * Math.Cos(Rotation);
|
|
// 移动到实际位置
|
corners[i] = new HPoint(rotatedX + X, rotatedY + Y);
|
}
|
|
return corners;
|
}
|
}
|
}
|
|
[Serializable]
|
public class HCircle : ROI
|
{
|
public HCircle() { Type = "HCircle"; }
|
|
//public HCircle(HTuple row, HTuple column, HTuple radius)
|
//{
|
// Type = "HCircle";
|
// this.Row = row.TupleReal();
|
// this.Column = column.TupleReal();
|
// this.Radius = radius.TupleReal();
|
//}
|
|
// 带私有参数的构造函数
|
[JsonConstructor] // 标记为用于反序列化
|
public HCircle(double X = 0, double Y = 0, double radius = 100)
|
{
|
Type = "HCircle";
|
this.X = X;
|
this.Y = Y;
|
Radius = radius;
|
}
|
|
public double Radius = 100;
|
public double Diameter
|
{
|
get { return Radius * 2; }
|
set
|
{
|
double result = 0;
|
value = double.TryParse(value.ToString(), out result) ? result : 0;
|
Radius = value / 2.0;
|
}
|
}
|
}
|
|
public class HEllipse : ROI
|
{
|
public HEllipse() { Type = "HEllipse"; }
|
|
// 带私有参数的构造函数
|
[JsonConstructor] // 标记为用于反序列化
|
public HEllipse(double x, double y, double phi, double radius1, double radius2, double start_angle = 0, double end_angle = Math.PI)
|
{
|
Type = "HEllipse";
|
this.X = x;
|
this.Y = y;
|
this.Phi = phi;
|
Radius1 = radius1;
|
Radius2 = radius2;
|
StartAngle = start_angle;
|
EndAngle = end_angle;
|
}
|
|
public double Radius1 = 100;
|
public double Radius2 = 100;
|
public double StartAngle = 0;
|
public double EndAngle = Math.PI;
|
}
|
|
[Serializable]
|
public class HSegment : ROI
|
{
|
public HSegment() { Type = "HSegment"; }
|
|
// 带私有参数的构造函数
|
[JsonConstructor] // 标记为用于反序列化
|
public HSegment(double startX = 0, double startY = 0, double endX = 0, double endY = 0)
|
{
|
Type = "HSegment";
|
StartX = startX;
|
StartY = startY;
|
EndX = endX;
|
EndY = endY;
|
}
|
|
public HSegment(HPoint startPoint, HPoint endPoint)
|
{
|
Type = "HSegment";
|
BeginRow = startPoint.Row;
|
BeginColumn = startPoint.Column;
|
EndRow = endPoint.Row;
|
EndColumn = endPoint.Column;
|
}
|
|
public HObject GetHObject()
|
{
|
HOperatorSet.GenRegionLine(out HObject hObject, (HTuple)BeginRow, (HTuple)BeginColumn, (HTuple)EndRow, (HTuple)EndColumn);
|
return hObject;
|
}
|
|
public HPoint StartPoint
|
{
|
get { return new HPoint(BeginColumn, BeginRow); }
|
set { BeginRow = value.Row; BeginColumn = value.Column; }
|
}
|
|
public HPoint EndPoint
|
{
|
get { return new HPoint(EndColumn, EndRow); }
|
set { EndRow = value.Row; EndColumn = value.Column; }
|
}
|
|
public double BeginColumn = 0;
|
public double StartX
|
{
|
get { return BeginColumn; }
|
set
|
{
|
double result = 0;
|
value = double.TryParse(value.ToString(), out result) ? result : 0;
|
BeginColumn = value;
|
}
|
}
|
|
public double BeginRow = 0;
|
public double StartY
|
{
|
get { return BeginRow; }
|
set
|
{
|
double result = 0;
|
value = double.TryParse(value.ToString(), out result) ? result : 0;
|
BeginRow = value;
|
}
|
}
|
|
public double EndColumn = 100;
|
public double EndX
|
{
|
get { return EndColumn; }
|
set
|
{
|
double result = 0;
|
value = double.TryParse(value.ToString(), out result) ? result : 0;
|
EndColumn = value;
|
}
|
}
|
|
public double EndRow = 100;
|
public double EndY
|
{
|
get
|
{
|
return EndRow;
|
}
|
set
|
{
|
double result = 0;
|
value = double.TryParse(value.ToString(), out result) ? result : 0;
|
EndRow = value;
|
}
|
}
|
|
public double MidX
|
{
|
get { return (StartX + EndX) / 2; }
|
}
|
|
public double MidY
|
{
|
get { return (StartY + EndY) / 2; }
|
}
|
|
public double Length
|
{
|
get { return Math.Sqrt(Math.Pow(StartX - EndX, 2) + Math.Pow(StartX - EndY, 2)); }
|
}
|
}
|
|
[Serializable]
|
public class HLine : ROI
|
{
|
public HLine() { Type = "HLine"; }
|
|
// 带私有参数的构造函数
|
[JsonConstructor] // 标记为用于反序列化
|
public HLine(double x = 0, double y = 0, double phi = 0)
|
{
|
Type = "HLine";
|
X = x;
|
Y = y;
|
Phi = phi;
|
}
|
|
public HLine(HPoint point, double phi = 0)
|
{
|
Type = "HLine";
|
X = point.Row;
|
Y = point.Column;
|
Phi = phi;
|
}
|
}
|
|
[Serializable]
|
public class HPoint : ROI
|
{
|
public HPoint() { Type = "HPoint"; }
|
|
// 带私有参数的构造函数
|
[JsonConstructor] // 标记为用于反序列化
|
public HPoint(double x, double y, double z = 0)
|
{
|
Type = "HPoint";
|
X = x;
|
Y = y;
|
Z = z;
|
}
|
|
public HPoint(OpenCvSharp.Point point)
|
{
|
Type = "HPoint";
|
X = point.X;
|
Y = point.Y;
|
}
|
|
public HPoint(HPoint point)
|
{
|
Type = "HPoint";
|
X = point.X;
|
Y = point.Y;
|
}
|
|
public HObject GetHObject()
|
{
|
HOperatorSet.GenRegionPoints(out HObject hObject, (HTuple)Row, (HTuple)Column);
|
return hObject;
|
}
|
|
public Point2d ToPoint2d() { return new Point2d(X, Y); }
|
}
|
|
public class ROIConverter : JsonConverter
|
{
|
public override bool CanConvert(Type objectType)
|
{
|
return objectType == typeof(ROI);
|
}
|
|
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
|
{
|
JObject jo = JObject.Load(reader); // 只调用一次 Load(reader)
|
if (jo != null)
|
{
|
var type = jo["Type"]?.ToString(); // 获取类型标识符
|
|
// 根据类型标识符反序列化为具体类型
|
switch (type)
|
{
|
case "ROI":
|
return jo.ToObject<ROI>();
|
case "HRectangle2":
|
return jo.ToObject<HRectangle2>();
|
case "HCircle":
|
return jo.ToObject<HCircle>();
|
case "HSegment":
|
return jo.ToObject<HSegment>();
|
case "HLine":
|
return jo.ToObject<HLine>();
|
case "HPoint":
|
return jo.ToObject<HPoint>();
|
default:
|
// 其他类型的处理方式
|
throw new JsonSerializationException($"Unknown type: {type}");
|
}
|
}
|
return null;
|
}
|
|
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
|
{
|
try
|
{
|
if (value != null)
|
{
|
// 创建一个 JObject 来序列化 ROI 对象
|
JObject jo = JObject.FromObject(value, serializer);
|
var type = value.GetType().Name;
|
// 根据类型标识符反序列化为具体类型
|
switch (type)
|
{
|
case "ROI":
|
ROI roi = value as ROI;
|
if (roi == null)
|
throw new JsonSerializationException($"Convert {type} to null");
|
|
// 开始写入 JSON 对象
|
writer.WriteStartObject();
|
|
writer.WritePropertyName("Type");
|
writer.WriteValue(roi.Type);
|
|
// 结束对象
|
writer.WriteEndObject();
|
break;
|
case "HRectangle2":
|
HRectangle2 hRectangle2 = value as HRectangle2;
|
if (hRectangle2 == null)
|
throw new JsonSerializationException($"Convert {type} to null");
|
|
// 开始写入 JSON 对象
|
writer.WriteStartObject();
|
|
writer.WritePropertyName("Type");
|
writer.WriteValue(hRectangle2.Type);
|
|
writer.WritePropertyName("X");
|
writer.WriteValue(hRectangle2.X);
|
|
writer.WritePropertyName("Y");
|
writer.WriteValue(hRectangle2.Y);
|
|
writer.WritePropertyName("Rotation");
|
writer.WriteValue(hRectangle2.Rotation);
|
|
writer.WritePropertyName("Width");
|
writer.WriteValue(hRectangle2.Width);
|
|
writer.WritePropertyName("Height");
|
writer.WriteValue(hRectangle2.Height);
|
|
// 结束对象
|
writer.WriteEndObject();
|
break;
|
case "HCircle":
|
HCircle hCircle = value as HCircle;
|
if (hCircle == null)
|
throw new JsonSerializationException($"Convert {type} to null");
|
|
// 开始写入 JSON 对象
|
writer.WriteStartObject();
|
|
writer.WritePropertyName("Type");
|
writer.WriteValue(hCircle.Type);
|
|
writer.WritePropertyName("X");
|
writer.WriteValue(hCircle.X);
|
|
writer.WritePropertyName("Y");
|
writer.WriteValue(hCircle.Y);
|
|
writer.WritePropertyName("Radius");
|
writer.WriteValue(hCircle.Radius);
|
|
// 结束对象
|
writer.WriteEndObject();
|
break;
|
case "HPoint":
|
HPoint hPoint = value as HPoint;
|
if (hPoint == null)
|
throw new JsonSerializationException($"Convert {type} to null");
|
|
// 开始写入 JSON 对象
|
writer.WriteStartObject();
|
|
writer.WritePropertyName("Type");
|
writer.WriteValue(hPoint.Type);
|
|
writer.WritePropertyName("X");
|
writer.WriteValue(hPoint.X);
|
|
writer.WritePropertyName("Y");
|
writer.WriteValue(hPoint.Y);
|
|
// 结束对象
|
writer.WriteEndObject();
|
break;
|
case "HSegment":
|
HSegment hSegment = value as HSegment;
|
if (hSegment == null)
|
throw new JsonSerializationException($"Convert {type} to null");
|
|
// 开始写入 JSON 对象
|
writer.WriteStartObject();
|
|
writer.WritePropertyName("Type");
|
writer.WriteValue(hSegment.Type);
|
|
writer.WritePropertyName("StartX");
|
writer.WriteValue(hSegment.StartX);
|
|
writer.WritePropertyName("StartY");
|
writer.WriteValue(hSegment.StartY);
|
|
writer.WritePropertyName("EndX");
|
writer.WriteValue(hSegment.EndX);
|
|
writer.WritePropertyName("EndY");
|
writer.WriteValue(hSegment.EndY);
|
|
// 结束对象
|
writer.WriteEndObject();
|
break;
|
case "HLine":
|
default:
|
// 其他类型的处理方式
|
throw new JsonSerializationException($"Unsupport convert {type}");
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
// 输出异常信息进行调试
|
Debug.WriteLine($"Error: {ex.Message}");
|
}
|
}
|
}
|
}
|
