def getScopFamily(self, id, chainid=None, resnum=None):
if len(id) == 4:
families = []
for entry in self.entriesByPdbid.get(id, []):
if chainid is not None:
# check chainid
pass
if resnum is not None:
# check resnum
pass
families.append(entry.scopfamily)
families = sort(uniq(families))
return ';'.join(families)
return ''
def rank_succession(population, k):
weights_sum = sum(algoscore.to_fitness() for _, algoscore in population)
sorted_population = sort(population)
result = list()
for _ in xrange(k):
pick = random.uniform(0, weights_sum)
current = 0
for t in sorted_population:
current += _tuple_to_score(t)
if current > pick:
result.append(t)
break
return result
def splitGoodPolygonByZonesOldVersion(goodPolygon, polygon, zones):
assert (len(polygon) == 12 and len(zones) == 5)
newPolygon = []
rays = []
for i in range(3, 7):
rays.append(GeneralizedSegment(polygon[i], polygon[i - 1], False,
True))
#print('LEN: ', len(goodPolygon))
for i in range(0, len(goodPolygon)):
p = goodPolygon[i]
np = goodPolygon[i + 1 if (i + 1 < len(goodPolygon)) else 0]
seg = GeneralizedSegment(p, np, False, False)
ps = [p]
for j in range(0, len(rays)):
inter = segmentIntersection(seg, rays[j])
if (inter is None):
continue
ps.append(inter)
ps = utils.sort(ps, ByManhattenDistanceComparator(p))
#print('PS: ', ps)
newPolygon.extend(ps)
anss = []
for i in range(0, 5):
anss.append([])
for i in range(0, len(newPolygon)):
for j in range(0, 5):
if (isInStarPolygon(newPolygon[i], zones[j])):
anss[j].append(newPolygon[i])
anssp = []
for i in range(0, 5):
#print('WorkWith12Gon: splitGoodPolygonsByZones:', i)
#for j in range(len(anss[i])):
# print(j, anss[i][j])
anss[i] = deleteThreePointsOnOneLine(anss[i])
#print('WorkWith12Gon: splitGoodPolygonsByZones after:', i)
#for j in range(len(anss[i])):
# print(j, anss[i][j])
checkIsNotThreeOnOneLine(anss[i])
if (len(anss[i]) >= 3):
anssp.append((anss[i], i))
return anssp
def createTable(gameteA, gameteB):
results = []
i = 0
j = 0
print " ",
for item in gameteB:
print " {} ".format(item),
print
print "--------------------------------------"
for x in gameteA:
results.append([])
print " {} | ".format(x),
for y in gameteB:
tmp = sort(x + y)
results[i].append(tmp)
print " {} ".format(tmp),
i += 1
print
return results
def isSegmentInPolygon(p1, p2, polygonB, T=None):
if T is None:
T = type(p1.GetX())
if not (isPointInPolygon(p1, polygonB) and isPointInPolygon(p2, polygonB)):
return False
ps = [p1, p2]
for i in range(len(polygonB)):
p = intersectSegments(p1, p2, polygonB[i], polygonB[i - 1])
if not (p is None):
ps.append(p)
ps = utils.sort(ps, ByPolarAngleAroundCenterComparator(p1))
ps = utils.unique(ps)
for i in range(len(ps)):
#print(ps[i].GetX(), ps[i].GetY(), ps[i-1].GetX(), ps[i-1].GetY())
if not isPointInPolygon((ps[i] + ps[i - 1]) / T(2), polygonB):
#print(i)
return False
return True
def list_users(message):
try:
users = session.query(User).all()
msg = u"".join([user_template.format(
user.id, user.fullname, user.age, user.gender.value, user.city, user.country) for user in sort(users)])
bot.reply_to(message, msg)
except Exception as e:
bot.reply_to(message, e.message)
import utils
# TODO Use same input and compare executaion time
@utils.measure_time
def bubble_sort(input):
swapped = True
# Precontion check
if input == None: print "You must provide a list."
if len(input) <= 1: return input
while swapped:
swapped = False # Reset the flag
for i in range(0, len(input) - 1):
if input[i] > input[i + 1]:
# Swap
temp = input[i]
input[i] = input[i + 1]
input[i + 1] = temp
swapped = True
return input
if __name__ == '__main__':
utils.sort(bubble_sort)
parser.add_argument(
"path",
default=PATH,
type=str,
help="path to activation values .hdf5 file",
nargs="?",
)
parser.add_argument(
"title", default=TITLE, type=str, help="title of the image", nargs="?"
)
args = parser.parse_args()
if __name__ == "__main__":
f = h5py.File(args.path, "r")
variance = list()
keys = sort([x for x in f.keys() if "Pretrain" in x])
pretrain = len(keys)
keys += sort([x for x in f.keys() if "Iteration" in x])
for i in keys:
variance.append(np.var(f[i], axis=1))
variance = np.array(variance).T
for i in range(len(variance)):
ax = sns.lineplot(
x=range(len(variance[0])), y=variance[i], label="Layer {}".format(i + 1)
)
x_pos = (pretrain - min(ax.get_xlim())) / (max(ax.get_xlim()) - min(ax.get_xlim()))
if pretrain:
def get_modus(self):
return sort(self.detector.percentage_sum.items())[0]
def find_updates(self, before, after):
# If a part is (partially) computed in the before and
# does not appear in the after or
# going from before to after requires undoing some computation
# it is potentially unstable, and more expensive: ignore
try:
before_finputs = self.express_in_terms_of_input(before)
after_finputs = self.express_in_terms_of_input(after)
except:
# [TODO] In LU's variant 5, parts of A appear as lhs's
return None
#
dict_bef = dict([(str(u.get_children()[0]), u)
for u in before_finputs])
dict_aft = dict([(str(u.get_children()[0]), u) for u in after_finputs])
same = []
ignore = False
for k, v in dict_bef.items():
if k in dict_aft and matchq(v, dict_aft[k]):
same.extend(v.children[0].children)
if k not in dict_aft:
ignore = True
reason = "%s not in %s" % (k, dict_aft.keys())
break
else:
rules = self.expr_to_rule_rhs_lhs([v])
rules = list(itertools.chain(*rules))
expr_copy = copy.deepcopy(dict_aft[k])
t = replace(expr_copy, rules)
#if v == replace( expr_copy, rules ):
if dict_aft[k] == t:
ignore = True
reason = "%s would require undoing job" % k
break
if ignore:
print("[INFO] Skipping invariant: %s" % reason)
return None
#
# Wrap outputs for before and after
WrapBefOut = WrapOutBef
lhss = []
for u in before:
lhss.extend(u.children[0])
u.children[0] = NList([WrapBefOut(l) for l in u.children[0]])
for u in before:
u.children[1] = replace(
u.children[1],
[RewriteRule(l, Replacement(WrapBefOut(l))) for l in lhss])
#
lhss = []
for u in after:
lhss.extend(u.children[0])
u.children[0] = NList([WrapOutAft(l) for l in u.children[0]])
wrap_rules_after = \
[
RewriteRule(l, Replacement(WrapBefOut(l))) if l in same else
RewriteRule(l, Replacement(WrapOutAft(l))) for l in lhss
]
for u in after:
u.children[1] = replace(u.children[1], wrap_rules_after)
# replace before in before
wrap_rules_before = []
for u in before:
lhs, rhs = u.get_children()
#if len(lhs.children) > 1:
#wrap_rules_before.append([])
#continue
rules = self.expr_to_rule_rhs_lhs([u])
wrap_rules_before.append(list(itertools.chain(*rules)))
#
new_rules = []
for i, rules in enumerate(wrap_rules_before):
new_rules.append([])
for rule in rules:
new_r = copy.deepcopy(rule)
new_r.pattern = replace_all(
new_r.pattern,
list(
itertools.chain.from_iterable(wrap_rules_before[:i] +
wrap_rules_before[i +
1:])))
if new_r.pattern != rule.pattern:
new_rules[-1].append(new_r)
for r1, r2 in zip(new_rules, wrap_rules_before):
r2.extend(r1)
#
wrap_rules_before = list(itertools.chain(*wrap_rules_before))
done = False
while not done:
after_top = [copy.deepcopy(u) for u in after]
for i, u in enumerate(after):
_, rhs = u.get_children()
u.children[1] = simplify(
to_canonical(
replace_all(copy.deepcopy(rhs), wrap_rules_before)))
done = True
for top, bot in zip(after_top, after):
if top != bot:
done = False
break
# replace after in after
done = False
while not done:
# replace after in after
wrap_rules_after = []
for u in after:
lhs, rhs = u.get_children()
#if len(lhs.children) > 1:
#wrap_rules_after.append([])
#continue
rules = self.expr_to_rule_rhs_lhs([u])
wrap_rules_after.append(list(itertools.chain(*rules)))
#
after_top = [copy.deepcopy(u) for u in after]
for i, u in enumerate(after):
_, rhs = u.get_children()
rules = list(
itertools.chain.from_iterable(wrap_rules_after[:i] +
wrap_rules_after[i + 1:]))
u.children[1] = simplify(
to_canonical(replace_all(copy.deepcopy(rhs), rules)))
done = True
for top, bot in zip(after_top, after):
if top != bot:
done = False
break
# [TODO] Multiple lhss, won't work
updates = []
for u in after:
lhs, rhs = u.get_children()
if len(lhs.children) == 1:
lhs = lhs.children[0] # NList[op] -> op
if isinstance(rhs, WrapBefOut) and isinstance(lhs, WrapOutAft) and \
matchq(lhs.children[0], rhs.children[0]):
continue
elif not isinstance(rhs,
NList): # multiple outputs/predicate in rhs,
# but not complete (otherwise it would be NList)
pass
else:
to_skip = True
for l, r in zip(lhs.children, rhs.children):
if not( isinstance(r, WrapBefOut) and isinstance(l, WrapOutAft) and \
matchq(l.children[0], r.children[0]) ):
to_skip = False
break
if to_skip:
continue
updates.append(u)
#
tiled_updates = []
for u in updates:
print("* ", u)
tilings = list(tile_expr(u))
if len(tilings) > 1:
print("[WARNING] Multiple (%d) tilings for expression %s" %
(len(tilings), u))
print(" Discarding all but one")
tiled_updates.extend(tilings[0])
tiled_updates = sort(tiled_updates)
print("* Tiled update")
for t in tiled_updates:
print("* ", t)
# Drop WrapOutBef's
# Drop WrapOutAft's
s = PatternDot("s")
updates = []
for u in tiled_updates:
u = replace_all(
u, [RewriteRule(WrapOutAft(s), Replacement(lambda d: d["s"]))])
u = replace_all(
u, [RewriteRule(WrapOutBef(s), Replacement(lambda d: d["s"]))])
updates.append(u)
return updates
f"You must create directory for {tol['name']} and populate it with data.yaml, config.yaml and renderer.py files."
)
continue
data = parse_yaml(datafile / "data.yaml")
config_local = parse_yaml(datafile / "config.yaml")
# Section description
description = config_local.get("description", None)
if description is not None:
f.write(p(description))
newline(f)
# Sort content of section
sort_key = config_local.get("sort_key", None)
data = sort(data, sort_key, config_local.get("sort_reverse", False))
exec(f"from {datafile}.renderer import renderer")
try:
exec(f"from {datafile}.renderer import renderer_subdir")
# e.g. content of Papers / README.md
fp_sub2 = open(str(Path(tol["name"]) / "README.md"), "w")
fp_sub2.write(h1(tol["name"]))
fp_sub2.write(
a(["Back to awesome edge machine learning", config["url"]]))
newline(fp_sub2, iter=2)
except:
pass
if not isinstance(data, list):
def fulltext(self):
"""Get errors from todays fulltext logs and generate a list for each
type of error of corresponding bibcodes and source directories. These
lists are written to files that are further processed in compute.py"""
# types of errors with corresponding file names
errors = conf['FULLTEXT_ERRORS']
# get todays date
now = datetime.strftime(datetime.now(), "%Y-%m-%d")
# loop through types of errors messages
for err_msg in errors.keys():
bibs = []
dirs = []
# location of bibcode and directory in message field
"""example log:
{"asctime": "2019-08-26T11:38:34.201Z", "msecs": 201.6739845275879,
"levelname": "ERROR", "process": 13411, "threadName": "MainThread",
"filename": "checker.py", "lineno": 238, "message": "Bibcode '2019arXiv190105463B'
is linked to a non-existent file '/some/directory/filename.xml'",
"timestamp": "2019-08-26T11:38:34.201Z", "hostname": "adsvm05"}"""
loc_bib = 1
loc_dir = 3
if (err_msg == "No such file or directory"):
loc_bib = 3
loc_dir = 11
elif (err_msg == "format not currently supported for extraction"):
loc_bib = 7
loc_dir = 23
# loop through files
for name in glob.glob(errors[err_msg]):
command = "awk -F\: '/" + err_msg + "/ && /" + now + "/ && /ERROR/ {print $0}' " + name
args = shlex.split(command)
x = Popen(args, stdout=PIPE, stderr=STDOUT)
# get bibcodes/directories from todays errors
resp = x.communicate()[0].split("\n")
for r in resp:
if r:
r = r.split("'")
bibs.append(r[loc_bib])
dirs.append(r[loc_dir])
# create filename based on error message and date
fname = Filename.get(
self.date,
FileType.FULLTEXT,
adjective=None,
msg="_" + ("_".join(err_msg.split())).replace('-', '_') + "_")
# write bibcodes and directories for each error type to file
with open(fname, 'w') as f:
writer = csv.writer(f, delimiter='\t')
writer.writerows(zip(bibs, dirs))
sort(fname)
def splitPolygonByLine(polygon, line, verbose=False):
polygon = polygon.copy()
T = type(polygon[0].GetX())
square = getDoubledOrientedSquare(polygon)
if verbose:
print('SQUARE: ', square)
if square < T(0):
if verbose:
print('REVERSE')
polygon.reverse()
signs = [lineSign(point, line) for point in polygon]
numSigns = [signs.count(0), signs.count(1), signs.count(-1)]
if numSigns[-1] == 0:
return ([], [polygon])
if numSigns[1] == 0:
return ([polygon], [])
newPolygon = []
for i in range(len(polygon)):
if signs[i] * signs[i - 1] == -1:
newPolygon.append(
segmentIntersection(
line,
GeneralizedSegment(polygon[i], polygon[i - 1], False,
False)))
newPolygon.append(polygon[i])
polygon = newPolygon
signs = [lineSign(point, line) for point in polygon]
n = len(polygon)
graph = []
for i in range(n):
graph.append([])
if i:
graph[i - 1].append(i)
graph[n - 1].append(0)
def segmentIntersectionCoordinateComparator(line):
def coordinate(point):
return (line.getSecondPoint() -
line.getFirstPoint()) ^ (point - line.getFirstPoint())
def less(num1, num2):
return coordinate(polygon[num1]) < coordinate(polygon[num2])
return less
if verbose:
print('SIGNS AFTER:', signs)
pointsOnLine = [i for i in range(n) if signs[i] == 0]
pointsOnLine = utils.sort(
pointsOnLine, less=segmentIntersectionCoordinateComparator(line))
for i in range(1, len(pointsOnLine)):
graph[pointsOnLine[i]].append(pointsOnLine[i - 1])
graph[pointsOnLine[i - 1]].append(pointsOnLine[i])
if verbose:
for i in range(n):
for j in range(len(graph[i])):
print('EDGE: ', i, graph[i][j])
used = [0] * n
ans = ([], [])
for vertex in range(n):
if signs[vertex] != 0 and used[vertex] == 0:
assert len(graph[vertex]) == 1
if verbose:
print('VERTEX: ', vertex)
currentVertex = graph[vertex][0]
previousVertex = vertex
newPolygon = [polygon[currentVertex]]
used[currentVertex] = 1
while currentVertex != vertex:
if len(graph[currentVertex]) == 1:
nextVertex = graph[currentVertex][0]
else:
less = ByDirectionPolAngleComparator(
polygon[currentVertex], polygon[previousVertex])
nextVertex = None
for v in graph[currentVertex]:
if v != previousVertex:
if nextVertex == None or less(
polygon[nextVertex], polygon[v]):
nextVertex = v
used[nextVertex] = 1
#sys.stdout.write(str(nextVertex))
#sys.stdout.write(' ')
newPolygon.append(polygon[nextVertex])
previousVertex = currentVertex
currentVertex = nextVertex
#sys.stdout.write('\n')
newPolygon = deleteThreePointsOnOneLine(newPolygon)
if signs[vertex] < 0:
ans[0].append(newPolygon)
else:
ans[1].append(newPolygon)
return ans
"""
from os import path
import json
from collections import OrderedDict
from utils import sort, error
ABS_PATH = path.dirname(path.abspath(__file__))
DB_FILE = path.realpath(path.join(ABS_PATH, "../data.json"))
with open(DB_FILE, 'r') as db_obj:
data = json.load(db_obj, object_pairs_hook=OrderedDict)
keys = list(data.keys())
ordreded_keys = sort(keys)
has_errors = False
for i in range(len(keys)):
if keys[i] != ordreded_keys[i]:
correct_position = ordreded_keys.index(keys[i])
has_errors = True
error("Database entry {} not correctly " "ordred".format(keys[i]))
print("Should be placed at {} instead "
"of {}".format(correct_position, i))
for key, value in data.items():
if value.get("linux"):
symlinks = value["linux"].get("symlinks")
if symlinks:
ordered_symlinks = sort(symlinks)
import insertion_sort, bubble_sort import utils if __name__ == '__main__': utils.sort(insertion_sort.insertion_sort) utils.sort(bubble_sort.bubble_sort)
from utils import sort
#sort('data/ppi/atpin.ppi.2evidence.no-weight.txt', 'data/arabi_gdic.txt', out='test/test.ppi.txt')
sort('data/ppi/atpin.ppi.2evidence.no-weight.txt',
'data/arabi_gdic.txt',
out='data/ppi_mat/atpin.2.no-weight.ppi.txt')
sort('data/ppi/atpin.ppi.2evidence.weight.txt',
'data/arabi_gdic.txt',
out='data/ppi_mat/atpin.2.weight.ppi.txt')
import utils
@utils.measure_time
def insertion_sort(input):
# Precondition check.
if input == None: print "Input cannot be None."
for i in range(2, len(input)):
num = input[i]
j = i
while j > 0 and num < input[j - 1]:
input[j] = input[j - 1]
j = (j - 1)
input[j] = num
if __name__ == '__main__':
utils.sort(insertion_sort)
index=False)
tb[tb['m'] > 300][['n1', 'n2', 'm']].to_csv(out_f5,
sep=' ',
header=None,
index=False)
tb[tb['m'] > 500][['n1', 'n2', 'm']].to_csv(out_f6,
sep=' ',
header=None,
index=False)
tb[tb['m'] > 700][['n1', 'n2', 'm']].to_csv(out_f7,
sep=' ',
header=None,
index=False)
tb[tb['m'] > 900][['n1', 'n2', 'm']].to_csv(out_f8,
sep=' ',
header=None,
index=False)
if __name__ == '__main__':
filt_atpin(ppi_f1)
# filt_string(ppi_f2)
d = 'data/ppi'
out_d = 'data/ppi_mult'
for i in os.listdir(d):
if i.startswith('atpin.ppi') and i.endswith('txt'):
mat_f = os.path.join(d, i)
out = os.path.join(out_d, i)
sort(mat_f, 'data/arabi_gdic.txt', out=out, rm=None)
# sort('data/atpin.ppi.4evidence.no-weight.txt', 'data/gdic.txt', out='data/test_sort.txt', rm=None)
from os import path
import json
from collections import OrderedDict
from utils import sort, error
ABS_PATH = path.dirname(path.abspath(__file__))
DB_FILE = path.realpath(path.join(ABS_PATH, "../data.json"))
with open(DB_FILE, 'r') as db_obj:
data = json.load(db_obj, object_pairs_hook=OrderedDict)
keys = list(data.keys())
ordreded_keys = sort(keys)
has_errors = False
for i in range(len(keys)):
if keys[i] != ordreded_keys[i]:
correct_position = ordreded_keys.index(keys[i])
has_errors = True
error("Database entry {} not correctly "
"ordred".format(keys[i]))
print("Should be placed at {} instead "
"of {}".format(correct_position, i))
for key, value in data.items():
if value.get("linux"):
symlinks = value["linux"].get("symlinks")
def predict(self, image):
predictions = self.detector.predict([image]).items()
self.push_percentage(predictions)
return sort(predictions)
def find_updates_v2(self, before, after):
# If a part is (partially) computed in the before and
# does not appear in the after or
# going from before to after requires undoing some computation
# it is potentially unstable, and more expensive: ignore
dict_bef = dict([(str(u.get_children()[0]), u) for u in before])
dict_aft = dict([(str(u.get_children()[0]), u) for u in after])
ignore = False
quadrant = None
for k, v in dict_bef.items():
if k not in dict_aft:
ignore = True
break
else:
rules = self.expr_to_rule_rhs_lhs([v])
rules = list(itertools.chain(*rules))
expr_copy = copy.deepcopy(dict_aft[k])
t = replace(expr_copy, rules)
#if v == replace( expr_copy, rules ):
if dict_aft[k] == t:
ignore = True
break
if ignore:
print("[INFO] Skipping invariant: %s" % reason)
return None
#
# Wrap outputs for before and after
WrapBefOut = WrapOutBef
for u in before:
u.children[0] = NList([WrapBefOut(l) for l in u.children[0]])
#
wrap_rules_after = []
for u in after:
u.children[0] = NList([WrapOutAft(l) for l in u.children[0]])
# replace before in after
wrap_rules_before = []
for u in before:
print(u)
lhs, rhs = u.get_children()
if len(lhs.children) > 1:
continue
rules = self.expr_to_rule_rhs_lhs([u])
wrap_rules_before.append(list(itertools.chain(*rules)))
#
for i, rule in enumerate(reversed(wrap_rules_before)):
idx = len(wrap_rules_before) - i - 1
for j in range(idx - 1, -1, -1):
for _rule in rule:
_rule.pattern = replace_all(_rule.pattern,
wrap_rules_before[j])
wrap_rules_before = list(itertools.chain(*wrap_rules_before))
#
for u in after:
_, rhs = u.get_children()
u.children[1] = simplify(
to_canonical(replace_all(copy.deepcopy(rhs),
wrap_rules_before)))
# replace after in after
done = False
while not done:
# replace after in after
wrap_rules_after = []
for u in after:
lhs, rhs = u.get_children()
if len(lhs.children) > 1:
wrap_rules_after.append([])
continue
rules = self.expr_to_rule_rhs_lhs([u])
wrap_rules_after.append(list(itertools.chain(*rules)))
#
after_top = [copy.deepcopy(u) for u in after]
for i, u in enumerate(after):
_, rhs = u.get_children()
rules = list(
itertools.chain.from_iterable(wrap_rules_after[:i] +
wrap_rules_after[i + 1:]))
u.children[1] = simplify(
to_canonical(replace_all(copy.deepcopy(rhs), rules)))
done = True
for top, bot in zip(after_top, after):
if top != bot:
done = False
break
# [TODO] Multiple lhss, won't work
updates = []
for u in after:
lhs, rhs = u.get_children()
lhs = lhs.children[0] # NList[op] -> op
if isinstance(rhs, WrapBefOut) and isinstance(lhs, WrapOutAft) and \
matchq(lhs.children[0], rhs.children[0]):
continue
updates.append(u)
#
tiled_updates = []
for u in updates:
print("* ", u)
tilings = list(tile_expr(u))
if len(tilings) > 1:
print("[WARNING] Multiple (%d) tilings for expression %s" %
(len(tilings), u))
print(" Discarding all but one")
tiled_updates.extend(tilings[0])
tiled_updates = sort(tiled_updates)
print("* Tiled update")
for t in tiled_updates:
print("* ", t)
# Drop WrapOutBef's
# Drop WrapOutAft's
s = PatternDot("s")
updates = []
for u in tiled_updates:
u = replace_all(
u, [RewriteRule(WrapOutAft(s), Replacement(lambda d: d["s"]))])
u = replace_all(
u, [RewriteRule(WrapOutBef(s), Replacement(lambda d: d["s"]))])
updates.append(u)
return updates
def drawGeneralizedSegment(surface, segment, color, fat=1):
T = type(segment.getFirstPoint().GetX())
rect = surface.get_rect()
a = [None] * 6
p1 = segment.getFirstPoint()
p2 = segment.getSecondPoint()
#print('drawGeneralizedSegment arguments: ', p1, p2)
if not(segment.isContinuedForFirst()) and IsValidPoint(surface, p1):
a[0] = p1
#a[0] = Point2D(float(p1.x), float(p1.y))
if not(segment.isContinuedForSecond()) and IsValidPoint(surface, p2):
a[1] = p2
#a[1] = Point2D(float(p2.x), float(p2.y))
leftUpCorner = Point2D(T(rect.x), T(rect.y))
rightUpCorner = Point2D(T(rect.x + rect.w), T(rect.y))
rightDownCorner = Point2D(T(rect.x + rect.w), T(rect.y + rect.h))
leftDownCorner = Point2D(T(rect.x), T(rect.y + rect.h))
#print('leftUpCorner ', leftUpCorner)
#print('rightUpCorner ', leftUpCorner)
#print('leftDownCorner ', leftDownCorner)
#print('rightDownCorner ', rightDownCorner)
a[2] = segmentIntersection(segment, GeneralizedSegment(leftUpCorner, rightUpCorner, False, False))
a[3] = segmentIntersection(segment, GeneralizedSegment(rightUpCorner, rightDownCorner, False, False))
a[4] = segmentIntersection(segment, GeneralizedSegment(rightDownCorner, leftDownCorner, False, False))
a[5] = segmentIntersection(segment, GeneralizedSegment(leftDownCorner, leftUpCorner, False, False))
#print('lstBefore: ', a[0], a[1], a[2], a[3], a[4], a[5])
for i in range(0, 5):
if a[i]:
for j in range(i+1, 6):
if a[j] and (a[i] == a[j]):
a[j] = None
#print('lstPre: ', a[0], a[1], a[2], a[3], a[4], a[5])
r = 0
l = 0
while (l < 6):
if not a[l]:
r = max(l, r)
while (r < 6 and not a[r]):
r += 1
if r == 6:
break
t = a[l]
a[l] = a[r]
a[r] = t
l += 1
#print('lst: ', a[0], a[1], a[2], a[3], a[4], a[5])
#if l <= 2:
# sys.exit()
while len(a) > l:
a.pop()
if l >= 3:
for i in range(2, l):
if a[i]:
assert (a[1] - a[0])*(a[i]-a[0]) == T(0), 'ERROR: point ' + str(i) + ' is not on line...'
a = utils.sort(a, ByManhattenDistanceComparator(a[0]))
a = utils.sort(a, ByManhattenDistanceComparator(a[0]))
a[1] = a[-1]
while len(a) > 2:
a.pop()
l = len(a)
assert l <= 2, 'ERROR: l is ' + str(l) + 'which is more than 2\n'
if l == 0:
return
if l == 1:
DrawPoint(surface, a[0], color, fat)
else:
#print('real segment: ', a[0], a[1])
drawSegment(surface, a[0], a[1], color, fat)
