Ejemplo n.º 1
0
        public ImagingObservationWpfControl(AimTemplateTreeImagingObservationNode imagingObservation)
        {
            ImagingObservation = imagingObservation;
            InitializeComponent();

            _originalBackground = Background;
            ChildControls       = new List <IValidTreeControl>();

            // Hide the allowed terms control that is not being used
            if (MaxNumberOfAnswers > 1)
            {
                _comboBox.Visibility = Visibility.Hidden;
                _comboBox.Height     = 0;

                var cardinalityString = String.Empty;

                if (ImagingObservation.MinCardinality > 0 && ImagingObservation.MaxCardinality >= ImagingObservation.AllowedTerms.Count)
                {
                    cardinalityString = "Select at least " + ImagingObservation.MinCardinality;
                }
                else if (ImagingObservation.MaxCardinality < ImagingObservation.AllowedTerms.Count && ImagingObservation.MinCardinality <= 0)
                {
                    cardinalityString = "Select less than " + (ImagingObservation.MaxCardinality + 1);
                }
                else if (ImagingObservation.MinCardinality > 0 && ImagingObservation.MaxCardinality < ImagingObservation.AllowedTerms.Count)
                {
                    cardinalityString = "Select at least " + ImagingObservation.MinCardinality + " and less than " +
                                        (ImagingObservation.MaxCardinality + 1);
                }

                if (!String.IsNullOrEmpty(cardinalityString))
                {
                    ((TextBlock)_label.Content).Text += Environment.NewLine + cardinalityString;
                }
            }
            else
            {
                _itemsControl.Visibility = Visibility.Hidden;
                _itemsControl.Height     = 0;
            }

            // Add confidence control
            if (ImagingObservation.ShouldDisplay && ImagingObservation.HasConfidence)
            {
                NodeConfidenceWpfControl = new NodeConfidenceWpfControl(ImagingObservation);
                _stackPanel.Children.Add(NodeConfidenceWpfControl);
            }

            var groupedNodes = new List <AimTemplateTreeNode>();

            foreach (var characteristic in imagingObservation.ImagingObservationCharacteristicTreeNodes)
            {
                // Start or add to group label control
                if (!String.IsNullOrEmpty(characteristic.GroupLabel))
                {
                    if (groupedNodes.Count > 0 && characteristic.GroupLabel == groupedNodes[0].GroupLabel)
                    {
                        groupedNodes.Add(characteristic);
                    }
                    else
                    {
                        // Finish and add the group label control
                        if (groupedNodes.Count > 0)
                        {
                            var groupLabel = new GroupLabelWpfControl(groupedNodes)
                            {
                                Header = groupedNodes[0].GroupLabel
                            };
                            _stackPanel.Children.Add(groupLabel);
                            ChildControls.Add(groupLabel);
                        }

                        groupedNodes = new List <AimTemplateTreeNode> {
                            characteristic
                        };
                    }
                }
                else
                {
                    // Finish and add the group label control
                    if (groupedNodes.Count > 0)
                    {
                        var groupLabel = new GroupLabelWpfControl(groupedNodes)
                        {
                            Header = groupedNodes[0].GroupLabel
                        };
                        groupedNodes.Clear();
                        _stackPanel.Children.Add(groupLabel);
                        ChildControls.Add(groupLabel);
                    }

                    var characteristicControl = new ImagingObservationCharacteristicWpfControl(characteristic);
                    _stackPanel.Children.Add(characteristicControl);
                    ChildControls.Add(characteristicControl);
                }
            }

            // Finish and add the group label control
            if (groupedNodes.Count > 0)
            {
                var groupLabel = new GroupLabelWpfControl(groupedNodes)
                {
                    Header = groupedNodes[0].GroupLabel
                };
                _stackPanel.Children.Add(groupLabel);
                ChildControls.Add(groupLabel);
            }

            Loaded += ImagingObservationWpfControlLoaded;

            ImagingObservation.SelectedAllowedTermsChanged += SelectedAllowedTermsCollectionChanged;
            CheckBoxControls = new Dictionary <AimTemplateTreeAllowedTerm, CheckBox>();

            if (!ImagingObservation.ShouldDisplay)
            {
                _label.Visibility        = Visibility.Hidden;
                _label.Height            = 0;
                _itemsControl.Visibility = Visibility.Hidden;
                _itemsControl.Height     = 0;
                _comboBox.Visibility     = Visibility.Hidden;
                _comboBox.Height         = 0;
                if (imagingObservation.ImagingObservationCharacteristicTreeNodes.TrueForAll(item => !item.ShouldDisplay))
                {
                    Visibility = Visibility.Hidden;
                    Height     = 0;
                }
            }
        }
        private AimTemplateTreeImagingObservationNode AimTemplateTreeImagingObservationNodeFromXsdImagingObservation(TemplateComponent component, TemplateComponentImagingObservation imagingObservation)
        {
            var allowedTerms = new List<AimTemplateTreeAllowedTerm>();
            for (int index = 0; index < component.Items.Length; index++)
            {
                object item = component.Items[index];
                if (item.GetType() == typeof(TemplateComponentAllowedTerm))
                {
                    var term = AllowedTermFromXsdAllowedTerm((TemplateComponentAllowedTerm)item);
                    if (term != null)
                    {
                        term.PresentationIndex = index;
                        allowedTerms.Add(term);
                    }
                }
            }

            var imagingObservationCharacteristics = new List<AimTemplateTreeImagingObservationCharacteristicNode>();
            if (imagingObservation.ImagingObservationCharacteristic != null)
            {
                imagingObservationCharacteristics.AddRange(imagingObservation.ImagingObservationCharacteristic.Select(
                anatomicEntityCharacteristic => AimTemplateTreeImagingObservationCharacteristicNodeFromXsdImagingObservationCharacteristic(anatomicEntityCharacteristic)).ToList());
            }

            int itemNumber;
            int.TryParse(component.itemNumber, out itemNumber);

            int minCardinality;
            int.TryParse(component.minCardinality, out minCardinality);

            int maxCardinality;
            int.TryParse(component.maxCardinality, out maxCardinality);

            string label = component.label;
            if (component.QuestionType != null)
                label = component.QuestionType.codeMeaning;

            var node = new AimTemplateTreeImagingObservationNode(
                label,
                itemNumber,
                component.explanatoryText,
                minCardinality,
                maxCardinality,
                component.shouldDisplay,
                component.groupLabel,
                ValidTermFromXsdValidTerm(component.QuestionType),
                imagingObservation.annotatorConfidence,
                allowedTerms,
                imagingObservationCharacteristics,
                component.id
                );
            return node;
        }
Ejemplo n.º 3
0
        private AimTemplateTreeImagingObservationNode AimTemplateTreeImagingObservationNodeFromXsdImagingObservation(TemplateComponent component, TemplateComponentImagingObservation imagingObservation)
        {
            var allowedTerms = new List <AimTemplateTreeAllowedTerm>();

            for (int index = 0; index < component.Items.Length; index++)
            {
                object item = component.Items[index];
                if (item.GetType() == typeof(TemplateComponentAllowedTerm))
                {
                    var term = AllowedTermFromXsdAllowedTerm((TemplateComponentAllowedTerm)item);
                    if (term != null)
                    {
                        term.PresentationIndex = index;
                        allowedTerms.Add(term);
                    }
                }
            }

            var imagingObservationCharacteristics = new List <AimTemplateTreeImagingObservationCharacteristicNode>();

            if (imagingObservation.ImagingObservationCharacteristic != null)
            {
                imagingObservationCharacteristics.AddRange(imagingObservation.ImagingObservationCharacteristic.Select(
                                                               anatomicEntityCharacteristic => AimTemplateTreeImagingObservationCharacteristicNodeFromXsdImagingObservationCharacteristic(anatomicEntityCharacteristic)).ToList());
            }

            int itemNumber;

            int.TryParse(component.itemNumber, out itemNumber);

            int minCardinality;

            int.TryParse(component.minCardinality, out minCardinality);

            int maxCardinality;

            int.TryParse(component.maxCardinality, out maxCardinality);

            string label = component.label;

            if (component.QuestionType != null)
            {
                label = component.QuestionType.codeMeaning;
            }

            var node = new AimTemplateTreeImagingObservationNode(
                label,
                itemNumber,
                component.explanatoryText,
                minCardinality,
                maxCardinality,
                component.shouldDisplay,
                component.groupLabel,
                ValidTermFromXsdValidTerm(component.QuestionType),
                imagingObservation.annotatorConfidence,
                allowedTerms,
                imagingObservationCharacteristics,
                component.id
                );

            return(node);
        }