...
#include "aabb.h"
...

class hittable_list : public hittable {
    public:
        ...
        virtual bool hit(
            const ray& r, double t_min, double t_max, hit_record& rec) const override;

        //包围盒生成函数
        virtual bool bounding_box(
            double time0, double time1, aabb& output_box) const override;
    ...
};

...
bool hittable_list::bounding_box(double time0, double time1, aabb& output_box) const {
    //如果物体列表为空，我们无法为空物体生成包围盒，直接返回false。
    if (objects.empty()) return false;

    aabb temp_box;
    //设定一个flag用来初始化一个包围盒。
    bool first_box = true;
    //遍历列表内物体。
    for (const auto& object : objects) {
        //如果遍历刀列表内有物体无法建立包围盒（返回fasle），那对不起，物体列表也无能为力了，直接返回。
        //注意，这个if中的bounding_box函数把这个子物体的包围盒赋给了temp_box。
        if (!object->bounding_box(time0, time1, temp_box)) return false;
        //如果是第一次建立包围盒，那直接使用temp_box。
        //否则要求本循环子物体的aabb和之前包围盒的包围盒，使用surrounding_box函数。
        output_box = first_box ? temp_box : surrounding_box(output_box, temp_box);
        //在首次建立包围盒成功之后，把first_box置false。
        first_box = false;
    }

    return true;
}

#ifndef BVH_H
#define BVH_H

#include "rtweekend.h"

#include "hittable.h"
#include "hittable_list.h"

//这个节点类是物体类的子类，我们还是得依靠多态的便利性。
class bvh_node : public hittable {
    public:
        bvh_node();
        //这是传入物体列表的构造，直接调用下面的有vector的构造。
        bvh_node(const hittable_list& list, double time0, double time1)
            : bvh_node(list.objects, 0, list.objects.size(), time0, time1)
        {}
        //这个构造函数非常复杂，之后再说。
        bvh_node(
            const std::vector<shared_ptr<hittable>>& src_objects,
            size_t start, size_t end, double time0, double time1);
        
        //override hit函数。
        virtual bool hit(
            const ray& r, double t_min, double t_max, hit_record& rec) const override;
        
        //生成包围盒的函数
        virtual bool bounding_box(double time0, double time1, aabb& output_box) const override;

    public:
        //本节点的左右子节点指针，它们都是物体类型的指针。
        shared_ptr<hittable> left;
        shared_ptr<hittable> right;
        //本节点的包围盒，会在构造函数里生成。
        aabb box;
};

//注意，bvh节点类的包围盒我们会在构造函数里生成，这里直接赋值即可。
bool bvh_node::bounding_box(double time0, double time1, aabb& output_box) const {
    output_box = box;
    return true;
}

#endif

bool bvh_node::hit(const ray& r, double t_min, double t_max, hit_record& rec) const {
    //你连我的盒子都碰不到，那我们就没有继续看下去的必要了。
    if (!box.hit(r, t_min, t_max))
        return false;
    
    //继续遍历左右物体。
    bool hit_left = left->hit(r, t_min, t_max, rec);
    
    //见下方讲解。
    bool hit_right = right->hit(r, t_min, hit_left ? rec.t : t_max, rec);
    
    //遍历过程中只要不是所有的子物体都没碰到，就算产生了碰撞。
    return hit_left || hit_right;
}

#include <algorithm>
...

bvh_node::bvh_node(
    const std::vector<shared_ptr<hittable>>& src_objects,
    size_t start, size_t end, double time0, double time1
) {
    //创建一个指针指向形参中的物体列表，增加代码可读性。
    auto objects = src_objects; 
    //随机一个int值，0，1，2分别代表x，y，z轴，这个函数之后会给出。
    int axis = random_int(0,2);
    //通过选定的是哪个坐标轴选到特定的比较器，注意，这个comparator是一个函数指针
    //之后会给出box_x_compare等三个函数的签名即具体函数体。
    auto comparator = (axis == 0) ? box_x_compare
                    : (axis == 1) ? box_y_compare
                                  : box_z_compare;
    //本列表中有多少物体？
    size_t object_span = end - start;
    //如果发现这个列表中只有一个物体了，那令本节点的左右孩子指针都指向这个物体。
    if (object_span == 1) {
        left = right = objects[start];
    }
    //如果有俩物体，按照给定轴信息，看看谁在左，谁在右。
    else if (object_span == 2) {
        if (comparator(objects[start], objects[start+1])) {
            left = objects[start];
            right = objects[start+1];
        } else {
            left = objects[start+1];
            right = objects[start];
        }
    }
    //如果本段物体列表有超过两个物体，直接对其进行排序，并且二分之后，开启下一轮递归。
    else {
        std::sort(objects.begin() + start, objects.begin() + end, comparator);
        //二分找中值。
        auto mid = start + object_span/2;
        left = make_shared<bvh_node>(objects, start, mid, time0, time1);
        right = make_shared<bvh_node>(objects, mid, end, time0, time1);
    }
    
    //注意，代码运行到这里，说明本节点的左右孩子递归代码都已经执行完毕。是时候给他们套上包围盒了。
    aabb box_left, box_right;
    //给左右节点分别套盒子，并且利用返回信息来判断盒子是否成功生成。
    if (  !left->bounding_box (time0, time1, box_left)
       || !right->bounding_box(time0, time1, box_right)
    )
        //进入这个if表示左右孩子的某个盒子没有生成成功。
        std::cerr << "No bounding box in bvh_node constructor.\n";
    //注意，这里有一个bug，如果bouding_box返回false,其box一定是没有被赋值的，即为空。
    //空box调用下面的surrounding_box函数是会出错的，因为访问了空物体。
    //我们暂时没有无法生成包围盒的物体，如：无限大的平面。所以这个问题我们先不要管。
    box = surrounding_box(box_left, box_right);
}

inline int random_int(int min, int max) {
    // 返回[min,max]范围内int值。
    return static_cast<int>(random_double(min, max+1));
}

//比较两个物体的盒子“大小”的主要函数，第三个参数axis表示比较的是哪个轴。
inline bool box_compare(const shared_ptr<hittable> a, const shared_ptr<hittable> b, int axis) {
    aabb box_a;
    aabb box_b;
    //先求两个物体的盒子。
    if (!a->bounding_box(0,0, box_a) || !b->bounding_box(0,0, box_b))
        std::cerr << "No bounding box in bvh_node constructor.\n";
    //比较两个盒子的较小的边，谁的给定轴分量越大，谁就越大。
    return box_a.min().e[axis] < box_b.min().e[axis];
}

//下面是三个轴比较函数，都是调用上面的比较函数。这三个函数存在的意义是方便构造函数中的函数指针。

bool box_x_compare (const shared_ptr<hittable> a, const shared_ptr<hittable> b) {
    return box_compare(a, b, 0);
}

bool box_y_compare (const shared_ptr<hittable> a, const shared_ptr<hittable> b) {
    return box_compare(a, b, 1);
}

bool box_z_compare (const shared_ptr<hittable> a, const shared_ptr<hittable> b) {
    return box_compare(a, b, 2);
}

#if !MULTITHREAD

...
//需要引用此头文件
#include <windows.h>

...
int main() {
    //这个函数可以获取当前时间，并转换成某种基于毫秒的整数。
    auto start = GetTickCount64();
    
    //main中的全部代码都要被包进来。
    ...
    
    std::cerr << "\nDone.\n";
    //再次获得当前时间，并且减去main函数开头时记录的时间，便得到了毫秒差。
    int time = GetTickCount64() - start;
    time = time / 1000;
    auto minute = time / 60;
    auto second = time % 60;
    //简单转换一下，并输出出去。
    std::cerr << "took " << minute << "m " << second <<"s  to complete. \n";
}

}

//调用函数生成一个有着许多随机小球的场景！！！
//auto world = random_scene();
auto world = bvh_node(random_scene(),0,1);

if (光线碰到了某个立方体)
    if(光线碰到了子立方体1号){
        if(光线碰到了子立方体1号内的某个物体){
            处理碰撞信息。
            return true;
        }
    }
    else if(光线碰到了子立方体2号){
        ...
    }
    ...
    else if(光线碰到了子立方体7号){
        ...
    }
    else{
        ...
    }
else
    return false

compute (tx0, tx1)
compute (ty0, ty1)
compute (tz0, tz1)
//返回这三个时间段有无重叠
return overlap?( (tx0, tx1), (ty0, ty1), (tz0, tz1))

bool overlap(a, b, c, d)
    f = max(a, c)
    F = min(b, d)
    return (f < F)

#ifndef AABB_H
#define AABB_H

#include "rtweekend.h"

class aabb {
    public:
        aabb() {}
        // 如何唯一确定一个3D-AABB？只需要两个点即可！
        aabb(const point3& a, const point3& b) { minimum = a; maximum = b;}

        //返回三个分量都较小的那一个点。
        point3 min() const {return minimum; }
        //返回minimum点在盒子上的对角点，即三个分量都较大的那个点。
        point3 max() const {return maximum; }

        //光线和AABB求交代码，注意这个hit和物体类的hit没有一毛钱关系。
        bool hit(const ray& r, double t_min, double t_max) const {
            //for循环判断三个轴向的三对面和光线碰撞的时间。
            for (int a = 0; a < 3; a++) {
                //见解析。
                auto t0 = fmin((minimum[a] - r.origin()[a]) / r.direction()[a],
                               (maximum[a] - r.origin()[a]) / r.direction()[a]);
                auto t1 = fmax((minimum[a] - r.origin()[a]) / r.direction()[a],
                               (maximum[a] - r.origin()[a]) / r.direction()[a]);
                t_min = fmax(t0, t_min);
                t_max = fmin(t1, t_max);
                if (t_max <= t_min)
                    return false;
            }
            return true;
        }
        
    
        point3 minimum;
        point3 maximum;
};

#endif

inline bool aabb::hit(const ray& r, double t_min, double t_max) const {
    for (int a = 0; a < 3; a++) {
        auto invD = 1.0f / r.direction()[a];
        auto t0 = (min()[a] - r.origin()[a]) * invD;
        auto t1 = (max()[a] - r.origin()[a]) * invD;
        //如果光线的方向向量某个分量为负，则光线一定会逆向穿过本轴上的对面。
        if (invD < 0.0f)
            std::swap(t0, t1);
        t_min = t0 > t_min ? t0 : t_min;
        t_max = t1 < t_max ? t1 : t_max;
        if (t_max <= t_min)
            return false;
    }
    return true;
}

#include "aabb.h"
...

class hittable {
    public:
        ...
        virtual bool hit(const ray& r, double t_min, double t_max, hit_record& rec) const = 0;
        //制造包围盒子的函数。
        virtual bool bounding_box(double time0, double time1, aabb& output_box) const = 0;
        ...
};

class sphere : public hittable {
    public:
        ...
        virtual bool hit(
            const ray& r, double t_min, double t_max, hit_record& rec) const override;

        //override包围盒生成函数。
        virtual bool bounding_box(double time0, double time1, aabb& output_box) const override;
        ...
};

...
bool sphere::bounding_box(double time0, double time1, aabb& output_box) const {
    //这是一个球的外切立方体。它是能包裹住球且体积最小的AABB。
    output_box = aabb(
        center - vec3(radius, radius, radius),
        center + vec3(radius, radius, radius));
    return true;
}

...
#include "aabb.h"
...

class moving_sphere : public hittable {
    public:
        ...
        virtual bool hit(
            const ray& r, double t_min, double t_max, hit_record& rec) const override;
        
        //override包围盒生成函数。
        virtual bool bounding_box(
            double _time0, double _time1, aabb& output_box) const override;
        ...
};

...
bool moving_sphere::bounding_box(double _time0, double _time1, aabb& output_box) const {
    //我们先生成移动的球在两个极端时间下的包围盒。
    aabb box0(
        center(_time0) - vec3(radius, radius, radius),
        center(_time0) + vec3(radius, radius, radius));
    aabb box1(
        center(_time1) - vec3(radius, radius, radius),
        center(_time1) + vec3(radius, radius, radius));
    //然后再求这两个包围盒的包围盒。这个surrounding_box函数会在之后给出。
    output_box = surrounding_box(box0, box1);
    return true;
}

aabb surrounding_box(aabb box0, aabb box1) {
    point3 small(fmin(box0.min().x(), box1.min().x()),
                 fmin(box0.min().y(), box1.min().y()),
                 fmin(box0.min().z(), box1.min().z()));

    point3 big(fmax(box0.max().x(), box1.max().x()),
               fmax(box0.max().y(), box1.max().y()),
               fmax(box0.max().z(), box1.max().z()));

    return aabb(small,big);
}

class lambertian : public material {
    ...
        virtual bool scatter(
            const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered
        ) const override {
			...
			//把time信息传递给出射光线。
            scattered = ray(rec.p, scatter_direction, r_in.time());
			...
        }
        ...
};

class metal : public material {
    ...
        virtual bool scatter(
           ...
        ) const override {
			...
            //把time信息传递给出射光线。
        	scattered = ray(rec.p, reflected + fuzz*random_in_unit_sphere(), r_in.time());
			...
        }
        ...
};

class dielectric : public material {
    ...
        virtual bool scatter(
            ...
        	//把time信息传递给出射光线。
            scattered = ray(rec.p, direction, r_in.time());
			...
        }
        ...
};

...
#include "moving_sphere.h"

...
hittable_list random_scene() {
	...

    for (int a = -11; a < 11; a++) {
        for (int b = -11; b < 11; b++) {
        	...

                if (choose_mat < 0.8) {
                    auto albedo = color::random() * color::random();
                    sphere_material = make_shared<lambertian>(albedo);
                    
                    // center2表示1.0时刻球心位置。
                    auto center2 = center + vec3(0, random_double(0,.5), 0);
                    
                 	// 创建moving_sphere时，比sphere多传入四个参数。
                    world.add(make_shared<moving_sphere>(
                        center, center2, 0.0, 1.0, 0.2, sphere_material));
                    
                } else if (choose_mat < 0.95) {
                 	...

}

int main() {
    
	// change
    auto aspect_ratio = 16.0 / 9.0;
    // ↓↓↓
    int image_width = 400;
    // ↓↓↓
    int samples_per_pixel = 100;

    ...

	//相机传入的两个时间值和刚刚移动的球中的值保持一致，方便同步修改。
    camera cam(lookfrom, lookat, vup, 20, aspect_ratio, aperture, dist_to_focus, 0.0, 1.0);

#if MULTITHREAD
//我们需要用到c语言中的部分内存操作函数，比如sprintf，在C++标准中它们被认为是危险和禁忌的。
//使用这个宏即可解禁这些函数，你亦可将其写入预处理器命令中。
#define _CRT_SECURE_NO_WARNINGS
...
#include "moving_sphere.h"

// 调整为16/9，和本章中动态模糊示例代码保持一致。
const auto aspect_ratio = 16.0 / 9.0;
// ↓↓↓，因为要输出多张图片，我们让其尽可能的快。
const int image_width = 200;

const int image_height = static_cast<int>(image_width / aspect_ratio);
const int samples_per_pixel = 100;
const int max_depth = 50;

...
    
hittable_list random_scene() {
    ...

    if (choose_mat < 0.8) {
        ...

         // 让center2尽可能的高，我打算让球高高的飞起！
         auto center2 = center + vec3(0, random_double(0, 50), 0);

         // 时间依然不变，卡在1个单位时间内运行完毕。
         world.add(make_shared<moving_sphere>(
            center, center2, 0.0, 1.0, 0.2, sphere_material));
    } else if (choose_mat < 0.95) {
        ...       
    ...
}

int main() {
    // 视频一共有多少帧。
    int video_frame_num = 10;
    // 把这些序列帧存放在指定目录下，方便查看和编辑。
    std::string video_folder_path = "video";

    world = random_scene();
    point3 lookfrom(13, 2, 3);
    point3 lookat(0, 0, 0);
    vec3 vup(0, 1, 0);
    auto dist_to_focus = 10.0;
    auto aperture = 0.1;

    // C的新建文件夹的多种方式之一，这种通过system命令新建文件夹的方式不需要多余的头文件包含，很方便。
    std::string command;
    // mkdir命令就是命令行中新建文件夹的命令，后跟新文件夹目录
    command = "mkdir " + video_folder_path;
    // 会在当前目录上创建video文件夹。
    // system只接受c风格字符串，所以要用c_str转换一下。
    system(command.c_str());
    // 具体文件名。
    char filename[50];
    
    // 循环创建多帧。
    for (int i = 0; i < video_frame_num; i++) {

        std::cerr << "LineIndex:" << i << std::endl;

        // sprintf和c语言中人尽皆知的printf几乎没有什么不同。
        // 唯一的区别是它要把字符串输出给一个char数组而不是标准输出流。
        // 图片名需要规律排列，ffmpeg会从编号为0的图片开始串帧成视频。
        sprintf(filename, "./%s/videoframe%04d.ppm", video_folder_path.c_str(), i);

        buf = new imageoutput(image_width, image_height, filename);
        std::vector<std::thread> threads;

        //本帧图片的时间区间，随后讲解。
        cam = new camera(lookfrom, lookat, vup, 20, aspect_ratio, aperture, dist_to_focus, pow(i / (float)video_frame_num, 5), pow((i + 1) / (float)video_frame_num, 5));

        for (int k = 0; k < numThread; k++) {
            threads.push_back(std::thread(ray_tracing_by_thread, k));
        }
        for (auto& thread : threads) {
            thread.detach();
        }

        while (thread_remain > 0) {
            std::cerr << "\rScanlines remaining : " << line_remain - 1 << ' ' << std::flush;
        }

        //注意初始化这些进程监视相关变量。
        line_remain = image_height;
        thread_remain = numThread;

        std::cerr << "\nDone.\n";
        buf->buffer_2_file();

        delete cam;
        delete buf;
    }

    return 0;
}

#endif

#include <thread>
func(par1, par2){...}

//直接构造thread对象t，第一个参数为函数，后面依次传入对应函数所需参数
std::thread t(func, par1, par2...);

//detach表示彻底放养t线程，这是一个危险的行为，如果不能保证主线程在t线程之后走完
//就会导致t线程的资源无法回收。
t.detach();

//join t线程到本线程，在join完后表示接下来的代码必须等待t执行完成之后才开始执行。
t.join();

#ifndef IMAGEOUTPUT_H
#define IMAGEOUTPUT_H

#include <iostream>
#include <fstream>

// 颜色的值最高只到255，只需要8bit存储，使用int类型太过浪费。
// 我们给unsigned char这个8bit类型重命名，用它来当缓冲区类型。
typedef unsigned char D_BYTE;

class imageoutput {
public:
    // 构造函数，通过文件名直接输出。
    imageoutput(int wth, int hgt, const char* file_nm) :width(wth), height(hgt) {
        // 分配一块大小为width * height * 3的区域用于存取像素的rgb。
        buffer = new D_BYTE[width * height * 3];
        // 建立输出文件流。
        outFile = std::ofstream(file_nm);
        // ppm文件的开头要加上这句话。
        outFile << "P3\n" << width << " " << height << "\n255\n";
    }
    // 析构函数，释放缓冲区。为保证安全性，需要确认它不为空。
    ~imageoutput() {
         if (buffer != nullptr) {
            delete[] buffer;
        }
    }
    
    // 填写颜色到数组中，需要传入像素的位置，以及rgb值。这里做了之前color类做的一些事情。
    void write_buffer(const int& x, const int& y, const double red, const double green, const double blue) {
        D_BYTE ir = D_BYTE(255.999 * clamp(red, 0, 0.999));
        D_BYTE ig = D_BYTE(255.999 * clamp(green, 0, 0.999));
        D_BYTE ib = D_BYTE(255.999 * clamp(blue, 0, 0.999));
        // 二维坐标转一维数组坐标，然后依次填入rgb。
        int n = (y * width + x) * 3;
        buffer[n] = ir;
        buffer[n + 1] = ig;
        buffer[n + 2] = ib;
    }

    // 这个函数把整个缓冲区内的数据写入文件。
    void buffer_to_file() {
        for (int j = (height - 1); j >= 0; j--) {
            for (int i = 0; i < width; i++) {
                int n = (j * width + i) * 3;
                outFile << (int)buffer[n] << " " << (int)buffer[n + 1] 
                    << " " << (int)buffer[n + 2] << std::endl;
            }
        }
    }

private:
    int width;
    int height;
    D_BYTE* buffer;
    std::ofstream outFile;
};

#endif

#include "camera.h"
#include "rtweekend.h"
#include "color.h"
#include "hittable_list.h"
#include "sphere.h"
#include "material.h"
#include "imageoutput.h"
#include <thread>

//图片参数
const auto aspect_ratio = 3.0 / 2.0;
const int image_width = 400;
const int image_height = static_cast<int>(image_width / aspect_ratio);
const int samples_per_pixel = 100;
const int max_depth = 50;

//thread相关，通过hardware_concurrency()获得处理器核心数量，来初始化线程数。
int numThread = max(std::thread::hardware_concurrency(), (unsigned int)1);
//定义一个输出设置
imageoutput* buf;

//相机与场景
hittable_list world;
camera* cam;

//着色函数，直接复制。
color ray_color(const ray& r, const hittable& world, int depth) {...}
//最终场景，直接复制。
hittable_list random_scene(){...}

//把渲染循环切分成numThread份，分配给每个线程执行。
//这是分配第k个线程的任务。
void ray_tracing_by_thread(int k) {
    for (int j = image_height - k - 1; j >= 0; j -= numThread) {
        for (int i = 0; i < image_width; i++) {
            color tmp(0, 0, 0);
            for (int s = 0; s < samples_per_pixel; s++) {
                auto u = (i + random_double()) / (image_width - 1);
                auto v = (j + random_double()) / (image_height - 1);
                ray r = cam->get_ray(u, v);
                tmp += ray_color(r, world, max_depth);
            }
            tmp /= float(samples_per_pixel);
            //将颜色gamma矫正，存入缓冲区
   			buf->write_buffer(i, j, sqrt(tmp[0]), sqrt(tmp[1]), sqrt(tmp[2]));
        }
    }
}

int main() {
    // 摆放场景
    world = random_scene();

    // 初始化缓冲区和输出文件流，并给图片命名。
    buf = new imageoutput(image_width, image_height,"image.ppm");
   
    // 线程列表
    std::vector<std::thread> threads;
  
    // 放置相机
    point3 lookfrom(13, 2, 3);
    point3 lookat(0, 0, 0);
    vec3 vup(0, 1, 0);
    auto dist_to_focus = 10.0;
    auto aperture = 0.1;
    cam = new camera(lookfrom, lookat, vec3(0, 1, 0), 20, aspect_ratio, aperture, dist_to_focus);

    //多线程下的renderloop
    for (int k = 0; k < numThread; k++) {
        threads.push_back(std::thread(ray_tracing_by_thread, k));
    }
    for (auto& thread : threads) {
        //阻塞主线程，必须等待所有线程执行完毕，再会执行后续的代码。
        thread.join();
    }
    //缓冲区已经填充完毕，输出成文件。
    buf->buffer_2_file();
    
    //释放堆上内存。
    delete cam;
    delete buf;
}

//剩余行数
int line_remain = image_height;
//剩余多少线程没完成任务
int thread_remain = numThread;

void ray_tracing_by_thread(int k) {
    for (int j = image_height - k - 1; j >= 0; j -= numThread) {
        for (int i = 0; i < image_width; i++) {
           ...
            buf->write_buffer(i, j, sqrt(tmp[0]), sqrt(tmp[1]), sqrt(tmp[2]));

        }
        //执行到这说明有一行像素存缓冲区完毕。
        --line_remain;         
    }
    //执行到这说明有一个线程执行完毕。
    --thread_remain;
}

int main() {

    ...
    cam = new camera(lookfrom, lookat, vec3(0, 1, 0), 20, aspect_ratio, aperture, dist_to_focus);

    //多线程下的renderloop
    for (int k = 0; k < numThread; k++) {
        threads.push_back(std::thread(ray_tracing_by_thread, k));
    }
    for (auto& thread : threads) {
        //detach单独使用是非常危险的，但后续的while循环会卡住主线程，让线程结束顺序变得可控。
        thread.detach();
    }
    while (thread_remain > 0) {
        // line_remain-1是为了最后能让显示数字归零，工整好看。
        std::cerr << "\rScanlines remaining: " << line_remain-1 << ' ' << std::flush;
    }
    std::cerr << "\nDone.\n";
    buf->buffer_2_file();

    delete cam;
    delete buf;
    
    return 0;
}

//运行到这的线程都会尝试给some_mutex加上属于它们自己的锁。
//但是如果这时候锁已经有主人了，这个请求就会失败，申请的线程会被阻塞，直到锁被持有者释放。
some_mutex.lock();

//互斥代码
...
//锁的持有者释放了这个锁！现在其他线程们可以来抢夺这枚锁了！
some_mutex.unlock();

#include<mutex>
//信号量
std::mutex line_remain_mutex;
std::mutex thread_remain_mutex;
for (int j = image_height - k - 1; j >= 0; j -= numThread) {
        for (int i = 0; i < image_width; i++) {
          ...
        }
        line_remain_mutex.lock();
        --line_remain;
        line_remain_mutex.unlock();
    }
    thread_remain_mutex.lock();
    --thread_remain;
    thread_remain_mutex.unlock();

#if !MULTITHREAD

//所有代码
...

#endif

#if MULTITHREAD

//所有代码
...

#endif