static PatternTree ToPatternTree(string preString)
        {
            const char separator = ',';

            const bool notCare      = true;
            var        miningParams = new MiningParams(SubtreeType.Induced,
                                                       notCare,
                                                       notCare,
                                                       notCare,
                                                       notCare,
                                                       SupportType.Hybrid,
                                                       1,
                                                       1,
                                                       Global.Seperator,
                                                       Global.BackTrack);

            var segments = preString.Split(new[] { separator });

            var symbols = new NodeSymbol[segments.Length];

            for (var i = 0; i < segments.Length; i++)
            {
                symbols[i] = segments[i];
            }

            return(PatternTree.Create(symbols, notCare, miningParams));
        }
        private int GetOccNumberInTree(PatternTree pt)
        {
            if (pt == null || node == null)
            {
                return(0);
            }

            return(pt.Occurrences.Count(occ => occ.TreeId == node.TreeNode.Tree.TreeId));
        }
        private void ShowTree(string treeId, IOccurrence occ, PatternTree pt)
        {
            var tree = GetTree(treeId);

            if (tree == null)
            {
                return;
            }

            treeVisualizer.SetTree(tree);
            treeVisualizer.SetHighLightOccurrence(occ, pt);
        }
        public void SetHighLightOccurrence(IOccurrence occ, PatternTree pt)
        {
            lblOccNumber.Text = string.Empty;
            occurrences.Clear();
            txtPatternTree.Text = string.Empty;

            if (occ == null)
            {
                return;
            }

            occurrences.Add(occ);

            txtPatternTree.Text = pt == null ? string.Empty : pt.ToString();
        }
        public void SetHighLightOccurrences(PatternTree pt)
        {
            lblOccNumber.Text = string.Empty;
            occurrences.Clear();
            txtPatternTree.Text = string.Empty;

            if (pt == null)
            {
                return;
            }
            lblOccNumber.Text = string.Format("Occurrence Number: {0}", GetOccNumberInTree(pt));
            foreach (var occ in pt.Occurrences)
            {
                occurrences.Add(occ);
            }

            txtPatternTree.Text = pt.ToString();
        }
        public FOccurrencesViewer(IList <ITextTree> textTrees, PatternTree pattern)
        {
            if (textTrees == null)
            {
                throw new ArgumentNullException("textTrees");
            }
            if (pattern == null)
            {
                throw new ArgumentNullException("pattern");
            }
            if (pattern.TransactionSupport != textTrees.Count)
            {
                throw new ArgumentException();
            }

            InitializeComponent();

            this.textTrees = new ReadOnlyCollection <ITextTree>(textTrees);
            this.pattern   = pattern;
            range          = this.textTrees.Count;

            Text += string.Format("    {0}; TransactionSupport={1}; RootOccurrenceSuppoer={2}",
                                  this.pattern.PreorderString, this.pattern.TransactionSupport, this.pattern.RootSupport);
        }