OpenWalnut  1.4.0
WDataSetFiberVector.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 <string>
26 #include <algorithm>
27 #include <vector>
28 
29 #include "../common/WLogger.h"
30 #include "../common/datastructures/WFiber.h"
31 #include "WDataSet.h"
32 #include "WDataSetFiberVector.h"
33 
34 // prototype instance as singleton
35 boost::shared_ptr< WPrototyped > WDataSetFiberVector::m_prototype = boost::shared_ptr< WPrototyped >();
36 
38  : WMixinVector< WFiber >(),
39  WDataSet()
40 {
41 }
42 
43 WDataSetFiberVector::WDataSetFiberVector( boost::shared_ptr< std::vector< WFiber > > fibs )
44  : WMixinVector< WFiber >( *fibs ), // COPYING this into this since, WMixinVector has no possibility for references or boost::shared_ptr
45  WDataSet()
46 {
47 }
48 
49 WDataSetFiberVector::WDataSetFiberVector( boost::shared_ptr< const WDataSetFibers > fiberDS )
50  : WMixinVector< WFiber >(),
51  WDataSet()
52 {
53  if( !fiberDS.get() )
54  {
55  wlog::error( "WDataSetFiberVector" ) << "During constructing a WDataSetFiberVector out of an empty WDataSetFibers";
56  return;
57  }
58 
59  if( fiberDS->getFilename() != "" )
60  {
61  setFilename( fiberDS->getFilename() );
62  }
63  size_t numLines = fiberDS->size();
64  const std::vector< size_t >& lineLengths = *fiberDS->getLineLengths();
65  reserve( numLines );
66 
67  while( size() < numLines )
68  {
69  WFiber fib;
70  for( size_t i = 0; i < lineLengths[ size() ]; ++i )
71  {
72  fib.push_back( fiberDS->getPosition( size(), i ) );
73  }
74  push_back( fib );
75  }
76 }
77 
79  : WMixinVector< WFiber >( other ),
80  WDataSet()
81 {
82 }
83 
85 {
86  if( this == &other )
87  {
88  return *this;
89  }
90  assign( other.begin(), other.end() );
91  return *this;
92 }
93 
95 {
96  // since no pointer deallocation is needed, nothing to do here
97 }
98 
100 {
101  std::sort( begin(), end(), hasMorePointsThen );
102 }
103 
104 boost::shared_ptr< WDataSetFiberVector > WDataSetFiberVector::generateDataSetOutOfUsedFibers( const std::vector< bool > &unused ) const
105 {
106  boost::shared_ptr< WDataSetFiberVector > result( new WDataSetFiberVector() );
107  assert( unused.size() == size() );
108  for( size_t i = 0 ; i < unused.size(); ++i )
109  {
110  if( !unused[i] )
111  {
112  result->push_back( at( i ) );
113  }
114  }
115  return result;
116 }
117 
119 {
120  return false;
121 }
122 
123 const std::string WDataSetFiberVector::getName() const
124 {
125  return "WDataSetFiberVector";
126 }
127 
128 const std::string WDataSetFiberVector::getDescription() const
129 {
130  return "Contains tracked fiber data.";
131 }
132 
133 boost::shared_ptr< WPrototyped > WDataSetFiberVector::getPrototype()
134 {
135  if( !m_prototype )
136  {
137  m_prototype = boost::shared_ptr< WPrototyped >( new WDataSetFiberVector() );
138  }
139 
140  return m_prototype;
141 }
142 
143 boost::shared_ptr< WDataSetFibers > WDataSetFiberVector::toWDataSetFibers() const
144 {
145  boost::shared_ptr< std::vector< float > > points( new std::vector< float > );
146  boost::shared_ptr< std::vector< size_t > > fiberStartIndices( new std::vector< size_t > );
147  boost::shared_ptr< std::vector< size_t > > fiberLengths( new std::vector< size_t > );
148  boost::shared_ptr< std::vector< size_t > > pointFiberMapping( new std::vector< size_t > );
149 
150  fiberStartIndices->reserve( size() );
151  fiberLengths->reserve( size() );
152  // other reserving for points and pointFiberMapping is not possible here without cycling through the whole data
153 
154  size_t fiberID = 0;
155  for( const_iterator cit = begin(); cit != end(); ++cit, ++fiberID )
156  {
157  const WFiber& fib = *cit;
158  // the division by 3 is necessary since it carries the point numbers not the number of the i'th component
159  fiberStartIndices->push_back( points->size() / 3 );
160  fiberLengths->push_back( fib.size() );
161  for( WFiber::const_iterator fit = fib.begin(); fit != fib.end(); ++fit )
162  {
163  points->push_back( ( *fit )[0] );
164  points->push_back( ( *fit )[1] );
165  points->push_back( ( *fit )[2] );
166  pointFiberMapping->push_back( fiberID );
167  }
168  }
169 
170  return boost::shared_ptr< WDataSetFibers >( new WDataSetFibers( points, fiberStartIndices, fiberLengths, pointFiberMapping ) );
171 }
172 
173 boost::shared_ptr< WFiber > centerLine( boost::shared_ptr< const WDataSetFiberVector > tracts )
174 {
175  if( !tracts || tracts->empty() ) // invalid data produces invalid center lines
176  {
177  return boost::shared_ptr< WFiber >( new WFiber() );
178  }
179 
180  size_t avgTractSize = 0;
181  for( WDataSetFiberVector::const_iterator cit = tracts->begin(); cit != tracts->end(); ++cit )
182  {
183  avgTractSize += cit->size();
184  }
185  avgTractSize /= tracts->size();
186 
187  WFiber firstTract( tracts->front() );
188  firstTract.resampleByNumberOfPoints( avgTractSize );
189  boost::shared_ptr< WFiber > result( new WFiber( firstTract ) ); // copy the first tract into result centerline
190 
191  for( size_t tractIndex = 1; tractIndex < tracts->size(); ++tractIndex )
192  {
193  WFiber other( tracts->at( tractIndex ) );
194  other.resampleByNumberOfPoints( avgTractSize );
195  other.unifyDirectionBy( firstTract );
196 
197  for( size_t pointIndex = 0; pointIndex < avgTractSize; ++pointIndex )
198  {
199  result->at( pointIndex ) += other[ pointIndex ];
200  }
201  }
202 
203  for( size_t pointIndex = 0; pointIndex < avgTractSize; ++pointIndex )
204  {
205  result->at( pointIndex ) /= static_cast< double >( tracts->size() );
206  }
207 
208  return result;
209 }
210 
211 boost::shared_ptr< WFiber > longestLine( boost::shared_ptr< const WDataSetFiberVector > tracts )
212 {
213  if( !tracts || tracts->empty() ) // invalid data produces invalid longest lines
214  {
215  return boost::shared_ptr< WFiber >( new WFiber() );
216  }
217 
218  size_t maxSize = 0;
219  size_t maxIndex = 0;
220 
221  for( size_t tractIndex = 0; tractIndex < tracts->size(); ++tractIndex )
222  {
223  if( maxSize < tracts->at( tractIndex ).size() )
224  {
225  maxSize = tracts->at( tractIndex ).size();
226  maxIndex = tractIndex;
227  }
228  }
229 
230  return boost::shared_ptr< WFiber >( new WFiber( tracts->at( maxIndex ) ) );
231 }
232 
233 boost::shared_ptr< WFiber > centerLine( boost::shared_ptr< const WDataSetFibers > tracts )
234 {
235  return centerLine( boost::shared_ptr< WDataSetFiberVector >( new WDataSetFiberVector( tracts ) ) );
236 }
237 
238 boost::shared_ptr< WFiber > longestLine( boost::shared_ptr< const WDataSetFibers > tracts )
239 {
240  return longestLine( boost::shared_ptr< WDataSetFiberVector >( new WDataSetFiberVector( tracts ) ) );
241 }
WStreamedLogger error(const std::string &source)
Logging an error message.
Definition: WLogger.h:298
Represents a simple set of WFibers.
Represents a neural pathway.
Definition: WFiber.h:39
virtual ~WDataSetFiberVector()
Destructs WDataSetFiberVector instances.
Base class for all data set types.
Definition: WDataSet.h:51
vector_type::const_iterator const_iterator
Compares to std::vector type.
Definition: WMixinVector.h:87
const_reference at(size_type index) const
Wrapper around std::vector member function.
Definition: WMixinVector.h:413
const_iterator begin() const
Wrapper around std::vector member function.
Definition: WMixinVector.h:307
void push_back(const value_type &value)
Wrapper around std::vector member function.
Definition: WMixinVector.h:457
void resampleByNumberOfPoints(size_t numPoints)
Resample this line so it has a number of given points afterwards.
Definition: WLine.cpp:78
static boost::shared_ptr< WPrototyped > m_prototype
The prototype as singleton.
const_iterator end() const
Wrapper around std::vector member function.
Definition: WMixinVector.h:327
void reserve(size_type new_capacity)
Wrapper around std::vector member function.
Definition: WMixinVector.h:227
virtual const std::string getDescription() const
Gets the description for this prototype.
virtual const std::string getName() const
Gets the name of this prototype.
Represents a simple set of WFibers.
void setFilename(const std::string filename)
Set the name of the file that this data set stems from.
Definition: WDataSet.cpp:57
boost::shared_ptr< WDataSetFibers > toWDataSetFibers() const
Convert this dataset into WDataSetFibers format for other purposes if needed.
WDataSetFiberVector()
Default constructor for creating an empty fiber vector.
WDataSetFiberVector & operator=(const WDataSetFiberVector &other)
Operator for assigning instances of WDataSetFiberVector.
boost::shared_ptr< WDataSetFiberVector > generateDataSetOutOfUsedFibers(const std::vector< bool > &unused) const
Generates new WDataSetFiberVector out of the used fibers from this dataset.
virtual bool isTexture() const
Determines whether this dataset can be used as a texture.
static boost::shared_ptr< WPrototyped > getPrototype()
Returns a prototype instantiated with the true type of the deriving class.
This is taken from OpenSceneGraph <osg/MixinVector> but copy and pasted in order to reduce dependency...
Definition: WMixinVector.h:47
void assign(size_type count, const value_type &value)
Wrapper around std::vector member function.
Definition: WMixinVector.h:436
void sortDescLength()
Sort fibers descending on their length and update.
size_type size() const
Wrapper around std::vector member function.
Definition: WMixinVector.h:267