QML Camera size issue



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


  • 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;
        }
    }

Log in to reply
 

Looks like your connection to Qt Forum was lost, please wait while we try to reconnect.