/// <summary>
/// Handler of the ProcessingCommandBase.Finished event.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="ImageProcessedEventArgs"/> instance containing the event data.</param>
void command_Finished(object sender, ImageProcessedEventArgs e)
{
ProcessingCommandBase command = (ProcessingCommandBase)sender;
command.Finished -= new EventHandler <ImageProcessedEventArgs>(command_Finished);
if (command is ParallelizingProcessingCommand)
{
command = ((ParallelizingProcessingCommand)command).ProcessingCommand;
}
if (command is OverlayCommand ||
command is OverlayWithBlendingCommand ||
command is OverlayMaskedCommand)
{
if (_overlayImage != null)
{
// dispose the temporary overlay image because the processing command is finished
_overlayImage.Dispose();
_overlayImage = null;
}
if (_maskImage != null)
{
// dispose the temporary mask image because the processing command is finished
_maskImage.Dispose();
_maskImage = null;
}
}
if (command is ImageComparisonCommand)
{
if (_comparisonImage != null)
{
_comparisonImage.Dispose();
_comparisonImage = null;
}
}
_isImageProcessingWorking = false;
if (_imageProcessingUndoMonitor != null)
{
_imageProcessingUndoMonitor.Dispose();
_imageProcessingUndoMonitor = null;
}
OnImageProcessingCommandFinished((ProcessingCommandBase)sender, e);
}
/// <summary>
/// Executes image processing command synchronously or asynchronously.
/// </summary>
/// <param name="command">Command to execute.</param>
/// <param name="async">A value indicating whether to execute command asynchronously.</param>
public bool ExecuteProcessingCommand(ProcessingCommandBase command, bool async)
{
RectangularSelectionToolWithCopyPaste rectSelectionTool = CompositeVisualTool.FindVisualTool <RectangularSelectionToolWithCopyPaste>(_viewer.VisualTool);
CustomSelectionTool customSelectionTool = CompositeVisualTool.FindVisualTool <CustomSelectionTool>(_viewer.VisualTool);
if (rectSelectionTool != null)
{
// set the region of interest
Rectangle selectionRectangle = ViewerSelectionRectangle;
ProcessingCommandWithRegion commandWorkWithRegion = command as ProcessingCommandWithRegion;
if (commandWorkWithRegion != null)
{
commandWorkWithRegion.RegionOfInterest = new RegionOfInterest(selectionRectangle.Left, selectionRectangle.Top, selectionRectangle.Width, selectionRectangle.Height);
}
else if (command is DrawImageCommand)
{
((DrawImageCommand)command).DestRect = selectionRectangle;
}
else if (!selectionRectangle.IsEmpty)
{
MessageBox.Show("Selected image processing command cannot work with regions. Entire image will be processed.",
"Warning", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
else if (customSelectionTool != null)
{
RectangleF selectionBBox = RectangleF.Empty;
if (customSelectionTool.Selection != null)
{
selectionBBox = customSelectionTool.Selection.GetBoundingBox();
}
if (selectionBBox.Width >= 1 && selectionBBox.Height >= 1)
{
if (command is ChangePixelFormatCommand ||
command is ChangePixelFormatToBgrCommand ||
command is ChangePixelFormatToBlackWhiteCommand ||
command is ChangePixelFormatToGrayscaleCommand ||
command is ChangePixelFormatToPaletteCommand ||
command is RotateCommand ||
command is ResampleCommand ||
command is ResizeCommand ||
!command.CanModifyImage)
{
MessageBox.Show("Selected image processing command cannot work with custom selection. Entire image will be processed.",
"Warning", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
GraphicsPath path = customSelectionTool.Selection.GetAsGraphicsPath();
RectangleF pathBounds = path.GetBounds();
if (pathBounds.Width > 0 && pathBounds.Height > 0)
{
if (command is CropCommand)
{
// crop to custom selection
command = GetCropToPathCommand(path, pathBounds, (CropCommand)command);
// clear selection
customSelectionTool.Selection = null;
}
else
{
// process path
command = new ProcessPathCommand(command, path);
}
}
else
{
MessageBox.Show("Selected path is empty.",
"Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
return(false);
}
}
}
}
// get a reference to the image for processing
VintasoftImage imageToProcess = _viewer.Image;
ProcessingCommandBase executeCommand = command;
if (_executeMultithread)
{
ParallelizingProcessingCommand parallelizingCommand = new ParallelizingProcessingCommand(command);
if (command is ProcessingCommandWithRegion)
{
parallelizingCommand.RegionOfInterest = ((ProcessingCommandWithRegion)command).RegionOfInterest;
}
executeCommand = parallelizingCommand;
}
if (UndoManager != null)
{
_imageProcessingUndoMonitor = new ImageProcessingUndoMonitor(UndoManager, executeCommand);
}
// subscribe to the events of the image processing command
executeCommand.Started += new EventHandler <ImageProcessingEventArgs>(command_Started);
executeCommand.Progress += new EventHandler <ImageProcessingProgressEventArgs>(command_Progress);
executeCommand.Finished += new EventHandler <ImageProcessedEventArgs>(command_Finished);
executeCommand.ExpandSupportedPixelFormats = ExpandSupportedPixelFormats;
executeCommand.RestoreSourcePixelFormat = false;
// specify that image processing command is working (several commands cannot work together)
_isImageProcessingWorking = true;
// get the start time of the image processing command
_processingCommandStartTime = DateTime.Now;
// if image processing command should be executed asynchronously
if (async)
{
// start the image processing command asynchronously
ProcessingCommandTask executor = new ProcessingCommandTask(executeCommand, imageToProcess);
executor.ImageProcessingExceptionOccurs += new EventHandler(executor_ImageProcessingExceptionOccurs);
Thread thread = new Thread(executor.Execute);
thread.IsBackground = true;
thread.Start();
}
// if image processing command should be executed synchronously
else
{
try
{
// execute the image processing command synchronously
executeCommand.ExecuteInPlace(imageToProcess);
}
catch (Exception ex)
{
executor_ImageProcessingExceptionOccurs(this, EventArgs.Empty);
DemosTools.ShowErrorMessage(ex);
return(false);
}
}
return(true);
}
