initial commit

Author: ibmibmibm

.gitignore

@@ -26,3 +26,7 @@
 *.exe
 *.out
 *.app
+
+# Build environment
+build
+img2bbs

CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR)
+project(img2bbs CXX)
+find_package(OpenCV REQUIRED)
+find_package(Freetype REQUIRED)
+set(CMAKE_BUILD_TYPE Release)
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto")
+set(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -flto")
+add_subdirectory(src)

build.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+[ -d build ] || mkdir build
+cd build
+cmake .. && make -j && cp -fv src/img2bbs ..

src/B2U.txt

@@ -0,0 +1,28 @@
+include_directories(${FREETYPE_INCLUDE_DIRS})
+add_executable(img2bbs
+    img2bbs.cpp
+
+    error.cpp
+    library.cpp
+    face.cpp
+    screen.cpp
+)
+target_compile_features(img2bbs PRIVATE
+    cxx_auto_type
+    cxx_constexpr
+    cxx_decltype
+    cxx_defaulted_functions
+    cxx_defaulted_move_initializers
+    cxx_deleted_functions
+    cxx_explicit_conversions
+    cxx_func_identifier
+    cxx_lambdas
+    cxx_noexcept
+    cxx_nullptr
+    cxx_range_for
+    cxx_rvalue_references
+    cxx_variadic_macros
+    cxx_variadic_templates
+    cxx_template_template_parameters
+)
+target_link_libraries(img2bbs ${OpenCV_LIBS} ${FREETYPE_LIBRARIES})

src/CMakeLists.txt

@@ -0,0 +1,19 @@
+#include "error.hpp"
+
+namespace FT {
+
+const char * Error::what() const noexcept {
+    switch (m_error) {
+
+#undef __FTERRORS_H__
+#define FT_ERRORDEF(e, v, s) \
+        case (e): return (s);
+#define FT_ERROR_START_LIST
+#define FT_ERROR_END_LIST
+#include FT_ERRORS_H
+
+        default: return "unknown";
+    }
+}
+
+} // namespace FT

src/error.cpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include <exception>
+
+namespace FT {
+
+class Error: public std::exception {
+public:
+    Error(FT_Error error) noexcept: m_error(error) {}
+    virtual const char * what() const noexcept;
+private:
+    FT_Error m_error;
+};
+
+} // namespace FT

src/error.hpp

@@ -0,0 +1,118 @@
+#include <iostream>
+#include "face.hpp"
+#include FT_GLYPH_H
+
+namespace FT {
+
+void Face::putText(cv::Mat & img, cv::Point pos, const std::string & text) {
+    FT_Vector pen = {pos.x * 64, pos.y * 64};
+    for (const auto & c: text) {
+        FT_Vector small = {pen.x % 64, pen.y % 64};
+        FT_Set_Transform(m_face, nullptr, &small);
+        auto glyph_index = FT_Get_Char_Index(m_face, c);
+        auto error = FT_Load_Glyph(m_face, glyph_index, FT_LOAD_DEFAULT);
+        if (error) {throw Error(error);}
+        error = FT_Render_Glyph(m_face->glyph, FT_RENDER_MODE_NORMAL);
+        if (error) {throw Error(error);}
+        const auto & glyph = *m_face->glyph;
+        const auto & bitmap = glyph.bitmap;
+        cv::Mat glyph_img(bitmap.rows, bitmap.width, CV_8UC1, bitmap.buffer, bitmap.pitch);
+        cvtColor(glyph_img, glyph_img, CV_GRAY2RGB);
+        glyph_img.convertTo(glyph_img, img.type());
+
+        cv::Mat color = cv::Mat::zeros(bitmap.rows, bitmap.width, img.type());
+        color = cv::Scalar(255, 255, 255);
+
+        cv::Rect roi(cv::Size(pen.x / 64 + glyph.bitmap_left, pen.y / 64 - glyph.bitmap_top), glyph_img.size());
+
+        img(roi) = color.mul(glyph_img, 1.0 / 255.0) + img(roi).mul(cv::Scalar(255, 255, 255) - glyph_img, 1.0 / 255.0);
+
+        pen.x += glyph.advance.x;
+        pen.y += glyph.advance.y;
+    }
+}
+
+void Face::putChar(cv::Mat & img, const cv::Rect & pos, const cv::Point & offset,
+    const cv::Scalar & fgcolor, const cv::Scalar & bgcolor, uint32_t unicode) {
+
+    auto glyph_index = FT_Get_Char_Index(m_face, unicode);
+    auto error = FT_Load_Glyph(m_face, glyph_index, FT_LOAD_DEFAULT);
+    if (error) {throw Error(error);}
+
+    FT_Glyph glyph;
+    error = FT_Get_Glyph(m_face->glyph, &glyph);
+    if (error) {throw Error(error);}
+
+    FT_BBox box;
+    FT_Glyph_Get_CBox(glyph, FT_GLYPH_BBOX_UNSCALED, &box);
+    FT_Done_Glyph(glyph);
+
+    FT_Pos x = (pos.x + offset.x + pos.width / 2) * 64 - (box.xMax - box.xMin) / 2 - box.xMin;
+    FT_Pos y = (pos.y + offset.y + pos.height * 5 / 6) * 64;
+    FT_Vector small = {x % 64, y % 64};
+    FT_Set_Transform(m_face, nullptr, &small);
+
+    // render
+    error = FT_Render_Glyph(m_face->glyph, FT_RENDER_MODE_NORMAL);
+    if (error) {throw Error(error);}
+    const auto & bitmap = m_face->glyph->bitmap;
+    cv::Mat glyph_img(bitmap.rows, bitmap.width, CV_8UC1, bitmap.buffer, bitmap.pitch);
+    cv::Rect roi(cv::Size(x / 64 + m_face->glyph->bitmap_left, y / 64 - m_face->glyph->bitmap_top), glyph_img.size());
+    cv::Rect shrink1 = roi & pos;
+    cv::Rect shrink2(shrink1.tl() - roi.tl(), cv::Point2i(glyph_img.size()) + shrink1.br() - roi.br());
+
+    // crop
+    if (shrink2.area() > 0) {
+        cvtColor(glyph_img(shrink2), glyph_img, CV_GRAY2RGB);
+        glyph_img.convertTo(glyph_img, img.type());
+    }
+
+    cv::Mat bg = cv::Mat::zeros(pos.size(), img.type());
+    bg = bgcolor;
+    bg.copyTo(img(pos));
+
+    if (shrink1.area() > 0) {
+        cv::Mat fg = cv::Mat::zeros(glyph_img.rows, glyph_img.cols, img.type());
+        fg = fgcolor;
+        img(shrink1) = fg.mul(glyph_img, 1.0 / 255.0) + img(shrink1).mul(cv::Scalar(255, 255, 255) - glyph_img, 1.0 / 255.0);
+    }
+}
+
+void Face::putChar(cv::Mat & img, uint32_t unicode) {
+    auto glyph_index = FT_Get_Char_Index(m_face, unicode);
+    auto error = FT_Load_Glyph(m_face, glyph_index, FT_LOAD_DEFAULT);
+    if (error) {throw Error(error);}
+
+    FT_Glyph glyph;
+    error = FT_Get_Glyph(m_face->glyph, &glyph);
+    if (error) {throw Error(error);}
+
+    FT_BBox box;
+    FT_Glyph_Get_CBox(glyph, FT_GLYPH_BBOX_UNSCALED, &box);
+    FT_Done_Glyph(glyph);
+
+    FT_Pos x = (img.cols / 2) * 64 - (box.xMax - box.xMin) / 2 - box.xMin;
+    FT_Pos y = (img.rows * 5 / 6) * 64;
+    FT_Vector small = {x % 64, y % 64};
+    FT_Set_Transform(m_face, nullptr, &small);
+
+    // render
+    error = FT_Render_Glyph(m_face->glyph, FT_RENDER_MODE_NORMAL);
+    if (error) {throw Error(error);}
+    const auto & bitmap = m_face->glyph->bitmap;
+
+    cv::Mat glyph_img(bitmap.rows, bitmap.width, CV_8UC1, bitmap.buffer, bitmap.pitch);
+
+    cv::Rect roi(cv::Point(x / 64 + m_face->glyph->bitmap_left, y / 64 - m_face->glyph->bitmap_top), glyph_img.size());
+    cv::Rect shrink1 = roi & cv::Rect(0, 0, img.cols, img.rows);
+    cv::Rect shrink2(shrink1.tl() - roi.tl(), cv::Point(glyph_img.size()) + shrink1.br() - roi.br());
+
+    // crop
+    if (shrink2.area() == 0) {
+        return;
+    }
+    cvtColor(glyph_img(shrink2), glyph_img, CV_GRAY2RGB);
+    glyph_img.convertTo(img(shrink1), img.type());
+}
+
+} // namespace FT

src/face.cpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <string>
+#include <memory>
+#include <opencv2/imgproc.hpp>
+#include "error.hpp"
+
+namespace FT {
+
+class Face: public std::shared_ptr<Face> {
+public:
+    Face(FT_Face face) noexcept(false): m_face(face) {
+        auto error = FT_Set_Char_Size(m_face, 0, 20 * 64, 96, 96);
+        if (error) {throw Error(error);}
+    }
+    ~Face() noexcept {FT_Done_Face(m_face);}
+    void putText(cv::Mat & img, cv::Point org, const std::string & text);
+    void putChar(cv::Mat & img, const cv::Rect & pos, const cv::Point & offset,
+        const cv::Scalar & fgcolor, const cv::Scalar & bgcolor, uint32_t unicode);
+    void putChar(cv::Mat & img, uint32_t unicode);
+private:
+    FT_Face m_face;
+};
+
+} // namespace FT

src/face.hpp

@@ -0,0 +1,63 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgcodecs/imgcodecs_c.h>
+#include <opencv2/imgproc.hpp>
+#include "library.hpp"
+#include "screen.hpp"
+
+namespace {
+
+static thread_local std::mt19937 rd(time(NULL));
+static thread_local std::uniform_int_distribution<size_t> gen_idx(0, 99);
+
+cv::Mat normalize(cv::Mat &src) {
+    src.convertTo(src, CV_64FC3);
+    cv::Mat dst = cv::Mat::zeros(23 * kCharH, 80 * kCharW, src.type());
+    cv::Rect roi;
+    if (src.cols * dst.rows > src.rows * dst.cols) {
+        roi.width = dst.cols;
+        roi.x = 0;
+        roi.height = src.rows * dst.cols / src.cols;
+        roi.y = (dst.rows - roi.height) / 2;
+    } else if (src.cols * dst.rows < src.rows * dst.cols) {
+        roi.height = dst.rows;
+        roi.y = 0;
+        roi.width = src.cols * dst.rows / src.rows;
+        roi.x = (dst.cols - roi.width) / 2;
+    } else {
+        roi.x = 0;
+        roi.y = 0;
+        roi.width = dst.cols;
+        roi.height = dst.rows;
+    }
+    resize(src, dst(roi), roi.size(), 0, 0, cv::INTER_LANCZOS4);
+    return std::move(dst);
+}
+
+} // namespace
+
+int main(int argc, char *argv[]) {
+    if (argc != 4) return -1;
+
+    cv::Mat src = cv::imread(argv[1]);
+    src = normalize(src);
+
+    Screen::init();
+
+    auto s = std::make_shared<Screen>(src);
+    //s->sample();
+    s->best();
+    cv::Mat dst;
+    s->render(dst);
+
+    std::cout << *s << std::endl;
+    std::cout << s->psnr << std::endl;
+
+    imwrite(argv[2], dst);
+
+    std::ofstream fs(argv[3], std::ios::binary);
+    fs << s->to_string();
+    return 0;
+}

src/img2bbs.cpp

@@ -0,0 +1,15 @@
+#include "face.hpp"
+#include "library.hpp"
+
+namespace FT {
+
+std::shared_ptr<Face> Library::new_face(const char * filepathname, FT_Long face_index) noexcept(false) {
+    FT_Face face;
+    auto error = FT_New_Face(m_lib, filepathname, face_index, &face);
+    if (error) {
+        throw Error(error);
+    }
+    return std::make_shared<Face>(face);
+}
+
+} // namespace FT

src/library.cpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <memory>
+#include "error.hpp"
+
+namespace FT {
+
+class Face;
+
+class Library {
+public:
+    Library() noexcept(false) {
+        auto error = FT_Init_FreeType(&m_lib);
+        if (error) {
+            throw Error(error);
+        }
+    }
+    ~Library() noexcept {FT_Done_FreeType(m_lib);}
+    Library(const Library&) = delete;
+    Library& operator=(const Library&) = delete;
+    std::shared_ptr<Face> new_face(const char * filepathname, FT_Long face_index) noexcept(false);
+private:
+    FT_Library m_lib;
+};
+
+} // namespace FT