def simgv_load_image_to_viewer(self, index):
        """
        Load an image to viewer. If the show feature points is checked, then load feature points as well.
        This option can be done only if the user has run a feature point method first.
        :param index: index of image to load.
        :return: Nothing
        """
        if self.draw_kp:
            img_rgb = self.image_list[index].img_get_img_rgb_with_feature_points()
            feature_point_number = len(self.image_list[index].feature_points.keypoints)
            self.ui_simple_img_viewer.label_feature_points_number.setText(str(feature_point_number))
        else:
            img_rgb = self.image_list[index].img_get_img_rgb()
            self.ui_simple_img_viewer.label_feature_points_number.clear()
        bytes_per_line = 3 * self.image_list[index].info.width
        q_img = QImage(img_rgb, self.image_list[index].info.width, self.image_list[index].info.height,
                                bytes_per_line, QImage.Format_RGB888)
        width = self.ui_simple_img_viewer.image_view.width()
        height = self.ui_simple_img_viewer.image_view.height()
        if q_img.width() < width or q_img.height() < height:
            width = q_img.width()
            height = q_img.height()
        size = QSize(width, height)
        pixmap = QPixmap()
        pixmap = pixmap.fromImage(q_img)
        pixmap = pixmap.scaled(size, self.Q_ASPECT_RATIO)
        self.ui_simple_img_viewer.image_view.setPixmap(pixmap)
        self.ui_simple_img_viewer.image_view.show()

        self.ui_simple_img_viewer.button_previous.setEnabled(self.UP)
        self.ui_simple_img_viewer.button_next.setEnabled(self.UP)
        if index == 0:
            self.ui_simple_img_viewer.button_previous.setEnabled(self.DOWN)
        if index == len(self.image_list) - 1:
            self.ui_simple_img_viewer.button_next.setEnabled(self.DOWN)
Example #2
0
    def showPicture(self):
        fileName = DBConnectSingleton.instance.getPicPath(self.p_id)
        self.lbl_photo_loc.setText(fileName)
        if (len(fileName) is not 0):
            print(fileName)
        img = QImage(fileName)
        if(img.width() is 0 or img.height() is 0):
            msgBox = QMessageBox()
            msgBox.setText("The file is not exist.");
            msgBox.exec();
            return
        h = self.lbl_photo_view.height()
        w = self.lbl_photo_view.width()

        img_h = img.height()
        img_w = img.width()
        if (img_h > img_w):
            scale_factor = h / img_h
            img_h = h
            img_w *= scale_factor
        else:
            scale_factor = w / img_w
            img_w = w
            img_h *= scale_factor
        image = img.scaledToHeight(img_h)
        self.lbl_photo_view.setPixmap(QPixmap.fromImage(image))
Example #3
0
    def showPicture(self):
        fileName = DBConnectSingleton.instance.getPicPath(self.p_id)
        if (len(fileName) is not 0):
            print(fileName)
        img = QImage(fileName)
        if(img.height() is 0 or img.width() is 0):
            msg = QMessageBox()
            msg.setWindowTitle("ERROR")
            msg.setText("File open ERROR")
            msg.exec()
            return
        h = 155
        w = 201

        img_h = img.height()
        img_w = img.width()
        if (img_h > img_w):
            scale_factor = h / img_h
            img_h = h
            img_w *= scale_factor
        else:
            scale_factor = w / img_w
            img_w = w
            img_h *= scale_factor
        image = img.scaledToHeight(img_h)
        self.lbl_pic_view.setPixmap(QPixmap.fromImage(image))
Example #4
0
def scale_image(data, width=60, height=80, compression_quality=70, as_png=False, preserve_aspect_ratio=True):
    ''' Scale an image, returning it as either JPEG or PNG data (bytestring).
    Transparency is alpha blended with white when converting to JPEG. Is thread
    safe and does not require a QApplication. '''
    # We use Qt instead of ImageMagick here because ImageMagick seems to use
    # some kind of memory pool, causing memory consumption to sky rocket.
    if isinstance(data, QImage):
        img = data
    else:
        img = QImage()
        if not img.loadFromData(data):
            raise ValueError('Could not load image for thumbnail generation')
    if preserve_aspect_ratio:
        scaled, nwidth, nheight = fit_image(img.width(), img.height(), width, height)
        if scaled:
            img = img.scaled(nwidth, nheight, Qt.KeepAspectRatio, Qt.SmoothTransformation)
    else:
        if img.width() != width or img.height() != height:
            img = img.scaled(width, height, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
    if not as_png and img.hasAlphaChannel():
        nimg = QImage(img.size(), QImage.Format_RGB32)
        nimg.fill(Qt.white)
        p = QPainter(nimg)
        p.drawImage(0, 0, img)
        p.end()
        img = nimg
    ba = QByteArray()
    buf = QBuffer(ba)
    buf.open(QBuffer.WriteOnly)
    fmt = 'PNG' if as_png else 'JPEG'
    if not img.save(buf, fmt, quality=compression_quality):
        raise ValueError('Failed to export thumbnail image to: ' + fmt)
    return img.width(), img.height(), ba.data()
Example #5
0
class Body(QGraphicsItem):
    def __init__(self, parent, width, height):
        super().__init__(parent=parent)
        self.width = width
        self.height = height
        # self.setOpacity(0.0)
        self.head_img = QImage("resource/a_oryzae.png")

    def paint(self,
              paint: QPainter,
              style: QStyleOptionGraphicsItem,
              widget=None):
        qpen = QPen()
        qpen.setColor(Qt.white)
        # paint.setBackground()
        paint.setPen(qpen)
        aspect = self.head_img.width() / self.head_img.height()
        ratio = self.height * 0.2
        target = QRectF(0, 0, aspect * ratio, ratio)
        source = QRectF(0, 0, self.head_img.width(), self.head_img.height())

        paint.drawImage(target, self.head_img, source)

    def boundingRect(self):
        return QRectF(0, 0, self.width, self.height)
Example #6
0
 def render_html(self, ok):
     try:
         if not ok:
             return
         cwidth, cheight = self.page.mainFrame().contentsSize().width(), self.page.mainFrame().contentsSize().height()
         self.page.setViewportSize(QSize(cwidth, cheight))
         factor = float(self.width)/cwidth if cwidth > self.width else 1
         cutoff_height = int(self.height/factor)-3
         image = QImage(self.page.viewportSize(), QImage.Format_ARGB32)
         image.setDotsPerMeterX(self.dpi*(100/2.54))
         image.setDotsPerMeterY(self.dpi*(100/2.54))
         painter = QPainter(image)
         self.page.mainFrame().render(painter)
         painter.end()
         cheight = image.height()
         cwidth = image.width()
         pos = 0
         while pos < cheight:
             img = image.copy(0, pos, cwidth, min(cheight-pos, cutoff_height))
             pos += cutoff_height-20
             if cwidth > self.width:
                 img = img.scaledToWidth(self.width, Qt.SmoothTransform)
             f = os.path.join(self.tdir, '%d.png'%pos)
             img.save(f)
             self.images.append((f, img.width(), img.height()))
     finally:
         QApplication.quit()
Example #7
0
 def __init__ (self,database,progressBar,parent=None):
     super(Univers,self).__init__(parent)
     self.progress = progressBar
     self.factions = {}
     self.temples = {}
     self.database = database
     self.list_actions = {}
     self.cancelled_heros_id = []
     self.modifications = []
     self.loadFromFile()
     self.currentFaction = None
     self.currentEmpire = None
     self.currentKingdom= None
     self.currentGroupe= None     
     self.selected_Warriors = [[],[]]
     self.filtered_Warriors = []
     self.settings = Config().instance.settings
     colors =  self.settings.value ("global/groupe_color").split(",")
     self.groupe_color_icons = {}
     self.groupe_color_value = {}
     for color in colors :
         icon = QIcon(":textures/"+color)
         self.groupe_color_icons[color] = icon
         image = QImage(":textures/"+color)
         value = image.pixel(image.width()/2.0,image.height()/2.0)
         # pour view map donner une couleur a item warrior
         self.groupe_color_value[color]  = QColor(value)
Example #8
0
    def render_cover(self, book_id):
        if self.ignore_render_requests.is_set():
            return
        tcdata, timestamp = self.thumbnail_cache[book_id]
        use_cache = False
        if timestamp is None:
            # Not in cache
            has_cover, cdata, timestamp = self.model(
            ).db.new_api.cover_or_cache(book_id, 0)
        else:
            has_cover, cdata, timestamp = self.model(
            ).db.new_api.cover_or_cache(book_id, timestamp)
            if has_cover and cdata is None:
                # The cached cover is fresh
                cdata = tcdata
                use_cache = True

        if has_cover:
            p = QImage()
            p.loadFromData(cdata, CACHE_FORMAT if cdata is tcdata else 'JPEG')
            dpr = self.device_pixel_ratio
            p.setDevicePixelRatio(dpr)
            if p.isNull() and cdata is tcdata:
                # Invalid image in cache
                self.thumbnail_cache.invalidate((book_id, ))
                self.update_item.emit(book_id)
                return
            cdata = None if p.isNull() else p
            if not use_cache:  # cache is stale
                if cdata is not None:
                    width, height = p.width(), p.height()
                    scaled, nwidth, nheight = fit_image(
                        width, height,
                        int(dpr * self.delegate.cover_size.width()),
                        int(dpr * self.delegate.cover_size.height()))
                    if scaled:
                        if self.ignore_render_requests.is_set():
                            return
                        p = p.scaled(nwidth, nheight, Qt.IgnoreAspectRatio,
                                     Qt.SmoothTransformation)
                        p.setDevicePixelRatio(dpr)
                    cdata = p
                # update cache
                if cdata is None:
                    self.thumbnail_cache.invalidate((book_id, ))
                else:
                    try:
                        self.thumbnail_cache.insert(book_id, timestamp,
                                                    image_to_data(cdata))
                    except EncodeError as err:
                        self.thumbnail_cache.invalidate((book_id, ))
                        prints(err)
                    except Exception:
                        import traceback
                        traceback.print_exc()
        elif tcdata is not None:
            # Cover was removed, but it exists in cache, remove from cache
            self.thumbnail_cache.invalidate((book_id, ))
        self.delegate.cover_cache.set(book_id, cdata)
        self.update_item.emit(book_id)
Example #9
0
def generate_cover(mi, prefs=None, as_qimage=False):
    init_environment()
    prefs = prefs or cprefs
    prefs = {k: prefs.get(k) for k in cprefs.defaults}
    prefs = Prefs(**prefs)
    color_theme = random.choice(load_color_themes(prefs))
    style = random.choice(load_styles(prefs))(color_theme, prefs)
    title, subtitle, footer = format_text(mi, prefs)
    img = QImage(prefs.cover_width, prefs.cover_height, QImage.Format_ARGB32)
    title_block, subtitle_block, footer_block = layout_text(
        prefs, img, title, subtitle, footer,
        img.height() // 3, style)
    p = QPainter(img)
    rect = QRect(0, 0, img.width(), img.height())
    colors = style(p, rect, color_theme, title_block, subtitle_block,
                   footer_block)
    for block, color in zip((title_block, subtitle_block, footer_block),
                            colors):
        p.setPen(color)
        block.draw(p)
    p.end()
    img.setText('Generated cover', '%s %s' % (__appname__, __version__))
    if as_qimage:
        return img
    return pixmap_to_data(img)
Example #10
0
 def render_html(self, ok):
     try:
         if not ok:
             return
         cwidth, cheight = self.page.mainFrame().contentsSize().width(
         ), self.page.mainFrame().contentsSize().height()
         self.page.setViewportSize(QSize(cwidth, cheight))
         factor = float(self.width) / cwidth if cwidth > self.width else 1
         cutoff_height = int(self.height / factor) - 3
         image = QImage(self.page.viewportSize(), QImage.Format_ARGB32)
         image.setDotsPerMeterX(self.dpi * (100 / 2.54))
         image.setDotsPerMeterY(self.dpi * (100 / 2.54))
         painter = QPainter(image)
         self.page.mainFrame().render(painter)
         painter.end()
         cheight = image.height()
         cwidth = image.width()
         pos = 0
         while pos < cheight:
             img = image.copy(0, pos, cwidth,
                              min(cheight - pos, cutoff_height))
             pos += cutoff_height - 20
             if cwidth > self.width:
                 img = img.scaledToWidth(self.width, Qt.SmoothTransform)
             f = os.path.join(self.tdir, '%d.png' % pos)
             img.save(f)
             self.images.append((f, img.width(), img.height()))
     finally:
         QApplication.quit()
Example #11
0
def calibre_cover2(title,
                   author_string='',
                   series_string='',
                   prefs=None,
                   as_qimage=False,
                   logo_path=None):
    init_environment()
    title, subtitle, footer = '<b>' + escape_formatting(
        title), '<i>' + escape_formatting(
            series_string), '<b>' + escape_formatting(author_string)
    prefs = prefs or cprefs
    prefs = {k: prefs.get(k) for k in cprefs.defaults}
    scale = 800. / prefs['cover_height']
    scale_cover(prefs, scale)
    prefs = Prefs(**prefs)
    img = QImage(prefs.cover_width, prefs.cover_height,
                 QImage.Format.Format_ARGB32)
    img.fill(Qt.GlobalColor.white)
    # colors = to_theme('ffffff ffffff 000000 000000')
    color_theme = theme_to_colors(fallback_colors)

    class CalibeLogoStyle(Style):
        NAME = GUI_NAME = 'calibre'

        def __call__(self, painter, rect, color_theme, title_block,
                     subtitle_block, footer_block):
            top = title_block.position.y + 10
            extra_spacing = subtitle_block.line_spacing // 2 if subtitle_block.line_spacing else title_block.line_spacing // 3
            height = title_block.height + subtitle_block.height + extra_spacing + title_block.leading
            top += height + 25
            bottom = footer_block.position.y - 50
            logo = QImage(logo_path or I('library.png'))
            pwidth, pheight = rect.width(), bottom - top
            scaled, width, height = fit_image(logo.width(), logo.height(),
                                              pwidth, pheight)
            x, y = (pwidth - width) // 2, (pheight - height) // 2
            rect = QRect(x, top + y, width, height)
            painter.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform)
            painter.drawImage(rect, logo)
            return self.ccolor1, self.ccolor1, self.ccolor1

    style = CalibeLogoStyle(color_theme, prefs)
    title_block, subtitle_block, footer_block = layout_text(
        prefs, img, title, subtitle, footer,
        img.height() // 3, style)
    p = QPainter(img)
    rect = QRect(0, 0, img.width(), img.height())
    colors = style(p, rect, color_theme, title_block, subtitle_block,
                   footer_block)
    for block, color in zip((title_block, subtitle_block, footer_block),
                            colors):
        p.setPen(color)
        block.draw(p)
    p.end()
    img.setText('Generated cover', '%s %s' % (__appname__, __version__))
    if as_qimage:
        return img
    return pixmap_to_data(img)
Example #12
0
    def add_image(self, img, cache_key):
        ref = self.get_image(cache_key)
        if ref is not None:
            return ref

        fmt = img.format()
        image = QImage(img)
        if (image.depth() == 1 and img.colorTable().size() == 2 and
            img.colorTable().at(0) == QColor(Qt.black).rgba() and
            img.colorTable().at(1) == QColor(Qt.white).rgba()):
            if fmt == QImage.Format_MonoLSB:
                image = image.convertToFormat(QImage.Format_Mono)
            fmt = QImage.Format_Mono
        else:
            if (fmt != QImage.Format_RGB32 and fmt != QImage.Format_ARGB32):
                image = image.convertToFormat(QImage.Format_ARGB32)
                fmt = QImage.Format_ARGB32

        w = image.width()
        h = image.height()
        d = image.depth()

        if fmt == QImage.Format_Mono:
            bytes_per_line = (w + 7) >> 3
            data = image.constBits().asstring(bytes_per_line * h)
            return self.write_image(data, w, h, d, cache_key=cache_key)

        has_alpha = False
        soft_mask = None

        if fmt == QImage.Format_ARGB32:
            tmask = image.constBits().asstring(4*w*h)[self.alpha_bit::4]
            sdata = bytearray(tmask)
            vals = set(sdata)
            vals.discard(255)  # discard opaque pixels
            has_alpha = bool(vals)
            if has_alpha:
                # Blend image onto a white background as otherwise Qt will render
                # transparent pixels as black
                background = QImage(image.size(), QImage.Format_ARGB32_Premultiplied)
                background.fill(Qt.white)
                painter = QPainter(background)
                painter.drawImage(0, 0, image)
                painter.end()
                image = background

        ba = QByteArray()
        buf = QBuffer(ba)
        image.save(buf, 'jpeg', 94)
        data = bytes(ba.data())

        if has_alpha:
            soft_mask = self.write_image(tmask, w, h, 8)

        return self.write_image(data, w, h, 32, dct=True,
                                soft_mask=soft_mask, cache_key=cache_key)
Example #13
0
    def render_cover(self, book_id):
        if self.ignore_render_requests.is_set():
            return
        dpr = self.device_pixel_ratio
        page_width = int(dpr * self.delegate.cover_size.width())
        page_height = int(dpr * self.delegate.cover_size.height())
        tcdata, timestamp = self.thumbnail_cache[book_id]
        use_cache = False
        if timestamp is None:
            # Not in cache
            has_cover, cdata, timestamp = self.model().db.new_api.cover_or_cache(book_id, 0)
        else:
            has_cover, cdata, timestamp = self.model().db.new_api.cover_or_cache(book_id, timestamp)
            if has_cover and cdata is None:
                # The cached cover is fresh
                cdata = tcdata
                use_cache = True

        if has_cover:
            p = QImage()
            p.loadFromData(cdata, CACHE_FORMAT if cdata is tcdata else 'JPEG')
            p.setDevicePixelRatio(dpr)
            if p.isNull() and cdata is tcdata:
                # Invalid image in cache
                self.thumbnail_cache.invalidate((book_id,))
                self.update_item.emit(book_id)
                return
            cdata = None if p.isNull() else p
            if not use_cache:  # cache is stale
                if cdata is not None:
                    width, height = p.width(), p.height()
                    scaled, nwidth, nheight = fit_image(
                        width, height, page_width, page_height)
                    if scaled:
                        if self.ignore_render_requests.is_set():
                            return
                        p = p.scaled(nwidth, nheight, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
                        p.setDevicePixelRatio(dpr)
                    cdata = p
                # update cache
                if cdata is None:
                    self.thumbnail_cache.invalidate((book_id,))
                else:
                    try:
                        self.thumbnail_cache.insert(book_id, timestamp, image_to_data(cdata))
                    except EncodeError as err:
                        self.thumbnail_cache.invalidate((book_id,))
                        prints(err)
                    except Exception:
                        import traceback
                        traceback.print_exc()
        elif tcdata is not None:
            # Cover was removed, but it exists in cache, remove from cache
            self.thumbnail_cache.invalidate((book_id,))
        self.delegate.cover_cache.set(book_id, cdata)
        self.update_item.emit(book_id)
Example #14
0
    def add_image(self, img, cache_key):
        ref = self.get_image(cache_key)
        if ref is not None:
            return ref

        fmt = img.format()
        image = QImage(img)
        if (image.depth() == 1 and img.colorTable().size() == 2 and
            img.colorTable().at(0) == QColor(Qt.black).rgba() and
            img.colorTable().at(1) == QColor(Qt.white).rgba()):
            if fmt == QImage.Format_MonoLSB:
                image = image.convertToFormat(QImage.Format_Mono)
            fmt = QImage.Format_Mono
        else:
            if (fmt != QImage.Format_RGB32 and fmt != QImage.Format_ARGB32):
                image = image.convertToFormat(QImage.Format_ARGB32)
                fmt = QImage.Format_ARGB32

        w = image.width()
        h = image.height()
        d = image.depth()

        if fmt == QImage.Format_Mono:
            bytes_per_line = (w + 7) >> 3
            data = image.constBits().asstring(bytes_per_line * h)
            return self.write_image(data, w, h, d, cache_key=cache_key)

        has_alpha = False
        soft_mask = None

        if fmt == QImage.Format_ARGB32:
            tmask = image.constBits().asstring(4*w*h)[self.alpha_bit::4]
            sdata = bytearray(tmask)
            vals = set(sdata)
            vals.discard(255)  # discard opaque pixels
            has_alpha = bool(vals)
            if has_alpha:
                # Blend image onto a white background as otherwise Qt will render
                # transparent pixels as black
                background = QImage(image.size(), QImage.Format_ARGB32_Premultiplied)
                background.fill(Qt.white)
                painter = QPainter(background)
                painter.drawImage(0, 0, image)
                painter.end()
                image = background

        ba = QByteArray()
        buf = QBuffer(ba)
        image.save(buf, 'jpeg', 94)
        data = ba.data()

        if has_alpha:
            soft_mask = self.write_image(tmask, w, h, 8)

        return self.write_image(data, w, h, 32, dct=True,
                                soft_mask=soft_mask, cache_key=cache_key)
Example #15
0
def scale_image(data,
                width=60,
                height=80,
                compression_quality=70,
                as_png=False,
                preserve_aspect_ratio=True):
    ''' Scale an image, returning it as either JPEG or PNG data (bytestring).
    Transparency is alpha blended with white when converting to JPEG. Is thread
    safe and does not require a QApplication. '''
    # We use Qt instead of ImageMagick here because ImageMagick seems to use
    # some kind of memory pool, causing memory consumption to sky rocket.
    if isinstance(data, QImage):
        img = data
    else:
        img = QImage()
        if not img.loadFromData(data):
            raise ValueError('Could not load image for thumbnail generation')
    if preserve_aspect_ratio:
        scaled, nwidth, nheight = fit_image(img.width(), img.height(), width,
                                            height)
        if scaled:
            img = img.scaled(nwidth, nheight, Qt.KeepAspectRatio,
                             Qt.SmoothTransformation)
    else:
        if img.width() != width or img.height() != height:
            img = img.scaled(width, height, Qt.IgnoreAspectRatio,
                             Qt.SmoothTransformation)
    if not as_png and img.hasAlphaChannel():
        nimg = QImage(img.size(), QImage.Format_RGB32)
        nimg.fill(Qt.white)
        p = QPainter(nimg)
        p.drawImage(0, 0, img)
        p.end()
        img = nimg
    ba = QByteArray()
    buf = QBuffer(ba)
    buf.open(QBuffer.WriteOnly)
    fmt = 'PNG' if as_png else 'JPEG'
    if not img.save(buf, fmt, quality=compression_quality):
        raise ValueError('Failed to export thumbnail image to: ' + fmt)
    return img.width(), img.height(), ba.data()
Example #16
0
 def __call__(self, painter, rect, color_theme, title_block, subtitle_block, footer_block):
     top = title_block.position.y + 10
     extra_spacing = subtitle_block.line_spacing // 2 if subtitle_block.line_spacing else title_block.line_spacing // 3
     height = title_block.height + subtitle_block.height + extra_spacing + title_block.leading
     top += height + 25
     bottom = footer_block.position.y - 50
     logo = QImage(logo_path or I('library.png'))
     pwidth, pheight = rect.width(), bottom - top
     scaled, width, height = fit_image(logo.width(), logo.height(), pwidth, pheight)
     x, y = (pwidth - width) // 2, (pheight - height) // 2
     rect = QRect(x, top + y, width, height)
     painter.setRenderHint(QPainter.SmoothPixmapTransform)
     painter.drawImage(rect, logo)
     return self.ccolor1, self.ccolor1, self.ccolor1
Example #17
0
 def __call__(self, painter, rect, color_theme, title_block, subtitle_block, footer_block):
     top = title_block.position.y + 10
     extra_spacing = subtitle_block.line_spacing // 2 if subtitle_block.line_spacing else title_block.line_spacing // 3
     height = title_block.height + subtitle_block.height + extra_spacing + title_block.leading
     top += height + 25
     bottom = footer_block.position.y - 50
     logo = QImage(logo_path or I('library.png'))
     pwidth, pheight = rect.width(), bottom - top
     scaled, width, height = fit_image(logo.width(), logo.height(), pwidth, pheight)
     x, y = (pwidth - width) // 2, (pheight - height) // 2
     rect = QRect(x, top + y, width, height)
     painter.setRenderHint(QPainter.SmoothPixmapTransform)
     painter.drawImage(rect, logo)
     return self.ccolor1, self.ccolor1, self.ccolor1
Example #18
0
def qimage_to_magick(img):
    ans = Image()
    fmt = get_pixel_map()
    if not img.hasAlphaChannel():
        if img.format() != img.Format_RGB32:
            img = QImage(img)
            img.setFormat(QImage.Format_RGB32)
        fmt = fmt.replace('A', 'P')
    else:
        if img.format() != img.Format_ARGB32:
            img = QImage(img)
            img.setFormat(img.Format_ARGB32)
    raw = img.constBits().ascapsule()
    ans.constitute(img.width(), img.height(), fmt, raw)
    return ans
Example #19
0
def qimage_to_magick(img):
    ans = Image()
    fmt = get_pixel_map()
    if not img.hasAlphaChannel():
        if img.format() != img.Format_RGB32:
            img = QImage(img)
            img.setFormat(QImage.Format_RGB32)
        fmt = fmt.replace('A', 'P')
    else:
        if img.format() != img.Format_ARGB32:
            img = QImage(img)
            img.setFormat(img.Format_ARGB32)
    raw = img.constBits().ascapsule()
    ans.constitute(img.width(), img.height(), fmt, raw)
    return ans
Example #20
0
def calibre_cover2(title, author_string='', series_string='', prefs=None, as_qimage=False, logo_path=None):
    init_environment()
    title, subtitle, footer = '<b>' + escape_formatting(title), '<i>' + escape_formatting(series_string), '<b>' + escape_formatting(author_string)
    prefs = prefs or cprefs
    prefs = {k:prefs.get(k) for k in cprefs.defaults}
    scale = 800. / prefs['cover_height']
    scale_cover(prefs, scale)
    prefs = Prefs(**prefs)
    img = QImage(prefs.cover_width, prefs.cover_height, QImage.Format_ARGB32)
    img.fill(Qt.white)
    # colors = to_theme('ffffff ffffff 000000 000000')
    color_theme = theme_to_colors(fallback_colors)

    class CalibeLogoStyle(Style):
        NAME = GUI_NAME = 'calibre'

        def __call__(self, painter, rect, color_theme, title_block, subtitle_block, footer_block):
            top = title_block.position.y + 10
            extra_spacing = subtitle_block.line_spacing // 2 if subtitle_block.line_spacing else title_block.line_spacing // 3
            height = title_block.height + subtitle_block.height + extra_spacing + title_block.leading
            top += height + 25
            bottom = footer_block.position.y - 50
            logo = QImage(logo_path or I('library.png'))
            pwidth, pheight = rect.width(), bottom - top
            scaled, width, height = fit_image(logo.width(), logo.height(), pwidth, pheight)
            x, y = (pwidth - width) // 2, (pheight - height) // 2
            rect = QRect(x, top + y, width, height)
            painter.setRenderHint(QPainter.SmoothPixmapTransform)
            painter.drawImage(rect, logo)
            return self.ccolor1, self.ccolor1, self.ccolor1
    style = CalibeLogoStyle(color_theme, prefs)
    title_block, subtitle_block, footer_block = layout_text(
        prefs, img, title, subtitle, footer, img.height() // 3, style)
    p = QPainter(img)
    rect = QRect(0, 0, img.width(), img.height())
    colors = style(p, rect, color_theme, title_block, subtitle_block, footer_block)
    for block, color in zip((title_block, subtitle_block, footer_block), colors):
        p.setPen(color)
        block.draw(p)
    p.end()
    img.setText('Generated cover', '%s %s' % (__appname__, __version__))
    if as_qimage:
        return img
    return pixmap_to_data(img)
Example #21
0
def generate_cover(mi, prefs=None, as_qimage=False):
    init_environment()
    prefs = prefs or cprefs
    prefs = {k:prefs.get(k) for k in cprefs.defaults}
    prefs = Prefs(**prefs)
    color_theme = random.choice(load_color_themes(prefs))
    style = random.choice(load_styles(prefs))(color_theme, prefs)
    title, subtitle, footer = format_text(mi, prefs)
    img = QImage(prefs.cover_width, prefs.cover_height, QImage.Format_ARGB32)
    title_block, subtitle_block, footer_block = layout_text(
        prefs, img, title, subtitle, footer, img.height() // 3, style)
    p = QPainter(img)
    rect = QRect(0, 0, img.width(), img.height())
    colors = style(p, rect, color_theme, title_block, subtitle_block, footer_block)
    for block, color in zip((title_block, subtitle_block, footer_block), colors):
        p.setPen(color)
        block.draw(p)
    p.end()
    img.setText('Generated cover', '%s %s' % (__appname__, __version__))
    if as_qimage:
        return img
    return pixmap_to_data(img)
Example #22
0
    def update (self,warrior):
        self.warrior = warrior
        groupe_name = warrior.groupe().name
        if warrior.masterGroupe() != None : 
            groupe_name = warrior.masterGroupe().name+"/"+groupe_name
         
        kingdom_name = warrior.kingdom().name
        empire_name = warrior.empire().name
        faction_name = warrior.faction().name
        path = os.path.join(Config().instance.path_to_pic(),faction_name,empire_name,kingdom_name,'Picture',groupe_name,warrior.name)
        picture = QPixmap(path+"/portrait.jpg").scaledToWidth(self.picture.width())
   
        self.warrior_name.setText(warrior.name.replace("_"," "))
        self.warrior_name.setObjectName("Warrior_name")
        couleur = warrior.groupe().attribs['color']
        if warrior.masterGroupe() != None : 
            couleur = warrior.masterGroupe().attribs['color']

        self.picture.setPixmap(picture)


        self.progressBar_life.setStyleSheet("  QProgressBar{ background-color: red;}")
        #self.ui.progressBar_life.setAlignment(QtCore.Qt.AlignCenter)
        #self.progressBar_energy.setStyleSheet("  QProgressBar::chunk {     background-color: #05B8CC;width: 20px;}")
        #self.ui.progressBar_MP.setAlignment(QtCore.Qt.AlignCenter)
        try:
            hp_percent = float(self.warrior.attribs['HP'] / self.warrior.attribs['HP_max'])* 100
            mp_percent = float(self.warrior.attribs['MP'] / self.warrior.attribs['MP_max'])* 100
        except (ZeroDivisionError,KeyError) as e :
            hp_percent =0
            mp_percent =0
        self.progressBar_life.setValue(int(hp_percent))
        self.progressBar_energy.setValue(int(mp_percent))
        self.profil_completion.setPixmap(QPixmap(":/icons/128x128/state_"+str(warrior.attribs['complete']+1)).scaledToHeight(32))
        self.profil_completion.setStyleSheet("#"+self.profil_completion.objectName()+"{background-color:transparent;}")

        pal = QPalette(self.rank_text.palette())
        image = QImage(os.path.join(Config().instance.path_to_icons(),"rank")+"/star_"+warrior.groupe().attribs["color"]+".png")
        value = image.pixel(image.width()/2.0,image.height()/2.0)
        pal.setColor(QPalette.WindowText, QColor(value))
        self.rank_text.setPalette(pal)
        self.rank_text.setText(str(warrior.attribs["rank"]))
        #Boutton Faction 
        path = os.path.join(Config().instance.path_to_icons(),"faction","32x32",faction_name)
        self.iconFaction.setIcon(QIcon(path))
        self.iconFaction.setToolTip(warrior.faction().name)
        #Boutton Empire 
        path = os.path.join(Config().instance.path_to_icons(),"empire","32x32",empire_name)
        self.iconEmpire.setIcon(QIcon(path))
        self.iconEmpire.setToolTip(warrior.empire().name)
        self.iconEmpire.clicked.connect(self.onEmpireClicked)
        #Boutton Kingdom
        path = os.path.join(Config().instance.path_to_icons(),"kingdom","32x32",kingdom_name)
        self.iconKingdom.setIcon(QIcon(path))
        self.iconKingdom.setToolTip(self.warrior.kingdom().name)
        self.iconKingdom.clicked.connect(self.onKingdomClicked)
        #Boutton Groupe
        self.iconGroupe.setText(groupe_name.replace("_"," "))
        groupe_color = self.warrior.groupe().attribs['color']
        if self.warrior.masterGroupe() != None : 
            groupe_color = self.warrior.masterGroupe().attribs['color']
        self.iconGroupe.setStyleSheet("#"+self.iconGroupe.objectName()+"{background-image:url(:/textures/"+groupe_color+");}")
        self.iconGroupe.clicked.connect(self.onGroupClicked)
        path = os.path.join(Config().instance.path_to_icons(),"actions",warrior.attribs['status'])
        # Icone d etat
        self.iconState.setPixmap(QPixmap(path).scaledToHeight(64))
Example #23
0
class ToolButton(QToolButton):
    _MultiIconOption = 1
    _ShowMenuInsideOption = 2
    _ToolBarLookOption = 4
    _ShowMenuOnRightClick = 8
    def __init__(self, parent=None):
        super(ToolButton, self).__init__(parent)
        self._multiIcon = QImage()
        self._themeIcon = ''
        self._pressTimer = QTimer()
        self._menu = None  # QMenu
        self._options = 0

        self.setMinimumWidth(16)
        opt = QStyleOptionToolButton()
        self.initStyleOption(opt)

        self._pressTimer.setSingleShot(True)
        self._pressTimer.setInterval(QApplication.style().styleHint(
            QStyle.SH_ToolButton_PopupDelay, opt, self
        ))
        self._pressTimer.timeout.connect(self._showMenu)

    def size(self):
        return super().size()

    def setFixedSize(self, size):
        return super().setFixedSize(size)

    fixedsize = pyqtProperty(QSize, size, setFixedSize)

    def width(self):
        return super().width()

    def setFixedWidth(self, width):
        return super().setFixedWidth(width)

    fixedwidth = pyqtProperty(int, width, setFixedWidth)

    def height(self):
        return super().height()

    def setFixedHeight(self, height):
        return super().setFixedHeight(height)

    fixedheight = pyqtProperty(int, height, setFixedHeight)

    def multiIcon(self):
        '''
        @brief: MultiIcon - Image containing pixmaps for all button states
        @return: QImage
        '''
        return self._multiIcon

    def setMultiIcon(self, image):
        '''
        @param: image QImage
        '''
        self._options |= self._MultiIconOption
        self._multiIcon = image
        self.setFixedSize(self._multiIcon.width(), self._multiIcon.height())

        self.update()

    multiIcon = pyqtProperty(QImage, multiIcon, setMultiIcon)

    def icon(self):
        '''
        @brief: Icon - Standard QToolButton with icon
        @return: QIcon
        '''
        return super().icon()

    def setIcon(self, icon):
        '''
        @param: QIcon
        '''
        if self._options & self._MultiIconOption:
            self.setFixedSize(self.sizeHint())

        self._options &= ~self._MultiIconOption
        if not isinstance(icon, QIcon):
            icon = QIcon(icon)
        super().setIcon(icon)

    icon = pyqtProperty(QIcon, icon, setIcon)

    def themeIcon(self):
        '''
        @brief: ThemeIcon - Standard QToolButton with theme icon
        @return: QString
        '''
        return self._themeIcon

    def setThemeIcon(self, icon):
        '''
        @param: icon QString
        '''
        # QIcon ic
        ic = QIcon.fromTheme(icon)
        if not ic.isNull():
            self._themeIcon = icon
            self.setIcon(QIcon.fromTheme(self._themeIcon))

    themeIcon = pyqtProperty(str, themeIcon, setThemeIcon)

    def fallbackIcon(self):
        '''
        @brief: FallbackIcon - In case theme doesn't contain ThemeIcon
        @return: QIcon
        '''
        return self.icon

    def setFallbackIcon(self, fallbackIcon):
        '''
        @param: fallbackIcon QIcon
        '''
        if self.icon.isNull():
            self.setIcon(fallbackIcon)

    fallbackIcon = pyqtProperty(QIcon, fallbackIcon, setFallbackIcon)

    def menu(self):
        '''
        @note: Menu - Menu is handled in ToolButton and is not passed to QToolButton
            There won't be menu indicator shown in the button
            QToolButton::MenuButtonPopup is not supported
        @return: QMenu
        '''
        return self._menu

    def setMenu(self, menu):
        '''
        @param: menu QMenu
        '''
        assert(menu)

        if self._menu:
            self._menu.aboutToHide.disconnect(self._menuAboutToHide)

        self._menu = menu
        self._menu.aboutToHide.connect(self._menuAboutToHide)

    def showMenuInside(self):
        '''
        @brief: Align the right corner of menu to the right corner of button
        '''
        return self._options & self._ShowMenuInsideOption

    def setShowMenuInside(self, enable):
        if enable:
            self._options |= self._ShowMenuInsideOption
        else:
            self._options &= ~self._ShowMenuInsideOption

    def showMenuOnRightClick(self):
        '''
        @brief: Show button menu on right click
        '''
        return self._options & self._ShowMenuOnRightClick

    def setShowMenuOnRightClick(self, enable):
        if enable:
            self._options |= self._ShowMenuOnRightClick
        else:
            self._options &= ~self._ShowMenuOnRightClick

    def toolbarButtonLook(self):
        '''
        @brief: Set the button to look as it was in toolbar
            (it now only sets the correct icon size)
        @return: bool
        '''
        return self._options & self._ToolBarLookOption

    def setToolbarButtonLook(self, enable):
        if enable:
            self._options |= self._ToolBarLookOption

            opt = QStyleOption()
            opt.initFrom(self)
            size = self.style().pixelMetric(QStyle.PM_ToolBarIconSize, opt, self)
            self.setIconSize(QSize(size, size))
        else:
            self._options &= ~self._ToolBarLookOption

        self.setProperty('toolbar-look', enable)
        self.style().unpolish(self)
        self.style().polish(self)

    # Q_SIGNALS
    middleMouseClicked = pyqtSignal()
    controlClicked = pyqtSignal()
    doubleClicked = pyqtSignal()

    # It is needed to use these signals with ShowMenuInside
    aboutToShowMenu = pyqtSignal()
    aboutToHideMenu = pyqtSignal()

    # private Q_SLOTS
    def _menuAboutToHide(self):
        self.setDown(False)
        self.aboutToHideMenu.emit()

    def _showMenu(self):
        if not self._menu or self._menu.isVisible():
            return

        self.aboutToShowMenu.emit()

        pos = QPoint()

        if self._options & self._ShowMenuInsideOption:
            pos = self.mapToGlobal(self.rect().bottomRight())
            if QApplication.layoutDirection() == Qt.RightToLeft:
                pos.setX(pos.x() - self.rect().width())
            else:
                pos.setX(pos.x() - self._menu.sizeHint().width())
        else:
            pos = self.mapToGlobal(self.rect().bottomLeft())

        self._menu.popup(pos)

    # protected:
    # override
    def mousePressEvent(self, event):
        '''
        @param: event QMouseEvent
        '''
        buttons = event.buttons()
        if buttons == Qt.LeftButton and self.popupMode() == QToolButton.DelayedPopup:
            self._pressTimer.start()

        if buttons == Qt.LeftButton and self.menu() and self.popupMode() == QToolButton.InstantPopup:
            self.setDown(True)
            self._showMenu()
        elif buttons == Qt.RightButton and self.menu() and self._options & self.showMenuOnRightClick:
            self.setDown(True)
            self._showMenu()
        else:
            super().mousePressEvent(event)

    # override
    def mouseReleaseEvent(self, event):
        '''
        @param: event QMouseEvent
        '''
        self._pressTimer.stop()

        button = event.button()
        if button == Qt.MiddleButton and self.rect().contains(event.pos()):
            self.middleMouseClicked.emit()
            self.setDown(False)
        elif button == Qt.LeftButton and self.rect().contains(event.pos()) and \
                event.modifiers() == Qt.ControlModifier:
            self.controlClicked.emit()
            self.setDown(False)
        else:
            super().mouseReleaseEvent(event)

    # override
    def mouseDoubleClickEvent(self, event):
        '''
        @param: event QMouseEvent
        '''
        super().mouseDoubleClickEvent(event)

        self._pressTimer.stop()

        if event.buttons() == Qt.LeftButton:
            self.doubleClicked.emit()

    # override
    def contextMenuEvent(self, event):
        '''
        @param: event QContextMenuEvent
        '''
        # Block to prevent showing both context menu and button menu
        if self.menu() and self._options & self._ShowMenuOnRightClick:
            return

        super().contextMenuEvent(event)

    # override
    def paintEvent(self, event):
        '''
        @param: event QPaintEvent
        '''
        if not (self._options & self._MultiIconOption):
            super().paintEvent(event)
            return

        p = QPainter(self)

        w = self._multiIcon.width()
        h4 = self._multiIcon.height() / 4

        if not self.isEnabled():
            p.drawImage(0, 0, self._multiIcon, 0, h4 * 3, w, h4)
        elif self.isDown():
            p.drawImage(0, 0, self._multiIcon, 0, h4 * 2, w, h4)
        elif self.underMouse():
            p.drawImage(0, 0, self._multiIcon, 0, h4 * 1, w, h4)
        else:
            p.drawImage(0, 0, self._multiIcon, 0, h4 * 0, w, h4)
Example #24
0
    def _populate_covers(self):
        '''
        Display calibre cover for both unless mismatch
        '''
        def _fetch_marvin_cover(border_width=0):
            '''
            Retrieve LargeCoverJpg from cache
            '''
            #self._log_location('border_width: {0}'.format(border_width))
            con = sqlite3.connect(self.marvin_db_path)
            with con:
                con.row_factory = sqlite3.Row

                # Fetch Hash from mainDb
                cover_cur = con.cursor()
                cover_cur.execute('''SELECT
                                      Hash
                                     FROM Books
                                     WHERE ID = '{0}'
                                  '''.format(self.book_id))
                row = cover_cur.fetchone()

            book_hash = row[b'Hash']
            large_covers_subpath = self.connected_device._cover_subpath(
                size="large")
            cover_path = '/'.join([large_covers_subpath, '%s.jpg' % book_hash])
            stats = self.parent.ios.exists(cover_path)
            if stats:
                self._log("fetching large cover from cache")
                #self._log("cover size: {:,} bytes".format(int(stats['st_size'])))
                cover_bytes = self.parent.ios.read(cover_path, mode='rb')
                m_image = QImage()
                m_image.loadFromData(cover_bytes)

                if border_width:
                    # Construct a QPixmap with oversized yellow background
                    m_image = m_image.scaledToHeight(
                        self.COVER_ICON_SIZE - border_width * 2,
                        Qt.SmoothTransformation)

                    self.m_pixmap = QPixmap(
                        QSize(m_image.width() + border_width * 2,
                              m_image.height() + border_width * 2))

                    m_painter = QPainter(self.m_pixmap)
                    m_painter.setRenderHints(m_painter.Antialiasing)

                    m_painter.fillRect(self.m_pixmap.rect(),
                                       self.MISMATCH_COLOR)
                    m_painter.drawImage(border_width, border_width, m_image)
                else:
                    m_image = m_image.scaledToHeight(self.COVER_ICON_SIZE,
                                                     Qt.SmoothTransformation)

                    self.m_pixmap = QPixmap(
                        QSize(m_image.width(), m_image.height()))

                    m_painter = QPainter(self.m_pixmap)
                    m_painter.setRenderHints(m_painter.Antialiasing)

                    m_painter.drawImage(0, 0, m_image)

                self.marvin_cover.setPixmap(self.m_pixmap)
            else:
                # No cover available, use generic
                self._log("No cached cover, using generic")
                pixmap = QPixmap()
                pixmap.load(I('book.png'))
                pixmap = pixmap.scaled(self.COVER_ICON_SIZE,
                                       self.COVER_ICON_SIZE,
                                       aspectRatioMode=Qt.KeepAspectRatio,
                                       transformMode=Qt.SmoothTransformation)
                self.marvin_cover.setPixmap(pixmap)

        self.calibre_cover.setMaximumSize(
            QSize(self.COVER_ICON_SIZE, self.COVER_ICON_SIZE))
        self.calibre_cover.setText('')
        self.calibre_cover.setScaledContents(False)

        self.marvin_cover.setMaximumSize(
            QSize(self.COVER_ICON_SIZE, self.COVER_ICON_SIZE))
        self.marvin_cover.setText('')
        self.marvin_cover.setScaledContents(False)

        if self.cid:
            db = self.opts.gui.current_db
            if 'cover_hash' not in self.mismatches:
                mi = db.get_metadata(self.cid,
                                     index_is_id=True,
                                     get_cover=True,
                                     cover_as_data=True)

                c_image = QImage()
                if mi.has_cover:
                    c_image.loadFromData(mi.cover_data[1])
                    c_image = c_image.scaledToHeight(self.COVER_ICON_SIZE,
                                                     Qt.SmoothTransformation)
                    self.c_pixmap = QPixmap(
                        QSize(c_image.width(), c_image.height()))
                    c_painter = QPainter(self.c_pixmap)
                    c_painter.setRenderHints(c_painter.Antialiasing)
                    c_painter.drawImage(0, 0, c_image)
                else:
                    c_image.load(I('book.png'))
                    c_image = c_image.scaledToWidth(135,
                                                    Qt.SmoothTransformation)
                    # Construct a QPixmap with dialog background
                    self.c_pixmap = QPixmap(
                        QSize(c_image.width(), c_image.height()))
                    c_painter = QPainter(self.c_pixmap)
                    c_painter.setRenderHints(c_painter.Antialiasing)
                    bgcolor = self.palette().color(QPalette.Background)
                    c_painter.fillRect(self.c_pixmap.rect(), bgcolor)
                    c_painter.drawImage(0, 0, c_image)

                # Set calibre cover
                self.calibre_cover.setPixmap(self.c_pixmap)

                if self.opts.prefs.get('development_mode', False):
                    # Show individual covers
                    _fetch_marvin_cover()
                else:
                    # Show calibre cover on both sides
                    self.marvin_cover.setPixmap(self.c_pixmap)

            else:
                # Covers don't match - render with border
                # Construct a QImage with the cover sized to fit inside border
                c_image = QImage()
                cdata = db.cover(self.cid, index_is_id=True)
                if cdata is None:
                    c_image.load(I('book.png'))
                    self.calibre_cover.setScaledContents(True)
                else:
                    c_image.loadFromData(cdata)

                c_image = c_image.scaledToHeight(
                    self.COVER_ICON_SIZE - self.BORDER_WIDTH * 2,
                    Qt.SmoothTransformation)

                # Construct a QPixmap with yellow background
                self.c_pixmap = QPixmap(
                    QSize(c_image.width() + self.BORDER_WIDTH * 2,
                          c_image.height() + self.BORDER_WIDTH * 2))
                c_painter = QPainter(self.c_pixmap)
                c_painter.setRenderHints(c_painter.Antialiasing)
                c_painter.fillRect(self.c_pixmap.rect(), self.MISMATCH_COLOR)
                c_painter.drawImage(self.BORDER_WIDTH, self.BORDER_WIDTH,
                                    c_image)
                self.calibre_cover.setPixmap(self.c_pixmap)

                # Render Marvin cover with small border if different covers,
                # large cover if no cover hash (loaded via OPDS)
                border_width = self.BORDER_WIDTH
                if self.mismatches['cover_hash']['Marvin'] is None:
                    border_width = self.BORDER_WIDTH * 3
                _fetch_marvin_cover(border_width=border_width)
        else:
            _fetch_marvin_cover()
Example #25
0
        def _fetch_marvin_cover(border_width=0):
            '''
            Retrieve LargeCoverJpg from cache
            '''
            #self._log_location('border_width: {0}'.format(border_width))
            con = sqlite3.connect(self.marvin_db_path)
            with con:
                con.row_factory = sqlite3.Row

                # Fetch Hash from mainDb
                cover_cur = con.cursor()
                cover_cur.execute('''SELECT
                                      Hash
                                     FROM Books
                                     WHERE ID = '{0}'
                                  '''.format(self.book_id))
                row = cover_cur.fetchone()

            book_hash = row[b'Hash']
            large_covers_subpath = self.connected_device._cover_subpath(
                size="large")
            cover_path = '/'.join([large_covers_subpath, '%s.jpg' % book_hash])
            stats = self.parent.ios.exists(cover_path)
            if stats:
                self._log("fetching large cover from cache")
                #self._log("cover size: {:,} bytes".format(int(stats['st_size'])))
                cover_bytes = self.parent.ios.read(cover_path, mode='rb')
                m_image = QImage()
                m_image.loadFromData(cover_bytes)

                if border_width:
                    # Construct a QPixmap with oversized yellow background
                    m_image = m_image.scaledToHeight(
                        self.COVER_ICON_SIZE - border_width * 2,
                        Qt.SmoothTransformation)

                    self.m_pixmap = QPixmap(
                        QSize(m_image.width() + border_width * 2,
                              m_image.height() + border_width * 2))

                    m_painter = QPainter(self.m_pixmap)
                    m_painter.setRenderHints(m_painter.Antialiasing)

                    m_painter.fillRect(self.m_pixmap.rect(),
                                       self.MISMATCH_COLOR)
                    m_painter.drawImage(border_width, border_width, m_image)
                else:
                    m_image = m_image.scaledToHeight(self.COVER_ICON_SIZE,
                                                     Qt.SmoothTransformation)

                    self.m_pixmap = QPixmap(
                        QSize(m_image.width(), m_image.height()))

                    m_painter = QPainter(self.m_pixmap)
                    m_painter.setRenderHints(m_painter.Antialiasing)

                    m_painter.drawImage(0, 0, m_image)

                self.marvin_cover.setPixmap(self.m_pixmap)
            else:
                # No cover available, use generic
                self._log("No cached cover, using generic")
                pixmap = QPixmap()
                pixmap.load(I('book.png'))
                pixmap = pixmap.scaled(self.COVER_ICON_SIZE,
                                       self.COVER_ICON_SIZE,
                                       aspectRatioMode=Qt.KeepAspectRatio,
                                       transformMode=Qt.SmoothTransformation)
                self.marvin_cover.setPixmap(pixmap)
        def _fetch_marvin_cover(border_width=0):
            '''
            Retrieve LargeCoverJpg from cache
            '''
            #self._log_location('border_width: {0}'.format(border_width))
            con = sqlite3.connect(self.marvin_db_path)
            with con:
                con.row_factory = sqlite3.Row

                # Fetch Hash from mainDb
                cover_cur = con.cursor()
                cover_cur.execute('''SELECT
                                      Hash
                                     FROM Books
                                     WHERE ID = '{0}'
                                  '''.format(self.book_id))
                row = cover_cur.fetchone()

            book_hash = row[b'Hash']
            large_covers_subpath = self.connected_device._cover_subpath(size="large")
            cover_path = '/'.join([large_covers_subpath, '%s.jpg' % book_hash])
            stats = self.parent.ios.exists(cover_path)
            if stats:
                self._log("fetching large cover from cache")
                #self._log("cover size: {:,} bytes".format(int(stats['st_size'])))
                cover_bytes = self.parent.ios.read(cover_path, mode='rb')
                m_image = QImage()
                m_image.loadFromData(cover_bytes)

                if border_width:
                    # Construct a QPixmap with oversized yellow background
                    m_image = m_image.scaledToHeight(
                        self.COVER_ICON_SIZE - border_width * 2,
                        Qt.SmoothTransformation)

                    self.m_pixmap = QPixmap(
                        QSize(m_image.width() + border_width * 2,
                              m_image.height() + border_width * 2))

                    m_painter = QPainter(self.m_pixmap)
                    m_painter.setRenderHints(m_painter.Antialiasing)

                    m_painter.fillRect(self.m_pixmap.rect(), self.MISMATCH_COLOR)
                    m_painter.drawImage(border_width,
                                        border_width,
                                        m_image)
                else:
                    m_image = m_image.scaledToHeight(
                        self.COVER_ICON_SIZE,
                        Qt.SmoothTransformation)

                    self.m_pixmap = QPixmap(
                        QSize(m_image.width(),
                              m_image.height()))

                    m_painter = QPainter(self.m_pixmap)
                    m_painter.setRenderHints(m_painter.Antialiasing)

                    m_painter.drawImage(0, 0, m_image)

                self.marvin_cover.setPixmap(self.m_pixmap)
            else:
                # No cover available, use generic
                self._log("No cached cover, using generic")
                pixmap = QPixmap()
                pixmap.load(I('book.png'))
                pixmap = pixmap.scaled(self.COVER_ICON_SIZE,
                                       self.COVER_ICON_SIZE,
                                       aspectRatioMode=Qt.KeepAspectRatio,
                                       transformMode=Qt.SmoothTransformation)
                self.marvin_cover.setPixmap(pixmap)
    def _populate_covers(self):
        '''
        Display calibre cover for both unless mismatch
        '''
        def _fetch_marvin_cover(border_width=0):
            '''
            Retrieve LargeCoverJpg from cache
            '''
            #self._log_location('border_width: {0}'.format(border_width))
            con = sqlite3.connect(self.marvin_db_path)
            with con:
                con.row_factory = sqlite3.Row

                # Fetch Hash from mainDb
                cover_cur = con.cursor()
                cover_cur.execute('''SELECT
                                      Hash
                                     FROM Books
                                     WHERE ID = '{0}'
                                  '''.format(self.book_id))
                row = cover_cur.fetchone()

            book_hash = row[b'Hash']
            large_covers_subpath = self.connected_device._cover_subpath(size="large")
            cover_path = '/'.join([large_covers_subpath, '%s.jpg' % book_hash])
            stats = self.parent.ios.exists(cover_path)
            if stats:
                self._log("fetching large cover from cache")
                #self._log("cover size: {:,} bytes".format(int(stats['st_size'])))
                cover_bytes = self.parent.ios.read(cover_path, mode='rb')
                m_image = QImage()
                m_image.loadFromData(cover_bytes)

                if border_width:
                    # Construct a QPixmap with oversized yellow background
                    m_image = m_image.scaledToHeight(
                        self.COVER_ICON_SIZE - border_width * 2,
                        Qt.SmoothTransformation)

                    self.m_pixmap = QPixmap(
                        QSize(m_image.width() + border_width * 2,
                              m_image.height() + border_width * 2))

                    m_painter = QPainter(self.m_pixmap)
                    m_painter.setRenderHints(m_painter.Antialiasing)

                    m_painter.fillRect(self.m_pixmap.rect(), self.MISMATCH_COLOR)
                    m_painter.drawImage(border_width,
                                        border_width,
                                        m_image)
                else:
                    m_image = m_image.scaledToHeight(
                        self.COVER_ICON_SIZE,
                        Qt.SmoothTransformation)

                    self.m_pixmap = QPixmap(
                        QSize(m_image.width(),
                              m_image.height()))

                    m_painter = QPainter(self.m_pixmap)
                    m_painter.setRenderHints(m_painter.Antialiasing)

                    m_painter.drawImage(0, 0, m_image)

                self.marvin_cover.setPixmap(self.m_pixmap)
            else:
                # No cover available, use generic
                self._log("No cached cover, using generic")
                pixmap = QPixmap()
                pixmap.load(I('book.png'))
                pixmap = pixmap.scaled(self.COVER_ICON_SIZE,
                                       self.COVER_ICON_SIZE,
                                       aspectRatioMode=Qt.KeepAspectRatio,
                                       transformMode=Qt.SmoothTransformation)
                self.marvin_cover.setPixmap(pixmap)

        self.calibre_cover.setMaximumSize(QSize(self.COVER_ICON_SIZE, self.COVER_ICON_SIZE))
        self.calibre_cover.setText('')
        self.calibre_cover.setScaledContents(False)

        self.marvin_cover.setMaximumSize(QSize(self.COVER_ICON_SIZE, self.COVER_ICON_SIZE))
        self.marvin_cover.setText('')
        self.marvin_cover.setScaledContents(False)

        if self.cid:
            db = self.opts.gui.current_db
            if 'cover_hash' not in self.mismatches:
                mi = db.get_metadata(self.cid, index_is_id=True, get_cover=True, cover_as_data=True)

                c_image = QImage()
                if mi.has_cover:
                    c_image.loadFromData(mi.cover_data[1])
                    c_image = c_image.scaledToHeight(self.COVER_ICON_SIZE,
                                                     Qt.SmoothTransformation)
                    self.c_pixmap = QPixmap(QSize(c_image.width(),
                                                  c_image.height()))
                    c_painter = QPainter(self.c_pixmap)
                    c_painter.setRenderHints(c_painter.Antialiasing)
                    c_painter.drawImage(0, 0, c_image)
                else:
                    c_image.load(I('book.png'))
                    c_image = c_image.scaledToWidth(135,
                                                    Qt.SmoothTransformation)
                    # Construct a QPixmap with dialog background
                    self.c_pixmap = QPixmap(
                        QSize(c_image.width(),
                              c_image.height()))
                    c_painter = QPainter(self.c_pixmap)
                    c_painter.setRenderHints(c_painter.Antialiasing)
                    bgcolor = self.palette().color(QPalette.Background)
                    c_painter.fillRect(self.c_pixmap.rect(), bgcolor)
                    c_painter.drawImage(0, 0, c_image)

                # Set calibre cover
                self.calibre_cover.setPixmap(self.c_pixmap)

                if self.opts.prefs.get('development_mode', False):
                    # Show individual covers
                    _fetch_marvin_cover()
                else:
                    # Show calibre cover on both sides
                    self.marvin_cover.setPixmap(self.c_pixmap)

            else:
                # Covers don't match - render with border
                # Construct a QImage with the cover sized to fit inside border
                c_image = QImage()
                cdata = db.cover(self.cid, index_is_id=True)
                if cdata is None:
                    c_image.load(I('book.png'))
                    self.calibre_cover.setScaledContents(True)
                else:
                    c_image.loadFromData(cdata)

                c_image = c_image.scaledToHeight(
                    self.COVER_ICON_SIZE - self.BORDER_WIDTH * 2,
                    Qt.SmoothTransformation)

                # Construct a QPixmap with yellow background
                self.c_pixmap = QPixmap(
                    QSize(c_image.width() + self.BORDER_WIDTH * 2,
                          c_image.height() + self.BORDER_WIDTH * 2))
                c_painter = QPainter(self.c_pixmap)
                c_painter.setRenderHints(c_painter.Antialiasing)
                c_painter.fillRect(self.c_pixmap.rect(),self.MISMATCH_COLOR)
                c_painter.drawImage(self.BORDER_WIDTH, self.BORDER_WIDTH, c_image)
                self.calibre_cover.setPixmap(self.c_pixmap)

                # Render Marvin cover with small border if different covers,
                # large cover if no cover hash (loaded via OPDS)
                border_width = self.BORDER_WIDTH
                if self.mismatches['cover_hash']['Marvin'] is None:
                    border_width = self.BORDER_WIDTH * 3
                _fetch_marvin_cover(border_width=border_width)
        else:
            _fetch_marvin_cover()
Example #28
0
class Window:
    def __init__(self):
        # ------------------------
        # Set flags
        # ------------------------
        self.UP = True
        self.DOWN = False

        self.ALL_IMG_FORMAT = "All Supported (*.jpg *.jpeg *.jpe *.png *.bmp *.tif *.tiff " \
                              "*.dib *.pbm *.pgm *.ppm *.sr *.ras)"
        self.JPG_FORMAT = "JPG (*.jpg *.jpeg *.jpe)"
        self.PNG_FORMAT = "PNG (*.png)"
        self.BMP_FORMAT = "BMP (*.bmp)"
        self.TIF_FORMAT = "TIFF (*.tif *.tiff)"
        self.DIB_FORMAT = "DIB (*.dib)"
        self.PBM_FORMAT = "PBM (*.pbm)"
        self.PGM_FORMAT = "PGM (*.pgm)"
        self.PPM_FORMAT = "PPM (*.ppm)"
        self.SR__FORMAT = "SR (*.sr)"
        self.RAS_FORMAT = "RAS (*.ras)"
        self.DD = ";;"

        self.IMG_FILTER = self.ALL_IMG_FORMAT + self.DD + self.JPG_FORMAT + self.DD + self.PNG_FORMAT + self.DD + \
                          self.BMP_FORMAT + self.DD + self.TIF_FORMAT + self.DD + self.DIB_FORMAT + self.DD + \
                          self.PBM_FORMAT + self.DD + self.PGM_FORMAT + self.DD + self.PPM_FORMAT + self.DD + \
                          self.SR__FORMAT + self.DD + self.RAS_FORMAT

        self.DIALOG_FLAG = QFileDialog.DontUseNativeDialog
        self.Q_ASPECT_RATIO = Qt.KeepAspectRatio
        # ------------------------
        # Flags Section ends here
        # ---------------------------------------------------------------------------------------------------------- #
        # ------------------------
        # Set class items
        # ------------------------
        self.q_img = QImage()
        self.img_view_timer = QTimer()

        self.img = Image()
        self.img_proc = ImageProcessing()
        self.is_img_Open = False
        self.is_img_Save = False

        # ------------------------
        # Class items ends here
        # ---------------------------------------------------------------------------------------------------------- #
        # ------------------------
        # Set up the ui
        # ------------------------
        self.app = QtWidgets.QApplication(sys.argv)
        self.ui = Ui_MainWindow()
        self.MainWindow = QtWidgets.QMainWindow()
        self.ui.setupUi(self.MainWindow)

        self.DialogColor = QtWidgets.QDialog()
        self.ui_color = Ui_DialogColoring()
        self.ui_color.setupUi(self.DialogColor)
        # ------------------------
        # Setting up ends here
        # ---------------------------------------------------------------------------------------------------------- #
        # ------------------------
        # Actions list starts here
        # ------------------------
        self.ui.actionOpen.triggered.connect(self.open)
        self.ui.actionSave.triggered.connect(self.save)
        self.ui.actionSave_as.triggered.connect(self.save_as)
        self.ui.actionExit.triggered.connect(self.exit_window)

        self.ui.actionLight_Contrast.triggered.connect(
            self.open_color_light_dialog)

        self.ui.light_spinbox.valueChanged.connect(
            self.light_spinbox_value_changed)
        self.ui.contrast_spinbox.valueChanged.connect(
            self.contrast_spinbox_value_changed)

        self.img_view_timer.timeout.connect(self.update_img_view)
        self.img_view_timer.start(250)

        self.ui_color.l_radio_all_bands.clicked.connect(
            self.dialog_color_light_all_checked)
        self.ui_color.l_radio_rgb.clicked.connect(
            self.dialog_color_light_rgb_checked)
        self.ui_color.c_radio_all_bands.clicked.connect(
            self.dialog_color_contrast_all_checked)
        self.ui_color.c_radio_rgb.clicked.connect(
            self.dialog_color_contrast_rgb_checked)

        self.ui_color.cancel_button.clicked.connect(self.dialog_color_cancel)
        self.ui_color.compute_button.clicked.connect(self.dialog_color_compute)

        # ------------------------
        # Actions list ends here
        # ---------------------------------------------------------------------------------------------------------- #
        # ------------------------
        # Main loop and exit app
        # ------------------------
        self.MainWindow.show()
        sys.exit(self.app.exec_())
        # ------------------------
        # END OF APPLICATION
        # ---------------------------------------------------------------------------------------------------------- #

    def enable_options(self):
        # Enable Menu/Actions
        self.ui.actionSave.setEnabled(self.UP)
        self.ui.actionSave_as.setEnabled(self.UP)
        self.ui.menuFilters.setEnabled(self.UP)
        self.ui.menuTransformations.setEnabled(self.UP)

        # Enable Spinbox
        self.ui.light_spinbox.setEnabled(self.UP)
        self.ui.light_spinbox.setValue(0)
        self.ui.contrast_spinbox.setEnabled(self.UP)
        self.ui.contrast_spinbox.setValue(1.0)

    def update_img_view(self):
        if self.is_img_Open:
            #print(self.ui.img_view.size())
            width = self.ui.img_view.width()
            height = self.ui.img_view.height()
            if self.img.width < width or self.img.height < height:
                width = self.q_img.width()
                height = self.q_img.height()
            size = QSize(width, height)
            pixmap = QPixmap()
            pixmap = pixmap.fromImage(self.q_img)
            pixmap = pixmap.scaled(size, self.Q_ASPECT_RATIO)
            self.ui.img_view.setPixmap(pixmap)
            self.ui.img_view.show()

    def open_img_path(self):
        """
        Open the dialog and take the path.
        :return: True/False, path_string/empty_string
        """
        file_dialog = QFileDialog()
        f_path = file_dialog.getOpenFileName(parent=None,
                                             caption="Open Image",
                                             directory=QDir.homePath(),
                                             filter=self.IMG_FILTER,
                                             initialFilter="",
                                             options=self.DIALOG_FLAG)[0]
        if f_path:
            return True, f_path
        return False, ""

    def save_img_path(self):
        """
        Open the dialog and take the path.
        :return: True/False, path_string/empty_string
        """
        file_dialog = QFileDialog()
        f_path = file_dialog.getSaveFileName(parent=None,
                                             caption="Save Image as",
                                             directory=QDir.homePath(),
                                             filter=self.IMG_FILTER,
                                             initialFilter="",
                                             options=self.DIALOG_FLAG)[0]
        if f_path:
            return True, f_path
        return False, ""

    def open(self):
        """
        Open an image and create a QImage() item for view.
        :return: Nothing
        """
        self.is_img_Open, f_path = self.open_img_path(
        )  # Open dialog and take the path
        if self.is_img_Open:  # Check if user gave a path or not (aka pressed "Open" or "Cancel"
            self.img.open_image_from(f_path)  # Open image
            self.img.print_img_info()  # Print info for debugging
            # Transform Image() to QImage()
            bytes_per_line = 3 * self.img.width
            self.img.set_img_tmp(self.img.img)
            self.q_img = QImage(self.img.img_tmp_RGB(), self.img.width,
                                self.img.height, bytes_per_line,
                                QImage.Format_RGB888)
            self.enable_options()  # Enable all image processing utilities

    def save(self):
        """
        Save an image to a given path. (If image has already been saved to a path reuses this path)
        :return: Nothing
        """
        if not self.is_img_Save:
            self.save_as()  # Open dialog and take the path
        else:  # Check if user gave a path or not (aka pressed "Open" or "Cancel")
            self.img.set_img_from_img_tmp()
            self.img.save_image()

    def save_as(self):
        """
        Save an image to a given path. (Asks every time the user to specify a path)
        :return: Nothing
        """
        self.is_img_Save, f_path = self.save_img_path(
        )  # Open dialog and take the path
        if self.is_img_Save:  # Check if user gave a path or not (aka pressed "Open" or "Cancel"
            self.img.set_img_from_img_tmp()
            self.img.save_image_as(f_path)

    def exit_window(self):
        """
        Signal exit application
        :return: Nothing
        """
        self.MainWindow.close()  # Close The window

    def light_spinbox_value_changed(self):
        self.img_proc.set_light(self.ui.light_spinbox.value())
        self.ui_color.l_spin_light_for_all.setValue(
            self.ui.light_spinbox.value())
        img_rgb = self.img.img_RGB()
        img_rgb = self.img_proc.compute_light_contrast(img_rgb)
        self.img.set_img_tmp(self.img.img_RGB2BGR(img_rgb))
        bytes_per_line = 3 * self.img.width
        self.q_img = QImage(self.img.img_tmp_RGB(), self.img.width,
                            self.img.height, bytes_per_line,
                            QImage.Format_RGB888)

    def contrast_spinbox_value_changed(self):
        self.img_proc.set_contrast(self.ui.contrast_spinbox.value())
        self.ui_color.c_contrast_for_all.setValue(
            self.ui.contrast_spinbox.value())
        img_rgb = self.img.img_RGB()
        img_rgb = self.img_proc.compute_light_contrast(img_rgb)
        self.img.set_img_tmp(self.img.img_RGB2BGR(img_rgb))
        bytes_per_line = 3 * self.img.width
        self.q_img = QImage(self.img.img_tmp_RGB(), self.img.width,
                            self.img.height, bytes_per_line,
                            QImage.Format_RGB888)

    def open_color_light_dialog(self):
        self.DialogColor.show()

    def dialog_color_cancel(self):
        self.DialogColor.close()

    def dialog_color_light_all_checked(self):
        self.ui_color.l_all_bands_widget.setEnabled(self.UP)
        self.ui_color.l_rgb_widget.setEnabled(self.DOWN)

    def dialog_color_light_rgb_checked(self):
        self.ui_color.l_all_bands_widget.setEnabled(self.DOWN)
        self.ui_color.l_rgb_widget.setEnabled(self.UP)
        self.img_proc.set_default_light_contrast_rgb()

    def dialog_color_contrast_all_checked(self):
        self.ui_color.c_all_bands_widget.setEnabled(self.UP)
        self.ui_color.c_rgb_widget.setEnabled(self.DOWN)

    def dialog_color_contrast_rgb_checked(self):
        self.ui_color.c_all_bands_widget.setEnabled(self.DOWN)
        self.ui_color.c_rgb_widget.setEnabled(self.UP)

    def dialog_color_compute(self):
        if self.ui_color.l_radio_all_bands.isChecked():
            self.img_proc.set_light(self.ui_color.l_spin_light_for_all.value())
            self.ui_color.l_spin_red.setValue(
                self.ui_color.l_spin_light_for_all.value())
            self.ui_color.l_spin_green.setValue(
                self.ui_color.l_spin_light_for_all.value())
            self.ui_color.l_spin_blue.setValue(
                self.ui_color.l_spin_light_for_all.value())
            self.ui.light_spinbox.setValue(
                self.ui_color.l_spin_light_for_all.value())
            img_rgb = self.img.img_RGB()
            img_rgb = self.img_proc.compute_light_contrast(img_rgb)
            self.img.set_img_tmp(self.img.img_RGB2BGR(img_rgb))

        if self.ui_color.c_radio_all_bands.isChecked():
            self.img_proc.set_contrast(self.ui.contrast_spinbox.value())
            self.ui.contrast_spinbox.setValue(
                self.ui_color.c_contrast_for_all.value())
            self.ui_color.c_double_spin_red.setValue(
                self.ui_color.c_contrast_for_all.value())
            self.ui_color.c_double_spin_green.setValue(
                self.ui_color.c_contrast_for_all.value())
            self.ui_color.c_double_spin_blue.setValue(
                self.ui_color.c_contrast_for_all.value())
            img_rgb = self.img.img_RGB()
            img_rgb = self.img_proc.compute_light_contrast(img_rgb)
            self.img.set_img_tmp(self.img.img_RGB2BGR(img_rgb))

        if self.ui_color.l_radio_rgb.isChecked(
        ) or self.ui_color.c_radio_rgb.isChecked():
            self.img_proc.set_light_contrast_rgb(
                self.ui_color.l_spin_red.value(),
                self.ui_color.l_spin_green.value(),
                self.ui_color.l_spin_blue.value(),
                self.ui_color.c_double_spin_red.value(),
                self.ui_color.c_double_spin_green.value(),
                self.ui_color.c_double_spin_blue.value())
            img_rgb = self.img.img_RGB()
            img_rgb = self.img_proc.compute_light_contrast_per_channel(img_rgb)
            self.img.set_img_tmp(self.img.img_RGB2BGR(img_rgb))
            bytes_per_line = 3 * self.img.width
            self.q_img = QImage(self.img.img_tmp_RGB(), self.img.width,
                                self.img.height, bytes_per_line,
                                QImage.Format_RGB888)
            self.img_proc.compute_light_contrast_per_channel(self.img.img_tmp)

        bytes_per_line = 3 * self.img.width
        self.q_img = QImage(self.img.img_tmp_RGB(), self.img.width,
                            self.img.height, bytes_per_line,
                            QImage.Format_RGB888)
Example #29
0
class Window:
    def __init__(self):
        # ------------------------
        # Set flags
        # ------------------------
        self.UP = True
        self.DOWN = False

        self.ALL_IMG_FORMAT = "All Supported (*.jpg *.jpeg *.jpe *.png *.bmp *.tif *.tiff " \
                              "*.dib *.pbm *.pgm *.ppm *.sr *.ras)"
        self.JPG_FORMAT = "JPG (*.jpg *.jpeg *.jpe)"
        self.PNG_FORMAT = "PNG (*.png)"
        self.BMP_FORMAT = "BMP (*.bmp)"
        self.TIF_FORMAT = "TIFF (*.tif *.tiff)"
        self.DIB_FORMAT = "DIB (*.dib)"
        self.PBM_FORMAT = "PBM (*.pbm)"
        self.PGM_FORMAT = "PGM (*.pgm)"
        self.PPM_FORMAT = "PPM (*.ppm)"
        self.SR__FORMAT = "SR (*.sr)"
        self.RAS_FORMAT = "RAS (*.ras)"
        self.DD = ";;"

        self.IMG_FILTER = self.ALL_IMG_FORMAT + self.DD + self.JPG_FORMAT + self.DD + self.PNG_FORMAT + self.DD + \
                          self.BMP_FORMAT + self.DD + self.TIF_FORMAT + self.DD + self.DIB_FORMAT + self.DD + \
                          self.PBM_FORMAT + self.DD + self.PGM_FORMAT + self.DD + self.PPM_FORMAT + self.DD + \
                          self.SR__FORMAT + self.DD + self.RAS_FORMAT

        self.DIALOG_FLAG = QFileDialog.DontUseNativeDialog
        self.Q_ASPECT_RATIO = Qt.KeepAspectRatio
        # ------------------------
        # Flags Section ends here
        # ---------------------------------------------------------------------------------------------------------- #
        # ------------------------
        # Set class items
        # ------------------------
        self.q_img = QImage()
        self.img_view_timer = QTimer()

        self.img = Image()
        self.is_img_Open = False
        self.is_img_Save = False

        # ------------------------
        # Class items ends here
        # ---------------------------------------------------------------------------------------------------------- #
        # ------------------------
        # Set up the ui
        # ------------------------
        self.app = QtWidgets.QApplication(sys.argv)
        self.ui = Ui_MainWindow()
        self.MainWindow = QtWidgets.QMainWindow()
        self.ui.setupUi(self.MainWindow)
        # ------------------------
        # Setting up ends here
        # ---------------------------------------------------------------------------------------------------------- #
        # ------------------------
        # Actions list starts here
        # ------------------------
        self.ui.actionOpen.triggered.connect(self.open)
        self.ui.actionSave.triggered.connect(self.save)
        self.ui.actionExit.triggered.connect(self.exit_window)

        self.img_view_timer.timeout.connect(self.update_img_view)
        self.img_view_timer.start(250)
        # ------------------------
        # Actions list ends here
        # ---------------------------------------------------------------------------------------------------------- #
        # ------------------------
        # Main loop and exit app
        # ------------------------
        self.MainWindow.show()
        sys.exit(self.app.exec_())
        # ------------------------
        # END OF APPLICATION
        # ---------------------------------------------------------------------------------------------------------- #

    def update_img_view(self):
        if self.is_img_Open:
            #print(self.ui.img_view.size())
            width = self.ui.img_view.width()
            height = self.ui.img_view.height()
            if self.img.width < width or self.img.height < height:
                width = self.q_img.width()
                height = self.q_img.height()
            size = QSize(width, height)
            pixmap = QPixmap()
            pixmap = pixmap.fromImage(self.q_img)
            pixmap = pixmap.scaled(size, self.Q_ASPECT_RATIO)
            self.ui.img_view.setPixmap(pixmap)
            self.ui.img_view.show()

    def open_img_path(self):
        """
        Open the dialog and take the path.
        :return: True/False, path_string/empty_string
        """
        file_dialog = QFileDialog()
        f_path = file_dialog.getOpenFileName(parent=None,
                                             caption="Open Image",
                                             directory=QDir.homePath(),
                                             filter=self.IMG_FILTER,
                                             initialFilter="",
                                             options=self.DIALOG_FLAG)[0]
        if f_path:
            return True, f_path
        return False, ""

    def save_img_path(self):
        """
        Open the dialog and take the path.
        :return: True/False, path_string/empty_string
        """
        file_dialog = QFileDialog()
        f_path = file_dialog.getSaveFileName(parent=None,
                                             caption="Save Image as",
                                             directory=QDir.homePath(),
                                             filter=self.IMG_FILTER,
                                             initialFilter="",
                                             options=self.DIALOG_FLAG)[0]
        if f_path:
            return True, f_path
        return False, ""

    def open(self):
        """
        Open an image and create a QImage() item for view.
        :return: Nothing
        """
        self.is_img_Open, f_path = self.open_img_path(
        )  # Open dialog and take the path
        if self.is_img_Open:  # Check if user gave a path or not (aka pressed "Open" or "Cancel"
            self.img.open_image_from(f_path)  # Open image
            self.img.print_img_info()  # Print info for debugging
            # Transform Image() to QImage()
            bytes_per_line = 3 * self.img.width
            self.q_img = QImage(self.img.img_RGB(), self.img.width,
                                self.img.height, bytes_per_line,
                                QImage.Format_RGB888)
            self.ui.actionSave.setEnabled(
                self.UP)  # Enable save (currently not so useful)

    def save(self):
        """
        Save an image to a given path
        :return: Nothing
        """
        self.is_img_Save, f_path = self.save_img_path(
        )  # Open dialog and take the path
        if self.is_img_Save:  # Check if user gave a path or not (aka pressed "Open" or "Cancel"
            self.img.save_image_as(f_path)

    def exit_window(self):
        """
        Signal exit application
        :return: Nothing
        """
        self.MainWindow.close()  # Close The window