##// END OF EJS Templates
schain
RSS
Feature added to GUI. Power or I/Q plot can be choose from Voltage View
Miguel Valdez -
r740:543b4b6ada50
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,6060 +1,6078
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 Module implementing MainWindow.
4 4 #+++++++++++++GUI V1++++++++++++++#
5 5 @author: AlexanderValdezPortocarrero
6 6
7 7 #+++++++++++++GUI V2++++++++++++++#
8 8 @author Miguel Urco
9 9 """
10 10 import os, sys
11 11 import datetime
12 12 import numpy
13 13 import ast
14 14
15 15 from Queue import Queue
16 16
17 17 from collections import OrderedDict
18 18 from os.path import expanduser
19 19 from time import sleep
20 20
21 21 from PyQt4.QtGui import QMainWindow
22 22 from PyQt4.QtCore import pyqtSignature
23 23 from PyQt4.QtCore import pyqtSignal
24 24 from PyQt4 import QtCore
25 25 from PyQt4 import QtGui
26 26
27 27 from propertiesViewModel import TreeModel, PropertyBuffer
28 28 from parametersModel import ProjectParms
29 29
30 30 from schainpy.gui.viewer.ui_unitprocess import Ui_UnitProcess
31 31 from schainpy.gui.viewer.ui_ftp import Ui_Ftp
32 32 from schainpy.gui.viewer.ui_mainwindow import Ui_BasicWindow
33 33
34 34 from schainpy.controller_api import ControllerThread
35 35 from schainpy.controller import Project
36 36
37 37 from schainpy.model.graphics.jroplotter import PlotManager
38 38 from schainpy.gui.figures import tools
39 39
40 40 FIGURES_PATH = tools.get_path()
41 41 TEMPORAL_FILE = ".temp.xml"
42 42
43 43 def isRadarFile(file):
44 44 try:
45 45 year = int(file[1:5])
46 46 doy = int(file[5:8])
47 47 set = int(file[8:11])
48 48 except:
49 49 return 0
50 50
51 51 return 1
52 52
53 53 def isRadarPath(path):
54 54 try:
55 55 year = int(path[1:5])
56 56 doy = int(path[5:8])
57 57 except:
58 58 return 0
59 59
60 60 return 1
61 61
62 62 def isInt(cadena):
63 63
64 64 try:
65 65 int(cadena)
66 66 except:
67 67 return 0
68 68
69 69 return 1
70 70
71 71 def isFloat(cadena):
72 72
73 73 try:
74 74 float(cadena)
75 75 except:
76 76 return 0
77 77
78 78 return 1
79 79
80 80 def isList(cadena):
81 81
82 82 value = str.strip(cadena)
83 83
84 84 if not value:
85 85 return 0
86 86
87 87 try:
88 88 x = ast.literal_eval(value)
89 89 except:
90 90 return 0
91 91
92 92 if type(x) in (int, float, tuple, list):
93 93 return 1
94 94
95 95 return 0
96 96
97 97 def isIntList(cadena):
98 98
99 99 value = str.strip(cadena)
100 100
101 101 if not value:
102 102 return 0
103 103
104 104 try:
105 105 x = ast.literal_eval(value)
106 106 except:
107 107 return 0
108 108
109 109 if type(x) not in (int, tuple, list):
110 110 return 0
111 111
112 112 return 1
113 113
114 114 def isFloatRange(cadena):
115 115
116 116 value = str.strip(cadena)
117 117
118 118 if not value:
119 119 return 0
120 120
121 121 c = str.split(value, ",")
122 122
123 123 if len(c) != 2:
124 124 return 0
125 125
126 126 if not isFloat(c[0]):
127 127 return 0
128 128
129 129 if not isFloat(c[1]):
130 130 return 0
131 131
132 132 return 1
133 133
134 134 def isIntRange(cadena):
135 135
136 136 value = str.strip(cadena)
137 137
138 138 if not value:
139 139 return 0
140 140
141 141 c = str.split(value, ",")
142 142
143 143 if len(c) != 2:
144 144 return 0
145 145
146 146 if not isInt(c[0]):
147 147 return 0
148 148
149 149 if not isInt(c[1]):
150 150 return 0
151 151
152 152 def isPair(value):
153 153
154 154 if type(value) not in (tuple, list):
155 155 return 0
156 156
157 157 if len(value) != 2:
158 158 return 0
159 159
160 160 for i in value:
161 161 if type(i) not in (int,):
162 162 return 0
163 163
164 164 return 1
165 165
166 166 def isPairList(cadena):
167 167
168 168 value = str.strip(cadena)
169 169
170 170 if not value:
171 171 return 0
172 172
173 173 try:
174 174 x = ast.literal_eval(value)
175 175 except:
176 176 return 0
177 177
178 178 if type(x) not in (tuple, list):
179 179 return 0
180 180
181 181 if type(x[0]) not in (tuple, list):
182 182 #x = (0,1)
183 183 if not isPair(x):
184 184 return 0
185 185
186 186 return 1
187 187
188 188 for thisPair in x:
189 189 if not isPair(thisPair):
190 190 return 0
191 191
192 192 return 1
193 193
194 194 def isMultiList(cadena):
195 195
196 196 value = str.strip(cadena)
197 197
198 198 if not value:
199 199 return 0
200 200
201 201 try:
202 202 x = ast.literal_eval(value)
203 203 except:
204 204 return 0
205 205
206 206 if type(x) not in (tuple, list):
207 207 return 0
208 208
209 209 if type(x[0]) not in (int, tuple, list):
210 210 return 0
211 211
212 212 for thisList in x:
213 213 if type(thisList) not in (tuple, list):
214 214 return 0
215 215
216 216 return 1
217 217
218 218 def getCode(cadena):
219 219
220 220 if not isMultiList(cadena):
221 221 return None
222 222
223 223 try:
224 224 x = ast.literal_eval(value)
225 225 except:
226 226 return 0
227 227
228 228 if type(x[0]) not in (tuple, list):
229 229 return [x]
230 230
231 231 return x
232 232
233 233
234 234 class BasicWindow(QMainWindow, Ui_BasicWindow):
235 235 """
236 236 """
237 237 def __init__(self, parent=None):
238 238 """
239 239
240 240 """
241 241 QMainWindow.__init__(self, parent)
242 242 self.setupUi(self)
243 243 self.__puObjDict = {}
244 244 self.__itemTreeDict = {}
245 245 self.readUnitConfObjList = []
246 246 self.operObjList = []
247 247 self.projecObjView = None
248 248 self.idProject = 0
249 249 # self.idImag = 0
250 250
251 251 self.idImagscope = 0
252 252 self.idImagspectra = 0
253 253 self.idImagcross = 0
254 254 self.idImagrti = 0
255 255 self.idImagcoherence = 0
256 256 self.idImagpower = 0
257 257 self.idImagrtinoise = 0
258 258 self.idImagspectraHeis = 0
259 259 self.idImagrtiHeis = 0
260 260
261 261 self.dateList = []
262 262 self.dataPath = None
263 263 self.create = False
264 264 self.selectedItemTree = None
265 265 self.controllerThread = None
266 266 # self.commCtrlPThread = None
267 267 # self.create_figure()
268 268 self.temporalFTP = ftpBuffer()
269 269 self.projectProperCaracteristica = []
270 270 self.projectProperPrincipal = []
271 271 self.projectProperDescripcion = []
272 272 self.volProperCaracteristica = []
273 273 self.volProperPrincipal = []
274 274 self.volProperDescripcion = []
275 275 self.specProperCaracteristica = []
276 276 self.specProperPrincipal = []
277 277 self.specProperDescripcion = []
278 278
279 279 self.specHeisProperCaracteristica = []
280 280 self.specHeisProperPrincipal = []
281 281 self.specHeisProperDescripcion = []
282 282
283 283 # self.pathWorkSpace = './'
284 284
285 285 self.__projectObjDict = {}
286 286 self.__operationObjDict = {}
287 287
288 288 self.__puLocalFolder2FTP = {}
289 289 self.threadStarted = False
290 290
291 291 self.plotManager = None
292 292
293 293 # self.create_comm()
294 294 self.create_updating_timer()
295 295 self.setGUIStatus()
296 296
297 297 @pyqtSignature("")
298 298 def on_actionOpen_triggered(self):
299 299 """
300 300 Slot documentation goes here.
301 301 """
302 302 self.openProject()
303 303
304 304 @pyqtSignature("")
305 305 def on_actionCreate_triggered(self):
306 306 """
307 307 Slot documentation goes here.
308 308 """
309 309 self.setInputsProject_View()
310 310 self.create = True
311 311
312 312 @pyqtSignature("")
313 313 def on_actionSave_triggered(self):
314 314 """
315 315 Slot documentation goes here.
316 316 """
317 317 self.saveProject()
318 318
319 319 @pyqtSignature("")
320 320 def on_actionClose_triggered(self):
321 321 """
322 322 Slot documentation goes here.
323 323 """
324 324 self.close()
325 325
326 326 @pyqtSignature("")
327 327 def on_actionStart_triggered(self):
328 328 """
329 329 """
330 330 self.playProject()
331 331
332 332 @pyqtSignature("")
333 333 def on_actionPause_triggered(self):
334 334 """
335 335 """
336 336 self.pauseProject()
337 337
338 338 @pyqtSignature("")
339 339 def on_actionStop_triggered(self):
340 340 """
341 341 """
342 342 self.stopProject()
343 343
344 344 @pyqtSignature("")
345 345 def on_actionAbout_triggered(self):
346 346 """
347 347 """
348 348 self.aboutEvent()
349 349
350 350 @pyqtSignature("")
351 351 def on_actionFTP_triggered(self):
352 352 """
353 353 """
354 354 self.configFTPWindowObj = Ftp(self)
355 355
356 356 if not self.temporalFTP.create:
357 357 self.temporalFTP.setwithoutconfiguration()
358 358
359 359 self.configFTPWindowObj.setParmsfromTemporal(self.temporalFTP.server,
360 360 self.temporalFTP.remotefolder,
361 361 self.temporalFTP.username,
362 362 self.temporalFTP.password,
363 363 self.temporalFTP.ftp_wei,
364 364 self.temporalFTP.exp_code,
365 365 self.temporalFTP.sub_exp_code,
366 366 self.temporalFTP.plot_pos)
367 367
368 368 self.configFTPWindowObj.show()
369 369 self.configFTPWindowObj.closed.connect(self.createFTPConfig)
370 370
371 371 def createFTPConfig(self):
372 372
373 373 if not self.configFTPWindowObj.create:
374 374 self.console.clear()
375 375 self.console.append("There is no FTP configuration")
376 376 return
377 377
378 378 self.console.append("Push Ok in Spectra view to Add FTP Configuration")
379 379
380 380 server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.configFTPWindowObj.getParmsFromFtpWindow()
381 381 self.temporalFTP.save(server=server,
382 382 remotefolder=remotefolder,
383 383 username=username,
384 384 password=password,
385 385 ftp_wei=ftp_wei,
386 386 exp_code=exp_code,
387 387 sub_exp_code=sub_exp_code,
388 388 plot_pos=plot_pos)
389 389
390 390 @pyqtSignature("")
391 391 def on_actionOpenToolbar_triggered(self):
392 392 """
393 393 Slot documentation goes here.
394 394 """
395 395 self.openProject()
396 396
397 397 @pyqtSignature("")
398 398 def on_actionCreateToolbar_triggered(self):
399 399 """
400 400 Slot documentation goes here.
401 401 """
402 402 self.setInputsProject_View()
403 403 self.create = True
404 404
405 405 @pyqtSignature("")
406 406 def on_actionAddPU_triggered(self):
407 407
408 408 if len(self.__projectObjDict) == 0:
409 409 outputstr = "First create a Project before add any Processing Unit"
410 410 self.console.clear()
411 411 self.console.append(outputstr)
412 412 return
413 413 else:
414 414 self.addPUWindow()
415 415 self.console.clear()
416 416 self.console.append("Please, Choose the type of Processing Unit")
417 417 # self.console.append("If your Datatype is rawdata, you will start with processing unit Type Voltage")
418 418 # self.console.append("If your Datatype is pdata, you will choose between processing unit Type Spectra or Correlation")
419 419 # self.console.append("If your Datatype is fits, you will start with processing unit Type SpectraHeis")
420 420
421 421
422 422 @pyqtSignature("")
423 423 def on_actionSaveToolbar_triggered(self):
424 424 """
425 425 Slot documentation goes here.
426 426 """
427 427 self.saveProject()
428 428
429 429 @pyqtSignature("")
430 430 def on_actionStarToolbar_triggered(self):
431 431 """
432 432 Slot documentation goes here.
433 433 """
434 434 self.playProject()
435 435
436 436 @pyqtSignature("")
437 437 def on_actionPauseToolbar_triggered(self):
438 438
439 439 self.pauseProject()
440 440
441 441 @pyqtSignature("")
442 442 def on_actionStopToolbar_triggered(self):
443 443 """
444 444 Slot documentation goes here.
445 445 """
446 446 self.stopProject()
447 447
448 448 @pyqtSignature("int")
449 449 def on_proComReadMode_activated(self, index):
450 450 """
451 451 SELECCION DEL MODO DE LECTURA ON=1, OFF=0
452 452 """
453 453 if index == 0:
454 454 # self.proDelay.setText("0")
455 455 self.proSet.setEnabled(True)
456 456 self.proDelay.setEnabled(False)
457 457 elif index == 1:
458 458 self.proSet.setText("")
459 459 # self.proDelay.setText("5")
460 460 self.proSet.setEnabled(False)
461 461 self.proDelay.setEnabled(True)
462 462
463 463
464 464 def __setRawDataWindow(self):
465 465
466 466 self.__setPDataWindow()
467 467
468 468 self.frame_data.show()
469 469
470 470 self.labnTxs.show()
471 471 self.pronTxs.show()
472 472
473 473 self.labByBlock.show()
474 474 self.proComByBlock.show()
475 475
476 476 def __setPDataWindow(self):
477 477
478 478 self.labelIPPKm.hide()
479 479 self.proIPPKm.hide()
480 480
481 481 self.labelSet.show()
482 482 self.proSet.show()
483 483
484 484 self.labExpLabel.show()
485 485 self.proExpLabel.show()
486 486
487 487 self.labelWalk.show()
488 488 self.proComWalk.show()
489 489
490 490 self.frame_data.hide()
491 491
492 492 # self.labnTxs.hide()
493 493 # self.pronTxs.hide()
494 494 #
495 495 # self.labByBlock.hide()
496 496 # self.proComByBlock.hide()
497 497
498 498 def __setUSRPDataWindow(self):
499 499
500 500 self.frame_data.show()
501 501
502 502 self.labelIPPKm.show()
503 503 self.proIPPKm.show()
504 504
505 505 self.labelSet.hide()
506 506 self.proSet.hide()
507 507
508 508 self.labExpLabel.hide()
509 509 self.proExpLabel.hide()
510 510
511 511 self.labelWalk.hide()
512 512 self.proComWalk.hide()
513 513
514 514 self.labnTxs.hide()
515 515 self.pronTxs.hide()
516 516
517 517 self.labByBlock.hide()
518 518 self.proComByBlock.hide()
519 519
520 520 @pyqtSignature("int")
521 521 def on_proComDataType_activated(self, index):
522 522 """
523 523 Voltage or Spectra
524 524 """
525 525
526 526 if index == 0:
527 527 extension = '.r'
528 528 self.__setRawDataWindow()
529 529
530 530 elif index == 1:
531 531 extension = '.pdata'
532 532 self.__setPDataWindow()
533 533
534 534
535 535 elif index == 2:
536 536 extension = '.fits'
537 537 self.__setPDataWindow()
538 538
539 539 elif index == 3:
540 540 extension = '.hdf5'
541 541 self.__setUSRPDataWindow()
542 542
543 543 self.proDataType.setText(extension)
544 544
545 545 @pyqtSignature("int")
546 546 def on_proComWalk_activated(self, index):
547 547 """
548 548
549 549 """
550 550 if index == 0:
551 551 self.proExpLabel.setEnabled(False)
552 552 elif index == 1:
553 553 self.proExpLabel.setEnabled(True)
554 554
555 555 @pyqtSignature("")
556 556 def on_proToolPath_clicked(self):
557 557 """
558 558 Choose your path
559 559 """
560 560
561 561 current_dpath = './'
562 562 if self.dataPath:
563 563 current_dpath = self.dataPath
564 564
565 565 datapath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', current_dpath, QtGui.QFileDialog.ShowDirsOnly))
566 566
567 567 #If it was canceled
568 568 if not datapath:
569 569 return
570 570
571 571 #If any change was done
572 572 if datapath == self.dataPath:
573 573 return
574 574
575 575 self.proDataPath.setText(datapath)
576 576
577 577 self._disable_play_button()
578 578 self._disable_save_button()
579 579 self.proOk.setEnabled(False)
580 580
581 581 self.proComStartDate.clear()
582 582 self.proComEndDate.clear()
583 583
584 584 if not os.path.exists(datapath):
585 585
586 586 self.console.clear()
587 587 self.console.append("Write a valid path")
588 588 return
589 589
590 590 self.dataPath = datapath
591 591
592 592 self.console.clear()
593 593 self.console.append("Select the read mode and press 'load button'")
594 594
595 595
596 596 @pyqtSignature("")
597 597 def on_proLoadButton_clicked(self):
598 598
599 599 self.console.clear()
600 600
601 601 projectParms = self.__getParmsFromProjectWindow()
602 602
603 603 if not projectParms.online:
604 604 self.proComStartDate.clear()
605 605 self.proComEndDate.clear()
606 606 self.proComStartDate.setEnabled(True)
607 607 self.proComEndDate.setEnabled(True)
608 608 self.proStartTime.setEnabled(True)
609 609 self.proEndTime.setEnabled(True)
610 610 self.frame_2.setEnabled(True)
611 611
612 612 else:
613 613 self.proComStartDate.addItem("1960/01/30")
614 614 self.proComEndDate.addItem("2018/12/31")
615 615 self.proComStartDate.setEnabled(False)
616 616 self.proComEndDate.setEnabled(False)
617 617 self.proStartTime.setEnabled(False)
618 618 self.proEndTime.setEnabled(False)
619 619 self.frame_2.setEnabled(True)
620 620
621 621 if self.loadDays(projectParms.dpath, projectParms.ext, projectParms.walk, projectParms.expLabel) == []:
622 622 self._disable_save_button()
623 623 self._disable_play_button()
624 624 self.proOk.setEnabled(False)
625 625 else:
626 626 self._enable_save_button()
627 627 self._enable_play_button()
628 628 self.proOk.setEnabled(True)
629 629
630 630 @pyqtSignature("int")
631 631 def on_proComStartDate_activated(self, index):
632 632 """
633 633 SELECCION DEL RANGO DE FECHAS -START DATE
634 634 """
635 635 stopIndex = self.proComEndDate.count() - self.proComEndDate.currentIndex() - 1
636 636
637 637 self.proComEndDate.clear()
638 638 for i in self.dateList[index:]:
639 639 self.proComEndDate.addItem(i)
640 640
641 641 if self.proComEndDate.count() - stopIndex - 1 >= 0:
642 642 self.proComEndDate.setCurrentIndex(self.proComEndDate.count() - stopIndex - 1)
643 643 else:
644 644 self.proComEndDate.setCurrentIndex(self.proComEndDate.count() - 1)
645 645
646 646 @pyqtSignature("int")
647 647 def on_proComEndDate_activated(self, index):
648 648 """
649 649 SELECCION DEL RANGO DE FECHAS-END DATE
650 650 """
651 651 pass
652 652
653 653 @pyqtSignature("")
654 654 def on_proOk_clicked(self):
655 655 """
656 656 AΓ±ade al Obj XML de Projecto, name,datatype,date,time,readmode,wait,etc, crea el readUnitProcess del archivo xml.
657 657 Prepara la configuraciΓ³n del diΓ‘grama del Arbol del treeView numero 2
658 658 """
659 659
660 660 self._disable_play_button()
661 661 self._disable_save_button()
662 662
663 663 self.console.clear()
664 664
665 665 if self.create:
666 666
667 667 projectId = self.__getNewProjectId()
668 668
669 669 if not projectId:
670 670 return 0
671 671
672 672 projectObjView = self.createProjectView(projectId)
673 673
674 674 if not projectObjView:
675 675 return 0
676 676
677 677 self.create = False
678 678
679 679 readUnitObj = self.createReadUnitView(projectObjView)
680 680
681 681 if not readUnitObj:
682 682 return 0
683 683
684 684 else:
685 685 projectObjView = self.updateProjectView()
686 686
687 687 if not projectObjView:
688 688 return 0
689 689
690 690 projectId = projectObjView.getId()
691 691 idReadUnit = projectObjView.getReadUnitId()
692 692 readUnitObj = self.updateReadUnitView(projectObjView, idReadUnit)
693 693
694 694 if not readUnitObj:
695 695 return 0
696 696
697 697 self.__itemTreeDict[projectId].setText(projectObjView.name)
698 698 # Project Properties
699 699 self.refreshProjectProperties(projectObjView)
700 700 # Disable tabProject after finish the creation
701 701
702 702 self._enable_play_button()
703 703 self._enable_save_button()
704 704
705 705 self.console.clear()
706 706 self.console.append("The project parameters were validated")
707 707
708 708 return 1
709 709
710 710 @pyqtSignature("")
711 711 def on_proClear_clicked(self):
712 712
713 713 self.console.clear()
714 714
715 715 @pyqtSignature("int")
716 716 def on_volOpCebChannels_stateChanged(self, p0):
717 717 """
718 718 Check Box habilita operaciones de SelecciοΏ½n de Canales
719 719 """
720 720 if p0 == 2:
721 721 self.volOpComChannels.setEnabled(True)
722 722 self.volOpChannel.setEnabled(True)
723 723
724 724 if p0 == 0:
725 725 self.volOpComChannels.setEnabled(False)
726 726 self.volOpChannel.setEnabled(False)
727 727 # self.volOpChannel.clear()
728 728
729 729 @pyqtSignature("int")
730 730 def on_volOpCebHeights_stateChanged(self, p0):
731 731 """
732 732 Check Box habilita operaciones de SelecciοΏ½n de Alturas
733 733 """
734 734 if p0 == 2:
735 735 self.volOpHeights.setEnabled(True)
736 736 self.volOpComHeights.setEnabled(True)
737 737
738 738 if p0 == 0:
739 739 self.volOpHeights.setEnabled(False)
740 740 # self.volOpHeights.clear()
741 741 self.volOpComHeights.setEnabled(False)
742 742
743 743 @pyqtSignature("int")
744 744 def on_volOpCebFilter_stateChanged(self, p0):
745 745 """
746 746 Name='Decoder', optype='other'
747 747 """
748 748 if p0 == 2:
749 749 self.volOpFilter.setEnabled(True)
750 750
751 751 if p0 == 0:
752 752 self.volOpFilter.setEnabled(False)
753 753 # self.volOpFilter.clear()
754 754
755 755 @pyqtSignature("int")
756 756 def on_volOpCebProfile_stateChanged(self, p0):
757 757 """
758 758 Check Box habilita ingreso del rango de Perfiles
759 759 """
760 760 if p0 == 2:
761 761 self.volOpComProfile.setEnabled(True)
762 762 self.volOpProfile.setEnabled(True)
763 763
764 764 if p0 == 0:
765 765 self.volOpComProfile.setEnabled(False)
766 766 self.volOpProfile.setEnabled(False)
767 767 # self.volOpProfile.clear()
768 768
769 769 @pyqtSignature("int")
770 770 def on_volOpComProfile_activated(self, index):
771 771 """
772 772 Check Box habilita ingreso del rango de Perfiles
773 773 """
774 774 #Profile List
775 775 if index == 0:
776 776 self.volOpProfile.setToolTip('List of selected profiles. Example: 0, 1, 2, 3, 4, 5, 6, 7')
777 777
778 778 #Profile Range
779 779 if index == 1:
780 780 self.volOpProfile.setToolTip('Minimum and maximum profile index. Example: 0, 7')
781 781
782 782 #Profile Range List
783 783 if index == 2:
784 784 self.volOpProfile.setToolTip('List of profile ranges. Example: (0, 7), (12, 19), (100, 200)')
785 785
786 786 @pyqtSignature("int")
787 787 def on_volOpCebDecodification_stateChanged(self, p0):
788 788 """
789 789 Check Box habilita
790 790 """
791 791 if p0 == 2:
792 792 self.volOpComCode.setEnabled(True)
793 793 self.volOpComMode.setEnabled(True)
794 794 if p0 == 0:
795 795 self.volOpComCode.setEnabled(False)
796 796 self.volOpComMode.setEnabled(False)
797 797
798 798 @pyqtSignature("int")
799 799 def on_volOpComCode_activated(self, index):
800 800 """
801 801 Check Box habilita ingreso
802 802 """
803 803 if index == 13:
804 804 self.volOpCode.setEnabled(True)
805 805 else:
806 806 self.volOpCode.setEnabled(False)
807 807
808 808 if index == 0:
809 809 code = ''
810 810 self.volOpCode.setText(str(code))
811 811 return
812 812
813 813 if index == 1:
814 814 code = '(1,1,-1)'
815 815 nCode = '1'
816 816 nBaud = '3'
817 817 if index == 2:
818 818 code = '(1,1,-1,1)'
819 819 nCode = '1'
820 820 nBaud = '4'
821 821 if index == 3:
822 822 code = '(1,1,1,-1,1)'
823 823 nCode = '1'
824 824 nBaud = '5'
825 825 if index == 4:
826 826 code = '(1,1,1,-1,-1,1,-1)'
827 827 nCode = '1'
828 828 nBaud = '7'
829 829 if index == 5:
830 830 code = '(1,1,1,-1,-1,-1,1,-1,-1,1,-1)'
831 831 nCode = '1'
832 832 nBaud = '11'
833 833 if index == 6:
834 834 code = '(1,1,1,1,1,-1,-1,1,1,-1,1,-1,1)'
835 835 nCode = '1'
836 836 nBaud = '13'
837 837 if index == 7:
838 838 code = '(1,1,-1,-1,-1,1)'
839 839 nCode = '2'
840 840 nBaud = '3'
841 841 if index == 8:
842 842 code = '(1,1,-1,1,-1,-1,1,-1)'
843 843 nCode = '2'
844 844 nBaud = '4'
845 845 if index == 9:
846 846 code = '(1,1,1,-1,1,-1,-1,-1,1,-1)'
847 847 nCode = '2'
848 848 nBaud = '5'
849 849 if index == 10:
850 850 code = '(1,1,1,-1,-1,1,-1,-1,-1,-1,1,1,-1,1)'
851 851 nCode = '2'
852 852 nBaud = '7'
853 853 if index == 11:
854 854 code = '(1,1,1,-1,-1,-1,1,-1,-1,1,-1,-1 ,-1 ,-1 ,1 ,1,1,-1 ,1 ,1 ,-1 ,1)'
855 855 nCode = '2'
856 856 nBaud = '11'
857 857 if index == 12:
858 858 code = '(1,1,1,1,1,-1,-1,1,1,-1,1,-1,1,-1,-1,-1,-1,-1,1,1,-1,-1,1,-1,1,-1)'
859 859 nCode = '2'
860 860 nBaud = '13'
861 861
862 862 code = ast.literal_eval(code)
863 863 nCode = int(nCode)
864 864 nBaud = int(nBaud)
865 865
866 866 code = numpy.asarray(code).reshape((nCode, nBaud)).tolist()
867 867
868 868 self.volOpCode.setText(str(code))
869 869
870 870 @pyqtSignature("int")
871 871 def on_volOpCebFlip_stateChanged(self, p0):
872 872 """
873 873 Check Box habilita ingresode del numero de Integraciones a realizar
874 874 """
875 875 if p0 == 2:
876 876 self.volOpFlip.setEnabled(True)
877 877 if p0 == 0:
878 878 self.volOpFlip.setEnabled(False)
879 879 # self.volOpFlip.clear()
880 880
881 881 @pyqtSignature("int")
882 882 def on_volOpCebCohInt_stateChanged(self, p0):
883 883 """
884 884 Check Box habilita ingresode del numero de Integraciones a realizar
885 885 """
886 886 if p0 == 2:
887 887 self.volOpCohInt.setEnabled(True)
888 888 if p0 == 0:
889 889 self.volOpCohInt.setEnabled(False)
890 890 # self.volOpCohInt.clear()
891 891
892 892 @pyqtSignature("int")
893 893 def on_volOpCebRadarfrequency_stateChanged(self, p0):
894 894 """
895 895 Check Box habilita ingresode del numero de Integraciones a realizar
896 896 """
897 897 if p0 == 2:
898 898 self.volOpRadarfrequency.setEnabled(True)
899 899 if p0 == 0:
900 900 self.volOpRadarfrequency.clear()
901 901 self.volOpRadarfrequency.setEnabled(False)
902 902
903 903 @pyqtSignature("")
904 904 def on_volOutputToolPath_clicked(self):
905 905 dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
906 906 self.volOutputPath.setText(dirOutPath)
907 907
908 908 @pyqtSignature("")
909 909 def on_specOutputToolPath_clicked(self):
910 910 dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
911 911 self.specOutputPath.setText(dirOutPath)
912 912
913 913 @pyqtSignature("")
914 914 def on_specHeisOutputToolPath_clicked(self):
915 915 dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
916 916 self.specHeisOutputPath.setText(dirOutPath)
917 917
918 918 @pyqtSignature("")
919 919 def on_specHeisOutputMetadaToolPath_clicked(self):
920 920
921 921 filename = str(QtGui.QFileDialog.getOpenFileName(self, "Open text file", self.pathWorkSpace, self.tr("Text Files (*.xml)")))
922 922 self.specHeisOutputMetada.setText(filename)
923 923
924 924 @pyqtSignature("")
925 925 def on_volOpOk_clicked(self):
926 926 """
927 927 BUSCA EN LA LISTA DE OPERACIONES DEL TIPO VOLTAJE Y LES AοΏ½ADE EL PARAMETRO ADECUADO ESPERANDO LA ACEPTACION DEL USUARIO
928 928 PARA AGREGARLO AL ARCHIVO DE CONFIGURACION XML
929 929 """
930 930
931 931 checkPath = False
932 932
933 933 self._disable_play_button()
934 934 self._disable_save_button()
935 935
936 936 self.console.clear()
937 937 self.console.append("Checking input parameters:\n")
938 938
939 939 puObj = self.getSelectedItemObj()
940 940 puObj.removeOperations()
941 941
942 942 if self.volOpCebRadarfrequency.isChecked():
943 943 value = str(self.volOpRadarfrequency.text())
944 944 format = 'float'
945 945 name_operation = 'setRadarFrequency'
946 946 name_parameter = 'frequency'
947 947
948 948 if not isFloat(value):
949 949 self.console.append("Invalid value '%s' for Radar Frequency" %value)
950 950 return 0
951 951
952 952 opObj = puObj.addOperation(name=name_operation)
953 953 opObj.addParameter(name=name_parameter, value=radarfreq, format=format)
954 954
955 955 if self.volOpCebChannels.isChecked():
956 956
957 957 format = 'intlist'
958 958 if self.volOpComChannels.currentIndex() == 0:
959 959 name_operation = "selectChannels"
960 960 name_parameter = 'channelList'
961 961 else:
962 962 name_operation = "selectChannelsByIndex"
963 963 name_parameter = 'channelIndexList'
964 964
965 965 value = str(self.volOpChannel.text())
966 966
967 967 if not isIntList(value):
968 968 self.console.append("Invalid value '%s' for %s" %(value,name_parameter))
969 969 return 0
970 970
971 971 opObj = puObj.addOperation(name=name_operation)
972 972 opObj.addParameter(name=name_parameter, value=value, format=format)
973 973
974 974 if self.volOpCebHeights.isChecked():
975 975 value = str(self.volOpHeights.text())
976 976
977 977 if not isFloatRange(value):
978 978 self.console.append("Invalid value '%s' for Height range" %value)
979 979 return 0
980 980
981 981 valueList = value.split(',')
982 982
983 983 if self.volOpComHeights.currentIndex() == 0:
984 984 format = 'float'
985 985 name_operation = 'selectHeights'
986 986 name_parameter1 = 'minHei'
987 987 name_parameter2 = 'maxHei'
988 988 else:
989 989 format = 'int'
990 990 name_operation = 'selectHeightsByIndex'
991 991 name_parameter1 = 'minIndex'
992 992 name_parameter2 = 'maxIndex'
993 993
994 994 opObj = puObj.addOperation(name=name_operation)
995 995 opObj.addParameter(name=name_parameter1, value=valueList[0], format=format)
996 996 opObj.addParameter(name=name_parameter2, value=valueList[1], format=format)
997 997
998 998 if self.volOpCebFilter.isChecked():
999 999 value = str(self.volOpFilter.text())
1000 1000
1001 1001 if not isInt(value):
1002 1002 self.console.append("Invalid value '%s' for Filter" %value)
1003 1003 return 0
1004 1004
1005 1005 format = 'int'
1006 1006 name_operation = 'filterByHeights'
1007 1007 name_parameter = 'window'
1008 1008 opObj = puObj.addOperation(name=name_operation)
1009 1009 opObj.addParameter(name=name_parameter, value=value, format=format)
1010 1010
1011 1011 if self.volOpCebProfile.isChecked():
1012 1012 value = str(self.volOpProfile.text())
1013 1013
1014 1014 format = 'intlist'
1015 1015 optype = 'other'
1016 1016 name_operation = 'ProfileSelector'
1017 1017
1018 1018 if self.volOpComProfile.currentIndex() == 0:
1019 1019 name_parameter = 'profileList'
1020 1020 if self.volOpComProfile.currentIndex() == 1:
1021 1021 name_parameter = 'profileRangeList'
1022 1022 if self.volOpComProfile.currentIndex() == 2:
1023 1023 name_parameter = 'rangeList'
1024 1024
1025 1025 if not isIntList(value):
1026 1026 self.console.append("Invalid value '%s' for %s" %(value, name_parameter) )
1027 1027 return 0
1028 1028
1029 1029 opObj = puObj.addOperation(name='ProfileSelector', optype='other')
1030 1030 opObj.addParameter(name=name_parameter, value=value, format=format)
1031 1031
1032 1032 if self.volOpCebDecodification.isChecked():
1033 1033 name_operation = 'Decoder'
1034 1034 opObj = puObj.addOperation(name=name_operation, optype='other')
1035 1035
1036 1036 if self.volOpComCode.currentIndex() != 0:
1037 1037
1038 1038 code = str(self.volOpCode.text())
1039 1039
1040 1040 if not isMultiList(code):
1041 1041 self.console.append("Please write a valid Code (Example: [1,1,-1], [1,-1,1])")
1042 1042 return 0
1043 1043
1044 1044 real_code = getCode(code)
1045 1045 nCode = len(real_code)
1046 1046 nBaud = len(real_code[0])
1047 1047
1048 1048 opObj.addParameter(name='code', value=code, format='intlist')
1049 1049 opObj.addParameter(name='nCode', value=nCode, format='int')
1050 1050 opObj.addParameter(name='nBaud', value=nBaud, format='int')
1051 1051
1052 1052 name_parameter = 'mode'
1053 1053 format = 'int'
1054 1054 value = str(self.volOpComMode.currentIndex())
1055 1055
1056 1056 opObj.addParameter(name=name_parameter, value=value, format=format)
1057 1057
1058 1058
1059 1059 if self.volOpCebFlip.isChecked():
1060 1060 name_operation = 'deFlip'
1061 1061 optype = 'self'
1062 1062
1063 1063 opObj = puObj.addOperation(name=name_operation, optype=optype)
1064 1064
1065 1065 name_parameter = 'channelList'
1066 1066 format = 'intlist'
1067 1067 value = str(self.volOpFlip.text())
1068 1068
1069 1069 if not isIntList(value):
1070 1070 self.console.append("Invalid value '%s' for '%s'" %(value,name_parameter))
1071 1071 return 0
1072 1072
1073 1073 opObj.addParameter(name=name_parameter, value=value, format=format)
1074 1074
1075 1075 if self.volOpCebCohInt.isChecked():
1076 1076 name_operation = 'CohInt'
1077 1077 optype = 'other'
1078 1078 value = str(self.volOpCohInt.text())
1079 1079
1080 1080 if not isInt(value):
1081 1081 self.console.append("Invalid value '%s' for '%s'" %(value,name_parameter))
1082 1082 return 0
1083 1083
1084 1084 name_parameter = 'n'
1085 1085 format = 'int'
1086 1086
1087 1087 opObj = puObj.addOperation(name=name_operation, optype=optype)
1088 1088 opObj.addParameter(name=name_parameter, value=value, format=format)
1089 1089
1090 1090 if self.volGraphCebshow.isChecked():
1091 1091 name_operation = 'Scope'
1092 1092 optype = 'other'
1093 1093 name_parameter = 'type'
1094 1094 value = 'Scope'
1095 1095 if self.idImagscope == 0:
1096 1096 self.idImagscope = 100
1097 1097 else:
1098 1098 self.idImagscope = self.idImagscope + 1
1099 1099
1100 1100 name_parameter1 = 'id'
1101 1101 value1 = int(self.idImagscope)
1102 1102 format1 = 'int'
1103 1103 format = 'str'
1104 1104
1105 1105 opObj = puObj.addOperation(name=name_operation, optype=optype)
1106 1106 # opObj.addParameter(name=name_parameter, value=value, format=format)
1107 1107 opObj.addParameter(name=name_parameter1, value=opObj.id, format=format1)
1108 1108
1109 1109 channelList = str(self.volGraphChannelList.text()).strip()
1110 xvalue = str(self.volGraphfreqrange.text()).strip()
1111 yvalue = str(self.volGraphHeightrange.text()).strip()
1110 xvalue = str(self.volGraphHeightrange.text()).strip()
1111 yvalue = str(self.volGraphIntensityRange.text()).strip()
1112 1112 figpath = str(self.volGraphPath.text()).strip()
1113 1113 figfile = str(self.volGraphPrefix.text()).strip()
1114 1114
1115 1115 if channelList != "":
1116 1116 if not isIntList(channelList):
1117 1117 self.console.append("Invalid value '%s' for 'Graphics:ChannelList'" %(channelList))
1118 1118 return 0
1119 1119
1120 1120 if xvalue != "":
1121 1121 if not isFloatRange(xvalue):
1122 self.console.append("Invalid value '%s' for 'Graphics:Frequncy-Range'" %(xvalue))
1122 self.console.append("Invalid value '%s' for 'Graphics:Height-Range'" %(xvalue))
1123 1123 return 0
1124 1124
1125 1125 if yvalue != "":
1126 1126 if not isFloatRange(yvalue):
1127 self.console.append("Invalid value '%s' for 'Graphics:Height-Range'" %(yvalue))
1127 self.console.append("Invalid value '%s' for 'Graphics:Amplitude-Range'" %(yvalue))
1128 1128 return 0
1129 1129
1130 1130
1131 1131 if channelList:
1132 1132 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1133 1133
1134 1134 if xvalue:
1135 1135 xvalueList = xvalue.split(',')
1136 1136
1137 1137 opObj.addParameter(name='xmin', value=xvalueList[0], format='float')
1138 1138 opObj.addParameter(name='xmax', value=xvalueList[1], format='float')
1139 1139
1140 1140 if yvalue:
1141 1141 yvalueList = yvalue.split(",")
1142 1142
1143 1143 opObj.addParameter(name='ymin', value=yvalueList[0], format='int')
1144 1144 opObj.addParameter(name='ymax', value=yvalueList[1], format='int')
1145
1145
1146 plot_type = self.volComScopeType.currentIndex()
1147
1148 if plot_type == 0:
1149 opObj.addParameter(name='type', value="iq")
1150 if plot_type == 1:
1151 opObj.addParameter(name='type', value="power")
1152
1146 1153 if self.volGraphCebSave.isChecked():
1147 1154 checkPath = True
1148 1155
1149 1156 opObj.addParameter(name='save', value='1', format='int')
1150 1157 opObj.addParameter(name='figpath', value=figpath, format='str')
1151 1158
1152 1159 if figfile:
1153 1160 opObj.addParameter(name='figfile', value=value, format='str')
1154 1161
1155 1162 if checkPath:
1156 1163
1157 1164 if not figpath:
1158 1165 self.console.clear()
1159 1166 self.console.append("Graphic path should be defined")
1160 1167 return 0
1161 1168
1162 1169 if os.path.isdir(figpath):
1163 1170 self.console.clear()
1164 1171 self.console.append("Graphic path does not exist, it has to be created")
1165 1172 return 0
1166 1173
1167 1174 # if something happend
1168 1175 parms_ok, output_path, blocksperfile, profilesperblock = self.checkInputsPUSave(datatype='Voltage')
1169 1176 if parms_ok:
1170 1177 name_operation = 'VoltageWriter'
1171 1178 optype = 'other'
1172 1179 name_parameter1 = 'path'
1173 1180 name_parameter2 = 'blocksPerFile'
1174 1181 name_parameter3 = 'profilesPerBlock'
1175 1182 value1 = output_path
1176 1183 value2 = blocksperfile
1177 1184 value3 = profilesperblock
1178 1185 format = "int"
1179 1186 opObj = puObj.addOperation(name=name_operation, optype=optype)
1180 1187 opObj.addParameter(name=name_parameter1, value=value1)
1181 1188 opObj.addParameter(name=name_parameter2, value=value2, format=format)
1182 1189 opObj.addParameter(name=name_parameter3, value=value3, format=format)
1183 1190
1184 1191 self.console.clear()
1185 1192 try:
1186 1193 self.refreshPUProperties(puObj)
1187 1194 except:
1188 1195 self.console.append("An error reading input parameters was found ...Check them!")
1189 1196 return 0
1190 1197
1191 1198 self.console.append("Save your project and press Play button to start signal processing")
1192 1199
1193 1200 self._enable_play_button()
1194 1201 self._enable_save_button()
1195 1202
1196 1203 return 1
1197 1204
1198 1205 """
1199 1206 Voltage Graph
1200 1207 """
1201 1208 @pyqtSignature("int")
1202 1209 def on_volGraphCebSave_stateChanged(self, p0):
1203 1210 """
1204 1211 Check Box habilita ingresode del numero de Integraciones a realizar
1205 1212 """
1206 1213 if p0 == 2:
1207 1214 self.volGraphPath.setEnabled(True)
1208 1215 self.volGraphPrefix.setEnabled(True)
1209 1216 self.volGraphToolPath.setEnabled(True)
1210 1217
1211 1218 if p0 == 0:
1212 1219 self.volGraphPath.setEnabled(False)
1213 1220 self.volGraphPrefix.setEnabled(False)
1214 1221 self.volGraphToolPath.setEnabled(False)
1215 1222
1216 1223 @pyqtSignature("")
1217 1224 def on_volGraphToolPath_clicked(self):
1218 1225 """
1219 1226 Donde se guardan los DATOS
1220 1227 """
1221 1228 save_path = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
1222 1229 self.volGraphPath.setText(save_path)
1223 1230
1224 1231 if not os.path.exists(save_path):
1225 1232 self.console.clear()
1226 1233 self.console.append("Set a valid path")
1227 1234 self.volGraphOk.setEnabled(False)
1228 1235 return
1229 1236
1230 1237 @pyqtSignature("int")
1231 1238 def on_volGraphCebshow_stateChanged(self, p0):
1232 1239 """
1233 1240 Check Box habilita ingresode del numero de Integraciones a realizar
1234 1241 """
1235 1242 if p0 == 0:
1236 1243
1237 1244 self.volGraphChannelList.setEnabled(False)
1238 self.volGraphfreqrange.setEnabled(False)
1245 self.volGraphIntensityRange.setEnabled(False)
1239 1246 self.volGraphHeightrange.setEnabled(False)
1240 1247 if p0 == 2:
1241 1248
1242 1249 self.volGraphChannelList.setEnabled(True)
1243 self.volGraphfreqrange.setEnabled(True)
1250 self.volGraphIntensityRange.setEnabled(True)
1244 1251 self.volGraphHeightrange.setEnabled(True)
1245 1252
1246 1253 """
1247 1254 Spectra operation
1248 1255 """
1249 1256 @pyqtSignature("int")
1250 1257 def on_specOpCebRadarfrequency_stateChanged(self, p0):
1251 1258 """
1252 1259 Check Box habilita ingresode del numero de Integraciones a realizar
1253 1260 """
1254 1261 if p0 == 2:
1255 1262 self.specOpRadarfrequency.setEnabled(True)
1256 1263 if p0 == 0:
1257 1264 # self.specOpRadarfrequency.clear()
1258 1265 self.specOpRadarfrequency.setEnabled(False)
1259 1266
1260 1267
1261 1268 @pyqtSignature("int")
1262 1269 def on_specOpCebCrossSpectra_stateChanged(self, p0):
1263 1270 """
1264 1271 Habilita la opcion de aοΏ½adir el parοΏ½metro CrossSpectra a la Unidad de Procesamiento .
1265 1272 """
1266 1273 if p0 == 2:
1267 1274 # self.specOpnFFTpoints.setEnabled(True)
1268 1275 self.specOpComCrossSpectra.setEnabled(True)
1269 1276 self.specOppairsList.setEnabled(True)
1270 1277
1271 1278 if p0 == 0:
1272 1279 # self.specOpnFFTpoints.setEnabled(False)
1273 1280 self.specOpComCrossSpectra.setEnabled(False)
1274 1281 self.specOppairsList.setEnabled(False)
1275 1282
1276 1283 @pyqtSignature("int")
1277 1284 def on_specOpCebChannel_stateChanged(self, p0):
1278 1285 """
1279 1286 Habilita la opcion de aοΏ½adir el parοΏ½metro numero de Canales a la Unidad de Procesamiento .
1280 1287 """
1281 1288 if p0 == 2:
1282 1289 self.specOpChannel.setEnabled(True)
1283 1290 self.specOpComChannel.setEnabled(True)
1284 1291 if p0 == 0:
1285 1292 self.specOpChannel.setEnabled(False)
1286 1293 self.specOpComChannel.setEnabled(False)
1287 1294
1288 1295 @pyqtSignature("int")
1289 1296 def on_specOpCebHeights_stateChanged(self, p0):
1290 1297 """
1291 1298 Habilita la opcion de aοΏ½adir el parοΏ½metro de alturas a la Unidad de Procesamiento .
1292 1299 """
1293 1300 if p0 == 2:
1294 1301 self.specOpComHeights.setEnabled(True)
1295 1302 self.specOpHeights.setEnabled(True)
1296 1303 if p0 == 0:
1297 1304 self.specOpComHeights.setEnabled(False)
1298 1305 self.specOpHeights.setEnabled(False)
1299 1306
1300 1307
1301 1308 @pyqtSignature("int")
1302 1309 def on_specOpCebIncoherent_stateChanged(self, p0):
1303 1310 """
1304 1311 Habilita la opcion de aοΏ½adir el parοΏ½metro integraciones incoherentes a la Unidad de Procesamiento .
1305 1312 """
1306 1313 if p0 == 2:
1307 1314 self.specOpIncoherent.setEnabled(True)
1308 1315 if p0 == 0:
1309 1316 self.specOpIncoherent.setEnabled(False)
1310 1317
1311 1318 @pyqtSignature("int")
1312 1319 def on_specOpCebRemoveDC_stateChanged(self, p0):
1313 1320 """
1314 1321 Habilita la opcion de aοΏ½adir el parοΏ½metro remover DC a la Unidad de Procesamiento .
1315 1322 """
1316 1323 if p0 == 2:
1317 1324 self.specOpComRemoveDC.setEnabled(True)
1318 1325 if p0 == 0:
1319 1326 self.specOpComRemoveDC.setEnabled(False)
1320 1327
1321 1328 @pyqtSignature("int")
1322 1329 def on_specOpCebgetNoise_stateChanged(self, p0):
1323 1330 """
1324 1331 Habilita la opcion de aοΏ½adir la estimacion de ruido a la Unidad de Procesamiento .
1325 1332 """
1326 1333 if p0 == 2:
1327 1334 self.specOpgetNoise.setEnabled(True)
1328 1335
1329 1336 if p0 == 0:
1330 1337 self.specOpgetNoise.setEnabled(False)
1331 1338
1332 1339 @pyqtSignature("")
1333 1340 def on_specOpOk_clicked(self):
1334 1341 """
1335 1342 AΓ‘ADE OPERACION SPECTRA
1336 1343 """
1337 1344
1338 1345 addFTP = False
1339 1346 checkPath = False
1340 1347
1341 1348 self._disable_play_button()
1342 1349 self._disable_save_button()
1343 1350
1344 1351 self.console.clear()
1345 1352 self.console.append("Checking input parameters:\n")
1346 1353
1347 1354 projectObj = self.getSelectedProjectObj()
1348 1355
1349 1356 if not projectObj:
1350 1357 self.console.append("Please select a project before update it")
1351 1358 return
1352 1359
1353 1360 puObj = self.getSelectedItemObj()
1354 1361
1355 1362 puObj.removeOperations()
1356 1363
1357 1364 if self.specOpCebRadarfrequency.isChecked():
1358 1365 value = str(self.specOpRadarfrequency.text())
1359 1366 format = 'float'
1360 1367 name_operation = 'setRadarFrequency'
1361 1368 name_parameter = 'frequency'
1362 1369
1363 1370 if not isFloat(value):
1364 1371 self.console.clear()
1365 1372 self.console.append("Invalid value [%s] for '%s'" %(value, name_parameter))
1366 1373 return 0
1367 1374
1368 1375 radarfreq = float(value)*1e6
1369 1376 opObj = puObj.addOperation(name=name_operation)
1370 1377 opObj.addParameter(name=name_parameter, value=radarfreq, format=format)
1371 1378
1372 1379 inputId = puObj.getInputId()
1373 1380 inputPuObj = projectObj.getProcUnitObj(inputId)
1374 1381
1375 1382 if inputPuObj.datatype == 'Voltage' or inputPuObj.datatype == 'USRP':
1376 1383
1377 1384 value = str(self.specOpnFFTpoints.text())
1378 1385
1379 1386 if not isInt(value):
1380 1387 self.console.append("Invalid value [%s] for '%s'" %(value, 'nFFTPoints'))
1381 1388 return 0
1382 1389
1383 1390 puObj.addParameter(name='nFFTPoints', value=value, format='int')
1384 1391
1385 1392 value = str(self.specOpProfiles.text())
1386 1393 if not isInt(value):
1387 1394 self.console.append("Please write a value on Profiles field")
1388 1395 else:
1389 1396 puObj.addParameter(name='nProfiles', value=value, format='int')
1390 1397
1391 1398 value = str(self.specOpippFactor.text())
1392 1399 if not isInt(value):
1393 1400 self.console.append("Please write a value on IppFactor field")
1394 1401 else:
1395 1402 puObj.addParameter(name='ippFactor' , value=value , format='int')
1396 1403
1397 1404 if self.specOpCebCrossSpectra.isChecked():
1398 1405 name_parameter = 'pairsList'
1399 1406 format = 'pairslist'
1400 1407 value = str(self.specOppairsList.text())
1401 1408
1402 1409 if not isPairList(value):
1403 1410 self.console.append("Invalid value [%s] for '%s'" %(value, name_parameter))
1404 1411 return 0
1405 1412
1406 1413 puObj.addParameter(name=name_parameter, value=value, format=format)
1407 1414
1408 1415 if self.specOpCebHeights.isChecked():
1409 1416 value = str(self.specOpHeights.text())
1410 1417
1411 1418 if not isFloatRange(value):
1412 1419 self.console.append("Invalid value [%s] for Height range" %value)
1413 1420 return 0
1414 1421
1415 1422 valueList = value.split(',')
1416 1423 value0 = valueList[0]
1417 1424 value1 = valueList[1]
1418 1425
1419 1426 if self.specOpComHeights.currentIndex() == 0:
1420 1427 name_operation = 'selectHeights'
1421 1428 name_parameter1 = 'minHei'
1422 1429 name_parameter2 = 'maxHei'
1423 1430 else:
1424 1431 name_operation = 'selectHeightsByIndex'
1425 1432 name_parameter1 = 'minIndex'
1426 1433 name_parameter2 = 'maxIndex'
1427 1434
1428 1435 format = 'float'
1429 1436
1430 1437 opObj = puObj.addOperation(name=name_operation)
1431 1438 opObj.addParameter(name=name_parameter1, value=value0, format=format)
1432 1439 opObj.addParameter(name=name_parameter2, value=value1, format=format)
1433 1440
1434 1441 if self.specOpCebChannel.isChecked():
1435 1442
1436 1443 if self.specOpComChannel.currentIndex() == 0:
1437 1444 name_operation = "selectChannels"
1438 1445 name_parameter = 'channelList'
1439 1446 else:
1440 1447 name_operation = "selectChannelsByIndex"
1441 1448 name_parameter = 'channelIndexList'
1442 1449
1443 1450 format = 'intlist'
1444 1451 value = str(self.specOpChannel.text())
1445 1452
1446 1453 if not isIntList(value):
1447 1454 self.console.append("Invalid value [%s] for '%s'" %(value, name_parameter))
1448 1455 return 0
1449 1456
1450 1457 opObj = puObj.addOperation(name=name_operation)
1451 1458 opObj.addParameter(name=name_parameter, value=value, format=format)
1452 1459
1453 1460 if self.specOpCebIncoherent.isChecked():
1454 1461
1455 1462 name_operation = 'IncohInt'
1456 1463 optype = 'other'
1457 1464
1458 1465 if self.specOpCobIncInt.currentIndex() == 0:
1459 1466 name_parameter = 'timeInterval'
1460 1467 format = 'float'
1461 1468 else:
1462 1469 name_parameter = 'n'
1463 1470 format = 'int'
1464 1471
1465 1472 value = str(self.specOpIncoherent.text())
1466 1473
1467 1474 if not isFloat(value):
1468 1475 self.console.append("Invalid value [%s] for '%s'" %(value, name_parameter))
1469 1476 return 0
1470 1477
1471 1478 opObj = puObj.addOperation(name=name_operation, optype=optype)
1472 1479 opObj.addParameter(name=name_parameter, value=value, format=format)
1473 1480
1474 1481 if self.specOpCebRemoveDC.isChecked():
1475 1482 name_operation = 'removeDC'
1476 1483 name_parameter = 'mode'
1477 1484 format = 'int'
1478 1485
1479 1486 if self.specOpComRemoveDC.currentIndex() == 0:
1480 1487 value = 1
1481 1488 else:
1482 1489 value = 2
1483 1490
1484 1491 opObj = puObj.addOperation(name=name_operation)
1485 1492 opObj.addParameter(name=name_parameter, value=value, format=format)
1486 1493
1487 1494 if self.specOpCebRemoveInt.isChecked():
1488 1495 name_operation = 'removeInterference'
1489 1496 opObj = puObj.addOperation(name=name_operation)
1490 1497
1491 1498
1492 1499 if self.specOpCebgetNoise.isChecked():
1493 1500 value = str(self.specOpgetNoise.text())
1494 1501 valueList = value.split(',')
1495 1502 format = 'float'
1496 1503 name_operation = "getNoise"
1497 1504 opObj = puObj.addOperation(name=name_operation)
1498 1505
1499 1506 if not value == '':
1500 1507 valueList = value.split(',')
1501 1508 length = len(valueList)
1502 1509 if length == 1:
1503 1510 try:
1504 1511 value1 = float(valueList[0])
1505 1512 except:
1506 1513 self.console.clear()
1507 1514 self.console.append("Please Write correct parameter Get Noise")
1508 1515 return 0
1509 1516 name1 = 'minHei'
1510 1517 opObj.addParameter(name=name1, value=value1, format=format)
1511 1518 elif length == 2:
1512 1519 try:
1513 1520 value1 = float(valueList[0])
1514 1521 value2 = float(valueList[1])
1515 1522 except:
1516 1523 self.console.clear()
1517 1524 self.console.append("Please Write corrects parameter Get Noise")
1518 1525 return 0
1519 1526 name1 = 'minHei'
1520 1527 name2 = 'maxHei'
1521 1528 opObj.addParameter(name=name1, value=value1, format=format)
1522 1529 opObj.addParameter(name=name2, value=value2, format=format)
1523 1530
1524 1531 elif length == 3:
1525 1532 try:
1526 1533 value1 = float(valueList[0])
1527 1534 value2 = float(valueList[1])
1528 1535 value3 = float(valueList[2])
1529 1536 except:
1530 1537 self.console.clear()
1531 1538 self.console.append("Please Write corrects parameter Get Noise")
1532 1539 return 0
1533 1540 name1 = 'minHei'
1534 1541 name2 = 'maxHei'
1535 1542 name3 = 'minVel'
1536 1543 opObj.addParameter(name=name1, value=value1, format=format)
1537 1544 opObj.addParameter(name=name2, value=value2, format=format)
1538 1545 opObj.addParameter(name=name3, value=value3, format=format)
1539 1546
1540 1547 elif length == 4:
1541 1548 try:
1542 1549 value1 = float(valueList[0])
1543 1550 value2 = float(valueList[1])
1544 1551 value3 = float(valueList[2])
1545 1552 value4 = float(valueList[3])
1546 1553 except:
1547 1554 self.console.clear()
1548 1555 self.console.append("Please Write corrects parameter Get Noise")
1549 1556 return 0
1550 1557 name1 = 'minHei'
1551 1558 name2 = 'maxHei'
1552 1559 name3 = 'minVel'
1553 1560 name4 = 'maxVel'
1554 1561 opObj.addParameter(name=name1, value=value1, format=format)
1555 1562 opObj.addParameter(name=name2, value=value2, format=format)
1556 1563 opObj.addParameter(name=name3, value=value3, format=format)
1557 1564 opObj.addParameter(name=name4, value=value4, format=format)
1558 1565
1559 1566 elif length > 4:
1560 1567 self.console.clear()
1561 1568 self.console.append("Get Noise Operation only accepts 4 parameters")
1562 1569 return 0
1563 1570
1564 1571 channelList = str(self.specGgraphChannelList.text()).strip()
1565 1572 vel_range = str(self.specGgraphFreq.text()).strip()
1566 1573 hei_range = str(self.specGgraphHeight.text()).strip()
1567 1574 db_range = str(self.specGgraphDbsrange.text()).strip()
1568 1575
1569 1576 trange = str(self.specGgraphTminTmax.text()).strip()
1570 1577 magrange = str(self.specGgraphmagnitud.text()).strip()
1571 1578 phaserange = str(self.specGgraphPhase.text()).strip()
1572 1579 # timerange = str(self.specGgraphTimeRange.text()).strip()
1573 1580
1574 1581 figpath = str(self.specGraphPath.text()).strip()
1575 1582 figfile = str(self.specGraphPrefix.text()).strip()
1576 1583
1577 1584 try:
1578 1585 wrperiod = int(str(self.specGgraphftpratio.text()).strip())
1579 1586 except:
1580 1587 wrperiod = None
1581 1588
1582 1589 #-----Spectra Plot-----
1583 1590 if self.specGraphCebSpectraplot.isChecked():
1584 1591
1585 1592 opObj = puObj.addOperation(name='SpectraPlot', optype='other')
1586 1593 opObj.addParameter(name='id', value=opObj.id, format='int')
1587 1594
1588 1595 if channelList:
1589 1596
1590 1597 if not isList(channelList):
1591 1598 self.console.append("Invalid value [%s] for 'Graphic:ChannelList" %(channelList))
1592 1599 return 0
1593 1600
1594 1601 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1595 1602
1596 1603 if vel_range:
1597 1604
1598 1605 if not isFloatRange(vel_range):
1599 1606 self.console.append("Invalid value [%s] for 'Graphic:Velocity-Range" %(vel_range))
1600 1607 return 0
1601 1608
1602 1609 xvalueList = vel_range.split(',')
1603 1610 value1 = float(xvalueList[0])
1604 1611 value2 = float(xvalueList[1])
1605 1612
1606 1613 opObj.addParameter(name='xmin', value=value1, format='float')
1607 1614 opObj.addParameter(name='xmax', value=value2, format='float')
1608 1615
1609 1616 if hei_range:
1610 1617
1611 1618 if not isFloatRange(hei_range):
1612 1619 self.console.append("Invalid value [%s] for 'Graphic:Height-Range" %(hei_range))
1613 1620 return 0
1614 1621
1615 1622 yvalueList = hei_range.split(",")
1616 1623 value1 = float(yvalueList[0])
1617 1624 value2 = float(yvalueList[1])
1618 1625
1619 1626 opObj.addParameter(name='ymin', value=value1, format='float')
1620 1627 opObj.addParameter(name='ymax', value=value2, format='float')
1621 1628
1622 1629 if db_range:
1623 1630
1624 1631 if not isFloatRange(db_range):
1625 1632 self.console.append("Invalid value [%s] for 'Graphic:dB-Range" %(db_range))
1626 1633 return 0
1627 1634
1628 1635 zvalueList = db_range.split(",")
1629 1636 value1 = float(zvalueList[0])
1630 1637 value2 = float(zvalueList[1])
1631 1638
1632 1639 opObj.addParameter(name='zmin', value=value1, format='float')
1633 1640 opObj.addParameter(name='zmax', value=value2, format='float')
1634 1641
1635 1642 if self.specGraphSaveSpectra.isChecked():
1636 1643
1637 1644 checkPath = True
1638 1645 opObj.addParameter(name='save', value=1 , format='bool')
1639 1646 opObj.addParameter(name='figpath', value=figpath, format='str')
1640 1647 if figfile:
1641 1648 opObj.addParameter(name='figfile', value=figfile, format='str')
1642 1649 if wrperiod:
1643 1650 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1644 1651
1645 1652 if self.specGraphftpSpectra.isChecked():
1646 1653
1647 1654 opObj.addParameter(name='ftp', value='1', format='int')
1648 1655 self.addFTPConf2Operation(puObj, opObj)
1649 1656 addFTP = True
1650 1657
1651 1658 if self.specGraphCebCrossSpectraplot.isChecked():
1652 1659
1653 1660 opObj = puObj.addOperation(name='CrossSpectraPlot', optype='other')
1654 1661 opObj.addParameter(name='id', value=opObj.id, format='int')
1655 1662
1656 1663 if vel_range:
1657 1664
1658 1665 if not isFloatRange(vel_range):
1659 1666 self.console.append("Invalid value [%s] for 'Graphic:Velocity-Range" %(vel_range))
1660 1667 return 0
1661 1668
1662 1669 xvalueList = vel_range.split(',')
1663 1670 value1 = float(xvalueList[0])
1664 1671 value2 = float(xvalueList[1])
1665 1672
1666 1673 opObj.addParameter(name='xmin', value=value1, format='float')
1667 1674 opObj.addParameter(name='xmax', value=value2, format='float')
1668 1675
1669 1676 if hei_range:
1670 1677
1671 1678 if not isFloatRange(hei_range):
1672 1679 self.console.append("Invalid value [%s] for 'Graphic:Height-Range" %(hei_range))
1673 1680 return 0
1674 1681
1675 1682 yvalueList = hei_range.split(",")
1676 1683 value1 = float(yvalueList[0])
1677 1684 value2 = float(yvalueList[1])
1678 1685
1679 1686 opObj.addParameter(name='ymin', value=value1, format='float')
1680 1687 opObj.addParameter(name='ymax', value=value2, format='float')
1681 1688
1682 1689 if db_range:
1683 1690
1684 1691 if not isFloatRange(db_range):
1685 1692 self.console.append("Invalid value [%s] for 'Graphic:dB-Range" %(db_range))
1686 1693 return 0
1687 1694
1688 1695 zvalueList = db_range.split(",")
1689 1696 value1 = float(zvalueList[0])
1690 1697 value2 = float(zvalueList[1])
1691 1698
1692 1699 opObj.addParameter(name='zmin', value=value1, format='float')
1693 1700 opObj.addParameter(name='zmax', value=value2, format='float')
1694 1701
1695 1702 if magrange:
1696 1703
1697 1704 if not isFloatRange(magrange):
1698 1705 self.console.append("Invalid value [%s] for 'Graphic:Magnitud-Range" %(magrange))
1699 1706 return 0
1700 1707
1701 1708 zvalueList = magrange.split(",")
1702 1709 value1 = float(zvalueList[0])
1703 1710 value2 = float(zvalueList[1])
1704 1711
1705 1712 opObj.addParameter(name='coh_min', value=value1, format='float')
1706 1713 opObj.addParameter(name='coh_max', value=value2, format='float')
1707 1714
1708 1715 if phaserange:
1709 1716
1710 1717 if not isFloatRange(phaserange):
1711 1718 self.console.append("Invalid value [%s] for 'Graphic:Phase-Range" %(phaserange))
1712 1719 return 0
1713 1720
1714 1721 zvalueList = phaserange.split(",")
1715 1722 value1 = float(zvalueList[0])
1716 1723 value2 = float(zvalueList[1])
1717 1724
1718 1725 opObj.addParameter(name='phase_min', value=value1, format='float')
1719 1726 opObj.addParameter(name='phase_max', value=value2, format='float')
1720 1727
1721 1728 if self.specGraphSaveCross.isChecked():
1722 1729 checkPath = True
1723 1730 opObj.addParameter(name='save', value='1', format='bool')
1724 1731 opObj.addParameter(name='figpath', value=figpath, format='str')
1725 1732 if figfile:
1726 1733 opObj.addParameter(name='figfile', value=figfile, format='str')
1727 1734 if wrperiod:
1728 1735 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1729 1736
1730 1737 if self.specGraphftpCross.isChecked():
1731 1738 opObj.addParameter(name='ftp', value='1', format='int')
1732 1739 self.addFTPConf2Operation(puObj, opObj)
1733 1740 addFTP = True
1734 1741
1735 1742 if self.specGraphCebRTIplot.isChecked():
1736 1743
1737 1744 opObj = puObj.addOperation(name='RTIPlot', optype='other')
1738 1745 opObj.addParameter(name='id', value=opObj.id, format='int')
1739 1746
1740 1747 if channelList:
1741 1748
1742 1749 if not isIntList(channelList):
1743 1750 self.console.append("Invalid value [%s] for 'Graphic:ChannelList" %(channelList))
1744 1751 return 0
1745 1752
1746 1753 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1747 1754
1748 1755 if trange:
1749 1756
1750 1757 if not isFloatRange(trange):
1751 1758 self.console.append("Invalid value [%s] for 'Graphic:Time-Range" %(trange))
1752 1759 return 0
1753 1760
1754 1761 zvalueList = trange.split(",")
1755 1762 value1 = float(zvalueList[0])
1756 1763 value2 = float(zvalueList[1])
1757 1764
1758 1765 opObj.addParameter(name='xmin', value=value1, format='float')
1759 1766 opObj.addParameter(name='xmax', value=value2, format='float')
1760 1767
1761 1768 if hei_range:
1762 1769
1763 1770 if not isFloatRange(hei_range):
1764 1771 self.console.append("Invalid value [%s] for 'Graphic:Height-Range" %(hei_range))
1765 1772 return 0
1766 1773
1767 1774 yvalueList = hei_range.split(",")
1768 1775 value1 = float(yvalueList[0])
1769 1776 value2 = float(yvalueList[1])
1770 1777
1771 1778 opObj.addParameter(name='ymin', value=value1, format='float')
1772 1779 opObj.addParameter(name='ymax', value=value2, format='float')
1773 1780
1774 1781 if db_range:
1775 1782
1776 1783 if not isFloatRange(db_range):
1777 1784 self.console.append("Invalid value [%s] for 'Graphic:dB-Range" %(db_range))
1778 1785 return 0
1779 1786
1780 1787 zvalueList = db_range.split(",")
1781 1788 value1 = float(zvalueList[0])
1782 1789 value2 = float(zvalueList[1])
1783 1790
1784 1791 opObj.addParameter(name='zmin', value=value1, format='float')
1785 1792 opObj.addParameter(name='zmax', value=value2, format='float')
1786 1793
1787 1794 if self.specGraphSaveRTIplot.isChecked():
1788 1795 checkPath = True
1789 1796 opObj.addParameter(name='save', value='1', format='bool')
1790 1797 opObj.addParameter(name='figpath', value=figpath, format='str')
1791 1798 if figfile:
1792 1799 opObj.addParameter(name='figfile', value=value, format='str')
1793 1800 if wrperiod:
1794 1801 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1795 1802
1796 1803 if self.specGraphftpRTIplot.isChecked():
1797 1804 opObj.addParameter(name='ftp', value='1', format='int')
1798 1805 self.addFTPConf2Operation(puObj, opObj)
1799 1806 addFTP = True
1800 1807
1801 1808 if self.specGraphCebCoherencmap.isChecked():
1802 1809
1803 1810 opObj = puObj.addOperation(name='CoherenceMap', optype='other')
1804 1811 opObj.addParameter(name='id', value=opObj.id, format='int')
1805 1812
1806 1813 if trange:
1807 1814
1808 1815 if not isFloatRange(trange):
1809 1816 self.console.append("Invalid value [%s] for 'Graphic:Time-Range" %(trange))
1810 1817 return 0
1811 1818
1812 1819 zvalueList = trange.split(",")
1813 1820 value1 = float(zvalueList[0])
1814 1821 value2 = float(zvalueList[1])
1815 1822
1816 1823 opObj.addParameter(name='xmin', value=value1, format='float')
1817 1824 opObj.addParameter(name='xmax', value=value2, format='float')
1818 1825
1819 1826 if hei_range:
1820 1827
1821 1828 if not isFloatRange(hei_range):
1822 1829 self.console.append("Invalid value [%s] for 'Graphic:Height-Range" %(hei_range))
1823 1830 return 0
1824 1831
1825 1832 yvalueList = hei_range.split(",")
1826 1833 value1 = float(yvalueList[0])
1827 1834 value2 = float(yvalueList[1])
1828 1835
1829 1836 opObj.addParameter(name='ymin', value=value1, format='float')
1830 1837 opObj.addParameter(name='ymax', value=value2, format='float')
1831 1838
1832 1839 if magrange:
1833 1840
1834 1841 if not isFloatRange(magrange):
1835 1842 self.console.append("Invalid value [%s] for 'Graphic:Magnitud-Range" %(magrange))
1836 1843 return 0
1837 1844
1838 1845 zvalueList = magrange.split(",")
1839 1846 value1 = float(zvalueList[0])
1840 1847 value2 = float(zvalueList[1])
1841 1848
1842 1849 opObj.addParameter(name='zmin', value=value1, format='float')
1843 1850 opObj.addParameter(name='zmax', value=value2, format='float')
1844 1851
1845 1852 if phaserange:
1846 1853
1847 1854 if not isFloatRange(phaserange):
1848 1855 self.console.append("Invalid value [%s] for 'Graphic:Phase-Range" %(phaserange))
1849 1856 return 0
1850 1857
1851 1858 zvalueList = phaserange.split(",")
1852 1859 value1 = float(zvalueList[0])
1853 1860 value2 = float(zvalueList[1])
1854 1861
1855 1862 opObj.addParameter(name='phase_min', value=value1, format='float')
1856 1863 opObj.addParameter(name='phase_max', value=value2, format='float')
1857 1864
1858 1865 if self.specGraphSaveCoherencemap.isChecked():
1859 1866 checkPath = True
1860 1867 opObj.addParameter(name='save', value='1', format='bool')
1861 1868 opObj.addParameter(name='figpath', value=figpath, format='str')
1862 1869 if figfile:
1863 1870 opObj.addParameter(name='figfile', value=value, format='str')
1864 1871 if wrperiod:
1865 1872 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1866 1873
1867 1874 if self.specGraphftpCoherencemap.isChecked():
1868 1875 opObj.addParameter(name='ftp', value='1', format='int')
1869 1876 self.addFTPConf2Operation(puObj, opObj)
1870 1877 addFTP = True
1871 1878
1872 1879 if self.specGraphPowerprofile.isChecked():
1873 1880
1874 1881 opObj = puObj.addOperation(name='PowerProfilePlot', optype='other')
1875 1882 opObj.addParameter(name='id', value=opObj.id, format='int')
1876 1883
1877 1884 if channelList:
1878 1885
1879 1886 if not isList(channelList):
1880 1887 self.console.append("Invalid value [%s] for 'Graphic:ChannelList" %(channelList))
1881 1888 return 0
1882 1889
1883 1890 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1884 1891
1885 1892 if hei_range:
1886 1893
1887 1894 if not isFloatRange(hei_range):
1888 1895 self.console.append("Invalid value [%s] for 'Graphic:Height-Range" %(hei_range))
1889 1896 return 0
1890 1897
1891 1898 yvalueList = hei_range.split(",")
1892 1899 value1 = float(yvalueList[0])
1893 1900 value2 = float(yvalueList[1])
1894 1901
1895 1902 opObj.addParameter(name='ymin', value=value1, format='float')
1896 1903 opObj.addParameter(name='ymax', value=value2, format='float')
1897 1904
1898 1905 if db_range:
1899 1906
1900 1907 if not isFloatRange(db_range):
1901 1908 self.console.append("Invalid value [%s] for 'Graphic:dB-Range" %(db_range))
1902 1909 return 0
1903 1910
1904 1911 zvalueList = db_range.split(",")
1905 1912 value1 = float(zvalueList[0])
1906 1913 value2 = float(zvalueList[1])
1907 1914
1908 1915 opObj.addParameter(name='xmin', value=value1, format='float')
1909 1916 opObj.addParameter(name='xmax', value=value2, format='float')
1910 1917
1911 1918 if self.specGraphSavePowerprofile.isChecked():
1912 1919 checkPath = True
1913 1920 opObj.addParameter(name='save', value='1', format='bool')
1914 1921 opObj.addParameter(name='figpath', value=figpath, format='str')
1915 1922 if figfile:
1916 1923 opObj.addParameter(name='figfile', value=value, format='str')
1917 1924 if wrperiod:
1918 1925 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1919 1926
1920 1927 if self.specGraphftpPowerprofile.isChecked():
1921 1928 opObj.addParameter(name='ftp', value='1', format='int')
1922 1929 self.addFTPConf2Operation(puObj, opObj)
1923 1930 addFTP = True
1924 1931 # rti noise
1925 1932
1926 1933 if self.specGraphCebRTInoise.isChecked():
1927 1934
1928 1935 opObj = puObj.addOperation(name='Noise', optype='other')
1929 1936 opObj.addParameter(name='id', value=opObj.id, format='int')
1930 1937
1931 1938 if channelList:
1932 1939
1933 1940 if not isList(channelList):
1934 1941 self.console.append("Invalid value [%s] for 'Graphic:ChannelList" %(channelList))
1935 1942 return 0
1936 1943
1937 1944 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1938 1945
1939 1946 if trange:
1940 1947
1941 1948 if not isFloatRange(trange):
1942 1949 self.console.append("Invalid value [%s] for 'Graphic:Time-Range" %(trange))
1943 1950 return 0
1944 1951
1945 1952 zvalueList = trange.split(",")
1946 1953 value1 = float(zvalueList[0])
1947 1954 value2 = float(zvalueList[1])
1948 1955
1949 1956 opObj.addParameter(name='xmin', value=value1, format='float')
1950 1957 opObj.addParameter(name='xmax', value=value2, format='float')
1951 1958
1952 1959 if db_range:
1953 1960
1954 1961 if not isFloatRange(db_range):
1955 1962 self.console.append("Invalid value [%s] for 'Graphic:dB-Range" %(db_range))
1956 1963 return 0
1957 1964
1958 1965 zvalueList = db_range.split(",")
1959 1966 value1 = float(zvalueList[0])
1960 1967 value2 = float(zvalueList[1])
1961 1968
1962 1969 opObj.addParameter(name='ymin', value=value1, format='float')
1963 1970 opObj.addParameter(name='ymax', value=value2, format='float')
1964 1971
1965 1972 if self.specGraphSaveRTInoise.isChecked():
1966 1973 checkPath = True
1967 1974 opObj.addParameter(name='save', value='1', format='bool')
1968 1975 opObj.addParameter(name='figpath', value=figpath, format='str')
1969 1976 if figfile:
1970 1977 opObj.addParameter(name='figfile', value=value, format='str')
1971 1978 if wrperiod:
1972 1979 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1973 1980
1974 1981 # test_ftp
1975 1982 if self.specGraphftpRTInoise.isChecked():
1976 1983 opObj.addParameter(name='ftp', value='1', format='int')
1977 1984 self.addFTPConf2Operation(puObj, opObj)
1978 1985 addFTP = True
1979 1986
1980 1987 if checkPath:
1981 1988 if not figpath:
1982 1989 self.console.clear()
1983 1990 self.console.append("Graphic path should be defined")
1984 1991 return 0
1985 1992
1986 1993 if addFTP and not figpath:
1987 1994 self.console.clear()
1988 1995 self.console.append("You have to save the plots before sending them to FTP Server")
1989 1996 return 0
1990 1997
1991 1998 # if something happend
1992 1999 parms_ok, output_path, blocksperfile, profilesperblock = self.checkInputsPUSave(datatype='Spectra')
1993 2000 if parms_ok:
1994 2001 opObj = puObj.addOperation(name='SpectraWriter', optype='other')
1995 2002 opObj.addParameter(name='path', value=output_path)
1996 2003 opObj.addParameter(name='blocksPerFile', value=blocksperfile, format='int')
1997 2004
1998 2005 self.console.clear()
1999 2006 try:
2000 2007 self.refreshPUProperties(puObj)
2001 2008 except:
2002 2009 self.console.append("An error reading input parameters was found ... Check them!")
2003 2010 return 0
2004 2011
2005 2012 self.console.append("Save your project and press Play button to start signal processing")
2006 2013
2007 2014 self._enable_play_button()
2008 2015 self._enable_save_button()
2009 2016
2010 2017 return 1
2011 2018
2012 2019 """
2013 2020 Spectra Graph
2014 2021 """
2015 2022 @pyqtSignature("int")
2016 2023 def on_specGraphCebSpectraplot_stateChanged(self, p0):
2017 2024
2018 2025 self.__checkSpecGraphFilters()
2019 2026
2020 2027
2021 2028 @pyqtSignature("int")
2022 2029 def on_specGraphCebCrossSpectraplot_stateChanged(self, p0):
2023 2030
2024 2031 self.__checkSpecGraphFilters()
2025 2032
2026 2033 @pyqtSignature("int")
2027 2034 def on_specGraphCebRTIplot_stateChanged(self, p0):
2028 2035
2029 2036 self.__checkSpecGraphFilters()
2030 2037
2031 2038
2032 2039 @pyqtSignature("int")
2033 2040 def on_specGraphCebRTInoise_stateChanged(self, p0):
2034 2041
2035 2042 self.__checkSpecGraphFilters()
2036 2043
2037 2044
2038 2045 @pyqtSignature("int")
2039 2046 def on_specGraphCebCoherencmap_stateChanged(self, p0):
2040 2047
2041 2048 self.__checkSpecGraphFilters()
2042 2049
2043 2050 @pyqtSignature("int")
2044 2051 def on_specGraphPowerprofile_stateChanged(self, p0):
2045 2052
2046 2053 self.__checkSpecGraphFilters()
2047 2054
2048 2055 @pyqtSignature("int")
2049 2056 def on_specGraphPhase_stateChanged(self, p0):
2050 2057
2051 2058 self.__checkSpecGraphFilters()
2052 2059
2053 2060 @pyqtSignature("int")
2054 2061 def on_specGraphSaveSpectra_stateChanged(self, p0):
2055 2062 """
2056 2063 """
2057 2064 self.__checkSpecGraphSaving()
2058 2065
2059 2066 @pyqtSignature("int")
2060 2067 def on_specGraphSaveCross_stateChanged(self, p0):
2061 2068
2062 2069 self.__checkSpecGraphSaving()
2063 2070
2064 2071 @pyqtSignature("int")
2065 2072 def on_specGraphSaveRTIplot_stateChanged(self, p0):
2066 2073
2067 2074 self.__checkSpecGraphSaving()
2068 2075
2069 2076 @pyqtSignature("int")
2070 2077 def on_specGraphSaveRTInoise_stateChanged(self, p0):
2071 2078
2072 2079 self.__checkSpecGraphSaving()
2073 2080
2074 2081 @pyqtSignature("int")
2075 2082 def on_specGraphSaveCoherencemap_stateChanged(self, p0):
2076 2083
2077 2084 self.__checkSpecGraphSaving()
2078 2085
2079 2086 @pyqtSignature("int")
2080 2087 def on_specGraphSavePowerprofile_stateChanged(self, p0):
2081 2088
2082 2089 self.__checkSpecGraphSaving()
2083 2090
2084 2091 @pyqtSignature("int")
2085 2092 def on_specGraphftpSpectra_stateChanged(self, p0):
2086 2093 """
2087 2094 """
2088 2095 self.__checkSpecGraphFTP()
2089 2096
2090 2097
2091 2098 @pyqtSignature("int")
2092 2099 def on_specGraphftpCross_stateChanged(self, p0):
2093 2100
2094 2101 self.__checkSpecGraphFTP()
2095 2102
2096 2103 @pyqtSignature("int")
2097 2104 def on_specGraphftpRTIplot_stateChanged(self, p0):
2098 2105
2099 2106 self.__checkSpecGraphFTP()
2100 2107
2101 2108 @pyqtSignature("int")
2102 2109 def on_specGraphftpRTInoise_stateChanged(self, p0):
2103 2110
2104 2111 self.__checkSpecGraphFTP()
2105 2112
2106 2113 @pyqtSignature("int")
2107 2114 def on_specGraphftpCoherencemap_stateChanged(self, p0):
2108 2115
2109 2116 self.__checkSpecGraphFTP()
2110 2117
2111 2118 @pyqtSignature("int")
2112 2119 def on_specGraphftpPowerprofile_stateChanged(self, p0):
2113 2120
2114 2121 self.__checkSpecGraphFTP()
2115 2122
2116 2123 @pyqtSignature("")
2117 2124 def on_specGraphToolPath_clicked(self):
2118 2125 """
2119 2126 """
2120 2127 save_path = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
2121 2128 self.specGraphPath.setText(save_path)
2122 2129 if not os.path.exists(save_path):
2123 2130 self.console.clear()
2124 2131 self.console.append("Write a valid path")
2125 2132 return
2126 2133
2127 2134 @pyqtSignature("")
2128 2135 def on_specGraphClear_clicked(self):
2129 2136 return
2130 2137
2131 2138 @pyqtSignature("")
2132 2139 def on_specHeisGraphToolPath_clicked(self):
2133 2140 """
2134 2141 """
2135 2142 save_path = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
2136 2143 self.specHeisGraphPath.setText(save_path)
2137 2144 if not os.path.exists(save_path):
2138 2145 self.console.clear()
2139 2146 self.console.append("Write a valid path")
2140 2147 return
2141 2148
2142 2149 @pyqtSignature("int")
2143 2150 def on_specHeisOpCebIncoherent_stateChanged(self, p0):
2144 2151 """
2145 2152 Habilita la opcion de aοΏ½adir el parοΏ½metro integraciones incoherentes a la Unidad de Procesamiento .
2146 2153 """
2147 2154 if p0 == 2:
2148 2155 self.specHeisOpIncoherent.setEnabled(True)
2149 2156 self.specHeisOpCobIncInt.setEnabled(True)
2150 2157 if p0 == 0:
2151 2158 self.specHeisOpIncoherent.setEnabled(False)
2152 2159 self.specHeisOpCobIncInt.setEnabled(False)
2153 2160
2154 2161 @pyqtSignature("")
2155 2162 def on_specHeisOpOk_clicked(self):
2156 2163 """
2157 2164 AΓ‘ADE OPERACION SPECTRAHEIS
2158 2165 """
2159 2166 addFTP = False
2160 2167 checkPath = False
2161 2168
2162 2169 self._disable_play_button()
2163 2170 self._disable_save_button()
2164 2171
2165 2172 self.console.clear()
2166 2173 self.console.append("Checking input parameters ...")
2167 2174
2168 2175 puObj = self.getSelectedItemObj()
2169 2176 puObj.removeOperations()
2170 2177
2171 2178 if self.specHeisOpCebIncoherent.isChecked():
2172 2179 value = str(self.specHeisOpIncoherent.text())
2173 2180 name_operation = 'IncohInt4SpectraHeis'
2174 2181 optype = 'other'
2175 2182
2176 2183 name_parameter = 'timeInterval'
2177 2184 format = 'float'
2178 2185
2179 2186 if self.specOpCobIncInt.currentIndex() == 0:
2180 2187 name_parameter = 'timeInterval'
2181 2188 format = 'float'
2182 2189
2183 2190 if not isFloat(value):
2184 2191 self.console.append("Invalid value '%s' for '%s'" %(value, name_parameter))
2185 2192 return 0
2186 2193
2187 2194 opObj = puObj.addOperation(name=name_operation, optype=optype)
2188 2195
2189 2196 if not opObj.addParameter(name=name_parameter, value=value, format=format):
2190 2197 self.console.append("Invalid value '%s' for '%s'" %(value, name_parameter))
2191 2198 return 0
2192 2199
2193 2200 channelList = str(self.specHeisGgraphChannelList.text())
2194 2201 freq_range = str(self.specHeisGgraphXminXmax.text())
2195 2202 power_range = str(self.specHeisGgraphYminYmax.text())
2196 2203 time_range = str(self.specHeisGgraphTminTmax.text())
2197 2204 timerange = str(self.specHeisGgraphTimeRange.text())
2198 2205
2199 2206 # ---- Spectra Plot-----
2200 2207 if self.specHeisGraphCebSpectraplot.isChecked():
2201 2208
2202 2209 name_operation = 'SpectraHeisScope'
2203 2210 optype = 'other'
2204 2211 opObj = puObj.addOperation(name=name_operation, optype=optype)
2205 2212
2206 2213 name_parameter = 'id'
2207 2214 format = 'int'
2208 2215 value = opObj.id
2209 2216
2210 2217 if not opObj.addParameter(name=name_parameter, value=value, format=format):
2211 2218 self.console.append("Invalid value '%s' for '%s'" %(value, name_parameter))
2212 2219 return 0
2213 2220
2214 2221 if not (channelList == ''):
2215 2222 name_parameter = 'channelList'
2216 2223 format = 'intlist'
2217 2224
2218 2225 if not isList(channelList):
2219 2226 self.console.append("Invalid value '%s' for '%s'" %(channelList, name_parameter))
2220 2227 return 0
2221 2228
2222 2229 opObj.addParameter(name=name_parameter, value=channelList, format=format)
2223 2230
2224 2231 if not freq_range == '':
2225 2232 xvalueList = freq_range.split(',')
2226 2233
2227 2234 if len(xvalueList) != 2:
2228 2235 self.console.append("Invalid value '%s' for '%s'" %(freq_range, "xrange"))
2229 2236 return 0
2230 2237
2231 2238 value1 = xvalueList[0]
2232 2239 value2 = xvalueList[1]
2233 2240
2234 2241 if not isFloat(value1) or not isFloat(value2):
2235 2242 self.console.append("Invalid value '%s' for '%s'" %(freq_range, "xrange"))
2236 2243 return 0
2237 2244
2238 2245 name1 = 'xmin'
2239 2246 name2 = 'xmax'
2240 2247 format = 'float'
2241 2248
2242 2249 opObj.addParameter(name=name1, value=value1, format=format)
2243 2250 opObj.addParameter(name=name2, value=value2, format=format)
2244 2251
2245 2252 #------specHeisGgraphYmin-Ymax---
2246 2253 if not power_range == '':
2247 2254 yvalueList = power_range.split(",")
2248 2255
2249 2256 if len(yvalueList) != 2:
2250 2257 self.console.append("Invalid value '%s' for '%s'" %(power_range, "xrange"))
2251 2258 return 0
2252 2259
2253 2260 value1 = yvalueList[0]
2254 2261 value2 = yvalueList[1]
2255 2262
2256 2263 if not isFloat(value1) or not isFloat(value2):
2257 2264 self.console.append("Invalid value '%s' for '%s'" %(power_range, "yrange"))
2258 2265 return 0
2259 2266
2260 2267 name1 = 'ymin'
2261 2268 name2 = 'ymax'
2262 2269 format = 'float'
2263 2270 opObj.addParameter(name=name1, value=value1, format=format)
2264 2271 opObj.addParameter(name=name2, value=value2, format=format)
2265 2272
2266 2273 if self.specHeisGraphSaveSpectra.isChecked():
2267 2274 checkPath = True
2268 2275 name_parameter1 = 'save'
2269 2276 name_parameter2 = 'figpath'
2270 2277 name_parameter3 = 'figfile'
2271 2278 value1 = '1'
2272 2279 value2 = str(self.specHeisGraphPath.text())
2273 2280 value3 = str(self.specHeisGraphPrefix.text())
2274 2281 format1 = 'bool'
2275 2282 format2 = 'str'
2276 2283 opObj.addParameter(name=name_parameter1, value=value1 , format=format1)
2277 2284 opObj.addParameter(name=name_parameter2, value=value2, format=format2)
2278 2285 if not value3 == "":
2279 2286 try:
2280 2287 value3 = str(self.specHeisGraphPrefix.text())
2281 2288 except:
2282 2289 self.console.clear()
2283 2290 self.console.append("Please Write prefix")
2284 2291 return 0
2285 2292 opObj.addParameter(name='figfile', value=str(self.specHeisGraphPrefix.text()), format='str')
2286 2293
2287 2294 # opObj.addParameter(name=name_parameter3, value=value3, format=format2)
2288 2295 # opObj.addParameter(name='wr_period', value='5',format='int')
2289 2296
2290 2297 if self.specHeisGraphftpSpectra.isChecked():
2291 2298 opObj.addParameter(name='ftp', value='1', format='int')
2292 2299 self.addFTPConf2Operation(puObj, opObj)
2293 2300 addFTP = True
2294 2301
2295 2302 if self.specHeisGraphCebRTIplot.isChecked():
2296 2303 name_operation = 'RTIfromSpectraHeis'
2297 2304 optype = 'other'
2298 2305
2299 2306 name_parameter = 'id'
2300 2307 format = 'int'
2301 2308
2302 2309 opObj = puObj.addOperation(name=name_operation, optype=optype)
2303 2310 value = opObj.id
2304 2311 opObj.addParameter(name=name_parameter, value=value, format=format)
2305 2312
2306 2313 if not channelList == '':
2307 2314 opObj.addParameter(name='channelList', value=channelList, format='intlist')
2308 2315
2309 2316 if not time_range == '':
2310 2317 xvalueList = time_range.split(',')
2311 2318 try:
2312 2319 value = float(xvalueList[0])
2313 2320 value = float(xvalueList[1])
2314 2321 except:
2315 2322 return 0
2316 2323 format = 'float'
2317 2324 opObj.addParameter(name='xmin', value=xvalueList[0], format=format)
2318 2325 opObj.addParameter(name='xmax', value=xvalueList[1], format=format)
2319 2326
2320 2327 if not timerange == '':
2321 2328 format = 'int'
2322 2329 try:
2323 2330 timerange = int(timerange)
2324 2331 except:
2325 2332 return 0
2326 2333 opObj.addParameter(name='timerange', value=timerange, format=format)
2327 2334
2328 2335
2329 2336 if not power_range == '':
2330 2337 yvalueList = power_range.split(",")
2331 2338 try:
2332 2339 value = float(yvalueList[0])
2333 2340 value = float(yvalueList[1])
2334 2341 except:
2335 2342 return 0
2336 2343
2337 2344 format = 'float'
2338 2345 opObj.addParameter(name='ymin', value=yvalueList[0], format=format)
2339 2346 opObj.addParameter(name='ymax', value=yvalueList[1], format=format)
2340 2347
2341 2348 if self.specHeisGraphSaveRTIplot.isChecked():
2342 2349 checkPath = True
2343 2350 opObj.addParameter(name='save', value='1', format='bool')
2344 2351 opObj.addParameter(name='figpath', value=str(self.specHeisGraphPath.text()), format='str')
2345 2352 value = str(self.specHeisGraphPrefix.text())
2346 2353 if not value == "":
2347 2354 try:
2348 2355 value = str(self.specHeisGraphPrefix.text())
2349 2356 except:
2350 2357 self.console.clear()
2351 2358 self.console.append("Please Write prefix")
2352 2359 return 0
2353 2360 opObj.addParameter(name='figfile', value=value, format='str')
2354 2361
2355 2362 # test_ftp
2356 2363 if self.specHeisGraphftpRTIplot.isChecked():
2357 2364 opObj.addParameter(name='ftp', value='1', format='int')
2358 2365 self.addFTPConf2Operation(puObj, opObj)
2359 2366 addFTP = True
2360 2367
2361 2368 localfolder = None
2362 2369 if checkPath:
2363 2370 localfolder = str(self.specHeisGraphPath.text())
2364 2371 if localfolder == '':
2365 2372 self.console.clear()
2366 2373 self.console.append("Graphic path should be defined")
2367 2374 return 0
2368 2375
2369 2376 if addFTP and not localfolder:
2370 2377 self.console.clear()
2371 2378 self.console.append("You should save plots before send them to FTP Server")
2372 2379 return 0
2373 2380
2374 2381 # if something happened
2375 2382 parms_ok, output_path, blocksperfile, metadata_file = self.checkInputsPUSave(datatype='SpectraHeis')
2376 2383 if parms_ok:
2377 2384 name_operation = 'FitsWriter'
2378 2385 optype = 'other'
2379 2386 name_parameter1 = 'path'
2380 2387 name_parameter2 = 'dataBlocksPerFile'
2381 2388 name_parameter3 = 'metadatafile'
2382 2389 value1 = output_path
2383 2390 value2 = blocksperfile
2384 2391 value3 = metadata_file
2385 2392 format2 = "int"
2386 2393 format3 = "str"
2387 2394 opObj = puObj.addOperation(name=name_operation, optype=optype)
2388 2395
2389 2396 opObj.addParameter(name=name_parameter1, value=value1)
2390 2397
2391 2398 if blocksperfile:
2392 2399 opObj.addParameter(name=name_parameter2, value=value2, format=format2)
2393 2400
2394 2401 if metadata_file:
2395 2402 opObj.addParameter(name=name_parameter3, value=value3, format=format3)
2396 2403
2397 2404 self.console.clear()
2398 2405 try:
2399 2406 self.refreshPUProperties(puObj)
2400 2407 except:
2401 2408 self.console.append("An error reading input parameters was found ... Check them!")
2402 2409 return 0
2403 2410
2404 2411 self.console.append("Save your project and press Play button to start signal processing")
2405 2412
2406 2413 self._enable_save_button()
2407 2414 self._enable_play_button()
2408 2415
2409 2416 return 1
2410 2417 @pyqtSignature("int")
2411 2418 def on_specHeisGraphCebSpectraplot_stateChanged(self, p0):
2412 2419
2413 2420 if p0 == 2:
2414 2421 self.specHeisGgraphChannelList.setEnabled(True)
2415 2422 self.specHeisGgraphXminXmax.setEnabled(True)
2416 2423 self.specHeisGgraphYminYmax.setEnabled(True)
2417 2424 if p0 == 0:
2418 2425 self.specHeisGgraphXminXmax.setEnabled(False)
2419 2426 self.specHeisGgraphYminYmax.setEnabled(False)
2420 2427
2421 2428 @pyqtSignature("int")
2422 2429 def on_specHeisGraphCebRTIplot_stateChanged(self, p0):
2423 2430
2424 2431 if p0 == 2:
2425 2432 self.specHeisGgraphChannelList.setEnabled(True)
2426 2433 self.specHeisGgraphTminTmax.setEnabled(True)
2427 2434 self.specHeisGgraphYminYmax.setEnabled(True)
2428 2435 self.specHeisGgraphTimeRange.setEnabled(True)
2429 2436
2430 2437 if p0 == 0:
2431 2438 self.specHeisGgraphTminTmax.setEnabled(False)
2432 2439 self.specHeisGgraphYminYmax.setEnabled(False)
2433 2440 self.specHeisGgraphTimeRange.setEnabled(False)
2434 2441
2435 2442 @pyqtSignature("int")
2436 2443 def on_specHeisGraphSaveSpectra_stateChanged(self, p0):
2437 2444 """
2438 2445 """
2439 2446 if p0 == 2:
2440 2447 self.specHeisGraphPath.setEnabled(True)
2441 2448 self.specHeisGraphPrefix.setEnabled(True)
2442 2449 self.specHeisGraphToolPath.setEnabled(True)
2443 2450 if p0 == 0:
2444 2451 self.specHeisGraphPath.setEnabled(False)
2445 2452 self.specHeisGraphPrefix.setEnabled(False)
2446 2453 self.specHeisGraphToolPath.setEnabled(False)
2447 2454
2448 2455 @pyqtSignature("int")
2449 2456 def on_specHeisGraphSaveRTIplot_stateChanged(self, p0):
2450 2457 if p0 == 2:
2451 2458 self.specHeisGraphPath.setEnabled(True)
2452 2459 self.specHeisGraphPrefix.setEnabled(True)
2453 2460 self.specHeisGraphToolPath.setEnabled(True)
2454 2461
2455 2462 @pyqtSignature("int")
2456 2463 def on_specHeisGraphftpSpectra_stateChanged(self, p0):
2457 2464 """
2458 2465 """
2459 2466 if p0 == 2:
2460 2467 self.specHeisGgraphftpratio.setEnabled(True)
2461 2468
2462 2469 if p0 == 0:
2463 2470 self.specHeisGgraphftpratio.setEnabled(False)
2464 2471
2465 2472 @pyqtSignature("int")
2466 2473 def on_specHeisGraphftpRTIplot_stateChanged(self, p0):
2467 2474 if p0 == 2:
2468 2475 self.specHeisGgraphftpratio.setEnabled(True)
2469 2476
2470 2477 @pyqtSignature("")
2471 2478 def on_specHeisGraphClear_clicked(self):
2472 2479 pass
2473 2480
2474 2481 def __checkSpecGraphSaving(self):
2475 2482
2476 2483 enable = False
2477 2484
2478 2485 if self.specGraphSaveSpectra.checkState():
2479 2486 enable = True
2480 2487
2481 2488 if self.specGraphSaveCross.checkState():
2482 2489 enable = True
2483 2490
2484 2491 if self.specGraphSaveRTIplot.checkState():
2485 2492 enable = True
2486 2493
2487 2494 if self.specGraphSaveCoherencemap.checkState():
2488 2495 enable = True
2489 2496
2490 2497 if self.specGraphSavePowerprofile.checkState():
2491 2498 enable = True
2492 2499
2493 2500 if self.specGraphSaveRTInoise.checkState():
2494 2501 enable = True
2495 2502
2496 2503 self.specGraphPath.setEnabled(enable)
2497 2504 self.specGraphPrefix.setEnabled(enable)
2498 2505 self.specGraphToolPath.setEnabled(enable)
2499 2506
2500 2507 self.specGgraphftpratio.setEnabled(enable)
2501 2508
2502 2509 def __checkSpecGraphFTP(self):
2503 2510
2504 2511 enable = False
2505 2512
2506 2513 if self.specGraphftpSpectra.checkState():
2507 2514 enable = True
2508 2515
2509 2516 if self.specGraphftpCross.checkState():
2510 2517 enable = True
2511 2518
2512 2519 if self.specGraphftpRTIplot.checkState():
2513 2520 enable = True
2514 2521
2515 2522 if self.specGraphftpCoherencemap.checkState():
2516 2523 enable = True
2517 2524
2518 2525 if self.specGraphftpPowerprofile.checkState():
2519 2526 enable = True
2520 2527
2521 2528 if self.specGraphftpRTInoise.checkState():
2522 2529 enable = True
2523 2530
2524 2531 # self.specGgraphftpratio.setEnabled(enable)
2525 2532
2526 2533 def __checkSpecGraphFilters(self):
2527 2534
2528 2535 freq = False
2529 2536 height = False
2530 2537 db = False
2531 2538 timerange = False
2532 2539 magnitud = False
2533 2540 phase = False
2534 2541 channelList = False
2535 2542
2536 2543 if self.specGraphCebSpectraplot.checkState():
2537 2544 freq = True
2538 2545 height = True
2539 2546 db = True
2540 2547 channelList = True
2541 2548
2542 2549 if self.specGraphCebCrossSpectraplot.checkState():
2543 2550 freq = True
2544 2551 height = True
2545 2552 db = True
2546 2553 magnitud = True
2547 2554 phase = True
2548 2555
2549 2556 if self.specGraphCebRTIplot.checkState():
2550 2557 height = True
2551 2558 db = True
2552 2559 timerange = True
2553 2560 channelList = True
2554 2561
2555 2562 if self.specGraphCebCoherencmap.checkState():
2556 2563 height = True
2557 2564 timerange = True
2558 2565 magnitud = True
2559 2566 phase = True
2560 2567
2561 2568 if self.specGraphPowerprofile.checkState():
2562 2569 height = True
2563 2570 db = True
2564 2571 channelList = True
2565 2572
2566 2573 if self.specGraphCebRTInoise.checkState():
2567 2574 db = True
2568 2575 timerange = True
2569 2576 channelList = True
2570 2577
2571 2578
2572 2579 self.specGgraphFreq.setEnabled(freq)
2573 2580 self.specGgraphHeight.setEnabled(height)
2574 2581 self.specGgraphDbsrange.setEnabled(db)
2575 2582 self.specGgraphTminTmax.setEnabled(timerange)
2576 2583
2577 2584 self.specGgraphmagnitud.setEnabled(magnitud)
2578 2585 self.specGgraphPhase.setEnabled(phase)
2579 2586 self.specGgraphChannelList.setEnabled(channelList)
2580 2587
2581 2588 def __getParmsFromProjectWindow(self):
2582 2589 """
2583 2590 Check Inputs Project:
2584 2591 - project_name
2585 2592 - datatype
2586 2593 - ext
2587 2594 - data_path
2588 2595 - readmode
2589 2596 - delay
2590 2597 - set
2591 2598 - walk
2592 2599 """
2593 2600 parms_ok = True
2594 2601
2595 2602 project_name = str(self.proName.text())
2596 2603
2597 2604 if project_name == '' or project_name == None:
2598 2605 outputstr = "Enter a project Name"
2599 2606 self.console.append(outputstr)
2600 2607 parms_ok = False
2601 2608 project_name = None
2602 2609
2603 2610 description = str(self.proDescription.toPlainText())
2604 2611
2605 2612 datatype = str(self.proComDataType.currentText())
2606 2613
2607 2614 ext = str(self.proDataType.text())
2608 2615
2609 2616 dpath = str(self.proDataPath.text())
2610 2617
2611 2618 if dpath == '':
2612 2619 outputstr = 'Datapath is empty'
2613 2620 self.console.append(outputstr)
2614 2621 parms_ok = False
2615 2622 dpath = None
2616 2623
2617 2624 if dpath != None:
2618 2625 if not os.path.isdir(dpath):
2619 2626 outputstr = 'Datapath (%s) does not exist' % dpath
2620 2627 self.console.append(outputstr)
2621 2628 parms_ok = False
2622 2629 dpath = None
2623 2630
2624 2631 online = int(self.proComReadMode.currentIndex())
2625 2632
2626 2633 delay = None
2627 2634 if online==1:
2628 2635 try:
2629 2636 delay = int(str(self.proDelay.text()))
2630 2637 except:
2631 2638 outputstr = 'Delay value (%s) must be a integer number' %str(self.proDelay.text())
2632 2639 self.console.append(outputstr)
2633 2640 parms_ok = False
2634 2641
2635 2642
2636 2643 set = None
2637 2644 value = str(self.proSet.text())
2638 2645 try:
2639 2646 set = int(value)
2640 2647 except:
2641 2648 pass
2642 2649
2643 2650 ippKm = None
2644 2651
2645 2652 value = str(self.proIPPKm.text())
2646 2653
2647 2654 try:
2648 2655 ippKm = float(value)
2649 2656 except:
2650 2657 if datatype=="USRP":
2651 2658 outputstr = 'IPP value "%s" must be a float number' % str(self.proIPPKm.text())
2652 2659 self.console.append(outputstr)
2653 2660 parms_ok = False
2654 2661
2655 2662 walk = int(self.proComWalk.currentIndex())
2656 2663 expLabel = str(self.proExpLabel.text())
2657 2664
2658 2665 startDate = str(self.proComStartDate.currentText()).strip()
2659 2666 endDate = str(self.proComEndDate.currentText()).strip()
2660 2667
2661 2668 if not startDate:
2662 2669 parms_ok = False
2663 2670
2664 2671 if not endDate:
2665 2672 parms_ok = False
2666 2673
2667 2674 # startDateList = startDate.split("/")
2668 2675 # endDateList = endDate.split("/")
2669 2676 #
2670 2677 # startDate = datetime.date(int(startDateList[0]), int(startDateList[1]), int(startDateList[2]))
2671 2678 # endDate = datetime.date(int(endDateList[0]), int(endDateList[1]), int(endDateList[2]))
2672 2679
2673 2680 startTime = self.proStartTime.time()
2674 2681 endTime = self.proEndTime.time()
2675 2682
2676 2683 startTime = str(startTime.toString("H:m:s"))
2677 2684 endTime = str(endTime.toString("H:m:s"))
2678 2685
2679 2686 projectParms = ProjectParms()
2680 2687
2681 2688 projectParms.name = project_name
2682 2689 projectParms.description = description
2683 2690 projectParms.datatype = datatype
2684 2691 projectParms.ext = ext
2685 2692 projectParms.dpath = dpath
2686 2693 projectParms.online = online
2687 2694 projectParms.startDate = startDate
2688 2695 projectParms.endDate = endDate
2689 2696 projectParms.startTime = startTime
2690 2697 projectParms.endTime = endTime
2691 2698 projectParms.delay = delay
2692 2699 projectParms.walk = walk
2693 2700 projectParms.expLabel = expLabel
2694 2701 projectParms.set = set
2695 2702 projectParms.ippKm = ippKm
2696 2703 projectParms.parmsOk = parms_ok
2697 2704
2698 2705 return projectParms
2699 2706
2700 2707
2701 2708 def __getParmsFromProjectObj(self, projectObjView):
2702 2709
2703 2710 parms_ok = True
2704 2711
2705 2712 project_name, description = projectObjView.name, projectObjView.description
2706 2713
2707 2714 readUnitObj = projectObjView.getReadUnitObj()
2708 2715 datatype = readUnitObj.datatype
2709 2716
2710 2717 operationObj = readUnitObj.getOperationObj(name='run')
2711 2718
2712 2719 dpath = operationObj.getParameterValue(parameterName='path')
2713 2720 startDate = operationObj.getParameterValue(parameterName='startDate')
2714 2721 endDate = operationObj.getParameterValue(parameterName='endDate')
2715 2722
2716 2723 startDate = startDate.strftime("%Y/%m/%d")
2717 2724 endDate = endDate.strftime("%Y/%m/%d")
2718 2725
2719 2726 startTime = operationObj.getParameterValue(parameterName='startTime')
2720 2727 endTime = operationObj.getParameterValue(parameterName='endTime')
2721 2728
2722 2729 startTime = startTime.strftime("%H:%M:%S")
2723 2730 endTime = endTime.strftime("%H:%M:%S")
2724 2731
2725 2732 online = 0
2726 2733 try:
2727 2734 online = operationObj.getParameterValue(parameterName='online')
2728 2735 except:
2729 2736 pass
2730 2737
2731 2738 delay = ''
2732 2739 try:
2733 2740 delay = operationObj.getParameterValue(parameterName='delay')
2734 2741 except:
2735 2742 pass
2736 2743
2737 2744 walk = 0
2738 2745 try:
2739 2746 walk = operationObj.getParameterValue(parameterName='walk')
2740 2747 except:
2741 2748 pass
2742 2749
2743 2750 set = ''
2744 2751 try:
2745 2752 set = operationObj.getParameterValue(parameterName='set')
2746 2753 except:
2747 2754 pass
2748 2755
2749 2756 expLabel = ''
2750 2757 try:
2751 2758 expLabel = operationObj.getParameterValue(parameterName='expLabel')
2752 2759 except:
2753 2760 pass
2754 2761
2755 2762 ippKm = ''
2756 2763 if datatype.lower() == 'usrp':
2757 2764 try:
2758 2765 ippKm = operationObj.getParameterValue(parameterName='ippKm')
2759 2766 except:
2760 2767 pass
2761 2768
2762 2769 projectParms = ProjectParms()
2763 2770
2764 2771 projectParms.name = project_name
2765 2772 projectParms.description = description
2766 2773 projectParms.datatype = datatype
2767 2774 projectParms.ext = None
2768 2775 projectParms.dpath = dpath
2769 2776 projectParms.online = online
2770 2777 projectParms.startDate = startDate
2771 2778 projectParms.endDate = endDate
2772 2779 projectParms.startTime = startTime
2773 2780 projectParms.endTime = endTime
2774 2781 projectParms.delay=delay
2775 2782 projectParms.walk=walk
2776 2783 projectParms.set=set
2777 2784 projectParms.ippKm=ippKm
2778 2785 projectParms.expLabel = expLabel
2779 2786 projectParms.parmsOk=parms_ok
2780 2787
2781 2788 return projectParms
2782 2789
2783 2790 def refreshProjectWindow(self, projectObjView):
2784 2791
2785 2792 self.proOk.setEnabled(False)
2786 2793
2787 2794 projectParms = self.__getParmsFromProjectObj(projectObjView)
2788 2795
2789 2796 index = projectParms.getDatatypeIndex()
2790 2797
2791 2798 self.proName.setText(projectParms.name)
2792 2799 self.proDescription.clear()
2793 2800 self.proDescription.append(projectParms.description)
2794 2801
2795 2802 self.on_proComDataType_activated(index=index)
2796 2803 self.proDataPath.setText(projectParms.dpath)
2797 2804 self.proComDataType.setCurrentIndex(index)
2798 2805 self.proComReadMode.setCurrentIndex(projectParms.online)
2799 2806 self.proDelay.setText(str(projectParms.delay))
2800 2807 self.proSet.setText(str(projectParms.set))
2801 2808 self.proIPPKm.setText(str(projectParms.ippKm))
2802 2809 self.proComWalk.setCurrentIndex(projectParms.walk)
2803 2810 self.proExpLabel.setText(str(projectParms.expLabel).strip())
2804 2811
2805 2812 self.on_proComReadMode_activated(projectParms.online)
2806 2813 self.on_proComWalk_activated(projectParms.walk)
2807 2814
2808 2815 dateList = self.loadDays(data_path = projectParms.dpath,
2809 2816 ext = projectParms.getExt(),
2810 2817 walk = projectParms.walk,
2811 2818 expLabel = projectParms.expLabel)
2812 2819
2813 2820 if not dateList:
2814 2821 return 0
2815 2822
2816 2823 try:
2817 2824 startDateIndex = dateList.index(projectParms.startDate)
2818 2825 except:
2819 2826 startDateIndex = 0
2820 2827
2821 2828 try:
2822 2829 endDateIndex = dateList.index(projectParms.endDate)
2823 2830 except:
2824 2831 endDateIndex = int(self.proComEndDate.count()-1)
2825 2832
2826 2833 self.proComStartDate.setCurrentIndex(startDateIndex)
2827 2834 self.proComEndDate.setCurrentIndex(endDateIndex)
2828 2835
2829 2836 startlist = projectParms.startTime.split(":")
2830 2837 endlist = projectParms.endTime.split(":")
2831 2838
2832 2839 self.time.setHMS(int(startlist[0]), int(startlist[1]), int(startlist[2]))
2833 2840 self.proStartTime.setTime(self.time)
2834 2841
2835 2842 self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
2836 2843 self.proEndTime.setTime(self.time)
2837 2844
2838 2845 self.proOk.setEnabled(True)
2839 2846
2840 2847 return 1
2841 2848
2842 2849 def __refreshVoltageWindow(self, puObj):
2843 2850
2844 2851 opObj = puObj.getOperationObj(name='setRadarFrequency')
2845 2852 if opObj == None:
2846 2853 self.volOpRadarfrequency.clear()
2847 2854 self.volOpCebRadarfrequency.setCheckState(0)
2848 2855 else:
2849 2856 value = opObj.getParameterValue(parameterName='frequency')
2850 2857 value = str(float(value)/1e6)
2851 2858 self.volOpRadarfrequency.setText(value)
2852 2859 self.volOpRadarfrequency.setEnabled(True)
2853 2860 self.volOpCebRadarfrequency.setCheckState(QtCore.Qt.Checked)
2854 2861
2855 2862 opObj = puObj.getOperationObj(name="selectChannels")
2856 2863
2857 2864 if opObj == None:
2858 2865 opObj = puObj.getOperationObj(name="selectChannelsByIndex")
2859 2866
2860 2867 if opObj == None:
2861 2868 self.volOpChannel.clear()
2862 2869 self.volOpCebChannels.setCheckState(0)
2863 2870 else:
2864 2871 channelEnabled = False
2865 2872 try:
2866 2873 value = opObj.getParameterValue(parameterName='channelList')
2867 2874 value = str(value)[1:-1]
2868 2875 channelEnabled = True
2869 2876 channelMode = 0
2870 2877 except:
2871 2878 pass
2872 2879 try:
2873 2880 value = opObj.getParameterValue(parameterName='channelIndexList')
2874 2881 value = str(value)[1:-1]
2875 2882 channelEnabled = True
2876 2883 channelMode = 1
2877 2884 except:
2878 2885 pass
2879 2886
2880 2887 if channelEnabled:
2881 2888 self.volOpChannel.setText(value)
2882 2889 self.volOpChannel.setEnabled(True)
2883 2890 self.volOpCebChannels.setCheckState(QtCore.Qt.Checked)
2884 2891 self.volOpComChannels.setCurrentIndex(channelMode)
2885 2892
2886 2893 opObj = puObj.getOperationObj(name="selectHeights")
2887 2894 if opObj == None:
2888 2895 self.volOpHeights.clear()
2889 2896 self.volOpCebHeights.setCheckState(0)
2890 2897 else:
2891 2898 value1 = str(opObj.getParameterValue(parameterName='minHei'))
2892 2899 value2 = str(opObj.getParameterValue(parameterName='maxHei'))
2893 2900 value = value1 + "," + value2
2894 2901 self.volOpHeights.setText(value)
2895 2902 self.volOpHeights.setEnabled(True)
2896 2903 self.volOpCebHeights.setCheckState(QtCore.Qt.Checked)
2897 2904
2898 2905 opObj = puObj.getOperationObj(name="filterByHeights")
2899 2906 if opObj == None:
2900 2907 self.volOpFilter.clear()
2901 2908 self.volOpCebFilter.setCheckState(0)
2902 2909 else:
2903 2910 value = opObj.getParameterValue(parameterName='window')
2904 2911 value = str(value)
2905 2912 self.volOpFilter.setText(value)
2906 2913 self.volOpFilter.setEnabled(True)
2907 2914 self.volOpCebFilter.setCheckState(QtCore.Qt.Checked)
2908 2915
2909 2916 opObj = puObj.getOperationObj(name="ProfileSelector")
2910 2917 if opObj == None:
2911 2918 self.volOpProfile.clear()
2912 2919 self.volOpCebProfile.setCheckState(0)
2913 2920 else:
2914 2921 for parmObj in opObj.getParameterObjList():
2915 2922
2916 2923 if parmObj.name == "profileList":
2917 2924 value = parmObj.getValue()
2918 2925 value = str(value)[1:-1]
2919 2926 self.volOpProfile.setText(value)
2920 2927 self.volOpProfile.setEnabled(True)
2921 2928 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
2922 2929 self.volOpComProfile.setCurrentIndex(0)
2923 2930
2924 2931 if parmObj.name == "profileRangeList":
2925 2932 value = parmObj.getValue()
2926 2933 value = str(value)[1:-1]
2927 2934 self.volOpProfile.setText(value)
2928 2935 self.volOpProfile.setEnabled(True)
2929 2936 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
2930 2937 self.volOpComProfile.setCurrentIndex(1)
2931 2938
2932 2939 if parmObj.name == "rangeList":
2933 2940 value = parmObj.getValue()
2934 2941 value = str(value)[1:-1]
2935 2942 self.volOpProfile.setText(value)
2936 2943 self.volOpProfile.setEnabled(True)
2937 2944 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
2938 2945 self.volOpComProfile.setCurrentIndex(2)
2939 2946
2940 2947 opObj = puObj.getOperationObj(name="Decoder")
2941 2948 self.volOpCode.setText("")
2942 2949 if opObj == None:
2943 2950 self.volOpCebDecodification.setCheckState(0)
2944 2951 else:
2945 2952 self.volOpCebDecodification.setCheckState(QtCore.Qt.Checked)
2946 2953
2947 2954 parmObj = opObj.getParameterObj('code')
2948 2955
2949 2956 if parmObj == None:
2950 2957 self.volOpComCode.setCurrentIndex(0)
2951 2958 else:
2952 2959
2953 2960 parmObj1 = opObj.getParameterObj('nCode')
2954 2961 parmObj2 = opObj.getParameterObj('nBaud')
2955 2962
2956 2963 if parmObj1 == None or parmObj2 == None:
2957 2964 self.volOpComCode.setCurrentIndex(0)
2958 2965 else:
2959 2966 code = ast.literal_eval(str(parmObj.getValue()))
2960 2967 nCode = parmObj1.getValue()
2961 2968 nBaud = parmObj2.getValue()
2962 2969
2963 2970 code = numpy.asarray(code).reshape((nCode, nBaud)).tolist()
2964 2971
2965 2972 #User defined by default
2966 2973 self.volOpComCode.setCurrentIndex(13)
2967 2974 self.volOpCode.setText(str(code))
2968 2975
2969 2976 if nCode == 1:
2970 2977 if nBaud == 3:
2971 2978 self.volOpComCode.setCurrentIndex(1)
2972 2979 if nBaud == 4:
2973 2980 self.volOpComCode.setCurrentIndex(2)
2974 2981 if nBaud == 5:
2975 2982 self.volOpComCode.setCurrentIndex(3)
2976 2983 if nBaud == 7:
2977 2984 self.volOpComCode.setCurrentIndex(4)
2978 2985 if nBaud == 11:
2979 2986 self.volOpComCode.setCurrentIndex(5)
2980 2987 if nBaud == 13:
2981 2988 self.volOpComCode.setCurrentIndex(6)
2982 2989
2983 2990 if nCode == 2:
2984 2991 if nBaud == 3:
2985 2992 self.volOpComCode.setCurrentIndex(7)
2986 2993 if nBaud == 4:
2987 2994 self.volOpComCode.setCurrentIndex(8)
2988 2995 if nBaud == 5:
2989 2996 self.volOpComCode.setCurrentIndex(9)
2990 2997 if nBaud == 7:
2991 2998 self.volOpComCode.setCurrentIndex(10)
2992 2999 if nBaud == 11:
2993 3000 self.volOpComCode.setCurrentIndex(11)
2994 3001 if nBaud == 13:
2995 3002 self.volOpComCode.setCurrentIndex(12)
2996 3003
2997 3004
2998 3005 opObj = puObj.getOperationObj(name="deFlip")
2999 3006 if opObj == None:
3000 3007 self.volOpFlip.clear()
3001 3008 self.volOpFlip.setEnabled(False)
3002 3009 self.volOpCebFlip.setCheckState(0)
3003 3010 else:
3004 3011 try:
3005 3012 value = opObj.getParameterValue(parameterName='channelList')
3006 3013 value = str(value)[1:-1]
3007 3014 except:
3008 3015 value = ""
3009 3016
3010 3017 self.volOpFlip.setText(value)
3011 3018 self.volOpFlip.setEnabled(True)
3012 3019 self.volOpCebFlip.setCheckState(QtCore.Qt.Checked)
3013 3020
3014 3021 opObj = puObj.getOperationObj(name="CohInt")
3015 3022 if opObj == None:
3016 3023 self.volOpCohInt.clear()
3017 3024 self.volOpCebCohInt.setCheckState(0)
3018 3025 else:
3019 3026 value = opObj.getParameterValue(parameterName='n')
3020 3027 self.volOpCohInt.setText(str(value))
3021 3028 self.volOpCohInt.setEnabled(True)
3022 3029 self.volOpCebCohInt.setCheckState(QtCore.Qt.Checked)
3023 3030
3024 3031 opObj = puObj.getOperationObj(name='Scope')
3025 3032 if opObj == None:
3026 3033 self.volGraphCebshow.setCheckState(0)
3027 3034 else:
3028 3035 self.volGraphCebshow.setCheckState(QtCore.Qt.Checked)
3029 3036
3030 3037 parmObj = opObj.getParameterObj(parameterName='channelList')
3031 3038
3032 3039 if parmObj == None:
3033 3040 self.volGraphChannelList.clear()
3034 3041 else:
3035 3042 value = parmObj.getValue()
3036 3043 value = str(value)
3037 3044 self.volGraphChannelList.setText(value)
3038 self.volOpProfile.setEnabled(True)
3045 # self.volOpChannel.setEnabled(True)
3039 3046
3040 parmObj1 = opObj.getParameterObj(parameterName='xmin')
3041 parmObj2 = opObj.getParameterObj(parameterName='xmax')
3047 parmObj1 = opObj.getParameterObj(parameterName='ymin')
3048 parmObj2 = opObj.getParameterObj(parameterName='ymax')
3042 3049
3043 3050 if parmObj1 == None or parmObj2 ==None:
3044 self.volGraphfreqrange.clear()
3051 self.volGraphIntensityRange.clear()
3045 3052 else:
3046 3053 value1 = parmObj1.getValue()
3047 3054 value1 = str(value1)
3048 3055 value2 = parmObj2.getValue()
3049 3056 value2 = str(value2)
3050 3057 value = value1 + "," + value2
3051 self.volGraphfreqrange.setText(value)
3058 self.volGraphIntensityRange.setText(value)
3052 3059
3053 parmObj1 = opObj.getParameterObj(parameterName='ymin')
3054 parmObj2 = opObj.getParameterObj(parameterName='ymax')
3060 parmObj1 = opObj.getParameterObj(parameterName='xmin')
3061 parmObj2 = opObj.getParameterObj(parameterName='xmax')
3055 3062
3056 3063 if parmObj1 == None or parmObj2 ==None:
3057 3064 self.volGraphHeightrange.clear()
3058 3065 else:
3059 3066 value1 = parmObj1.getValue()
3060 3067 value1 = str(value1)
3061 3068 value2 = parmObj2.getValue()
3062 3069 value2 = str(value2)
3063 3070 value = value1 + "," + value2
3064 3071 value2 = str(value2)
3065 3072 self.volGraphHeightrange.setText(value)
3066 3073
3074 parmObj = opObj.getParameterObj(parameterName='type')
3075
3076 if parmObj == None:
3077 self.volComScopeType.setCurrentIndex(0)
3078 else:
3079 value = parmObj.getValue()
3080 if value == "iq":
3081 self.volComScopeType.setCurrentIndex(0)
3082 if value == "power":
3083 self.volComScopeType.setCurrentIndex(1)
3084
3067 3085 parmObj = opObj.getParameterObj(parameterName='save')
3068 3086
3069 3087 if parmObj == None:
3070 3088 self.volGraphCebSave.setCheckState(QtCore.Qt.Unchecked)
3071 3089 else:
3072 3090 value = parmObj.getValue()
3073 3091 if value:
3074 3092 self.volGraphCebSave.setCheckState(QtCore.Qt.Checked)
3075 3093 else:
3076 3094 self.volGraphCebSave.setCheckState(QtCore.Qt.Unchecked)
3077 3095
3078 3096 parmObj = opObj.getParameterObj(parameterName='figpath')
3079 3097 if parmObj == None:
3080 3098 self.volGraphPath.clear()
3081 3099 else:
3082 3100 value = parmObj.getValue()
3083 3101 path = str(value)
3084 3102 self.volGraphPath.setText(path)
3085 3103
3086 3104 parmObj = opObj.getParameterObj(parameterName='figfile')
3087 3105 if parmObj == None:
3088 3106 self.volGraphPrefix.clear()
3089 3107 else:
3090 3108 value = parmObj.getValue()
3091 3109 figfile = str(value)
3092 3110 self.volGraphPrefix.setText(figfile)
3093 3111
3094 3112 # outputVoltageWrite
3095 3113 opObj = puObj.getOperationObj(name='VoltageWriter')
3096 3114
3097 3115 if opObj == None:
3098 3116 self.volOutputPath.clear()
3099 3117 self.volOutputblocksperfile.clear()
3100 3118 self.volOutputprofilesperblock.clear()
3101 3119 else:
3102 3120 parmObj = opObj.getParameterObj(parameterName='path')
3103 3121 if parmObj == None:
3104 3122 self.volOutputPath.clear()
3105 3123 else:
3106 3124 value = parmObj.getValue()
3107 3125 path = str(value)
3108 3126 self.volOutputPath.setText(path)
3109 3127
3110 3128 parmObj = opObj.getParameterObj(parameterName='blocksPerFile')
3111 3129 if parmObj == None:
3112 3130 self.volOutputblocksperfile.clear()
3113 3131 else:
3114 3132 value = parmObj.getValue()
3115 3133 blocksperfile = str(value)
3116 3134 self.volOutputblocksperfile.setText(blocksperfile)
3117 3135
3118 3136 parmObj = opObj.getParameterObj(parameterName='profilesPerBlock')
3119 3137 if parmObj == None:
3120 3138 self.volOutputprofilesperblock.clear()
3121 3139 else:
3122 3140 value = parmObj.getValue()
3123 3141 profilesPerBlock = str(value)
3124 3142 self.volOutputprofilesperblock.setText(profilesPerBlock)
3125 3143
3126 3144 return
3127 3145
3128 3146 def __refreshSpectraWindow(self, puObj):
3129 3147
3130 3148 inputId = puObj.getInputId()
3131 3149 inputPUObj = self.__puObjDict[inputId]
3132 3150
3133 3151 if inputPUObj.datatype == 'Voltage':
3134 3152 self.specOpnFFTpoints.setEnabled(True)
3135 3153 self.specOpProfiles.setEnabled(True)
3136 3154 self.specOpippFactor.setEnabled(True)
3137 3155 else:
3138 3156 self.specOpnFFTpoints.setEnabled(False)
3139 3157 self.specOpProfiles.setEnabled(False)
3140 3158 self.specOpippFactor.setEnabled(False)
3141 3159
3142 3160 opObj = puObj.getOperationObj(name='setRadarFrequency')
3143 3161 if opObj == None:
3144 3162 self.specOpRadarfrequency.clear()
3145 3163 self.specOpCebRadarfrequency.setCheckState(0)
3146 3164 else:
3147 3165 value = opObj.getParameterValue(parameterName='frequency')
3148 3166 value = str(float(value)/1e6)
3149 3167 self.specOpRadarfrequency.setText(value)
3150 3168 self.specOpRadarfrequency.setEnabled(True)
3151 3169 self.specOpCebRadarfrequency.setCheckState(QtCore.Qt.Checked)
3152 3170
3153 3171 opObj = puObj.getOperationObj(name="run")
3154 3172 if opObj == None:
3155 3173 self.specOpnFFTpoints.clear()
3156 3174 self.specOpProfiles.clear()
3157 3175 self.specOpippFactor.clear()
3158 3176 else:
3159 3177 parmObj = opObj.getParameterObj(parameterName='nFFTPoints')
3160 3178 if parmObj == None:
3161 3179 self.specOpnFFTpoints.clear()
3162 3180 else:
3163 3181 self.specOpnFFTpoints.setEnabled(True)
3164 3182 value = opObj.getParameterValue(parameterName='nFFTPoints')
3165 3183 self.specOpnFFTpoints.setText(str(value))
3166 3184
3167 3185 parmObj = opObj.getParameterObj(parameterName='nProfiles')
3168 3186 if parmObj == None:
3169 3187 self.specOpProfiles.clear()
3170 3188 else:
3171 3189 self.specOpProfiles.setEnabled(True)
3172 3190 value = opObj.getParameterValue(parameterName='nProfiles')
3173 3191 self.specOpProfiles.setText(str(value))
3174 3192
3175 3193 parmObj = opObj.getParameterObj(parameterName='ippFactor')
3176 3194 if parmObj == None:
3177 3195 self.specOpippFactor.clear()
3178 3196 else:
3179 3197 self.specOpippFactor.setEnabled(True)
3180 3198 value = opObj.getParameterValue(parameterName='ippFactor')
3181 3199 self.specOpippFactor.setText(str(value))
3182 3200
3183 3201 opObj = puObj.getOperationObj(name="run")
3184 3202 if opObj == None:
3185 3203 self.specOppairsList.clear()
3186 3204 self.specOpCebCrossSpectra.setCheckState(0)
3187 3205 else:
3188 3206 parmObj = opObj.getParameterObj(parameterName='pairsList')
3189 3207 if parmObj == None:
3190 3208 self.specOppairsList.clear()
3191 3209 self.specOpCebCrossSpectra.setCheckState(0)
3192 3210 else:
3193 3211 value = opObj.getParameterValue(parameterName='pairsList')
3194 3212 value = str(value)[1:-1]
3195 3213 self.specOppairsList.setText(str(value))
3196 3214 self.specOppairsList.setEnabled(True)
3197 3215 self.specOpCebCrossSpectra.setCheckState(QtCore.Qt.Checked)
3198 3216
3199 3217 opObj = puObj.getOperationObj(name="selectChannels")
3200 3218
3201 3219 if opObj == None:
3202 3220 opObj = puObj.getOperationObj(name="selectChannelsByIndex")
3203 3221
3204 3222 if opObj == None:
3205 3223 self.specOpChannel.clear()
3206 3224 self.specOpCebChannel.setCheckState(0)
3207 3225 else:
3208 3226 channelEnabled = False
3209 3227 try:
3210 3228 value = opObj.getParameterValue(parameterName='channelList')
3211 3229 value = str(value)[1:-1]
3212 3230 channelEnabled = True
3213 3231 channelMode = 0
3214 3232 except:
3215 3233 pass
3216 3234 try:
3217 3235 value = opObj.getParameterValue(parameterName='channelIndexList')
3218 3236 value = str(value)[1:-1]
3219 3237 channelEnabled = True
3220 3238 channelMode = 1
3221 3239 except:
3222 3240 pass
3223 3241
3224 3242 if channelEnabled:
3225 3243 self.specOpChannel.setText(value)
3226 3244 self.specOpChannel.setEnabled(True)
3227 3245 self.specOpCebChannel.setCheckState(QtCore.Qt.Checked)
3228 3246 self.specOpComChannel.setCurrentIndex(channelMode)
3229 3247
3230 3248 opObj = puObj.getOperationObj(name="selectHeights")
3231 3249 if opObj == None:
3232 3250 self.specOpHeights.clear()
3233 3251 self.specOpCebHeights.setCheckState(0)
3234 3252 else:
3235 3253 value1 = int(opObj.getParameterValue(parameterName='minHei'))
3236 3254 value1 = str(value1)
3237 3255 value2 = int(opObj.getParameterValue(parameterName='maxHei'))
3238 3256 value2 = str(value2)
3239 3257 value = value1 + "," + value2
3240 3258 self.specOpHeights.setText(value)
3241 3259 self.specOpHeights.setEnabled(True)
3242 3260 self.specOpCebHeights.setCheckState(QtCore.Qt.Checked)
3243 3261
3244 3262 opObj = puObj.getOperationObj(name="IncohInt")
3245 3263 if opObj == None:
3246 3264 self.specOpIncoherent.clear()
3247 3265 self.specOpCebIncoherent.setCheckState(0)
3248 3266 else:
3249 3267 for parmObj in opObj.getParameterObjList():
3250 3268 if parmObj.name == 'timeInterval':
3251 3269 value = opObj.getParameterValue(parameterName='timeInterval')
3252 3270 self.specOpIncoherent.setText(str(value))
3253 3271 self.specOpIncoherent.setEnabled(True)
3254 3272 self.specOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
3255 3273 self.specOpCobIncInt.setCurrentIndex(0)
3256 3274
3257 3275 if parmObj.name == 'n':
3258 3276 value = opObj.getParameterValue(parameterName='n')
3259 3277 self.specOpIncoherent.setText(str(value))
3260 3278 self.specOpIncoherent.setEnabled(True)
3261 3279 self.specOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
3262 3280 self.specOpCobIncInt.setCurrentIndex(1)
3263 3281
3264 3282 opObj = puObj.getOperationObj(name="removeDC")
3265 3283 if opObj == None:
3266 3284 self.specOpCebRemoveDC.setCheckState(0)
3267 3285 else:
3268 3286 self.specOpCebRemoveDC.setCheckState(QtCore.Qt.Checked)
3269 3287
3270 3288 parmObj = opObj.getParameterObj(parameterName='mode')
3271 3289
3272 3290 value = 1
3273 3291 if parmObj:
3274 3292 value = parmObj.getValue()
3275 3293
3276 3294 if value == 1:
3277 3295 self.specOpComRemoveDC.setCurrentIndex(0)
3278 3296 elif value == 2:
3279 3297 self.specOpComRemoveDC.setCurrentIndex(1)
3280 3298
3281 3299 opObj = puObj.getOperationObj(name="removeInterference")
3282 3300 if opObj == None:
3283 3301 self.specOpCebRemoveInt.setCheckState(0)
3284 3302 else:
3285 3303 self.specOpCebRemoveInt.setCheckState(QtCore.Qt.Checked)
3286 3304
3287 3305 opObj = puObj.getOperationObj(name='getNoise')
3288 3306 if opObj == None:
3289 3307 self.specOpCebgetNoise.setCheckState(0)
3290 3308 self.specOpgetNoise.clear()
3291 3309 else:
3292 3310 self.specOpCebgetNoise.setCheckState(QtCore.Qt.Checked)
3293 3311 parmObj = opObj.getParameterObj(parameterName='minHei')
3294 3312 if parmObj == None:
3295 3313 self.specOpgetNoise.clear()
3296 3314 value1 = None
3297 3315 else:
3298 3316 value1 = opObj.getParameterValue(parameterName='minHei')
3299 3317 value1 = str(value1)
3300 3318 parmObj = opObj.getParameterObj(parameterName='maxHei')
3301 3319 if parmObj == None:
3302 3320 value2 = None
3303 3321 value = value1
3304 3322 self.specOpgetNoise.setText(value)
3305 3323 self.specOpgetNoise.setEnabled(True)
3306 3324 else:
3307 3325 value2 = opObj.getParameterValue(parameterName='maxHei')
3308 3326 value2 = str(value2)
3309 3327 parmObj = opObj.getParameterObj(parameterName='minVel')
3310 3328 if parmObj == None:
3311 3329 value3 = None
3312 3330 value = value1 + "," + value2
3313 3331 self.specOpgetNoise.setText(value)
3314 3332 self.specOpgetNoise.setEnabled(True)
3315 3333 else:
3316 3334 value3 = opObj.getParameterValue(parameterName='minVel')
3317 3335 value3 = str(value3)
3318 3336 parmObj = opObj.getParameterObj(parameterName='maxVel')
3319 3337 if parmObj == None:
3320 3338 value4 = None
3321 3339 value = value1 + "," + value2 + "," + value3
3322 3340 self.specOpgetNoise.setText(value)
3323 3341 self.specOpgetNoise.setEnabled(True)
3324 3342 else:
3325 3343 value4 = opObj.getParameterValue(parameterName='maxVel')
3326 3344 value4 = str(value4)
3327 3345 value = value1 + "," + value2 + "," + value3 + ',' + value4
3328 3346 self.specOpgetNoise.setText(value)
3329 3347 self.specOpgetNoise.setEnabled(True)
3330 3348
3331 3349 self.specGraphPath.clear()
3332 3350 self.specGraphPrefix.clear()
3333 3351 self.specGgraphFreq.clear()
3334 3352 self.specGgraphHeight.clear()
3335 3353 self.specGgraphDbsrange.clear()
3336 3354 self.specGgraphmagnitud.clear()
3337 3355 self.specGgraphPhase.clear()
3338 3356 self.specGgraphChannelList.clear()
3339 3357 self.specGgraphTminTmax.clear()
3340 3358 self.specGgraphTimeRange.clear()
3341 3359 self.specGgraphftpratio.clear()
3342 3360
3343 3361 opObj = puObj.getOperationObj(name='SpectraPlot')
3344 3362
3345 3363 if opObj == None:
3346 3364 self.specGraphCebSpectraplot.setCheckState(0)
3347 3365 self.specGraphSaveSpectra.setCheckState(0)
3348 3366 self.specGraphftpSpectra.setCheckState(0)
3349 3367 else:
3350 3368 operationSpectraPlot = "Enable"
3351 3369 self.specGraphCebSpectraplot.setCheckState(QtCore.Qt.Checked)
3352 3370 parmObj = opObj.getParameterObj(parameterName='channelList')
3353 3371 if parmObj == None:
3354 3372 self.specGgraphChannelList.clear()
3355 3373 else:
3356 3374 value = opObj.getParameterValue(parameterName='channelList')
3357 3375 channelListSpectraPlot = str(value)[1:-1]
3358 3376 self.specGgraphChannelList.setText(channelListSpectraPlot)
3359 3377 self.specGgraphChannelList.setEnabled(True)
3360 3378
3361 3379 parmObj = opObj.getParameterObj(parameterName='xmin')
3362 3380 if parmObj == None:
3363 3381 self.specGgraphFreq.clear()
3364 3382 else:
3365 3383 value1 = opObj.getParameterValue(parameterName='xmin')
3366 3384 value1 = str(value1)
3367 3385 value2 = opObj.getParameterValue(parameterName='xmax')
3368 3386 value2 = str(value2)
3369 3387 value = value1 + "," + value2
3370 3388 self.specGgraphFreq.setText(value)
3371 3389 self.specGgraphFreq.setEnabled(True)
3372 3390
3373 3391 parmObj = opObj.getParameterObj(parameterName='ymin')
3374 3392 if parmObj == None:
3375 3393 self.specGgraphHeight.clear()
3376 3394 else:
3377 3395 value1 = opObj.getParameterValue(parameterName='ymin')
3378 3396 value1 = str(value1)
3379 3397 value2 = opObj.getParameterValue(parameterName='ymax')
3380 3398 value2 = str(value2)
3381 3399 value = value1 + "," + value2
3382 3400 self.specGgraphHeight.setText(value)
3383 3401 self.specGgraphHeight.setEnabled(True)
3384 3402
3385 3403 parmObj = opObj.getParameterObj(parameterName='zmin')
3386 3404 if parmObj == None:
3387 3405 self.specGgraphDbsrange.clear()
3388 3406 else:
3389 3407 value1 = opObj.getParameterValue(parameterName='zmin')
3390 3408 value1 = str(value1)
3391 3409 value2 = opObj.getParameterValue(parameterName='zmax')
3392 3410 value2 = str(value2)
3393 3411 value = value1 + "," + value2
3394 3412 self.specGgraphDbsrange.setText(value)
3395 3413 self.specGgraphDbsrange.setEnabled(True)
3396 3414
3397 3415 parmObj = opObj.getParameterObj(parameterName="save")
3398 3416 if parmObj == None:
3399 3417 self.specGraphSaveSpectra.setCheckState(0)
3400 3418 else:
3401 3419 self.specGraphSaveSpectra.setCheckState(QtCore.Qt.Checked)
3402 3420
3403 3421 parmObj = opObj.getParameterObj(parameterName="ftp")
3404 3422 if parmObj == None:
3405 3423 self.specGraphftpSpectra.setCheckState(0)
3406 3424 else:
3407 3425 self.specGraphftpSpectra.setCheckState(QtCore.Qt.Checked)
3408 3426
3409 3427 parmObj = opObj.getParameterObj(parameterName="figpath")
3410 3428 if parmObj:
3411 3429 value = parmObj.getValue()
3412 3430 self.specGraphPath.setText(value)
3413 3431
3414 3432 parmObj = opObj.getParameterObj(parameterName="wr_period")
3415 3433 if parmObj:
3416 3434 value = parmObj.getValue()
3417 3435 self.specGgraphftpratio.setText(str(value))
3418 3436
3419 3437 opObj = puObj.getOperationObj(name='CrossSpectraPlot')
3420 3438
3421 3439 if opObj == None:
3422 3440 self.specGraphCebCrossSpectraplot.setCheckState(0)
3423 3441 self.specGraphSaveCross.setCheckState(0)
3424 3442 self.specGraphftpCross.setCheckState(0)
3425 3443 else:
3426 3444 operationCrossSpectraPlot = "Enable"
3427 3445 self.specGraphCebCrossSpectraplot.setCheckState(QtCore.Qt.Checked)
3428 3446 parmObj = opObj.getParameterObj(parameterName='xmin')
3429 3447 if parmObj == None:
3430 3448 self.specGgraphFreq.clear()
3431 3449 else:
3432 3450 value1 = opObj.getParameterValue(parameterName='xmin')
3433 3451 value1 = str(value1)
3434 3452 value2 = opObj.getParameterValue(parameterName='xmax')
3435 3453 value2 = str(value2)
3436 3454 value = value1 + "," + value2
3437 3455 self.specGgraphFreq.setText(value)
3438 3456 self.specGgraphFreq.setEnabled(True)
3439 3457
3440 3458 parmObj = opObj.getParameterObj(parameterName='ymin')
3441 3459 if parmObj == None:
3442 3460 self.specGgraphHeight.clear()
3443 3461 else:
3444 3462 value1 = opObj.getParameterValue(parameterName='ymin')
3445 3463 value1 = str(value1)
3446 3464 value2 = opObj.getParameterValue(parameterName='ymax')
3447 3465 value2 = str(value2)
3448 3466 value = value1 + "," + value2
3449 3467 self.specGgraphHeight.setText(value)
3450 3468 self.specGgraphHeight.setEnabled(True)
3451 3469
3452 3470 parmObj = opObj.getParameterObj(parameterName='zmin')
3453 3471 if parmObj == None:
3454 3472 self.specGgraphDbsrange.clear()
3455 3473 else:
3456 3474 value1 = opObj.getParameterValue(parameterName='zmin')
3457 3475 value1 = str(value1)
3458 3476 value2 = opObj.getParameterValue(parameterName='zmax')
3459 3477 value2 = str(value2)
3460 3478 value = value1 + "," + value2
3461 3479 self.specGgraphDbsrange.setText(value)
3462 3480 self.specGgraphDbsrange.setEnabled(True)
3463 3481
3464 3482 parmObj = opObj.getParameterObj(parameterName='coh_min')
3465 3483 if parmObj == None:
3466 3484 self.specGgraphmagnitud.clear()
3467 3485 else:
3468 3486 value1 = opObj.getParameterValue(parameterName='coh_min')
3469 3487 value1 = str(value1)
3470 3488 value2 = opObj.getParameterValue(parameterName='coh_max')
3471 3489 value2 = str(value2)
3472 3490 value = value1 + "," + value2
3473 3491 self.specGgraphmagnitud.setText(value)
3474 3492 self.specGgraphmagnitud.setEnabled(True)
3475 3493
3476 3494 parmObj = opObj.getParameterObj(parameterName='phase_min')
3477 3495 if parmObj == None:
3478 3496 self.specGgraphPhase.clear()
3479 3497 else:
3480 3498 value1 = opObj.getParameterValue(parameterName='phase_min')
3481 3499 value1 = str(value1)
3482 3500 value2 = opObj.getParameterValue(parameterName='phase_max')
3483 3501 value2 = str(value2)
3484 3502 value = value1 + "," + value2
3485 3503 self.specGgraphPhase.setText(value)
3486 3504 self.specGgraphPhase.setEnabled(True)
3487 3505
3488 3506 parmObj = opObj.getParameterObj(parameterName="save")
3489 3507 if parmObj == None:
3490 3508 self.specGraphSaveCross.setCheckState(0)
3491 3509 else:
3492 3510 self.specGraphSaveCross.setCheckState(QtCore.Qt.Checked)
3493 3511
3494 3512 parmObj = opObj.getParameterObj(parameterName="ftp")
3495 3513 if parmObj == None:
3496 3514 self.specGraphftpCross.setCheckState(0)
3497 3515 else:
3498 3516 self.specGraphftpCross.setCheckState(QtCore.Qt.Checked)
3499 3517
3500 3518 parmObj = opObj.getParameterObj(parameterName="figpath")
3501 3519 if parmObj:
3502 3520 value = parmObj.getValue()
3503 3521 self.specGraphPath.setText(value)
3504 3522
3505 3523 parmObj = opObj.getParameterObj(parameterName="wr_period")
3506 3524 if parmObj:
3507 3525 value = parmObj.getValue()
3508 3526 self.specGgraphftpratio.setText(str(value))
3509 3527
3510 3528 opObj = puObj.getOperationObj(name='RTIPlot')
3511 3529
3512 3530 if opObj == None:
3513 3531 self.specGraphCebRTIplot.setCheckState(0)
3514 3532 self.specGraphSaveRTIplot.setCheckState(0)
3515 3533 self.specGraphftpRTIplot.setCheckState(0)
3516 3534 else:
3517 3535 self.specGraphCebRTIplot.setCheckState(QtCore.Qt.Checked)
3518 3536 parmObj = opObj.getParameterObj(parameterName='channelList')
3519 3537 if parmObj == None:
3520 3538 self.specGgraphChannelList.clear()
3521 3539 else:
3522 3540 value = opObj.getParameterValue(parameterName='channelList')
3523 3541 channelListRTIPlot = str(value)[1:-1]
3524 3542 self.specGgraphChannelList.setText(channelListRTIPlot)
3525 3543 self.specGgraphChannelList.setEnabled(True)
3526 3544
3527 3545 parmObj = opObj.getParameterObj(parameterName='xmin')
3528 3546 if parmObj == None:
3529 3547 self.specGgraphTminTmax.clear()
3530 3548 else:
3531 3549 value1 = opObj.getParameterValue(parameterName='xmin')
3532 3550 value1 = str(value1)
3533 3551 value2 = opObj.getParameterValue(parameterName='xmax')
3534 3552 value2 = str(value2)
3535 3553 value = value1 + "," + value2
3536 3554 self.specGgraphTminTmax.setText(value)
3537 3555 self.specGgraphTminTmax.setEnabled(True)
3538 3556
3539 3557 parmObj = opObj.getParameterObj(parameterName='timerange')
3540 3558 if parmObj == None:
3541 3559 self.specGgraphTimeRange.clear()
3542 3560 else:
3543 3561 value1 = opObj.getParameterValue(parameterName='timerange')
3544 3562 value1 = str(value1)
3545 3563 self.specGgraphTimeRange.setText(value1)
3546 3564 self.specGgraphTimeRange.setEnabled(True)
3547 3565
3548 3566 parmObj = opObj.getParameterObj(parameterName='ymin')
3549 3567 if parmObj == None:
3550 3568 self.specGgraphHeight.clear()
3551 3569 else:
3552 3570 value1 = opObj.getParameterValue(parameterName='ymin')
3553 3571 value1 = str(value1)
3554 3572 value2 = opObj.getParameterValue(parameterName='ymax')
3555 3573 value2 = str(value2)
3556 3574 value = value1 + "," + value2
3557 3575 self.specGgraphHeight.setText(value)
3558 3576 self.specGgraphHeight.setEnabled(True)
3559 3577
3560 3578 parmObj = opObj.getParameterObj(parameterName='zmin')
3561 3579 if parmObj == None:
3562 3580 self.specGgraphDbsrange.clear()
3563 3581 else:
3564 3582 value1 = opObj.getParameterValue(parameterName='zmin')
3565 3583 value1 = str(value1)
3566 3584 value2 = opObj.getParameterValue(parameterName='zmax')
3567 3585 value2 = str(value2)
3568 3586 value = value1 + "," + value2
3569 3587 self.specGgraphDbsrange.setText(value)
3570 3588 self.specGgraphDbsrange.setEnabled(True)
3571 3589
3572 3590 parmObj = opObj.getParameterObj(parameterName="save")
3573 3591 if parmObj == None:
3574 3592 self.specGraphSaveRTIplot.setCheckState(0)
3575 3593 else:
3576 3594 self.specGraphSaveRTIplot.setCheckState(QtCore.Qt.Checked)
3577 3595
3578 3596 parmObj = opObj.getParameterObj(parameterName="ftp")
3579 3597 if parmObj == None:
3580 3598 self.specGraphftpRTIplot.setCheckState(0)
3581 3599 else:
3582 3600 self.specGraphftpRTIplot.setCheckState(QtCore.Qt.Checked)
3583 3601
3584 3602 parmObj = opObj.getParameterObj(parameterName="figpath")
3585 3603 if parmObj:
3586 3604 value = parmObj.getValue()
3587 3605 self.specGraphPath.setText(value)
3588 3606
3589 3607 parmObj = opObj.getParameterObj(parameterName="wr_period")
3590 3608 if parmObj:
3591 3609 value = parmObj.getValue()
3592 3610 self.specGgraphftpratio.setText(str(value))
3593 3611
3594 3612 opObj = puObj.getOperationObj(name='CoherenceMap')
3595 3613
3596 3614 if opObj == None:
3597 3615 self.specGraphCebCoherencmap.setCheckState(0)
3598 3616 self.specGraphSaveCoherencemap.setCheckState(0)
3599 3617 self.specGraphftpCoherencemap.setCheckState(0)
3600 3618 else:
3601 3619 operationCoherenceMap = "Enable"
3602 3620 self.specGraphCebCoherencmap.setCheckState(QtCore.Qt.Checked)
3603 3621 parmObj = opObj.getParameterObj(parameterName='xmin')
3604 3622 if parmObj == None:
3605 3623 self.specGgraphTminTmax.clear()
3606 3624 else:
3607 3625 value1 = opObj.getParameterValue(parameterName='xmin')
3608 3626 value1 = str(value1)
3609 3627 value2 = opObj.getParameterValue(parameterName='xmax')
3610 3628 value2 = str(value2)
3611 3629 value = value1 + "," + value2
3612 3630 self.specGgraphTminTmax.setText(value)
3613 3631 self.specGgraphTminTmax.setEnabled(True)
3614 3632
3615 3633 parmObj = opObj.getParameterObj(parameterName='timerange')
3616 3634 if parmObj == None:
3617 3635 self.specGgraphTimeRange.clear()
3618 3636 else:
3619 3637 value1 = opObj.getParameterValue(parameterName='timerange')
3620 3638 value1 = str(value1)
3621 3639 self.specGgraphTimeRange.setText(value1)
3622 3640 self.specGgraphTimeRange.setEnabled(True)
3623 3641
3624 3642 parmObj = opObj.getParameterObj(parameterName='ymin')
3625 3643 if parmObj == None:
3626 3644 self.specGgraphHeight.clear()
3627 3645 else:
3628 3646 value1 = opObj.getParameterValue(parameterName='ymin')
3629 3647 value1 = str(value1)
3630 3648 value2 = opObj.getParameterValue(parameterName='ymax')
3631 3649 value2 = str(value2)
3632 3650 value = value1 + "," + value2
3633 3651 self.specGgraphHeight.setText(value)
3634 3652 self.specGgraphHeight.setEnabled(True)
3635 3653
3636 3654 parmObj = opObj.getParameterObj(parameterName='zmin')
3637 3655 if parmObj == None:
3638 3656 self.specGgraphmagnitud.clear()
3639 3657 else:
3640 3658 value1 = opObj.getParameterValue(parameterName='zmin')
3641 3659 value1 = str(value1)
3642 3660 value2 = opObj.getParameterValue(parameterName='zmax')
3643 3661 value2 = str(value2)
3644 3662 value = value1 + "," + value2
3645 3663 self.specGgraphmagnitud.setText(value)
3646 3664 self.specGgraphmagnitud.setEnabled(True)
3647 3665
3648 3666 parmObj = opObj.getParameterObj(parameterName='coh_min')
3649 3667 if parmObj == None:
3650 3668 self.specGgraphmagnitud.clear()
3651 3669 else:
3652 3670 value1 = opObj.getParameterValue(parameterName='coh_min')
3653 3671 value1 = str(value1)
3654 3672 value2 = opObj.getParameterValue(parameterName='coh_max')
3655 3673 value2 = str(value2)
3656 3674 value = value1 + "," + value2
3657 3675 self.specGgraphmagnitud.setText(value)
3658 3676 self.specGgraphmagnitud.setEnabled(True)
3659 3677
3660 3678 parmObj = opObj.getParameterObj(parameterName='phase_min')
3661 3679 if parmObj == None:
3662 3680 self.specGgraphPhase.clear()
3663 3681 else:
3664 3682 value1 = opObj.getParameterValue(parameterName='phase_min')
3665 3683 value1 = str(value1)
3666 3684 value2 = opObj.getParameterValue(parameterName='phase_max')
3667 3685 value2 = str(value2)
3668 3686 value = value1 + "," + value2
3669 3687 self.specGgraphPhase.setText(value)
3670 3688 self.specGgraphPhase.setEnabled(True)
3671 3689
3672 3690 parmObj = opObj.getParameterObj(parameterName="save")
3673 3691 if parmObj == None:
3674 3692 self.specGraphSaveCoherencemap.setCheckState(0)
3675 3693 else:
3676 3694 self.specGraphSaveCoherencemap.setCheckState(QtCore.Qt.Checked)
3677 3695
3678 3696 parmObj = opObj.getParameterObj(parameterName="ftp")
3679 3697 if parmObj == None:
3680 3698 self.specGraphftpCoherencemap.setCheckState(0)
3681 3699 else:
3682 3700 self.specGraphftpCoherencemap.setCheckState(QtCore.Qt.Checked)
3683 3701
3684 3702 parmObj = opObj.getParameterObj(parameterName="figpath")
3685 3703 if parmObj:
3686 3704 value = parmObj.getValue()
3687 3705 self.specGraphPath.setText(value)
3688 3706
3689 3707 parmObj = opObj.getParameterObj(parameterName="wr_period")
3690 3708 if parmObj:
3691 3709 value = parmObj.getValue()
3692 3710 self.specGgraphftpratio.setText(str(value))
3693 3711
3694 3712 opObj = puObj.getOperationObj(name='PowerProfilePlot')
3695 3713
3696 3714 if opObj == None:
3697 3715 self.specGraphPowerprofile.setCheckState(0)
3698 3716 self.specGraphSavePowerprofile.setCheckState(0)
3699 3717 self.specGraphftpPowerprofile.setCheckState(0)
3700 3718 operationPowerProfilePlot = "Disabled"
3701 3719 channelList = None
3702 3720 freq_vel = None
3703 3721 heightsrange = None
3704 3722 else:
3705 3723 operationPowerProfilePlot = "Enable"
3706 3724 self.specGraphPowerprofile.setCheckState(QtCore.Qt.Checked)
3707 3725 parmObj = opObj.getParameterObj(parameterName='xmin')
3708 3726 if parmObj == None:
3709 3727 self.specGgraphDbsrange.clear()
3710 3728 else:
3711 3729 value1 = opObj.getParameterValue(parameterName='xmin')
3712 3730 value1 = str(value1)
3713 3731 value2 = opObj.getParameterValue(parameterName='xmax')
3714 3732 value2 = str(value2)
3715 3733 value = value1 + "," + value2
3716 3734 self.specGgraphDbsrange.setText(value)
3717 3735 self.specGgraphDbsrange.setEnabled(True)
3718 3736
3719 3737 parmObj = opObj.getParameterObj(parameterName='ymin')
3720 3738 if parmObj == None:
3721 3739 self.specGgraphHeight.clear()
3722 3740 else:
3723 3741 value1 = opObj.getParameterValue(parameterName='ymin')
3724 3742 value1 = str(value1)
3725 3743 value2 = opObj.getParameterValue(parameterName='ymax')
3726 3744 value2 = str(value2)
3727 3745 value = value1 + "," + value2
3728 3746 self.specGgraphHeight.setText(value)
3729 3747 self.specGgraphHeight.setEnabled(True)
3730 3748
3731 3749 parmObj = opObj.getParameterObj(parameterName="save")
3732 3750 if parmObj == None:
3733 3751 self.specGraphSavePowerprofile.setCheckState(0)
3734 3752 else:
3735 3753 self.specGraphSavePowerprofile.setCheckState(QtCore.Qt.Checked)
3736 3754
3737 3755 parmObj = opObj.getParameterObj(parameterName="ftp")
3738 3756 if parmObj == None:
3739 3757 self.specGraphftpPowerprofile.setCheckState(0)
3740 3758 else:
3741 3759 self.specGraphftpPowerprofile.setCheckState(QtCore.Qt.Checked)
3742 3760
3743 3761 parmObj = opObj.getParameterObj(parameterName="figpath")
3744 3762 if parmObj:
3745 3763 value = parmObj.getValue()
3746 3764 self.specGraphPath.setText(value)
3747 3765
3748 3766 parmObj = opObj.getParameterObj(parameterName="wr_period")
3749 3767 if parmObj:
3750 3768 value = parmObj.getValue()
3751 3769 self.specGgraphftpratio.setText(str(value))
3752 3770
3753 3771 opObj = puObj.getOperationObj(name='Noise')
3754 3772
3755 3773 if opObj == None:
3756 3774 self.specGraphCebRTInoise.setCheckState(0)
3757 3775 self.specGraphSaveRTInoise.setCheckState(0)
3758 3776 self.specGraphftpRTInoise.setCheckState(0)
3759 3777 else:
3760 3778 self.specGraphCebRTInoise.setCheckState(QtCore.Qt.Checked)
3761 3779 parmObj = opObj.getParameterObj(parameterName='channelList')
3762 3780 if parmObj == None:
3763 3781 self.specGgraphChannelList.clear()
3764 3782 else:
3765 3783 value = opObj.getParameterValue(parameterName='channelList')
3766 3784 channelListRTINoise = str(value)[1:-1]
3767 3785 self.specGgraphChannelList.setText(channelListRTINoise)
3768 3786 self.specGgraphChannelList.setEnabled(True)
3769 3787
3770 3788 parmObj = opObj.getParameterObj(parameterName='xmin')
3771 3789 if parmObj == None:
3772 3790 self.specGgraphTminTmax.clear()
3773 3791 else:
3774 3792 value1 = opObj.getParameterValue(parameterName='xmin')
3775 3793 value1 = str(value1)
3776 3794 value2 = opObj.getParameterValue(parameterName='xmax')
3777 3795 value2 = str(value2)
3778 3796 value = value1 + "," + value2
3779 3797 self.specGgraphTminTmax.setText(value)
3780 3798 self.specGgraphTminTmax.setEnabled(True)
3781 3799
3782 3800 parmObj = opObj.getParameterObj(parameterName='timerange')
3783 3801 if parmObj == None:
3784 3802 self.specGgraphTimeRange.clear()
3785 3803 else:
3786 3804 value1 = opObj.getParameterValue(parameterName='timerange')
3787 3805 value1 = str(value1)
3788 3806 self.specGgraphTimeRange.setText(value1)
3789 3807 self.specGgraphTimeRange.setEnabled(True)
3790 3808
3791 3809
3792 3810 parmObj = opObj.getParameterObj(parameterName='ymin')
3793 3811 if parmObj == None:
3794 3812 self.specGgraphDbsrange.clear()
3795 3813 else:
3796 3814 value1 = opObj.getParameterValue(parameterName='ymin')
3797 3815 value1 = str(value1)
3798 3816 value2 = opObj.getParameterValue(parameterName='ymax')
3799 3817 value2 = str(value2)
3800 3818 value = value1 + "," + value2
3801 3819 self.specGgraphDbsrange.setText(value)
3802 3820 self.specGgraphDbsrange.setEnabled(True)
3803 3821
3804 3822 parmObj = opObj.getParameterObj(parameterName="save")
3805 3823 if parmObj == None:
3806 3824 self.specGraphSaveRTInoise.setCheckState(0)
3807 3825 else:
3808 3826 self.specGraphSaveRTInoise.setCheckState(QtCore.Qt.Checked)
3809 3827
3810 3828 parmObj = opObj.getParameterObj(parameterName="ftp")
3811 3829 if parmObj == None:
3812 3830 self.specGraphftpRTInoise.setCheckState(0)
3813 3831 else:
3814 3832 self.specGraphftpRTInoise.setCheckState(QtCore.Qt.Checked)
3815 3833
3816 3834 parmObj = opObj.getParameterObj(parameterName="figpath")
3817 3835 if parmObj:
3818 3836 value = parmObj.getValue()
3819 3837 self.specGraphPath.setText(value)
3820 3838
3821 3839 parmObj = opObj.getParameterObj(parameterName="wr_period")
3822 3840 if parmObj:
3823 3841 value = parmObj.getValue()
3824 3842 self.specGgraphftpratio.setText(str(value))
3825 3843
3826 3844 opObj = puObj.getOperationObj(name='SpectraWriter')
3827 3845 if opObj == None:
3828 3846 self.specOutputPath.clear()
3829 3847 self.specOutputblocksperfile.clear()
3830 3848 else:
3831 3849 value = opObj.getParameterObj(parameterName='path')
3832 3850 if value == None:
3833 3851 self.specOutputPath.clear()
3834 3852 else:
3835 3853 value = opObj.getParameterValue(parameterName='path')
3836 3854 path = str(value)
3837 3855 self.specOutputPath.setText(path)
3838 3856 value = opObj.getParameterObj(parameterName='blocksPerFile')
3839 3857 if value == None:
3840 3858 self.specOutputblocksperfile.clear()
3841 3859 else:
3842 3860 value = opObj.getParameterValue(parameterName='blocksPerFile')
3843 3861 blocksperfile = str(value)
3844 3862 self.specOutputblocksperfile.setText(blocksperfile)
3845 3863
3846 3864 return
3847 3865
3848 3866 def __refreshSpectraHeisWindow(self, puObj):
3849 3867
3850 3868 opObj = puObj.getOperationObj(name="IncohInt4SpectraHeis")
3851 3869 if opObj == None:
3852 3870 self.specHeisOpIncoherent.clear()
3853 3871 self.specHeisOpCebIncoherent.setCheckState(0)
3854 3872 else:
3855 3873 for parmObj in opObj.getParameterObjList():
3856 3874 if parmObj.name == 'timeInterval':
3857 3875 value = opObj.getParameterValue(parameterName='timeInterval')
3858 3876 self.specHeisOpIncoherent.setText(str(value))
3859 3877 self.specHeisOpIncoherent.setEnabled(True)
3860 3878 self.specHeisOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
3861 3879 self.specHeisOpCobIncInt.setCurrentIndex(0)
3862 3880
3863 3881 # SpectraHeis Graph
3864 3882
3865 3883 self.specHeisGgraphXminXmax.clear()
3866 3884 self.specHeisGgraphYminYmax.clear()
3867 3885
3868 3886 self.specHeisGgraphChannelList.clear()
3869 3887 self.specHeisGgraphTminTmax.clear()
3870 3888 self.specHeisGgraphTimeRange.clear()
3871 3889 self.specHeisGgraphftpratio.clear()
3872 3890
3873 3891 opObj = puObj.getOperationObj(name='SpectraHeisScope')
3874 3892 if opObj == None:
3875 3893 self.specHeisGraphCebSpectraplot.setCheckState(0)
3876 3894 self.specHeisGraphSaveSpectra.setCheckState(0)
3877 3895 self.specHeisGraphftpSpectra.setCheckState(0)
3878 3896 else:
3879 3897 operationSpectraHeisScope = "Enable"
3880 3898 self.specHeisGraphCebSpectraplot.setCheckState(QtCore.Qt.Checked)
3881 3899
3882 3900 parmObj = opObj.getParameterObj(parameterName='channelList')
3883 3901 if parmObj == None:
3884 3902 self.specHeisGgraphChannelList.clear()
3885 3903 else:
3886 3904 value = opObj.getParameterValue(parameterName='channelList')
3887 3905 channelListSpectraHeisScope = str(value)[1:-1]
3888 3906 self.specHeisGgraphChannelList.setText(channelListSpectraHeisScope)
3889 3907 self.specHeisGgraphChannelList.setEnabled(True)
3890 3908
3891 3909 parmObj = opObj.getParameterObj(parameterName='xmin')
3892 3910 if parmObj == None:
3893 3911 self.specHeisGgraphXminXmax.clear()
3894 3912 else:
3895 3913 value1 = opObj.getParameterValue(parameterName='xmin')
3896 3914 value1 = str(value1)
3897 3915 value2 = opObj.getParameterValue(parameterName='xmax')
3898 3916 value2 = str(value2)
3899 3917 value = value1 + "," + value2
3900 3918 self.specHeisGgraphXminXmax.setText(value)
3901 3919 self.specHeisGgraphXminXmax.setEnabled(True)
3902 3920
3903 3921 parmObj = opObj.getParameterObj(parameterName='ymin')
3904 3922 if parmObj == None:
3905 3923 self.specHeisGgraphYminYmax.clear()
3906 3924 else:
3907 3925 value1 = opObj.getParameterValue(parameterName='ymin')
3908 3926 value1 = str(value1)
3909 3927 value2 = opObj.getParameterValue(parameterName='ymax')
3910 3928 value2 = str(value2)
3911 3929 value = value1 + "," + value2
3912 3930 self.specHeisGgraphYminYmax.setText(value)
3913 3931 self.specHeisGgraphYminYmax.setEnabled(True)
3914 3932
3915 3933 parmObj = opObj.getParameterObj(parameterName="save")
3916 3934 if parmObj == None:
3917 3935 self.specHeisGraphSaveSpectra.setCheckState(0)
3918 3936 else:
3919 3937 self.specHeisGraphSaveSpectra.setCheckState(QtCore.Qt.Checked)
3920 3938
3921 3939 parmObj = opObj.getParameterObj(parameterName="ftp")
3922 3940 if parmObj == None:
3923 3941 self.specHeisGraphftpSpectra.setCheckState(0)
3924 3942 else:
3925 3943 self.specHeisGraphftpSpectra.setCheckState(QtCore.Qt.Checked)
3926 3944
3927 3945 parmObj = opObj.getParameterObj(parameterName="figpath")
3928 3946 if parmObj:
3929 3947 value = parmObj.getValue()
3930 3948 self.specHeisGraphPath.setText(value)
3931 3949
3932 3950 parmObj = opObj.getParameterObj(parameterName="wr_period")
3933 3951 if parmObj:
3934 3952 value = parmObj.getValue()
3935 3953 self.specHeisGgraphftpratio.setText(str(value))
3936 3954
3937 3955 opObj = puObj.getOperationObj(name='RTIfromSpectraHeis')
3938 3956
3939 3957 if opObj == None:
3940 3958 self.specHeisGraphCebRTIplot.setCheckState(0)
3941 3959 self.specHeisGraphSaveRTIplot.setCheckState(0)
3942 3960 self.specHeisGraphftpRTIplot.setCheckState(0)
3943 3961 else:
3944 3962 self.specHeisGraphCebRTIplot.setCheckState(QtCore.Qt.Checked)
3945 3963 parmObj = opObj.getParameterObj(parameterName='channelList')
3946 3964 if parmObj == None:
3947 3965 self.specHeisGgraphChannelList.clear()
3948 3966 else:
3949 3967 value = opObj.getParameterValue(parameterName='channelList')
3950 3968 channelListRTIPlot = str(value)[1:-1]
3951 3969 self.specGgraphChannelList.setText(channelListRTIPlot)
3952 3970 self.specGgraphChannelList.setEnabled(True)
3953 3971
3954 3972 parmObj = opObj.getParameterObj(parameterName='xmin')
3955 3973 if parmObj == None:
3956 3974 self.specHeisGgraphTminTmax.clear()
3957 3975 else:
3958 3976 value1 = opObj.getParameterValue(parameterName='xmin')
3959 3977 value1 = str(value1)
3960 3978 value2 = opObj.getParameterValue(parameterName='xmax')
3961 3979 value2 = str(value2)
3962 3980 value = value1 + "," + value2
3963 3981 self.specHeisGgraphTminTmax.setText(value)
3964 3982 self.specHeisGgraphTminTmax.setEnabled(True)
3965 3983
3966 3984 parmObj = opObj.getParameterObj(parameterName='timerange')
3967 3985 if parmObj == None:
3968 3986 self.specGgraphTimeRange.clear()
3969 3987 else:
3970 3988 value1 = opObj.getParameterValue(parameterName='timerange')
3971 3989 value1 = str(value1)
3972 3990 self.specHeisGgraphTimeRange.setText(value1)
3973 3991 self.specHeisGgraphTimeRange.setEnabled(True)
3974 3992
3975 3993 parmObj = opObj.getParameterObj(parameterName='ymin')
3976 3994 if parmObj == None:
3977 3995 self.specHeisGgraphYminYmax.clear()
3978 3996 else:
3979 3997 value1 = opObj.getParameterValue(parameterName='ymin')
3980 3998 value1 = str(value1)
3981 3999 value2 = opObj.getParameterValue(parameterName='ymax')
3982 4000 value2 = str(value2)
3983 4001 value = value1 + "," + value2
3984 4002 self.specHeisGgraphYminYmax.setText(value)
3985 4003 self.specHeisGgraphYminYmax.setEnabled(True)
3986 4004
3987 4005 parmObj = opObj.getParameterObj(parameterName="save")
3988 4006 if parmObj == None:
3989 4007 self.specHeisGraphSaveRTIplot.setCheckState(0)
3990 4008 else:
3991 4009 self.specHeisGraphSaveRTIplot.setCheckState(QtCore.Qt.Checked)
3992 4010
3993 4011 parmObj = opObj.getParameterObj(parameterName="ftp")
3994 4012 if parmObj == None:
3995 4013 self.specHeisGraphftpRTIplot.setCheckState(0)
3996 4014 else:
3997 4015 self.specHeisGraphftpRTIplot.setCheckState(QtCore.Qt.Checked)
3998 4016
3999 4017 parmObj = opObj.getParameterObj(parameterName="figpath")
4000 4018 if parmObj:
4001 4019 value = parmObj.getValue()
4002 4020 self.specHeisGraphPath.setText(value)
4003 4021
4004 4022 parmObj = opObj.getParameterObj(parameterName="wr_period")
4005 4023 if parmObj:
4006 4024 value = parmObj.getValue()
4007 4025 self.specHeisGgraphftpratio.setText(str(value))
4008 4026
4009 4027 # outputSpectraHeisWrite
4010 4028 opObj = puObj.getOperationObj(name='FitsWriter')
4011 4029 if opObj == None:
4012 4030 self.specHeisOutputPath.clear()
4013 4031 self.specHeisOutputblocksperfile.clear()
4014 4032 self.specHeisOutputMetada.clear()
4015 4033 else:
4016 4034 value = opObj.getParameterObj(parameterName='path')
4017 4035 if value == None:
4018 4036 self.specHeisOutputPath.clear()
4019 4037 else:
4020 4038 value = opObj.getParameterValue(parameterName='path')
4021 4039 path = str(value)
4022 4040 self.specHeisOutputPath.setText(path)
4023 4041 value = opObj.getParameterObj(parameterName='dataBlocksPerFile')
4024 4042 if value == None:
4025 4043 self.specHeisOutputblocksperfile.clear()
4026 4044 else:
4027 4045 value = opObj.getParameterValue(parameterName='dataBlocksPerFile')
4028 4046 blocksperfile = str(value)
4029 4047 self.specHeisOutputblocksperfile.setText(blocksperfile)
4030 4048 value = opObj.getParameterObj(parameterName='metadatafile')
4031 4049 if value == None:
4032 4050 self.specHeisOutputMetada.clear()
4033 4051 else:
4034 4052 value = opObj.getParameterValue(parameterName='metadatafile')
4035 4053 metadata_file = str(value)
4036 4054 self.specHeisOutputMetada.setText(metadata_file)
4037 4055
4038 4056 return
4039 4057
4040 4058 def __refreshCorrelationWindow(self, puObj):
4041 4059 pass
4042 4060
4043 4061 def refreshPUWindow(self, puObj):
4044 4062
4045 4063 if puObj.datatype == 'Voltage':
4046 4064 self.__refreshVoltageWindow(puObj)
4047 4065
4048 4066 if puObj.datatype == 'Spectra':
4049 4067 self.__refreshSpectraWindow(puObj)
4050 4068
4051 4069 if puObj.datatype == 'SpectraHeis':
4052 4070 self.__refreshSpectraHeisWindow(puObj)
4053 4071
4054 4072 def refreshProjectProperties(self, projectObjView):
4055 4073
4056 4074 propertyBuffObj = PropertyBuffer()
4057 4075 name = projectObjView.name
4058 4076
4059 4077 propertyBuffObj.append("Properties", "Name", projectObjView.name),
4060 4078 propertyBuffObj.append("Properties", "Description", projectObjView.description)
4061 4079 propertyBuffObj.append("Properties", "Workspace", self.pathWorkSpace)
4062 4080
4063 4081 readUnitObj = projectObjView.getReadUnitObj()
4064 4082 runOperationObj = readUnitObj.getOperationObj(name='run')
4065 4083
4066 4084 for thisParmObj in runOperationObj.getParameterObjList():
4067 4085 propertyBuffObj.append("Reading parms", thisParmObj.name, str(thisParmObj.getValue()))
4068 4086
4069 4087 propertiesModel = propertyBuffObj.getPropertyModel()
4070 4088
4071 4089 self.treeProjectProperties.setModel(propertiesModel)
4072 4090 self.treeProjectProperties.expandAll()
4073 4091 self.treeProjectProperties.resizeColumnToContents(0)
4074 4092 self.treeProjectProperties.resizeColumnToContents(1)
4075 4093
4076 4094 def refreshPUProperties(self, puObjView):
4077 4095
4078 4096 ############ FTP CONFIG ################################
4079 4097 #Deleting FTP Conf. This processing unit have not got any
4080 4098 #FTP configuration by default
4081 4099 if puObjView.id in self.__puLocalFolder2FTP.keys():
4082 4100 self.__puLocalFolder2FTP.pop(puObjView.id)
4083 4101 ########################################################
4084 4102
4085 4103 propertyBuffObj = PropertyBuffer()
4086 4104
4087 4105 for thisOp in puObjView.getOperationObjList():
4088 4106
4089 4107 operationName = thisOp.name
4090 4108
4091 4109 if operationName == 'run':
4092 4110 operationName = 'Properties'
4093 4111
4094 4112 else:
4095 4113 if not thisOp.getParameterObjList():
4096 4114 propertyBuffObj.append(operationName, '--', '--')
4097 4115 continue
4098 4116
4099 4117 for thisParmObj in thisOp.getParameterObjList():
4100 4118 propertyBuffObj.append(operationName, thisParmObj.name, str(thisParmObj.getValue()))
4101 4119
4102 4120 ############ FTP CONFIG ################################
4103 4121 if thisParmObj.name == "ftp_wei" and thisParmObj.getValue():
4104 4122 value = thisParmObj.getValue()
4105 4123 self.temporalFTP.ftp_wei = value
4106 4124
4107 4125 if thisParmObj.name == "exp_code" and thisParmObj.getValue():
4108 4126 value = thisParmObj.getValue()
4109 4127 self.temporalFTP.exp_code = value
4110 4128
4111 4129 if thisParmObj.name == "sub_exp_code" and thisParmObj.getValue():
4112 4130 value = thisParmObj.getValue()
4113 4131 self.temporalFTP.sub_exp_code = value
4114 4132
4115 4133 if thisParmObj.name == "plot_pos" and thisParmObj.getValue():
4116 4134 value = thisParmObj.getValue()
4117 4135 self.temporalFTP.plot_pos = value
4118 4136
4119 4137 if thisParmObj.name == 'ftp' and thisParmObj.getValue():
4120 4138 figpathObj = thisOp.getParameterObj('figpath')
4121 4139 if figpathObj:
4122 4140 self.__puLocalFolder2FTP[puObjView.id] = figpathObj.getValue()
4123 4141
4124 4142 ########################################################
4125 4143
4126 4144 propertiesModel = propertyBuffObj.getPropertyModel()
4127 4145
4128 4146 self.treeProjectProperties.setModel(propertiesModel)
4129 4147 self.treeProjectProperties.expandAll()
4130 4148 self.treeProjectProperties.resizeColumnToContents(0)
4131 4149 self.treeProjectProperties.resizeColumnToContents(1)
4132 4150
4133 4151 def refreshGraphicsId(self):
4134 4152
4135 4153 projectObj = self.getSelectedProjectObj()
4136 4154
4137 4155 if not projectObj:
4138 4156 return
4139 4157
4140 4158 for idPU, puObj in projectObj.procUnitConfObjDict.items():
4141 4159
4142 4160 for opObj in puObj.getOperationObjList():
4143 4161
4144 4162 if opObj.name not in ('Scope', 'SpectraPlot', 'CrossSpectraPlot', 'RTIPlot', 'CoherenceMap', 'PowerProfilePlot', 'Noise', 'SpectraHeisScope', 'RTIfromSpectraHeis'):
4145 4163 continue
4146 4164
4147 4165 opObj.changeParameter(name='id', value=opObj.id, format='int')
4148 4166
4149 4167 def on_click(self, index):
4150 4168
4151 4169 self._disable_save_button()
4152 4170 self._disable_play_button()
4153 4171
4154 4172 self.console.clear()
4155 4173
4156 4174 self.selectedItemTree = self.projectExplorerModel.itemFromIndex(index)
4157 4175
4158 4176 projectObjView = self.getSelectedProjectObj()
4159 4177
4160 4178 if not projectObjView:
4161 4179 return
4162 4180
4163 4181 self.create = False
4164 4182 selectedObjView = self.getSelectedItemObj()
4165 4183
4166 4184 self.refreshProjectWindow(projectObjView)
4167 4185 self.refreshProjectProperties(projectObjView)
4168 4186
4169 4187 #A project has been selected
4170 4188 if projectObjView == selectedObjView:
4171 4189
4172 4190 self.tabProject.setEnabled(True)
4173 4191 self.tabVoltage.setEnabled(False)
4174 4192 self.tabSpectra.setEnabled(False)
4175 4193 self.tabCorrelation.setEnabled(False)
4176 4194 self.tabSpectraHeis.setEnabled(False)
4177 4195 self.tabWidgetProject.setCurrentWidget(self.tabProject)
4178 4196
4179 4197 if self.dateList:
4180 4198 self._enable_save_button()
4181 4199 self._enable_play_button()
4182 4200
4183 4201 return
4184 4202
4185 4203 #A processing unit has been selected
4186 4204 voltEnable = False
4187 4205 specEnable = False
4188 4206 corrEnable = False
4189 4207 specHeisEnable = False
4190 4208 tabSelected = self.tabProject
4191 4209
4192 4210 puObj = selectedObjView
4193 4211
4194 4212 self.refreshPUWindow(puObj)
4195 4213 self.refreshPUProperties(puObj)
4196 4214 self.showtabPUCreated(puObj.datatype)
4197 4215
4198 4216 if self.dateList:
4199 4217 self._enable_save_button()
4200 4218 self._enable_play_button()
4201 4219
4202 4220 def on_right_click(self, pos):
4203 4221
4204 4222 self.menu = QtGui.QMenu()
4205 4223 quitAction0 = self.menu.addAction("Create a New Project")
4206 4224 quitAction1 = self.menu.addAction("Create a New Processing Unit")
4207 4225 quitAction2 = self.menu.addAction("Delete Item")
4208 4226 quitAction3 = self.menu.addAction("Quit")
4209 4227
4210 4228 if len(self.__itemTreeDict) == 0:
4211 4229 quitAction2.setEnabled(False)
4212 4230 else:
4213 4231 quitAction2.setEnabled(True)
4214 4232
4215 4233 action = self.menu.exec_(self.mapToGlobal(pos))
4216 4234
4217 4235 if action == quitAction0:
4218 4236 self. setInputsProject_View()
4219 4237 self.create = True
4220 4238
4221 4239 if action == quitAction1:
4222 4240 if len(self.__projectObjDict) == 0:
4223 4241 outputstr = "You need to create a Project before adding a Processing Unit"
4224 4242 self.console.clear()
4225 4243 self.console.append(outputstr)
4226 4244 return 0
4227 4245 else:
4228 4246 self.addPUWindow()
4229 4247 self.console.clear()
4230 4248 self.console.append("Please, Choose the type of Processing Unit")
4231 4249 # self.console.append("If your Datatype is rawdata, you will start with processing unit Type Voltage")
4232 4250 # self.console.append("If your Datatype is pdata, you will choose between processing unit Type Spectra or Correlation")
4233 4251 # self.console.append("If your Datatype is fits, you will start with processing unit Type SpectraHeis")
4234 4252
4235 4253 if action == quitAction2:
4236 4254 index = self.selectedItemTree
4237 4255 try:
4238 4256 index.parent()
4239 4257 except:
4240 4258 self.console.append('Please, first at all select a Project or Processing Unit')
4241 4259 return 0
4242 4260 # print index.parent(),index
4243 4261 if index.parent() == None:
4244 4262 self.projectExplorerModel.removeRow(index.row())
4245 4263 else:
4246 4264 index.parent().removeRow(index.row())
4247 4265 self.removeItemTreeFromProject()
4248 4266 self.console.clear()
4249 4267 # for i in self.projectExplorerTree.selectionModel().selection().indexes():
4250 4268 # print i.row()
4251 4269
4252 4270 if action == quitAction3:
4253 4271 self.close()
4254 4272 return 0
4255 4273
4256 4274 def createProjectView(self, id):
4257 4275
4258 4276 # project_name, description, datatype, data_path, starDate, endDate, startTime, endTime, online, delay, walk, set = self.getParmsFromProjectWindow()
4259 4277 id = str(id)
4260 4278 projectParms = self.__getParmsFromProjectWindow()
4261 4279
4262 4280 if not projectParms.isValid():
4263 4281 return None
4264 4282
4265 4283 projectObjView = Project()
4266 4284 projectObjView.setup(id=id, name=projectParms.name, description=projectParms.description)
4267 4285
4268 4286 self.__projectObjDict[id] = projectObjView
4269 4287 self.addProject2ProjectExplorer(id=id, name=projectObjView.name)
4270 4288
4271 4289 return projectObjView
4272 4290
4273 4291 def updateProjectView(self):
4274 4292
4275 4293 # project_name, description, datatype, data_path, starDate, endDate, startTime, endTime, online, delay, walk, set = self.getParmsFromProjectWindow()
4276 4294
4277 4295 projectParms = self.__getParmsFromProjectWindow()
4278 4296
4279 4297 if not projectParms.isValid():
4280 4298 return None
4281 4299
4282 4300 projectObjView = self.getSelectedProjectObj()
4283 4301
4284 4302 if not projectObjView:
4285 4303 self.console.append("Please select a project before update it")
4286 4304 return None
4287 4305
4288 4306 projectObjView.update(name=projectParms.name, description=projectParms.description)
4289 4307
4290 4308 return projectObjView
4291 4309
4292 4310 def createReadUnitView(self, projectObjView, idReadUnit=None):
4293 4311
4294 4312 projectParms = self.__getParmsFromProjectWindow()
4295 4313
4296 4314 if not projectParms.isValid():
4297 4315 return None
4298 4316
4299 4317 if projectParms.datatype in ("Voltage", "Spectra", "Fits"):
4300 4318 readUnitConfObj = projectObjView.addReadUnit(id=idReadUnit,
4301 4319 datatype=projectParms.datatype,
4302 4320 path=projectParms.dpath,
4303 4321 startDate=projectParms.startDate,
4304 4322 endDate=projectParms.endDate,
4305 4323 startTime=projectParms.startTime,
4306 4324 endTime=projectParms.endTime,
4307 4325 online=projectParms.online,
4308 4326 walk=projectParms.walk
4309 4327 )
4310 4328
4311 4329 if projectParms.set:
4312 4330 readUnitConfObj.addParameter(name="set", value=projectParms.set, format="int")
4313 4331
4314 4332 if projectParms.delay:
4315 4333 readUnitConfObj.addParameter(name="delay", value=projectParms.delay, format="int")
4316 4334
4317 4335 if projectParms.expLabel:
4318 4336 readUnitConfObj.addParameter(name="expLabel", value=projectParms.expLabel)
4319 4337
4320 4338 readUnitConfObj.addOperation(name="printInfo")
4321 4339
4322 4340 if projectParms.datatype == "USRP":
4323 4341 readUnitConfObj = projectObjView.addReadUnit(id=idReadUnit,
4324 4342 datatype=projectParms.datatype,
4325 4343 path=projectParms.dpath,
4326 4344 startDate=projectParms.startDate,
4327 4345 endDate=projectParms.endDate,
4328 4346 startTime=projectParms.startTime,
4329 4347 endTime=projectParms.endTime,
4330 4348 online=projectParms.online,
4331 4349 ippKm=projectParms.ippKm
4332 4350 )
4333 4351
4334 4352 if projectParms.delay:
4335 4353 readUnitConfObj.addParameter(name="delay", value=projectParms.delay, format="int")
4336 4354
4337 4355 return readUnitConfObj
4338 4356
4339 4357 def updateReadUnitView(self, projectObjView, idReadUnit):
4340 4358
4341 4359 projectObjView.removeProcUnit(idReadUnit)
4342 4360
4343 4361 readUnitConfObj = self.createReadUnitView(projectObjView, idReadUnit)
4344 4362
4345 4363 return readUnitConfObj
4346 4364
4347 4365 def createProcUnitView(self, projectObjView, datatype, inputId):
4348 4366
4349 4367 procUnitConfObj = projectObjView.addProcUnit(datatype=datatype, inputId=inputId)
4350 4368
4351 4369 self.__puObjDict[procUnitConfObj.getId()] = procUnitConfObj
4352 4370
4353 4371 return procUnitConfObj
4354 4372
4355 4373 def updateProcUnitView(self, id):
4356 4374
4357 4375 pass
4358 4376
4359 4377 def addPUWindow(self):
4360 4378
4361 4379 self.configUPWindowObj = UnitProcessWindow(self)
4362 4380 fatherObj = self.getSelectedItemObj()
4363 4381 try:
4364 4382 fatherObj.getElementName()
4365 4383 except:
4366 4384 self.console.append("First left click on Project or Processing Unit")
4367 4385 return 0
4368 4386
4369 4387 if fatherObj.getElementName() == 'Project':
4370 4388 readUnitConfObj = fatherObj.getReadUnitObj()
4371 4389 self.configUPWindowObj.dataTypeProject = str(readUnitConfObj.datatype)
4372 4390
4373 4391 self.configUPWindowObj.getfromWindowList.append(fatherObj)
4374 4392 self.configUPWindowObj.loadTotalList()
4375 4393 self.configUPWindowObj.show()
4376 4394 self.configUPWindowObj.closed.connect(self.createPUWindow)
4377 4395
4378 4396 def createPUWindow(self):
4379 4397
4380 4398 if not self.configUPWindowObj.create:
4381 4399 return
4382 4400
4383 4401 fatherObj = self.configUPWindowObj.getFromWindow
4384 4402 datatype = self.configUPWindowObj.typeofUP
4385 4403
4386 4404 if fatherObj.getElementName() == 'Project':
4387 4405 inputId = fatherObj.getReadUnitId()
4388 4406 projectObjView = fatherObj
4389 4407 else:
4390 4408 inputId = fatherObj.getId()
4391 4409 projectObjView = self.getSelectedProjectObj()
4392 4410
4393 4411 if not projectObjView:
4394 4412 return
4395 4413
4396 4414 puObj = self.createProcUnitView(projectObjView, datatype, inputId)
4397 4415
4398 4416 self.addPU2ProjectExplorer(puObj)
4399 4417
4400 4418 self.showtabPUCreated(datatype)
4401 4419
4402 4420 self.clearPUWindow(datatype)
4403 4421
4404 4422 self.showPUinitView()
4405 4423
4406 4424 def addFTPConf2Operation(self, puObj, opObj):
4407 4425
4408 4426 if not self.temporalFTP.create:
4409 4427 self.temporalFTP.setwithoutconfiguration()
4410 4428
4411 4429 # opObj.addParameter(name='server', value=self.temporalFTP.server, format='str')
4412 4430 # opObj.addParameter(name='remotefolder', value=self.temporalFTP.remotefolder, format='str')
4413 4431 # opObj.addParameter(name='username', value=self.temporalFTP.username, format='str')
4414 4432 # opObj.addParameter(name='password', value=self.temporalFTP.password, format='str')
4415 4433
4416 4434 if self.temporalFTP.ftp_wei:
4417 4435 opObj.addParameter(name='ftp_wei', value=int(self.temporalFTP.ftp_wei), format='int')
4418 4436 if self.temporalFTP.exp_code:
4419 4437 opObj.addParameter(name='exp_code', value=int(self.temporalFTP.exp_code), format='int')
4420 4438 if self.temporalFTP.sub_exp_code:
4421 4439 opObj.addParameter(name='sub_exp_code', value=int(self.temporalFTP.sub_exp_code), format='int')
4422 4440 if self.temporalFTP.plot_pos:
4423 4441 opObj.addParameter(name='plot_pos', value=int(self.temporalFTP.plot_pos), format='int')
4424 4442
4425 4443 # def __checkFTPProcUnit(self, projectObj, localfolder):
4426 4444 #
4427 4445 # puId = None
4428 4446 # puObj = None
4429 4447 #
4430 4448 # for thisPuId, thisPuObj in projectObj.procUnitItems():
4431 4449 #
4432 4450 # if not thisPuObj.name == "SendToServer":
4433 4451 # continue
4434 4452 #
4435 4453 # opObj = thisPuObj.getOperationObj(name='run')
4436 4454 #
4437 4455 # parmObj = opObj.getParameterObj('localfolder')
4438 4456 #
4439 4457 # #localfolder parameter should always be set, if it is not set then ProcUnit should be removed
4440 4458 # if not parmObj:
4441 4459 # projectObj.removeProcUnit(thisPuId)
4442 4460 # continue
4443 4461 #
4444 4462 # thisLocalfolder = parmObj.getValue()
4445 4463 #
4446 4464 # if localfolder != thisLocalfolder:
4447 4465 # continue
4448 4466 #
4449 4467 # puId = thisPuId
4450 4468 # puObj = thisPuObj
4451 4469 # break
4452 4470 #
4453 4471 # return puObj
4454 4472
4455 4473 def createFTPProcUnitView(self):
4456 4474
4457 4475 if not self.temporalFTP.create:
4458 4476 self.temporalFTP.setwithoutconfiguration()
4459 4477
4460 4478 projectObj = self.getSelectedProjectObj()
4461 4479
4462 4480 if not projectObj:
4463 4481 return
4464 4482
4465 4483 self.removeAllFTPProcUnitView(projectObj)
4466 4484
4467 4485 if not self.__puLocalFolder2FTP:
4468 4486 return
4469 4487
4470 4488 folderList = ",".join(self.__puLocalFolder2FTP.values())
4471 4489
4472 4490 procUnitConfObj = projectObj.addProcUnit(name="SendToServer")
4473 4491
4474 4492 procUnitConfObj.addParameter(name='server', value=self.temporalFTP.server, format='str')
4475 4493 procUnitConfObj.addParameter(name='username', value=self.temporalFTP.username, format='str')
4476 4494 procUnitConfObj.addParameter(name='password', value=self.temporalFTP.password, format='str')
4477 4495 procUnitConfObj.addParameter(name='localfolder', value=folderList, format='list')
4478 4496 procUnitConfObj.addParameter(name='remotefolder', value=self.temporalFTP.remotefolder, format='str')
4479 4497 procUnitConfObj.addParameter(name='ext', value=self.temporalFTP.extension, format='str')
4480 4498 procUnitConfObj.addParameter(name='period', value=self.temporalFTP.period, format='int')
4481 4499 procUnitConfObj.addParameter(name='protocol', value=self.temporalFTP.protocol, format='str')
4482 4500
4483 4501 procUnitConfObj.addParameter(name='ftp_wei', value=self.temporalFTP.ftp_wei, format='int')
4484 4502 procUnitConfObj.addParameter(name='exp_code', value=self.temporalFTP.exp_code, format='int')
4485 4503 procUnitConfObj.addParameter(name='sub_exp_code', value=self.temporalFTP.sub_exp_code, format='int')
4486 4504 procUnitConfObj.addParameter(name='plot_pos', value=self.temporalFTP.plot_pos, format='int')
4487 4505
4488 4506 self.__puObjDict[procUnitConfObj.getId()] = procUnitConfObj
4489 4507
4490 4508 def removeAllFTPProcUnitView(self, projectObj):
4491 4509
4492 4510 for thisPuId, thisPuObj in projectObj.procUnitItems():
4493 4511
4494 4512 if not thisPuObj.name == "SendToServer":
4495 4513 continue
4496 4514
4497 4515 projectObj.removeProcUnit(thisPuId)
4498 4516
4499 4517 if thisPuId not in self.__puObjDict.keys():
4500 4518 continue
4501 4519
4502 4520 self.__puObjDict.pop(thisPuId)
4503 4521
4504 4522 def showPUinitView(self):
4505 4523
4506 4524 self.propertiesModel = TreeModel()
4507 4525 self.propertiesModel.initPUVoltageView()
4508 4526 self.treeProjectProperties.setModel(self.propertiesModel)
4509 4527 self.treeProjectProperties.expandAll()
4510 4528 self.treeProjectProperties.allColumnsShowFocus()
4511 4529 self.treeProjectProperties.resizeColumnToContents(1)
4512 4530
4513 4531 def saveFTPFromOpObj(self, operationObj):
4514 4532
4515 4533 if operationObj.name != "SendByFTP":
4516 4534 return
4517 4535
4518 4536 server = operationObj.getParameterValue("server")
4519 4537 username = operationObj.getParameterValue("username")
4520 4538 password = operationObj.getParameterValue("password")
4521 4539 localfolder = operationObj.getParameterValue("localfolder")
4522 4540 remotefolder = operationObj.getParameterValue("remotefolder")
4523 4541 ext = operationObj.getParameterValue("ext")
4524 4542 period = operationObj.getParameterValue("period")
4525 4543
4526 4544 self.temporalFTP.save(server=server,
4527 4545 remotefolder=remotefolder,
4528 4546 username=username,
4529 4547 password=password,
4530 4548 localfolder=localfolder,
4531 4549 extension=ext)
4532 4550
4533 4551 return
4534 4552
4535 4553 def saveFTPFromProcUnitObj(self, puObj):
4536 4554
4537 4555 opObj = puObj.getOperationObj(name="run")
4538 4556
4539 4557 parmObj = opObj.getParameterObj(parameterName="server")
4540 4558 if parmObj == None:
4541 4559 server = 'jro-app.igp.gob.pe'
4542 4560 else:
4543 4561 server = parmObj.getValue()
4544 4562
4545 4563 parmObj = opObj.getParameterObj(parameterName="remotefolder")
4546 4564 if parmObj == None:
4547 4565 remotefolder = '/home/wmaster/graficos'
4548 4566 else:
4549 4567 remotefolder = parmObj.getValue()
4550 4568
4551 4569 parmObj = opObj.getParameterObj(parameterName="username")
4552 4570 if parmObj == None:
4553 4571 username = 'wmaster'
4554 4572 else:
4555 4573 username = parmObj.getValue()
4556 4574
4557 4575 parmObj = opObj.getParameterObj(parameterName="password")
4558 4576 if parmObj == None:
4559 4577 password = 'mst2010vhf'
4560 4578 else:
4561 4579 password = parmObj.getValue()
4562 4580
4563 4581 parmObj = opObj.getParameterObj(parameterName="ftp_wei")
4564 4582 if parmObj == None:
4565 4583 ftp_wei = 0
4566 4584 else:
4567 4585 ftp_wei = parmObj.getValue()
4568 4586
4569 4587 parmObj = opObj.getParameterObj(parameterName="exp_code")
4570 4588 if parmObj == None:
4571 4589 exp_code = 0
4572 4590 else:
4573 4591 exp_code = parmObj.getValue()
4574 4592
4575 4593 parmObj = opObj.getParameterObj(parameterName="sub_exp_code")
4576 4594 if parmObj == None:
4577 4595 sub_exp_code = 0
4578 4596 else:
4579 4597 sub_exp_code = parmObj.getValue()
4580 4598
4581 4599 parmObj = opObj.getParameterObj(parameterName="plot_pos")
4582 4600 if parmObj == None:
4583 4601 plot_pos = 0
4584 4602 else:
4585 4603 plot_pos = parmObj.getValue()
4586 4604
4587 4605 parmObj = opObj.getParameterObj(parameterName="localfolder")
4588 4606 if parmObj == None:
4589 4607 localfolder = None
4590 4608 else:
4591 4609 localfolder = parmObj.getValue()
4592 4610
4593 4611 parmObj = opObj.getParameterObj(parameterName="ext")
4594 4612 if parmObj == None:
4595 4613 extension = '.png'
4596 4614 else:
4597 4615 extension = parmObj.getValue()
4598 4616
4599 4617 self.temporalFTP.save(server=server,
4600 4618 remotefolder=remotefolder,
4601 4619 username=username,
4602 4620 password=password,
4603 4621 ftp_wei=ftp_wei,
4604 4622 exp_code=exp_code,
4605 4623 sub_exp_code=sub_exp_code,
4606 4624 plot_pos=plot_pos,
4607 4625 localfolder=localfolder,
4608 4626 extension=extension)
4609 4627
4610 4628 def addProject2ProjectExplorer(self, id, name):
4611 4629
4612 4630 itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
4613 4631
4614 4632 parentItem = self.projectExplorerModel.invisibleRootItem()
4615 4633 parentItem.appendRow(itemTree)
4616 4634
4617 4635 self.projectExplorerTree.setCurrentIndex(itemTree.index())
4618 4636
4619 4637 self.selectedItemTree = itemTree
4620 4638
4621 4639 self.__itemTreeDict[id] = itemTree
4622 4640
4623 4641 def addPU2ProjectExplorer(self, puObj):
4624 4642
4625 4643 id, name = puObj.id, puObj.datatype
4626 4644
4627 4645 itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
4628 4646
4629 4647 parentItem = self.selectedItemTree
4630 4648 parentItem.appendRow(itemTree)
4631 4649 self.projectExplorerTree.expandAll()
4632 4650
4633 4651 self.projectExplorerTree.setCurrentIndex(itemTree.index())
4634 4652
4635 4653 self.selectedItemTree = itemTree
4636 4654
4637 4655 self.__itemTreeDict[id] = itemTree
4638 4656
4639 4657 def addPU2PELoadXML(self, puObj):
4640 4658
4641 4659 id, name, inputId = puObj.id, puObj.datatype, puObj.inputId
4642 4660
4643 4661 itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
4644 4662
4645 4663 if self.__itemTreeDict.has_key(inputId):
4646 4664 parentItem = self.__itemTreeDict[inputId]
4647 4665 else:
4648 4666 #If parent is a Reader object
4649 4667 parentItem = self.__itemTreeDict[id[:-1]]
4650 4668
4651 4669 parentItem.appendRow(itemTree)
4652 4670 self.projectExplorerTree.expandAll()
4653 4671 parentItem = itemTree
4654 4672 self.projectExplorerTree.setCurrentIndex(parentItem.index())
4655 4673
4656 4674 self.__itemTreeDict[id] = itemTree
4657 4675 self.selectedItemTree = itemTree
4658 4676
4659 4677 def getSelectedProjectObj(self):
4660 4678 """
4661 4679 Return the current project object selected. If a processing unit is
4662 4680 actually selected this function returns associated project.
4663 4681
4664 4682 None if any project or processing unit is selected
4665 4683 """
4666 4684 for key in self.__itemTreeDict.keys():
4667 4685 if self.__itemTreeDict[key] != self.selectedItemTree:
4668 4686 continue
4669 4687
4670 4688 if self.__projectObjDict.has_key(key):
4671 4689 projectObj = self.__projectObjDict[key]
4672 4690 return projectObj
4673 4691
4674 4692 puObj = self.__puObjDict[key]
4675 4693
4676 4694 if puObj.parentId == None:
4677 4695 projectId = puObj.getId()[0]
4678 4696 else:
4679 4697 projectId = puObj.parentId
4680 4698
4681 4699 projectObj = self.__projectObjDict[projectId]
4682 4700 return projectObj
4683 4701
4684 4702 return None
4685 4703
4686 4704 def getSelectedItemObj(self):
4687 4705 """
4688 4706 Return the current project or processing unit object selected
4689 4707
4690 4708 None if any project or processing unit is selected
4691 4709 """
4692 4710 for key in self.__itemTreeDict.keys():
4693 4711 if self.__itemTreeDict[key] != self.selectedItemTree:
4694 4712 continue
4695 4713
4696 4714 if self.__projectObjDict.has_key(key) == True:
4697 4715 fatherObj = self.__projectObjDict[key]
4698 4716 else:
4699 4717 fatherObj = self.__puObjDict[key]
4700 4718
4701 4719 return fatherObj
4702 4720
4703 4721 return None
4704 4722
4705 4723 def _WarningWindow(self, text, information):
4706 4724
4707 4725 msgBox = QtGui.QMessageBox()
4708 4726 msgBox.setText(text)
4709 4727 msgBox.setInformativeText(information)
4710 4728 msgBox.setStandardButtons(QtGui.QMessageBox.Ok | QtGui.QMessageBox.Cancel)
4711 4729 msgBox.setDefaultButton(QtGui.QMessageBox.Ok)
4712 4730 ret = msgBox.exec_()
4713 4731
4714 4732 answer = False
4715 4733
4716 4734 if ret == QtGui.QMessageBox.Ok:
4717 4735 answer = True
4718 4736
4719 4737 return answer
4720 4738
4721 4739 def __getNewProjectId(self):
4722 4740
4723 4741 loadProject = False
4724 4742
4725 4743 for thisId in range(1,10):
4726 4744 newId = str(thisId)
4727 4745 if newId in self.__projectObjDict.keys():
4728 4746 continue
4729 4747
4730 4748 loadProject = True
4731 4749 projectId = newId
4732 4750 break
4733 4751
4734 4752 if not loadProject:
4735 4753 self.console.clear()
4736 4754 self.console.append("The maximum number of projects has been loaded, a new project can not be loaded")
4737 4755 return None
4738 4756
4739 4757 return projectId
4740 4758
4741 4759 def openProject(self):
4742 4760
4743 4761 self._disable_save_button()
4744 4762 self._disable_play_button()
4745 4763
4746 4764 self.console.clear()
4747 4765
4748 4766 self.frame_2.setEnabled(True)
4749 4767
4750 4768 # print self.dir
4751 4769 filename = str(QtGui.QFileDialog.getOpenFileName(self, "Open a project file", self.pathWorkSpace, self.tr("Html Files (*.xml)")))
4752 4770
4753 4771 projectObjLoad = Project()
4754 4772
4755 4773 if not projectObjLoad.readXml(filename):
4756 4774 self.console.append("The selected xml file could not be loaded ...")
4757 4775 return 0
4758 4776
4759 4777 self.create = False
4760 4778 self.refreshProjectWindow(projectObjLoad)
4761 4779 self.refreshProjectProperties(projectObjLoad)
4762 4780
4763 4781 projectId = projectObjLoad.id
4764 4782
4765 4783 if projectId in self.__projectObjDict.keys():
4766 4784
4767 4785 projectId = self.__getNewProjectId()
4768 4786
4769 4787 if not projectId:
4770 4788 return 0
4771 4789
4772 4790 projectObjLoad.updateId(projectId)
4773 4791
4774 4792 self.__projectObjDict[projectId] = projectObjLoad
4775 4793
4776 4794 self.addProject2ProjectExplorer(id=projectId, name=projectObjLoad.name)
4777 4795
4778 4796 self.tabWidgetProject.setEnabled(True)
4779 4797 self.tabWidgetProject.setCurrentWidget(self.tabProject)
4780 4798 # Disable tabProject after finish the creation
4781 4799 self.tabProject.setEnabled(True)
4782 4800 puObjorderList = OrderedDict(sorted(projectObjLoad.procUnitConfObjDict.items(), key=lambda x: x[0]))
4783 4801
4784 4802 for puId, puObj in puObjorderList.items():
4785 4803
4786 4804 self.__puObjDict[puId] = puObj
4787 4805
4788 4806 if puObj.name == "SendToServer":
4789 4807 self.saveFTPFromProcUnitObj(puObj)
4790 4808
4791 4809 ############## COMPATIBLE WITH OLD VERSIONS ################
4792 4810 operationObj = puObj.getOperationObj("SendByFTP")
4793 4811
4794 4812 if operationObj:
4795 4813 self.saveFTPFromOpObj(operationObj)
4796 4814 ############################################################
4797 4815
4798 4816 if puObj.inputId == '0':
4799 4817 continue
4800 4818
4801 4819 self.addPU2PELoadXML(puObj)
4802 4820
4803 4821 self.refreshPUWindow(puObj)
4804 4822 self.refreshPUProperties(puObj)
4805 4823 self.showtabPUCreated(datatype=puObj.datatype)
4806 4824
4807 4825 # self.console.clear()
4808 4826 self.console.append("\nThe selected xml file has been loaded successfully")
4809 4827
4810 4828 if self.dateList:
4811 4829 self._disable_save_button()
4812 4830 self._enable_play_button()
4813 4831
4814 4832 def create_updating_timer(self):
4815 4833
4816 4834 self.comm_data_timer = QtCore.QTimer(self)
4817 4835 self.comm_data_timer.timeout.connect(self.on_comm_updating_timer)
4818 4836 self.comm_data_timer.start(1000)
4819 4837
4820 4838 def on_comm_updating_timer(self):
4821 4839 # Verifica si algun proceso ha sido inicializado y sigue ejecutandose
4822 4840 # Si el proceso se ha parado actualizar el GUI (stopProject)
4823 4841 if not self.threadStarted:
4824 4842 return
4825 4843
4826 4844 if self.controllerThread.isFinished():
4827 4845 self.stopProject()
4828 4846 return
4829 4847
4830 4848 def use_plotmanager(self, controllerThread):
4831 4849
4832 4850 self.plotManager = controllerThread.useExternalPlotter()
4833 4851
4834 4852 self.plot_timer = QtCore.QTimer()
4835 4853 self.plot_timer.timeout.connect(self.on_plotmanager_timer)
4836 4854 self.plot_timer.start(10)
4837 4855
4838 4856 def on_plotmanager_timer(self):
4839 4857
4840 4858 if not self.plotManager:
4841 4859 return
4842 4860
4843 4861 self.plotManager.run()
4844 4862
4845 4863 if self.plotManager.isErrorDetected():
4846 4864 self.stopProject()
4847 4865 return
4848 4866
4849 4867 def playProject(self, ext=".xml", save=1):
4850 4868
4851 4869 self._disable_play_button()
4852 4870 self._disable_save_button()
4853 4871
4854 4872 if self.controllerThread:
4855 4873 if self.controllerThread.isRunning():
4856 4874 self.console.append("There is already another process running")
4857 4875 self._enable_stop_button()
4858 4876 return
4859 4877
4860 4878 if not self.dateList:
4861 4879 self.console.append("No data found, check datapath")
4862 4880
4863 4881 projectObj = self.getSelectedProjectObj()
4864 4882
4865 4883 if not projectObj:
4866 4884 self.console.append("Please, select a project to start it")
4867 4885 return
4868 4886
4869 4887 if save:
4870 4888 filename = self.saveProject()
4871 4889 if filename == None:
4872 4890 self.console.append("Process not initialized.")
4873 4891 return
4874 4892 else:
4875 4893 filename = TEMPORAL_FILE
4876 4894 projectObj.writeXml( os.path.join(self.pathWorkSpace,filename) )
4877 4895
4878 4896 self.console.clear()
4879 4897 self.console.append("Please wait...")
4880 4898
4881 4899 self.controllerThread = ControllerThread()
4882 4900 self.controllerThread.readXml(filename)
4883 4901
4884 4902 self.use_plotmanager(self.controllerThread)
4885 4903
4886 4904 self.console.clear()
4887 4905
4888 4906 self.controllerThread.start()
4889 4907
4890 4908 sleep(0.5)
4891 4909
4892 4910
4893 4911 self.threadStarted = True
4894 4912
4895 4913 self._disable_play_button()
4896 4914 self._disable_save_button()
4897 4915 self._enable_stop_button()
4898 4916
4899 4917 def stopProject(self):
4900 4918
4901 4919 self.threadStarted = False
4902 4920 self.controllerThread.stop()
4903 4921 self.plot_timer.stop()
4904 4922
4905 4923 self.plotManager.join()
4906 4924 self.plotManager = None
4907 4925
4908 4926 while self.controllerThread.isRunning():
4909 4927 sleep(0.5)
4910 4928
4911 4929 self._disable_stop_button()
4912 4930 self._enable_play_button()
4913 4931
4914 4932 def pauseProject(self):
4915 4933
4916 4934 # self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.PAUSE, data=True))
4917 4935 paused = self.controllerThread.pause()
4918 4936
4919 4937 self.changePauseIcon(paused)
4920 4938
4921 4939 def saveProject(self, filename=None):
4922 4940
4923 4941 self._disable_save_button()
4924 4942 self._disable_play_button()
4925 4943
4926 4944 projectObj = self.getSelectedProjectObj()
4927 4945
4928 4946 if not projectObj:
4929 4947
4930 4948 if self.create:
4931 4949 self.console.append("Please press Ok before save it")
4932 4950 else:
4933 4951 self.console.append("Please select a project before save it")
4934 4952 return
4935 4953
4936 4954 self.refreshGraphicsId()
4937 4955
4938 4956 sts = True
4939 4957 selectedItemObj = self.getSelectedItemObj()
4940 4958
4941 4959 #A Processing Unit has been selected
4942 4960 if projectObj == selectedItemObj:
4943 4961 if not self.on_proOk_clicked():
4944 4962 return None
4945 4963
4946 4964 #A Processing Unit has been selected
4947 4965 if projectObj != selectedItemObj:
4948 4966 puObj = selectedItemObj
4949 4967
4950 4968 if puObj.name == 'VoltageProc':
4951 4969 sts = self.on_volOpOk_clicked()
4952 4970 if puObj.name == 'SpectraProc':
4953 4971 sts = self.on_specOpOk_clicked()
4954 4972 if puObj.name == 'SpectraHeisProc':
4955 4973 sts = self.on_specHeisOpOk_clicked()
4956 4974
4957 4975 if not sts:
4958 4976 return None
4959 4977
4960 4978 self.createFTPProcUnitView()
4961 4979
4962 4980 if not filename:
4963 4981 filename = os.path.join( str(self.pathWorkSpace), "%s%s" %(str(projectObj.name), '.xml') )
4964 4982
4965 4983 projectObj.writeXml(filename)
4966 4984 self.console.clear()
4967 4985 self.console.append("Project saved")
4968 4986 self.console.append("Press Play button to start data processing ...")
4969 4987
4970 4988 self._disable_save_button()
4971 4989 self._enable_play_button()
4972 4990
4973 4991 return filename
4974 4992
4975 4993 def removeItemTreeFromProject(self):
4976 4994 """
4977 4995 Metodo para eliminar el proyecto en el dictionario de proyectos y en el dictionario de vista de arbol
4978 4996 """
4979 4997 for key in self.__itemTreeDict.keys():
4980 4998
4981 4999 #Check again because an item can delete multiple items (childs)
4982 5000 if key not in self.__itemTreeDict.keys():
4983 5001 continue
4984 5002
4985 5003 if self.__itemTreeDict[key] != self.selectedItemTree:
4986 5004 continue
4987 5005
4988 5006 if self.__projectObjDict.has_key(key) == True:
4989 5007
4990 5008 del self.__projectObjDict[key]
4991 5009 del self.__itemTreeDict[key]
4992 5010
4993 5011 else:
4994 5012 puObj = self.__puObjDict[key]
4995 5013 idProjectParent = puObj.parentId
4996 5014 projectObj = self.__projectObjDict[idProjectParent]
4997 5015
4998 5016 del self.__puObjDict[key]
4999 5017 del self.__itemTreeDict[key]
5000 5018 del projectObj.procUnitConfObjDict[key]
5001 5019
5002 5020 for key in projectObj.procUnitConfObjDict.keys():
5003 5021 if projectObj.procUnitConfObjDict[key].inputId != puObj.getId():
5004 5022 continue
5005 5023 del self.__puObjDict[projectObj.procUnitConfObjDict[key].getId()]
5006 5024 del self.__itemTreeDict[projectObj.procUnitConfObjDict[key].getId()]
5007 5025 del projectObj.procUnitConfObjDict[key]
5008 5026 # print projectObj.procUnitConfObjDict
5009 5027 # print self.__itemTreeDict,self.__projectObjDict,self.__puObjDict
5010 5028
5011 5029 def setInputsProject_View(self):
5012 5030
5013 5031 self.tabWidgetProject.setEnabled(True)
5014 5032 self.tabWidgetProject.setCurrentWidget(self.tabProject)
5015 5033 self.tabProject.setEnabled(True)
5016 5034 self.frame_2.setEnabled(False)
5017 5035 self.proName.clear()
5018 5036 self.proName.setFocus()
5019 5037 self.proName.setSelection(0, 0)
5020 5038 self.proName.setCursorPosition(0)
5021 5039 self.proDataType.setText('.r')
5022 5040 self.proDataPath.clear()
5023 5041 self.proComDataType.clear()
5024 5042 self.proComDataType.addItem("Voltage")
5025 5043 self.proComDataType.addItem("Spectra")
5026 5044 self.proComDataType.addItem("Fits")
5027 5045 self.proComDataType.addItem("USRP")
5028 5046
5029 5047 self.proComStartDate.clear()
5030 5048 self.proComEndDate.clear()
5031 5049
5032 5050 startTime = "00:00:00"
5033 5051 endTime = "23:59:59"
5034 5052 starlist = startTime.split(":")
5035 5053 endlist = endTime.split(":")
5036 5054 self.proDelay.setText("60")
5037 5055 self.proSet.setText("")
5038 5056
5039 5057 self.labelSet.show()
5040 5058 self.proSet.show()
5041 5059
5042 5060 self.labelIPPKm.hide()
5043 5061 self.proIPPKm.hide()
5044 5062
5045 5063 self.time.setHMS(int(starlist[0]), int(starlist[1]), int(starlist[2]))
5046 5064 self.proStartTime.setTime(self.time)
5047 5065 self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
5048 5066 self.proEndTime.setTime(self.time)
5049 5067 self.proDescription.clear()
5050 5068 self.proOk.setEnabled(False)
5051 5069 # self.console.append("Please, Write a name Project")
5052 5070 # self.console.append("Introduce Project Parameters")DC
5053 5071 # self.console.append("Select data type Voltage( .rawdata) or Spectra(.pdata)")
5054 5072
5055 5073 def clearPUWindow(self, datatype):
5056 5074
5057 5075 projectObjView = self.getSelectedProjectObj()
5058 5076
5059 5077 if not projectObjView:
5060 5078 return
5061 5079
5062 5080 puObj = self.getSelectedItemObj()
5063 5081 inputId = puObj.getInputId()
5064 5082 inputPUObj = projectObjView.getProcUnitObj(inputId)
5065 5083
5066 5084 if datatype == 'Voltage':
5067 5085 self.volOpComChannels.setEnabled(False)
5068 5086 self.volOpComHeights.setEnabled(False)
5069 5087 self.volOpFilter.setEnabled(False)
5070 5088 self.volOpComProfile.setEnabled(False)
5071 5089 self.volOpComCode.setEnabled(False)
5072 5090 self.volOpCohInt.setEnabled(False)
5073 5091 self.volOpChannel.setEnabled(False)
5074 5092 self.volOpHeights.setEnabled(False)
5075 5093 self.volOpProfile.setEnabled(False)
5076 5094 self.volOpRadarfrequency.setEnabled(False)
5077 5095 self.volOpCebChannels.setCheckState(0)
5078 5096 self.volOpCebRadarfrequency.setCheckState(0)
5079 5097 self.volOpCebHeights.setCheckState(0)
5080 5098 self.volOpCebFilter.setCheckState(0)
5081 5099 self.volOpCebProfile.setCheckState(0)
5082 5100 self.volOpCebDecodification.setCheckState(0)
5083 5101 self.volOpCebCohInt.setCheckState(0)
5084 5102
5085 5103 self.volOpChannel.clear()
5086 5104 self.volOpHeights.clear()
5087 5105 self.volOpProfile.clear()
5088 5106 self.volOpFilter.clear()
5089 5107 self.volOpCohInt.clear()
5090 5108 self.volOpRadarfrequency.clear()
5091 5109
5092 5110 if datatype == 'Spectra':
5093 5111
5094 5112 if inputPUObj.datatype == 'Spectra':
5095 5113 self.specOpnFFTpoints.setEnabled(False)
5096 5114 self.specOpProfiles.setEnabled(False)
5097 5115 self.specOpippFactor.setEnabled(False)
5098 5116 else:
5099 5117 self.specOpnFFTpoints.setEnabled(True)
5100 5118 self.specOpProfiles.setEnabled(True)
5101 5119 self.specOpippFactor.setEnabled(True)
5102 5120
5103 5121 self.specOpCebCrossSpectra.setCheckState(0)
5104 5122 self.specOpCebChannel.setCheckState(0)
5105 5123 self.specOpCebHeights.setCheckState(0)
5106 5124 self.specOpCebIncoherent.setCheckState(0)
5107 5125 self.specOpCebRemoveDC.setCheckState(0)
5108 5126 self.specOpCebRemoveInt.setCheckState(0)
5109 5127 self.specOpCebgetNoise.setCheckState(0)
5110 5128 self.specOpCebRadarfrequency.setCheckState(0)
5111 5129
5112 5130 self.specOpRadarfrequency.setEnabled(False)
5113 5131 self.specOppairsList.setEnabled(False)
5114 5132 self.specOpChannel.setEnabled(False)
5115 5133 self.specOpHeights.setEnabled(False)
5116 5134 self.specOpIncoherent.setEnabled(False)
5117 5135 self.specOpgetNoise.setEnabled(False)
5118 5136
5119 5137 self.specOpRadarfrequency.clear()
5120 5138 self.specOpnFFTpoints.clear()
5121 5139 self.specOpProfiles.clear()
5122 5140 self.specOpippFactor.clear
5123 5141 self.specOppairsList.clear()
5124 5142 self.specOpChannel.clear()
5125 5143 self.specOpHeights.clear()
5126 5144 self.specOpIncoherent.clear()
5127 5145 self.specOpgetNoise.clear()
5128 5146
5129 5147 self.specGraphCebSpectraplot.setCheckState(0)
5130 5148 self.specGraphCebCrossSpectraplot.setCheckState(0)
5131 5149 self.specGraphCebRTIplot.setCheckState(0)
5132 5150 self.specGraphCebRTInoise.setCheckState(0)
5133 5151 self.specGraphCebCoherencmap.setCheckState(0)
5134 5152 self.specGraphPowerprofile.setCheckState(0)
5135 5153
5136 5154 self.specGraphSaveSpectra.setCheckState(0)
5137 5155 self.specGraphSaveCross.setCheckState(0)
5138 5156 self.specGraphSaveRTIplot.setCheckState(0)
5139 5157 self.specGraphSaveRTInoise.setCheckState(0)
5140 5158 self.specGraphSaveCoherencemap.setCheckState(0)
5141 5159 self.specGraphSavePowerprofile.setCheckState(0)
5142 5160
5143 5161 self.specGraphftpRTIplot.setCheckState(0)
5144 5162 self.specGraphftpRTInoise.setCheckState(0)
5145 5163 self.specGraphftpCoherencemap.setCheckState(0)
5146 5164
5147 5165 self.specGraphPath.clear()
5148 5166 self.specGraphPrefix.clear()
5149 5167
5150 5168 self.specGgraphftpratio.clear()
5151 5169
5152 5170 self.specGgraphChannelList.clear()
5153 5171 self.specGgraphFreq.clear()
5154 5172 self.specGgraphHeight.clear()
5155 5173 self.specGgraphDbsrange.clear()
5156 5174 self.specGgraphmagnitud.clear()
5157 5175 self.specGgraphTminTmax.clear()
5158 5176 self.specGgraphTimeRange.clear()
5159 5177
5160 5178 if datatype == 'SpectraHeis':
5161 5179 self.specHeisOpCebIncoherent.setCheckState(0)
5162 5180 self.specHeisOpIncoherent.setEnabled(False)
5163 5181 self.specHeisOpIncoherent.clear()
5164 5182
5165 5183 self.specHeisGraphCebSpectraplot.setCheckState(0)
5166 5184 self.specHeisGraphCebRTIplot.setCheckState(0)
5167 5185
5168 5186 self.specHeisGraphSaveSpectra.setCheckState(0)
5169 5187 self.specHeisGraphSaveRTIplot.setCheckState(0)
5170 5188
5171 5189 self.specHeisGraphftpSpectra.setCheckState(0)
5172 5190 self.specHeisGraphftpRTIplot.setCheckState(0)
5173 5191
5174 5192 self.specHeisGraphPath.clear()
5175 5193 self.specHeisGraphPrefix.clear()
5176 5194 self.specHeisGgraphChannelList.clear()
5177 5195 self.specHeisGgraphXminXmax.clear()
5178 5196 self.specHeisGgraphYminYmax.clear()
5179 5197 self.specHeisGgraphTminTmax.clear()
5180 5198 self.specHeisGgraphTimeRange.clear()
5181 5199 self.specHeisGgraphftpratio.clear()
5182 5200
5183 5201 def showtabPUCreated(self, datatype):
5184 5202
5185 5203 if datatype == "Voltage":
5186 5204 self.tabVoltage.setEnabled(True)
5187 5205 self.tabProject.setEnabled(False)
5188 5206 self.tabSpectra.setEnabled(False)
5189 5207 self.tabCorrelation.setEnabled(False)
5190 5208 self.tabSpectraHeis.setEnabled(False)
5191 5209 self.tabWidgetProject.setCurrentWidget(self.tabVoltage)
5192 5210
5193 5211 if datatype == "Spectra":
5194 5212 self.tabVoltage.setEnabled(False)
5195 5213 self.tabProject.setEnabled(False)
5196 5214 self.tabSpectra.setEnabled(True)
5197 5215 self.tabCorrelation.setEnabled(False)
5198 5216 self.tabSpectraHeis.setEnabled(False)
5199 5217 self.tabWidgetProject.setCurrentWidget(self.tabSpectra)
5200 5218
5201 5219 if datatype == "SpectraHeis":
5202 5220 self.tabVoltage.setEnabled(False)
5203 5221 self.tabProject.setEnabled(False)
5204 5222 self.tabSpectra.setEnabled(False)
5205 5223 self.tabCorrelation.setEnabled(False)
5206 5224 self.tabSpectraHeis.setEnabled(True)
5207 5225 self.tabWidgetProject.setCurrentWidget(self.tabSpectraHeis)
5208 5226
5209 5227 def checkInputsProject(self):
5210 5228 """
5211 5229 Check Inputs Project:
5212 5230 - project_name
5213 5231 - datatype
5214 5232 - ext
5215 5233 - data_path
5216 5234 - readmode
5217 5235 - delay
5218 5236 - set
5219 5237 - walk
5220 5238 """
5221 5239 parms_ok = True
5222 5240 project_name = str(self.proName.text())
5223 5241 if project_name == '' or project_name == None:
5224 5242 outputstr = "Enter the Project Name"
5225 5243 self.console.append(outputstr)
5226 5244 parms_ok = False
5227 5245 project_name = None
5228 5246
5229 5247 datatype = str(self.proComDataType.currentText())
5230 5248 if not(datatype in ['Voltage', 'Spectra', 'Fits', 'USRP']):
5231 5249 outputstr = 'datatype = %s, this must be either Voltage, Spectra, SpectraHeis or USRP' % datatype
5232 5250 self.console.append(outputstr)
5233 5251 parms_ok = False
5234 5252 datatype = None
5235 5253
5236 5254 ext = str(self.proDataType.text())
5237 5255 if not(ext in ['.r', '.pdata', '.fits', '.hdf5']):
5238 5256 outputstr = "extension files must be .r , .pdata, .fits or .hdf5"
5239 5257 self.console.append(outputstr)
5240 5258 parms_ok = False
5241 5259 ext = None
5242 5260
5243 5261 data_path = str(self.proDataPath.text())
5244 5262
5245 5263 if data_path == '':
5246 5264 outputstr = 'Datapath is empty'
5247 5265 self.console.append(outputstr)
5248 5266 parms_ok = False
5249 5267 data_path = None
5250 5268
5251 5269 if data_path != None:
5252 5270 if not os.path.isdir(data_path):
5253 5271 outputstr = 'Datapath:%s does not exists' % data_path
5254 5272 self.console.append(outputstr)
5255 5273 parms_ok = False
5256 5274 data_path = None
5257 5275
5258 5276 read_mode = str(self.proComReadMode.currentText())
5259 5277 if not(read_mode in ['Online', 'Offline']):
5260 5278 outputstr = 'Read Mode: %s, this must be either Online or Offline' % read_mode
5261 5279 self.console.append(outputstr)
5262 5280 parms_ok = False
5263 5281 read_mode = None
5264 5282
5265 5283 delay = None
5266 5284 if read_mode == "Online":
5267 5285 parms_ok = False
5268 5286 try:
5269 5287 delay = int(str(self.proDelay.text()))
5270 5288 parms_ok = True
5271 5289 except:
5272 5290 outputstr = 'Delay: %s, this must be a integer number' % str(self.proDelay.text())
5273 5291 self.console.append(outputstr)
5274 5292
5275 5293 try:
5276 5294 set = int(str(self.proSet.text()))
5277 5295 except:
5278 5296 # outputstr = 'Set: %s, this must be a integer number' % str(self.proName.text())
5279 5297 # self.console.append(outputstr)
5280 5298 # parms_ok = False
5281 5299 set = None
5282 5300
5283 5301 walk = int(self.proComWalk.currentIndex())
5284 5302 expLabel = str(self.proExpLabel.text())
5285 5303
5286 5304 return parms_ok, project_name, datatype, ext, data_path, read_mode, delay, walk, set, expLabel
5287 5305
5288 5306 def checkInputsPUSave(self, datatype):
5289 5307 """
5290 5308 Check Inputs Spectra Save:
5291 5309 - path
5292 5310 - blocks Per File
5293 5311 - sufix
5294 5312 - dataformat
5295 5313 """
5296 5314 parms_ok = True
5297 5315
5298 5316 if datatype == "Voltage":
5299 5317 output_path = str(self.volOutputPath.text())
5300 5318 blocksperfile = str(self.volOutputblocksperfile.text())
5301 5319 profilesperblock = str(self.volOutputprofilesperblock.text())
5302 5320
5303 5321 if datatype == "Spectra":
5304 5322 output_path = str(self.specOutputPath.text())
5305 5323 blocksperfile = str(self.specOutputblocksperfile.text())
5306 5324 profilesperblock = 0
5307 5325
5308 5326 if datatype == "SpectraHeis":
5309 5327 output_path = str(self.specHeisOutputPath.text())
5310 5328 blocksperfile = str(self.specHeisOutputblocksperfile.text())
5311 5329 metadata_file = str(self.specHeisOutputMetada.text())
5312 5330
5313 5331 if output_path == '':
5314 5332 outputstr = 'Outputpath is empty'
5315 5333 self.console.append(outputstr)
5316 5334 parms_ok = False
5317 5335
5318 5336 if not os.path.isdir(output_path):
5319 5337 outputstr = 'OutputPath:%s does not exists' % output_path
5320 5338 self.console.append(outputstr)
5321 5339 parms_ok = False
5322 5340
5323 5341 try:
5324 5342 profilesperblock = int(profilesperblock)
5325 5343 except:
5326 5344 if datatype == "Voltage":
5327 5345 outputstr = 'Profilesperblock: %s, this must be a integer number' % str(self.volOutputprofilesperblock.text())
5328 5346 self.console.append(outputstr)
5329 5347 parms_ok = False
5330 5348 profilesperblock = None
5331 5349
5332 5350 try:
5333 5351 blocksperfile = int(blocksperfile)
5334 5352 except:
5335 5353 if datatype == "Voltage":
5336 5354 outputstr = 'Blocksperfile: %s, this must be a integer number' % str(self.volOutputblocksperfile.text())
5337 5355 elif datatype == "Spectra":
5338 5356 outputstr = 'Blocksperfile: %s, this must be a integer number' % str(self.specOutputblocksperfile.text())
5339 5357 elif datatype == "SpectraHeis":
5340 5358 outputstr = 'Blocksperfile: %s, this must be a integer number' % str(self.specHeisOutputblocksperfile.text())
5341 5359
5342 5360 self.console.append(outputstr)
5343 5361 parms_ok = False
5344 5362 blocksperfile = None
5345 5363
5346 5364 if datatype == "SpectraHeis":
5347 5365 if metadata_file != '':
5348 5366 if not os.path.isfile(metadata_file):
5349 5367 outputstr = 'Metadata file %s does not exist' % metadata_file
5350 5368 self.console.append(outputstr)
5351 5369 parms_ok = False
5352 5370
5353 5371 if datatype == "Voltage":
5354 5372 return parms_ok, output_path, blocksperfile, profilesperblock
5355 5373
5356 5374
5357 5375 if datatype == "Spectra":
5358 5376 return parms_ok, output_path, blocksperfile, profilesperblock
5359 5377
5360 5378
5361 5379 if datatype == "SpectraHeis":
5362 5380 return parms_ok, output_path, blocksperfile, metadata_file
5363 5381
5364 5382 def findDatafiles(self, data_path, ext, walk, expLabel=''):
5365 5383
5366 5384 dateList = []
5367 5385 fileList = []
5368 5386
5369 5387 if ext == ".r":
5370 5388 from schainpy.model.io.jroIO_base import JRODataReader
5371 5389
5372 5390 readerObj = JRODataReader()
5373 5391 dateList = readerObj.findDatafiles(path=data_path,
5374 5392 expLabel=expLabel,
5375 5393 ext=ext,
5376 5394 walk=walk)
5377 5395
5378 5396 if ext == ".pdata":
5379 5397 from schainpy.model.io.jroIO_base import JRODataReader
5380 5398
5381 5399 readerObj = JRODataReader()
5382 5400 dateList = readerObj.findDatafiles(path=data_path,
5383 5401 expLabel=expLabel,
5384 5402 ext=ext,
5385 5403 walk=walk)
5386 5404
5387 5405 if ext == ".fits":
5388 5406 from schainpy.model.io.jroIO_base import JRODataReader
5389 5407
5390 5408 readerObj = JRODataReader()
5391 5409 dateList = readerObj.findDatafiles(path=data_path,
5392 5410 expLabel=expLabel,
5393 5411 ext=ext,
5394 5412 walk=walk)
5395 5413
5396 5414 if ext == ".hdf5":
5397 5415 from schainpy.model.io.jroIO_usrp import USRPReader
5398 5416
5399 5417 readerObj = USRPReader()
5400 5418 dateList = readerObj.findDatafiles(path=data_path)
5401 5419
5402 5420 return dateList
5403 5421
5404 5422 def loadDays(self, data_path, ext, walk, expLabel=''):
5405 5423 """
5406 5424 Method to loads day
5407 5425 """
5408 5426 # self._disable_save_button()
5409 5427 # self._disable_play_button()
5410 5428 # self.proOk.setEnabled(False)
5411 5429
5412 5430 self.proComStartDate.clear()
5413 5431 self.proComEndDate.clear()
5414 5432
5415 5433 self.dateList = []
5416 5434
5417 5435 if not data_path:
5418 5436 self.console.append("Datapath has not been set")
5419 5437 return []
5420 5438
5421 5439 if not os.path.isdir(data_path):
5422 5440 self.console.append("Directory %s does not exist" %data_path)
5423 5441 return []
5424 5442
5425 5443 self.dataPath = data_path
5426 5444
5427 5445 dateList = self.findDatafiles(data_path, ext=ext, walk=walk, expLabel=expLabel)
5428 5446
5429 5447 if not dateList:
5430 5448 # self.console.clear()
5431 5449 if walk:
5432 5450 if expLabel:
5433 5451 outputstr = "No files (*%s) were found on %s/DOYPATH/%s" % (ext, data_path, expLabel)
5434 5452 else:
5435 5453 outputstr = "No files (*%s) were found on %s" % (ext, data_path)
5436 5454 else:
5437 5455 outputstr = "No files (*%s) were found on %s" % (ext, data_path)
5438 5456
5439 5457 self.console.append(outputstr)
5440 5458 return []
5441 5459
5442 5460 dateStrList = []
5443 5461 for thisDate in dateList:
5444 5462 dateStr = thisDate.strftime("%Y/%m/%d")
5445 5463
5446 5464 self.proComStartDate.addItem(dateStr)
5447 5465 self.proComEndDate.addItem(dateStr)
5448 5466 dateStrList.append(dateStr)
5449 5467
5450 5468 self.proComStartDate.setCurrentIndex(0)
5451 5469 self.proComEndDate.setCurrentIndex(self.proComEndDate.count() - 1)
5452 5470
5453 5471 self.dateList = dateStrList
5454 5472
5455 5473 self.console.clear()
5456 5474 self.console.append("Successful load")
5457 5475
5458 5476 # self.proOk.setEnabled(True)
5459 5477 # self._enable_play_button()
5460 5478 # self._enable_save_button()
5461 5479
5462 5480 return self.dateList
5463 5481
5464 5482 def setWorkSpaceGUI(self, pathWorkSpace=None):
5465 5483
5466 5484 if pathWorkSpace == None:
5467 5485 home = os.path.expanduser("~")
5468 5486 pathWorkSpace = os.path.join(home,'schain_workspace')
5469 5487
5470 5488 self.pathWorkSpace = pathWorkSpace
5471 5489
5472 5490 """
5473 5491 Comandos Usados en Console
5474 5492 """
5475 5493 def __del__(self):
5476 5494 sys.stdout = sys.__stdout__
5477 5495 sys.stderr = sys.__stderr__
5478 5496
5479 5497 def normalOutputWritten(self, text):
5480 5498 color_black = QtGui.QColor(0,0,0)
5481 5499 self.console.setTextColor(color_black)
5482 5500 self.console.append(text)
5483 5501
5484 5502 def errorOutputWritten(self, text):
5485 5503 color_red = QtGui.QColor(255,0,0)
5486 5504 color_black = QtGui.QColor(0,0,0)
5487 5505
5488 5506 self.console.setTextColor(color_red)
5489 5507 self.console.append(text)
5490 5508 self.console.setTextColor(color_black)
5491 5509
5492 5510 def _enable_save_button(self):
5493 5511
5494 5512 self.actionSaveToolbar.setEnabled(True)
5495 5513 self.actionSave.setEnabled(True)
5496 5514
5497 5515 def _disable_save_button(self):
5498 5516
5499 5517 self.actionSaveToolbar.setEnabled(False)
5500 5518 self.actionSave.setEnabled(False)
5501 5519
5502 5520 def _enable_play_button(self):
5503 5521
5504 5522 if self.controllerThread:
5505 5523 if self.controllerThread.isRunning():
5506 5524 return
5507 5525
5508 5526 self.actionStart.setEnabled(True)
5509 5527 self.actionStarToolbar.setEnabled(True)
5510 5528
5511 5529 self.changeStartIcon(started=False)
5512 5530
5513 5531 def _disable_play_button(self):
5514 5532
5515 5533 self.actionStart.setEnabled(False)
5516 5534 self.actionStarToolbar.setEnabled(False)
5517 5535
5518 5536 self.changeStartIcon(started=True)
5519 5537
5520 5538 def _enable_stop_button(self):
5521 5539
5522 5540 self.actionPause.setEnabled(True)
5523 5541 self.actionStop.setEnabled(True)
5524 5542
5525 5543 self.actionPauseToolbar.setEnabled(True)
5526 5544 self.actionStopToolbar.setEnabled(True)
5527 5545
5528 5546 self.changePauseIcon(paused=False)
5529 5547 self.changeStopIcon(started=True)
5530 5548
5531 5549 def _disable_stop_button(self):
5532 5550
5533 5551 self.actionPause.setEnabled(False)
5534 5552 self.actionStop.setEnabled(False)
5535 5553
5536 5554 self.actionPauseToolbar.setEnabled(False)
5537 5555 self.actionStopToolbar.setEnabled(False)
5538 5556
5539 5557 self.changePauseIcon(paused=False)
5540 5558 self.changeStopIcon(started=False)
5541 5559
5542 5560 def setGUIStatus(self):
5543 5561
5544 5562 self.setWindowTitle("ROJ-Signal Chain")
5545 5563 self.setWindowIcon(QtGui.QIcon( os.path.join(FIGURES_PATH,"logo.png") ))
5546 5564
5547 5565 self.tabWidgetProject.setEnabled(False)
5548 5566 self.tabVoltage.setEnabled(False)
5549 5567 self.tabSpectra.setEnabled(False)
5550 5568 self.tabCorrelation.setEnabled(False)
5551 5569 self.frame_2.setEnabled(False)
5552 5570
5553 5571 self.actionCreate.setShortcut('Ctrl+N')
5554 5572 self.actionOpen.setShortcut('Ctrl+O')
5555 5573 self.actionSave.setShortcut('Ctrl+S')
5556 5574 self.actionClose.setShortcut('Ctrl+X')
5557 5575
5558 5576 self.actionStart.setShortcut('Ctrl+1')
5559 5577 self.actionPause.setShortcut('Ctrl+2')
5560 5578 self.actionStop.setShortcut('Ctrl+3')
5561 5579
5562 5580 self.actionFTP.setShortcut('Ctrl+F')
5563 5581
5564 5582 self.actionStart.setEnabled(False)
5565 5583 self.actionPause.setEnabled(False)
5566 5584 self.actionStop.setEnabled(False)
5567 5585
5568 5586 self.actionStarToolbar.setEnabled(False)
5569 5587 self.actionPauseToolbar.setEnabled(False)
5570 5588 self.actionStopToolbar.setEnabled(False)
5571 5589
5572 5590 self.proName.clear()
5573 5591 self.proDataPath.setText('')
5574 5592 self.console.setReadOnly(True)
5575 5593 self.console.append("Welcome to Signal Chain\n\n")
5576 5594 self.console.append("Open a project or Create a new one\n")
5577 5595 self.proStartTime.setDisplayFormat("hh:mm:ss")
5578 5596 self.proDataType.setEnabled(False)
5579 5597 self.time = QtCore.QTime()
5580 5598 self.proEndTime.setDisplayFormat("hh:mm:ss")
5581 5599 startTime = "00:00:00"
5582 5600 endTime = "23:59:59"
5583 5601 starlist = startTime.split(":")
5584 5602 endlist = endTime.split(":")
5585 5603 self.time.setHMS(int(starlist[0]), int(starlist[1]), int(starlist[2]))
5586 5604 self.proStartTime.setTime(self.time)
5587 5605 self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
5588 5606 self.proEndTime.setTime(self.time)
5589 5607 self.proOk.setEnabled(False)
5590 5608 # set model Project Explorer
5591 5609 self.projectExplorerModel = QtGui.QStandardItemModel()
5592 5610 self.projectExplorerModel.setHorizontalHeaderLabels(("Project Explorer",))
5593 5611 layout = QtGui.QVBoxLayout()
5594 5612 layout.addWidget(self.projectExplorerTree)
5595 5613 self.projectExplorerTree.setModel(self.projectExplorerModel)
5596 5614 self.projectExplorerTree.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
5597 5615 self.projectExplorerTree.customContextMenuRequested.connect(self.on_right_click)
5598 5616 self.projectExplorerTree.clicked.connect(self.on_click)
5599 5617 self.projectExplorerTree.expandAll()
5600 5618 # set model Project Properties
5601 5619
5602 5620 self.propertiesModel = TreeModel()
5603 5621 self.propertiesModel.initProjectView()
5604 5622 self.treeProjectProperties.setModel(self.propertiesModel)
5605 5623 self.treeProjectProperties.expandAll()
5606 5624 self.treeProjectProperties.allColumnsShowFocus()
5607 5625 self.treeProjectProperties.resizeColumnToContents(1)
5608 5626
5609 5627 # set Project
5610 5628 self.pronTxs.setEnabled(False)
5611 5629 self.proComByBlock.setEnabled(False)
5612 5630 self.proExpLabel.setEnabled(False)
5613 5631 self.proDelay.setEnabled(False)
5614 5632 self.proSet.setEnabled(True)
5615 5633 self.proDataType.setReadOnly(True)
5616 5634
5617 5635 # set Operation Voltage
5618 5636 self.volOpComChannels.setEnabled(False)
5619 5637 self.volOpComHeights.setEnabled(False)
5620 5638 self.volOpFilter.setEnabled(False)
5621 5639 self.volOpComProfile.setEnabled(False)
5622 5640 self.volOpComCode.setEnabled(False)
5623 5641 self.volOpFlip.setEnabled(False)
5624 5642 self.volOpCohInt.setEnabled(False)
5625 5643 self.volOpRadarfrequency.setEnabled(False)
5626 5644
5627 5645 self.volOpChannel.setEnabled(False)
5628 5646 self.volOpHeights.setEnabled(False)
5629 5647 self.volOpProfile.setEnabled(False)
5630 5648 self.volOpComMode.setEnabled(False)
5631 5649
5632 5650 self.volOpReshaper.setEnabled(False)
5633 5651 self.volOpAdjustHei.setEnabled(False)
5634 5652
5635 5653 self.volOpCebReshaper.setEnabled(False)
5636 5654 self.volOpCebAdjustHei.setEnabled(False)
5637 5655
5638 5656 self.volGraphPath.setEnabled(False)
5639 5657 self.volGraphPrefix.setEnabled(False)
5640 5658 self.volGraphToolPath.setEnabled(False)
5641 5659
5642 5660 # set Graph Voltage
5643 5661 self.volGraphChannelList.setEnabled(False)
5644 self.volGraphfreqrange.setEnabled(False)
5662 self.volGraphIntensityRange.setEnabled(False)
5645 5663 self.volGraphHeightrange.setEnabled(False)
5646 5664
5647 5665 # set Operation Spectra
5648 5666 self.specOpnFFTpoints.setEnabled(False)
5649 5667 self.specOpProfiles.setEnabled(False)
5650 5668 self.specOpippFactor.setEnabled(False)
5651 5669 self.specOppairsList.setEnabled(False)
5652 5670
5653 5671 self.specOpComCrossSpectra.setEnabled(False)
5654 5672 self.specOpComChannel.setEnabled(False)
5655 5673 self.specOpComHeights.setEnabled(False)
5656 5674 self.specOpIncoherent.setEnabled(False)
5657 5675 self.specOpgetNoise.setEnabled(False)
5658 5676 self.specOpRadarfrequency.setEnabled(False)
5659 5677
5660 5678
5661 5679 self.specOpChannel.setEnabled(False)
5662 5680 self.specOpHeights.setEnabled(False)
5663 5681 # set Graph Spectra
5664 5682 self.specGgraphChannelList.setEnabled(False)
5665 5683 self.specGgraphFreq.setEnabled(False)
5666 5684 self.specGgraphHeight.setEnabled(False)
5667 5685 self.specGgraphDbsrange.setEnabled(False)
5668 5686 self.specGgraphmagnitud.setEnabled(False)
5669 5687 self.specGgraphTminTmax.setEnabled(False)
5670 5688 self.specGgraphTimeRange.setEnabled(False)
5671 5689 self.specGraphPath.setEnabled(False)
5672 5690 self.specGraphToolPath.setEnabled(False)
5673 5691 self.specGraphPrefix.setEnabled(False)
5674 5692
5675 5693 self.specGgraphftpratio.setEnabled(False)
5676 5694 # set Operation SpectraHeis
5677 5695 self.specHeisOpIncoherent.setEnabled(False)
5678 5696 self.specHeisOpCobIncInt.setEnabled(False)
5679 5697 # set Graph SpectraHeis
5680 5698 self.specHeisGgraphChannelList.setEnabled(False)
5681 5699 self.specHeisGgraphXminXmax.setEnabled(False)
5682 5700 self.specHeisGgraphYminYmax.setEnabled(False)
5683 5701 self.specHeisGgraphTminTmax.setEnabled(False)
5684 5702 self.specHeisGgraphTimeRange.setEnabled(False)
5685 5703 self.specHeisGgraphftpratio.setEnabled(False)
5686 5704 self.specHeisGraphPath.setEnabled(False)
5687 5705 self.specHeisGraphPrefix.setEnabled(False)
5688 5706 self.specHeisGraphToolPath.setEnabled(False)
5689 5707
5690 5708 self.proComWalk.setCurrentIndex(0)
5691 5709
5692 5710 # tool tip gui
5693 5711 QtGui.QToolTip.setFont(QtGui.QFont('SansSerif', 10))
5694 5712 self.projectExplorerTree.setToolTip('Right clik to add Project or Unit Process')
5695 5713 # tool tip gui project
5696 5714
5697 5715 # tool tip gui volOp
5698 5716 # self.volOpChannel.setToolTip('Example: 1,2,3,4,5')
5699 5717 # self.volOpHeights.setToolTip('Example: 90,180')
5700 5718 # self.volOpFilter.setToolTip('Example: 2')
5701 5719 # self.volOpProfile.setToolTip('Example:0,127')
5702 5720 # self.volOpCohInt.setToolTip('Example: 128')
5703 5721 # self.volOpFlip.setToolTip('ChannelList where flip will be applied. Example: 0,2,3')
5704 5722 # self.volOpOk.setToolTip('If you have finished, please Ok ')
5705 5723 # # tool tip gui volGraph
5706 # self.volGraphfreqrange.setToolTip('Height range. Example: 50,100')
5724 # self.volGraphIntensityRange.setToolTip('Height range. Example: 50,100')
5707 5725 # self.volGraphHeightrange.setToolTip('Amplitude. Example: 0,10000')
5708 5726 # tool tip gui specOp
5709 5727 # self.specOpnFFTpoints.setToolTip('Example: 128')
5710 5728 # self.specOpProfiles.setToolTip('Example: 128')
5711 5729 # self.specOpippFactor.setToolTip('Example:1.0')
5712 5730 # self.specOpIncoherent.setToolTip('Example: 10')
5713 5731 # self.specOpgetNoise.setToolTip('Example:20,180,30,120 (minHei,maxHei,minVel,maxVel)')
5714 5732 #
5715 5733 # self.specOpChannel.setToolTip('Example: 0,1,2,3')
5716 5734 # self.specOpHeights.setToolTip('Example: 90,180')
5717 5735 # self.specOppairsList.setToolTip('Example: (0,1),(2,3)')
5718 5736 # # tool tip gui specGraph
5719 5737 #
5720 5738 # self.specGgraphChannelList.setToolTip('Example: 0,3,4')
5721 5739 # self.specGgraphFreq.setToolTip('Example: -20,20')
5722 5740 # self.specGgraphHeight.setToolTip('Example: 100,400')
5723 5741 # self.specGgraphDbsrange.setToolTip('Example: 30,170')
5724 5742 #
5725 5743 # self.specGraphPrefix.setToolTip('Example: EXPERIMENT_NAME')
5726 5744 #
5727 5745 #
5728 5746 # self.specHeisOpIncoherent.setToolTip('Example: 10')
5729 5747 #
5730 5748 # self.specHeisGgraphChannelList.setToolTip('Example: 0,2,3')
5731 5749 # self.specHeisGgraphXminXmax.setToolTip('Example (Hz): -1000, 1000')
5732 5750 # self.specHeisGgraphYminYmax.setToolTip('Example (dB): 5, 35')
5733 5751 # self.specHeisGgraphTminTmax.setToolTip('Example (hours): 0, 24')
5734 5752 # self.specHeisGgraphTimeRange.setToolTip('Example (hours): 8')
5735 5753
5736 5754 self.labelSet.show()
5737 5755 self.proSet.show()
5738 5756
5739 5757 self.labelIPPKm.hide()
5740 5758 self.proIPPKm.hide()
5741 5759
5742 5760 sys.stdout = ShowMeConsole(textWritten=self.normalOutputWritten)
5743 5761 # sys.stderr = ShowMeConsole(textWritten=self.errorOutputWritten)
5744 5762
5745 5763
5746 5764 class UnitProcessWindow(QMainWindow, Ui_UnitProcess):
5747 5765 """
5748 5766 Class documentation goes here.
5749 5767 """
5750 5768 closed = pyqtSignal()
5751 5769 create = False
5752 5770
5753 5771 def __init__(self, parent=None):
5754 5772 """
5755 5773 Constructor
5756 5774 """
5757 5775 QMainWindow.__init__(self, parent)
5758 5776 self.setupUi(self)
5759 5777 self.getFromWindow = None
5760 5778 self.getfromWindowList = []
5761 5779 self.dataTypeProject = None
5762 5780
5763 5781 self.listUP = None
5764 5782
5765 5783 @pyqtSignature("")
5766 5784 def on_unitPokbut_clicked(self):
5767 5785 """
5768 5786 Slot documentation goes here.
5769 5787 """
5770 5788 self.create = True
5771 5789 self.getFromWindow = self.getfromWindowList[int(self.comboInputBox.currentIndex())]
5772 5790 # self.nameofUP= str(self.nameUptxt.text())
5773 5791 self.typeofUP = str(self.comboTypeBox.currentText())
5774 5792 self.close()
5775 5793
5776 5794
5777 5795 @pyqtSignature("")
5778 5796 def on_unitPcancelbut_clicked(self):
5779 5797 """
5780 5798 Slot documentation goes here.
5781 5799 """
5782 5800 self.create = False
5783 5801 self.close()
5784 5802
5785 5803 def loadTotalList(self):
5786 5804 self.comboInputBox.clear()
5787 5805 for i in self.getfromWindowList:
5788 5806
5789 5807 name = i.getElementName()
5790 5808 if name == 'Project':
5791 5809 id = i.id
5792 5810 name = i.name
5793 5811 if self.dataTypeProject == 'Voltage':
5794 5812 self.comboTypeBox.clear()
5795 5813 self.comboTypeBox.addItem("Voltage")
5796 5814
5797 5815 if self.dataTypeProject == 'Spectra':
5798 5816 self.comboTypeBox.clear()
5799 5817 self.comboTypeBox.addItem("Spectra")
5800 5818 self.comboTypeBox.addItem("Correlation")
5801 5819 if self.dataTypeProject == 'Fits':
5802 5820 self.comboTypeBox.clear()
5803 5821 self.comboTypeBox.addItem("SpectraHeis")
5804 5822
5805 5823
5806 5824 if name == 'ProcUnit':
5807 5825 id = int(i.id) - 1
5808 5826 name = i.datatype
5809 5827 if name == 'Voltage':
5810 5828 self.comboTypeBox.clear()
5811 5829 self.comboTypeBox.addItem("Spectra")
5812 5830 self.comboTypeBox.addItem("SpectraHeis")
5813 5831 self.comboTypeBox.addItem("Correlation")
5814 5832 if name == 'Spectra':
5815 5833 self.comboTypeBox.clear()
5816 5834 self.comboTypeBox.addItem("Spectra")
5817 5835 self.comboTypeBox.addItem("SpectraHeis")
5818 5836 self.comboTypeBox.addItem("Correlation")
5819 5837 if name == 'SpectraHeis':
5820 5838 self.comboTypeBox.clear()
5821 5839 self.comboTypeBox.addItem("SpectraHeis")
5822 5840
5823 5841 self.comboInputBox.addItem(str(name))
5824 5842 # self.comboInputBox.addItem(str(name)+str(id))
5825 5843
5826 5844 def closeEvent(self, event):
5827 5845 self.closed.emit()
5828 5846 event.accept()
5829 5847
5830 5848 class Ftp(QMainWindow, Ui_Ftp):
5831 5849 """
5832 5850 Class documentation goes here.
5833 5851 """
5834 5852 create = False
5835 5853 closed = pyqtSignal()
5836 5854 server = None
5837 5855 remotefolder = None
5838 5856 username = None
5839 5857 password = None
5840 5858 ftp_wei = None
5841 5859 exp_code = None
5842 5860 sub_exp_code = None
5843 5861 plot_pos = None
5844 5862
5845 5863 def __init__(self, parent=None):
5846 5864 """
5847 5865 Constructor
5848 5866 """
5849 5867 QMainWindow.__init__(self, parent)
5850 5868 self.setupUi(self)
5851 5869 self.setGUIStatus()
5852 5870
5853 5871 def setGUIStatus(self):
5854 5872 self.setWindowTitle("ROJ-Signal Chain")
5855 5873 self.serverFTP.setToolTip('Example: jro-app.igp.gob.pe')
5856 5874 self.folderFTP.setToolTip('Example: /home/wmaster/graficos')
5857 5875 self.usernameFTP.setToolTip('Example: myusername')
5858 5876 self.passwordFTP.setToolTip('Example: mypass ')
5859 5877 self.weightFTP.setToolTip('Example: 0')
5860 5878 self.expcodeFTP.setToolTip('Example: 0')
5861 5879 self.subexpFTP.setToolTip('Example: 0')
5862 5880 self.plotposFTP.setToolTip('Example: 0')
5863 5881
5864 5882 def setParmsfromTemporal(self, server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos):
5865 5883 self.serverFTP.setText(str(server))
5866 5884 self.folderFTP.setText(str(remotefolder))
5867 5885 self.usernameFTP.setText(str(username))
5868 5886 self.passwordFTP.setText(str(password))
5869 5887 self.weightFTP.setText(str(ftp_wei))
5870 5888 self.expcodeFTP.setText(str(exp_code))
5871 5889 self.subexpFTP.setText(str(sub_exp_code))
5872 5890 self.plotposFTP.setText(str(plot_pos))
5873 5891
5874 5892 def getParmsFromFtpWindow(self):
5875 5893 """
5876 5894 Return Inputs Project:
5877 5895 - server
5878 5896 - remotefolder
5879 5897 - username
5880 5898 - password
5881 5899 - ftp_wei
5882 5900 - exp_code
5883 5901 - sub_exp_code
5884 5902 - plot_pos
5885 5903 """
5886 5904 name_server_ftp = str(self.serverFTP.text())
5887 5905 if not name_server_ftp:
5888 5906 self.console.clear()
5889 5907 self.console.append("Please Write a FTP Server")
5890 5908 return 0
5891 5909
5892 5910 folder_server_ftp = str(self.folderFTP.text())
5893 5911 if not folder_server_ftp:
5894 5912 self.console.clear()
5895 5913 self.console.append("Please Write a Folder")
5896 5914 return 0
5897 5915
5898 5916 username_ftp = str(self.usernameFTP.text())
5899 5917 if not username_ftp:
5900 5918 self.console.clear()
5901 5919 self.console.append("Please Write a User Name")
5902 5920 return 0
5903 5921
5904 5922 password_ftp = str(self.passwordFTP.text())
5905 5923 if not password_ftp:
5906 5924 self.console.clear()
5907 5925 self.console.append("Please Write a passwordFTP")
5908 5926 return 0
5909 5927
5910 5928 ftp_wei = str(self.weightFTP.text())
5911 5929 if not ftp_wei == "":
5912 5930 try:
5913 5931 ftp_wei = int(self.weightFTP.text())
5914 5932 except:
5915 5933 self.console.clear()
5916 5934 self.console.append("Please Write a ftp_wei number")
5917 5935 return 0
5918 5936
5919 5937 exp_code = str(self.expcodeFTP.text())
5920 5938 if not exp_code == "":
5921 5939 try:
5922 5940 exp_code = int(self.expcodeFTP.text())
5923 5941 except:
5924 5942 self.console.clear()
5925 5943 self.console.append("Please Write a exp_code number")
5926 5944 return 0
5927 5945
5928 5946
5929 5947 sub_exp_code = str(self.subexpFTP.text())
5930 5948 if not sub_exp_code == "":
5931 5949 try:
5932 5950 sub_exp_code = int(self.subexpFTP.text())
5933 5951 except:
5934 5952 self.console.clear()
5935 5953 self.console.append("Please Write a sub_exp_code number")
5936 5954 return 0
5937 5955
5938 5956 plot_pos = str(self.plotposFTP.text())
5939 5957 if not plot_pos == "":
5940 5958 try:
5941 5959 plot_pos = int(self.plotposFTP.text())
5942 5960 except:
5943 5961 self.console.clear()
5944 5962 self.console.append("Please Write a plot_pos number")
5945 5963 return 0
5946 5964
5947 5965 return name_server_ftp, folder_server_ftp, username_ftp, password_ftp, ftp_wei, exp_code, sub_exp_code, plot_pos
5948 5966
5949 5967 @pyqtSignature("")
5950 5968 def on_ftpOkButton_clicked(self):
5951 5969 server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.getParmsFromFtpWindow()
5952 5970 self.create = True
5953 5971 self.close()
5954 5972
5955 5973 @pyqtSignature("")
5956 5974 def on_ftpCancelButton_clicked(self):
5957 5975 self.create = False
5958 5976 self.close()
5959 5977
5960 5978 def closeEvent(self, event):
5961 5979 self.closed.emit()
5962 5980 event.accept()
5963 5981
5964 5982 class ftpBuffer():
5965 5983
5966 5984 server = None
5967 5985 remotefolder = None
5968 5986 username = None
5969 5987 password = None
5970 5988 ftp_wei = None
5971 5989 exp_code = None
5972 5990 sub_exp_code = None
5973 5991 plot_pos = None
5974 5992 create = False
5975 5993 withoutconfig = False
5976 5994 createforView = False
5977 5995 localfolder = None
5978 5996 extension = None
5979 5997 period = None
5980 5998 protocol = None
5981 5999
5982 6000 def __init__(self):
5983 6001
5984 6002 self.create = False
5985 6003 self.server = None
5986 6004 self.remotefolder = None
5987 6005 self.username = None
5988 6006 self.password = None
5989 6007 self.ftp_wei = None
5990 6008 self.exp_code = None
5991 6009 self.sub_exp_code = None
5992 6010 self.plot_pos = None
5993 6011 # self.create = False
5994 6012 self.localfolder = None
5995 6013 self.extension = None
5996 6014 self.period = None
5997 6015 self.protocol = None
5998 6016
5999 6017 def setwithoutconfiguration(self):
6000 6018
6001 6019 self.create = False
6002 6020 self.server = "jro-app.igp.gob.pe"
6003 6021 self.remotefolder = "/home/wmaster/graficos"
6004 6022 self.username = "wmaster"
6005 6023 self.password = "mst2010vhf"
6006 6024 self.withoutconfig = True
6007 6025 self.localfolder = './'
6008 6026 self.extension = '.png'
6009 6027 self.period = 60
6010 6028 self.protocol = 'ftp'
6011 6029 self.createforView = True
6012 6030
6013 6031 if not self.ftp_wei:
6014 6032 self.ftp_wei = 0
6015 6033
6016 6034 if not self.exp_code:
6017 6035 self.exp_code = 0
6018 6036
6019 6037 if not self.sub_exp_code:
6020 6038 self.sub_exp_code = 0
6021 6039
6022 6040 if not self.plot_pos:
6023 6041 self.plot_pos = 0
6024 6042
6025 6043 def save(self, server, remotefolder, username, password, ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, localfolder='./', extension='.png', period=60, protocol='ftp'):
6026 6044
6027 6045 self.server = server
6028 6046 self.remotefolder = remotefolder
6029 6047 self.username = username
6030 6048 self.password = password
6031 6049 self.ftp_wei = ftp_wei
6032 6050 self.exp_code = exp_code
6033 6051 self.sub_exp_code = sub_exp_code
6034 6052 self.plot_pos = plot_pos
6035 6053 self.create = True
6036 6054 self.withoutconfig = False
6037 6055 self.createforView = True
6038 6056 self.localfolder = localfolder
6039 6057 self.extension = extension
6040 6058 self.period = period
6041 6059 self.protocol = protocol
6042 6060
6043 6061 def recover(self):
6044 6062
6045 6063 return self.server, self.remotefolder, self.username, self.password, self.ftp_wei, self.exp_code, self.sub_exp_code, self.plot_pos, self.extension, self.period, self.protocol
6046 6064
6047 6065 class ShowMeConsole(QtCore.QObject):
6048 6066
6049 6067 textWritten = QtCore.pyqtSignal(str)
6050 6068
6051 6069 def write(self, text):
6052 6070
6053 6071 if len(text) == 0:
6054 6072 self.textWritten.emit("\n")
6055 6073 return
6056 6074
6057 6075 if text[-1] == "\n":
6058 6076 text = text[:-1]
6059 6077
6060 6078 self.textWritten.emit(str(text))
Show file before | Show file after | Hide comments
@@ -1,388 +1,407
1 1
2 2 from PyQt4 import QtCore, QtGui
3 3
4 4 try:
5 5 _fromUtf8 = QtCore.QString.fromUtf8
6 6 except AttributeError:
7 7 def _fromUtf8(s):
8 8 return s
9 9
10 10 try:
11 11 _encoding = QtGui.QApplication.UnicodeUTF8
12 12 def _translate(context, text, disambig):
13 13 return QtGui.QApplication.translate(context, text, disambig, _encoding)
14 14 except AttributeError:
15 15 def _translate(context, text, disambig):
16 16 return QtGui.QApplication.translate(context, text, disambig)
17 17
18 18 class Ui_VoltageTab(object):
19 19
20 20 def setupUi(self):
21 21
22 22 self.tabVoltage = QtGui.QWidget()
23 23 self.tabVoltage.setObjectName(_fromUtf8("tabVoltage"))
24 24
25 25 self.gridLayout_3 = QtGui.QGridLayout(self.tabVoltage)
26 26 self.gridLayout_3.setObjectName(_fromUtf8("gridLayout_3"))
27 27
28 28 self.frame_4 = QtGui.QFrame(self.tabVoltage)
29 29 self.frame_4.setFrameShape(QtGui.QFrame.StyledPanel)
30 30 self.frame_4.setFrameShadow(QtGui.QFrame.Raised)
31 31 self.frame_4.setObjectName(_fromUtf8("frame_4"))
32 32
33 33 self.gridLayout_17 = QtGui.QGridLayout(self.frame_4)
34 34 self.gridLayout_17.setObjectName(_fromUtf8("gridLayout_17"))
35 35 self.volOpOk = QtGui.QPushButton(self.frame_4)
36 36 self.volOpOk.setObjectName(_fromUtf8("volOpOk"))
37 37 self.gridLayout_17.addWidget(self.volOpOk, 0, 0, 1, 1)
38 38 self.volGraphClear = QtGui.QPushButton(self.frame_4)
39 39 self.volGraphClear.setObjectName(_fromUtf8("volGraphClear"))
40 40 self.gridLayout_17.addWidget(self.volGraphClear, 0, 1, 1, 1)
41 41 self.gridLayout_3.addWidget(self.frame_4, 1, 1, 1, 1)
42 42
43 43
44 44 self.tabWidgetVoltage = QtGui.QTabWidget(self.tabVoltage)
45 45 self.tabWidgetVoltage.setObjectName(_fromUtf8("tabWidgetVoltage"))
46 46 self.tabopVoltage = QtGui.QWidget()
47 47 self.tabopVoltage.setObjectName(_fromUtf8("tabopVoltage"))
48 48 self.gridLayout = QtGui.QGridLayout(self.tabopVoltage)
49 49 self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
50 50
51 51 self.volOpCebRadarfrequency = QtGui.QCheckBox(self.tabopVoltage)
52 52 self.volOpCebRadarfrequency.setObjectName(_fromUtf8("volOpCebRadarfrequency"))
53 53 self.gridLayout.addWidget(self.volOpCebRadarfrequency, 0, 0, 1, 1)
54 54
55 55 self.volOpRadarfrequency = QtGui.QLineEdit(self.tabopVoltage)
56 56 self.volOpRadarfrequency.setObjectName(_fromUtf8("volOpRadarfrequency"))
57 57 self.gridLayout.addWidget(self.volOpRadarfrequency, 0, 1, 1, 4)
58 58
59 59 self.volOpCebChannels = QtGui.QCheckBox(self.tabopVoltage)
60 60 self.volOpCebChannels.setObjectName(_fromUtf8("volOpCebChannels"))
61 61 self.gridLayout.addWidget(self.volOpCebChannels, 1, 0, 1, 1)
62 62
63 63 self.volOpComChannels = QtGui.QComboBox(self.tabopVoltage)
64 64 self.volOpComChannels.setObjectName(_fromUtf8("volOpComChannels"))
65 65 self.volOpComChannels.addItem(_fromUtf8(""))
66 66 self.volOpComChannels.addItem(_fromUtf8(""))
67 67 self.gridLayout.addWidget(self.volOpComChannels, 1, 1, 1, 2)
68 68
69 69 self.volOpChannel = QtGui.QLineEdit(self.tabopVoltage)
70 70 self.volOpChannel.setObjectName(_fromUtf8("volOpChannel"))
71 71 self.gridLayout.addWidget(self.volOpChannel, 1, 3, 1, 2)
72 72
73 73
74 74 self.volOpCebHeights = QtGui.QCheckBox(self.tabopVoltage)
75 75 self.volOpCebHeights.setObjectName(_fromUtf8("volOpCebHeights"))
76 76 self.gridLayout.addWidget(self.volOpCebHeights, 3, 0, 1, 1)
77 77
78 78 self.volOpComHeights = QtGui.QComboBox(self.tabopVoltage)
79 79 self.volOpComHeights.setObjectName(_fromUtf8("volOpComHeights"))
80 80 self.volOpComHeights.addItem(_fromUtf8(""))
81 81 self.volOpComHeights.addItem(_fromUtf8(""))
82 82 self.gridLayout.addWidget(self.volOpComHeights, 3, 1, 1, 2)
83 83
84 84 self.volOpHeights = QtGui.QLineEdit(self.tabopVoltage)
85 85 self.volOpHeights.setObjectName(_fromUtf8("volOpHeights"))
86 86 self.gridLayout.addWidget(self.volOpHeights, 3, 3, 1, 2)
87 87
88 88
89 89
90 90 self.volOpCebProfile = QtGui.QCheckBox(self.tabopVoltage)
91 91 self.volOpCebProfile.setObjectName(_fromUtf8("volOpCebProfile"))
92 92 self.gridLayout.addWidget(self.volOpCebProfile, 5, 0, 1, 1)
93 93
94 94 self.volOpComProfile = QtGui.QComboBox(self.tabopVoltage)
95 95 self.volOpComProfile.setObjectName(_fromUtf8("volOpComProfile"))
96 96 self.volOpComProfile.addItem(_fromUtf8(""))
97 97 self.volOpComProfile.addItem(_fromUtf8(""))
98 98 self.volOpComProfile.addItem(_fromUtf8(""))
99 99 self.gridLayout.addWidget(self.volOpComProfile, 5, 1, 1, 2)
100 100
101 101 self.volOpProfile = QtGui.QLineEdit(self.tabopVoltage)
102 102 self.volOpProfile.setObjectName(_fromUtf8("volOpProfile"))
103 103 self.gridLayout.addWidget(self.volOpProfile, 5, 3, 1, 2)
104 104
105 105 self.volOpCebReshaper = QtGui.QCheckBox(self.tabopVoltage)
106 106 self.volOpCebReshaper.setObjectName(_fromUtf8("volOpCebReshaper"))
107 107 self.gridLayout.addWidget(self.volOpCebReshaper, 6, 0, 1, 1)
108 108
109 109 self.volOpReshaper = QtGui.QLineEdit(self.tabopVoltage)
110 110 self.volOpReshaper.setObjectName(_fromUtf8("volOpReshaper"))
111 111 self.gridLayout.addWidget(self.volOpReshaper, 6, 1, 1, 4)
112 112
113 113 self.volOpCebFilter = QtGui.QCheckBox(self.tabopVoltage)
114 114 self.volOpCebFilter.setObjectName(_fromUtf8("volOpCebFilter"))
115 115 self.gridLayout.addWidget(self.volOpCebFilter, 7, 0, 1, 1)
116 116
117 117 self.volOpFilter = QtGui.QLineEdit(self.tabopVoltage)
118 118 self.volOpFilter.setObjectName(_fromUtf8("volOpFilter"))
119 119 self.gridLayout.addWidget(self.volOpFilter, 7, 1, 1, 4)
120 120
121 121 # spacerItem = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
122 122 # self.gridLayout.addItem(spacerItem, 6, 4, 1, 1)
123 123 # spacerItem1 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
124 124 # self.gridLayout.addItem(spacerItem1, 8, 4, 1, 1)
125 125 # spacerItem2 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
126 126 # self.gridLayout.addItem(spacerItem2, 3, 4, 1, 1)
127 127
128 128
129 129
130 130 # spacerItem3 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
131 131 # self.gridLayout.addItem(spacerItem3, 1, 4, 1, 1)
132 132
133 133
134 134 self.volOpCebDecodification = QtGui.QCheckBox(self.tabopVoltage)
135 135 self.volOpCebDecodification.setObjectName(_fromUtf8("volOpCebDecodification"))
136 136 self.gridLayout.addWidget(self.volOpCebDecodification, 8, 0, 1, 1)
137 137
138 138 self.volLabCodeMode = QtGui.QLabel(self.tabopVoltage)
139 139 self.volLabCodeMode.setObjectName(_fromUtf8("volLabCodeMode"))
140 140 self.gridLayout.addWidget(self.volLabCodeMode, 8, 1, 1, 1)
141 141
142 142 self.volOpComMode = QtGui.QComboBox(self.tabopVoltage)
143 143 self.volOpComMode.setObjectName(_fromUtf8("volOpComMode"))
144 144 self.volOpComMode.addItem(_fromUtf8(""))
145 145 self.volOpComMode.addItem(_fromUtf8(""))
146 146 self.gridLayout.addWidget(self.volOpComMode, 8, 2, 1, 3)
147 147
148 148 self.volLabCodeType = QtGui.QLabel(self.tabopVoltage)
149 149 self.volLabCodeType.setObjectName(_fromUtf8("volLabCodeType"))
150 150 self.gridLayout.addWidget(self.volLabCodeType, 9, 1, 1, 1)
151 151
152 152 self.volOpComCode = QtGui.QComboBox(self.tabopVoltage)
153 153 self.volOpComCode.setObjectName(_fromUtf8("volOpComCode"))
154 154 self.volOpComCode.addItem(_fromUtf8(""))
155 155 self.volOpComCode.addItem(_fromUtf8(""))
156 156 self.volOpComCode.addItem(_fromUtf8(""))
157 157 self.volOpComCode.addItem(_fromUtf8(""))
158 158 self.volOpComCode.addItem(_fromUtf8(""))
159 159 self.volOpComCode.addItem(_fromUtf8(""))
160 160 self.volOpComCode.addItem(_fromUtf8(""))
161 161 self.volOpComCode.addItem(_fromUtf8(""))
162 162 self.volOpComCode.addItem(_fromUtf8(""))
163 163 self.volOpComCode.addItem(_fromUtf8(""))
164 164 self.volOpComCode.addItem(_fromUtf8(""))
165 165 self.volOpComCode.addItem(_fromUtf8(""))
166 166 self.volOpComCode.addItem(_fromUtf8(""))
167 167 self.volOpComCode.addItem(_fromUtf8(""))
168 168 self.gridLayout.addWidget(self.volOpComCode, 9, 2, 1, 3)
169 169
170 170 self.volLabCode = QtGui.QLabel(self.tabopVoltage)
171 171 self.volLabCode.setObjectName(_fromUtf8("volLabCode"))
172 172 self.gridLayout.addWidget(self.volLabCode, 10, 1, 1, 1)
173 173
174 174 self.volOpCode = QtGui.QLineEdit(self.tabopVoltage)
175 175 self.volOpCode.setObjectName(_fromUtf8("volOpCode"))
176 176 self.gridLayout.addWidget(self.volOpCode, 10, 2, 1, 3)
177 177
178 178 self.volOpCebFlip = QtGui.QCheckBox(self.tabopVoltage)
179 179 self.volOpCebFlip.setObjectName(_fromUtf8("volOpCebFlip"))
180 180 self.gridLayout.addWidget(self.volOpCebFlip, 11, 0, 1, 1)
181 181
182 182 self.volOpFlip = QtGui.QLineEdit(self.tabopVoltage)
183 183 self.volOpFlip.setObjectName(_fromUtf8("volOpFlip"))
184 184 self.gridLayout.addWidget(self.volOpFlip, 11, 1, 1, 4)
185 185
186 186 self.volOpCebCohInt = QtGui.QCheckBox(self.tabopVoltage)
187 187 self.volOpCebCohInt.setObjectName(_fromUtf8("volOpCebCohInt"))
188 188 self.gridLayout.addWidget(self.volOpCebCohInt, 12, 0, 1, 1)
189 189
190 190 self.volOpCohInt = QtGui.QLineEdit(self.tabopVoltage)
191 191 self.volOpCohInt.setObjectName(_fromUtf8("volOpCohInt"))
192 192 self.gridLayout.addWidget(self.volOpCohInt, 12, 1, 1, 4)
193 193
194 194 self.volOpCebAdjustHei = QtGui.QCheckBox(self.tabopVoltage)
195 195 self.volOpCebAdjustHei.setObjectName(_fromUtf8("volOpCebAdjustHei"))
196 196 self.gridLayout.addWidget(self.volOpCebAdjustHei, 13, 0, 1, 1)
197 197
198 198 self.volOpAdjustHei = QtGui.QLineEdit(self.tabopVoltage)
199 199 self.volOpAdjustHei.setObjectName(_fromUtf8("volOpAdjustHei"))
200 200 self.gridLayout.addWidget(self.volOpAdjustHei, 13, 1, 1, 4)
201 201
202 202 self.tabWidgetVoltage.addTab(self.tabopVoltage, _fromUtf8(""))
203 203
204 204 self.tabgraphVoltage = QtGui.QWidget()
205 205 self.tabgraphVoltage.setObjectName(_fromUtf8("tabgraphVoltage"))
206 206 self.gridLayout_6 = QtGui.QGridLayout(self.tabgraphVoltage)
207 207 self.gridLayout_6.setObjectName(_fromUtf8("gridLayout_6"))
208 208 spacerItem4 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
209 209 self.gridLayout_6.addItem(spacerItem4, 12, 3, 1, 1)
210 self.volGraphfreqrange = QtGui.QLineEdit(self.tabgraphVoltage)
211 self.volGraphfreqrange.setObjectName(_fromUtf8("volGraphfreqrange"))
212 self.gridLayout_6.addWidget(self.volGraphfreqrange, 9, 1, 1, 6)
210 self.volGraphIntensityRange = QtGui.QLineEdit(self.tabgraphVoltage)
211 self.volGraphIntensityRange.setObjectName(_fromUtf8("volGraphIntensityRange"))
212 self.gridLayout_6.addWidget(self.volGraphIntensityRange, 9, 1, 1, 6)
213 213 self.volGraphPrefix = QtGui.QLineEdit(self.tabgraphVoltage)
214 214 self.volGraphPrefix.setObjectName(_fromUtf8("volGraphPrefix"))
215 215 self.gridLayout_6.addWidget(self.volGraphPrefix, 2, 1, 1, 6)
216 216 self.volGraphToolPath = QtGui.QToolButton(self.tabgraphVoltage)
217 217 self.volGraphToolPath.setObjectName(_fromUtf8("volGraphToolPath"))
218 218 self.gridLayout_6.addWidget(self.volGraphToolPath, 1, 5, 1, 2)
219 219 self.volGraphPath = QtGui.QLineEdit(self.tabgraphVoltage)
220 220 self.volGraphPath.setObjectName(_fromUtf8("volGraphPath"))
221 221 self.gridLayout_6.addWidget(self.volGraphPath, 1, 1, 1, 4)
222 222 self.label_14 = QtGui.QLabel(self.tabgraphVoltage)
223 223 self.label_14.setObjectName(_fromUtf8("label_14"))
224 224 self.gridLayout_6.addWidget(self.label_14, 6, 0, 1, 1)
225 225 spacerItem5 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
226 226 self.gridLayout_6.addItem(spacerItem5, 3, 3, 1, 1)
227 227 self.label_8 = QtGui.QLabel(self.tabgraphVoltage)
228 228 self.label_8.setObjectName(_fromUtf8("label_8"))
229 229 self.gridLayout_6.addWidget(self.label_8, 8, 0, 1, 1)
230 230 self.label_49 = QtGui.QLabel(self.tabgraphVoltage)
231 231 self.label_49.setObjectName(_fromUtf8("label_49"))
232 232 self.gridLayout_6.addWidget(self.label_49, 4, 3, 1, 1)
233 233 self.label_51 = QtGui.QLabel(self.tabgraphVoltage)
234 234 self.label_51.setObjectName(_fromUtf8("label_51"))
235 235 self.gridLayout_6.addWidget(self.label_51, 9, 0, 1, 1)
236 236 self.volGraphCebshow = QtGui.QCheckBox(self.tabgraphVoltage)
237 237 self.volGraphCebshow.setText(_fromUtf8(""))
238 238 self.volGraphCebshow.setObjectName(_fromUtf8("volGraphCebshow"))
239 239 self.gridLayout_6.addWidget(self.volGraphCebshow, 6, 3, 1, 1)
240 240 self.label_12 = QtGui.QLabel(self.tabgraphVoltage)
241 241 self.label_12.setObjectName(_fromUtf8("label_12"))
242 242 self.gridLayout_6.addWidget(self.label_12, 1, 0, 1, 1)
243 243 self.label_13 = QtGui.QLabel(self.tabgraphVoltage)
244 244 self.label_13.setObjectName(_fromUtf8("label_13"))
245 245 self.gridLayout_6.addWidget(self.label_13, 2, 0, 1, 1)
246 246 self.label_52 = QtGui.QLabel(self.tabgraphVoltage)
247 247 self.label_52.setObjectName(_fromUtf8("label_52"))
248
248 249 self.gridLayout_6.addWidget(self.label_52, 11, 0, 1, 1)
249 250 spacerItem6 = QtGui.QSpacerItem(40, 12, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
250 251 self.gridLayout_6.addItem(spacerItem6, 14, 5, 1, 2)
251 252 spacerItem7 = QtGui.QSpacerItem(18, 12, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
252 253 self.gridLayout_6.addItem(spacerItem7, 14, 3, 1, 1)
254
255 self.volLabScopeType = QtGui.QLabel(self.tabgraphVoltage)
256 self.volLabScopeType.setObjectName(_fromUtf8("volLabScopeType"))
257 self.gridLayout_6.addWidget(self.volLabScopeType, 7, 0, 1, 1)
258
259 self.volComScopeType = QtGui.QComboBox(self.tabgraphVoltage)
260 self.volComScopeType.setObjectName(_fromUtf8("volComScopeType"))
261 self.volComScopeType.addItem(_fromUtf8(""))
262 self.volComScopeType.addItem(_fromUtf8(""))
263 self.gridLayout_6.addWidget(self.volComScopeType, 7, 1, 1, 6)
264
253 265 self.volGraphChannelList = QtGui.QLineEdit(self.tabgraphVoltage)
254 266 self.volGraphChannelList.setObjectName(_fromUtf8("volGraphChannelList"))
255 267 self.gridLayout_6.addWidget(self.volGraphChannelList, 8, 1, 1, 6)
268
269
256 270 self.volGraphHeightrange = QtGui.QLineEdit(self.tabgraphVoltage)
257 271 self.volGraphHeightrange.setObjectName(_fromUtf8("volGraphHeightrange"))
258 272 self.gridLayout_6.addWidget(self.volGraphHeightrange, 11, 1, 1, 6)
259 273 self.label_50 = QtGui.QLabel(self.tabgraphVoltage)
260 274 self.label_50.setObjectName(_fromUtf8("label_50"))
261 275 self.gridLayout_6.addWidget(self.label_50, 4, 4, 1, 1)
262 276 self.volGraphCebSave = QtGui.QCheckBox(self.tabgraphVoltage)
263 277 self.volGraphCebSave.setText(_fromUtf8(""))
264 278 self.volGraphCebSave.setObjectName(_fromUtf8("volGraphCebSave"))
265 279 self.gridLayout_6.addWidget(self.volGraphCebSave, 6, 4, 1, 1)
266 280 self.tabWidgetVoltage.addTab(self.tabgraphVoltage, _fromUtf8(""))
267 281
268 282 self.taboutputVoltage = QtGui.QWidget()
269 283 self.taboutputVoltage.setObjectName(_fromUtf8("taboutputVoltage"))
270 284 self.gridLayout_12 = QtGui.QGridLayout(self.taboutputVoltage)
271 285 self.gridLayout_12.setObjectName(_fromUtf8("gridLayout_12"))
272 286 self.label_36 = QtGui.QLabel(self.taboutputVoltage)
273 287 self.label_36.setObjectName(_fromUtf8("label_36"))
274 288 self.gridLayout_12.addWidget(self.label_36, 0, 0, 1, 1)
275 289 self.label_37 = QtGui.QLabel(self.taboutputVoltage)
276 290 self.label_37.setObjectName(_fromUtf8("label_37"))
277 291 self.gridLayout_12.addWidget(self.label_37, 1, 0, 1, 1)
278 292 self.volOutputPath = QtGui.QLineEdit(self.taboutputVoltage)
279 293 self.volOutputPath.setObjectName(_fromUtf8("volOutputPath"))
280 294 self.gridLayout_12.addWidget(self.volOutputPath, 1, 2, 1, 1)
281 295 self.volOutputToolPath = QtGui.QToolButton(self.taboutputVoltage)
282 296 self.volOutputToolPath.setObjectName(_fromUtf8("volOutputToolPath"))
283 297 self.gridLayout_12.addWidget(self.volOutputToolPath, 1, 3, 1, 1)
284 298 self.volOutputComData = QtGui.QComboBox(self.taboutputVoltage)
285 299 self.volOutputComData.setObjectName(_fromUtf8("volOutputComData"))
286 300 self.volOutputComData.addItem(_fromUtf8(""))
287 301 self.gridLayout_12.addWidget(self.volOutputComData, 0, 2, 1, 2)
288 302 spacerItem8 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
289 303 self.gridLayout_12.addItem(spacerItem8, 5, 2, 1, 1)
290 304 self.volOutputblocksperfile = QtGui.QLineEdit(self.taboutputVoltage)
291 305 self.volOutputblocksperfile.setObjectName(_fromUtf8("volOutputblocksperfile"))
292 306 self.gridLayout_12.addWidget(self.volOutputblocksperfile, 3, 2, 1, 1)
293 307 self.label_7 = QtGui.QLabel(self.taboutputVoltage)
294 308 self.label_7.setObjectName(_fromUtf8("label_7"))
295 309 self.gridLayout_12.addWidget(self.label_7, 3, 0, 1, 1)
296 310 self.label_35 = QtGui.QLabel(self.taboutputVoltage)
297 311 self.label_35.setObjectName(_fromUtf8("label_35"))
298 312 self.gridLayout_12.addWidget(self.label_35, 4, 0, 1, 1)
299 313 self.volOutputprofilesperblock = QtGui.QLineEdit(self.taboutputVoltage)
300 314 self.volOutputprofilesperblock.setObjectName(_fromUtf8("volOutputprofilesperblock"))
301 315 self.gridLayout_12.addWidget(self.volOutputprofilesperblock, 4, 2, 1, 1)
302 316 self.tabWidgetVoltage.addTab(self.taboutputVoltage, _fromUtf8(""))
303 317 self.gridLayout_3.addWidget(self.tabWidgetVoltage, 0, 1, 1, 1)
304 318
305 319 self.tabWidgetProject.addTab(self.tabVoltage, _fromUtf8(""))
306 320
307 321 self.tabWidgetVoltage.setCurrentIndex(0)
308 322
309 323 def retranslateUi(self):
310 324
311 325 self.volOpOk.setText(_translate("MainWindow", "Ok", None))
312 326 self.volGraphClear.setText(_translate("MainWindow", "Clear", None))
313 327 self.volOpComHeights.setItemText(0, _translate("MainWindow", "Value", None))
314 328 self.volOpComHeights.setItemText(1, _translate("MainWindow", "Index", None))
315 329 self.volOpComChannels.setItemText(0, _translate("MainWindow", "Value", None))
316 330 self.volOpComChannels.setItemText(1, _translate("MainWindow", "Index", None))
317 331 self.volOpCebProfile.setText(_translate("MainWindow", "Select Profiles", None))
318 332 self.volOpComProfile.setItemText(0, _translate("MainWindow", "Profile List", None))
319 333 self.volOpComProfile.setItemText(1, _translate("MainWindow", "Profile Range", None))
320 334 self.volOpComProfile.setItemText(2, _translate("MainWindow", "List of Profile Ranges", None))
321 335 self.volOpCebDecodification.setText(_translate("MainWindow", "Decoder:", None))
322 336 self.volOpCebCohInt.setText(_translate("MainWindow", "Coherent Integration:", None))
323 337 self.volOpCebFlip.setText(_translate("MainWindow", "Flip:", None))
324 338 self.volLabCodeType.setText(_translate("MainWindow", "Code type:", None))
325 339 self.volOpCebChannels.setText(_translate("MainWindow", "Select Channels:", None))
326 340 self.volOpCebHeights.setText(_translate("MainWindow", "Select Heights:", None))
327 341 self.volOpCebFilter.setText(_translate("MainWindow", "Filter:", None))
328 342 self.volOpCebReshaper.setText(_translate("MainWindow", "Reshape data: ", None))
329 343 self.volOpCebRadarfrequency.setText(_translate("MainWindow", "Radar frequency (MHz):", None))
330 344 self.volLabCodeMode.setText(_translate("MainWindow", "Mode:", None))
331 345 self.volLabCode.setText(_translate("MainWindow", "Code:", None))
332 346 self.volOpComCode.setItemText(0, _translate("MainWindow", "Read from header", None))
333 347 self.volOpComCode.setItemText(1, _translate("MainWindow", "Barker 3", None))
334 348 self.volOpComCode.setItemText(2, _translate("MainWindow", "Barker 4", None))
335 349 self.volOpComCode.setItemText(3, _translate("MainWindow", "Barker 5", None))
336 350 self.volOpComCode.setItemText(4, _translate("MainWindow", "Barker 7", None))
337 351 self.volOpComCode.setItemText(5, _translate("MainWindow", "Barker 11", None))
338 352 self.volOpComCode.setItemText(6, _translate("MainWindow", "Barker 13", None))
339 353 self.volOpComCode.setItemText(7, _translate("MainWindow", "Barker 3 + Comp.", None))
340 354 self.volOpComCode.setItemText(8, _translate("MainWindow", "Barker 4 + Comp.", None))
341 355 self.volOpComCode.setItemText(9, _translate("MainWindow", "Barker 5 + Comp.", None))
342 356 self.volOpComCode.setItemText(10, _translate("MainWindow", "Barker 7 + Comp.", None))
343 357 self.volOpComCode.setItemText(11, _translate("MainWindow", "Barker 11+ Comp.", None))
344 358 self.volOpComCode.setItemText(12, _translate("MainWindow", "Barker 13+ Comp.", None))
345 359 self.volOpComCode.setItemText(13, _translate("MainWindow", "User defined", None))
346 360 self.volOpComMode.setItemText(0, _translate("MainWindow", "Time", None))
347 361 self.volOpComMode.setItemText(1, _translate("MainWindow", "Frequency", None))
348 362 self.volOpCebAdjustHei.setText(_translate("MainWindow", "Calibrate H0:", None))
349 363
350 364 self.tabWidgetVoltage.setTabText(self.tabWidgetVoltage.indexOf(self.tabopVoltage), _translate("MainWindow", "Operation", None))
351 365
352 366 self.volGraphToolPath.setText(_translate("MainWindow", "...", None))
353 367 self.label_14.setText(_translate("MainWindow", "Scope:", None))
354 368 self.label_8.setText(_translate("MainWindow", "Channel List:", None))
355 369 self.label_49.setText(_translate("MainWindow", "Show:", None))
356 self.label_51.setText(_translate("MainWindow", "Height range:", None))
370 self.label_51.setText(_translate("MainWindow", "Amplitude/Intensity:", None))
357 371 self.label_12.setText(_translate("MainWindow", "Path :", None))
358 372 self.label_13.setText(_translate("MainWindow", "Figure name:", None))
359 self.label_52.setText(_translate("MainWindow", "Amplitude:", None))
373 self.label_52.setText(_translate("MainWindow", "Height range:", None))
360 374 self.label_50.setText(_translate("MainWindow", "Save:", None))
375
376 self.volLabScopeType.setText(_translate("MainWindow", "Scope type:", None))
377 self.volComScopeType.setItemText(0, _translate("MainWindow", "I&Q", None))
378 self.volComScopeType.setItemText(1, _translate("MainWindow", "Power", None))
379
361 380 self.tabWidgetVoltage.setTabText(self.tabWidgetVoltage.indexOf(self.tabgraphVoltage), _translate("MainWindow", "Graphics", None))
362 381
363 382 self.label_36.setText(_translate("MainWindow", "Type:", None))
364 383 self.label_37.setText(_translate("MainWindow", "Path:", None))
365 384 self.volOutputToolPath.setText(_translate("MainWindow", "...", None))
366 385 self.volOutputComData.setItemText(0, _translate("MainWindow", ".rawdata", None))
367 386 self.label_7.setText(_translate("MainWindow", "Blocks per File: ", None))
368 387 self.label_35.setText(_translate("MainWindow", "Profiles per Block: ", None))
369 388 self.tabWidgetVoltage.setTabText(self.tabWidgetVoltage.indexOf(self.taboutputVoltage), _translate("MainWindow", "Output", None))
370 389
371 390 self.tabWidgetProject.setTabText(self.tabWidgetProject.indexOf(self.tabVoltage), _translate("MainWindow", "Voltage", None))
372 391
373 392 self.__setToolTip()
374 393
375 394 def __setToolTip(self):
376 395
377 396 self.volOpChannel.setToolTip('Example: 1,2,3,4,5')
378 397 self.volOpHeights.setToolTip('Example: 90,180')
379 398 self.volOpFilter.setToolTip('Example: 2')
380 399 self.volOpProfile.setToolTip('Example:0,127')
381 400 self.volOpCohInt.setToolTip('Example: 128')
382 401 self.volOpFlip.setToolTip('ChannelList where flip will be applied. Example: 0,2,3')
383 402 self.volOpOk.setToolTip('If you have finished, please Ok ')
384 403 # tool tip gui volGraph
385 self.volGraphfreqrange.setToolTip('Height range. Example: 50,100')
404 self.volGraphIntensityRange.setToolTip('Height range. Example: 50,100')
386 405 self.volGraphHeightrange.setToolTip('Amplitude. Example: 0,10000')
387 406
388 407 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now