def compute_graph(edges, x, y, precision, tollerance):
if booldebug: print(x, y)
graph = Graph('image')
q = Queue('nodes')
p_node = Point(x, y)
node = Node(p_node)
graph.nodes.append(node)
q.push(node)
while not q.empty():
node = q.top()
q.pop()
links = []
p_node = node.get_point()
x = p_node.get_x()
y = p_node.get_y()
cell = generate_cell(edges, p_node, precision)
links = find_lines(cell, edges, x - precision, y - precision,
tollerance)
#if booldebug: print(links)
delete(edges, cell, x - precision, y - precision)
for p in links:
graph.nodes.append(Node(p))
q.push(Node(p))
graph.manage_links(node, links)
if len(graph.nodes) > 2:
return DPS(graph)
def test_is_line(self):
p1 = Point(-1, -1)
p2 = Point(2, 3)
p4 = Point(-1, 3)
p5 = Point(-4, -5)
self.assertFalse(Triangle(p1, p2, p4).is_line())
self.assertTrue(Triangle(p1, p2, p5).is_line())
def calculate_mean_line(linhas):
first_point_x = int(round(np.mean([linha.point1.x for linha in linhas])))
first_point_y = int(round(np.mean([linha.point1.y for linha in linhas])))
second_point_x = int(round(np.mean([linha.point2.x for linha in linhas])))
second_point_y = int(round(np.mean([linha.point2.y for linha in linhas])))
first_point = Point(first_point_x, first_point_y)
second_point = Point(second_point_x, second_point_y)
return Line(first_point, second_point)
def res():
circle = Circle(1, 2)
triangle = Triangle(Point(0, 1), Point(2, 3), Point(10, 2))
square = Square(Point(0, 1), Point(4, 4))
spis_figure = []
spis_figure.append(circle.ploshad())
spis_figure.append(triangle.ploshad())
spis_figure.append(square.ploshad())
return spis_figure
def __init_subclass__(self):
self._K = Point(0, 290)
self._A = Point(250, 290)
self.BC = 290
self.BE = 380
self.CD = 35
self.CE = 110
self.EF = 120
self.HI = 280
def __init_subclass__(self):
self._K = Point(0, 300)
self._A = Point(50, 300)
self.BC = 260
self.BE = 350
self.CD = 45
self.CE = 90
self.EF = 110
self.HI = 285
def getDistanceOf(rect1, rect2):
"""
calculate the distance between rect1 and rect2
:param rect1: tuple of 4 - (top, right, bottom, left)
:param rect2: tuple of 4 - (top, right, bottom, left)
:return: euclidean distance between upper-left point of the rects.
"""
p1 = Point(rect1[3], rect1[0]) # upper-left point of rect1
p2 = Point(rect2[3], rect2[0]) # upper-left point of rect2
return p1.distanceFrom(p2)
def test_equality(self):
p1 = Point(1, 2, 3)
p2 = Point(4, 5, 6)
p3 = Point(1, 2, 3)
self.assertEqual(p1, p3)
self.assertNotEqual(p1, p2)
self.assertTrue(p1 == p3)
self.assertFalse(p1 != p3)
self.assertFalse(p1 == p2)
self.assertTrue(p1 != p2)
self.assertFalse(p1 != p3)
def aggregateConfigurations(self, trajectories):
envelope = Trajectory(0, 0, 0, [])
efforts = []
[efforts.extend([point.effort for point in trajectory.points if point.effort not in efforts]) for trajectory in trajectories]
efforts.sort()
for effort in efforts:
if self.data.scenario['ac'] == "best":
envelope.points.append(Point(effort, min([trajectory.getValue(effort) for trajectory in trajectories])))
if self.data.scenario['ac'] == "worst":
envelope.points.append(Point(effort, max([trajectory.getValue(effort) for trajectory in trajectories])))
return envelope
def __init__(self, nitron):
self.nitron = nitron
self._A
self._B = Point(0, 0)
self._J = Point(10, -30)
self._K
self.BC
self.BE
self.CD
self.CE
self.EF
self.HI
def aggregate(self, replications):
result = Trajectory(0, 0, 0, [])
if self.data.scenario['ar'] == "exp":
return self.exponentialModel(replications)
efforts = []
[efforts.extend([point.effort for point in replication.points if point.effort not in efforts]) for replication in replications]
efforts.sort()
for effort in efforts:
if self.data.scenario['ar'] == "best":
result.points.append(Point(effort, min([replication.getValue(effort) for replication in replications])))
elif self.data.scenario['ar'] == "worst":
result.points.append(Point(effort, max([replication.getValue(effort) for replication in replications])))
return result
def aggressivenessToKeep(self, refExecution):
effortCap = refExecution['trajectory'].getLastEffort()
valueCap = refExecution['trajectory'].getResult()
executions = self.data.getExecutions(refExecution['instance-id'], False, refExecution['id'] - 1)
if len(executions) == 0: return None
steps = []
ratios = []
for exe in executions:
steps.append(len([point for point in exe['trajectory'].points if point.effort >= effortCap]))
if exe['trajectory'].getValue(effortCap) != 0:
ratios.append(exe['trajectory'].getResult() / exe['trajectory'].getValue(effortCap))
medianSteps = ceil(statistics.median(steps))
medianRatio = statistics.median(ratios)
trajectory = Trajectory(0, 0, 0, [])
trajectory.points = refExecution['trajectory'].points
if medianSteps > 0:
effortStep = (self.data.scenario['effort-limit'] - effortCap) / (medianSteps + 1)
finalValue = valueCap * medianRatio
valueStep = (valueCap - finalValue) / medianSteps
lastEffort = effortCap
lastValue = valueCap
for i in range(medianSteps):
lastEffort += effortStep
lastValue -= valueStep
trajectory.points.append(Point(lastEffort, lastValue))
executions.sort(key = lambda x : x['trajectory'].getResult())
amount = 0
for i in range(len(executions)):
bound = i + 1
efforts = []
[efforts.extend([point.effort for point in exe['trajectory'].points if point.effort not in efforts]) for exe in executions[:bound]]
efforts.sort()
envelope = Trajectory(0, 0, 0, [])
for effort in efforts:
envelope.addPoint(Point(effort, max([exe['trajectory'].getValue(effort) for exe in executions[:bound]])), self.data.scenario['effort-limit'])
efforts = efforts + [point.effort for point in trajectory.points if point.effort not in efforts]
cap = False
for effort in efforts:
if trajectory.getValue(effort) > envelope.getValue(effort):
cap = True
break
if cap:
amount += 1
else:
amount += 1
break
return 1 - (amount / len(executions))
def main():
point_a = Point(2, 4)
point_b = Point(6, 11)
point_c = Point(3, 4)
triangle_1 = Triangle(point_a, point_b, point_c)
print(triangle_1.triangle_S())
print(triangle_1.triangle_P())
print('=' * 20)
square_1 = Square(point_a, point_b)
print(square_1.square_S())
print(square_1.square_P())
print('=' * 20)
circle_1 = Circle(point_a, 15)
print(circle_1.circle_S())
print(circle_1.circle_P())
def create_points_try(dim):
points_grid = list()
for h in range(0, dim):
points_grid.append(list())
for w in range(0, dim):
points_grid[h].append(Point(calc_position(h, w)))
return points_grid
def find_eye_corners(eye_image, eye_center):
corners = cv2.goodFeaturesToTrack(img_as_ubyte(eye_image), 5, 0.01, 15)
all_corners = np.int0(corners)
all_corners = list(map(lambda c: Point(*(c.ravel().tolist())),
all_corners))
# give each corner a score, according to our heuristic
left_corner_score = map(
lambda corner:
(corner, corner_measure(corner, eye_center, leftness=1)), all_corners)
# find the best corner
try:
left_corner = max(left_corner_score, key=lambda cs: cs[1])[0]
except Exception:
left_corner = (0, 0)
# give each corner a score, according to our heuristic
right_corner_score = map(
lambda corner:
(corner, corner_measure(corner, eye_center, leftness=-1)), all_corners)
# find the best corner
try:
right_corner = max(right_corner_score, key=lambda cs: cs[1])[0]
except Exception:
right_corner = (0, 0)
return right_corner, left_corner, all_corners #TODO: fix x and y coords being reversed
def Convert():
if not os.path.exists("gosat/data"):
os.makedirs("gosat/data")
hdf5_l = os.listdir('gosat/tmp/HDF/SWIRL2CO2/')
for hdf5 in hdf5_l:
with h5py.File('gosat/tmp/HDF/SWIRL2CO2/' + hdf5, 'r') as f:
Data = f['Data']
geolocation = Data['geolocation']
longitude = geolocation['longitude']
latitude = geolocation['latitude']
scanAttribute = f['scanAttribute']
mixingRatio = Data['mixingRatio']
timeList = list(scanAttribute['time'])
# Значение
co2_l = list(mixingRatio['XCO2'])
lon_l = list(longitude)
lat_l = list(latitude)
with open(f'gosat/data/{timeList[0].decode("utf-8")[:10]}.json',
'w') as f:
f.write('[\n')
for i in range(len(co2_l)):
f.write(str(Point(lat_l[i], lon_l[i], timeList[i], co2_l[i])))
if i != len(co2_l) - 1:
f.write(',\n')
f.write(']')
def test_case_10(self):
ans = "\n" + inspect.stack()[0][3] + ": \n"
s = Rectangle(width=3, height=4)
ans += str(s) + "\n"
ans += s.details() + "\n"
r = Rectangle(0, 0)
p = Point(1, 1)
x = r.union(p)
r.enclose(p)
r.enclose(Point(2, 2))
ans += r.details() + "\n"
self.check(ans, 12087, True)
def load_data(filename: str) -> List[Point]:
"""
Чтение файла
:param filename: путь к файлу типа pdb
:return: список координат атомов в этом файле
"""
file: TextIO = open(filename)
res = []
while file.readable():
line: str = file.readline()
if line.startswith("ENDMDL") or line == "":
break
if not (line.startswith("ATOM") or line.startswith("HETATM")):
continue
if line[-3] == 'H' or line[-4] == 'H': # водород
continue
point_coords = line[31:54].split()
x = float(point_coords[0])
y = float(point_coords[1])
z = float(point_coords[2])
point = Point(x, y, z)
res.append(point)
return res
def _process(image, annotations, detector, reid_model):
result = detector.get_bboxes(img_filename)
bboxes, crops = [], []
for row in range(len(result)):
if result[row][4] < 0.3:
continue
x1, y1, x2, y2 = map(int, result[row][:4])
bbox = Bbox(x1=x1, y1=y1, x2=x2, y2=y2)
bbox.clip(max_w=image.shape[1], max_h=image.shape[0])
bboxes.append(bbox)
crops.append(image[bbox.y1:bbox.y2, bbox.x1:bbox.x2, :])
embeddings = reid_model.get_embeddings(crops)
shelves_per_images: Dict[str, List[Shelve]] = {}
for filename, shelves in annotations.items():
shelves_per_images[filename] = []
for shelve_idx, shelve in tqdm.tqdm(enumerate(shelves),
total=len(shelves)):
shelve_name, shelve_points = shelve
shelve = Shelve(name='shelve_{}'.format(shelve_idx),
points=[Point(x, y) for x, y in shelve_points])
shelves_per_images[filename].append(shelve)
crops = []
for bbox, embedding in zip(bboxes, embeddings):
area = bbox.intersection_area(shelve.points)
if area <= 0:
continue
intersection_area = area / bbox.area
if intersection_area <= threshold:
continue
item = Item(bbox, embedding=embedding)
shelve.items.add(item)
x1 = bbox.x1
y1 = bbox.y1
x2 = bbox.x2
y2 = bbox.y2
crops.append(image[y1:y2, x1:x2, :])
for filename, shelves in shelves_per_images.items():
for shelve in shelves:
embeddings = np.array([item.embedding for item in shelve.items])
if len(embeddings) == 0:
continue
clustering = DBSCAN(eps=0.2, min_samples=2,
metric='cosine').fit(embeddings)
for item, label in zip(shelve.items, clustering.labels_):
item.label = label
return shelves_per_images
def generate():
number_of_vertex = random.randrange(3, 10, 1)
points_array = []
i = 0
while i < number_of_vertex:
point = Point(random.randrange(0, 10, 1), random.randrange(0, 10, 1))
points_array.append(point)
i += 1
return points_array
def lkhParseOutput(output, elapsedTime):
bestSoFar = float('inf')
for line in reversed(output):
if 'Cost = ' in line and 'Time = ' in line:
bestSoFar = min(
bestSoFar,
int(line[line.index('Cost = ') + 7:line.index(', Time')]))
return Point(round(elapsedTime, 1),
bestSoFar) if bestSoFar != float('inf') else None
def main():
c = Circle()
c.center = Point()
c.center.x = 0
c.center.y = 0
c.radius = 100
rect = Rectangle()
rect.corner = Point()
rect.corner.x = -100
rect.corner.y = 100
rect.width = 200
rect.height = 300
bob = turtle.Turtle()
draw_circle(bob, c)
draw_rectangle(bob, rect)
turtle.mainloop()
def create(pt, r=None):
n = len(pt)
if (r == None):
if n == 1:
x, y = pt[0]
return Point(x, y)
elif n == 2:
return Segment(pt)
elif n == 3:
return Triangle(pt)
else:
return Polygon(pt)
elif n == 1:
x, y = pt[0]
if (r > 0):
return Circle(x, y, r)
else:
return Point(x, y)
def find_center_line(input_file: str, s_start: Point, min_z: float,
max_z: float) -> TunnelCenterLine:
"""
Поиск туннеля в молекуле
:param input_file: название файла с туннелем(должен быть в папке input_files)
:param s_start: начальная точка x, y, z
:param min_z: нижняя граница туннеля
:param max_z: верхняя граница туннеля
:return:туннель заданный последовательностью точек
"""
directory: str = "input_files"
points: List[Point] = load_data(os.path.join(directory, input_file))
# r: float = 100
# circle_ponts = [(r * cos(radians(teta + 45)), r * sin(radians(teta + 45))) for teta in range(360) if teta % 2 == 0]
# points: List[Point] = [Point(x, y, z) for x, y in circle_ponts for z in range(-50, 51, 10)]
save_center_line_to_pdb(points, 'in.pdb')
np_points = np.array(list(map(lambda p: p.coords, points)))
tri = Delaunay(np_points)
vertices, edges = get_voronoy_edges(tri)
g: int = len(vertices)
save_center_line_to_pdb(vertices, 'verts.pdb')
graph: Graph = create_graph_from_edges(edges, set(range(g)),
set(range(len(edges))))
s_start_ind: int = min(range(g), key=lambda i: s_start.dist(vertices[i]))
# def stop(ind: int) -> bool:
# return vertices[ind].coords[2] > max_z or vertices[ind].coords[2] < min_z
stop_max = lambda ind: vertices[ind].coords[2] > max_z
stop_min = lambda ind: vertices[ind].coords[2] < min_z
best_tunnel_indexes: List[int] = compute_tunnel(graph, g, s_start_ind,
stop_min)
#best_tunnel: List[Point] = [vertices[i] for i in best_tunnel_indexes]
best_tunnel_indexes2: List[int] = compute_tunnel(graph, g, s_start_ind,
stop_max)
#best_tunnel2: List[Point] = [vertices[i] for i in best_tunnel_indexes2]
tunnel_indexes = [
*best_tunnel_indexes, *(list(reversed(best_tunnel_indexes2))[1:])
]
best_tunnel: List[Point] = [vertices[tunnel_indexes[0]]]
for i in range(1, len(tunnel_indexes)):
mid_point = (vertices[tunnel_indexes[i - 1]] +
vertices[tunnel_indexes[i]]) / 2
best_tunnel.append(mid_point)
best_tunnel.append(vertices[tunnel_indexes[i]])
#tunnel = [*best_tunnel, *best_tunnel2]
#plot(points, tri, vertices, edges)
return best_tunnel
def trilateration(point1, r1, point2, r2, point3, r3):
A = 2 * point2.x - 2 * point1.x
B = 2 * point2.y - 2 * point1.y
C = r1**2 - r2**2 - point1.x**2 + point2.x**2 - point1.y**2 + point2.y**2
D = 2 * point3.x - 2 * point2.x
E = 2 * point3.y - 2 * point2.y
F = r2**2 - r3**2 - point2.x**2 + point3.x**2 - point2.y**2 + point3.y**2
x = (C * E - F * B) / (E * A - B * D)
y = (C * D - A * F) / (B * D - A * E)
return Point(x, y)
def newPoint(x, y, z=None):
res = None
for point in PointFactory.registry:
if (point.x == x) and (point.y == y) and (point.z == z):
res = point
break
if res is None:
res = Point(x, y, z)
PointFactory.registry.append(res)
return res
def decrease_lambda(grid, decrement_step_size):
"""
Creates a copy of the given grid and for this decreases the lambda value by the decrement_step_size.
:param grid: The given grid.
:param decrement_step_size: The amount lambda has to be decreased.
:return: A copy of the given grid, where the lambda value is decreased.
"""
lambda_val = grid.lambda_val - decrement_step_size
decreased_grid = Grid(lambda_val, list(), list(), list())
for edge_point in grid.edge_points:
new_edge_point = Point(edge_point.position)
edge_point.add_next_point(new_edge_point)
decreased_grid.edge_points.append(new_edge_point)
for point in grid.points:
new_point = Point(point.position)
point.add_next_point(new_point)
decreased_grid.points.append(new_point)
decreased_grid.springs = reconnect_grid(grid)
return decreased_grid
def Convert():
if not os.path.exists("oco2/data"):
os.makedirs("oco2/data")
nc4_l = os.listdir('oco2/tmp/NC4/')
nc4_l.sort()
if DEBUG:
print(nc4_l[:10])
for nc4 in nc4_l:
_path = 'oco2/tmp/NC4/' + nc4
try:
with netCDF4.Dataset(_path) as f:
lon_l = np.array(f.variables['longitude'] )
lat_l = np.array(f.variables['latitude'])
co2_l = np.array(f.variables['xco2'])
date_l = np.array(f.variables['date'])
if DEBUG:
print(f'{type(date_l)}')
print(f'{date_l[0]}')
for i in date_l[0]:
print(f'{i} = {human_size(i)}')
print(f'size: date_l={human_size(date_l[0])}')
print(f'size: co2_l={human_size(co2_l[0])}')
print(f"oco2/data/{date_l[0][0]:4d}-{date_l[0][1]:02d}-{date_l[0][2]:02d}.json")
print(f'file: {nc4}')
print(f'points: {len(date_l)} {len(lat_l)} {len(lon_l)} {len(co2_l)}')
print(f'size: lon_l={human_size(lon_l)}')
print(f'size: lat_l={human_size(lat_l)}')
print(f'size: co2_l={human_size(co2_l)}')
print(f'size: date={human_size(date_l)}')
with open(f"oco2/data/{date_l[0][0]:4d}-{date_l[0][1]:02d}-{date_l[0][2]:02d}.json", 'w') as f1:
print(f"oco2/data/{date_l[0][0]:4d}-{date_l[0][1]:02d}-{date_l[0][2]:02d}.json")
f1.write("[\n")
for i in range(len(co2_l)):
f1.write(str(Point(lat_l[i], lon_l[i], date_l[i][0], co2_l[i])))
if i != len(co2_l)-1:
f1.write(',\n')
f1.write(']')
except Exception as e:
print(e)
finally:
if not DEBUG:
print(f'remove {_path}')
if os.path.isfile(_path):
os.remove(_path)
else: ## Show an error ##
print("Error: %s file not found" % _path)
def div_loc(point, x_max, y_max):
x = point.x / x_max
if x > 1:
x = 1 - random.random() * 0.2
elif x < 0:
x = 0 + random.random() * 0.2
y = point.y / y_max
if y > 1:
y = 1 - random.random() * 0.2
elif y < 0:
y = 0 + random.random() * 0.2
return Point(x, y)
def import_lines():
from classes import Point, Line
fin = open('lines.txt','r')
lines = []
riga = fin.readline().strip()
while riga != '':
vett = riga.split('|')
v1 = vett[0]
v2 = vett[1]
p1 = v1.split('-')
p2 = v2.split('-')
line = Line(Point(int(p1[0]),int(p1[1])),Point(int(p2[0]),int(p2[1])))
lines.append(line)
riga = fin.readline().strip()
fin.close()
return lines