/// <summary>
/// PLC触发更新数据
/// </summary>
protected virtual void PLCRefreshPar()
{
try
{
ShowState("PLC触发更新参数数据");
//如果新建的型号相同
if (ComConfigPar.C_I.NameModel != ParLogicPLC.P_I.NameModel)
{
WinMsgBox.ShowMsgBox("当前名称型号参数不存在，请新建型号！");
return;
}
#region 将PLC中读取的参数复制到配置文件类
ReadParProductFromPLC();
#endregion 将DealPLC中读取的参数复制到配置文件类
//换型
if (RefreshPar())
{
ShowState("PLC触发更新产品参数");
}
else
{
ShowAlarm("PLC触发更新产品参数失败");
}
//每次换型时，需要写入PLC的值
WritePLCModelPar();//回调
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
}
}
/// <summary>
/// 恢复参数
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public virtual void btnRecover_Click(object sender, RoutedEventArgs e)
{
try
{
FunBackup.F_I.BackupAdjust();//备份调整值
base.IndexP = this.dgDir.SelectedIndex;
if (WinMsgBox.ShowMsgBox("使用备份参数永久覆盖当前所有调整值，是否继续？"))
{
DirectoryInfo theFolder = new DirectoryInfo(ParRecover.P_I.g_BaseParRecoverDir_L[base.IndexP].Path);
foreach (FileInfo item in theFolder.GetFiles())
{
//edit by xc-190401,传入filename
if (item.Name == FileName + ".ini")
{
File.Copy(item.FullName, ParAdjust.PathAdjust, true);
}
}
RecoverPar_event();//刷新参数
}
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
WinMsgBox.ShowMsgBox("参数恢复失败", false);
}
}
private void BtnSave_Click(object sender, RoutedEventArgs e)
{
try
{
if (!blSideIndexSetOK)
{
WinMsgBox.ShowMsgBox("边序号设置不合法，请检查");
TxtSideMatch.Focus();
return;
}
var a_Var = g_ParAll[0].IntArrSidesMatch.Intersect(g_ParAll[1].IntArrSidesMatch).ToArray();
if (g_ParAll[0].IntArrSidesMatch.Intersect(g_ParAll[1].IntArrSidesMatch).ToArray().Length != 0)
{
WinMsgBox.ShowMsgBox("边序号设置重复，请检查");
return;
}
if (g_ParAll.WriteIni())
{
WinMsgBox.ShowMsgBox("保存完成");
Close();
}
}
catch (Exception ex)
{
Log.L_I.WriteError(g_NameClass, ex);
}
}
private void PasswordBox_KeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Enter)
{
if (PsdBx.Password == "ccd1234" || PsdBx.Password == "finevision")
{
StackTrace stack = new StackTrace();
Assembly assembly = Assembly.GetExecutingAssembly();
string path = assembly.Location;
string path1 = assembly.CodeBase;;
string path3 = assembly.EscapedCodeBase;
if (File.Exists("PathVsion.log"))
{
File.Delete("PathVsion.log");
}
Log.L_I.WriteLog("PathVsion.log", path, path1, path3);
WinMsgBox.ShowMsgBox("已输出！");
Close();
}
else
{
LblState.Content = "密码错误";
}
}
}
/// <summary>
/// 恢复参数
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public override void btnRecover_Click(object sender, RoutedEventArgs e)
{
try
{
FunBackup.F_I.BackupStd();//备份基准值
base.IndexP = this.dgDir.SelectedIndex;
if (WinMsgBox.ShowMsgBox("使用备份参数永久覆盖当前所有基准值，是否继续？"))
{
DirectoryInfo theFolder = new DirectoryInfo(ParRecover.P_I.g_BaseParRecoverDir_L[base.IndexP].Path);
foreach (FileInfo item in theFolder.GetFiles())
{
if (item.Name == "Std.ini")
{
File.Copy(item.FullName, ParStd.PathStd, true);
}
}
RecoverPar_event();//刷新参数
}
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
WinMsgBox.ShowMsgBox("参数恢复失败", false);
}
}
/// <summary>
/// 计算相机的映射系数
/// </summary>
/// <param name="par1">基准相机参数</param>
/// <param name="index1">算子索引号</param>
/// <param name="par2"></param>
/// <param name="index2">算子索引号</param>
/// <returns></returns>
bool CalibMult_Co(BaseParComprehensive par1, int index1, BaseParComprehensive par2, int index2)
{
try
{
//第一个相机
List <string> name1_L = par1.GetAllNameCellByType("多目校准");
if (name1_L.Count < index1)
{
WinMsgBox.ShowMsgBox("算子个数小于序号!");
return(false);
}
string name1 = name1_L[index1 - 1];
ParCalibMult parCalibMult1 = par1.GetCellParCalibrate(name1) as ParCalibMult;
//第二个相机
List <string> name2_L = par2.GetAllNameCellByType("多目校准");
if (name2_L.Count < index1)
{
WinMsgBox.ShowMsgBox("算子个数小于序号!");
return(false);
}
string name2 = name2_L[index1 - 1];
ParCalibMult parCalibMult2 = par2.GetCellParCalibrate(name2) as ParCalibMult;
//计算系数
FunCalibMult fun = new FunCalibMult();
fun.CalCalibMult(parCalibMult1, parCalibMult2);
//保存此单元格
bool blSave = par1.WriteXmlDoc(par1.NameCell);
if (blSave)
{
ShowState(string.Format("将相机{0}参数{1}保存到本地成功", par1.NoCamera.ToString(), par1.NameCell));
}
else
{
ShowAlarm(string.Format("将相机{0}参数{1}保存到本地失败", par1.NoCamera.ToString(), par1.NameCell));
return(false);
}
blSave = par2.WriteXmlDoc(par2.NameCell);
if (blSave)
{
ShowState(string.Format("将相机{0}参数{1}保存到本地成功", par2.NoCamera.ToString(), par2.NameCell));
}
else
{
ShowAlarm(string.Format("将相机{0}参数{1}保存到本地失败", par2.NoCamera.ToString(), par2.NameCell));
return(false);
}
return(true);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
return(false);
}
}
private void Win_RecoverPar_event()
{
try
{
ShowPar();
WinMsgBox.ShowMsgBox("基准值按照恢复的历史参数完成刷新", true, 2000);
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
}
}
void InitMotionCtler()
{
if (!ParMotionCtrler.P_I.IsEnable)
{
return;
}
//包括初始化IO模块
LogicMotionCtler.L_I.InitModule();
DmcResult result = LogicMotionCtler.L_I.Dmc_card_init();
//板卡初始化之后初始化实deng例
InitLight();
InitAirCylider();
if (result.resultType == ResultType.OK)
{
ParMotionCtrler.P_I.IsInitialized = true;
if (WinMsgBox.ShowMsgBox("开始按照既定的顺序\n执行回零？"))
{
this.Dispatcher.Invoke(new Action(() =>
{
this.gdRoot.Children.Add(uiShield);
}));
ShowState("打开气缸，等待气缸到达限位");
g_AirCyliderUpDown.OnAirCylinder(4000);
ShowState("气缸已打开，开始回零");
LogicMotionCtler.L_I.Home();
this.Dispatcher.Invoke(new Action(() =>
{
this.gdRoot.Children.Remove(uiShield);
}));
ShowState("回零动作结束，已回到初始位！");
}
else
{
ShowState("已拒绝回零！");
}
}
else
{
WinError.GetWinInst().ShowError("控制卡初始化失败！\n" + result.resultInfo);
};
}
/// <summary>
/// 显示换型结果
/// </summary>
void ShowResultChangeModel()
{
try
{
if (g_BlFinishBasePar &&
g_BlFinishComprehensive)
{
if (numError > 0)
{
ShowAlarm("换型失败");
WinMsgBox.ShowMsgBox("换型失败!", false);
}
else
{
ShowState("换型成功");
WinMsgBox.ShowMsgBox("换型成功!", true, 3000);
}
}
}
catch (Exception ex)
{
Log.L_I.WriteError(NameClass, ex);
}
}
/// 创建启动屏幕对象，显示系统初始化信息，最后显示主窗体
static void ShowSplashScreen()
{
try
{
g_StartUpWindow = new StartUpWindow();
g_StartUpWindow.ShowDialog();
//显示主窗体
Application application = new Application();
application.Run(new MainWindow());
}
catch (Exception ex)
{
WinMsgBox.ShowMsgBox("软件发生异常\r①点击确定或取消后软件将关闭 \r②移开此窗口并手动对主界面截屏\r③观察机台内当前巡边玻璃是否已往后流\r④记录时间，发送异常信息日志和运行报警日志到开发人员邮箱");
BinaryFormatter formatter = null;
string path = Log.CreateAllTimeFile(Log.L_I.PathErrorLog) + "Exception" + DateTime.Now.ToString(" HH-mm-ss") + ".dat";
using (FileStream ms = new FileStream(path, FileMode.Create))
{
formatter = new BinaryFormatter();
formatter.Serialize(ms, ex);
}
Log.L_I.WriteError("Program", ex);
}
}
/// <summary>
/// 自动校准旋转中心,1401表示位置1第一次拍照，
/// </summary>
/// <param name="pos">算子序号，不表示拍照位置</param>
/// <param name="index"></param>
/// <param name="htResult">哈希表结果</param>
/// <returns></returns>
bool CalibRotate(int pos, int index, out Hashtable htResult)
{
htResult = null;
Stopwatch sw = new Stopwatch();
try
{
//获取该算子所有的单元格
List <string> nameCell_L = g_BaseParComprehensive.GetAllNameCellByType("旋转中心变换");
if (nameCell_L.Count < pos)
{
WinMsgBox.ShowMsgBox("算子个数小于序号!");
return(false);
}
string nameCell = nameCell_L[pos - 1];//单元格名称
ParCalibRotate par = g_BaseParComprehensive.GetCellParCalibrate(nameCell) as ParCalibRotate;
int indexCell = int.Parse(nameCell.Replace("C", ""));//单元格索引
ParCellExeReference parCellExeReference = par.g_ParCellExecuteReference;
ParGetResultFromCell parGetResultFromCell = par.g_ParGetResultFromCellForRC;//用来计算旋转中心
//调用执行
g_BaseDealComprehensive.DealComprehensivePosCell_ForTestRun(g_UCDisplayCamera, parCellExeReference, par.g_ParCellExecuteReference.g_CellExecute_L, out htResult);//执行算法且显示
string cellError = "";
if (!GetErrorCell(htResult, pos, out cellError))
{
WinMsgBox.ShowMsgBox(string.Format("相机{0}位置{1}，单元格{2}校准计算错误", g_NoCamera.ToString(), pos.ToString(), par.NameCell));
return(false);
}
FunCellDataReferenc fun = new FunCellDataReferenc();
fun.GetResultValue(htResult, parGetResultFromCell, index - 1);
string info = string.Format("相机{0}位置{1}，单元格{2}", g_NoCamera.ToString(), pos.ToString(), par.NameCell);
if (index == 1)
{
info += "旋转中心校准第一次拍照";
ShowState(info);
SaveStdImage(par, "旋转中心位置1");
}
else if (index == 2)
{
info += "旋转中心校准第二次拍照";
ShowState(info);
SaveStdImage(par, "旋转中心位置2");
FunCalibRotate funCalibRotate = new FunCalibRotate();
Point2D point = funCalibRotate.GetOriginPoint(par);
par.XRC = point.DblValue1;
par.YRC = point.DblValue2;
//显示求取的旋转中心
info = string.Format("旋转中心:X{0},Y{1}", par.XRC.ToString(), par.YRC.ToString());
ShowState(info);
//保存此单元格
bool blSave = g_BaseParComprehensive.WriteXmlDoc(par.NameCell);
if (blSave)
{
ShowState(string.Format("将参数旋转中心校准{0}保存到本地成功", par.NameCell));
}
else
{
ShowAlarm(string.Format("将参数旋转中心校准{0}保存到本地失败", par.NameCell));
return(false);
}
//将参数保存到结果中
bool blSaveResult = g_BaseDealComprehensive.InitCalibRotate(indexCell);
if (blSaveResult)
{
ShowState(string.Format("将参数旋转中心校准{0}保存到结果成功", par.NameCell));
}
else
{
ShowAlarm(string.Format("将参数旋转中心校准{0}保存到结果失败", par.NameCell));
return(false);
}
}
return(true);
}
catch (Exception ex)
{
ShowAlarm(string.Format("相机{0}旋转中心计算进入Catch", g_NoCamera.ToString()));
Log.L_I.WriteError(NameClass, ex);
return(false);
}
}
private void tb_Checked(object sender, RoutedEventArgs e)
{
//WinLogImage.GetWinInst().Show();
WinMsgBox.ShowMsgBox("123", false);
}
/// <summary>
/// 自动轴,1301表示位置1第一次拍照，轴坐标的计算是双数点进行保存，轴计算是两个数据表示一根轴，20181111-zx
/// </summary>
/// <param name="pos">算子的序号，并非拍照位置</param>
/// <param name="index"></param>
/// <param name="htResult">哈希表结果</param>
/// <returns></returns>
bool CalibAxis(int pos, int index, out Hashtable htResult)
{
htResult = null;
Stopwatch sw = new Stopwatch();
sw.Restart();
try
{
List <string> nameCell_L = g_BaseParComprehensive.GetAllNameCellByType("轴坐标校准");
if (nameCell_L.Count < pos)
{
WinMsgBox.ShowMsgBox("算子个数小于序号!");
return(false);
}
string nameCell = nameCell_L[pos - 1];
ParCalibAxis par = g_BaseParComprehensive.GetCellParCalibrate(nameCell) as ParCalibAxis;
int indexCell = int.Parse(nameCell.Replace("C", ""));//单元格索引
ParCellExeReference parCellExeReference = par.g_ParCellExecuteReference;
ParGetResultFromCell parGetResultFromCell = par.g_ParGetResultFromCell;//用来计算轴
//调用执行
g_BaseDealComprehensive.DealComprehensivePosCell_ForTestRun(g_UCDisplayCamera, parCellExeReference, par.g_ParCellExecuteReference.g_CellExecute_L, out htResult);//执行算法且显示
string cellError = "";
if (!GetErrorCell(htResult, pos, out cellError))
{
WinMsgBox.ShowMsgBox(string.Format("相机{0}位置{1}，单元格{2}校准计算错误", g_NoCamera.ToString(), pos.ToString(), par.NameCell));
return(false);
}
FunCellDataReferenc fun = new FunCellDataReferenc();
fun.GetResultValue(htResult, parGetResultFromCell, index - 1);
string info = string.Format("相机{0}位置{1}，单元格{2}", g_NoCamera.ToString(), pos.ToString(), par.NameCell);
//保存基准图片
SaveStdImage(par, "轴校准" + index.ToString());
if (index % 2 == 1)
{
info += string.Format("轴校准第{0}次拍照", index);
//日志
ShowState_Cam(info);
}
else
{
info += string.Format("轴校准第{0}次拍照", index);
//保存基准图片
SaveStdImage(par, "旋转中心位置2");
//日志
ShowState_Cam(info);
FunCalibAxis funCalibCoord = new FunCalibAxis();
Point4D pResult = funCalibCoord.GetAxisAngleDir(par);
par.XAxisAngle_J = pResult.DblValue1;
par.YAxisAngle_J = pResult.DblValue2;
par.XAxisDir = (int)pResult.DblValue3;
par.YAxisDir = (int)pResult.DblValue4;
//显示求取的轴角度
info = string.Format("轴角度:X轴{0},Y轴{1}", par.XAxisAngle_J.ToString(), par.YAxisAngle_J.ToString());
//日志
ShowState_Cam(info);
//显示求取的轴方向
info = string.Format("轴方向:X轴{0},Y轴{1}", par.XAxisDir.ToString(), par.YAxisDir.ToString());
//日志
ShowState_Cam(info);
//保存此单元格
bool blSave = g_BaseParComprehensive.WriteXmlDoc(par.NameCell);
if (blSave)
{
//日志
ShowState_Cam(string.Format("将参数{0}保存到本地成功", par.NameCell));
}
else
{
//日志
ShowAlarm_Cam(string.Format("将参数{0}保存到本地失败", par.NameCell));
return(false);
}
//将参数保存到结果中
bool blSaveResult = g_BaseDealComprehensive.InitCalibAxis(indexCell);
if (blSaveResult)
{
//日志
ShowState_Cam(string.Format("将参数{0}保存到结果成功", par.NameCell));
}
else
{
//日志
ShowAlarm_Cam(string.Format("将参数{0}保存到结果失败", par.NameCell));
return(false);
}
}
return(true);
}
catch (Exception ex)
{
//日志
ShowAlarm_Cam("轴校准计算进入Catch");
Log.L_I.WriteError(NameClass, ex);
return(false);
}
}
/// <summary>
/// 自动相机校准,1201表示位置1第一次拍照，
/// </summary>
/// <param name="pos"></param>
/// <param name="index"></param>
/// <returns></returns>
bool CalibHandEye(int pos, int index, out Hashtable htResult)
{
htResult = null;
Stopwatch sw = new Stopwatch();
sw.Restart();
try
{
string info = "";
ParCalibHandEye par = g_BaseParComprehensive.GetCellParCalibByType("手眼校准", pos) as ParCalibHandEye;
string nameCell = par.NameCell; //单元格名称
int indexCell = int.Parse(nameCell.Replace("C", "")); //单元格索引
if (index != 9)
{
//关联算法，用来获取角点
ParCellExeReference parCellExeReference = par.g_ParCellExecuteReference;
ParGetResultFromCell parGetResultFromCell = par.g_ParGetResultFromCell;
//调用执行
g_BaseDealComprehensive.DealComprehensivePosCell_ForTestRun(g_UCDisplayCamera, parCellExeReference, par.g_ParCellExecuteReference.g_CellExecute_L, out htResult);//执行算法且显示
string cellError = "";
if (!GetErrorCell(htResult, pos, out cellError))
{
WinMsgBox.ShowMsgBox(string.Format("相机{0}位置{1}，单元格{2}手眼校准计算错误", g_NoCamera.ToString(), pos.ToString(), par.NameCell));
return(false);
}
FunCellDataReferenc fun = new FunCellDataReferenc();
fun.GetResultValue(htResult, parGetResultFromCell, index - 1);
info = string.Format("相机{0}位置{1}，单元格{2}手眼校准触发拍照", g_NoCamera.ToString(), pos.ToString(), par.NameCell);
ShowState(info);
//标定开始，清空值
if (index == 0)
{
par.XDelta = 0;
par.YDelta = 0;
parGetResultFromCell.ClearResult();
}
}
//保存基准图片
SaveStdImage(par, "手眼校准" + index.ToString());
//表示标定结束
if (index == 99)
{
FunCalibHandEye funCalibHandEye = new FunCalibHandEye();
ResultCalibHandEye result = funCalibHandEye.CalCalibHandEye(par);
//自校准
funCalibHandEye.CheckSelf(par, -1);
List <double> XDelta_L = new List <double>();
List <double> YDelta_L = new List <double>();
//自动计算偏差
funCalibHandEye.CalDeltaforCalib(par, out XDelta_L, out YDelta_L);
string xInfo = "";
string yInfo = "";
for (int i = 0; i < XDelta_L.Count; i++)
{
xInfo += XDelta_L[i].ToString() + ",";
yInfo += YDelta_L[i].ToString() + ",";
}
ShowState(string.Format("自校准的偏差为X{0}", xInfo));
ShowState(string.Format("自校准的偏差为Y{0}", yInfo));
info = "将标定参数保存到结果";
ShowState(info);
//参数保存到Par
bool blSavePar = funCalibHandEye.SaveResultToPar(par, result);
//将参数保存到结果中
bool blSaveResult = funCalibHandEye.SaveResultToStdResult(par, htResult);
if (blSaveResult)
{
ShowState(string.Format("将相机{0}手眼校准参数{1}保存到结果成功", g_NoCamera.ToString(), par.NameCell));
}
else
{
ShowAlarm(string.Format("将相机{0}手眼校准参数{1}保存到结果失败", g_NoCamera.ToString(), par.NameCell));
return(false);
}
//保存此单元格
bool blSave = g_BaseParComprehensive.WriteXmlDoc(par.NameCell);
if (blSave)
{
ShowState(string.Format("将相机{0}手眼校准参数{1}保存到本地成功", g_NoCamera.ToString(), par.NameCell));
}
else
{
ShowAlarm(string.Format("将相机{0}手眼校准参数{1}保存到本地失败", g_NoCamera.ToString(), par.NameCell));
return(false);
}
}
return(true);
}
catch (Exception ex)
{
WinMsgBox.ShowMsgBox(string.Format("手眼{0}校准计算进入Catch", g_NoCamera.ToString()));
ShowAlarm("手眼校准计算进入Catch");
Log.L_I.WriteError(NameClass, ex);
return(false);
}
}
/// <summary>
/// 自动相机校准,1201表示位置1第一次拍照，
/// </summary>
/// <param name="pos"></param>
/// <param name="index"></param>
/// <returns></returns>
bool CalibCamera(int pos, int index, out Hashtable htResult)
{
htResult = null;
Stopwatch sw = new Stopwatch();
sw.Restart();
try
{
ParCalibCamera par = g_BaseParComprehensive.GetCellParCalibByType("相机校准", pos) as ParCalibCamera;
string nameCell = par.NameCell; //单元格名称
int indexCell = int.Parse(nameCell.Replace("C", "")); //单元格索引
//关联算法，用来获取角点
ParCellExeReference parCellExeReference = par.g_ParCellExecuteReference;
ParGetResultFromCell parGetResultFromCell = par.g_ParGetResultFromCell;
//调用执行
g_BaseDealComprehensive.DealComprehensivePosCell_ForTestRun(g_UCDisplayCamera, parCellExeReference, par.g_ParCellExecuteReference.g_CellExecute_L, out htResult);//执行算法但不显示
string cellError = "";
if (!GetErrorCell(htResult, pos, out cellError))
{
WinMsgBox.ShowMsgBox(string.Format("相机{0}位置{1}，单元格{2}校准计算错误", g_NoCamera.ToString(), pos.ToString(), par.NameCell));
return(false);
}
FunCellDataReferenc fun = new FunCellDataReferenc();
fun.GetResultValue(htResult, parGetResultFromCell, index - 1);
string info = string.Format("相机{0}位置{1}，单元格{2}相机校准触发拍照", g_NoCamera.ToString(), pos.ToString(), par.NameCell);
ShowState(info);
FunCalibCamera funCalibCamera = new FunCalibCamera();
ResultCalibCamera result = funCalibCamera.DealCalibCamera(par);
info = "将标定参数保存到结果";
ShowState(info);
//参数保存到Par
bool blSavePar = funCalibCamera.SaveResultToPar(par, result);
//将参数保存到结果中
bool blSaveResult = funCalibCamera.SaveResultToStdResult(par, htResult);
if (blSaveResult)
{
ShowState(string.Format("将相机{0}参数{1}保存到结果成功", g_NoCamera.ToString(), par.NameCell));
}
else
{
ShowAlarm(string.Format("将相机{0}参数{1}保存到结果失败", g_NoCamera.ToString(), par.NameCell));
return(false);
}
//保存基准图片
SaveStdImage(par, "相机校准");
//保存此单元格
bool blSave = g_BaseParComprehensive.WriteXmlDoc(par.NameCell);
if (blSave)
{
ShowState(string.Format("将相机{0}参数{1}保存到本地成功", g_NoCamera.ToString(), par.NameCell));
}
else
{
ShowAlarm(string.Format("将相机{0}参数{1}保存到本地失败", g_NoCamera.ToString(), par.NameCell));
return(false);
}
return(true);
}
catch (Exception ex)
{
WinMsgBox.ShowMsgBox(string.Format("相机{0}校准计算进入Catch", g_NoCamera.ToString()));
ShowAlarm("相机校准计算进入Catch");
Log.L_I.WriteError(NameClass, ex);
return(false);
}
}
/// <summary>
/// 多目校准，获取坐标
/// </summary>
/// <param name="pos">算子的序号，并非拍照位置</param>
/// <param name="index">拍照次序</param>
/// <param name="htResult">哈希表结果</param>
/// <returns></returns>
bool CalibMult_GetPoint(int pos, int index, out Hashtable htResult)
{
htResult = null;
Stopwatch sw = new Stopwatch();
sw.Restart();
try
{
List <string> nameCell_L = g_BaseParComprehensive.GetAllNameCellByType("多目校准");
if (nameCell_L.Count < pos)
{
WinMsgBox.ShowMsgBox("算子个数小于序号!");
return(false);
}
string nameCell = nameCell_L[pos - 1];
ParCalibMult par = g_BaseParComprehensive.GetCellParCalibrate(nameCell) as ParCalibMult;
int indexCell = int.Parse(nameCell.Replace("C", ""));//单元格索引
//关联算法，用来获取角点
ParCellExeReference parCellExeReference = par.g_ParCellExecuteReference;
ParGetResultFromCell parGetResultFromCell = par.g_ParGetResultFromCell;
//第一次获取坐标的时候，清空历史记录,不能Clear，只能赋值0
if (index == 1)
{
for (int i = 0; i < parGetResultFromCell.ResultforCalib_L.Count; i++)
{
parGetResultFromCell.ResultforCalib_L[i].XResult = 0;
parGetResultFromCell.ResultforCalib_L[i].YResult = 0;
}
}
//调用执行
g_UCDisplayCamera.GrabImageAndShow();
g_BaseDealComprehensive.DealComprehensivePosCell_ForTestRun(g_UCDisplayCamera, parCellExeReference, par.g_ParCellExecuteReference.g_CellExecute_L, out htResult);//执行算法且显示
//比对对应的单元格名称，判断结果是否正确
string cellError = "";
if (!GetErrorCell(htResult, par.g_ParCellExecuteReference.NameCellExecute_L, out cellError))
{
WinMsgBox.ShowMsgBox(string.Format("相机{0}位置{1}，单元格{2}校准计算错误", g_NoCamera.ToString(), pos.ToString(), par.NameCell));
return(false);
}
FunCellDataReferenc fun = new FunCellDataReferenc();
fun.GetResultValue(htResult, parGetResultFromCell, index - 1);
string info = string.Format("相机{0}位置{1}，单元格{2}相机多目校准触发拍照", g_NoCamera.ToString(), pos.ToString(), par.NameCell);
ShowState(info);
//保存基准图片
SaveStdImage(par, "多目校准");
//保存此单元格
bool blSave = g_BaseParComprehensive.WriteXmlDoc(par.NameCell);
if (blSave)
{
ShowState(string.Format("将相机{0}参数{1}保存到本地成功", g_NoCamera.ToString(), par.NameCell));
}
else
{
ShowAlarm(string.Format("将相机{0}参数{1}保存到本地失败", g_NoCamera.ToString(), par.NameCell));
return(false);
}
return(true);
}
catch (Exception ex)
{
WinMsgBox.ShowMsgBox(string.Format("相机{0}多目校准计算进入Catch", g_NoCamera.ToString()));
ShowAlarm("相机校准计算进入Catch");
Log.L_I.WriteError(NameClass, ex);
return(false);
}
}
/// <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);
}
}
