00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include <algorithm>
00026 #include <iostream>
00027 #include <utility>
00028 #include <vector>
00029 #include <queue>
00030 #include <list>
00031
00032 #include "WHierarchicalTreeFibers.h"
00033
00034 WHierarchicalTreeFibers::WHierarchicalTreeFibers() :
00035 WHierarchicalTree()
00036 {
00037 }
00038
00039 WHierarchicalTreeFibers::~WHierarchicalTreeFibers()
00040 {
00041 }
00042
00043 void WHierarchicalTreeFibers::addLeaf()
00044 {
00045
00046 if( m_leafesLocked )
00047 {
00048 return;
00049 }
00050
00051 m_level.push_back( 0 );
00052 m_parents.push_back( m_clusterCount );
00053 std::vector<size_t> tmp( 1, m_clusterCount );
00054 m_containsLeafes.push_back( tmp );
00055 std::pair<size_t, size_t>tmp2;
00056 m_children.push_back( tmp2 );
00057 m_customData.push_back( 0.0 );
00058 m_colors.push_back( WColor( 0.3, 0.3, 0.3, 1.0 ) );
00059
00060 ++m_leafCount;
00061 ++m_clusterCount;
00062 }
00063
00064 void WHierarchicalTreeFibers::addCluster( size_t cluster1, size_t cluster2, size_t level, std::vector<size_t> leafes, float customData )
00065 {
00066 m_leafesLocked = true;
00067
00068 m_level.push_back( level );
00069 m_maxLevel = std::max( m_maxLevel, level );
00070
00071 m_parents.push_back( m_clusterCount );
00072 m_containsLeafes.push_back( leafes );
00073 m_customData.push_back( customData );
00074 m_colors.push_back( WColor( 0.3, 0.3, 0.3, 1.0 ) );
00075
00076 std::pair<size_t, size_t>childs( cluster1, cluster2 );
00077 m_children.push_back( childs );
00078
00079 m_parents[cluster1] = m_clusterCount;
00080 m_parents[cluster2] = m_clusterCount;
00081
00082 ++m_clusterCount;
00083 }
00084
00085 boost::shared_ptr< std::vector<bool> > WHierarchicalTreeFibers::getOutputBitfield( size_t cluster )
00086 {
00087 boost::shared_ptr< std::vector< bool > > bf;
00088
00089 if( cluster < m_leafCount )
00090 {
00091 bf = boost::shared_ptr< std::vector< bool > >( new std::vector< bool >( m_leafCount, false ) );
00092 ( *bf )[cluster] = true;
00093 }
00094 else
00095 {
00096 if( cluster >= m_clusterCount )
00097 {
00098 return bf;
00099 }
00100
00101 bf = boost::shared_ptr< std::vector< bool > >( new std::vector< bool >( m_leafCount, false ) );
00102
00103 std::vector<size_t> fibers = m_containsLeafes[cluster];
00104 for( size_t i = 0; i < fibers.size(); ++i )
00105 {
00106 ( *bf )[fibers[i]] = true;
00107 }
00108
00109
00110 }
00111 return bf;
00112 }
00113
00114 boost::shared_ptr< std::vector<bool> >WHierarchicalTreeFibers::getOutputBitfield( std::vector<size_t>clusters )
00115 {
00116 boost::shared_ptr< std::vector< bool > > bf;
00117
00118
00119 bf = boost::shared_ptr< std::vector< bool > >( new std::vector< bool >( m_leafCount, false ) );
00120
00121 for( size_t k = 0; k < clusters.size(); ++k )
00122 {
00123 size_t cluster = clusters[k];
00124 std::vector<size_t> fibers = m_containsLeafes[cluster];
00125 for( size_t i = 0; i < fibers.size(); ++i )
00126 {
00127 ( *bf )[fibers[i]] = true;
00128 }
00129 }
00130 return bf;
00131 }
00132
00133 std::vector<size_t> WHierarchicalTreeFibers::getBestClustersFittingRoi( float ratio, size_t number )
00134 {
00135 if( number == 0 )
00136 {
00137 number = 1;
00138 }
00139 std::list<size_t>candidateList;
00140
00141 std::queue<size_t>worklist;
00142 worklist.push( getClusterCount() - 1 );
00143
00144 while( !worklist.empty() )
00145 {
00146 size_t current = worklist.front();
00147 worklist.pop();
00148
00149 if( getRatio( current ) >= ratio )
00150 {
00151 candidateList.push_back( current );
00152 }
00153 else
00154 {
00155 if( getLevel( current ) > 1 )
00156 {
00157 std::pair<size_t, size_t> children = getChildren( current );
00158 if( getLevel( children.first ) > 0 )
00159 {
00160 worklist.push( children.first );
00161 }
00162 if( getLevel( children.second ) > 0 )
00163 {
00164 worklist.push( children.second );
00165 }
00166 }
00167 }
00168 }
00169 candidateList.sort( compSize( this ) );
00170
00171 std::vector<size_t>returnList;
00172
00173 std::list<size_t>::iterator it;
00174 for( it = candidateList.begin(); it != candidateList.end(); ++it )
00175 {
00176 size_t current = *it;
00177 returnList.push_back( current );
00178 --number;
00179 if( number == 0 )
00180 {
00181 break;
00182 }
00183 }
00184
00185
00186 return returnList;
00187 }
00188
00189 float WHierarchicalTreeFibers::getRatio( size_t cluster )
00190 {
00191 std::vector<size_t>fibersInCluster = m_containsLeafes[cluster];
00192
00193 size_t countFibersInCluster = fibersInCluster.size();
00194 size_t fibersFromClusterActive = 0;
00195
00196 for( size_t i = 0; i < countFibersInCluster; ++i )
00197 {
00198 if( ( *m_roiSelection )[fibersInCluster[i]] )
00199 {
00200 ++fibersFromClusterActive;
00201 }
00202 }
00203 return static_cast<float>( fibersFromClusterActive ) / static_cast<float>( countFibersInCluster );
00204 }