@@ -0,0 +1,17 | |||
|
1 | ''' | |
|
2 | Created on Feb 7, 2012 | |
|
3 | ||
|
4 | @author: roj-idl71 | |
|
5 | ''' | |
|
6 | ||
|
7 | class Correlation(Data): | |
|
8 | ''' | |
|
9 | classdocs | |
|
10 | ''' | |
|
11 | ||
|
12 | ||
|
13 | def __init__(self): | |
|
14 | ''' | |
|
15 | Constructor | |
|
16 | ''' | |
|
17 | pass No newline at end of file |
@@ -0,0 +1,18 | |||
|
1 | ''' | |
|
2 | Created on Feb 7, 2012 | |
|
3 | ||
|
4 | @author: roj-idl71 | |
|
5 | ''' | |
|
6 | ||
|
7 | class Data: | |
|
8 | ''' | |
|
9 | classdocs | |
|
10 | ''' | |
|
11 | ||
|
12 | ||
|
13 | def __init__(self): | |
|
14 | ''' | |
|
15 | Constructor | |
|
16 | ''' | |
|
17 | pass | |
|
18 | No newline at end of file |
@@ -0,0 +1,18 | |||
|
1 | ''' | |
|
2 | Created on Feb 7, 2012 | |
|
3 | ||
|
4 | @author: roj-idl71 | |
|
5 | ''' | |
|
6 | ||
|
7 | class Noise: | |
|
8 | ''' | |
|
9 | classdocs | |
|
10 | ''' | |
|
11 | ||
|
12 | ||
|
13 | def __init__(self): | |
|
14 | ''' | |
|
15 | Constructor | |
|
16 | ''' | |
|
17 | pass | |
|
18 | No newline at end of file |
@@ -0,0 +1,18 | |||
|
1 | ''' | |
|
2 | Created on Feb 7, 2012 | |
|
3 | ||
|
4 | @author: roj-idl71 | |
|
5 | ''' | |
|
6 | ||
|
7 | class Spectra(Data): | |
|
8 | ''' | |
|
9 | classdocs | |
|
10 | ''' | |
|
11 | ||
|
12 | ||
|
13 | def __init__(self): | |
|
14 | ''' | |
|
15 | Constructor | |
|
16 | ''' | |
|
17 | pass | |
|
18 | No newline at end of file |
@@ -0,0 +1,18 | |||
|
1 | ''' | |
|
2 | Created on Feb 7, 2012 | |
|
3 | ||
|
4 | @author: roj-idl71 | |
|
5 | ''' | |
|
6 | ||
|
7 | class Voltage(Data): | |
|
8 | ''' | |
|
9 | classdocs | |
|
10 | ''' | |
|
11 | ||
|
12 | ||
|
13 | def __init__(self): | |
|
14 | ''' | |
|
15 | Constructor | |
|
16 | ''' | |
|
17 | pass | |
|
18 | No newline at end of file |
|
1 | NO CONTENT: new file 100644 |
@@ -0,0 +1,17 | |||
|
1 | ''' | |
|
2 | Created on Feb 7, 2012 | |
|
3 | ||
|
4 | @author: roj-idl71 | |
|
5 | ''' | |
|
6 | ||
|
7 | class CorrelationProcessor(): | |
|
8 | ''' | |
|
9 | classdocs | |
|
10 | ''' | |
|
11 | ||
|
12 | ||
|
13 | def __init__(self): | |
|
14 | ''' | |
|
15 | Constructor | |
|
16 | ''' | |
|
17 | pass No newline at end of file |
@@ -0,0 +1,17 | |||
|
1 | ''' | |
|
2 | Created on Feb 7, 2012 | |
|
3 | ||
|
4 | @author: roj-idl71 | |
|
5 | ''' | |
|
6 | ||
|
7 | class SpectraProcessor(): | |
|
8 | ''' | |
|
9 | classdocs | |
|
10 | ''' | |
|
11 | ||
|
12 | ||
|
13 | def __init__(self): | |
|
14 | ''' | |
|
15 | Constructor | |
|
16 | ''' | |
|
17 | pass No newline at end of file |
@@ -0,0 +1,17 | |||
|
1 | ''' | |
|
2 | Created on Feb 7, 2012 | |
|
3 | ||
|
4 | @author: roj-idl71 | |
|
5 | ''' | |
|
6 | ||
|
7 | class VoltageProcessor(): | |
|
8 | ''' | |
|
9 | classdocs | |
|
10 | ''' | |
|
11 | ||
|
12 | ||
|
13 | def __init__(self): | |
|
14 | ''' | |
|
15 | Constructor | |
|
16 | ''' | |
|
17 | pass No newline at end of file |
|
1 | NO CONTENT: new file 100644 |
@@ -0,0 +1,18 | |||
|
1 | ''' | |
|
2 | Created on Feb 7, 2012 | |
|
3 | ||
|
4 | @author: roj-idl71 | |
|
5 | ''' | |
|
6 | ||
|
7 | class FtpServer(): | |
|
8 | ''' | |
|
9 | classdocs | |
|
10 | ''' | |
|
11 | ||
|
12 | ||
|
13 | def __init__(self): | |
|
14 | ''' | |
|
15 | Constructor | |
|
16 | ''' | |
|
17 | pass | |
|
18 | No newline at end of file |
@@ -0,0 +1,17 | |||
|
1 | ''' | |
|
2 | Created on Feb 7, 2012 | |
|
3 | ||
|
4 | @author: roj-idl71 | |
|
5 | ''' | |
|
6 | ||
|
7 | class FtpServerList(): | |
|
8 | ''' | |
|
9 | classdocs | |
|
10 | ''' | |
|
11 | ||
|
12 | ||
|
13 | def __init__(self): | |
|
14 | ''' | |
|
15 | Constructor | |
|
16 | ''' | |
|
17 | pass No newline at end of file |
|
1 | NO CONTENT: new file 100644 |
|
1 | NO CONTENT: modified file |
|
1 | NO CONTENT: modified file |
@@ -75,6 +75,14 class BasicHeader: | |||
|
75 | 75 | |
|
76 | 76 | return 1 |
|
77 | 77 | |
|
78 | def copy(self): | |
|
79 | ||
|
80 | obj = BasicHeader() | |
|
81 | obj.size = self.size | |
|
82 | ||
|
83 | ||
|
84 | return obj | |
|
85 | ||
|
78 | 86 | class SystemHeader: |
|
79 | 87 | size = 0 |
|
80 | 88 | numSamples = 0 |
|
1 | NO CONTENT: modified file |
@@ -4,8 +4,9 Created on 23/01/2012 | |||
|
4 | 4 | @author: danielangelsuarezmunoz |
|
5 | 5 | ''' |
|
6 | 6 | |
|
7 | ||
|
8 | import os, sys | |
|
7 | 9 | import numpy |
|
8 | import os.path | |
|
9 | 10 | import glob |
|
10 | 11 | import fnmatch |
|
11 | 12 | import time |
@@ -15,6 +16,11 from Header import * | |||
|
15 | 16 | from Data import DataReader |
|
16 | 17 | from Data import DataWriter |
|
17 | 18 | |
|
19 | path = os.path.split(os.getcwd())[0] | |
|
20 | sys.path.append(os.path.join(path,"Model")) | |
|
21 | ||
|
22 | from Voltage import Voltage | |
|
23 | ||
|
18 | 24 | class VoltageReader(DataReader): |
|
19 | 25 | |
|
20 | 26 | __idFile = 0 |
@@ -53,40 +59,41 class VoltageReader(DataReader): | |||
|
53 | 59 | |
|
54 | 60 | basicHeaderSize = 24 |
|
55 | 61 | |
|
56 |
|
|
|
62 | m_BasicHeader = BasicHeader() | |
|
63 | ||
|
64 | m_SystemHeader = SystemHeader() | |
|
57 | 65 | |
|
58 | systemHeaderObj = SystemHeader() | |
|
66 | m_RadarControllerHeader = RadarControllerHeader() | |
|
59 | 67 | |
|
60 | radarControllerHeaderObj = RadarControllerHeader() | |
|
68 | m_ProcessingHeader = ProcessingHeader() | |
|
61 | 69 | |
|
62 | processingHeaderObj = ProcessingHeader() | |
|
70 | m_Voltage = None | |
|
63 | 71 | |
|
64 | 72 | __buffer = 0 |
|
65 | 73 | |
|
66 | 74 | __buffer_id = 9999 |
|
67 | #m_Voltage= Voltage() | |
|
68 | 75 | |
|
76 | def __init__(self, m_Voltage): | |
|
69 | 77 | |
|
70 | def __init__(self): | |
|
71 | pass | |
|
78 | self.m_Voltage = m_Voltage | |
|
72 | 79 | |
|
73 | 80 | def __rdSystemHeader(self,fp=None): |
|
74 | 81 | if fp == None: |
|
75 | 82 | fp = self.__fp |
|
76 | 83 | |
|
77 |
self. |
|
|
84 | self.m_SystemHeader.read(fp) | |
|
78 | 85 | |
|
79 | 86 | def __rdRadarControllerHeader(self,fp=None): |
|
80 | 87 | if fp == None: |
|
81 | 88 | fp = self.__fp |
|
82 | 89 | |
|
83 |
self. |
|
|
90 | self.m_RadarControllerHeader.read(fp) | |
|
84 | 91 | |
|
85 | 92 | def __rdProcessingHeader(self,fp=None): |
|
86 | 93 | if fp == None: |
|
87 | 94 | fp = self.__fp |
|
88 | 95 | |
|
89 |
self. |
|
|
96 | self.m_ProcessingHeader.read(fp) | |
|
90 | 97 | |
|
91 | 98 | def __searchFiles(self,path, startDateTime, endDateTime, set=None, expLabel = "", ext = "*.r"): |
|
92 | 99 | |
@@ -166,14 +173,14 class VoltageReader(DataReader): | |||
|
166 | 173 | if endUTSeconds==None: |
|
167 | 174 | endUTSeconds = self.endUTCSeconds |
|
168 | 175 | |
|
169 |
|
|
|
176 | m_BasicHeader = BasicHeader() | |
|
170 | 177 | |
|
171 |
if not( |
|
|
178 | if not(m_BasicHeader.read(fp)): | |
|
172 | 179 | return 0 |
|
173 | 180 | |
|
174 | 181 | fp.close() |
|
175 | 182 | |
|
176 |
if not ((startUTSeconds <= |
|
|
183 | if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)): | |
|
177 | 184 | return 0 |
|
178 | 185 | |
|
179 | 186 | return 1 |
@@ -183,7 +190,7 class VoltageReader(DataReader): | |||
|
183 | 190 | if fp == None: |
|
184 | 191 | fp = self.__fp |
|
185 | 192 | |
|
186 |
self. |
|
|
193 | self.m_BasicHeader.read(fp) | |
|
187 | 194 | |
|
188 | 195 | def __readFirstHeader(self): |
|
189 | 196 | |
@@ -191,9 +198,9 class VoltageReader(DataReader): | |||
|
191 | 198 | self.__rdSystemHeader() |
|
192 | 199 | self.__rdRadarControllerHeader() |
|
193 | 200 | self.__rdProcessingHeader() |
|
194 |
self.firstHeaderSize = self. |
|
|
201 | self.firstHeaderSize = self.m_BasicHeader.size | |
|
195 | 202 | |
|
196 |
data_type=int(numpy.log2((self. |
|
|
203 | data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR)) | |
|
197 | 204 | if data_type == 0: |
|
198 | 205 | tmp=numpy.dtype([('real','<i1'),('imag','<i1')]) |
|
199 | 206 | elif data_type == 1: |
@@ -211,7 +218,7 class VoltageReader(DataReader): | |||
|
211 | 218 | tmp = 0 |
|
212 | 219 | |
|
213 | 220 | self.__dataType = tmp |
|
214 |
self.__sizeOfFileByHeader = self. |
|
|
221 | self.__sizeOfFileByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1) | |
|
215 | 222 | |
|
216 | 223 | def __setNextFileOnline(self): |
|
217 | 224 | return 0 |
@@ -232,7 +239,7 class VoltageReader(DataReader): | |||
|
232 | 239 | fp = open(filename,'rb') |
|
233 | 240 | |
|
234 | 241 | currentSize = fileSize - fp.tell() |
|
235 |
neededSize = self. |
|
|
242 | neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize | |
|
236 | 243 | |
|
237 | 244 | if (currentSize < neededSize): |
|
238 | 245 | continue |
@@ -262,7 +269,7 class VoltageReader(DataReader): | |||
|
262 | 269 | return 1 |
|
263 | 270 | |
|
264 | 271 | currentSize = self.fileSize - self.__fp.tell() |
|
265 |
neededSize = self. |
|
|
272 | neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize | |
|
266 | 273 | |
|
267 | 274 | # Bloque Completo |
|
268 | 275 | if (currentSize >= neededSize): |
@@ -274,7 +281,7 class VoltageReader(DataReader): | |||
|
274 | 281 | |
|
275 | 282 | self.__readFirstHeader() |
|
276 | 283 | |
|
277 |
deltaTime = self. |
|
|
284 | deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this | |
|
278 | 285 | |
|
279 | 286 | self.flagResetProcessing = 0 |
|
280 | 287 | if deltaTime > self.__maxTimeStep: |
@@ -289,11 +296,11 class VoltageReader(DataReader): | |||
|
289 | 296 | seteado a 0 |
|
290 | 297 | """ |
|
291 | 298 | |
|
292 |
pts2read = self. |
|
|
299 | pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels | |
|
293 | 300 | |
|
294 | 301 | data = numpy.fromfile(self.__fp,self.__dataType,pts2read) |
|
295 | 302 | |
|
296 |
data = data.reshape((self. |
|
|
303 | data = data.reshape((self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels)) | |
|
297 | 304 | |
|
298 | 305 | self.__flagIsNewFile = 0 |
|
299 | 306 | |
@@ -308,12 +315,12 class VoltageReader(DataReader): | |||
|
308 | 315 | |
|
309 | 316 | self.__readBlock() |
|
310 | 317 | |
|
311 |
self.__lastUTTime = self. |
|
|
318 | self.__lastUTTime = self.m_BasicHeader.utc | |
|
312 | 319 | |
|
313 | 320 | return 1 |
|
314 | 321 | |
|
315 | 322 | def __hasNotDataInBuffer(self): |
|
316 |
if self.__buffer_id >= self. |
|
|
323 | if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock: | |
|
317 | 324 | return 1 |
|
318 | 325 | |
|
319 | 326 | return 0 |
@@ -334,8 +341,14 class VoltageReader(DataReader): | |||
|
334 | 341 | return None |
|
335 | 342 | |
|
336 | 343 | data = self.__buffer[self.__buffer_id,:,:] |
|
337 | #time = timeblock + n*ipp | |
|
338 | #print self.__buffer_id | |
|
344 | time = 111 | |
|
345 | ||
|
346 | self.m_Voltage.data = data | |
|
347 | self.m_Voltage.timeProfile = time | |
|
348 | self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy() | |
|
349 | self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy() | |
|
350 | self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy() | |
|
351 | self.m_Voltage.m_SystemHeader = self.m_systemHeader.copy() | |
|
339 | 352 | |
|
340 | 353 | self.__buffer_id += 1 |
|
341 | 354 | |
@@ -380,6 +393,22 class VoltageReader(DataReader): | |||
|
380 | 393 | |
|
381 | 394 | class VoltageWriter(DataWriter): |
|
382 | 395 | |
|
383 | def __init__(self): | |
|
384 | pass | |
|
396 | m_BasicHeader= BasicHeader() | |
|
397 | ||
|
398 | ||
|
399 | m_SystemHeader = SystemHeader() | |
|
400 | ||
|
401 | ||
|
402 | m_RadarControllerHeader = RadarControllerHeader() | |
|
403 | ||
|
404 | ||
|
405 | m_ProcessingHeader = ProcessingHeader() | |
|
406 | ||
|
407 | m_Voltage = None | |
|
408 | ||
|
409 | def __init__(self, m_Voltage): | |
|
410 | ||
|
411 | self.m_Voltage = m_Voltage | |
|
412 | ||
|
413 | ||
|
385 | 414 | No newline at end of file |
General Comments 0
You need to be logged in to leave comments.
Login now