def similarity(sketch, other_sketch):
"""
sketch = sketchpad json output
other_sketch = saved json output from Django
"""
result = {}
if isinstance(sketch, dict) and isinstance(other_sketch, dict):
x, y = create_xy_coords('search', sketch)
P = np.array([x, y]).T
x1, y1 = create_xy_coords('other', other_sketch)
Q = np.array([x1, y1]).T
dh, ind1, ind2 = directed_hausdorff(P, Q)
df = similaritymeasures.frechet_dist(P, Q)
dtw, d = similaritymeasures.dtw(P, Q)
pcm = similaritymeasures.pcm(P, Q)
area = similaritymeasures.area_between_two_curves(P, Q)
cl = similaritymeasures.curve_length_measure(P, Q)
result = {
"dh": dh,
"df": df,
"dtw": dtw,
"pcw": pcm,
"cl": cl,
"area": area
}
return result
else:
return {"dh": 0}
def similarity_measures(LOOKBACK=MS_IN_A_DAY, **kwargs):
"""
Calculate all similarity measures between two trajectories
"""
log.info(f'Loading GPS data for 1st trajectory...')
gps1 = gps(**kwargs)
if gps1:
arr1 = pd.DataFrame(gps1)[['latitude', 'longitude']].to_numpy()
else:
return {'timestamp':kwargs['start'],
'frechet_distance': None,
'area_between': None,
'partial_curve_mapping': None,
'curve_length_similarity': None,
'fastDTW_score': None}
log.info(f'Loading GPS data for 2nd trajectory...')
start2 = kwargs['start'] - LOOKBACK
end2 = kwargs['end'] - LOOKBACK
gps2 = gps(id = kwargs['id'], start = start2, end = end2)
log.info(f'Calculating all similarity measures...')
if gps2:
arr2 = pd.DataFrame(gps2)[['latitude', 'longitude']].to_numpy()
log.info(f'Calculating Frechet...')
discrete_frechet = similaritymeasures.frechet_dist(arr1, arr2)
log.info(f'Calculating Area between...')
area_between = similaritymeasures.area_between_two_curves(arr1, arr2)
log.info(f'Calculating PCM...')
pcm = similaritymeasures.pcm(arr1, arr2)
log.info(f'Calculating curve length...')
curve_length = similaritymeasures.curve_length_measure(arr1, arr2)
log.info(f'Calculating FastDTW...')
fastDTW_score, _ = fastdtw(arr1, arr2, dist=euclidean)
else:
return {'timestamp':kwargs['start'],
'frechet_distance': None,
'area_between': None,
'partial_curve_mapping': None,
'curve_length_similarity': None,
'fastDTW_score': None}
return {'timestamp':kwargs['start'],
'frechet_distance': discrete_frechet,
'area_between': area_between,
'partial_curve_mapping': pcm,
'curve_length_similarity': curve_length,
'fastDTW_score': fastDTW_score}
def get_best_blur(
evt_file,
numiter,
region_file,
blur_vals,
radius_100p,
binsize=0.2,
spectrum="core_flux_chart.dat",
out_root_common="core_psf",
):
xcen, ycen, ra, dec = get_centroids(evt_file, region_file)
print(xcen, ycen)
ecf_fractions = [
0.01,
0.025,
0.05,
0.075,
0.1,
0.2,
0.3,
0.4,
0.5,
0.6,
0.7,
0.8,
0.85,
0.9,
0.95,
0.99,
]
n_fractions = len(ecf_fractions)
ecf_profile_values = np.zeros((blur_vals.shape[0], n_fractions),
dtype=float)
ecf_radii_values = np.zeros((blur_vals.shape[0], n_fractions), dtype=float)
# generate the profile of the core
obs_ecf_file = "obs_ecf.fits"
ecf_calc.punlearn()
ecf_calc(
infile=evt_file,
outfile="obs_ecf.fits",
xpos=xcen,
ypos=ycen,
radius=radius_100p,
binsize=binsize,
clobber=True,
fraction=ecf_fractions,
)
for idx, blur in enumerate(blur_vals):
print(f"Blur={blur}")
outroot = out_root_common + "_blur_" + str(blur)
if not Path(outroot + "_projrays.fits").is_file():
print(f"Simulating PSF")
simulate_psf(
infile=evt_file,
outroot=outroot,
spectrum=spectrum,
numiter=numiter,
ra=ra,
dec=dec,
binsize=binsize,
blur=blur,
)
print("Generating the ecf profile")
out_ecf = generate_ecf_profile(
outroot + "_projrays.fits",
blur,
xcen,
ycen,
binsize=binsize,
ecf_fractions=ecf_fractions,
radius=radius_100p,
)
load_table(idx, out_ecf, colkeys=["r_mid", "fraction"])
ecf_profile = get_data(idx)
ecf_profile_values[idx, :] = ecf_profile.y
ecf_radii_values[idx, :] = ecf_profile.x
plt.plot(ecf_profile.x, ecf_profile.y, label=f"blur={blur}")
print("Done")
load_table(idx + 1, obs_ecf_file, colkeys=["r_mid", "fraction"])
obs_ecf = get_data(idx + 1)
plt.plot(obs_ecf.x,
obs_ecf.y,
label=f"Observation",
ls="--",
lw=2,
color="black")
plt.legend()
plt.xlabel("Radius (ACIS pixels)")
plt.ylabel("ECF")
plt.show()
dtw_vals = np.zeros(idx + 1)
pcm_vals = np.zeros(idx + 1)
clm_vals = pcm_vals.copy()
abtc_vals = pcm_vals.copy()
for i in range(idx + 1):
n1 = np.zeros((n_fractions, 2))
n2 = n1.copy()
n1[:, 0] = ecf_radii_values[i, :]
n2[:, 0] = obs_ecf.x
n1[:, 1] = ecf_profile_values[i, :]
n2[:, 1] = obs_ecf.y
dtw_vals[i], _ = similaritymeasures.dtw(n1, n2)
pcm_vals[i] = similaritymeasures.pcm(n1, n2)
clm_vals[i] = similaritymeasures.curve_length_measure(n1, n2)
abtc_vals[i] = similaritymeasures.area_between_two_curves(n1, n2)
print(f"Blur (Dynamic time warping) {blur_vals[np.argmin(dtw_vals)]}")
print(f"Blur (Partial Curve Mapping): {blur_vals[np.argmin(pcm_vals)]}")
print(f"Blur (Curve Length Measure): {blur_vals[np.argmin(clm_vals)]}")
print(f"Blur (Area Curve Measure): {blur_vals[np.argmin(abtc_vals)]}")
def test_c3_c4_cl(self):
cl = similaritymeasures.curve_length_measure(curve3, curve4)
self.assertTrue(cl, 10.986122886681098)
def test_c1_c2_cl(self):
cl = similaritymeasures.curve_length_measure(curve1, curve2)
self.assertTrue(cl, 4.054651081081643)
def test_cl_zeros(self):
z1 = np.zeros((100, 2))
z2 = np.zeros((100, 2))
_ = similaritymeasures.curve_length_measure(z1, z2)
self.assertTrue(True)
def test_random_cl(self):
_ = similaritymeasures.curve_length_measure(curve_a_rand, curve_b_rand)
self.assertTrue(True)
])
# quantify the difference between the two curves using PCM
pcm = similaritymeasures.pcm(exp_data, num_data)
# quantify the difference between the two curves using
# Discrete Frechet distance
df = similaritymeasures.frechet_dist(exp_data, num_data)
# quantify the difference between the two curves using
# area between two curves
area = similaritymeasures.area_between_two_curves(exp_data, num_data)
# quantify the difference between the two curves using
# Curve Length based similarity measure
cl = similaritymeasures.curve_length_measure(exp_data, num_data)
# quantify the difference between the two curves using
# Dynamic Time Warping distance
dtw, d = similaritymeasures.dtw(exp_data, num_data)
# print the results
print(pcm, df, area, cl, dtw)
# plot the data
fig = plt.figure()
ax1 = fig.add_subplot(111, projection='3d')
ax1.plot_wireframe(x, y, subz)
ax1.plot_wireframe(xx, yy, subzz, color='deeppink')
ax1.set_xlabel('x')
Q = Q[::-1]
f_d, p_i, q_i = FrechetDist.frechetdist_index_2(P, Q)
print("frechet distance: ", f_d, p_i, q_i)
f_d, p_i, q_i = FrechetDist.frechetdist_index(P, Q)
print("frechet distance 2: ", f_d, p_i, q_i)
d = simm.frechet_dist(P, Q)
print("frechet distance: ", d)
distance = directed_hausdorff(P, Q)
print("hausdorff distance P-Q: ", distance)
distance = directed_hausdorff(Q, P)
print("hausdorff distance Q-P: ", distance)
px = [p[0] for p in P]
py = [p[1] for p in P]
qx = [p[0] for p in Q]
qy = [p[1] for p in Q]
plt.scatter(px+qx, py+qy)
plt.plot(px, py, label="P", color="red")
plt.plot(qx, qy, label="Q", color="blue")
plt.plot([px[p_i], qx[q_i]], [py[p_i], qy[q_i]], label="frechet dist", linestyle=":", color="purple")
plt.show()
df = simm.area_between_two_curves(P, Q)
print("area bt two curves: {}".format(df))
df = simm.dtw(P, Q)
print("dtw: {}".format(df))
df = simm.curve_length_measure(P, Q)
print("curve length: {}".format(df))
df = simm.pcm(P, Q)
print("pcm: {}".format(df))
