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