C ++如何使用指针数组缩小图像？

Question

我正在编写一个处理图像的 c++ 程序，这是缩小图像的函数。有一个“像素”指针数组和一个定义了图像颜色的类。除了 Visual Studio 中包含的用于此图像程序的库之外，我不能使用任何其他库。我遇到了这个函数的问题，我需要遍历图像中的像素并将其分割成块；用户将输入块的宽度/高度。创建块后，需要从每个块中获取平均 RGB 值（该平均值将成为一个新的像素），并且所有这些都被安排好后，它将“缩小”图像。到目前为止，似乎是因为图像变小而创建了块，但我的图像完全变灰了。 RGB 像素的总数添加正确，但代码的其余部分一定有问题，我无法查明它。这是我的代码：

//creates a block of average colors based on range of pixels given
pixel CreateBlock(int start, int stop, pixel** currpix, int blockHeight, int blockWidth)
{
    pixel** block;          //Problem? might have to be a single pointer pixel* block[];
    block = new pixel*[blockHeight];

    for (int i = 0; i < blockHeight; i++)
        block[i] = new pixel[blockWidth];

    pixel newPix;

    float totred = 0, totblue = 0, totgreen = 0;
    int redav = 0.0, blueav = 0.0, greenav = 0.0;

    for (int i = 0; i < blockHeight; i++)
    {
        for (int j = 0; j < blockWidth; j++)
        {
            totred = totred + block[i][j].red;
            totblue = totblue + block[i][j].blue;
            totgreen = totgreen + block[i][j].green;
        }
    }

    redav = totred / (blockHeight*blockWidth);
    blueav = totblue / (blockHeight* blockWidth);
    greenav = totgreen / (blockHeight*blockWidth);

    newPix.red = redav;
    newPix.blue = blueav;
    newPix.green = greenav;

    return newPix;
}

//make a new image that is a smaller resampling of the bigger image
void averageRegions(int blockWidth, int blockHeight)
{
    int height = displayed->getHeight(), width = displayed->getWidth();
    int i = 0, j = 0;
    pixel** currpix = displayed->getPixels();           //PROBLEM
    image* shrunk = displayed;
    //shrunk->getPixels();
    shrunk->createNewImage(width / blockWidth, height / blockHeight);
    while (i < height)
    {
        while (j < width)
        {
            int start = i, stop = i + 10;
            shrunk->getPixels()[i][j] = CreateBlock(start, stop, currpix, blockHeight, blockWidth);
            j = j + blockWidth;
        }
        i = i + blockHeight;
    }

    return;
}

这是图像类：

class image {
    public:
        image();            //the image constructor (initializes everything)
        image(string filename);  //a image constructor that directly loads an image from disk
        ~image();           //the image destructor  (deletes the dynamically created pixel array)

        void createNewImage(int width, int height); //this function deletes any current image data and creates a new blank image
                                                //with the specified width/height and allocates the needed number of pixels
                                                //dynamically.
        bool loadImage(string filename);        //load an image from the specified file path.  Return true if it works, false if it is not a valid image.
                                            //Note that we only accept images of the RGB 8bit colorspace!
        void saveImage(string filename);       //Save an image to the specified path
        pixel** getPixels();                    //return the 2-dimensional pixels array
        int getWidth();                     //return the width of the image
        int getHeight();                    //return the height of the image

        void viewImage(CImage* myImage);  //This function is called by the windows GUI.  It returns the image in format the GUI understands.


    private:
        void pixelsToCImage(CImage* myImage);  //this function is called internally by the image class.
                                            //it converts our pixel struct array to a standard BGR uchar array with word spacing.
                                            //(Don't worry about what this does)
        pixel** pixels;             // pixel data array for image 
        int width, height;      // stores the image dimensions 
};

这里是像素类：

class pixel
{
public:
    unsigned char red;      //the red component
    unsigned char green;    //the green component
    unsigned char blue;     //the blue component
};

Answer 1

好的，减去大量内存泄漏和误导性名称，您在 CreateBlock 中找到平均值的想法是正确的。我会尝试这样的事情：

pixel averagePixels(pixel **oldImage, int startRow, int startCol, int blockHeight, int blockWidth){
    float rTot, gTot, bTot;
    pixel avg;

    for(int i = startRow ; i < blockHeight + startRow ; i++){
        for(int j = startCol ; j < blockWidth + startCol ; j++){
            rTot += oldImage[i][j].red;
            gTot += oldImage[i][j].green;
            bTot += oldImage[i][j].blue;
        }
    }
    avg.red   = rTot / (blockHeight * blockWidth);
    avg.green = gTot / (blockHeight * blockWidth);
    avg.blue  = bTot / (blockHeight * blockWidth);
    return avg;
}

pixel **shrinkImage(pixel **oldImage, int blockHeight, int blockWidth){
    int newHeight = oldImage->getHeight() / blockHeight;
    int newWidth  = oldImage->getWidth()  / blockWidth;
    pixel **newImage = new pixel* [newHeight];
    for(int i = 0 ; i < newHeight ; i++)
        newImage[i] = new pixel[newWidth];

    for(int i = 0 ; i < newHeight){
        for(int j = 0 ; j < newWidth){
            newImage[i][j] = averagePixels(oldImage, blockHeight * i, blockWidth * j, blockWidth, blockHeight);
        }
    }
    return newImage;
}

免责声明，我还没有实际测试过这些，确保新的 rgb 值在可接受的范围内（我猜是 0-255？）可能是明智的（至少出于测试目的）。当图像大小不能完全被块大小整除时，您还需要一些边界检查/特殊情况。

Answer 2

问题似乎是您在这里使用了未初始化的值：

  totred = totred + block[i][j].red;
  totblue = totblue + block[i][j].blue;
  totgreen = totgreen + block[i][j].green;

您分配了block，但您未能初始化任何值。因此red、green 和blue 具有随机值。

您还有内存泄漏——您在此处分配了block，但未能解除分配：

pixel** block; 
block = new pixel*[blockHeight];

for (int i = 0; i < blockHeight; i++)
    block[i] = new pixel[blockWidth];

除此之外，最简单的解决方案是使用std::vector<std::vector<pixel>>：

#include <vector>
//...
std::vector<std::vector<pixel> > block(blockHeight, std::vector<pixel>(blockWidth));

一行代码完成了循环完成的所有工作，还消除了内存泄漏。它真正不做的事情是使用您需要的值初始化block。这些值是什么——你需要确定它们。

Answer 3

您没有在CreateBlock 代码中使用currpix。您正在平均代码中分配的随机数：

block = new pixel*[blockHeight];
for (int i = 0; i < blockHeight; i++)
    block[i] = new pixel[blockWidth];