Convert Time:[Distance,Speed] data to Distance:[Time,Speed] data - php

Question

I'm having trouble figuring out an algorithm...
I've got a long series of GPS data that records Time, Speed, Distance, at 1 second intervals. Assume the distance is meters, and speed in m/s. There may be upwards of 2 hours of data, or 7200 points. The "time" field in here is mainly just for reference.
So, the first 5 seconds would be values something like this, with [1-5] being seconds.
$data = array(
1 : array('distance'=>0, 'time'=>'2014-01-09 17:50:00', 'speed'=>0.0),
2 : array('distance'=>2, 'time'=>'2014-01-09 17:50:01', 'speed'=>2.0),
3 : array('distance'=>6, 'time'=>'2014-01-09 17:50:02', 'speed'=>4.0),
4 : array('distance'=>10, 'time'=>'2014-01-09 17:50:03', 'speed'=>4.0),
5 : array('distance'=>12, 'time'=>'2014-01-09 17:50:04', 'speed'=>2.0)
);
I'd like to convert this to data that is listed at 1 meter intervals instead, like this with [1-6] being meters.
$data = array(
1 : array('seconds'=>1.5, 'time'=>'2014-01-09 17:50:01.500', 'speed'=>.666),
2 : array('seconds'=>2, 'time'=>'2014-01-09 17:50:02', 'speed'=>2.0),
3 : array('seconds'=>2.25, 'time'=>'2014-01-09 17:50:02.250', 'speed'=>4.0),
4 : array('seconds'=>2.5, 'time'=>'2014-01-09 17:50:02.500', 'speed'=>4.0),
5 : array('seconds'=>2.75, 'time'=>'2014-01-09 17:50:02.750', 'speed'=>4.0),
6 : array('seconds'=>3, 'time'=>'2014-01-09 17:50:03', 'speed'=>4.0)
);
This can be done w/o the time field of course. I'm having trouble with the calculation, since it definitely isn't 1-to-1. If we start with 7200 seconds of data, we could end up with more or less depending on the distance covered (more or less than 7200 meters).
EDIT (01/10/2014)
Below are the actual implementations of the two methods. I'm actually having trouble deciding which I like better, the iterative or recursive method. I may go with the iterative
METHOD 1, iterative (#Ezequiel Muns, with very minor modifications by me):
function timeToDistance($data) {
if(sizeof($data) == 0){ return; }
$startTime = $data[0]['time'];
$prev = null;
$result = array();
foreach ($data as $secs => $row) {
$row['seconds'] = $secs; // to simplify passing in secs
if ($prev == null) {
// make sure we have a pair
$prev = array( 'distance'=>0 );
}
foreach (distanceRowsBetween($startTime,$prev, $row) as $dist => $distRow) {
$result[$dist] = $distRow;
}
$prev = $row;
}
return $result;
}
function distanceRowsBetween($startTime,$prevRow, $nextRow) {
// Return the by-distance rows that are between $prevRow (exclusive)
// and $nextRow (inclusive)
$rows = array();
$currDist = $prevRow['distance'];
while (true) {
// try to move to the next whole unit of distance
$dDist = ceil($currDist) - $currDist;
$dDist = $dDist == 0.0? 1.0 : $dDist; // dDist is 1 unit if currDist is whole
$currDist += $dDist;
if ($currDist > $nextRow['distance'])
break;
$currSpeed = $nextRow['speed'];
$currSecs = strtotime($nextRow['time']) - strtotime($startTime);
$currTime = $nextRow['time'];
$rows[$currDist] = array(
'speed' => $currSpeed,
'seconds' => $currSecs,
'time' => $currTime,
);
}
return $rows;
}
METHOD 2, recursive (#Nathaniel Ford pseudocode, me actual code):
function data2dist($time_data = array()){
$dist_data = array();
if(sizeof($time_data) == 0){ return $dist_data; }
$start_point = array_shift($time_data);
$start_time = $start_point['time'];
data2dist_sub($start_time, $time_data,$dist_data,$start_point);
return $dist_data;
}
function data2dist_sub($start_time,&$time_data, &$dist_data, $start_point = array()){
if(sizeof($time_data) == 0 && !isset($start_point)){
return;
}
if(sizeof($dist_data) == 0){
$prev_dist = 0;
} else {
$prev_dist = $dist_data[sizeof($dist_data)-1]['distance'];
}
// since distances are accumulating, get curr distance by subtracting last one
$point_dist = $start_point['distance'] - $prev_dist;
if($point_dist == 1){
// exactly 1: perfect, add and continue
$dist_data[] = $start_point;
$start_point = array_shift($time_data);
} else if($point_dist > 1){
// larger than 1: effectively remove 1 from current point and send it forward
$partial_point = $start_point;
$partial_point['distance'] = 1 + $prev_dist;
$dist_data[] = $partial_point;
} else if($point_dist < 1){
// less than 1, carry forward to the next item and continue (minor: this partial speed is absorbed into next item)
$start_point = array_shift($time_data);
if(!isset($start_point)){ return; }
$start_point['distance'] += $point_dist;
}
data2dist_sub($start_time,$time_data,$dist_data,$start_point);
}

Answer 1

You can simplify this by noting that for every contiguous pair of by-time rows you need to calculate 0 or more by-distance rows, and these depend solely on those two by-time rows.
So start with a function to do this simpler calculation, this is a skeleton leaving the calculation of the transformed 'seconds', 'speed' and 'time' values out for simplicity.
function distanceRowsBetween($prevRow, $nextRow) {
// Return the by-distance rows that are between $prevRow (exclusive)
// and $nextRow (inclusive)
$rows = array();
$currDist = $prevRow['distance'];
while (true) {
// try to move to the next whole unit of distance
$dDist = ceil($currDist) - $currDist;
$dDist = $dDist == 0.0? 1.0 : $dDist; // dDist is 1 unit if currDist is whole
$currDist += $dDist;
if ($currDist > $nextRow['distance'])
break;
// calculate $currSecs at distance $currDist
// calculate $currSpeed
// calculate $currTime
$rows[$currDist] = array(
'speed' => $currSpeed,
'seconds' => $currSecs,
'time' => $currTime,
);
}
return $rows;
}
Now that you have this all that remains is iterating over each contiguous pair in the input and accumulate resulting by-distance rows:
function timeToDistance($data) {
$prev = null;
$result = array();
foreach ($data as $secs => $row) {
$row['seconds'] = $secs; // to simplify passing in secs
if ($prev == null) {
$prev = $row; // make sure we have a pair
continue;
}
foreach (distanceRowsBetween($prev, $row) as $dist => $distRow) {
$result[$dist] = $distRow;
}
$prev = $row;
}
return $result;
}
Note in this function I am populating and passing in the current 'seconds' value in the row, to reduce the number of parameters passed into the previous function.

Answer 2

This is a bit of a mind-bender, and there are a couple of edge cases that make it difficult. However, your basic algorithm should boil down to:
Take in an array of by-Time data points
Create a new array of by-Distance data points
Create a first by-Distance data point with 'zero' speed/distance
Pass this to your subfunction
Subfunction (Takes by-Time array, by-Distance array and 'start point')
Take the first by-Time data point and 'add' it to the by-Distance data point, call this 'temp'
Convert to seconds/speed
If distance covered by temp is exactly 1, add this new array to the by-Distance array
If it is more than one, subtract the portion that would equal one
back-calculate distance/speed/time, add to by-Distance array
Recurse into the subfunction, using the remainder as your new start point
If it is less than one
Recurse into the subfunction, using the modified start point as new start point
Note that the sub-function will need to use mutable copies of the arrays: the by-Time array should slowly shrink and the by-Distance array grow. Also, you will want to trampoline the function (rather than use straight recursion) because with 7200 datapoints you will probably have more than that in stack frames, and you run into a potential memory problem.