A basic documentation for users get started with.

Design and implement the algorithm to compute area.

Fix Continuos to Continuous in the attribute naming.

Design and implement a class to represent a collection attributes over the nodes of a component tree. For example, this class should provide a way to access the values of a set of attributes (defined by the user) for each node. For example:

attr[attr_type][node_id] => return the value of attribute 'attr_type' of the node 'node_id'.

Design and implement the algorithm to compute the bit-quads incrementally.

Design and implement the class IncrementalAttributeComputer which implements AttributeComputer. This class provides the interface and algorithm to compute attributes in incremental fashion using a no-recursive algorithm.

The classes CTree and CTNode should have aliases for the most common types like the class Point2D.

The types should have aliases are:

• unsigned char
• char
• unsigned int
• int
• unsigned long
• long
• float
• double

Make all inheritance virtual.

https://en.wikipedia.org/wiki/Virtual_inheritance

Change the attributes integer vectors 'dx' and 'dy' to use IPoint2D vector instead, such that the caller must specify the same number of x and y coordinates.

We should write the pruning and image reconstruct algorithm and then we can write a "get started application" by implementing a connected filter (e.g. area opening).

Change return type from std::unique_ptr to std::unique_ptr in all methods of 8- and 4-connected adjacency creation.

Implement increasing and decreasing count sort algorithms.

Change the CTSorter to be a function in the CTBuilder's method build.

Design and implement the attribute computer which interacts with attribute collection. This function provides the interface to classes which compute attributes for a component tree.

The wiki page should have a get started page where the basic functionality of the framework should be shown. In this example, an image should be read (maybe using stb library), its component tree should be read, an attribute like area should be computed and an opening filter should be executed.

Design and implement a set of classes to represent Image 2D Indexing such that if it accesses a position out of domain it returns an invalid value (a constant value, null, exception etc...)

This is a refactor issue, the class and method names are pretty bad. This issue tries to make these names shorter and clear in order to make code shorter and easy to understand.

Below there are some suggestions to be discussed: (original name => proposed new name)

MorphologicalTree => CTree

nodes
cmap

MorphologicalTree() => CTree()
MorphologicalTree(parent, sortedIndex, vertices) => CTree(parent, sortedIndices, vertices)
tranverseFromLeavesToRoot(visit) => tranverse(visit)
getNumberOfNodes() => numberOfNodes()
getNodeLevel(id) => nodeLevel(id)
getNodeParent(id) => nodeParent(id)
getNodeChildren(id) => nodeChildren(id)
getNodePixels(id) => nodeVertices(id)
reconstructTreeNode() => reconstructNode()
createNodes(parent, sortedIndex, vertices) => createNodes(parent, sortedIndices, vertices)

MTNode => CTNode

OK excepted by:
vertexIndixes => vertexIndices

MorphologicalTreeBuilderSorter => CTSorter (Extract it from the Builder file)

sort(vertices) => sort(vertices)
countingSort() => countingSort(vertices)

MaxTreeSorter => MaxTreeSorter

sort(vertices) => sort(vertices)
countingSort() => countingSort(vertices)

MorphologicalTreeBuilder => CTBuilder

build(vertices, adj, treeType)
buildWithSorter(vertices, adj, sorter) => build(vertices, adj, sorter)
findRoot(zpar, x)
canonizeTree(vertices, sortedVertices, parent)

AdjacencyRelation => Adjacency

getAdjacentElements(curElem) => neighbours(id)

Image2DAdjacencyRelationByTranslating => AdjacencyByTranslating (remove it from Image2D)

Image2DAdjacencyRelationByTranslating(width, height, t) => AdjacencyByTranslating
createFourConnectedAdjacency(width, height) => create4CAdjacency(width, height)
createEightConnectedAdjacency(width, height) => create8CAdjacency(width, height)

Point2D => OK