private void DoExport(IBackgroundTaskContext context) { try { int i = 0; int fileCount = _files.Count; foreach (string filename in _files) { string message = String.Format(SR.MessageFormatExportingFiles, i + 1, fileCount); BackgroundTaskProgress progress = new BackgroundTaskProgress(i, fileCount, message); context.ReportProgress(progress); SaveFile(filename); if (_canceled || context.CancelRequested) { _canceled = true; context.Cancel(); return; } i++; } context.Complete(); } catch (Exception e) { context.Error(e); } }
public async ValueTask Handle(IBackgroundTaskContext context) { if (context.BackgroundTask is not ReadBackgroundTask readBackgroundTask) { return; } try { var physicalDrives = await physicalDriveManager.GetPhysicalDrives(); var commandHelper = new CommandHelper(); var readCommand = new ReadCommand(loggerFactory.CreateLogger <ReadCommand>(), commandHelper, physicalDrives, readBackgroundTask.SourcePath, readBackgroundTask.DestinationPath); readCommand.DataProcessed += async(_, args) => { await progressHubConnection.UpdateProgress(new Progress { Title = readBackgroundTask.Title, IsComplete = false, PercentComplete = args.PercentComplete, BytesProcessed = args.BytesProcessed, BytesRemaining = args.BytesRemaining, BytesTotal = args.BytesTotal, MillisecondsElapsed = args.PercentComplete > 0 ? (long)args.TimeElapsed.TotalMilliseconds : new long?(), MillisecondsRemaining = args.PercentComplete > 0 ? (long)args.TimeRemaining.TotalMilliseconds : new long?(), MillisecondsTotal = args.PercentComplete > 0 ? (long)args.TimeTotal.TotalMilliseconds : new long?() }, context.Token); }; var result = await readCommand.Execute(context.Token); await progressHubConnection.UpdateProgress(new Progress { Title = readBackgroundTask.Title, IsComplete = true, HasError = result.IsFaulted, ErrorMessage = result.IsFaulted ? result.Error.Message : null, PercentComplete = 100 }, context.Token); } catch (Exception e) { await progressHubConnection.UpdateProgress(new Progress { Title = readBackgroundTask.Title, IsComplete = true, HasError = true, ErrorMessage = e.Message, PercentComplete = 100 }, context.Token); } }
private void Process(IBackgroundTaskContext context) { try { _taskContext = context; ICollection <string> files = GetFilesToImport(); if (files.Count > 0 && !_taskContext.CancelRequested) { ConvertFiles(files); ImportFiles(); } } catch (Exception e) { Platform.Log(LogLevel.Error, e); _error = e; } if (_taskContext.CancelRequested) { _taskContext.Cancel(); } else { _taskContext.Complete(); } }
private static void ReportTaskProgress(IBackgroundTaskContext context, int index, int total, string message) { if (context != null) { context.ReportProgress(new BackgroundTaskProgress(index, total, message)); } }
private void DoMoveFolderAsync(IBackgroundTaskContext context) { var list = context.UserState as SortableResultList <ScanResultEntry>; int entryCount = list.Count; int counter = 0; foreach (ScanResultEntry entry in list) { if (context.CancelRequested) { break; } DirectoryInfo dir = new DirectoryInfo(entry.Path); if (dir.Exists) { string path = System.IO.Path.Combine(folderBrowserDialog1.SelectedPath, dir.Name); if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } DirectoryUtility.Move(entry.Path, path); counter++; context.ReportProgress(new BackgroundTaskProgress(counter * 100 / entryCount, String.Empty)); } } }
public async ValueTask Handle(IBackgroundTaskContext context) { if (context.BackgroundTask is not PhysicalDriveInfoBackgroundTask infoBackgroundTask) { return; } var physicalDrives = await physicalDriveManager.GetPhysicalDrives(); var commandHelper = new CommandHelper(); var logger = loggerFactory.CreateLogger <InfoCommand>(); var infoCommand = new InfoCommand(logger, commandHelper, physicalDrives, infoBackgroundTask.Path); infoCommand.DiskInfoRead += async(_, args) => { await resultHubConnection.SendInfoResult(args.MediaInfo.ToViewModel()); }; var result = await infoCommand.Execute(context.Token); if (result.IsFaulted) { await errorHubConnection.UpdateError(result.Error.Message, context.Token); } }
private void UpdateProgressBar(IBackgroundTaskContext context) { //TODO (CR Sept 2010): just use a timer, and all this could be done on the UI thread. while (!context.CancelRequested) { // if we didn't get a SynchronizationContext from the thread that calls .Draw(), then we can't update the progress bar SynchronizationContext synchronizationContext = _synchronizationContext; if (synchronizationContext == null) { break; } Box box = new Box(); synchronizationContext.Send(s => { if (this.ParentPresentationImage != null) { ((Box)s).Value = this.ParentPresentationImage.Visible; this.Draw(); } }, box); if (context.CancelRequested || !box.Value) { break; } Thread.Sleep(_animationTick); } }
public async ValueTask Handle(IBackgroundTaskContext context) { if (context.BackgroundTask is not ImageFileVerifyBackgroundTask verifyBackgroundTask) { return; } try { var commandHelper = new CommandHelper(); var verifyCommand = new VerifyCommand(loggerFactory.CreateLogger <VerifyCommand>(), commandHelper, Enumerable.Empty <IPhysicalDrive>(), verifyBackgroundTask.SourcePath, verifyBackgroundTask.DestinationPath); verifyCommand.DataProcessed += async(_, args) => { await progressHubContext.SendProgress(new Progress { Title = verifyBackgroundTask.Title, IsComplete = false, PercentComplete = args.PercentComplete, BytesProcessed = args.BytesProcessed, BytesRemaining = args.BytesRemaining, BytesTotal = args.BytesTotal, MillisecondsElapsed = args.PercentComplete > 0 ? (long)args.TimeElapsed.TotalMilliseconds : new long?(), MillisecondsRemaining = args.PercentComplete > 0 ? (long)args.TimeRemaining.TotalMilliseconds : new long?(), MillisecondsTotal = args.PercentComplete > 0 ? (long)args.TimeTotal.TotalMilliseconds : new long?() }, context.Token); }; var result = await verifyCommand.Execute(context.Token); await progressHubContext.SendProgress(new Progress { Title = verifyBackgroundTask.Title, IsComplete = true, HasError = result.IsFaulted, ErrorMessage = result.IsFaulted ? result.Error.Message : null, PercentComplete = 100 }, context.Token); } catch (Exception e) { await progressHubContext.SendProgress(new Progress { Title = verifyBackgroundTask.Title, IsComplete = true, HasError = true, ErrorMessage = e.Message, PercentComplete = 100 }, context.Token); } }
private void UpdateProgress(IBackgroundTaskContext context, string status, int batch, int lineCount) { int importedRows = Math.Min(batch * _batchSize, lineCount); float percentage = (lineCount == 0) ? 0 : 100 * ((float)importedRows) / (float)lineCount; string message = string.Format("{0} - processed {1} rows.", status, importedRows); context.ReportProgress(new BackgroundTaskProgress((int)percentage, message)); }
private void ExportImages(IBackgroundTaskContext context, ref List <IPresentationImage> imagesToDispose) { ExportImageParams exportParams = new ExportImageParams(); exportParams.Scale = Scale; exportParams.ExportOption = _exportOption; exportParams.DisplayRectangle = _clipboardItem.DisplayRectangle; exportParams.SizeMode = SizeMode; exportParams.OutputSize = new Size(Width, Height); exportParams.BackgroundColor = BackgroundColor; using (Avi.VideoStreamWriter writer = new Avi.VideoStreamWriter(_selectedCodec)) { if (!UseDefaultQuality) { writer.Quality = _quality; } for (int i = 0; i < NumberOfImages; ++i) { if (context != null && context.CancelRequested) { break; } if (context != null) { int number = i + 1; string message = String.Format(SR.MessageFormatExportingFrame, number, NumberOfImages); ReportProgress(context, message, number); } IPresentationImage image = ImageExporter.ClonePresentationImage(DisplaySet.PresentationImages[i]); imagesToDispose.Add(image); using (Bitmap bitmap = ImageExporter.DrawToBitmap(image, exportParams)) { if (!writer.IsOpen) { //many codecs (like DivX) expect width and/or height to be divisible by 4. int width = NormalizeDimension(bitmap.Width); int height = NormalizeDimension(bitmap.Height); writer.Width = width; writer.Height = height; writer.FrameRate = this.FrameRate; writer.Open(this.FilePath); } writer.AddBitmap(bitmap); } } } }
private void DoImport(IBackgroundTaskContext context) { int lineCount = 0; int batch = 0; try { lineCount = PrescanFile(); using (StreamReader reader = File.OpenText(_filename)) { // treat as csv List <string> lines = null; while ((lines = ReadLines(reader, _batchSize)).Count > 0) { if (context.CancelRequested) { break; } try { Platform.GetService <IImportService>( delegate(IImportService service) { service.ImportCsv(new ImportCsvRequest(_importType, lines)); }); } catch (FaultException <ImportException> e) { // unwrap the fault exception throw e.Detail; } UpdateProgress(context, "Importing", batch++, lineCount); } } if (context.CancelRequested) { UpdateProgress(context, "Cancelled", batch, lineCount); context.Cancel(); } else { UpdateProgress(context, "Completed", batch, lineCount); context.Complete(null); } } catch (Exception e) { UpdateProgress(context, "Error", batch, lineCount); context.Error(e); } }
private void ReportProgress(IBackgroundTaskContext context, string message, int currentStep) { if (context == null) { return; } int percent = Math.Min((int)(currentStep / (float)NumberOfImages * 100), 100); context.ReportProgress(new BackgroundTaskProgress(percent, message)); }
private void DoPrint(IBackgroundTaskContext context) { try { if (_selectPresentationsInformations == null || _selectPresentationsInformations.Count == 0) { return; } Thread.Sleep(20); BackgroundTaskReportStatus(context, "Dicom打印开始", 0); Thread.Sleep(10); BackgroundTaskReportStatus(context, "开始处理图像...", 0); Thread.Sleep(10); //UISynchronizationContext.Send(DoImageProcess, null); DoImageProcess(null); if (_selectPresentationsInformations.Count == 0) { BackgroundTaskReportStatus(context, "处理图像处理结果为0", 0); return; } BackgroundTaskReportStatus(context, "开始向打印机发送图像", 0); Thread.Sleep(10); PrintScu scu = new PrintScu(); DicomPrintProgressUpdate progressUpdate = new DicomPrintProgressUpdate(); progressUpdate.dicomPrintManager = this; progressUpdate.printScu = scu; progressUpdate.Task = context; scu.ProgressUpdated += progressUpdate.Update; _dicomPrintSession = new DicomPrintSession(DicomPrinter, new SelectPresentationsInformationsCollection(_selectPresentationsInformations)); PrintScu.FilmSession filmSession = DicomPrintSession.GetFilmSession(_dicomPrintSession.SelectPresentationsCollection, _dicomPrintSession.DicomPrinter.Config); DicomState dicomState = scu.Print("MacroAETile", _dicomPrintSession.DicomPrinter.AETitle, _dicomPrintSession.DicomPrinter.Host, _dicomPrintSession.DicomPrinter.Port, filmSession); scu.Join(); if (dicomState == DicomState.Success) { //UpDicomPrintStatus(context); if (_dicomPrintComponent != null) { UISynchronizationContext.Send(_dicomPrintComponent.PrintedDeleteImage, this); } } } catch (Exception e) { Platform.Log(LogLevel.Debug, e); BackgroundTaskReportStatus(context, e.Message, 100); } if (_studyInstanceUid != null) { _studyInstanceUid.Clear(); _studyInstanceUid = null; } GC.Collect(); }
private void StartScaning(IBackgroundTaskContext context) { FolderScanner owner = context.UserState as FolderScanner; DirectoryInfo dir = new DirectoryInfo(owner.Path); int dirCount = 0; if (dir.Exists) { context.ReportProgress(new BackgroundTaskProgress(0, "Starting..")); DirectoryInfo[] subDirs = dir.GetDirectories(); _foldersCount = subDirs.Length; string path = dir.FullName.TrimEnd(new[] { System.IO.Path.DirectorySeparatorChar }); string[] dirs = path.Split(new [] { System.IO.Path.DirectorySeparatorChar }); string partitionFolder = dirs.Length >= 2 ? dirs[dirs.Length - 2] : string.Empty; ServerEntityKey partitionKey = GetPartitionKey(partitionFolder); if (partitionKey == null) { context.ReportProgress(new BackgroundTaskProgress(100, "Folder does not match a partition...")); return; } foreach (DirectoryInfo subDir in subDirs) { if (context.CancelRequested) { break; } try { var result = ProcessDir(subDir, partitionKey); ScanResultSet.Results.Add(result); } catch (Exception ex) { MessageBox.Show(ex.Message); } finally { dirCount++; context.ReportProgress(new BackgroundTaskProgress(dirCount * 100 / _foldersCount, String.Format("Scanning {0}", subDir.FullName))); } } } }
private void Go(IBackgroundTaskContext context) { string studyUid = DicomUid.GenerateUid().UID; string seriesUid = DicomUid.GenerateUid().UID; PixelAspectRatioChanger changer = new PixelAspectRatioChanger { IncreasePixelDimensions = _component.IncreasePixelDimensions, NewAspectRatio = new PixelAspectRatio(_component.AspectRatioRow, _component.AspectRatioColumn), RemoveCalibration = _component.RemoveCalibration }; int i = 0; context.ReportProgress(new BackgroundTaskProgress(i, _dicomFileNames.Count, "Exporting ...")); try { foreach (string originalFile in _dicomFileNames) { var file = new DicomFile(originalFile); file.Load(DicomReadOptions.None); string sopInstanceUid = DicomUid.GenerateUid().UID; file.DataSet[DicomTags.StudyInstanceUid].SetStringValue(studyUid); file.DataSet[DicomTags.SeriesInstanceUid].SetStringValue(seriesUid); file.DataSet[DicomTags.SopInstanceUid].SetStringValue(sopInstanceUid); changer.ChangeAspectRatio(file); string outputFileName = Path.Combine(_outputDirectory, String.Format("{0}.dcm", sopInstanceUid)); file.Save(outputFileName); if (context.CancelRequested) { context.Cancel(); return; } context.ReportProgress(new BackgroundTaskProgress(++i, _dicomFileNames.Count + 1, "Exporting ...")); } } catch (Exception e) { context.Error(e); return; } context.Complete(); }
private void LoadVolume(IBackgroundTaskContext context) { try { ProgressTask mainTask = new ProgressTask(); mainTask.AddSubTask("BUILD", 90); mainTask.AddSubTask("LAYOUT", 10); context.ReportProgress(new BackgroundTaskProgress(mainTask.IntPercent, string.Format(SR.MessageInitializingMpr, mainTask.Progress))); BackgroundTaskParams @params = (BackgroundTaskParams)context.UserState; Volume volume = Volume.Create(@params.Frames, delegate(int i, int count) { if (context.CancelRequested) { throw new BackgroundTaskCancelledException(); } if (i == 0) { mainTask["BUILD"].AddSubTask("", count); } mainTask["BUILD"][""].Increment(); string message = string.Format(SR.MessageBuildingMprVolumeProgress, mainTask.Progress, i + 1, count, mainTask["BUILD"].Progress); context.ReportProgress(new BackgroundTaskProgress(mainTask.IntPercent, message)); }); mainTask["BUILD"].MarkComplete(); context.ReportProgress(new BackgroundTaskProgress(mainTask.IntPercent, string.Format(SR.MessagePerformingMprWorkspaceLayout, mainTask.Progress))); //call layout here b/c it could take a while @params.SynchronizationContext.Send(delegate { _viewer = new MprViewerComponent(volume); _viewer.Layout(); }, null); mainTask["LAYOUT"].MarkComplete(); context.ReportProgress(new BackgroundTaskProgress(mainTask.IntPercent, string.Format(SR.MessageDone, mainTask.Progress))); context.Complete(); } catch (BackgroundTaskCancelledException) { context.Cancel(); } catch (Exception ex) { context.Error(ex); } }
private static void LoadWorker(IBackgroundTaskContext context) { State state = context.UserState as State; if (state == null) { context.Cancel(); return; } context.ReportProgress(new BackgroundTaskProgress(0, 1000, SR.MessageLoading)); if (context.CancelRequested) { context.Cancel(); return; } List <string> fileList = new List <string>(); try { foreach (string path in state.Paths) { fileList.AddRange(EnumerateFiles(path, state.Recursive)); } } catch (Exception ex) { context.Error(ex); return; } for (int n = 0; n < fileList.Count; n++) { context.ReportProgress(new BackgroundTaskProgress(n, fileList.Count, SR.MessageLoading)); if (context.CancelRequested) { context.Cancel(); return; } state.SynchronizationContext.Send(i => state.Component.Load(fileList[(int)i]), n); } if (context.CancelRequested) { context.Cancel(); return; } context.Complete(); }
private VolumeData LoadVolume(IBackgroundTaskContext context) { // TODO (CR Apr 2013): Ideally, loading and unloading could be done with minimal locking; this way, // Unload actually has to wait for Load to finish and vice versa. I think a quicker way would be to // have a _loading field - have this method set it inside the lock, then proceed to do the load, // then set the _volume field when done. Have Unload check _loading and just return, otherwise set _volume to null. // Basically, you don't need to lock the entire load operation - you only need to guarantee that multiple loads // can't occur at once, and that Unload actually unloads it. // wait for synchronized access lock (_syncVolumeDataLock) { _largeObjectData.Lock(); try { // if the data is now available, return it immediately // (i.e. we were blocked because we were already reading the data) if (_volume != null) { return(_volume); } // load the volume data if (context == null) { _volume = VolumeData.Create(_frames); } else { _volume = VolumeData.Create(_frames, (n, count) => context.ReportProgress(new BackgroundTaskProgress(n, count, SR.MessageFusionInProgress))); } // update our stats _largeObjectData.BytesHeldCount = 2 * _volume.SizeInVoxels; _largeObjectData.LargeObjectCount = 1; _largeObjectData.UpdateLastAccessTime(); // regenerating the volume data takes a few seconds _largeObjectData.RegenerationCost = LargeObjectContainerData.PresetComputedData; // register with memory manager MemoryManager.Add(this); return(_volume); } finally { _largeObjectData.Unlock(); } } }
private void ChangeToSyntax(IBackgroundTaskContext context) { var study = (StudyTableItem)context.UserState; try { _tempPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "ClearCanvas"); _tempPath = System.IO.Path.Combine(_tempPath, "Compression"); _tempPath = System.IO.Path.Combine(_tempPath, Path.GetRandomFileName()); string message = String.Format("Changing transfer syntax to: {0}", _syntax); context.ReportProgress(new BackgroundTaskProgress(0, message)); var loader = study.Server.GetService <IStudyLoader>(); int numberOfSops = loader.Start(new StudyLoaderArgs(study.StudyInstanceUid, null)); if (numberOfSops <= 0) { return; } for (int i = 0; i < numberOfSops; ++i) { Sop sop = loader.LoadNextSop(); if (sop != null) { if (sop.DataSource is ILocalSopDataSource) { string filename = Path.Combine(_tempPath, string.Format("{0}.dcm", i)); DicomFile file = ((ILocalSopDataSource)sop.DataSource).File; file.ChangeTransferSyntax(_syntax); file.Save(filename); } } int progressPercent = (int)Math.Floor((i + 1) / (float)numberOfSops * 100); context.ReportProgress(new BackgroundTaskProgress(progressPercent, message)); } //trigger an import of the anonymized files. var client = new DicomFileImportBridge(); client.ImportFileList(new List <string> { _tempPath }, BadFileBehaviourEnum.Move, FileImportBehaviourEnum.Move); context.Complete(); } catch (Exception e) { context.Error(e); } }
private void Complete() { if (IsAsynchronous) { ItemsToExport.ForEach(delegate(IClipboardItem item) { item.Unlock(); }); } _progressComponentShelf = null; //notify the owner that we're done. _exportComponent.OnMultipleImageExportComplete(_error); _error = null; _taskContext = null; }
private void ExportImages(IBackgroundTaskContext context) { List <IPresentationImage> imagesToDispose = new List <IPresentationImage>(); EventResult result = EventResult.Success; AuditedInstances exportedInstances = new AuditedInstances(); foreach (IPresentationImage image in this.DisplaySet.PresentationImages) { IImageSopProvider sopProv = image as IImageSopProvider; if (sopProv != null) { exportedInstances.AddInstance(sopProv.ImageSop.PatientId, sopProv.ImageSop.PatientsName, sopProv.ImageSop.StudyInstanceUid, this.FilePath); } } try { ReportProgress(context, SR.MessageCreatingVideo, 0); ExportImages(context, ref imagesToDispose); if (context != null) { if (context.CancelRequested) { ReportProgress(context, SR.MessageCancelled, NumberOfImages); context.Cancel(); } else { ReportProgress(context, SR.MessageExportComplete, NumberOfImages); context.Complete(); } } } catch (Exception e) { _error = e; result = EventResult.SeriousFailure; Platform.Log(LogLevel.Error, e); } finally { AuditHelper.LogExportStudies(exportedInstances, EventSource.CurrentUser, result); imagesToDispose.ForEach(delegate(IPresentationImage image) { image.Dispose(); }); } }
public async ValueTask Handle(IBackgroundTaskContext context) { if (context.BackgroundTask is not BlankBackgroundTask blankBackgroundTask) { return; } try { await progressHubContext.SendProgress(new Progress { Title = blankBackgroundTask.Title, IsComplete = false, PercentComplete = 50, }, context.Token); var commandHelper = new CommandHelper(); var blankCommand = new BlankCommand(loggerFactory.CreateLogger <BlankCommand>(), commandHelper, blankBackgroundTask.Path, blankBackgroundTask.CompatibleSize ? Convert.ToInt64(blankBackgroundTask.Size * 0.95) : blankBackgroundTask.Size); var result = await blankCommand.Execute(context.Token); await Task.Delay(1000, context.Token); await progressHubContext.SendProgress(new Progress { Title = blankBackgroundTask.Title, IsComplete = true, HasError = result.IsFaulted, ErrorMessage = result.IsFaulted ? result.Error.Message : null, PercentComplete = 100 }, context.Token); } catch (Exception e) { await progressHubContext.SendProgress(new Progress { Title = blankBackgroundTask.Title, IsComplete = true, HasError = true, ErrorMessage = e.Message, PercentComplete = 100 }, context.Token); } }
private void UpDicomPrintStatus(IBackgroundTaskContext context) { try { BackgroundTaskReportStatus(context, "更新打印状态", 100); Thread.Sleep(10); string str = Path.Combine(Environment.CurrentDirectory, "PrintStatus.dll"); if (!File.Exists(str)) { this.BackgroundTaskReportStatus(context, "执行更新的DLL不存在", 100); Thread.Sleep(10); return; } Assembly assembly = Assembly.LoadFile(str); Type type = assembly.GetType("PrintStatus.StudyKeyList"); object list = Activator.CreateInstance(typeof(List <>).MakeGenericType(new Type[] { type }), (object[])null); MethodInfo listAdd = list.GetType().GetMethod("Add", BindingFlags.Public | BindingFlags.Instance); foreach (string studyInstanceUid in _studyInstanceUid) { object studyKeyList = assembly.CreateInstance("PrintStatus.StudyKeyList"); MethodInfo setSpecialNeeds = studyKeyList.GetType().GetMethod("set_Special_needs", BindingFlags.Public | BindingFlags.Instance); MethodInfo setStudyInstanceUid = studyKeyList.GetType().GetMethod("set_Study_instance_uid", BindingFlags.Public | BindingFlags.Instance); setSpecialNeeds.Invoke(studyKeyList, new object[] { "已打印" }); setStudyInstanceUid.Invoke(studyKeyList, new object[] { studyInstanceUid }); listAdd.Invoke(list, new object[] { studyKeyList }); } object study = assembly.CreateInstance("PrintStatus.Study"); bool flag = (bool)(study.GetType().GetMethod("UpdateStudySpecial_needs", BindingFlags.Public | BindingFlags.Instance).Invoke(study, new object[] { list })); if (flag) { BackgroundTaskReportStatus(context, "更新打印状态成功", 100); Thread.Sleep(10); } else { BackgroundTaskReportStatus(context, "更新打印状态失败", 100); Thread.Sleep(10); } } catch (Exception exception) { BackgroundTaskReportStatus(context, "更新打印状态失败:" + exception.Message, 100); Thread.Sleep(10); } }
public async ValueTask Handle(IBackgroundTaskContext context) { if (context.BackgroundTask is not OptimizeBackgroundTask optimizeBackgroundTask) { return; } try { await progressHubContext.SendProgress(new Progress { Title = optimizeBackgroundTask.Title, IsComplete = false, PercentComplete = 50, }, context.Token); var commandHelper = new CommandHelper(); var optimizeCommand = new OptimizeCommand(loggerFactory.CreateLogger <OptimizeCommand>(), commandHelper, optimizeBackgroundTask.Path); var result = await optimizeCommand.Execute(context.Token); await Task.Delay(1000, context.Token); await progressHubContext.SendProgress(new Progress { Title = optimizeBackgroundTask.Title, IsComplete = true, HasError = result.IsFaulted, ErrorMessage = result.IsFaulted ? result.Error.Message : null, PercentComplete = 100 }, context.Token); } catch (Exception e) { await progressHubContext.SendProgress(new Progress { Title = optimizeBackgroundTask.Title, IsComplete = true, HasError = true, ErrorMessage = e.Message, PercentComplete = 100 }, context.Token); } }
public async ValueTask Handle(IBackgroundTaskContext context) { var physicalDrives = await physicalDriveManager.GetPhysicalDrives(); var commandHelper = new CommandHelper(); var listCommand = new ListCommand(loggerFactory.CreateLogger <ListCommand>(), commandHelper, physicalDrives); listCommand.ListRead += async(_, args) => { await resultHubConnection.SendListResult(args.MediaInfos.Select(x => x.ToViewModel()).ToList()); }; var result = await listCommand.Execute(context.Token); if (result.IsFaulted) { await errorHubConnection.UpdateError(result.Error.Message, context.Token); } }
private void BackgroundSendAnnotationsToAimService(IBackgroundTaskContext context) { var xmlAnnotations = context.UserState as Dictionary <string, string>; try { if (xmlAnnotations != null && xmlAnnotations.Count > 0) { var progress = new BackgroundTaskProgress(20, string.Format("Sending {0} annotation(s) to AIM data service.", xmlAnnotations.Count)); context.ReportProgress(progress); AIMTCGAService.AIMTCGASubmit.sendAIMTCGAAnnotation(new List <string>(xmlAnnotations.Values).ToArray()); } context.Complete(); } catch (Exception ex) { SaveAnnotationsToQueue(xmlAnnotations, AIMTCGAService.AIMTCGASubmit.ServiceUrl); context.Error(ex); } }
private static void LoadWorker(IBackgroundTaskContext context) { State state = context.UserState as State; if (state == null) { context.Cancel(); return; } context.ReportProgress(new BackgroundTaskProgress(0, 1000, SR.MessageLoading)); if (context.CancelRequested) { context.Cancel(); return; } List<string> fileList = new List<string>(); foreach (string path in state.Paths) fileList.AddRange(EnumerateFiles(path, state.Recursive)); for (int n = 0; n < fileList.Count; n++) { context.ReportProgress(new BackgroundTaskProgress(n, fileList.Count, SR.MessageLoading)); if (context.CancelRequested) { context.Cancel(); return; } state.SynchronizationContext.Send(delegate { state.Component.Load(fileList[n]); }, null); } if (context.CancelRequested) { context.Cancel(); return; } context.Complete(); }
private void Export(IBackgroundTaskContext context) { EventResult result = EventResult.Success; AuditedInstances exportedInstances = GetInstancesForAudit(ItemsToExport, this._exportComponent.ExportFilePath); try { _taskContext = context; Export(); } catch (Exception e) { _error = e; result = EventResult.SeriousFailure; Platform.Log(LogLevel.Error, e); } finally { AuditHelper.LogExportStudies(exportedInstances, EventSource.CurrentUser, result); _imagesToDispose.ForEach(delegate(IPresentationImage image) { image.Dispose(); }); } }
private async ValueTask ShowSaveDialogWorkItem(IBackgroundTaskContext context) { if (!HybridSupport.IsElectronActive) { return; } if (context.BackgroundTask is not ShowDialogBackgroundTask showDialogBackgroundTask) { return; } var browserWindow = Electron.WindowManager.BrowserWindows.FirstOrDefault(); if (browserWindow == null) { return; } var path = await Electron.Dialog.ShowSaveDialogAsync(browserWindow, new SaveDialogOptions { Title = showDialogBackgroundTask.Title, Filters = showDialogBackgroundTask.FileFilters.Select(x => new FileFilter { Name = x.Name, Extensions = x.Extensions.ToArray() }).ToArray(), DefaultPath = showDialogBackgroundTask.Path }); await showDialogResultContext.Clients.All.SendAsync("ShowDialogResult", new ShowDialogResult { Id = showDialogBackgroundTask.Id, IsSuccess = !string.IsNullOrWhiteSpace(path), Paths = new [] { path } }, context.Token); }
private void Run(IBackgroundTaskContext context) { SopGenerator[] generatorArray = _generator.ToArray(); int completedDayStudies = 0; DateTime currentDay = _startDate; int currentStudiesPerDay = currentDay.DayOfWeek == DayOfWeek.Saturday || currentDay.DayOfWeek == DayOfWeek.Sunday ? _studiesPerDay * _percentWeekend / 100 : _studiesPerDay; _completedStudies = 0; while (_completedStudies < _totalStudies - 1) { InsertStudy(generatorArray[_rand.Next(1, generatorArray.Length)], currentDay); completedDayStudies++; _completedStudies++; if (completedDayStudies > currentStudiesPerDay) { currentDay = currentDay.AddDays(1); currentStudiesPerDay = currentDay.DayOfWeek == DayOfWeek.Saturday || currentDay.DayOfWeek == DayOfWeek.Sunday ? _studiesPerDay * _percentWeekend / 100 : _studiesPerDay; completedDayStudies = 0; } if ((_completedStudies % 10) == 0) { context.ReportProgress(new BackgroundTaskProgress(_completedStudies, _totalStudies, "Studies Created")); } if (context.CancelRequested) { return; } } }
private VolumeData LoadVolume(IBackgroundTaskContext context) { // wait for synchronized access lock (_syncVolumeDataLock) { // if the data is now available, return it immediately // (i.e. we were blocked because we were already reading the data) if (_volume != null) { return(_volume); } // load the volume data if (context == null) { _volume = VolumeData.Create(_frames); } else { _volume = VolumeData.Create(_frames, (n, count) => context.ReportProgress(new BackgroundTaskProgress(n, count, SR.MessageFusionInProgress))); } // update our stats _largeObjectData.BytesHeldCount = 2 * _volume.SizeInVoxels; _largeObjectData.LargeObjectCount = 1; _largeObjectData.UpdateLastAccessTime(); // regenerating the volume data is easy when the source frames are already in memory! _largeObjectData.RegenerationCost = RegenerationCost.Low; // register with memory manager MemoryManager.Add(this); return(_volume); } }
private void ChangeToSyntax(IBackgroundTaskContext context) { var study = (StudyTableItem)context.UserState; try { _tempPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "ClearCanvas"); _tempPath = System.IO.Path.Combine(_tempPath, "Compression"); _tempPath = System.IO.Path.Combine(_tempPath, Path.GetRandomFileName()); string message = String.Format("Changing transfer syntax to: {0}", _syntax); context.ReportProgress(new BackgroundTaskProgress(0, message)); var loader = study.Server.GetService<IStudyLoader>(); int numberOfSops = loader.Start(new StudyLoaderArgs(study.StudyInstanceUid, null, StudyLoaderOptions.Default)); if (numberOfSops <= 0) return; for (int i = 0; i < numberOfSops; ++i) { Sop sop = loader.LoadNextSop(); if (sop != null) { if (sop.DataSource is ILocalSopDataSource) { string filename = Path.Combine(_tempPath, string.Format("{0}.dcm", i)); DicomFile file = ((ILocalSopDataSource)sop.DataSource).File; file.ChangeTransferSyntax(_syntax); file.Save(filename); } } int progressPercent = (int)Math.Floor((i + 1) / (float)numberOfSops * 100); context.ReportProgress(new BackgroundTaskProgress(progressPercent, message)); } //trigger an import of the anonymized files. var client = new DicomFileImportBridge(); client.ImportFileList(new List<string> {_tempPath}, BadFileBehaviourEnum.Move, FileImportBehaviourEnum.Move); context.Complete(); } catch(Exception e) { context.Error(e); } }
private void UpdateProgressBar(IBackgroundTaskContext context) { //TODO (CR Sept 2010): just use a timer, and all this could be done on the UI thread. while (!context.CancelRequested) { // if we didn't get a SynchronizationContext from the thread that calls .Draw(), then we can't update the progress bar SynchronizationContext synchronizationContext = _synchronizationContext; if (synchronizationContext == null) break; Box box = new Box(); synchronizationContext.Send(s => { if (this.ParentPresentationImage != null) { ((Box) s).Value = this.ParentPresentationImage.Visible; this.Draw(); } }, box); if (context.CancelRequested || !box.Value) break; Thread.Sleep(_animationTick); } }
private void Anonymize(IBackgroundTaskContext context) { //TODO (Marmot) This probably should be its own WorkItem type and have it done in the background there. var study = (StudyTableItem) context.UserState; var anonymizedInstances = new AuditedInstances(); try { context.ReportProgress(new BackgroundTaskProgress(0, SR.MessageAnonymizingStudy)); var loader = study.Server.GetService<IStudyLoader>(); int numberOfSops = loader.Start(new StudyLoaderArgs(study.StudyInstanceUid, null)); if (numberOfSops <= 0) return; var anonymizer = new DicomAnonymizer {StudyDataPrototype = _component.AnonymizedData}; if (_component.PreserveSeriesData) { //The default anonymizer removes the series data, so we just clone the original. anonymizer.AnonymizeSeriesDataDelegate = original => original.Clone(); } // Setup the ImportFilesUtility to perform the import var configuration = DicomServer.GetConfiguration(); // setup auditing information var result = EventResult.Success; string patientsSex = null; for (int i = 0; i < numberOfSops; ++i) { using (var sop = loader.LoadNextSop()) { if (sop != null && (_component.KeepReportsAndAttachments || !IsReportOrAttachmentSopClass(sop.SopClassUid))) { //preserve the patient sex. if (patientsSex == null) anonymizer.StudyDataPrototype.PatientsSex = patientsSex = sop.PatientsSex ?? ""; var localSopDataSource = sop.DataSource as ILocalSopDataSource; if (localSopDataSource != null) { string filename = string.Format("{0}.dcm", i); DicomFile file = (localSopDataSource).File; // make sure we anonymize a new instance, not the same instance that the Sop cache holds!! file = new DicomFile(filename, file.MetaInfo.Copy(), file.DataSet.Copy()); anonymizer.Anonymize(file); // TODO (CR Jun 2012): Importing each file separately? Platform.GetService((IPublishFiles w) => w.PublishLocal(new List<DicomFile> {file})); string studyInstanceUid = file.DataSet[DicomTags.StudyInstanceUid].ToString(); string patientId = file.DataSet[DicomTags.PatientId].ToString(); string patientsName = file.DataSet[DicomTags.PatientsName].ToString(); anonymizedInstances.AddInstance(patientId, patientsName, studyInstanceUid); var progressPercent = (int)Math.Floor((i + 1) / (float)numberOfSops * 100); var progressMessage = String.Format(SR.MessageAnonymizingStudy, file.MediaStorageSopInstanceUid); context.ReportProgress(new BackgroundTaskProgress(progressPercent, progressMessage)); } } } } AuditHelper.LogCreateInstances(new[]{configuration.AETitle}, anonymizedInstances, EventSource.CurrentUser, result); context.Complete(); } catch (Exception e) { AuditHelper.LogCreateInstances(new[] { string.Empty }, anonymizedInstances, EventSource.CurrentUser, EventResult.MajorFailure); context.Error(e); } }
private void DoExport(IBackgroundTaskContext context) { try { int i = 0; int fileCount = _files.Count; foreach (string filename in _files) { string message = String.Format(SR.MessageFormatExportingFiles, i + 1, fileCount); BackgroundTaskProgress progress = new BackgroundTaskProgress(i, fileCount, message); context.ReportProgress(progress); SaveFile(filename); if (_canceled || context.CancelRequested) { _canceled = true; context.Cancel(); return; } i++; } context.Complete(); } catch (Exception e) { context.Error(e); } }
private void Go(IBackgroundTaskContext context) { string studyUid = DicomUid.GenerateUid().UID; string seriesUid = DicomUid.GenerateUid().UID; PixelAspectRatioChanger changer = new PixelAspectRatioChanger { IncreasePixelDimensions = _component.IncreasePixelDimensions, NewAspectRatio = new PixelAspectRatio(_component.AspectRatioRow, _component.AspectRatioColumn), RemoveCalibration = _component.RemoveCalibration }; int i = 0; context.ReportProgress(new BackgroundTaskProgress(i, _dicomFileNames.Count, "Exporting ...")); try { foreach (string originalFile in _dicomFileNames) { var file = new DicomFile(originalFile); file.Load(DicomReadOptions.None); string sopInstanceUid = DicomUid.GenerateUid().UID; file.DataSet[DicomTags.StudyInstanceUid].SetStringValue(studyUid); file.DataSet[DicomTags.SeriesInstanceUid].SetStringValue(seriesUid); file.DataSet[DicomTags.SopInstanceUid].SetStringValue(sopInstanceUid); changer.ChangeAspectRatio(file); string outputFileName = Path.Combine(_outputDirectory, String.Format("{0}.dcm", sopInstanceUid)); file.Save(outputFileName); if (context.CancelRequested) { context.Cancel(); return; } context.ReportProgress(new BackgroundTaskProgress(++i, _dicomFileNames.Count + 1, "Exporting ...")); } } catch (Exception e) { context.Error(e); return; } context.Complete(); }
private VolumeData LoadVolume(IBackgroundTaskContext context) { // wait for synchronized access lock (_syncVolumeDataLock) { // if the data is now available, return it immediately // (i.e. we were blocked because we were already reading the data) if (_volume != null) return _volume; // load the volume data if (context == null) _volume = VolumeData.Create(_frames); else _volume = VolumeData.Create(_frames, (n, count) => context.ReportProgress(new BackgroundTaskProgress(n, count, SR.MessageFusionInProgress))); // update our stats _largeObjectData.BytesHeldCount = 2*_volume.SizeInVoxels; _largeObjectData.LargeObjectCount = 1; _largeObjectData.UpdateLastAccessTime(); // regenerating the volume data is easy when the source frames are already in memory! _largeObjectData.RegenerationCost = RegenerationCost.Low; // register with memory manager MemoryManager.Add(this); return _volume; } }
private void Run(IBackgroundTaskContext context) { SopGenerator[] generatorArray = _generator.ToArray(); int completedDayStudies = 0; DateTime currentDay = _startDate; int currentStudiesPerDay = currentDay.DayOfWeek == DayOfWeek.Saturday || currentDay.DayOfWeek == DayOfWeek.Sunday ? _studiesPerDay*_percentWeekend/100 : _studiesPerDay; _completedStudies = 0; while (_completedStudies < _totalStudies-1) { InsertStudy(generatorArray[_rand.Next(1,generatorArray.Length)],currentDay); completedDayStudies++; _completedStudies++; if (completedDayStudies > currentStudiesPerDay) { currentDay = currentDay.AddDays(1); currentStudiesPerDay = currentDay.DayOfWeek == DayOfWeek.Saturday || currentDay.DayOfWeek == DayOfWeek.Sunday ? _studiesPerDay * _percentWeekend / 100 : _studiesPerDay; completedDayStudies = 0; } if ((_completedStudies % 10) == 0) context.ReportProgress(new BackgroundTaskProgress(_completedStudies, _totalStudies, "Studies Created")); if (context.CancelRequested) return; } }
private VolumeData LoadVolume(IBackgroundTaskContext context) { // TODO (CR Apr 2013): Ideally, loading and unloading could be done with minimal locking; this way, // Unload actually has to wait for Load to finish and vice versa. I think a quicker way would be to // have a _loading field - have this method set it inside the lock, then proceed to do the load, // then set the _volume field when done. Have Unload check _loading and just return, otherwise set _volume to null. // Basically, you don't need to lock the entire load operation - you only need to guarantee that multiple loads // can't occur at once, and that Unload actually unloads it. // wait for synchronized access lock (_syncVolumeDataLock) { _largeObjectData.Lock(); try { // if the data is now available, return it immediately // (i.e. we were blocked because we were already reading the data) if (_volume != null) return _volume; // load the volume data if (context == null) _volume = VolumeData.Create(_frames); else _volume = VolumeData.Create(_frames, (n, count) => context.ReportProgress(new BackgroundTaskProgress(n, count, SR.MessageFusionInProgress))); // update our stats _largeObjectData.BytesHeldCount = 2*_volume.SizeInVoxels; _largeObjectData.LargeObjectCount = 1; _largeObjectData.UpdateLastAccessTime(); // regenerating the volume data takes a few seconds _largeObjectData.RegenerationCost = LargeObjectContainerData.PresetComputedData; // register with memory manager MemoryManager.Add(this); return _volume; } finally { _largeObjectData.Unlock(); } } }
private void LoadVolume(IBackgroundTaskContext context) { try { ProgressTask mainTask = new ProgressTask(); mainTask.AddSubTask("BUILD", 90); mainTask.AddSubTask("LAYOUT", 10); context.ReportProgress(new BackgroundTaskProgress(mainTask.IntPercent, string.Format(SR.MessageInitializingMpr, mainTask.Progress))); BackgroundTaskParams @params = (BackgroundTaskParams) context.UserState; Volume volume = Volume.Create(@params.Frames, delegate(int i, int count) { if (context.CancelRequested) throw new BackgroundTaskCancelledException(); if (i == 0) mainTask["BUILD"].AddSubTask("", count); mainTask["BUILD"][""].Increment(); string message = string.Format(SR.MessageBuildingMprVolumeProgress, mainTask.Progress, i + 1, count, mainTask["BUILD"].Progress); context.ReportProgress(new BackgroundTaskProgress(mainTask.IntPercent, message)); }); mainTask["BUILD"].MarkComplete(); context.ReportProgress(new BackgroundTaskProgress(mainTask.IntPercent, string.Format(SR.MessagePerformingMprWorkspaceLayout, mainTask.Progress))); //call layout here b/c it could take a while @params.SynchronizationContext.Send(delegate { _viewer = new MprViewerComponent(volume); _viewer.Layout(); }, null); mainTask["LAYOUT"].MarkComplete(); context.ReportProgress(new BackgroundTaskProgress(mainTask.IntPercent, string.Format(SR.MessageDone, mainTask.Progress))); context.Complete(); } catch (BackgroundTaskCancelledException) { context.Cancel(); } catch (Exception ex) { context.Error(ex); } }
private void Export(IBackgroundTaskContext context) { EventResult result = EventResult.Success; AuditedInstances exportedInstances = GetInstancesForAudit(ItemsToExport, this._exportComponent.ExportFilePath); try { _taskContext = context; Export(); } catch (Exception e) { _error = e; result = EventResult.SeriousFailure; Platform.Log(LogLevel.Error, e); } finally { AuditHelper.LogExportStudies(exportedInstances, EventSource.CurrentUser, result); _imagesToDispose.ForEach(delegate(IPresentationImage image) { image.Dispose(); }); } }
private void Process(IBackgroundTaskContext context) { try { _taskContext = context; ICollection<string> files = GetFilesToImport(); if (files.Count > 0 && !_taskContext.CancelRequested) { ConvertFiles(files); ImportFiles(); } } catch(Exception e) { Platform.Log(LogLevel.Error, e); _error = e; } if (_taskContext.CancelRequested) _taskContext.Cancel(); else _taskContext.Complete(); }
private void DoMoveFolderAsync(IBackgroundTaskContext context) { var list = context.UserState as SortableResultList<ScanResultEntry>; int entryCount = list.Count; int counter = 0; foreach (ScanResultEntry entry in list) { if (context.CancelRequested) break; DirectoryInfo dir = new DirectoryInfo(entry.Path); if (dir.Exists) { string path = System.IO.Path.Combine(folderBrowserDialog1.SelectedPath, dir.Name); if (!Directory.Exists(path)) Directory.CreateDirectory(path); DirectoryUtility.Move(entry.Path, path); counter++; context.ReportProgress(new BackgroundTaskProgress(counter*100/entryCount, String.Empty)); } } }
private void Complete() { if (IsAsynchronous) ItemsToExport.ForEach(delegate(IClipboardItem item) { item.Unlock(); }); _progressComponentShelf = null; //notify the owner that we're done. _exportComponent.OnMultipleImageExportComplete(_error); _error = null; _taskContext = null; }
private void StartScaning(IBackgroundTaskContext context) { FolderScanner owner = context.UserState as FolderScanner; DirectoryInfo dir = new DirectoryInfo(owner.Path); int dirCount = 0; if (dir.Exists) { context.ReportProgress(new BackgroundTaskProgress(0, "Starting..")); DirectoryInfo[] subDirs = dir.GetDirectories(); _foldersCount = subDirs.Length; string path = dir.FullName.TrimEnd(new[] {System.IO.Path.DirectorySeparatorChar}); string[] dirs = path.Split(new [] { System.IO.Path.DirectorySeparatorChar }); string partitionFolder = dirs.Length >= 2 ? dirs[dirs.Length - 2] : string.Empty; ServerEntityKey partitionKey = GetPartitionKey(partitionFolder); if (partitionKey==null) { context.ReportProgress(new BackgroundTaskProgress(100, "Folder does not match a partition...")); return; } foreach (DirectoryInfo subDir in subDirs) { if (context.CancelRequested) { break; } try { var result = ProcessDir(subDir, partitionKey); ScanResultSet.Results.Add(result); } catch (Exception ex) { MessageBox.Show(ex.Message); } finally { dirCount++; context.ReportProgress(new BackgroundTaskProgress(dirCount * 100 / _foldersCount, String.Format("Scanning {0}", subDir.FullName))); } } } }