示例#1
0
 static public MatchType CalcPageMatchType(PageReportData pageReport)
 {
     if (pageReport.ClassMatch.Count > 0)
     {
         var matchClass = pageReport.ClassMatch.First();
         if (matchClass.Key == pageReport.Page.Setup.ClassName)
         {
             return(MatchType.Match);
         }
         else
         {
             return(MatchType.FalsePositive);
         }
     }
     else
     {
         return(MatchType.Reject);
     }
 }
示例#2
0
 public PageReportViewModel(PageReportData pageReportData) :
     base(pageReportData.Page)
 {
     m_pageReportData = pageReportData;
 }
示例#3
0
 public PageReportViewModel(PageData page) :
     base(page)
 {
     m_pageReportData = null;
 }
示例#4
0
        protected override void LoadData(object state)
        {
            m_reportsData.Clear();
            m_parameters.Clear();

            AppDataCenter.Singleton.StartAnalyzer();

            try
            {
                var vm = state as MultiRunConfigurationViewModel;

                // Build set of configuration according the selected parameters
                BuildConfigurations(vm.Parameters.Where(x => x.IsSelected == true).ToList());

                int noOfRuns = AppDataCenter.Singleton.SetupData.ClassifierConfigurations.Count();


                for (int i = 0; i < noOfRuns; i++)
                {
                    ReportData reportData = m_reportsData[i];

                    var startTime = DateTime.Now;

                    // Train...


                    try
                    {
                        ConcurrentBag <Page> trainPages = new ConcurrentBag <Page>();
                        Parallel.ForEach(AppDataCenter.Singleton.TrainPages.GroupBy(x => x.FileName), pagesDate =>
                        {
                            var dec = TiffBitmapDecoder.Create(new Uri(pagesDate.Key), BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
                            foreach (var pageData in pagesDate)
                            {
                                var frame = dec.Frames[pageData.PageNo - 1];
                                var image = ImageHelper.BitmapFromSource(frame);
                                var page  = new Page()
                                {
                                    Image     = image,
                                    ClassName = pageData.ClassName
                                };
                                trainPages.Add(page);

                                PageReportData pageReportData = new PageReportData()
                                {
                                    Page = pageData
                                };
                                pageReportData.ClassMatch.Clear();
                                pageReportData.ClassMatch.Add(page.ClassName, 1);
                                reportData.PagesReportData.Add(pageReportData);
                            }
                        });

                        ClassifierService.Service.Train(trainPages,
                                                        AppDataCenter.Singleton.SetupData.ClassifierConfigurations.ElementAt(i));

                        // Run...
                        Parallel.ForEach(AppDataCenter.Singleton.SetupData.Pages
                                         .Where(x => AppDataCenter.Singleton.TrainPages.Contains(x) == false)
                                         .GroupBy(x => x.FileName), pagesDate =>
                        {
                            var dec = TiffBitmapDecoder.Create(new Uri(pagesDate.Key), BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
                            foreach (var pageData in pagesDate)
                            {
                                var frame = dec.Frames[pageData.PageNo - 1];
                                var image = ImageHelper.BitmapFromSource(frame);
                                var page  = new Page()
                                {
                                    Image     = image,
                                    ClassName = ""
                                };
                                ClassifierService.Service.Run(page, null, classesMatch =>
                                {
                                    PageReportData pageReportData = new PageReportData()
                                    {
                                        Page = pageData
                                    };

                                    if (classesMatch.Count() > 0)
                                    {
                                        foreach (var classMatch in classesMatch)
                                        {
                                            pageReportData.ClassMatch.Add(classMatch.Key, classMatch.Value);
                                        }
                                    }
                                    else
                                    {
                                        pageReportData.ClassMatch.Clear();
                                    }
                                    reportData.PagesReportData.Add(pageReportData);
                                });
                            }
                        });
                    }
                    // In case the configuration is not valid
                    catch (Exception)
                    {
                    }

                    reportData.Duration = DateTime.Now - startTime;

                    // Add report data to system
                    AppDataCenter.Singleton.AddReportData(reportData);
                }

                if (AppDataCenter.Singleton.ReportsData.Count() > 2)
                {
                    var result = AppDataCenter.Singleton.ReportsData.OrderBy(x => x, new AppDataCenter.CompareReportData()).First();

                    AppDataCenter.Singleton.SetReportByParameter(result.ParameterValue);
                }
            }
            finally
            {
                AppDataCenter.Singleton.FinishAnalyzer();
            }
        }