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