/// <summary> /// Expands the specified steps. /// </summary> /// <param name="steps">The steps.</param> public void expand(int steps) { getReady(); if (item == null) { return; } if (termNotFoundInLexicon) { return; } List <graphWrapNode <termSparkArm> > output = new List <graphWrapNode <termSparkArm> >(); List <graphWrapNode <termSparkArm> > stack = new List <graphWrapNode <termSparkArm> >(); List <ILexiconItem> known = new List <ILexiconItem>(); stack.AddRangeUnique(getLeafs()); int step_i = 1; while (stack.Any()) { List <graphWrapNode <termSparkArm> > n_stack = new List <graphWrapNode <termSparkArm> >(); foreach (graphWrapNode <termSparkArm> child in stack) { lexiconItemExpandEnum reach = lexiconItemExpandEnum.upBelowLateral; reach = lexiconItemExpandEnum.upBelowLateral | lexiconItemExpandEnum.conceptUp; //if (child.item.lexItem.getItemTypeName()==nameof(Concept)) //{ // graphWrapNode<termSparkArm> p = child.parent as graphWrapNode<termSparkArm>; // if (p.item.lexItem.getItemTypeName() != nameof(Concept)) // { // ; // } //} List <ILexiconItem> exp = null; //lock (ExpandLock) { int ri = 0; int rl = 10; while (ri < rl) { try { exp = child.item.lexItem.expandOnce(reach, known); ri = rl + 1; } catch (Exception ex) { ri++; Thread.Sleep(100); aceLog.log("Expand crashed (" + ex.Message + ") -- retry " + ri + " / " + rl); Thread.SpinWait(100); } } //} foreach (ILexiconItem __lexItem in exp) { if (__lexItem != null) { graphWrapNode <termSparkArm> nd = null; //if (child == this) //{ // nd = child.Add(new termSparkArm(__lexItem.name, __lexItem, 1)); //} //else //{ nd = child.Add(new termSparkArm(__lexItem.name, __lexItem, (1 / ((double)child.level + 1)))); //} known.Add(nd.item.lexItem); if (lemma == null) { if (__lexItem is TermLemma) { lemma = (TermLemma)__lexItem; } } } if (known.Count() > expandReachLimit) { return; break; } } if (step_i < steps) { n_stack.AddRangeUnique(child); } } step_i++; stack = n_stack; } }
/// <summary> /// Expands the once. /// </summary> /// <param name="lexItem">The lex item to expand from</param> /// <param name="type">The type of expansion</param> /// <param name="exclude">Items not to expand to</param> /// <returns></returns> public static List <ILexiconItem> expandOnce(this ILexiconItem lexItem, lexiconItemExpandEnum type = lexiconItemExpandEnum.upBelowLateral, List <ILexiconItem> exclude = null) { string itemType = lexItem.getItemTypeName(); List <ILexiconItem> output = new List <ILexiconItem>(); if (exclude == null) { exclude = new List <ILexiconItem>(); } if (type.HasFlag(lexiconItemExpandEnum.includeStart)) { output.Add(lexItem); } switch (itemType) { case nameof(semanticLexicon.Concept): IConcept concept = lexItem as IConcept; if (type.HasFlag(lexiconItemExpandEnum.below)) { output.AddRange(concept.lemmas); output.AddRange(concept.hypoConcepts); } if (type.HasFlag(lexiconItemExpandEnum.lateral)) { output.AddRange(concept.relatedTo); output.AddRange(concept.relatedFrom, true); } if (type.HasFlag(lexiconItemExpandEnum.conceptUp)) { output.AddUnique(concept.hyperConcept); } break; case nameof(TermLemma): ITermLemma lemma = lexItem as ITermLemma; if (lemma == null) { return(output); } if (type.HasFlag(lexiconItemExpandEnum.below)) { if (lemma.instances != null) { output.AddRange(lemma.instances); } } if (type.HasFlag(lexiconItemExpandEnum.lateral)) { if (lemma.relatedFrom != null) { output.AddRange(lemma.relatedFrom); } if (lemma.relatedTo != null) { output.AddRange(lemma.relatedTo); } } if (type.HasFlag(lexiconItemExpandEnum.up)) { if (lemma.concepts != null) { output.AddRange(lemma.concepts); } } if (type.HasFlag(lexiconItemExpandEnum.compounds)) { if (lemma.compounds != null) { output.AddRange(lemma.compounds); } } break; case nameof(TermInstance): ITermInstance instance = lexItem as ITermInstance; if (type.HasFlag(lexiconItemExpandEnum.up)) { output.AddUnique(instance.lemma); } break; } output.RemoveAll(x => exclude.Contains(x)); return(output); }