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