Comment consulter/modifier un élément de la matrice dans OpenCV? Pourquoi à() est templatized?

Comme bien d'ores et déjà souligné par William, vous devez fournir le bon type comme un argument de modèle pour at. Je crois que cv::Mat lui-même n'est pas faite de modèle pour la simplification. Cependant, OpenCV équipage s'efforce de soutenir des fonctionnalités C++, y compris les modèles. L'interface est devenue légèrement hétérogène de cette façon.

Vous ne pouvait pas déduire compilateur le type d'une variable de type à l'exécution, pour une raison évidente. Cependant, vous pouvez déduire au moment de la compilation, si votre variable de type est connu à ce point, à l'aide d'une classe de traits:

template<int I>
struct CvType {};

template<>
struct CvType<CV_64F> { typedef double type_t; };
template<>
struct CvType<CV_32F> { typedef float type_t; };
template<>
struct CvType<CV_8U> { typedef unsigned char type_t; };
//Other types go here

void main()
{
  const int type = CV_64F;
  cv::Mat mat(10, 10, type);
  mat.at<CvType<type>::type_t>(1, 1);
}

Dans ce cas, vous pouvez modifier la valeur de type et n'aurait pas besoin de changer les types manuellement pour tous les at ou d'autres appels de méthodes.

OriginalL'auteur Mikhail

La Mat classe n'est pas une classe de modèle, ce qui permet de changer son "type" au moment de l'exécution. Changer le type est utile par exemple lorsque la lecture à partir d'un fichier. N'étant pas un modèle pratique, lors de l'utilisation d'un Mat en tant que paramètre de la fonction, puisque la fonction n'est pas nécessaire d'être un modèle de fonction.

Cependant, pour accéder à des éléments uniques (avec les pointeurs, au ou les itérateurs) vous avez besoin du type de données. Je suppose que c'est fait pour des raisons de performances. Cela va à l'encontre de l'exécution type de système et le rend plus difficile à écrire du code générique, lorsque vous ne connaissez pas le type au moment de la compilation. Néanmoins, vous pouvez le faire avec une solution de contournement.

La méthode la plus simple est tout simplement d'utiliser un if-else-cascade:

Mat img = imread("test.png");
if (img.channels() == 1) {
    if (img.depth() == CV_8U) {
        cout << (int)(img.at<uint8_t>(0,0)) << endl;
    }
    else if (img.depth() == CV_8S) {
        /* ... */
    }
    /* ... */
}
/* ... */
else if (img.channels() == 3) {
    if (img.depth() == CV_8U) {
        auto p = img.at<array<uint8_t,3>>(0,0);
        cout << (int)(p[0]) << ";" << (int)(p[1]) << ";" << (int)(p[2]) << endl;
    }
    /* ... */
}
/* ... */

Mais vous pouvez imaginer que cela devient lourd, si vous écrivez pour tous les types et les canaux. Vous devez limiter le nombre de canaux de toute façon, car il n'y a aucune limite à l'utilisation d'OpenCV. Nous choisissons 4 ci-après.

J'ai écrit un helper modèle metaprogram en-tête, qui fait le travail. Vous pouvez fournir un foncteur avec basé sur un modèle operator(). Appelez ensuite le modèle metaprogram, qui va appeler le foncteur avec un temps de compilation type. Voir cet exemple pour un foncteur qui imprime le premier pixel et retourne si elle n'est pas nulle:

struct PrintPixel {
    Mat img;

    //this template function will be called from the metaprogram
    template<int cv_type> //compile time value e.g. CV_8UC3
    bool operator()() {
        using elem_t  = typename CvTypeTraits<cv_type>::base_type;
        using array_t = typename CvTypeTraits<cv_type>::array_type;
        //you could also do static_asserts here

        array_t pixel = img.at<array_t>(0,0);
        for (elem_t val : pixel)
            cout << (double)(val) << ", ";
        cout << endl;
        return any_of(pixel.begin(), pixel.end(), [](elem_t v){return v != 0;});
    }
};

Note, le type de retour de la operator() peut être arbitraire, mais ne peut pas dépendre du type d'image cv_type malheureusement. C'est parce qu'il est également utilisé comme type de retour de la fonction qui détient le si-sinon cascade (la run fonction, voir ci-dessous).

Voici le code appelant, qui peut vérifier pour "tous" les canaux (1 à 4) et les types ou pour un ensemble spécifié:

Mat img = imread("test.png");
int t = img.type();

//call functor, check for 1-4 channels and all 7 base types
bool not_zero = CallFunctor::run(PrintPixel{img}, t);

//call functor, check only for 1 or 3 channels and 8 bit unsigned int
CallFunctorRestrictChannelsTo<1,3>::AndBaseTypesTo<CV_8U>::run(PrintPixel{img}, t);

Le dernier appel va lever une exception, si t n'est pas CV_8UC1 ou CV_8UC3. Si vous êtes souvent en utilisant la même restriction, vous pouvez abréger, avec l'aide de déclaration (voir au bas de l'en-tête de fichier ci-dessous).

Donc, c'est un outil facile à utiliser la solution qui vous permet d'utiliser un temps de compilation valeur "fabriqué" à partir d'un moment de l'exécution de la valeur. Mais rappelez-vous, dans le fond d'un si-sinon-cascade est en train de faire toutes les vérifications (dans l'ordre dans lequel les canaux et les types ont été spécifiée). Cela implique que pour chaque combinaison de canal et le type est vérifié un béton foncteur classe est générée. S'il est grand, ce qui pourrait être mauvais. Il ne doit inclure le type charge des parties. Il pourrait également être une usine foncteur qui instancie basé sur un modèle de classe avec un non-modèle de base avec des fonctions virtuelles pour réduire la taille du code.

Il suit le fichier d'en-tête, qui contient le CvTypeTraits classe et le modèle metaprogram fonctions. En bas, vous pouvez voir que le CallFunctor type est vraiment juste une abréviation pour une "restriction" de types et de canaux. Vous pouvez également déclarer quelque chose comme ça avec d'autres restrictions.

#pragma once
#include <cstdint>
#include <type_traits>
#include <array>
#include <opencv2/core/types_c.h>
template<int> struct BaseType { };
template<> struct BaseType<CV_8S>  { using base_type = int8_t;   };
template<> struct BaseType<CV_8U>  { using base_type = uint8_t;  };
template<> struct BaseType<CV_16S> { using base_type = int16_t;  };
template<> struct BaseType<CV_16U> { using base_type = uint16_t; };
template<> struct BaseType<CV_32S> { using base_type = int32_t;  };
template<> struct BaseType<CV_32F> { using base_type = float;    };
template<> struct BaseType<CV_64F> { using base_type = double;   };
template<int t>
struct CvTypeTraits {
constexpr static int channels = t / CV_DEPTH_MAX + 1;
using base_type = typename BaseType<t % CV_DEPTH_MAX>::base_type;
using array_type = std::array<base_type, channels>;
};
template<int currentChannel, int... otherChannels>
struct find_chan_impl {
template<typename ret_type, int... types>
struct find_type_impl {
template<class Functor>
static inline ret_type run(Functor&& f, int const& c, int const& t) {
if (c == currentChannel)
return find_chan_impl<currentChannel>::template find_type_impl<ret_type, types...>::run(std::forward<Functor>(f), c, t);
else
return find_chan_impl<otherChannels...>::template find_type_impl<ret_type, types...>::run(std::forward<Functor>(f), c, t);
}
};
};
template<>
struct find_chan_impl<0> {
template<typename ret_type, int... types>
struct find_type_impl {
template<class Functor>
[[noreturn]] static inline ret_type run(Functor&& f, int const& c, int const& t) {
throw std::runtime_error("The image has " + std::to_string(c) + " channels, but you did not try to call the functor with this number of channels.");
}
};
};
template<int channel>
struct find_chan_impl<channel> {
template<typename ret_type, int currentType, int... otherTypes>
struct find_type_impl {
static_assert(currentType < CV_DEPTH_MAX, "You can only restrict to base types, without channel specification");
template<class Functor>
static inline ret_type run(Functor&& f, int const& c, int const& t) {
if (t == currentType)
return find_type_impl<ret_type, currentType>::run(std::forward<Functor>(f), c, t);
else
return find_type_impl<ret_type, otherTypes...>::run(std::forward<Functor>(f), c, t);
}
};
template<typename ret_type, int type>
struct find_type_impl<ret_type, type> {
template<class Functor>
static inline ret_type run(Functor&& f, int const& c, int const& t) {
return f.template operator()<CV_MAKETYPE(type,channel)>();
}
};
template<typename ret_type>
struct find_type_impl<ret_type, -1> {
template<class Functor>
[[noreturn]] static inline ret_type run(Functor&& f, int const& c, int const& t) {
throw std::runtime_error("The image is of base type " + std::to_string(t) + ", but you did not try to call the functor with this base type.");
}
};
};
template<int... channels>
struct CallFunctorRestrictChannelsTo {
template<int firstType, int... types>
struct AndBaseTypesTo {
template<class Functor>
static inline auto run(Functor&& f, int t) -> decltype(f.template operator()<firstType>()) {
using functor_ret_type = decltype(f.template operator()<firstType>());
std::div_t d = std::div(t, CV_DEPTH_MAX);
int c             = d.quot + 1;
int const& base_t = d.rem;
return find_chan_impl<channels..., 0>::template find_type_impl<functor_ret_type, firstType, types..., -1>::run(std::forward<Functor>(f), c, base_t);
}
};
template<class Functor>
static inline auto run(Functor&& f, int t) -> decltype(f.template operator()<CV_8S>()) {
return AndBaseTypesTo<CV_8S, CV_8U, CV_16S, CV_16U, CV_32S, CV_32F, CV_64F>::run(std::forward<Functor>(f), t);
}
};
template<int... types>
using CallFunctorRestrictBaseTypesTo = CallFunctorRestrictChannelsTo<1,2,3,4>::template AndBaseTypesTo<types...>;
using CallFunctor = CallFunctorRestrictChannelsTo<1,2,3,4>::template AndBaseTypesTo<CV_8S, CV_8U, CV_16S, CV_16U, CV_32S, CV_32F, CV_64F>;

OriginalL'auteur John