def fit(self, lines): # Collate all the contours from all the 'border' words (those on the first and last lines, and # the first and last words from all other lines). borderPoints = g.PointArray() for word in self.selectBorderWords(lines): for wrappedPoint in word.contour: borderPoints.append(wrappedPoint[0]) self.angle = lines.avgAngle # interestingly, it's faster to sort the whole list, which is theoretical O(n log n), than it is # to do a min operation followed by a max operation, both of which are O(n). sortedHorizontally = sorted( borderPoints, key=lambda point: point.rotate(self.angle).x) leftPoint = sortedHorizontally[0] rightPoint = sortedHorizontally[-1] sortedVertically = sorted(borderPoints, key=lambda point: point.rotate(self.angle).y) topPoint = sortedVertically[0] bottomPoint = sortedVertically[-1] self.left = g.Line([leftPoint], self.angle) self.right = g.Line([rightPoint], self.angle) self.top = g.Line([topPoint], self.angle + 90) self.bottom = g.Line([bottomPoint], self.angle + 90) self.height = abs( topPoint.rotate(self.angle).y - bottomPoint.rotate(self.angle).y) self.width = abs( leftPoint.rotate(self.angle).x - rightPoint.rotate(self.angle).x)
def test_pseudo_tangent_contact(): circle = gm.Circle(radius=20, center=gm.Point(0, 0)) # Parallel to x-axis pt1 = gm.Point(-1, 25) pt2 = gm.Point(1, 25) l1 = gm.Line(pt1, pt2) l2 = gm.Line(pt2, pt1) iPt1 = circle.get_contact_point_pseudo_tangent(l1) iPt2 = circle.get_contact_point_pseudo_tangent(l2) print "GT: (0,20), Predict: ", iPt1 print "GT: (0,20), Predict: ", iPt2 # Parallel to y-axis pt1 = gm.Point(-25, 5) pt2 = gm.Point(-25, 50) pt3 = gm.Point(30, 5) pt4 = gm.Point(30, 50) l1 = gm.Line(pt1, pt2) l2 = gm.Line(pt3, pt4) iPt1 = circle.get_contact_point_pseudo_tangent(l1) iPt2 = circle.get_contact_point_pseudo_tangent(l2) print "GT: (-20,0), Predict: ", iPt1 print "GT: (20,0), Predict: ", iPt2 # A diagonal pt1 = gm.Point(50, 0) pt2 = gm.Point(0, 50) l1 = gm.Line(pt1, pt2) iPt1 = circle.get_contact_point_pseudo_tangent(l1) print iPt1
def make_coordinates(self): self.lTop_ = self.pos_ self.lBot_ = self.pos_ + gm.Point(0, self.sz_.y()) self.rTop_ = self.pos_ + gm.Point(self.sz_.x(), 0) self.rBot_ = self.pos_ + gm.Point(self.sz_.x(), self.sz_.y()) self.l1_ = gm.Line(self.lTop_, self.lBot_) # Left line self.l2_ = gm.Line(self.lBot_, self.rBot_) self.l3_ = gm.Line(self.rBot_, self.rTop_) self.l4_ = gm.Line(self.rTop_, self.lTop_) self.bbox_ = gm.Bbox(self.lTop_, self.lBot_, self.rBot_, self.rTop_)
def is_corner_sharp( end_point1, center_point, end_point2 ): """Returns True if angle between lines end_point1-cetner_point and center_point-end_point2 is less then 90 degrees.""" cathetus1 = geometry.Line( center_point, end_point1 ) cathetus2 = cathetus1.perpendicular( end_point1 ) hypotenuse = geometry.Line( center_point, end_point2 ) cathetus2_intersection = geometry.intersect_lines( cathetus2, hypotenuse ) if cathetus2_intersection is None: return False return cathetus1.are_on_the_same_side( end_point2, cathetus2_intersection )
def test_line_bbox_intersection(): bbox = gm.Bbox(gm.Point(1, 2), gm.Point(1, 1), gm.Point(2, 1), gm.Point(2, 2)) l1 = gm.Line(gm.Point(0, 0), gm.Point(1.5, 1.9)) l2 = gm.Line(gm.Point(0, 0), gm.Point(1, 10)) l3 = gm.Line(gm.Point(0, 1), gm.Point(5, 1)) print "GT: True, Predict:", bbox.is_intersect_line(l1) print "GT: False, Predict:", bbox.is_intersect_line(l2) print "GT: True, Predict:", bbox.is_intersect_line(l3) pt1, s1 = bbox.get_intersection_with_line(l1) pt2, s2 = bbox.get_intersection_with_line(l2) pt3, s3 = bbox.get_intersection_with_line(l3) print pt1, s1 print pt2, s2 print pt3, s3
def run_process(self, iterations): for k in range(iterations): line_hits_cluster = False while not line_hits_cluster: random_line_params = self.get_random_line() random_line = geom.Line(random_line_params[0], random_line_params[1]) if self.line_hits_cluster(random_line): line_hits_cluster = True next_particle = self.get_next_particle(random_line) """ add particle at next_particle to the cluster, remove it from the boundary_set and add its empty neighbours to it, actualize cluster_radius, so the next random line can be chosen correct accordingly """ self.particles.append(next_particle) self.actualize_boundary_set() self.actualize_cluster_radius() print(k) else: self.missed_counter += 1 #counts how often a random line missed the current cluster, as described in the paper print("line missed cluster") print("DONE") print("number of misses: " + str(self.missed_counter))
def update_rangefinder_sensors(self): """ The function to update the agent range finder sensors. """ for i, angle in enumerate(self.agent.range_finder_angles): rad = geometry.deg_to_rad(angle) # project a point from agent location outwards projection_point = geometry.Point( x=self.agent.location.x + math.cos(rad) * self.agent.range_finder_range, y=self.agent.location.y + math.sin(rad) * self.agent.range_finder_range) # rotate the projection point by the agent's heading angle to # align it with heading direction projection_point.rotate(self.agent.heading, self.agent.location) # create the line segment from the agent location to the projected point projection_line = geometry.Line(a=self.agent.location, b=projection_point) # set range to maximum detection range min_range = self.agent.range_finder_range # now test against maze walls to see if projection line hits any wall # and find the closest hit for wall in self.walls: found, intersection = wall.intersection(projection_line) if found: found_range = intersection.distance(self.agent.location) # we are interested in the closest hit if found_range < min_range: min_range = found_range # Update sensor value self.agent.range_finders[i] = min_range
def create_geometries(self): return { self.name: [ geometry.Line(start=d1, end=d2) for (d1, d2) in pairwise(self.dc.to_dc_items(self.axis)) ] }
def vertice_for_one_corner_wall( corner_point, end_point, other_end_point ): vertices = vertices_for_line_segment_end( corner_point, end_point, offset ) wall_line = geometry.Line( corner_point, end_point ) if not wall_line.are_on_the_same_side( vertices[0], other_end_point ): return vertices[0] else: return vertices[1]
def parallel_outstanding_line( corner, end, other_end ): corner_wall_line = geometry.Line( corner, end ) perpendicular = corner_wall_line.perpendicular( corner ) intersections = geometry.intersect_line_and_circle( geometry.Circle( corner, offset ), perpendicular ) assert( len( intersections ) == 2 ) if not corner_wall_line.are_on_the_same_side( intersections[0], other_end ): return perpendicular.perpendicular( intersections[0] ) else: return perpendicular.perpendicular(intersections[1])
def main(args): """ Generates a file containing the coordinates of a body. Parameters ---------- args: namespace Arguments parsed from the command-line. """ if args.body_type == 'file': body = geometry.Geometry(file_path=args.file_path) elif args.body_type == 'circle': body = geometry.Circle(radius=args.circle[0], center=geometry.Point(args.circle[1], args.circle[2]), n=args.n, ds=args.ds) elif args.body_type == 'line': body = geometry.Line(length=args.line[0], start=geometry.Point(args.line[1], args.line[2]), n=args.n, ds=args.ds) elif args.body_type == 'rectangle': body = geometry.Rectangle(bottom_left=geometry.Point(args.rectangle[0], args.rectangle[1]), top_right=geometry.Point(args.rectangle[2], args.rectangle[3]), nx=args.n, ny=args.n, ds=args.ds) elif args.body_type == 'sphere': body = geometry.Sphere(radius=args.sphere[0], center=geometry.Point(args.sphere[1], args.sphere[2], args.sphere[3]), n=args.n, ds=args.ds) body.scale(ratio=args.scale) body.rotation(center=args.rotation, roll=args.roll, yaw=args.yaw, pitch=args.pitch, mode=args.mode) body.translation(displacement=args.translation) if body.dimensions == 2 and args.body_type == 'file': body.discretization(n=args.n, ds=args.ds) if body.dimensions == 2 and args.extrusion: body = body.extrusion(limits=args.extrusion, n=args.n, ds=args.ds, force=args.force) if args.save: output_path = os.path.join(args.save_directory, args.save_name + '.' + args.extension) body.write(file_path=output_path) if args.show: body.plot()
def get_toc_ball_wall(obj1, obj2): ''' obj1: ball obj2: wall ''' lines = obj2.get_lines() vel = obj1.get_velocity() pos = obj1.get_position() r = obj1.get_radius() tCol = np.inf nrmlCol = None ptCol = None for l in lines: #This is the nrml from the line towards the point nrml = l.get_normal_towards_point(pos) nrml.scale(-1) #Normal from point towards line speed = vel.dot(nrml) if speed <=0: continue #Velocity in orthogonal direction velOrth = vel - (speed * nrml) lDir = l.get_direction() #Find the time of collision ray = gm.Line(pos, pos + nrml) intPoint = l.get_intersection_ray(ray) #print l assert intPoint is not None, ("Intersection point cannot be none - pos, nmrl", pos.x(), pos.y(), nrml.x(), nrml.y()) distCenter = pos.distance(intPoint) dist = distCenter - r if dist < 0: #It is possible that a line (but not the line segment) intersects the ball. Then #dist < 0, and we need to rule out such cases. assert distCenter >= 0 onSegment = l.is_on_segment(intPoint) if onSegment: print "Something is amiss" pdb.set_trace() else: continue t = dist / speed #Find the intersection point on line #i.e. the point linePoint = intPoint + (t * velOrth) onSegment = l.is_on_segment(linePoint) if not onSegment: continue if t < tCol: tCol = t nrml.scale(-1) nrmlCol = nrml ptCol = linePoint #pdb.set_trace() #print tCol, nrmlCol, ptCol return tCol, nrmlCol, ptCol
def paint(self, image, color=colors.YELLOW): for character in self.characters: image = character.paint(image, color) for neighbour in character.nearestNeighbours: line = g.Line([character, neighbour]) image = line.paint(image, color) return image
def test_get_normal_towards_point(): pt1 = gm.Point(0, 0) pt2 = gm.Point(1, 1) l = gm.Line(pt1, pt2) pt3 = gm.Point(1, 0) nr1 = l.get_normal_towards_point(pt3) print "GT: (0.71,-0.71), Predict: ", nr1 pt3 = gm.Point(0, 1) nr1 = l.get_normal_towards_point(pt3) print "GT: (-0.71,0.71), Predict: ", nr1
def calculate(self, face): top = Point(face.central_point.x, 0) vertical_line = geometry.Line(face.central_point, top) self.break_point_nose_point = DisplacementAngle( face.break_point, face.point_nose, vertical_line) self.central_point_wall = SymmetryAngle(face.wall, face.central_point, top) self.nose_point_wall = SymmetryAngle(face.wall, face.point_nose, face.break_point) self.nose_point_maxilar = SymmetryAngle(face.maxilar, face.point_nose, face.break_point)
def __init__(self, candidateLines): self.candidateLines = candidateLines fullLines = [ line for line in self.candidateLines if 1280 < line.box.width < 1330 ] left = g.Line([line.box.center.left for line in fullLines]) right = g.Line([line.box.center.right for line in fullLines]) # Make sure that 'start' means the same end for both geometric lines. This fixes a frustrating problem, # where in some pages most lines wouldn't be picked up. if left.start[1] < left.end[1]: left.start, left.end = left.end, left.start if right.start[1] < right.end[1]: right.start, right.end = right.end, right.start self.points = g.PointArray( [left.start, left.end, right.end, right.start])
def findTuples(self): # Get tuple info ... 2/21/2018 for character in self.characters: for neighbour in character.nearestNeighbours: line = g.Line([character, neighbour]) angle = line.calculateAngle(line.start, line.end) delta = line.start - line.end distance = math.sqrt(delta.x**2 + delta.y**2) #print("START: ",line.start, " END: ", line.end, " DIST: ", distance," ANGLE_degree: ", angle.degrees(), "ANGLE_canonical: ", angle.canonical) self.angles.append(angle.canonical) #self.angles.append(angle.degrees()) self.distances.append(distance)
def __visibility_test(self, node_a, node_b): """Performs a simple direct visibility test between two points, in an unoptimized fashion""" # Todo: ensure visibility checks cannot go through polygons (facepalm) direct_line = geometry.Line(node_a, node_b) for p in self.polygons: for l in p.lines: if l.does_intersect(direct_line, False): return False for l in p.triangle_lines: if l.does_intersect(direct_line, False): return False if direct_line in p.triangle_lines: return False return True # survived all the tests
def paint(self, image, color=colors.YELLOW): for character in self.characters: image = character.paint(image, color) for neighbour in character.nearestNeighbours: line = g.Line([character, neighbour]) image = line.paint(image, color, thickness=1) box = self.getBoundingBox() if box is not None: cv2.rectangle(image, (box[0], box[1]), (box[2], box[3]), (0, 255, 0), 1) return image
def get_random_line(self): """ We choose uniform random parameters (alpha, p) in [0, pi) x [0, 20/19 * self.cluster_radius) which is equivalent to choosing a B-isotropic line where B is a circle with radius 20/19 * self.cluster_radius with center 0 and by contstruction therefore certainly contains the current cluster. random.random() chooses uniformly in [0, 1.0) return is the parameters pair (alpha, p) """ alpha = pi * random.random() radius = self.cluster_radius + 2 #radius of a circle which certainly surrounds the current cluster p = 2 * radius * random.random() - radius return geom.Line(alpha, p)
def test_line_ray_intersection(): l1 = gm.Line(gm.Point(-5, 5), gm.Point(5, 5)) l2 = gm.Line(gm.Point(-1, 0), gm.Point(1, 10)) print "GT:(0,5) Predict:", l1.get_intersection_ray(l2) l1 = gm.Line(gm.Point(-5, 5), gm.Point(5, 5)) l2 = gm.Line(gm.Point(-1, 0), gm.Point(-1, 3)) print "GT:(-1,5) Predict:", l1.get_intersection_ray(l2) l1 = gm.Line(gm.Point(-5, 5), gm.Point(5, 5)) l2 = gm.Line(gm.Point(-1, 3), gm.Point(-1, 0)) print "GT:None Predict:", l1.get_intersection_ray(l2)
def test_line_intersection(): # Intersect x, y axis l1 = gm.Line(gm.Point(-1, 0), gm.Point(1, 0)) l2 = gm.Line(gm.Point(0, -1), gm.Point(0, 1)) print "GT:(0,0) Predict:", l1.get_intersection(l2) # 45 lines l1 = gm.Line(gm.Point(0, 0), gm.Point(1, 1)) l2 = gm.Line(gm.Point(1, 0), gm.Point(0, 1)) print "GT:(0.5,0.5) Predict:", l1.get_intersection(l2) # Parallel lines l1 = gm.Line(gm.Point(0, 0), gm.Point(1, 1)) l2 = gm.Line(gm.Point(1, 3), gm.Point(5, 7)) print "GT:None Predict:", l1.get_intersection(l2) # Parallel lines l1 = gm.Line(gm.Point(0, -1), gm.Point(0, 1)) l2 = gm.Line(gm.Point(2, -1), gm.Point(2, 1)) print "GT:None Predict:", l1.get_intersection(l2)
def get_box_coords(stPoint, enPoint, wThick=30): ''' stPoint: bottom-left point enPoint: The direction along which thickness needs to expanded. wThick: thickness of the wall ''' line = gm.Line(stPoint, enPoint) pDiff = enPoint - stPoint dist = pDiff.mag() nrml = line.get_normal() lDir = line.get_direction() # print "nrml", nrml pt1 = stPoint pt2 = pt1 + dist * lDir pt3 = pt2 - (wThick * nrml) pt4 = pt3 - (dist * lDir) pts = [pt1, pt2, pt3, pt4] # print pt1, pt2, pt3, pt4 return pts
def test_line_ray_bbox_intersection(): bbox = gm.Bbox(gm.Point(1, 2), gm.Point(1, 1), gm.Point(2, 1), gm.Point(2, 2)) l1 = gm.Line(gm.Point(0, 0), gm.Point(1.5, 1.9)) l2 = gm.Line(gm.Point(0, 0), gm.Point(1, 10)) l3 = gm.Line(gm.Point(0, 1), gm.Point(5, 1)) print "GT: True, Predict:", bbox.is_intersect_line(l1) print "GT: False, Predict:", bbox.is_intersect_line(l2) print "GT: True, Predict:", bbox.is_intersect_line(l3) l4 = gm.Line(gm.Point(1.5, 0.5), gm.Point(1.5, -0.5)) l6 = gm.Line(gm.Point(1.5, -0.5), gm.Point(1.5, 0.5)) l5 = gm.Line(gm.Point(1.5, 1.9), gm.Point(0, 0)) print "GT: False, Predict:", bbox.is_intersect_line_ray(l4) print "GT: True, Predict:", bbox.is_intersect_line(l4) print "GT: True, Predict:", bbox.is_intersect_line_ray(l6) print "GT: True, Predict:", bbox.is_intersect_line_ray(l5)
def _create_walls(self, xleft, yleft, thetas, wlens, fColor): theta1, theta2, theta3 = thetas wlen1, wlen2, wlen3 = wlens pt1 = gm.Point(xleft, yleft) dir1 = gm.theta2dir(theta1) pt2 = pt1 + (wlen1 * dir1) dir2 = gm.theta2dir(theta2) pt3 = pt2 + (wlen2 * dir2) dir3 = gm.theta2dir(theta3) pt4 = pt3 + (wlen3 * dir3) pts = [pt1, pt2, pt3, pt4] if self.verbose_ > 0: print 'Wall Points: %s, %s, %s, %s' % (pt1, pt2, pt3, pt4) walls = pm.create_cage(pts, wThick=self.wthick_, fColor=fColor) # get the lines within which the balls need to be added. self.pts = pts self.lines_ = [] for w in walls: self.world_.add_object(w) for i in range(len(pts)): self.lines_.append(gm.Line(pts[i], pts[np.mod(i + 1, len(pts))])) return walls
def propagateDown(self): self.newState = [] currentPlayer = self.state.players[self.player] for i in geometry.directions: if geometry.dot(currentPlayer.direction, i) != -1: tempState = copy.deepcopy(self.state) newPlayer = tempState.players[self.player] newPlayer.direction = i dead = False for j in range(1, newPlayer.speed + 1): newPos = newPlayer.pos + newPlayer.direction * j if (newPos.x < 0 or newPos.x > setup.gameWidth or newPos.y < 0 or newPos.y > setup.height): dead = True else: for r in range(setup.players): for line in self.state.players[r].lines: end = line.direction * line.length + line.start if (geometry.colinear(newPos, line.start, end) and min(line.start.x, end.x) <= newPos.x <= max(line.start.x, end.x) and max(line.start.y, end.y) <= newPos.y <= max(line.start.y, end.y)): dead = True if (len(newPlayer.lines) == 0 or newPlayer.lines[-1].direction != newPlayer.direction): l = geometry.Line(newPlayer.pos, newPlayer.direction, newPlayer.speed) newPlayer.lines.append(l) else: newPlayer.lines[-1].length += newPlayer.speed newPlayer.pos += newPlayer.direction * newPlayer.speed self.newState.append((Node(self.depth + 1, self.maxDepth, tempState, self.player), dead))
def find_textline(self, image): image = image.copy() ratio = 4.0 / 8.0 #ratio = 4.0/4.0 for word in self.words: #dir(word) #word.angles points = [] multiplier = 1 for character in word.characters: #print "(",character.x,", ",character.y,")" #print "nn: ", character.nearestNeighbors points.append([character.x, character.y]) points.sort(key=lambda x: x[0]) #print("points:",points) w = max(points, key=lambda x: x[0])[0] - min(points, key=lambda x: x[0])[0] #print("w:",w) h = max(points, key=lambda x: x[1])[1] - min(points, key=lambda x: x[1])[1] #print(h) dx, dy, x0, y0 = cv2.fitLine(numpy.array(points), cv2.cv.CV_DIST_L2, 0, 0.01, 0.01) #print("dx:",dx,", dy:",dy,", x0:",x0,", y0:",y0) #start = (int(x0 - dx*w*ratio), int(y0 - dy*w*ratio)) start = (int(min(points, key=lambda x: x[0])[0]), int((dy / dx) * (min(points, key=lambda x: x[0])[0] - x0) + y0)) #end = (int(x0 + dx*w*ratio), int(y0 + dy*w*ratio)) end = (int(max(points, key=lambda x: x[0])[0]), int((dy / dx) * (max(points, key=lambda x: x[0])[0] - x0) + y0)) #print(start,end) self.lines.append(g.Line([start, end])) cv2.line(image, start, end, (0, 255, 255), 2) return image
def test_point_along_line(): pt1 = gm.Point(0, 0) pt2 = gm.Point(1, 1) l = gm.Line(pt1, pt2) pt = l.get_point_along_line(pt2, 3) print pt
def create_line_instance(self): C1 = (1, 8) C2 = (8, 10) LINE = geometry.Line(C1, C2) return LINE
def getWords(self): words = [] k = 5 mode = 'horizontal' # mode = ['default','horizontal','vertical'] #EPS = 1e-2 # find the average distance between nearest neighbours NNDistances = [] NNHorizontalDistances = [] NNVerticalDistances = [] remove_counter = 0 for character in self.characters: remove_counter = remove_counter + 1 result = self.NNTree.query( character.toArray(), k=k ) # we only want nearest neighbour, but the first result will be the point matching itself. nearestNeighbourDistance = result[0] for i in xrange(1, k): #print("[%s] nearestNeighbourDistance: %s"%(remove_counter,result[0])) NNDistances.append(nearestNeighbourDistance[i]) avgNNDistance = sum(NNDistances) / len(NNDistances) maxDistance = avgNNDistance * 3 #maxDistance = avgNNDistance*20000 for character in self.characters: #print ("Finding a a nn of ",character.x,character.y) queryResult = self.NNTree.query(character.coordinate, k=k) distances = queryResult[0] neighbours = queryResult[1] for i in range(1, k): if mode == 'horizontal': ################################### # Transitive Closure - Horizontal # ################################### #if(abs(self.characters[neighbours[i]].y-character.y) < avgNNDistance/2): neighbour = self.characters[neighbours[i]] line = g.Line([character.coordinate, neighbour.coordinate]) angle = line.calculateAngle(line.start, line.end) if ( abs(angle.canonical) <= 0.261799 and distances[i] < maxDistance ): # 15(degree) = 0.261799(rad), 30(degree) = 0.523599(rad) character.nearestNeighbours.append(neighbour) NNHorizontalDistances.append(distances[i]) #print (i,"th nn!", "dist:", distances[i], " neighbor:(",neighbour.x,",",neighbour.y,")") # Below is just for calculating the most common vertical distance purpose... if ( 1.309 <= abs(angle.canonical) <= 1.8326 and distances[i] < maxDistance ): # 75(degree)=1.309(rad), 105(degree)=1.8326(rad) 60(degree)=1.0472(rad), 90(degree)=1.5708(rad), 120(degree)=2.0944(rad) NNVerticalDistances.append(distances[i]) elif mode == 'vertical': # This code might be deleted in future..? ################################### # Transitive Closure - Vertical # ################################### #if(abs(self.characters[neighbours[i]].x-character.x) < avgNNDistance/2): neighbour = self.characters[neighbours[i]] line = g.Line([character.coordinate, neighbour.coordinate]) angle = line.calculateAngle(line.start, line.end) if ( 1.309 <= abs(angle.canonical) <= 1.8326 ): # 75(degree)=1.309(rad), 105(degree)=1.8326(rad) 60(degree)=1.0472(rad), 90(degree)=1.5708(rad), 120(degree)=2.0944(rad) character.nearestNeighbours.append(neighbour) NNVerticalDistances.append(distances[i]) # print (i,"th nn!", "dist:", distances[i], " neighbor:(",neighbour.x,",",neighbour.y,") angle:",angle.canonical) else: ################################### # Transitive Closure - Default # ################################### # Find nn in every direction within maxDistance if distances[i] < maxDistance: neighbour = self.characters[neighbours[i]] character.nearestNeighbours.append(neighbour) num_bins = int( (numpy.max(NNDistances) - numpy.min(NNDistances) + 1) / 10) n, bins, patches = plt.hist(NNDistances, num_bins, facecolor='orange', alpha=0.5) plt.show() print("Total %d all NNs" % len(NNDistances)) print("average NN distance: ", avgNNDistance) num_bins = int((numpy.max(NNHorizontalDistances) - numpy.min(NNHorizontalDistances) + 1) / 10) n, bins, patches = plt.hist(NNHorizontalDistances, num_bins, facecolor='orange', alpha=0.5) plt.show() print("Total %d hor NNs" % len(NNHorizontalDistances)) dist_peaks = [] n_copy = n.copy() n_copy[::-1].sort() # sort in reverse way for i in xrange(num_bins): _max_idx = numpy.where(n == n_copy[i]) # Find peak for j in xrange(len(_max_idx[0])): dist_peaks.append(int(bins[_max_idx[0][j]])) print("Distance peaks: %s" % dist_peaks) avgHorizontalNNDistance = sum(NNHorizontalDistances) / ( len(NNHorizontalDistances)) print("average NN horizontal distance: %.2f\n" % avgHorizontalNNDistance) num_bins = int((numpy.max(NNVerticalDistances) - numpy.min(NNVerticalDistances) + 1) / 10) n, bins, patches = plt.hist(NNVerticalDistances, num_bins, facecolor='orange', alpha=0.5) plt.show() print("Total %d ver NNs" % len(NNVerticalDistances)) dist_peaks = [] n_copy = n.copy() n_copy[::-1].sort() # sort in reverse way for i in xrange(num_bins): _max_idx = numpy.where(n == n_copy[i]) # Find peak for j in xrange(len(_max_idx[0])): dist_peaks.append(int(bins[_max_idx[0][j]])) print("Distance peaks: %s" % dist_peaks) avgVerticalNNDistance = sum(NNVerticalDistances) / ( len(NNVerticalDistances)) print("average NN vertical distance: %.2f\n" % avgVerticalNNDistance) self.characters = sorted(self.characters, key=lambda character: (character.x)) for character in self.characters: #print ("Deciding wordness of (",character.x,character.y,")") if character.parentWord == None: #print ("(",character.x,character.y,") is a parent!") if len(character.nearestNeighbours) >= 0: #print ("(",character.x,character.y,") is a word!!!!") word = Word([character]) word.findTuples() words.append(word) ''' print "Total ", len(words), " words are found." for idx, word in enumerate(words): print "[",idx,"] word:" for idx_char, character in enumerate(word.characters): print "**[", idx_char, "] char info.. ", "(",character.x,",",character.y,")" ''' return words