qrcode.rb

在线生成手机二维码的源程序

p [mask_array]
p [rs_block_order]
p [format_information_x2,format_information_y2]
p rs_ecc_codewords

    format_information_x1=Array[0,1,2,3,4,5,7,8,8,8,8,8,8,8,8]
    format_information_y1=Array[8,8,8,8,8,8,8,8,7,5,4,3,2,1,0]

    max_data_codewords=(max_data_bits >>3)

    filename = @path+"/rsc"+rs_ecc_codewords.to_s+".dat"

p filename

    fp =File.open(filename, "rb")

    i=0
    rs_cal_table_array=Array.new

    while i<256
        rs_cal_table_array[i]=fp.read(rs_ecc_codewords)
        i+=1
    end
    fp.close

#/* -- read frame data  -- */

    filename = @path+"/qrvfr"+@qrcode_version.to_s+".dat"
p filename

    fp = File.open(filename, "rb")
        frame_data = fp.read(65535);
    fp.close

#/*  --- set terminator */

    if (total_data_bits<=max_data_bits-4) then
        data_value[data_counter]=0
        data_bits[data_counter]=4
    elsif  (total_data_bits<max_data_bits) then
	    data_value[data_counter]=0
            data_bits[data_counter]=max_data_bits-total_data_bits
        elsif (total_data_bits>max_data_bits) then
                raise "Overflow error"
	        return 0
    end

#/* ----divide data by 8bit */

i=0
codewords_counter=0
codewords=Array.new
codewords[0]=0
remaining_bits=8

while (i <= data_counter)
    buffer=data_value[i]
    buffer_bits=data_bits[i]

    flag=1
    while flag!=0 
        if remaining_bits>buffer_bits then 
            codewords[codewords_counter]=0 if codewords[codewords_counter] ==nil
            codewords[codewords_counter]=((codewords[codewords_counter]<<buffer_bits) | buffer)

p [codewords_counter,codewords[codewords_counter],buffer_bits,buffer]

            remaining_bits-=buffer_bits
            flag=0
        else 
            buffer_bits-=remaining_bits
            codewords[codewords_counter]=((codewords[codewords_counter] << remaining_bits) | (buffer >> buffer_bits))

            if (buffer_bits==0) then
                flag=0
            else 
                buffer= (buffer & ((1 << buffer_bits)-1) )
                flag=1
            end

            codewords_counter+=1
            if (codewords_counter<max_data_codewords-1) then
                codewords[codewords_counter]=0
            end
            remaining_bits=8
        end
    end
    i+=1
end

if (remaining_bits!=8) then
    codewords[codewords_counter]=codewords[codewords_counter] << remaining_bits
else
    codewords_counter-=1
end

#/* ----  set padding character */

if (codewords_counter<max_data_codewords-1) then
    flag=1
    while codewords_counter<max_data_codewords-1
        codewords_counter+=1
        if (flag==1)  then
            codewords[codewords_counter]=236
        else 
            codewords[codewords_counter]=17
        end
        flag=flag*(-1)
    end
end

#/* ---- RS-ECC prepare */

i=0
j=0
rs_block_number=0
rs_temp=Array.new
rs_temp[0]=""

while i<max_data_codewords

    rs_temp[rs_block_number] << codewords[i]
    j+=1

    if j>=rs_block_order[rs_block_number]-rs_ecc_codewords then
        j=0
        rs_block_number+=1
        rs_temp[rs_block_number]=""
    end
    i+=1
end

p rs_block_order
p rs_temp[0].unpack("C*")
p rs_cal_table_array

#/*
#
# RS-ECC main
#
#*/

rs_block_number=0
rs_block_order_num=rs_block_order.length




while rs_block_number<rs_block_order_num

    rs_codewords=rs_block_order[rs_block_number]
    rs_data_codewords=rs_codewords-rs_ecc_codewords

    rstemp=rs_temp[rs_block_number]
    j=rs_data_codewords
    while j>0
        first=rstemp[0]
        if first!=0 then
            left_chr=rstemp[1,rstemp.length-1]
            cal=rs_cal_table_array[first]
            p cal.unpack("C*")
            rstemp=string_bit_cal(left_chr,cal,"xor")
        else
            rstemp=rstemp[1,rstemp.length-1]
        end

        j-=1
    end

    codewords +=  rstemp.unpack("C*")

    rs_block_number+=1
end

#---- 
#/* ---- flash matrix */

matrix_content=(0...max_modules_1side).collect { Array.new(max_modules_1side).fill(0) }


#/* --- attach data */

i=0
while i<max_codewords
    codeword_i=codewords[i]
    j=7
    while j>=0
        codeword_bits_number=(i << 3) +  j
        matrix_content[ matrix_x_array[codeword_bits_number] ][ matrix_y_array[codeword_bits_number] ]=((255*(codeword_i & 1)) ^ mask_array[codeword_bits_number] )
        codeword_i= codeword_i >> 1
        j-=1
    end
    i+=1
end



matrix_remain=matrix_remain_bit[@qrcode_version]
while matrix_remain>0
    remain_bit_temp = matrix_remain + ( max_codewords << 3)-1

    matrix_content[ matrix_x_array[remain_bit_temp] ][ matrix_y_array[remain_bit_temp] ]  =  ( 255 ^ mask_array[remain_bit_temp] )

    matrix_remain-=1
end

#--- mask select

min_demerit_score=0

    hor_master=""
    ver_master=""
    k=0
    while k<max_modules_1side
        l=0
        while l<max_modules_1side
            hor_master += matrix_content[l][k].to_int.chr
            ver_master += matrix_content[k][l].to_int.chr
            l+=1
        end
        k+=1
    end

i=0
all_matrix=max_modules_1side*max_modules_1side


while i<8
    demerit_n1=0
    ptn_temp=Array.new
    bit= 1<< i

    bit_r=(~bit) & 255

    bit_mask=bit.chr * all_matrix
    hor = string_bit_cal(hor_master,bit_mask,"and")
    ver = string_bit_cal(ver_master,bit_mask,"and")

    ver_and= string_bit_cal( ((170.chr * max_modules_1side) + ver), (ver + (170.chr * max_modules_1side)),"and")

    ver_or=  string_bit_cal( ((170.chr * max_modules_1side) + ver), (ver + (170.chr * max_modules_1side)),"or")

    hor= string_bit_not(hor)
    ver= string_bit_not(ver)

    ver_and = string_bit_not(ver_and)
    ver_or  = string_bit_not(ver_or)

    ver_and[all_matrix,0] = 170.chr
    ver_or[all_matrix,0] = 170.chr
    k = max_modules_1side - 1

    while k>=0
       hor[k * max_modules_1side,0] = 170.chr
       ver[k * max_modules_1side,0] = 170.chr
       ver_and[k * max_modules_1side,0] = 170.chr
       ver_or[k * max_modules_1side,0] = 170.chr
       k-=1
    end

    hor=hor + 170.chr + ver
    n1_search=(255.chr * 5)+"+|"+(bit_r.chr * 5) + "+"
    n2_search1=bit_r.chr + bit_r.chr + "+"
    n2_search2=255.chr + 255.chr + "+"

    n3_search=bit_r.chr + 255.chr + bit_r.chr + bit_r.chr + bit_r.chr + 255.chr + bit_r.chr

    n4_search=bit_r.chr
    hor_temp=hor

    demerit_n3 = (hor_temp.scan(Regexp.compile(n3_search)).size)*40


    demerit_n4 = ((((ver.count(n4_search)*100) / byte_num)-50)/5).abs.to_i * 10

    demerit_n2=0
    ptn_temp=ver_and.scan(Regexp.compile(n2_search1))
    ptn_temp.each{|te|
        demerit_n2+=(te.length-1)
    }
    ptn_temp=ver_or.scan(Regexp.compile(n2_search2))
    ptn_temp.each{|te|
        demerit_n2+=(te.length-1)
    }
    demerit_n2*=3

    ptn_temp=hor.scan(Regexp.compile(n1_search))
    ptn_temp.each{|te|
        demerit_n1+=(te.length-2)
    }
    demerit_score=demerit_n1+demerit_n2+demerit_n3+demerit_n4

    if (demerit_score<=min_demerit_score || i==0) then
        mask_number=i
        min_demerit_score=demerit_score
    end

i+=1
end


mask_content=1 << mask_number

# --- format information

format_information_value=((ec << 3) | mask_number)
format_information_array=Array["101010000010010","101000100100101",
"101111001111100","101101101001011","100010111111001","100000011001110",
"100111110010111","100101010100000","111011111000100","111001011110011",
"111110110101010","111100010011101","110011000101111","110001100011000",
"110110001000001","110100101110110","001011010001001","001001110111110",
"001110011100111","001100111010000","000011101100010","000001001010101",
"000110100001100","000100000111011","011010101011111","011000001101000",
"011111100110001","011101000000110","010010010110100","010000110000011",
"010111011011010","010101111101101"]

i=0

while i<15
    content=format_information_array[format_information_value][i,1].to_i

    matrix_content[format_information_x1[i]][format_information_y1[i]]=content * 255
    matrix_content[format_information_x2[i]][format_information_y2[i]]=content * 255
    i+=1
end

out=""
mxe=max_modules_1side
i=0
while i<mxe
    j=0
    while j<mxe
        if (matrix_content[j][i].to_i & mask_content)!=0 then
            out+="1"
        else 
            out+="0"
        end
        j+=1
    end
    out+="\n"
    i+=1
end

out=string_bit_cal(out,frame_data ,"or")

puts out

return (out)

end
end