248 lines
8.2 KiB
PHP
248 lines
8.2 KiB
PHP
<?php
|
|
|
|
/**
|
|
* GPX to GeoJSON Converter
|
|
*
|
|
* To convert a gpx file:
|
|
* 1. Add file <file_name>.gpx to geo/ folder
|
|
* 2. Assign file to project: UPDATE projects SET codename = '<file_name>' WHERE id_project = <id_project>;
|
|
* 3. Load any page
|
|
*
|
|
* To force gpx rebuild:
|
|
* ?a=build_geojson&name=<file_name>
|
|
*/
|
|
class Converter extends PhpObject {
|
|
|
|
public function __construct() {
|
|
parent::__construct(__CLASS__, Settings::DEBUG);
|
|
}
|
|
|
|
public static function convertToGeoJson($sCodeName) {
|
|
$oGpx = new Gpx($sCodeName);
|
|
$oGeoJson = new GeoJson($sCodeName);
|
|
|
|
$oGeoJson->buildTracks($oGpx->getTracks());
|
|
if($oGeoJson->isSimplicationRequired()) $oGeoJson->buildTracks($oGpx->getTracks(), true);
|
|
$oGeoJson->saveFile();
|
|
|
|
return $oGpx->getLog().'<br />'.$oGeoJson->getLog();
|
|
}
|
|
|
|
public static function isGeoJsonValid($sCodeName) {
|
|
$bResult = false;
|
|
$sGeoJsonFilePath = Geo::getFilePath($sCodeName, GeoJson::EXT);
|
|
if(file_exists($sGeoJsonFilePath) && filemtime($sGeoJsonFilePath) > filemtime(Geo::getFilePath($sCodeName, Gpx::EXT))) $bResult = true;
|
|
return $bResult;
|
|
}
|
|
}
|
|
|
|
class Geo extends PhpObject {
|
|
|
|
const GEO_FOLDER = 'geo/';
|
|
const OPT_SIMPLE = 'simplification';
|
|
|
|
protected $asTracks;
|
|
protected $sFilePath;
|
|
|
|
public function __construct($sCodeName) {
|
|
parent::__construct(get_class($this), Settings::DEBUG, PhpObject::MODE_HTML);
|
|
$this->sFilePath = self::getFilePath($sCodeName, static::EXT);
|
|
$this->asTracks = array();
|
|
}
|
|
|
|
public static function getFilePath($sCodeName, $sExt) {
|
|
return self::GEO_FOLDER.$sCodeName.$sExt;
|
|
}
|
|
|
|
public function getLog() {
|
|
return $this->getCleanMessageStack(PhpObject::NOTICE_TAB);
|
|
}
|
|
}
|
|
|
|
class Gpx extends Geo {
|
|
|
|
const EXT = '.gpx';
|
|
|
|
public function __construct($sCodeName) {
|
|
parent::__construct($sCodeName);
|
|
$this->parseFile();
|
|
}
|
|
|
|
public function getTracks() {
|
|
return $this->asTracks;
|
|
}
|
|
|
|
private function parseFile() {
|
|
$this->addNotice('Parsing: '.$this->sFilePath);
|
|
$oXml = simplexml_load_file($this->sFilePath);
|
|
|
|
//Tracks
|
|
$this->addNotice('Converting '.count($oXml->trk).' tracks');
|
|
foreach($oXml->trk as $aoTrack) {
|
|
$asTrack = array(
|
|
'name' => (string) $aoTrack->name,
|
|
'desc' => str_replace("\n", '', ToolBox::fixEOL((strip_tags($aoTrack->desc)))),
|
|
'cmt' => ToolBox::fixEOL((strip_tags($aoTrack->cmt))),
|
|
'color' => (string) $aoTrack->extensions->children('gpxx', true)->TrackExtension->DisplayColor,
|
|
'points'=> array()
|
|
);
|
|
|
|
foreach($aoTrack->trkseg as $asSegment) {
|
|
foreach($asSegment as $asPoint) {
|
|
$asTrack['points'][] = array(
|
|
'lon' => (float) $asPoint['lon'],
|
|
'lat' => (float) $asPoint['lat'],
|
|
'ele' => (int) $asPoint->ele
|
|
);
|
|
}
|
|
}
|
|
$this->asTracks[] = $asTrack;
|
|
}
|
|
|
|
//Waypoints
|
|
$this->addNotice('Ignoring '.count($oXml->wpt).' waypoints');
|
|
}
|
|
}
|
|
|
|
class GeoJson extends Geo {
|
|
|
|
const EXT = '.geojson';
|
|
const MAX_FILESIZE = 2; //MB
|
|
const MAX_DEVIATION_FLAT = 0.1; //10%
|
|
const MAX_DEVIATION_ELEV = 0.1; //20%
|
|
|
|
public function __construct($sCodeName) {
|
|
parent::__construct($sCodeName);
|
|
}
|
|
|
|
public function saveFile() {
|
|
$this->addNotice('Saving '.$this->sFilePath);
|
|
file_put_contents($this->sFilePath, $this->buildGeoJson());
|
|
}
|
|
|
|
public function isSimplicationRequired() {
|
|
//Size in bytes
|
|
$iFileSize = strlen($this->buildGeoJson());
|
|
|
|
//Convert to MB
|
|
$iFileSize = round($iFileSize / pow(1024, 2), 2);
|
|
|
|
//Compare with max allowed size
|
|
$bFileTooLarge = ($iFileSize > self::MAX_FILESIZE);
|
|
if($bFileTooLarge) $this->addNotice('Output file is too large ('.$iFileSize.'MB > '.self::MAX_FILESIZE.'MB)');
|
|
|
|
return $bFileTooLarge;
|
|
}
|
|
|
|
public function buildTracks($asTracks, $bSimplify=false) {
|
|
$this->addNotice('Creating '.($bSimplify?'Simplified ':'').'GeoJson Tracks');
|
|
|
|
$iGlobalInvalidPointCount = 0;
|
|
$iGlobalPointCount = 0;
|
|
|
|
$this->asTracks = array();
|
|
foreach($asTracks as $asTrackProps) {
|
|
$asOptions = $this->parseOptions($asTrackProps['cmt']);
|
|
|
|
//Color mapping
|
|
switch($asTrackProps['color']) {
|
|
case 'DarkBlue':
|
|
$sType = 'main';
|
|
break;
|
|
case 'Magenta':
|
|
if($bSimplify && $asOptions[self::OPT_SIMPLE]!='keep') {
|
|
$this->addNotice('Ignoring Track "'.$asTrackProps['name'].' (off-track)');
|
|
continue 2; //discard tracks
|
|
}
|
|
else {
|
|
$sType = 'off-track';
|
|
break;
|
|
}
|
|
case 'Red':
|
|
$sType = 'hitchhiking';
|
|
break;
|
|
default:
|
|
$this->addNotice('Ignoring Track "'.$asTrackProps['name'].' (unknown color "'.$asTrackProps['color'].'")');
|
|
continue 2; //discard tracks
|
|
}
|
|
|
|
$asTrack = array(
|
|
'type' => 'Feature',
|
|
'properties' => array(
|
|
'name' => $asTrackProps['name'],
|
|
'type' => $sType,
|
|
'description' => $asTrackProps['desc']
|
|
),
|
|
'geometry' => array(
|
|
'type' => 'LineString',
|
|
'coordinates' => array()
|
|
)
|
|
);
|
|
|
|
//Track points
|
|
$asTrackPoints = $asTrackProps['points'];
|
|
$iPointCount = count($asTrackPoints);
|
|
$iInvalidPointCount = 0;
|
|
$asPrevPoint = array();
|
|
foreach($asTrackPoints as $iIndex=>$asPoint) {
|
|
$asNextPoint = ($iIndex < ($iPointCount - 1))?$asTrackPoints[$iIndex + 1]:array();
|
|
if($bSimplify && !empty($asPrevPoint) && !empty($asNextPoint)) {
|
|
if(!$this->isPointValid($asPrevPoint, $asPoint, $asNextPoint)) {
|
|
$iInvalidPointCount++;
|
|
continue;
|
|
}
|
|
}
|
|
$asTrack['geometry']['coordinates'][] = array_values($asPoint);
|
|
$asPrevPoint = $asPoint;
|
|
}
|
|
$this->asTracks[] = $asTrack;
|
|
|
|
$iGlobalInvalidPointCount += $iInvalidPointCount;
|
|
$iGlobalPointCount += $iPointCount;
|
|
if($iInvalidPointCount > 0) $this->addNotice('Removing '.$iInvalidPointCount.'/'.$iPointCount.' points ('.round($iInvalidPointCount / $iPointCount * 100, 1).'%) from '.$asTrackProps['name']);
|
|
}
|
|
|
|
if($bSimplify) $this->addNotice('Total: '.$iGlobalInvalidPointCount.'/'.$iGlobalPointCount.' points removed ('.round($iGlobalInvalidPointCount / $iGlobalPointCount * 100, 1).'%)');
|
|
}
|
|
|
|
private function parseOptions($sComment){
|
|
$asOptions = array(self::OPT_SIMPLE=>'');
|
|
foreach(explode("\n", $sComment) as $sLine) {
|
|
$asOptions[mb_strtolower(trim(mb_strstr($sLine, ':', true)))] = mb_strtolower(trim(mb_substr(mb_strstr($sLine, ':'), 1)));
|
|
}
|
|
return $asOptions;
|
|
}
|
|
|
|
private function isPointValid($asPointA, $asPointO, $asPointB) {
|
|
/* A----O Calculate angle AO^OB
|
|
* \ If angle is within [90% Pi ; 110% Pi], O can be discarded
|
|
* \ O is valid otherwise
|
|
* B
|
|
*/
|
|
|
|
//Path Turn Check -> -> -> ->
|
|
//Law of Cosines (vector): angle = arccos(OA.OB / ||OA||.||OB||)
|
|
$fVectorOA = array('lon'=>($asPointA['lon'] - $asPointO['lon']), 'lat'=> ($asPointA['lat'] - $asPointO['lat']));
|
|
$fVectorOB = array('lon'=>($asPointB['lon'] - $asPointO['lon']), 'lat'=> ($asPointB['lat'] - $asPointO['lat']));
|
|
|
|
$fLengthOA = sqrt(pow($asPointA['lon'] - $asPointO['lon'], 2) + pow($asPointA['lat'] - $asPointO['lat'], 2));
|
|
$fLengthOB = sqrt(pow($asPointO['lon'] - $asPointB['lon'], 2) + pow($asPointO['lat'] - $asPointB['lat'], 2));
|
|
|
|
$fVectorOAxOB = $fVectorOA['lon'] * $fVectorOB['lon'] + $fVectorOA['lat'] * $fVectorOB['lat'];
|
|
$fAngleAOB = acos($fVectorOAxOB/($fLengthOA * $fLengthOB));
|
|
|
|
//Elevation Check
|
|
//Law of Cosines: angle = arccos((OB² + AO² - AB²) / (2*OB*AO))
|
|
$fLengthAB = sqrt(pow($asPointB['ele'] - $asPointA['ele'], 2) + pow($fLengthOA + $fLengthOB, 2));
|
|
$fLengthAO = sqrt(pow($asPointO['ele'] - $asPointA['ele'], 2) + pow($fLengthOA, 2));
|
|
$fLengthOB = sqrt(pow($asPointB['ele'] - $asPointO['ele'], 2) + pow($fLengthOB, 2));
|
|
$fAngleAOBElev = acos((pow($fLengthOB, 2) + pow($fLengthAO, 2) - pow($fLengthAB, 2)) / (2 * $fLengthOB * $fLengthAO));
|
|
|
|
return ($fAngleAOB <= (1 - self::MAX_DEVIATION_FLAT) * M_PI || $fAngleAOB >= (1 + self::MAX_DEVIATION_FLAT) * M_PI ||
|
|
$fAngleAOBElev <= (1 - self::MAX_DEVIATION_ELEV) * M_PI || $fAngleAOBElev >= (1 + self::MAX_DEVIATION_ELEV) * M_PI);
|
|
}
|
|
|
|
private function buildGeoJson() {
|
|
return json_encode(array('features'=>$this->asTracks));
|
|
}
|
|
} |