File: DisplaySettingsCells.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 (242 lines) | stat: -rw-r--r-- 8,877 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
/*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_CELLS_H__
#define __VE_DISPLAY_SETTINGS_CELLS_H__

#include "CellBase.h"
#include "CellColorFile.h"
#include "DisplaySettings.h"

class BrainSet;
class CellProjection;

/// Display settings for cells and cell projections
class DisplaySettingsCells : public DisplaySettings {
   public:
      
      /// Display Mode
      enum CELL_DISPLAY_MODE {
         CELL_DISPLAY_MODE_SHOW_ALL,
         CELL_DISPLAY_MODE_SHOW_DEEP_ONLY,
         CELL_DISPLAY_MODE_SHOW_SUPERFICIAL_ONLY
      };
      
      /// Constructor
      DisplaySettingsCells(BrainSet* bs);
      
      /// Destructor
      virtual ~DisplaySettingsCells();
      
      /// Reinitialize all display settings
      virtual void reset();
      
      /// Update any selections due to changes in loaded cells
      virtual void update();
      
      /// get display cells
      bool getDisplayCells() const { return displayCells; }
      
      /// set display cells
      void setDisplayCells(const bool dfc) { displayCells = dfc; }
      
      /// get display volume cells
      bool getDisplayVolumeCells() const { return displayVolumeCells; }
      
      /// set display volume cells
      void setDisplayVolumeCells(const bool dfc) { displayVolumeCells = dfc; }
      
      /// get display cell raised on flat surface
      bool getDisplayFlatCellsRaised() const { return displayFlatCellsRaised; }
      
      /// set dislay cells raised on flat surface
      void setDisplayFlatCellsRaised(const bool fsr) { displayFlatCellsRaised = fsr; }
     
      /// get display cells pasted onto 3D surfaces
      bool getDisplayPasteCellsOnto3D() const { return displayPasteCellsOnto3D; }
      
      /// set display cells pasted onto 3D surface
      void setDisplayPasteCellsOnto3D(const bool d3d) { displayPasteCellsOnto3D = d3d; }
      
      /// get the symbol override
      ColorFile::ColorStorage::SYMBOL getSymbolOverride() const { return symbolOverride; }
      
      /// set the symbol override
      void setSymbolOverride(const ColorFile::ColorStorage::SYMBOL so) { symbolOverride = so; }
      
      /// get cell draw size
      float getDrawSize() const { return cellSize; }
      
      /// set cell draw size
      void setDrawSize(const float ds) { cellSize = ds; }
      
      /// set display cells only on the correct hemisphere
      void setDisplayCellsOnCorrectHemisphereOnly(const bool b)
              { displayCellsOnCorrectHemisphereOnly = b; }
      
      /// ge display cells only on the correct hemisphere
      bool getDisplayCellsOnCorrectHemisphereOnly() const 
              { return displayCellsOnCorrectHemisphereOnly; }
      
      /// get the distance to surface limit
      float getDistanceToSurfaceLimit() const { return distanceToSurfaceLimit; }
      
      /// set the distance to surface limit
      void setDistanceToSurfaceLimit(const float dist) { distanceToSurfaceLimit = dist; }
      
      /// get the border opacity
      float getOpacity() const { return opacity; }
      
      /// set the border opacity
      void setOpacity(const float o) { opacity = o; }
      
      /// get the display mode
      CELL_DISPLAY_MODE getDisplayMode() const { return cellDisplayMode; }
      
      /// set the display mode
      void setDisplayMode(const CELL_DISPLAY_MODE cdm) { cellDisplayMode = cdm; }
      
      /// determine which cells should be displayed (set's cell display flags)
      void determineDisplayedCells(const bool fociFlag = false);
      
      /// determine which volume cells should be displayed (set's cell display flags)
      void determineDisplayedVolumeCells();
      
      /// 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 coloring mode
      CellBase::CELL_COLOR_MODE getColorMode() const { return cellColorMode; }
      
      /// set the coloring mode
      void setColorMode(const CellBase::CELL_COLOR_MODE ccm) { cellColorMode = ccm; }
      
      /// get display cells without class assignments
      bool getDisplayCellsWithoutClassAssignments() const 
           { return displayCellsWithoutClassAssignments; }
      
      /// set display cells without class assignments
      void setDisplayCellsWithoutClassAssignments(const bool b)
           { displayCellsWithoutClassAssignments = b; }
      
      /// get display cells without matching color
      bool getDisplayCellsWithoutMatchingColor() const
           { return displayCellsWithoutMatchingColor; }
      
      /// set display cells without matching color
      void setDisplayCellsWithoutMatchingColor(const bool b)
           { displayCellsWithoutMatchingColor = b; }
      
      /// get display cells without a link to a study with keywords
      bool getDisplayCellsWithoutLinkToStudyWithKeywords() const 
           { return displayCellsWithoutLinkToStudyWithKeywords; }
      
      /// set display cells without a link to a study with keywords
      void setDisplayCellsWithoutLinkToStudyWithKeywords(const bool b)
           { displayCellsWithoutLinkToStudyWithKeywords = b; }
      
      /// get display only keywords for displayed cells
      //bool getDisplayKeywordsForOnlyDisplayedCells() const 
      //      { return displayKeywordsForOnlyDisplayedCells; }
            
      /// set display only keywords for displayed cells
      //void setDisplayKeywordsForOnlyDisplayedCells(const bool b) 
      //      { displayKeywordsForOnlyDisplayedCells = b; }
            
      /// get display cells without a link to a table subheader
      bool getDisplayCellsWithoutLinkToStudyWithTableSubHeader() const 
           { return displayCellsWithoutLinkToStudyWithTableSubHeader; }
      
      /// set display cells without a link to a table subheader
      void setDisplayCellsWithoutLinkToStudyWithTableSubHeader(const bool b)
           { displayCellsWithoutLinkToStudyWithTableSubHeader = b; }

      /// get only show cells that are in the search
      bool getDislayCellsOnlyIfInSearch() const { return displayCellsOnlyIfInSearch; }
      
      /// set only show cells that are in the search
      bool setDisplayCellsOnlyIfInSearch(const bool b) { return displayCellsOnlyIfInSearch = b; }
      
   protected:
      /// display cells
      bool displayCells;
      
      /// display volume cells
      bool displayVolumeCells;
      
      /// show cells raised on flat surface
      bool displayFlatCellsRaised;
      
      /// paste cells onto 3D surfaces
      bool displayPasteCellsOnto3D;
      
      /// symbol override
      ColorFile::ColorStorage::SYMBOL symbolOverride;
      
      /// draw size
      float cellSize;
      
      /// display cells only on the correct hemisphere
      bool displayCellsOnCorrectHemisphereOnly;
      
      /// limit display to cells within distance to surface
      float distanceToSurfaceLimit;
      
      /// cell display mode
      CELL_DISPLAY_MODE cellDisplayMode;

      /// cell coloring mode
      CellBase::CELL_COLOR_MODE cellColorMode;
      
      /// opacity
      float opacity;
      
      /// display cells without class assignments
      bool displayCellsWithoutClassAssignments;
      
      /// display cells without matching color
      bool displayCellsWithoutMatchingColor;
      
      /// display cells without a link to a study with keywords
      bool displayCellsWithoutLinkToStudyWithKeywords;
      
      /// display keywords for only cells that are displayed
      //bool displayKeywordsForOnlyDisplayedCells;
      
      /// display cells without a link to a table subheader
      bool displayCellsWithoutLinkToStudyWithTableSubHeader;

      // show only cells that are in the search
      bool displayCellsOnlyIfInSearch;
};

#endif