opencv imencode和imdecode使用，用于网络传输图片

example 1:

#include <string>
#include <fstream>
#include <vector>

#include <opencv2/opencv.hpp>

#include <iterator>
using namespace cv;

void memtoMat()
{
	std::ifstream file("c.png", std::ifstream::binary);
	std::vector<char> data;

	file >> std::noskipws;
	std::copy(std::istream_iterator<char>(file), std::istream_iterator<char>(), std::back_inserter(data));

	Mat matrixJprg = imdecode(Mat(data), CV_LOAD_IMAGE_COLOR);
	imwrite("./result.jpg", matrixJprg);
}

int main()
{
	memtoMat();
	std::cout << "hello" << std::endl;
	return 0;
}

example 2:

#include<iostream>

#include<opencv2/core/core.hpp>
#include<opencv2/opencv.hpp>

using namespace std;
using namespace cv;
//this program is used for testing opencv encode and decode for jgeg pictures

int main()
{
	Mat tstMat = imread("b.jpg");
	// imshow("picture",tstMat);
	vector<unsigned char> inImage;
	imencode(".jpg", tstMat, inImage);

	Mat show = imdecode(inImage, CV_LOAD_IMAGE_COLOR);
	imshow("picture", show);

	cv::waitKey(0);
	cout << "hello world" << endl;
	return 0;
}

example 3:

#include <string>
#include <fstream>
#include <vector>

#include <opencv2/opencv.hpp>

int test_encode_decode()
{
	// cv::imread/cv::imwrite
	std::string image_name = "b.jpg";
	cv::Mat mat1 = cv::imread(image_name, 1);
	if (mat1.empty()) {
		fprintf(stderr, "read image fail: %s\n", image_name.c_str());
		return -1;
	}

	std::string save_image = "b1_1.jpg";
	cv::imwrite(save_image, mat1);

	// cv::imdecode/cv::imencode
	std::ifstream file(image_name.c_str(), std::ios::in | std::ios::binary | std::ios::ate);
	if (!file.is_open()) {
		fprintf(stderr, "open file fail: %s\n", image_name.c_str());
		return -1;
	}

	std::streampos size = file.tellg();
	file.seekg(0, std::ios::beg);
	std::string buffer(size, ' ');
	file.read(&buffer[0], size);
	file.close();

	std::vector<char> vec_data(&buffer[0], &buffer[0] + size);
	cv::Mat mat2 = cv::imdecode(vec_data, 1);
	std::string save_image2 = "b2_1.jpg";
	cv::imwrite(save_image2, mat2);

	std::vector<uchar> buf;
	cv::imencode(".jpg", mat1, buf);
	std::string save_image3 = "b2_2.jpg";
	std::ofstream file2(save_image3.c_str(), std::ios::out | std::ios::binary);
	if (!file2) {
		fprintf(stderr, "open file fail: %s\n", save_image3.c_str());
		return -1;
	}
	file2.write((char*)&buf[0], buf.size()*sizeof(uchar));
	file2.close();

	cv::Mat image1 = cv::imread(save_image, 1);
	cv::Mat image2 = cv::imread(save_image2, 1);
	cv::Mat image3 = cv::imread(save_image3, 1);
	if (!image1.data || !image2.data || !image3.data) {
		fprintf(stderr, "read image fail\n");
		return -1;
	}

	if (image1.rows != image2.rows || image1.cols != image2.cols ||
		image1.rows != image3.rows || image1.cols != image3.cols ||
		image1.step != image2.step || image1.step != image3.step) {
		fprintf(stderr, "their size are different\n");
		return -1;
	}

	for (int h = 0; h < image1.rows; ++h) {
		const uchar* p1 = image1.ptr(h);
		const uchar* p2 = image2.ptr(h);
		const uchar* p3 = image3.ptr(h);

		for (int w = 0; w < image1.cols; ++w) {
			if (p1[w] != p2[w] || p1[w] != p3[w]) {
				fprintf(stderr, "their value are different\n");
				return -1;
			}
		}
	}

	fprintf(stdout, "test image encode/decode, imread/imwrite finish\n");

	return 0;
}

int main()
{
	test_encode_decode();
	std::cout << "hello" << std::endl;
	return 0;
}