Qt: cambiar el tamaño de un QLabel que contiene un QPixmap manteniendo su relación de aspecto

Utilizo QLabel para mostrar al usuario el contenido de un QPixmap más grande que cambia dinámicamente. Sería bueno hacer esta etiqueta más pequeña / más grande según el espacio disponible. El tamaño de la pantalla no siempre es tan grande como el QPixmap.

¿Cómo puedo modificar QSizePolicyy sizeHint()de QLabel para cambiar el tamaño del QPixmap manteniendo la relación de aspecto del QPixmap original?

No puedo modificar sizeHint()el QLabel, establecer el minimumSize()en cero no ayuda. La configuración hasScaledContents()en QLabel permite crecer, pero rompe la relación de aspecto ...

Subclasificar QLabel ayudó, pero esta solución agrega demasiado código para un simple problema ...

¿Algún consejo inteligente sobre cómo lograr esto sin subclases?

Para cambiar el tamaño de la etiqueta, puede seleccionar una política de tamaño adecuada para la etiqueta, como expansión o expansión mínima.

Puede escalar el mapa de píxeles manteniendo su relación de aspecto cada vez que cambia:

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));

Hay dos lugares donde debe agregar este código:

• Cuando se actualiza el mapa de píxeles
• En el resizeEventdel widget que contiene la etiqueta

He pulido esta subclase faltante de QLabel. Es impresionante y funciona bien.

Aspectratiopixmaplabel.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

Aspectratiopixmaplabel.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());
}

¡Espero que ayude! (Actualizado resizeEvent, según la respuesta de @ dmzl)

Solo uso contentsMarginpara arreglar la relación de aspecto.

#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);
    }
}

Funciona perfectamente para mí hasta ahora. De nada.

Intenté usar la AspectRatioPixmapLabelclase de phyatt , pero experimenté algunos problemas:

• A veces, mi aplicación entraba en un ciclo infinito de eventos de cambio de tamaño. QLabel::setPixmap(...)Rastreé esto hasta la llamada de dentro del método resizeEvent, porque en QLabelrealidad las llamadas updateGeometrydentro setPixmap, lo que puede desencadenar eventos de cambio de tamaño ...
• heightForWidthparecía ser ignorado por el widget contenedor (a QScrollAreaen mi caso) hasta que comencé a configurar una política de tamaño para la etiqueta, llamando explícitamentepolicy.setHeightForWidth(true)
• Quiero que la etiqueta nunca crezca más que el tamaño del mapa de píxeles original
• QLabelLa implementación de minimumSizeHint()hace algo de magia para las etiquetas que contienen texto, pero siempre restablece la política de tamaño a la predeterminada, así que tuve que sobrescribirla

Dicho esto, aquí está mi solución. Descubrí que podía usar setScaledContents(true)y dejar QLabelmanejar el cambio de tamaño. Por supuesto, esto depende del widget / diseño que lo contenga respetando el heightForWidth.

Aspectratiopixmaplabel.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

Aspectratiopixmaplabel.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();
    }
}

Adaptado de Timmmm a 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)

La documentación de Qt tiene un ejemplo de Visor de imágenes que demuestra cómo manejar imágenes de cambio de tamaño dentro de un archivoQLabel . La idea básica es utilizar QScrollAreacomo un contenedor para el QLabely si es necesario, utilice label.setScaledContents(bool)y scrollarea.setWidgetResizable(bool)para llenar el espacio disponible y / o garantizar QLabel interior es de tamaño variable. Además, para cambiar el tamaño de QLabel respetando la relación de aspecto, utilice:

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

El widthy heightse puede establecer basándose en scrollarea.width()y scrollarea.height(). De esta manera, no es necesario crear una subclase de QLabel.