def __gt__(self, other):
if self.source.point != other.source.point and self.to.point != other.to.point:
line_level = max(self.source.point.y, other.source.point.y)
line_p1 = Point(0, line_level)
line_p2 = Point(1, line_level)
x_self, _ = utils.intersect(self.source.point, self.to.point,
line_p1, line_p2)
x_other, _ = utils.intersect(other.source.point, other.to.point,
line_p1, line_p2)
if x_self is None:
x_self = self.source.point.x
if x_other is None:
x_other = self.to.point.x
return x_self > x_other
if self.source.point == other.source.point:
origin = self.source.point
self_angle = utils.polar_angle(origin, self.to.point)
other_angle = utils.polar_angle(origin, other.to.point)
return self_angle < other_angle
else:
origin = self.to.point
self_angle = utils.polar_angle(origin, self.source.point)
other_angle = utils.polar_angle(origin, other.source.point)
return self_angle > other_angle
def search(self):
db = connect()
game_search = list(tokenize(self.search_box.get()))
game_ids = None
mechanics_ids = None
categories_ids = None
if len(game_search) > 0:
ids = []
for token in game_search:
# Append array of ids
ids.append(
list(
map(lambda g: g['id'],
db.get_by_posting('games', 'word', token))))
game_ids = list(reduce(reduce_intersection, ids))
if len(self.mechanics) > 0:
ids = []
for mechanic_item in self.mechanics:
mechanic_id = mechanic_item.value
ids.append(
list(
map(
lambda tuple: tuple[0],
db.get_by_posting('game_mechanic', 'mechanic',
mechanic_id))))
mechanics_ids = list(reduce(reduce_intersection, ids))
if len(self.categories) > 0:
ids = []
for category_item in self.categories:
category_id = category_item.value
ids.append(
list(
map(
lambda tuple: tuple[0],
db.get_by_posting('game_category', 'category',
category_id))))
categories_ids = list(reduce(reduce_intersection, ids))
results = list(
intersect(intersect(game_ids, mechanics_ids), categories_ids)
or [])
self.present_results(results)
def pick_entity(self, pos, ray):
"""Picks an entity and returns it.
:param pos: The origin of the ray
:type pos: :class:`mathlib.Vec`
:param ray: The normalized ray vector
:type ray: :class:`mathlib.Vec`
:returns: The entity picked
:rtype: :class:`game.entities.entity.Entity` or None
"""
# This is the list of the entities, sorted by z-axis (reverse order)
entities = sorted([
self.entities[e_id] for e_id in self.server_entities_map.values()
if self.entities[e_id].bounding_box
],
key=lambda entity: entity.bounding_box[1].z,
reverse=True)
# Check eventual intersections between the ray and the bounding boxes
for e in entities:
if intersect(pos, ray, e.bounding_box):
return e
return None
def otherSegmentConnected(self, other):
'''Need to know if the other segment is connected to this segment. If we test intersection including endpoints, then the other segment is connected if the intersection is at this segements endpoints where s = 0 or s = 1'''
s, t = utils.intersect(self.p1, other.p1, self.vector, other.vector)
#print("connection check: " + str(s) + ", " + str(t))
if (s == 0 or s == 1) and (t == 0 or t == 1):
return True
return False
def crashing_moves(game):
"""Return banned moves where we could potentially crash into another snake."""
banned_moves = []
our_neigh = game.me.head().neighbours(False)
# Find heads that are 8 directional neighbours to us
for s in game.other_snakes:
# If another snakes neighbours are neighbours to us
# Only do this if the snake's length is >= ours
if s.length() < game.me.length():
continue
other_neigh = s.head().neighbours(False)
same_neighbours = utils.intersect(our_neigh, other_neigh)
# If we have some of the same neighbours,
# don't move in that direction
if len(same_neighbours) > 0:
for n in same_neighbours:
# Rank how bad the move is
# if there we are sharing a neighbour that is a food, that is really bad
# if we are just sharing a neighbour, less bad
goodness = 0
if n not in game.foods:
goodness = 0.5
banned_moves = banned_moves + map(lambda d: Move(d, goodness, 'crashing'), game.me.moves_to(n))
return banned_moves
def most_frequent_old(self):
freq_words = set(self.news[0].all_text)
for i in range(1, len(self.news)):
freq_words = intersect(freq_words, self.news[i].all_text)
freq_words = {word for word in freq_words if word.upper() not in COUNTRIES}
freq_dict = dict.fromkeys(freq_words, 0)
for word in freq_words:
for new in self.news:
all_text = new.translated['title'] + new.translated['lead'] + new.translated['content']
all_text = all_text.lower()
c = all_text.count(word.lower())
freq_dict[word] += c
for word, c in freq_dict.items():
for ent in self.name:
if word in ent and len(ent) > len(word):
try:
freq_dict[ent] += freq_dict[word]
freq_dict[word] = 0
except KeyError:
try:
freq_dict[ent] = freq_dict[word]
del freq_dict[word]
except KeyError:
continue
ans = sorted(freq_dict.items(), key=operator.itemgetter(1), reverse=True)
ans = [a[0] for a in ans if a[1] != 0]
self.frequent = ans
return ans
def seg_intersect(self, segment: Tuple[Point, Point]) -> bool:
"""
Return true if segment intersects the polygon, but does not share a vertex.
"""
return any(
utils.intersect(*segment, *edge, closed=False)
for edge in self.segments)
def computeWordOvelap(imgc, word_gt, words, wordsOk, wordsFp):
best_match = 0
best_match2 = 0
for det_word in words:
try:
cv2.rectangle(imgc, (det_word[0], det_word[1]),
(det_word[2], det_word[3]), (0, 0, 255))
for gt_box in word_gt:
rect_int = utils.intersect(det_word, gt_box)
int_area = utils.area(rect_int)
union_area = utils.area(utils.union(det_word, gt_box))
ratio = int_area / float(union_area)
ratio2 = int_area / utils.area(gt_box)
if ratio > best_match:
best_match = ratio
w = det_word
best_match2 = ratio2
if best_match2 > 0.3:
wordsOk.append(det_word)
elif best_match == 0:
wordsFp.append(det_word)
except:
pass
return (best_match, best_match2)
def computeWordOvelap(imgc, word_gt, words, wordsOk, wordsFp):
best_match = 0
best_match2 = 0
for det_word in words:
try:
cv2.rectangle(imgc, (det_word[0], det_word[1]), (det_word[2], det_word[3]), (0, 0, 255))
for gt_box in word_gt:
rect_int = utils.intersect( det_word, gt_box )
int_area = utils.area(rect_int)
union_area = utils.area(utils.union(det_word, gt_box))
ratio = int_area / float(union_area)
ratio2 = int_area / utils.area(gt_box)
if ratio > best_match:
best_match = ratio
w = det_word
best_match2 = ratio2
if best_match2 > 0.3:
wordsOk.append(det_word)
elif best_match == 0:
wordsFp.append(det_word)
except:
pass
return (best_match, best_match2)
def ss(xq, xb, G):
n, d = xb.shape
ks = [1, 5, 10, 20, 50, 100, 1000]
Ts = [2**i for i in range(2 + int(math.log2(n)))]
nlist = 100
m = 8
quantizer = faiss.IndexFlatL2(d) # this remains the same
index = faiss.IndexIVFPQ(quantizer, d, nlist, m, 8)
# 8 specifies that each sub-vector is encoded as 8 bits
index.train(xb)
index.add(xb)
print("# Probed \t Items \t", end="")
for top_k in ks:
print("top-%d\t" % (top_k), end="")
print()
for t in Ts:
index.nprobe = t # make comparable with experiment above
D, ids = index.search(xq, t) # search
items = np.mean([len(id) for id in ids])
print("%6d \t %6d \t" % (t, items), end="")
for top_k in ks:
rc = intersect(G[:, :top_k], ids)
print("%.4f \t" % (rc / float(top_k)), end="")
print()
def intersectSegmentRaw(self, segment):
'''Same as above, but instead we are only looking ahead of ray not behind and we want full range of t: 0<=t<=1'''
s, t = utils.intersect(self.position, segment.p1, self.direction,
segment.vector)
if s > 0:
return t
return None
def search(self):
self.results.clear()
self.results.add_item('No items found!')
string = self.search_bar.get()
if string == None:
return
tokens = tokenize(string)
if len(tokens) <= 0:
return
db = connect()
indexes = None
for token in tokens:
values = db.postings['publishers_word'].get_values(token)
if len(values) > 0:
indexes = list(intersect(indexes, values))
if indexes == None or len(indexes) <= 0:
return
self.results.clear()
for idx in indexes:
publisher = db.tables['publishers'].load(idx)
item = ListItem(publisher, publisher['name'])
self.results.add_item(item)
self.ui.move_focus(self.results)
def pick_entity(self, pos, ray):
"""Picks an entity and returns it.
:param pos: The origin of the ray
:type pos: :class:`mathlib.Vec`
:param ray: The normalized ray vector
:type ray: :class:`mathlib.Vec`
:returns: The entity picked
:rtype: :class:`game.entities.entity.Entity` or None
"""
# This is the list of the entities, sorted by z-axis (reverse order)
entities = sorted(
[
self.entities[e_id]
for e_id in self.server_entities_map.values()
if self.entities[e_id].bounding_box
],
key=lambda entity: entity.bounding_box[1].z, reverse=True)
# Check eventual intersections between the ray and the bounding boxes
for e in entities:
if intersect(pos, ray, e.bounding_box):
return e
return None
def test_split_rectangles():
for tc in test_cases:
result = split_rectangles(tc)
info = f'{tc} {result}'
assert not utils.intersect(result), info
assert utils.total_area(tc) == sum(r.area for r in result), info
assert utils.bounding_box(tc) == utils.bounding_box(result), info
def find_sequence(layers, periods, symbols, global_start, global_target, args,
recorder):
"""Main Algorithm"""
# number of scales available
nscales = len(periods)
# active symbols - everything on scale 0
active_symbols = [global_start
] # layers[0].ts[symbols[global_start].t[0]].domain
targets = [global_target]
i = 0
tick = 0
scale = 0
any_target_found = utils.intersect(targets, active_symbols)
while not any_target_found:
for s in active_symbols:
symbols[s].retrieval_tick = tick
# fetch all symbols that follow from a given set of active symbols
next_symbols = layers[scale].expand(active_symbols, symbols, tick)
# the next active symbols are all those that are not already in the set
# of active symbols, and for which the retrieval tick is not yet set
active_symbols = [
s for s in next_symbols
if s not in active_symbols and symbols[s].retrieval_tick < 0
]
recorder.record_expansion(scale, tick, global_start, targets,
active_symbols,
utils.intersect(targets, active_symbols))
# increase scale if we didn't find anything on this one
if i >= args.max_i:
scale += 1
if scale >= nscales:
scale = nscales - 1
i = 0
i += 1
tick += 1
# check if we reached the destination
any_target_found = utils.intersect(targets, active_symbols) != []
if any_target_found:
break
def intersectVector(self, pos, vec):
'''Does this segment intersect a vector?'''
s, t = utils.intersect(self.p1, pos, self.vector, vec)
#print(self.name + " intersects " + other.name + " using (s, t) -> ("+str(s)+", "+str(t)+")")
#print("s="+str(s)+", t="+str(t))
if 0 < s < 1 and t >= 0:
return True
return False
def intersectSegmentEndpoints(self, other):
'''In a special case we want to know when this segment is intersecting the other segment only at this segments endpoints'''
#print("Checking endpoint intersections")
#print(self.name + " ..... " + other.name)
s, t = utils.intersect(self.p1, other.p1, self.vector, other.vector)
if (s == 0 or s == 1) and 0 < t < 1:
return t
return None
def _is_simple_split(self, u: int, p: Point, v: int) -> bool:
"""
Return True if connecting u->p and p->v creates two mutually simple
polygons within the original polygon.
"""
u = self.pts[u]
v = self.pts[v]
# Checks if u->p or p->v intersects any side of the polygon.
for i, j in self.segments:
if u not in (i, j):
if utils.intersect(u, p, i, j):
return False
if v not in (i, j):
if utils.intersect(v, p, i, j):
return False
return True
def find_sequence_on_scale(layers, scale, symbols, start, targets, args,
recorder):
"""Find a sequence from start to target on a certain scale."""
# initializiation
# active_symbols = [start]
# this is the horror...
# XXX: change to [start] to prevent back-activation of symbols?
active_symbols = layers[scale].ts[symbols[start].t[scale]].domain
tick = 0
any_target_found = False
recorder.record_expansion(scale, tick, start, targets, active_symbols,
utils.intersect(targets, active_symbols))
any_target_found = utils.intersect(targets, active_symbols) != []
while not any_target_found:
# update 'retrieval tick' -> this emulates refractory periods of place
# cells. This comes from marking symbols as "expanded"
for s in active_symbols:
symbols[s].retrieval_tick = tick
# predict next batch of symbols, and remove currently active ones
next_symbols = layers[scale].expand(active_symbols, symbols, tick)
active_symbols = [
s for s in next_symbols
if s not in active_symbols and symbols[s].retrieval_tick < 0
]
# update time
tick += 1
# record everything!!1
recorder.record_expansion(scale, tick, start, targets, active_symbols,
utils.intersect(targets, active_symbols))
# check if we reached the destination
any_target_found = utils.intersect(targets, active_symbols) != []
if any_target_found:
break
return utils.intersect(targets, active_symbols)
def computeSegmOverlap(gt_rects, segmentations, MIN_SEGM_OVRLAP=0.6):
segm2chars = 0
for k in range(len(gt_rects)):
gt_rect = gt_rects[k]
best_match = 0
best_match_line = 0
if (gt_rect[4] == ',' or gt_rect[4] == '.' or gt_rect[4] == '\''
or gt_rect[4] == ':'
or gt_rect[4] == '-') and not evalPunctuation:
continue
best_match2 = 0
for detId in range(segmentations.shape[0]):
rectn = segmentations[detId, :]
rect_int = utils.intersect(rectn, gt_rect)
int_area = utils.area(rect_int)
union_area = utils.area(utils.union(rectn, gt_rect))
ratio = int_area / float(union_area)
if ratio > best_match:
best_match = ratio
if ratio > best_match_line and rectn[7] == 1.0:
best_match_line = ratio
gt_rect[5] = best_match
if best_match < MIN_SEGM_OVRLAP:
if k < len(gt_rects) - 1:
gt_rect2 = gt_rects[k + 1]
chars2Rect = utils.union(gt_rect2, gt_rect)
rect_int = utils.intersect(rectn, chars2Rect)
int_area = utils.area(rect_int)
union_area = utils.area(utils.union(rectn, chars2Rect))
ratio = int_area / float(union_area)
if ratio > best_match2:
if ratio > MIN_SEGM_OVRLAP:
segm2chars += 1
best_match2 = ratio
gt_rect[5] = ratio
gt_rect2[5] = ratio
def lower_envelop(intervals, key):
assert (np.all(
[float('inf') > key(interval, interval[0]) for interval in intervals]))
assert (np.all([
math.fabs(interval[0] - interval[1]) > eps for interval in intervals
]))
start_points = [(interval[0], i) for (i, interval) in enumerate(intervals)]
end_points = [(interval[1], i) for (i, interval) in enumerate(intervals)]
points = sorted(start_points + end_points)
active_intervals = []
minimum = []
while len(points) > 0:
current_x = points[0][0]
# process all events
while len(points) > 0 and points[0][0] <= current_x + eps:
x, index = points.pop(0)
if index >= 0:
interval = intervals[index]
if interval[0] + eps >= current_x:
active_intervals.append(index)
else:
assert (interval[1] + eps >= current_x)
active_intervals.remove(index)
if len(active_intervals) > 0:
next_x = points[0][0]
epsilon_key = lambda a: (eps_round(a[0]), eps_round(a[1]))
sorted_intervals = sorted([(key(intervals[index], current_x),
key(intervals[index], next_x), index)
for index in active_intervals],
key=epsilon_key)
current_y = sorted_intervals[0][0]
minimum.append((current_x, sorted_intervals[0][2]))
for (y_1, y_1_next, index_1), (y_2, y_2_next, index_2) in zip(
sorted_intervals[:-1], sorted_intervals[1:]):
# FIXME this need to be replaced by a real intersection test
#if y_1 < y_2 and y_1_next > y_2_next:
x_1_min, x_1_max, _, f_1 = intervals[index_1]
x_2_min, x_2_max, _, f_2 = intervals[index_2]
x_min, x_max = intersect((x_1_min, x_1_max),
(x_2_min, x_2_max))
x_min = max(current_x, x_min)
if x_min < x_max:
intersections = intersect_functions(
f_1, f_2, (x_min, x_max))
points += [(x, -1) for x in intersections]
points = sorted(points)
xs = [x for x, _ in minimum] + [float('inf')]
idxs = [index for _, index in minimum]
result = []
for x_min, x_max, idx in zip(xs[:-1], xs[1:], idxs):
result.append((x_min, x_max, idx))
return result
def getIntersectionMatrix(self):
'''Get the sMatrix which shows how all of the segments intersect each other'''
sMatrix = {} #Value for key segment to intersect the other segments
for segment in self.segments:
sMatrix[segment.name] = {}
for other in self.segments:
if other is not segment:
s, t = utils.intersect(segment.p1, other.p1,
segment.vector, other.vector)
sMatrix[segment.name][other.name] = t
return sMatrix
def run():
seed(time.time())
g = lambda: randint(1, 100)
while True:
n = randint(2, 100)
print(f'n = {n}')
recs = [Rect(g(), g(), g(), g()) for _ in range(n)]
result = split_rectangles(recs)
assert not utils.intersect(result)
assert utils.bounding_box(recs) == utils.bounding_box(result)
assert utils.total_area(recs) == sum(r.area for r in result)
def intersectSegment(self, other, includeEndpoints=False):
'''Segment-Segment intersection. Segments physically intersect each other'''
s, t = utils.intersect(self.p1, other.p1, self.vector, other.vector)
#print(self.name + " intersects " + other.name + " using (s, t) -> ("+str(s)+", "+str(t)+")")
if includeEndpoints:
if 0 < s < 1 and 0 <= t <= 1:
return True
else:
if 0 < s < 1 and 0 < t < 1:
return True
return False
def getOtherIntersectionValue(self, other, includeEndpoints=False):
'''Get the value of intersection for the other segment where this segment has its endpoint on the other segment'''
s, t = utils.intersect(self.p1, other.p1, self.vector, other.vector)
#print(self.name + " intersects " + other.name + " using (s, t) -> ("+str(s)+", "+str(t)+")")
if includeEndpoints:
if (s == 0 or s == 1) and 0 <= t <= 1:
return t
else:
if (s == 0 or s == 1) and 0 < t < 1:
return t
return None
def computeSegmOverlap(gt_rects, segmentations, MIN_SEGM_OVRLAP = 0.6):
segm2chars = 0
for k in range(len(gt_rects)):
gt_rect = gt_rects[k]
best_match = 0
best_match_line = 0
if (gt_rect[4] == ',' or gt_rect[4] == '.' or gt_rect[4] == '\'' or gt_rect[4] == ':' or gt_rect[4] == '-') and not evalPunctuation:
continue
best_match2 = 0
for detId in range(segmentations.shape[0]):
rectn = segmentations[detId, :]
rect_int = utils.intersect( rectn, gt_rect )
int_area = utils.area(rect_int)
union_area = utils.area(utils.union(rectn, gt_rect))
ratio = int_area / float(union_area)
if ratio > best_match:
best_match = ratio
if ratio > best_match_line and rectn[7] == 1.0 :
best_match_line = ratio
gt_rect[5] = best_match
if best_match < MIN_SEGM_OVRLAP:
if k < len(gt_rects) - 1:
gt_rect2 = gt_rects[k + 1]
chars2Rect = utils.union(gt_rect2, gt_rect)
rect_int = utils.intersect( rectn, chars2Rect )
int_area = utils.area(rect_int)
union_area = utils.area(utils.union(rectn, chars2Rect))
ratio = int_area / float(union_area)
if ratio > best_match2:
if ratio > MIN_SEGM_OVRLAP:
segm2chars += 1
best_match2 = ratio
gt_rect[5] = ratio
gt_rect2[5] = ratio
def intersectSegment(self, segment, includeEndpoints=False):
'''Returns the s value indicating where the intersection is occuring on the segment. If no intersection, then None is returned. If s is negative, then the intersection is happening behind it.'''
s, t = utils.intersect(self.position, segment.p1, self.direction,
segment.vector)
if includeEndpoints:
#print("s, t = " + str(s) + ", " + str(t))
if 0 <= t <= 1:
if s != 0 and s != 1: #still need to ignore endpoints where this segment is connected to
return s
else:
if 0 < t < 1:
return s
return None
def split(self, other):
'''Split this segment into 2 segments. We really just create 1 new Segment and then modify this segment.'''
s, t = utils.intersect(self.p1, other.p1, self.vector, other.vector)
if t == 0: #other.p1 intersects this segment
segment2 = Segment(other.p1, self.p2, self.virtual, self.name+"_2")
self.p2 = other.p1
#segment1 = Segment(self.p1, other.p1, self.virtual)
elif t == 1: #other.p2 intersects this segment
segment2 = Segment(other.p2, self.p2, self.virtual, self.name+"_2")
self.p2 = other.p2
#segment1 = Segment(self.p1, other.p2, self.virtual)
return segment2
def cutout_process(image, boxes, labels, fill_val=0, bbox_remove_thres=0.4):
image = image[0]
boxes = boxes[0]
labels = labels[0]
original_h = image.size(1)
original_w = image.size(2)
original_channel = image.size(0)
new_image = image
for _ in range(50):
# Random cutout size: [0.15, 0.5] of original dimension
cutout_size_h = random.uniform(0.15 * original_h, 0.5 * original_h)
cutout_size_w = random.uniform(0.15 * original_w, 0.5 * original_w)
# Random position for cutout
left = random.uniform(0, original_w - cutout_size_w)
right = left + cutout_size_w
top = random.uniform(0, original_h - cutout_size_h)
bottom = top + cutout_size_h
cutout = torch.FloatTensor(
[int(left), int(top), int(right),
int(bottom)])
# Calculate intersect between cutout and bounding boxes
overlap_size = intersect(cutout.unsqueeze(0), boxes)
area_boxes = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
ratio = overlap_size / area_boxes
# If all boxes have Iou greater than bbox_remove_thres, try again
if ratio.min().item() > bbox_remove_thres:
continue
cutout_arr = torch.full(
(original_channel, int(bottom) - int(top), int(right) - int(left)),
fill_val)
new_image[:, int(top):int(bottom), int(left):int(right)] = cutout_arr
# Create new boxes and labels
boolean = ratio < bbox_remove_thres
new_boxes = boxes[boolean[0], :]
new_labels = labels[boolean[0]]
return new_image.unsqueeze(dim=0), new_boxes.unsqueeze(
dim=0), new_labels.unsqueeze(dim=0)
def find_topics(self, mode={"country": 1, "not_country": 2}):
""" Find initial topics """
for row in self.data:
others = [r for r in self.data if r.country != row.country]
# others = [r for r in self.data if r.id != row.id]
for ot in others:
cw = intersect(row.all_text, ot.all_text)
# cw = {w for w in cw if w[0].islower() or w in COUNTRIES}
if count_not_countries(cw) >= mode["not_country"] and count_countries(cw) >= mode["country"]:
# if len(cw) >= 4 and count_countries(cw) >= 1:
news = [row, ot]
new_topic = Topic(cw, news)
self.topics.append(new_topic)
self.topics = list(set(self.topics))
def narrow_docids(self, idx):
m0 = [ decode_array(idx[w]) for w in self.r0 if idx.has_key(w) ]
if self.r0 and not m0:
return []
m2 = [ decode_array(idx[w]) for w in self.r2 if idx.has_key(w) ]
if self.r2 and not m2:
return []
if self.r1:
try:
refs = intersect( decode_array(idx[w]) for w in self.r1 )
except KeyError:
return []
refs = union(refs, [ m for m in (m0,m2) if m ])
elif not self.r2:
refs = merge(m0)
else:
refs = union(merge(m0), [m2])
# Now: refs = [ docid1,sentid1, docid2,sentid2, ... ]
locs = [ (refs[i], refs[i+1]) for i in xrange(0, len(refs), 2) ]
return locs
def narrow_docids(self, idx):
m0 = [decode_array(idx[w]) for w in self.r0 if idx.has_key(w)]
if self.r0 and not m0:
return []
m2 = [decode_array(idx[w]) for w in self.r2 if idx.has_key(w)]
if self.r2 and not m2:
return []
if self.r1:
try:
refs = intersect(decode_array(idx[w]) for w in self.r1)
except KeyError:
return []
refs = union(refs, [m for m in (m0, m2) if m])
elif not self.r2:
refs = merge(m0)
else:
refs = union(merge(m0), [m2])
# Now: refs = [ docid1,sentid1, docid2,sentid2, ... ]
locs = [(refs[i], refs[i + 1]) for i in xrange(0, len(refs), 2)]
return locs
def encode(self, s, block=None):
""" Encode a message.
Parameters
----------
s : str
A message to encode.
block : int, optional
Divide output into blocks of this size. All non-transcodable
symbols will be stripped. Specify the value `0` to strip all
non-transcodable symbols and not divide into blocks.
Specify the value `None` to disable chunking. Default `None`.
Returns
-------
out : str
The encoded message.
Notes
-----
Although this can invoke either `self._encode` or `super().encode`, it
essentially falls prey to the "call super" antipattern and should
probably be refactored. [TODO]
"""
if block is not None:
# filter message to characters in ciphertext alphabet
s = intersect(s, self.alphabet)
if block > 0:
padding = upward_factor(block, len(s))
s = s.ljust(padding, self.DEFAULT_NULLCHAR)
out = super().encode(s)
if block is not None and block > 0:
out = ' '.join(chunks(out, block))
return ''.join(out)
def update_vision(self):
agents = set()
for tile in self.tile.neighbors(self.sight):
agents.update(tile.agents)
agents.remove(self)
vision = []
for sight_dir in utils.linspace(-self.aov / 2, self.aov / 2,
self.n_cell):
sight_dir = self.direction + sight_dir
min_sight = 1.0
for agent in agents:
sight = utils.intersect(self.x, self.y, self.sight, sight_dir,
agent.x, agent.y, agent.size / 2)
min_sight = min(sight, min_sight)
vision.append(min_sight)
self.vision = vision
self.reward = 0
for agent in agents:
if self.is_collide_with(agent):
self.reward -= 1
def handleCollisions(self): carNumber = 0 for car in self.cars: if car.isAlive: car.update() if self.canBeUpdated(carNumber): rayPoints = [[], [], [], [], [], [], []] car.rayPoints = [[], [], [], [], [], [], []] for i in range(0, len(self.walls)-1): for j in range(0, len(car.edgesPointsAprox)-1): if utils.intersect(car.edgesPointsAprox[j], car.edgesPointsAprox[j+1], self.walls[i], self.walls[i+1]): if car.isAlive: car.isAlive = False self.deadCars += 1 break points = utils.lineRayIntersectionPoint(car.position, (car.leftPoint[0] - car.position[0], car.leftPoint[1] - car.position[1]), self.walls[i], self.walls[i+1]) if points: rayPoints[0] += points points = utils.lineRayIntersectionPoint(car.position, (car.frontLeft2Point[0] - car.position[0], car.frontLeft2Point[1] - car.position[1]), self.walls[i], self.walls[i+1]) if points: rayPoints[1] += points points = utils.lineRayIntersectionPoint(car.position, (car.frontLeftPoint[0] - car.position[0], car.frontLeftPoint[1] - car.position[1]), self.walls[i], self.walls[i+1]) if points: rayPoints[2] += points points = utils.lineRayIntersectionPoint(car.position, (car.frontPoint[0] - car.position[0], car.frontPoint[1] - car.position[1]), self.walls[i], self.walls[i+1]) if points: rayPoints[3] += points points = utils.lineRayIntersectionPoint(car.position, (car.frontRightPoint[0] - car.position[0], car.frontRightPoint[1] - car.position[1]), self.walls[i], self.walls[i+1]) if points: rayPoints[4] += points points = utils.lineRayIntersectionPoint(car.position, (car.frontRight2Point[0] - car.position[0], car.frontRight2Point[1] - car.position[1]), self.walls[i], self.walls[i+1]) if points: rayPoints[5] += points points = utils.lineRayIntersectionPoint(car.position, (car.rightPoint[0] - car.position[0], car.rightPoint[1] - car.position[1]), self.walls[i], self.walls[i+1]) if points: rayPoints[6] += points for i in range(0, len(rayPoints)): if rayPoints[i]: index = 0 minDist = utils.distance(rayPoints[i][0], car.position) for j in range(0, len(rayPoints[i])): dist = utils.distance(rayPoints[i][j], car.position) if dist < minDist: minDist = dist; index = j car.inputs[i] = minDist car.rayPoints[i] = int(round(rayPoints[i][index][0])), int(round(rayPoints[i][index][1])) else: car.rayPoints[i] = (0, 0) car.inputs = [float(i)/max(car.inputs) for i in car.inputs] for i in range(0, len(self.cookies)): for j in range(0, len(car.edgesPointsAprox)-1): if utils.intersect(car.edgesPointsAprox[j], car.edgesPointsAprox[j+1], self.cookies[i][0], self.cookies[i][1]): f = lambda a,b: a if (a > b) else b maxCookie = -1 if car.lastsCookies: maxCookie = functools.reduce(f, car.lastsCookies) if i not in car.lastsCookies and i > maxCookie: car.lastsCookies.append(i) car.incrementFitness() if len(car.lastsCookies) > 5: car.lastsCookies.pop(0) carNumber += 1
def getGenerator(self):
"""Build and return a Generator instance from an abstract
specification."""
### Instantiate (flatten) target model structured specification
## Flatten ModelSpec self.mspec using indepvarname global and inputs
# and using connectivity bindings (latter not yet implemented)
globalRefs = [self.indepvarname] + self.inputs.keys()
try:
flatspec = self.mspec.flattenSpec(self.unravelInfo, globalRefs, ignoreInputs=True)
except:
print "Problem flattening Model Spec '%s'" % self.mspec.name
print "Global refs: ", globalRefs
raise
FScompatibleNames = flatspec["FScompatibleNames"]
FScompatibleNamesInv = flatspec["FScompatibleNamesInv"]
## Check target Generator info
if self.targetGen in self.mspec.compatibleGens and self.targetGen in theGenSpecHelper:
gsh = theGenSpecHelper(self.targetGen)
if gsh.lang not in self.mspec.targetLangs:
raise ValueError("Incompatible target language between supplied" " ModelSpec and target Generator")
else:
print "ModelSpec's compatible Generators:", ", ".join(self.mspec.compatibleGens)
print "ModelConstructor target Generator:", self.targetGen
raise ValueError("Target Generator mismatch during generator " "construction")
self.targetLang = gsh.lang
## Make Generator initialization argument dictionary
a = args()
if self.abseps is not None:
a.abseps = self.abseps
a.pars = {}
parnames = flatspec["pars"].keys()
for p, valstr in flatspec["pars"].iteritems():
if valstr == "":
if FScompatibleNamesInv(p) not in self.parvalues:
raise ValueError("Parameter %s is missing a value" % FScompatibleNamesInv(p))
else:
try:
a.pars[p] = float(valstr)
except ValueError:
raise ValueError("Invalid parameter value set in ModelSpec" " for '%s'" % p)
# override any par vals set in ModelSpec with those explicitly set
# here
for p, val in self.parvalues.iteritems():
try:
pr = FScompatibleNames(p)
except KeyError:
raise NameError("Parameter '%s' missing from ModelSpec" % p)
if pr not in flatspec["pars"]:
raise NameError("Parameter '%s' missing from ModelSpec" % p)
a.pars[pr] = val
if self.icvalues != {}:
a.ics = {}
for v, val in self.icvalues.iteritems():
try:
vr = FScompatibleNames(v)
except KeyError:
raise NameError("Variable '%s' missing from ModelSpec" % v)
if vr not in flatspec["vars"]:
raise NameError("Variable '%s' missing from ModelSpec" % v)
a.ics[vr] = val
a.tdomain = self.indepvardomain
# a.ttype = 'float' or 'int' ?
a.inputs = self.inputs
a.name = self.mspec.name
xdomain = {}
pdomain = {}
for k, d in flatspec["domains"].iteritems():
# e.g. d == (float, Continuous, [-Inf, Inf])
assert d[1] == gsh.domain, "Domain mismatch with target Generator"
if k in flatspec["vars"]:
assert len(d[2]) == 2, "Domain spec must be a valid interval"
xdomain[k] = d[2]
elif k in flatspec["pars"]:
assert len(d[2]) == 2, "Domain spec must be a valid interval"
pdomain[k] = d[2]
a.xdomain = xdomain
a.pdomain = pdomain
exp_vars = [v for (v, t) in flatspec["spectypes"].items() if t == "ExpFuncSpec"]
rhs_vars = [v for (v, t) in flatspec["spectypes"].items() if t == "RHSfuncSpec"]
imp_vars = [v for (v, t) in flatspec["spectypes"].items() if t == "ImpFuncSpec"]
if gsh.specType == "RHSfuncSpec":
assert imp_vars == [], "Cannot use implicitly defined variables"
assert self.forcedAuxVars == [], "Cannot force auxiliary variables"
varnames = rhs_vars
auxvarnames = exp_vars
elif gsh.specType == "ExpFuncSpec":
assert imp_vars == [], "Cannot use implicitly defined variables"
assert rhs_vars == [], "Cannot use RHS-type variables"
varnames = exp_vars
invalid_auxvars = remain(self.forcedAuxVars, varnames)
if invalid_auxvars == []:
# then all forced aux varnames were legitimate
# so remove them from varnames and put them in auxvarnames
varnames = remain(varnames, self.forcedAuxVars)
auxvarnames = self.forcedAuxVars
else:
print "Invalid auxiliary variable names:"
print invalid_auxvars
raise ValueError("Forced auxiliary variable names were invalid")
elif gsh.specType == "ImpFuncSpec":
assert rhs_vars == [], "Cannot use RHS-type variables"
varnames = imp_vars
auxvarnames = exp_vars
# search for explicit variable interdependencies and resolve by
# creating 'reuseterms' declarations, substituting in the cross-ref'd
# definitions
# e.g. state variables v and w, and explicit aux vars are given by:
# x = 1+v
# y = f(x) + w
# Here, y illegally depends on x, so define a 'reused' temporary
# definition, and re-write in terms of that:
# temp = 1+v
# x = temp
# y = f(temp) + w
# e.g. state variables v and w, aux var x:
# v' = 1-v -f(x)
# Here, v illegally uses an auxiliary variable on the RHS, so make
# a 'reused' substitution as before
#
# first pass to find which substitutions are needed
reuseTerms, subsExpr = processReused(
varnames + auxvarnames, auxvarnames, flatspec, self.mspec._registry, FScompatibleNames, FScompatibleNamesInv
)
clash_reused = intersect(reuseTerms.keys(), self.reuseTerms.keys())
if clash_reused != []:
print "Clashing terms:", clash_reused
raise ValueError("User-supplied reused terms clash with auto-" "generated terms")
# second pass, this time to actually make the substitutions
for v in subsExpr:
flatspec["vars"][v] = subsExpr[v]
reuseTerms.update(self.reuseTerms)
a.reuseterms = reuseTerms
a.varspecs = dict(zip(varnames + auxvarnames, [flatspec["vars"][v] for v in varnames + auxvarnames]))
a.auxvars = auxvarnames
try:
a.fnspecs = flatspec["auxfns"]
except KeyError:
# no aux fns defined!
pass
a.checklevel = self.checklevel
a.algparams = self.algparams
if self.vfcodeinsert_start != "":
a.vfcodeinsert_start = self.vfcodeinsert_start
if self.vfcodeinsert_end != "":
a.vfcodeinsert_end = self.vfcodeinsert_end
## Events
events = []
# make events from bound constraints (activated accordingly)
# (parameter bounds only useful for continuation with PyCont)
domnames = varnames + parnames
for xname in domnames:
hier_name_lo = FScompatibleNamesInv(xname) + "_domlo"
FScompatibleNames[hier_name_lo] = xname + "_domlo"
FScompatibleNamesInv[xname + "_domlo"] = hier_name_lo
hier_name_hi = FScompatibleNamesInv(xname) + "_domi"
FScompatibleNames[hier_name_hi] = xname + "_domhi"
FScompatibleNamesInv[xname + "_domhi"] = hier_name_hi
if self.activateAllBounds:
a.activatedbounds = {}.fromkeys(domnames, (True, True))
else:
a.activatedbounds = self.activatedBounds
a.enforcebounds = True
# add events from user events
for e in self.userevents:
if e not in events:
events.append(e)
else:
raise ValueError, "Repeated event definition!"
# events.extend(self.userevents)
a.events = events
# Add any additional special options (e.g. 'nobuild' directive)
for k, v in self.optDict.iteritems():
if hasattr(a, k):
raise KeyError("'%s' already exists as a Generator argument" % k)
a.k = v
# keep a copy of the arguments in self for users to see what was done
self.conargs = a
self.FScompatibleNames = FScompatibleNames
self.FScompatibleNamesInv = FScompatibleNamesInv
## Make Generator
try:
return eval("Generator." + self.targetGen + "(a)")
except:
print "Problem initializing target Generator '%s'" % self.targetGen
raise
def evaluate_image(batch, detections, word_gto, iou_th=0.3, iou_th_vis=0.5, iou_th_eval=0.4):
'''
Summary : Returns end-to-end true-positives, detection true-positives, number of GT to be considered for eval (len > 2).
Description : For each predicted bounding-box, comparision is made with each GT entry. Values of number of end-to-end true
positives, number of detection true positives, number of GT entries to be considered for evaluation are computed.
Parameters
----------
iou_th_eval : float
Threshold value of intersection-over-union used for evaluation of predicted bounding-boxes
iou_th_vis : float
Threshold value of intersection-over-union used for visualization when transciption is true but IoU is lesser.
iou_th : float
Threshold value of intersection-over-union between GT and prediction.
word_gto : list of lists
List of ground-truth bounding boxes along with transcription.
batch : list of lists
List containing data (input image, image file name, ground truth).
detections : tuple of tuples
Tuple of predicted bounding boxes along with transcriptions and text/no-text score.
Returns
-------
tp : int
Number of predicted bounding-boxes having IoU with GT greater than iou_th_eval.
tp_e2e : int
Number of predicted bounding-boxes having same transciption as GT and len > 2.
gt_e2e : int
Number of GT entries for which transcription len > 2.
'''
gt_to_detection = {}
tp = 0
tp_e2e = 0
gt_e2e = 0
draw = batch[4][0]
normFactor = math.sqrt(draw.shape[1] * draw.shape[1] + draw.shape[0] * draw.shape[0]) # Normalization factor
for i in range(0, len(detections)):
det = detections[i]
boxr = det[0]
box = cv2.boxPoints(boxr) # Predicted bounding-box parameters
box = np.array(box, dtype="int") # Convert predicted bounding-box to numpy array
bbox = cv2.boundingRect(box)
bbox = [bbox[0], bbox[1], bbox[2], bbox[3]]
bbox[2] += bbox[0] # Convert width to right-coordinate
bbox[3] += bbox[1] # Convert height to bottom-coordinate
vis.draw_box_points(draw, box, color = (255, 0, 0))
det_text = det[1][0] # Predicted transcription for bounding-box
#print(det_text)
for gt_no in range(len(word_gto)):
gt = word_gto[gt_no]
txt = gt[5] # GT transcription for given GT bounding-box
gtbox = ((gt[0] * draw.shape[1], gt[1] * draw.shape[0]), (gt[2] * normFactor, gt[3] * normFactor), gt[4] * 180 / 3.14) # Re-scaling GT values
gtbox = cv2.boxPoints(gtbox)
gtbox = np.array(gtbox, dtype="int")
rect_gt = cv2.boundingRect(gtbox)
rect_gt = [rect_gt[0], rect_gt[1], rect_gt[2], rect_gt[3]]
rect_gt[2] += rect_gt[0] # Convert GT width to right-coordinate
rect_gt[3] += rect_gt[1] # Convert GT height to bottom-coordinate
inter = intersect(bbox, rect_gt) # Intersection of predicted and GT bounding-boxes
uni = union(bbox, rect_gt) # Union of predicted and GT bounding-boxes
ratio = area(inter) / float(area(uni)) # IoU measure between predicted and GT bounding-boxes
# 1). Visualize the predicted-bounding box if IoU with GT is higher than IoU threshold (iou_th) (Always required)
# 2). Visualize the predicted-bounding box if transcription matches the GT and condition 1. holds
# 3). Visualize the predicted-bounding box if transcription matches and IoU with GT is less than iou_th_vis and 1. and 2. hold
if ratio > iou_th:
vis.draw_box_points(draw, box, color = (0, 128, 0))
if not gt_to_detection.has_key(gt_no):
gt_to_detection[gt_no] = [0, 0]
if txt.lower() == det_text.lower():
to_cls_x.append([len(det_text), det[1][1], det[1][2], det[1][3]])
to_cls_y.append(1)
vis.draw_box_points(draw, box, color = (0, 255, 0), thickness=2)
gt[7] = 1 # Change this parameter to 1 when predicted transcription is correct.
if ratio < iou_th_vis:
vis.draw_box_points(draw, box, color = (255, 255, 255), thickness=2)
cv2.imshow('draw', draw)
#cv2.waitKey(0)
else:
to_cls_x.append([len(det_text), det[1][1], det[1][2], det[1][3]])
to_cls_y.append(0)
tupl = gt_to_detection[gt_no]
if tupl[0] < ratio:
tupl[0] = ratio
tupl[1] = i
# Count the number of end-to-end and detection true-positives
for gt_no in range(len(word_gto)):
gt = word_gto[gt_no]
txt = gt[5]
if len(txt) > 2:
gt_e2e += 1
if gt[7] == 1:
tp_e2e += 1
if gt_to_detection.has_key(gt_no):
tupl = gt_to_detection[gt_no]
if tupl[0] > iou_th_eval: # Increment detection true-positive, if IoU is greater than iou_th_eval
tp += 1
cv2.imshow('draw', draw)
return tp, tp_e2e, gt_e2e
def run_evaluation(inputDir, outputDir, process_color = 0, processTest = 0):
if not os.path.exists(outputDir):
os.mkdir(outputDir)
edgeThreshold = 14
fastex = FASTex(edgeThreshold = edgeThreshold)
modelFile = '/home/busta/outModel.boost'
model = cv2.Boost()
model.load(modelFile)
images = glob.glob('{0}/*.jpg'.format(inputDir))
segmDir = '{0}/segmentations'.format(inputDir)
precision = 0;
precisionDen = 0
recall = 0
recall05 = 0
recallNonMax = 0
recallDen = 0
wordRecall = 0
wordRecallDen = 0
segm2chars = 0
regionsCount = 0
regionsCountNonMax = 0
missing_segmNonMaxCount = 0
letterKeypointHistogram = defaultdict(lambda : defaultdict(float))
octaveLetterKeypointHistogram = defaultdict(lambda : defaultdict(float))
missing_letters = {}
letterHistogram = defaultdict(int)
missing_segm = {}
missing_segm2 = {}
missing_segmNonMax = {}
diffMaxOctavesMap = {}
diffScoreOctavesMap = {}
segmHistogram = []
segmWordHistogram = []
results = []
hist = None
histFp = None
histDist = None
histDistFp = None
histDistMax = None
histDistMaxWhite = None
histDistMaxFp = None
hist2dDist =None
hist2dDistFp = None
hist2dDistScore = None
hist2dDistScoreFp = None
histDistMaxWhiteFp = None
histSegm = np.zeros((256), dtype = np.float)
histSegmCount = np.zeros((256), dtype = np.int)
stat = np.asarray([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=np.float)
times = []
gtSegmCount = 0
wordsOk = []
wordsFp = []
keypointsTotal = 0
keypointsTotalInside = 0
orbTime = 0
lineNo = 0
perfectWords = 0;
perfectWordsNS = 0;
hasSegm = False
for image in images:
print('Processing {0}'.format(image))
img = cv2.imread(image, 0)
imgc = cv2.imread(image)
imgcO = cv2.imread(image)
if process_color == 1:
imgproc = imgc
else:
imgproc = img
baseName = os.path.basename(image)
baseName = baseName[:-4]
workPoint = 0.3
segmentations = fastex.getCharSegmentations(imgproc, outputDir, baseName)
segmentations = segmentations[:, 0:10]
segmentations = np.column_stack( [ segmentations , np.zeros( (segmentations.shape[0], 2), dtype = np.float ) ] )
maskDuplicates = segmentations[:, 8] == -1
segmentationsDuplicates = segmentations[maskDuplicates, :]
maskNoNei = segmentationsDuplicates[:, 9] > workPoint
segmentationsNoNei = segmentationsDuplicates[maskNoNei, :]
if segmentations.shape[0] > 0:
print( 'Dupl ratio: {0} - {1}/ {2} - {3}'.format(segmentationsDuplicates.shape[0] / float(segmentations.shape[0]), segmentationsDuplicates.shape[0], segmentations.shape[0], segmentationsNoNei.shape[0] ) )
keypoints = fastex.getLastDetectionKeypoints()
keypointsTotal += keypoints.shape[0]
statc = fastex.getDetectionStat()
times.append([ statc[1], statc[2], statc[3], statc[4], statc[5], statc[6], statc[7], statc[8], statc[9], statc[10]])
stat += statc
values = img[ keypoints[:, 1].astype(int), keypoints[:, 0].astype(int) ]
valuesMax = img[keypoints[:, 6].astype(int), keypoints[:, 5].astype(int)]
diffValMax = np.abs(values - valuesMax)
regionsCount += segmentations.shape[0]
regionsCountNonMax += segmentationsNoNei.shape[0]
segmentations[:, 2] += segmentations[:, 0]
segmentations[:, 3] += segmentations[:, 1]
keypointsOrb = fastex.getLastDetectionOrbKeypoints()
orbTime += keypointsOrb[0][9]
segmGt = '{0}/{1}_GT.txt'.format(segmDir, baseName)
pden = 0
rden = 0
if os.path.exists(segmGt):
hasSegm = True
(gt_rects, groups) = utls.read_icdar2013_segm_gt(segmGt)
segmImg = '{0}/{1}_GT.bmp'.format(segmDir, baseName)
if not os.path.exists(segmImg):
segmImg = '{0}/gt_{1}.png'.format(segmDir, baseName)
segmImg = cv2.imread(segmImg)
try:
(hist, histFp, histDist, histDistMax, histDistMaxWhite, hist2dDist, hist2dDistScore, histDistFp, histDistMaxFp, histDistMaxWhiteFp, hist2dDistFp, hist2dDistScoreFp, keypointsInside) = collect_histograms(img, segmImg, keypoints, values, diffValMax, keypointsTotalInside, diffMaxOctavesMap, diffScoreOctavesMap, hist, histFp, histDist, histDistMax, histDistMaxWhite, hist2dDist, hist2dDistScore, histDistFp, histDistMaxFp, histDistMaxWhiteFp, hist2dDistFp, hist2dDistScoreFp)
except:
pass
rcurrent = 0
rcurrent05 = 0
rcurrentNonMax = 0
for k in range(len(gt_rects)):
gt_rect = gt_rects[k]
best_match = 0
best_match_line = 0
if (gt_rect[4] == ',' or gt_rect[4] == '.' or gt_rect[4] == '\'' or gt_rect[4] == ':' or gt_rect[4] == '-') and not evalPunctuation:
continue
gtSegmCount += 1
rectMask = np.bitwise_and(np.bitwise_and( keypointsInside[:, 0] >= gt_rect[0], keypointsInside[:, 0] <= gt_rect[2]), np.bitwise_and(keypointsInside[:, 1] >= gt_rect[1], keypointsInside[:, 1] <= gt_rect[3]))
letterInside = keypointsInside[rectMask, :]
#make keypoints histogram
if letterInside.shape[0] > 0:
octaves = np.unique( letterInside[:, 2])
maxOctave = np.max(octaves)
maxOctavePoints = 0
for i in range(int(maxOctave) + 1):
octavePoints = letterInside[letterInside[:, 2] == i, :]
maxOctavePoints = max(maxOctavePoints, octavePoints.shape[0])
if maxOctavePoints > 0:
octaveLetterKeypointHistogram[gt_rect[4]][0] += 1
if maxOctavePoints > 1:
octaveLetterKeypointHistogram[gt_rect[4]][1] += 1
if maxOctavePoints > 2:
octaveLetterKeypointHistogram[gt_rect[4]][2] += 1
if maxOctavePoints > 3:
octaveLetterKeypointHistogram[gt_rect[4]][3] += 1
if letterInside.shape[0] == 0:
if not missing_letters.has_key(gt_rect[4]):
missing_letters[gt_rect[4]] = []
missing_letters[gt_rect[4]].append( (image, gt_rect) )
if letterInside.shape[0] > 0:
letterKeypointHistogram[gt_rect[4]][0] += 1
if letterInside.shape[0] > 1:
letterKeypointHistogram[gt_rect[4]][1] += 1
if letterInside.shape[0] > 2:
letterKeypointHistogram[gt_rect[4]][2] += 1
if letterInside.shape[0] > 3:
letterKeypointHistogram[gt_rect[4]][3] += 1
letterHistogram[gt_rect[4]] += 1
best_match2 = 0
minSingleOverlap = MIN_SEGM_OVRLAP
if gt_rect[4] == 'i' or gt_rect[4] == '!':
minSingleOverlap = 0.5
for detId in range(segmentations.shape[0]):
rectn = segmentations[detId, :]
rect_int = utils.intersect( rectn, gt_rect )
int_area = utils.area(rect_int)
union_area = utils.area(utils.union(rectn, gt_rect))
ratio = int_area / float(union_area)
rectn[10] = max(ratio, rectn[10])
if rectn[9] > workPoint:
gt_rect[6] = max(ratio, gt_rect[6])
if ratio > best_match:
best_match = ratio
best_segm = segmentations[detId, :]
if ratio > best_match_line and rectn[7] == 1.0 :
best_match_line = ratio
if best_match < minSingleOverlap:
if k < len(gt_rects) - 1:
gt_rect2 = gt_rects[k + 1]
chars2Rect = utils.union(gt_rect2, gt_rect)
rect_int = utils.intersect( rectn, chars2Rect )
int_area = utils.area(rect_int)
union_area = utils.area(utils.union(rectn, chars2Rect))
ratio = int_area / float(union_area)
rectn[10] = max(ratio, rectn[10])
if ratio > best_match2:
if ratio > MIN_SEGM_OVRLAP:
segm2chars += 1
best_match2 = ratio
gt_rect[5] = ratio
gt_rect2[5] = ratio
thickness = 1
color = (255, 0, 255)
if best_match >= minSingleOverlap:
color = (0, 255, 0)
if best_match > 0.7:
thickness = 2
cv2.rectangle(imgc, (gt_rect[0], gt_rect[1]), (gt_rect[2], gt_rect[3]), color, thickness)
recall += best_match
recallNonMax += gt_rect[6]
if best_match >= minSingleOverlap:
recall05 += best_match
rcurrent05 += best_match
else:
if not missing_segm.has_key(image):
missing_segm[image] = []
missing_segm[image].append(gt_rect)
if gt_rect[5] < MIN_SEGM_OVRLAP:
if not missing_segm2.has_key(image):
missing_segm2[image] = []
missing_segm2[image].append(gt_rect)
segm2chars += 1
if gt_rect[6] < minSingleOverlap:
if not missing_segmNonMax.has_key(image):
missing_segmNonMax[image] = []
missing_segmNonMax[image].append(gt_rect)
missing_segmNonMaxCount += 1
rcurrent += best_match
rcurrentNonMax += gt_rect[6]
recallDen += 1
rden += 1
if best_match > 0 and process_color != 1:
val = img[best_segm[5], best_segm[4]]
histSegm[val] += best_match
histSegmCount[val] += 1
pcurrent = 0
for detId in range(segmentations.shape[0]):
best_match = 0
rectn = segmentations[detId, :]
for gt_rect in gt_rects:
rect_int = utils.intersect( rectn, gt_rect )
int_area = utils.area(rect_int)
union_area = utils.area(utils.union(rectn, gt_rect))
ratio = int_area / float(union_area)
if ratio > best_match:
best_match = ratio
precision += best_match
pcurrent += best_match
precisionDen += 1
pden += 1
if pden == 0:
pcurrent = 0
else:
pcurrent = pcurrent / pden
if rden == 0:
rcurrent = 0
rcurrent05 = 0
rcurrentNonMax = 0
else:
rcurrent = rcurrent / rden
rcurrent05 = rcurrent05 / rden
rcurrentNonMax = rcurrentNonMax / rden
segmHistogram.append([ segmentations.shape[0], segmentations[segmentations[:, 10] > 0.4].shape[0], segmentations[segmentations[:, 10] > 0.5].shape[0], segmentations[segmentations[:, 10] > 0.6].shape[0], segmentations[segmentations[:, 10] > 0.7].shape[0] ])
segmWordHistogram.append([segmentations.shape[0], segmentations[np.bitwise_or(segmentations[:, 10] > 0.5, segmentations[:, 11] > 0.5 )].shape[0]])
results.append((baseName, rcurrent, pcurrent, rcurrent05))
if precisionDen == 0:
pcurrent = 0
else:
precision = precision / precisionDen
if recallDen == 0:
rcurrent = 0
else:
recall = recall / recallDen
recall05 = recall05 / recallDen
recallNonMax = recallNonMax / recallDen
wordRecall = wordRecall / max(1, wordRecallDen)
try:
histSegm = histSegm / max(1, histSegmCount)
except ValueError:
pass
print('Evalation Results:')
print( 'recall: {0}, precision: {1}, recall 0.5: {2}, recall NonMax: {3}'.format(recall, precision, recall05, recallNonMax) )
kpTimes = np.histogram(np.asarray(times)[:, 0], bins=20)
print('Keypoint Time Histogram: {0}'.format(kpTimes))
print('Detection statistics:')
print(stat)
for letter in letterKeypointHistogram.keys():
for num in letterKeypointHistogram[letter].keys():
letterKeypointHistogram[letter][num] = letterKeypointHistogram[letter][num] / float(letterHistogram[letter])
for num in octaveLetterKeypointHistogram[letter].keys():
octaveLetterKeypointHistogram[letter][num] = octaveLetterKeypointHistogram[letter][num] / float(letterHistogram[letter])
letterKeypointHistogram[letter] = dict(letterKeypointHistogram[letter])
octaveLetterKeypointHistogram[letter] = dict(octaveLetterKeypointHistogram[letter])
print('Perfect words: {0}'.format(perfectWords))
eval_date = datetime.date.today()
np.savez('{0}/evaluation'.format(outputDir), recall=recall, recall05 = recall05, recallNonMax=recallNonMax, precision=precision, eval_date=eval_date, regionsCount=regionsCount, inputDir = inputDir, hist = hist, histSegm = histSegm, stat=stat, letterKeypointHistogram = dict(letterKeypointHistogram), missing_letters=missing_letters, octaveLetterKeypointHistogram=dict(octaveLetterKeypointHistogram), missing_segm=missing_segm,
times=np.asarray(times), histFp = histFp, gtSegmCount = gtSegmCount, wordRecall=wordRecall, histDist=histDist, histDistFp = histDistFp, histDistMax=histDistMax, histDistMaxFp=histDistMaxFp, hist2dDist=hist2dDist, hist2dDistFp=hist2dDistFp, hist2dDistScore=hist2dDistScore, hist2dDistScoreFp=hist2dDistScoreFp, histDistMaxWhite=histDistMaxWhite, histDistMaxWhiteFp=histDistMaxWhiteFp, wordsOk=wordsOk, wordsFp=wordsFp, diffMaxOctavesMap = diffMaxOctavesMap, diffScoreOctavesMap = diffScoreOctavesMap,
missing_segm2=missing_segm2, segmHistogram=segmHistogram, segmWordHistogram=segmWordHistogram, regionsCountNonMax=regionsCountNonMax, missing_segmNonMax=missing_segmNonMax)
print( "GT segmentations count {0}".format(gtSegmCount) )
print('FasTex Inside {0}/{1} ({2})'.format(keypointsTotalInside, keypointsTotal, keypointsTotalInside / float(keypointsTotal) ))
print('FasText time: {0}, Orb time: {1} '.format( np.sum(times, 0)[0], orbTime))
print('2 Chars Segmentation: {0}'.format(segm2chars) )
print('NonMax Regions Count: {0}/{1}'.format(regionsCountNonMax, missing_segmNonMaxCount))
def process_batch(nets, optim, optim2, image_size, args):
global it, mean_loss, mean_rec
net, net_ctc = nets
net = net.net
net_ctc = net_ctc.net
net.blobs['data'].reshape(args.batch_size,1,image_size[1],image_size[0])
net.reshape()
it += 1
optim2.step(1)
im = net.blobs['data'].data[...]
draw = np.swapaxes(im,2,3)
draw = np.swapaxes(draw,1,3)
im_ctc = np.copy(draw)
draw += 1
draw *= 128
draw = np.array(draw, dtype="uint8").copy()
if args.debug:
grid_step = 16
line = 0
while line < image_size[0]:
cv2.line(draw[0], (0, line), (image_size[1], line), (128, 128, 128))
line += grid_step
boxes = net.blobs['boxes'].data[...]
word_gtob = net.blobs['gt_boxes'].data[...]
word_txt = net.blobs['gt_labels'].data[...]
lines_gtob = net.blobs['line_boxes'].data[...]
lines_txt = net.blobs['line_labels'].data[...]
#nms = boxeso[:, 0, 0, 8] == 0
#boxes = boxes[:, :, nms, :]
boxes[:, 0, :, 0] *= image_size[0]
boxes[:, 0, :, 1] *= image_size[1]
normFactor = math.sqrt(image_size[1] * image_size[1] + image_size[0] * image_size[0])
boxes[:, 0, :, 2] *= normFactor
boxes[:, 0, :, 3] *= normFactor
sum_cost = 0
count = 0
labels_gt = []
labels_det = []
gt_to_detection = {}
net_ctc.clear_param_diffs()
batch_buckets = []
dummy = {}
matched_detections = 0
for bid in range(im.shape[0]):
o_image = net.layers[0].get_image_file_name(bid)
o_image = cv2.imread(o_image, cv2.IMREAD_GRAYSCALE)
cx = net.layers[0].get_crop(bid, 0)
cy = net.layers[0].get_crop(bid, 1)
cmx = net.layers[0].get_crop(bid, 2)
cmy = net.layers[0].get_crop(bid, 3)
o_image = o_image[cy:cmy, cx:cmx]
boxes_count = 0
for i in range(0, boxes.shape[2]):
det_word = boxes[bid, 0, i]
if (det_word[0] == 0 and det_word[1] == 0) or det_word[5] < 0.01:
break
boxes_count += 1
x = [i for i in range(boxes_count)]
#random.shuffle(x)
bucket_images = {}
batch_buckets.append(bucket_images)
word_gto = word_gtob[bid]
word_gto_txt = word_txt[bid]
gt_count = 0
for gt_no in range(word_gto.shape[0]):
gt = word_gto[gt_no, :]
gt = gt.reshape(6)
gtnum = 1000 * bid + gt_no
if gt[5] == -1:
#print("ignore gt!")
continue
gt_count += 1
txt = word_gto_txt[gt_no, :]
gtbox = ((gt[0] * image_size[0], gt[1] * image_size[1]), (gt[2] * normFactor, gt[3] * normFactor), gt[4] * 180 / 3.14)
gtbox = cv2.boxPoints(gtbox)
gtbox = np.array(gtbox, dtype="int")
rect_gt = cv2.boundingRect(gtbox)
if rect_gt[0] == 0 or rect_gt[1] == 0 or rect_gt[0] + rect_gt[2] >= image_size[0] or rect_gt[1] + rect_gt[3] >= image_size[1]:
continue
if gt[3] * normFactor < 3:
if args.debug:
#print('too small gt!')
vis.draw_box_points(draw[bid], gtbox, color = (255, 255, 0))
cv2.imshow('draw', draw[bid])
continue
if args.debug:
vis.draw_box_points(draw[bid], gtbox, color = (0, 0, 0), thickness=2)
#vis.draw_box_points(draw[bid], gtbox, color = (255, 255, 255))
#cv2.imshow('draw', draw[bid])
rect_gt = [rect_gt[0], rect_gt[1], rect_gt[2], rect_gt[3]]
rect_gt[2] += rect_gt[0]
rect_gt[3] += rect_gt[1]
for i in range(0, min(100, boxes_count)):
if math.fabs(gt[4] - det_word[4]) > math.pi / 16:
continue
det_word = boxes[bid, 0, x[i], :]
if (det_word[0] == 0 and det_word[1] == 0) or det_word[5] < 0.01:
break
box = ((det_word[0], det_word[1]), (det_word[2], det_word[3]), det_word[4] * 180 / 3.14)
box = cv2.boxPoints(box)
if args.debug:
boxp = np.array(box, dtype="int")
vis.draw_box_points(draw[bid], boxp, color = (0, 255, 0))
box = np.array(box, dtype="int")
bbox = cv2.boundingRect(box)
bbox = [bbox[0], bbox[1], bbox[2], bbox[3]]
bbox[2] += bbox[0]
bbox[3] += bbox[1]
#rectangle intersection ...
inter = intersect(bbox, rect_gt)
uni = union(bbox, rect_gt)
ratio = area(inter) / float(area(uni))
ratio_gt = area(inter) / float(area(rect_gt))
if ratio_gt < 0.95:
continue
if ratio < 0.5:
continue
if not gt_to_detection.has_key(gtnum):
gt_to_detection[gtnum] = [0, 0, 0]
tupl = gt_to_detection[gtnum]
if tupl[0] < ratio:
tupl[0] = ratio
tupl[1] = x[i]
tupl[2] = ratio_gt
det_word = boxes[bid, 0, x[i], :]
box = ([det_word[0], det_word[1]], [det_word[2], det_word[3]], det_word[4] * 180 / 3.14)
boxO = get_obox(im_ctc[bid], o_image, box)
boxO = ((boxO[0][0], boxO[0][1]), (boxO[1][0], boxO[1][1]), boxO[2])
norm2, rot_mat = get_normalized_image(o_image, boxO)
#norm3, rot_mat = get_normalized_image(im_ctc[bid], ([det_word[0], det_word[1]], [det_word[2] * 1.2, det_word[3] * 1.1], det_word[4] * 180 / 3.14))
if norm2 is None:
continue
#if norm3 is None:
# continue
#continue
#cv2.imshow('ts', norm2)
#cv2.imshow('ts3', norm3)
#cv2.waitKey(1)
width_scale = 32.0 / norm2.shape[0]
width = norm2.shape[1] * width_scale
best_diff = width
bestb = 0
for b in range(0, len(buckets)):
if best_diff > abs(width * 1.3 - buckets[b]):
best_diff = abs(width * 1.3 - buckets[b])
bestb = b
scaled = cv2.resize(norm2, (buckets[bestb], 32))
scaled = np.asarray(scaled, dtype=np.float)
delta = scaled.max() - scaled.min()
scaled = (scaled) / (delta / 2)
scaled -= scaled.mean()
if not bucket_images.has_key(bestb):
bucket_images[bestb] = {}
bucket_images[bestb]['img'] = []
bucket_images[bestb]['sizes'] = []
bucket_images[bestb]['txt'] = []
bucket_images[bestb]['gt_enc'] = []
dummy[bestb] = 1
else:
if args.debug and len(bucket_images[bestb]) > 4:
continue
elif len(bucket_images[bestb]) > 32:
continue
gt_labels = []
txt_enc = ''
for k in range(txt.shape[1]):
if txt[0, k] > 0:
if codec_rev.has_key(txt[0, k]):
gt_labels.append( codec_rev[txt[0, k]] )
else:
gt_labels.append( 3 )
txt_enc += unichr(txt[0, k])
else:
gt_labels.append( 0 )
if scaled.ndim == 3:
scaled = cv2.cvtColor(scaled, cv2.COLOR_BGR2GRAY)
if args.debug:
cv2.imshow('scaled', scaled)
bucket_images[bestb]['sizes'].append(len(gt_labels))
bucket_images[bestb]['gt_enc'].append(gt_labels)
bucket_images[bestb]['txt'].append(txt_enc)
bucket_images[bestb]['img'].append(scaled)
matched_detections += 1
#and learn OCR
for bucket in bucket_images.keys():
imtf = np.asarray(bucket_images[bucket]['img'], dtype=np.float)
imtf = np.reshape(imtf, (imtf.shape[0], -1, imtf.shape[1], imtf.shape[2]))
#imtf = imtf.reshape((imtf.shape[0], imtf.shape[1], imtf.shape[2], 1))
#imtf = np.swapaxes(imtf,1,3)
net_ctc.blobs['data'].reshape(imtf.shape[0],imtf.shape[1],imtf.shape[2], imtf.shape[3])
net_ctc.blobs['data'].data[...] = imtf
labels = bucket_images[bucket]['gt_enc']
txt = bucket_images[bucket]['txt']
max_len = 0
for l in range(0, len(labels)):
max_len = max(max_len, len(labels[l]))
for l in range(0, len(labels)):
while len(labels[l]) < max_len:
labels[l].append(0)
labels = np.asarray(labels, np.float)
net_ctc.blobs['label'].reshape(labels.shape[0], labels.shape[1])
net_ctc.blobs['label'].data[...] = labels
if args.debug:
vis.vis_square(imtf[0])
cv2.imshow('draw', draw[0])
cv2.waitKey(5)
optim.step(1)
sum_cost += net_ctc.blobs['loss'].data[...]
if net_ctc.blobs['loss'].data[...] > 10:
vis.vis_square(imtf[0])
cv2.imshow('draw', draw[0])
sf = net_ctc.blobs['transpose'].data[...]
labels2 = sf.argmax(3)
out = utils.print_seq(labels2[:, 0, :])
print(u'{0} - {1}'.format(out, txt[0]) )
cv2.waitKey(5)
count += imtf.shape[0]
correct_cout = 0
for i in range(len(labels_gt)):
det_text = labels_det[i]
gt_text = labels_gt[i]
if it % 100 == 0:
print( u"{0} - {1}".format(det_text, gt_text).encode('utf8') )
if det_text == gt_text:
correct_cout += 1
count = max(count, 1)
mean_loss = 0.99 * mean_loss + 0.01 * sum_cost / count
mean_rec = mean_rec * 0.99 + 0.01 * correct_cout / float(max(1, len(labels_gt)))
#count detection ratio
tp = 0
for bid in range(im.shape[0]):
word_gto = word_gtob[bid]
for gt_no in range(len(word_gto)):
gt = word_gto[gt_no]
gtnum = 1000 * bid + gt_no
if gt_to_detection.has_key(gtnum):
tupl = gt_to_detection[gtnum]
if tupl[0] > 0.5:
tp += 1
loc_recall = tp / float(max(1, gt_count))
if args.debug:
cv2.imshow('draw', draw[0])
if im.shape[0] > 1:
cv2.imshow('draw2', draw[1])
cv2.waitKey(10)
if it % 10 == 0:
print('{0} - lr:{1:.3e} ctc:{2:.4f}/{3:.4f} wr:{4:.2f}/{5:.2f}, loc:{6:.2f} {7}'.format(it, 0.0001, sum_cost / count, mean_loss, correct_cout / float(max(1, len(labels_gt))), mean_rec, loc_recall, matched_detections))
if it % 1000 == 0:
optim.snapshot()
optim2.snapshot()
