Example #1
0
 def plotContours(self, widget):
     """Plot the stored image and outline of the fitted ROIs onto the widget"""
     viewbox = widget.addViewBox()
     viewbox.addItem(pg.ImageItem(_transform(self._imvals)))
     for i, df in self.df.iterrows():  # note: image coordinates inverted
         e = pg.EllipseROI(
             (df['xc'] - self._d * 0.5,
              self._imvals.shape[0] - df['yc'] - self._d * 0.25),
             (2 * df['w'], 2 * df['h']),  # origin is bottom-left
             movable=False,
             rotatable=False,
             resizable=False,
             pen=pg.intColor(i, self._n))
         viewbox.addItem(e)
         for h in e.getHandles():
             e.removeHandle(h)
         s = pg.ROI(
             (df['xc'] - self._d,
              self._imvals.shape[0] - df['yc'] - self._d),
             (2 * self._d, 2 * self._d),  # origin is bottom-left
             movable=False,
             rotatable=False,
             resizable=False,
             pen='w')
         viewbox.addItem(s)
 def togglePhotometryMode(self):
     if not self.rois:
         self.rois = []
     self.rois.append(pg.EllipseROI([100, 150], [30, 20], pen=(7 , 3)) )
     for roi in self.rois:
        # roi.sigRegionChanged.connect(self.updateROIs)
         self.view.addItem(roi)
Example #3
0
    def __init__(self, **kwargs):
        """ """
        super().__init__(**kwargs)

        # Draw ROI for eyes region selection:
        self.pre_th = [0, 0]

        self.eye_params = self.experiment.pipeline.eyetrack._params
        self.roi_eyes = pg.ROI(
            pos=self.eye_params.wnd_pos,
            size=self.eye_params.wnd_dim,
            pen=dict(color=(5, 40, 200), width=3),
        )

        self.roi_eyes.addScaleHandle([0, 0], [1, 1])
        self.roi_eyes.addScaleHandle([1, 1], [0, 0])

        self.curves_eyes = [
            pg.EllipseROI(
                pos=(0, 0), size=(10, 10), movable=False, pen=dict(color=k, width=3)
            )
            for k in [(5, 40, 230), (40, 230, 5)]
        ]

        for c in self.curves_eyes:
            self.display_area.addItem(c)
            [c.removeHandle(h) for h in c.getHandles()]

        self.initialise_roi(self.roi_eyes)

        self.setting_param_val = False
Example #4
0
    def initializeUI(self):
        image_logic = self.image_logic
        roi_logic = self.roi_logic

        widget = pg.GraphicsWindow(border=True)
        widget.setWindowTitle(self.description)
        self.addWidget(widget)
        layout = widget.addLayout(row=0, col=0)

        view = layout.addViewBox(row=0, col=0, rowspan=2, lockAspect=True)
        self.view = view
        full_image_item = pg.ImageItem(image_logic.image_array)
        self.full_image_item = full_image_item
        spacing = image_logic.image.GetSpacing()
        size = image_logic.image.GetSize()
        rect = QtCore.QRectF(0, 0,
                             640, 640*size[1]*spacing[1]/size[0]/spacing[0])
        full_image_item.setRect(rect)
        view.addItem(full_image_item)

        zoom_roi_view = layout.addViewBox(row=2, col=0)
        self.zoom_roi = pg.EllipseROI([300, 200], roi_logic.zoom_roi_pos,
                                      pen=(3, 9))
        view.addItem(self.zoom_roi)
        self.roi_image_item = pg.ImageItem()
        zoom_roi_view.addItem(self.roi_image_item)

        self.zoom_roi.sigRegionChanged.connect(self.roi_logic.set_zoom_roi_pos)
        self.roi_logic.zoom_roi_pos_changed.connect(self.update_zoom_roi_content)
        self.update_zoom_roi_content(self.zoom_roi)

        full_image_item.setRect(rect)
Example #5
0
def test_getArrayRegion(transpose=False):
    pr = pg.PolyLineROI([[0, 0], [27, 0], [0, 28]], closed=True)
    pr.setPos(1, 1)
    rois = [
        (pg.ROI([1, 1], [27, 28], pen='y'), 'baseroi'),
        (pg.RectROI([1, 1], [27, 28], pen='y'), 'rectroi'),
        (pg.EllipseROI([1, 1], [27, 28], pen='y'), 'ellipseroi'),
        (pr, 'polylineroi'),
    ]
    for roi, name in rois:
        # For some ROIs, resize should not be used.
        testResize = not isinstance(roi, pg.PolyLineROI)

        origMode = pg.getConfigOption('imageAxisOrder')
        try:
            if transpose:
                pg.setConfigOptions(imageAxisOrder='row-major')
                check_getArrayRegion(roi,
                                     'roi/' + name,
                                     testResize,
                                     transpose=True)
            else:
                pg.setConfigOptions(imageAxisOrder='col-major')
                check_getArrayRegion(roi, 'roi/' + name, testResize)
        finally:
            pg.setConfigOptions(imageAxisOrder=origMode)
Example #6
0
 def initROI(self,
             imv,
             pos,
             size,
             angle,
             pen,
             updateFunc=None,
             releaseFunc=None):
     """Add an ROI to an ImageView."""
     roi = pg.EllipseROI(pos, size, angle=angle, pen=pen)
     if updateFunc is not None:
         roi.sigRegionChanged.connect(updateFunc)
     if releaseFunc is not None:
         roi.sigRegionChangeFinished.connect(releaseFunc)
     if updateFunc is None and releaseFunc is None:
         roi = pg.EllipseROI(pos, size, angle=angle, pen=pen, movable=False)
     imv.getView().addItem(roi)
     self.param_gui['roi'] = roi
     return roi
Example #7
0
 def addEllipse(self):
     if self.ellipse == None and self.imagedata is not None:
         x, y = self.imagedata.shape
         unit = np.sqrt(x * y) / 4
         self.ellipse = pg.EllipseROI(pos=[(x / 2) - unit,
                                           (y / 2) - unit * 1.5],
                                      size=[unit * 2, unit * 3],
                                      pen={'color': "00FF7F"})
         self.addItem(self.ellipse)
         self.rois.append('ellipse')
Example #8
0
 def draw(self, parent, imy, imx, dy, dx):
     roipen = pg.mkPen(self.color, width=3,
                       style=QtCore.Qt.SolidLine)
     self.ROI = pg.EllipseROI([imx, imy], [dx, dy], pen=roipen, removable=True)
     self.ROI.handleSize = 8
     self.ROI.handlePen = roipen
     self.ROI.addScaleHandle([1, 0.5], [0., 0.5])
     self.ROI.addScaleHandle([0.5, 0], [0.5, 1])
     self.ROI.setAcceptedMouseButtons(QtCore.Qt.LeftButton)
     parent.p0.addItem(self.ROI)
Example #9
0
    def __init__(self, **kwargs):
        """ """
        super().__init__(**kwargs)

        # We need to initialise the ellipse, add it to the area, and remove
        # the handles from the ellipseROI:
        self.fly_ell = pg.EllipseROI(pos=(0, 0), size=(10, 10), movable=False, pen=None)

        self.display_area.addItem(self.fly_ell)
        [self.fly_ell.removeHandle(h) for h in self.fly_ell.getHandles()]
        self.pre_th = 0
Example #10
0
    def pick(self, win, pos):
        self.cleanup()

        self.win = win
        self.view = self.ivl.ortho_views[self.win]

        fx, fy = self._xy_coords(pos)
        self.roisel = pg.EllipseROI((fx, fy), (1, 1), pen=(255, 0, 255))
        self.view.vb.addItem(self.roisel)
        self.ox, self.oy = fx, fy
        self._points = [(fx, fy), (fx, fy + 1), (fx + 1, fy + 1), (fx + 1, fy)]
Example #11
0
def test_getArrayRegion():
    pr = pg.PolyLineROI([[0, 0], [27, 0], [0, 28]], closed=True)
    pr.setPos(1, 1)
    rois = [
        (pg.ROI([1, 1], [27, 28], pen='y'), 'baseroi'),
        (pg.RectROI([1, 1], [27, 28], pen='y'), 'rectroi'),
        (pg.EllipseROI([1, 1], [27, 28], pen='y'), 'ellipseroi'),
        (pr, 'polylineroi'),
    ]
    for roi, name in rois:
        # For some ROIs, resize should not be used.
        testResize = not isinstance(roi, pg.PolyLineROI)
        
        check_getArrayRegion(roi, 'roi/'+name, testResize)
Example #12
0
 def setup(self):
     
     
 
     self.winImage = pg.GraphicsLayoutWidget()
     self.winImage.setContentsMargins(0,0,0,0)
     self.winImage.setAspectLocked(True)
     self.winImage.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
     self.winImage.ci.setContentsMargins(0,0,0,0)
     
     vbox2=QVBoxLayout()
     vbox2.addWidget(self.winImage)
     vbox2.setContentsMargins(1,1,1,1)
     
 
     self.p1=self.winImage.addPlot()
     self.imh=pg.ImageItem()
     self.p1.addItem(self.imh)
     self.p1.setMouseEnabled(x=False,y=False)
     self.p1.setContentsMargins(0,0,0,0)
     self.p1.setAspectLocked(True,ratio=1)
     self.p1.showAxis('right',show=False)
     self.p1.showAxis('top',show=False)
     self.p1.showAxis('left',show=False)
     self.p1.showAxis('bottom',show=False)
     
     self.vLine = pg.InfiniteLine(angle=90, movable=False,pen='y')
     self.hLine = pg.InfiniteLine(angle=0, movable=False,pen='y')
     self.p1.addItem(self.vLine)
     self.p1.addItem(self.hLine, ignoreBounds=False)
     self.xc=int(self.confCCD.value(self.nbcam+"/xc"))
     self.yc=int(self.confCCD.value(self.nbcam+"/yc"))
     self.rx=int(self.confCCD.value(self.nbcam+"/rx"))
     self.ry=int(self.confCCD.value(self.nbcam+"/ry"))
     self.vLine.setPos(self.xc)
     self.hLine.setPos(self.yc)
     
     self.ro1=pg.EllipseROI([self.xc,self.yc],[self.rx,self.ry],pen='y',movable=False,maxBounds=QtCore.QRectF(0,0,self.rx,self.ry))
     self.ro1.setPos([self.xc-(self.rx/2),self.yc-(self.ry/2)])
     self.p1.addItem(self.ro1)
     
     self.hist = pg.HistogramLUTItem() 
     self.hist.setImageItem(self.imh)
     self.hist.autoHistogramRange()
     self.hist.gradient.loadPreset('flame')
     HLayout=QHBoxLayout()
 
     HLayout.addLayout(vbox2)
     self.setLayout(HLayout)
Example #13
0
    def draw(self, parent, imy, imx, dy, dx, angle=0):
        roipen = pg.mkPen(self.color, width=3, style=QtCore.Qt.SolidLine)
        self.ROI = pg.EllipseROI([imx, imy], [dx, dy],
                                 angle=angle,
                                 movable=self.moveable,
                                 rotatable=self.moveable,
                                 resizable=self.moveable,
                                 pen=roipen,
                                 removable=self.moveable)

        self.ROI.handleSize = 7
        self.ROI.handlePen = roipen
        if self.moveable:
            self.ROI.addScaleHandle([0.5, 0], [0.5, 1])
            self.ROI.setAcceptedMouseButtons(QtCore.Qt.LeftButton)
        parent.pPupil.addItem(self.ROI)
 def draw(self,
          parent,
          imy,
          imx,
          dy,
          dx,
          angle=0,
          movable=True,
          removable=True):
     roipen = pg.mkPen(self.color, width=2, style=QtCore.Qt.SolidLine)
     self.ROI = pg.EllipseROI([imx, imy], [dx, dy],
                              pen=roipen,
                              movable=True,
                              removable=True,
                              resizable=False,
                              rotatable=False)
     self.ROI.handleSize = 1
     self.ROI.handlePen = roipen
     self.ROI.addScaleHandle([0.1, 0], [0.1, 0.2])
     self.ROI.setAcceptedMouseButtons(QtCore.Qt.LeftButton)
     self.add_to_view(parent.view_Center)
Example #15
0
    def __init__(self, tail=False, eyes=False, **kwargs):
        """ """
        self.eyes = eyes
        self.tail = tail
        super().__init__(**kwargs)

        # Draw ROI for tail selection:
        if tail:
            self.roi_tail = pg.PolyLineROI(
                (
                    self.track_params["tail_start"],
                    (
                        self.track_params["tail_start"][0]
                        + self.track_params["tail_length"][0],
                        self.track_params["tail_start"][1]
                        + self.track_params["tail_length"][1],
                    ),
                ),
                pen=dict(color=(40, 5, 200), width=3),
            )

            # Prepare curve for plotting tracked tail position:
            self.curve_tail = pg.PlotCurveItem(pen=dict(color=(230, 40, 5), width=3))
            self.display_area.addItem(self.curve_tail)

            self.initialise_roi(self.roi_tail)
        else:
            self.roi_tail = None
            self.curve_tail = None

        # Draw ROI for eyes region selection:

        self.pre_th = [0, 0]
        if eyes:
            self.roi_eyes = pg.ROI(
                pos=self.track_params["wnd_pos"],
                size=self.track_params["wnd_dim"],
                pen=dict(color=(5, 40, 200), width=3),
            )

            self.roi_eyes.addScaleHandle([0, 0], [1, 1])
            self.roi_eyes.addScaleHandle([1, 1], [0, 0])

            self.curves_eyes = [
                pg.EllipseROI(
                    pos=(0, 0), size=(10, 10), movable=False, pen=dict(color=k, width=3)
                )
                for k in [(5, 40, 230), (40, 230, 5)]
            ]

            for c in self.curves_eyes:
                self.display_area.addItem(c)
                [c.removeHandle(h) for h in c.getHandles()]

            self.tgl_threshold_view = QCheckBox()
            self.lbl_threshold_view = QLabel("View thresholded image")
            self.layout_control.addWidget(self.tgl_threshold_view)
            self.layout_control.addWidget(self.lbl_threshold_view)

            self.initialise_roi(self.roi_eyes)
        else:
            self.roi_eyes = None
            self.curves_eyes = None
Example #16
0
    def setROI(self,ax = 's',type='Poly'):
        if self.__image is None:
            return
        self.__ROIArray = np.zeros(self.__imageArray.shape)


        if ax =='S':
            self.__ROIAx = ax
            if type == 'Poly':
                points =  np.array([[np.shape(self.__sagittal)[0]//4,np.shape(self.__sagittal)[1]//4],
                                    [np.shape(self.__sagittal)[0] // 4, np.shape(self.__sagittal)[1] // 2],
                                    [np.shape(self.__sagittal)[0] // 2, np.shape(self.__sagittal)[1] // 2]]
                                   )
                self.__ROI = pg.PolyLineROI(points,closed=True)
            elif type=='Circle':
                self.__ROI = pg.EllipseROI([np.shape(self.__sagittal)[0] // 2, np.shape(self.__sagittal)[1] // 2], [np.shape(self.__sagittal)[0]//8,np.shape(self.__sagittal)[1]//8])
            else:
                self.__ROI = pg.RectROI([np.shape(self.__sagittal)[0] // 2, np.shape(self.__sagittal)[1] // 2], [np.shape(self.__sagittal)[0]//8,np.shape(self.__sagittal)[1]//8])

            self.p_s.addItem(self.__ROI)
            cols, rows = self.__sagittal.shape
            m = np.mgrid[:cols, :rows]
            self.possx = m[0, :, :]  # make the x pos array
            self.possy = m[1, :, :]  # make the y pos array
            self.possx.shape = cols, rows
            self.possy.shape = cols, rows
            self.__ROISlice = np.zeros(self.__sagittal.shape)

        if ax =='A':
            self.__ROIAx = ax
            if type == 'Poly':
                points = np.array([[np.shape(self.__axial)[1] // 4, np.shape(self.__axial)[0] // 4],
                                   [np.shape(self.__axial)[1] // 2, np.shape(self.__axial)[0] // 4],
                                   [np.shape(self.__axial)[1] // 2, np.shape(self.__axial)[0] // 2]]
                                  )
                self.__ROI = pg.PolyLineROI(points,closed=True)
            elif type=='Circle':
                self.__ROI = pg.EllipseROI([np.shape(self.__axial)[1] // 2, np.shape(self.__axial)[0] // 2], [np.shape(self.__axial)[1] // 8, np.shape(self.__axial)[0] // 8])
            else:
                self.__ROI = pg.RectROI([np.shape(self.__axial)[1] // 2, np.shape(self.__axial)[0] // 2], [np.shape(self.__axial)[1] // 8, np.shape(self.__axial)[0] // 8])

            self.p_a.addItem(self.__ROI)
            # print('add a!',points)
            cols, rows = self.__axial.shape
            m = np.mgrid[:cols, :rows]
            self.possx = m[0, :, :]  # make the x pos array
            self.possy = m[1, :, :]  # make the y pos array
            self.possx.shape = cols, rows
            self.possy.shape = cols, rows
            self.__ROISlice = np.zeros(self.__axial.shape)

        if ax =='C':
            self.__ROIAx = ax
            if type == 'Poly':
                points = np.array([[np.shape(self.__coronal)[1] // 4, np.shape(self.__coronal)[0] // 4],
                                   [np.shape(self.__coronal)[1] // 2, np.shape(self.__coronal)[0] // 4],
                                   [np.shape(self.__coronal)[1] // 2, np.shape(self.__coronal)[0] // 2]]
                                  )
                self.__ROI = pg.PolyLineROI(points,closed=True)
            elif type=='Circle':
                self.__ROI = pg.EllipseROI([np.shape(self.__coronal)[1] // 2, np.shape(self.__coronal)[0] // 2], [np.shape(self.__coronal)[1] // 8, np.shape(self.__coronal)[0] // 8])
            else:
                self.__ROI = pg.RectROI([np.shape(self.__coronal)[1] // 2, np.shape(self.__coronal)[0] // 2], [np.shape(self.__coronal)[1] // 8, np.shape(self.__coronal)[0] // 8])

            self.p_c.addItem(self.__ROI)
            cols, rows = self.__coronal.shape
            m = np.mgrid[:cols, :rows]
            self.possx = m[0, :, :]  # make the x pos array
            self.possy = m[1, :, :]  # make the y pos array
            self.possx.shape = cols, rows
            self.possy.shape = cols, rows
            self.__ROISlice = np.zeros(self.__coronal.shape)
Example #17
0
    def setROI(self, shape, rect=((10, 10), (20, 20))):
        '''ROI 추가를 위한 메서드. 좌상, 우하 좌표와, 모양을 인자로 받아
        선형, 사각형, 다선형, 삼각형, 원형의 ROI를 추가한다'''
        make = [pg.LineROI, pg.RectROI]
        roi_lst = []
        roi_id = len(self.roi_lst)

        def update(roi):
            '''ROI에 변화가 생겼을 대에 이를 다른 뷰에 적용시킨다'''
            state = roi.saveState()
            for r in self.roi_lst[roi_id]:
                r.setAngle(state['angle'], update=False)
                r.setPos(state['pos'], update=False)
                r.setSize(state['size'], update=False)

        def clicked(roi):
            '''ROI 우클릭 시에 팝업 윈도우를 보여준다'''
            ROIPopup(roi, self.ui)
            print "clicked"

        (x1, y1), (x2, y2) = rect
        x = min(x1, x2)
        y = min(y1, y2)
        xlen = abs(x1 - x2)
        ylen = abs(y1 - y2)

        for widget in self.widget_lst:
            if shape == 0:
                roi = pg.LineROI([x1, y1], [x2, 2 * y1 - y2],
                                 width=0,
                                 pen=(1, 9))
            elif shape == 1:
                roi = pg.RectROI([x, y], [xlen, ylen], pen=(3, 9))
            elif shape == 2:
                roi = pg.PolyLineROI(
                    [[x, y + ylen], [x + xlen / 4, y], [
                        x + xlen / 2, y + ylen
                    ], [x + xlen * 3 / 4, y], [x + xlen, y + ylen]],
                    closed=False,
                    pen=(5, 9))
            elif shape == 3:
                roi = pg.PolyLineROI(
                    [[x, y], [x + xlen / 4, y + ylen], [x + xlen / 2, y],
                     [x + xlen * 3 / 4, y + ylen], [x + xlen, y]],
                    closed=False,
                    pen=(7, 9))
            elif shape == 4:
                roi = pg.PolyLineROI(
                    [[x, y], [x + xlen / 2, y + ylen], [x + xlen, y]],
                    closed=True,
                    pen=(9, 9))
            elif shape == 5:
                roi = pg.EllipseROI([x, y], [xlen, ylen], pen=(4, 9))
            else:
                raise Exception("Shape unbound")

            # 시그널 연결
            roi.sigRegionChanged.connect(update)
            roi.setAcceptedMouseButtons(QtCore.Qt.RightButton)
            roi.sigClicked.connect(clicked)
            if shape == 2 or shape == 3 or shape == 4:
                for seg in roi.segments:
                    seg.sigRegionChanged.connect(update)
            widget.addItem(roi)
            roi_lst.append(roi)
        self.roi_lst.append(roi_lst)
        return x
Example #18
0
    def setup(self):    
        
        vbox1=QVBoxLayout() 
        
        
        self.camNameLabel=QLabel('nomcam',self)
        
        self.camNameLabel.setText(self.confCCD.value(self.nbcam+"/name"))

        self.camNameLabel.setAlignment(Qt.AlignCenter)
        self.camNameLabel.setStyleSheet('font: bold 20px')
        self.camNameLabel.setStyleSheet('color: yellow')
        vbox1.addWidget(self.camNameLabel)
        
        hbox1=QHBoxLayout() # horizontal layout pour run et stop
        self.runButton=QPushButton(self)
        self.runButton.setMaximumWidth(60)
        self.runButton.setMinimumHeight(60)
        self.runButton.setStyleSheet("QPushButton:!pressed{border-image: url(./icons/Circled Play-595b40b65ba036ed117d436f.svg);background-color: rgb(0, 0, 0,0) ;border-color: green;}""QPushButton:pressed{image: url(./icons/Circled Play-595b40b65ba036ed117d436f.svg);background-color: rgb(0, 0, 0,0) ;border-color: rgb(0, 0, 0)}")
        self.stopButton=QPushButton(self)
        
        self.stopButton.setMaximumWidth(60)
        self.stopButton.setMinimumHeight(50)
        self.stopButton.setStyleSheet("QPushButton:!pressed{border-image: url(./icons/Stop.svg);background-color: rgb(0, 0, 0,0) ;border-color: rgb(0, 0, 0,0);}""QPushButton:pressed{image: url(./icons/Stop.svg);background-color: rgb(0, 0, 0,0) ;border-color: rgb(0, 0, 0)}")
        
        
        hbox1.addWidget(self.runButton)
        hbox1.addWidget(self.stopButton)
#        self.oneButton=QPushButton(self)
#        hbox1.addWidget(self.oneButton)
        
        vbox1.addLayout(hbox1)
        
        self.trigg=QComboBox()
        self.trigg.setMaximumWidth(60)
        self.trigg.addItem('OFF')
        self.trigg.addItem('ON')
        self.labelTrigger=QLabel('Trigger')
        self.labelTrigger.setMaximumWidth(60)
        self.itrig=self.trigg.currentIndex()
        hbox2=QHBoxLayout()
        hbox2.addWidget(self.labelTrigger)
        hbox2.addWidget(self.trigg)
        vbox1.addLayout(hbox2)
        
        self.labelExp=QLabel('Exposure (ms)')
        self.labelExp.setMaximumWidth(120)
        self.labelExp.setAlignment(Qt.AlignCenter)
        vbox1.addWidget(self.labelExp)
        self.hSliderShutter=QSlider(Qt.Horizontal)
        self.hSliderShutter.setMinimum(1)
        self.hSliderShutter.setMaximum(1000)
        self.hSliderShutter.setMaximumWidth(120)
        self.shutterBox=QSpinBox()
        self.shutterBox.setMinimum(1)
        self.shutterBox.setMaximum(1000)
        self.shutterBox.setMaximumWidth(60)
       
        hboxShutter=QHBoxLayout()
        hboxShutter.addWidget(self.hSliderShutter)
        hboxShutter.addWidget(self.shutterBox)
        vbox1.addLayout(hboxShutter)
        
        
        

        hboxGain=QHBoxLayout()
        self.labelGain=QLabel('Gain')
        self.labelGain.setMaximumWidth(120)
        self.labelGain.setAlignment(Qt.AlignCenter)
        vbox1.addWidget(self.labelGain)
        self.hSliderGain=QSlider(Qt.Horizontal)
        self.hSliderGain.setMaximumWidth(120)
        
        self.gainBox=QSpinBox()
        
           
        self.gainBox.setMaximumWidth(60)
        hboxGain.addWidget(self.hSliderGain)
        hboxGain.addWidget(self.gainBox)
        vbox1.addLayout(hboxGain)
        
        
        hbox3=QHBoxLayout()
        self.checkBoxScale=QCheckBox('AScale',self)
        self.checkBoxScale.setChecked(True)
        self.checkBoxScale.setStyleSheet("QCheckBox::indicator{width: 30px;height: 30px;}""QCheckBox::indicator:unchecked { image : url(./icons/Toggle Off-595b40b85ba036ed117dac78.svg);}""QCheckBox::indicator:checked { image:  url(./icons/Toggle On-595b40b85ba036ed117dac79.svg);}")
    
        hbox3.addWidget(self.checkBoxScale)
        
        self.checkBoxColor=QCheckBox('Color',self)
        self.checkBoxColor.setChecked(True)
        self.checkBoxColor.setStyleSheet("QCheckBox::indicator{width: 30px;height: 30px;}""QCheckBox::indicator:unchecked { image : url(./icons/Toggle Off-595b40b85ba036ed117dac78.svg);}""QCheckBox::indicator:checked { image:  url(./icons/Toggle On-595b40b85ba036ed117dac79.svg);}")
    
        hbox3.addWidget(self.checkBoxColor)
        
        vbox1.addLayout(hbox3)
        hbox4=QHBoxLayout()
        self.checkBoxZoom=QCheckBox('Zoom',self)
        self.checkBoxZoom.setChecked(False)
        self.checkBoxZoom.setStyleSheet("QCheckBox::indicator{width: 30px;height: 30px;}""QCheckBox::indicator:unchecked { image : url(./icons/Toggle Off-595b40b85ba036ed117dac78.svg);}""QCheckBox::indicator:checked { image:  url(./icons/Toggle On-595b40b85ba036ed117dac79.svg);}")
    
        hbox4.addWidget(self.checkBoxZoom)
        
        self.checkBoxFullScreen=QCheckBox('FScreen',self)
        self.checkBoxFullScreen.setChecked(False)
        self.checkBoxFullScreen.setStyleSheet("QCheckBox::indicator{width: 30px;height: 30px;}""QCheckBox::indicator:unchecked { image : url(./icons/Toggle Off-595b40b85ba036ed117dac78.svg);}""QCheckBox::indicator:checked { image:  url(./icons/Toggle On-595b40b85ba036ed117dac79.svg);}")
    
        hbox4.addWidget(self.checkBoxFullScreen)
        
        
        vbox1.addLayout(hbox4)
        
        vbox1.setContentsMargins(0,0,0,0)
        vbox1.addStretch(1)
        self.vbox1=vbox1
        
        ### affichage image###
        
        self.winImage = pg.GraphicsLayoutWidget()
        self.winImage.setContentsMargins(0,0,0,0)
        self.winImage.setAspectLocked(True)
        self.winImage.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        self.winImage.ci.setContentsMargins(0,0,0,0)
        
        vbox2=QVBoxLayout()
        vbox2.addWidget(self.winImage)
        vbox2.setContentsMargins(1,1,1,1)
        
    
        self.p1=self.winImage.addPlot()
        self.imh=pg.ImageItem()
        self.p1.addItem(self.imh)
        self.p1.setMouseEnabled(x=False,y=False)
        self.p1.setContentsMargins(0,0,0,0)
        self.p1.setAspectLocked(True,ratio=1)
        self.p1.showAxis('right',show=False)
        self.p1.showAxis('top',show=False)
        self.p1.showAxis('left',show=False)
        self.p1.showAxis('bottom',show=False)
        
        self.vLine = pg.InfiniteLine(angle=90, movable=False,pen='y')
        self.hLine = pg.InfiniteLine(angle=0, movable=False,pen='y')
        self.p1.addItem(self.vLine)
        self.p1.addItem(self.hLine, ignoreBounds=False)
        self.xc=int(self.confCCD.value(self.nbcam+"/xc"))
        self.yc=int(self.confCCD.value(self.nbcam+"/yc"))
        self.rx=int(self.confCCD.value(self.nbcam+"/rx"))
        self.ry=int(self.confCCD.value(self.nbcam+"/ry"))
        self.vLine.setPos(self.xc)
        self.hLine.setPos(self.yc)
        
        self.ro1=pg.EllipseROI([self.xc,self.yc],[self.rx,self.ry],pen='y',movable=False)#maxBounds=QtCore.QRectF(0,0,self.rx,self.ry)
        self.ro1.setPos([self.xc-(self.rx/2),self.yc-(self.ry/2)])
        self.p1.addItem(self.ro1)
        
        
        #histogramme
        self.hist = pg.HistogramLUTItem() 
        self.hist.setImageItem(self.imh)
        self.hist.autoHistogramRange()
        self.hist.gradient.loadPreset('flame')
        
        ## Graph coupe XY  
        
        self.curve2=pg.PlotCurveItem()
        self.curve3=pg.PlotCurveItem()
        
        ## main layout
        
        hMainLayout=QHBoxLayout()
        if self.visuGauche==True:
            hMainLayout.addLayout(self.vbox1)
            hMainLayout.addLayout(vbox2)
        else:
            hMainLayout.addLayout(vbox2)
            hMainLayout.addLayout(self.vbox1)
        hMainLayout.setContentsMargins(1,1,1,1)
        hMainLayout.setSpacing(1)
        hMainLayout.setStretch(3,1)
        
        self.setLayout(hMainLayout)
        self.setContentsMargins(1,1,1,1)
        
        # Blocage de la souris
        self.shortcutb=QtGui.QShortcut(QtGui.QKeySequence("Ctrl+b"),self)
        self.shortcutb.activated.connect(self.bloquer)
        self.shortcutb.setContext(Qt.ShortcutContext(3))
        self.shortcutd=QtGui.QShortcut(QtGui.QKeySequence("Ctrl+d"),self)
        self.shortcutd.activated.connect(self.debloquer)
        self.shortcutd.setContext(Qt.ShortcutContext(3))
        self.shortcutPu=QShortcut(QtGui.QKeySequence("+"),self)
        self.shortcutPu.activated.connect(self.paletteup)
        self.shortcutPu.setContext(Qt.ShortcutContext(3))
        #3: The shortcut is active when its parent widget, or any of its children has focus. default O The shortcut is active when its parent widget has focus.
        self.shortcutPd=QtGui.QShortcut(QtGui.QKeySequence("-"),self)
        self.shortcutPd.activated.connect(self.palettedown)
        self.shortcutPd.setContext(Qt.ShortcutContext(3))
        
        # mvt de la souris
        self.proxy=pg.SignalProxy(self.p1.scene().sigMouseMoved, rateLimit=60, slot=self.mouseMoved)
        self.vb=self.p1.vb
        
        # text pour afficher fwhm sur p1
        self.textX = pg.TextItem(angle=-90) 
        self.textY = pg.TextItem()
Example #19
0
    def setup(self):
        # definition of all button 
        
        TogOff=self.icon+'Toggle_Off.png' 
        TogOn=self.icon+'Toggle_On.png'
        TogOff=pathlib.Path(TogOff)
        TogOff=pathlib.PurePosixPath(TogOff)
        TogOn=pathlib.Path(TogOn)
        TogOn=pathlib.PurePosixPath(TogOn)
        
        self.setStyleSheet("QCheckBox::indicator{width: 30px;height: 30px;}""QCheckBox::indicator:unchecked { image : url(%s);}""QCheckBox::indicator:checked { image:  url(%s);}""QCheckBox{font :10pt;}" % (TogOff,TogOn) )
        
        vbox1=QVBoxLayout() 
        self.hbox0=QHBoxLayout()
        vbox1.addLayout(self.hbox0)
                
        hbox1=QHBoxLayout()
        self.checkBoxPlot=QCheckBox('CROSS',self)
        self.checkBoxPlot.setChecked(False)
        self.label_CrossValue=QLabel()
        self.label_CrossValue.setStyleSheet("font:13pt")
        hbox1.addWidget(self.checkBoxPlot)
        hbox1.addWidget(self.label_CrossValue)
        
        hbox2=QHBoxLayout()
        self.label_Cross=QLabel()
        #self.label_Cross.setMaximumHeight(20)
        self.label_Cross.setMaximumWidth(170)
        self.label_Cross. setStyleSheet("font:12pt")
        hbox2.addWidget(self.label_Cross)
        
        vbox1.addLayout(hbox1)
        vbox1.addLayout(hbox2)
        
        self.ZoomLabel=QLabel('Zoom')
        vbox1.addWidget(self.ZoomLabel)
        self.checkBoxZoom=QSlider(Qt.Horizontal)
        self.checkBoxZoom.setMaximumWidth(250)
        self.checkBoxZoom.setMinimum(0)
        self.checkBoxZoom.setMaximum(200)
        self.checkBoxZoom.setValue(0)
        vbox1.addWidget(self.checkBoxZoom)
        
        self.checkBoxScale=QCheckBox('Auto Scale',self)
        self.checkBoxScale.setChecked(True)
        self.checkBoxScale.setMaximumWidth(100)
        
        self.checkBoxColor=QCheckBox('Color',self)
        self.checkBoxColor.setChecked(True)
    
        self.checkBoxHist=QCheckBox('Hist',self)
        self.checkBoxHist.setChecked(False)
        self.maxGraphBox=QCheckBox('Max',self)
        hbox3=QHBoxLayout()
        grid_layout = QGridLayout()
        grid_layout.setVerticalSpacing(0)
        grid_layout.setHorizontalSpacing(10)
        grid_layout.addWidget(self.checkBoxScale, 0, 0)
        grid_layout.addWidget(self.checkBoxColor,1,0)
        grid_layout.addWidget(self.checkBoxHist, 0, 1)
        #grid_layout.addWidget(self.checkBoxZoom, 1, 0)
        grid_layout.addWidget(self.maxGraphBox, 1,1)
        
        hbox3.addLayout(grid_layout)
        
        vbox1.addLayout(hbox3)
        
        hbox4=QHBoxLayout()
        
        if self.meas=='on':
            self.MeasButton=QPushButton('Meas.')
            hbox4.addWidget(self.MeasButton)
        
        
        vbox1.addLayout(hbox4)
        
        vbox1.addStretch(1)
        
        self.winImage = pg.GraphicsLayoutWidget()
        #self.winImage.setContentsMargins(1,1,1,1)
        self.winImage.setAspectLocked(True)
        self.winImage.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        #self.winImage.ci.setContentsMargins(1,1,1,1)
        
        vbox2=QVBoxLayout()
        # self.dockImage=QDockWidget(self)
        
        # self.dockImage.setWidget(self.winImage)
        # self.dockImage.setFeatures(QDockWidget.DockWidgetFloatable)
        #vbox2.addWidget(self.dockImage)
        vbox2.addWidget(self.winImage)
        vbox2.setContentsMargins(0,0,0,0)
        
        self.p1=self.winImage.addPlot()
        self.imh=pg.ImageItem()
        self.axeX=self.p1.getAxis('bottom')
        self.axeY=self.p1.getAxis('left')
        self.p1.addItem(self.imh)
        self.p1.setMouseEnabled(x=False,y=False)
        self.p1.setContentsMargins(0,0,0,0)
   
        self.p1.setAspectLocked(True,ratio=1)
        self.p1.showAxis('right',show=False)
        self.p1.showAxis('top',show=False)
        self.p1.showAxis('left',show=True)
        self.p1.showAxis('bottom',show=True)
        
        if self.bloqKeyboard==True:
            self.vLine = pg.InfiniteLine(angle=90, movable=False,pen='r')
            self.hLine = pg.InfiniteLine(angle=0, movable=False,pen='r')
        else:
            self.vLine = pg.InfiniteLine(angle=90, movable=False,pen='y')
            self.hLine = pg.InfiniteLine(angle=0, movable=False,pen='y')

        self.xc=int(self.conf.value(self.name+"/xc"))
        self.yc=int(self.conf.value(self.name+"/yc"))
        self.rx=int(self.conf.value(self.name+"/rx"))
        self.ry=int(self.conf.value(self.name+"/ry"))
        self.vLine.setPos(self.xc)
        self.hLine.setPos(self.yc)
       
        
        self.ro1=pg.EllipseROI([self.xc,self.yc],[self.rx,self.ry],pen='y',movable=False,maxBounds=QtCore.QRectF(0,0,self.rx,self.ry))
        self.ro1.setPos([self.xc-(self.rx/2),self.yc-(self.ry/2)])
      
       
        # text for fwhm on p1
        self.textX = pg.TextItem(angle=-90) 
        self.textY = pg.TextItem()
        
        #histogram
        self.hist = pg.HistogramLUTItem() 
        self.hist.setImageItem(self.imh)
        self.hist.autoHistogramRange()
        self.hist.gradient.loadPreset('flame')
        
        ##  XY  graph
        self.curve2=pg.PlotCurveItem()
        self.curve3=pg.PlotCurveItem()
        
        ## main layout
        hMainLayout=QHBoxLayout()
        if self.aff=='right':
            hMainLayout.addLayout(vbox2)
            hMainLayout.addLayout(vbox1)
        else :
            hMainLayout.addLayout(vbox1)
            hMainLayout.addLayout(vbox2)
            
        hMainLayout.setContentsMargins(1,1,1,1)
        hMainLayout.setSpacing(1)
        hMainLayout.setStretch(10,1)
        
        self.setLayout(hMainLayout)
        self.setContentsMargins(1,1,1,1)
Example #20
0
 def draw_shape(self):
     """
     Adds a selected ROI shape in the selected image to create mask
     """
     self.masking = 1
     if self.shape_ListWidget.count() == 0:
         self.mask = {}
         self.mask_number = 0
         self.mask_val = {}
     centerx = self.imageData.shape[
         0] / 2  #(self.image_xmax+self.image_xmin)/2.0
     centery = self.imageData.shape[
         1] / 2  #(self.image_ymax+self.image_ymin)/2.0
     lenx = self.imageData.shape[0]  #(self.image_xmax-self.image_xmin)
     leny = self.imageData.shape[1]  #(self.image_ymax-self.image_ymin)
     self.roiPS = int(self.roiPSLineEdit.text())
     self.roiLW = int(self.roiLWLineEdit.text())
     self.roiPen = pg.mkPen(color=self.roiColorButton.color(),
                            width=self.roiLW)
     if str(self.maskShapeComboBox.currentText()) == 'upper-threshold':
         self.mask_type[
             self.mask_number] = self.maskShapeComboBox.currentText()
         self.mask_val[self.mask_number] = 1
         self.threshold[self.mask_number], _ = QInputDialog.getDouble(
             self, 'Upper-threshold', 'Upper-threshld value:', value=1e6)
         self.shape_ListWidget.addItem(
             str(self.mask_number) + ':upper-threshold: val=%.e' %
             (self.threshold[self.mask_number]))
     elif str(self.maskShapeComboBox.currentText()) == 'lower-threshold':
         self.mask_type[
             self.mask_number] = self.maskShapeComboBox.currentText()
         self.mask_val[self.mask_number] = 1
         self.threshold[self.mask_number], _ = QInputDialog.getDouble(
             self,
             'Lower-threshold value',
             'Lower-threshld value:',
             value=0)
         self.shape_ListWidget.addItem(
             str(self.mask_number) + ':lower-threshold: val=%.e' %
             (self.threshold[self.mask_number]))
     elif str(self.maskShapeComboBox.currentText()) == 'rectangle':
         self.mask_type[
             self.mask_number] = self.maskShapeComboBox.currentText()
         pos = [centerx - 0.1 * lenx / 2.0, centery - 0.1 * leny / 2.0]
         size = [0.1 * lenx, 0.1 * leny]
         self.mask[self.mask_number] = pg.ROI(pos, size, pen=self.roiPen)
         self.mask_val[self.mask_number] = 1
         #self.mask[self.mask_number].addRotateFreeHandle((0,0),(0.5,0.5))
         self.mask[self.mask_number].addScaleHandle((1, 1), (0.0, 0.0))
         self.shape_ListWidget.addItem(
             str(self.mask_number) + ':rectangle: pos=' + str(pos) +
             ';size=' + str(size) + ';val=' +
             str(self.mask_val[self.mask_number]))
     elif str(self.maskShapeComboBox.currentText()) == 'inverted-rectangle':
         self.mask_type[
             self.mask_number] = self.maskShapeComboBox.currentText()
         pos = [centerx - 0.1 * lenx / 2.0, centery - 0.1 * leny / 2.0]
         size = [0.1 * lenx, 0.1 * leny]
         self.mask[self.mask_number] = pg.ROI(pos, size, pen=self.roiPen)
         self.mask_val[self.mask_number] = -1
         #self.mask[self.mask_number].addRotateFreeHandle((0,0),(0.5,0.5))
         self.mask[self.mask_number].addScaleHandle((1, 1), (0.0, 0.0))
         self.shape_ListWidget.addItem(
             str(self.mask_number) + ':inverted-rectangle: pos=' +
             str(pos) + ';size=' + str(size) + ';val=' +
             str(self.mask_val[self.mask_number]))
     elif self.maskShapeComboBox.currentText() == 'ellipse':
         self.mask_type[
             self.mask_number] = self.maskShapeComboBox.currentText()
         pos = [centerx, centery]
         size = [0.1 * lenx, 0.1 * leny]
         self.mask[self.mask_number] = pg.EllipseROI(pos,
                                                     size,
                                                     pen=self.roiPen)
         self.mask_val[self.mask_number] = 1
         self.shape_ListWidget.addItem(
             str(self.mask_number) + ':ellipse: pos=' + str(pos) +
             ';size=' + str(size) + ';val=' +
             str(self.mask_val[self.mask_number]))
     elif self.maskShapeComboBox.currentText() == 'inverted-ellipse':
         self.mask_type[
             self.mask_number] = self.maskShapeComboBox.currentText()
         pos = [centerx, centery]
         size = [0.1 * lenx, 0.1 * leny]
         self.mask[self.mask_number] = pg.EllipseROI(pos,
                                                     size,
                                                     pen=self.roiPen)
         self.mask_val[self.mask_number] = -1
         self.shape_ListWidget.addItem(
             str(self.mask_number) + ':inverted-ellipse: pos=' + str(pos) +
             ';size=' + str(size) + ';val=' +
             str(self.mask_val[self.mask_number]))
     elif self.maskShapeComboBox.currentText() == 'polyline':
         self.mask_type[
             self.mask_number] = self.maskShapeComboBox.currentText()
         self.pg_axis.scene().sigMouseClicked.connect(self.draw_polyline)
         self.roi_finished = False
         self.new_pos = []
         self.mask[self.mask_number] = PolyLineROI_new(self.new_pos,
                                                       closed=False,
                                                       pen=self.roiPen)
         self.mask[self.mask_number].pen = self.roiPen
         self.tmpLine = PolyLineROI_new(self.new_pos,
                                        closed=False,
                                        pen=self.roiPen)
         self.tmpLine.pen = self.roiPen
         self.pg_axis.addItem(self.mask[self.mask_number])
         self.pg_axis.addItem(self.tmpLine)
         return
     elif self.maskShapeComboBox.currentText() == 'inverted-polyline':
         self.mask_type[
             self.mask_number] = self.maskShapeComboBox.currentText()
         self.pg_axis.scene().sigMouseClicked.connect(self.draw_polyline)
         self.roi_finished = False
         self.new_pos = []
         self.mask[self.mask_number] = PolyLineROI_new(self.new_pos,
                                                       closed=False,
                                                       pen=self.roiPen)
         self.tmpLine = PolyLineROI_new(self.new_pos,
                                        closed=False,
                                        pen=self.roiPen)
         self.pg_axis.addItem(self.mask[self.mask_number])
         self.pg_axis.addItem(self.tmpLine)
         return
     if str(self.maskShapeComboBox.currentText()
            ) != 'lower-threshold' and str(
                self.maskShapeComboBox.currentText()) != 'upper-threshold':
         self.pg_axis.addItem(self.mask[self.mask_number])
         self.mask[self.mask_number].sigRegionChangeFinished.connect(
             self.update_shape)
         self.mask[self.mask_number].sigHoverEvent.connect(
             self.shape_selected_in_image)
     self.mask_number = self.mask_number + 1
Example #21
0
 def open_shape_file(self):
     """
     Opens the shape file
     """
     self.masking = 1
     self.shape_ListWidget.clear()
     fname = QFileDialog.getOpenFileName(filter='Shape Files (*.shp)')[0]
     fh = open(fname, 'r')
     lines = fh.readlines()
     #self.shape_ListWidget.addItems(lines)
     for line in lines:
         self.shape_ListWidget.addItem(line.strip())
         s_line = line.strip().split(':')
         self.mask_number = int(s_line[0])
         mask_type = s_line[1]
         self.mask_type[self.mask_number] = mask_type
         if mask_type == 'upper-threshold':
             val = eval(s_line[2].split('=')[1])
             self.mask_val[self.mask_number] = 1
             self.threshold[self.mask_number] = val
             self.mask_number += 1
         elif mask_type == 'lower-threshold':
             val = eval(s_line[2].split('=')[1])
             self.mask_val[self.mask_number] = 1
             self.threshold[self.mask_number] = val
             self.mask_number += 1
         elif (mask_type == 'rectangle') or (mask_type
                                             == 'inverted-rectangle'):
             size_pos = s_line[2].split(';')
             pos = eval(size_pos[0].split('=')[1])
             size = eval(size_pos[1].split('=')[1])
             val = eval(size_pos[2].split('=')[1])
             self.mask[self.mask_number] = pg.ROI(pos, size)
             self.mask_val[self.mask_number] = val
             #self.mask[self.mask_number].addRotateFreeHandle((0,0),(0.5,0.5))
             self.mask[self.mask_number].addScaleHandle((1, 1), (0, 0))
             self.mask[self.mask_number].sigRegionChangeFinished.connect(
                 self.update_shape)
             self.mask[self.mask_number].sigHoverEvent.connect(
                 self.shape_selected_in_image)
             self.pg_axis.addItem(self.mask[self.mask_number])
         elif (mask_type == 'ellipse') or (mask_type == 'inverted-ellipse'):
             size_pos = s_line[2].split(';')
             pos = eval(size_pos[0].split('=')[1])
             size = eval(size_pos[1].split('=')[1])
             val = eval(size_pos[2].split('=')[1])
             self.mask[self.mask_number] = pg.EllipseROI(pos, size)
             self.mask_val[self.mask_number] = val
             self.mask[self.mask_number].sigRegionChangeFinished.connect(
                 self.update_shape)
             self.mask[self.mask_number].sigHoverEvent.connect(
                 self.shape_selected_in_image)
             self.pg_axis.addItem(self.mask[self.mask_number])
         else:
             pos_val = s_line[2].split(';')
             pos = eval(pos_val[0].split('=')[1])
             val = eval(pos_val[1].split('=')[1])
             self.mask[self.mask_number] = PolyLineROI_new(pos, closed=True)
             self.mask_val[self.mask_number] = val
             self.mask[self.mask_number].sigRegionChangeFinished.connect(
                 self.update_shape)
             self.mask[self.mask_number].sigHoverEvent.connect(
                 self.shape_selected_in_image)
             self.pg_axis.addItem(self.mask[self.mask_number])
         #self.mask[self.mask_number].sigRegionChangeStarted.connect(self.move_shape)
     self.mask_number = self.mask_number + 1
Example #22
0
 def addROI(self, pos, size, angle, pen, movable=True):
     roi = pg.EllipseROI(pos, size, angle=angle, pen=pen, movable=movable)
     self.getView().addItem(roi)
     return roi
Example #23
0
    def refreshROIView(self, selected_object_index=None):
        """
        Draws a user-visible ROI for every ROI that belongs to the selected source
        into the CellSelection ImageView.

        If a non-image-sequence is selecteda as source, nothing will be displayed.
        
        Also draws a ROI for the Background if it is chosen for the currently selected ROI.
        """
        if selected_object_index is None:
            selected_object_index = self.data_manager.object_selection
        # remove currently shown objects
        for roi_view in [
                roi_view for roi_view in self.roi_views if roi_view is not None
        ]:
            self.cell_selection.getView().removeItem(roi_view)
        self.roi_views = []
        # remove background roi if shown
        if self.background_roi_view is not None:
            self.cell_selection.getView().removeItem(self.background_roi_view)
            self.background_roi_view = None
        # do not show anything if no roi is selected or selected roi does not belong to image
        if selected_object_index is None or self.data_manager.objects[
                selected_object_index].source.filetype != 'tif':
            self.data_manager.cell_selection.getUserROI().hide()
            return
        colorTable = colors.getColorTable(len(self.data_manager.objects))
        # iterate every roi
        for i in range(len(self.data_manager.objects)):
            current_is_selected = i == selected_object_index
            current_belongs_to_correct_source = self.data_manager.objects[
                i].source is self.data_manager.objects[
                    selected_object_index].source
            # only show roi if it belongs to the source that the selected roi belongs to and roi is active (if its inactive but the selected, still show it!)
            if current_belongs_to_correct_source and (
                    self.data_manager.objects[i].active
                    or current_is_selected):
                roi = self.data_manager.objects[i]
                # get color for the roi
                pen = pg.mkPen(color=colorTable[i], width=2)
                if current_is_selected:
                    # if the roi is the currently selected roi: update the position and color of the roi view, without emitting update signals
                    roi_view = self.data_manager.cell_selection.getUserROI()
                    self.data_manager.cell_selection.disconnectUserROISignals()
                    roi_view.setPen(pen)
                    roi_view.setPos(roi.pos)
                    roi_view.setSize(roi.size)
                    roi_view.setAngle(roi.angle)
                    self.data_manager.cell_selection.connectUserROISignals()
                else:
                    # otherwise, if the roi is not the currently selected roi: create an roi view
                    if roi.ellipse_mode:
                        roi_view = pg.EllipseROI(roi.pos,
                                                 roi.size,
                                                 angle=roi.angle,
                                                 pen=pen,
                                                 movable=False)
                    else:
                        roi_view = pg.RectROI(roi.pos,
                                              roi.size,
                                              pen=pen,
                                              movable=False)
                    self.roi_views.append(roi_view)
                    self.cell_selection.getView().addItem(roi_view)
                    # remove all handles s.t. it can not be edited
                    for h in roi_view.getHandles():
                        roi_view.removeHandle(h)
            else:
                self.roi_views.append(None)
Example #24
0
img1a = pg.ImageItem(arr)
v1a.addItem(img1a)
img1b = pg.ImageItem()
v1b.addItem(img1b)
v1a.disableAutoRange('xy')
v1b.disableAutoRange('xy')
v1a.autoRange()
v1b.autoRange()

rois = []
rois.append(pg.RectROI([20, 20], [20, 20], pen=(0, 9)))
rois[-1].addRotateHandle([1, 0], [0.5, 0.5])
rois.append(pg.LineROI([0, 60], [20, 80], width=5, pen=(1, 9)))
rois.append(
    pg.MultiRectROI([[20, 90], [50, 60], [60, 90]], width=5, pen=(2, 9)))
rois.append(pg.EllipseROI([60, 10], [30, 20], pen=(3, 9)))
rois.append(pg.CircleROI([80, 50], [20, 20], pen=(4, 9)))
#rois.append(pg.LineSegmentROI([[110, 50], [20, 20]], pen=(5,9)))
rois.append(
    pg.PolyLineROI([[80, 60], [90, 30], [60, 40]], pen=(6, 9), closed=True))


def update(roi):
    img1b.setImage(roi.getArrayRegion(arr, img1a), levels=(0, arr.max()))
    v1b.autoRange()


for roi in rois:
    roi.sigRegionChanged.connect(update)
    v1a.addItem(roi)
Example #25
0
    def setup(self):

        TogOff = self.icon + 'Toggle_Off.png'
        TogOn = self.icon + 'Toggle_On.png'
        TogOff = pathlib.Path(TogOff)
        TogOff = pathlib.PurePosixPath(TogOff)
        TogOn = pathlib.Path(TogOn)
        TogOn = pathlib.PurePosixPath(TogOn)

        self.setStyleSheet("QCheckBox::indicator{width: 30px;height: 30px;}"
                           "QCheckBox::indicator:unchecked { image : url(%s);}"
                           "QCheckBox::indicator:checked { image:  url(%s);}"
                           "QCheckBox{font :10pt;}" % (TogOff, TogOn))

        vbox1 = QVBoxLayout()

        hbox2 = QHBoxLayout()
        self.openButton = QPushButton('Open', self)
        self.openButton.setIcon(QtGui.QIcon(self.icon + "Open.png"))
        self.openButton.setIconSize(QtCore.QSize(50, 50))
        self.openButton.setMaximumWidth(200)
        self.openButton.setMaximumHeight(100)
        self.openButton.setShortcut(QtGui.QKeySequence("Ctrl+O"))
        hbox2.addWidget(self.openButton)
        self.openButtonhbox4 = QHBoxLayout()
        self.openButton.setStyleSheet(
            "background-color: transparent ;border-color: transparent")

        self.saveButton = QPushButton('Save', self)
        self.saveButton.setMaximumWidth(100)
        self.saveButton.setMinimumHeight(100)
        self.saveButton.setIconSize(QtCore.QSize(50, 50))
        hbox2.addWidget(self.saveButton)
        self.saveButton.setIcon(QtGui.QIcon(self.icon + "Saving.png"))
        self.saveButton.setStyleSheet(
            "background-color: transparent ;border-color: transparent")
        vbox1.addLayout(hbox2)

        hbox3 = QHBoxLayout()
        grid_layout0 = QGridLayout()
        self.checkBoxAutoSave = QCheckBox('AutoSave', self)
        self.checkBoxAutoSave.setChecked(False)
        grid_layout0.addWidget(self.checkBoxAutoSave, 0, 0)
        self.checkBoxBg = QCheckBox('Bg substraction', self)
        self.checkBoxBg.setChecked(False)
        grid_layout0.addWidget(self.checkBoxBg, 1, 0)
        self.optionAutoSave = QPushButton('Options', self)
        hbox3.addLayout(grid_layout0)
        self.optionAutoSave.setIcon(QtGui.QIcon(self.icon + "Settings.png"))
        #self.optionAutoSave.setIconSize(QtCore.QSize(20,20))
        hbox3.addWidget(self.optionAutoSave)
        vbox1.addLayout(hbox3)

        hbox8 = QHBoxLayout()

        hbox4 = QHBoxLayout()
        self.labelFileName = QLabel("File :")
        self.labelFileName.setStyleSheet("font:15pt;")
        self.labelFileName.setMinimumHeight(30)
        self.labelFileName.setMaximumWidth(40)
        hbox4.addWidget(self.labelFileName)
        hbox42 = QHBoxLayout()

        self.fileName = QLabel()
        self.fileName.setStyleSheet("font:10pt")
        self.fileName.setMaximumHeight(30)
        self.fileName.setMaximumWidth(150)
        hbox42.addWidget(self.fileName)
        vbox1.addLayout(hbox4)
        vbox1.addLayout(hbox42)

        hbox5 = QHBoxLayout()
        self.checkBoxPlot = QCheckBox('CROSS', self)
        self.checkBoxPlot.setChecked(False)

        hbox5.addWidget(self.checkBoxPlot)
        hbox6 = QHBoxLayout()
        self.label_Cross = QLabel()
        #self.label_Cross.setMaximumHeight(20)
        self.label_Cross.setMaximumWidth(150)
        self.label_Cross.setStyleSheet("font:10pt")
        hbox6.addWidget(self.label_Cross)
        #hbox6.setSpacing(1)
        vbox1.addLayout(hbox5)
        vbox1.addLayout(hbox6)

        self.ZoomLabel = QLabel('Zoom')
        vbox1.addWidget(self.ZoomLabel)
        self.checkBoxZoom = QSlider(Qt.Horizontal)
        self.checkBoxZoom.setMaximumWidth(200)
        self.checkBoxZoom.setMinimum(-5)
        self.checkBoxZoom.setMaximum(100)
        self.checkBoxZoom.setValue(-20)
        vbox1.addWidget(self.checkBoxZoom)

        self.checkBoxScale = QCheckBox('Auto Scale', self)
        self.checkBoxScale.setChecked(True)
        self.checkBoxScale.setMaximumWidth(100)

        self.checkBoxColor = QCheckBox('Color', self)
        self.checkBoxColor.setChecked(True)

        self.checkBoxHist = QCheckBox('Hist', self)
        self.checkBoxHist.setChecked(False)
        self.maxGraphBox = QCheckBox('Max', self)
        grid_layout = QGridLayout()
        grid_layout.setVerticalSpacing(0)
        grid_layout.setHorizontalSpacing(10)
        grid_layout.addWidget(self.checkBoxScale, 0, 0)
        grid_layout.addWidget(self.checkBoxColor, 1, 0)
        grid_layout.addWidget(self.checkBoxHist, 0, 1)
        #grid_layout.addWidget(self.checkBoxZoom, 1, 0)
        grid_layout.addWidget(self.maxGraphBox, 1, 1)

        hbox8.addLayout(grid_layout)

        vbox1.addLayout(hbox8)

        hbox9 = QHBoxLayout()
        self.energyBox = QPushButton('&Encercled', self)
        hbox9.addWidget(self.energyBox)
        self.filtreBox = QPushButton('&Filters', self)
        menu = QMenu()
        menu.addAction('&Gaussian', self.Gauss)
        menu.addAction('&Median', self.Median)
        menu.addAction('&Origin', self.Orig)
        self.filtreBox.setMenu(menu)
        hbox9.addWidget(self.filtreBox)
        vbox1.addLayout(hbox9)

        hbox11 = QHBoxLayout()
        self.PlotButton = QPushButton('Plot')
        hbox11.addWidget(self.PlotButton)
        self.MeasButton = QPushButton('Meas.')
        hbox11.addWidget(self.MeasButton)

        hbox10 = QHBoxLayout()
        self.ligneButton = QPushButton('Line')
        self.ligneButton.setIcon(QtGui.QIcon(self.icon + "ligne.jpeg"))

        hbox10.addWidget(self.ligneButton)

        self.rectangleButton = QPushButton('Rect')
        self.rectangleButton.setIcon(QtGui.QIcon(self.icon + "rectangle.png"))
        hbox10.addWidget(self.rectangleButton)

        self.circleButton = QPushButton('Circle')
        self.circleButton.setIcon(QtGui.QIcon(self.icon + "Red_circle.png"))
        hbox10.addWidget(self.circleButton)

        vbox1.addLayout(hbox11)
        vbox1.addLayout(hbox10)
        vbox1.addStretch(1)

        self.winImage = pg.GraphicsLayoutWidget()
        self.winImage.setContentsMargins(0, 0, 0, 0)
        self.winImage.setAspectLocked(True)
        self.winImage.setSizePolicy(QSizePolicy.Expanding,
                                    QSizePolicy.Expanding)
        self.winImage.ci.setContentsMargins(0, 0, 0, 0)

        vbox2 = QVBoxLayout()
        vbox2.addWidget(self.winImage)
        vbox2.setContentsMargins(0, 0, 0, 0)

        self.p1 = self.winImage.addPlot()
        self.imh = pg.ImageItem()
        self.p1.addItem(self.imh)
        self.p1.setMouseEnabled(x=False, y=False)
        self.p1.setContentsMargins(0, 0, 0, 0)

        self.p1.setAspectLocked(True, ratio=1)
        self.p1.showAxis('right', show=False)
        self.p1.showAxis('top', show=False)
        self.p1.showAxis('left', show=False)
        self.p1.showAxis('bottom', show=False)

        self.vLine = pg.InfiniteLine(angle=90, movable=False, pen='y')
        self.hLine = pg.InfiniteLine(angle=0, movable=False, pen='y')

        self.xc = 10
        self.yc = 10
        self.rx = 50
        self.ry = 50
        self.vLine.setPos(self.xc)
        self.hLine.setPos(self.yc)

        self.ro1 = pg.EllipseROI([self.xc, self.yc], [self.rx, self.ry],
                                 pen='y',
                                 movable=False,
                                 maxBounds=QtCore.QRectF(
                                     0, 0, self.rx, self.ry))
        self.ro1.setPos([self.xc - (self.rx / 2), self.yc - (self.ry / 2)])

        # text for fwhm on p1
        self.textX = pg.TextItem(angle=-90)
        self.textY = pg.TextItem()

        #histogram
        self.hist = pg.HistogramLUTItem()
        self.hist.setImageItem(self.imh)
        self.hist.autoHistogramRange()
        self.hist.gradient.loadPreset('flame')

        ##  XY  graph
        self.curve2 = pg.PlotCurveItem()
        self.curve3 = pg.PlotCurveItem()

        ## main layout
        hMainLayout = QHBoxLayout()
        hMainLayout.addLayout(vbox2)
        hMainLayout.addLayout(vbox1)
        hMainLayout.setContentsMargins(1, 1, 1, 1)
        hMainLayout.setSpacing(1)
        hMainLayout.setStretch(10, 1)

        self.setLayout(hMainLayout)
        self.setContentsMargins(1, 1, 1, 1)
        #self.plotLine=pg.LineSegmentROI(positions=((self.dimx/2-100,self.dimy/2),(self.dimx/2+100,self.dimy/2)), movable=True,angle=0,pen='b')
        self.plotLine = pg.LineSegmentROI(positions=((0, 200), (200, 200)),
                                          movable=True,
                                          angle=0,
                                          pen='w')
        #self.plotLine=pg.PolyLineROI(positions=((0,200),(200,200),(300,200)), movable=True,angle=0,pen='w')
        self.plotRect = pg.RectROI([self.xc, self.yc], [4 * self.rx, self.ry],
                                   pen='g')
        self.plotCercle = pg.CircleROI([self.xc, self.yc], [80, 80], pen='g')