/// <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);
}
