public InspectionInfo Inspect(ImageInfo imageInfo)
{
var defectInfos = new DefectInfo[1024];
var measurementInfos = new MeasurementInfo[1024];
var inspectInfo = SimInspectorInteropApi.Inspect(imageInfo, defectInfos, measurementInfos);
var iiEntity = new InspectionInfo
{
Index = inspectInfo.Index,
SurfaceTypeIndex = inspectInfo.SurfaceTypeIndex,
HasError = (inspectInfo.HasError != 0),
};
for (int i = 0; i < inspectInfo.DefectsCount; i++)
{
var di = defectInfos[i];
// di.X = di.X - di.Width/2;
// di.Y = di.Y - di.Height/2;
iiEntity.DefectInfos.Add(di);
}
for (int i = 0; i < inspectInfo.MeasurementsCount; i++)
{
var di = measurementInfos[i];
iiEntity.MeasurementInfos.Add(di);
}
return(iiEntity);
}
private List <SqlParameter> Set_Values_In_Defects(DefectInfo defects)
{
List <SqlParameter> sqlParamList = new List <SqlParameter>();
sqlParamList.Add(new SqlParameter("@Defect_Name", defects.Defect_Name));
sqlParamList.Add(new SqlParameter("@Process_Id", defects.Process_Id));
sqlParamList.Add(new SqlParameter("@Defect_Major", defects.Defect_Major));
sqlParamList.Add(new SqlParameter("@Defect_Minor", defects.Defect_Minor));
sqlParamList.Add(new SqlParameter("@Status", defects.Status));
sqlParamList.Add(new SqlParameter("@UpdatedBy", defects.UpdatedBy));
if (defects.Defect_Id == 0)
{
sqlParamList.Add(new SqlParameter("@CreatedBy", defects.CreatedBy));
}
if (defects.Defect_Id != 0)
{
sqlParamList.Add(new SqlParameter("@Defect_Id", defects.Defect_Id));
}
return(sqlParamList);
}
public DefectInfo Get_Defects_By_Id(int Defect_Id)
{
DefectInfo defects = new DefectInfo();
List <SqlParameter> sqlParams = new List <SqlParameter>();
sqlParams.Add(new SqlParameter("@Defect_Id", Defect_Id));
DataTable dt = _sqlRepo.ExecuteDataTable(sqlParams, StoredProcedures.Get_Defect_By_Id_sp.ToString(), CommandType.StoredProcedure);
if (dt != null && dt.Rows.Count > 0)
{
int count = 0;
List <DataRow> drList = new List <DataRow>();
drList = dt.AsEnumerable().ToList();
count = drList.Count();
foreach (DataRow dr in drList)
{
defects = Get_Defect_Values(dr);
}
}
return(defects);
}
public static bool TryParse(string str, out MarkRegionInfo markRegionInfo)
{
markRegionInfo = new MarkRegionInfo();
var array = str.Split(';');
if (array == null || array.Length < 3)
{
return(false);
}
var headArray = array[0].Split(',');
EMarkDataType markType;
int x, y, w, h;
if (headArray == null || headArray.Length != 5 ||
!EMarkDataType.TryParse(headArray[0], out markType) ||
!int.TryParse(headArray[1], out x) ||
!int.TryParse(headArray[2], out y) ||
!int.TryParse(headArray[3], out w) ||
!int.TryParse(headArray[4], out h))
{
return(false);
}
markRegionInfo.MarkRegionType = markType;
markRegionInfo.SmallestRect = new Rectangle(x, y, w, h);
markRegionInfo.DefectInfos = new Dictionary <int, DefectInfo>();
for (int i = 1; i < array.Length - 1; i++)
{
var infoArray = array[i].Split(',');
int index, codeNum;
int infoX, infoY, infoW, infoH;
if (infoArray == null || infoArray.Length != 6 ||
!int.TryParse(infoArray[0], out index) ||
!int.TryParse(infoArray[1], out codeNum) ||
!int.TryParse(infoArray[2], out infoX) ||
!int.TryParse(infoArray[3], out infoY) ||
!int.TryParse(infoArray[4], out infoW) ||
!int.TryParse(infoArray[5], out infoH))
{
return(false);
}
DefectInfo defectInfo = new DefectInfo();
defectInfo.CodeNum = codeNum;
defectInfo.DefectRect = new Rectangle(infoX, infoY, infoW, infoH);
if (markRegionInfo.DefectInfos.ContainsKey(index))
{
return(false);
}
else
{
markRegionInfo.DefectInfos.Add(index, defectInfo);
}
}
return(true);
}
private DefectInfo Get_Defect_Values(DataRow dr)
{
DefectInfo defects = new DefectInfo();
defects.Defect_Id = Convert.ToInt32(dr["Defect_Id"]);
defects.Process_Id = Convert.ToInt32(dr["Process_Id"]);
if (dr["Process_Name"] != DBNull.Value)
{
defects.Process_Name = Convert.ToString(dr["Process_Name"]);
}
else
{
defects.Process_Name = "";
}
if (dr["Defect_Major"] != DBNull.Value)
{
defects.Defect_Major = Convert.ToString(dr["Defect_Major"]);
}
else
{
defects.Defect_Major = "";
}
if (dr["Defect_Minor"] != DBNull.Value)
{
defects.Defect_Minor = Convert.ToString(dr["Defect_Minor"]);
}
else
{
defects.Defect_Minor = "";
}
if (dr["Defect_Name"] != DBNull.Value)
{
defects.Defect_Name = Convert.ToString(dr["Defect_Name"]);
}
else
{
defects.Defect_Name = "";
}
defects.Status = Convert.ToBoolean(dr["Status"]);
defects.CreatedBy = Convert.ToInt32(dr["CreatedBy"]);
defects.CreatedOn = Convert.ToDateTime(dr["CreatedOn"]);
defects.UpdatedBy = Convert.ToInt32(dr["UpdatedBy"]);
defects.UpdatedOn = Convert.ToDateTime(dr["UpdatedOn"]);
return(defects);
}
public bool ReadDefectInfos(string defectName, out List <DefectInfo> defectInfoList)
{
defectInfoList = new List <DefectInfo>();
IniHelper iniHelper = new IniHelper();
string str;
if (iniHelper.ReadValue(defectName, "NumSubDefect", _fileName, out str) <= 0)
{
return(false);
}
int subDefectNum;
if (!int.TryParse(str, out subDefectNum))
{
return(false);
}
int codeNum = -1;
for (int i = 0; i < subDefectNum; i++)
{
string subDefectName = string.Format("SD_{0:0000}", i);
if (iniHelper.ReadValue(defectName, subDefectName, _fileName, out str) <= 0)
{
return(false);
}
var array = str.Split('#');
if (array != null && array.Length > 0)
{
int.TryParse(array[0], out codeNum);
}
array = str.Split('|');
foreach (var subStr in array)
{
if (subStr == null || subStr.Length == 0)
{
continue;
}
Rectangle rect;
if (DecodeSubDefect(subStr, out rect))
{
DefectInfo defectInfo = new DefectInfo();
defectInfo.CodeNum = codeNum;
defectInfo.DefectRect = rect;
defectInfoList.Add(defectInfo);
}
else
{
return(false);
}
}
}
return(true);
}
public DefectInfo Get_Defect_By_Id(int Defect_Id)
{
DefectInfo defects = new DefectInfo();
DefectRepo dRepo = new DefectRepo();
defects = dRepo.Get_Defects_By_Id(Defect_Id);
return(defects);
}
private static void Main(string[] args)
{
SimInspectorInteropApi.Init();
SimInspectorInteropApi.LoadParameters();
var dis = new DefectInfo[1024];
var mis = new MeasurementInfo[1024];
var ii = SimInspectorInteropApi.Inspect(new ImageInfo(), dis, mis);
Console.WriteLine("Press any key to exit!");
Console.ReadKey();
SimInspectorInteropApi.FreeObject();
}
public DefectViewModel()
{
Defect = new DefectInfo();
DefectGrid = new List <DefectInfo>();
EditMode = new DefectEditMode();
Filter = new DefectFilter();
Processes = new List <ProcessInfo>();
Pager = new PaginationInfo();
Friendly_Message = new List <FriendlyMessageInfo>();
}
public bool SetByDefectCell(DefectCell defectCell, int regionIndex, EMarkDataType markType)
{
if (defectCell == null ||
defectCell.DefectRegions == null ||
regionIndex < 0 ||
regionIndex >= defectCell.DefectRegions.Count ||
defectCell.DefectRegions[regionIndex] == null ||
defectCell.DefectRegions[regionIndex].DefectInfoIndexList == null ||
defectCell.DefectRegions[regionIndex].DefectInfoIndexList.Count <= 0 ||
defectCell.DefectInfos == null ||
defectCell.DefectInfos.Count <= 0)
{
return(false);
}
SingleDefectRegion defectRegion = defectCell.DefectRegions[regionIndex];
MarkRegionType = markType;
SmallestRect = new Rectangle(defectRegion.SmallestRect.X, defectRegion.SmallestRect.Y,
defectRegion.SmallestRect.Width, defectRegion.SmallestRect.Height);
DefectInfos = new Dictionary <int, DefectInfo>();
foreach (var index in defectRegion.DefectInfoIndexList)
{
if (index < 0 || index >= defectCell.DefectInfos.Count)
{
return(false);
}
DefectInfo defectInfo = new DefectInfo();
defectInfo.CodeNum = defectCell.DefectInfos[index].CodeNum;
Rectangle rect = defectCell.DefectInfos[index].DefectRect;
defectInfo.DefectRect = new Rectangle(rect.X, rect.Y, rect.Width, rect.Height);
if (DefectInfos.ContainsKey(index))
{
return(false);
}
else
{
DefectInfos.Add(index, defectInfo);
}
}
return(true);
}
public string GenString()
{
string str = MarkRegionType.ToString() + "," +
SmallestRect.X.ToString() + "," +
SmallestRect.Y.ToString() + "," +
SmallestRect.Width.ToString() + "," +
SmallestRect.Height.ToString() + ";";
foreach (var defectInfo in DefectInfos)
{
int index = defectInfo.Key;
DefectInfo info = defectInfo.Value;
str += index.ToString() + "," +
info.CodeNum.ToString() + "," +
info.DefectRect.X.ToString() + "," +
info.DefectRect.Y.ToString() + "," +
info.DefectRect.Width.ToString() + "," +
info.DefectRect.Height.ToString() + ";";
}
return(str);
}
public void Update(DefectInfo defect)
{
DefectRepo dRepo = new DefectRepo();
dRepo.Update(defect);
}
public void Init()
{
DefectInfosCollectionView = DefectInfos.GetDefaultCollectionView();
// Init SurfaceMonitors
SurfaceMonitors = new List <SurfaceMonitorViewModel>();
int surfaceCount = 0;
surfaceCount = 2;
for (int i = 0; i < surfaceCount; i++)
{
var sm = new SurfaceMonitorViewModel
{
Index = i,
SurfaceTypeIndex = i,
DisplayDefectInfo = true,
DisplayAllDefectInfos = false,
DisplayMeasurementInfo = true,
DisplayAllMeasurementInfos = false,
};
SurfaceMonitors.Add(sm);
}
//
CreateWorkpieceInfoCommand = new DelegateCommand(
() =>
{
var dialog = new OpenFileDialog()
{
Multiselect = false,
Title = "Select Image File",
};
var ret = dialog.ShowDialog();
if (ret != true)
{
return;
}
var fn = dialog.FileName;
var di = ServiceLocator.GetInstance <WorkpieceInfo>();
//di.StoreImage(fn);
di.InspectDateTime = DateTime.Now;
di.IsReject = true;
InspectionDomainService.AddWorkpieceInfo(di);
});
DeleteWorkpieceInfoCommand = new DelegateCommand <WorkpieceInfoEntryViewModel>(
(di) =>
{
if (di == null)
{
MessageBox.Show("Please select a WorkpieceInfo!");
return;
}
InspectionDomainService.DeleteWorkpieceInfo(di.Id);
},
(x) => { return(SelectedWorkpieceInfo != null); });
SelectWorkpieceInfoCommand = new DelegateCommand <WorkpieceInfoEntryViewModel>(
(workpieceInfoEntry) =>
{
// var deferRefresh= DefectInfosCollectionView.DeferRefresh();
DefectInfosCollectionView.Filter = null;
_defectInfos.Clear();
foreach (var surfaceMonitor in SurfaceMonitors)
{
surfaceMonitor.Reset();
}
HideAll();
UpdateCommandStates();
if (workpieceInfoEntry == null)
{
return;
}
var id = workpieceInfoEntry.Id;
var workpieceInfo = InspectionDomainService.GetWorkpieceInfoById(id);
var defVms = workpieceInfo.DefectInfos.Select(x => x.ToViewModel());
_defectInfos.AddRange(defVms);
for (int i = 0; i < workpieceInfo.StoredImageInfo.Count; i++)
{
var sii = workpieceInfo.StoredImageInfo[i];
var bs = sii.LoadImage();
var surfaceMonitor = SurfaceMonitors[sii.SurfaceTypeIndex];
surfaceMonitor.BitmapSource = bs;
var ds = _defectInfos.Where(x => x.SurfaceTypeIndex == surfaceMonitor.SurfaceTypeIndex).ToList();
if (ds.IsEmpty())
{
surfaceMonitor.DefectInfos = null;
surfaceMonitor.InspectState = InspectState.InspectedWithAccepted;
}
else
{
surfaceMonitor.DefectInfos = ds;
surfaceMonitor.InspectState = InspectState.InspectedWithRejected;
}
}
// deferRefresh.Dispose();
DefectInfosCollectionView.Filter = null;
DefectInfosCollectionView.Refresh();
UpdateCommandStates();
});
EventAggregator
.GetEvents <WorkpieceInfoAddedDomainEvent>()
.Subscribe(evt =>
{
var entryVm = evt.WorkpieceInfo.ToEntry().ToViewModel();
WorkpieceInfoEntries.Add(entryVm);
UpdateCommandStates();
});
EventAggregator
.GetEvents <WorkpieceInfoRemovedDomainEvent>()
.Subscribe(evt =>
{
var s = WorkpieceInfoEntries.SingleOrDefault(x => x.Id == evt.Id);
if (s != null)
{
WorkpieceInfoEntries.Remove(s);
}
UpdateCommandStates();
});
CreateDefectInfoCommand = new DelegateCommand(
() =>
{
if (SelectedWorkpieceInfo == null)
{
}
else
{
var index = DefectInfos.Count;
var defectInfo = new DefectInfo {
Width = 200, Height = 200, X = index * 100, Y = index * 100
};
InspectionDomainService.AddDefectInfo(SelectedWorkpieceInfo.Id, defectInfo);
}
},
() => { return(SelectedWorkpieceInfo != null); });
DeleteDefectInfoCommand = new DelegateCommand <DefectInfoViewModel>(
(di) =>
{
if (SelectedWorkpieceInfo == null)
{
return;
}
if (SelectedDefectInfo == null)
{
return;
}
InspectionDomainService.DeleteDefectInfo(SelectedWorkpieceInfo.Id, SelectedDefectInfo.Id);
},
(x) => { return(SelectedDefectInfo != null); });
CleanOldWorkpieceInfosCommand = new DelegateCommand(OnCleanOldWorkpieceInfosCommand);
SelectDefectInfoCommand = new DelegateCommand <DefectInfoViewModel>(
(di) =>
{
if (di != null)
{
CroppedRegionRect = new Rect(di.X, di.Y, di.Width, di.Height);
}
UpdateCommandStates();
});
CreateMonithReportCommand = new DelegateCommand(
() =>
{
var report = ReportingDomainService.GetMonthReport(SelectedMonthReportDateTime.Year,
SelectedMonthReportDateTime.Month);
if (report == null)
{
MessageDialogService.Show("没有数据，无法生成报表");
return;
}
PreviewReportingDialogService
.Show(report)
.Subscribe(args =>
{
if (args.IsCanceled)
{
return;
}
ReportingDomainService.ExportReport(args.Data);
});
});
QueryMonthRecordsCommand = new DelegateCommand(
() =>
{
var dis = ReportingDomainService.GetWorkpieceInfoEntriesByMonth(SelectedMonthReportDateTime.Year,
SelectedMonthReportDateTime.Month);
WorkpieceInfoEntries.Clear();
WorkpieceInfoEntries.AddRange(dis.Select(x => x.ToViewModel()));
});
CreateDayReportCommand = new DelegateCommand(
() =>
{
var report = ReportingDomainService.GetDayReport(SelectedDayReportDateTime.Year,
SelectedDayReportDateTime.Month,
SelectedDayReportDateTime.Day);
if (report == null)
{
MessageDialogService.Show("没有数据，无法生成报表");
return;
}
PreviewReportingDialogService
.Show(report)
.Subscribe(args =>
{
if (args.IsCanceled)
{
return;
}
ReportingDomainService.ExportReport(args.Data);
});
});
QueryDayRecordsCommand = new DelegateCommand(
() =>
{
var dis = ReportingDomainService.GetWorkpieceInfoEntriesByDay(SelectedDayReportDateTime.Year,
SelectedDayReportDateTime.Month,
SelectedDayReportDateTime.Day);
WorkpieceInfoEntries.Clear();
WorkpieceInfoEntries.AddRange(dis.Select(x => x.ToViewModel()));
});
ZoomInCommand = new DelegateCommand(
() =>
{
if (SelectedSurfaceMonitor != null)
{
SelectedSurfaceMonitor.ZoomIn();
}
_isZoomFitDisplayAreaEnabled = false;
_isZoomActualEnabled = false;
},
() => SelectedSurfaceMonitor != null);
ZoomOutCommand = new DelegateCommand(
() =>
{
if (SelectedSurfaceMonitor != null)
{
SelectedSurfaceMonitor.ZoomOut();
}
_isZoomFitDisplayAreaEnabled = false;
_isZoomActualEnabled = false;
},
() => SelectedSurfaceMonitor != null);
ZoomFitCommand = new DelegateCommand(
() =>
{
_isZoomFitDisplayAreaEnabled = !_isZoomFitDisplayAreaEnabled;
if (_isZoomFitDisplayAreaEnabled)
{
if (SelectedSurfaceMonitor != null)
{
SelectedSurfaceMonitor.ZoomFitDisplayArea();
}
}
else
{
if (SelectedSurfaceMonitor != null)
{
SelectedSurfaceMonitor.ZoomFit();
}
}
_isZoomActualEnabled = false;
},
() => SelectedSurfaceMonitor != null);
ZoomActualCommand = new DelegateCommand(
() =>
{
_isZoomActualEnabled = !_isZoomActualEnabled;
if (_isZoomActualEnabled)
{
if (SelectedSurfaceMonitor != null)
{
SelectedSurfaceMonitor.ZoomActual();
}
}
else
{
if (SelectedSurfaceMonitor != null)
{
SelectedSurfaceMonitor.ZoomFit();
}
}
_isZoomFitDisplayAreaEnabled = false;
},
() => SelectedSurfaceMonitor != null);
SaveImageToFileCommand = new DelegateCommand(
OnSaveImageToFileCommand,
() => SelectedSurfaceMonitor != null);
EventAggregator
.GetEvents <DefectInfoAddedDomainEvent>()
.Subscribe(evt =>
{
if (SelectedWorkpieceInfo == null)
{
return;
}
if (SelectedWorkpieceInfo.Id != evt.WorkpieceInfoId)
{
return;
}
_defectInfos.Add(evt.DefectInfo.ToViewModel());
UpdateCommandStates();
});
EventAggregator
.GetEvents <DefectInfoRemovedDomainEvent>()
.Subscribe(evt =>
{
if (SelectedDefectInfo != null && SelectedDefectInfo.Id == evt.DefectInfoId)
{
SelectedDefectInfo = null;
}
var di = _defectInfos.SingleOrDefault(x => x.Id == evt.DefectInfoId);
if (di != null)
{
_defectInfos.Remove(di);
}
UpdateCommandStates();
});
EventAggregator.GetEvents <ReportExportFailedEvent>()
.Subscribe(evt => { MessageBox.Show("导出失败!" + "\n\n" + evt.Exception.Message); });
EventAggregator.GetEvents <ReportExportSuccessfulEvent>()
.Subscribe(evt => { MessageBox.Show("导出成功!" + "\n\n" + evt.FileName); });
var thisMonth = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
MonthReportDateTimes.Add(thisMonth);
for (int i = 0; i < 5; i++)
{
MonthReportDateTimes.Add(thisMonth.AddMonths(-i - 1));
}
SelectedMonthReportDateTime = thisMonth;
SelectedDayReportYearMonthDateTime = thisMonth;
}
public void Insert(DefectInfo defect)
{
DefectRepo dRepo = new DefectRepo();
dRepo.Insert(defect);
}
public static extern int GetInspectDefect(int defectIndex, out DefectInfo defectInfo);
public void Update(DefectInfo defects)
{
_sqlRepo.ExecuteNonQuery(Set_Values_In_Defects(defects), StoredProcedures.Update_Defect_sp.ToString(), CommandType.StoredProcedure);
}
public static DefectInfoViewModel ToViewModel(this DefectInfo source)
{
var vm = source.Map <DefectInfo, DefectInfoViewModel>();
return(vm);
}
