void DealComprehensive_Camera5_event(TriggerSource_enum trigerSource_e, int i)
{
g_MtCamera5.WaitOne();
try
{
//同一流程内，第几次拍照
StateComprehensive_enum stateComprehensive_e = DealComprehensiveResult5.D_I.DealComprehensiveResultFun(trigerSource_e, i);
ShowInfo(trigerSource_e, stateComprehensive_e, 5, i);
}
catch (Exception ex)
{
Log.L_I.WriteError("MainWindow", ex);
}
finally
{
g_MtCamera5.ReleaseMutex();
}
}
/// <summary>
///
/// </summary>
/// <param name="htResult"></param>
/// <returns></returns>
public override StateComprehensive_enum DealComprehensiveResultFun3(
TriggerSource_enum trigerSource_e, int index, out Hashtable htResult)
{
#region 定义
htResult = g_HtResult;
//int pos = 3;
bool blResult = true;
Stopwatch sw = new Stopwatch();
sw.Restart();
#endregion 定义
try
{
//标定旋转中心
StateComprehensive_enum stateComprehensive_e = g_BaseDealComprehensive.DealComprehensivePosNoDisplay(
g_UCDisplayCamera, g_HtUCDisplay, Pos_enum.Pos1, out htResult);
BaseResult result = htResult[Camera2Match1] as BaseResult;
if (!DealTypeResult(result))
{
ShowAlarm("精定位相机2标定旋转中心拍照NG!");
LogicRobot.L_I.WriteRobotCMD(Protocols.BotCmd_PreciseNG);
MessageBox.Show("标定旋转中心失败，请重新标定!", "提示");
return(StateComprehensive_enum.False);
}
Pt2MarkRC.DblValue1 = result.X;
Pt2MarkRC.DblValue2 = result.Y;
CalibRC();
return(StateComprehensive_enum.True);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(StateComprehensive_enum.False);
}
finally
{
#region 显示和日志记录
Display(Pos_enum.Pos1, htResult, blResult, sw);
#endregion 显示和日志记录
}
}
public override StateComprehensive_enum DealComprehensiveResultFun2(
TriggerSource_enum trigerSource_e, int index, out Hashtable htResult)
{
#region 定义
htResult = g_HtResult;
PosNow_e = Pos_enum.Pos2; //当前位置
bool blResult = true; //结果是否正确
Stopwatch sw = new Stopwatch();
sw.Restart();
#endregion 定义
try
{
//标定基准位
StateComprehensive_enum stateComprehensive_e = g_BaseDealComprehensive.DealComprehensivePosNoDisplay(
g_UCDisplayCamera, g_HtUCDisplay, Pos_enum.Pos1, out htResult);
BaseResult result = htResult[Camera1Match1] as BaseResult;
if (!DealTypeResult(result))
{
ShowAlarm("精定位相机1第二次拍照NG!");
LogicRobot.L_I.WriteRobotCMD(Protocols.BotCmd_PreciseNG);
return(StateComprehensive_enum.False);
}
Pt2Mark1.DblValue1 = result.X;
Pt2Mark1.DblValue2 = result.Y;
Camera1Done = true;
CalibDual(index);
return(StateComprehensive_enum.True);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(StateComprehensive_enum.False);
}
finally
{
#region 显示和日志记录
Display(Pos_enum.Pos1, htResult, blResult, sw);
#endregion 显示和日志记录
}
}
/// <summary>
///
/// </summary>
/// <param name="htResult"></param>
/// <returns></returns>
public override StateComprehensive_enum DealComprehensiveResultFun1(TriggerSource_enum trigerSource_e, int station, out Hashtable htResult)
{
#region 定义
htResult = g_HtResult;
//int pos = 1;
bool blResult = true;
Stopwatch sw = new Stopwatch();
sw.Restart();
#endregion 定义
try
{
if (ParStateSoft.StateMachine_e == StateMachine_enum.NullRun)
{
return(StateComprehensive_enum.True);
}
StateComprehensive_enum stateComprehensive_e = g_BaseDealComprehensive.DealComprehensivePosNoDisplay(g_UCDisplayCamera, g_HtUCDisplay, Pos_enum.Pos1, out htResult);
BaseResult result = (BaseResult)htResult[strCamera3Match1];
if (result.Num != 1)
{
ShowAlarm("相机3--双目定位拍照NG!");
LogicRobot.L_I.WriteRobotCMD(PCToRbt.PRP_PreciseNG);
return(StateComprehensive_enum.False);
}
biyMark2[(int)PtType_Binary.AutoMark] = new Point2D(result.X, result.Y);
ShowState(string.Format("双目自动流程Mark2像素:X_{0},Y_{1}", result.X, result.Y));
CalcAutoStPos(station);
return(StateComprehensive_enum.True);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(StateComprehensive_enum.False);
}
finally
{
#region 显示和日志记录
Display(Pos_enum.Pos1, htResult, blResult, sw);
#endregion 显示和日志记录
}
}
/// <summary>
/// 触发拍照并传入区分参考数组
/// </summary>
/// <param name="trigerSource_e"></param>
/// <param name="i"></param>
/// <param name="index"></param>
protected virtual void DealComprehensive_Camera8_event(TriggerSource_enum trigerSource_e, int i, int[] index)
{
g_MtCamera8.WaitOne();
try
{
//同一流程内，第几次拍照
StateComprehensive_enum stateComprehensive_e = DealComprehensiveResult8.DealComprehensiveResultFun(trigerSource_e, i, index);
ShowInfo(trigerSource_e, stateComprehensive_e, 8, i);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
}
finally
{
g_MtCamera8.ReleaseMutex();
}
}
/// <summary>
/// 传入参考数组
/// </summary>
/// <param name="trigerSource_e"></param>
/// <param name="i"></param>
/// <param name="index"></param>
/// <returns></returns>
public StateComprehensive_enum DealComprehensiveResultFun(TriggerSource_enum trigerSource_e, int i, int[] index)
{
try
{
Hashtable htResult = null;
StateComprehensive_enum stateComprehensive_e = StateComprehensive_enum.False;
switch (i)
{
case 1:
stateComprehensive_e = DealComprehensiveResultFun1(trigerSource_e, index, out htResult);
break;
case 2:
stateComprehensive_e = DealComprehensiveResultFun2(trigerSource_e, index, out htResult);
break;
case 3:
stateComprehensive_e = DealComprehensiveResultFun3(trigerSource_e, index, out htResult);
break;
case 4:
stateComprehensive_e = DealComprehensiveResultFun4(trigerSource_e, index, out htResult);
break;
case 5:
stateComprehensive_e = DealComprehensiveResultFun5(trigerSource_e, index, out htResult);
break;
case 6:
stateComprehensive_e = DealComprehensiveResultFun6(trigerSource_e, index, out htResult);
break;
}
string cellError = "";
GetErrorCell(htResult, i, out cellError);//显示错误信息
return(stateComprehensive_e);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(StateComprehensive_enum.False);
}
}
/// <summary>
///
/// </summary>
/// <param name="htResult"></param>
/// <returns></returns>
public override StateComprehensive_enum DealComprehensiveResultFun3(TriggerSource_enum trigerSource_e, int station, out Hashtable htResult)
{
#region 定义
htResult = g_HtResult;
//int pos = 3;
bool blResult = true;//结果是否正确
Stopwatch sw = new Stopwatch();
sw.Restart();
#endregion 定义
try
{
if (ParStateSoft.StateMachine_e == StateMachine_enum.NullRun)
{
return(StateComprehensive_enum.True);
}
StateComprehensive_enum stateComprehensive_e = g_BaseDealComprehensive.DealComprehensivePosNoDisplay(g_UCDisplayCamera, g_HtUCDisplay, Pos_enum.Pos1, out htResult);
BaseResult result = (BaseResult)htResult[strCamera3Match1];
if (result.Num != 1)
{
ShowAlarm("相机3--双目定位标定流程拍照NG!");
LogicPLC.L_I.WriteRegData1((int)DataRegister1.PCAlarm, (int)PCAlarm_Enum.标定失败);
return(StateComprehensive_enum.False);
}
biyMark2[(int)PtType_Binary.Calib] = new Point2D(result.X, result.Y);
ShowState(string.Format("双目标定流程Mark2像素:X_{0},Y_{1}", result.X, result.Y));
CalcCalibPos(station);
return(StateComprehensive_enum.True);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(StateComprehensive_enum.False);
}
finally
{
#region 显示和日志记录
Display(Pos_enum.Pos1, htResult, blResult, sw);
#endregion 显示和日志记录
}
}
/// <summary>
/// 开始进行皮带线扫描
/// </summary>
/// <param name="htResult"></param>
public void BeltScan(out Hashtable htResult)
{
htResult = null;
try
{
StateComprehensive_enum stateComprehensive_e = g_BaseDealComprehensive.DealComprehensivePosNoDisplay(
g_UCDisplayCamera, g_HtUCDisplay, Pos_enum.Pos1, out htResult);
BaseResult result = (BaseResult)htResult[strCamera8Match1];
if (result.X * result.Y != 0)
{
LogicPLC.L_I.WriteRegData1((int)DataRegister1.StopBelt, 1);
StopBelt?.Invoke();
}
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
}
}
public void FinishPhotoRobot(int cameraNo, int pos, StateComprehensive_enum stateComprehensive_e)
{
if (ParSetRobot.P_I.TypeRobot_e == TypeRobot_enum.Null)
{
return;
}
int result = 0;
if (stateComprehensive_e == StateComprehensive_enum.False)
{
result = 2;
}
else
{
result = 1;
}
//添加机器人拍照正确或错误处理
//
}
/// <summary>
/// 背光不规则区域基准值保存
/// </summary>
/// <param name="index"></param>
/// <param name="cellName"></param>
/// <param name="htResult"></param>
/// <returns></returns>
public StateComprehensive_enum CalibStdValue(int index, string cellName, out Hashtable htResult)
{
htResult = null;
try
{
StateComprehensive_enum stateComprehensive_e = g_BaseDealComprehensive.DealComprehensivePosNoDisplay(
g_UCDisplayCamera, g_HtUCDisplay, 1, out htResult);
ResultBlob resultBlob = (ResultBlob)htResult[cellName];
if (!DealTypeResult(resultBlob))
{
ShowState(string.Format("精定位自动标定第{0}点拍照失败", index + 1));
return(StateComprehensive_enum.False);
}
//保存当前匹配结果
pt2Calib[index] = new Point2D(resultBlob.X, resultBlob.Y);
if (index == 1)
{
LogicRobot.L_I.WriteRobotCMD(ModelParams.cmd_PreciseCalib2);
//第二次的话保存基准值到算子中
if (!(RecordStdValue(cellName, pt2Calib[0], pt2Calib[1])))
{
return(StateComprehensive_enum.False);
}
}
else
{
ShowState(string.Format("相机{0}基准值标定第1点计算成功", g_NoCamera));
LogicRobot.L_I.WriteRobotCMD(ModelParams.cmd_PreciseCalib1);
}
return(StateComprehensive_enum.True);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(StateComprehensive_enum.False);
}
}
public override StateComprehensive_enum DealComprehensiveResultFun2(TriggerSource_enum trigerSource_e, int station, out Hashtable htResult)
{
#region 定义
htResult = g_HtResult;
//int pos = 2;
bool blResult = true;
Stopwatch sw = new Stopwatch();
sw.Restart();
#endregion 定义
try
{
BaseDealComprehensiveResult.BlFinishPos2_Cam2 = false;
StateComprehensive_enum stateComprehensive_e = g_BaseDealComprehensive.DealComprehensivePosNoDisplay(g_UCDisplayCamera, g_HtUCDisplay, Pos_enum.Pos1, out htResult);
BaseResult result = (BaseResult)htResult[strCamera2Match1];
if (result.Num != 1)
{
ShowAlarm("相机2--双目定位精度验证Mark已出视野!");
return(StateComprehensive_enum.True);
}
biyMark1[(int)PtType_Binary.PreciseConfirmMark] = new Point2D(result.X, result.Y);
ShowState(string.Format("双目精度验证流程Mark1像素:X_{0},Y_{1}", result.X, result.Y));
BaseDealComprehensiveResult.BlFinishPos2_Cam2 = true;
return(StateComprehensive_enum.True);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(StateComprehensive_enum.False);
}
finally
{
#region 显示和日志记录
Display(Pos_enum.Pos1, htResult, blResult, sw);
#endregion 显示和日志记录
}
}
/// <summary>
/// 传入参考数组
/// </summary>
/// <param name="trigerSource_e"></param>
/// <param name="i"></param>
/// <param name="index"></param>
/// <returns></returns>
public StateComprehensive_enum DealComprehensiveResultFun(TriggerSource_enum trigerSource_e, int i, int[] index)
{
try
{
Hashtable hashtable = null;
StateComprehensive_enum stateComprehensive_e = StateComprehensive_enum.False;
switch (i)
{
case 1:
stateComprehensive_e = DealComprehensiveResultFun1(trigerSource_e, index, out hashtable);
break;
case 2:
stateComprehensive_e = DealComprehensiveResultFun2(trigerSource_e, index, out hashtable);
break;
case 3:
stateComprehensive_e = DealComprehensiveResultFun3(trigerSource_e, index, out hashtable);
break;
case 4:
stateComprehensive_e = DealComprehensiveResultFun4(trigerSource_e, index, out hashtable);
break;
case 5:
stateComprehensive_e = DealComprehensiveResultFun5(trigerSource_e, index, out hashtable);
break;
}
g_UCResult.AddResult(hashtable, g_NoCamera);
GetErrorCell(hashtable);//显示错误信息
return(stateComprehensive_e);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(StateComprehensive_enum.False);
}
}
/// <summary>
/// 保存对应单元格的匹配结果
/// </summary>
/// <param name="index">当前坐标对应的数组索引</param>
/// <param name="cellName">M直线算子序号</param>
/// <param name="pos">拍照位置</param>
/// <param name="htResult"></param>
/// <returns></returns>
public bool SaveMatchResult(int index, string cellName, Pos_enum pos, out Hashtable htResult)
{
htResult = null;
try
{
StateComprehensive_enum stateComprehensive_e = g_BaseDealComprehensive.DealComprehensivePosNoDisplay(g_UCDisplayCamera, g_HtUCDisplay, pos, out htResult);
ResultCrossLines result = htResult[cellName] as ResultCrossLines;
if (!DealTypeResult(result))
{
return(false);
}
//保存当前匹配结果
pt2MarkArray[index].DblValue1 = result.X;
pt2MarkArray[index].DblValue2 = result.Y;
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(false);
}
return(true);
}
public override StateComprehensive_enum DealComprehensiveResultFun4(TriggerSource_enum trigerSource_e, out Hashtable htResult)
{
#region 定义
htResult = g_HtResult;
//int pos = 4;
bool blResult = true;
Stopwatch sw = new Stopwatch();
sw.Restart();
#endregion 定义
try
{
StateComprehensive_enum stateComprehensive_e = g_BaseDealComprehensive.DealComprehensivePosNoDisplay(g_UCDisplayCamera, g_HtUCDisplay, Pos_enum.Pos1, out htResult);
BaseResult result = (BaseResult)htResult[strCamera2Match1];
if (!DealTypeResult(result))
{
ShowAlarm("相机2--双目标定旋转中心流程拍照NG!");
ShowWinError_Invoke("旋转中心标定失败，请重新标定!");
LogicRobot.L_I.WriteRobotCMD(PCToRbt.PRP_FinishCalibRC);
return(StateComprehensive_enum.False);
}
CalibData_L.Add(new Point2D(result.X, result.Y));
DealCalibRC(CalibData_L.Count);
return(StateComprehensive_enum.True);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(StateComprehensive_enum.False);
}
finally
{
#region 显示和日志记录
Display(Pos_enum.Pos1, htResult, blResult, sw);
#endregion 显示和日志记录
}
}
/// <summary>
/// 位置1处理
/// </summary>
/// <param name="hashtable"></param>
/// <returns></returns>
public override StateComprehensive_enum DealComprehensiveResultFun1(TriggerSource_enum trigerSource_e, out Hashtable htResult)
{
htResult = null;
int pos = 1;
sw_Tact.Restart();
try
{
StateComprehensive_enum stateComprehensive_e = StateComprehensive_enum.Null;
return(stateComprehensive_e);
}
catch (Exception ex)
{
LogicPLC.L_I.FinishPhoto(g_regClearCamera + g_regFinishPhoto, 2);
Log.L_I.WriteError(NameClass, ex);
return(StateComprehensive_enum.False);
}
finally
{
//记录当前整体节拍
RecordTact(g_NoCamera, pos, htResult);
g_DealComprehensiveBase.DisplayComprehensivePos(g_UCDisplayCamera, g_HtUCDisplay, pos, htResult);
}
}
/// <summary>
/// 显示信息
/// </summary>
/// <param name="trigerSource_e"></param>
/// <param name="stateComprehensive_e"></param>
/// <param name="i"></param>
/// <param name="j"></param>
public void ShowInfo(TriggerSource_enum trigerSource_e, StateComprehensive_enum stateComprehensive_e, int i, int j)
{
try
{
switch (stateComprehensive_e)
{
case StateComprehensive_enum.False:
ShowAlarm(trigerSource_e.ToString() + "触发相机" + i.ToString() + "第" + j.ToString() + "次图像处理异常！");
break;
case StateComprehensive_enum.NGTrue:
ShowAlarm(trigerSource_e.ToString() + "触发相机" + i.ToString() + "第" + j.ToString() + "次图像处理异常！但不产生警报！");
break;
case StateComprehensive_enum.True:
ShowState(trigerSource_e.ToString() + "触发相机" + i.ToString() + "第" + j.ToString() + "次图像处理成功！");
break;
}
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
}
}
/// <summary>
/// 接收触发信号，计算校准
/// </summary>
/// <param name="trigerSource_e"></param>
/// <param name="i"></param>
/// <returns></returns>
public StateComprehensive_enum DealComprehensiveResultFun_Calib(TriggerSource_enum trigerSource_e, int i, out Hashtable htResult)
{
htResult = null;
try
{
if (ParStateSoft.StateMachine_e != StateMachine_enum.Calib)
{
if (WinMsgBox.ShowMsgBox("软件非校准模式，不允许进行校准触发，是否切换到校准模式"))
{
//校准模式
ParStateSoft.StateMachine_e = StateMachine_enum.Calib;
if (Fun_SoftState != null)
{
Fun_SoftState();
}
}
return(StateComprehensive_enum.False);
}
StateComprehensive_enum stateComprehensive_e = StateComprehensive_enum.False;
int pos = i / 1000; //提取算子的相对序号，不是拍照位置
int type = int.Parse(i.ToString().Substring(1, 1)); //标定类型
int index = int.Parse(i.ToString().Substring(2, 2)); //序号
TypeCalib_enum TypeCalib_e = (TypeCalib_enum)type;
switch (TypeCalib_e)
{
//相机校准（标定板）
case TypeCalib_enum.CalibCamera:
ShowState("相机校准");
stateComprehensive_e = DealComprehensiveResultFun_CalibCamera(trigerSource_e, pos, index, out htResult);
break;
//旋转中心校准
case TypeCalib_enum.CalibRotate:
ShowState("旋转中心校准");
stateComprehensive_e = DealComprehensiveResultFun_CalibRotate(trigerSource_e, pos, index, out htResult);
break;
//轴校准
case TypeCalib_enum.CalibAxis:
ShowState("轴校准");
stateComprehensive_e = DealComprehensiveResultFun_CalibAxis(trigerSource_e, pos, index, out htResult);
break;
//投影校准
case TypeCalib_enum.CalibAffineCamera:
ShowState("相机投影校准");
stateComprehensive_e = DealComprehensiveResultFun_CalibAffineCamera(trigerSource_e, pos, index, out htResult);
break;
//多目校准
case TypeCalib_enum.CalibMult:
ShowState("多目校准");
stateComprehensive_e = DealComprehensiveResultFun_CalibMult(trigerSource_e, pos, index, out htResult);
break;
//校准
case TypeCalib_enum.CalibHandEye:
ShowState("手眼校准");
stateComprehensive_e = DealComprehensiveResultFun_CalibHandEye(trigerSource_e, pos, index, out htResult);
break;
}
switch (g_NoCamera)
{
case 1:
blCamera1CalibFinish = true;
Camera1CalibResult_e = stateComprehensive_e;
WritePlcCalibResult_Cam12_A2A2();
LogicPLC.L_I.ClearPLC(RegMonitor.R_I[6]);
break;
case 2:
blCamera2CalibFinish = true;
Camera2CalibResult_e = stateComprehensive_e;
WritePlcCalibResult_Cam12_A2A2();
LogicPLC.L_I.ClearPLC(RegMonitor.R_I[7]);
break;
case 3:
blCamera3CalibFinish = true;
Camera3CalibResult_e = stateComprehensive_e;
WritePlcCalibResult_Cam34_A2A2();
LogicPLC.L_I.ClearPLC(RegMonitor.R_I[8]);
break;
case 4:
blCamera4CalibFinish = true;
Camera4CalibResult_e = stateComprehensive_e;
WritePlcCalibResult_Cam34_A2A2();
LogicPLC.L_I.ClearPLC(RegMonitor.R_I[9]);
break;
case 5:
blCamera5CalibFinish = true;
Camera5CalibResult_e = stateComprehensive_e;
WritePlcCalibResult_Cam56_A2A2();
LogicPLC.L_I.ClearPLC(RegMonitor.R_I[10]);
break;
case 6:
blCamera6CalibFinish = true;
Camera6CalibResult_e = stateComprehensive_e;
WritePlcCalibResult_Cam56_A2A2();
LogicPLC.L_I.ClearPLC(RegMonitor.R_I[11]);
break;
case 7:
blCamera7CalibFinish = true;
Camera7CalibResult_e = stateComprehensive_e;
WritePlcCalibResult_Cam78_A2A2();
LogicPLC.L_I.ClearPLC(RegMonitor.R_I[12]);
break;
case 8:
blCamera8CalibFinish = true;
Camera8CalibResult_e = stateComprehensive_e;
WritePlcCalibResult_Cam78_A2A2();
LogicPLC.L_I.ClearPLC(RegMonitor.R_I[13]);
break;
}
return(stateComprehensive_e);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(StateComprehensive_enum.False);
}
}
/// <summary>
/// 接收外部触发源的指令
/// </summary>
/// <param name="trigerSource_e"></param>
/// <param name="i"></param>
/// <returns></returns>
public StateComprehensive_enum DealComprehensiveResultFun(TriggerSource_enum trigerSource_e, int i)
{
Hashtable htResult = null;
StateComprehensive_enum stateComprehensive_e = StateComprehensive_enum.False;
try
{
//if (ParStateSoft.StateMachine_e == StateMachine_enum.Calib
// && i < 100)
//{
// if (WinMsgBox.ShowMsgBox("校准模式，不允许触发运行，是否切换到运行模式"))
// {
// //校准模式
// ParStateSoft.StateMachine_e = StateMachine_enum.Auto;
// if (Fun_SoftState != null)
// {
// Fun_SoftState();
// }
// }
// return StateComprehensive_enum.False;
//}
switch (i)
{
#region 正常拍照
case 1:
stateComprehensive_e = DealComprehensiveResultFun1(trigerSource_e, out htResult);
break;
case 2:
stateComprehensive_e = DealComprehensiveResultFun2(trigerSource_e, out htResult);
break;
case 3:
stateComprehensive_e = DealComprehensiveResultFun3(trigerSource_e, out htResult);
break;
case 4:
stateComprehensive_e = DealComprehensiveResultFun4(trigerSource_e, out htResult);
break;
case 5:
stateComprehensive_e = DealComprehensiveResultFun5(trigerSource_e, out htResult);
break;
case 6:
stateComprehensive_e = DealComprehensiveResultFun6(trigerSource_e, out htResult);
break;
case 7:
stateComprehensive_e = DealComprehensiveResultFun7(trigerSource_e, out htResult);
break;
case 8:
stateComprehensive_e = DealComprehensiveResultFun8(trigerSource_e, out htResult);
break;
case 9:
stateComprehensive_e = DealComprehensiveResultFun9(trigerSource_e, out htResult);
break;
case 10:
stateComprehensive_e = DealComprehensiveResultFun10(trigerSource_e, out htResult);
break;
#endregion 正常拍照
}
#region 校准触发
if (i > 100)
{
stateComprehensive_e = DealComprehensiveResultFun_Calib(trigerSource_e, i, out htResult);
}
#endregion 校准触发
string cellError = "";
GetErrorCell(htResult, i, out cellError);//显示错误信息
return(stateComprehensive_e);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(StateComprehensive_enum.False);
}
}
/// <summary>
/// 处理残材检测
/// </summary>
/// <param name="cellName">算子序号</param>
/// <param name="pos">表明用的第几次拍照的结果</param>
/// <param name="htResult"></param>
/// <returns></returns>
public StateComprehensive_enum DealSharpness(string cellName, Pos_enum pos, out Hashtable htResult)
{
htResult = null;
double[] dblResult;
try
{
#region 空跑
if (ParStateSoft.StateMachine_e == StateMachine_enum.NullRun)
{
ShowState(string.Format("相机{0}空跑默认无残边", g_NoCamera));
FinishPhotoPLC(1);
return(StateComprehensive_enum.True);
}
#endregion
//获取算子计算结果
StateComprehensive_enum StateComprehensive_e = g_BaseDealComprehensive.DealComprehensivePosNoDisplay(
g_UCDisplayCamera, g_HtUCDisplay, pos, out htResult);
ResultSharpness result = (ResultSharpness)htResult[cellName];
double dblThread = ModelParams.WastageThread1;
if (g_NoCamera == 4)
{
dblThread = ModelParams.WastageThread2;
}
//对计算结果进行判别
if (WastageDetection.CalcSharpnessRatio(result.Deviation_L, dblThread,
g_NoCamera, ModelParams.DefaultOKCamera, ModelParams.IfSingleElectrode,
RegeditMain.R_I.ID, ModelParams.IfRecordData, out dblResult))
{
FinishPhotoPLC(1);
g_UCDisplayCamera.ShowResult("拍照位置：" + pos +
"\nCF清晰度：" + dblResult[0].ToString(ReservDigits) +
"\nTFT清晰度：" + dblResult[1].ToString(ReservDigits) +
"\n比例：" + dblResult[2].ToString(ReservDigits) +
"\n阈值：" + dblThread.ToString(ReservDigits) +
"\nOK");
return(StateComprehensive_enum.True);
}
else
{
//连续低清晰度报警
if (++WastageDetection.WastageInvalidCount[g_NoCamera] > 5)
{
ShowAlarm(string.Format("相机{0}连续低清晰度报警", g_NoCamera));
LogicPLC.L_I.WriteRegData1((int)DataRegister1.WastageAlarm, 1);
}
else
{
WastageDetection.WastageInvalidCount[g_NoCamera] = 0;
}
FinishPhotoPLC(2);
g_UCDisplayCamera.ShowResult("拍照位置：" + pos +
"\nTFT清晰度：" + dblResult[0].ToString(ReservDigits) +
"\nCF清晰度：" + dblResult[1].ToString(ReservDigits) +
"\n比例：" + dblResult[2].ToString(ReservDigits) +
"\n阈值：" + dblThread.ToString(ReservDigits) +
"\nNG", "red");
return(StateComprehensive_enum.False);
}
}
catch
{
FinishPhotoPLC(2);
ShowAlarm("残才相机处理过程中发生异常");
return(StateComprehensive_enum.False);
}
}
public bool BlobAngleCalc(string cellName, out Hashtable htResult)
{
htResult = null;
double[] dblResult = new double[2];
bool blResult = true;
try
{
#region 空跑
if (ParStateSoft.StateMachine_e == StateMachine_enum.NullRun)
{
ShowState(string.Format("相机{0}空跑，默认发送OK", g_NoCamera));
LogicRobot.L_I.WriteRobotCMD(ModelParams.PrecisePos, ModelParams.cmd_PreciseAngle);
return(true);
}
#endregion
StateComprehensive_enum stateComprehensive_e = g_BaseDealComprehensive.DealComprehensivePosNoDisplay(
g_UCDisplayCamera, g_HtUCDisplay, Pos_enum.Pos1, out htResult);
ResultBlob resultBlob = (ResultBlob)htResult[cellName];
//算子基准值记录到基准值当中
if (ModelParams.PreciseStdValue.DblValue1 == 0)
{
ModelParams.PreciseStdValue = new Point2D(resultBlob.StdX, resultBlob.StdY);
}
//面积判断
#region 面积检测
if (!BlobAreaDetect(resultBlob.Area, out dblResult))
{
ShowState("精定位第一次拍照失败");
blResult = false;
return(false);
}
#endregion
//一次拍照计算偏差，目前用于和二次拍照进行对比
BackLightLocation.Verify(new Point2D(resultBlob.X, resultBlob.Y),
new Point2D(resultBlob.StdX, resultBlob.StdY), //不规则区域基准值，即旋转中心
resultBlob.R_J, //不规则区域角度
ParCalibWorld.V_I[g_NoCamera], //相机系数
ModelParams.BLDisplayType, //背光在相机显示中的方向
ModelParams.PreciseRobotAngle, //精定位机器人u轴角度
ModelParams.BotWastageAngle, //机器人残材平台放片角度
ModelParams.BotPlaceAngle, //机器人放置角度
ModelParams.DisplayAngle, //相机显示角度
ModelParams.BLPlaceAngle); //背光放置方向
blResult = BackLightLocation.BlobAngleCalc(
resultBlob.R_J, //不规则区域角度
ModelParams.PrecisePos, //机器人精定位位置
ModelParams.cmd_PreciseAngle, //精定位角度调整指令
ModelParams.cmd_PreciseFailed, //精定位失败指令
ModelParams.PreciseThreadR, //精定位角度偏差阈值
ModelParams.BLDisplayType, //背光在相机显示中的方向
RegeditMain.R_I.ID, //UniqueID
ModelParams.IfRecordData, //是否进行数据记录
out phi); //输出实际给机器人补偿的角度
return(blResult);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(false);
}
finally
{
string strResult = "OK";
if (!blResult)
{
strResult = "NG";
}
g_UCDisplayCamera.ShowResult("面积比例：" + dblResult[1].ToString(ReservDigits) +
"\n角度补正：" + phi.ToString(ReservDigits) +
"\n角度阈值：" + ModelParams.PreciseThreadR.ToString(ReservDigits) +
"\n" + strResult, blResult);
}
}
//double
#endregion 定义
#region 位置1拍照
/// <summary>
///
/// </summary>
public override StateComprehensive_enum DealComprehensiveResultFun1(
TriggerSource_enum trigerSource_e, int index, out Hashtable htResult)
{
#region 定义
htResult = g_HtResult;
PosNow_e = Pos_enum.Pos1;//当前位置
bool blResult = true;
Stopwatch sw = new Stopwatch();
sw.Restart();
#endregion 定义
try
{
if (ParStateSoft.StateMachine_e == StateMachine_enum.NullRun)
{
ShowState("相机1空跑默认OK");
return(StateComprehensive_enum.True);
}
StateComprehensive_enum stateComprehensive_e = g_BaseDealComprehensive.DealComprehensivePosNoDisplay(
g_UCDisplayCamera, g_HtUCDisplay, Pos_enum.Pos1, out htResult);
BaseResult result = htResult[Camera1Match1] as BaseResult;
if (!DealTypeResult(result))
{
ShowAlarm("精定位相机1拍照NG!");
LogicRobot.L_I.WriteRobotCMD(Protocols.BotCmd_PreciseNG);
return(StateComprehensive_enum.False);
}
Pt2Mark1.DblValue1 = result.X;
Pt2Mark1.DblValue2 = result.Y;
Camera1Done = true;
DualLocation(index);
return(StateComprehensive_enum.True);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(StateComprehensive_enum.False);
}
finally
{
#region 显示和日志记录
Display(Pos_enum.Pos1, htResult, blResult, sw);
#endregion 显示和日志记录
//g_UCDisplayCamera.ShowResult("NG\nX=20\nY=100\n", false);
//long t = g_UCDisplayCamera.SaveBitFullPath_Screen("Came","D:\\");
//t = g_UCDisplayCamera.SaveBit_Screen("D:\\");
//ShowState_Hidden("保存屏幕截图时间:"+t.ToString());
//ShowResult_Camera1("1",true);
//ShowResult_Camera2("2", true);
//ShowResult_Camera3("3", true);
//ShowResult_Camera4("4", true);
//ShowResult_Camera5("5", true);
//ShowResult_Camera6("6", true);
}
}
/// <summary>
/// 不规则区域偏差计算
/// </summary>
/// <param name="cellName"></param>
/// <param name="htResult"></param>
/// <returns></returns>
public bool BlobDeviation(string cellName, out Hashtable htResult)
{
htResult = null;
Point2D pDelta = new Point2D();
bool blResult = true;
double[] dblResult = new double[2];
try
{
#region 空跑
if (ParStateSoft.StateMachine_e == StateMachine_enum.NullRun)
{
ShowState("空跑默认发送平台1坐标");
LogicRobot.L_I.WriteRobotCMD(ModelParams.PosWastagePlat1, ModelParams.cmd_PreciseResult);
return(true);
}
#endregion
StateComprehensive_enum stateComprehensive_e = g_BaseDealComprehensive.DealComprehensivePosNoDisplay(
g_UCDisplayCamera, g_HtUCDisplay, Pos_enum.Pos1, out htResult);
ResultBlob resultBlob = (ResultBlob)htResult[cellName];
#region 面积检测
if (!BlobAreaDetect(resultBlob.Area, out dblResult))
{
blResult = false;
return(false);
}
#endregion
//获取像素偏差
//Point2D delta = new Point2D((ModelParams.isMirrorX ? 1 : -1) * resultBlob.DeltaX * AMP,
// (ModelParams.isMirrorY ? 1 : -1) * resultBlob.DeltaY * AMP);
double deltaX = resultBlob.X - ModelParams.PreciseStdValue.DblValue1;
double deltaY = resultBlob.Y - ModelParams.PreciseStdValue.DblValue2;
Point2D delta = new Point2D((ModelParams.isMirrorX ? 1 : -1) * deltaX * AMP,
(ModelParams.isMirrorY ? 1 : -1) * deltaY * AMP);
//将像素偏差代入计算
blResult = BolbDevationCalc(phi, delta, out pDelta);
return(blResult);
}
catch (Exception ex)
{
blResult = false;
Log.L_I.WriteError(NameClass, ex);
return(false);
}
finally
{
string strResult = "OK";
if (!blResult)
{
strResult = "NG";
}
g_UCDisplayCamera.ShowResult(
"面积比例：" + dblResult[1].ToString("f3") +
" 阈值：" + ModelParams.AreaMin.ToString(ReservDigits) + "-" + ModelParams.AreaMax.ToString(ReservDigits) +
"\n补正值X：" + pDelta.DblValue1.ToString("f3") +
" 阈值：" + ModelParams.PreciseThreadX.ToString(ReservDigits) +
"\n补正值Y：" + pDelta.DblValue2.ToString("f3") +
" 阈值：" + ModelParams.PreciseThreadY.ToString(ReservDigits) +
"\n" + strResult, blResult);
}
}
