public static void ConformTrees(DataTree t1, DataTree t2, DataGroupingModes mode, out DataTree firstTree, out DataTree secondTree, int primary = 0)
{
int ind = -1;
if (mode == DataGroupingModes.Shortest)
{
ind = t1.Count <= t2.Count ? 0 : 1;
}
else if (mode == DataGroupingModes.Longest)
{
ind = t1.Count >= t2.Count ? 0 : 1;
}
else if (mode == DataGroupingModes.Primary)
{
firstTree = primary == 0 ? t1 : t1.ConformTree(t2);
secondTree = primary == 0 ? t2.ConformTree(t1) : t2;
return;
}
if (ind != -1)
{
if (ind == 0)
{
firstTree = t1; secondTree = t2.ConformList(t1);
}
else
{
firstTree = t1.ConformList(t2); secondTree = t2;
}
bool test = ind == 0 ? firstTree.IsTree : secondTree.IsTree;
if (test)
{
if (ind == 0 && !secondTree.IsTree)
{
secondTree.GraftTree();
}
else if (ind == 1 && !firstTree.IsTree)
{
firstTree.GraftTree();
}
for (int i = 0; i < firstTree.Count; i++)
{
ConformTrees(firstTree[i] as DataTree, secondTree[i] as DataTree, mode, out DataTree f1, out DataTree f2, primary);
firstTree.Data[i].Replace(f1);
secondTree.Data[i].Replace(f2);
}
}
}
else
{
CrossRefTree(t1, t2, out firstTree, out secondTree);
}
}
private static void ConformListOfTreesLongestShortest(List <DataTree> input, out List <DataTree> output, DataGroupingModes mode)
{
output = new List <DataTree>();
int maxCount = -1;
int maxIndex = -1;
int minCount = int.MaxValue;
int minIndex = -1;
for (int i = 0; i < input.Count; i++)
{
if (input[i].Count > maxCount)
{
maxCount = input[i].Count; maxIndex = i;
}
; if (input[i].Count < minCount)
{
minCount = input[i].Count; minIndex = i;
}
}
bool test = false;
foreach (var l in input)
{
output.Add(l.RequestNewSizeRepeatLast(mode == DataGroupingModes.Longest ? maxCount : minCount));
test |= l.IsTree;
}
if (test)
{
foreach (var l in output)
{
if (!(l.IsTree))
{
l.GraftTree();
}
}
for (int i = 0; i < output[0].Count; i++)
{
var newInput = new List <DataTree>();
foreach (var l in output)
{
newInput.Add(l.Data[i] as DataTree);
}
ConformListOfTreesLongestShortest(newInput, out List <DataTree> newOutput, mode);
for (int j = 0; j < newOutput.Count; j++)
{
output[j].ReplaceBranch(newOutput[j], i);
}
}
}
}
public static void ConformTrees(List <DataTree> trees, out List <DataTree> output, DataGroupingModes mode, int primaryIndex = 0)
{
output = new List <DataTree>();
if (mode == DataGroupingModes.Primary)
{
output.Add(trees[primaryIndex]);
for (int i = 0; i < trees.Count; i++)
{
if (i != primaryIndex)
{
ConformTrees(trees[primaryIndex], trees[i], mode, out DataTree f1, out DataTree f2, 0);
//output.Add(f1);
output.Add(f2);
}
}
}
else if (mode == DataGroupingModes.CrossReference)
{
CrossRefTree(trees, out output);
}
else
{
ConformListOfTreesLongestShortest(trees, out output, mode);
}
}
