Quando si usa GPX in Xcode per simulare i cambiamenti di posizione, c'è un modo per controllare la velocità?

Question

Sto utilizzando il seguente file GPX in Xcode 4.2 per simulare un cambio di posizione. Funziona bene, ma non riesco a controllare la velocità del cambio di posizione. il francobollo sembra non funzionare. Qualcuno ha una soluzione per questo?

<?xml version="1.0"?> 
<gpx version="1.1" creator="Xcode"> 
    <wpt lat="37.331705" lon="-122.030237"></wpt> 
    <wpt lat="37.331705" lon="-122.030337"></wpt> 
    <wpt lat="37.331705" lon="-122.030437"></wpt> 
    <wpt lat="37.331705" lon="-122.030537"></wpt> 
</gpx> 

Answer 1

Non credo che (sapere) che questo è possibile nel GPX direttamente, ma è possibile verificare il cambiamento posizione con strumenti/Automation.

devi usare uno script come:

var target = UIATarget.localTarget(); 
target.setLocation(<location); 
target.delay(5); 
target.setLocation(...); 

E così via. Ho preso questo esempio dal video WWDC11 https://developer.apple.com/videos/play/wwdc2011/518/ (Test delle applicazioni in grado di localizzare)

Sono consapevole che in realtà non consente di definire la velocità, ma i ritardi in qualche modo spiegano ciò che spero. Forse questo ti aiuterà.

Answer 2

V'è anche un metodo che permette di passare nella velocità e alcune altre proprietà:

target.setLocationWithOptions({latitude: 46.546928, longitude: 11.867127}, {altitude: 200.0, speed: 5}); 

(Controllare questo AppleDoc per maggiori dettagli)

si possono ancora vedere i tuoi NSLog di nella console applicazione (/Applications/Utilities/Console.app). Basta aggiungere un filtro per ottenere risultati corretti.

Answer 3

Non penso che si possa fare con i file GPX. Ma è facile con lo strumento di automazione all'interno di Intruments. Ecco uno degli script me stesso che uso per il mio test app e screenshots in grado di raccogliere:

var target = UIATarget.localTarget(); 

// speed is in meters/sec 
var points = [ 
      {location:{latitude:48.8899,longitude:14.2}, options:{speed:8, altitude:200, horizontalAccuracy:10, verticalAccuracy:15}}, 
      {location:{latitude:48.8899,longitude:14.9}, options:{speed:11, altitude:200, horizontalAccuracy:10, verticalAccuracy:15}}, 
      {location:{latitude:48.8899,longitude:14.6}, options:{speed:12, altitude:200, horizontalAccuracy:10, verticalAccuracy:15}}, 
      {location:{latitude:48.8899,longitude:14.7}, options:{speed:13, altitude:200, horizontalAccuracy:10, verticalAccuracy:15}}, 
      {location:{latitude:49.2,longitude:14.10}, options:{speed:15, altitude:200, horizontalAccuracy:10, verticalAccuracy:15}}, 
      {location:{latitude:49.4,longitude:14.8}, options:{speed:15, altitude:200, horizontalAccuracy:10, verticalAccuracy:15}}, 
      {location:{latitude:48.8899,longitude:14.9}, options:{speed:9, altitude:200, horizontalAccuracy:10, verticalAccuracy:15}}, 
      {location:{latitude:48.8899,longitude:15.1}, options:{speed:8, altitude:200, horizontalAccuracy:10, verticalAccuracy:15}}, 
      {location:{latitude:48.8899,longitude:16.1}, options:{speed:3, altitude:200, horizontalAccuracy:10, verticalAccuracy:15}}, 
      ]; 

for (var i = 0; i < points.length; i++) 
{ 
target.setLocationWithOptions(points[i].location,points[i].options); 
target.captureScreenWithName(i+"_.png"); 
target.delay(1.0); 
} 

ho creato step by step walkthrough per come ho usato la simulazione posizione con l'automazione e perdite per afferrare le immagini e trovare le perdite

Answer 4

Se don Non voglio avere a che fare con l'automatore, puoi farlo funzionare solo con un file GPX. Il trucco è creare un sacco di punti.

Ad esempio, anziché creare solo 2 punti per passare da A a B, creare un gruppo di punti intermedi tra di loro. Funziona perché il simulatore di posizione impiega un tempo costante per spostarsi da un punto a un altro, indipendentemente dalla distanza tra i due punti.

Piuttosto che dover creare manualmente un gruppo di punti, è possibile utilizzare il seguente codice.

Istruzioni:

1. incolla il codice qui sotto, modificando la costante kDesiredSpeed ​​a proprio piacimento.
2. Aggiungi un UITapGestureRecognizer alla visualizzazione mappa, collegandolo alla mappaViewTappato:
3. Aggiungi pulsanti che chiamano startRecordingPoints e stopRecordingPoints.
4. Eseguire l'app.
5. Toccare il pulsante StartRecordingPoints.
6. Toccare dove deve iniziare il percorso.
7. Tocca un'altra posizione sulla mappa.Questo genererà X quantità di punti tra l'ultimo nodo e il nuovo nodo in modo che sembrerà spostarsi alla velocità desiderata.
8. Ripeti il ​​passaggio precedente tutte le volte che vuoi.
9. Premere interrompere la registrazione.
10. Copia l'output della console.
11. File> Nuovo file ...
12. Scegliere Risorsa> GPX file
13. incollare il contenuto e salvare il file.
14. Toccare la freccia della posizione nel debugger e scegliere il file GPX.
15. Siediti e guarda come la posizione viene aggiornata esattamente alla velocità desiderata!

Codice:

@property (strong, nonatomic) CLLocation *lastRecordedPoint; 
@property (strong, nonatomic) NSMutableString *recordingOutput; 

... 

- (IBAction)mapViewTapped:(UITapGestureRecognizer *)sender { 
    if (sender.state != UIGestureRecognizerStateEnded || !self.recordingOutput) { 
     return; 
    } 

    CLLocationCoordinate2D coord = [self.mapView convertPoint:[sender locationInView:self.mapView] 
             toCoordinateFromView:self.mapView]; 
    [self recordPoint:coord]; 
} 

- (void)recordPoint:(CLLocationCoordinate2D)newPoint { 
    const CGFloat kAppleTravelTime = 2; // the default time it takes to travel from one point to another 
    const CGFloat kDesiredSpeed = 6; // meters per sec 
    const CGFloat kDesiredDistanceBetweenPoints = kDesiredSpeed * kAppleTravelTime; 
    NSString * const kFormatString = @" <wpt lat=\"%f\" lon=\"%f\"></wpt>\n"; 

    CLLocation *newLocation = [[CLLocation alloc] initWithLatitude:newPoint.latitude longitude:newPoint.longitude]; 
    NSInteger numberOfPoints = 1; 
    if (self.lastRecordedPoint) { 
     CLLocationDistance distance = [self.lastRecordedPoint distanceFromLocation:newLocation]; 
     numberOfPoints = MAX(round(distance/kDesiredDistanceBetweenPoints), 1); 
     CGFloat deltaLatitude = newPoint.latitude - self.lastRecordedPoint.coordinate.latitude; 
     CGFloat deltaLongitude = newPoint.longitude - self.lastRecordedPoint.coordinate.longitude; 
     for (NSInteger i = 0; i < numberOfPoints; i++) { 
      CLLocationDegrees latitude = self.lastRecordedPoint.coordinate.latitude + (numberOfPoints/distance * deltaLatitude) * (i+1); 
      CLLocationDegrees longitude = self.lastRecordedPoint.coordinate.longitude + (numberOfPoints/distance * deltaLongitude) * (i+1); 
      [self.recordingOutput appendFormat:kFormatString, latitude, longitude]; 
     } 
    } else { 
     [self.recordingOutput appendFormat:kFormatString, newPoint.latitude, newPoint.longitude]; 
    } 
    NSLog(@"Recorded %ld point(s) to: %f,%f", (long)numberOfPoints, newPoint.latitude, newPoint.longitude); 

    self.lastRecordedPoint = newLocation; 
} 


- (void)startRecordingPoints { 
    NSLog(@"Started recording points. Tap anywhere on the map to begin recording points."); 
    self.recordingOutput = [NSMutableString string]; 
    [self.recordingOutput appendString:@"<?xml version=\"1.0\"?>\n<gpx version=\"1.1\" creator=\"Xcode\">\n"]; 
    self.lastRecordedPoint = nil; 
} 

- (void)stopRecordingPoints { 
    [self.recordingOutput appendString:@"</gpx>"]; 
    NSLog(@"Done recording, here is your gpx file: \n%@", self.recordingOutput); 
    self.recordingOutput = nil; 
} 

responsabilità:kAppleTravelTime = 2 è solo una supposizione. Se si dispone di un valore più preciso, si prega di postarlo in un commento.

Answer 5

Il supporto Xcode simula il cambio di velocità con un file GPX.

Fornire uno o più waypoint contenenti una coppia di latitudine/longitudine. Se fornisci un waypoint, Xcode simulerà quella posizione specifica. Se fornisci più waypoint, Xcode simulerà un percorso visitando ogni waypoint.

Fornire facoltativamente un elemento orario per ciascun waypoint. Xcode interpolerà il movimento a un tasso di velocità in base al tempo trascorso tra ciascun waypoint. Se non si fornisce un elemento temporale, Xcode utilizzerà una velocità fissa. I waypoint devono essere ordinati per ora in ordine crescente.

scrittura come questo:

<wpt lat="39.96104510" lon="116.4450860"> 
    <time>2010-01-01T00:00:00Z</time> 
</wpt> 
<wpt lat="39.96090940" lon="116.4451400"> 
    <time>2010-01-01T00:00:05Z</time> 
</wpt> 
... 
<wpt lat="39.96087240" lon="116.4450430"> 
    <time>2010-01-01T00:00:09Z</time> 
</wpt> 

circa -1 velocità

velocità dell'oggetto CoreLocation sarà sempre -1 durante la simulazione. Una possibile soluzione è salvare un'ultima posizione quindi calcolare noi stessi la velocità. Esempio di codice:

CLLocationSpeed speed = location.speed; 
if (speed < 0) { 
    // A negative value indicates an invalid speed. Try calculate manually. 
    CLLocation *lastLocation = self.lastLocation; 
    NSTimeInterval time = [location.timestamp timeIntervalSinceDate:lastLocation.timestamp]; 

    if (time <= 0) { 
     // If there are several location manager work at the same time, an outdated cache location may returns and should be ignored. 
     return; 
    } 

    CLLocationDistance distanceFromLast = [lastLocation distanceFromLocation:location]; 
    if (distanceFromLast < DISTANCE_THRESHOLD 
     || time < DURATION_THRESHOLD) { 
     // Optional, dont calculate if two location are too close. This may avoid gets unreasonable value. 
     return; 
    } 
    speed = distanceFromLast/time; 
    self.lastLocation = location; 
}