def __init__(self, parent = None):
        QtGui.QWidget.__init__(self, parent)
        
        pg.setConfigOption('background', 'w')
        pg.setConfigOption('foreground', 'k')
        pg.setConfigOptions(antialias=False)
        self.scopeWidget = pg.PlotWidget()
        self.scopeWidget.setTitle('Scope trace', size='12')

        self.vbl = QtGui.QVBoxLayout()
        self.vbl.addWidget(self.scopeWidget)
        self.setLayout(self.vbl)
        self.scopeWidget.setLabel('left', 'Signal', units='V')
        self.scopeWidget.setLabel('bottom', 'Time', units='s')
        self.scopeWidget.showGrid(x=False, y=True)
        self.scopeWidget.clear()

        self.lr1 = pg.LinearRegionItem([0,0], brush=pg.mkBrush(0,0,160,80))
        self.lr2 = pg.LinearRegionItem([0,0], brush=pg.mkBrush(52,124,23,80))
        self.lr1.setZValue(10)
        self.lr2.setZValue(10)
        self.scopeWidget.addItem(self.lr2)
        self.scopeWidget.addItem(self.lr1)
        self.lr1.setMovable(False)
        self.lr2.setMovable(False)

 def __init__(self):
     # *******************Setup interactive plotting*********************************
     self.app = QtGui.QApplication([])
     self.staticLayout = QtGui.QGridLayout()
     self.win = pg.GraphicsWindow(title="Basic plotting examples")
     self.win.setLayout(self.staticLayout)
     self.win.resize(1000, 600)
     self.win.setWindowTitle('Smith_Charts')
     pg.setConfigOptions(antialias=True)  # Enable anti-aliasing for prettier plots
     # ******************  Variable Definitions ***********************************
     self.df = pd.DataFrame  # where main bulk of data is stored
     self.windowCount = 1
     # ********************** Dynamic widgets decelerations ****************************************
     self.plotTypeGroup = {}
     self.plotCanvas = QtGui.QGraphicsWidget()
     self.plotCanvasLayout = QtGui.QGraphicsGridLayout(self.plotCanvas)
     self.filesLabel = QtGui.QLabel()
     # Dictionaries to keep track of user settings
     self.settings={}
     self.currentSelectedWindow = 0
     # Dictionaries to keep track of dynamic widgets
     self.files = {}
     self.filesP = {}
     self.markerFreq={}
     self.markerFreqP={}
     self.freqSlice = {}
     self.freqSlice = {}
     self.colors = {}
     self.canvas = {}
     self.titles={}
     self.titlesP={}
     self.smithBoxes={}
     self.smithBoxesP ={}
     self.logMagBoxes={}
     self.logMagBoxesP={}
     self.plots = {}
     self.trace = {}
     self.ports = {}
     self.portsP = {}
     # ******************** Static widgets *****************************************************
     self.staticWidgets = QtGui.QGraphicsWidget()
     self.staticLayout = QtGui.QGraphicsGridLayout(self.staticWidgets)
     # Data selection button
     self.dataButton = QtGui.QPushButton('Grab Data')
     self.dataButtonP = QtGui.QGraphicsProxyWidget()
     self.dataButtonP.setWidget(self.dataButton)
     self.dataButton.clicked.connect(self.GrabData)
     self.staticLayout.addItem(self.dataButtonP, 0, 0)
     # Number of windows
     self.numberOfWindows = QtGui.QLineEdit()
     self.doubleValidator = QtGui.QIntValidator()
     self.numberOfWindows.setValidator(self.doubleValidator)
     self.numberOfWindows.textChanged.connect(self.ValidateWindowCount)
     self.numberOfWindows.setStyleSheet('background-color:black;border-style: outset;color: rgb(255,255,255)')
     self.numberOfWindows.setPlaceholderText("How Many Data Windows")
     self.numberOfWindowsP = QtGui.QGraphicsProxyWidget()
     self.numberOfWindowsP.setWidget(self.numberOfWindows)
     self.staticLayout.addItem(self.numberOfWindowsP, 0, 1)
     self.staticWidgets.setLayout(self.staticLayout)
     self.win.addItem(self.staticWidgets, 0, 0, 1, 1)

def create_window():
    win = QtGui.QMainWindow()
    win.resize(1000,600)
    win.setWindowTitle('HypnoPy')

    pg.setConfigOptions(antialias=True) # Enable antialiasing for prettier plots

    plot_widget = create_plot_widget('Spiral')
    sidebar_width = 200
    slider_widget1 = create_slider_widget(label='SPL threshold',
                                          unit='dB',
                                          min_value=-50,
                                          max_value=50,
                                          init_value=0,
                                          step=1,
                                          connect=_update_SPL_THRESHOLD,
                                          max_width=sidebar_width)
    slider_widget2 = create_slider_widget(label='Window size',
                                          unit='',
                                          min_value=256,
                                          max_value=len(get_buffer()),
                                          init_value=len(get_buffer()),
                                          step=2,
                                          connect=_update_WINDOW_SIZE,
                                          max_width=sidebar_width)
    sidebar = create_sidebar(sidebar_width, slider_widget1, slider_widget2) 
    layout = pg.LayoutWidget()
    layout.addWidget(plot_widget)
    layout.addWidget(sidebar)
    layout.show()
    return layout, plot_widget

    def __init__(self):
        """
        Constructor
        """
        self.win.resize(1400, 800)
        self.win.setWindowTitle("Attitude plots")
        pg.setConfigOptions(antialias=True)

        # self.win2.resize(1000,600)
        # self.win2.setWindowTitle('Following control')

        self.buildQuaternion()
        self.buildTheta()
        self.buildX()
        self.buildXDot()
        self.win.nextRow()
        self.buildThetaDot()
        self.buildTorque()
        self.buildA()
        self.buildMotor()
        # self.buildMoveX()
        # self.buildMoveY()
        # self.buildMoveZ()
        timer = QtCore.QTimer()
        timer.timeout.connect(self.update)
        timer.start(50)

	def __init__(self, conn, ide, sensor, numCanal):
		super(QObject, self).__init__()
		self.conn = conn
		self.sensor = sensor
		self.ide = ide
		self.numCanal = numCanal
		pg.setConfigOptions(antialias=True)
		self.dlg = QDialog()
		self.plotDlg = Ui_PlotDlg()
		self.plotDlg.setupUi(self.dlg)
		self.dlg.setWindowModality(Qt.ApplicationModal)
		self.plot = pg.PlotWidget(parent=None, background='default', labels={'left': ('Temperature', 'ºC')},
		                          axisItems={'bottom': TimeAxisItem(orientation='bottom')})
		self.plot.setObjectName("plot")
		self.plotDlg.verticalLayout.addWidget(self.plot)
		self.dlg.show()
		self.curve = self.plot.plot()
		self.plot.enableAutoRange()
		self.curve.curve.setClickable(True)
		self.plot.showGrid(x=True, y=True, alpha=0.5)

		self.plotDlg.dayButton.clicked.connect(self.dayData)
		self.plotDlg.hourButton.clicked.connect(self.hourData)
		self.plotDlg.weekButton.clicked.connect(self.weekData)
		self.plotDlg.monthButton.clicked.connect(self.monthData)
		self.plotDlg.yearButton.clicked.connect(self.yearData)
		self.plot.sigRangeChanged.connect(self.plotClicked)
		self.plot.scene().sigMouseMoved.connect(self.mouseMoved)
		#self.cpoint = pg.CurvePoint(self.curve)
		#self.plot.addItem(self.cpoint)
		self.label = pg.TextItem(anchor=(0, 0))
		#self.label.setParentItem(self.cpoint)
		self.plot.addItem(self.label)
		self.plotDlg.dayButton.setFocus()
		self.dayData()

    def initUi(self):
        """初始化界面"""
        portfolio = self.portfolio
        
        self.setWindowTitle(u'波动率图表')

        pg.setConfigOptions(antialias=True)         #启用抗锯齿
        
        # 创建绘图区以及线
        for chain in portfolio.chainDict.values():
            symbol = chain.symbol + CALL_SUFFIX

            chart = self.addPlot(title=symbol)
            chart.showGrid(x=True, y=True) 
            chart.setLabel('left', u'波动率')          #设置左边标签
            chart.setLabel('bottom', u'行权价')        #设置底部标签                

            self.bidCurveDict[symbol] = chart.plot(pen='r', symbol='t', symbolSize=8, symbolBrush='r')
            self.askCurveDict[symbol] = chart.plot(pen='g', symbolSize=8, symbolBrush='g')
            self.pricingCurveDict[symbol] = chart.plot(pen='w', symbol = 's', symbolSize=8, symbolBrush='w')
        
        self.nextRow()
        
        for chain in portfolio.chainDict.values():
            symbol = chain.symbol + PUT_SUFFIX

            chart = self.addPlot(title=symbol)
            chart.showGrid(x=True, y=True) 
            chart.setLabel('left', u'波动率') 
            chart.setLabel('bottom', u'行权价')

            self.bidCurveDict[symbol] = chart.plot(pen='r', symbol='t', symbolSize=8, symbolBrush='r')
            self.askCurveDict[symbol] = chart.plot(pen='g', symbolSize=8, symbolBrush='g')
            self.pricingCurveDict[symbol] = chart.plot(pen='w', symbol = 's', symbolSize=8, symbolBrush='w')

def plotting():
    from pyqtgraph.Qt import QtGui, QtCore
    import pyqtgraph as pg

    app = QtGui.QApplication([])

    pg.setConfigOptions(antialias=True)

    win = pg.GraphicsWindow(title="examples")
    win.resize(1000,600)
    win.setWindowTitle('Plotting')

    a = win.addPlot(title=title[0][6:title[0].find(',')])
    a.plot(listing[0], listing[1])
    a.showGrid(x=True, y=True)

    for i in range(2, len(listing), 2):
        print i
        if i % 3 == 0:
            win.nextRow()
        p1 = win.addPlot(title=title[i/ 2][6:title[i/2].find(',')])
        p1.plot(listing[i], listing[i + 1])
        p1.showGrid(x=True, y=True)
        p1.setXLink(a)
        p1.setYLink(a)

    if __name__ == '__main__':
        import sys
        if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
            QtGui.QApplication.instance().exec_()

    def init_gui(self):
        # create a window with 14 plots (7 rows x 2 columns)
        ## create a window with 8 plots (4 rows x 2 columns)

        win = pg.GraphicsWindow(title="Trigno display")
        win.resize(1000,600)
        win.setWindowTitle('Trigno display')
        pg.setConfigOptions(antialias=True)

        #cols, rows = 2, 4
        cols = 2
        rows = self.config.nchan / cols
        self.npt = 2000
        self.axes = np.empty((rows, cols), dtype=object)
        for i in xrange(rows):
            for j in xrange(cols):
                ax = win.addPlot(title="EMG%d" % (i * cols + j))
                #ax.disableAutoRange(axis=None)
                self.axes[i,j] = ax.plot(np.random.normal(1,1, size=432*3))
            win.nextRow()
            
        self.old_data = np.zeros((self.config.nchan, self.npt))
        self.new_data = np.zeros((self.config.nchan, self.npt))
        
        timer = QtCore.QTimer(self)
        timer.connect(timer, QtCore.SIGNAL("timeout()"), self.timer_event)
        timer.start(0)

    def __init__(self, args):    
    	self.args = args

        #QtGui.QApplication.setGraphicsSystem('raster')
        app = QtGui.QApplication([])
        #mw = QtGui.QMainWindow()
        #mw.resize(800,800)

        pg.setConfigOption('background', 'w')
        pg.setConfigOption('foreground', 'k')

        win = pg.GraphicsWindow(title="Basic plotting examples")
        win.resize(1000,600)
        win.setWindowTitle('plot')

        # Enable antialiasing for prettier plots
        pg.setConfigOptions(antialias=True)
    
        self.order_book_plot = OrderBookPlot(self.args, win)

        if self.args.enable_sample_mode:
            timer = QtCore.QTimer()
            timer.timeout.connect(self.update_sample)
            timer.start(500)
        else:
            thread = RabbitMQThread(self.args)
            thread.newData.connect(self.order_book_plot.update)
            thread.start()
    
        import sys
        ## Start Qt event loop unless running in interactive mode or using pyside.
        if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
            QtGui.QApplication.instance().exec_()

 def onZipfPlot(self):
     before = time.time()
     
     pg.setConfigOptions(antialias=True)
     dialog= QtGui.QDialog(self)
     plotWidget = pg.PlotWidget(name='Zipf\'s Law Plot')
     
     logx = self.model.getLogX()
     ab = self.model.getPolyFit()
     s = ScatterPlotItem(logx, self.model.getLogfreqDist(), size=4, pen=None, brush=pg.mkBrush(255, 255, 255))
     s.addPoints(logx, self.model.getLogfreqDist())
     plot = plotWidget.plot(logx, [self.model.getPoly(x) for x in logx],  pen=(0,255,255), size=4)
     
     legend = LegendItem((130,60), offset=(500,30))
     legend.setParentItem(plotWidget.getPlotItem())
     legend.addItem(s, 'Corpus data')
     legend.addItem(plot, str(round(ab[0], 3)) + 'x + ' +str(round(ab[1], 3)))
     
     plotWidget.addItem(s)
     lay = QtGui.QVBoxLayout()
     lay.addWidget(plotWidget)
     
     dialog.setLayout(lay)
     dialog.show()
             
     self.fillTimeData("creating Zipf plot", time.time() - before)

	def __init__(self, parent=None):
		pg.GraphicsWindow.__init__(self, title="Spectrum Analyzer")
		self.resize(400,300)
		self.setWindowTitle('Spectrum Analyzer')
		pg.setConfigOptions(antialias=True)
		self.plot_item = self.addPlot(title='Time Domain - u(t)', labels={'left': 'u(t)', 'bottom': 't'})
		self.plot_samples()

    def initUI(self):
        win = pg.GraphicsLayoutWidget()
        win.resize(1000, 600)
        win.setWindowTitle(u"Node: "+unicode(self.parent().name()))

        # Enable anti-aliasing for prettier plots
        pg.setConfigOptions(antialias=True)
        # Add Label where coords of current mouse position will be printed
        self.coordLabel = pg.LabelItem(justify='right')
        win.addItem(self.coordLabel)
        
        #add custom datetime axis
        x_axis1 = DateAxisItem(orientation='bottom')
        x_axis2 = DateAxisItem(orientation='bottom')
        self.y_axis1  = pg.AxisItem(orientation='left')  # keep reference to itm since we want to modify its label
        self.y_axis2  = pg.AxisItem(orientation='left')  # keep reference to itm since we want to modify its label

        self.p1 = win.addPlot(row=1, col=0, axisItems={'bottom': x_axis1, 'left': self.y_axis1})
        #self.p1.setClipToView(True)
        self.p2 = win.addPlot(row=2, col=0, axisItems={'bottom': x_axis2, 'left': self.y_axis2}, enableMenu=False, title=' ')
        #self.p1.setClipToView(True)
        self.vb = self.p1.vb  # ViewBox
        
        self.zoomRegion = pg.LinearRegionItem()
        self.zoomRegion.setZValue(-10)
        self.zoomRegion.setRegion([1000, 2000])
        self.p2.addItem(self.zoomRegion, ignoreBounds=True)
        
        self.p1.setAutoVisible(y=True)
        self.legend = self.p1.addLegend()

        self.initCrosshair()
        self.win = win

def plotting():
    from pyqtgraph.Qt import QtGui, QtCore
    import pyqtgraph as pg

    ts = listing[0]
    gids = listing[1]

    #QtGui.QApplication.setGraphicsSystem('raster')
    app = QtGui.QApplication([])
    #mw = QtGui.QMainWindow()
    #mw.resize(800,800)
    # Enable antialiasing for prettier plots
    pg.setConfigOptions(antialias=True)

    win = pg.GraphicsWindow(title="Basic plotting examples")
    win.resize(1000,600)
    win.setWindowTitle('pyqtgraph example: Plotting')

    p4 = win.addPlot(title="Parametric, grid enabled")
    p4.plot(ts, gids)
    p4.showGrid(x=True, y=True)

    ## Start Qt event loop unless running in interactive mode or using pyside.
    if __name__ == '__main__':
        import sys
        if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
            QtGui.QApplication.instance().exec_()

def setup_graphics(app):

    print("setup graphics")

    global curve1, curve2, win, timer

    win = pg.GraphicsWindow(title="Basic plotting examples")
    win.resize(1000,600)
    win.setWindowTitle('pyqtgraph example: Plotting')

    # Enable antialiasing for prettier plots
    pg.setConfigOptions(antialias=True)

    # add the main plot
    p = win.addPlot(title="ADC1")
    p.showGrid(x=True, y=True)
    p.setRange(xRange=[0, 45000], yRange=[0, 256])
    curve1 = p.plot(pen='y')
    curve2 = p.plot(pen='r')
    #data = np.random.normal(size=(10,1000))
    #ptr = 0

    timer = QtCore.QTimer()
    timer.timeout.connect(update_plot)
    timer.start(50)

    print("timer set")

def main():
    print "Starting main"
    
    win = QtGui.QMainWindow()    
    
    cw = QtGui.QWidget()
    
    #component = DoubleBusRing()
    component = SingleBusCROW()
    lbda_step = 0.00001
    lbdas = np.arange(1.5455,1.5485+lbda_step,lbda_step)
    manip = Manipulate(component, lbdas)
    
    cw.setLayout(manip.layout)
    win.setCentralWidget(cw)
    win.show()    
    
    win.setCentralWidget(cw)
   
    pg.setConfigOptions(antialias=True)
    win.setGeometry(100,100,1200,600)
    win.setWindowTitle('Analysor')   
         
    import sys
    pg.setConfigOptions(useWeave=False)
    print "Hello"
    if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
        print "Running"
        QtGui.QApplication.instance().exec_()
        print "Done"

def set_pg_colors(form):
    '''Set default BG and FG color for pyqtgraph plots.'''
    bgColorRGBA = form.palette().color(QtGui.QPalette.ColorRole.Window)
    fgColorRGBA = form.palette().color(QtGui.QPalette.ColorRole.WindowText)
    pg.setConfigOption('background', bgColorRGBA)
    pg.setConfigOption('foreground', fgColorRGBA)
    pg.setConfigOptions(antialias=True)  ## this will be expensive for the local plot

    def create_main_frame(self):
                # Load Qt UI from .ui file
        ui_loader = QtUiTools.QUiLoader()
        ui_file = QtCore.QFile("view_data.ui")
        ui_file.open(QtCore.QFile.ReadOnly); 
        self.ui = ui_loader.load(ui_file)
        ui_file.close()
        
        self.ui.setParent(self)

        
        #set up image
        pg.setConfigOptions(useWeave=False)
        self.imv = pg.ImageView()
#         self.vLine_1, self.hLine_1 = self.cross_hair(self.imv)
        self.square = self.make_dot(self.imv)
        
        self.imv.setMinimumSize(350, 350)
        plot_tools.plot_pyqt(self.imv,self.data , self.dataview)
        self.imv.scene.sigMouseClicked.connect(self.mouseMoved_image)
        self.imv.getView().setMouseEnabled(x=False, y=False)
        

        self.graph = self.setup_graph()
        
        self.ui.image.addWidget(self.imv)
        self.ui.graphs.addWidget(self.graph)
        
        self.set_slider_settings()

        self.connect_events()
        self.connect_shortcuts()

    def __init__(self, widget, func, sampleinterval=0.05 * ureg.s,
                 timewindow=10. * ureg.s):

        # Data stuff
        self._interval = int(sampleinterval.to(ureg.s).magnitude*1000)
        self._bufsize = int((timewindow.to(ureg.s) /
                                        sampleinterval.to(ureg.s)).magnitude)
        self.databuffer = collections.deque([0.0]*self._bufsize, self._bufsize)
        self.x = np.linspace(-timewindow.to(ureg.s).magnitude, 0.0,
                                                                 self._bufsize)
        self.y = np.zeros(self._bufsize, dtype=np.float)

        self.func = func

        self.plt = widget

        pg.setConfigOptions(antialias=True)
#        self.plt = pg.plot(title='Dynamic Plotting with PyQtGraph')
        size = [widget.width(), widget.height()]
        self.plt.resize(*size)
        self.plt.showGrid(x=True, y=True)
        self.plt.setLabel('left', self.func.__name__, self.func().units)
        self.plt.setLabel('bottom', 'time', 's')
        self.curve = self.plt.plot(self.x, self.y, pen='y')
        # QTimer
        self.timer = QtCore.QTimer()
        self.timer.timeout.connect(self.updateplot)
        self.timer.start(self._interval)

def setPgConfigOptions(**kwargs):
    """ Sets the PyQtGraph config options and emits a log message
    """
    for key, value in kwargs.items():
        logger.debug("Setting PyQtGraph config option: {} = {}".format(key, value))

    pg.setConfigOptions(**kwargs)

	def draw_spectrum_analyzer(all_frames, thresh_frames):
		time.sleep(1) # Wait just one second
		pw = pg.plot(title="Spectrum Analyzer") # Window title
		pg.setConfigOptions(antialias=True) # Enable antialias for better resolution
		pw.win.resize(800, 300) # Define window size
		pw.win.move(540 * SCREEN_WIDTH / 1920, 500 * SCREEN_HEIGHT / 1080) # Define window position
		while True: # Loop over the frames of the audio / data chunks
			data = ''.join(all_frames[-1:]) # Get only the last frame of all frames
			data = numpy.fromstring(data, 'int16') # Binary string to numpy int16 data format
			pw.setMouseEnabled(y=False) # Disable mouse
			pw.setYRange(0,1000) # Set Y range of graph
			pw.setXRange(-(RATE/16), (RATE/16), padding=0) # Set X range of graph relative to Bit Rate
			pwAxis = pw.getAxis("bottom") # Get bottom axis
			pwAxis.setLabel("Frequency [Hz]") # Set bottom axis label
			f, Pxx = HearingPerception.find_frequency(data) # Call find frequency function
			f = f.tolist() # Numpy array to list
			Pxx = (numpy.absolute(Pxx)).tolist() # Numpy array to list
			try: # Try this block
				if thresh_frames[-1:][0] == EMPTY_CHUNK: # If last thresh frame is equal to EMPTY CHUNK
					pw.plot(x=f,y=Pxx, clear=True, pen=pg.mkPen('w', width=1.0, style=QtCore.Qt.SolidLine)) # Then plot with white pen
				else: # If last thresh frame is not equal to EMPTY CHUNK
					pw.plot(x=f,y=Pxx, clear=True, pen=pg.mkPen('y', width=1.0, style=QtCore.Qt.SolidLine)) # Then plot with yellow pen
			except IndexError: # If we are getting an IndexError because of this -> thresh_frames[-1:][0]
				pw.plot(x=f,y=Pxx, clear=True, pen=pg.mkPen('w', width=1.0, style=QtCore.Qt.SolidLine)) # Then plot with white pen
			pg.QtGui.QApplication.processEvents() # ???
			time.sleep(0.05) # Wait a few miliseconds