File: BrainModelSurfaceSulcalIdentificationProbabilistic.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 (218 lines) | stat: -rw-r--r-- 8,313 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
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218

#ifndef __BRAIN_MODEL_SURFACE_SULCAL_IDENTIFICATION_PROBABILISTIC_H__
#define __BRAIN_MODEL_SURFACE_SULCAL_IDENTIFICATION_PROBABILISTIC_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 <vector>

#include "BrainModelAlgorithm.h"

class AreaColorFile;
class BrainModelSurface;
class MetricFile;
class PaintFile;
class SurfaceShapeFile;
class VocabularyFile;

/// class for identifying sulci
class BrainModelSurfaceSulcalIdentificationProbabilistic : public BrainModelAlgorithm {
   public:
      // constructor
      BrainModelSurfaceSulcalIdentificationProbabilistic(BrainSet* bs,
                                            const BrainModelSurface* fiducialSurfaceIn,
                                            const BrainModelSurface* inflatedSurfaceIn,
                                            const BrainModelSurface* veryInflatedSurfaceIn,
                                            const PaintFile* inputPaintFileIn,
                                            const int paintFileGeographyColumnNumberIn,
                                            const SurfaceShapeFile* surfaceShapeFileIn,
                                            const int surfaceShapeFileDepthColumnNumberIn,
                                            const QString& probabilisticDepthVolumeCSVFileNameIn,
                                            const float postCentralSulcusOffsetIn = 25.0,
                                            const float postCentralSulcusStdDevSquareIn = 100.0,
                                            const float postCentralSulcusSplitIn = 5.0);
      
      // destructor
      ~BrainModelSurfaceSulcalIdentificationProbabilistic();
      
      // execute the algorithm
      void execute() throw (BrainModelAlgorithmException);
      
      // get the output paint file (will be delete'd by this algorithm, so copy if needed)
      const PaintFile* getOutputPaintFile() const { return outputPaintFile; }
      
      // get the output area color file
      const AreaColorFile* getOutputAreaColorFile() const { return outputAreaColorFile; }
      
      // get the output metric file containing probabilistic mappings
      const MetricFile* getOutputMetricFile() const { return probabilisticMetricFile; }
       
      // get the output vocabulary file
      const VocabularyFile* getOutputVocabularyFile() const { return outputVocabularyFile; }
      
      /// get the name of the Sulcus ID paint column
      static QString getSulcusIdPaintColumnName() { return "Sulcal Identification"; }
      
   protected:
      /// class for sulcal names and matching volume file
      class SulcalNameAndVolume {
         public:
            /// constructor
            SulcalNameAndVolume(const QString& sulcusNameIn,
                                const float& depthThresholdIn,
                                const QString& volumeNameIn,
                                const int maximumClustersIn) {
               sulcusName = sulcusNameIn;
               depthThreshold = depthThresholdIn;
               volumeName = volumeNameIn;
               maximumClusters = maximumClustersIn;
            }
            
            /// get name of sulcus
            QString getSulcusName() const { return sulcusName; }
            
            /// get the depth threshold
            float getDepthThreshold() const { return depthThreshold; }
            
            /// get name of volume
            QString getVolumeName() const { return volumeName; }
         
            /// get the maximum number of clusters
            int getMaximumClusters() const { return maximumClusters; }
            
         protected:
            /// name of sulcus
            QString sulcusName;
            
            /// depth threshold 
            float depthThreshold;
            
            /// name of volume
            QString volumeName;
            
            /// maximum clusters
            int maximumClusters;
      };
      
      /// add an area color
      void addAreaColor(const QString& colorName);
      
      // load the colors
      void loadColors();
      
      // load vocabulary
      void loadVocabulary();
      
      // add casename to name
      QString addCaseNameToName(const QString& name) const;
      
      // add vocabulary
      void addVocabulary(const QString& name);
      
      // map the probabilistic functional volumes to the metric file
      void mapProbabilisticFunctionalVolumes() throw (BrainModelAlgorithmException);
      
      // create the initial sulcal identification
      void createInitialSulcalIdentification(const int paintColumn) throw (BrainModelAlgorithmException);
      
      // dilate the sulcal identification
      void dilateSulcalIdentification(const int paintColumn) throw (BrainModelAlgorithmException);
      
      // read the probabilistic volume file list
      void readProbabilisticVolumeFileList() throw (BrainModelAlgorithmException);
      
      // multiply probabilistic volumes by depth
      void multiplyProbabilisticFunctionalDataByDepth() throw (BrainModelAlgorithmException);
      
      // rotate the very inflated surface
      void rotateVeryInflatedSurface() throw (BrainModelAlgorithmException);
      
      // special process for the hippocampal fissure
      void specialProcessingForHippocampalFissure(MetricFile* metricFile,
                                                  const int metricFileColumnNumber);
      
      /// sulcal names and volumes
      std::vector<SulcalNameAndVolume> sulcalNamesAndVolumes;
      
      /// the fiducial surface
      const BrainModelSurface* fiducialSurface;
      
      /// the inflated surface
      const BrainModelSurface* inflatedSurface;
      
      /// the very inflated surface
      const BrainModelSurface* veryInflatedSurface;
      
      /// the rotated very inflated surface
      BrainModelSurface* rotatedVeryInflatedSurface;
      
      /// the input paint file
      const PaintFile* inputPaintFile;
      
      /// the output paint file
      PaintFile* outputPaintFile;
      
      /// the metric file for mapping functional probabilistic volumes
      MetricFile* probabilisticMetricFile;
      
      /// the paint file geography column number
      int paintFileGeographyColumnNumber;

      /// the output area color file
      AreaColorFile* outputAreaColorFile;
      
      /// the default area colors
      AreaColorFile* defaultAreaColorFile;
      
      /// the surface shape file
      const SurfaceShapeFile* surfaceShapeFile;
      
      /// the surface shape file depth column number
      int surfaceShapeFileDepthColumnNumber;
      
      /// output vocabulary file
      VocabularyFile* outputVocabularyFile;
      
      /// default vocabulary file
      VocabularyFile* defaultVocabularyFile;
      
      /// name of file listing sulcal names, depth thresholds, and volume file names
      const QString probabilisticDepthVolumeCSVFileName;

      /// post central sulcus offset from central sulcus
      const float postCentralSulcusOffset;
      
      /// post central sulcus offset from central sulcus std dev squared
      const float postCentralSulcusStdDevSquare;
      
      /// post central sulcus split between two largest post central sulci
      const float postCentralSulcusSplit;
      
      /// flag to add some default colors
      bool addingFirstColorFlag;
};

#endif // __BRAIN_MODEL_SURFACE_SULCAL_IDENTIFICATION_PROBABILISTIC_H__