package main
import (
"fmt"
"image"
"image/color"
"image/png"
"os"
)
const (
Size = 21
DataCodewords = 19
ECCCodewords = 7
MaxBytesByteMode = 17
ModeIndicatorByte = 0x4
)
var gfExp [512]int
var gfLog [256]int
func initGFTables() {
x := 1
for i := 0; i < 255; i++ {
gfExp[i] = x
gfLog[x] = i
x <<= 1
if x&0x100 != 0 {
x ^= 0x11d
}
}
for i := 255; i < 512; i++ {
gfExp[i] = gfExp[i-255]
}
gfLog[0] = -1
}
func gfMul(a, b int) int {
if a == 0 || b == 0 {
return 0
}
return gfExp[(gfLog[a]+gfLog[b])%255]
}
func rsGenerator(n int) []int {
g := []int{1}
for i := 0; i < n; i++ {
newG := make([]int, len(g)+1)
for j := range newG {
newG[j] = 0
}
for j := 0; j < len(g); j++ {
newG[j] ^= g[j]
newG[j+1] ^= gfMul(g[j], gfExp[i])
}
g = newG
}
return g
}
func rsComputeECC(data []int, eccLen int, g []int) []int {
poly := make([]int, len(data)+eccLen)
copy(poly, data)
for i := 0; i < len(data); i++ {
coef := poly[i]
if coef != 0 {
for j := 0; j < len(g); j++ {
poly[i+j] ^= gfMul(coef, g[j])
}
}
}
return poly[len(data):]
}
type bitBuffer struct {
bits []bool
}
func (bb *bitBuffer) appendBits(val int, length int) {
for i := length - 1; i >= 0; i-- {
bb.bits = append(bb.bits, ((val>>i)&1) == 1)
}
}
func encodeBytesToCodewords(data []byte) ([]int, error) {
if len(data) > MaxBytesByteMode {
return nil, fmt.Errorf("input too long for version 1-L: max %d bytes", MaxBytesByteMode)
}
var bb bitBuffer
bb.appendBits(ModeIndicatorByte, 4)
bb.appendBits(len(data), 8)
for _, b := range data {
bb.appendBits(int(b), 8)
}
remainingBits := DataCodewords*8 - len(bb.bits)
if remainingBits < 0 {
return nil, fmt.Errorf("data bits exceed capacity")
}
if remainingBits >= 4 {
bb.appendBits(0, 4)
remainingBits -= 4
} else {
bb.appendBits(0, remainingBits)
remainingBits = 0
}
if (len(bb.bits) % 8) != 0 {
toPad := 8 - (len(bb.bits) % 8)
bb.appendBits(0, toPad)
remainingBits -= toPad
}
padBytes := []int{0xEC, 0x11}
idx := 0
for (len(bb.bits) / 8) < DataCodewords {
bb.appendBits(padBytes[idx%2], 8)
idx++
}
codewords := make([]int, DataCodewords)
for i := 0; i < DataCodewords; i++ {
val := 0
for b := 0; b < 8; b++ {
if bb.bits[i*8+b] {
val |= 1 << (7 - b)
}
}
codewords[i] = val
}
return codewords, nil
}
func newMatrix() [][]int {
m := make([][]int, Size)
for i := range m {
m[i] = make([]int, Size)
for j := range m[i] {
m[i][j] = -1
}
}
return m
}
func placeFinder(m [][]int, r, c int) {
p := []string{
"1111111",
"1000001",
"1011101",
"1011101",
"1011101",
"1000001",
"1111111",
}
for i := 0; i < 7; i++ {
for j := 0; j < 7; j++ {
if p[i][j] == '1' {
m[r+i][c+j] = 1
} else {
m[r+i][c+j] = 0
}
}
}
for i := -1; i <= 7; i++ {
for j := -1; j <= 7; j++ {
rr := r + i
cc := c + j
if rr < 0 || rr >= Size || cc < 0 || cc >= Size {
continue
}
if (i == -1 || i == 7 || j == -1 || j == 7) && m[rr][cc] == -1 {
m[rr][cc] = 0
}
}
}
}
func placeTiming(m [][]int) {
for i := 8; i < Size-8; i++ {
if m[6][i] == -1 {
if i%2 == 0 {
m[6][i] = 1
} else {
m[6][i] = 0
}
}
if m[i][6] == -1 {
if i%2 == 0 {
m[i][6] = 1
} else {
m[i][6] = 0
}
}
}
}
func placeData(m [][]int, dataBits []bool) {
dirUp := true
row := Size - 1
col := Size - 1
bitIdx := 0
for col > 0 {
if col == 6 {
col--
}
for {
for c := col; c >= col-1; c-- {
if m[row][c] == -1 {
var bit bool
if bitIdx < len(dataBits) {
bit = dataBits[bitIdx]
} else {
bit = false
}
if bit {
m[row][c] = 1
} else {
m[row][c] = 0
}
bitIdx++
}
}
if dirUp {
row--
} else {
row++
}
if row < 0 || row >= Size {
break
}
}
dirUp = !dirUp
if row < 0 {
row = 0
} else {
row = Size - 1
}
col -= 2
}
}
func applyMask(m [][]int) {
for r := 0; r < Size; r++ {
for c := 0; c < Size; c++ {
if isFunctionModule(r, c) {
continue
}
if (r+c)%2 == 0 {
// flip
if m[r][c] == 0 {
m[r][c] = 1
} else if m[r][c] == 1 {
m[r][c] = 0
}
}
}
}
}
func isFunctionModule(r, c int) bool {
if (r >= 0 && r <= 8 && c >= 0 && c <= 8) ||
(r >= 0 && r <= 8 && c >= Size-9 && c <= Size-1) ||
(r >= Size-9 && r <= Size-1 && c >= 0 && c <= 8) {
return true
}
if r == 6 || c == 6 {
return true
}
formatPos := [][2]int{
{8, 0}, {8, 1}, {8, 2}, {8, 3}, {8, 4}, {8, 5}, {8, 7}, {8, 8},
{7, 8}, {5, 8}, {4, 8}, {3, 8}, {2, 8}, {1, 8}, {0, 8},
{Size - 1, 8}, {Size - 2, 8}, {Size - 3, 8}, {Size - 4, 8}, {Size - 5, 8},
{8, Size - 1}, {8, Size - 2}, {8, Size - 3}, {8, Size - 4}, {8, Size - 5},
}
for _, p := range formatPos {
if p[0] == r && p[1] == c {
return true
}
}
return false
}
var formatBits15 = []int{
1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0,
}
func placeFormatBits(m [][]int) {
_ = [][2]int{{8, 0}, {8, 1}, {8, 2}, {8, 3}, {8, 4}, {8, 5}, {8, 7}, {8, 8}}
_ = [][2]int{{7, 8}, {6, 8}, {5, 8}, {4, 8}, {3, 8}, {2, 8}, {1, 8}, {0, 8}}
_ = [][2]int{{Size - 1, 8}, {Size - 2, 8}, {Size - 3, 8}, {Size - 4, 8}, {Size - 5, 8}, {Size - 6, 8}, {Size - 7, 8}, {Size - 8, 8}}
_ = [][2]int{{8, Size - 1}, {8, Size - 2}, {8, Size - 3}, {8, Size - 4}, {8, Size - 5}, {8, Size - 6}, {8, Size - 7}, {8, Size - 8}}
pos := [][2]int{
{8, 0}, {8, 1}, {8, 2}, {8, 3}, {8, 4}, {8, 5}, {8, 7}, {8, 8},
{7, 8}, {6, 8}, {5, 8}, {4, 8}, {3, 8}, {2, 8}, {1, 8},
}
for i := 0; i < 15; i++ {
r := pos[i][0]
c := pos[i][1]
m[r][c] = formatBits15[i]
}
m[Size-1][8] = formatBits15[0]
m[Size-2][8] = formatBits15[1]
m[Size-3][8] = formatBits15[2]
m[Size-4][8] = formatBits15[3]
m[Size-5][8] = formatBits15[4]
m[Size-6][8] = formatBits15[5]
m[Size-7][8] = formatBits15[6]
m[8][Size-1] = formatBits15[7]
m[8][Size-2] = formatBits15[8]
m[8][Size-3] = formatBits15[9]
m[8][Size-4] = formatBits15[10]
m[8][Size-5] = formatBits15[11]
m[8][Size-6] = formatBits15[12]
m[8][Size-7] = formatBits15[13]
m[8][Size-8] = formatBits15[14]
}
func bitsFromCodewords(codewords []int, ecc []int) []bool {
total := append(codewords, ecc...)
bits := make([]bool, 0, len(total)*8)
for _, cw := range total {
for i := 7; i >= 0; i-- {
bits = append(bits, ((cw>>i)&1) == 1)
}
}
return bits
}
func renderPNG(m [][]int, scale int, filename string) error {
img := image.NewRGBA(image.Rect(0, 0, Size*scale, Size*scale))
white := color.RGBA{255, 255, 255, 255}
black := color.RGBA{0, 0, 0, 255}
for y := 0; y < Size*scale; y++ {
for x := 0; x < Size*scale; x++ {
img.Set(x, y, white)
}
}
for r := 0; r < Size; r++ {
for c := 0; c < Size; c++ {
val := m[r][c]
if val == 1 {
// draw black
for y := r * scale; y < (r+1)*scale; y++ {
for x := c * scale; x < (c+1)*scale; x++ {
img.Set(x, y, black)
}
}
}
}
}
f, err := os.Create(filename)
if err != nil {
return err
}
defer f.Close()
return png.Encode(f, img)
}
func main() {
initGFTables()
payload := []byte("Hello from Ashok")
dataCW, err := encodeBytesToCodewords(payload)
if err != nil {
fmt.Println("encode error:", err)
return
}
gen := rsGenerator(ECCCodewords)
ecc := rsComputeECC(dataCW, ECCCodewords, gen)
mat := newMatrix()
placeFinder(mat, 0, 0)
placeFinder(mat, 0, Size-7)
placeFinder(mat, Size-7, 0)
placeTiming(mat)
mat[8][Size-8] = 1
dataBits := bitsFromCodewords(dataCW, ecc)
placeData(mat, dataBits)
applyMask(mat)
placeFormatBits(mat)
out := "qrcode.png"
if err := renderPNG(mat, 8, out); err != nil {
fmt.Println("render error:", err)
return
}
fmt.Println("Written", out)
}
