File: BrainModelSurfaceMetricFindClustersBase.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 (249 lines) | stat: -rw-r--r-- 9,233 bytes parent folder | download
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
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
#ifndef __BRAIN_MODEL_SURFACE_SHAPE_FIND_CLUSTERS_BASE_H__
#define __BRAIN_MODEL_SURFACE_SHAPE_FIND_CLUSTERS_BASE_H__

/*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*/

#include <QString>
#include <vector>

#include "BrainModelAlgorithm.h"

class BrainModelSurface;
class BrainModelSurfaceMetricClustering;
class MetricFile;
class QTextStream;

/// base class for finding clusters in surface shape files
class BrainModelSurfaceMetricFindClustersBase : public BrainModelAlgorithm {
   public:
      // constructor
      BrainModelSurfaceMetricFindClustersBase(BrainSet* bs,
                                         const QString& fiducialCoordFileNameIn,
                                         const QString& openTopoFileNameIn,
                                         const QString& distortionShapeFileNameIn,
                                         const QString& statisticalMapFileNameIn,
                                         const QString& shuffledStatisticalMapFileNameIn,
                                         const QString& clustersPaintFileNameIn,
                                         const QString& clustersMetricFileNameIn,
                                         const QString& reportFileNameIn,
                                         const int distortionShapeFileColumnIn,
                                         const float negativeThreshIn,
                                         const float positiveThreshIn,
                                         const float pValueIn,
                                         const int tVarianceSmoothingIterationsIn,
                                         const float tVarianceSmoothingStrengthIn,
                                         const bool doStatisticalMapDOFIn,
                                         const bool doStatisticalMapPValueIn,
                                         const int numberOfThreadsIn);
      
      // destructor
      ~BrainModelSurfaceMetricFindClustersBase();
      
      // execute the algorithm
      void execute() throw (BrainModelAlgorithmException);
      
   protected:
      /// class for cluster thresholding
      class Cluster {
         public:
            QString name;
            int column;
            int numberOfNodes;
            std::vector<int> nodes;
            float area;
            float areaCorrected;
            float cogX;
            float cogY;
            float cogZ;
            float pValue;
            float threshMin;
            float threshMax;
            
            /// constructor
            Cluster() {
               name = "";
               column = -1;
               numberOfNodes = 0;
               area = 0.0;
               areaCorrected = 0.0;
               cogX = 0.0;
               cogY = 0.0;
               cogZ = 0.0;
               pValue = -1.0;
               threshMin = 0.0;
               threshMax = 0.0;
               nodes.clear();
            }
            
            /// comparison operator using area corrected
            bool operator<(const Cluster& c) const {
               return (areaCorrected < c.areaCorrected);
            }
            
            /// set the name of a cluster
            void setName() {
               name = "";
               if (threshMax < 0.0) {
                  name += "minus_";
               }
               else {
                  name += "plus_";
               }
               name += "cluster_area_";
               name += QString::number(areaCorrected, 'f', 1);
               name += "_nodes_";
               name += QString::number(numberOfNodes);
            }
      };
      
      /// must be implemented by subclasses
      virtual void executeClusterSearch() throw (BrainModelAlgorithmException) = 0;
      
      // free memory
      virtual void cleanUp();
      
      // find clusters in shape file
      void findClusters(MetricFile* mf, 
                        std::vector<Cluster>& clustersOut,
                        const QString& progressMessage,
                        const int limitToColumn,
                        const bool useLargestClusterPerColumnFlag) throw (BrainModelAlgorithmException);
      
      // find clusters 
      void findClustersSingleThread(MetricFile* mf, 
                        std::vector<Cluster>& clustersOut,
                        const QString& progressMessage,
                        const int limitToColumn,
                        const bool useLargestClusterPerColumnFlag) throw (BrainModelAlgorithmException);
      
      // find clusters in shape file using multiple threads
      void findClustersMultiThread(MetricFile* mf, 
                                std::vector<Cluster>& clustersOut,
                                const QString& progressMessage,
                                const int limitToColumn,
                                const bool useLargestClusterPerColumnFlag,
                                const int numberOfThreads) throw (BrainModelAlgorithmException);
      
      /// Get the clusters after the cluster finding algorithm has finished
      void saveClusters(BrainModelSurfaceMetricClustering* bmsmc,
                        std::vector<Cluster>& clustersOut,
                        const int columnNumber,
                        const bool useLargestClusterPerColumnFlag);
      
      // set randomized cluster p-values
      void setRandomizedClusterPValues(const MetricFile& randomFile, 
                                std::vector<Cluster>& randomClusters);
                                
      // print the clusters
      void printClusters(QTextStream& stream, const std::vector<Cluster>& clusters,
                         const float sigArea = -1.0);
      
      /// create the clusters paint file
      void createClustersPaintFile(const std::vector<Cluster>& clusters,
                                   const float sigArea,
                                   const int numNodes);
       
      /// create the clusters metric file
      void createClustersMetricFile(const std::vector<Cluster>& clusters,
                                    const int statisticalMapColumn,
                                    const int numNodes);
      
      /// set names of all clusters
      void setNamesForClusters(std::vector<Cluster>& clusters);
      
      /// create the clusters report file
      void createMetricShapeClustersReportFile(const std::vector<Cluster>& clusters,
                                               const QString& metricShapeFileName);
                                    
      /// name of fiducial coord file
      QString fiducialCoordFileName;
   
      /// name of open topo file
      QString openTopoFileName;
   
      /// name of area correction shape file
      QString areaCorrectionShapeFileName;
   
      /// name of Statistical Map file
      QString statisticalMapFileName;
   
      /// name of shuffled Statistical map file
      QString shuffledStatisticalMapFileName;
      
      /// name of clusters paint file
      QString clustersPaintFileName;
      
      /// name of clusters metric file name
      QString clustersMetricFileName;
      
      /// name of report file 
      QString reportFileName;
      
      ///  area correction shape file column
      int areaCorrectionShapeFileColumn;
      
      /// negative threshold
      float negativeThresh;
      
      /// positive threshold
      float positiveThresh;
      
      /// P-Value
      float pValue;
      
      /// brain set used by this algorithm
      BrainSet* brain;
      
      /// surface used by this algorithm
      BrainModelSurface* bms;
      
      // area correction shape file
      MetricFile* areaCorrectionShapeFile;

      /// shuffled statistical map file
      MetricFile* shuffleStatisticalMapShapeFile;
      
      /// statistical map shape fie
      MetricFile* statisticalMapShapeFile;

      /// t-map variance smoothing iterations
      int tVarianceSmoothingIterations;
      
      /// t-map variance smoothing strength
      float tVarianceSmoothingStrength;
      
      /// compute degrees of freedom for statistical map
      bool doStatisticalMapDOF;
      
      /// compute p-value for statistical map
      bool doStatisticalMapPValue;
      
      /// number of threads for cluster search
      int numberOfThreads;
};

#endif // __BRAIN_MODEL_SURFACE_SHAPE_FIND_CLUSTERS_BASE_H__