Fly's profile - activity

@berak It works. OMG. Thank you so much! Just for the record though, what exactly are all the things that are wrong with my loop :D?

@berak Right, just noticed that too - Thanks! I actually tried converting it now, but failed horribly at doing so (Stack Overflow error)... I'll put the code I wrote in my post.

I'm trying to export some frames as a GIF by using this library: https://github.com/ginsweater/gif-h

Unfortunately, it seems that the char-array the library requires for each frame is ordered differently than Mat#data. Which led me to memory errors when trying to simply pass the Mat-data-array as argument.

I did read the documentation of "Mat", but can't say that I truly understood, and thus don't know how to properly convert it.

I tried to convert it like this:

const int dim = resolution.width * resolution.height * 4;
uint8_t* pixels = (uint8_t*)alloca(sizeof(uint8_t) * dim);
for (int y = 1; y <= res.width; y++){
    for (int x = 1; x <= res.height; x++){
        uint8_t* pixel = NULL; 
        f->pixelAt(x-1, y-1, pixel);
        pixels[(y*x-1)] = pixel[0];
        pixels[(y*x - 1) + 1] = pixel[1];
        pixels[(y*x - 1) + 2] = pixel[2];
        pixels[(y*x - 1) + 3] = 255;
    }
}

Where f->pixelAt(x, y, pixel) equals to:

void OpenCV_Frame::pixelAt(int x, int y, uint8_t* retVal){
    retVal = new uint8_t[3];
    cv::Vec3b vec = at<cv::Vec3b>(y, x);
    retVal[0] = vec[0];
    retVal[1] = vec[1];
    retVal[2] = vec[2];
}

I get a stackoverflow error when allocating the uint8_t array. I know that the array is ridiculously big, but I'm not sure how to approach this problem otherwise.

Help appreciated, thanks!

@berak Thanks, I guess that will solve the problem. Still, it would be awesome to know what the pixel-array contains, just in case I'd have to perform some edits on it.

@berak Thanks for the answer, I'll try it out. What exactly is Mat.type()? And if it is different, can I somehow convert it to be, well, equal (That's why I'd have liked pixel-looping, to be able to control everything)? And what if I want, for Example, to draw on a frame? Then I'd need the pixel-changing, don't I (And if yes, how is the pixel-array organized? Would be cool to know.)? (Ok, I checked the types, thing is that the types of my two images ARE different, mainly probably because one image is a frame of a video while the other is a real image)

I wrote a little function in order to be able to "stick" the pixels of an image on top of another, but it somehow doesnt work: While the "shapes" of my "sticked" image is right, the colors are not.

The example flower is the first image, and as a second image I had a black trapezoid png. As you can see, there are multiple problems: 1. The colors are shown weirdly. Actually there are no colors, just greyscale, and some weird stripes as overlay. 2. Alpha values are not respected. The white part of the overlay image is transparent in the png.

Here is my code:

void mergeMats(Mat mat1, Mat mat2, int x, int y){
    //unsigned char * pixelPtr = (unsigned char *)mat2.data;
    //unsigned char * pixelPtr2 = (unsigned char *)mat1.data;
    //int cn = mat2.channels();
    //int cn2 = mat2.channels();
    //Scalar_<unsigned char> bgrPixel;

    for (int i = 0; i < mat2.cols; i++){
        for (int j = 0; j < mat2.rows; j++){
            if (x + i < mat1.cols && y + j < mat1.rows){

                Vec3b &intensity = mat1.at<Vec3b>(j+y, i+x);
                Vec3b intensity2 = mat2.at<Vec3b>(j, i);
                for (int k = 0; k < mat1.channels(); k++) {
                    intensity.val[k] = saturate_cast<uchar>(intensity2.val[k]);
                }
                //pixelPtr2[(i + x)*mat1.cols*cn2 + (j + y)*cn2 + 0] = pixelPtr[(i + x)*mat2.cols*cn + (j + y)*cn + 0];
                //pixelPtr2[(i + x)*mat1.cols*cn2 + (j + y)*cn2 + 1] = pixelPtr[(i + x)*mat2.cols*cn + (j + y)*cn + 1];
                //pixelPtr2[(i + x)*mat1.cols*cn2 + (j + y)*cn2 + 2] = pixelPtr[(i + x)*mat2.cols*cn + (j + y)*cn + 2];
            }
        }
    }
}

The commented code was another approach, but had the same results. So, here are my questions:

1. How do I solve the 2 problems (1. the colors..., 2. alpha ...)

2. How is the pixel-array of any Mat-Object actually, well, organized? I guess it would be easier for me to manipulate those arrays if I knew whats in them.

(I already asked this question on stackoverflow, but I guess it's better to ask it here.)