Skip to content
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups
  • Search
  • Get Qt Extensions
  • Unsolved
Collapse
Brand Logo
  1. Home
  2. Qt Development
  3. QML and Qt Quick
  4. QML Camera size issue
Forum Updated to NodeBB v4.3 + New Features

QML Camera size issue

Scheduled Pinned Locked Moved Solved QML and Qt Quick
2 Posts 1 Posters 629 Views 1 Watching
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • guidupasG Offline
    guidupasG Offline
    guidupas
    wrote on last edited by
    #1

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

    Att.
    Guilherme Cortada Dupas

    1 Reply Last reply
    0
    • guidupasG Offline
      guidupasG Offline
      guidupas
      wrote on last edited by
      #2

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

      Att.
      Guilherme Cortada Dupas

      1 Reply Last reply
      0

      • Login

      • Login or register to search.
      • First post
        Last post
      0
      • Categories
      • Recent
      • Tags
      • Popular
      • Users
      • Groups
      • Search
      • Get Qt Extensions
      • Unsolved