OpenCV cv::Mat 到 std::ifstream 用于 base64 编码

2021-12-10 00:00:00 opencv stream base64 c++

老实说，我很惊讶到目前为止没有人遇到过这种情况.我正在将 OpenCV 中的图片加载到 cv::Mat 中，我想在通过套接字发送它之前对其进行 base64 编码.

To be honest I'm suprised nobody has run into this thus far. I'm loading a picture from OpenCV into cv::Mat, which I want to base64 encode before I send it over a socket.

对于 base64，我使用 libb64，因为它是 Debian/Ubuntu 原生的，并且易于使用且非常快速地.编码函数将std::ifstream作为参数，并输出std::ofstream.

For base64 I am using libb64 as it is native to Debian/Ubuntu, and easy to use and very fast. The encoding function takes as a parameter an std::ifstream, and outputs an std::ofstream.

#include <opencv2/opencv.hpp>
#include <b64/encode.h>
#include <fstream>

using namespace cv;
Mat image;
image = imread( "picture.jpg", CV_LOAD_IMAGE_COLOR );

if ( image.data )
{
    std::ifstream instream( ???, std::ios_base::in | std::ios_base::binary);
    std::ofstream outstream;        

    // Convert Matrix to ifstream
    // ...

    base64::encoder E;
    E.encode( instream, outstream );

    // Now put it in a string, and send it over a socket...
}

我真的不知道如何从 cv::Mat 填充内流.谷歌搜索，我发现我可以按列和行迭代 cv::Mat，并获得每个(我假设的像素)RGB 值:

I don't really know how to populate the instream from the cv::Mat. Googling around, I found that I can iterate a cv::Mat, by columns and rows, and get each (pixel I am assuming) RGB values:

for ( int j = 0; j < image.rows; j++ )
{
    for ( int i = 0; i < image.cols; i++ )
    {
        unsigned char b = input [ image.step * j + i ] ;
        unsigned char g = input [ image.step * j + i + 1 ];
        unsigned char r = input [ image.step * j + i + 2 ];
    }
}

这是正确的处理方式吗?有没有更优雅的方式?

Is this the right way of going on about it? Is there some more elegant way?

推荐答案

为了能够通过 HTTP 发送图像，您还需要对其宽度、高度和类型进行编码.您需要将 Mat 序列化为一个流并使用 libb64 对该流进行编码.另一方面，您需要解码该流并反序列化图像以检索它.

In order to be able to send an image via HTTP, you also need to encode its width, height and type. You need to serialize the Mat into a stream and encode that stream with libb64. On the other side you need to decode that stream and deserialize the image to retrieve it.

我实现了一个小型测试程序，该程序使用 std::stringstream 作为缓冲区进行序列化和反序列化.我选择它是因为它同时扩展了 libb64 使用的 std::istream 和 std::ostream.

I implemented a small test program that does this serialization and deserialization using std::stringstream as a buffer. I chose it because it extends both std::istream and std::ostream which libb64 uses.

serialize 函数将 cv::Mat 序列化为 std::stringstream.在里面，我写了图像的宽度、高度、类型、缓冲区的大小和缓冲区本身.

The serialize function serializes a cv::Mat into a std::stringstream. In it, I write the image width, height, type, size of the buffer and the buffer itself.

deserialize 函数做相反的事情.它读取缓冲区和缓冲区的宽度、高度、类型、大小.它的效率并不高，因为它需要分配一个临时缓冲区来从字符串流中读取数据.此外，它需要克隆图像，以便它不依赖临时缓冲区并处理自己的内存分配.我敢肯定，稍加修改可以提高效率.

The deserialize function does the reverse. It reads the width, height, type, size of the buffer and the buffer. It's not as efficient as it could be because it needs to allocate a temporary buffer to read the data from the stringstream. Also, it needs to clone the image so that it does not rely on the temporary buffer and it will handle its own memory allocation. I'm sure that with some tinkering it can be made more efficient.

主函数加载图像，对其进行序列化，使用 libb64 对其进行编码，然后对其进行解码、反序列化并将其显示在窗口中.这应该模拟您正在尝试做的事情.

The main function loads an image, serializes it, encodes it using libb64, then decodes it, deserializes it and displays it in a window. This should simulate what you are trying to do .

// Serialize a cv::Mat to a stringstream
stringstream serialize(Mat input)
{
    // We will need to also serialize the width, height, type and size of the matrix
    int width = input.cols;
    int height = input.rows;
    int type = input.type();
    size_t size = input.total() * input.elemSize();

    // Initialize a stringstream and write the data
    stringstream ss;
    ss.write((char*)(&width), sizeof(int));
    ss.write((char*)(&height), sizeof(int));
    ss.write((char*)(&type), sizeof(int));
    ss.write((char*)(&size), sizeof(size_t));

    // Write the whole image data
    ss.write((char*)input.data, size);

    return ss;
}

// Deserialize a Mat from a stringstream
Mat deserialize(stringstream& input)
{
    // The data we need to deserialize
    int width = 0;
    int height = 0;
    int type = 0;
    size_t size = 0;

    // Read the width, height, type and size of the buffer
    input.read((char*)(&width), sizeof(int));
    input.read((char*)(&height), sizeof(int));
    input.read((char*)(&type), sizeof(int));
    input.read((char*)(&size), sizeof(size_t));

    // Allocate a buffer for the pixels
    char* data = new char[size];
    // Read the pixels from the stringstream
    input.read(data, size);

    // Construct the image (clone it so that it won't need our buffer anymore)
    Mat m = Mat(height, width, type, data).clone();

    // Delete our buffer
    delete[]data;

    // Return the matrix
    return m;
}

void main()
{
    // Read a test image
    Mat input = imread("D:\test\test.jpg");

    // Serialize the input image to a stringstream
    stringstream serializedStream = serialize(input);

    // Base64 encode the stringstream
    base64::encoder E;
    stringstream encoded;
    E.encode(serializedStream, encoded);

    // Base64 decode the stringstream
    base64::decoder D;
    stringstream decoded;
    D.decode(encoded, decoded);

    // Deserialize the image from the decoded stringstream
    Mat deserialized = deserialize(decoded);

    // Show the retrieved image
    imshow("Retrieved image", deserialized);
    waitKey(0);
}

相关文章