public TrackConnection(Vector2 p1, Vector2 p2, Track track)
{
this.track = track;
Point1 = new TrackPoint(p1, track);
Point2 = new TrackPoint(p2, track);
id = track.NewId;
}
public static string GetAreaFromGpsData(TrackPoint p, string preArea = null)
{
Telogis.GeoBase.LatLon loc = new Telogis.GeoBase.LatLon(p.Latitude, p.Longitude);
string tableName = "all";
//if (type == AreaType.区域)
// tableName = "states";
//else if (type == AreaType.重要地点)
// tableName = "islands";
var ret = Telogis.GeoBase.DataQuery.QueryPolygonsAtPoint(loc, tableName);
if (ret.Length == 0)
return null;
else if (ret.Length == 1 || string.IsNullOrEmpty(preArea))
return ret[0].Name;
else
{
foreach (var i in ret)
{
if (i.Name == preArea)
{
return i.Name;
}
}
return ret[0].Name;
}
}
public void Route()
{
// track length
Assert.AreEqual(90.0f, track.Length);
// Route list
Assert.AreEqual(2, track.Pits.ToList().Count);
Assert.AreEqual(1, track.Grid.ToList().Count);
Assert.AreEqual(3, track.Route.Where(x => x.Type == TrackPointType.SECTOR1).ToList().Count);
Assert.AreEqual(3, track.Route.Where(x => x.Type == TrackPointType.SECTOR2).ToList().Count);
Assert.AreEqual(4, track.Route.Where(x => x.Type == TrackPointType.SECTOR3).ToList().Count);
// Route order point (asceding order of meters)
var prevPoint = new TrackPoint(0, TrackPointType.GRID, 0,0,0, new float[1] { 0}, new float[0]);
var prevPointInit = false;
foreach(var point in track.Route)
{
if (prevPointInit)
{
Assert.Greater(point.Meter, prevPoint.Meter);
}
prevPointInit = true;
prevPoint = point;
}
// Track bounds
Assert.AreEqual(-1.0f, track.TrackCoordinateMinX);
Assert.AreEqual(2.0f, track.TrackCoordinateMaxX);
Assert.AreEqual(-1.0f, track.TrackCoordinateMinY);
Assert.AreEqual(1.0f, track.TrackCoordinateMaxY);
}
public void SendTrackPoint (AdformTrackPoint adFormTrackPoint)
{
if (_initOptions == null) {
SystemLogger.Log (SystemLogger.Module.PLATFORM, "Adform [SendTrackPoint] - Error: no init options loaded, please check if you have the 'adform-config.xml' file in your project");
return;
}
try {
nint tpID = _initOptions.TrackingID;
TrackPoint trackPoint = new TrackPoint(tpID);
trackPoint.SetSectionName(adFormTrackPoint.SectionName);
if(adFormTrackPoint.CustomParameters != null) {
foreach (AdformCustomParameter cp in adFormTrackPoint.CustomParameters) {
trackPoint.AddParameter(cp.Name, cp.Value);
}
}
SystemLogger.Log (SystemLogger.Module.PLATFORM, "Adform [SendTrackPoint] to id: " + tpID);
AdformTrackingSDK.SharedInstance ().SendTrackPoint(trackPoint);
} catch (Exception ex) {
SystemLogger.Log (SystemLogger.Module.PLATFORM, "EXCEPTION Adform SendTrackPoint... ", ex);
}
}
public TrackConnection(TrackPoint p1, TrackPoint p2, Track track)
{
this.track = track;
Point1 = p1;
Point2 = p2;
id = track.NewId;
}
public void SetPoints(int trackId, TrackPoint[] points)
{
var sb = new StringBuilder();
for (int i = 0; i < points.Length; i++)
{
if (i % 1000 == 0)
{
if(sb.Length>0) sb.Remove(sb.Length - 1, 1);
sb.AppendLine(";").AppendLine("insert into MR.tTrackPoint (TrackId, Idx, Lat, Lon, Elevation, PointTime) values ");
}
var p = points[i];
sb.AppendLine().Append("(")
.Append(trackId).Append(",")
.Append(i).Append(",")
.Append(p.Lat.ToString(CultureInfo.InvariantCulture)).Append(",")
.Append(p.Lon.ToString(CultureInfo.InvariantCulture)).Append(",")
.Append(p.Elevation.ToString(CultureInfo.InvariantCulture)).Append(",")
.Append("'").Append(p.PointTime.ToString("o",CultureInfo.InvariantCulture)).Append("'")
.Append("),");
}
var sql = sb.ToString().TrimEnd(',');
var db = new Database(_config.ConnectionString, "System.Data.SqlClient");
try
{
db.Execute(sql);
}
catch (SqlException ex)
{
throw new Exception(sql, ex);
}
}
private static TrackingReplay.TrackPoints ConvertDataTableToTrackingPoints(DataTable trackingTable)
{
TrackingReplay.TrackPoints oTrackingPoints = new TrackPoints();
TrackingReplay.TrackPoint oTrackingPoint;
foreach (DataRow dr in trackingTable.Rows)
{
oTrackingPoint = new TrackPoint();
oTrackingPoint.ID = Int32.Parse(dr["geoid"].ToString());
oTrackingPoint.X = double.Parse(dr["x"].ToString());
oTrackingPoint.Y = double.Parse(dr["y"].ToString());
oTrackingPoint.TimeStamp = DateTime.Parse(dr["currenttime"].ToString());
oTrackingPoints.Add(oTrackingPoint);
}
return oTrackingPoints;
}
private wptType GetWayPoint(TrackPoint point, DateTimeOffset time)
{
return new wptType
{
lat = (decimal)point.Position.Latitude,
lon = (decimal)point.Position.Longitude,
ele = (decimal)point.Position.Altitude,
eleSpecified = true,
time = time.UtcDateTime,
timeSpecified = true,
src = "Lumia SensorCore",
extensions = new extensionsType
{
Any = new[]
{
new XElement(_sce + "Id", point.Id),
new XElement(_sce + "Radius", point.Radius),
new XElement(_sce + "LengthOfStay", point.LengthOfStay.ToString("g"))
}
}
};
}
private static TrackingReplay.TrackPoints ConvertDataTableToTrackingPoints(DataTable trackingTable, DateTime startTime, DateTime endTime)
{
TrackingReplay.TrackPoints oTrackingPoints = new TrackPoints();
TrackingReplay.TrackPoint oTrackingPoint;
DateTime tCurTime;
foreach (DataRow dr in trackingTable.Rows)
{
tCurTime = DateTime.Parse(dr["currenttime"].ToString());
if (!(tCurTime >= startTime && tCurTime <= endTime))
continue;
oTrackingPoint = new TrackPoint();
oTrackingPoint.ID = Int32.Parse(dr["geoid"].ToString());
oTrackingPoint.X = double.Parse(dr["x"].ToString());
oTrackingPoint.Y = double.Parse(dr["y"].ToString());
oTrackingPoint.TimeStamp = tCurTime;
oTrackingPoints.Add(oTrackingPoint);
}
return oTrackingPoints;
}
public void ShowPointToEdit(TrackPoint point)
{
EditPoint = point;
}
protected virtual int WriteTrackPoint(int offset, TrackPoint trackpoint)
{
throw new GlobalsatProtocol.FeatureNotSupportedException();
}
/// <summary>
/// Calculates altitude based statistics
/// </summary>
/// <param name="track">track to calculate statistics for</param>
/// <param name="trackPoint">current track point</param>
/// <param name="previousPoint">previous track point</param>
private static void CalcAltitudeStatistics(Track track, TrackPoint trackPoint, TrackPoint previousPoint)
{
double altitude = trackPoint.Altitude.Value;
track.MinHeight = Math.Min(altitude, track.MinHeight);
track.MaxHeight = Math.Max(altitude, track.MaxHeight);
double?previousHeight = previousPoint?.Altitude;
double timeInSeconds = 1.0;
if (previousPoint != null &&
previousPoint.Time.HasValue &&
trackPoint.Time.HasValue)
{
timeInSeconds = (trackPoint.Time.Value - previousPoint.Time.Value).TotalSeconds;
}
if (previousHeight.HasValue)
{
double altitudeDelta = altitude - previousHeight.Value;
double climbRate = Math.Abs(timeInSeconds) < 1e-6 ? 0.0 : altitudeDelta / timeInSeconds;
if (altitudeDelta > 0.0)
{
track.HeightGain += altitudeDelta;
track.MaxClimbRate = Math.Max(track.MaxClimbRate, climbRate);
}
else if (altitudeDelta < 0.0)
{
track.HeightLoss += -altitudeDelta;
track.MaxSinkRate = Math.Min(track.MaxSinkRate, climbRate);
}
}
}
protected void OnButtonFindGapClicked(object sender, EventArgs e)
{
trackOnGapOverlay.Clear();
tracksDistance.RemoveAll(x => x.Id == "MissingTrack");
string message = "Найдены разрывы в треке:";
double replacedDistance = 0;
TrackPoint lastPoint = null;
foreach (var point in track.TrackPoints)
{
if (lastPoint == null)
{
lastPoint = point;
continue;
}
var distance = GMapProviders.EmptyProvider.Projection.GetDistance(
new PointLatLng(lastPoint.Latitude, lastPoint.Longitude),
new PointLatLng(point.Latitude, point.Longitude));
if (distance > 0.5)
{
logger.Info("Найден разрыв в треке расстоянием в {0}", distance);
message += string.Format("\n* разрыв c {1:t} по {2:t} — {0:N1} км.",
distance,
lastPoint.TimeStamp,
point.TimeStamp
);
replacedDistance += distance;
var addressesByCompletion = routeList.Addresses
.Where(x => x.Status == RouteListItemStatus.Completed)
.OrderBy(x => x.StatusLastUpdate)
.ToList();
RouteListItem addressBeforeGap = addressesByCompletion.LastOrDefault(x => x.StatusLastUpdate < lastPoint.TimeStamp.AddMinutes(2));
RouteListItem addressAfterGap = addressesByCompletion.FirstOrDefault(x => x.StatusLastUpdate > point.TimeStamp.AddMinutes(-2));
var beforeIndex = addressBeforeGap == null ? -1 : addressesByCompletion.IndexOf(addressBeforeGap);
var afterIndex = addressAfterGap == null ? addressesByCompletion.Count : addressesByCompletion.IndexOf(addressAfterGap);
var routePoints = new List <PointOnEarth> {
new PointOnEarth(lastPoint.Latitude, lastPoint.Longitude)
};
if (afterIndex - beforeIndex > 1)
{
var throughAddress = addressesByCompletion.GetRange(beforeIndex + 1, afterIndex - beforeIndex - 1);
logger.Info("В разрыве найдены выполенные адреса порядковый(е) номер(а) {0}", String.Join(", ", throughAddress.Select(x => x.IndexInRoute)));
routePoints.AddRange(
throughAddress.Where(x => x.Order?.DeliveryPoint?.Latitude != null && x.Order?.DeliveryPoint?.Longitude != null)
.Select(x => new PointOnEarth(x.Order.DeliveryPoint.Latitude.Value, x.Order.DeliveryPoint.Longitude.Value)));
message += $" c выполненными адресами({beforeIndex + 2}-{afterIndex}) п/п в МЛ " + String.Join(", ", throughAddress.Select(x => x.IndexInRoute));
}
routePoints.Add(new PointOnEarth(point.Latitude, point.Longitude));
var missedTrack = SputnikMain.GetRoute(routePoints, false, true);
if (missedTrack == null)
{
MessageDialogHelper.RunErrorDialog("Не удалось получить ответ от сервиса \"Спутник\"");
return;
}
if (missedTrack.Status != 0)
{
MessageDialogHelper.RunErrorDialog("Cервис \"Спутник\" сообщил об ошибке {0}: {1}", missedTrack.Status, missedTrack.StatusMessageRus);
return;
}
var decodedPoints = Polyline.DecodePolyline(missedTrack.RouteGeometry);
var points = decodedPoints.Select(p => new PointLatLng(p.Latitude * 0.1, p.Longitude * 0.1)).ToList();
var route = new GMapRoute(points, "MissedRoute")
{
Stroke = new Pen(Color.DarkMagenta)
{
Width = 4,
DashStyle = System.Drawing.Drawing2D.DashStyle.Dot
}
};
trackOnGapOverlay.Routes.Add(route);
}
lastPoint = point;
}
if (trackOnGapOverlay.Routes.Count > 0)
{
var distanceLayout = MakeDistanceLayout(trackOnGapOverlay.Routes.ToArray());
distanceLayout.Id = "MissingTrack";
tracksDistance.Add(distanceLayout);
var oldDistance = track.DistanceEdited ? trackRoute.Distance : track.Distance;
var missedRouteDistance = trackOnGapOverlay.Routes.Sum(x => x.Distance);
var newDistance = oldDistance - replacedDistance + missedRouteDistance;
var diffDistance = newDistance - oldDistance;
message += $"\n Старая длинна трека:{oldDistance:N1} км." +
$"\n Новая длинна трека: {newDistance:N1} км.(+{diffDistance:N1})" +
"\n Сохранить изменения длинны трека?";
if (MessageDialogHelper.RunQuestionDialog(message))
{
track.Distance = newDistance;
track.DistanceEdited = true;
UoW.Save(track);
UoW.Commit();
UpdateDistanceLabel();
}
}
else
{
MessageDialogHelper.RunInfoDialog("Разрывов в треке не найдено.");
}
}
public void SelectPointToo(TrackPoint p)
{
if(!selectedPoints.Contains(p)){
selectedPoints.Add(p);
}
}
private TrackPoint ECEF2LonLat(DataLogFixFull local)
{
TrackPoint result = null;
double x = (double)local.X;
double y = (double)local.Y;
double z = (double)local.Z;
double lat = 0;
double lon = 0;
double alt = 0;
// ECEF_to_LLA(x, y, z, out lat, out lon, out alt);
long time = 0;
//time = gpstime_to_timet(local.WN, (int)local.TOW) - 315964800;
DateTime dt = new DateTime(1980, 1, 6, 0, 0, 0);
dt = dt.AddSeconds(time);
result = new TrackPoint((decimal)lon, (decimal)lat, dt);
result.Speed = (local.V * 1000);
result.Speed /= 3600;
result.Elevation = (decimal)alt;
return result;
}
public float CheckDistance(Vector3 carPosition, TrackPoint point)
{
return(Vector3.Distance(carPosition, point.position));
}
static void GetTrackPoints(ref byte[] arrayToParse, ref Track track)
{
int cursor = TRACKPOINT_LATITUDE;
TrackPoint trackpoint = new TrackPoint();
// *** This end test fails if input contains routes.
while(arrayToParse.Length > TRACKPOINT_LENGTH)
{
trackpoint.Latitude = BitConverter.ToDouble(arrayToParse, cursor);
cursor = TRACKPOINT_LONGITUDE;
trackpoint.Longitude = BitConverter.ToDouble(arrayToParse, cursor);
// *** Wasn't really getting elevation - don't know where it is.
//cursor = TRACKPOINT_ELEVATION;
//trackpoint.Elevation = BitConverter.ToInt16(arrayToParse, cursor);
arrayToParse = Extensions.Right(arrayToParse, TRACKPOINT_LENGTH, arrayToParse.Length - TRACKPOINT_LENGTH);
track.Trackpoints.Add(trackpoint);
}
return;
}
public static void SetValue(MapElement target, TrackPoint value)
{
SetValueProperty(target, value);
}
private static void SetValueProperty(DependencyObject element, TrackPoint value)
{
element.SetValue(ValueProperty, value);
}
public void ConvertGpx(string vehicleName, string gpxData)
{
XDocument gpxDoc = GetGpxDoc(gpxData);
XNamespace gpx = GetGpxNameSpace();
var tracks = from track in gpxDoc.Descendants(gpx + "trk")
select new
{
Name = track.Element(gpx + "name") != null ?
track.Element(gpx + "name").Value : null,
Segs = (
from trackpoint in track.Descendants(gpx + "trkpt")
select new
{
Latitude = trackpoint.Attribute("lat").Value,
Longitude = trackpoint.Attribute("lon").Value,
Elevation = trackpoint.Element(gpx + "ele") != null ?
trackpoint.Element(gpx + "ele").Value : null,
Time = trackpoint.Element(gpx + "time") != null ?
trackpoint.Element(gpx + "time").Value : null
}
)
};
var waypoints = from waypoint in gpxDoc.Descendants(gpx + "wpt")
select new
{
Latitude = waypoint.Attribute("lat").Value,
Longitude = waypoint.Attribute("lon").Value,
Elevation = waypoint.Element(gpx + "ele") != null ?
waypoint.Element(gpx + "ele").Value : null,
Name = waypoint.Element(gpx + "name") != null ?
waypoint.Element(gpx + "name").Value : null,
Dt = waypoint.Element(gpx + "cmt") != null ?
waypoint.Element(gpx + "cmt").Value : null
};
using (var rep = ServiceProvider.GetService<IRepositoryFactory>().GenerateRepository<TrackPoint>())
{
try
{
rep.BeginTransaction();
Track track = new Track
{
Name = "FromGpx",
VehicleName = vehicleName,
IsActive = true,
Created = System.DateTime.Now,
CreatedBy = "Feng.Map"
};
rep.Save(track);
foreach (var trk in tracks)
{
// Populate track data objects.
foreach (var trkSeg in trk.Segs)
{
TrackPoint tp = new TrackPoint
{
Track = track,
Latitude = Convert.ToDouble(trkSeg.Latitude),
Longitude = Convert.ToDouble(trkSeg.Longitude),
GpsTime = string.IsNullOrEmpty(trkSeg.Time) ? System.DateTime.Now : Convert.ToDateTime(trkSeg.Time),
MessageTime = System.DateTime.Now,
VehicleName = vehicleName,
};
rep.Save(tp);
}
}
foreach (var wpt in waypoints)
{
WayPoint wp = new WayPoint
{
Track = track,
Latitude = Convert.ToDouble(wpt.Latitude),
Longitude = Convert.ToDouble(wpt.Longitude),
GpsTime = System.DateTime.Now,
MessageTime = System.DateTime.Now,
IsActive = true,
};
rep.Save(wp);
}
rep.Save(track);
rep.CommitTransaction();
}
catch (Exception)
{
rep.RollbackTransaction();
}
}
}
public static string GetRoadFromGpsData(TrackPoint gpsData, string preRoad = null)
{
Telogis.GeoBase.LatLon loc = new Telogis.GeoBase.LatLon(gpsData.Latitude, gpsData.Longitude);
var arg = new Telogis.GeoBase.ReverseGeoCodeArgs(loc);
arg.Heading = gpsData.Heading;
if (!string.IsNullOrEmpty(preRoad))
{
arg.LastNames = new string[] { preRoad };
}
arg.Mode = Telogis.GeoBase.ReverseGeoCodeMode.AllLinks;
arg.Speed = gpsData.Speed;
var streetFull = Telogis.GeoBase.GeoCoder.ReverseGeoCodeFull(arg);
if (streetFull != null)
{
double distance = streetFull.Intersection.DistanceTo(loc, Telogis.GeoBase.DistanceUnit.METERS);
if (distance > RoadWidth)
return null;
if (preRoad != null)
{
if (streetFull.Address != null)
{
foreach (var i in streetFull.Address.Names)
{
if (i == preRoad)
{
return i;
}
}
}
if (streetFull.CrossStreet != null)
{
foreach (var i in streetFull.CrossStreet.Name)
{
if (i == preRoad)
{
return i;
}
}
}
}
if (string.IsNullOrEmpty(streetFull.Address.PrimaryName))
return preRoad;
return streetFull.Address.PrimaryName;
}
return null;
}
internal void ShowPointToEdit(TrackPoint point)
{
ShowSingleMarker(point, GMarkerGoogleType.blue, LAYER_EDIT_POINTS);
}
/// <summary>
/// Creates map icon for track point
/// </summary>
/// <param name="point">Track point to create map icon for</param>
/// <param name="largeIcon">If <c>true</c> will use large icon, if <c>false</c> will use small icon</param>
private void CreateMapIcon( TrackPoint point, bool largeIcon )
{
var icon = new MapIcon
{
NormalizedAnchorPoint = new Windows.Foundation.Point( 0.5, 0.5 ),
Location = new Geopoint( point.Position )
};
if( largeIcon )
{
icon.Image = RandomAccessStreamReference.CreateFromUri( new Uri( "ms-appx:///Assets/dot.png" ) );
}
else
{
icon.Image = RandomAccessStreamReference.CreateFromUri( new Uri( "ms-appx:///Assets/dotSmall.png" ) );
}
MapExtensions.SetValue( icon, point );
TracksMap.MapElements.Add( icon );
}
internal void SetEditCoursePointMarker(TrackPoint point)
{
ShowSingleMarker(point, GMarkerGoogleType.arrow, LAYER_EDIT_POINTS);
}
public void Register(TrackPoint p)
{
points.Add(p);
}
public void ShowPointToEdit(TrackPoint point)
{
mapControl1.ShowPointToEdit(point);
}
public void ShowEditCoursePointMarker(TrackPoint position)
{
mapControl1.SetEditCoursePointMarker(position);
}
public void ShowEditTrackPointMarker(TrackPoint position)
{
mapControl1.ShowPointToEdit(position);
}
public void ExtractData()
{
if (_rideDataFolder != null && _baseOutputFolder != null)
{
for (int i = 0; i < _trips.Count; i++)
{
// USE THE FOR LOOP VARIABLE TO RETURN PROGRESS TO THE GUI
// VIA AN EVENT HANDLER
// Create new XML file object;
XmlFile extract = new XmlFile();
extract.RideMetadata = new Metadata();
// Import the ride data of the current trip.
string filePath = FileIO.MergeTwoPathParts(_rideDataFolder, _trips[i].FileName);
SerializationStruct rideData = FileIO.ImportRideDataFile(filePath);
// Populate the XML metadata.
extract.RideMetadata.RideID = FileIO.FileNameOnly(filePath);
extract.RideMetadata.Title = _trips[i].Descr;
extract.RideMetadata.Distance = _trips[i].Distance;
extract.RideMetadata.StartTimeLocal = rideData.startTime;
extract.RideMetadata.StartTimeUtc = rideData.startTime.ToUniversalTime();
extract.RideMetadata.StartTimeUtcString = TimeToXmlString(extract.RideMetadata.StartTimeUtc);
extract.RideMetadata.EndTimeLocal = rideData.endTime;
extract.RideMetadata.EndTimeUtc = rideData.endTime.ToUniversalTime();
extract.RideMetadata.EndTimeUtcString = TimeToXmlString(extract.RideMetadata.EndTimeUtc);
extract.RideMetadata.DurationSeconds = TicksToSeconds(_trips[i].DurationTicks);
extract.RideMetadata.PauseSeconds = TicksToSeconds(rideData.pauseDuration);
extract.RideMetadata.RideDateTimeLocal = _trips[i].DateOfRoute;
extract.RideMetadata.RideDateTimeUtc = _trips[i].DateOfRoute.ToUniversalTime();
extract.RideMetadata.RideDateTimeUtcString = TimeToXmlString(extract.RideMetadata.RideDateTimeUtc);
extract.RideMetadata.TotalCaloriesBurned = _trips[i].CaloriesBurned;
extract.RideMetadata.MaxSpeed = rideData.dMaxSpeed;
extract.RideMetadata.Weather = _weather[_trips[i].Weather];
extract.RideMetadata.CourseJoy = _trips[i].CourseJoy;
extract.RideMetadata.ExtraNotes = _trips[i].ExtraNotes;
// Prepare the pause data, if needed.
int pauseSeconds = 0;
List <int> pauseKeys = new List <int>();
List <int> pauseDuration = new List <int>();
// if the ride was paused at least once...
if (rideData.pausesList.Count > 0)
{
// ...then for each pause...
foreach (item ridePause in rideData.pausesList)
{
// ...if the length of the pause was greater than zero...
if (ridePause.value.@long > 0)
{
// ...then convert the pause ticks to seconds
pauseSeconds += TicksToSeconds(ridePause.value.@long);
// add the pause key and seconds to the Lists
pauseKeys.Add(ridePause.key.@int);
pauseDuration.Add(pauseSeconds);
// add a new track to the XmlFile object
extract.RideTracks.Add(new TrackSegment());
}
}
}
// ...otherwise there were no pauses...
else
{
// ...so just add a single track to the XmlFile object
extract.RideTracks.Add(new TrackSegment());
}
// Populate the ride data.
for (int c = 0; c < rideData.coordsList.Count; c++)
{
PathCoord coord = rideData.coordsList[c];
DateTime coordTime = coord.timeGathered;
int secondsToAdd = 0;
int trackId = 0;
for (int j = pauseKeys.Count - 1; j >= 0; j--)
{
if (c > pauseKeys[j])
{
trackId = j;
secondsToAdd = pauseDuration[j];
break;
}
}
coordTime = coordTime.AddSeconds(secondsToAdd);
TrackPoint coordPoint = new TrackPoint();
coordPoint.PointTimeLocal = coordTime;
coordPoint.PointTimeUtc = coordTime.ToUniversalTime();
coordPoint.PointTimeUtcString = TimeToXmlString(coordPoint.PointTimeUtc);
coordPoint.Latitude = coord.coord.Location.Latitude;
coordPoint.Longitude = coord.coord.Location.Longitude;
coordPoint.Altitude = coord.coord.Location.Altitude;
coordPoint.HorizontalAccuracy = coord.coord.Location.HorizontalAccuracy;
coordPoint.VerticalAccuracy = coord.coord.Location.VerticalAccuracy;
coordPoint.Speed = coord.coord.Location.Speed;
coordPoint.Course = coord.coord.Location.Course;
coordPoint.Distance = coord.dWalkDistance;
coordPoint.CaloriesBurned = coord.dCalories;
extract.RideTracks[trackId].SegmentPoints.Add(coordPoint);
}
}
}
}
public List <Activity> LoadFiles(List <string> fileNames)
{
//string[] fileNames = Directory.GetFiles(".\\activity\\");
double totalDistance = 0;
double totalElevationGain = 0;
List <Activity> activities = new List <Activity>();
foreach (string name in fileNames)
{
Console.WriteLine(name);
Activity activity = LoadFile(name);
totalDistance += Measurements.CalculateDistance(activity.Points);
totalElevationGain += CalculateElevationGain(activity.Points);
activities.Add(activity);
}
activities = activities.OrderBy(x => x.StartTime).ToList();
double discrepancy = 0.0;
double elevationGainDiscrepancy = 0.0;
for (int i = 0; i < activities.Count - 1; i++)
{
//check current activity with next activity last point - first point, for discrepances
TrackPoint current = activities[i].Points.Last();
TrackPoint next = activities[i + 1].Points.First();
var pointPair = new List <TrackPoint> {
current, next
};
double d = Measurements.CalculateDistance(pointPair);
double e = CalculateElevationGain(pointPair);
//skip the bus trip
if (d > 100)
{
continue;
}
if (d < 1)
{
continue;
}
discrepancy += d;
elevationGainDiscrepancy += e;
// add extra points at 1km intervals
int extraPoints = (int)Math.Round(discrepancy);
double latInc = (next.Lat - current.Lat) / (extraPoints + 1);
double lonInc = (next.Lon - current.Lon) / (extraPoints + 1);
//consider an average of 6 minutes per km
double minInc = 6.0;
for (int j = 0; j < extraPoints + 1; j++)
{
//add the new activity
TrackPoint n = new TrackPoint
{
Lat = current.Lat + latInc * j,
Lon = current.Lon + lonInc * j,
Elevation = next.Elevation,
Time = next.Time > current.Time.AddMinutes(minInc * j) ? current.Time.AddMinutes(minInc * j) : next.Time
};
activities[i].Points.Add(n);
}
}
Console.WriteLine($"Untracked distance: {discrepancy}");
Console.WriteLine($"Untracked elevation gain: {elevationGainDiscrepancy}");
totalDistance += discrepancy;
Console.WriteLine($"Total distance: {totalDistance}");
Console.WriteLine($"Total elevation gain: {totalElevationGain}");
return(activities);
}
/// <summary>
/// Calculates distance and speed statistics
/// </summary>
/// <param name="track">track to update</param>
/// <param name="trackPoint">current track point</param>
/// <param name="previousPoint">previous track point</param>
/// <param name="averageSpeedTrackPointCount">
/// reference to current track point could for calculating average speed
/// </param>
private static void CalcDistanceAndSpeedStatistics(Track track, TrackPoint trackPoint, TrackPoint previousPoint, ref int averageSpeedTrackPointCount)
{
var point1 = new MapPoint(previousPoint.Latitude, previousPoint.Longitude);
var point2 = new MapPoint(trackPoint.Latitude, trackPoint.Longitude);
double distanceInMeter = point1.DistanceTo(point2);
track.LengthInMeter += distanceInMeter;
double timeInSeconds = 1.0;
if (previousPoint.Time.HasValue && trackPoint.Time.HasValue)
{
timeInSeconds = (trackPoint.Time.Value - previousPoint.Time.Value).TotalSeconds;
}
double speedInKmh = distanceInMeter / timeInSeconds * Constants.FactorMeterPerSecondToKilometerPerHour;
if (Math.Abs(timeInSeconds) < 1e-6)
{
speedInKmh = 0.0;
}
track.MaxSpeed = Math.Max(track.MaxSpeed, speedInKmh);
track.AverageSpeed += speedInKmh;
averageSpeedTrackPointCount++;
}
public void ResetTrackNode()
{
targetNode = track.StartingNode();
}
public void AddTrackPoint(TrackPoint point)
{
if (point == null)
{
return;
}
if (m_tracks.Count == 0)
{
NewTrackSegment();
}
m_tracks[0].Segments[m_tracks[0].Segments.Count - 1].Points.Add(point);
Dirty = true;
}
public void SetTargetNode(TrackPoint point)
{
targetNode = point;
}
public void ShowEditTrackPointMarker(TrackPoint position)
{
throw new NotImplementedException();
}
private static void SetValueProperty(DependencyObject element, TrackPoint value)
{
element.SetValue(ValueProperty, value);
}
/// <summary>
/// Calculates statistics for a <see cref="IGpsTrack"/> object.
/// </summary>
/// <param name="gpsTrack"><see cref="IGpsTrack"/> object to calculate statistics for.</param>
/// <returns>GpsTrackStatistics object containing the statistics data.</returns>
static public GpsTrackStatistics CalculateTrackStatistics(Track track)
{
GpsTrackStatistics stat = new GpsTrackStatistics();
TrackPoint lastPoint = null;
TrackPoint lastPointWithElevation = null;
foreach (TrackSegment segment in track.Segments)
{
foreach (TrackPoint point in segment.Points)
{
stat.Bounds.ExtendToCover(point.Location);
if (point.Elevation.HasValue)
{
stat.MinElevation = Math.Min(stat.MinElevation, point.Elevation.Value);
stat.MaxElevation = Math.Max(stat.MaxElevation, point.Elevation.Value);
}
if (point.Time.HasValue)
{
if (false == stat.StartTime.HasValue || point.Time < stat.StartTime)
{
stat.StartTime = point.Time.Value;
}
if (false == stat.EndTime.HasValue || point.Time > stat.EndTime)
{
stat.EndTime = point.Time.Value;
}
}
if (lastPoint != null)
{
double horizontalDistance = GpsUtilities.CalculateHorizontalDistance(lastPoint, point);
stat.HorizontalDistance += horizontalDistance;
}
if (lastPointWithElevation != null)
{
// calculate ascent/descent
if (point.Elevation.HasValue)
{
double elevationDifference = point.Elevation.Value - lastPointWithElevation.Elevation.Value;
if (elevationDifference < 0)
{
stat.TotalDescent -= elevationDifference;
}
else
{
stat.TotalAscent += elevationDifference;
}
}
}
lastPoint = point;
if (point.Elevation.HasValue)
{
lastPointWithElevation = point;
}
}
}
return(stat);
}
public bool IsConnectedWith(TrackPoint p)
{
return (AllConnections.Find((c) => c.Point1 == p || c.Point2 == p) != null);
}
public float CheckSetDone(Vector3 carPosition)
{
int startPoint = pointNum;
float totDistance = 0;
for (int i = 0; i < 50; i++)
{
if (startPoint + i == track.trackPoints.Count)
{
break;
}
startPoint = pointNum;
int nextPointIndex = startPoint + i;
if (nextPointIndex >= track.trackPoints.Count)
{
nextPointIndex = 0;
}
if (CheckDistance(carPosition, track.trackPoints[nextPointIndex]) < CheckDistance(carPosition, currentPoint))
{
for (int j = 0; j <= i; j++)
{
if (startPoint + j >= track.trackPoints.Count || track.trackPoints[startPoint + j].isDone)
{
continue;
}
if (!(tracker.laps == 0 && j + startPoint == 0))
{
track.trackPoints[startPoint + j].SetDone(car);
}
currentPoint = nextPoint;
nextPoint = track.trackPoints[pointNum];
totDistance += track.trackPoints[startPoint + j].distance;
pointNum++;
if (pointNum == track.trackPoints.Count)
{
tracker.laps++;
if (tracker.laps == GA_Parameters.laps)
{
break;
}
Reset();
}
}
}
}
startPoint = pointNum;
for (int i = 1; i < 2; i++)
{
if (startPoint - i < 0 || startPoint - i + 2 >= track.trackPoints.Count)
{
break;
}
if (CheckDistance(carPosition, track.trackPoints[startPoint - i]) < CheckDistance(carPosition, track.trackPoints[startPoint - i + 1]) && CheckDistance(carPosition, track.trackPoints[startPoint - i + 2]) > CheckDistance(carPosition, track.trackPoints[startPoint - i]))
{
totDistance -= track.trackPoints[startPoint - i].distance;
track.trackPoints[startPoint - i].isDone = false;
nextPoint = track.trackPoints[startPoint - i + 1];
currentPoint = track.trackPoints[startPoint - i];
pointNum--;
startPoint = pointNum;
}
}
startPoint = pointNum;
return(totDistance);
}
public ProfileCreated(Guid id, Guid userId, Guid chartId, string name, DateTime createdTime, Track track, double ascending, double descending, TrackPoint highestPoint, TrackPoint lowestPoint, Climb[] climbs, ProfilePlace[] places, Leg[] legs, Result result)
{
Id = id;
UserId = userId;
ChartId = chartId;
Name = name;
CreatedTime = createdTime;
Track = track;
Ascending = ascending;
Descending = descending;
HighestPoint = highestPoint;
LowestPoint = lowestPoint;
Climbs = climbs;
Places = places;
Legs = legs;
Result = result;
}
public static void SetValue(MapElement target, TrackPoint value)
{
SetValueProperty(target, value);
}
public static double GetDistance(TrackPoint p1, TrackPoint p2)
{
return Math.Sqrt(Math.Pow((p1.Longitude - p2.Longitude), 2) + Math.Pow((p1.Latitude - p2.Latitude), 2));
}
public Activity Read(string filename)
{
var activity = new Activity();
var document = new XmlDocument();
document.Load(filename);
if (filename.Contains(".gpx"))
{
var index = filename.LastIndexOf(".gpx");
var filenameParts = filename.Substring(0, index).Split(' ');
if (filenameParts.Length == 4)
{
activity.ActivityType = filenameParts[3];
}
}
if (activity.ActivityType == null)
{
activity.ActivityType = "None";
}
foreach (var trackPointNodeObject in document.GetElementsByTagName("trkpt"))
{
var trackPointNode = trackPointNodeObject as XmlNode;
if (trackPointNode != null)
{
var trackPoint = new TrackPoint();
trackPoint.Lon = trackPointNode.ReadAttributeAsDouble("lon");
trackPoint.Lat = trackPointNode.ReadAttributeAsDouble("lat");
var eleNode = trackPointNode.GetChildsByName("ele").FirstOrDefault();
if (eleNode != null)
{
trackPoint.Elevation = eleNode.GetInnerTextAsDouble();
}
var timeNode = trackPointNode.GetChildsByName("time").FirstOrDefault();
if (timeNode != null)
{
trackPoint.DateTime = timeNode.GetInnerTextAsDateTime();
}
activity.TrackPoints.Add(trackPoint);
}
if (activity.StartDateTime.HasValue)
{
activity.Name = string.Format
(
"{0} - {1} ({2})",
activity.StartDateTime.Value.ToString("yyyy-MM-dd HH:mm:ss"),
activity.StopDateTime.Value.ToString("yyyy-MM-dd HH:mm:ss"),
activity.ActivityType
);
}
}
if (activity.TrackPoints.Count == 0)
{
return(null);
}
return(activity);
}
public bool CreateBezieredPoints(ref Vector3[] positions, ref Quaternion[] rotations, ref float[] widths, ref float[] heights, bool saveSourceForCheckUpdate, float bezierTStepSize)
{
if (pointsNew.Length < 2)
{
Debug.LogError("need more then 1 point!!");
needMorePoints = true;
return(false);
}
//create temporary source point lists
List <Vector3> tempListPos = new List <Vector3> ();
List <Quaternion> tempListRot = new List <Quaternion> ();
List <float> tempListWidth = new List <float>();
List <float> tempListHeight = new List <float>();
for (i = 0; i < pointsNew.Length; i++)
{
pointsNew[i].name = name + " p: " + i;
tempListPos.Add(pointsNew[i].position);
tempListRot.Add(pointsNew[i].rotation);
TrackPoint trackPoint = pointsNew[i].GetComponent <TrackPoint>();
tempListWidth.Add(trackPoint.width);
tempListHeight.Add(trackPoint.height);
}
//create temporary beziered point lists
List <Vector3> pointsBeziered = new List <Vector3> ();
List <Quaternion> rotationsBeziered = new List <Quaternion> ();
List <float> widthBeziered = new List <float>();
List <float> heightBeziered = new List <float>();
// create other variables needed
int bezierLevels = tempListPos.Count + 1 - 2;
float bezierApproximateLength = 0;
for (i = 0; i < bezierLevels; i++)
{
bezierApproximateLength += Vector3.Distance(tempListPos[i], tempListPos[i + 1]);
}
//float bezierSubsections = bezierApproximateLength * trackSettings.pointsPerUnityUnit;
/*
* Debug.Log ("bezierSubsections: "+bezierSubsections);
* Debug.Log ("bezierLevels: "+bezierLevels);
* Debug.Log ("bezierApproximateLength: "+bezierApproximateLength);
* Debug.Log ("bezierTStepSize: "+bezierTStepSize);
*/
// create beziered point from points
for (t = 0; t < 1; t += bezierTStepSize)
{
Vector3[] levelPositions = new Vector3[bezierLevels];
Vector3[] levelPositionsNew;
Quaternion[] levelRotations = new Quaternion[bezierLevels];
Quaternion[] levelRotationsNew;
float[] levelWidth = new float[bezierLevels];
float[] levelWidthNew;
float[] levelHeight = new float[bezierLevels];
float[] levelHeightNew;
for (j = 0; j < bezierLevels + 1; j++)
{
int levelPointCalculationLength = ((bezierLevels - 1) - j);
//first bezierLevels
if (j == 0)
{
for (l = 0; l < levelPointCalculationLength + 1; l++)
{
levelRotations[l] = Quaternion.Lerp(tempListRot[l], tempListRot[l + 1], t);
levelPositions[l] = Vector3.Lerp(tempListPos[l], tempListPos[l + 1], t);
levelWidth[l] = Mathf.Lerp(tempListWidth[l], tempListWidth[l + 1], t);
levelHeight[l] = Mathf.Lerp(tempListHeight[l], tempListHeight[l + 1], t);
}
//last bezierLevels
}
else if (j == bezierLevels)
{
pointsBeziered.Add(levelPositions[0]);
rotationsBeziered.Add(levelRotations[0]);
widthBeziered.Add(levelWidth[0]);
heightBeziered.Add(levelHeight[0]);
// in between bezierLevels
}
else
{
levelPositionsNew = new Vector3[bezierLevels];
levelRotationsNew = new Quaternion[bezierLevels];
levelWidthNew = new float[bezierLevels];
levelHeightNew = new float[bezierLevels];
for (l = 0; l < levelPointCalculationLength + 1; l++)
{
levelPositionsNew[l] = Vector3.Lerp(levelPositions[l], levelPositions[l + 1], t);
levelRotationsNew[l] = Quaternion.Lerp(levelRotations[l], levelRotations[l + 1], t);
levelWidthNew[l] = Mathf.Lerp(levelWidth[l], levelWidth[l + 1], t);
levelHeightNew[l] = Mathf.Lerp(levelHeight[l], levelHeight[l + 1], t);
}
levelRotations = levelRotationsNew;
levelPositions = levelPositionsNew;
levelWidth = levelWidthNew;
levelHeight = levelHeightNew;
}
}
}
//add point t 1 (last point)
pointsBeziered.Add(Vector3.Lerp(tempListPos[tempListPos.Count - 2], tempListPos[tempListPos.Count - 1], 1));
rotationsBeziered.Add(Quaternion.Lerp(tempListRot[tempListRot.Count - 2], tempListRot[tempListRot.Count - 1], 1));
widthBeziered.Add(Mathf.Lerp(tempListWidth[tempListWidth.Count - 2], tempListWidth[tempListWidth.Count - 1], 1));
heightBeziered.Add(Mathf.Lerp(tempListHeight[tempListHeight.Count - 2], tempListHeight[tempListHeight.Count - 1], 1));
//bezied track data
positions = pointsBeziered.ToArray();
rotations = rotationsBeziered.ToArray();
widths = widthBeziered.ToArray();
heights = heightBeziered.ToArray();
if (saveSourceForCheckUpdate)
{
//save source for update checks
currentPositionsSource = tempListPos.ToArray();
currentRottationsSource = tempListRot.ToArray();
currentWidthsSource = tempListWidth.ToArray();
currentHeightsSource = tempListHeight.ToArray();
}
//Debug.Log("pointsCurrent.length: "+pointsCurrent.Length);
//for (i = 0; i < pointsCurrent.Length; i++) {
// Debug.Log(i+":"+pointsCurrent[i]);
//}
return(true);
}
public void ConvertGpx(string vehicleName, string gpxData)
{
XDocument gpxDoc = GetGpxDoc(gpxData);
XNamespace gpx = GetGpxNameSpace();
var tracks = from track in gpxDoc.Descendants(gpx + "trk")
select new
{
Name = track.Element(gpx + "name") != null?
track.Element(gpx + "name").Value : null,
Segs = (
from trackpoint in track.Descendants(gpx + "trkpt")
select new
{
Latitude = trackpoint.Attribute("lat").Value,
Longitude = trackpoint.Attribute("lon").Value,
Elevation = trackpoint.Element(gpx + "ele") != null ?
trackpoint.Element(gpx + "ele").Value : null,
Time = trackpoint.Element(gpx + "time") != null ?
trackpoint.Element(gpx + "time").Value : null
}
)
};
var waypoints = from waypoint in gpxDoc.Descendants(gpx + "wpt")
select new
{
Latitude = waypoint.Attribute("lat").Value,
Longitude = waypoint.Attribute("lon").Value,
Elevation = waypoint.Element(gpx + "ele") != null?
waypoint.Element(gpx + "ele").Value : null,
Name = waypoint.Element(gpx + "name") != null?
waypoint.Element(gpx + "name").Value : null,
Dt = waypoint.Element(gpx + "cmt") != null?
waypoint.Element(gpx + "cmt").Value : null
};
using (var rep = ServiceProvider.GetService <IRepositoryFactory>().GenerateRepository <TrackPoint>())
{
try
{
rep.BeginTransaction();
Track track = new Track
{
Name = "FromGpx",
VehicleName = vehicleName,
IsActive = true,
Created = System.DateTime.Now,
CreatedBy = "Feng.Map"
};
rep.Save(track);
foreach (var trk in tracks)
{
// Populate track data objects.
foreach (var trkSeg in trk.Segs)
{
TrackPoint tp = new TrackPoint
{
Track = track,
Latitude = Convert.ToDouble(trkSeg.Latitude),
Longitude = Convert.ToDouble(trkSeg.Longitude),
GpsTime = string.IsNullOrEmpty(trkSeg.Time) ? System.DateTime.Now : Convert.ToDateTime(trkSeg.Time),
MessageTime = System.DateTime.Now,
VehicleName = vehicleName,
};
rep.Save(tp);
}
}
foreach (var wpt in waypoints)
{
WayPoint wp = new WayPoint
{
Track = track,
Latitude = Convert.ToDouble(wpt.Latitude),
Longitude = Convert.ToDouble(wpt.Longitude),
GpsTime = System.DateTime.Now,
MessageTime = System.DateTime.Now,
IsActive = true,
};
rep.Save(wp);
}
rep.Save(track);
rep.CommitTransaction();
}
catch (Exception)
{
rep.RollbackTransaction();
}
}
}
private static void SimulateTrack(long trackId, Action <TrackPoint> action4TrackPoint = null, Action <WayPoint> action4WayPoint = null)
{
System.Console.WriteLine("Start to simulateTrack.");
var track = TrackDao.GetTrack(trackId);
DateTime?endDate = track.EndTime;
track.EndTime = null;
(new TrackDao()).Update(track);
var trackPointDao = new TrackPointDao();
var wayPointDao = new WayPointDao();
var trackPoints = TrackPointDao.GetTrackPoints(track);
foreach (var p in trackPoints)
{
p.IsActive = false;
trackPointDao.Update(p);
}
var wayPoints = WayPointDao.GetWaypoints(track);
foreach (var p in wayPoints)
{
p.IsActive = false;
wayPointDao.Update(p);
}
int wayPointIdx = 0;
TrackPoint lastp = null;
foreach (var p in trackPoints)
{
//if (lastp != null && p.GpsTime == lastp.GpsTime)
// continue;
p.IsActive = true;
trackPointDao.Update(p);
if (action4TrackPoint != null)
{
action4TrackPoint(p);
}
if (wayPointIdx < wayPoints.Count &&
p.MessageTime >= wayPoints[wayPointIdx].MessageTime)
{
wayPoints[wayPointIdx].IsActive = true;
wayPointDao.Update(wayPoints[wayPointIdx]);
action4WayPoint(wayPoints[wayPointIdx]);
wayPointIdx++;
}
System.Console.Write("Press any Key.");
System.Console.ReadLine();
//System.Threading.Thread.Sleep(5000);
System.Console.WriteLine(string.Format("write trackpoint at {0}", p.GpsTime));
lastp = p;
}
track.EndTime = endDate;
(new TrackDao()).Update(track);
System.Console.WriteLine("Finish.");
}
private void save_btn_Click(object sender, EventArgs e)
{
if (id_tb.Text.Length != 0 &&
name_tb.Text.Length != 0)
{
try
{
PowerSupplyModel _psModel = new PowerSupplyModel();
_psModel.powerSupplyID = int.Parse(id_tb.Text);
_psModel.powerSupplyName = name_tb.Text;
_psModel.powerSupplyRange = psRange_tb.Text;
List <TrackPoint> _tpList = new List <TrackPoint>();
List <TrackLine> _tlList = new List <TrackLine>();
List <Signal> _signalList = new List <Signal>();
if (containPoints_lv.Items.Count != 0)
{
foreach (ListViewItem lvi in containPoints_lv.Items)
{
TrackPoint _tp = new TrackPoint();
_tp = (TrackPoint)tPoint[int.Parse(lvi.SubItems[3].Text)].Clone();
if (lvi.SubItems[2] != null)
{
if (lvi.SubItems[2].Text.Contains("定"))
{
_tp.switchDirection = 1;
}
else if (lvi.SubItems[2].Text.Contains("反"))
{
_tp.switchDirection = 2;
}
}
_tpList.Add(_tp);
}
}
if (containTracks_lv.Items.Count != 0)
{
foreach (ListViewItem lvi in containTracks_lv.Items)
{
TrackLine _tline = new TrackLine();
_tline = (TrackLine)tLine[int.Parse(lvi.SubItems[3].Text)].Clone();
if (lvi.SubItems[2].Text.Contains("全部"))
{
_tline.containsInPS = 0;
}
else if (lvi.SubItems[2].Text.Contains("左"))
{
_tline.containsInPS = 1;
}
else if (lvi.SubItems[2].Text.Contains("右"))
{
_tline.containsInPS = 2;
}
_tlList.Add(_tline);
}
}
if (containsFunctionalPoints_lv.Items.Count != 0)
{
foreach (ListViewItem lvi in containsFunctionalPoints_lv.Items)
{
Signal _s = new Signal();
_s = (Signal)signal[int.Parse(lvi.SubItems[2].Text)].Clone();
_signalList.Add(_s);
}
}
_psModel.containedTrackLine = _tlList;
_psModel.containedTrackPoint = _tpList;
_psModel.functionalTrackPoint = _signalList;
if (ps_lv.SelectedItems.Count != 0)
{
psModel.RemoveAt(ps_lv.SelectedItems[0].Index);
}
psModel.Add(_psModel);
initUI(true);
removeText();
}
catch (Exception e1)
{
MessageBox.Show(e1.ToString().Split('。')[0] + "。", "错误", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
else
{
MessageBox.Show("请填写左边框内ID和名称", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
public override string ToString()
{
var tp = new TrackPoint(this);
return(tp.ToString());
}
public Track Get(string id)
{
System.Threading.Thread.Sleep(10);
Debug.WriteLine("Track::Get(\"" + id + "\")");
//
var scan = new IniScannerOld {
IniFile = FilePath + id
};
scan.Read();
// Read data:
var name = scan.TryGetString("TrackName");
var location = scan.TryGetString("Location");
var laprecordRace = 0.0f;
var laprecordQualify = 0.0f;
float.TryParse(scan.TryGetString("Race Laptime").Trim(), out laprecordRace);
float.TryParse(scan.TryGetString("Qualify Laptime").Trim(), out laprecordQualify);
// Read track path:
var path = new List <TrackPoint>();
TrackPoint trackPoint = null;
// Temporary variables:
float x = 0.0f, y = 0.0f, z = 0.0f, meter = 0.0f;
TrackPointType type = TrackPointType.GRID;
float[] boundsL = new float[0], boundsR = new float[0];
var perpVector = new float[3] {
0.0f, 0.0f, 0.0f
};
var track_aiw = new IniScannerOld {
IniFile = FilePath + id.Replace("gdb", "aiw")
};
track_aiw.HandleCustomKeys += (d) =>
{
var a = (object[])d;
var key = (string)a[0];
var values = (string[])a[1];
switch (key)
{
// pos = coordinates)
case "Main.wp_pos":
x = Convert.ToSingle(values[0]);
z = Convert.ToSingle(values[1]);
y = Convert.ToSingle(values[2]);
break;
// score = sector, distance
case "Main.wp_score":
var sector = Convert.ToInt32(values[0]) + 1;
if (sector == 1)
{
type = TrackPointType.SECTOR1;
}
if (sector == 2)
{
type = TrackPointType.SECTOR2;
}
if (sector == 3)
{
type = TrackPointType.SECTOR3;
}
meter = Convert.ToSingle(values[1]);
break;
// branchID = path ID, 0=main, 1=pitlane
case "Main.wp_branchid":
if (values.Length == 1)
{
switch (values[0])
{
case "1":
type = TrackPointType.PITS;
break;
default:
// TODO: Double check this.
type = TrackPointType.GRID;
break;
}
}
else
{
type = TrackPointType.GRID;
}
break;
case "Main.wp_perp":
perpVector = new float[3]
{
Convert.ToSingle(values[0]),
Convert.ToSingle(values[1]),
Convert.ToSingle(values[2])
};
break;
case "Main.wp_width":
boundsL = new float[2]
{
x - perpVector[0] * Convert.ToSingle(values[0]),
y - perpVector[2] * Convert.ToSingle(values[0])
};
boundsR = new float[2]
{
x + perpVector[0] * Convert.ToSingle(values[1]),
y + perpVector[2] * Convert.ToSingle(values[1])
};
break;
// ptrs = next path, previous path, pitbox route (-1 for no pitbox), following branchID
case "Main.wp_ptrs":
path.Add(new TrackPoint(meter, type, x, y, z, boundsL, boundsR));
break;
}
};
track_aiw.FireEventsForKeys = new List <string>();
track_aiw.FireEventsForKeys.AddRange(new string[6]
{
"Main.wp_pos", "Main.wp_score", "Main.wp_branchid",
"Main.wp_perp", "Main.wp_width", "Main.wp_ptrs"
});
track_aiw.Read();
var t = new Track(id, name, location, laprecordRace, laprecordQualify);
t.SetTrack(path);
return(t);
}
public void RespawnTrack()
{
currentNodes = Track1;
closestNode = currentNodes[0];
}
public void SelectPoint(TrackPoint p)
{
selectedConnections = new List<TrackConnection>();
selectedPoints = new List<TrackPoint>();
selectedPoints.Add(p);
}
//public void ReconfigureTrack(TrackPoint newNode)
//{
// Debug.Log("Configure track here");
//}
public void AssignNextTrack(string trackName)
{
List<TrackPoint> newTrack = new List<TrackPoint>();
switch (trackName)
{
case "1":
newTrack = Track1;
break;
case "2":
newTrack = Track2;
break;
case "3":
newTrack = Track3;
break;
case "4":
newTrack = Track4;
break;
case "5":
newTrack = Track5;
break;
case "6":
newTrack = Track6;
break;
case "7":
newTrack = Track7;
break;
case "8":
newTrack = Track8;
break;
case "9":
newTrack = Track9;
break;
case "10":
newTrack = Track10;
break;
case "11":
newTrack = Track11;
break;
case "12":
newTrack = Track12;
break;
case "13":
newTrack = Track13;
break;
case "14":
newTrack = Track14;
break;
case "15":
newTrack = Track15;
break;
case "16":
newTrack = Track16;
break;
case "17":
newTrack = Track17;
break;
case "18":
newTrack = Track18;
break;
case "19":
newTrack = Track19;
break;
case "20":
newTrack = Track20;
break;
case "21":
newTrack = Track21;
break;
case "22":
newTrack = Track22;
break;
case "23":
newTrack = Track23;
break;
case "24":
newTrack = Track24;
break;
default:
break;
}
currentNodes = newTrack;
currentPosition = 0;
closestNode = currentNodes[currentPosition];
}
public void UnRegister(TrackPoint p)
{
points.Remove(p);
selectedPoints.Remove(p);
}
public void Intersect()
{
Vector2 pos;
pos = 0.5f * (Point1.position + Point2.position) ;
TrackPoint oldP = Point2;
Point2 = new TrackPoint(pos, track);
new TrackConnection(Point2, oldP, track);
}
