File: DisplaySettingsMetric.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 (294 lines) | stat: -rw-r--r-- 10,987 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
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
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
/*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 __VE_DISPLAY_SETTINGS_METRIC_H__
#define __VE_DISPLAY_SETTINGS_METRIC_H__

#include <vector>

#include "DisplaySettingsNodeAttributeFile.h"

class BrainModelSurface;
class BrainSet;
class VolumeFile;

/// DisplaySettingsMetric is a class that maintains parameters for controlling
/// the display of metric data files.
class DisplaySettingsMetric : public DisplaySettingsNodeAttributeFile {
   public:
      /// Metric graphing
      enum METRIC_DATA_PLOT {
         METRIC_DATA_PLOT_OFF,
         METRIC_DATA_PLOT_NODE,
         METRIC_DATA_PLOT_NODE_AND_NEIGHBORS
      };
      
      /// Metric scaling for color mapping
      enum METRIC_OVERLAY_SCALE {
         /// auto scale metric column min/max
         METRIC_OVERLAY_SCALE_AUTO,
         /// auto scale metric column percentage min/max
         METRIC_OVERLAY_SCALE_AUTO_PERCENTAGE,
         /// auto scale using a specified metric column min/max
         METRIC_OVERLAY_SCALE_AUTO_SPECIFIED_COLUMN,
         /// auto scale using selection functional volume min/max
         METRIC_OVERLAY_SCALE_AUTO_FUNC_VOLUME,
         /// auto scale using user entered min/max
         METRIC_OVERLAY_SCALE_USER
      };
      
      /// Positive/Negative Display
      enum METRIC_DISPLAY_MODE {
         METRIC_DISPLAY_MODE_POSITIVE_AND_NEGATIVE,
         METRIC_DISPLAY_MODE_POSITIVE_ONLY,
         METRIC_DISPLAY_MODE_NEGATIVE_ONLY
      };
      
      /// type of thresholding
      enum METRIC_THRESHOLDING_TYPE {
         METRIC_THRESHOLDING_TYPE_FILE_COLUMN,
         METRIC_THRESHOLDING_TYPE_FILE_COLUMN_AVERAGE,
         METRIC_THRESHOLDING_TYPE_USER_VALUES,
      };
      
      /// Constructor
      DisplaySettingsMetric(BrainSet* bs);
      
      /// Destructor
      ~DisplaySettingsMetric();
      
      /// Reinitialize all display settings
      void reset();
      
      /// Update any selections due to changes in loaded metric file
      void update();
      
      /// get the column number for the overlay scale specified column
      int getOverlayScaleSpecifiedColumnNumber() const 
               { return overlayScaleSpecifiedColumnNumber; }
      
      /// set the column number for the overlay scale specified column
      void setOverlayScaleSpecifiedColumnNumber(const int col)
               { overlayScaleSpecifiedColumnNumber = col; }
               
      /// get the type of metric thresholding
      METRIC_THRESHOLDING_TYPE getMetricThresholdingType() const { return thresholdType; }
      
      /// set the type of metric thresholding
      void setMetricThresholdingType(const METRIC_THRESHOLDING_TYPE mtt) 
         { thresholdType = mtt; }
         
      /// get the user thresholding values
      void getUserThresholdingValues(float& negThresh, float& posThresh) const;
      
      /// set the user thresholding values
      void setUserThresholdingValues(const float negThresh, const float posThresh);
      
      /// get selected overlay scale
      METRIC_OVERLAY_SCALE getSelectedOverlayScale() const { return overlayScale; }
      
      /// set selected overlay scale
      void setSelectedOverlayScale(const METRIC_OVERLAY_SCALE mos) { overlayScale = mos; }
      
      /// get the user scale minimum and maximum
      void getUserScaleMinMax(float& posMinValue, 
                              float& posMaxValue,
                              float& negMinValue,
                              float& negMaxValue) const;
      
      /// set the user scale minimum and maximum
      void setUserScaleMinMax(const float posMinValue,
                              const float posMaxValue,
                              const float negMinValue,
                              const float negMaxValue);
      
      /// get display color bar
      bool getDisplayColorBar() const { return displayColorBar; }

      /// set display color bar
      void setDisplayColorBar(const bool dcb) { displayColorBar = dcb; }

      /// get interpolate colors flag
      bool getInterpolateColors() const { return interpolateColors; }
      
      /// set interpolate colors flag
      void setInterpolateColors(const int ic) { interpolateColors = ic; }
      
      /// get the display mode
      METRIC_DISPLAY_MODE getDisplayMode() const { return displayMode; }
      
      /// set the display mode
      void setDisplayMode(const METRIC_DISPLAY_MODE mdm) { displayMode = mdm; }
      
      /// get the selected palette index
      int getSelectedPaletteIndex() const { return paletteIndex; }

      /// set the selected palette index
      void setSelectedPaletteIndex(const int pi) { paletteIndex = pi; }

      /// get popup plot of metric data when node identified
      METRIC_DATA_PLOT getMDataPlotOnNodeID() const { return metricDataPlot; }
      
      /// set popup plot of metric data when node identified
      void setDataPlotOnNodeID(const METRIC_DATA_PLOT dp) { metricDataPlot = dp; }
      
      /// get manual data plot scaling
      bool getDataPlotManualScaling(float& minPlot, float& maxPlot) const;
      
      /// set manual data plot scaling
      void setDataPlotManualScaling(const bool b, const float minPlot,
                                    const float maxPlot);
                                    
      /// get show special color for thresholded nodes
      bool getShowSpecialColorForThresholdedNodes() const
             { return showSpecialColorForThresholdedNodes; }
             
      /// set show special color for thresholded nodes
      void setShowSpecialColorForThresholdedNodes(const bool b)
             { showSpecialColorForThresholdedNodes = b; }
             
      /// get special color for thresholded nodes
      void getSpecialColorsForThresholdedNodes(unsigned char negThreshColor[3],
                                               unsigned char posThreshColor[3]) const;
                                               
      /// apply a scene (set display settings)
      virtual void showScene(const SceneFile::Scene& scene, QString& errorMessage) ;
      
      /// create a scene (read display settings)
      virtual void saveScene(SceneFile::Scene& scene, const bool onlyIfSelected,
                             QString& errorMessage);
                       
      // get the display and threshold columns for palette (negative if invalid)
      void getMetricsForColoringAndPalette(int& displayColumnOut,
                                           int& thresholdColumnOut,
                                           float& negMaxValue,
                                           float& negMinValue,
                                           float& posMinValue,
                                           float& posMaxValue,
                                           const bool volumeFlag = false) const;

      /// get the auto scale percentage negative minimum
      float getAutoScalePercentageNegativeMinimum() const
         { return autoScalePercentageNegativeMinimum; }

      /// set the auto scale percentage negative minimum
      void setAutoScalePercentageNegativeMinimum(const float nm)
         { autoScalePercentageNegativeMinimum = nm; }

      /// get the auto scale percentage negative maximum
      float getAutoScalePercentageNegativeMaximum() const
         { return autoScalePercentageNegativeMaximum; }

      /// set the auto scale percentage negative maximum
      void setAutoScalePercentageNegativeMaximum(const float nm)
         { autoScalePercentageNegativeMaximum = nm; }

      /// get the auto scale percentage positive minimum
      float getAutoScalePercentagePositiveMinimum() const
         { return autoScalePercentagePositiveMinimum; }

      /// set the auto scale percentage positive minimum
      void setAutoScalePercentagePositiveMinimum(const float pm)
         { autoScalePercentagePositiveMinimum = pm; }

      /// get the auto scale percentage positive maximum
      float getAutoScalePercentagePositiveMaximum() const
         { return autoScalePercentagePositiveMaximum; }

      /// set the auto scale percentage positive maximum
      void setAutoScalePercentagePositiveMaximum(const float pm)
         { autoScalePercentagePositiveMaximum = pm; }

   private:
      /// metric thresholding type
      METRIC_THRESHOLDING_TYPE thresholdType;
      
      /// user negative threshold
      float userNegativeThreshold;
      
      /// user positive threshold
      float userPositiveThreshold;
      
      /// overlay scale
      METRIC_OVERLAY_SCALE overlayScale;
      
      /// user scale positive minimum value
      float userScalePositiveMinimum;
      
      /// user scale positive maximum
      float userScalePositiveMaximum;
      
      /// user scale negative minimum value
      float userScaleNegativeMinimum;
      
      /// user scale negative maximum
      float userScaleNegativeMaximum;
      
      /// interpolate colors
      bool interpolateColors;
      
      /// display metric color bar
      bool displayColorBar;

      /// selected palette index
      int paletteIndex;

      /// positive / negative display mode
      METRIC_DISPLAY_MODE displayMode;
      
      /// type of data plot
      METRIC_DATA_PLOT metricDataPlot;
      
      /// metric data plot manual scale
      bool metricDataPlotManualScaleFlag;
      
      /// metric data plot manual scale minimum
      float metricDataPlotManualScaleMinimum;
      
      /// metric data plot manual scale maximum
      float metricDataPlotManualScaleMaximum;
      
      /// show thresholded nodes in special color
      bool showSpecialColorForThresholdedNodes;
      
      /// column number for the overlay scale specified column
      int overlayScaleSpecifiedColumnNumber;

      /// auto scale percentage negative minimum
      float autoScalePercentageNegativeMinimum;

      /// auto scale percentage negative maximum
      float autoScalePercentageNegativeMaximum;

      /// auto scale percentage positive minimum
      float autoScalePercentagePositiveMinimum;

      /// auto scale percentage positive maximum
      float autoScalePercentagePositiveMaximum;
 };

#endif