参考

参考图

编码

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

#include <sys/stat.h>
#include <sys/types.h>

using namespace cv;
using namespace std;

/** ***************************************************************************
 * @brief 生成8张图，且每个最小的编码占据8个像素
 *
 * @param[in] savePath
 * @return int
 * ************************************************************************** */
int genGrayImg(std::string &savePath)
{

    int imgNums = 8;   ///< 8张图
    int BaseWidth = 8; ///< 最小的编码宽度

    cv::Mat whiteimg = cv::Mat(1080, 1920, CV_8UC1, Scalar(255));
    imwrite(savePath + "/white.bmp", whiteimg);
    for (int num = 0; num < imgNums; num++)
    {

        cv::Mat Phase_h = cv::Mat(1080, 1920, CV_8UC1);
        cv::Mat Phase_v = cv::Mat(1080, 1920, CV_8UC1);
        for (int i = 0; i < Phase_h.rows; i++)
        {
            for (int j = 0; j < Phase_h.cols; j++)
            {
                uchar v{}, h{};
                uchar vPow{8 - num - 1}, hPow{8 - num - 1};

                int xc = (int)ceil(i / (pow(2, (int)vPow)*BaseWidth)) / 2;
                int yc = (int)ceil(j / (pow(2, (int)vPow)*BaseWidth)) / 2;
                int xmod = xc%2;
                int ymod = yc%2;
                if (ymod==0)
                {
                    v = 0;
                }
                else
                {
                    v = 255;
                }

                if (xmod==0)
                {
                    h = 0;
                }
                else
                {
                    h = 255;
                }

                Phase_h.at<uchar>(i, j) = h;
                Phase_v.at<uchar>(i, j) = v;
            }
        }
        string pa = savePath + "/h_" + to_string(num) + ".bmp";
        imwrite(savePath + "/h_" + to_string(num) + ".bmp", Phase_h);
        imwrite(savePath + "/v_" + to_string(num) + ".bmp", Phase_v);
    }
    return true;
}

int main(int argc, char const *argv[])
{
    std::string path = "gray8";
    mkdir(path.c_str(), S_IRUSR | S_IWUSR | S_IXUSR | S_IRWXG | S_IRWXO);
    genGrayImg(path);
    return 0;
}

解码matlab程序

pics = zeros(1080,1920,8);
path='gray8/h_';
for NC=0:7
    pics(:,:,NC+1) = imread([path,num2str(NC),'.bmp'],'bmp');
end

%% 开始解码
thresh = 127;
bin = (pics>127); %二值化
for NC=2:8
    bin(:,:,NC)=xor(bin(:,:,NC-1),bin(:,:,NC));
end

%% 合成结果图
result =zeros(1080,1920);
for NC=1:8
    result = result+bin(:,:,NC).*(2^(8-NC));
end

mesh(result)

解码效果

解码c++版本，方便移植到cuda

移植的时候把宏注释都打开就行

#include<iostream>
using namespace std;

// #ifdef __CUDACC__
// #define __3D_CUDA_HOST_DEVICE__ __host__ __device__ __forceinline__
// #else
#define __3D_CUDA_HOST_DEVICE__
// #endif

struct uint8bit
{
    unsigned int gray1 : 1; ///< 第一张图的解析出来的gray码，下面一次是2~8
    unsigned int gray2 : 1;
    unsigned int gray3 : 1;
    unsigned int gray4 : 1;
    unsigned int gray5 : 1;
    unsigned int gray6 : 1;
    unsigned int gray7 : 1;
    unsigned int gray8 : 1;

    // 给方法全部加上限定宏，在cuda上运行
    __3D_CUDA_HOST_DEVICE__  uint8bit()
        : gray1(0), gray2(0), gray3(0), gray4(0),
          gray5(0), gray6(0), gray7(0), gray8(0)
    {
    }

    __3D_CUDA_HOST_DEVICE__  uint8bit(const uint8bit &u)
        : gray1(u.gray1), gray2(u.gray2), gray3(u.gray3), gray4(u.gray4),
          gray5(u.gray5), gray6(u.gray6), gray7(u.gray7), gray8(u.gray8)
    {
    }

    __3D_CUDA_HOST_DEVICE__ uint8bit(const unsigned char &data)
    {
        gray1 = ((uint8bit*)&data)->gray1;
        gray2 = ((uint8bit*)&data)->gray2;
        gray3 = ((uint8bit*)&data)->gray3;
        gray4 = ((uint8bit*)&data)->gray4;
        gray5 = ((uint8bit*)&data)->gray5;
        gray6 = ((uint8bit*)&data)->gray6;
        gray7 = ((uint8bit*)&data)->gray7;
        gray8 = ((uint8bit*)&data)->gray8;
    }

    /** ***************************************************************************
     * @brief 
     * 
     * @return uint8bit 
     * ************************************************************************** */
    __3D_CUDA_HOST_DEVICE__ uint8bit list_xor()
    {
        gray7 = gray8^gray7;   
        gray6 = gray7^gray6;   
        gray5 = gray6^gray5;   
        gray4 = gray5^gray4;   
        gray3 = gray4^gray3;   
        gray2 = gray3^gray2;   
        gray1 = gray2^gray1;   
        return *this;
    }

    __3D_CUDA_HOST_DEVICE__ unsigned char uint8()
    {
        return *(unsigned char *)this;
    }

};



int main(int argc, char const *argv[])
{
    unsigned char zero{0},seven{7};
    uint8bit u0(zero),u7(seven);
    cout<<(int)u0.uint8()<<endl;
    cout<<(int)u7.uint8()<<endl;

    uint8bit u_0 = u0.list_xor();
    uint8bit u_7 = u7.list_xor();

    cout<<(int)u_0.uint8()<<endl;
    cout<<(int)u_7.uint8()<<endl;


    return 0;
}

测试结果

0
7
0
5