OpenWalnut  1.3.1
WHierarchicalTreeFibers.cpp
1 //---------------------------------------------------------------------------
2 //
3 // Project: OpenWalnut ( http://www.openwalnut.org )
4 //
5 // Copyright 2009 OpenWalnut Community, BSV@Uni-Leipzig and CNCF@MPI-CBS
6 // For more information see http://www.openwalnut.org/copying
7 //
8 // This file is part of OpenWalnut.
9 //
10 // OpenWalnut is free software: you can redistribute it and/or modify
11 // it under the terms of the GNU Lesser General Public License as published by
12 // the Free Software Foundation, either version 3 of the License, or
13 // (at your option) any later version.
14 //
15 // OpenWalnut is distributed in the hope that it will be useful,
16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 // GNU Lesser General Public License for more details.
19 //
20 // You should have received a copy of the GNU Lesser General Public License
21 // along with OpenWalnut. If not, see <http://www.gnu.org/licenses/>.
22 //
23 //---------------------------------------------------------------------------
24 
25 #include <algorithm>
26 #include <iostream>
27 #include <utility>
28 #include <vector>
29 #include <queue>
30 #include <list>
31 
32 #include "WHierarchicalTreeFibers.h"
33 
36 {
37 }
38 
40 {
41 }
42 
44 {
45  // after a cluster was added no more leafes may be inserted
46  if( m_leafesLocked )
47  {
48  return;
49  }
50 
51  m_level.push_back( 0 );
52  m_parents.push_back( m_clusterCount );
53  std::vector<size_t> tmp( 1, m_clusterCount );
54  m_containsLeafes.push_back( tmp );
55  std::pair<size_t, size_t>tmp2;
56  m_children.push_back( tmp2 );
57  m_customData.push_back( 0.0 );
58  m_colors.push_back( WColor( 0.3, 0.3, 0.3, 1.0 ) );
59 
60  ++m_leafCount;
62 }
63 
64 void WHierarchicalTreeFibers::addCluster( size_t cluster1, size_t cluster2, size_t level, std::vector<size_t> leafes, float customData )
65 {
66  m_leafesLocked = true;
67 
68  m_level.push_back( level );
69  m_maxLevel = std::max( m_maxLevel, level );
70 
71  m_parents.push_back( m_clusterCount );
72  m_containsLeafes.push_back( leafes );
73  m_customData.push_back( customData );
74  m_colors.push_back( WColor( 0.3, 0.3, 0.3, 1.0 ) );
75 
76  std::pair<size_t, size_t>childs( cluster1, cluster2 );
77  m_children.push_back( childs );
78 
79  m_parents[cluster1] = m_clusterCount;
80  m_parents[cluster2] = m_clusterCount;
81 
83 }
84 
85 boost::shared_ptr< std::vector<bool> > WHierarchicalTreeFibers::getOutputBitfield( size_t cluster )
86 {
87  boost::shared_ptr< std::vector< bool > > bf;
88  // only a single fiber selected
89  if( cluster < m_leafCount )
90  {
91  bf = boost::shared_ptr< std::vector< bool > >( new std::vector< bool >( m_leafCount, false ) );
92  ( *bf )[cluster] = true;
93  }
94  else
95  {
96  if( cluster >= m_clusterCount )
97  {
98  return bf;
99  }
100 
101  bf = boost::shared_ptr< std::vector< bool > >( new std::vector< bool >( m_leafCount, false ) );
102 
103  std::vector<size_t> fibers = m_containsLeafes[cluster];
104  for( size_t i = 0; i < fibers.size(); ++i )
105  {
106  ( *bf )[fibers[i]] = true;
107  }
108 
109  //std::cout << fibers.size() << " fibers selected" << std::endl;
110  }
111  return bf;
112 }
113 
114 boost::shared_ptr< std::vector<bool> >WHierarchicalTreeFibers::getOutputBitfield( std::vector<size_t>clusters )
115 {
116  boost::shared_ptr< std::vector< bool > > bf;
117  // only a single fiber selected
118 
119  bf = boost::shared_ptr< std::vector< bool > >( new std::vector< bool >( m_leafCount, false ) );
120 
121  for( size_t k = 0; k < clusters.size(); ++k )
122  {
123  size_t cluster = clusters[k];
124  std::vector<size_t> fibers = m_containsLeafes[cluster];
125  for( size_t i = 0; i < fibers.size(); ++i )
126  {
127  ( *bf )[fibers[i]] = true;
128  }
129  }
130  return bf;
131 }
132 
133 std::vector<size_t> WHierarchicalTreeFibers::getBestClustersFittingRoi( float ratio, size_t number )
134 {
135  if( number == 0 )
136  {
137  number = 1;
138  }
139  std::list<size_t>candidateList;
140 
141  std::queue<size_t>worklist;
142  worklist.push( getClusterCount() - 1 );
143 
144  while( !worklist.empty() )
145  {
146  size_t current = worklist.front();
147  worklist.pop();
148 
149  if( getRatio( current ) >= ratio )
150  {
151  candidateList.push_back( current );
152  }
153  else
154  {
155  if( getLevel( current ) > 1 )
156  {
157  std::pair<size_t, size_t> children = getChildren( current );
158  if( getLevel( children.first ) > 0 )
159  {
160  worklist.push( children.first );
161  }
162  if( getLevel( children.second ) > 0 )
163  {
164  worklist.push( children.second );
165  }
166  }
167  }
168  }
169  candidateList.sort( compSize( this ) );
170 
171  std::vector<size_t>returnList;
172 
173  std::list<size_t>::iterator it;
174  for( it = candidateList.begin(); it != candidateList.end(); ++it )
175  {
176  size_t current = *it;
177  returnList.push_back( current );
178  --number;
179  if( number == 0 )
180  {
181  break;
182  }
183  }
184 
185 
186  return returnList;
187 }
188 
189 float WHierarchicalTreeFibers::getRatio( size_t cluster )
190 {
191  std::vector<size_t>fibersInCluster = m_containsLeafes[cluster];
192 
193  size_t countFibersInCluster = fibersInCluster.size();
194  size_t fibersFromClusterActive = 0;
195 
196  for( size_t i = 0; i < countFibersInCluster; ++i )
197  {
198  if( ( *m_roiSelection )[fibersInCluster[i]] )
199  {
200  ++fibersFromClusterActive;
201  }
202  }
203  return static_cast<float>( fibersFromClusterActive ) / static_cast<float>( countFibersInCluster );
204 }