image.cpp

浏览该文件的文档.

/*
 * @Description: 图像类 实现
 * @Version:
 * @Autor: dreamy-xay
 * @date: 2023-12-17
 * @LastEditors: dreamy-xay
 * @LastEditTime: 2024-05-28
 */
 
#include "common/feature/image.h"
 
namespace cm {
 
Image::Image() : cv::Mat() {}
 
Image::Image(const cv::Mat& image) : cv::Mat(image) {}
 
Image::Image(const Image& image) : cv::Mat(image){};
 
Image::~Image() {}
 
cv::Size Image::Size() const {
    return cv::Size(this->cols, this->rows);
}
 
Image& Image::Resize(size_t width, size_t height, int interpolation) {
    // 如果宽高不变则不缩放
    if (cols == width && rows == height)
        return *this;
 
    if (cols > width && rows > height)  // 缩小
        cv::resize(*this, *this, cv::Size(width, height), 0, 0, cv::INTER_AREA);
    else  // 不确定
        cv::resize(*this, *this, cv::Size(width, height), 0, 0, interpolation);
 
    return *this;
}
 
Image& Image::Resize(size_t max_size, ResizeType resize_type) {
    if ((resize_type == RT_AUTO) || (resize_type == RT_ZOOM_IN && (rows < max_size && cols < max_size)) || (resize_type == RT_ZOOM_OUT && (rows > max_size || cols > max_size))) {
        size_t width;   // 新图像宽度
        size_t height;  // 新图像高度
 
        if (rows > cols) {  // 高大于宽
            width = cols * max_size / rows;
            height = max_size;
        } else {  // 其他情况
            width = max_size;
            height = rows * max_size / cols;
        }
 
        // resize
        this->Resize(width, height);
    }
 
    return *this;
}
 
Image& Image::Scale(double factor, int interpolation) {
    return this->Resize(factor * cols, factor * rows, interpolation);
}
 
Image& Image::RmRedBlueStamp(uchar bg_gray_value) {
    Cm_Assert(this->channels() == 3, "this image is a three-channel image!!!");
 
    if (this->empty())
        return *this;
 
    std::vector<cv::Mat> channels;
    cv::split(*this, channels);
 
    cv::Mat& image_red_channel = channels[2];
    cv::Mat& image_green_channel = channels[1];
    cv::Mat& image_blue_channel = channels[0];
 
    // 删除红色印章
    Image::AdjustImageByGrayImage(image_red_channel, image_green_channel, bg_gray_value, {20, 100, 100});
    image_blue_channel = ~((~image_blue_channel) & (~image_red_channel));
    image_green_channel = ~((~image_green_channel) & (~image_red_channel));
 
    // 删除蓝色印章
    Image::AdjustImageByGrayImage(image_blue_channel, image_green_channel & image_red_channel, bg_gray_value, {0, 150, 255});
    image_red_channel = ~((~image_red_channel) & (~image_blue_channel));
    image_green_channel = ~((~image_green_channel) & (~image_blue_channel));
 
    // 删除印章残留的绿色
    Image::AdjustImageByGrayImage(image_green_channel, image_red_channel & image_blue_channel, bg_gray_value, {0, 255, 255});
    image_red_channel = ~((~image_red_channel) & (~image_green_channel));
    image_blue_channel = ~((~image_blue_channel) & (~image_green_channel));
 
    // 将三通道合并为一根通道并且返回给image
    cv::merge(channels, *this);  // 合并通道
 
    return *this;
}
 
Image& Image::RmRedStamp(uchar bg_gray_value) {
    Cm_Assert(this->channels() == 3, "this image is a three-channel image!!!");
 
    if (this->empty())
        return *this;
 
    std::vector<cv::Mat> channels;
 
    cv::split(*this, channels);
 
    Image::AdjustImageByGrayImage(channels[2], channels[1], bg_gray_value, {20, 100, 100});
 
    channels[0] = ~((~channels[0]) & (~channels[2]));
    channels[1] = ~((~channels[1]) & (~channels[2]));
 
    // 合并三个通道得到最终的图像
    cv::merge(channels, *this);
 
    return *this;
}
 
double Image::AdjustImageByGrayImage(cv::Mat& image, const cv::Mat& gray_image, uchar bg_gray_value, const std::vector<uchar>& thresholds) {
    if (image.empty() || gray_image.empty())
        return 0;
 
    Cm_Assert(image.channels() == 1, "the image is a single channel image!!!");
    Cm_Assert(gray_image.channels() == 1, "the grayscale image is a single channel image!!!");
    Cm_Assert(image.rows == gray_image.rows && image.cols == gray_image.cols, "the image and the grayscale map must be the same size!!!");
 
    int num_nonzero = 0;
 
    cv::Mat result_image1, result_image2, result_image3;
 
    cv::Mat compare_image(image.size(), image.type(), thresholds[0]);
    cv::compare(image - gray_image, compare_image, result_image1, cv::CMP_GT);
 
    compare_image = thresholds[1];
    cv::compare(image, compare_image, result_image2, cv::CMP_GE);
 
    compare_image = thresholds[2];
    cv::compare(gray_image, compare_image, result_image3, cv::CMP_GE);
 
    cv::multiply(result_image2 + result_image3, result_image1, result_image1);
 
    threshold(result_image1, result_image1, 0, bg_gray_value, 0);
    threshold(result_image1, result_image2, 0, 1, 0);
 
    cv::multiply(image, result_image2, result_image2);
    num_nonzero = cv::countNonZero(result_image2);
 
    cv::multiply(image, 1 - result_image2, image);
    image += result_image1;
 
    // 计算平均灰度
    if (num_nonzero != 0)
        return (sum(result_image2)[0] / num_nonzero);
    else
        return cv::mean(image).val[0];  // 返回图像均值
}
 
Image& Image::HorizontalLengthSmooth(int threshold) {
    Cm_Assert(this->channels() == 1, "the image is a single channel image!!!");
 
    if (this->empty())
        return *this;
 
    // 图像本身
    auto& this_image = *this;
 
    // 先归一化
    this_image /= 255;
 
    // 遍历所有行
    for (size_t row = 0; row < rows; ++row) {
        uchar* row_ptr = this->ptr<uchar>(row);  // 二值图行指针（加速索引）
 
        size_t cursor_start = 0;  // 游程开始
        size_t cursor_end = 0;    // 游程结束
 
        // 遍历每一行的所有像素
        while (cursor_end < cols) {
            // 如果当前像素为黑色
            if (row_ptr[cursor_start] == 0) {
                cursor_end = cursor_start + 1;
 
                // 查找连续的非纯白色像素，计算游程长度
                while (cursor_end < cols && row_ptr[cursor_end] != 1)
                    ++cursor_end;
 
                // 如果游程长度小于等于阈值，则将这些黑色像素全部变成白色
                if (cursor_end - cursor_start <= threshold)
                    while (cursor_start < cursor_end) {
                        row_ptr[cursor_start] = 1;
                        ++cursor_start;
                    }
 
                cursor_start = cursor_end;  // 更新游程开始坐标
            } else {
                // 游程开始和结束自增
                ++cursor_start;
                ++cursor_end;
            }
        }
    }
 
    // 再重归一化状态恢复
    this_image *= 255;
 
    return this_image;
}
 
Rects Image::GetTextAreaOutline(size_t dilate_size, double max_aspect_ratio) const {
    Cm_Assert(this->channels() == 1, "the image is a single channel image!!!");
 
    // 当图像为空时返回空列表
    if (this->empty())
        return {};
 
    // 文本区域矩形轮廓列表
    Rects text_areas;
 
    // 膨胀图像
    cv::Mat dilate_img;
 
    // Dilate to connect text together
    if (dilate_size >= 1) {
        cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(dilate_size, 1));
        cv::dilate(*this, dilate_img, kernel);
    } else
        dilate_img = *this;
 
    // Contours detect
    std::vector<std::vector<cv::Point>> contours;
    cv::findContours(dilate_img, contours, cv::RETR_TREE, cv::CHAIN_APPROX_NONE);
 
    for (auto& contour : contours) {
        // Obtain minimal bounding rectangle of contour
        cv::Rect rect = boundingRect(contour);
 
        double aspect_ratio = double(rect.width) / rect.height;  // Ratio of width to height
 
        if (aspect_ratio <= max_aspect_ratio && rect.height > 1)
            text_areas.emplace_back(rect);
    }
 
    return std::move(text_areas);
}
 
Lines Image::GetLines(LineType line_type, const ImagePreprocessor& imp, int threshold, double min_line_length, double max_line_gap) const {
    if (this->empty())  // 如果图像为空，则返回空
        return {};
 
    // 二值图
    cv::Mat binary_image = std::move(imp.Preprocess(*this));
 
    // 线列表
    std::vector<cv::Vec4i> lines;
 
    // 通过霍夫变换获取线列表
    cv::HoughLinesP(binary_image, lines, 1, CV_PI / 360, threshold, min_line_length, max_line_gap);
 
    // 过滤指定类型线并返回
    return std::move(cm::Lines(lines).Filter([line_type](const cm::Line& line) { return line.Type() == line_type && !line.IsPoint(); }));
}
 
Image& Image::ModifyLinesAreaValue(LineType line_type, const Lines& lines, int pixel_margin, uchar pixel_value) {
    if (this->empty() || lines.empty())
        return *this;
 
    Cm_Assert(this->channels() == 1, "the image is a single channel image!!!");
 
    switch (line_type) {
        case HLINE: {
            // 断言查看所有线是否都是指定线类型
            Cm_Assert(lines.Filter([line_type](const cm::Line& line) { return line.Type() == line_type; }).size() == lines.size(), Sprintf("The line type in the line list must all be \"%s\"!!!", line_type == HLINE ? "cm::HLINE" : "cm::VLINE"));
 
            Interval row_range(0, rows);
            Interval iter_interval;
            cv::Point point;
 
            for (auto& line : lines) {
                cv::LineIterator line_iter(*this, line.pt1, line.pt2);  // 迭代整条横线
 
                for (int i = 0; i != line_iter.count; ++i, ++line_iter) {
                    point = line_iter.pos();  // 获取线当前点坐标
 
                    iter_interval = row_range.Intersect({point.y - pixel_margin, point.y + pixel_margin + 1});
 
                    for (int y = iter_interval.start; y < iter_interval.end; ++y)  // 横线上下两边像素也修改值
                        this->at<uchar>(y, point.x) = pixel_value;
                }
            }
 
            break;
        }
        case VLINE: {
            // 断言查看所有线是否都是指定线类型
            Cm_Assert(lines.Filter([line_type](const cm::Line& line) { return line.Type() == line_type; }).size() == lines.size(), Sprintf("The line type in the line list must all be \"%s\"!!!", line_type == HLINE ? "cm::HLINE" : "cm::VLINE"));
 
            Interval col_range(0, cols);
            Interval iter_interval;
            cv::Point point;
 
            for (auto& line : lines) {
                cv::LineIterator line_iter(*this, line.pt1, line.pt2);  // 迭代整条竖线
 
                for (int i = 0; i != line_iter.count; ++i, ++line_iter) {
                    point = line_iter.pos();  // 获取线当前点坐标
 
                    iter_interval = col_range.Intersect({point.x - pixel_margin, point.x + pixel_margin + 1});
 
                    for (int x = iter_interval.start; x < iter_interval.end; ++x)  // 竖线左右两边像素也修改值
                        this->at<uchar>(point.y, x) = pixel_value;
                }
            }
 
            break;
        }
        case ULINE: {
            // 横线列表和竖线列表
            Lines hlines, vlines;
 
            // 分类横竖线
            lines.ClassifyLines(hlines, vlines);
 
            // 横线列表和竖线列表分别修改值
            this->ModifyLinesAreaValue(HLINE, hlines, pixel_margin, pixel_value);
            this->ModifyLinesAreaValue(VLINE, vlines, pixel_margin, pixel_value);
 
            break;
        }
        default:
            throw Exception("The type(LineType) of param \"line_type\" is incorrect!");
    }
 
    return *this;
}
 
Image Image::InvertColorRegion(double min_area) const {
    Image result_image = this->clone();
 
    if (this->empty())
        return std::move(result_image);
 
    cv::Mat binary_image;
 
    // 获取灰度图
    cv::cvtColor(result_image, binary_image, cv::COLOR_BGR2GRAY);
 
    // 通过OTSU算法获取二值图
    cv::threshold(binary_image, binary_image, 0, 255, cv::THRESH_BINARY_INV | cv::THRESH_OTSU);
 
    // 找到所有白色块轮廓
    std::vector<std::vector<cv::Point>> contours;
    cv::findContours(binary_image, contours, cv::RETR_TREE, cv::CHAIN_APPROX_NONE);
 
    // 在新的图像上绘制轮廓所组成的封闭区域
    cv::Mat mask(result_image.size(), CV_8UC1, cv::Scalar(0, 0, 0));
    int effective_area_count = 0;
    for (int i = 0; i < contours.size(); ++i) {
        // 计算轮廓面积
        double area = cv::contourArea(contours[i]);
        // 有较大白色块的区域
        if (area >= min_area) {
            ++effective_area_count;
            cv::drawContours(mask, contours, i, cv::Scalar(255, 255, 255), cv::FILLED);
        }
    }
 
    // 如果存在有效区域图像
    if (effective_area_count) {
        // 原图像掩膜区域重置为黑底
        result_image.setTo(cv::Scalar(0, 0, 0), mask);
        // 将二值图像转换为三通道 RGB 彩色图像
        cv::Mat rgb_image;
        cv::cvtColor(binary_image, rgb_image, cv::COLOR_GRAY2RGB);
        // 掩膜区域反转色
        cv::bitwise_or(result_image, rgb_image, result_image, mask);
    }
 
    return std::move(result_image);
}
 
Image Image::SeparateColor(SeparatedColorType type) const {
    Cm_Assert(this->channels() == 3, "the image must be an RGB three-channel image!!!");
 
    // hsv图
    cv::Mat hsv_image;
 
    // bgr 转 hsv
    cv::cvtColor(*this, hsv_image, CV_BGR2HSV);
 
    cv::Mat result_image;  // 结果图像
    cv::Mat temp_image;    // 临时图像
 
    switch (type) {
        case SCT_BLUE:
            cv::inRange(hsv_image, cv::Scalar(100, 43, 46), cv::Scalar(124, 255, 255), result_image);  // 阈值分割
            break;
        case SCT_RED:
            cv::inRange(hsv_image, cv::Scalar(0, 43, 46), cv::Scalar(10, 255, 255), result_image);  // 阈值分割
            cv::inRange(hsv_image, cv::Scalar(156, 43, 46), cv::Scalar(180, 255, 255), temp_image);
            result_image += temp_image;
            break;
        case SCT_BLACK:
            cv::inRange(hsv_image, cv::Scalar(0, 0, 0), cv::Scalar(180, 255, 180), result_image);  // 阈值分割
            break;
        default:
            break;
    }
 
    return std::move(result_image);
}
 
Image Image::GetGrayHistogram() const {
    Cm_Assert(this->channels() == 1, "the image is a single channel image!!!");
 
    Image histogram;  // 直方图
 
    if (this->empty())
        return histogram;
 
    cv::Mat this_image = *this;  // 图像本身
 
    int hist_size = 256;  // 直方图的大小
    float range[] = {0, 256};
    const float* hist_range = {range};
    // 计算灰度直方图
    cv::calcHist(&this_image, 1, nullptr, cv::Mat(), histogram, 1, &hist_size, &hist_range);
 
    return std::move(histogram);
}
 
}  // namespace cm