Redimensionner une image d'un carré, mais garder l'aspect ratio c++, opencv

Est-il un moyen de redimensionner des images de n'importe quelle forme ou taille-à-dire [500x500] mais ont le format de l'image sera maintenu, levaing l'espace vide sera rempli avec le blanc/noir de remplissage?

Donc, dire que l'image est [2000x1000], après avoir redimensionné pour [500x500] l'image elle-même serait [500x250], avec 125 chaque côté blanc/noir de remplissage.

Quelque chose comme ceci:

Sortie

Redimensionner une image d'un carré, mais garder l'aspect ratio c++, opencv

MODIFIER

Je ne le souhaitez pas il suffit d'afficher l'image dans une fenêtre carrée, plutôt que l'image a changé à cet état, puis enregistrées dans le fichier de création d'une collection de même de la taille des images avec peu de distorsion de l'image que possible.

La seule chose que je suis venu à travers de poser une question semblable a été ce post, mais son php.

Avez-vous essayé tout?
Je peux redimensionner les images fine, de ses la plus de la noire que je ne connais pas
Remplissez votre fond noir, puis coller l'image sur elle...?
Ce n'est pas spécifiquement pour l'affichage de souci, en plus de l'avoir sauvé de cette manière
Votre image est un Mat[500,500], n'est-ce pas ?

OriginalL'auteur MLMLTL | 2015-02-17

c++image image-resizing opencv

Pas entièrement optimisé, mais vous pouvez essayer ceci:

MODIFIER gérer la taille de la cible qui n'est pas 500x500 pixels et l'enveloppant comme une fonction.

cv::Mat GetSquareImage( const cv::Mat& img, int target_width = 500 )
{
    int width = img.cols,
       height = img.rows;

    cv::Mat square = cv::Mat::zeros( target_width, target_width, img.type() );

    int max_dim = ( width >= height ) ? width : height;
    float scale = ( ( float ) target_width ) / max_dim;
    cv::Rect roi;
    if ( width >= height )
    {
        roi.width = target_width;
        roi.x = 0;
        roi.height = height * scale;
        roi.y = ( target_width - roi.height ) / 2;
    }
    else
    {
        roi.y = 0;
        roi.height = target_width;
        roi.width = width * scale;
        roi.x = ( target_width - roi.width ) / 2;
    }

    cv::resize( img, square( roi ), roi.size() );

    return square;
}

J'ai changé quelques choses de telle sorte que la nouvelle image n'a pas été étirée pour s'adapter à 500x500 à chaque fois, mais pour ce que jamais la taille est définie, mais sinon, ouais super!
L'édition, c'est juste parfait
génial, merci, btw, vous pouvez également contrôler la couleur d'arrière-plan avec un paramètre, mais j'ai gardé les choses simples..

OriginalL'auteur Rosa Gronchi

Une approche générale:

cv::Mat utilites::resizeKeepAspectRatio(const cv::Mat &input, const cv::Size &dstSize, const cv::Scalar &bgcolor)
{
    cv::Mat output;

    double h1 = dstSize.width * (input.rows/(double)input.cols);
    double w2 = dstSize.height * (input.cols/(double)input.rows);
    if( h1 <= dstSize.height) {
        cv::resize( input, output, cv::Size(dstSize.width, h1));
    } else {
        cv::resize( input, output, cv::Size(w2, dstSize.height));
    }

    int top = (dstSize.height-output.rows) / 2;
    int down = (dstSize.height-output.rows+1) / 2;
    int left = (dstSize.width - output.cols) / 2;
    int right = (dstSize.width - output.cols+1) / 2;

    cv::copyMakeBorder(output, output, top, down, left, right, cv::BORDER_CONSTANT, bgcolor );

    return output;
}

La bonne réponse. Mais pourquoi la const et passage par référence?
const indique un lecteur de code que votre image d'entrée ne sera pas modifié lors de l'appel de cette fonction. Passage par référence évite la copie par la valeur qui est cher légèrement, même si la copie ne peut pas être effectuée.

OriginalL'auteur alireza

Alireza la réponse est bonne, cependant j'ai modifié le code légèrement, de sorte que je ne pas ajouter des bordures verticales lorsque l'image s'adapte à la verticale et je n'ai pas ajouter horizontale frontières lorsque l'image s'adapte à l'horizontale (ce qui est plus proche de l'original de la demande):

cv::Mat utilites::resizeKeepAspectRatio(const cv::Mat &input, const cv::Size &dstSize, const cv::Scalar &bgcolor)
{
    cv::Mat output;

    //initially no borders
    int top = 0;
    int down = 0;
    int left = 0;
    int right = 0;
    if( h1 <= dstSize.height) 
    {
        //only vertical borders
        top = (dstSize.height - h1) / 2;
        down = top;
        cv::resize( input, output, cv::Size(dstSize.width, h1));
    } 
    else 
    {
        //only horizontal borders
        left = (dstSize.width - w2) / 2;
        right = left;
        cv::resize( input, output, cv::Size(w2, dstSize.height));
    }

    return output;
}

Votre solution est incomplète et il est pas évident de savoir comment Alireza du code doit être modifié à l'aide de la vôtre.
Mise à jour de la solution pour être plus complet

OriginalL'auteur Dragan Ostojić

Vous pouvez créer une autre image de la place de la taille que vous souhaitez, puis de placer votre image dans le milieu de la place de l'image. Quelque chose comme ceci:

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include "opencv2/imgproc/imgproc.hpp"

int main(int argc, char *argv[])
{
    //read an image
    cv::Mat image1= cv::imread("/home/hdang/Desktop/colorCode.png");

    //resize it
    cv::Size newSize = cv::Size(image1.cols/2,image1.rows/2);
    cv::resize(image1, image1, newSize, 0, 0, cv::INTER_LINEAR);

    //create the square container
    int dstWidth = 500;
    int dstHeight = 500;
    cv::Mat dst = cv::Mat(dstHeight, dstWidth, CV_8UC3, cv::Scalar(0,0,0));

    //Put the image into the container, roi is the new position
    cv::Rect roi(cv::Rect(0,dst.rows*0.25,image1.cols,image1.rows));
    cv::Mat targetROI = dst(roi);
    image1.copyTo(targetROI);

    //View the result
    cv::namedWindow("OpenCV Window");
    cv::imshow("OpenCV Window", dst);

    //wait key for 5000 ms
    cv::waitKey(5000);

    return 0;
}

OriginalL'auteur Ha Dang

Vous devez vous connecter pour publier un commentaire.