QML Camera size issue

[guidupas]

Hello!

I am facing an issue with image size when I pass the image from QML to Qt to process some modification.

I have a Camera element and a VideoOutput element inside a QML document and I have a class that takes the Camera image to perform the changes in C++. This class is registered to be used with QML: qmlRegisterType<processaImagem>("ProcessaImagemQml", 1, 0, "ProcessaImagem"); in main.cpp

Inside the processaImagem class I have a Q_PROPERTY called tamanhoImagem that holds the size of the image. The value of this property is defined inside the QML document camera.tamanhoImagem = Qt.size(cameraView.sourceRect.width, cameraView.sourceRect.height);

The problem is that in QML the image size is retuning a different value than the same value passed to C++. In QML the result of console.log("Tamanho da imagem: " + camera.tamanhoImagem); is 320 x 240 and in C++ the result of qDebug() << p_tamanhoImagem; is 180 x 240.

This problem just occurs when I run this code in a smartphone, in a desktop it runs OK.

Code below:

    Camera {
        id: camera
    
        property string caminhoPreview: ""
        property size tamanhoImagem: Qt.size(0, 0);
    
        captureMode: Camera.CaptureStillImage
    
        imageCapture {
            onImageCaptured: {
                imagemPreview.source = preview;

                camera.caminhoPreview = preview;
        
                camera.tamanhoImagem = Qt.size(cameraView.sourceRect.width, cameraView.sourceRect.height);
    
                camera.stop();
    
                console.log("Tamanho da imagem: " + camera.tamanhoImagem);
            }
        }
    }

    VideoOutput {
        id: cameraView
    
        visible: true
    
        focus: visible
    
        anchors.fill: parent

        source: camera
        orientation: camera.orientation
        fillMode: VideoOutput.PreserveAspectFit
    }

    ProcessaImagem {
        id: processaImagem
    
        caminhoImagem: camera.caminhoPreview
        tamanhoImagem: camera.tamanhoImagem

        onCaminhoImagemChanged: {
            ProvedorImagem.carregaImagem(processaImagem.carregaImagem());
        }
    }

processaimagem.h

    class processaImagem : public QObject
    {
        Q_OBJECT

        Q_PROPERTY(QString caminhoImagem READ caminhoImagem WRITE setCaminhoImagem NOTIFY caminhoImagemChanged)
    
        Q_PROPERTY(QSize tamanhoImagem READ tamanhoImagem WRITE setTamanhoImagem NOTIFY tamanhoImagemChanged)
    
    public slots:
        QImage carregaImagem();
    
    public:
        processaImagem(QObject *parent = 0);

        QString caminhoImagem() const;
        void setCaminhoImagem(const QString valor);

        QSize tamanhoImagem() const;
        void setTamanhoImagem(const QSize valor);
    
    private:
        QString p_caminhoImagem = "";        
        QSize p_tamanhoImagem = QSize(0, 0);
    
    signals:
        void caminhoImagemChanged();
        void tamanhoImagemChanged();
    };

processaimagem.cpp

    processaImagem::processaImagem(QObject *parent)
    {
    
    }
    
    QImage processaImagem::carregaImagem()
    {
        QUrl caminhoImagem(p_caminhoImagem);
        QQmlEngine *engine = QQmlEngine::contextForObject(this)->engine();
        QQmlImageProviderBase *imageProviderBase = engine->imageProvider(caminhoImagem.host());
        QQuickImageProvider *imageProvider = static_cast<QQuickImageProvider*>(imageProviderBase);
    
        QString imageId = caminhoImagem.path().remove(0, 1);
        QImage imagem = imageProvider->requestImage(imageId, &p_tamanhoImagem, p_tamanhoImagem);
    
        if(imagem.isNull())
        {
            qDebug() << "Erro ao carregar a imagem";
            imagem = QImage();
        }
        else
        {
            qDebug() << "p_imagem size: ";
            qDebug() << p_tamanhoImagem;
        }
    }
    
    QString processaImagem::caminhoImagem() const
    {
        return p_caminhoImagem;
    }
    
    void processaImagem::setCaminhoImagem(const QString valor)
    {
        if (valor != p_caminhoImagem)
        {
            p_caminhoImagem = valor;
            emit caminhoImagemChanged();
        }
    }
    
    QSize processaImagem::tamanhoImagem() const
    {
        return p_tamanhoImagem;
    }
    
    void processaImagem::setTamanhoImagem(const QSize valor)
    {
        bool alterou = false;
    
        if (valor.width() != p_tamanhoImagem.width())
        {
            p_tamanhoImagem.setWidth(valor.width());
            alterou = true;
        }
    
        if (valor.height() != p_tamanhoImagem.height())
        {
            p_tamanhoImagem.setHeight(valor.height());
            alterou = true;
        }
    
        if(alterou)
        {
            emit tamanhoImagemChanged();
        }
    }

[guidupas]

Answering my own question:

In the method processaImagem just pass a empty QSize as parameter to the provider and it will return the image with it original size:

QImage processaImagem::carregaImagem()
{
    QUrl caminhoImagem(p_caminhoImagem);
    QQmlEngine *engine = QQmlEngine::contextForObject(this)->engine();
    QQmlImageProviderBase *imageProviderBase = engine->imageProvider(caminhoImagem.host());
    QQuickImageProvider *imageProvider = static_cast<QQuickImageProvider*>(imageProviderBase);

    QSize imageSize;    
    QString imageId = caminhoImagem.path().remove(0, 1);
    QImage imagem = imageProvider->requestImage(imageId, &imageSize, imageSize);

    if(imagem.isNull())
    {
        qDebug() << "Erro ao carregar a imagem";
        imagem = QImage();
    }
    else
    {
        qDebug() << "p_imagem size: ";
        qDebug() << p_tamanhoImagem;
    }
}