/// <summary>
        /// Merges the specified item b.
        /// </summary>
        /// <param name="itemB">The item b.</param>
        public void Merge(HtmlTagCategoryTree itemB)
        {
            List <HtmlTagCounter> newNodes = new List <HtmlTagCounter>();

            List <imbSCI.Data.interfaces.IObjectWithPathAndChildren> leaves = itemB.getAllLeafs();

            leaves.ForEach(x => newNodes.Add(x as HtmlTagCounter));


            while (newNodes.Count != 0)
            {
                List <HtmlTagCounter> actNodes = newNodes;
                newNodes = new List <HtmlTagCounter>();
                foreach (HtmlTagCounter n in actNodes)
                {
                    var an = this.GetOrAddCategory(n.path, n.description, n.weight);
                    an.Score += n.Score;

                    foreach (String cn in n.getChildNames())
                    {
                        newNodes.Add(n[cn] as HtmlTagCounter);
                    }
                }
            }


            UnknownTags.Score += itemB.UnknownTags.Score;

            DistinctTags.AddRange(itemB.DistinctTags, true);
            DistinctUnknownTags.AddRange(itemB.DistinctUnknownTags, true);
        }
        /// <summary>
        /// Gets the data table.
        /// </summary>
        /// <param name="_name">The name.</param>
        /// <param name="_description">The description.</param>
        /// <returns></returns>
        public DataTable GetDataTable(String _name, String _description)
        {
            DataTableTypeExtended <HtmlTagCounterResult> output = new DataTableTypeExtended <HtmlTagCounterResult>(_name, _description);
            var results = GetResultList();

            results.ForEach(x => output.AddRow(x));

            output.SetAdditionalInfoEntry("Unknown dist. tags", DistinctUnknownTags.Count, "Number of distinct unknown tags");
            output.SetAdditionalInfoEntry("Distinct tags", DistinctTags.Count, "Number of known distinct tags");
            output.SetAdditionalInfoEntry("Unknown tags", UnknownTags.Count(), "Number of unknown distinct tags");

            output.AddExtra("Distinct tags found: [" + DistinctTags.toCsvInLine() + "]");
            output.AddExtra("Unknown tags found: [" + UnknownTags.toCsvInLine() + "]");

            return(output);
        }
        public override GridShape GetGridShape()
        {
            int channels = DistinctTags.Count();

            switch (m_ChannelEncoding)
            {
            case ColliderEncodingType.OneHotAndShortestDistance:
                channels++;
                break;

            case ColliderEncodingType.OneHotAndDistances:
                channels *= 2;
                break;
            }

            return(new GridShape(m_ObservationStackSize, channels, m_GridDimensions));
        }
        /// <summary>
        /// Counts the tags.
        /// </summary>
        /// <param name="nodes">The nodes.</param>
        public void CountTags(IEnumerable <HtmlNode> nodes)
        {
            List <HtmlNode> newNodes = new List <HtmlNode>();

            newNodes.AddRange(nodes);

            while (newNodes.Count != 0)
            {
                List <HtmlNode> actNodes = newNodes;
                newNodes = new List <HtmlNode>();
                foreach (HtmlNode n in actNodes)
                {
                    if (n.NodeType == HtmlNodeType.Element)
                    {
                        String nl = n.Name.ToLower();
                        if (counterDictionary.ContainsKey(nl))
                        {
                            counterDictionary[nl].ScoreUp(nl);
                            if (!DistinctTags.Contains(nl))
                            {
                                DistinctTags.Add(nl);
                            }
                        }
                        else
                        {
                            UnknownTags.Score++;
                            if (!DistinctUnknownTags.Contains(nl))
                            {
                                DistinctUnknownTags.Add(nl);
                            }
                        }

                        newNodes.AddRange(n.ChildNodes);
                    }
                }
            }
        }