public MaxTreeAutoDual(IAlgebraReal <ElementType> algebra, IMaxTreeBuilder <ElementType> builder, ITopologyElement topology, ElementType[] element_values)
{
this.algebra = algebra;
this.max_tree = builder.BuildMaxTree(element_values, new ComparerNatural <ElementType>(), topology, element_values.Length);
this.min_tree = builder.BuildMaxTree(element_values, new ComparerNatural <ElementType>(true), topology, element_values.Length);
this.element_values = ToolsCollection.Copy(element_values);
}
public void TestDefaultBuilderTrivial0(IMaxTreeBuilder <int> builder)
{
int[] data = new int[] { 0, 0, 0, 0 };
IImageRaster2D <int> image = new ImageRaster2D <int>(2, 2, data, false);
ITopologyElement topology = new TopologyElementRaster2D4Connectivity(image.Raster);
IMaxTree <int> maxtree = builder.BuildMaxTree(data, new ComparerNatural <int>(), topology, data.Length);
}
public void TestDefaultBuilderTrivial4(IMaxTreeBuilder <int> builder)
{
int[] data = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
IImageRaster3D <int> image = new ImageRaster3D <int>(3, 3, 1, data, false);
ITopologyElement topology = new TopologyElementRaster3D6Connectivity(image.Raster);
IMaxTree <int> maxtree = builder.BuildMaxTree(data, new ComparerNatural <int>(), topology, data.Length);
maxtree.GetDisplayValues();
}
public void TestDefaultBuilderVeryBig(IMaxTreeBuilder <int> builder)
{
Random random = new Random(0);
int[] data = new int[512 * 512 * 10];
for (int index = 1; index < data.Length; index++)
{
data[index] = (int)(random.NextDouble() * 100.0);
}
IImageRaster3D <int> image = new ImageRaster3D <int>(512, 512, 10, data, false);
ITopologyElement topology = new TopologyElementRaster3D6Connectivity(image.Raster);
IMaxTree <int> maxtree = builder.BuildMaxTree(data, new ComparerNatural <int>(), topology, data.Length);
}
public MaxTreeFloat3DFeaturesDouble(IImageRaster <IRaster3DInteger, float> image, FeatureGeneratorElementNode3DDouble generator, IProgressReporter reporter)
{
this.raster = image.Raster;
this.inner_max_tree = new MaxTreeBuilderSingleQueue <float>().BuildMaxTree(image.GetElementValues(false), new ComparerNatural <float>(), new TopologyElementRaster3D6Connectivity(image.Raster), image.Raster.ElementCount);
if (generator != null)
{
this.features = new double[inner_max_tree.NodeCount, generator.FeatureCount];
generator.GenerateFeaturesTree(raster, inner_max_tree.BottomLevelNode, features);
}
else
{
this.features = null;
}
}
public void TestDefaultBuilderTrivial3(IMaxTreeBuilder <int> builder)
{
int[] data = new int[] { 1, 2, 2, 0, 2, 1 };
IImageRaster2D <int> image = new ImageRaster2D <int>(2, 3, data, false);
ITopologyElement topology = new TopologyElementRaster2D4Connectivity(image.Raster);
IMaxTree <int> maxtree = builder.BuildMaxTree(data, new ComparerNatural <int>(), topology, data.Length);
int[] element_indexes_0 = maxtree.GetFullElementsIndexesOfElementLevelAndAbove(1);
Assert.AreEqual(1, element_indexes_0.Length);
int[] element_indexes_1 = maxtree.GetFullElementsIndexesOfElementLevelAndAbove(4);
Assert.AreEqual(2, element_indexes_1.Length);
int[] element_indexes_2 = maxtree.GetFullElementsIndexesOfElementLevelAndAbove(0);
Assert.AreEqual(5, element_indexes_2.Length);
int[] element_indexes_3 = maxtree.GetFullElementsIndexesOfElementLevelAndAbove(3);
Assert.AreEqual(6, element_indexes_3.Length);
}
public void TestDefaultBuilderBig(IMaxTreeBuilder <int> builder)
{
Random random = new Random(0);
int[] data = new int [512 * 512];
for (int index = 1; index < data.Length; index++)
{
data[index] = (int)(random.NextDouble() * 100.0);
}
IImageRaster2D <int> image = new ImageRaster2D <int>(512, 512, data, false);
ITopologyElement topology = new TopologyElementRaster2D4Connectivity(image.Raster);
IMaxTree <int> maxtree = builder.BuildMaxTree(data, new ComparerNatural <int>(), topology, data.Length);
maxtree.GetFullElementsIndexesOfElementLevelAndAbove(0);
maxtree.GetFullElementsIndexesOfElementLevelAndAbove(500);
maxtree.GetFullElementsIndexesOfElementLevelAndAbove(1800);
}
public void ComputePrimitives(
IMaxTree <ElementType> max_tree)
{
int real_image_size = max_tree.RealElementCount;
// Depth first for low memory and
Stack <Tuple <MaxTreeNode <ElementType>, int> > node_stack = new Stack <Tuple <MaxTreeNode <ElementType>, int> >();
node_stack.Push(new Tuple <MaxTreeNode <ElementType>, int>(this, 0));
while (node_stack.Count != 0)
{
Tuple <MaxTreeNode <ElementType>, int> node_index_pair = node_stack.Pop();
MaxTreeNode <ElementType> node = node_index_pair.Item1;
int index = node_index_pair.Item2;
if (index < node.children.Count)
{
node_stack.Push(new Tuple <MaxTreeNode <ElementType>, int>(node, index + 1));
node_stack.Push(new Tuple <MaxTreeNode <ElementType>, int>(node.children[index], 0));
}
else
{
node.MaxTree = max_tree;
node.PeakComponentValue = node.Value;
node.CulmativeFullSize = 0;
foreach (int element in node.NodeElementIndexes)
{
node.CulmativeFullSize++;
if (element < real_image_size)
{
node.CulmativeRealSize++;
}
}
foreach (MaxTreeNode <ElementType> child in node.children)
{
if (element_value_comparer.Compare(PeakComponentValue, child.PeakComponentValue) == -1)
{
node.PeakComponentValue = child.PeakComponentValue;
}
node.CulmativeFullSize += child.CulmativeFullSize;
node.CulmativeRealSize += child.CulmativeRealSize;
}
}
}
}
public IAlphaPartitionTree <EdgeValueType> BuildAlphaPartitionTree(
ITopologyElementEdge element_topology,
IFunctionDissimilarity <ElementValueType, EdgeValueType> edge_function,
ElementValueType[] element_values,
IProgressReporter reporter)
{
Debug.Assert(element_topology.ElementCountReal == element_values.Length);
Tuple <EdgeValueType[], EdgeValueType> element_and_edge_values =
element_topology.CreateAlphaPartitionTreeElementArray <ElementValueType, EdgeValueType>(
this.algebra,
edge_function,
element_values);
EdgeValueType[] edge_values = element_and_edge_values.Item1;
//Note max tree is really a min tree becuase of the edge value flip flip by the topology
IMaxTree <EdgeValueType> min_tree = builder.BuildMaxTree(element_and_edge_values.Item1, new ComparerNatural <EdgeValueType>(), element_topology, element_values.Length, reporter);
return(new AlphaPartitionTreeMinTree <EdgeValueType>(algebra, min_tree, element_and_edge_values.Item2));
}
public IAlphaPartitionTree <EdgeValueType> BuildAlphaPartitionTree(ITopologyElementEdge element_topology, EdgeValueType[] element_and_egde_values, EdgeValueType max_edge_value, IProgressReporter reporter)
{
IMaxTree <EdgeValueType> min_tree = builder.BuildMaxTree(element_and_egde_values, new ComparerNatural <EdgeValueType>(), element_topology, element_topology.ElementCountReal, reporter);
return(new AlphaPartitionTreeMinTree <EdgeValueType>(algebra, min_tree, max_edge_value));
}
public AlphaPartitionTreeMinTree(IAlgebraReal <EdgeValueType> algebra, IMaxTree <EdgeValueType> min_tree, EdgeValueType max_edge_value)
{
this.algebra = algebra;
this.min_tree = min_tree;
this.max_edge_value = max_edge_value;
}
