public static IEnumerable <Tuple <double, Rtssc> > InverseGeocodeMultipleWithDistance(this PostGIS client, GeoCoordinate coordinates, int radius, DateTime date)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
if (coordinates == null)
{
throw new ArgumentNullException("coordinates");
}
LambertCoordinate lambert = GpsHelper.ConvertNAD83ToLambertMtq(coordinates.Latitude, coordinates.Longitude);
return(client.ObtenirListeRTSSC(new Point {
X = lambert.X, Y = lambert.Y
}, radius, string.Empty, date.ToString())
.Select(rtssc => Tuple.Create(
rtssc.Distance,
new Rtssc {
Ide = client.ObtenirIDE(rtssc, date.ToShortDateString()).IdentifiantIDE,
Route = rtssc.Route,
Troncon = rtssc.Troncon,
Section = rtssc.Section,
SousRoute = rtssc.CodeSousRoute,
Chainage = Math.Round(rtssc.Chainage, 0),
Longueur = rtssc.LongueurSousRoute
})));
}
private void UpdateCompass()
{
if (!_hiking)
{
return;
}
// Check GPS
if (Input.location.status != LocationServiceStatus.Running)
{
return;
}
// Check time
_timeSinceLastCompassCheck += Time.deltaTime;
if (_timeSinceLastCompassCheck < _checkCompassDelayInSec)
{
return;
}
_timeSinceLastCompassCheck -= _checkCompassDelayInSec;
// Check angle for the needle
var localPosition = new GpsPosition(Input.location.lastData.latitude, Input.location.lastData.longitude);
var angle = GpsHelper.AngleTo(localPosition, _hikeTargets[_hikeTargetIndex].Position);
_needleTransform.LeanRotateZ(Input.compass.trueHeading + angle, _checkCompassDelayInSec * 2f);
// Check angle for north
_northTransform.LeanRotateZ(Input.compass.trueHeading, _checkCompassDelayInSec * 2f);
}
public void DistanceTest()
{
var result = GpsHelper.Distance(38.50225, 118.1186, 38.66333, 118.457);
Console.WriteLine(result);
Assert.AreEqual(34477, (int)result);//近似算到证书
}
public void DistanceTest()
{
var result = GpsHelper.Distance(31.3131, 120.5815, 31.2751, 120.6497);
Assert.IsTrue(result > 0);
Console.WriteLine(result);
}
public void GetLongitudeDifferenceTest()
{
var result = GpsHelper.GetLongitudeDifference(10);
Assert.IsTrue(result > 0);
Console.WriteLine(result);
}
public override bool OnOptionsItemSelected(IMenuItem item)
{
try
{
MobileCenter_Helper.TrackEvent(new FileAccessManager(), GetType().Name, MethodBase.GetCurrentMethod().Name + ", " + item?.TitleFormatted?.ToString());
DynamicUIBuild_Utils.ManageDayNightModeMenuClick(item, this);
switch (item.ItemId)
{
case Android.Resource.Id.Home:
OnBackPressed();
return(true);
case Resource.Id.dashboardActivity_menu_simulator:
m_bIsSimulatorActivated = !m_bIsSimulatorActivated;
UpdateGpsLayout();
if (!m_bIsSimulatorActivated && !m_bHasGPSBeenInit)
{
GpsHelper.StartListening(OnPositionChanged);
m_bHasGPSBeenInit = true;
}
return(true);
}
}
catch (Exception e)
{
MobileCenter_Helper.ReportError(new FileAccessManager(), e, GetType().Name, MethodBase.GetCurrentMethod().Name);
}
return(base.OnOptionsItemSelected(item));
}
private void OnPositionChanged(object sender, PositionEventArgs e)
{
if (e.Position.Accuracy <= Settings.GpsMinAccuracy)
{
var newPosition = new ActivityPosition
{
Latitude = e.Position.Latitude,
Longitude = e.Position.Longitude,
Altitude = e.Position.Altitude,
Speed = e.Position.Speed,
Timestamp = e.Position.Timestamp.DateTime
};
if (CurrentActivity.Positions.Count > 0)
{
var lastPosition = CurrentActivity.Positions.Last();
CurrentActivity.Distance += GpsHelper.CalculateDistanceBetweenPoints(lastPosition.Latitude,
lastPosition.Longitude, newPosition.Latitude, newPosition.Longitude);
CurrentActivity.AverageSpeed = CurrentActivity.Positions.Sum(p => p.Speed) /
CurrentActivity.Positions.Count;
}
CurrentActivity.Positions.Add(newPosition);
ActualPosition = newPosition;
}
}
public void GetLongitudeDifferenceTest()
{
var result = GpsHelper.GetLongitudeDifference(100);
Console.WriteLine(result);
Assert.AreEqual("0.909090909090909", result.ToString());
}
private Vector <double> GetCircleNextPosition(IEnumerable <GeoData> previous, GeoData current, ProviderState state, int pointCount)
{
if (previous == null)
{
throw new ArgumentNullException("previous");
}
if (current == null)
{
throw new ArgumentNullException("current");
}
if (state == null)
{
throw new ArgumentNullException("state");
}
if (pointCount < 0)
{
throw new ArgumentOutOfRangeException("pointCount");
}
double currentSpeed = current.VelocityData.SpeedKmh;
var last = previous.Last();
double distance = CalculateAverageDistanceBySpeed(currentSpeed, this.Frequency);
var currentPosition = GpsHelper.ConvertGeoCoordinateToCartesian(last.PositionData.Latitude, last.PositionData.Longitude);
var newPosition = PrimitivesFitting.GetCartesianPoint(currentPosition, state.CircleData, pointCount, distance);
return(GpsHelper.ConvertCartesianToGeoCoordinate(newPosition[0], newPosition[1], newPosition[2]));
}
public async void Initialize()
{
StopsNearby = (await DataProvider.GetBusStopsInCircleAsync(new GpsLocation(51.590705, -0.14287), 150))
.OrderBy(b => GpsHelper.Distance(GpsHelper.GetMyLocation(), b.Location))
.ToList();
SelectedBusStop = StopsNearby.FirstOrDefault();
}
private static Matrix <double> ConvertPositionBufferToCartesianMatrix(IEnumerable <GeoData> previous, GeoData current, ProviderState state)
{
if (previous == null)
{
throw new ArgumentNullException("previous");
}
if (current == null)
{
throw new ArgumentNullException("current");
}
if (state == null)
{
throw new ArgumentNullException("state");
}
PositionData[] distinctCoordinates = previous.Select(x => x.PositionData).Distinct(PositionLatLongComparer.Instance).ToArray();
var positions = new double[distinctCoordinates.Length][];
for (int i = 0; i < distinctCoordinates.Length; i++)
{
var coor = GpsHelper.ConvertGeoCoordinateToCartesian(distinctCoordinates[i].Latitude, distinctCoordinates[i].Longitude);
positions[i] = coor.ToArray();
}
return(Matrix <double> .Build.DenseOfRowArrays(positions));
}
/// <summary>
/// obtient une liste de RTSSC ainsi que sa distance par rapport à la BGR
/// </summary>
public IList <Tuple <double, Rtssc> > InverseGeocodeMultipleWithDistance(GeoCoordinate coordonnees, int rayonRecherche, int nombreMaximumRtssRechercher, IEnumerable <int> ideRtss)
{
// conversion coordonnées gps vers lambert
LambertCoordinate lambert = GpsHelper.ConvertNAD83ToLambertMtq(coordonnees.Latitude, coordonnees.Longitude);
var request = new ObtenirSousRouteCoordonneesRequete();
request.CoordonneeX = lambert.X;
request.CoordonneeY = lambert.Y;
request.RayonRecherche = rayonRecherche;
request.NombreMaximumRtssRechercher = nombreMaximumRtssRechercher;
ObtenirSousRouteCoordonneesReponse response = this.ObtenirSousRouteCoordonnees(request);
var listeResultat = response.ListeSousRoute.Select(coord => coord.IdentifiantSousRoute).OrderBy(_ => _).ToArray();
if (ideRtss == null || !listeResultat.Intersect(ideRtss).Any())
{
return(InverseGeocodeMultipleRouteWithDistance(lambert, rayonRecherche, listeResultat));
}
else
{
return(InverseGeocodeMultipleRouteWithDistance(lambert, rayonRecherche, listeResultat.Intersect(ideRtss)));
}
}
public IList <T> InverseGeocodeMultipleRoute <T>(GeoCoordinate coordonnees, int rayonRecherche, IEnumerable <int> ideRTSs)
where T : IRtssc, new()
{
// conversion coordonnées gps vers lambert
LambertCoordinate lambert = GpsHelper.ConvertNAD83ToLambertMtq(coordonnees.Latitude, coordonnees.Longitude);
var request = new GeocoderPointsInverseRequete();
request.ListeInformation = ideRTSs.Select(
ideRTS => new InfoGeocoderPointInverse {
CoordonneeX = lambert.X,
CoordonneeY = lambert.Y,
RayonRecherche = rayonRecherche,
IdentifiantTheme = 207,
IdentifiantSousRoute = Convert.ToInt32(ideRTS),
DateActivite = DateTime.Today,
CodeEmplacement = ""
}).ToArray();
GeocoderPointsInverseReponse response = this.GeocoderPointsInverse(request);
return(response.ListeInformation
.OrderBy(item => item.DistanceTrace)
.Select(
item => new T {
Chainage = item.Chainage,
Route = item.NumeroRoute,
Section = item.NumeroSection,
SousRoute = item.NumeroSousRoute,
Troncon = item.NumeroTroncon,
Ide = Convert.ToInt32(item.IdentifiantSousRoute)
})
.ToList());
}
public async Task <ProcessedDownloadedFile> ProcessImageAsync(DownloadedFileInfo downloadedFile)
{
using var imageProcessor = new ImageProcessor(downloadedFile.FileContents);
imageProcessor.Rotate();
var sizeFileIdMap = new Dictionary <int, long>();
foreach (var size in _imageProcessingSettings.Sizes)
{
imageProcessor.Crop(size);
var bytes = imageProcessor.GetImageBytes();
var savedFile = await _imageUploadService.SaveThumbnailAsync(bytes, downloadedFile.ResourceName,
downloadedFile.UserName, downloadedFile.Source, size);
sizeFileIdMap.Add(size, savedFile.Id);
}
DateTime?dateTimeTaken = null;
string exifString = null;
double? longitude = null;
double? latitude = null;
var exifExtractor = new ExifExtractor();
var exif = exifExtractor.GetDataAsync(downloadedFile.FileContents);
if (exif != null)
{
dateTimeTaken = GetDate(exif);
var gps = exif.Gps;
if (gps != null)
{
latitude = gps.Latitude != null && gps.LatitudeRef != null
? GpsHelper.ConvertLatitude(gps.Latitude, gps.LatitudeRef)
: (double?)null;
longitude = gps.Longitude != null && gps.LongitudeRef != null
? GpsHelper.ConvertLongitude(gps.Longitude, gps.LongitudeRef)
: (double?)null;
}
exifString = JsonConvert.SerializeObject(exif);
}
return(new ProcessedDownloadedFile
{
FileName = downloadedFile.ResourceName,
FileSource = downloadedFile.Source,
Thumbs = sizeFileIdMap,
Path = downloadedFile.Path,
FileCreatedOn = downloadedFile.CreatedOn,
PhotoTakenOn = dateTimeTaken,
ExifString = exifString,
Latitude = latitude,
Longitude = longitude
});
}
private bool IsPositionReliable(IEnumerable <GeoData> previous, GeoData current, ProviderState state)
{
if (previous == null)
{
throw new ArgumentNullException("previous");
}
if (current == null)
{
throw new ArgumentNullException("current");
}
if (state == null)
{
throw new ArgumentNullException("state");
}
// if previous.count > 1
if (previous.Skip(1).Any())
{
var position = current.PositionData;
var speed = current.VelocityData.SpeedKmh;
var last = previous.Last();
var secondToLast = previous.Reverse().Skip(1).Take(1).Single();
var oldVector = GpsHelper.ConvertGeoCoordinateToCartesian(secondToLast.PositionData.Latitude, secondToLast.PositionData.Longitude);
var newVector = GpsHelper.ConvertGeoCoordinateToCartesian(last.PositionData.Latitude, last.PositionData.Longitude);
var currentVector = GpsHelper.ConvertGeoCoordinateToCartesian(position.Latitude, position.Longitude);
// only make verification if new position is more recent
if (last.PositionData.Utc < position.Utc)
{
oldVector = newVector.Subtract(oldVector);
oldVector = oldVector.Normalize(2);
currentVector = currentVector.Subtract(newVector);
currentVector = currentVector.Normalize(2);
// calculate angle between vector of last two points
// and vector of last and current points
double radAngle = Math.Acos(oldVector.DotProduct(currentVector));
double degreeAngle = radAngle * 180 / Math.PI;
if (degreeAngle > 25)
{
return(false);
}
// calculate distance between last and current points
double distance = GpsHelper.OrthodromicDistance(position.Latitude, position.Longitude, last.PositionData.Latitude, last.PositionData.Longitude);
long timeDistortionGap = EvaluateTimeDistortion(last.PositionData.Utc, position.Utc, this.Frequency);
double averageDistance = CalculateAverageDistanceBySpeed(speed, this.Frequency);
if (distance > averageDistance * timeDistortionGap + averageDistance)
{
return(false);
}
}
}
return(true);
}
public void TestFormatConvert()
{
var(latitude, longitude, _) = GpsHelper.ConvertString("N50° 1' 57.39\",E8° 32' 26.37\",+000338.14");
var(latitudeSt, longitudeSt, _) = GpsHelper.ConvertString("N50* 1' 57.39\",E8* 32' 26.37\",+000338.14");
Assert.AreEqual(latitude, latitudeSt);
Assert.AreEqual(longitude, longitudeSt);
}
private static bool GetCircleDirection(Vector <double> first, Vector <double> last, double theta, double circleRadius)
{
double circumference = 2 * Math.PI * circleRadius;
double thetaOffset = 2 * Math.PI / circumference;
Vector <double> newPointMinus = GpsHelper.ConvertPolarToCartesian(circleRadius, theta - thetaOffset, last[2]);
Vector <double> newPointPlus = GpsHelper.ConvertPolarToCartesian(circleRadius, theta + thetaOffset, last[2]);
return((newPointMinus - first).Count <= (newPointPlus - first).Count);
}
public object Convert(object value, Type targetType, object parameter, string language)
{
var distanceKm = GpsHelper.Distance(GpsHelper.GetMyLocation(), (GpsLocation)value);
if (string.Equals(parameter, "Meters"))
{
return((int)(distanceKm * 1000));
}
return(distanceKm);
}
protected override async void OnDestroy()
{
try
{
base.OnDestroy();
await GpsHelper.StopListening();
}
catch (Exception e)
{
MobileCenter_Helper.ReportError(new FileAccessManager(), e, GetType().Name, MethodBase.GetCurrentMethod().Name);
}
}
/// <summary>
/// Update distance label related to current acquisition step (and triggered start/stop mode).
/// </summary>
private IDisposable UpdateDistanceBeforeTrigger(ProviderState state, TriggeredAcquisitionParameter param)
{
IDisposable subscription = null;
switch (state)
{
case ProviderState.StartingRecord:
case ProviderState.StoppingRecord:
Label currentLblDistance = state == ProviderState.StartingRecord ? lblDistanceBeforeStartRecord : lblDistanceBeforeStopRecord;
switch (param.TriggerMode)
{
case AcquisitionTriggerMode.Rtssc:
case AcquisitionTriggerMode.RtsscProximity:
case AcquisitionTriggerMode.EndSection:
{
subscription = AgentBroker.Instance.ObserveAny <ILocalisationAgent, LocalisationData>("DataSource")
.Sample(UIRefreshInterval)
.ObserveOn(WindowsFormsSynchronizationContext.Current)
.Subscribe(data =>
{
if (param.GeoCoordinate == null || data == null)
{
currentLblDistance.Text = "Error!";
return;
}
double distance = GpsHelper.OrthodromicDistance(param.GeoCoordinate, data.CorrectedData.PositionData) - (param.ProximityRange.HasValue ? param.ProximityRange.Value : 0);
currentLblDistance.Text = distance >= 1000 ? Math.Round(distance / 1000, 2).ToString("0.00") + " km" : distance.ToString("0") + " m";
});
break;
}
case AcquisitionTriggerMode.Distance:
{
subscription = AgentBroker.Instance.ObserveAny <IDistanceAgent, DistanceData>("DataSource")
.Sample(UIRefreshInterval)
.ObserveOn(WindowsFormsSynchronizationContext.Current)
.Subscribe(
data =>
{
double distance = param.Distance.Value - data.AbsoluteDistance;
currentLblDistance.Text = distance >= 1000 ? Math.Round(distance / 1000, 2).ToString("0.00") + " km" : distance.ToString("0") + " m";
});
break;
}
}
break;
}
return(subscription);
}
public IEnumerable <ModalNearbyDetails> GetNearbyModals(decimal latitude, decimal longitude, decimal?distance, string lineId)
{
var modals = new List <ModalNearbyDetails>();
if (distance == null)
{
distance = Convert.ToDecimal(ConfigurationManager.AppSettings["DefaultDistance"] ?? "200");
}
var gpses = _gpsService.GetNerbyModalsGps(latitude, longitude, distance.Value, lineId).ToList();
if (gpses.Any())
{
var recentGpses = gpses.Where(i => i.Timestamp.Year == DateTime.UtcNow.Year &&
i.Timestamp.Month == DateTime.UtcNow.Month &&
i.Timestamp.Day == DateTime.UtcNow.Day &&
i.Timestamp.Hour == DateTime.UtcNow.Hour &&
i.Timestamp.Minute - DateTime.UtcNow.Minute < 5).ToList();
foreach (var gps in recentGpses)
{
var distanceInMeters =
GpsHelper.DistanceBetweenCoordenates(latitude, longitude, gps.Latitude, gps.Longitude);
var modalAvgSpeed = Convert.ToDouble(ConfigurationManager.AppSettings["BusAvgSpeed"] ?? "4.2");
var minutesToArrive = (distanceInMeters / modalAvgSpeed) / 60.0;
var modal = new ModalNearbyDetails()
{
Modal = gps.ModalId,
Line = gps.LineId,
Distance = distanceInMeters,
//MinutesToArrive = Convert.ToInt32(minutesToArrive),
LastUpdateDate = gps.LastUpdateDate,
TimeStamp = gps.Timestamp,
Gps = new ModalGps()
{
Latitude = gps.Latitude,
Longitude = gps.Longitude,
Direction = gps.Direction.ToString()
}
};
modals.Add(modal);
}
}
return(modals.OrderBy(i => i.Distance));
}
public static Vector <double> GetCartesianPoint(Vector <double> currentCartesianPoint, CircleData circleData, int nbStep, double stepLength)
{
if (circleData == null)
{
throw new ArgumentNullException("circleData");
}
double initialTheta = GpsHelper.ConvertCartesianToPolar(currentCartesianPoint[0], currentCartesianPoint[1])[1];
double theta = initialTheta + nbStep * stepLength;
return(Vector <double> .Build.Dense(new[] {
circleData.CircleRadius *Math.Cos(theta) + circleData.CircleCentroid[0],
circleData.CircleRadius *Math.Sin(theta) + circleData.CircleCentroid[1],
0
}));
}
private void PreviewPhoto(MediaFile mediaFile)
{
using (Stream photo = mediaFile.GetStream())
{
var picture = ExifReader.ReadJpeg(photo);
FilePath = mediaFile.Path;
ExifOrientation orientation = picture.Orientation;
ExifGpsLatitudeRef latRef = picture.GpsLatitudeRef;
ExifGpsLongitudeRef longRef = picture.GpsLongitudeRef;
Latitude = GpsHelper.GetLatitude(latRef, picture.GpsLatitude);
Longitude = GpsHelper.GetLongitude(picture.GpsLongitude);
}
}
/// <summary>
/// obtient une liste RTSSC qui se trouvent à la coordonnée GPS demandée
/// </summary>
public IList <Rtssc> InverseGeocodeMultiple(GeoCoordinate coordonnees, int rayonRecherche, int nombreMaximumRtssRechercher)
{
// conversion coordonnées gps vers lambert
LambertCoordinate lambert = GpsHelper.ConvertNAD83ToLambertMtq(coordonnees.Latitude, coordonnees.Longitude);
var request = new ObtenirSousRouteCoordonneesRequete();
request.CoordonneeX = lambert.X;
request.CoordonneeY = lambert.Y;
request.RayonRecherche = rayonRecherche;
request.NombreMaximumRtssRechercher = nombreMaximumRtssRechercher;
ObtenirSousRouteCoordonneesReponse response = this.ObtenirSousRouteCoordonnees(request);
return(InverseGeocodeMultipleRoute <Rtssc>(coordonnees, rayonRecherche, response.ListeSousRoute.Select(coord => coord.IdentifiantSousRoute)));
}
public static CircleData Ls2DCircle(Matrix <double> data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
var dataTmp = data.Clone();
var dataOut = new CircleData();
// Check number of data points
if (dataTmp.RowCount < 2)
{
return(dataOut);
}
// init A and b
var A = Matrix <double> .Build.Dense(dataTmp.RowCount, 3);
var b = Vector <double> .Build.Dense(dataTmp.RowCount);
for (int i = 0; i < dataTmp.RowCount; i++)
{
A[i, 0] = -2 * dataTmp[i, 0];
A[i, 1] = -2 * dataTmp[i, 1];
A[i, 2] = 1.0f;
b[i] = -(Math.Pow(dataTmp[i, 0], 2) + Math.Pow(dataTmp[i, 1], 2));
}
Vector <double> C = A.QR(QRMethod.Full).Solve(b);
// set circle centroid
dataOut.CircleCentroid[0] = C[0];
dataOut.CircleCentroid[1] = C[1];
// compute circle radius
dataOut.CircleRadius = Math.Sqrt(Math.Pow(C[0], 2) + Math.Pow(C[1], 2) - C[2]);
// Convert last to polar coordinates
Vector <double> lastPolar = GpsHelper.ConvertCartesianToPolar(dataTmp[dataTmp.RowCount - 1, 0], dataTmp[dataTmp.RowCount - 1, 1], dataTmp[dataTmp.RowCount - 1, 2]);
dataOut.Inclination = lastPolar[1];
return(dataOut);
}
protected override async void OnAppearing()
{
base.OnAppearing();
GpsHelper gpsHelper = new GpsHelper();
var currentPostion = await gpsHelper.GetLocation();
MainMap.MoveToRegion(MapSpan.FromCenterAndRadius(new Position(currentPostion.Latitude, currentPostion.Longitude),
Distance.FromKilometers(5)));
List <Pin> pins = await GetPins();
foreach (var pin in pins)
{
pin.Clicked += Pin_Clicked;
MainMap.Pins.Add(pin);
}
}
private async void Hub_OnAircraftUpdated(string clientId, AircraftStatus status)
{
if (viewModel.IsTracking && viewModel.AircraftStatus != null &&
GpsHelper.CalculateDistance(status.Latitude, status.Longitude, viewModel.AircraftStatus.Latitude, viewModel.AircraftStatus.Longitude) < 10000)
{
try
{
var pref = await userPreferencesLoader.LoadAsync();
if (pref.ClientId != clientId)
{
await udpBroadcastLogic.SendTrafficAsync(status);
}
}
catch (Exception ex)
{
logger.LogError(ex, "Cannot send network package!");
}
}
}
public void SetScore(float time, float distance, int score)
{
_scoreCanvas.alpha = 1;
_scoreCanvas.blocksRaycasts = true;
// Time
var timeSpan = TimeSpan.FromSeconds(time);
_timeText.text = "Time: " + timeSpan.ToString(@"hh\:mm\:ss");
// Distance
_distanceText.text = "Distance: " + GpsHelper.DistanceToString(distance);
// Speed
var kph = distance / (time / 3600f);
_speedText.text = "Speed: " + kph + " KM/H";
// Score
_scoreText.text = "Score: " + score;
}
public void TestCultureConvert()
{
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
var(latitude, longitude, altitude) = GpsHelper.ConvertString("N50° 1' 57.39\",E8° 32' 26.37\",+000338.14");
Assert.AreEqual(338.14, altitude);
CultureInfo.DefaultThreadCurrentCulture = new CultureInfo("de-DE");
var(latitudeDe, longitudeDe, altitudeDe) = GpsHelper.ConvertString("N50° 1' 57.39\",E8° 32' 26.37\",+000338.14");
Assert.AreEqual(338.14, altitudeDe);
Assert.AreEqual(latitude, latitudeDe);
Assert.AreEqual(longitude, longitudeDe);
CultureInfo.DefaultThreadCurrentCulture = new CultureInfo("fr-FR");
var(latitudeFr, longitudeFr, altitudeFr) = GpsHelper.ConvertString("N50° 1' 57.39\",E8° 32' 26.37\",+000338.14");
Assert.AreEqual(338.14, altitudeFr);
Assert.AreEqual(latitude, latitudeFr);
Assert.AreEqual(longitude, longitudeFr);
}
private void CreateProgressBar()
{
// Reset list
_hikeTargetIndex = 0;
_hikeTargetObjects = new List <HikeTargetBehaviour>();
_hikeLineObjects = new List <HikeLineBehaviour>();
// Remove all childs
foreach (Transform child in _hikeProgressRoot)
{
Destroy(child.gameObject);
}
// Need at least 2 targets
if (_hikeTargets.Length < 2)
{
return;
}
// Create new targets and lines
for (int i = 0; i < _hikeTargets.Length; i++)
{
var target = Instantiate(_hikeTargetPrefab, _hikeProgressRoot);
_hikeTargetObjects.Add(target.GetComponent <HikeTargetBehaviour>());
if (i < _hikeTargets.Length - 1)
{
var line = Instantiate(_hikeLinePrefab, _hikeProgressRoot);
var lineBehaviour = line.GetComponent <HikeLineBehaviour>();
_hikeLineObjects.Add(lineBehaviour);
var distance = GpsHelper.DistanceTo(_hikeTargets[i].Position, _hikeTargets[i + 1].Position);
lineBehaviour.SetDistance(distance);
_hikingDistance += distance;
}
}
Debug.Log(_hikingDistance);
}
