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))