#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
using namespace cv;
namespace opencv
{
namespace image
{
// read file content to buffer
char* file_read_all(string path, int& size)
{
std::ifstream fin(path, std::ios::binary); if (!fin) { std::cerr << "open failed: " << path << std::endl; }
fin.seekg(0, fin.end); size = fin.tellg(); fin.seekg(0, fin.beg); std::cout << "file size: " << size << std::endl;
char* buf = new char[size]; fin.read(buf, size); return buf;
}
class ImageProcessor
{
public:
string path; // image file path
int size=-1; // file size
char* buf=0; // file content buffer
int bytes_per_pixel = -1; // buf中每个像素点的字节数
int type = -1; // buf中图片的格式，比如16UC1
int bits = 16;
Mat img; // 原始图片
int w=-1; // 原始图片的宽
int h=-1; // 原始图片的高
int pixel_count = 0; // 原始图片的像素个数
uint8_t pixel_average = 0; // 原始图片的像素平均值
Mat resizedImg; // 从原始图片resize后得到的图片，其像素值保持原始值不变
int w_resize = -1; // resizedImg的宽
int h_resize = -1; // resizedImg的高
int pixel_count_resize = 0; // resizedImg的像素点个数
Mat rotatedImg; // 从resizedImg旋转后得到的图片，其像素值保持原始值不变
double rotate_angle=0.0f; // 旋转角度
int w_rotate = -1; // rotatedImg的宽
int h_rotate = -1; // rotatedImg的高
Mat nowImg; // 当前图片，以rotatedImg为基础，改变像素值得到，其像素值随时可以改变
int w_now = -1; // rotatedImg的宽
int h_now = -1; // rotatedImg的高
float bright_now = 1.0f; // nowImg的亮度相对于原始图片亮度的比率
float contrast_now = 1.0f; // nowImg的对比度相对于原始图片的比率
const uint8_t BestBright = 200; // 最佳亮度，将nowImg的像素平均值调到这个值，即为最佳亮度
float U16Const;
const float BrightConst = 255.0f / 20000.0f;
const float BrightConst2 = 20000.0f / 255.0f;
const float ContrastConst = 0.9f / 10000.0f;
const float ContrastConst1 = 9.0f / 10000.0f;
const float ContrastConst2 = 10000.0f / 0.9f;
const float ContrastConst3 = 10000.0f / 9.0f;
ImageProcessor(int bits = 16): bits(bits) { U16Const = 255.0f / (pow(2, bits) - 1); }
ImageProcessor(string path, int bits=16) : path(path), bits(bits) { U16Const = 255.0f / (pow(2, bits) - 1); }
~ImageProcessor() { if (buf) delete[] buf; }
// 解析raw, type==-1时由程序自动检测type值，否则使用指定的type值
void parse_raw()
{
pixel_count = w * h; img = Mat::zeros(cv::Size(w, h), CV_8UC1);
buf = file_read_all(path, size); if (size <= 0) { printf("file size error: %d\n", size); return; } if (buf == 0) { printf("file content error\n"); return; }
bytes_per_pixel = size / pixel_count; if(bytes_per_pixel* pixel_count!=size) { printf("file size %d is not multiple times of pixel count %d.\n", size, pixel_count); delete[] buf; buf = 0; return; }
printf("bytes for each pixel is %d\n", bytes_per_pixel);
if (type == -1) { if (bytes_per_pixel == 2) { type = CV_16UC1; } else if (bytes_per_pixel == 3) type = CV_8UC3; else if (bytes_per_pixel == 4) type = CV_8UC4; else if (bytes_per_pixel == 1) type = CV_8UC1; }
if (type != CV_16UC1 && type != CV_16SC1) { printf("unknown type for %d bytes per pixel.\n", bytes_per_pixel); delete[] buf; buf = 0; return; }
w_resize = w; h_resize = h;
fresh_raw();
}
void init_raw()
{
pixel_count = w * h; img = Mat::zeros(cv::Size(w, h), CV_8UC1);
buf = (char*)(new uint16_t[pixel_count]);
w_resize = w; h_resize = h;
}
void fresh_raw(bool reset=false)
{
//LARGE_INTEGER t1, t2, tc; QueryPerformanceFrequency(&tc); QueryPerformanceCounter(&t1);
if (reset) { w_resize = w; h_resize = h; rotate_angle = 0.0f; bright_now = 1.0f; contrast_now = 1.0f; }
Mat img16 = Mat(cv::Size(w, h), type, buf); auto data = (uint8_t*)img.data; auto data16 = (uint16_t*)img16.data;
if (type == CV_16UC1) { for (int i = 0; i < pixel_count; i++) { *data = (uint8_t)(*data16 * U16Const); data++; data16++; } }
else if (type == CV_16SC1) { for (int i = 0; i < pixel_count; i++) { *data = (uint8_t)(((int)(*(int16_t*)data16) + 32768) * U16Const); data++; data16++; } }
pixel_average = get_pixel_average(img, pixel_count);
resize(w_resize, h_resize);
//QueryPerformanceCounter(&t2); auto time = (double)(t2.QuadPart - t1.QuadPart) / (double)tc.QuadPart; cout << "time = " << time << " seconds" << endl;
}
// 调整图片大小
void resize(int w, int h)
{
if (w == this->w && h == this->h) img.copyTo(resizedImg); else cv::resize(img, resizedImg, Size(w, h), 0, 0, INTER_AREA);
w_resize = resizedImg.cols; h_resize = resizedImg.rows; pixel_count_resize = w_resize * h_resize;
rotate(rotate_angle);
}
// rate是相对于原始图片大小的比率
void resize(float rate)
{
resize(w*rate, h*rate);
}
// 旋转, mode=1时自动扩展图片尺寸以包含全部图片信息，mode=0时保持原来的图片尺寸，部分图片信息会在旋转后丢失
void rotate(double angle, int mode=1)
{
rotate_angle = angle;
if (angle == 0.0) { w_rotate = w_resize; h_rotate = h_resize; resizedImg.copyTo(rotatedImg); }
else
{
if (mode == 0)
{
cv::Point2f center((w_resize - 1) / 2.0, (h_resize - 1) / 2.0);
cv::Mat rot = cv::getRotationMatrix2D(center, angle, 1.0);
w_rotate = w_resize; h_rotate = h_resize;
cv::warpAffine(resizedImg, rotatedImg, rot, Size(w_rotate, h_rotate));
}
else
{
double alpha = -angle * CV_PI / 180.0;
cv::Point2f srcP[3], dstP[3];
srcP[0] = cv::Point2f(0, h_resize); srcP[1] = cv::Point2f(w_resize, 0); srcP[2] = cv::Point2f(w_resize, h_resize);
for (int i = 0; i < 3; i++) dstP[i] = cv::Point2f(srcP[i].x * cos(alpha) - srcP[i].y * sin(alpha), srcP[i].y * cos(alpha) + srcP[i].x * sin(alpha));
double minx, miny, maxx, maxy;
minx = std::min(std::min(std::min(dstP[0].x, dstP[1].x), dstP[2].x), float(0.0));
miny = std::min(std::min(std::min(dstP[0].y, dstP[1].y), dstP[2].y), float(0.0));
maxx = std::max(std::max(std::max(dstP[0].x, dstP[1].x), dstP[2].x), float(0.0));
maxy = std::max(std::max(std::max(dstP[0].y, dstP[1].y), dstP[2].y), float(0.0));
w_rotate = maxx - minx; h_rotate = maxy - miny;
for (int i = 0; i < 3; i++) { if (minx < 0) dstP[i].x -= minx; if (miny < 0) dstP[i].y -= miny; }
cv::Mat warpMat = cv::getAffineTransform(srcP, dstP);
cv::warpAffine(resizedImg, rotatedImg, warpMat, cv::Size(w_rotate, h_rotate));
}
}
w_now = w_rotate; h_now = h_rotate;
rotatedImg.copyTo(nowImg); set_brightness_contrast(bright_now, contrast_now);
}
// 将亮度设置为原始图片的bright倍, 对比度设为原始图片的contrast倍
void set_brightness_contrast(float bright, float contrast)
{
float diff = bright - contrast;
auto buf_now = (uint8_t*)nowImg.data; auto buf2 = (uint8_t*)rotatedImg.data; float nowf;
for (int i = 0; i < pixel_count_resize; i++)
{
nowf = *buf2 * contrast + pixel_average*diff; *buf_now = saturate_cast(nowf); buf_now++; buf2++;
}
bright_now = bright; contrast_now = contrast;
}
// bright和contrast的取值范围均为0-20000
void set_brightness_contrast(int bright, int contrast)
{
set_brightness_contrast(get_brightf(bright), get_contrastf(contrast));
}
// 将当前图片的亮度和对比度调到最佳
void set_brightness_and_contrast_to_best()
{
float bright = 1.0f * BestBright / pixel_average; float contrast = (bright > 1.0f ? bright : 1.0f / bright);
set_brightness_contrast(bright, contrast);
}
// 获取图片的像素平均值, pc为像素点个数
uint8_t get_pixel_average(Mat& mat, int pc)
{
uint64_t sum = 0; auto buf2 = (uint8_t*)mat.data;
for (int i = 0; i < pc; i++)
{
sum += *(buf2++);
}
uint8_t pixel_average = sum / (uint64_t)pixel_count; // printf("pixel average is %u\n", pixel_average);
return pixel_average;
}
// 当前亮度值，范围0-20000
int bright() { return bright_now * pixel_average * BrightConst2; }
// 当前对比度，范围0-20000
int contrast()
{
if (contrast_now <= 1.0f) return (contrast_now - 0.1) * ContrastConst2; else return (contrast_now - 1) * ContrastConst3 + 10000.0f;
}
// 将0-20000的亮度值转为对原始图片亮度值的比率
float get_brightf(int bright)
{
return bright * BrightConst / pixel_average;
}
// 将0-20000的对比度转为对原始图片对比度的比率
float get_contrastf(int contrast)
{
float contrast_f; int contrast2 = contrast - 10000;
if (contrast2 == 0) return 1.0f;
else if (contrast2 > 0) return contrast2 * ContrastConst1 + 1.0f;
else { return 0.1 + contrast * ContrastConst; }
}
};
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）