格雷码编码+解码+实现（Python）

/*==================================================
@Project：GrayCode
@File   : main
@Desc   ：生成格雷码
----------------------------------------------------
@Author ：Jianbin Cao
@Email  : fly_cjb@163.com
@Date   ：2020/11/10 20:40
==================================================*/
#include <iostream>
#include <vector>
#include <cassert>
using namespace std;


vector<string> GrayCode(int n) {
    if (n < 1) {
        cout << "格雷码数量必须大于0" << endl;
        assert(0);
    } else if (n == 1) {
        vector<string> code;
        code.emplace_back("0");
        code.emplace_back("1");
        return code;
    } else {
        vector<string> code;
        vector<string> code_pre = GrayCode(n - 1);
        
        for (int idx = 0; idx < code_pre.size(); ++idx) {
            code.push_back("0" + code_pre[idx]);
        }
        for (int idx = int(code_pre.size() - 1); idx >= 0; --idx) {
            code.push_back("1" + code_pre[idx]);
        }
        return code;
    }
}


int main()
{
    int n = 4;
    vector<string> gray_code = GrayCode(n);
    for (auto &g : gray_code){
        cout << g << endl;
    }
}

vector<int> GrayCode2(int n){
    int count = 1 << n;
    vector<int> res(count,0);
    for(int i = 1 ; i < count; i ++)
    {
        int bin = i,cur = bin >> (n - 1);
        for(int k = n - 1;k > 0;k --)
            cur = (cur << 1) + (((bin >> k) & 1) ^ ((bin >>(k - 1)) & 1));
        res[i] = cur;
    }
    return res;
}
vector<int> gray_code2 = GrayCode2(n);
    for (auto &g : gray_code2){
        cout << (bitset<n>)g << endl;
    }

import cv2
import numpy as np

class GrayCode:
    codes = np.array([])
    k2code = {}
    k2v = {}           
    v2k = {}

    def __init__(self, n:int=3):
        self.n = n
        self.codes = self.__creatCode(self.n)

        # 从k（idx）转换到格雷码
        for k in range(2**n):
            self.k2code[k] = self.__k2code(k)
        # 从格雷码转换到v
        for k in range(2 ** n):
            self.k2v[k] = self.__k2v(k)
        # 从v转换到k（idx）
        for k, v in self.k2v.items():
            self.v2k[v] = k

    def toPattern(self, idx:int, cols:int = 1280, rows:int = 800):
        assert (idx >= 0)
        row = self.codes[idx, :]
        one_row = np.zeros([cols], np.uint8)
        assert (cols % len(row) == 0)
        per_col = int(cols / len(row))

        for i in range(len(row)):
            one_row[i * per_col : (i + 1) * per_col] = row[i]
        pattern = np.tile(one_row, (rows, 1)) * 255
        return pattern

    def __creatCode(self, n:int):
        code_temp = GrayCode.__createGrayCode(n)
        codes = []
        for row in range(len(code_temp[0])):
            c = []
            for idx in range(len(code_temp)):
                c.append(int(code_temp[idx][row]))
            codes.append(c)
        return np.array(codes, np.uint8)

    def __k2code(self, k):
        col = self.codes[:, k]
        code = ""
        for i in col:
            code += str(i)
        return code

    def __k2v(self, k):
        col = list(self.codes[:, k])
        col = [str(i) for i in col]
        code = "".join(col)
        return int(code, 2)

    @staticmethod
    def __createGrayCode(n:int):
        if n < 1:
            print("输入数字必须大于0")
            assert (0);
        elif n == 1:
            code = ["0", "1"]
            return code
        else:
            code = []
            code_pre = GrayCode.__createGrayCode(n - 1)
            for idx in range(len(code_pre)):
                code.append("0" + code_pre[idx])
            for idx in range(len(code_pre) - 1, -1, -1):
                code.append("1" + code_pre[idx])
            return code


if __name__ == '__main__':
    n = 8
    g = GrayCode(n)
    print("code")
    print(g.codes)
    print("\nk -> code")
    print(g.k2code)
    print("\nk -> v")
    print(g.k2v)
    print("\nv -> k")
    print(g.v2k)
    for i in range(n):
        pattern = g.toPattern(i)
        title = str(i) + "-img"
        cv2.imshow(title, pattern)
        cv2.waitKey(0)
        cv2.destroyWindow(title)