OpenWalnut  1.4.0
WHierarchicalTreeFibers.cpp
00001 //---------------------------------------------------------------------------
00002 //
00003 // Project: OpenWalnut ( http://www.openwalnut.org )
00004 //
00005 // Copyright 2009 OpenWalnut Community, BSV@Uni-Leipzig and CNCF@MPI-CBS
00006 // For more information see http://www.openwalnut.org/copying
00007 //
00008 // This file is part of OpenWalnut.
00009 //
00010 // OpenWalnut is free software: you can redistribute it and/or modify
00011 // it under the terms of the GNU Lesser General Public License as published by
00012 // the Free Software Foundation, either version 3 of the License, or
00013 // (at your option) any later version.
00014 //
00015 // OpenWalnut is distributed in the hope that it will be useful,
00016 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00017 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018 // GNU Lesser General Public License for more details.
00019 //
00020 // You should have received a copy of the GNU Lesser General Public License
00021 // along with OpenWalnut. If not, see <http://www.gnu.org/licenses/>.
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     // after a cluster was added no more leafes may be inserted
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     // only a single fiber selected
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         //std::cout << fibers.size() << " fibers selected" << std::endl;
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     // only a single fiber selected
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 }