| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 #ifndef DicomBeamControlPoint__HH 26 #ifndef DicomBeamControlPoint__HH
27 #define DicomBeamControlPoint__HH 27 #define DicomBeamControlPoint__HH
28 28
29 #include "dcmtk/dcmrt/seq/drtcps.h" // for Co <<
30 <<
31 #include <iostream> <<
32 #include <vector> 29 #include <vector>
>> 30 #include <iostream>
>> 31 #include "dcmtk/dcmrt/seq/drtcps.h" // for ControlPointSequence
33 class DicomBeamDevicePos; 32 class DicomBeamDevicePos;
34 33
35 #include "G4ThreeVector.hh" 34 #include "G4ThreeVector.hh"
36 35
37 class DicomBeamControlPoint << 36 class DicomBeamControlPoint
38 { << 37 {
39 public: << 38 public:
40 DicomBeamControlPoint(DRTControlPointSeque << 39 DicomBeamControlPoint(DRTControlPointSequence::Item cpItem, DicomBeamControlPoint* point0 );
41 ~DicomBeamControlPoint() {}; << 40 ~DicomBeamControlPoint(){};
42 << 41
43 public: << 42 public:
44 void SetIndex(Sint32 dat) { theIndex = dat << 43 void SetIndex( Sint32 dat ) {
45 Sint32 GetIndex() const { return theIndex; << 44 theIndex = dat;
46 void SetNominalBeamEnergy(Float64 dat) { t << 45 }
47 Float64 GetNominalBeamEnergy() const { ret << 46 Sint32 GetIndex() const {
48 void SetGantryAngle(Float64 dat) { theGant << 47 return theIndex;
49 void SetGantryRotationDirection(OFString d << 48 }
50 void SetBeamLimitingDeviceAngle(Float64 da << 49 void SetNominalBeamEnergy(Float64 dat){
51 void SetBeamLimitingDeviceRotationDirectio << 50 theNominalBeamEnergy = dat;
52 { << 51 }
53 theBeamLimitingDeviceRotationDirection = << 52 Float64 GetNominalBeamEnergy() const {
54 } << 53 return theNominalBeamEnergy;
55 void SetPatientSupportAngle(Float64 dat) { << 54 }
56 void SetPatientSupportRotationDirection(OF << 55 void SetGantryAngle(Float64 dat){
57 { << 56 theGantryAngle = dat;
58 thePatientSupportRotationDirection = dat << 57 }
59 } << 58 void SetGantryRotationDirection(OFString dat){
60 void SetTableTopEccentricAngle(Float64 dat << 59 theGantryRotationDirection = dat;
61 void SetTableTopEccentricRotationDirection << 60 }
62 { << 61 void SetBeamLimitingDeviceAngle(Float64 dat){
63 theTableTopEccentricRotationDirection = << 62 theBeamLimitingDeviceAngle = dat;
64 } << 63 }
65 void SetIsocenterPosition(G4ThreeVector da << 64 void SetBeamLimitingDeviceRotationDirection(OFString dat){
66 void SetSourceToSurfaceDistance(Float64 da << 65 theBeamLimitingDeviceRotationDirection = dat;
67 void SetCumulativeMetersetWeight(Float64 d << 66 }
68 void SetMetersetWeight(Float64 dat) { theM << 67 void SetPatientSupportAngle(Float64 dat){
69 void SetGantryPitchAngle(Float32 dat) { th << 68 thePatientSupportAngle = dat;
70 void SetSurfaceEntryPoint(Float64 dat) { t << 69 }
71 void SetTableTopEccentricAxisDistance(Floa << 70 void SetPatientSupportRotationDirection(OFString dat){
72 void SetTableTopLateralPosition(Float64 da << 71 thePatientSupportRotationDirection = dat;
73 void SetTableTopLongitudinalPosition(Float << 72 }
74 void SetTableTopPitchAngle(Float32 dat) { << 73 void SetTableTopEccentricAngle(Float64 dat){
75 void SetTableTopPitchRotationDirection(OFS << 74 theTableTopEccentricAngle = dat;
76 { << 75 }
77 theTableTopPitchRotationDirection = dat; << 76 void SetTableTopEccentricRotationDirection(OFString dat){
78 } << 77 theTableTopEccentricRotationDirection = dat;
79 void SetTableTopRollAngle(Float32 dat) { t << 78 }
80 void SetTableTopRollRotationDirection(OFSt << 79 void SetIsocenterPosition(G4ThreeVector dat){
81 void SetTableTopVerticalPosition(Float64 d << 80 theIsocenterPosition = dat;
82 OFString GetGantryRotationDirection() cons << 81 }
83 Float64 GetBeamLimitingDeviceAngle() const << 82 void SetSourceToSurfaceDistance(Float64 dat){
84 OFString GetBeamLimitingDeviceRotationDire << 83 theSourceToSurfaceDistance = dat;
85 { << 84 }
86 return theBeamLimitingDeviceRotationDire << 85 void SetCumulativeMetersetWeight(Float64 dat){
87 } << 86 theCumulativeMetersetWeight = dat;
88 Float64 GetPatientSupportAngle() const { r << 87 }
89 OFString GetPatientSupportRotationDirectio << 88 void SetMetersetWeight(Float64 dat){
90 { << 89 theMetersetWeight = dat;
91 return thePatientSupportRotationDirectio << 90 }
92 } << 91 void SetGantryPitchAngle(Float32 dat){
93 Float64 GetTableTopEccentricAngle() const << 92 theGantryPitchAngle = dat;
94 OFString GetTableTopEccentricRotationDirec << 93 }
95 { << 94 void SetSurfaceEntryPoint(Float64 dat){
96 return theTableTopEccentricRotationDirec << 95 theSurfaceEntryPoint = dat;
97 } << 96 }
98 G4ThreeVector GetIsocenterPosition() const << 97 void SetTableTopEccentricAxisDistance(Float64 dat){
99 Float64 GetSourceToSurfaceDistance() const << 98 theTableTopEccentricAxisDistance = dat;
100 Float64 GetCumulativeMetersetWeight() cons << 99 }
101 Float64 GetMetersetWeight() const { return << 100 void SetTableTopLateralPosition(Float64 dat){
102 Float32 GetGantryPitchAngle() const { retu << 101 theTableTopLateralPosition = dat;
103 Float64 GetSurfaceEntryPoint() const { ret << 102 }
104 Float64 GetTableTopEccentricAxisDistance() << 103 void SetTableTopLongitudinalPosition(Float64 dat){
105 Float64 GetTableTopLateralPosition() const << 104 theTableTopLongitudinalPosition = dat;
106 Float64 GetTableTopLongitudinalPosition() << 105 }
107 Float32 GetTableTopPitchAngle() const { re << 106 void SetTableTopPitchAngle(Float32 dat){
108 OFString GetTableTopPitchRotationDirection << 107 theTableTopPitchAngle = dat;
109 Float32 GetTableTopRollAngle() const { ret << 108 }
110 OFString GetTableTopRollRotationDirection( << 109 void SetTableTopPitchRotationDirection(OFString dat){
111 Float64 GetTableTopVerticalPosition() cons << 110 theTableTopPitchRotationDirection = dat;
112 << 111 }
113 void AddDevice(DicomBeamDevicePos* dbd) { << 112 void SetTableTopRollAngle(Float32 dat){
114 << 113 theTableTopRollAngle = dat;
115 void DumpToFile(std::ofstream& out); << 114 }
116 << 115 void SetTableTopRollRotationDirection(OFString dat){
117 void Print(std::ostream& out); << 116 theTableTopRollRotationDirection = dat;
118 << 117 }
119 private: << 118 void SetTableTopVerticalPosition(Float64 dat){
120 Sint32 theIndex; << 119 theTableTopVerticalPosition = dat;
121 Float64 theNominalBeamEnergy; << 120 }
122 Float64 theGantryAngle; << 121 OFString GetGantryRotationDirection() const {
123 OFString theGantryRotationDirection; << 122 return theGantryRotationDirection;
124 Float64 theBeamLimitingDeviceAngle; << 123 }
125 OFString theBeamLimitingDeviceRotationDire << 124 Float64 GetBeamLimitingDeviceAngle() const {
126 Float64 thePatientSupportAngle; << 125 return theBeamLimitingDeviceAngle;
127 OFString thePatientSupportRotationDirectio << 126 }
128 Float64 theTableTopEccentricAngle; << 127 OFString GetBeamLimitingDeviceRotationDirection() const {
129 OFString theTableTopEccentricRotationDirec << 128 return theBeamLimitingDeviceRotationDirection;
130 G4ThreeVector theIsocenterPosition; << 129 }
131 Float64 theSourceToSurfaceDistance; << 130 Float64 GetPatientSupportAngle() const {
132 Float64 theCumulativeMetersetWeight; << 131 return thePatientSupportAngle;
133 Float64 theMetersetWeight; << 132 }
134 Float32 theGantryPitchAngle; << 133 OFString GetPatientSupportRotationDirection() const {
135 Float64 theSurfaceEntryPoint; << 134 return thePatientSupportRotationDirection;
136 Float64 theTableTopEccentricAxisDistance; << 135 }
137 Float64 theTableTopLateralPosition; << 136 Float64 GetTableTopEccentricAngle() const {
138 Float64 theTableTopLongitudinalPosition; << 137 return theTableTopEccentricAngle;
139 Float32 theTableTopPitchAngle; << 138 }
140 OFString theTableTopPitchRotationDirection << 139 OFString GetTableTopEccentricRotationDirection() const {
141 Float32 theTableTopRollAngle; << 140 return theTableTopEccentricRotationDirection;
142 OFString theTableTopRollRotationDirection; << 141 }
143 Float64 theTableTopVerticalPosition; << 142 G4ThreeVector GetIsocenterPosition() const {
>> 143 return theIsocenterPosition;
>> 144 }
>> 145 Float64 GetSourceToSurfaceDistance() const {
>> 146 return theSourceToSurfaceDistance;
>> 147 }
>> 148 Float64 GetCumulativeMetersetWeight() const {
>> 149 return theCumulativeMetersetWeight;
>> 150 }
>> 151 Float64 GetMetersetWeight() const {
>> 152 return theMetersetWeight;
>> 153 }
>> 154 Float32 GetGantryPitchAngle() const {
>> 155 return theGantryPitchAngle;
>> 156 }
>> 157 Float64 GetSurfaceEntryPoint() const {
>> 158 return theSurfaceEntryPoint;
>> 159 }
>> 160 Float64 GetTableTopEccentricAxisDistance() const {
>> 161 return theTableTopEccentricAxisDistance;
>> 162 }
>> 163 Float64 GetTableTopLateralPosition() const {
>> 164 return theTableTopLateralPosition;
>> 165 }
>> 166 Float64 GetTableTopLongitudinalPosition() const {
>> 167 return theTableTopLongitudinalPosition;
>> 168 }
>> 169 Float32 GetTableTopPitchAngle() const {
>> 170 return theTableTopPitchAngle;
>> 171 }
>> 172 OFString GetTableTopPitchRotationDirection() const {
>> 173 return theTableTopPitchRotationDirection;
>> 174 }
>> 175 Float32 GetTableTopRollAngle() const {
>> 176 return theTableTopRollAngle;
>> 177 }
>> 178 OFString GetTableTopRollRotationDirection() const {
>> 179 return theTableTopRollRotationDirection;
>> 180 }
>> 181 Float64 GetTableTopVerticalPosition() const {
>> 182 return theTableTopVerticalPosition;
>> 183 }
>> 184
>> 185 void AddDevice(DicomBeamDevicePos* dbd){
>> 186 theDevices.push_back(dbd);
>> 187 }
>> 188
>> 189 void DumpToFile( std::ofstream& out );
>> 190
>> 191 void Print( std::ostream& out );
>> 192
>> 193 private:
>> 194 Sint32 theIndex;
>> 195 Float64 theNominalBeamEnergy;
>> 196 Float64 theGantryAngle;
>> 197 OFString theGantryRotationDirection;
>> 198 Float64 theBeamLimitingDeviceAngle;
>> 199 OFString theBeamLimitingDeviceRotationDirection;
>> 200 Float64 thePatientSupportAngle;
>> 201 OFString thePatientSupportRotationDirection;
>> 202 Float64 theTableTopEccentricAngle;
>> 203 OFString theTableTopEccentricRotationDirection;
>> 204 G4ThreeVector theIsocenterPosition;
>> 205 Float64 theSourceToSurfaceDistance;
>> 206 Float64 theCumulativeMetersetWeight;
>> 207 Float64 theMetersetWeight;
>> 208 Float32 theGantryPitchAngle;
>> 209 Float64 theSurfaceEntryPoint;
>> 210 Float64 theTableTopEccentricAxisDistance;
>> 211 Float64 theTableTopLateralPosition;
>> 212 Float64 theTableTopLongitudinalPosition;
>> 213 Float32 theTableTopPitchAngle;
>> 214 OFString theTableTopPitchRotationDirection;
>> 215 Float32 theTableTopRollAngle;
>> 216 OFString theTableTopRollRotationDirection;
>> 217 Float64 theTableTopVerticalPosition;
>> 218
>> 219 std::vector<DicomBeamDevicePos *> theDevices;
144 220
145 std::vector<DicomBeamDevicePos*> theDevice <<
146 }; 221 };
147 222
148 #endif << 223 #endif
149 224