鬼の领地

line_count = 0
 
def read_split(f):
    global line_count
    line_count += 1
    line = f.readline()
    if not line:
        return False
    return line[:-1].split()
 
with open('simsun-12.bdf', 'r') as f:
    chars = {}
    line = ['']
    try:
        # 获得字符总数
        while line[0] != 'CHARS':
            line = read_split(f)
        # 读取所有字符
        for i in range(int(line[1])):
            assert read_split(f)[0] == 'STARTCHAR'
            line = read_split(f)
            # 编码
            assert line[0] == 'ENCODING'
            char = unichr(int(line[1]))
            line = read_split(f)
            # 绘制参数
            assert line[0] == 'BBX'
            width, height, x1, y1 = [int(x) for x in line[1:]]
            x0, y0 = (1 + x1, 12 - y1 - height)
            # 准备绘制文字
            base_image = [[0 for x in range(14)] for y in range(14)]
            # 读取并绘制文字
            line = read_split(f)
            assert line[0] == 'BITMAP'
            for y in range(y0, y0 + height):
                line = read_split(f)[0]
                bits = int(line, 16)
                bits >>= len(line) * 4 - width
                for x in range(x0 + width - 1, x0 - 1, -1):
                    base_image[y][x] = bits & 1
                    bits >>= 1
            chars[char] = base_image
            # 结束这个文字
            line = read_split(f)
            assert line[0] == 'ENDCHAR'
        line = read_split(f)
        assert line[0] == 'ENDFONT'
    except AssertionError:
        print 'line', line_count
        raise

import marshal
marshal.dump(chars, open('base_image', 'wb'))

#!/usr/bin/python
# - * - coding: utf8 - * -
 
import marshal
import copy
 
base_chars = marshal.load(open('base_image', 'rb'))
chars = {}
for char, image in base_chars.iteritems():
    new_image = []
    for y in range(14):
        new_row = []
        for x in range(14):
            if image[y][x]:
                value = 81
            else:
                value = 0
            if y > 0 and image[y-1][x]:
                value += 4
            if y < 13 and image[y+1][x]:
                value += 4
            if x > 0 and image[y][x-1]:
                value += 4
            if x < 13 and image[y][x+1]:
                value += 4
            new_image.append(value)
    chars[char] = new_image
 
marshal.dump(chars, open('advanced_data', 'wb'))

#!/usr/bin/python
# - * - coding: utf8 - * -
 
import marshal
 
chars = marshal.load(open('advanced_data', 'rb'))
 
def image_diff(image1, image2):
    ret = 0
    for v1, v2 in zip(image1, image2):
        ret += (v1 - v2) ** 2
    return ret
 
remember_number = 5
try:
    searched = marshal.load(open('searched_chars', 'rb'))
except IOError:
    searched = {}
while True:
    input_string = unicode(raw_input('ID: '), 'utf8')
    if not input_string:
        break
    for char in input_string:
        if char not in chars:
            continue
        if char not in searched:
            diff_data = []
            image = chars[char]
            for c, v in chars.iteritems():
                if c == char:
                    continue
                diff_data.append((image_diff(v, image), c))
            diff_data.sort()
            searched[char] = diff_data[:remember_number]
        print char,
        for item in searched[char]:
            print u'({0}, {1})'.format(*item),
        print
    print
 
marshal.dump(searched, open('searched_chars', 'wb'))

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import math
sqrt = math.sqrt
 
def gen_imet(func):
  def retfunc(self, other):
    ret = func(self, other)
    self.ave = ret.ave
    self.u = ret.u
    self.digs = ret.digs
    return self
  return retfunc
 
def get_digs(a, b):
  if a == 0: return b
  elif b == 0: return a
  else: return min(a, b)
 
class PhyStat:
  """
  物理实验数据
 
  PhyStat(ave, u = 0.0, digs = 0)
  ave   表示平均值，如果传入一列数则自动计算平均值及其标准误差
  u     表示标准误差，如果 ave 传入数据列表则此处表示仪器精度
  digs  表示有效数字个数，0 表示不限制
  """
 
  def __init__(self, ave, u = 0.0, digs = 0):
    """
    对于 ave 为数据列表的情况，使用下面公式计算平均值：
    ave = Σx[i] / n
    根据下面公式计算标准误差：
    S = Sqrt(Σ(x[i]-ave)^2 / (n - 1))
    u = Δinst / Sqrt(3)
    U = Sqrt(S^2 + u^2)
    """
    self.digs = digs
 
    if isinstance(ave, tuple) or isinstance(ave, list):
      data = ave
      n = len(data)
      ave = math.fsum(ave) / n
      self.ave = ave
 
      s = 0.0
      for i in data:
        s += (i - ave) ** 2
      s = sqrt(s / (n - 1))
      u /= sqrt(3)
      self.u = sqrt(s ** 2 + u ** 2)
    else:
      self.ave = float(ave)
      self.u = abs(float(u))
 
  def __repr__(self):
    ave = self.ave
    exp = int(math.floor(math.log10(ave)))
    exp10 = 10 ** exp
    ave = ave / exp10
    u = self.u / exp10
    digs = self.digs
    if digs == 0:
      ret = '%f ±%f'
    else:
      ret = '%%.%df ±%%.%df' % (digs, digs)
    if exp:
      ret = '(%s) E %d' % (ret, exp)
    return ret % (ave, u)
 
  __neg__ = lambda self: PhyStat(-self.ave, self.u, self.digs)
  __pos__ = lambda self: self
  __abs__ = lambda self: PhyStat(abs(self.ave), self.u, self.digs)
 
  def __add__(self, other):
    if isinstance(other, PhyStat):
      ave = self.ave + other.ave
      u = sqrt(self.u ** 2 + other.u ** 2)
      digs = get_digs(self.digs, other.digs)
      return PhyStat(ave, u, digs)
    else:
      ave = self.ave + other
      return PhyStat(ave, self.u, self.digs)
 
  __radd__ = __add__
  __sub__ = lambda self, other: self + (-other)
  __rsub__ = lambda self, other: other + (-self)
 
  def __mul__(self, other):
    if isinstance(other, PhyStat):
      a = self.ave
      b = other.ave
      ave = a * b
      u = ave * sqrt((self.u / a) ** 2 + (other.u / b) ** 2)
      digs = get_digs(self.digs, other.digs)
      return PhyStat(ave, u, digs)
    else:
      ave = self.ave * other
      u = self.u * other
      return PhyStat(ave, u, self.digs)
 
  __rmul__ = __mul__
 
  def __div__(self, other):
    if isinstance(other, PhyStat):
      return self * other ** -1
    else:
      return (1.0 / other) * self
 
  __rdiv__ = lambda self, other: other * self ** -1
 
  def __pow__(self, other):
    a = self.ave
    ave = a ** other
    u = abs(other * self.u / a * ave)
    return PhyStat(ave, u, self.digs)
 
  __iadd__ = gen_imet(lambda self, other: self + other)
  __isub__ = gen_imet(lambda self, other: self - other)
  __imul__ = gen_imet(lambda self, other: self * other)
  __idiv__ = gen_imet(lambda self, other: self / other)
  __ipow__ = gen_imet(lambda self, other: self ** other)
 
  __int__ = lambda self: int(self.ave)
  __long__ = lambda self: long(self.ave)
  __float__ = lambda self: self.ave