Ejemplo n.º 1
0
    def on_imageZoomDoubleSpinBox_valueChanged(self, zoom=None):
        ''' Called when the user wants to plot only a subset of the data
        
        :Parameters:
        
        index : int
                New index in the subset combobox
        '''

        if zoom is None: zoom = self.ui.imageZoomDoubleSpinBox.value()
        self.ui.zoomSlider.blockSignals(True)
        self.ui.zoomSlider.setValue(int(self.ui.zoomSlider.maximum() * zoom))
        self.ui.zoomSlider.blockSignals(False)

        if self.imagesize > 0:
            n = max(5, int(self.imagesize * zoom))
            self.ui.imageListView.setIconSize(QtCore.QSize(n, n))
Ejemplo n.º 2
0
    def on_loadImagesPushButton_clicked(self):
        ''' Load the current batch of images into the list
        '''

        if len(self.files) == 0: return
        self.imageListModel.clear()
        index, start = self.imageSubset(self.ui.pageSpinBox.value() - 1,
                                        self.ui.imageCountSpinBox.value())
        if len(index) == 0:
            self.ui.pageSpinBox.blockSignals(True)
            self.ui.pageSpinBox.setValue(0)
            self.ui.pageSpinBox.blockSignals(False)
            self.ui.imageCountSpinBox.blockSignals(True)
            self.ui.imageCountSpinBox.setValue(1)
            self.ui.imageCountSpinBox.blockSignals(False)
            index, start = self.imageSubset(0, 1)
        bin_factor = self.ui.decimateSpinBox.value()
        nstd = self.ui.clampDoubleSpinBox.value()
        img = None
        self.loaded_images = []
        self.base_level = None
        zoom = self.ui.imageZoomDoubleSpinBox.value()
        masks = {}

        template = self.get_template()

        progressDialog = QtGui.QProgressDialog('Opening...', "Cancel", 0,
                                               len(index), self)
        progressDialog.setWindowModality(QtCore.Qt.WindowModal)
        progressDialog.show()

        self.ui.imageListView.setModel(None)

        if not drawing.is_available():
            _logger.info("No PIL loaded")
            self.advanced_settings.mark_image = False
        if not plotting.is_available():
            _logger.info("No matplotlib loaded")
            self.advanced_settings.mark_image = False

        current_powerspec = self.advanced_settings.current_powerspec
        if current_powerspec:
            if self.advanced_settings.invert:
                _logger.info("Cannot invert a power spectra")
        else:
            if self.advanced_settings.center_mask > 0:
                _logger.info("Cannot mask micrograph")

        added_items = []
        for i, (imgname, img, pixel_size) in enumerate(
                iter_images(self.files, index, template)):
            selimg = None
            progressDialog.setValue(i + 1)
            if hasattr(img, 'ndim'):
                if current_powerspec and self.advanced_settings.center_mask > 0 and img.shape not in masks:
                    masks[img.shape] = ndimage_utility.model_disk(
                        self.advanced_settings.center_mask, img.shape) * -1 + 1
                if self.advanced_settings.invert and not current_powerspec:
                    if img.max() != img.min(): ndimage_utility.invert(img, img)
                img = ndimage_utility.replace_outlier(img,
                                                      nstd,
                                                      nstd,
                                                      replace='mean')
                if self.advanced_settings.gaussian_high_pass > 0.0:
                    img = ndimage_filter.filter_gaussian_highpass(
                        img,
                        pixel_size / self.advanced_settings.gaussian_high_pass)
                if self.advanced_settings.gaussian_low_pass > 0.0:
                    img = ndimage_filter.filter_gaussian_lowpass(
                        img,
                        pixel_size / self.advanced_settings.gaussian_low_pass)
                if current_powerspec and self.advanced_settings.center_mask > 0:
                    #img[numpy.logical_not(masks[img.shape])] = numpy.mean(img[masks[img.shape]])
                    img *= masks[img.shape]
                if bin_factor > 1.0:
                    img = ndimage_interpolate.interpolate(
                        img, bin_factor,
                        self.advanced_settings.downsample_type)
                pixel_size *= bin_factor
                img = self.display_powerspectra_1D(img, imgname, pixel_size)
                img = self.display_resolution(img, imgname, pixel_size)
                img = self.box_particles(img, imgname)
                if self.advanced_settings.mark_image:
                    imgm = self.imageMarker(img)
                    selimg = qimage_utility.numpy_to_qimage(imgm)
                qimg = qimage_utility.numpy_to_qimage(img)
                if img.ndim == 2:
                    if self.base_level is not None:
                        qimg.setColorTable(self.color_level)
                    else:
                        self.base_level = qimg.colorTable()
                        self.color_level = qimage_utility.adjust_level(
                            qimage_utility.change_contrast, self.base_level,
                            self.ui.contrastSlider.value())
                        qimg.setColorTable(self.color_level)
                else:
                    if self.base_level is None: self.base_level = []
                    self.base_level.append(qimg.colorTable())
                    self.color_level = qimage_utility.adjust_level(
                        qimage_utility.change_contrast, self.base_level[-1],
                        self.ui.contrastSlider.value())
                    qimg.setColorTable(self.color_level)

            else:
                qimg = img.convertToFormat(QtGui.QImage.Format_Indexed8)
                if self.base_level is None: self.base_level = []
                self.base_level.append(qimg.colorTable())
                self.color_level = qimage_utility.adjust_level(
                    qimage_utility.change_contrast, self.base_level[-1],
                    self.ui.contrastSlider.value())
                qimg.setColorTable(self.color_level)
            self.loaded_images.append(qimg)
            pix = QtGui.QPixmap.fromImage(qimg)
            icon = QtGui.QIcon()
            icon.addPixmap(pix, QtGui.QIcon.Normal)
            if selimg is not None:
                pix = QtGui.QPixmap.fromImage(selimg)
            icon.addPixmap(pix, QtGui.QIcon.Selected)
            if self.advanced_settings.show_label:
                item = QtGui.QStandardItem(
                    icon,
                    "%s/%d" % (os.path.basename(imgname[0]), imgname[1] + 1))
            else:
                item = QtGui.QStandardItem(icon, "")
            if hasattr(start, '__iter__'):
                item.setData(start[i], QtCore.Qt.UserRole)
            else:
                item.setData(i + start, QtCore.Qt.UserRole)

            self.addToolTipImage(imgname, item, pixel_size)
            self.imageListModel.appendRow(item)
            added_items.append(item)

        self.ui.imageListView.setModel(self.imageListModel)
        progressDialog.hide()
        for item in added_items:
            self.notify_added_item(item)

        self.imagesize = img.shape[0] if hasattr(img, 'shape') else img.width()
        n = max(5, int(self.imagesize * zoom))
        self.ui.imageListView.setIconSize(QtCore.QSize(n, n))

        batch_count = numpy.ceil(
            float(self.imageTotal()) / self.ui.imageCountSpinBox.value())
        self.ui.pageSpinBox.setSuffix(" of %d" % batch_count)
        self.ui.pageSpinBox.setMaximum(batch_count)
        self.ui.actionForward.setEnabled(
            self.ui.pageSpinBox.value() < batch_count)
        self.ui.actionBackward.setEnabled(self.ui.pageSpinBox.value() > 0)