Normaliser les canaux de couleur d'une image en fonction de l'intensité des valeurs, OpenCV

J'ai découper une image en 3 couches de couleur - un bleu, un vert et un rouge. Je tiens à normaliser chacun de ces canaux par l'image de l'intensité, où l'intensité = (rouge + bleu + vert)/3. Pour être clair, je suis en train de faire une image qui est composée de l'un des trois canaux de couleur, divisé par l'image de l'intensité, où l'intensité est décrit par l'équation ci-dessus.
Je suis nouveau sur OpenCV et je ne pense pas que je le fais correctement; lorsque les images sont affichées, tous les pixels apparaissent en noir.
Je suis nouveau sur OpenCV (j'ai travaillé à travers les tutoriels qui viennent avec la documentation, mais c'est tout) - des conseils sur la façon d'aller sur cette normalisation pourrait être extrêmement utile.

Merci!

Voici ma tentative:

int main(int argc, char** argv){
Mat sourceImage, I;
const char* redWindow = "Red Color Channel";
const char* greenWindow = "Green Color Channel";
const char* blueWindow = "Blue Color Channel";


if(argc != 2)
{
  cout << "Incorrect number of arguments" << endl;
}
/* Load the image */
sourceImage = imread(argv[1], 1);
if(!sourceImage.data)
{
  cout << "Image failed to load" << endl;
}

/* First, we have to allocate the new channels */
Mat r(sourceImage.rows, sourceImage.cols, CV_8UC1);
Mat b(sourceImage.rows, sourceImage.cols, CV_8UC1);
Mat g(sourceImage.rows, sourceImage.cols, CV_8UC1);

/* Now we put these into a matrix */
Mat out[] = {b, g, r};

/* Split the image into the three color channels */
split(sourceImage, out);

/* I = (r + b + g)/3  */
add(b, g, I);
add(I, r, I);
I = I/3;

Mat red = r/I;
Mat blue = b/I;
Mat green = g/I;

/* Create the windows */
namedWindow(blueWindow, 0);
namedWindow(greenWindow, 0);
namedWindow(redWindow, 0);

/* Show the images */
imshow(blueWindow, blue);
imshow(greenWindow, green);
imshow(redWindow, red);

waitKey(0);
return 0;
}

1. vous n'avez pas besoin de pré-allocation des canaux utilisés dans la fonction split() (ils vont se realloced/écrasé de toute façon) 2. quelque chose comme r/je souffre d'une division entière 3. n'#t le faire dans l'espace rvb, convertir vhs, split,manipuler h seulement, de fusionner, de se reconvertir en rgb
Merci! Ok, je me suis débarrassé de la pré-affectation, et j'ai utilisé la fonction de division au lieu de '/' (est-ce mieux?). Aussi, pouvez-vous expliquer un peu plus ce que tu veux dire par manipuler h seulement?
diviser c'est la même chose que /. et désolé pour mon sloppyness, - je dû poser la question avant, ce que vous essayez d'atteindre par cette normalisation ?
Pas de soucis - je suis en train de mettre en œuvre une base saillants de l'objet de l'algorithme de détection. En tant que tel, l'une des principales région qui en contiennent le moins probable de la valeur de r, g ou b canaux de couleur
Afin de normaliser chacun des canaux signifie que certaines zones semblent plus brillants sur l'un des normalisé canaux. (théoriquement, au moins autant que je le comprends)
ahh, voir, source de malentendus, - j'ai été plus penser en termes de péréquation. mais encore une fois, si vous voulez diviser, vous avez probablement besoin de convertir les chaînes à virgule flottante en premier. d'autre vous rencontrez des problèmes comme: 7/12 (c'est 0 avec des entiers/char)
Bien, merci, un autre bon point!
Est-il possible que vous pourriez nous expliquer un peu plus ce que tu veux dire par manipuler h seulement?
encore une fois, c'était plus fait référence à une égalisation de problème, et j'ai même été trompé, si vous le convertissez en vhs (ou de laboratoire), vous pouvez normaliser v seulement pour obtenir une égalisation de la luminosité/intensité. de nouveau, probablement pas exactement ce que vous êtes après.
Ok un grand merci!
c'est ce que j'ai confondu votre problème: stackoverflow.com/questions/24341114/...

InformationsquelleAutor Nathan | 2014-06-25

c++color-channel normalization opencv

Une fois que vous divisez par l'intensité du pixel de valeurs dans l'intervalle [0, 1], à l'exception, car ils sont des entiers, ils vont être 0 ou 1. Pour une image de l'écran blanc est de 255 et 0 est noir, donc c'est pourquoi tout semble noir à vous.
Vous devez utiliser la virgule flottante pour obtenir un résultat précis, et vous devez ajuster le résultat en 255 à voir.
Faire que les résultats de cette (que j'ai d'un pas sûr, c'est particulièrement utile)

Normaliser les canaux de couleur d'une image en fonction de l'intensité des valeurs, OpenCV
(Source de l'Image: BSDS500)

Et voici le code qui les a générés:

#include <opencv2/core/core.hpp>
#include <vector>   
int main(int argc, char** argv)
{
    //READ RGB color image and convert it to Lab
    cv::Mat bgr_image = cv::imread("208001.jpg"); //BSDS500 mushroom
    cv::imshow("original image", bgr_image);
    cv::Mat bgr_image_f;
    bgr_image.convertTo(bgr_image_f, CV_32FC3);

    //Extract the color planes and calculate I = (r + g + b) /3
    std::vector<cv::Mat> planes(3);
    cv::split(bgr_image_f, planes); 

    cv::Mat intensity_f((planes[0] + planes[1] + planes[2]) / 3.0f);
    cv::Mat intensity;
    intensity_f.convertTo(intensity, CV_8UC1);
    cv::imshow("intensity", intensity);

    //void divide(InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
    cv::Mat b_normalized_f;
    cv::divide(planes[0], intensity_f, b_normalized_f);
    cv::Mat b_normalized;
    b_normalized_f.convertTo(b_normalized, CV_8UC1, 255.0);
    cv::imshow("b_normalized", b_normalized);

    cv::Mat g_normalized_f;
    cv::divide(planes[1], intensity_f, g_normalized_f);
    cv::Mat g_normalized;
    g_normalized_f.convertTo(g_normalized, CV_8UC1, 255.0);
    cv::imshow("g_normalized", g_normalized);

    cv::Mat r_normalized_f;
    cv::divide(planes[2], intensity_f, r_normalized_f);
    cv::Mat r_normalized;
    r_normalized_f.convertTo(r_normalized, CV_8UC1, 255.0);
    cv::imshow("r_normalized", r_normalized);
    cv::waitKey();
}

Merci!!!! cela aide beaucoup
Je me rends compte que c'est un vieux de réponse, mais je tiens à ajouter ceci dans le cas d'autres rencontre. Il y a quelque chose d'un peu squirrely sur vos normalisation. En raison de la division de l'intensité par 3, un pixel de valeur initiale (255,0,0) aurait un b_normalized_f valeur de plan (3,0,0). Vous voulez probablement quitter l'intensité comme la somme plutôt que de ensuite normalisé valeur, de sorte que le normalisée canaux fonctionnent en réalité de 0 à 1. D'ailleurs, qui semble être la raison pour laquelle de vos chaînes ont tendance à clip dans le CV_8UC1 affiche.
Merci de souligner ce point. Ce que vous dites est logique, mais la réponse juste suivi ce que l'OP spécifié.

InformationsquelleAutor Bull

Vous devez vous connecter pour publier un commentaire.