""" An object with an x and a y field"""

__slots__ = ('x','y')

def __init__(self, x, y):

assert type(x) == float

assert type(y) == float

self.x = x

self.y = y

def __len__(self):

return 2

def __getitem__(self, key):

if key == 0: return self.x

if key == 1: return self.y

raise IndexError()

def __str__(self):

return str(self.x) + "," + str(self.y)

def __repr__(self):

return "Point(" + repr(self.x) + ", " + repr(self.y) + ")"

def is_empty(self):

__slots__ = ("x1","y1","x2","y2")

def __init__(self, x1,y1,x2,y2):

self.x1 = min(x1,x2)

self.y1 = min(y1,y2)

self.x2 = max(x1,x2)

self.y2 = max(y1,y2)

def extend_to_bbox(self, bbox):

x1 = min (self.x1, bbox.x1)

y1 = min (self.y1, bbox.y1)

x2 = max (self.x2, bbox.x2)

y2 = max (self.y2, bbox.y2)

return BoundingBox(x1,y1,x2,y2)

def p1(self):

return Point(self.x1, self.y1)

def p2(self):

return Point(self.x2, self.y2)

def __getitem__(self, key):

if key == 0: return self.x1

if key == 1: return self.y1

if key == 2: return self.x2

if key == 3: return self.y2

raise IndexError()

def width(self):

return self.x2 - self.x1

def height(self):

return self.y2 - self.y1

def center(self):

return Point((self.x1+self.x2)/2,

(self.y1+self.y2)/2)

def is_point_inside(self, point):

return (point.x >= self.x1) and (point.x <= self.x2) and \

(point.y >= self.y1) and (point.y <= self.y2)

def __str__(self):

return "(" + str(self.x1) + ", " + str(self.y1) + ", "+ str(self.x2) + ", " + str(self.y2) + ")"

def __repr__(self):

return "Position(" + repr(self.x1) + ", " + repr(self.y1) + ", "+ repr(self.x2) + ", " + repr(self.y2) + ")"

@staticmethod

def of_points(points):

xs = [p.x for p in points]

ys = [p.y for p in points]

def __init__(self):

pass

def transform_point(self, point):

raise Exception("not implemented")

def transform_points(self, points):

return [self.transform_point(p) for p in points]

def transform_bbox(self, bbox):

p1 = self.transform_point(bbox.p1())

p2 = self.transform_point(bbox.p2())

"""Transformation from IGNF coordinates used by the cadastre

into coordinates used by OSM"""

def __init__(self, cadastre_IGNF_code):

Transform.__init__(self)

source = osr.SpatialReference();

target = osr.SpatialReference();

source.ImportFromProj4(

"+init=IGNF:" + cadastre_IGNF_code + " +wktext");

target.ImportFromEPSG(4326);

self.transformation = osr.CoordinateTransformation(

source, target)

def transform_point(self, point):

x,y,z = self.transformation.TransformPoint(point[0], point[1], 0.0)

"""Transformation from cordinates used by OSM

to IGNF coordinates used by the cadastre"""

def __init__(self, cadastre_IGNF_code):

Transform.__init__(self)

source = osr.SpatialReference();

target = osr.SpatialReference();

target.ImportFromProj4(

"+init=IGNF:" + cadastre_IGNF_code + " +wktext");

source.ImportFromEPSG(4326);

self.transformation = osr.CoordinateTransformation(

source, target)

def transform_point(self, point):

x,y,z = self.transformation.TransformPoint(point[0], point[1], 0.0)

"""Transformation from the coordinates used inside a PDF, into the coordinate of the cadastre"""

def __init__(self, pdf_bbox, cadastre_bbox):

Transform.__init__(self)

Transform.__init__(self)

self.pdf_bbox = pdf_bbox

self.cadastre_bbox = cadastre_bbox

def transform_point(self, point):

return Point(

self.cadastre_bbox.x1 +

(point[0] - self.pdf_bbox.x1) *

self.cadastre_bbox.width() / self.pdf_bbox.width(),

self.cadastre_bbox.y1 +

(point[1] - self.pdf_bbox.y1)

"""Composition of many transformations"""

def __init__(self, *transforms):

Transform.__init__(self)

self.transforms = transforms

def transform_point(self, point):

for t in self.transforms:

point = t.transform_point(point)

if len(list):

return list[-1]

else:

""" Representation d'un path falicitant la reconnaisance.

Un path est composé de deux champs:

- une chaîne représentant une liste de commandes

- une liste de points (x,y)

Les commandes peuvent être:

M : move (1 argument)

L : line (1 argument)

C : curve (3 arguments)

Q : quadratic (2 arguments)

Z : close (0 argument)

"""

__slots__ = ('commands','points','most_distant_point_index', 'angle_and_points_for_path_recognition', 'style', 'd')

commands_argument_count = { 'M': 1, 'L':1, 'C':3, 'Q':2,'Z':0}

def __init__(self, commands, points, style="", d=None):

self.commands = commands

self.points = points

self.most_distant_point_index = None

self.angle_and_points_for_path_recognition = {}

self.style = style

self.d = d

def __str__(self):

result = []

i = 0

for c in self.commands:

result.append(c)

for foo in range(Path.commands_argument_count[c]):

result.append(str(self.points[i]))

i = i + 1

return "\n".join(result)

def __repr__(self):

return "Path(" + str(self) + ")"

def bbox(self, i=None):

# aproximation

if i == None:

return BoundingBox.of_points(self.points)

else:

return BoundingBox.of_points(self.points[:i])

def p0_distance(self, i=None):

if i == None: i = self.get_p0_most_distant_point_index()

(x1, y1), (x2, y2) = self.points[0], self.points[i]

return sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1))

def get_angle_and_points_for_path_recognition(self, i):

"""

Move, rotate and scale the list of points in order to facilitate

recognition.

The following transformations are applied:

- We first move the points so that the first one be in (0,0),

i.e. we move everypoints by (-x1,-y1)

- Then we rotate and scale the points so that the i commes

at position (1,0)

"""

if i not in self.angle_and_points_for_path_recognition:

x1,y1 = self.points[0] # le premier point

x2, y2 = self.points[i] # le second point

# le rayon =

r = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1))

if (r == 0.0):

self.points_for_path_recognition[i] = 0, self.points

else:

# l'angle:

t = atan2( (y2-y1), (x2-x1))

cosTbyR = cos(-t) / r

sinTbyR = sin(-t) / r

self.angle_and_points_for_path_recognition[i] = t, [

Point(

# move rotate and scale the coordinates:

cosTbyR * (x-x1) - sinTbyR * (y-y1),

sinTbyR * (x-x1) + cosTbyR * (y-y1))

for x,y in self.points ]

return self.angle_and_points_for_path_recognition[i]

def get_p0_most_distant_point_index(self):

""" retourne l'index du point le plus distant du premier"""

if self.most_distant_point_index == None:

max_squaredist = 0

max_i = 0

x0,y0 = self.points[0]

for i in range(1,len(self.points)):

xi, yi = self.points[i]

squaredist = (xi-x0)*(xi-x0) + (yi-y0)*(yi-y0)

if squaredist > max_squaredist:

max_squaredist = squaredist

max_i = i

self.most_distant_point_index = max_i

return self.most_distant_point_index

#def is_similar_to(self, other, tolerance = 0.05):

# i = self.get_p0_most_distant_point_index()

# return self.commands == other.commands and \

# maxdiff(self.get_points_for_path_recognition(i),

# other.get_points_for_path_recognition(i)) \

# <= tolerance

def startswith(self, other, tolerance = 0.05, min_scale = 0.9, max_scale=1.1):

if self.commands.startswith(other.commands):

i = other.get_p0_most_distant_point_index()

scale_factor = self.p0_distance(i) / other.p0_distance(i)

if scale_factor >= min_scale and scale_factor <= max_scale:

other_angle, other_points = other.get_angle_and_points_for_path_recognition(i)

self_angle, self_points = self.get_angle_and_points_for_path_recognition(i)

if maxdiff(self_points[:len(other.points)], other_points) < tolerance:

result = self_angle - other_angle

if result <= -math.pi:

result += 2*math.pi

elif result > math.pi:

result -= 2*math.pi

elif result == 0.0:

# renvoie quelque chose d'evalué à True proche de 0:

result = sys.float_info.min

return result

return False

@staticmethod

def from_svg(d):

""" Create a Path from a svg d string"""

commands = []

points = []

tokens = [ t for t in Path.__svg_path_tokenizer(d)]

tokens.reverse()

current_point = Point(0.0, 0.0)

while tokens:

t = tokens.pop()

if t in ['M','L']:

while True:

points.append(Point(tokens.pop(), tokens.pop()))

commands.append(t)

current_point = points[-1]

if type(peek(tokens)) != float: break

t = 'L' # M subsequent values becomes L

elif t in ['m', 'l']:

while True:

# convert to absolute:

points.append(Point(current_point.x + tokens.pop(), current_point.y + tokens.pop()))

commands.append(t.upper())

current_point = points[-1]

if type(peek(tokens)) != float: break

t = 'L' # M subsequent values becomes L

elif t in ['H','h','V','v']:

while True:

# convert to 'L'

if t == 'H':

points.append(Point(tokens.pop(), current_point.y))

elif t == 'h':

points.append(Point(current_point.x + tokens.pop(), current_point.y))

elif t == 'V':

points.append(Point(current_point.x, tokens.pop()))

elif t == 'v':

points.append(Point(current_point.x, current_point.y + tokens.pop()))

commands.append('L')

current_point = points[-1]

if type(peek(tokens)) != float: break

elif t == 'C':

while True:

for i in range(3):

points.append(Point(tokens.pop(), tokens.pop()))

commands.append('C')

current_point = points[-1]

if type(peek(tokens)) != float: break

elif t == 'c':

while True:

# convert to absolute

for i in range(3):

points.append(Point(current_point.x + tokens.pop(), current_point.y + tokens.pop()))

commands.append('C')

current_point = points[-1]

if type(peek(tokens)) != float: break

elif t in ['S', 's']:

while True:

if peek(commands) == 'C':

# the control point is the reflextion of the previous control point

previous_control_point = points[-2]

points.append(Point(

current_point.x - previous_control_point.x + current_point.x,

current_point.y - previous_control_point.y + current_point.y))

else:

# no previous control point, use the current point

points.append(Point(current_point.x, current_point.y))

for i in range(2):

if t == 'S':

points.append(Point(tokens.pop(), tokens.pop()))

else:

# Convert to absolute:

points.append(Point(

current_point.x + tokens.pop(),

current_point.y + tokens.pop()))

commands.append('C')

current_point = points[-1]

if type(peek(tokens)) != float: break

elif t == 'Q':

while True:

for i in range(2):

points.append(Point(tokens.pop(), tokens.pop()))

commands.append('Q')

#Path.__convert_last_quadratic_command_to_cubic(commands,points)

current_point = points[-1]

if type(peek(tokens)) != float: break

elif t == 'q':

while True:

for i in range(2):

# Convert to absolute:

points.append(Point(

current_point.x + tokens.pop(),

current_point.y + tokens.pop()))

commands.append('Q')

#Path.__convert_last_quadratic_command_to_cubic(commands,points)

current_point = points[-1]

if type(peek(tokens)) != float: break

elif t in ['T', 't']:

while True:

if peek(commands) == 'Q':

# the control point is the refextion of the previous control point

previous_control_point = points[-2]

points.append(Point(

current_point.x - previous_control_point.x + current_point.x,

current_point.y - previous_control_point.y + current_point.y))

else:

# no previous control point, use the current point

points.append(Point(current_point.x, current_point.y))

if t == 'T':

points.append(Point(tokens.pop(), tokens.pop()))

else:

# Convert to absolute:

points.append(Point(

current_point.x + tokens.pop(),

current_point.y + tokens.pop()))

commands.append('Q')

#Path.__convert_last_quadratic_command_to_cubic(commands,points)

current_point = points[-1]

if type(peek(tokens)) != float: break

elif t in ['A','a']:

raise Exception("unsuported svg path command: " + str(t) + " : " + d)

elif t in ['Z','z']:

commands.append('Z')

#pass

else:

raise Exception("invalid path " + str(t) + " : " + d)

return Path("".join(commands), points, d=d)

#@staticmethod

#def __convert_last_quadratic_command_to_cubic(commands, points):

# """ inkscape utilisé pour éditer les paths à reconnaître transforme

# malheureusement toute les commandes quadratic en cubic

# on fait donc de même pour pour pouvoir reconnaitre les path.

# Formule trouvée ici:

# http://fontforge.org/bezier.html

# """

# assert(commands[-1] == 'Q')

# commands[-1] = 'C'

# QP0 = points[-3]

# QP1 = points[-2]

# QP2 = points[-1]

# CP0 = QP0

# CP1 = Point(QP0[0] + (QP1[0] - QP0[0]) * 2 / 3, QP0[1] + (QP1[1] - QP0[1]) * 2 / 3) # QP0 + 2/3 *(QP1-QP0)

# CP2 = Point(QP2[0] + (QP1[0] - QP2[0]) * 2 / 3, QP2[1] + (QP1[1] - QP2[1]) * 2 / 3) # QP2 + 2/3 *(QP1-QP2)

# CP3 = QP2

# #points[-3] = CP0

# points[-2] = CP1

# points[-1] = CP2

# points.append(CP3)

@staticmethod

def __svg_path_tokenizer(d):

i = 0

while i < len(d):

c = d[i]

o = ord(c)

if o in (32, 9, 10, 13,44):

i = i + 1

elif o >= 45 and o <= 57:

j = i+1

while j < len(d):

oj = ord(d[j])

if ((oj < 45) or (oj > 57)) and (oj != ord('e')):

break

j = j + 1

yield float(d[i:j])

i = j

elif c in ['M','L','H','V','C','S','Q','T','A','Z', 'm','l','h','v','c','s','q','t','a','z']:

yield c

i = i + 1

else:

raise Exception("invalid character in path data: chr("

""" Calcule le rapport entre le premier et le deuxième segment du path.

Cela est utilisé en pratique pour distinguer le l minuscule du

I majuscule

"""

def distance((x1,y1),(x2,y2)):

return math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1))

l1 = distance(path.points[0], path.points[1])

l2 = distance(path.points[1], path.points[2])

__slots__ = ('database', 'tolerance', 'min_scale', 'max_scale', 'styles', 'force_horizontal', 'angle_tolerance_deg', 'space_width')

def __init__(self, tolerance, min_scale, max_scale, styles=[], force_horizontal = False, angle_tolerance_deg = 5):

self.database = {}

self.tolerance = tolerance

self.min_scale = min_scale

self.max_scale = max_scale

self.styles = styles

self.force_horizontal = force_horizontal

self.angle_tolerance_deg = angle_tolerance_deg

self.space_width = None

def add(self, value, path, alternatives=[]):

# On utilise le début de la commande du path comme

# index de la database:

idx = path.commands[:path.commands.index('Z')]

if not idx in self.database:

self.database[idx] = []

self.database[idx].append((value, path, alternatives))

def save_to_svg(self, filename):

f = open(filename,"w")

f.write("""<?xml version="1.0"?>\n<svg

xmlns="http://www.w3.org/2000/svg"

xml:space="preserve"

xmlns:svg="http://www.w3.org/2000/svg"

height="1052.5"

width="1488.75"

version="1.1">

""")

f.write(u"<!-- inversion de l'axe Y pour remettre à l'endroit:\n<g transform='matrix(1,0,0,-1,0,0)'>-->\n".encode("utf-8"))

for elems in self.database.itervalues():

for value, path, _ in elems:

f.write(' <path style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"\n d="')

f.write(path.d)

f.write('">\n')

f.write(" <title>" + value + "</title>\n")

f.write(" </path>\n")

f.write("<!--</g>-->\n")

f.write("</svg>\n")

f.close()

def load_from_svg(self, filename):

"""Charge les paths de référence pour la reconnaissance depuis un fichier SVG.

La valeur associée à reconnaître est stockée dans le titre des paths."""

root = ET.parse(filename).getroot()

elems = []

#sys.stdout.write((u"#Charge les path: " + os.path.basename(filename) + "\n").encode("utf-8"))

for p in root.iter('{http://www.w3.org/2000/svg}path'):

# La valeur à reconnaître pour le path est stockée dans le titre:

title = p.find('{http://www.w3.org/2000/svg}title')

if title != None:

elems.append((title.text, Path.from_svg(p.get('d'))))

if len(elems) == 0:

raise Exception("Aucun path avec un titre (<title>) dans le fichier " + filename)

# La façon de reconnaître le texte contenu dans un path consiste à

# comparer le début du path avec chacun des éléments de référence

# conterus dans la database jusqu'à en trouver un qui correspond,

# puis reconnaître la suite du path.

# Pour certains caratère, comme ceux avec accents (ex: é) le

# début du path vas être le même que la version sans sans accent

# (ex: e) donc il est important de comparer d'abord avec la version

# la plus complexe des path pour reconnaître é avant e, sans quoi

# un fois reconnus e, l'accent tout seul qui suit ne serait pas

# reconnu.

# On utilise un tri topologique pour prendre en compte ces dépendances.

# Mais il y a un autre problème à traiter: celui des caractrès

# différents qui sont représentés par un même path éqvivalent mais

# avec un angle différent, c'est le cas du carctère u qui est un n

# à l'envers ou de p et d. On ne peut pas trier ces cas là (car

# c'est une dépendance circulaire) mais on vas les traiter de

# façon particulière, en enregistrant pour chacun d'eux la liste

# des alternatives possibles qu'il faudra potentiellement

# considérer si on l'a reconnu.

deps = { i:set() for i in xrange(len(elems))}

alternatives = [set() for i in xrange(len(elems))]

for i in xrange(len(elems)-1):

value_i, path_i = elems[i]

for j in xrange(i+1,len(elems)):

value_j, path_j = elems[j]

if value_i != value_j:

i_startswith_j = path_i.startswith(path_j, tolerance = self.tolerance, min_scale=self.min_scale, max_scale=self.max_scale)

j_startswith_i = path_j.startswith(path_i, tolerance = self.tolerance, min_scale=self.min_scale, max_scale=self.max_scale)

if i_startswith_j:

if j_startswith_i:

#alternatives[i].add(j)

#alternatives[j].add(i)

angle_deg = abs(int(round(i_startswith_j*180/math.pi)))

#sys.stdout.write((u"#caractère %s ~(%d°) %s\n" % (value_i, (angle_deg/2)*2, value_j)).encode("utf-8"))

if angle_deg < self.angle_tolerance_deg:

alternatives[i].add(j)

#if angle_deg < 5:

# for v,p in [(value_i,path_i), (value_j,path_j)]:

# print " - %s : p0_distance : %f" %(v, p.p0_distance())

# print " len(points) : %d" % len(p.points)

# print " l2 / l1 = %f" % rapport_l2_sur_l1(p)

# #print str([(p.points[i][0]-p.points[i-1][0], p.points[i][1]-p.points[i-1][1]) for i in xrange(1, len(p.points))])

else:

#sys.stdout.write((value_i + " commence par " + value_j + "\n").encode("utf-8"))

deps[i].add(i)

elif j_startswith_i:

#sys.stdout.write((value_j + " commence par " + value_i + "\n").encode("utf-8"))

deps[j].add(i)

for i in toposort(deps):

val, path = elems[i]

alters = [elems[j] for j in alternatives[i]]

self.add(val, path, alters)

# Calcule la distance d'un espace comme la moité de la largeur moyenne des caractères:

# en considérant que les caractères sont horizontal (angle = 0)

largeur_moyenne = sum([largeur_path(0, path) for value,path in elems]) / len(elems)

self.space_width = largeur_moyenne / 2

#print "Largeur espaces = " + str(self.space_width)

def recognize(self, path):

if self.styles:

path_styles = path.style.split(';')

for s in self.styles:

if not s in path_styles: return None

original_path = path

result = ""

if self.force_horizontal:

original_angle = 0.0

else:

original_angle = None

previous_position = None

while len(path.points):

found = False

idx = path.commands[:path.commands.find('Z')]

if idx in self.database:

for value, compare_path, alternatives in self.database[idx]:

startswith = path.startswith(compare_path, tolerance=self.tolerance, min_scale=self.min_scale, max_scale=self.max_scale)

if startswith:

angle = startswith

if original_angle != None:

diff_angle = abs(angle - original_angle)

if diff_angle > math.pi:

diff_angle = abs(2*math.pi - diff_angle)

if (diff_angle * 180 / math.pi) > self.angle_tolerance_deg:

# Ce caractère est reconu mais pas avec le bon angle, on passe

continue

else:

# Le premier caractère du path déterminera l'angle du mot

# PB: traiter les alternatives (par exemple un mot qui commence par u OU n il faut considérer les deux possibilitées,

# qui peuvent ếtre déterminer par l'angle.

# Au lieux d'analyser toutes les alternatives, on vérifie que la positions du point suivant dans le path sera bien

# en avant par rapport au caractère considéré courant.

# FIXME: il faudrait mieux analyser toutes les alternatives possibles et renvoyer la liste de celle qui on reconnu tout le path

positions = projections_points(angle, path.points[:len(compare_path.points)])

if len(path.points) > len(compare_path.points):

mean_cur_position = sum(positions)/len(positions)

next_point_position = projection_point(angle, path.points[len(compare_path.points)])

if next_point_position < mean_cur_position:

#sys.stdout.write((u"caractère rejeté: " + value + "\n").encode("utf-8"))

# Le caractère suivant serait dérrière, on a pas du choisir le bon angle, c'est à dire

# le bon caractère à reconnaître, on continue pour en chercher un autre:

continue

original_angle = angle

#result = result + "angle(%.2f)" % (original_angle*180/math.pi)

if len(alternatives):

# Il y a des alternatives pour ce caractère, on vas utiliser le rapport_l2_l1 pour les

# départager

# NOTE: cela est fait en pratique uniquement pour distinguer le l minuscule du I majuscule

cur_rapport_l2_sur_l1 = rapport_l2_sur_l1(path)

compare_raport_l1_l2 = rapport_l2_sur_l1(compare_path)

for alt_value, alt_path in alternatives:

alt_rapport_l2_sur_l1 = rapport_l2_sur_l1(alt_path)

if abs(cur_rapport_l2_sur_l1-alt_rapport_l2_sur_l1) < abs(cur_rapport_l2_sur_l1-compare_raport_l1_l2):

value = alt_value

compare_raport_l1_l2 = alt_rapport_l2_sur_l1

# Calcule de la position des points por déterminer si il y a un espace

positions = projections_points(original_angle, path.points[:len(compare_path.points)])

if previous_position != None:

distance = min(positions) - previous_position

else:

distance = 0

previous_position = max(positions)

#result = result + "loc[%.2f,%.2f] pos[%.2f .. %.2f]" % (path.points[0][0], path.points[0][1], min(positions), max(positions))

#result = result + (" distance(%.2f)" % distance)

if distance > self.space_width:

result = result + " "

result = result + value

#result = result + ("(%.1f)" % (angle*180/math.pi))

# Maintenant on traite la suite du path:

path = Path(

path.commands[len(compare_path.commands):],

path.points[len(compare_path.points):])

found = True

break;

if not found:

break

if result:

if len(path.points):

# On a pas tout reconnu

result += "???"

position = original_path.bbox().center()

return result, position, original_angle

else:

return max(

[ max((abs(points1[i][0] - points2[i][0]),

abs(points1[i][1] - points2[i][1])))

""" Parse un fichier PDF obtenue depuis le cadastre,

pour y trouver les <path>

Les path qui nous intéressent sont tous dans le même groupe <g>,

donc on ignore completement les transformations de

coordonées (pdf transform).

"""

def __init__(self, path_handlers = None):

self.path_handlers = path_handlers if path_handlers else []

def add_path_handler(self, path_handler):

self.path_handlers.append(handler)

def parse(self, filename):

bbox_filename = os.path.splitext(filename)[0] + ".bbox"

self.cadastre_projection, cadastre_bbox = open(bbox_filename).read().split(":")

self.cadastre_bbox = BoundingBox(*[float(v) for v in cadastre_bbox.split(",")])

self.pdf_bbox = None

ext = os.path.splitext(filename)[1]

if ext == ".svg":

parser = xml.parsers.expat.ParserCreate()

parser.StartElementHandler = self.handle_start_element

parser.ParseFile(open(filename))

elif ext == ".pdf":

pipe = subprocess.Popen([

os.path.join(THIS_DIR, "pdfparser", "pdfparser"),

filename],

bufsize=128*1024, stdout=subprocess.PIPE).stdout

while True:

line = pipe.readline()

if not line:

break

path = Path.from_svg(line.rstrip())

path.style = pipe.readline().rstrip()

self.handle_path(path)

else:

raise Exception("not a pdf or svg filename: " + filename)

def handle_start_element(self, name, attrs):

name = name.lower()

if name.lower() == "path":

path = Path.from_svg(attrs["d"])

if "style" in attrs:

path.style = attrs["style"].replace(" ","")

self.handle_path(path)

def handle_path(self, path):

if self.pdf_bbox == None:

# Try to find the bbox (a white rectangle)

if (path.commands == "MLLLLZ"

and "fill:#ffffff" in path.style.split(";")):

self.pdf_bbox = path.bbox()

self.pdf_to_cadastre_transform = PDFToCadastreTransform(self.pdf_bbox, self.cadastre_bbox).transform_point

#sys.stdout.write("pdf bbox:" + str(self.bbox) + "\n")

else:

for path_handler in self.path_handlers:

if path_handler(path, self.pdf_to_cadastre_transform):

#osm_bbox = BoundingBox.of_points(housenumbers.keys())

output.write("<?xml version='1.0' encoding='UTF-8'?>\n")

output.write("<osm version='0.6' generator='%s' upload='false'>\n" % (sys.argv[0],))

id = 0;

for number, position, angle in housenumbers:

id = id-1;

output.write(" <node id='%d' lon='%f' lat='%f'>\n" %

(id, position.x, position.y))

output.write(" <tag k='addr:housenumber' v='%s' />\n"

% (number,))

output.write((" <tag k='source' v='" + SOURCE_TAG + "'' />\n").encode("utf-8"))

output.write(u" <tag k='fixme' v='À vérifier et associer à la bonne rue' />\n".encode("utf-8"))

output.write(" </node>\n")

def __init__(self):

TextPathRecognizer.__init__(self, tolerance=0.05, min_scale=0.8, max_scale=1.2, styles=["fill:#000000"])

self.load_from_svg(REFERENCE_HOUSENUMBERS)

self.housenumbers = []

def handle_path(self, path, transform):

found = self.recognize(path)

if found:

text, position, angle = found

if text[0] in ["1","2","3","4","5","6","7","8","9"]:

self.housenumbers.append((text, transform(position), angle))

return text.find("???") == -1

housenumber_recognizer = HousenumberPathRecognizer()

cadastre_parser = CadastreParser([housenumber_recognizer.handle_path])

for pdf_filename in pdf_filename_list:

cadastre_parser.parse(pdf_filename)

cadastre_projection, cadastre_housenumbers = \

pdf_vers_cadastre_housenumbers(pdf_filename_list)

cadastre_to_osm_transform = CadastreToOSMTransform(cadastre_projection).transform_point

osm_housenumbers = [

(value, cadastre_to_osm_transform(position),angle) for (value, position,angle) in

cadastre_housenumbers]

write_osm_for_housenumbers(osm_output, None, osm_housenumbers)

if (len(argv) < 2):

args_fatal_error("fichier .pdf non spécifié")

pdf_filename_list = sys.argv[1:]

if pdf_filename_list[-1].endswith(".osm"):

osm_output = open(pdf_filename_list.pop(),"w")

else:

osm_output = sys.stdout

for f in pdf_filename_list:

if (not f.endswith(".svg")) and (not f.endswith(".pdf")):

args_fatal_error("l'argument n'est pas un fichier .pdf ou .svg: " + f)

if not os.path.exists(f):

args_fatal_error("fichier non trouvé: " + f)

bboxfile = f[:-4] + ".bbox"

if not os.path.exists(bboxfile):

args_fatal_error("fichier .bbox correspondant non trouvé: " + bboxfile)