File: BrainModelSurfaceDeformationMultiStageSphericalVector.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 (151 lines) | stat: -rw-r--r-- 6,510 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
/*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 _BRAIN_MODEL_SURFACE_DEFORMATION_MULTI_STAGE_SPHERICAL_VECTOR_H
#define	_BRAIN_MODEL_SURFACE_DEFORMATION_MULTI_STAGE_SPHERICAL_VECTOR_H

#include "BrainModelSurfaceDeformation.h"
#include "SurfaceShapeFile.h"

class BrainModelSurface;
class DeformationMapFile;

class BrainModelSurfaceDeformationMultiStageSphericalVector :
                                                 public BrainModelSurfaceDeformation {
   public:
      /// Constructor
      BrainModelSurfaceDeformationMultiStageSphericalVector(BrainSet* brainSetIn,
                                       DeformationMapFile* DeformationMapFileIn);

      /// Destructor
      ~BrainModelSurfaceDeformationMultiStageSphericalVector();

   protected:
      /// Execute the deformation
      void executeDeformation() throw (BrainModelAlgorithmException);

      // Perform landmark constrained morphing on the sphere with source landmarks
      void landmarkMorphContrainedSource(BrainModelSurface* referenceDeformationSphere,
                                         const int stageNumber,
                                         const int cycleIndex) throw (BrainModelAlgorithmException);

      /// Perform landmark neighbor constrained smoothing on the sphere with source landmarks
      void landmarkNeighborConstrainedSmoothSource(const int stageIndex,
                                                   const int cycleNumber);

      /// Get a regularly tessellated sphere and set its radius.
      BrainModelSurface* getRegularSphere(BrainSet* bs, 
                                          const int stageIndex,
                                          const float radius) throw (BrainModelAlgorithmException);

      /// tessellate the target border into the target deformation sphere
      void tessellateTargetBordersIntoDeformationSphere(const int stageIndex) throw (BrainModelAlgorithmException);

      /// tessellate the source border into the source deformation sphere
      void tessellateSourceBordersIntoDeformationSphere(const int stageIndex) throw (BrainModelAlgorithmException);

      /// create the deformed coordinate file at the end of each cycle
      BrainModelSurface* createDeformedCoordinateFile(BrainModelSurface* sourceDeformationSphere,
                                        BrainModelSurface* registeredDeformationSourceSphere,
                                        const int stageIndex,
                                        const int cycleNumber,
                                        const QString& usersSourceCoordFileName);

      /// write a border file containing the deformed landmarks
      BorderFile* writeSourceBorderLandmarkFile(BrainModelSurface* surface,
                                         const int stageIndex,
                                         const int cycleNumber);

      /// write coords without the landmarks
      void writeCoordinatesWithoutLandmarks(BrainModelSurface* surface,
                                            const int stageIndex,
                                            const int cycleNumber);

      /// create the surface shape file containing the XYZ differences
      SurfaceShapeFile* createDifferenceShapeFile(int iterations);

      /// determine the fiducial sphere distortion
      void determineFiducialSphereDistortion();

      /// update the fiducial sphere distortion
      void updateSphereFiducialDistortion(const int stageIndex,
                                    const int cycle,
                                    BrainModelSurface* morphedSourceDeformationSphere);

      /// Determine distortion ratio of fiducial vs spherical tile areas.
      void determineSphericalDistortion(const BrainModelSurface* fiducialSurface,
                                        const BrainModelSurface* sphericalSurface,
                                        std::vector<float>& tileDistortion);

      /// move the landmark nodes to the average of their neighboring nodes
      void moveLandmarksToAverageOfNeighbors(BrainModelSurface* bms);

      /// the target deformation sphere
      BrainModelSurface* targetDeformationSphere;

      /// the source deformation sphere
      BrainModelSurface* sourceDeformationSphere;

      /// the reference source deformation sphere
      BrainModelSurface* referenceSourceDeformationSphere;

      /// the source surface operated on in this type of deformation
      BrainModelSurface* workingSourceSurface;

      /// the number of nodes in the regularly tessellated sphere prior to inserting landmarks
      int originalNumberOfNodes;

      /// keeps track of borders that are tessellated into the deformation sphere
      std::vector<std::pair<int,int> > usedBorderLinks;

      /// target file naming prefix for debugging
      QString debugTargetFileNamePrefix;

      /// source file naming prefix for debugging
      QString debugSourceFileNamePrefix;

      /// radius of the deformation sphere
      float deformationSphereRadius;

      /// keeps track of landmark nodes
      std::vector<bool> landmarkNodeFlags;

      /// the target brain set
      BrainSet* targetDeformationBrainSet;

      /// Keep track of distortion
      SurfaceShapeFile fiducialSphereDistortion;

      /// ratio of target fiducial and spherical tile areas
      std::vector<float> targetTileDistortion;

      /// ratio of source fiducial and spherical tile areas
      std::vector<float> sourceTileDistortion;

      /// shape file containing border variances for the landmark nodes
      SurfaceShapeFile borderVarianceValuesShapeFile;
};

#endif // _BRAIN_MODEL_SURFACE_DEFORMATION_MULTI_STAGE_SPHERICAL_VECTOR_H