File: BrainModelSurfaceSmoothing.h

package info (click to toggle)
caret 5.6.4~dfsg.1-3
  • links: PTS, VCS
  • area: main
  • in suites: jessie, jessie-kfreebsd, wheezy
  • size: 31,904 kB
  • ctags: 28,901
  • sloc: cpp: 378,050; python: 6,718; ansic: 5,507; makefile: 333; sh: 46
file content (197 lines) | stat: -rw-r--r-- 6,726 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
/*LICENSE_START*/
/*
 *  Copyright 1995-2002 Washington University School of Medicine
 *
 *  http://brainmap.wustl.edu
 *
 *  This file is part of CARET.
 *
 *  CARET is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  CARET is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with CARET; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
/*LICENSE_END*/

#ifndef __BRAIN_MODEL_SURFACE_SMOOTHING_H__
#define __BRAIN_MODEL_SURFACE_SMOOTHING_H__

#include <vector>

#include <QMutex>

#include "BrainModelAlgorithmMultiThreaded.h"

class BrainModelSurface;
class QWaitCondition;
class TopologyHelper;

/// class for smoothing a brain model surface, multiple threads optional
class BrainModelSurfaceSmoothing : public BrainModelAlgorithmMultiThreaded {
   public:
      /// Types of smoothing
      enum SMOOTHING_TYPE {
         SMOOTHING_TYPE_AREAL,
         SMOOTHING_TYPE_LINEAR,
         SMOOTHING_TYPE_LANDMARK_CONSTRAINED,
         SMOOTHING_TYPE_LANDMARK_NEIGHBOR_CONSTRAINED
      };
      
      /// constructor
      BrainModelSurfaceSmoothing(BrainSet* bs,
                                 BrainModelSurface* surfaceIn,
                                 const SMOOTHING_TYPE smoothingTypeIn,
                                 const float strengthIn,
                                 const int   iterationsIn,
                                 const int   edgeIterationsIn,
                                 const int   landmarkNeighborIterationsIn,
                                 const std::vector<bool>* smoothOnlyTheseNodesIn,
                                 const std::vector<bool>* landmarkNodeFlagsIn,
                                 const int projectToSphereEveryXIterationsIn,
                                 const int numberOfThreadsIn);
      
      /// Destructor
      ~BrainModelSurfaceSmoothing();
      
      /// execute the algorithm
      void execute() throw (BrainModelAlgorithmException);
      
   protected:
      /// class stores information about each node
      class NodeInfo {
         public:
            /// constructor
            NodeInfo();
            
            /// node types
            enum NODE_TYPE {
               NODE_TYPE_DO_NOT_SMOOTH,
               NODE_TYPE_NORMAL,
               NODE_TYPE_LANDMARK,
               NODE_TYPE_LANDMARK_NEIGHBOR
            };
            
            /// type of node
            NODE_TYPE nodeType;
            
            /// edge node flag
            int edgeNodeFlag;
            
            /// number of landmark neighbors
            int numLandmarkNeighbors;
            
            /// offset of a landmark node from average of its neighbors
            float offset[3]; 
      };
      
      /// Constructor (protected) used to created threaded executions.
      BrainModelSurfaceSmoothing(BrainSet* bs,
                                       const SMOOTHING_TYPE smoothingTypeIn,
                                       const float strengthIn,
                                       const float landmarkScaleIn,
                                       NodeInfo* nodeInfoIn,
                                       TopologyHelper* topologyHelperIn,
                                       const int startNodeIndexIn,
                                       const int endNodeIndexIn,
                                       BrainModelSurfaceSmoothing* parentOfThisThreadIn,
                                       const int threadNumberIn);
                                       
      /// Initialize member variables.
      void initialize();
      
      /// smooths for an iteration (required by QThread)
      void run();
      
      /// set smooth edges this iteration
      void setSmoothEdgesThisIteration(const bool smooth) { smoothEdgesThisIteration = smooth; }
      
      /// set smooth landmark neighbors this iteration
      void setSmoothLandmarkNeighborsThisIteration(const bool smooth)
                          { smoothLandmarkNeighborsThisIteration = smooth; }
 
      /// set the indices of the nodes that are to be smoothed (inclusive)
      void setIndicesOfNodesToSmooth(const int startNodeIndexIn, const int endNodeIndexIn);
      
      /// set the input and output coords
      void setInputAndOutputCoords(float* inCoords, float* outCoords);
      
      /// surface that is smoothed (DO NOT DELETE)
      BrainModelSurface* surface;
      
      /// smoothing type
      SMOOTHING_TYPE smoothingType;
      
      /// smoothing strength;
      float strength;
      
      /// inverse of strength (1.0 - strength)
      float inverseStrength;
      
      /// smoothing iterations
      int iterations;
      
      /// smoothing edge iterations
      int edgeIterations;
      
      /// smoothing landmark neighbors iterations
      int landmarkNeighborIterations;
      
      /// number of nodes
      int numberOfNodes;
      
      /// topology helper used to get node neighbors
      TopologyHelper* topologyHelper; 
      
      /// array for holding coordinates (inputCoords and outputCoords point to this)
      float* coordsArray1;
      
      /// array for holding coordinates (inputCoords and outputCoords point to this)
      float* coordsArray2;
      
      /// pointers for input coordinates (do not delete)
      float* inputCoords;
      
      /// pointers for output coordinates (do not delete)
      float* outputCoords;

      /// smooth edges this iteration
      bool smoothEdgesThisIteration;
      
      /// index of first node to smooth
      int startNodeIndex;
      
      /// index of last node to smooth
      int endNodeIndex;
      
      /// threads when running multi-threaded.
      std::vector<BrainModelSurfaceSmoothing*> threads;
      
      /// project to sphere every X iterations
      int projectToSphereEveryXIterations;
      
      /// information about each node
      NodeInfo* nodeInfo;
      
      /// scale for landmark nodes
      float landmarkScale;
      
      /// smooth landmark neighbors this iteration
      bool smoothLandmarkNeighborsThisIteration;
};

#ifdef __BRAIN_MODEL_SURFACE_SMOOTHING_MAIN_H__
#endif // __BRAIN_MODEL_SURFACE_SMOOTHING_MAIN_H__


#endif // __BRAIN_MODEL_SURFACE_SMOOTHING_H__