File: BrainModel.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 (188 lines) | stat: -rw-r--r-- 6,434 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
/*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_BRAIN_MODEL_H__
#define __VE_BRAIN_MODEL_H__


#include <QString>

class BrainSet;
class vtkTransform;

/// Class for the different brain model types.  This class cannot be instantiated.  
/// Must create subclass.
class BrainModel {
   public:
      /// Number of brain model viewers (also update brain model open gl
      enum BRAIN_MODEL_VIEW_NUMBER {     
         BRAIN_MODEL_VIEW_MAIN_WINDOW       = 0,
         BRAIN_MODEL_VIEW_AUX_WINDOW_2      = 1,
         BRAIN_MODEL_VIEW_AUX_WINDOW_3      = 2,
         BRAIN_MODEL_VIEW_AUX_WINDOW_4      = 3,
         BRAIN_MODEL_VIEW_AUX_WINDOW_5      = 4,
         BRAIN_MODEL_VIEW_AUX_WINDOW_6      = 5,
         BRAIN_MODEL_VIEW_AUX_WINDOW_7      = 6,
         BRAIN_MODEL_VIEW_AUX_WINDOW_8      = 7,
         BRAIN_MODEL_VIEW_AUX_WINDOW_9      = 8,
         BRAIN_MODEL_VIEW_AUX_WINDOW_10     = 9,
         NUMBER_OF_BRAIN_MODEL_VIEW_WINDOWS = 10 
      };

      /// The brain model types available
      enum BRAIN_MODEL_TYPE {
         BRAIN_MODEL_CONTOURS,
         BRAIN_MODEL_SURFACE,
         BRAIN_MODEL_VOLUME,
         BRAIN_MODEL_SURFACE_AND_VOLUME
      };
      
      /// Standard views enumerated types
      enum STANDARD_VIEWS {   // if the order of these is changed then
         VIEW_NONE,           // the combo box that uses these must be
         VIEW_RESET,          // updated.
         VIEW_ANTERIOR,
         VIEW_DORSAL,
         VIEW_LATERAL,
         VIEW_MEDIAL,
         VIEW_POSTERIOR,
         VIEW_VENTRAL,
         VIEW_ROTATE_X_90,
         VIEW_ROTATE_Y_90,
         VIEW_ROTATE_Z_90
      };

      /// Destructor
      virtual ~BrainModel();
      
      /// Get a descriptive name of the model
      virtual QString getDescriptiveName() const = 0;
      
      /// Get the model type.
      BRAIN_MODEL_TYPE getModelType() const { return modelType; }
      
      /// Get the index of this model in the brain set
      int getBrainModelIndex() const;
      
      /// get the brain set
      BrainSet* getBrainSet() { return brainSet; }
      
      /// get the brain set const methods
      const BrainSet* getBrainSet() const { return brainSet; }
      
      /// set the brain set
      void setBrainSet(BrainSet* bs) { brainSet = bs; }
      
      /// Copy the sources transformation to me
      void copyTransformations(BrainModel* sourceModel,
                               const int sourceModelNumber,
                               const int targetModelNumber);
                               
      /// get the rotation matrix inverse
      void getRotationMatrixInverse(const int viewNumber, float matrix[16]) const;
      
      /// get the rotation matrix
      void getRotationMatrix(const int viewNumber, float matrix[16]) const;
      
      /// set the rotation matrix
      void setRotationMatrix(const int viewNumber, const float matrix[16]);
      
      /// get the rotation matrix
      vtkTransform* getRotationTransformMatrix(const int viewNumber) { 
         return rotationMatrix[viewNumber]; 
      }
      
      /// get the model's scaling
      void getScaling(const int viewNumber, float scaleOut[3]) const;
            
      /// set the model's scaling
      virtual void setScaling(const int viewNumber, const float scaleIn[3]);
            
      /// set the model's scaling
      virtual void setScaling(const int viewNumber, const float sx, const float sy, const float sz);
            
      /// get the model's translation
      void getTranslation(const int viewNumber, float translationOut[3]) const;
      
      /// set the model's translation
      void setTranslation(const int viewNumber, const float translationIn[3]);
      
      /// get the model's perspective zooming
      float getPerspectiveZooming(const int viewNumber) const;
      
      /// set the model's perspective translation
      void setPerspectiveZooming(const int viewNumber, const float zoomingIn);
      
      /// reset the viewing transformations
      void resetViewingTransformations();
      
      /// get the perspective field of view
      float getPerspectiveFieldOfView() const { return perspectiveFieldOfView; }
      
      /// get transformations as string (3 trans, 16 rot, 1 scale, 1 persp fov)
      QString getTransformationsAsString(const int viewNumber) const;
      
      /// set transformations from string (3 trans, 16 rot, 1 scale, 1 persp fov)
      void setTransformationsAsString(const int viewNumber, const QString s);
      
      /// set to a standard view
      virtual void setToStandardView(const int viewNumber, const STANDARD_VIEWS view);
          
   protected:
      /// Constructor
      BrainModel(BrainSet* bs, const BRAIN_MODEL_TYPE bmt);
      
      /// Copy Constructor
      BrainModel(const BrainModel& bm);
      
      /// brain set this model is associated with
      BrainSet* brainSet;

      /// the model type
      BRAIN_MODEL_TYPE modelType;
      
      /// Rotation of model
      vtkTransform* rotationMatrix[NUMBER_OF_BRAIN_MODEL_VIEW_WINDOWS];
      
      /// Scaling of model
      float scaling[NUMBER_OF_BRAIN_MODEL_VIEW_WINDOWS][3];
      
      /// Translation of model
      float translation[NUMBER_OF_BRAIN_MODEL_VIEW_WINDOWS][3];
      
      /// Perspective (translate in Z)
      float perspectiveZooming[NUMBER_OF_BRAIN_MODEL_VIEW_WINDOWS];
      
      /// perspective field of view
      float perspectiveFieldOfView;
      
   private:
      /// initialize this object
      void initialize(BrainSet* bs, const BRAIN_MODEL_TYPE bmt);
};

#endif