public async Task <IActionResult> Get(string from, string to)
{
if (from == null || to == null)
{
return(BadRequest("Request parameters are not specified or insufficient"));
}
var fromLocation = await _locationFetcher.GetAirportLocation(from);
if (fromLocation == null || fromLocation.Location == null)
{
return(BadRequest("Error getting departure location"));
}
var toLocation = await _locationFetcher.GetAirportLocation(to);
if (toLocation == null || toLocation.Location == null)
{
return(BadRequest("Error getting destination location"));
}
var distance = DistanceAlgorithm.GetDistanceBetweenPlaces(fromLocation.Location.Lat, fromLocation.Location.Lon, toLocation.Location.Lat, toLocation.Location.Lon);
return(new JsonResult(distance));
}
/// <summary>
/// 根据距离算法和最大特征点数量构造WorleyNoise
/// </summary>
/// <param name="distanceAlgorithm">采用的距离算法</param>
/// <param name="maxPointsInCell">单个晶胞内，生成的最大特征点数量</param>
public WorleyNoise2D(DistanceAlgorithm distanceAlgorithm, int maxPointsInCell)
{
_distanceAlgorithm = distanceAlgorithm;
_maxPointsInCell = Mathf.Max(1, maxPointsInCell);
switch (distanceAlgorithm)
{
case DistanceAlgorithm.Chebyshev:
_distanceCalculator = MathUtility.ChebyshevDistance;
_distanceNormalize = (dis) => {
return(dis * 2 - 1);
};
break;
case DistanceAlgorithm.Euclidean:
_distanceCalculator = MathUtility.EuclideanDistance;
_distanceNormalize = (dis) => {
return(dis * SQRT2 - 1);
};
break;
case DistanceAlgorithm.Manhattan:
_distanceCalculator = MathUtility.ManhattanDistance;
_distanceNormalize = (dis) => {
return(dis - 1);
};
break;
}
}
private double CalculateA(List <Point> Points, DistanceAlgorithm distanceAlgorithm)
{
double sum = 0;
Points.ForEach((point) => {
sum += CalculateDistance(point, distanceAlgorithm);
});
return((double)sum / (double)Points.Count());
}
private double CalculateB(List <Point> Points, DistanceAlgorithm distanceAlgorithm)
{
List <double> distanses = new List <double>();
Points.ForEach((point) => {
distanses.Add(CalculateDistance(point, distanceAlgorithm));
});
return(distanses.Min());
}
public async Task <ICollection <User> > GetUsersFromLondon()
{
//throw new NotImplementedException();
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Add("User-Agent", "telnet");
List <User> usersList = new List <User>();
int numberOfIndividualsFormAPI;
try
{
var stringTask = client.GetStringAsync("https://bpdts-test-app.herokuapp.com/users");
var msg = await stringTask;
dynamic x = Newtonsoft.Json.JsonConvert.DeserializeObject(msg);
numberOfIndividualsFormAPI = x.Count;
for (int index = 0; index <= numberOfIndividualsFormAPI - 1; index++)
{
var user = new User();
user.Id = x[index].id;
user.first_name = x[index].first_name;
user.last_name = x[index].last_name;
user.ip_address = x[index].ip_address;
user.email = x[index].email;
user.ip_address = x[index].ip_address;
user.city = x[index].city;
user.latitude = x[index].latitude;
user.longitude = x[index].longitude;
user.DistanceFromLondon = Math.Round(DistanceAlgorithm.distance(51.506307, -0.132727, user.latitude, user.longitude, 'M'), 0);
usersList.Add(user);
}
;
}
catch (Exception e)
{
var excep = e.Message;
return(null);
}
// filter user unti 50 miles
var londonDiameterAverage = 80; // in miles
List <User> usersListFiltered = usersList.Where(c => c.DistanceFromLondon <= (50 + londonDiameterAverage)).ToList();
return(usersListFiltered);
}
public void Test_Distance_Algorithm_passing_same_LatLng_Result_0_meters()
{
double lat1 = 53.3450903;
double lat2 = 53.3450903;
double lng1 = -6.263803199999984;
double lng2 = -6.263803199999984;
double actual = DistanceAlgorithm.DistanceBetweenPlaces(lng1, lat1, lng2, lat2);
var expected = 0.0;
Assert.AreEqual(expected, actual);
}
public double CalculateDistance(Point point, DistanceAlgorithm distanceAlgorithm)
{
if (distanceAlgorithm == DistanceAlgorithm.Equlidient)
{
return(DistanceEqulidient(point));
}
if (distanceAlgorithm == DistanceAlgorithm.Manhattan)
{
return(DistanceManhattan(point));
}
return(0);
}
public double CalculateDistance(Cluster cluster, DistanceAlgorithm distanceAlgorithm)
{
if (distanceAlgorithm == DistanceAlgorithm.Equlidient)
{
return(DistanceEqulidient(cluster));
}
else if (distanceAlgorithm == DistanceAlgorithm.Manhattan)
{
return(DistanceManhattan(cluster));
}
return(0);
}
/// <summary>Create a new EditDistance object.</summary>
/// <param name="algorithm">The desired edit distance algorithm.</param>
public EditDistance(DistanceAlgorithm algorithm)
{
this.algorithm = algorithm;
switch (algorithm)
{
case DistanceAlgorithm.DamerauOSA: this.distanceComparer = new DamerauOSA(); break;
case DistanceAlgorithm.Levenshtein: this.distanceComparer = new Levenshtein(); break;
default: throw new ArgumentException("Unknown distance algorithm.");
}
}
public void SetCluster(List <Cluster> Clusters, DistanceAlgorithm distanceAlgorithm)
{
Clusters.ForEach((cluster) => {
if (Cluster == null)
{
Cluster = cluster;
}
else if (CalculateDistance(cluster, distanceAlgorithm) < CalculateDistance(Cluster, distanceAlgorithm))
{
Cluster = cluster;
}
});
}
private void Kmeans(int clusters, int points, DistanceAlgorithm algorithm)
{
Task.Run(async() => {
var watch = System.Diagnostics.Stopwatch.StartNew();
InitPoints(points);
InitChartPoints();
await Task.Delay(TimeSpan.FromSeconds(1));
InitClusters(clusters);
SetClusterForEachPoint();
InitClusterPoints();
watch.Stop();
ExecutionTime = watch.ElapsedMilliseconds;
});
}
/// <summary>Create a new EditDistance object.</summary>
/// <param name="baseString">The base string to which other strings will be compared.</param>
/// <param name="algorithm">The desired edit distance algorithm.</param>
public EditDistance(string baseString, DistanceAlgorithm algorithm)
{
this.baseString = baseString;
this.algorithm = algorithm;
if (this.baseString == "")
{
this.baseString = null;
return;
}
if (algorithm == DistanceAlgorithm.Damerau)
{
v0 = new int[baseString.Length];
v2 = new int[baseString.Length]; // stores one level further back (offset by +1 position)
}
}
public void CalculateSilhouette(List <Point> Points, DistanceAlgorithm distanceAlgorithm)
{
double A = CalculateA(Points.Where(p => p.Cluster.ClusterID == Cluster.ClusterID).ToList(), distanceAlgorithm);
double B = CalculateB(Points.Where(p => p.Cluster.ClusterID != Cluster.ClusterID).ToList(), distanceAlgorithm);
if (A > B)
{
Silhouette = ((double)B / (double)A) - 1;
}
else if (A == B)
{
Silhouette = 0;
}
else if (A < B)
{
Silhouette = 1 - ((double)A / (double)B);
}
}
public ActionResult Index(StopViewModel sm)
{
if (ModelState.IsValid)
{
string[] From = sm.stop_latlonFrom.Split('_');
string[] To = sm.stop_latlonTo.Split('_');
double latF = Convert.ToDouble(From[0]);
double lonF = Convert.ToDouble(From[1]);
double latT = Convert.ToDouble(To[0]);
double lonT = Convert.ToDouble(To[1]);
ViewBag.distance = "The distance is " + DistanceAlgorithm.DistanceBetweenPlaces(lonF, latF, lonT, latT).ToString("0.00") + " Kilometres.";
return(View(sm));
}
else
{
return(RedirectToAction("Index"));
}
}
public void TestDistanceCalculationAmsAsw()
{
var distance = DistanceAlgorithm.GetDistanceBetweenPlaces(52.309069, 4.763385, 23.968022, 32.824818);
Assert.IsTrue(Math.Abs(2313 - distance) <= _maxTolerance); // https://www.nhc.noaa.gov/
}
public void TestDistanceCalculationAmsJfk()
{
var distance = DistanceAlgorithm.GetDistanceBetweenPlaces(52.309069, 4.763385, 40.642335, -73.78817);
Assert.IsTrue(Math.Abs(4733 - distance) <= _maxTolerance); // https://www.nhc.noaa.gov/
}
public async Task <ICollection <User> > GetUsers()
{
//throw new NotImplementedException();
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Add("User-Agent", "telnet");
List <User> usersList = new List <User>();
int numberOfIndividualsFormAPI;
try
{
var stringTask = client.GetStringAsync("https://bpdts-test-app.herokuapp.com/users");
var msg = await stringTask;
dynamic x = Newtonsoft.Json.JsonConvert.DeserializeObject(msg);
numberOfIndividualsFormAPI = x.Count;
for (int index = 0; index <= numberOfIndividualsFormAPI - 1; index++)
{
var user = new User();
user.Id = x[index].id;
user.first_name = x[index].first_name;
user.last_name = x[index].last_name;
user.ip_address = x[index].ip_address;
user.email = x[index].email;
user.ip_address = x[index].ip_address;
user.city = x[index].city;
//if (user.city == null)
//{
// UserDto userDto = await GetCityFromIpAddress(user.ip_address); // geo location by IP; by using another API
// if (userDto != null)
// {
// user.city = userDto.city;
// user.Country = userDto.Country;
// user.ZipCode = userDto.ZipCode;
// user.Area = userDto.Area;
// }
//}
user.latitude = x[index].latitude;
user.longitude = x[index].longitude;
// Once we knew the user precise location (by IP) we can calculate distance to London
//if (user.Country == "GB")
//{
// // Calculate/update distance here
//}
// first two params are LONDON lat and long
user.DistanceFromLondon = Math.Round(DistanceAlgorithm.distance(51.506307, -0.132727, user.latitude, user.longitude, 'M'), 0);
usersList.Add(user);
}
;
}
catch
{
return(null);
}
return(usersList);
}
public void OnGUI()
{
distanceAlgorithm = (DistanceAlgorithm)EditorGUILayout.EnumPopup("distanceAlgorithm", distanceAlgorithm);
maxPointsInCell = EditorGUILayout.IntSlider("maxPointsInCell", maxPointsInCell, 1, 5);
loop = EditorGUILayout.Toggle("loop", loop);
}
