public int StartDownload(DownloadInfo downloadInfo)
{
TaskUnitInfo taskunitinfo = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(downloadInfo.VideoTaskUnitID);
if (taskunitinfo != null)
{
if (downloadInfo.StartTime < DataModel.Common.ZEROTIME)
{
downloadInfo.StartTime = taskunitinfo.StartTime;
}
if (downloadInfo.EndTime < DataModel.Common.ZEROTIME)
{
downloadInfo.EndTime = taskunitinfo.EndTime;
}
}
int sessionId = Framework.Container.Instance.IVXProtocol.DownloadVideoByTaskUnit(downloadInfo, 0);
if (sessionId > 0)
{
AddDownloadInfo(sessionId, downloadInfo);
}
return(sessionId);
}
void OnTaskUnitStatusChanged(uint taskUnitId)
{
if (m_taskUnitList == null)
{
return;
}
DataRow row = m_taskUnitList.Rows.Find(taskUnitId);
try
{
TaskUnitInfo taskUnitInfo = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(taskUnitId);
if (row != null && taskUnitInfo != null)
{
row["VideoAnalyzeTypeNum"] = taskUnitInfo.VideoAnalyzeTypeNum;
row["ImportStatus"] = taskUnitInfo.ImportStatus;
row["Progress"] = ((decimal)taskUnitInfo.Progress) / 10;
row["LeftTimeS"] = taskUnitInfo.LeftTimeS;
row["E_ANALYZE_OBJECT"] = GetAnalyseStatus(taskUnitInfo, E_VDA_ANALYZE_TYPE.E_ANALYZE_OBJECT);
row["E_ANALYZE_VEHICLE"] = GetAnalyseStatus(taskUnitInfo, E_VDA_ANALYZE_TYPE.E_ANALYZE_VEHICLE);
row["E_ANALYZE_FACE"] = GetAnalyseStatus(taskUnitInfo, E_VDA_ANALYZE_TYPE.E_ANALYZE_FACE);
row["E_ANALYZE_BRIEAF"] = GetAnalyseStatus(taskUnitInfo, E_VDA_ANALYZE_TYPE.E_ANALYZE_BRIEAF);
row["E_ANALYZE_VEHICLE_PIC"] = GetAnalyseStatus(taskUnitInfo, E_VDA_ANALYZE_TYPE.E_ANALYZE_VEHICLE_PIC);
row["E_ANALYZE_FACE_PIC"] = GetAnalyseStatus(taskUnitInfo, E_VDA_ANALYZE_TYPE.E_ANALYZE_FACE_PIC);
row["TaskUnitInfo"] = taskUnitInfo;
}
}
catch (SDKCallException ex)
{
Common.SDKCallExceptionHandler.Handle(ex, "根据编号获取任务单元");
}
}
public void UpdateCheckedResourcesEx(VideoPictureResource resource, bool isChecked)
{
if (resource != null)
{
if (resource.Type == ResourceType.File)
{
TaskUnitInfo taskUnit = resource.Subject as TaskUnitInfo;
if (taskUnit != null)
{
if (isChecked && !m_CheckedTaskUnitInfos.Contains(taskUnit))
{
m_CheckedTaskUnitInfos.Add(taskUnit);
}
else if (!isChecked && m_CheckedTaskUnitInfos.Contains(taskUnit))
{
m_CheckedTaskUnitInfos.Remove(taskUnit);
}
}
}
if (resource.Children != null && resource.Children.Count > 0)
{
foreach (VideoPictureResource child in resource.Children)
{
UpdateCheckedResourcesEx(child, isChecked);
}
}
}
}
public void UpdateCheckedResourcesEx(VideoPictureResource resource, bool isChecked)
{
if (resource != null)
{
if (resource.Type == ResourceType.VideoFile)
{
TaskUnitInfo taskUnit = resource.Subject as TaskUnitInfo;
if (taskUnit != null)
{
if (isChecked && !m_DTID2TaskUnitInfo.ContainsKey(taskUnit.TaskUnitID))
{
m_DTID2TaskUnitInfo.Add(taskUnit.TaskUnitID, taskUnit);
m_DTDisplayIndex2TaskUnitInfo.Add(resource.DisplayIndex, taskUnit);
}
else if (!isChecked && m_DTID2TaskUnitInfo.ContainsKey(taskUnit.TaskUnitID))
{
m_DTID2TaskUnitInfo.Remove(taskUnit.TaskUnitID);
m_DTDisplayIndex2TaskUnitInfo.Remove(resource.DisplayIndex);
}
}
}
//if (resource.Children != null && resource.Children.Count > 0)
//{
// foreach (VideoPictureResource child in resource.Children)
// {
// UpdateCheckedResourcesEx(child, isChecked);
// }
//}
}
}
public List <TaskUnitInfo> GetTaskUnitsWithoutCamera()
{
List <TaskUnitInfo> taskUnits = new List <TaskUnitInfo>();
//taskUnits.Add(new TaskUnitInfo { TaskUnitID = taskId * 10 + 1, TaskUnitName = "asdf" });
//return taskUnits;
int queryHandle = Framework.Container.Instance.IVXProtocol.QueryVideoTaskUnitListWithoutCamera();
int count = Framework.Container.Instance.IVXProtocol.GetTaskUnitTotalNum(queryHandle);
while (true)
{
TaskUnitInfo taskUnitInfo = Framework.Container.Instance.IVXProtocol.QueryNextTaskUnit(queryHandle);
if (taskUnitInfo != null)
{
taskUnits.Add(taskUnitInfo);
}
else
{
break;
}
}
Framework.Container.Instance.IVXProtocol.CloseTaskUnitListQuery(queryHandle);
return(taskUnits);
}
public void EditVideo()
{
VideoStatusInfo videoStatusInfo = Framework.Container.Instance.VideoPlayService.GetPlayStatus(CurrPlayer.HWnd);
if (videoStatusInfo != null)
{
if (videoStatusInfo.PlayState != VideoStatusType.E_STOP)
{
StopVideo();
}
TaskUnitInfo taskunit = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(videoStatusInfo.VideoTaskUnitID);
try
{
FormVideoEdit edit = new FormVideoEdit(taskunit
, taskunit.StartTime
, taskunit.StartTime.AddSeconds(videoStatusInfo.TotlePlayTime));
edit.ShowDialog();
}
catch (Exception ex)
{
SDKCallExceptionHandler.Handle(ex, "导出视频", true);
}
}
}
public void EditVideo()
{
VideoStatusInfo videoStatusInfo = Framework.Container.Instance.VideoPlayService.GetPlayStatus(m_player.HWnd);
if (videoStatusInfo != null)
{
if (videoStatusInfo.PlayState != VideoStatusType.E_STOP)
{
StopVideo();
}
TaskUnitInfo taskunit = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(videoStatusInfo.VideoTaskUnitID);
try
{
FormVideoEdit edit = new FormVideoEdit(taskunit
, m_currStartTime
, m_currEndTime);
edit.ShowDialog();
}
catch (Exception ex)
{
BOCOM.IVX.Common.SDKCallExceptionHandler.Handle(ex, "导出视频", true);
}
//return;
}
}
/// <summary>
/// 用本地播放定位实现播放文件中一段时间视频的功能
/// </summary>
/// <param name="hWnd"></param>
/// <param name="taskUnitID"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
public void PlayVideoPartialFile(IntPtr hWnd, uint taskUnitID, DateTime startTime = new DateTime(), DateTime endTime = new DateTime())
{
int playhandle = OpenVideo(hWnd, taskUnitID, startTime, endTime, false);
try
{
uint outval = 0;
Framework.Container.Instance.IVXProtocol.PlayBackControl(playhandle, E_VDA_PLAYCTRL_TYPE.E_PLAYCTRL_STOP, 0, out outval);
}
catch (SDKCallException)
{ }
if (playhandle > 0)
{
uint outval = 0;
VideoStatusInfo statinfo = new VideoStatusInfo();
statinfo.CurrPlayTime = 0;
statinfo.VideoTaskUnitID = taskUnitID;
statinfo.HWnd = hWnd;
statinfo.PlaySpeed = E_VDA_PLAY_SPEED.E_PLAYSPEED_NORMALSPEED;
statinfo.OriginalPlayState = E_VDA_PLAY_STATUS.E_PLAY_STATUS_NORMAL;
statinfo.PlayStatePriv = VideoStatusType.E_NULL;
statinfo.PlayState = VideoStatusType.E_NORMAL;
statinfo.PlayVideoHandle = playhandle;
Framework.Container.Instance.IVXProtocol.PlayBackControl(playhandle, E_VDA_PLAYCTRL_TYPE.E_PLAYCTRL_GETTIME_RANGE, 0, out outval);
statinfo.TotlePlayTime = outval;
TaskUnitInfo taskunitinfo = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(taskUnitID);
if (startTime > DataModel.Common.ZEROTIME)
{
statinfo.StartPlayTime = (uint)Math.Max(startTime.Subtract(taskunitinfo.StartTime).TotalSeconds, 0);
}
else
{
statinfo.StartPlayTime = (uint)Math.Max(startTime.Subtract(new DateTime()).TotalSeconds, 0);
}
if (endTime > DataModel.Common.ZEROTIME)
{
statinfo.EndPlayTime = (uint)endTime.Subtract(taskunitinfo.StartTime).TotalSeconds;
}
else
{
statinfo.EndPlayTime = (uint)endTime.Subtract(new DateTime()).TotalSeconds;
}
Debug.Assert(statinfo.StartPlayTime <= statinfo.TotlePlayTime && statinfo.EndPlayTime <= statinfo.TotlePlayTime);
uint startpos = 1000 * statinfo.StartPlayTime / statinfo.TotlePlayTime;
Framework.Container.Instance.IVXProtocol.PlayBackControl(playhandle, E_VDA_PLAYCTRL_TYPE.E_PLAYCTRL_PLAY_BY_SEEK, startpos, out outval);
m_DTVideoStatusList[playhandle] = statinfo;
m_DTVideoHandleList[playhandle] = hWnd;
PlayReady(playhandle);
}
}
private bool Match(TaskUnitInfo taskunit, TreeShowObjectFilter filter)
{
switch ((E_VDA_TASK_UNIT_STATUS)taskunit.ImportStatus)
{
case E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_NOUSE:
case E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_IMPORT_WAIT:
case E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_IMPORT_READY:
case E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_IMPORT_EXECUTING:
case E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_IMPORT_FAILED:
case E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_IMPORT_FINISH:
case E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_PREANALYSE_EXECUTING:
case E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_PREANALYSE_FAILED:
case E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_PREANALYSE_WAIT:
return(false);
}
if (filter == TreeShowObjectFilter.NoUse)
{
return(true);
}
bool retval = false;
foreach (E_VDA_ANALYZE_TYPE type in taskunit.AnalyzeStatus.Keys)
{
E_VDA_TASK_UNIT_STATUS status = taskunit.AnalyzeStatus[type];
if ((E_VDA_TASK_UNIT_STATUS)status != E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_ANALYSE_FINISH)
{
continue;
}
//switch ((E_VDA_TASK_UNIT_STATUS)status)
//{
// case E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_ANALYSE_WAIT:
// case E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_ANALYSE_EXECUTING:
// case E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_ANALYSE_FAILED:
// continue;
//}
if ((filter & TreeShowObjectFilter.Brief) > 0 && type == E_VDA_ANALYZE_TYPE.E_ANALYZE_BRIEAF)
{
retval = true;
}
else if ((filter & TreeShowObjectFilter.Face) > 0 && type == E_VDA_ANALYZE_TYPE.E_ANALYZE_FACE)
{
retval = true;
}
else if ((filter & TreeShowObjectFilter.Car) > 0 && type == E_VDA_ANALYZE_TYPE.E_ANALYZE_VEHICLE)
{
retval = true;
}
else if ((filter & TreeShowObjectFilter.Object) > 0 && type == E_VDA_ANALYZE_TYPE.E_ANALYZE_OBJECT)
{
retval = true;
}
}
return(retval);
}
private void RaiseTaskUnitAddedEvent(uint taskUnitId)
{
TaskUnitInfo taskUnit = Framework.Container.Instance.IVXProtocol.GetTaskUnitByID(taskUnitId);
if (taskUnit != null)
{
Framework.Container.Instance.EvtAggregator.GetEvent <TaskUnitAddedEvent>().Publish(taskUnit);
}
}
public SearchResultSingleViewModel(SearchSession session, SearchItem searchItem)
{
TaskUnitInfo info = null;
try
{
info = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(searchItem.TaskUnitId);
}
catch (SDKCallException ex)
{
info = null;
Common.SDKCallExceptionHandler.Handle(ex, "获取任务单元");
}
if (info != null)
{
CameraInfo camera = null;
try
{
camera = Framework.Container.Instance.VDAConfigService.GetCameraByID(info.CameraId);
}
catch (SDKCallException ex)
{
camera = null;
Common.SDKCallExceptionHandler.Handle(ex, "获取监控点");
}
if (camera != null)
{
Title = string.Format("{0} ({1}-{2}", camera.CameraName,
info.StartTime.ToString(DataModel.Constant.DATETIME_FORMAT),
info.EndTime.ToString(DataModel.Constant.DATETIME_FORMAT));
}
Title = info.TaskUnitName;
}
// 注册事件的时候， 可能事件已经 Fire 过了
lock (searchItem)
{
Framework.Container.Instance.EvtAggregator.GetEvent <SearchFinishedEvent>().Subscribe(OnSearchFinished, Microsoft.Practices.Prism.Events.ThreadOption.WinFormUIThread);
Framework.Container.Instance.EvtAggregator.GetEvent <SearchItemImageReceivedEvent>().Subscribe(OnSearchItemImageReceived, Microsoft.Practices.Prism.Events.ThreadOption.WinFormUIThread);
Framework.Container.Instance.EvtAggregator.GetEvent <SearchResultRecordSelectedEvent>().Subscribe(OnSearchResultRecordSelectedEvent, Microsoft.Practices.Prism.Events.ThreadOption.WinFormUIThread);
Framework.Container.Instance.EvtAggregator.GetEvent <SwitchPageBeginEvent>().Subscribe(OnSwitchPage, ThreadOption.PublisherThread);
Framework.Container.Instance.RegisterEventSubscriber(this);
m_currSearchItem = searchItem;
m_searchSessionID = session.SearchId;
m_SearchSession = session;
if (searchItem.IsFinished)
{
MyLog4Net.Container.Instance.Log.DebugFormat("Fire OnSearchFinished event in SearchResultSingleViewModel constructor, ResultSummary taskUnitID: {0}", searchItem.ResultSummary.TaskUnitID);
// 需要补上SearchBegin, SearchFinished 事件要做的事情
OnSearchFinished(searchItem.ResultSummary);
}
}
}
private string GetAnalyseStatus(TaskUnitInfo taskunitInfo, E_VDA_ANALYZE_TYPE type)
{
if (taskunitInfo.AnalyzeStatus.ContainsKey((E_VDA_ANALYZE_TYPE)type))
{
return(taskunitInfo.AnalyzeStatus[(E_VDA_ANALYZE_TYPE)type].ToString());
}
else
{
return(E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_ANALYSE_WAIT.ToString());
}
}
void OnTaskUnitAnalyseFinished(uint taskUnitId)
{
TaskUnitInfo taskUnitInfo = null;
try
{
taskUnitInfo = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(taskUnitId);
}
catch (SDKCallException ex)
{
Common.SDKCallExceptionHandler.Handle(ex, "根据编号获取任务单元");
return;
}
VideoPictureResource taskunitres = null;
foreach (VideoPictureResource item in m_RootResources)
{
taskunitres = GetResourceByTaskUnit(item, new TaskUnitInfo {
TaskUnitID = taskUnitId
});
if (taskunitres != null)
{
break;
}
}
if (taskunitres != null)
{
string name = taskUnitInfo.TaskUnitName;
if (taskUnitInfo.CameraId != 0)
{
name = string.Format("{0}[{1} - {2}]", taskUnitInfo.TaskUnitName, taskUnitInfo.StartTime.ToString(DataModel.Constant.DATETIME_FORMAT),
taskUnitInfo.EndTime.ToString(DataModel.Constant.DATETIME_FORMAT));
}
else
{
name = string.Format("{0}", taskUnitInfo.TaskUnitName);
}
taskunitres.Name = name;
taskunitres.Subject = taskUnitInfo;
if (/*taskunitres.Expand &&*/ TreeNodeEdited != null)
{
TreeNodeEdited(null, new EventEditNodeArgs {
NodeResource = taskunitres
});
}
}
else
{
OnTaskUnitAdded(taskUnitInfo);
}
}
public static SearchItem ToSearchItem(this TaskUnitInfo taskUnit, PageInfoBase pageInfo)
{
SearchItem searchItem = new SearchItem()
{
TaskUnitId = taskUnit.TaskUnitID,
PageInfo = pageInfo,
CameraId = taskUnit.CameraId
};
return(searchItem);
}
public void PlayBriefVideo()
{
if (!CheckPlayStatus(m_player.HWnd))
{
return;
}
if (SelectedFiles.Count > 0)
{
TaskUnitInfo info = SelectedFiles[0];
m_player.PlayVideoName = info.TaskUnitName;
m_player.EnabledEx = false;
ResetBriefParam();
try
{
Framework.Container.Instance.BriefVideoPlayService.ClearDrawFilterGraph(m_player.HWnd, E_VDA_BRIEF_DRAW_FILTER_TYPE.E_BRIEF_ACTION_FILTER_TYPE_NULL);
Framework.Container.Instance.BriefVideoPlayService.PlayVideo(
m_player.HWnd,
info.TaskUnitID,
m_briefDensityFilter,
BriefMoveObjTypeFilter,
(uint)Framework.Container.Instance.ColorService.GetObjectColorIndex(Color.FromArgb(BriefdwMoveObjColorFilter))
);
SetBriefDrawFilter(DrawFilterType);
TimeOverlayer = m_TimeOverlayer;
MoveObjOverlayer = m_MoveObjOverlayer;
AvtionOverlayer = m_AvtionOverlayer;
AreaOverlayer = m_AreaOverlayer;
m_currBriefTaskUnitID = info.TaskUnitID;
VodInfo vodinfo = new VodInfo();
vodinfo.VideoTaskUnitID = info.TaskUnitID;
vodinfo.StartTime = new DateTime();
vodinfo.IsPlayAllFile = true;
vodinfo.EndTime = new DateTime();
Framework.Container.Instance.EvtAggregator.GetEvent <OpenBriefPlaybackVideoEvent>().Publish(vodinfo);
}
catch (SDKCallException ex)
{
m_player.PlayVideoName = "";
m_player.EnabledEx = false;
Common.SDKCallExceptionHandler.Handle(ex, "摘要播放");
// Framework.Container.Instance.InteractionService.ShowMessageBox("失败：[" + ex.ErrorCode + "]" + ex.Message, Framework.Environment.PROGRAM_NAME);
}
finally
{
UpdateButtonStatus(m_player.HWnd);
}
}
}
private uint GetAnalyseStatus(TaskUnitInfo taskunitInfo, E_VDA_ANALYZE_TYPE type)
{
if (taskunitInfo.AnalyzeStatus.ContainsKey((E_VDA_ANALYZE_TYPE)type))
{
return((uint)taskunitInfo.AnalyzeStatus[(E_VDA_ANALYZE_TYPE)type]);
}
else
{
return((uint)E_VDA_TASK_UNIT_STATUS.E_TASK_UNIT_NOUSE);
}
}
void OnTaskUnitImportFinished(uint taskUnitId)
{
try
{
TaskUnitInfo taskUnitInfo = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(taskUnitId);
OnTaskUnitAdded(taskUnitInfo);
}
catch (SDKCallException ex)
{
Common.SDKCallExceptionHandler.Handle(ex, "根据编号获取任务单元");
}
}
private void OnTaskUnitAdded(TaskUnitInfo taskUnitInfo)
{
foreach (VideoPictureResource item in m_RootResources)
{
VideoPictureResource taskunitres = GetResourceByTaskUnit(item, taskUnitInfo);
if (taskunitres != null)
{
return;
}
}
VideoPictureResource camres = null;
foreach (VideoPictureResource item in m_RootResources)
{
camres = GetResourceByCamera(item, new CameraInfo {
CameraID = taskUnitInfo.CameraId
});
if (camres != null)
{
break;
}
}
if (camres != null /*&& camres.Expand*/)
{
if (Match(taskUnitInfo, m_filter))
{
VideoPictureResource child;
if (taskUnitInfo.CameraId != 0)
{
child = new VideoPictureResource(ResourceType.VideoFile,
string.Format("{0}[{1} - {2}]", taskUnitInfo.TaskUnitName, taskUnitInfo.StartTime.ToString(DataModel.Constant.DATETIME_FORMAT),
taskUnitInfo.EndTime.ToString(DataModel.Constant.DATETIME_FORMAT)), taskUnitInfo);
}
else
{
child = new VideoPictureResource(ResourceType.VideoFile,
string.Format("{0}", taskUnitInfo.TaskUnitName), taskUnitInfo);
}
camres.AddChild(child);
if (TreeNodeAdded != null)
{
TreeNodeAdded(null, new EventAddNodeArgs {
ParantTreeNode = camres.TreeNode, NodeResource = child
});
}
}
}
}
private void AddRow(DownloadInfo downloadInfo)
{
TaskUnitInfo tuInfo = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(downloadInfo.VideoTaskUnitID);
if (tuInfo != null)
{
string temp = "";
switch (downloadInfo.Status)
{
case VideoDownloadStatus.NOUSE:
break;
case VideoDownloadStatus.Trans_Wait:
case VideoDownloadStatus.Trans_Normal:
case VideoDownloadStatus.Trans_Finish:
case VideoDownloadStatus.Download_Wait:
case VideoDownloadStatus.Download_Normal:
temp = "导出中";
break;
case VideoDownloadStatus.Download_Finish:
temp = "导出完成";
break;
case VideoDownloadStatus.Trans_Failed:
case VideoDownloadStatus.Download_Failed:
temp = "导出失败";
break;
default:
break;
}
System.IO.FileInfo fi = new System.IO.FileInfo(downloadInfo.LocalSaveFilePath);
m_DTDownloadInfo.Rows.Add(new object[] {
downloadInfo.SessionId,
tuInfo.TaskUnitName,
fi.Name,
temp,
string.Format("{0}%", ((float)downloadInfo.ComposeProgress / 10)),
downloadInfo.LocalSaveFilePath,
"取消",
downloadInfo
});
RecordCount = m_DTDownloadInfo.Rows.Count;
}
}
private void OnOCXPlayVideo(uint taskUnitID)
{
SelectedFiles.Clear();
try
{
TaskUnitInfo info = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(taskUnitID);
if (info != null)
{
SelectedFiles.Add(info);
PlayVideo();
}
}
catch (SDKCallException ex)
{
Common.SDKCallExceptionHandler.Handle(ex, "根据编号获取任务单元");
}
}
void OnTaskUnitStatusChanged(uint taskUnitId)
{
if (m_newTaskUnitInfo.TaskUnitID != taskUnitId)
{
return;
}
try
{
TaskUnitInfo taskUnitInfo = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(taskUnitId);
if (taskUnitInfo != null)
{
m_newTaskUnitInfo.VideoAnalyzeTypeNum = taskUnitInfo.VideoAnalyzeTypeNum;
m_newTaskUnitInfo.ImportStatus = taskUnitInfo.ImportStatus;
m_newTaskUnitInfo.Progress = taskUnitInfo.Progress;
m_newTaskUnitInfo.LeftTimeS = taskUnitInfo.LeftTimeS;
m_newTaskUnitInfo.AnalyzeStatus = taskUnitInfo.AnalyzeStatus;
RaisePropertyChangedEvent("ObjectAnalyseChecked");
RaisePropertyChangedEvent("ObjectAnalyseEnable");
RaisePropertyChangedEvent("VicheilAnalyseChecked");
RaisePropertyChangedEvent("VicheilAnalyseEnable");
RaisePropertyChangedEvent("FaceAnalyseChecked");
RaisePropertyChangedEvent("FaceAnalyseEnable");
RaisePropertyChangedEvent("BriefAnalyseChecked");
RaisePropertyChangedEvent("BriefAnalyseEnable");
RaisePropertyChangedEvent("ImportStatus");
RaisePropertyChangedEvent("Title");
RaisePropertyChangedEvent("ObjectAnalyseImage");
RaisePropertyChangedEvent("ObjectAnalyseStatusImage");
RaisePropertyChangedEvent("VicheilAnalyseImage");
RaisePropertyChangedEvent("VicheilAnalyseStatusImage");
RaisePropertyChangedEvent("FaceAnalyseImage");
RaisePropertyChangedEvent("FaceAnalyseStatusImage");
RaisePropertyChangedEvent("BriefAnalyseImage");
RaisePropertyChangedEvent("BriefAnalyseStatusImage");
}
}
catch (SDKCallException ex)
{
Common.SDKCallExceptionHandler.Handle(ex, "根据编号获取任务单元");
}
}
private static string GetResourceNameByTaskUnitID(uint TaskUnitID)
{
string resourcename = string.Empty;
// 没有关联camera， 使用TaskUnit Name
TaskUnitInfo taskUnitInfo = null;
try
{
taskUnitInfo = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(TaskUnitID);
}
catch (SDKCallException ex)
{
Common.SDKCallExceptionHandler.Handle(ex, "获取任务单元");
}
resourcename = taskUnitInfo.TaskUnitName;
return(resourcename);
}
public void PlayVideo(SearchResultRecord record)
{
try
{
TaskUnitInfo taskUnit = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(record.TaskUnitID);
CurrFile = taskUnit;
DateTime dtStart = record.TargetAppearTs.AddSeconds(-5);
DateTime dtEnd = record.TargetDisappearTs.AddSeconds(10);
//if (dtStart < taskUnit.StartTime)
//{
// dtStart = taskUnit.StartTime;
//}
PlayVideo(dtStart, /*record.TargetDisappearTs*/ dtEnd); // TODO: 因为不知道TaskUnitInfo的结束时间， 加5秒无法判断是否越界。暂时不加5
}
catch (SDKCallException ex)
{
Common.SDKCallExceptionHandler.Handle(ex, "获取任务单元");
}
}
private void OnCameraSelectionChanged(List <object> list)
{
CurrFile = null;
foreach (object o in list)
{
if (o is TaskUnitInfo)
{
CurrFile = (TaskUnitInfo)o;
break;
}
}
if (CurrFile == null)
{
CurrFile = new TaskUnitInfo()
{
TaskUnitID = 0
}
}
;
}
private void OnBriefObjectPlayBack(VodInfo info)
{
if (!CheckPlayStatus(m_player.HWnd))
{
return;
}
try
{
TaskUnitInfo taskunit = Framework.Container.Instance.TaskManagerService.GetTaskUnitById(info.VideoTaskUnitID);
if (info != null)
{
SelectedFile = taskunit;
PlayVideo(info.StartTime, info.EndTime);
}
}
catch (SDKCallException ex)
{
Common.SDKCallExceptionHandler.Handle(ex, "获取任务单元");
}
}
public List <TaskUnitInfo> GetTaskUintListByTaskID(uint taskID)
{
List <TaskUnitInfo> list = new List <TaskUnitInfo>();
int lQueryHandle = Framework.Container.Instance.IVXProtocol.QueryTaskUnitList(taskID);
int count = Framework.Container.Instance.IVXProtocol.GetTaskUnitTotalNum(lQueryHandle);
while (true)
{
TaskUnitInfo taskUnitInfo = Framework.Container.Instance.IVXProtocol.QueryNextTaskUnit(lQueryHandle);
if (taskUnitInfo != null)
{
list.Add(taskUnitInfo);
}
else
{
break;
}
}
Framework.Container.Instance.IVXProtocol.CloseTaskUnitListQuery(lQueryHandle);
return(list);
}
private void OnTaskUnitAdded(TaskUnitInfo taskUnitInfo)
{
if (m_taskUnitList == null)
{
return;
}
if (taskUnitInfo.TaskID == CurrEditTask.TaskID)
{
DataRow row = m_taskUnitList.Rows.Find(taskUnitInfo.TaskUnitID);
if (row == null)
{
// 属于当前选中的任务， 任务单元中还没有包含
AddTaskUnitInfoRow(taskUnitInfo);
// CurrEditTaskUnit = taskUnitInfo;
if (TaskUnitAdded != null)
{
TaskUnitAdded(this, new TaskUnitChangedEventArgs(taskUnitInfo));
}
}
}
}
private VideoPictureResource GetResourceByTaskUnit(VideoPictureResource parantres, TaskUnitInfo taskUnitInfo)
{
if (parantres.Subject is TaskUnitInfo)
{
TaskUnitInfo info = parantres.Subject as TaskUnitInfo;
if (info.TaskUnitID == taskUnitInfo.TaskUnitID)
{
return(parantres);
}
}
else
{
foreach (VideoPictureResource item in parantres.Children)
{
VideoPictureResource ret = GetResourceByTaskUnit(item, taskUnitInfo);
if (ret != null)
{
return(ret);
}
}
}
return(null);
}
private bool CheckRunningWorks(TaskUnitInfo taskunit)
{
bool confirmed = true;
List <int> videoHandles = Framework.Container.Instance.VideoPlayService.GetPlayHandlesByTaskUnitId(taskunit.TaskUnitID);
List <int> briefVideoHandles = Framework.Container.Instance.BriefVideoPlayService.GetPlayHandlesByTaskUnitId(taskunit.TaskUnitID);
bool hasVideoWork = videoHandles != null && videoHandles.Count > 0;
bool hasBriefVideoWork = briefVideoHandles != null && briefVideoHandles.Count > 0;
if (hasVideoWork || hasBriefVideoWork)
{
confirmed = false;
string msg = string.Empty;
//if (hasVideoWork && hasBriefVideoWork)
//{
msg = string.Format("任务单元【{0}】正在播放视频或摘要视频， 删除将停止视频或摘要视频， 是否确定删除？",
taskunit.TaskUnitName);
//}
//else if (hasVideoWork)
//{
// msg = string.Format("任务单元【{0}】正在播放视频， 删除将停止视频， 是否确定删除？",
// CurrEditTaskUnit.TaskUnitName);
//}
//else if (hasBriefVideoWork)
//{
// msg = string.Format("任务单元【{0}】正在播放摘要视频， 删除将停止摘要视频， 是否确定删除？",
// CurrEditTaskUnit.TaskUnitName);
//}
if (Framework.Container.Instance.InteractionService.ShowMessageBox(
msg, Framework.Environment.PROGRAM_NAME, MessageBoxButtons.YesNo) == DialogResult.Yes)
{
confirmed = true;
}
}
return(confirmed);
}
private void AddTaskUnitInfoRow(TaskUnitInfo taskunitInfo)
{
m_taskUnitList.Rows.Add(taskunitInfo.TaskUnitID
, taskunitInfo.TaskID
, taskunitInfo.TaskUnitName
, taskunitInfo.TaskUnitSize
, taskunitInfo.TaskUnitType
, taskunitInfo.FilePathType
, taskunitInfo.FilePath
, taskunitInfo.StartTime
, taskunitInfo.EndTime
, taskunitInfo.ImportStatus
, taskunitInfo.VideoAnalyzeTypeNum
, ((decimal)taskunitInfo.Progress) / 10
, taskunitInfo.LeftTimeS
, GetAnalyseStatus(taskunitInfo, E_VDA_ANALYZE_TYPE.E_ANALYZE_OBJECT)
, GetAnalyseStatus(taskunitInfo, E_VDA_ANALYZE_TYPE.E_ANALYZE_VEHICLE)
, GetAnalyseStatus(taskunitInfo, E_VDA_ANALYZE_TYPE.E_ANALYZE_FACE)
, GetAnalyseStatus(taskunitInfo, E_VDA_ANALYZE_TYPE.E_ANALYZE_BRIEAF)
, GetAnalyseStatus(taskunitInfo, E_VDA_ANALYZE_TYPE.E_ANALYZE_VEHICLE_PIC)
, GetAnalyseStatus(taskunitInfo, E_VDA_ANALYZE_TYPE.E_ANALYZE_FACE_PIC)
, taskunitInfo
);
}
