public void DistanceBetweenTwoPointsCalculated(double[] from, double[] to, double expectedDistance)
        {
            var    calc = new DistanceCalculator();
            double dist = calc.DistanceBetweenTwoPoints(new LatitudeLongitude(from[0], from[1]), new LatitudeLongitude(to[0], to[1]));

            Assert.AreEqual(expectedDistance, dist);
        }
        public static DataSet GenerateDistances(DataSet ds, LatitudeLongitude centreOfPostcode, DistanceCalculator distanceCalculator)
        {
            if (ds == null)
            {
                throw new ArgumentNullException("ds");
            }
            if (distanceCalculator == null)
            {
                throw new ArgumentNullException("distanceCalculator");
            }

            using (DataColumn dcK = new DataColumn("Kilometres", Type.GetType("System.Double")))
            {
                using (DataColumn dcM = new DataColumn("Miles", Type.GetType("System.Double")))
                {
                    ds.Tables[0].Columns.Add(dcK);
                    ds.Tables[0].Columns.Add(dcM);
                    foreach (DataRow dr in ds.Tables[0].Rows)
                    {
                        var latLongInDataRow = new LatitudeLongitude(Convert.ToDouble(dr["Latitude"].ToString(), CultureInfo.InvariantCulture), Convert.ToDouble(dr["Longitude"].ToString(), CultureInfo.InvariantCulture));
                        var kilometres       = distanceCalculator.DistanceBetweenTwoPoints(centreOfPostcode, latLongInDataRow) / 1000;
                        dr["Kilometres"] = kilometres;
                        dr["Miles"]      = Math.Round((kilometres * 0.6214), 2);
                    }
                    ds.AcceptChanges();
                    return(ds);
                }
            }
        }
Beispiel #3
0
        public List <ZipCode> GetZipCodesBetweenTwoRadius(string zipCode, int startRadiusInMiles, int endInMiles)
        {
            ZipCode originZipCode = null;

            try
            {
                originZipCode = GetZipCode(zipCode).FirstOrDefault();
            }
            catch (ObjectNotFoundInPersistenceException <ZipCode> )
            {
                return(null);
            }

            if (originZipCode == null)
            {
                return(null);
            }

            List <ZipCode> zipCodes = GetAllZipCodes(); // If optimization is needed, try grabbing all within square.

            IDistanceCalculator distanceCalculator = new DistanceCalculator();

            return(zipCodes.Where(z =>
            {
                var distance =
                    distanceCalculator.
                    DistanceBetweenTwoPoints(originZipCode.Latitude,
                                             originZipCode.Longitude,
                                             z.Latitude, z.Longitude);
                return distance >= startRadiusInMiles && distance < endInMiles;
            }).ToList());
        }
Beispiel #4
0
        private static double CalculateDistanceBetweenTwoZips(ZipCode originalZipCode, ZipCode destinationZipCode)
        {
            IDistanceCalculator distanceCalculator = new DistanceCalculator();

            return
                (Math.Round(
                     distanceCalculator.DistanceBetweenTwoPoints(originalZipCode.Latitude, originalZipCode.Longitude,
                                                                 destinationZipCode.Latitude,
                                                                 destinationZipCode.Longitude), 2));
        }
        public async Task <DataSet> GetNearestLibrariesRadialFromCms(Double dist, string nearPostcode, Cache cache)
        {
            DataSet dsCms = await GetSiteData(cache);

            DataSet results;
            var     postcodeLookup   = new LocateApiPostcodeLookup(new Uri(ConfigurationManager.AppSettings["LocateApiAuthorityUrl"]), ConfigurationManager.AppSettings["LocateApiToken"], new ConfigurationProxyProvider());
            var     centreOfPostcode = await postcodeLookup.CoordinatesAtCentreOfPostcodeAsync(nearPostcode);

            if (centreOfPostcode == null)
            {
                return(null);
            }

            var distanceCalculator = new DistanceCalculator();

            results = dsCms.Clone();
            Double radius = dist;

            // need to loop through each row pull out the easting and northing for the site and run it through a method which checks if the
            // site is within the chosen radius
            foreach (DataRow dr in dsCms.Tables[0].Rows)
            {
                // missing live data will likely be null or empty string from the cms placeholder?
                if (!String.IsNullOrWhiteSpace(dr["Latitude"].ToString()) || !String.IsNullOrWhiteSpace(dr["Longitude"].ToString()))
                {
                    var locationToCheck = new LatitudeLongitude(Convert.ToDouble(dr["Latitude"], CultureInfo.InvariantCulture), Convert.ToDouble(dr["Longitude"], CultureInfo.InvariantCulture));

                    var howFarAway = distanceCalculator.DistanceBetweenTwoPoints(centreOfPostcode, locationToCheck);

                    if (howFarAway <= radius)
                    {
                        results.Tables[0].ImportRow(dr);
                    }
                }
            }

            return(GenerateDistances(results, centreOfPostcode, distanceCalculator));
        }