8ca10923c4
modifié : include/ArrayTree/ArrayTreeBuilder.tpp modifié : include/ArrayTree/Border.hpp modifié : include/ArrayTree/Border.tpp modifié : include/ArrayTree/GraphWalker.tpp modifié : include/ArrayTree/Leader.hpp modifié : include/ArrayTree/Leader.tpp modifié : include/Attribute.hpp modifié : include/AttributeProfiles.hpp modifié : include/AttributeProfiles.tpp modifié : include/CompAttribute.hpp modifié : include/CompAttribute.tpp modifié : include/IImage.hpp modifié : include/IImage.tpp modifié : include/Tree.hpp modifié : include/Tree.tpp modifié : include/TreeBuilder.hpp modifié : include/TreeBuilder.tpp supprimé : src/Attribute.cpp modifié : src/CMakeLists.txt modifié : src/QuadTree/QuadTreeBuilder.cpp modifié : src/TestArrayTreeBuilder.cpp modifié : src/Tree.cpp modifié : src/XMLTree/XMLTreeBuilder.cpp modifié : src/apGenerator.cpp
136 lines
3.4 KiB
C++
136 lines
3.4 KiB
C++
#ifndef _OTB_TRISKELE_TREE_TPP
|
|
#define _OTB_TRISKELE_TREE_TPP
|
|
|
|
// ========================================
|
|
inline unsigned int
|
|
Tree::getCoreCount () const {
|
|
return coreCount;
|
|
}
|
|
|
|
inline DimNodeId *
|
|
Tree::getChildSum () {
|
|
return &childSum[0];
|
|
}
|
|
|
|
inline void
|
|
Tree::setNodeCount (const DimImg &newNodeCount) {
|
|
nodeCount = newNodeCount;
|
|
}
|
|
inline void
|
|
Tree::setSize (const Size &newSize) {
|
|
size = newSize;
|
|
}
|
|
|
|
inline State
|
|
Tree::getState () const {
|
|
return state;
|
|
}
|
|
|
|
inline Size
|
|
Tree::getSize () const {
|
|
return size;
|
|
}
|
|
|
|
inline const DimSideImg &
|
|
Tree::getLeafCount () const {
|
|
return leafCount;
|
|
}
|
|
inline const DimNodeId &
|
|
Tree::getNodeCount () const {
|
|
return nodeCount;
|
|
}
|
|
inline DimImg
|
|
Tree::getCompCount () const {
|
|
return (DimImg) (nodeCount-leafCount);
|
|
}
|
|
inline DimNodeId
|
|
Tree::getNodeRoot () const {
|
|
return nodeCount-1;
|
|
}
|
|
inline DimImg
|
|
Tree::getCompRoot () const {
|
|
return (DimImg) (nodeCount-1-leafCount);
|
|
}
|
|
|
|
inline const DimImg &
|
|
Tree::getParent (const DimNodeId &nodeId) const {
|
|
return leafParents[nodeId];
|
|
}
|
|
inline const DimImg &
|
|
Tree::getLeafParent (const DimImg &leafId) const {
|
|
return leafParents[leafId];
|
|
}
|
|
inline const DimImg &
|
|
Tree::getCompParent (const DimImg &compId) const {
|
|
return compParents[compId];
|
|
}
|
|
|
|
inline const DimImg &
|
|
Tree::getChildrenCount (const DimImg &compId) const {
|
|
return childSum[compId];
|
|
}
|
|
inline const DimNodeId &
|
|
Tree::getChildren (const DimImg &childId) const {
|
|
return children[childId];
|
|
}
|
|
inline const DimNodeId *
|
|
Tree::getChildren () const {
|
|
return &children[0];
|
|
}
|
|
|
|
inline const vector<DimImg> &
|
|
Tree::getWeightBounds () const {
|
|
return weightBounds;
|
|
}
|
|
inline vector<DimImg> &
|
|
Tree::getWeightBounds () {
|
|
return weightBounds;
|
|
}
|
|
|
|
// ========================================
|
|
template<typename FuncToApply>
|
|
inline void
|
|
Tree::forEachLeaf (const FuncToApply &f /* f (DimImg leafId) */) const {
|
|
for (DimImg leafId = 0; leafId < leafCount; ++leafId)
|
|
f (leafId);
|
|
}
|
|
|
|
template<typename FuncToApply>
|
|
inline void
|
|
Tree::forEachComp (const FuncToApply &f /* f (DimImg compId) */) const {
|
|
const DimImg compCount = getCompCount ();
|
|
for (DimImg compId = 0; compId < compCount; ++compId)
|
|
f (compId);
|
|
}
|
|
|
|
template<typename FuncToApply>
|
|
inline void
|
|
Tree::forEachNode (const FuncToApply &f /* f (NodeDimImg nodeId) */) const {
|
|
for (DimNodeId nodeId = 0; nodeId < nodeCount; ++nodeId)
|
|
f (nodeId);
|
|
}
|
|
|
|
template<typename FuncToApply>
|
|
inline void
|
|
Tree::forEachChild (const DimNodeId &parentId, const FuncToApply &f /* f (DimNodeId childId) */) const {
|
|
DimNodeId minChild = childSum[parentId], maxChild = childSum[parentId+1];
|
|
for (DimNodeId childId = minChild; childId < maxChild; ++childId)
|
|
f (children[childId]);
|
|
}
|
|
template<typename FuncToApply>
|
|
inline void
|
|
Tree::forEachChildTI (const DimNodeId &parentId, const FuncToApply &f /* f (bool isLeaf, DimImg childId) */) const {
|
|
DimNodeId minChild = childSum[parentId], maxChild = childSum[parentId+1];
|
|
for (DimNodeId childId = minChild; childId < maxChild; ++childId) {
|
|
const DimNodeId &child (getChildren (childId));
|
|
const bool isLeaf = child < leafCount;
|
|
if (child >= getNodeCount ()) {
|
|
cerr << "coucou Tree::forEachChildTI parentId:" << parentId << " compCount:" << getCompCount () << " minChild:" << minChild << " maxChild:" << maxChild << " childId:" << childId << " child:" << child << endl;
|
|
}
|
|
BOOST_ASSERT (child < getNodeCount ());
|
|
f (isLeaf, isLeaf ? (DimImg) child : (DimImg) (child-leafCount));
|
|
}
|
|
}
|
|
|
|
#endif // _OTB_TRISKELE_TREE_TPP
|