Qt: Ändern der Größe eines QLabels, das eine QPixmap enthält, unter Beibehaltung des Seitenverhältnisses

Ich verwende ein QLabel, um dem Benutzer den Inhalt einer größeren, sich dynamisch ändernden QPixmap anzuzeigen. Es wäre schön, dieses Etikett je nach verfügbarem Platz kleiner / größer zu machen. Die Bildschirmgröße ist nicht immer so groß wie die QPixmap.

Wie kann ich das QSizePolicyund sizeHint()des QLabels ändern, um die Größe der QPixmap zu ändern, während das Seitenverhältnis der ursprünglichen QPixmap beibehalten wird?

Ich kann sizeHint()das QLabel nicht ändern , das Setzen minimumSize()auf Null hilft nicht. Das Einstellen hasScaledContents()auf dem QLabel ermöglicht das Wachsen, bricht aber das Seitenverhältnis ...

Die Unterklasse von QLabel hat geholfen, aber diese Lösung fügt zu viel Code für nur ein einfaches Problem hinzu ...

Irgendwelche intelligenten Hinweise, wie dies ohne Unterklassen erreicht werden kann?

Um die Etikettengröße zu ändern, können Sie eine geeignete Größenrichtlinie für das Etikett auswählen, z. B. das Erweitern oder das minimale Erweitern.

Sie können die Pixmap skalieren, indem Sie das Seitenverhältnis bei jeder Änderung beibehalten:

QPixmap p; // load pixmap
// get label dimensions
int w = label->width();
int h = label->height();

// set a scaled pixmap to a w x h window keeping its aspect ratio 
label->setPixmap(p.scaled(w,h,Qt::KeepAspectRatio));

Es gibt zwei Stellen, an denen Sie diesen Code hinzufügen sollten:

• Wenn die Pixmap aktualisiert wird
• Im resizeEventWidget, das die Beschriftung enthält

Ich habe diese fehlende Unterklasse von poliert QLabel. Es ist großartig und funktioniert gut.

aspektratiopixmaplabel.h

#ifndef ASPECTRATIOPIXMAPLABEL_H
#define ASPECTRATIOPIXMAPLABEL_H

#include <QLabel>
#include <QPixmap>
#include <QResizeEvent>

class AspectRatioPixmapLabel : public QLabel
{
    Q_OBJECT
public:
    explicit AspectRatioPixmapLabel(QWidget *parent = 0);
    virtual int heightForWidth( int width ) const;
    virtual QSize sizeHint() const;
    QPixmap scaledPixmap() const;
public slots:
    void setPixmap ( const QPixmap & );
    void resizeEvent(QResizeEvent *);
private:
    QPixmap pix;
};

#endif // ASPECTRATIOPIXMAPLABEL_H

aspektratiopixmaplabel.cpp

#include "aspectratiopixmaplabel.h"
//#include <QDebug>

AspectRatioPixmapLabel::AspectRatioPixmapLabel(QWidget *parent) :
    QLabel(parent)
{
    this->setMinimumSize(1,1);
    setScaledContents(false);
}

void AspectRatioPixmapLabel::setPixmap ( const QPixmap & p)
{
    pix = p;
    QLabel::setPixmap(scaledPixmap());
}

int AspectRatioPixmapLabel::heightForWidth( int width ) const
{
    return pix.isNull() ? this->height() : ((qreal)pix.height()*width)/pix.width();
}

QSize AspectRatioPixmapLabel::sizeHint() const
{
    int w = this->width();
    return QSize( w, heightForWidth(w) );
}

QPixmap AspectRatioPixmapLabel::scaledPixmap() const
{
    return pix.scaled(this->size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
}

void AspectRatioPixmapLabel::resizeEvent(QResizeEvent * e)
{
    if(!pix.isNull())
        QLabel::setPixmap(scaledPixmap());
}

Hoffentlich hilft das! (Aktualisiert resizeEventgemäß der Antwort von @ dmzl)

Ich benutze nur contentsMargin, um das Seitenverhältnis zu korrigieren.

#pragma once

#include <QLabel>

class AspectRatioLabel : public QLabel
{
public:
    explicit AspectRatioLabel(QWidget* parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags());
    ~AspectRatioLabel();

public slots:
    void setPixmap(const QPixmap& pm);

protected:
    void resizeEvent(QResizeEvent* event) override;

private:
    void updateMargins();

    int pixmapWidth = 0;
    int pixmapHeight = 0;
};

#include "AspectRatioLabel.h"

AspectRatioLabel::AspectRatioLabel(QWidget* parent, Qt::WindowFlags f) : QLabel(parent, f)
{
}

AspectRatioLabel::~AspectRatioLabel()
{
}

void AspectRatioLabel::setPixmap(const QPixmap& pm)
{
    pixmapWidth = pm.width();
    pixmapHeight = pm.height();

    updateMargins();
    QLabel::setPixmap(pm);
}

void AspectRatioLabel::resizeEvent(QResizeEvent* event)
{
    updateMargins();
    QLabel::resizeEvent(event);
}

void AspectRatioLabel::updateMargins()
{
    if (pixmapWidth <= 0 || pixmapHeight <= 0)
        return;

    int w = this->width();
    int h = this->height();

    if (w <= 0 || h <= 0)
        return;

    if (w * pixmapHeight > h * pixmapWidth)
    {
        int m = (w - (pixmapWidth * h / pixmapHeight)) / 2;
        setContentsMargins(m, 0, m, 0);
    }
    else
    {
        int m = (h - (pixmapHeight * w / pixmapWidth)) / 2;
        setContentsMargins(0, m, 0, m);
    }
}

Funktioniert bisher perfekt für mich. Bitte.

Ich habe versucht, Phyatt's AspectRatioPixmapLabelKlasse zu verwenden, hatte aber einige Probleme:

• Manchmal trat meine App in eine Endlosschleife von Größenänderungsereignissen ein. Ich habe dies auf den Aufruf von QLabel::setPixmap(...)inside der resizeEvent-Methode zurückgeführt, da QLabeltatsächlich updateGeometryinside aufgerufen wird setPixmap, was Größenänderungsereignisse auslösen kann ...
• heightForWidthschien vom enthaltenen Widget ( QScrollAreain meinem Fall a) ignoriert zu werden, bis ich anfing, eine Größenrichtlinie für das Etikett festzulegen und explizit aufzurufenpolicy.setHeightForWidth(true)
• Ich möchte, dass das Etikett nie größer wird als die ursprüngliche Pixmap-Größe
• QLabelDie Implementierung von minimumSizeHint()bewirkt etwas Magie für Beschriftungen, die Text enthalten, setzt jedoch die Größenrichtlinie immer auf die Standardrichtlinie zurück, sodass ich sie überschreiben musste

Das heißt, hier ist meine Lösung. Ich stellte fest, dass ich die Größenänderung einfach verwenden setScaledContents(true)und durchführen lassen konnte QLabel. Dies hängt natürlich davon ab, welches Widget / Layout das enthält heightForWidth.

aspektratiopixmaplabel.h

#ifndef ASPECTRATIOPIXMAPLABEL_H
#define ASPECTRATIOPIXMAPLABEL_H

#include <QLabel>
#include <QPixmap>

class AspectRatioPixmapLabel : public QLabel
{
    Q_OBJECT
public:
    explicit AspectRatioPixmapLabel(const QPixmap &pixmap, QWidget *parent = 0);
    virtual int heightForWidth(int width) const;
    virtual bool hasHeightForWidth() { return true; }
    virtual QSize sizeHint() const { return pixmap()->size(); }
    virtual QSize minimumSizeHint() const { return QSize(0, 0); }
};

#endif // ASPECTRATIOPIXMAPLABEL_H

aspektratiopixmaplabel.cpp

#include "aspectratiopixmaplabel.h"

AspectRatioPixmapLabel::AspectRatioPixmapLabel(const QPixmap &pixmap, QWidget *parent) :
    QLabel(parent)
{
    QLabel::setPixmap(pixmap);
    setScaledContents(true);
    QSizePolicy policy(QSizePolicy::Maximum, QSizePolicy::Maximum);
    policy.setHeightForWidth(true);
    this->setSizePolicy(policy);
}

int AspectRatioPixmapLabel::heightForWidth(int width) const
{
    if (width > pixmap()->width()) {
        return pixmap()->height();
    } else {
        return ((qreal)pixmap()->height()*width)/pixmap()->width();
    }
}

Angepasst von Timmmm an PYQT5

from PyQt5.QtGui import QPixmap
from PyQt5.QtGui import QResizeEvent
from PyQt5.QtWidgets import QLabel


class Label(QLabel):

    def __init__(self):
        super(Label, self).__init__()
        self.pixmap_width: int = 1
        self.pixmapHeight: int = 1

    def setPixmap(self, pm: QPixmap) -> None:
        self.pixmap_width = pm.width()
        self.pixmapHeight = pm.height()

        self.updateMargins()
        super(Label, self).setPixmap(pm)

    def resizeEvent(self, a0: QResizeEvent) -> None:
        self.updateMargins()
        super(Label, self).resizeEvent(a0)

    def updateMargins(self):
        if self.pixmap() is None:
            return
        pixmapWidth = self.pixmap().width()
        pixmapHeight = self.pixmap().height()
        if pixmapWidth <= 0 or pixmapHeight <= 0:
            return
        w, h = self.width(), self.height()
        if w <= 0 or h <= 0:
            return

        if w * pixmapHeight > h * pixmapWidth:
            m = int((w - (pixmapWidth * h / pixmapHeight)) / 2)
            self.setContentsMargins(m, 0, m, 0)
        else:
            m = int((h - (pixmapHeight * w / pixmapWidth)) / 2)
            self.setContentsMargins(0, m, 0, m)

Die Qt-Dokumentationen enthalten ein Image Viewer-Beispiel, das die Handhabung der Größenänderung von Bildern in a demonstriert QLabel. Die Grundidee besteht darin, QScrollAreaals Container für die QLabelund bei Bedarf zu verwenden label.setScaledContents(bool)und scrollarea.setWidgetResizable(bool)den verfügbaren Platz zu füllen und / oder sicherzustellen, dass die Größe von QLabel im Inneren geändert werden kann. Um die Größe von QLabel zu ändern und gleichzeitig das Seitenverhältnis zu berücksichtigen, verwenden Sie außerdem:

label.setPixmap(pixmap.scaled(width, height, Qt::KeepAspectRatio, Qt::FastTransformation));

Das widthund heightkann basierend auf scrollarea.width()und eingestellt werden scrollarea.height(). Auf diese Weise muss QLabel nicht in Unterklassen unterteilt werden.