#!/usr/bin/python | |
# -*- coding: utf-8 -*- | |
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer | |
import SocketServer | |
import urlparse | |
import os | |
import sys | |
import random | |
import json | |
import cgi | |
import cv2 | |
status = json.loads(open("status.json").read()) | |
bingotitle = cv2.imread("bingotitle.jpg") | |
blue_images = {} | |
for n in range(75): | |
blue_images[n+1] = cv2.imread("numbers/blue_" + ("%02d" % (n + 1)) + ".jpg") | |
gray_images = {} | |
for n in range(99): | |
gray_images[n+1] = cv2.imread("numbers/gray_" + ("%02d" % (n + 1)) + ".jpg") | |
def rnd(digit): | |
s = "" | |
for i in range(digit): | |
s += str(random.randint(0, 9)) | |
return s | |
def new_bingo(max_number=75): | |
num_base = [] | |
if max_number == 75: | |
I15 = [i+1 for i in range( 0, 15)] | |
I30 = [i+1 for i in range(15, 30)] | |
I45 = [i+1 for i in range(30, 45)] | |
I60 = [i+1 for i in range(45, 60)] | |
I75 = [i+1 for i in range(60, 75)] | |
random.shuffle(I15) | |
random.shuffle(I30) | |
random.shuffle(I45) | |
random.shuffle(I60) | |
random.shuffle(I75) | |
for i in range(5): | |
num_base.append(I15[i]) | |
num_base.append(I30[i]) | |
num_base.append(I45[i]) | |
num_base.append(I60[i]) | |
num_base.append(I75[i]) | |
else: | |
for i in range(max_number): | |
num_base.append(i+1) | |
random.shuffle(num_base) | |
num_base[12] = 99 | |
return num_base[:25] | |
def check_bingo(bingo, called_nums): | |
ck_list = [ | |
# yoko | |
[ 0, 1, 2, 3, 4], | |
[ 5, 6, 7, 8, 9], | |
[10,11,12,13,14], | |
[15,16,17,18,19], | |
[20,21,22,23,24], | |
# tate | |
[ 0, 5,10,15,20], | |
[ 1, 6,11,16,21], | |
[ 2, 7,12,17,22], | |
[ 3, 8,13,18,23], | |
[ 4, 9,14,19,24], | |
# naname | |
[ 0, 6,12,18,24], | |
[ 4, 8,12,16,20] | |
] | |
for ck in ck_list: | |
flag = True | |
for i in range(5): | |
if not bingo[ck[i]] in called_nums: | |
flag = False | |
break | |
if flag == True: | |
return 1 | |
return 0 | |
def save_jpg_for_size(original, size, baseurl): | |
cv2.imwrite(baseurl + "/" + str(size) + ".jpg", original) | |
def make_imagemap_from_data(userid, bingo, called_nums): | |
global status | |
global bingotitle | |
global blue_images | |
global gray_images | |
card = [bingotitle] | |
for i in range(5): | |
line_ = [] | |
for j in range(5): | |
n = bingo[ (i * 5) + j ] | |
if not n in called_nums: | |
one = blue_images[n] | |
else: | |
one = gray_images[n] | |
line_.append(one) | |
card.append(cv2.hconcat(line_)) | |
img = cv2.vconcat(card) | |
baseurl = status["local_pics_path"] + userid | |
if os.path.isdir(baseurl) == False: | |
os.mkdir(baseurl) | |
imageid = rnd(20) | |
baseurl = status["local_pics_path"] + userid + "/" + imageid | |
os.mkdir(baseurl) | |
save_jpg_for_size(img, 305, baseurl) | |
return status["web_pics_path"] + userid + "/" + imageid | |
def make_image_from_data(userid, bingo, called_nums): | |
global bingotitle | |
global blue_images | |
global gray_images | |
card = [bingotitle] | |
for i in range(5): | |
line_ = [] | |
for j in range(5): | |
n = bingo[ (i * 5) + j ] | |
if not n in called_nums: | |
one = blue_images[n] | |
else: | |
one = gray_images[n] | |
line_.append(one) | |
card.append(cv2.hconcat(line_)) | |
return cv2.vconcat(card) | |
def save_image(img, userid, bingo, called_nums): | |
global status | |
baseurl = status["local_pics_path"] + userid | |
if os.path.isdir(baseurl) == False: | |
os.mkdir(baseurl) | |
imageid = rnd(20) | |
baseurl = status["local_pics_path"] + userid + "/" + imageid | |
os.mkdir(baseurl) | |
save_jpg_for_size(img, 305, baseurl) | |
return status["web_pics_path"] + userid + "/" + imageid | |
def html(text): | |
print "Content-Type: application/json" | |
print "{'result': '" + text + "'}" | |
sys.exit() | |
def branch(): | |
form = cgi.FieldStorage() | |
num = form.getvalue("num") | |
if num != None: | |
return (0, num) | |
uid = form.getvalue("uid") | |
call = form.getvalue("call") | |
if uid != None and call != None: | |
return (1, uid, call) | |
return (-1, "error") | |
def main(): | |
result = branch() | |
if result[0] == 0: | |
routineA(result[1]) | |
return | |
if result[0] == 1: | |
routineB(result[1], result[2]) | |
return | |
html("404 not found") | |
return | |
def routineA(num): | |
global status | |
if num == None: | |
html('404 not found') | |
if int(num) < 1: | |
html('404 not found') | |
num = int(num) | |
if os.path.exists("a_cache"): | |
return open("a_cache").read() | |
uid = rnd(30) | |
data= { | |
'data': [], | |
'result': 'ok', | |
'called': [99] | |
} | |
for i in range(num): | |
bingo = new_bingo(75) | |
img = make_image_from_data(uid, bingo, [99]) | |
url = save_image(img, uid, bingo, [99]) | |
one = { | |
"url": url, | |
"data": bingo | |
} | |
data['data'].append(one) | |
path = status["local_pics_path"] + uid + "/" + "ginfo.json" | |
open(path, "w").write(json.dumps(data, indent=4)) | |
a_cache = json.dumps(data, indent=4) | |
open('a_cache', "w").write(a_cache) | |
return a_cache | |
def routineB(uid, call): | |
global status | |
path = status["local_pics_path"] + uid + "/" + "ginfo.json" | |
ginfo= json.loads(open(path).read()) | |
if not int(call) in ginfo["called"]: | |
ginfo["called"].append(int(call)) | |
if os.path.exists("b_cache"): | |
data = json.loads(open("b_cache").read()) | |
data["called"] = ginfo["called"] | |
return json.dumps(data, indent=4) | |
data = { | |
'data': [], | |
'result': 'ok', | |
'called': ginfo["called"] | |
} | |
for v in ginfo["data"]: | |
url = make_imagemap_from_data(uid, v["data"], ginfo["called"]) | |
one = { | |
"url": url, | |
"data": v["data"], | |
"bingo": check_bingo(v["data"], ginfo["called"]) | |
} | |
data['data'].append(one) | |
open(path, "w").write(json.dumps(data, indent=4)) | |
else: | |
data = ginfo | |
b_cache = json.dumps(data, indent=4) | |
open("b_cache", "w").write(b_cache) | |
return b_cache | |
class S(BaseHTTPRequestHandler): | |
def _set_headers(self): | |
self.send_response(200) | |
self.send_header('Content-type', 'application/json') | |
self.end_headers() | |
def do_GET(self): | |
parsed_path = urlparse.urlparse(self.path) | |
self._set_headers() | |
queries = {} | |
for q in parsed_path.query.split('&'): | |
queries[q.split('=')[0]] = q.split('=')[1] | |
result = branch() | |
if 'num' in queries: | |
self.wfile.write(routineA(queries['num'])) | |
else: | |
self.wfile.write(routineB(queries['uid'], queries['call'])) | |
def run(server_class=HTTPServer, handler_class=S, port=80): | |
server_address = ('', port) | |
httpd = server_class(server_address, handler_class) | |
print 'Starting httpd...' | |
httpd.serve_forever() | |
if __name__ == "__main__": | |
from sys import argv | |
if len(argv) == 2: | |
run(port=int(argv[1])) | |
else: | |
run() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment