/// <summary>
/// Raises the ImageProcessingCommandFinished event.
/// </summary>
/// <param name="command">Executed command.</param>
/// <param name="e">The <see cref="ImageProcessedEventArgs"/> instance containing the event data.</param>
void OnImageProcessingCommandFinished(ProcessingCommandBase command, ImageProcessedEventArgs e)
{
if (ImageProcessingCommandFinished != null)
{
ImageProcessingCommandFinished(command, e);
}
}
/// <summary>
/// Raises the ImageProcessingCommandStarted event.
/// </summary>
/// <param name="command">Executing command.</param>
/// <param name="e">The <see cref="ImageProcessingEventArgs"/> instance containing the event data.</param>
void OnImageProcessingCommandStarted(ProcessingCommandBase command, ImageProcessingEventArgs e)
{
if (ImageProcessingCommandStarted != null)
{
ImageProcessingCommandStarted(command, e);
}
}
/// <summary>
/// Raises the ImageProcessingCommandProgress event.
/// </summary>
/// <param name="command">Executing command.</param>
/// <param name="e">The <see cref="ImageProcessingProgressEventArgs"/> instance containing the event data.</param>
void OnImageProcessingCommandProgress(ProcessingCommandBase command, ImageProcessingProgressEventArgs e)
{
if (ImageProcessingCommandProgress != null)
{
ImageProcessingCommandProgress(command, e);
}
}
/// <summary>
/// Determines whether specified processing command can process the specified image.
/// </summary>
/// <param name="command">Image processing command.</param>
/// <param name="image">Image to process.</param>
/// <returns>
/// <b>true</b> - processing command can process image;
/// otherwise, <b>false</b>.
/// </returns>
private bool CommandCanProcessImage(ProcessingCommandBase command, VintasoftImage image)
{
bool needConvertToSupportedPixelFormat = command.ExpandSupportedPixelFormats;
command.ExpandSupportedPixelFormats = ExpandSupportedPixelFormats;
PixelFormat outputPixelFormat = command.GetOutputPixelFormat(image);
command.ExpandSupportedPixelFormats = needConvertToSupportedPixelFormat;
if (outputPixelFormat != PixelFormat.Undefined)
{
return(true);
}
System.Text.StringBuilder sb = new System.Text.StringBuilder();
ReadOnlyCollection <PixelFormat> formats = command.SupportedPixelFormats;
for (int i = 0; i < formats.Count; i++)
{
sb.Append(" -");
sb.Append(formats[i].ToString());
sb.AppendLine(";");
}
string supportedPixelFormatNames = sb.ToString();
string message = string.Format(
System.Globalization.CultureInfo.InvariantCulture,
"{0}: unsupported pixel format - {1}.\n\nProcessing command supports only the following pixel formats:\n{2}\nPlease convert the image to supported pixel format first.",
command.Name,
image.PixelFormat,
supportedPixelFormatNames);
DemosTools.ShowErrorMessage("Image processing exception", message);
return(false);
}
/// <summary>
/// Handler of the ProcessingCommandBase.Started event.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="ImageProcessingEventArgs"/> instance containing the event data.</param>
void command_Started(object sender, ImageProcessingEventArgs e)
{
ProcessingCommandBase command = (ProcessingCommandBase)sender;
command.Started -= new EventHandler <ImageProcessingEventArgs>(command_Started);
OnImageProcessingCommandStarted((ProcessingCommandBase)sender, e);
}
/// <summary>
/// Executes the processing command.
/// </summary>
protected virtual void ExecuteProcessing()
{
ProcessingCommandBase command = GetProcessingCommand();
if (command != null)
{
_imageProcessingPreviewInViewer.SetCommand(command);
}
}
/// <summary>
/// Builds the proccessing command to process current captured frame.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private void ChangeProcessingCommandHandler(object sender, EventArgs e)
{
List <ProcessingCommandBase> commands = new List <ProcessingCommandBase>();
// Invert
switch (invertComboBox.SelectedIndex)
{
case 1:
commands.Add(new InvertCommand());
break;
case 2:
commands.Add(new ColorBlendCommand(BlendingMode.Difference, Color.FromArgb(255, 0, 0)));
break;
case 3:
commands.Add(new ColorBlendCommand(BlendingMode.Difference, Color.FromArgb(0, 255, 0)));
break;
case 4:
commands.Add(new ColorBlendCommand(BlendingMode.Difference, Color.FromArgb(0, 0, 255)));
break;
}
// Grayscale
if (grayscaleCheckBox.Checked)
{
commands.Add(new ChangePixelFormatToGrayscaleCommand(PixelFormat.Gray8));
}
// Rotate
int rotate;
if (int.TryParse(rotateComboBox.Text, out rotate))
{
if (rotate != 0)
{
RotateCommand rotateCommand = new RotateCommand(rotate);
rotateCommand.BorderColorType = BorderColorType.Black;
commands.Add(rotateCommand);
}
}
if (commands.Count == 0)
{
_processingCommand = null;
}
else if (commands.Count == 1)
{
_processingCommand = commands[0];
}
else
{
_processingCommand = new CompositeCommand(commands.ToArray());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyGridConfigForm"/> class.
/// </summary>
/// <param name="viewer">The image viewer for image preview.</param>
/// <param name="command">Image processing command.</param>
public PropertyGridConfigForm(ImageViewer viewer, ProcessingCommandBase command)
: base(viewer)
{
InitializeComponent();
_command = command;
Text = command.Name;
propertyGrid1.SelectedObject = command;
previewCheckBox.Checked = IsPreviewEnabled;
}
/// <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>
/// Sets the current image processing command.
/// </summary>
/// <param name="command">The processing command.</param>
public void SetCommand(ProcessingCommandBase command)
{
if (_isPreviewStarted)
{
if (command != null)
{
command.ExpandSupportedPixelFormats = ExpandSupportedPixelFormats;
}
if (_viewer.VisualTool is CustomSelectionTool)
{
CustomSelectionTool selectionTool = (CustomSelectionTool)_viewer.VisualTool;
_processedSelectionRegionView.ProcessingCommand = command;
selectionTool.InvalidateItem(selectionTool.Selection);
}
else
{
_rectangularPreview.ProcessingCommand = command;
}
}
}
private void ExecuteCommand(ProcessingCommandBase command, VintasoftImage image)
{
command.Progress += new EventHandler <ImageProcessingProgressEventArgs>(command_Progress);
command.ExecuteInPlace(image);
command.Progress -= new EventHandler <ImageProcessingProgressEventArgs>(command_Progress);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProcessingCommandTask"/> class.
/// </summary>
/// <param name="command">Image processing command to execute.</param>
/// <param name="image">Image to process.</param>
public ProcessingCommandTask(ProcessingCommandBase command, VintasoftImage image)
{
_command = command;
_image = image;
}
/// <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);
}
/// <summary>
/// Executes image processing command asynchronously.
/// </summary>
/// <param name="command">Command to execute.</param>
public void ExecuteProcessingCommand(ProcessingCommandBase command)
{
ExecuteProcessingCommand(command, true);
}
