FastOpenGlDisplayer/src/Geometry.cpp

// Geometry.cpp: implementation of the Geometry class.
//
//////////////////////////////////////////////////////////////////////

#include "../interface/Geometry.h"

Geometry::Geometry(void)
{
}

Geometry::~Geometry(void)
{
}

void Geometry::Load (char* path)
{
        FILE* pFile = fopen(path,"rb" );

        stChunk* PrimaryChunk = new stChunk;

        PrimaryChunk->read  =fread(&PrimaryChunk->type,1,2,pFile);
        PrimaryChunk->read +=fread(&PrimaryChunk->size,1,4,pFile);

        if(PrimaryChunk->type!=C_PRIMARY){
                printf("PrimaryChunk has not a good Id (%i!=%i)\n",PrimaryChunk->type,C_PRIMARY);
                printf("Exiting...\n");
                exit(0);
        }

        Read(pFile,PrimaryChunk);

        fclose(pFile);
}

void Geometry::Read (FILE* pFile, stChunk* ParentChunk)
{
//      unsigned short temp;
//      fread(&temp,1,2,pFile);
//      fseek(pFile,-2,SEEK_CUR);
//      printf("Parent = %i --> Current ChunkId = %i to read = %i\n",ParentChunk->type,temp,0);

        stChunk* CurrentChunk  = new stChunk;
        ReadChunk(pFile, CurrentChunk);

        switch(CurrentChunk->type)
        {
                case C_GEOMETRY:                // Geometry                     
                        while(CurrentChunk->read<CurrentChunk->size){
                                Read(pFile,CurrentChunk);
                        }
                        break;


        ////////////////////////TRACKER DATA//////////////////////////
                case C_TRACKER:                 // TRACKER
                        while(CurrentChunk->read<CurrentChunk->size){
                                Read(pFile,CurrentChunk);
                        }
                        break;

                case C_TRACKER_PIB:{    // PIB                  
                        TrackerDet* Temp = new TrackerDet;
                        CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
                        Det_Tracker_PIB.push_back(Temp);
                        Det_Tracker_ALL.push_back(Temp);                        
                        }break;
                case C_TRACKER_PIE:{    // PIE                  
                        TrackerDet* Temp = new TrackerDet;
                        CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
                        Det_Tracker_PIE.push_back(Temp);
                        Det_Tracker_ALL.push_back(Temp);                        
                        }break;
                case C_TRACKER_TIB:{    // TIB                  
                        TrackerDet* Temp = new TrackerDet;
                        CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
                        Det_Tracker_TIB.push_back(Temp);
                        Det_Tracker_ALL.push_back(Temp);                        
                        }break;
                case C_TRACKER_TID:{    // TID                  
                        TrackerDet* Temp = new TrackerDet;
                        CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
                        Det_Tracker_TID.push_back(Temp);
                        Det_Tracker_ALL.push_back(Temp);                        
                        }break;
                case C_TRACKER_TOB:{    // TOB                  
                        TrackerDet* Temp = new TrackerDet;
                        CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
                        Det_Tracker_TOB.push_back(Temp);
                        Det_Tracker_ALL.push_back(Temp);                        
                        }break;
                case C_TRACKER_TEC:{    // TEC                  
                        TrackerDet* Temp = new TrackerDet;
                        CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
                        Det_Tracker_TEC.push_back(Temp);
                        Det_Tracker_ALL.push_back(Temp);                        
                        }break;

                ////////////////////////UNKOWN CHUNK ////////////////////////
                default:
                        printf("Unknown ChunkID (%i)\n",CurrentChunk->type);
                        printf("Chunk will be skipped\n");
                        printf("The program can not run properly\n");
                        fseek (pFile,CurrentChunk->size-CurrentChunk->read,SEEK_CUR);
                        CurrentChunk->read += CurrentChunk->size-CurrentChunk->read;
                        break;
        }               

        ParentChunk->read += CurrentChunk->read;

}
 
void Geometry::Save (char* path)
{
        stChunkToSave* Primary_chunk = new stChunkToSave;
        
        Primary_chunk->type  = C_PRIMARY;       
        Primary_chunk->size =  6;

        Write(Primary_chunk);

        printf("%i (%i)\n",Primary_chunk->type,Primary_chunk->size);
        for(unsigned int i=0;i<Primary_chunk->daughters.size();i++){
                stChunkToSave* tmp = Primary_chunk->daughters[i];
                printf("    %i (%i)\n",tmp->type,tmp->size);
                for(unsigned int j=0;j<tmp->daughters.size();j++){
                        stChunkToSave* Tmp = tmp->daughters[j];
                        printf("        %i (%i)\n",Tmp->type,Tmp->size);
                        for(unsigned int k=0;k<Tmp->daughters.size();k++){
                                stChunkToSave* TMp = Tmp->daughters[k];
                                printf("            %i (%i)\n",TMp->type,TMp->size);
                                for(unsigned int l=0;l<TMp->daughters.size();l++){
                                        stChunkToSave* TMP = TMp->daughters[l];
                                        printf("                %i (%i)\n",TMP->type,TMP->size);
                                }                               
                        }                       
                }               
        }

        FILE* pFile = fopen(path,"wb" );
                WriteChunk(pFile, Primary_chunk);
        fclose(pFile);
}

void Geometry::Write(stChunkToSave* ParentChunk)
{
        unsigned int i;
        stChunkToSave* CurrentChunk;
        
        switch(ParentChunk->type)
        {
                case C_PRIMARY:                 // PrimaryChunk         
                        CurrentChunk = new stChunkToSave;
                        CurrentChunk->type = C_GEOMETRY;
                        CurrentChunk->size = 6;
                        ParentChunk->daughters.push_back(CurrentChunk);
                        break;

                case C_GEOMETRY:                // Geometry
                        CurrentChunk = new stChunkToSave;
                        CurrentChunk->type = C_TRACKER;                                 
                        CurrentChunk->size = 6;
                        ParentChunk->daughters.push_back(CurrentChunk);
                        break;

                case C_TRACKER:                 // Tracker
                        for(i=0;i<Det_Tracker_PIB.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_TRACKER_PIB;
                                CurrentChunk->size = 6 + sizeof(TrackerDet);
                                CurrentChunk->data = Det_Tracker_PIB[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        for(i=0;i<Det_Tracker_PIE.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_TRACKER_PIE;
                                CurrentChunk->size = 6 + sizeof(TrackerDet);
                                CurrentChunk->data = Det_Tracker_PIE[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        for(i=0;i<Det_Tracker_TIB.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_TRACKER_TIB;
                                CurrentChunk->size = 6 + sizeof(TrackerDet);
                                CurrentChunk->data = Det_Tracker_TIB[i];
                                ParentChunk->daughters.push_back(CurrentChunk);                         
                        }
                        for(i=0;i<Det_Tracker_TID.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_TRACKER_TID;
                                CurrentChunk->size = 6 + sizeof(TrackerDet);
                                CurrentChunk->data = Det_Tracker_TID[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        for(i=0;i<Det_Tracker_TOB.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_TRACKER_TOB;
                                CurrentChunk->size = 6 + sizeof(TrackerDet);
                                CurrentChunk->data = Det_Tracker_TOB[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        for(i=0;i<Det_Tracker_TEC.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_TRACKER_TEC;
                                CurrentChunk->size = 6 + sizeof(TrackerDet);
                                CurrentChunk->data = Det_Tracker_TEC[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        break;

        
                default:
                        break;
        }       


        for(i=0; i<ParentChunk->daughters.size();i++)
        {
//              if( !(ParentChunk->type == C_PRIMARY && i!=ParentChunk->daughters.size()-1))
                        Write(ParentChunk->daughters[i]);                                               
                ParentChunk->size += ParentChunk->daughters[i]->size;           
        }
}


void Geometry::Add_TrackerDet(unsigned int DetId,
                                                          float PosX,    float PosY,    float PosZ,
                                                          float WidthX,  float WidthY,  float WidthZ,
                                                          float LengthX, float LengthY, float LengthZ,
                                                          float ThickX,  float ThickY,  float ThickZ){

        int SubDet = (DetId>>25)&0x7;

        if(SubDet<0 || SubDet>6)
        {
                printf("Unknown Subdet %i\n",SubDet);
                return;
        }

        TrackerDet* temp = new TrackerDet();
        temp->DetId = DetId;
        temp->PosX    = PosX;
        temp->PosY    = PosY;
        temp->PosZ    = PosZ;
        temp->WidthX  = WidthX;
        temp->WidthY  = WidthY;
        temp->WidthZ  = WidthZ;
        temp->LengthX = LengthX;
        temp->LengthY = LengthY;
        temp->LengthZ = LengthZ;
        temp->ThickX  = ThickX;
        temp->ThickY  = ThickY;
        temp->ThickZ  = ThickZ;
        
        Det_Tracker_ALL.push_back(temp);
        switch(SubDet)
        {
                case 1 : Det_Tracker_PIB.push_back(temp); break;
                case 2 : Det_Tracker_PIE.push_back(temp); break;
                case 3 : Det_Tracker_TIB.push_back(temp); break;
                case 4 : Det_Tracker_TID.push_back(temp); break;
                case 5 : Det_Tracker_TOB.push_back(temp); break;
                case 6 : Det_Tracker_TEC.push_back(temp); break;
        }
}

TrackerDet* Geometry::Find_TrackerDet (unsigned int DetId){
        int SubDet = (DetId>>25)&0x7;

        if(SubDet<0 || SubDet>6){
                printf("Unknown Subdet %i\n",SubDet);
                return NULL;
        }

        std::vector<TrackerDet*>* DetColl = NULL;

        switch(SubDet){
                case 1 : DetColl = &Det_Tracker_PIB; break;
                case 2 : DetColl = &Det_Tracker_PIE; break;
                case 3 : DetColl = &Det_Tracker_TIB; break;
                case 4 : DetColl = &Det_Tracker_TID; break;
                case 5 : DetColl = &Det_Tracker_TOB; break;
                case 6 : DetColl = &Det_Tracker_TEC; break;
        }

        if(DetColl==NULL){
                printf("No COllection has been found\n");
                return NULL;
        }

        for(std::vector<TrackerDet*>::iterator it = DetColl->begin();it!=DetColl->end();it++){
                TrackerDet* Det = *it;
                if(Det->DetId == DetId)return Det;
        }
        return NULL;
}


Revision:	1.3
Committed:	Wed Mar 19 13:57:30 2008 UTC (17 years, 1 month ago) by querten
Branch:	MAIN
Changes since 1.2:	+4 -4 lines
Log Message:	Add the FROG Logo and Increase Speed
#	User	Rev	Content
1	querten	1.1	// Geometry.cpp: implementation of the Geometry class.
2			//
3			//////////////////////////////////////////////////////////////////////
4
5			#include "../interface/Geometry.h"
6
7			Geometry::Geometry(void)
8			{
9			}
10
11			Geometry::~Geometry(void)
12			{
13			}
14
15			void Geometry::Load (char* path)
16			{
17			FILE* pFile = fopen(path,"rb" );
18
19			stChunk* PrimaryChunk = new stChunk;
20
21			PrimaryChunk->read =fread(&PrimaryChunk->type,1,2,pFile);
22			PrimaryChunk->read +=fread(&PrimaryChunk->size,1,4,pFile);
23
24			if(PrimaryChunk->type!=C_PRIMARY){
25			printf("PrimaryChunk has not a good Id (%i!=%i)\n",PrimaryChunk->type,C_PRIMARY);
26			printf("Exiting...\n");
27			exit(0);
28			}
29
30			Read(pFile,PrimaryChunk);
31
32			fclose(pFile);
33			}
34
35			void Geometry::Read (FILE* pFile, stChunk* ParentChunk)
36			{
37	querten	1.3	// unsigned short temp;
38			// fread(&temp,1,2,pFile);
39			// fseek(pFile,-2,SEEK_CUR);
40			// printf("Parent = %i --> Current ChunkId = %i to read = %i\n",ParentChunk->type,temp,0);
41	querten	1.1
42			stChunk* CurrentChunk = new stChunk;
43			ReadChunk(pFile, CurrentChunk);
44
45			switch(CurrentChunk->type)
46			{
47			case C_GEOMETRY: // Geometry
48			while(CurrentChunk->read<CurrentChunk->size){
49			Read(pFile,CurrentChunk);
50			}
51			break;
52
53
54			////////////////////////TRACKER DATA//////////////////////////
55			case C_TRACKER: // TRACKER
56			while(CurrentChunk->read<CurrentChunk->size){
57			Read(pFile,CurrentChunk);
58			}
59			break;
60
61			case C_TRACKER_PIB:{ // PIB
62			TrackerDet* Temp = new TrackerDet;
63			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
64			Det_Tracker_PIB.push_back(Temp);
65			Det_Tracker_ALL.push_back(Temp);
66			}break;
67			case C_TRACKER_PIE:{ // PIE
68			TrackerDet* Temp = new TrackerDet;
69			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
70			Det_Tracker_PIE.push_back(Temp);
71			Det_Tracker_ALL.push_back(Temp);
72			}break;
73			case C_TRACKER_TIB:{ // TIB
74			TrackerDet* Temp = new TrackerDet;
75			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
76			Det_Tracker_TIB.push_back(Temp);
77			Det_Tracker_ALL.push_back(Temp);
78			}break;
79			case C_TRACKER_TID:{ // TID
80			TrackerDet* Temp = new TrackerDet;
81			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
82			Det_Tracker_TID.push_back(Temp);
83			Det_Tracker_ALL.push_back(Temp);
84			}break;
85			case C_TRACKER_TOB:{ // TOB
86			TrackerDet* Temp = new TrackerDet;
87			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
88			Det_Tracker_TOB.push_back(Temp);
89			Det_Tracker_ALL.push_back(Temp);
90			}break;
91			case C_TRACKER_TEC:{ // TEC
92			TrackerDet* Temp = new TrackerDet;
93			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
94			Det_Tracker_TEC.push_back(Temp);
95			Det_Tracker_ALL.push_back(Temp);
96			}break;
97
98			////////////////////////UNKOWN CHUNK ////////////////////////
99			default:
100			printf("Unknown ChunkID (%i)\n",CurrentChunk->type);
101			printf("Chunk will be skipped\n");
102			printf("The program can not run properly\n");
103			fseek (pFile,CurrentChunk->size-CurrentChunk->read,SEEK_CUR);
104			CurrentChunk->read += CurrentChunk->size-CurrentChunk->read;
105			break;
106			}
107
108			ParentChunk->read += CurrentChunk->read;
109
110			}
111
112			void Geometry::Save (char* path)
113			{
114			stChunkToSave* Primary_chunk = new stChunkToSave;
115
116			Primary_chunk->type = C_PRIMARY;
117			Primary_chunk->size = 6;
118
119			Write(Primary_chunk);
120
121			printf("%i (%i)\n",Primary_chunk->type,Primary_chunk->size);
122			for(unsigned int i=0;i<Primary_chunk->daughters.size();i++){
123			stChunkToSave* tmp = Primary_chunk->daughters[i];
124			printf(" %i (%i)\n",tmp->type,tmp->size);
125			for(unsigned int j=0;j<tmp->daughters.size();j++){
126			stChunkToSave* Tmp = tmp->daughters[j];
127			printf(" %i (%i)\n",Tmp->type,Tmp->size);
128			for(unsigned int k=0;k<Tmp->daughters.size();k++){
129			stChunkToSave* TMp = Tmp->daughters[k];
130			printf(" %i (%i)\n",TMp->type,TMp->size);
131			for(unsigned int l=0;l<TMp->daughters.size();l++){
132			stChunkToSave* TMP = TMp->daughters[l];
133			printf(" %i (%i)\n",TMP->type,TMP->size);
134			}
135			}
136			}
137			}
138
139			FILE* pFile = fopen(path,"wb" );
140			WriteChunk(pFile, Primary_chunk);
141			fclose(pFile);
142			}
143
144			void Geometry::Write(stChunkToSave* ParentChunk)
145			{
146			unsigned int i;
147			stChunkToSave* CurrentChunk;
148
149			switch(ParentChunk->type)
150			{
151			case C_PRIMARY: // PrimaryChunk
152			CurrentChunk = new stChunkToSave;
153			CurrentChunk->type = C_GEOMETRY;
154			CurrentChunk->size = 6;
155			ParentChunk->daughters.push_back(CurrentChunk);
156			break;
157
158			case C_GEOMETRY: // Geometry
159			CurrentChunk = new stChunkToSave;
160			CurrentChunk->type = C_TRACKER;
161			CurrentChunk->size = 6;
162			ParentChunk->daughters.push_back(CurrentChunk);
163			break;
164
165			case C_TRACKER: // Tracker
166			for(i=0;i<Det_Tracker_PIB.size();i++){
167			CurrentChunk = new stChunkToSave;
168			CurrentChunk->type = C_TRACKER_PIB;
169			CurrentChunk->size = 6 + sizeof(TrackerDet);
170			CurrentChunk->data = Det_Tracker_PIB[i];
171			ParentChunk->daughters.push_back(CurrentChunk);
172			}
173			for(i=0;i<Det_Tracker_PIE.size();i++){
174			CurrentChunk = new stChunkToSave;
175			CurrentChunk->type = C_TRACKER_PIE;
176			CurrentChunk->size = 6 + sizeof(TrackerDet);
177			CurrentChunk->data = Det_Tracker_PIE[i];
178			ParentChunk->daughters.push_back(CurrentChunk);
179			}
180			for(i=0;i<Det_Tracker_TIB.size();i++){
181			CurrentChunk = new stChunkToSave;
182			CurrentChunk->type = C_TRACKER_TIB;
183			CurrentChunk->size = 6 + sizeof(TrackerDet);
184			CurrentChunk->data = Det_Tracker_TIB[i];
185			ParentChunk->daughters.push_back(CurrentChunk);
186			}
187			for(i=0;i<Det_Tracker_TID.size();i++){
188			CurrentChunk = new stChunkToSave;
189			CurrentChunk->type = C_TRACKER_TID;
190			CurrentChunk->size = 6 + sizeof(TrackerDet);
191			CurrentChunk->data = Det_Tracker_TID[i];
192			ParentChunk->daughters.push_back(CurrentChunk);
193			}
194			for(i=0;i<Det_Tracker_TOB.size();i++){
195			CurrentChunk = new stChunkToSave;
196			CurrentChunk->type = C_TRACKER_TOB;
197			CurrentChunk->size = 6 + sizeof(TrackerDet);
198			CurrentChunk->data = Det_Tracker_TOB[i];
199			ParentChunk->daughters.push_back(CurrentChunk);
200			}
201			for(i=0;i<Det_Tracker_TEC.size();i++){
202			CurrentChunk = new stChunkToSave;
203			CurrentChunk->type = C_TRACKER_TEC;
204			CurrentChunk->size = 6 + sizeof(TrackerDet);
205			CurrentChunk->data = Det_Tracker_TEC[i];
206			ParentChunk->daughters.push_back(CurrentChunk);
207			}
208			break;
209
210
211			default:
212			break;
213			}
214
215
216			for(i=0; i<ParentChunk->daughters.size();i++)
217			{
218			// if( !(ParentChunk->type == C_PRIMARY && i!=ParentChunk->daughters.size()-1))
219			Write(ParentChunk->daughters[i]);
220			ParentChunk->size += ParentChunk->daughters[i]->size;
221			}
222			}
223
224
225
226	querten	1.2	void Geometry::Add_TrackerDet(unsigned int DetId,
227			float PosX, float PosY, float PosZ,
228			float WidthX, float WidthY, float WidthZ,
229			float LengthX, float LengthY, float LengthZ,
230			float ThickX, float ThickY, float ThickZ){
231
232			int SubDet = (DetId>>25)&0x7;
233
234	querten	1.1	if(SubDet<0 \|\| SubDet>6)
235			{
236			printf("Unknown Subdet %i\n",SubDet);
237			return;
238			}
239
240			TrackerDet* temp = new TrackerDet();
241			temp->DetId = DetId;
242	querten	1.2	temp->PosX = PosX;
243			temp->PosY = PosY;
244			temp->PosZ = PosZ;
245			temp->WidthX = WidthX;
246			temp->WidthY = WidthY;
247			temp->WidthZ = WidthZ;
248			temp->LengthX = LengthX;
249			temp->LengthY = LengthY;
250			temp->LengthZ = LengthZ;
251			temp->ThickX = ThickX;
252			temp->ThickY = ThickY;
253			temp->ThickZ = ThickZ;
254
255	querten	1.1	Det_Tracker_ALL.push_back(temp);
256			switch(SubDet)
257			{
258			case 1 : Det_Tracker_PIB.push_back(temp); break;
259			case 2 : Det_Tracker_PIE.push_back(temp); break;
260			case 3 : Det_Tracker_TIB.push_back(temp); break;
261			case 4 : Det_Tracker_TID.push_back(temp); break;
262			case 5 : Det_Tracker_TOB.push_back(temp); break;
263			case 6 : Det_Tracker_TEC.push_back(temp); break;
264			}
265			}
266
267			TrackerDet* Geometry::Find_TrackerDet (unsigned int DetId){
268			int SubDet = (DetId>>25)&0x7;
269
270			if(SubDet<0 \|\| SubDet>6){
271			printf("Unknown Subdet %i\n",SubDet);
272			return NULL;
273			}
274
275			std::vector<TrackerDet> DetColl = NULL;
276
277			switch(SubDet){
278			case 1 : DetColl = &Det_Tracker_PIB; break;
279			case 2 : DetColl = &Det_Tracker_PIE; break;
280			case 3 : DetColl = &Det_Tracker_TIB; break;
281			case 4 : DetColl = &Det_Tracker_TID; break;
282			case 5 : DetColl = &Det_Tracker_TOB; break;
283			case 6 : DetColl = &Det_Tracker_TEC; break;
284			}
285
286			if(DetColl==NULL){
287			printf("No COllection has been found\n");
288			return NULL;
289			}
290
291			for(std::vector<TrackerDet*>::iterator it = DetColl->begin();it!=DetColl->end();it++){
292			TrackerDet* Det = *it;
293			if(Det->DetId == DetId)return Det;
294			}
295			return NULL;
296	querten	1.2	}
297
298