/// <summary>
/// Загрузка одного кадра (с изображения)
/// </summary>
/// <param name="data">Информация о кадре</param>
/// <returns>Кадр</returns>
public Task<GreyVideoFrame> LoadFrameAsync(object data)
{
try
{
if (data == null)
throw new ArgumentNullException("Null data in LoadFrameAsync");
IOData ioData = (IOData)data;
string frameFileName = ioData.FileName;
if (frameFileName == null || frameFileName.Length == 0)
throw new ArgumentNullException("Null frameFileName in LoadFrameAsync");
if (ioData.FrameHeight <= 0)
throw new ArgumentException("Error frameHeight value in LoadFrameAsync");
if (ioData.FrameWidth <= 0)
throw new ArgumentException("Error frameWidth value in LoadFrameAsync");
return Task.Run(() =>
{
Size size = new Size(ioData.FrameWidth, ioData.FrameHeight);
Bitmap bitmapFrame = new Bitmap(frameFileName);
// bitmapFrame.SetResolution(ioData.FrameWidth, ioData.FrameHeight);
BitmapConvertor bitmapConvertor = new BitmapConvertor();
GreyVideoFrame greyVideoFrame = new GreyVideoFrame();
greyVideoFrame.Frame = bitmapConvertor.ToGreyImage(bitmapFrame);
return greyVideoFrame;
});
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// Поиск ключевых кадров видео
/// </summary>
/// <param name="frames">Все серые кадры</param>
/// <param name="coloredFrames">Все цветные кадры</param>
/// <param name="framesDifferences">Разницы кадров</param>
/// <param name="treshold">Порог</param>
/// <returns>Ключевые кадры</returns>
private List<GreyVideoFrame> GetKeyFrames(List<Image<Gray, Byte>> frames, List<Image<Bgr, Byte>> coloredFrames,
List<int> framesDifferences, double treshold)
{
try
{
ImageConvertor imageConvertor = new ImageConvertor();
List<GreyVideoFrame> keyFrames = new List<GreyVideoFrame>();
GreyVideoFrame firstKeyFrame = new GreyVideoFrame();
firstKeyFrame.FrameNumber = 0;
firstKeyFrame.Frame = imageConvertor.ConvertColor(frames[0]);
keyFrames.Add(firstKeyFrame);
int framesDifferencesNumber = framesDifferences.Count;
int previousFrameNumber = 0;
for (int i = 0; i < framesDifferencesNumber; i++)
{
if (framesDifferences[i] > treshold && i + 1 != previousFrameNumber + 1)
{
GreyVideoFrame keyFrame = new GreyVideoFrame();
keyFrame.FrameNumber = i + 1;
previousFrameNumber = i + 1;
keyFrame.OriginalFrame = coloredFrames[i + 1];
keyFrame.Frame = imageConvertor.ConvertColor(frames[i + 1]);
keyFrames.Add(keyFrame);
}
if (i == framesDifferencesNumber - 1)
keyFrameExtractedEvent(i, i + 1, true);
else
keyFrameExtractedEvent(i, i + 1, false);
}
return keyFrames;
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// Добавление ключевого кадра в список ключевых кадров
/// </summary>
/// <param name="keyFrames">Список клбючевых кадров</param>
/// <param name="frame">Ключевой кадр</param>
/// <param name="frameFileName">Имя файла для сохранения ключевого кадра</param>
/// <param name="frameNumber">Номер ключевого кадра</param>
/// <param name="needProcess">Нуждается ли кадр в обработке</param>
private void AddKeyFrameFunction(List<GreyVideoFrame> keyFrames, Image<Gray, Byte> frame, string frameFileName, int frameNumber,
bool needProcess)
{
try
{
frame.Save(frameFileName);
Bitmap bitmapFrame = new Bitmap(frameFileName);
GreyVideoFrame keyFrame = new GreyVideoFrame();
keyFrame.FrameNumber = frameNumber;
BitmapConvertor bitmapConvertor = new BitmapConvertor();
keyFrame.Frame = bitmapConvertor.ToGreyImage(bitmapFrame);
keyFrame.NeedProcess = needProcess;
keyFrames.Add(keyFrame);
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// Сохранение одного кадра видео
/// </summary>
/// <param name="videoFrame"></param>
/// <param name="pen"></param>
/// <param name="saveFileName"></param>
public Task<bool> SaveVideoFrameAsync(GreyVideoFrame videoFrame, System.Drawing.Pen pen, string saveFileName)
{
try
{
if (videoFrame == null || videoFrame.Frame == null)
throw new ArgumentNullException("Null videoFrame");
if (saveFileName == null || saveFileName.Length == 0)
throw new ArgumentNullException("Null saveFileName");
if (pen == null)
throw new ArgumentNullException("Null pen");
return Task.Run(() =>
{
BitmapConvertor bitmapConvertor = new BitmapConvertor();
Bitmap bitmapFrame = bitmapConvertor.ToBitmap(videoFrame.Frame);
Draw.DrawTextBoundingBoxes(bitmapFrame, videoFrame.Frame.TextRegions, pen);
bitmapFrame.Save(saveFileName);
return true;
});
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// Запись инфориации о текстовых блоках кадра видеопотока в XML - файл
/// </summary>
/// <param name="videoFrame">Фрейм видео</param>
/// <param name="fileName">Имя файла</param>
/// <returns>true</returns>
public static Task<bool> WriteTextBlocksInformation(GreyVideoFrame videoFrame, string fileName)
{
if (videoFrame == null)
throw new ArgumentNullException("Null videoFrame in WriteTextBlocksInformation");
if (fileName == null || fileName.Length == 0)
throw new ArgumentNullException("Null fileName in WriteTextBlocksInformation");
try
{
return Task.Run(() =>
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.IndentChars = "\t";
XmlWriter xmlWriter = XmlWriter.Create(fileName, settings);
xmlWriter.WriteStartDocument();
xmlWriter.WriteStartElement("Video");
XMLWriter.WriteTextBlocksInformation(videoFrame.Frame.TextRegions, xmlWriter, videoFrame.FrameNumber, fileName);
xmlWriter.WriteEndDocument();
xmlWriter.Flush();
xmlWriter.Close();
return true;
});
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// Выяснение, есть ли неопределенные параметры у кадра (эвристки)
/// </summary>
/// <param name="videoFrame">Кард</param>
/// <returns>1 - есть неопределенные параметр(ы), 0 - иначе</returns>
private bool ParametersUndefined(GreyVideoFrame videoFrame)
{
try
{
bool result = false;
int undefinedParameter = GreyVideoFrame.UNDEFINED_PARAMETER;
if (videoFrame.AspectRatio == undefinedParameter || videoFrame.BbPixelsNumberMaxRatio == undefinedParameter ||
videoFrame.BbPixelsNumberMinRatio == undefinedParameter || videoFrame.DiamiterSWRatio == undefinedParameter ||
videoFrame.ImageRegionHeightRationMin == undefinedParameter || videoFrame.ImageRegionWidthRatioMin == undefinedParameter ||
videoFrame.PairsHeightRatio == undefinedParameter || videoFrame.PairsIntensityRatio == undefinedParameter ||
videoFrame.PairsOccupationRatio == undefinedParameter || videoFrame.PairsSWRatio == undefinedParameter ||
videoFrame.PairsWidthDistanceSqrRatio == undefinedParameter || videoFrame.VarienceAverageSWRation == undefinedParameter)
return true;
return result;
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// Выделение текста на единичном кадре видеопотока
/// </summary>
/// <param name="videoFrame">Кадр видео</param>
/// <returns>true</returns>
public Task<bool> DetectText(GreyVideoFrame videoFrame, int threadsNumber)
{
try
{
if (videoFrame == null || videoFrame.Frame == null)
throw new ArgumentNullException("Null frame in DetectText");
return Task.Run(() =>
{
if (videoFrame.NeedProcess)
{
EdgeDetectionFilter sobel = new SobelFilter();
GradientFilter gradientFiler = new SimpleGradientFilter();
SmoothingFilter gauss = null; //new GaussFilter(this.GaussFilterSize, this.GaussFilterSigma);
SmoothingFilter gaussForCanny = null;
SWTTextDetection sWTTextDetection = null;
if (ParametersUndefined(videoFrame))
{
if (this.UseAdaptiveSmoothing)
gaussForCanny = new AdaptiveGaussFilter(this.GaussFilterSigma);
else
gaussForCanny = new GaussFilter(this.GaussFilterSize, this.GaussFilterSigma);
gauss = new GaussFilter(this.GaussFilterSize, this.GaussFilterSigma);
CannyEdgeDetection canny = new CannyEdgeDetection(gaussForCanny, sobel, this.CannyLowTreshold, this.CannyHighTreshold);
sWTTextDetection = new SWTTextDetection(canny, gauss, gradientFiler, this.VarienceAverageSWRation,
this.AspectRatio, this.DiamiterSWRatio, this.BbPixelsNumberMinRatio, this.BbPixelsNumberMaxRatio, this.ImageRegionHeightRationMin,
this.ImageRegionWidthRatioMin, this.PairsHeightRatio, this.PairsIntensityRatio, this.PairsSWRatio,
this.PairsWidthDistanceSqrRatio, this.PairsOccupationRatio, this.MinLettersNumberInTextRegion, this.MergeByDirectionAndChainEnds);
}
else
{
if (videoFrame.UseAdaptiveSmoothing)
gaussForCanny = new AdaptiveGaussFilter(videoFrame.GaussFilterSigma);
else
gaussForCanny = new GaussFilter(videoFrame.GaussFilterSize, videoFrame.GaussFilterSigma);
gauss = new GaussFilter(videoFrame.GaussFilterSize, videoFrame.GaussFilterSigma);
CannyEdgeDetection canny = new CannyEdgeDetection(gaussForCanny, sobel, videoFrame.CannyLowTreshold, videoFrame.CannyHighTreshold);
sWTTextDetection = new SWTTextDetection(canny, gauss, gradientFiler, videoFrame.VarienceAverageSWRation, videoFrame.AspectRatio,
videoFrame.DiamiterSWRatio, videoFrame.BbPixelsNumberMinRatio, videoFrame.BbPixelsNumberMaxRatio, videoFrame.ImageRegionHeightRationMin,
videoFrame.ImageRegionWidthRatioMin, videoFrame.PairsHeightRatio, videoFrame.PairsIntensityRatio, videoFrame.PairsSWRatio,
videoFrame.PairsWidthDistanceSqrRatio, videoFrame.PairsOccupationRatio, videoFrame.MinLettersNumberInTextRegion, videoFrame.MergeByDirectionAndChainEnds);
}
sWTTextDetection.DetectText(videoFrame.Frame, threadsNumber);
}
return true;
});
}
catch (Exception exception)
{
throw exception;
}
}
private void AddProcessedFrameToBitmapArray(GreyVideoFrame videoFrame)
{
try
{
if (this.processedVideoFramesBitmap == null)
this.processedVideoFramesBitmap = new List<BitmapImage>();
if (this.processedVideoFramesBitmapForSave == null)
this.processedVideoFramesBitmapForSave = new List<Bitmap>();
if (this.textRegionsDictionary == null)
this.textRegionsDictionary = new Dictionary<int, List<TextRegion>>();
this.textRegionsDictionary.Add(videoFrame.FrameNumber, videoFrame.Frame.TextRegions);
BitmapConvertor bitmapConvertor = new BitmapConvertor();
BitmapImageConvertor bitmapImageConvertor = new Convertors.BitmapImageConvertor();
Bitmap bitmapFrame = bitmapConvertor.ToBitmap(videoFrame.Frame);
Draw.DrawTextBoundingBoxes(bitmapFrame, videoFrame.Frame.TextRegions, new System.Drawing.Pen(System.Drawing.Color.Red, 2));
this.processedVideoFramesBitmapForSave.Add(bitmapFrame);
this.processedVideoFramesBitmap.Add(bitmapImageConvertor.BitmapToBitmapImage(bitmapFrame));
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// Загрузка единичного кадра видео
/// </summary>
private async void LoadVideoFrameFunction()
{
try
{
OpenFileDialog dialog = new OpenFileDialog();
dialog.Filter = "JPEG Image (.jpg)|*.jpg";
dialog.ShowDialog();
FrameSizeWindow frameSizeWindow = FrameSizeWindow.InitializeFrameSizeWindow();
frameSizeWindow.capitalText.Text = PARAMETERS_SETTING_STRING;
frameSizeWindow.ShowDialog();
FrameSizeViewModel frameSizeViewModel = (FrameSizeViewModel)frameSizeWindow.DataContext;
IOData ioData = new IOData() { FileName = dialog.FileName, FrameHeight = frameSizeViewModel.FrameHeight, FrameWidth = frameSizeViewModel.FrameWidth };
VideoLoader.frameLoadedEvent += this.LoadingFramesProcessing;
VideoLoader videoLoader = new VideoLoader();
FrameLoader frameLoader = new FrameLoader();
videoFrame = await frameLoader.LoadFrameAsync(ioData);
OkButtonWindow okButtonWindow = OkButtonWindow.InitializeOkButtonWindow();
okButtonWindow.textInformation.Text = LOAD_FRAME_SUCCESS_STRING;
okButtonWindow.capitalText.Text = LOAD_FRAME_STRING;
okButtonWindow.ShowDialog();
Bitmap bitmapFrame = new Bitmap(dialog.FileName);
BitmapImageConvertor bitmapImageConvertor = new Convertors.BitmapImageConvertor();
this.FrameSource = bitmapImageConvertor.BitmapToBitmapImage(bitmapFrame);
this.ProcessedFrameSource = null;
this.IsVideoFrameTabSelected = true;
this.IsProcessedVideoFramesTabSelected = false;
this.IsProcessedVideoFrameTabSelected = false;
this.IsVideoTabSelected = false;
}
catch (Exception exception)
{
ShowExceptionMessage(exception.Message);
}
}
/// <summary>
/// Создание кадра видео
/// </summary>
/// <param name="frame">Кадр</param>
/// <param name="keyFrameIOInformation">Информация о кадре</param>
/// <returns>Кадр</returns>
private GreyVideoFrame CreateVideoFrame(Image<Gray, byte> frame, KeyFrameIOInformation keyFrameIOInformation)
{
try
{
// Bitmap bitmapFrame = new Bitmap(frameFileName);
ImageConvertor ImageConvertor = new DigitalVideoProcessingLib.IO.ImageConvertor();
GreyVideoFrame keyFrame = new GreyVideoFrame();
keyFrame.FrameNumber = keyFrameIOInformation.Number;
BitmapConvertor bitmapConvertor = new BitmapConvertor();
keyFrame.Frame = ImageConvertor.ConvertColor(frame);//bitmapConvertor.ToGreyImage(bitmapFrame);
keyFrame.NeedProcess = keyFrameIOInformation.NeedProcess;
keyFrame.AspectRatio = keyFrameIOInformation.AspectRatio;
keyFrame.BbPixelsNumberMaxRatio = keyFrameIOInformation.BbPixelsNumberMaxRatio;
keyFrame.BbPixelsNumberMinRatio = keyFrameIOInformation.BbPixelsNumberMinRatio;
keyFrame.DiamiterSWRatio = keyFrameIOInformation.DiamiterSWRatio;
keyFrame.ImageRegionHeightRationMin = keyFrameIOInformation.ImageRegionHeightRationMin;
keyFrame.ImageRegionWidthRatioMin = keyFrameIOInformation.ImageRegionWidthRatioMin;
keyFrame.MergeByDirectionAndChainEnds = keyFrameIOInformation.MergeByDirectionAndChainEnds;
keyFrame.MinLettersNumberInTextRegion = keyFrameIOInformation.MinLettersNumberInTextRegion;
keyFrame.PairsHeightRatio = keyFrameIOInformation.PairsHeightRatio;
keyFrame.PairsIntensityRatio = keyFrameIOInformation.PairsIntensityRatio;
keyFrame.PairsOccupationRatio = keyFrameIOInformation.PairsOccupationRatio;
keyFrame.PairsSWRatio = keyFrameIOInformation.PairsSWRatio;
keyFrame.PairsWidthDistanceSqrRatio = keyFrameIOInformation.PairsWidthDistanceSqrRatio;
keyFrame.UseAdaptiveSmoothing = keyFrameIOInformation.UseAdaptiveSmoothing;
keyFrame.VarienceAverageSWRation = keyFrameIOInformation.VarienceAverageSWRation;
keyFrame.GaussFilterSize = keyFrameIOInformation.GaussFilterSize;
keyFrame.GaussFilterSigma = keyFrameIOInformation.GaussFilterSigma;
keyFrame.CannyLowTreshold = keyFrameIOInformation.CannyLowTreshold;
keyFrame.CannyHighTreshold = keyFrameIOInformation.CannyHighTreshold;
return keyFrame;
}
catch (Exception exception)
{
throw exception;
}
}
