def circle_eyes(pos, img8_r, img8_l, roir, roil):
'''
Draws circles around eyes and Return coordinates.
Keyword arguments:
pos -- list of x,y coordinates of face ROI
img8_r -- 8-bit right eye (from isolation_methods.color_filter_main())
img8_l -- 8-bit left eye (from isolation_methods.color_filter_main())
frame_o -- original frame
roir -- coordinates of right eye ROI [y, y + h, x, x + w]
roil -- coordinates of left eye ROI [y, y + h, x, x + w]
Return:
frame with circled eyes (numpy ndarray)
right eye coordinates (tuple)
left eye coordinates (tuple)
'''
right_c = smallestenclosingcircle.make_circle(isolation_methods.get_points(img8_r))
left_c = smallestenclosingcircle.make_circle(isolation_methods.get_points(img8_l))
translated_right = None
translated_left = None
avg_radius = 0
if right_c != None:
translated_right = (int(pos[0] + round(right_c[1] + roir[2])),
int(roir[0] + pos[1] + round(right_c[0])))
avg_radius = right_c[2]
if left_c != None:
translated_left = (int(pos[0] + round(left_c[1] + roil[2])),
int(roil[0] + pos[1] + round(left_c[0])))
avg_radius = left_c[2]
if (left_c != None) and (right_c != None):
avg_radius = (right_c[2] + left_c[2]) / 2
return translated_right, translated_left, avg_radius
def etatsVoisins(self):
# les etats voisin seront a une difference de l'etat orginale
#
#on enleve un point de chaque antenne
for position in self.ptsRestants:
nvAntennePos = make_circle([position])
nvAntenne = Antenne(nvAntennePos, [position])
nvPtsRestantes = copy.deepcopy(self.ptsRestants)
nvPtsRestantes.remove(position)
nvListeAntennes = copy.deepcopy(self.antennes)
nvListeAntennes.append(nvAntenne)
nvEtat = Etat(nvListeAntennes, nvPtsRestantes)
self.neighbours.append(nvEtat)
indexAnt = 0 # necessaire pour garder la
for antenne in self.antennes:
for position in self.ptsRestants:
nvListePos = copy.deepcopy(antenne.positions)
nvListePos.append(position)
nvAntennePos = make_circle(nvListePos)
nvAntenne = Antenne(nvAntennePos, nvListePos)
nvPtsRestantes = copy.deepcopy(self.ptsRestants)
nvPtsRestantes.remove(position)
nvListeAntennes = copy.deepcopy(self.antennes)
del nvListeAntennes[indexAnt]
nvListeAntennes.append(nvAntenne)
nvEtat = Etat(nvListeAntennes, nvPtsRestantes)
self.neighbours.append(nvEtat)
indexAnt += 1
def test_scaling(self): TRIALS = 100 CHECKS = 10 for _ in range(TRIALS): points = _make_random_points(random.randint(1, 300)) reference = smallestenclosingcircle.make_circle(points) for _ in range(CHECKS): scale = random.gauss(0, 1) newpoints = [(x * scale, y * scale) for (x, y) in points] scaled = smallestenclosingcircle.make_circle(newpoints) self.assertAlmostEqual(scaled[0], reference[0] * scale , delta=_EPSILON) self.assertAlmostEqual(scaled[1], reference[1] * scale , delta=_EPSILON) self.assertAlmostEqual(scaled[2], reference[2] * abs(scale), delta=_EPSILON)
def test_translation(self): TRIALS = 100 CHECKS = 10 for _ in range(TRIALS): points = _make_random_points(random.randint(1, 300)) reference = smallestenclosingcircle.make_circle(points) for _ in range(CHECKS): dx = random.gauss(0, 1) dy = random.gauss(0, 1) newpoints = [(x + dx, y + dy) for (x, y) in points] translated = smallestenclosingcircle.make_circle(newpoints) self.assertAlmostEqual(translated[0], reference[0] + dx, delta=_EPSILON) self.assertAlmostEqual(translated[1], reference[1] + dy, delta=_EPSILON) self.assertAlmostEqual(translated[2], reference[2] , delta=_EPSILON)
def on_event(self, event):
if event.type == QUIT:
self.running = False
elif event.type == MOUSEBUTTONUP and event.button in (1, 2, 3):
print("an event: ", self.points)
if self.btn_get_box.pressed(event.pos):
self.box = bounding_box(self.points.copy())
print("get box:", self.box)
polyArea = int(self.polygon.area)
min_x, min_y = self.box[0][0], self.box[0][1]
max_x, max_y = self.box[2][0], self.box[2][1]
boxArea = int((max_x - min_x) * (max_y - min_y))
self.msg = "Polygon area: " + str(
polyArea) + " Bounding Box area: " + str(
boxArea) + " Ratio: " + str(
round(polyArea / boxArea, 5))
elif self.btn_get_circle.pressed(event.pos):
self.circle = make_circle(self.points.copy())
print("get circle:", self.circle)
polyArea = int(self.polygon.area)
r = self.circle[2]
circleArea = int(pi * r**2)
self.msg = "Polygon area: " + str(
polyArea) + " Min circle area: " + str(
circleArea) + " Ratio: " + str(
round(polyArea / circleArea, 5))
elif self.btn_get_convex.pressed(event.pos):
# send in a copy bc it changes the ordering to sorted
self.ch_points = convexHull(self.points.copy())
polyArea = int(self.polygon.area)
chArea = int(Polygon(self.ch_points).area)
self.msg = "Polygon area: " + str(
polyArea) + " CH area: " + str(
chArea) + " Ratio: " + str(
round(polyArea / chArea, 5))
print("get hull")
# print("convex hull event: ", self.points)
elif self.btn_reset.pressed(event.pos):
self.points, self.ch_points, self.circle, self.polygon, self.box = [], [], [], [], []
self.msg = "Click points in cw or ccw order to add"
print("reset")
else:
# don't add if the point isn't already in there
# (note: currently linear scan which is ok bc small # of pts. Can be improved later)
if event.pos not in self.points:
self.points.append(event.pos)
# the polygon must be updated - the only time it is is when you add a point
if len(self.points) > 2:
self.polygon = Polygon(self.points)
self.msg = "Added (x,y): " + str(
event.pos) + " Polygon area: " + str(
int(self.polygon.area))
else:
self.msg = "Added (x,y): " + str(event.pos)
def test_matching_naive_algorithm(self):
for _ in range(1000):
points = _make_random_points(random.randint(1, 30))
reference = _smallest_enclosing_circle_naive(points)
actual = smallestenclosingcircle.make_circle(points)
self.assertAlmostEqual(actual[0], reference[0], delta=_EPSILON)
self.assertAlmostEqual(actual[1], reference[1], delta=_EPSILON)
self.assertAlmostEqual(actual[2], reference[2], delta=_EPSILON)
def get_circle_impurity_score(markers, imp_boxes, areas, indices):
scores = np.full(imp_boxes.shape[0], np.infty)
for impurity in indices:
impurity_shape = np.argwhere(markers == impurity + 2)
circle = make_circle(impurity_shape)
circle_area = np.pi * circle[2]**2
scores[impurity] = (circle_area - areas[impurity]) / circle_area
return scores
def circumCircle(I):
"""
this version uses a function provided by Project Nayuki
under GNU Lesser General Public License
"""
points = np.argwhere(I > 100)
c = smallestenclosingcircle.make_circle(points)
return c
def solVoisine(etat):
#Strategy : We randomly take out a point from an antenna and give it randomly to another antenna
# if the deprived antenna has 0 points left, then we take it out of the state list
# we also need to make sure that the new solution is valid, such as every position is covered
if len(etat.antennes) <= 1:
return etat
#The first antenna is gonna give a position to the second
etatVoisin = copy.deepcopy(etat)
antennes = random.sample(etatVoisin.antennes, 2)
antToDeprive = antennes[0]
antToGive = antennes[1]
etatVoisin.antennes.remove(antToDeprive)
etatVoisin.antennes.remove(antToGive)
#positionToGive = random.sample(antToDeprive.positions, 1)
indexPos = randint(0,len(antToDeprive.positions)-1)
positionToGive = antToDeprive.positions[indexPos]
antToDeprive.positions.remove(positionToGive)
antToGive.positions.append(positionToGive)
etatRetour = None
nvAntennePos = make_circle(antToGive.positions)
nvAntenne = Antenne(nvAntennePos, antToGive.positions)
antenaList = etatVoisin.antennes + [nvAntenne]
if(len(antToDeprive.positions) == 0):
#only one position, so we deleted that antenna and we need to reconstruct the list with the new list
#antToDeprive.
etatRetour = Etat(antenaList,[])
else:
#we need to update the depraved antenna
nvDepAntennaPos = make_circle(antToDeprive.positions)
nvDepAntenna = Antenne(nvDepAntennaPos, antToDeprive.positions)
etatRetour = Etat(antenaList + [nvDepAntenna], [])
return etatRetour
def test_matching_naive_algorithm(self): TRIALS = 1000 for _ in range(TRIALS): points = _make_random_points(random.randint(1, 30)) reference = _smallest_enclosing_circle_naive(points) actual = smallestenclosingcircle.make_circle(points) self.assertAlmostEqual(actual[0], reference[0], delta=_EPSILON) self.assertAlmostEqual(actual[1], reference[1], delta=_EPSILON) self.assertAlmostEqual(actual[2], reference[2], delta=_EPSILON)
def solInitiale(Positions):
antennes = [];
position = Positions.pop(0)
antennes.append(Antenne(make_circle([tuple(position)]), [position]))
etat = Etat(antennes, Positions)
return etat
def solInitiale(Positions):
antennes = [];
for position in Positions:
antennes.append(Antenne(make_circle([tuple(position)]), [position]))
etat = Etat(antennes, [])
return etat
def get_polygon_center(pc):
"""
Estimate object center
"""
sample_size = 100
if len(pc) > sample_size:
random.sample(np.arange(len(pc)).tolist(), sample_size)
pc = np.array(pc)
center = np.sum(pc, axis=0) / len(pc)
circle = smallestenclosingcircle.make_circle(pc[:, 0:2])
return np.array([circle[0], circle[1], center[2]])
def find_neighbour(solution, positions):
if len(solution) <= 1:
return solution
antenna = solution[int(random.random() * len(solution))]
closest_antenna = min([ant for ant in solution if ant != antenna], key=lambda a : dist_squared(a, antenna))
ant1_coverage = [p for p in positions if verify_cover(p, antenna)]
ant2_coverage = [p for p in positions if verify_cover(p, closest_antenna)]
le_point = min(ant2_coverage, key=lambda pos : dist_squared(pos, antenna))
ant2_coverage = [p for p in ant2_coverage if p != le_point]
ant1_coverage.append(le_point)
new_ant1 = make_circle(ant1_coverage);
new_ant2 = make_circle(ant2_coverage);
solution = [ant for ant in solution if (ant != antenna and ant != closest_antenna)]
if new_ant1:
solution.append(new_ant1)
if new_ant2:
solution.append(new_ant2)
return solution
def shoot_for_optim(n_points, cannon, balloon, wind_tbl, ran):
x_values = []; y_values = [] #착탄점들의 중심점을 구하기 위해 다 저장
for i in range(n_points):
np.random.seed(i)
idland, xy_now, peak_z, theta, direc_now = peak_xy(cannon, balloon, ran)
# shoot
#현재 고도보다 바로 위에 있는 테이블 값의 풍향을 사용할 것임
wind_h = [idx[1] for idx in wind_tbl.index]; wind_h.insert(0,0)
idx_now = (wind_h >= peak_z).tolist().index(True)
h_now = peak_z
#포탄 경로 그리기 준비
while idx_now > 0:
h_down = h_now - wind_h[idx_now - 1] #수직 하강 거리
one_step = h_down * np.tan(theta) #전진 거리. 풍향의 영향이 없을 때의 방향을 기준으로 거리를 계산함
wind_vec = np.array(wind_tbl.vec[idx_now-1])
wind_vel = wind_tbl.wind_vel[idx_now-1]
interval_now = wind_tbl.index[idx_now - 1]
cossim = cos_sim(direc_now, wind_vec)
vel_power = (100 + cossim * 100 * wind_vel) / 100
one_step = one_step * vel_power #전진거리 수정
if abs(cossim) != 1:
#풍향과 풍속을 고려하여 방향 수정
w = np.random.beta(2,20) * vel_power
direc_now = (1-w) * direc_now + w * wind_vec.astype('float64')
direc_now = (direc_now ) / la.norm(direc_now) #unit vector로 만들기
#계산 종료.
#포탄의 전진.
xy_now = xy_now + direc_now * one_step
idx_now -=1
h_now = wind_h[idx_now]
x_values.append(xy_now[0])
y_values.append(xy_now[1])
cir = sc.make_circle(zip(x_values, y_values))
return np.array([cir[0], cir[1]])
def fi_factor(polygon):
"""
Calculates fi factor (the ratio of the area of the polygon to the area of the circumscribed circle)
Parameters
----------
polygon : shapely.geometry.Polygon
Returns
-------
fi : float [0,1]
"""
circle_points = make_circle(np.array(polygon.boundary.xy).T)
center = shapely.geometry.Point((circle_points[0], circle_points[1]))
circle = center.buffer(circle_points[2])
fi = polygon.area / circle.area
return fi
def greedy_solution(remaining_positions, k, c):
positions = list(remaining_positions)
if not remaining_positions:
return
antennas = [(remaining_positions[0][0], remaining_positions[0][1], 1)]
remaining_positions = remaining_positions[1:]
for pos in remaining_positions:
closest_antenna = min(antennas, key=lambda x : dist_squared(pos, (x[0],x[1])))
covered_points = [p for p in positions if verify_cover(p, closest_antenna)]
covered_points.append(pos)
new_antenna = make_circle(covered_points)
if((k+c*new_antenna[2]**2) > (k+c*closest_antenna[2]**2 + k)):
new_antenna = (pos[0], pos[1], 1)
else:
antennas = [ant for ant in antennas if ant != closest_antenna]
antennas.append(new_antenna)
remaining_positions = [p for p in remaining_positions if p != pos]
return antennas
def is_panning_scene(locs, dirs, scene, MIN_ANGLE, MAX_RADIUS):
if (scene.end - scene.start) < 1:
return False
# if it is panning scene
if not is_panning_angle(dirs, scene, MIN_ANGLE):
return False
points = [(locs[i][0], locs[i][1]) for i in range(scene.start, scene.end + 1, 1)]
# if radius of the smallest bounding circle of the camera locations are small
x = make_circle(points)
if x is not None:
cx, cy, r = x
# print cx, cy, r
else:
print "xxx"
cx, cy, r = 0, 0, 0
# print r/ONE_KM
if r/ONE_KM <= MAX_RADIUS:
return True
return False
def childs(self):
children = []
if not self.antennas:
for pos in positions:
child = State(self.antennas, self.remaining_positions)
child.add_antenna((pos[0], pos[1], 1))
child.remaining_positions = tuple([p for p in child.remaining_positions if p != pos])
children.append(child)
else:
child = State(self.antennas, self.remaining_positions)
pos = min(self.remaining_positions, key=lambda p : dist_squared(p, self.antennas[-1]))
closest_antenna = min(child.antennas, key=lambda x : dist_squared(pos, (x[0],x[1])))
#les points couvert par l'antenne
covered_points = [p for p in positions if child.verify_cover(p, closest_antenna)]
covered_points.append(pos)
new_antenna = make_circle(covered_points)
if((K+C*new_antenna[2]**2) > (K+C*closest_antenna[2]**2 + K)):
new_antenna = (pos[0], pos[1], 1)
else:
child.antennas = tuple([ant for ant in child.antennas if ant != closest_antenna])
child.add_antenna(new_antenna)
#child.remaining_positions = tuple([p for p in child.remaining_positions if p != pos])
children.append(child)
return children
def cluster_mc(sp=1.00, Nmax=1000, rs=0):
# main function that runs the monte carlo code used for creating the clusters
# sp = sticking probability, = 1 is the classical DLA case, 0 < sp =< 1 are the bounds
# Nmax = maximum number of particles in the cluster, the functions runs until Nmax is hit
# rs = random seed (just a number) that set the pseudo-random number generator
# the random seed is what makes this a Monte Carlo simulation
# some initial checks
if not 0 < sp <= 1:
print('ERROR: bounds for sticking probability (sp) are incorrect (must have 0 < sp <= 1). Stopping the simulation.')
return
if type(Nmax) is not int:
print('ERROR: maximum particle number (Nmax) must be type int. Stopping the simulation.')
return
rs = int(rs) # for file saving it is more convenient to have an integer
random.seed(rs) # set the random seed
# file opening
strname = 'cluster_mc_rs%d_n%d_p%0.2f'%(rs, Nmax, sp)
fh = open(strname + '.csv','w')
fh.write('number,x,y\n')
fh.write('1,0,0\n')
walkdir = [[1,0],[0,1],[-1,0],[0,-1]] # particles only walk in 4 directions
seed = [0,0] # single frozen seed
cluster = [seed] # just a list of points
clustsize = len(cluster)
stickps = [] # 3D array of sticking points
cluster_parts = [] # 3D array of particles in the cluster
bin_size = 3 # hard coded value to shape the 3D arrays
stickdir = [[1,0],[0,1],[-1,0],[0,-1]] # particle can attach only at 4 sites relative to other particles
for i in range(int(Nmax/bin_size) +10): # approximation to scale subintervals based on Nmax
stickps.append([[],[],[],[]]) # 4 lists for the 4 quadrants of the grid
cluster_parts.append([[],[],[],[]]) # 4 lists for the 4 quadrants of the grid
# initialize the sublists
add_to_stickps(stickps, stickdir, bin_size)
cluster_parts[0][0].append(cluster[0])
cluster_parts[0][1].append(cluster[0])
cluster_parts[0][2].append(cluster[0])
cluster_parts[0][3].append(cluster[0])
# circle is a list of three values --> [x_center, y_center, radius]
circ = smallestenclosingcircle.make_circle(cluster)
eff_r_check, eff_rl = update_eff_radii(circ[2], 0.5)
# set some controlling flag
active_particle = False # must initialize a random molecule
rand_walk = False
# now we can enter the main loop
while clustsize < Nmax:
if not active_particle:
# generate a random particle along the edge
theta = random.uniform(0,2*math.pi)
start_x = int(math.ceil(circ[0] + eff_r_check*math.cos(theta)))
start_y = int(math.ceil(circ[1] + eff_r_check*math.sin(theta)))
particle = [start_x, start_y]
# skip random walk step and set active_particle flag
active_particle = True
rand_walk = False
# random walk of active particle
if rand_walk:
# time to move to a new position, by randomly picking a walk direction
delta = random.randint(0,3)
temp_pos = [particle[0] + walkdir[delta][0], particle[1] + walkdir[delta][1]]
intersectpossibility = build_intersection(temp_pos, cluster_parts, bin_size)
while temp_pos in intersectpossibility: # keep particle out of cluster (needed when sp < 1)
delta = random.randint(0,3)
temp_pos = [particle[0] + walkdir[delta][0], particle[1] + walkdir[delta][1]]
intersectpossibility = build_intersection(temp_pos, cluster_parts, bin_size)
if distance(temp_pos, [circ[0], circ[1]]) >= eff_rl:
# reset particle if too far away fromthe circle
temp_pos = place_on_cirlce(temp_pos, circ[0], circ[1], eff_r_check)
# if eveything checks out, we can update the position of the particle
particle = temp_pos
# check to see if the particle should be added to the cluster
if distance(particle,[circ[0],circ[1]]) <= eff_r_check: # no need to try if the particle is outside the outside circle
stickps_intersection = build_intersection(particle, stickps, bin_size)
# if the particle is in a position to attach to the cluster
if particle in stickps_intersection:
prob = random.random() # number between 0 and 1
if prob < sp:
# the particle should be added to the cluster
add_to_stickps(stickps, stickdir, bin_size, particle)
add_to_cluster(stickps, particle, cluster_parts, cluster, bin_size)
circ = smallestenclosingcircle.make_circle(cluster)
eff_r_check, eff_rl = update_eff_radii(circ[2], 0.5)
# set the flag to make a new a particle
active_particle = False
else:
rand_walk = True
else:
rand_walk = True
# if you have a new particle, add it to the data
if len(cluster) > clustsize:
clustsize = len(cluster)
fh.write('%d,%d,%d\n'%(len(cluster),particle[0],particle[1]))
if clustsize%500 == 0:
# print an update every n particles (as a sanity check)
print('particle', len(cluster), 'at position:', particle)
if clustsize == Nmax:
# close the data file and make the picture of the cluster
fh.close()
fig, ax = plt.subplots(figsize=(10,10))
for particle in cluster:
plt.scatter(particle[0],particle[1], color='k',s=10)
ax.set_xlim(circ[0]-eff_r_check,circ[0]+eff_r_check)
ax.set_ylim(circ[1]-eff_r_check,circ[1]+eff_r_check)
ax.axis('off')
fig.savefig(fname=strname + '.png', dpi=600, bbox_inches='tight')
def get(self, geocast_id):
"""
Override the standard GET
"""
global all_data, eps
parts = geocast_id.split('/')
dataset = parts[0]
print parts
t = map(float, parts[1].split(','))
print dataset, t
# if task not in region
if not is_rect_cover(all_data[dataset][1], t):
self.write(json.dumps({"error": "invalid task"}))
return
q, q_log = geocast(all_data[dataset][0], t, float(eps))
no_workers, workers, Cells, no_hops, coverage, no_hops2 = post_geocast(t, q, q_log)
performed, worker, dist = performed_tasks(workers, Params.MTD, t, True)
x_min, y_min, x_max, y_max = [], [], [], []
worker_counts, utilities, distances, compactnesses, areas = [], [], [], [], []
if worker is not None:
worker = worker.tolist()
corner_points = Set([])
for cell in Cells:
x_min.append(cell[0].n_box[0][0])
y_min.append(cell[0].n_box[0][1])
x_max.append(cell[0].n_box[1][0])
y_max.append(cell[0].n_box[1][1])
worker_counts.append(cell[0].n_count)
utilities.append([cell[2][1], cell[2][2]])
compactnesses.append(cell[2][3])
distances.append(float("%.3f" % distance_to_rect(t[0], t[1], cell[0].n_box)))
distances.append(float("%.3f" % distance_to_rect(t[0], t[1], cell[0].n_box)))
areas.append(float("%.3f" % rect_area(cell[0].n_box)))
corner_points = corner_points | rect_vertex_set(cell[0].n_box)
points = list(corner_points)
x = make_circle(points)
if x is not None:
cx, cy, r = x
print cx, cy, r
else:
cx, cy, r = 0, 0, 0
no_hops2 = math.ceil(no_hops2)
if performed:
self.write(
json.dumps({"is_performed": performed,
"notified_workers": {"no_workers": no_workers,
"x_coords": workers[0].tolist(),
"y_coords": workers[1].tolist()},
"geocast_query": {"no_cell": len(Cells),
"compactness": q_log[-1][3],
"x_min_coords": x_min,
"y_min_coords": y_min,
"x_max_coords": x_max,
"y_max_coords": y_max,
"worker_counts": worker_counts,
"utilities": utilities,
"compactnesses": compactnesses,
"distances": distances,
"areas": areas},
"spatial_task": {"location": t},
"volunteer_worker": {"location": worker,
"distance": dist},
"hop_count": no_hops2,
"bounding_circle": [cx, cy, r]},
sort_keys=False)
)
else:
self.write(
json.dumps({"is_performed": False,
"notified_workers": {"no_workers": no_workers,
"x_coords": workers[0].tolist(),
"y_coords": workers[1].tolist()},
"geocast_query": {"no_cell": len(Cells),
"x_min_coords": x_min,
"y_min_coords": y_min,
"x_max_coords": x_max,
"y_max_coords": y_max,
"worker_counts": worker_counts,
"utilities": utilities,
"compactnesses": compactnesses,
"distances": distances,
"areas": areas},
"spatial_task": {"location": t},
"volunteer_worker": {"location": worker,
"distance": dist},
"hop_count": no_hops2,
"bounding_circle": [cx, cy, r]},
sort_keys=False)
)
# logging
if Params.GEOCAST_LOG:
info = GeocastInfo(int(performed), t, Cells)
log_str = str(info.logging()) + "\n"
geocast_log("geocast_server", log_str, eps)
def shoot_for_optim(n_points, cannon, enemy, degree, direc, wind_tbl):
x_values = []
y_values = [] #착탄점들의 중심점을 구하기 위해 다 저장
h, d_final = theta2hd(degree)
#print('d_final:', d_final)
idland_og = cannon[:2] + d_final * direc
#print('idland:', idland_og)
d = h / np.tan(degree * (np.pi / 180))
peak_z_og = cannon[2] + h
xy_now_og = cannon[:2] + d * direc
for i in range(n_points):
idland = idland_og
xy_now = xy_now_og
peak_z = peak_z_og
direc_now = direc
np.random.seed(i)
#initialize
# shoot
#현재 고도보다 바로 위에 있는 테이블 값의 풍향을 사용할 것임
wind_h = [idx[1] for idx in wind_tbl.index]
wind_h.insert(0, 0)
idx_now = (wind_h >= peak_z).tolist().index(True)
h_now = peak_z
#포탄 경로 그리기 준비
#total_move = 0
while idx_now > 0:
h_down = h_now - wind_h[idx_now - 1] #수직 하강 거리
one_step = h_down * np.tan(
degree * (np.pi / 180)) #전진 거리. 풍향의 영향이 없을 때의 방향을 기준으로 거리를 계산함
wind_vec = np.array(wind_tbl.vec[idx_now - 1])
wind_vel = wind_tbl.wind_vel[idx_now - 1]
interval_now = wind_tbl.index[idx_now - 1]
cossim = cos_sim(direc_now, wind_vec)
rbeta = np.random.beta(2, 40)
print('rbeta:', rbeta)
vel_power = (100 + cossim * 1.5 * wind_vel) / 100
one_step = one_step * vel_power * (1 + rbeta) #전진거리 수정
#print('풍속에 의해 수정된 전진 거리: {}'.format(one_step))
if abs(cossim) != 1:
#풍향과 풍속을 고려하여 방향 수정
w = rbeta * vel_power
direc_now = (1 -
w) * direc_now + w * wind_vec.astype('float64')
direc_now = (direc_now) / la.norm(direc_now) #unit vector로 만들기
#계산 종료.
#포탄의 전진.
xy_now = xy_now + direc_now * one_step
idx_now -= 1
h_now = wind_h[idx_now]
x_values.append(xy_now[0])
y_values.append(xy_now[1])
#print('실제로 총 {}만큼 전진'.format(total_move))
cir = sc.make_circle(zip(x_values, y_values))
return np.array([cir[0], cir[1]])
def shoot(n_iter, cannon, balloon, wind_tbl, ax, col_id):
mycol = col_list[col_id]
ax.scatter(cannon[0], cannon[1], color=mycol)
ax.text(cannon[0], cannon[1], 'fire')
ax.scatter(balloon[0], balloon[1], color=mycol, s=300)
ax.text(balloon[0], balloon[1], 'balloon')
x_values = []
y_values = [] #착탄점들의 중심점을 구하기 위해 다 저장
#x_shootline = []; y_shootline = [] #착탄 경로 저장
for i in range(n_iter):
np.random.seed(i)
#print('iteration {}'.format(i))
idland, xy_now, peak_z, degree, direc_now = peak_xy(cannon, balloon)
#print('peak_z:', peak_z)
if i == 0:
#ax.scatter(xy_now[0], xy_now[1], color = mycol); ax.text(xy_now[0], xy_now[1], 'peak') #최고점
ax.scatter(idland[0], idland[1], s=40, alpha=0.7, color=mycol)
ax.text(idland[0], idland[1], 'theoretical')
ax.plot([cannon[0], balloon[0]], [cannon[1], balloon[1]],
color=mycol) #cannon to balloon
ax.plot([balloon[0], xy_now[0]], [balloon[1], xy_now[1]],
color=mycol) #baloon to peak
ax.plot([xy_now[0], idland[0]], [xy_now[1], idland[1]],
linestyle='--',
color=mycol) #peak to ideal landing
# shoot
#현재 고도보다 바로 위에 있는 테이블 값의 풍향을 사용할 것임
wind_h = [idx[1] for idx in wind_tbl.index]
wind_h.insert(0, 0)
idx_now = (wind_h >= peak_z).tolist().index(True)
h_now = peak_z
#포탄 경로 그리기 준비
#total_move = 0
while idx_now > 0:
h_down = h_now - wind_h[idx_now - 1] #수직 하강 거리
#print('고도 {} -> {}. {}만큼 하강하는 동안'.format(h_now, wind_h[idx_now - 1], h_down))
one_step = h_down * np.tan(
degree * (np.pi / 180)) #전진 거리. 풍향의 영향이 없을 때의 방향을 기준으로 거리를 계산함
#total_move += one_step
#print('x,y좌표 기준으로 {}만큼 전진'.format(one_step))
wind_vec = np.array(wind_tbl.vec[idx_now - 1])
wind_vel = wind_tbl.wind_vel[idx_now - 1]
interval_now = wind_tbl.index[idx_now - 1]
#print('고도 {} in 구간 {}에서의 바람 방향: {}'.format(wind_h[idx_now], interval_now, wind_vec))
#print('원래 전진 방향: {}'.format(direc_now))
cossim = cos_sim(direc_now, wind_vec)
rbeta = np.random.beta(2, 15)
#print('rbeta:', rbeta)
vel_power = (100 + cossim * wind_vel) / 170
one_step = one_step * vel_power * (1 + rbeta) #전진거리 수정
#print('풍속에 의해 수정된 전진 거리: {}'.format(one_step))
if abs(cossim) != 1:
#풍향과 풍속을 고려하여 방향 수정
w = rbeta * vel_power
direc_now = (1 -
w) * direc_now + w * wind_vec.astype('float64')
direc_now = (direc_now) / la.norm(direc_now) #unit vector로 만들기
#print('바람에 의해 수정된 방향: {}'.format(direc_now))
#else:
#print('바람의 방향이 포탄의 방향과 정확히 일치(혹은 정확히 반대)하므로, 포탄 진행방향 변화 없음. 속도만 수정')
#계산 종료.
#포탄의 전진.
xy_now = xy_now + direc_now * one_step
#x_shootline.append(xy_now[0]); y_shootline.append(xy_now[1]) #peak에서 착탄까지 경로 저장
#print('{},{}에 도착\n'.format(xy_now, wind_h[idx_now - 1]))
idx_now -= 1
h_now = wind_h[idx_now]
#print(xy_now)
#print(x_shootline)
x_values.append(xy_now[0])
y_values.append(xy_now[1])
ax.scatter(xy_now[0], xy_now[1], s=5, color=mycol) #착탄지점 그래프에 그리기
#print('실제로 총 {}만큼 전진'.format(total_move))
cir = sc.make_circle(zip(x_values, y_values))
ax.text(cir[0], cir[1], 'center') #최고점
ax.add_patch(
patches.Circle(
(cir[0], cir[1]), # (x, y)
cir[2], # radius
alpha=0.4,
facecolor=mycol,
edgecolor=mycol,
linewidth=2,
linestyle='solid'))
return idland, np.array([cir[0], cir[1]])
col_sys = [ mag_sys[c]-mag_sys[c+1] for c in range(5) ] ug_rest_sys = grouped['ug_rest'][ ug_rest==np.min(ug_rest) ].iloc[0] # we put the bluest one as a representative in the catalog zs_sys = grouped['zs'][ ug_rest==np.min(ug_rest) ].iloc[0] # using i mag as a ref. to find the centroid :: grouped['ra'][0] is ra_m1 # the separation angle is so small that ra*cos(dec) won't make any difference ra_sys = np.sum(ra *10**(-0.4*mag[:,3])) / np.sum(10**(-0.4*mag[:,3])) dec_sys = np.sum(dec*10**(-0.4*mag[:,3])) / np.sum(10**(-0.4*mag[:,3])) # this one is fast points = [(x,y) for (x,y) in zip(ra,dec)] # pairing up two lists gsize_sys = smec.make_circle(points)[2]*3600 # the radius of the smallest enclosing circle (in arcsec) A = 10**(-0.4*mag[:,3]) # actual flux needs a factor because of the zero point, here we just use them as weights mu = [ra,dec] #np.array(points).T c = [ra_sys,dec_sys] e1_sys, e2_sys = get_shear(A,mu,c,e1,e2,kappa,gsize,reduced=False) # actually no kappa needed fo e! gamma1_sys, gamma2_sys = gamma1.mean(), gamma2.mean() #get_shear(A,mu,c,gamma1,gamma2,kappa,gsize,reduced=False) g1_sys, g2_sys = g1.mean(), g2.mean() #get_shear(A,mu,c,gamma1,gamma2,kappa,gsize) # reduced by default kappa_sys = kappa.mean() # should be checked if it is ok? nGoldmem = sum(i<limiting_mag_i_lsst) #---- magerr_sys[0] = vec_getMagError(mag_sys[0],'LSST_u') magerr_sys[1] = vec_getMagError(mag_sys[1],'LSST_g')
coeff = list(tck[1])
deg = tck[2]
assert deg == 3
pts_int = [[x, y] for x, y in zip(coeff[0], coeff[1])]
xi, yi = interpolate.splev(np.linspace(0, 1, 1000), tck)
c = NURBS.Curve()
c.degree = 3
c.ctrlpts = pts_int
c.knotvector = knots
'''c.vis = VisMPL.VisCurve2D(axes=False, labels=False, ctrlpts=False, legend=True)
c.render()'''
curves_0 = operations.decompose_curve(c)
base_pts = [(p[0], p[1]) for c in curves_0 for p in c.ctrlpts]
x, y, r = make_circle(base_pts) # O(n)
center = (x, y)
radius = r
pts_pr = []
for c in curves_0:
pts_pr.append(project_to_circle(c.ctrlpts[0], center, radius))
curves_1 = []
for i in range(len(pts_pr) - 1):
c = NURBS.Curve()
c.degree = 3
c.ctrlpts = [
pts_pr[i],
get_outer_angle_4(pts_pr[i], pts_pr[i + 1], center, radius)[1],
get_outer_angle_4(pts_pr[i], pts_pr[i + 1], center, radius)[2],
def get_cent_rad(f_name, coords_flag, cr_file_cols, m_m_n, vor_flag, ra_cent,
dec_cent, acp_pts, acp_mags, pts_area, pts_vert,
mean_filt_area, area_frac_range):
'''
Assign a center and a radius for each overdensity/group identified.
Use an automatic algorithm based on a Voronoi diagram and grouping neighbor
stars, or a file with center coordinates and radii already stored.
'''
if vor_flag == 'voronoi':
# Apply maximum area filter.
pts_area_thres, mag_area_thres, vert_area_thres = area_filter(
acp_pts, acp_mags, pts_area, pts_vert, mean_filt_area,
area_frac_range)
save_to_log(f_name, "\nStars filtered by area range: {}".format(
len(pts_area_thres)), 'a')
save_to_log(f_name, 'Detect shared vertex', 'a')
all_groups = shared_vertex(vert_area_thres)
# This is a costly process.
save_to_log(f_name, 'Assign points to groups', 'a')
neighbors, neig_mags = group_stars(pts_area_thres, mag_area_thres,
vert_area_thres, all_groups)
save_to_log(f_name, 'Groups found: {}'.format(len(neighbors)), 'a')
# Keep only those groups with a higher number of members than
# min_neighbors.
pts_neighbors, mags_neighbors = neighbors_filter(neighbors, neig_mags,
m_m_n)
save_to_log(f_name,
'\nGroups filtered by number of members: {}'.format(
len(pts_neighbors)), 'a')
# Check if at least one group was defined with the minimum
# required number of neighbors.
if pts_neighbors:
# Obtain center and radius for each overdensity identified.
cent_rad = []
for g in pts_neighbors:
pts = np.array(zip(*g))
mean_pts = np.mean(pts, 0)
# Translate towards origin
pts -= mean_pts
result = make_circle(pts)
# Move back to correct position.
c_r = (result[0] + mean_pts[0], result[1] + mean_pts[1],
result[2])
cent_rad.append([c_r[0], c_r[1], c_r[2]])
else:
cent_rad = []
save_to_log(f_name, "No groups found with members in range {}".
format(m_m_n), 'a')
else:
# Get data from file.
cent_rad = get_cents_rad_file(coords_flag, vor_flag, cr_file_cols,
ra_cent, dec_cent)
pts_area_thres, mag_area_thres = [[0., 0.], [0., 0.]], [0.]
pts_neighbors, mags_neighbors = [[[0.], [0.]]], [0]
return cent_rad, pts_area_thres, mag_area_thres, pts_neighbors,\
mags_neighbors
def loop_through_sources(sigma=5, my_directory='/data5/sean/ldr2'):
"""Plot postage stamp images of LDR2 BL Lacs.
Parameters
----------
sigma : float or integer
The threshold of the significance to set the mask, as a factor of the
local RMS. The default is 5.
my_directory : string
Working directory.
Returns
-------
string
The name of the CSV containing the results.
"""
results_path = f'{my_directory}/measure_point_sources/'
if Path(results_path).exists() and Path(results_path).is_dir():
shutil.rmtree(results_path)
os.mkdir(results_path, 0o755)
results_csv = (f'{results_path}/measure_point_sources.csv')
result_header = ('BZB,Name,RA,Dec,S_peak (mJy),RMS (mJy/beam),D (asec)')
print(result_header)
with open(results_csv, 'a') as f:
f.write(f'{result_header}\n')
df = pd.read_csv(f'{my_directory}/S_Code=S,DC_Maj=0,_1deg - S_Code=S,'
'DC_Maj=0,_1deg.csv')
df = df[(df['PS SNR'] > 10) & (df['Degree separation'] < 0.5)]
df = df[(df['DC_Maj'] == 0) & (df['DC_Min'] == 0) & (df['S_Code'] == 'S')]
plt.figure(figsize=(13.92, 8.60)).patch.set_facecolor('white')
plt.rcParams['font.family'] = 'serif'
plt.rcParams['mathtext.fontset'] = 'dejavuserif'
mpl.rcParams['xtick.major.size'] = 10
mpl.rcParams['xtick.major.width'] = 2
mpl.rcParams['xtick.minor.size'] = 5
mpl.rcParams['xtick.minor.width'] = 2
mpl.rcParams['ytick.major.size'] = 10
mpl.rcParams['ytick.major.width'] = 2
mpl.rcParams['ytick.minor.size'] = 5
mpl.rcParams['ytick.minor.width'] = 2
mpl.rcParams['axes.linewidth'] = 2
dummy = 123456
pix = 1.5 # arcseconds per pixel
colors = ['#118ab2', '#06d6a0', '#ffd166', '#ef476f']
for bzb, bzb_mosaic, source_name, ra, dec, mosaic, rms, pf in zip(
df['BZB name'], df['BZB mosaic'], df['Source_Name'], df['RA'],
df['DEC'], df['Mosaic_ID'], df['Isl_rms'], df['Peak_flux']):
if not bzb_mosaic:
continue # don't use the source if it is from a different pointing
threshold = sigma * rms / 1000 # jansky
hdu = fits.open(f'{my_directory}/mosaics/{mosaic}-mosaic.fits')[0]
wcs = WCS(hdu.header, naxis=2)
sky_position = SkyCoord(ra, dec, unit='deg')
size = [1, 1] * u.arcmin
cutout = Cutout2D(np.squeeze(hdu.data), sky_position, size=size,
wcs=wcs)
d = cutout.data
copy_d = np.copy(d)
last_copy = np.copy(d)
another_copy_d = np.copy(d)
d[d < threshold] = 0
d[d >= threshold] = 1
rows, cols = d.shape
d = label(d)
source_islands = nearest_to_centre(d, percent=0.1)
for source_island in source_islands:
d[d == source_island] = dummy
d[d != dummy] = 0
copy_d[d != dummy] = 0
set_to_nil = [] # identify values we can set to zero for being inside
for r in range(rows): # set to 0 if surrounded by non nans
for c in range(cols):
try:
if (d[r - 1, c - 1] != 0 and d[r - 1, c] != 0 and
d[r - 1, c + 1] != 0 and d[r, c - 1] != 0 and
d[r, c + 1] != 0 and d[r + 1, c - 1] != 0 and
d[r + 1, c] != 0 and d[r + 1, c + 1] != 0):
set_to_nil.append((r, c))
except IndexError:
print(f'Index error for {source_name}.')
continue
for r, c in set_to_nil:
d[r, c] = 0 # needs separate loop to avoid checkered pattern
# d is an outline of the source (one) and everything else is zero
# copy_d is the source with flux values and everything else is zero
# another_copy_d has flux values throughout
good_cells = []
for r in range(rows):
for c in range(cols):
if d[r, c] != 0:
good_cells.append([r, c])
x, y, r = smallestenclosingcircle.make_circle(good_cells)
ax = plt.subplot(projection=cutout.wcs)
plt.xlabel('Right ascension', fontsize=20, color='black')
plt.ylabel('Declination', fontsize=20, color='black')
ax.tick_params(axis='both', which='major', labelsize=20)
plt.imshow(another_copy_d, vmin=0, vmax=np.nanmax(another_copy_d),
origin='lower', norm=DS9Normalize(stretch='arcsinh'),
cmap='cubehelix_r', interpolation='gaussian')
beam = Circle((6, 6), radius=2, linestyle='dashed', lw=2, fc='none',
edgecolor='blue') # radius=2 pixels -> 3" -> diameter=6"
diffuse = Circle((y + 0.5, x + 0.5), radius=r, fc='none',
edgecolor='k', lw=2)
ax.add_patch(beam)
ax.add_patch(diffuse)
cbar = plt.colorbar()
cbar.set_label(r'Jy beam$^{-1}$', size=20)
cbar.ax.tick_params(labelsize=20)
plt.minorticks_on()
plt.tick_params(which='minor', length=0)
levels = [level * threshold for level in [1, 2, 4, 8]]
plt.contour(another_copy_d, levels=levels, origin='lower',
colors=colors)
plt.contour(last_copy, levels=[-threshold * (3 / 5)], colors='grey',
origin='lower', linestyles='dashed')
saved = f'{results_path}/{source_name}.png'
plt.savefig(saved)
plt.clf()
# os.system(f'convert {saved} -trim {saved}') # removes whitespace
result = (f'{bzb},{source_name},{ra},{dec},{pf},{rms},'
f'{r * pix * 2:.1f}')
print(result)
with open(results_csv, 'a') as f:
f.write(f'{result}\n')
return results_csv
def make_circles(polygons):
return [make_circle(np.array(poly.boundary.xy).T) for poly in polygons]
image[0, 0] = (image[0, 1] + image[1, 0]) / 2.
image = image - mark
image = image / 255.
return image
with open(csvfile, "w") as output:
writer = csv.writer(output, lineterminator='\n')
writer.writerow(['X', 'Y', 'R'])
for i in range(0, nb_samples):
image = np.array(Image.open(testImagesFolder + imageList[i]))
label = np.asarray(dfLabels.iloc[i, 1:].values, dtype='float32')
labelP = world2pixel(label.reshape((21, 3)).copy(), fx, fy, u0, v0)
circx, circy, radius = make_circle(labelP[:, 0:2].copy())
center = np.asarray([circx, circy])
radius = radius + 16
lefttop_pixel = center - radius
rightbottom_pixel = center + radius
new_Xmin = max(lefttop_pixel[0], 0)
new_Ymin = max(lefttop_pixel[1], 0)
new_Xmax = min(rightbottom_pixel[0], image.shape[1] - 1)
new_Ymax = min(rightbottom_pixel[1], image.shape[0] - 1)
# print([new_Xmin, new_Xmax, new_Ymin, new_Ymax])
if new_Xmin > 640 or abs(new_Xmin - new_Xmax) < 20:
continue
imCrop = image.copy()[int(new_Ymin):int(new_Ymax),
def loop_through_sources(sigma=4, my_directory='/data5/sean/ldr2'):
"""Plot postage stamp images of LDR2 BL Lacs.
Parameters
----------
sigma : float or integer
The threshold of the significance to set the mask, as a factor of the
local RMS. The default is 4.
my_directory : string
Working directory.
Returns
-------
string
The name of the CSV containing the results.
"""
df = pd.read_csv(f'{my_directory}/catalogues/pulsars-10asec-match.csv')
plt.figure(figsize=(13.92, 8.60)).patch.set_facecolor('white')
plt.rcParams['font.family'] = 'serif'
plt.rcParams['mathtext.fontset'] = 'dejavuserif'
mpl.rcParams['xtick.major.size'] = 10
mpl.rcParams['xtick.major.width'] = 2
mpl.rcParams['xtick.minor.size'] = 5
mpl.rcParams['xtick.minor.width'] = 2
mpl.rcParams['ytick.major.size'] = 10
mpl.rcParams['ytick.major.width'] = 2
mpl.rcParams['ytick.minor.size'] = 5
mpl.rcParams['ytick.minor.width'] = 2
mpl.rcParams['axes.linewidth'] = 2
dummy = 123456
sbar_asec = 30 # desired length of scalebar in arcseconds
pix = 1.5 # arcseconds per pixel
for source_name, ra, dec, mosaic, rms in zip(df['NAME'], df['RAJD'],
df['DECJD'], df['Mosaic_ID'],
df['Isl_rms']):
threshold = sigma * rms / 1000 # jansky
hdu = fits.open(f'{my_directory}/mosaics/{mosaic}-mosaic.fits')[0]
wcs = WCS(hdu.header, naxis=2)
sky_position = SkyCoord(ra, dec, unit='deg')
size = [2, 2] * u.arcmin
p = 6
cutout = Cutout2D(np.squeeze(hdu.data),
sky_position,
size=size,
wcs=wcs)
d = cutout.data
copy_d = np.copy(d)
another_copy_d = np.copy(d)
d[d < threshold] = 0
d[d >= threshold] = 1
rows, cols = d.shape
d = label(d) # label islands of emission
source_islands = nearest_to_centre(d, percent=0.1)
for source_island in source_islands:
d[d == source_island] = dummy
d[d != dummy] = 0
copy_d[d != dummy] = 0
set_to_nil = [] # identify values we can set to zero for being inside
for r in range(rows): # set to 0 if surrounded by non nans
for c in range(cols):
try:
if (d[r - 1, c - 1] != 0 and d[r - 1, c] != 0
and d[r - 1, c + 1] != 0 and d[r, c - 1] != 0
and d[r, c + 1] != 0 and d[r + 1, c - 1] != 0
and d[r + 1, c] != 0 and d[r + 1, c + 1] != 0):
set_to_nil.append((r, c))
except IndexError:
print(f'Index error for {source_name}.')
continue
for r, c in set_to_nil:
d[r, c] = 0 # needs separate loop to avoid checkered pattern
# d is an outline of the source (one) and everything else is zero
# copy_d is the source with flux values and everything else is zero
# another_copy_d has flux values throughout
good_cells = []
for r in range(rows):
for c in range(cols):
if d[r, c] != 0:
good_cells.append([r, c])
x, y, r = smallestenclosingcircle.make_circle(good_cells)
ax = plt.subplot(projection=cutout.wcs)
plt.xlabel('Right ascension', fontsize=20, color='black')
plt.ylabel('Declination', fontsize=20, color='black')
ax.tick_params(axis='both', which='major', labelsize=20)
plt.imshow(another_copy_d,
vmin=0,
vmax=np.nanmax(another_copy_d),
origin='lower',
norm=DS9Normalize(stretch='arcsinh'),
cmap='plasma_r') # interpolation='gaussian'
beam = Circle((6, 6),
radius=2,
linestyle='dashed',
lw=2,
fc='none',
edgecolor='blue')
diffuse = Circle((y + 0.5, x + 0.5),
radius=r,
fc='none',
edgecolor='k',
lw=2)
ax.add_patch(beam)
ax.add_patch(diffuse)
sbar = sbar_asec / pix # length of scalebar in pixels
s = cutout.data.shape[1] # plot scalebar
plt.plot([p, p + sbar], [s - p, s - p], marker='None', lw=2, color='b')
plt.text(p,
s - (5 * p / 6),
f'{sbar_asec:.0f}"',
fontsize=20,
color='b')
cbar = plt.colorbar()
cbar.set_label(r'Jy beam$^{-1}$', size=20)
cbar.ax.tick_params(labelsize=20)
plt.minorticks_on()
plt.tick_params(which='minor', length=0)
plt.contour(another_copy_d,
levels=[threshold],
origin='lower',
colors='w')
plt.contour(another_copy_d - copy_d,
levels=[threshold],
colors='grey',
origin='lower')
plt.savefig(f'{my_directory}/images/pulsar-{source_name}.png')
plt.clf()
print(f'{source_name}: {r * 1.5 * 2:.1f}"')
def find_rp(r, p, constraints, point_sets, mapping):
"""Function returns the smallest disc that contains p on its boundary."""
#print(f"Computing rp for {p}...")
all_points = [p for point_set in point_sets for p in point_set]
all_points = [
q for q in all_points if q != p and euclid_dist(p, q) < 2 * r
] # Compute I(p, r)
c_depth = [0 for ps in point_sets]
open_discs = [p]
valid_configs = []
intersections = []
c_depth[mapping[p]] += 1
intersection_mapping = {}
for q in all_points:
midpoint = ((p[0] + q[0]) / 2), ((p[1] + q[1]) / 2)
a = euclid_dist(p, q) / 2
h = math.sqrt(r**2 - a**2)
p1 = (midpoint[0] + h * ((q[1] - p[1]) / (2 * a)),
midpoint[1] - h * ((q[0] - p[0]) / (2 * a)))
p2 = (midpoint[0] - h * ((q[1] - p[1]) / (2 * a)),
midpoint[1] + h * ((q[0] - p[0]) / (2 * a)))
intersection_mapping[p1] = q
intersection_mapping[p2] = q
intersections.append(p1)
intersections.append(p2)
if abs((math.atan2(p1[1] - p[1], p1[0] - p[0]) + 2 * math.pi) %
(2 * math.pi) -
(math.atan2(p2[1] - p[1], p2[0] - p[0]) + 2 * math.pi) %
(2 * math.pi)) > math.pi:
open_discs.append(q)
c_depth[mapping[q]] += 1
intersections = sorted(
intersections,
key=lambda q: (math.atan2(q[1] - p[1], q[0] - p[0]) + 2 * math.pi) %
(2 * math.pi))
for i in range(0, len(intersections)):
intersection = intersections[i]
if intersection_mapping[intersection] in open_discs:
c_depth[mapping[intersection_mapping[intersection]]] -= 1
open_discs.remove(intersection_mapping[intersection])
else:
c_depth[mapping[intersection_mapping[intersection]]] += 1
open_discs.append(intersection_mapping[intersection])
valid = True
for d, (c, op) in zip(c_depth, constraints):
if (op == 1 or op == 0) and d < c: # >=
valid = False
break
'''elif op == 0 and d != c: # =
valid = False
break
elif op == -1 and d > c: # <=
valid = False
break'''
if valid:
valid_configs.append(list(open_discs))
circles = []
for v in valid_configs: # O(n^2)
x, y, r = make_circle(v) # O(n)
valid = True
for point_set, (c, op) in zip(point_sets, constraints): # O(n)
if op == 1:
continue
no_points = len(
[p for p in point_set if euclid_dist(p, (x, y)) <= r])
if op == 0 and no_points != c:
valid = False
break
elif op == -1 and no_points > c:
valid = False
break
if valid:
circles.append((x, y, r))
if len(circles) == 0:
min_disc = (0, 0, math.inf)
else:
min_disc = min(circles, key=lambda c: c[2])
return min_disc
def find_best_cylinder(list_atoms, coord_matrix):
"""Find the thinnest cylinder dimesions where the molecule could fit add clouds of points around the atoms before the PCA (pi/3 in every direction with atomic radius)
x = r*sin(theta)*cos(theta)
y = r*sin(theta)*sin(theta) theta is inclination from top (0 to pi) and phi is azimuth (0 to 2pi)
z = r*cos(theta)
"""
# import numpy as np
# import scipy
# from sklearn.decomposition import PCA
# from smallestenclosingcircle import make_circle
index_of_volumes = {
'H': 7.24,
'C': 20.58,
'N': 15.60,
'O': 14.71,
'F': 13.31,
'Cl': 22.45,
'Br': 26.52,
'I': 32.52,
'P': 24.43,
'S': 24.43,
'As': 26.52,
'B': 40.48,
'Si': 38.79,
'Se': 28.73,
'Te': 36.62
}
index_of_radii = {
'H': 1.2,
'C': 1.7,
'N': 1.55,
'O': 1.52,
'F': 1.47,
'Cl': 1.75,
'Br': 1.85,
'I': 1.98,
'P': 1.8,
'S': 1.8,
'As': 1.85,
'B': 2.13,
'Si': 2.1,
'Se': 1.9,
'Te': 2.06
}
angle_nbs = 6 # for angle_nbs = 3 there will be points spaced by pi/3 so three sections in inclinations and six in azimutal
sphere_points = []
for i in xrange(len(list_atoms)):
radius = index_of_radii[list_atoms[i]]
top_sphere_point = [
coord_matrix[i][0], coord_matrix[i][1],
coord_matrix[i][2] + radius * np.cos(0)
]
bottom_sphere_point = [
coord_matrix[i][0], coord_matrix[i][1],
coord_matrix[i][2] + radius * np.cos(np.pi)
]
sphere_points.append(top_sphere_point)
sphere_points.append(bottom_sphere_point)
for inclination_angle in np.linspace(0, np.pi, angle_nbs + 1)[1:-1]:
for azymuth_angle in np.linspace(0, np.pi * 2, angle_nbs * 2):
new_sphere_point = [
coord_matrix[i][0] +
radius * np.sin(inclination_angle) * np.cos(azymuth_angle),
coord_matrix[i][1] +
radius * np.sin(inclination_angle) * np.sin(azymuth_angle),
coord_matrix[i][2] + radius * np.cos(inclination_angle)
]
sphere_points.append(new_sphere_point)
# print len(sphere_points)
# print len(coord_matrix[:])
# print np.array(sphere_points)
total_matrix = np.concatenate((coord_matrix, sphere_points), axis=0)
pca = PCA(n_components=3)
transform = pca.fit_transform(total_matrix)
transform_coord = pca.transform(coord_matrix)
point_cloud = zip(transform.T[1][:], transform.T[2][:])
height = np.max(transform.T[0][:]) - np.min(transform.T[0][:])
rad = make_circle(point_cloud)
return [rad[2], height]
def show_cylinder(smiles):
conf, energ = get_best_conformation(smiles)
check_for_invalid_ = compose_matrix_from_raw_xyz(conf)
print 'this is the python plot coordinate string'
print conf
list_atoms, coord_matrix = check_for_invalid_
index_of_volumes = {
'H': 7.24,
'C': 20.58,
'N': 15.60,
'O': 14.71,
'F': 13.31,
'Cl': 22.45,
'Br': 26.52,
'I': 32.52,
'P': 24.43,
'S': 24.43,
'As': 26.52,
'B': 40.48,
'Si': 38.79,
'Se': 28.73,
'Te': 36.62
}
index_of_radii = {
'H': 1.2,
'C': 1.7,
'N': 1.55,
'O': 1.52,
'F': 1.47,
'Cl': 1.75,
'Br': 1.85,
'I': 1.98,
'P': 1.8,
'S': 1.8,
'As': 1.85,
'B': 2.13,
'Si': 2.1,
'Se': 1.9,
'Te': 2.06
}
angle_nbs = 6 # for angle_nbs = 3 there will be points spaced by pi/3 so three sections in inclinations and six in azimutal
sphere_points = []
for i in xrange(len(list_atoms)):
radius = index_of_radii[list_atoms[i]]
top_sphere_point = [
coord_matrix[i][0], coord_matrix[i][1],
coord_matrix[i][2] + radius * np.cos(0)
]
bottom_sphere_point = [
coord_matrix[i][0], coord_matrix[i][1],
coord_matrix[i][2] + radius * np.cos(np.pi)
]
sphere_points.append(top_sphere_point)
sphere_points.append(bottom_sphere_point)
for inclination_angle in np.linspace(0, np.pi, angle_nbs + 1)[1:-1]:
for azymuth_angle in np.linspace(0, np.pi * 2, angle_nbs * 2):
new_sphere_point = [
coord_matrix[i][0] +
radius * np.sin(inclination_angle) * np.cos(azymuth_angle),
coord_matrix[i][1] +
radius * np.sin(inclination_angle) * np.sin(azymuth_angle),
coord_matrix[i][2] + radius * np.cos(inclination_angle)
]
sphere_points.append(new_sphere_point)
# print len(sphere_points)
# print len(coord_matrix[:])
# print np.array(sphere_points)
total_matrix = np.concatenate((coord_matrix, sphere_points), axis=0)
pca = PCA(n_components=3)
transform = pca.fit_transform(total_matrix)
transform_coord = pca.transform(coord_matrix)
point_cloud = zip(transform.T[1][:], transform.T[2][:])
height = np.max(transform.T[0][:]) - np.min(transform.T[0][:])
rad = make_circle(point_cloud)
top = np.max(transform.T[0][:])
bottom = np.min(transform.T[0][:])
# print height
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
# print [index_of_radii[atom]**2*np.pi for atom in list_atoms]
### Not transformed coordinates scatter plot
### ax.scatter(coord_matrix.T[0][:],coord_matrix.T[1][:], coord_matrix.T[2][:], s=[(index_of_radii[atom]*5)**2*np.pi for atom in list_atoms], c=[index_of_radii[atom] for atom in list_atoms], alpha=0.75)
### ax.scatter(total_matrix.T[0][:],total_matrix.T[1][:], total_matrix.T[2][:], s = 2, alpha=0.75)
#### Transformed coordinates scatter plot
ax.scatter(transform_coord.T[0][:],
transform_coord.T[1][:],
transform_coord.T[2][:],
s=[(index_of_radii[atom] * 5)**2 * np.pi
for atom in list_atoms],
c=[index_of_radii[atom] for atom in list_atoms],
alpha=0.75)
ax.scatter(transform.T[0][:],
transform.T[1][:],
transform.T[2][:],
s=2,
alpha=0.75)
### Visual indications, mostly circles to outline the perimeter of the cylinder
n_circles = 6
zs = np.linspace(bottom, top, n_circles)
for i in xrange(n_circles):
circle = plt.Circle((rad[0], rad[1]),
rad[2],
fill=(i == 0 or i == n_circles - 1),
alpha=0.2)
ax.add_patch(circle)
art3d.pathpatch_2d_to_3d(circle, z=zs[i], zdir="x")
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
ax.set_title('{} ({})'.format(smiles, rad[2]))
plt.axis('equal')
plt.show()
def loop_through_sources(sigma=5, my_directory='/data5/sean/ldr2'):
"""Plot postage stamp images of LDR2 BL Lacs.
Parameters
----------
sigma : float or integer
The threshold of the significance to set the mask, as a factor of the
local RMS. The default is 4.
my_directory : string
Working directory.
Returns
-------
string
The name of the CSV containing the results.
"""
results_csv = f'{my_directory}/images/ldr2.csv'
try:
os.remove(results_csv)
except OSError:
pass
df = pd.read_csv(f'{my_directory}/catalogues/final.csv')
result_header = ('Name,RA,Dec,RMS (uJy),Redshift,Width ("),Width (kpc),'
'Peak flux (mJy)\n')
with open(results_csv, 'a') as f:
f.write(result_header)
plt.figure(figsize=(13.92, 8.60)).patch.set_facecolor('white')
plt.rcParams['font.family'] = 'serif'
plt.rcParams['mathtext.fontset'] = 'dejavuserif'
mpl.rcParams['xtick.major.size'] = 10
mpl.rcParams['xtick.major.width'] = 2
mpl.rcParams['xtick.minor.size'] = 5
mpl.rcParams['xtick.minor.width'] = 2
mpl.rcParams['ytick.major.size'] = 10
mpl.rcParams['ytick.major.width'] = 2
mpl.rcParams['ytick.minor.size'] = 5
mpl.rcParams['ytick.minor.width'] = 2
mpl.rcParams['axes.linewidth'] = 2
dummy = 123456
sbar_asec = 30 # desired length of scalebar in arcseconds
pix = 1.5 # arcseconds per pixel
colors = ['#118ab2', '#06d6a0', '#ffd166', '#ef476f']
print('Name, asec, kpc, threshold, UL?')
for source_name, ra, dec, mosaic, rms, z, pf, comp in zip(
df['Name'], df['BZCAT RA'], df['BZCAT Dec'], df['Mosaic_ID'],
df['Isl_rms'], df['redshift'], df['Peak_flux'], df['Compact']):
source_name = '5BZB' + source_name
source_name = source_name.replace(' ', '')
threshold = sigma * rms / 1000 # jansky
thresh_ans = f'{sigma}sigma'
# if threshold < (pf / 50) / 1000:
# # see 2.2 of https://arxiv.org/pdf/1907.03726.pdf
# four_sigma = threshold
# threshold = (pf / 50) / 1000
# thresh_ans = '1/50 S_peak'
hdu = fits.open(f'{my_directory}/mosaics/{mosaic}-mosaic.fits')[0]
wcs = WCS(hdu.header, naxis=2)
sky_position = SkyCoord(ra, dec, unit='deg')
if source_name == '5BZBJ1202+4444' or source_name == '5BZBJ1325+4115':
size = [3, 3] * u.arcmin
p = 9
elif (source_name == '5BZBJ1419+5423'
or source_name == '5BZBJ0945+5757'):
size = [4, 4] * u.arcmin
p = 12
else:
size = [2, 2] * u.arcmin
p = 6
cutout = Cutout2D(np.squeeze(hdu.data),
sky_position,
size=size,
wcs=wcs)
d = cutout.data
copy_d = np.copy(d)
last_copy = np.copy(d)
another_copy_d = np.copy(d)
d[d < threshold] = 0
d[d >= threshold] = 1
rows, cols = d.shape
d = label(d) # label islands of emission
source_islands = nearest_to_centre(d, percent=0.1)
if source_name == '5BZBJ1000+5746':
source_islands = [1, 2, 3, 4]
elif source_name == '5BZBJ1202+4444':
source_islands = [1, 2, 3]
elif (source_name == '5BZBJ1203+5430'
or source_name == '5BZBJ1419+5423'):
source_islands = [1, 2]
elif source_name == '5BZBJ1409+5939':
source_islands = [2, 3]
elif source_name == '5BZBJ1203+5430':
source_islands = [1, 2]
for source_island in source_islands:
d[d == source_island] = dummy
d[d != dummy] = 0
copy_d[d != dummy] = 0
set_to_nil = [] # identify values we can set to zero for being inside
for r in range(rows): # set to 0 if surrounded by non nans
for c in range(cols):
try:
if (d[r - 1, c - 1] != 0 and d[r - 1, c] != 0
and d[r - 1, c + 1] != 0 and d[r, c - 1] != 0
and d[r, c + 1] != 0 and d[r + 1, c - 1] != 0
and d[r + 1, c] != 0 and d[r + 1, c + 1] != 0):
set_to_nil.append((r, c))
except IndexError:
print(f'Index error for {source_name}.')
continue
for r, c in set_to_nil:
d[r, c] = 0 # needs separate loop to avoid checkered pattern
# d is an outline of the source (one) and everything else is zero
# copy_d is the source with flux values and everything else is zero
# another_copy_d has flux values throughout
good_cells = []
for r in range(rows):
for c in range(cols):
if d[r, c] != 0:
good_cells.append([r, c])
x, y, r = smallestenclosingcircle.make_circle(good_cells)
ax = plt.subplot(projection=cutout.wcs)
plt.xlabel('Right ascension', fontsize=20, color='black')
plt.ylabel('Declination', fontsize=20, color='black')
ax.tick_params(axis='both', which='major', labelsize=20)
plt.imshow(another_copy_d,
vmin=0,
vmax=np.nanmax(another_copy_d),
origin='lower',
norm=DS9Normalize(stretch='arcsinh'),
cmap='cubehelix_r',
interpolation='gaussian')
beam = Circle((6, 6),
radius=2,
linestyle='dashed',
lw=2,
fc='none',
edgecolor='blue') # radius=2 pixels -> 3" -> diameter=6"
# diffuse = Circle((y + 0.5, x + 0.5), radius=r, fc='none',
# edgecolor='k', lw=2)
ax.add_patch(beam)
# if comp == False: # noqa
# ax.add_patch(diffuse)
kpc_per_asec = get_kpc_per_asec(z=z)
sbar = sbar_asec / pix # length of scalebar in pixels
kpc_per_pixel = kpc_per_asec * pix
s = cutout.data.shape[1] # plot scalebar
plt.plot([p, p + sbar], [s - p, s - p], marker='None', lw=2, color='b')
plt.text(p,
s - (5 * p / 6), f'{sbar_asec:.0f}" = '
f'{kpc_per_pixel * sbar:.0f} kpc',
fontsize=20,
color='b')
cbar = plt.colorbar()
cbar.set_label(r'Jy beam$^{-1}$', size=20)
cbar.ax.tick_params(labelsize=20)
plt.minorticks_on()
plt.tick_params(which='minor', length=0)
# levels = [level * threshold for level in [1, 2, 4, 8]]
levels = [level * threshold for level in [1, 2, 4, 8]]
plt.contour(another_copy_d,
levels=levels,
origin='lower',
colors=colors)
plt.contour(last_copy,
levels=[-threshold * (3 / 5)],
colors='grey',
origin='lower',
linestyles='dashed')
# plt.contour(another_copy_d - copy_d, levels=[threshold],
# colors='grey', origin='lower')
saved = f'{my_directory}/images/ldr2-{source_name}.png'
# if thresh_ans == '1/50 S_peak':
# plt.contour(last_copy, levels=[-four_sigma], colors='grey',
# origin='lower', linestyles='dashed')
# plt.contour(last_copy, levels=[four_sigma], colors='grey',
# origin='lower', linestyles='solid')
print('view me: gpicview ' + saved)
plt.savefig(saved)
plt.clf()
os.system(f'convert {saved} -trim {saved}') # removes whitespace
width = r * kpc_per_pixel * 2 # radius to diameter
result = (f'{source_name},{ra},{dec},{rms * 1e3},{z},'
f'{r * pix * 2:.1f}, {width:.1f}, {pf}\n')
print(f'{source_name[4:]}, {r * pix * 2:.4f}, {width:.4f}, '
f'{thresh_ans}, {comp}')
with open(results_csv, 'a') as f:
f.write(result)
return results_csv