public void SchedulePixelComparisons_Simple()
        {
            // arrange - instantiate scheduler
            PixelComparisonScheduler scheduler = new PixelComparisonScheduler(2, 1, 2, 2);

            // get scheduled comparisons
            PixelComparisonGroupF[] scheduledComparisons = scheduler.ScheduledPixelComparisons;

            // assert - number of base classifiers
            Assert.AreEqual(2, scheduler.BaseClassifierCount);

            // assert - comparisons per classifier
            Assert.AreEqual(1, scheduler.ComparisonsPerClassifier);

            // gather all comparisons in one list
            List <PixelComparisonF> comparisons = new List <PixelComparisonF>();

            for (int i = 0; i < scheduler.BaseClassifierCount; i++)
            {
                for (int j = 0; j < scheduler.ComparisonsPerClassifier; j++)
                {
                    comparisons.Add(scheduledComparisons[i].Value[j]);
                }
            }

            // assert - all comparisons are unique
            CollectionAssert.AllItemsAreUnique(comparisons);
        }
        public void SchedulePixelComparisons_NotEnoughPixelComparisons()
        {
            // arrange - instantiate scheduler
            PixelComparisonScheduler scheduler = new PixelComparisonScheduler(5, 10, 3, 2);

            // assert - every classifier got only 1 comparison
            Assert.AreEqual(1, scheduler.ComparisonsPerClassifier);
        }
        public void SchedulePixelComparisons_BiggerCase()
        {
            // arrange - instantiate scheduler
            PixelComparisonScheduler scheduler = new PixelComparisonScheduler(5, 10, 10, 10);

            // get scheduled comparisons
            PixelComparisonGroupF[] scheduledComparisons = scheduler.ScheduledPixelComparisons;

            // gather all comparisons in one list
            List <PixelComparisonF> comparisons = new List <PixelComparisonF>();

            for (int i = 0; i < scheduler.BaseClassifierCount; i++)
            {
                for (int j = 0; j < scheduler.ComparisonsPerClassifier; j++)
                {
                    comparisons.Add(scheduledComparisons[i].Value[j]);
                }
            }

            // assert - all comparisons are unique
            CollectionAssert.AllItemsAreUnique(comparisons);
        }
Beispiel #4
0
        private static IDetector LoadDetector(IObjectModel objectModel)
        {
            // scanning window generator
            IScanningWindowGenerator scanningWindowGenerator = new ScanningWindowGenerator
                                                               (
                1.2f,
                0.1f,
                0.1f,
                100
                                                               );

            // cascaded classifier

            //      variance classifier
            IClassifier varianceClassifier = new VarianceClassifier(scanningWindowGenerator, 0.5);

            //      ensemble classifier
            int width  = objectModel.PatchSize.Width;
            int height = objectModel.PatchSize.Height;
            IPixelComparisonScheduler pcs  = new PixelComparisonScheduler(12, 3, width, height);
            IClassifier ensembleClassifier = new EnsembleClassifier(scanningWindowGenerator, pcs, 2);

            //      nn classifier
            NnClassifier nnClassifier = new NnClassifier(scanningWindowGenerator, objectModel, 0.75f, 0.55f);

            // instantiate cascaded classifier
            IClassifier cascadedClassifier = new CascadedClassifier(varianceClassifier, ensembleClassifier, nnClassifier);

            IDetector detector = new Detector
                                 (
                scanningWindowGenerator,
                cascadedClassifier,
                Service.NonMaximalBoundingBoxSuppress
                                 );

            return(detector);
        }