Exemple #1
0
        public void ShouldCreateNewObjectWhenDroppedFromDifferentCollectionThanSourceCollection()
        {
            // Given
            const int index            = 1;
            var       element          = new TwoPointNonUniformityCorrectionTemplate();
            var       dataSource       = new ProcessingChainDataStore();
            var       targetCollection = dataSource.ProcessingChainTemplate;
            var       sourceCollection = new List <IProcessingChainElementTemplate> {
                element
            };

            sourceCollection.Insert(index, element);

            var dropInfo = new TestDropInfo
            {
                Data             = element,
                TargetCollection = targetCollection,
                DragInfo         = new TestDragInfo {
                    SourceCollection = sourceCollection
                },
                InsertIndex = index
            };

            var dropHandler = new ProcessingChainDropHandler();

            // When
            dropHandler.Drop(dropInfo);
            var targetCollectionElement = targetCollection[index];

            // Then
            Assert.IsNotNull(targetCollectionElement);
            Assert.AreEqual(index, targetCollection.IndexOf(targetCollectionElement));
            Assert.IsFalse(ReferenceEquals(element, targetCollectionElement));
        }
        public void ShouldNotAllowToAddElementOtherThanIImageProviderTemplateAtStart()
        {
            // Given
            var template = new TwoPointNonUniformityCorrectionTemplate();
            var processingChainTemplate = new ProcessingChainTemplate();

            // When
            // Then
            Assert.Throws <InvalidProcessingChainElementInsertionException>(() => processingChainTemplate.Insert(0, template));
        }
        public void ShouldAllowToDragImageProcessingElements()
        {
            // Given
            var element     = new TwoPointNonUniformityCorrectionTemplate();
            var dragHandler = new ProcessingChainDragHandler();
            var dragInfo    = new TestDragInfo {
                SourceItems = new[] { element }
            };

            // When
            dragHandler.StartDrag(dragInfo);

            // Then
            Assert.IsNotNull(dragInfo.Data);
        }
        public void ShouldGenerateUniqueIdsForItemsWithoutIdAddedToChain()
        {
            // Given
            var processingChainTemplate = new ProcessingChainTemplate {
                new ImageProviderTemplate(), new ImageDisplayTemplateTemplate()
            };
            var template = new TwoPointNonUniformityCorrectionTemplate {
                Id = null
            };

            // When
            processingChainTemplate.Insert(1, template);

            // Then
            Assert.IsNotNull(template.Id);
            CollectionAssert.AllItemsAreUnique(processingChainTemplate.Select(i => i.Id));
        }
        public void ShouldNotGenerateIdsForItemsWithIdNotPresentInCollectionAddedToChain()
        {
            // Given
            var processingChainTemplate = new ProcessingChainTemplate {
                new ImageProviderTemplate(), new ImageDisplayTemplateTemplate()
            };

            var templateId = Guid.NewGuid().ToString();
            var template   = new TwoPointNonUniformityCorrectionTemplate {
                Id = templateId
            };

            // When
            processingChainTemplate.Insert(1, template);

            // Then
            Assert.AreEqual(templateId, template.Id);
            CollectionAssert.AllItemsAreUnique(processingChainTemplate.Select(i => i.Id));
        }
        public void ShouldGenerateNewIdWhenItemWithSameIdIsAlreadyPresentInChain()
        {
            // Given
            var template = new TwoPointNonUniformityCorrectionTemplate();

            var processingChainTemplate = new ProcessingChainTemplate {
                new ImageProviderTemplate(), new ImageDisplayTemplateTemplate()
            };

            processingChainTemplate.Insert(1, new TwoPointNonUniformityCorrectionTemplate());

            var templateId = processingChainTemplate.ElementAt(1).Id;

            // When
            processingChainTemplate.Insert(1, template);

            // Then
            Assert.AreNotEqual(templateId, template.Id);
            CollectionAssert.AllItemsAreUnique(processingChainTemplate.Select(i => i.Id));
        }
        public void ShouldNotGenerateNewIdWhenItemIsMoved()
        {
            // Given
            var template = new TwoPointNonUniformityCorrectionTemplate();

            var processingChainTemplate = new ProcessingChainTemplate {
                new ImageProviderTemplate(), new ImageDisplayTemplateTemplate()
            };

            processingChainTemplate.Insert(1, new TwoPointNonUniformityCorrectionTemplate());
            processingChainTemplate.Insert(2, template);

            var templateId = processingChainTemplate.Single(i => i == template).Id;

            // When
            processingChainTemplate.RemoveAt(2);
            processingChainTemplate.Insert(1, template);

            // Then
            Assert.AreEqual(templateId, template.Id);
            CollectionAssert.AllItemsAreUnique(processingChainTemplate.Select(i => i.Id));
        }
Exemple #8
0
 public TwoPointNonUniformityCorrectionAlgorithm(TwoPointNonUniformityCorrectionTemplate template)
 {
     _imageModel         = template.ImageModel;
     _nonUniformityModel = template.NonUniformityModel;
 }
        private IImageProcessingAlgorithm CreateTwoPointNonUniformityCorrectionTemplate(TwoPointNonUniformityCorrectionTemplate nonUniformityCorrectionTemplate,
                                                                                        Type algorithmType)
        {
            var nonUniformitySourceFilePath = nonUniformityCorrectionTemplate.NonUniformityModelFilePath;

            nonUniformityCorrectionTemplate.NonUniformityModel = _nonUniformityModelProvider.GetNonUniformityModel(nonUniformitySourceFilePath, nonUniformityCorrectionTemplate.ImageModel);

            return(CreateAlgorithm(nonUniformityCorrectionTemplate, algorithmType));
        }