addin' readme

.gitignore

@@ -0,0 +1,4 @@
+*.pyc
+*.project
+*.pydevproject
+

PrawoWiazkiApp.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+'''
+Created on 5 Feb 2016
+
+@author: kamichal
+'''
+
+from PyQt4 import QtGui, QtCore
+
+from WzorErlanga import ErlangB
+from PyQtKaWig import SuwakPoziomy, WidzetWykres
+
+from matplotlib.font_manager import FontProperties
+
+class WatekObliczeniowy(QtCore.QThread):
+    ''' Obliczenia sa wykonywane w osobnym watku. 
+    Kiedy watek sie konczy, sane sa wysylane przez sygnal '''
+    sygnalPoliczone = QtCore.pyqtSignal(dict)
+
+    def __init__(self, parent = None):
+        super(WatekObliczeniowy, self).__init__(parent)
+        self.parent = parent
+
+    @QtCore.pyqtSlot(dict)
+    def SlotZamowNowy(self, slownik):
+            self.zamowienie = slownik
+            self.start()  # uruchom watek
+
+    def run(self):
+        try:
+            sloZ = self.zamowienie
+            if 'typ' in sloZ.keys():
+                A = sloZ['wartA']
+                N = sloZ['wartN']
+                XX = self.__dziedzinaX(A, sloZ['typ'])
+                self.zamowienie['EbX'] = XX
+                self.zamowienie['EbY'] = ErlangB(XX, N)
+                (self.zamowienie['kursorX'],
+                 self.zamowienie['kursorY']) = self.__GenerujKursor(A,N)
+
+                if 'podpis' in self.zamowienie.keys():
+                    self.zamowienie['podpisPlus'] = \
+                    (self.zamowienie['podpis'] + '= %.3f' % ErlangB(A, N))
+
+                if self.zamowienie['podgPW']:
+                    ErB2 = ErlangB(2*A, 2*N)
+                    self.zamowienie['kursor2X'] = 2*A
+                    self.zamowienie['kursor2Y'] = ErB2
+                    if 'podpis' in self.zamowienie.keys():
+                        self.zamowienie['podpisPlus'] += (
+                               ' (Eb2= %.3f)' % ErB2)
+
+                self.sygnalPoliczone.emit(self.zamowienie)
+            else:
+                print 'bledny slownik zamowienia'
+
+        except (RuntimeError, TypeError, NameError):
+            raise ('Blad slownika')
+
+    def __dziedzinaX(self, x_zamawiane, typ):
+        if typ == 'podglad':
+            Npkt = 32
+        else:
+            Npkt = 200
+        x_max = max(32, x_zamawiane)
+        return [(1.0 * x * x_max / Npkt) for x in range(Npkt)]
+
+    def __GenerujKursor(self, A, N):
+        XX = [A, A, 0]
+        erlb = ErlangB(A, N)
+        YY = [0, erlb, erlb]
+        return (XX, YY)
+
+
+class FormularzKreslenia(QtGui.QWidget):
+    sygNowyFormularz = QtCore.pyqtSignal(dict)
+
+    def __init__(self, parent = None):
+        super(FormularzKreslenia, self).__init__(parent)
+        self.setMaximumHeight(72)
+
+
+        self.ukladLewy = QtGui.QVBoxLayout()
+        self.ukladPrawy = QtGui.QVBoxLayout()
+        self.ukladPrzyciskow = QtGui.QHBoxLayout()
+
+        self.parN = SuwakPoziomy(self, 'N', u'linii\nsieci')
+        self.parN.UstawMax(170) # silnia wiecej nie wyrobi
+        self.parN.SygnSuwakPoszedl.connect(self.__SlotZmianaFormularza)
+
+        self.parA = SuwakPoziomy(self, 'A', u'abonentow')
+        self.parA.UstawMax(600)
+        self.parA.SygnSuwakPoszedl.connect(self.__SlotZmianaFormularza)
+
+        self.ukladLewy.addWidget(self.parN)
+        self.ukladLewy.addWidget(self.parA)
+
+        self.opisSeriiDanych = QtGui.QLineEdit(self)
+        self.opisSeriiDanych.setText('wykres')
+
+        self.wyswPrawoWiazki = QtGui.QCheckBox(self)
+        self.wyswPrawoWiazki.setText(u'wyświetl Prawo\nWiązki (2N,2A)')
+        self.wyswPrawoWiazki.clicked.connect(self.__SlotZmianaFormularza)
+
+        self.zatwierdz = QtGui.QPushButton(self)
+        self.zatwierdz.setText(u'wykreśl')
+        self.zatwierdz.setMinimumHeight(30)
+        self.zatwierdz.clicked.connect(self.__SlotZlozZamowienie)
+
+        self.zmazik = QtGui.QPushButton(self)
+        self.zmazik.setText(u'wyczyść')
+        self.zmazik.setMinimumHeight(30)
+        self.zmazik.clicked.connect(parent.SlotCzysc)
+
+        self.ukladPrzyciskow.addWidget(self.wyswPrawoWiazki)
+        self.ukladPrzyciskow.addWidget(self.zatwierdz)
+        self.ukladPrzyciskow.addWidget(self.zmazik)
+
+        self.ukladPrawy.addWidget(self.opisSeriiDanych)
+        self.ukladPrawy.addLayout(self.ukladPrzyciskow)
+
+        self.formularz = QtGui.QHBoxLayout(self)
+        self.formularz.addLayout(self.ukladLewy)
+        self.formularz.addLayout(self.ukladPrawy)
+
+
+        self.__aktualizujPodpis()
+
+    @QtCore.pyqtSlot()
+    def __SlotZmianaFormularza(self):
+        self.__aktualizujPodpis()
+        slownik = self.__FormuujZamowienie()
+        slownik['typ'] = 'podglad'
+        self.sygNowyFormularz.emit(slownik)
+
+    @QtCore.pyqtSlot()
+    def __SlotZlozZamowienie(self):
+        slownik = self.__FormuujZamowienie()
+        slownik['typ'] = 'zatwierdzone'
+        slownik['podpis'] = str(self.opisSeriiDanych.text())
+        self.sygNowyFormularz.emit(slownik)
+
+    def __FormuujZamowienie(self):
+        return {
+               'wartN' : self.parN.wartosc.value() ,
+               'wartA' : self.parA.wartosc.value(),
+               'podgPW': self.wyswPrawoWiazki.isChecked()}
+
+    def __aktualizujPodpis(self):
+        #format = 'Eb 1,%dN (%dA)'
+        formatWys = 'E 1,%d(%d)'
+        podpis = formatWys % (self.parN.wartosc.value(),
+                              self.parA.wartosc.value())
+
+        self.opisSeriiDanych.setText(podpis)
+
+class KontrolerWykresuErlanga(QtGui.QWidget):
+    def __init__(self, parent = None):
+        super(KontrolerWykresuErlanga, self).__init__(parent)
+
+        self.formularz = FormularzKreslenia(self)
+        self.oknoRysowania = WidzetWykres(self)
+
+        self.ukladPionowy = QtGui.QVBoxLayout(self)
+        self.ukladPionowy.addWidget(self.formularz)
+        self.ukladPionowy.addWidget(self.oknoRysowania)
+
+        self.watek = WatekObliczeniowy(self)
+        self.watek.sygnalPoliczone.connect(self.SlotZamowienie)
+        self.watek.finished.connect(self.SlotWatekZakonczony)
+
+        self.formularz.sygNowyFormularz.connect(self.watek.SlotZamowNowy)
+
+        self.SlotCzysc()
+
+    @QtCore.pyqtSlot()
+    def SlotCzysc(self):
+        self.listaZamowien = []
+        self.slownikPodgladu = {}
+
+        self.oknoRysowania.axis.clear()
+        self.oknoRysowania.canvas.draw()
+
+    @QtCore.pyqtSlot(dict)
+    def SlotZamowienie(self, slo):
+        if 'typ' in slo.keys():
+            if slo['typ'] == 'zatwierdzone':
+                # zatwierdzone są akumulowane
+                self.listaZamowien.append(slo)
+                self.slownikPodgladu = {}
+            elif  slo['typ'] == 'podglad':
+                # podglad jest zastepowany
+                self.slownikPodgladu = slo
+        else:
+            print 'bledny slownik zamowienia'
+
+        self.__RysujZeSlownika()
+
+    @QtCore.pyqtSlot()
+    def SlotWatekZakonczony(self):
+        pass  # print 'ol rajt!'
+
+    def __RysujZeSlownika(self):
+
+        self.oknoRysowania.axis.clear()
+
+        for n, zam in enumerate(self.listaZamowien): 
+            self.oknoRysowania.axis.plot(zam['kursorX'], 
+                                         zam['kursorY'],
+                                         label=zam['podpisPlus'],
+                                         c=self.oknoRysowania.kolorLini(n),
+                                         marker=self.oknoRysowania.stylMarkera(n),
+                                         ls = '-.')
+
+        if self.listaZamowien:
+            fontP = FontProperties()
+            fontP.set_size('small')
+            self.oknoRysowania.axis.legend(prop = fontP, loc=4)
+
+        for n, zam in enumerate(self.listaZamowien):
+            self.oknoRysowania.axis.plot(
+                     zam['EbX'],
+                     zam['EbY'],
+                     label = zam['podpis'],
+                     c=self.oknoRysowania.kolorLini(n))
+
+            if 'kursor2X' in zam.keys() and 'kursor2Y' in zam.keys():
+                self.oknoRysowania.axis.plot(
+                         zam['kursor2X'], 
+                         zam['kursor2Y'],
+                         label=zam['podpisPlus'],
+                         c=self.oknoRysowania.kolorLini(n),
+                         marker=self.oknoRysowania.stylMarkera(n),
+                         ls = ':')
+
+
+        if self.slownikPodgladu:
+            pdg = self.slownikPodgladu
+            self.oknoRysowania.axis.plot(pdg['EbX'], 
+                                         pdg['EbY'], 
+                                         c = '#040802', 
+                                         ls = '--')
+            self.oknoRysowania.axis.plot(pdg['kursorX'], 
+                                         pdg['kursorY'], 
+                                         c = '#040802', 
+                                         ls = ':')
+
+            if 'kursor2X' in pdg.keys() and 'kursor2Y' in pdg.keys():
+                self.oknoRysowania.axis.plot(
+                         pdg['kursor2X'], 
+                         pdg['kursor2Y'],
+                         c= '#040802',
+                         marker='x',
+                         ls = ':')
+
+        self.oknoRysowania.axis.grid(b=None, which='major', color="#CCCCCC")
+        self.oknoRysowania.axis.set_xlabel(u'Ilość abonentów')
+        self.oknoRysowania.axis.set_ylabel(u'Prawd. blokady')
+        self.oknoRysowania.canvas.draw()
+
+
+class OknoGlowne(QtGui.QWidget):
+    def __init__(self, parent = None):
+        super(OknoGlowne, self).__init__(parent)
+
+        self.zakladki = QtGui.QTabWidget(self)
+        zakladka1 = QtGui.QWidget()
+        zakladka2 = KontrolerWykresuErlanga(self)
+
+        edytorTekstu = QtGui.QTextEdit(self)
+        edytorTekstu.setText(self.__opis())
+        edytorTekstu.setReadOnly(True)
+
+        ukladZakladki1 = QtGui.QVBoxLayout()
+        ukladZakladki1.addWidget(edytorTekstu)
+        zakladka1.setLayout(ukladZakladki1)
+
+        ukladOkna = QtGui.QVBoxLayout(self)
+        ukladOkna.addWidget(self.zakladki)
+
+        self.zakladki.addTab(zakladka1, "Opis programu")
+        self.zakladki.addTab(zakladka2, "Wykres B-Erlang'a (A)")
+        self.zakladki.setCurrentIndex(1)
+        self.zakladki.setWindowTitle('ErlangB')
+        self.zakladki.show()
+    def __opis(self):
+        return u''' Ten program wizualizuje wyniki obliczeń według wzoru Erlanga-B w następującej postaci:
+    
+    E1,N(A) = ( A^N / N! ) / ( suma dla i od 0 do N (A^i / i!))
+    
+    Ponieważ we wzorze użyta została silnia, to ograniczona jest wartość N do 170 linii sieci (wynik 170! jest liczbą całkowitą, która zajmuje bodajże tysiąc bitów, zatem to jest i tak niezły wynik). Silnia jest obliczana inkrementacyjnie, ale został wykorzystany dość szybki algorytm jej obliczania - dotychczas obliczone wartości dla kolejnych liczb naturalnych są umieszczane w tablicy wyników do przyszłego użycia.
+
+Z polskiej wikipedii:
+    Erlang – jednostka natężenia ruchu telekomunikacyjnego. Nazwa wywodzi się od nazwiska Agnera Krarupa Erlanga, autora teorii masowej obsługi, znanej również jako teoria kolejek, która stanowi uogólnienie zjawisk zaobserwowanych w telekomunikacji.
+
+Dla danego systemu telekomunikacyjnego składającego się z N linii, i czasu obserwacji równego 1 godzinie (60 minut), jeśli linia ta zajęta jest cały czas przez pełną godzinę, to natężenie ruchu wynosi 1 Erlang; odpowiednio, jeśli linia ta zajęta jest przez 30 minut, natężenie to wynosi 0,5 Erlanga.
+
+    Program został napisany w języku Python 2.7. z użyciem bibliotek matplotlib oraz PyQt4 i nakładki PyQt na matplotlib (FigureCanvasQTAgg z backend_qt4agg). Instalator programu dla środowisk bez interpretera Python 2.7. to PyInstaller
+    
+    Pierwotni autorzy: (Małgorzata Kania, Michał Kaczmarczyk) @ Politechnika Wrocławska, wydział Elektroniki. 
+
+    ''' 
+
+if __name__ == "__main__":
+    import sys
+
+    app = QtGui.QApplication(sys.argv)
+    app.setApplicationName('OknoGlowne')
+
+    main = OknoGlowne()
+    main.resize(666, 333)
+    main.show()
+
+    sys.exit(app.exec_())