Comment définir canal donné d'un cv::Mat pour une valeur donnée de manière efficace, sans modifier les autres canaux?

Comment définir canal donné d'un cv::Mat à une valeur donnée de manière efficace, sans modifier les autres canaux? Par exemple, je veux mettre sa quatrième canal (canal alpha) sur la valeur 120 (c'est à dire la moitié transparent), quelque chose comme:

cv::Mat mat; //with type CV_BGRA
...
mat.getChannel(3) = Scalar(120); //<- this is what I want to do

P. S.: Ma solution actuelle est d'abord divisé la mat en de multiples canaux et de définir le canal alpha, puis de les fusionner en arrière.

P. S. 2: je sais que je peux le faire rapidement si je veux aussi changer d'autres canaux par:

mat.setTo(Scalar(54, 154, 65, 120));

Mise à jour avec une solution:

Les deux méthodes de travail pour l'établissement de tous les tapis de valeurs au canal donné à la valeur donnée. Et ils vont travailler pour toutes les matrices qu'elles soient continues ou non.

Méthode-1 - plus efficace

-> basé sur @Antonio réponse et encore améliorée par @MichaelBurdinov

//set all mat values at given channel to given value
void setChannel(Mat &mat, unsigned int channel, unsigned char value)
{
    //make sure have enough channels
    if (mat.channels() < channel + 1)
        return;

    const int cols = mat.cols;
    const int step = mat.channels();
    const int rows = mat.rows;
    for (int y = 0; y < rows; y++) {
        //get pointer to the first byte to be changed in this row
        unsigned char *p_row = mat.ptr(y) + channel; 
        unsigned char *row_end = p_row + cols*step;
        for (; p_row != row_end; p_row += step)
            *p_row = value;
    }
}

Méthode-2 - plus élégant

-> basé sur @MichaelBurdinov la réponse de

//set all mat values at given channel to given value
void setChannel(Mat &mat, unsigned int channel, unsigned char value)
{
    //make sure have enough channels
    if (mat.channels() < channel+1)
        return;

    //check mat is continuous or not
    if (mat.isContinuous())
        mat.reshape(1, mat.rows*mat.cols).col(channel).setTo(Scalar(value));
    else{
        for (int i = 0; i < mat.rows; i++)
            mat.row(i).reshape(1, mat.cols).col(channel).setTo(Scalar(value));
    }
}

P. S.: Il est digne de noter que, selon la la documentation, matrices créé avec Mat::create() sont toujours en continu. Mais si vous extraire une partie de la matrice en utilisant la Mat::col(), Mat::diag(), et ainsi de suite, ou de la construction d'une matrice d'en-tête pour l'extérieur les données allouées, ces matrices peuvent ne plus avoir cette propriété.

Pour voir comment setTo est mis en œuvre, de construire OpenCV en mode debug et d'entrer dans la fonction du corps (en core.cpp)
Merci de bien vouloir examiner ma réponse. Merci!!!!

InformationsquelleAutor herohuyongtao | 2014-05-07

alpha-transparency c++color-channel matrix opencv

12

Si votre image est en continu dans la mémoire vous pouvez utiliser l'astuce suivante:
```
mat.reshape(1,mat.rows*mat.cols).col(3).setTo(Scalar(120));
```
Si elle n'est pas continue:
```
for(int i=0; i<mat.rows; i++)
    mat.row(i).reshape(1,mat.cols).col(3).setTo(Scalar(120));
```
Edit (merci à Antonio pour le commentaire):

Noter que ce code peut être le plus court et il n'est pas de l'attribution de nouveaux de la mémoire, mais elle n'est pas efficace du tout. Il peut être encore plus lente que split/merge approche. OpenCV est vraiment inefficace quand il doit effectuer des opérations sur les non-matrices continues avec 1 pixel dans une rangée. Si le temps le rendement est important, vous devez utiliser la solution proposée par @Antonio.

Juste une légère amélioration de sa solution:
```
const int cols = img.cols;
const int step = img.channels();
const int rows = img.rows;
for (int y = 0; y < rows; y++) {
    unsigned char* p_row = img.ptr(y) + SELECTED_CHANNEL_NUMBER; //gets pointer to the first byte to be changed in this row, SELECTED_CHANNEL_NUMBER is 3 for alpha
    unsigned char* row_end = p_row + cols*step;
    for(; p_row != row_end; p_row += step)
         *p_row = value;
    }
}
```
Cela économise de l'opération d'incrémentation de x et un moins de valeur dans le registre. Sur le système à ressources limitées, il peut donner à ~5% de l'accélération. Autrement le temps les performances seront les mêmes.
- Et si vous voulez à nouveau, ce que vous avez besoin de remodeler?
- +1 pour la solution la plus élégante approche, notons en outre que les Matrices de créé avec Mat::create() sont toujours en continu. Mais si vous extraire une partie de la matrice en utilisant la Mat::col(), Mat::diag() , et ainsi de suite, ou de la construction d'une matrice d'en-tête pour l'extérieur les données allouées, ces matrices peuvent ne plus avoir cette propriété. Et nous pouvons compter sur Mat::isContinuous() pour vérifier.
- ofthemoon, remodeler n'est pas en changeant d'origine de l'en-tête de la matrice, mais aussi pour en créer un nouveau et de le retourner. Comme un résultat que vous n'avez pas besoin de faire quelque chose pour le récupérer.
- +1 Oui, vous avez raison, je viens de me suis convaincu
- +1 je me demande vraiment si ce que sera l'efficacité de cette mise en œuvre, et de manière plus générale, pourquoi les personnes travaillant dans la vision par ordinateur ont tellement peur de l'écriture de fonctions d'aller au moyen d'une matrice et de l'évolution des octets de valeurs.
- le code est très court et propre, mais je suppose que le temps de la performance va en effet être assez terrible. OpenCV est vraiment inefficace quand il doit effectuer des opérations sur des matrices avec 1 pixel dans une rangée. Je vais mettre à jour ma réponse pour la rendre plus claire. Merci.
InformationsquelleAutor Michael Burdinov
7
```
Mat img;
[...]
const int cols = img.cols;
const int step = img.channels();
const int rows = img.rows;
for (int y = 0; y < rows; y++) {
    unsigned char* p_row = img.ptr(y) + SELECTED_CHANNEL_NUMBER; //gets pointer to the first byte to be changed in this row, SELECTED_CHANNEL_NUMBER is 3 for alpha
    for (int x = 0; x < cols; x++) {
         *p_row = value;
         p_row += step; //Goes to the next byte to be changed
    }
}
```
Remarque: Cela fonctionne à la fois continue et uncontinuous matrices, en fonction de l'utilisation du terme pour opencv: http://docs.opencv.org/modules/core/doc/basic_structures.html#bool%20Mat::isContinuous%28%29%20const
- Downvoter seraient bienvenues en commentaire
- votre img.ptr est le manque de <type> accolades, et CV_8UC4 (rgba) a été explicitement spécifié dans le post ci-dessus. et quelle est l'étape ? (oui, mon downvote)
- type accolades n'est pas obligatoire, cette fonction stub généralise sur tous les types d'images. Merci d'avoir remarqué le manque * (et le supplément de const, par la voie), mais c'est pas une raison pour downvote. L'étape est l'étape de byte à sauter d'un alpha octet pour la prochaine. docs.opencv.org/modules/core/doc/basic_structures.html#mat-ptr
- si le pointeur est const, vous ne pouvez pas faire p_row += step;
- Pas vrai, mais en fait c'était une erreur que je ne pouvais pas faire *p_row = value;. Cependant, il existe des erreurs facilement retiré après la compilation.
- k,k. je m'étais trompé.
- CV8_UC4 n'est-il pas BGRA? OpenCV stocke les images comme BGR en cv::Mat
- ofthemoon généralement, les images viennent comme bgr(CV_8UC3) dans opencv, mais herohuyongtao est question ci-dessus est sur la façon de définir le 4ème canal dans un BGRA(CV_8UC4) de l'image
InformationsquelleAutor Antonio
2

Qu'en direct Mat::accès aux données (je suis tout à fait sûr de setTo() ou oother opencv Mat api utiliser la même solution):
```
template<int N>
void SetChannel(Mat &img, unsigned char newVal) {   
    for(int x=0;x<img.cols;x++) {
        for(int y=0;y<img.rows;y++) {
            *(img.data + (y * img.cols + x) * img.channels() + N) = newVal;
        }
    }
}


int main() {
    Mat img = Mat::zeros(1000, 1000, CV_8UC4);
    SetChannel<3>(img, 120);
    imwrite("out.jpg", img);

    return 0;
}
```
- Merci. En fait j'attends de façon plus élégante de le faire. Ne pas OpenCV fournir l'API pour obtenir un canal spécifique?
- Aussi loin que je ne l'accepte pas. Bien sûr, il n'est pas aussi élégant, mais peut-être plus vite que la division et fusion des canaux séparément.
- Ceci ne prend pas en compte la foulée pourrait être différente de cols: img.data + (y * img.cols + x) devrait être img.data + (y * img.step1() + x)
- Merci, mais vous êtes partiellement droit - je ne prends pas en compte la foulée, mais à l'aide de l'étape 1. () ne permet pas de résoudre ce problème, car l'étape 1. () est juste (number_of_bytes_in_row / number_of_bytes_per_pixel, dans notre 8_UC4 cas 1() est de 4000), donc si la matrice n'est pas continue, à l'aide de l'étape 1. () ne permet pas à tous. Et le second, de vous souhaitez utiliser etape 1(), la ligne devrait ressembler à: *(img.données + y * img.etape 1() + x * img.canaux() + N) = newVal;
- etape 1 (), en effet, n'aide pas pour SparseMat, mais dans tous les autres cas (rembourrage en ligne, cv::Mat sélectionné à partir d'un plus grand cv::Mat). Votre code de correction est bon, merci.
InformationsquelleAutor marol

Algorithme Simple:

void SetChannel(Mat mat, uint channel, uchar value)
{
    const uint channels = mat.channels();
    if (channel > channels - 1)
        return;

    uchar * data = mat.data;
    uint N = mat.rows * mat.step / mat.elemSize1();

    for (uint i = channel; i < N; i += channels)
        data[i] = value;
}

InformationsquelleAutor Gold Digging Programmer

Vous devez vous connecter pour publier un commentaire.