lib/Geocode.php

   1 <?php
   2         class Geocode
   3         {
   4                 protected $oDB;
   5
   6                 protected $aLangPrefOrder = array();
   7
   8                 protected $bIncludeAddressDetails = false;
   9
  10                 protected $bIncludePolygonAsPoints = false;
  11                 protected $bIncludePolygonAsText = false;
  12                 protected $bIncludePolygonAsGeoJSON = false;
  13                 protected $bIncludePolygonAsKML = false;
  14                 protected $bIncludePolygonAsSVG = false;
  15
  16                 protected $aExcludePlaceIDs = array();
  17                 protected $bDeDupe = true;
  18                 protected $bReverseInPlan = false;
  19
  20                 protected $iLimit = 20;
  21                 protected $iFinalLimit = 10;
  22                 protected $iOffset = 0;
  23                 protected $bFallback = false;
  24
  25                 protected $aCountryCodes = false;
  26                 protected $aNearPoint = false;
  27
  28                 protected $bBoundedSearch = false;
  29                 protected $aViewBox = false;
  30                 protected $aRoutePoints = false;
  31
  32                 protected $iMaxRank = 20;
  33                 protected $iMinAddressRank = 0;
  34                 protected $iMaxAddressRank = 30;
  35                 protected $aAddressRankList = array();
  36                 protected $exactMatchCache = array();
  37
  38                 protected $sAllowedTypesSQLList = false;
  39
  40                 protected $sQuery = false;
  41                 protected $aStructuredQuery = false;
  42
  43                 function Geocode(&$oDB)
  44                 {
  45                         $this->oDB =& $oDB;
  46                 }
  47
  48                 function setReverseInPlan($bReverse)
  49                 {
  50                         $this->bReverseInPlan = $bReverse;
  51                 }
  52
  53                 function setLanguagePreference($aLangPref)
  54                 {
  55                         $this->aLangPrefOrder = $aLangPref;
  56                 }
  57
  58                 function setIncludeAddressDetails($bAddressDetails = true)
  59                 {
  60                         $this->bIncludeAddressDetails = (bool)$bAddressDetails;
  61                 }
  62
  63                 function getIncludeAddressDetails()
  64                 {
  65                         return $this->bIncludeAddressDetails;
  66                 }
  67
  68                 function setIncludePolygonAsPoints($b = true)
  69                 {
  70                         $this->bIncludePolygonAsPoints = $b;
  71                 }
  72
  73                 function getIncludePolygonAsPoints()
  74                 {
  75                         return $this->bIncludePolygonAsPoints;
  76                 }
  77
  78                 function setIncludePolygonAsText($b = true)
  79                 {
  80                         $this->bIncludePolygonAsText = $b;
  81                 }
  82
  83                 function getIncludePolygonAsText()
  84                 {
  85                         return $this->bIncludePolygonAsText;
  86                 }
  87
  88                 function setIncludePolygonAsGeoJSON($b = true)
  89                 {
  90                         $this->bIncludePolygonAsGeoJSON = $b;
  91                 }
  92
  93                 function setIncludePolygonAsKML($b = true)
  94                 {
  95                         $this->bIncludePolygonAsKML = $b;
  96                 }
  97
  98                 function setIncludePolygonAsSVG($b = true)
  99                 {
 100                         $this->bIncludePolygonAsSVG = $b;
 101                 }
 102
 103                 function setDeDupe($bDeDupe = true)
 104                 {
 105                         $this->bDeDupe = (bool)$bDeDupe;
 106                 }
 107
 108                 function setLimit($iLimit = 10)
 109                 {
 110                         if ($iLimit > 50) $iLimit = 50;
 111                         if ($iLimit < 1) $iLimit = 1;
 112
 113                         $this->iFinalLimit = $iLimit;
 114                         $this->iLimit = $this->iFinalLimit + min($this->iFinalLimit, 10);
 115                 }
 116
 117                 function setOffset($iOffset = 0)
 118                 {
 119                         $this->iOffset = $iOffset;
 120                 }
 121
 122                 function setFallback($bFallback = true)
 123                 {
 124                         $this->bFallback = (bool)$bFallback;
 125                 }
 126
 127                 function setExcludedPlaceIDs($a)
 128                 {
 129                         // TODO: force to int
 130                         $this->aExcludePlaceIDs = $a;
 131                 }
 132
 133                 function getExcludedPlaceIDs()
 134                 {
 135                         return $this->aExcludePlaceIDs;
 136                 }
 137
 138                 function setBounded($bBoundedSearch = true)
 139                 {
 140                         $this->bBoundedSearch = (bool)$bBoundedSearch;
 141                 }
 142
 143                 function setViewBox($fLeft, $fBottom, $fRight, $fTop)
 144                 {
 145                         $this->aViewBox = array($fLeft, $fBottom, $fRight, $fTop);
 146                 }
 147
 148                 function getViewBoxString()
 149                 {
 150                         if (!$this->aViewBox) return null;
 151                         return $this->aViewBox[0].','.$this->aViewBox[3].','.$this->aViewBox[2].','.$this->aViewBox[1];
 152                 }
 153
 154                 function setRoute($aRoutePoints)
 155                 {
 156                         $this->aRoutePoints = $aRoutePoints;
 157                 }
 158
 159                 function setFeatureType($sFeatureType)
 160                 {
 161                         switch($sFeatureType)
 162                         {
 163                         case 'country':
 164                                 $this->setRankRange(4, 4);
 165                                 break;
 166                         case 'state':
 167                                 $this->setRankRange(8, 8);
 168                                 break;
 169                         case 'city':
 170                                 $this->setRankRange(14, 16);
 171                                 break;
 172                         case 'settlement':
 173                                 $this->setRankRange(8, 20);
 174                                 break;
 175                         }
 176                 }
 177
 178                 function setRankRange($iMin, $iMax)
 179                 {
 180                         $this->iMinAddressRank = (int)$iMin;
 181                         $this->iMaxAddressRank = (int)$iMax;
 182                 }
 183
 184                 function setNearPoint($aNearPoint, $fRadiusDeg = 0.1)
 185                 {
 186                         $this->aNearPoint = array((float)$aNearPoint[0], (float)$aNearPoint[1], (float)$fRadiusDeg);
 187                 }
 188
 189                 function setCountryCodesList($aCountryCodes)
 190                 {
 191                         $this->aCountryCodes = $aCountryCodes;
 192                 }
 193
 194                 function setQuery($sQueryString)
 195                 {
 196                         $this->sQuery = $sQueryString;
 197                         $this->aStructuredQuery = false;
 198                 }
 199
 200                 function getQueryString()
 201                 {
 202                         return $this->sQuery;
 203                 }
 204
 205
 206                 function loadParamArray($aParams)
 207                 {
 208                         if (isset($aParams['addressdetails'])) $this->bIncludeAddressDetails = (bool)$aParams['addressdetails'];
 209                         if (isset($aParams['bounded'])) $this->bBoundedSearch = (bool)$aParams['bounded'];
 210                         if (isset($aParams['dedupe'])) $this->bDeDupe = (bool)$aParams['dedupe'];
 211
 212                         if (isset($aParams['limit'])) $this->setLimit((int)$aParams['limit']);
 213                         if (isset($aParams['offset'])) $this->iOffset = (int)$aParams['offset'];
 214
 215                         if (isset($aParams['fallback'])) $this->bFallback = (bool)$aParams['fallback'];
 216
 217                         // List of excluded Place IDs - used for more acurate pageing
 218                         if (isset($aParams['exclude_place_ids']) && $aParams['exclude_place_ids'])
 219                         {
 220                                 foreach(explode(',',$aParams['exclude_place_ids']) as $iExcludedPlaceID)
 221                                 {
 222                                         $iExcludedPlaceID = (int)$iExcludedPlaceID;
 223                                         if ($iExcludedPlaceID) $aExcludePlaceIDs[$iExcludedPlaceID] = $iExcludedPlaceID;
 224                                 }
 225                                 $this->aExcludePlaceIDs = $aExcludePlaceIDs;
 226                         }
 227
 228                         // Only certain ranks of feature
 229                         if (isset($aParams['featureType'])) $this->setFeatureType($aParams['featureType']);
 230                         if (isset($aParams['featuretype'])) $this->setFeatureType($aParams['featuretype']);
 231
 232                         // Country code list
 233                         if (isset($aParams['countrycodes']))
 234                         {
 235                                 $aCountryCodes = array();
 236                                 foreach(explode(',',$aParams['countrycodes']) as $sCountryCode)
 237                                 {
 238                                         if (preg_match('/^[a-zA-Z][a-zA-Z]$/', $sCountryCode))
 239                                         {
 240                                                 $aCountryCodes[] = strtolower($sCountryCode);
 241                                         }
 242                                 }
 243                                 $this->aCountryCodes = $aCountryCodes;
 244                         }
 245
 246                         if (isset($aParams['viewboxlbrt']) && $aParams['viewboxlbrt'])
 247                         {
 248                                 $aCoOrdinatesLBRT = explode(',',$aParams['viewboxlbrt']);
 249                                 $this->setViewBox($aCoOrdinatesLBRT[0], $aCoOrdinatesLBRT[1], $aCoOrdinatesLBRT[2], $aCoOrdinatesLBRT[3]);
 250                         }
 251                         else if (isset($aParams['viewbox']) && $aParams['viewbox'])
 252                         {
 253                                 $aCoOrdinatesLTRB = explode(',',$aParams['viewbox']);
 254                                 $this->setViewBox($aCoOrdinatesLTRB[0], $aCoOrdinatesLTRB[3], $aCoOrdinatesLTRB[2], $aCoOrdinatesLTRB[1]);
 255                         }
 256
 257                         if (isset($aParams['route']) && $aParams['route'] && isset($aParams['routewidth']) && $aParams['routewidth'])
 258                         {
 259                                 $aPoints = explode(',',$aParams['route']);
 260                                 if (sizeof($aPoints) % 2 != 0)
 261                                 {
 262                                         userError("Uneven number of points");
 263                                         exit;
 264                                 }
 265                                 $fPrevCoord = false;
 266                                 $aRoute = array();
 267                                 foreach($aPoints as $i => $fPoint)
 268                                 {
 269                                         if ($i%2)
 270                                         {
 271                                                 $aRoute[] = array((float)$fPoint, $fPrevCoord);
 272                                         }
 273                                         else
 274                                         {
 275                                                 $fPrevCoord = (float)$fPoint;
 276                                         }
 277                                 }
 278                                 $this->aRoutePoints = $aRoute;
 279                         }
 280                 }
 281
 282                 function setQueryFromParams($aParams)
 283                 {
 284                         // Search query
 285                         $sQuery = (isset($aParams['q'])?trim($aParams['q']):'');
 286                         if (!$sQuery)
 287                         {
 288                                 $this->setStructuredQuery(@$aParams['amenity'], @$aParams['street'], @$aParams['city'], @$aParams['county'], @$aParams['state'], @$aParams['country'], @$aParams['postalcode']);
 289                                 $this->setReverseInPlan(false);
 290                         }
 291                         else
 292                         {
 293                                 $this->setQuery($sQuery);
 294                         }
 295                 }
 296
 297                 function loadStructuredAddressElement($sValue, $sKey, $iNewMinAddressRank, $iNewMaxAddressRank, $aItemListValues)
 298                 {
 299                         $sValue = trim($sValue);
 300                         if (!$sValue) return false;
 301                         $this->aStructuredQuery[$sKey] = $sValue;
 302                         if ($this->iMinAddressRank == 0 && $this->iMaxAddressRank == 30)
 303                         {
 304                                 $this->iMinAddressRank = $iNewMinAddressRank;
 305                                 $this->iMaxAddressRank = $iNewMaxAddressRank;
 306                         }
 307                         if ($aItemListValues) $this->aAddressRankList = array_merge($this->aAddressRankList, $aItemListValues);
 308                         return true;
 309                 }
 310
 311                 function setStructuredQuery($sAmentiy = false, $sStreet = false, $sCity = false, $sCounty = false, $sState = false, $sCountry = false, $sPostalCode = false)
 312                 {
 313                         $this->sQuery = false;
 314
 315                         // Reset
 316                         $this->iMinAddressRank = 0;
 317                         $this->iMaxAddressRank = 30;
 318                         $this->aAddressRankList = array();
 319
 320                         $this->aStructuredQuery = array();
 321                         $this->sAllowedTypesSQLList = '';
 322
 323                         $this->loadStructuredAddressElement($sAmentiy, 'amenity', 26, 30, false);
 324                         $this->loadStructuredAddressElement($sStreet, 'street', 26, 30, false);
 325                         $this->loadStructuredAddressElement($sCity, 'city', 14, 24, false);
 326                         $this->loadStructuredAddressElement($sCounty, 'county', 9, 13, false);
 327                         $this->loadStructuredAddressElement($sState, 'state', 8, 8, false);
 328                         $this->loadStructuredAddressElement($sPostalCode, 'postalcode' , 5, 11, array(5, 11));
 329                         $this->loadStructuredAddressElement($sCountry, 'country', 4, 4, false);
 330
 331                         if (sizeof($this->aStructuredQuery) > 0)
 332                         {
 333                                 $this->sQuery = join(', ', $this->aStructuredQuery);
 334                                 if ($this->iMaxAddressRank < 30)
 335                                 {
 336                                         $sAllowedTypesSQLList = '(\'place\',\'boundary\')';
 337                                 }
 338                         }
 339                 }
 340
 341                 function fallbackStructuredQuery()
 342                 {
 343                         if (!$this->aStructuredQuery) return false;
 344
 345                         $aParams = $this->aStructuredQuery;
 346
 347                         if (sizeof($aParams) == 1) return false;
 348
 349                         $aOrderToFallback = array('postalcode', 'street', 'city', 'county', 'state');
 350
 351                         foreach($aOrderToFallback as $sType)
 352                         {
 353                                 if (isset($aParams[$sType]))
 354                                 {
 355                                         unset($aParams[$sType]);
 356                                         $this->setStructuredQuery(@$aParams['amenity'], @$aParams['street'], @$aParams['city'], @$aParams['county'], @$aParams['state'], @$aParams['country'], @$aParams['postalcode']);
 357                                         return true;
 358                                 }
 359                         }
 360
 361                         return false;
 362                 }
 363
 364                 function getDetails($aPlaceIDs)
 365                 {
 366                         if (sizeof($aPlaceIDs) == 0)  return array();
 367
 368                         $sLanguagePrefArraySQL = "ARRAY[".join(',',array_map("getDBQuoted",$this->aLangPrefOrder))."]";
 369
 370                         // Get the details for display (is this a redundant extra step?)
 371                         $sPlaceIDs = join(',',$aPlaceIDs);
 372
 373                         $sSQL = "select osm_type,osm_id,class,type,admin_level,rank_search,rank_address,min(place_id) as place_id, min(parent_place_id) as parent_place_id, calculated_country_code as country_code,";
 374                         $sSQL .= "get_address_by_language(place_id, $sLanguagePrefArraySQL) as langaddress,";
 375                         $sSQL .= "get_name_by_language(name, $sLanguagePrefArraySQL) as placename,";
 376                         $sSQL .= "get_name_by_language(name, ARRAY['ref']) as ref,";
 377                         $sSQL .= "avg(ST_X(centroid)) as lon,avg(ST_Y(centroid)) as lat, ";
 378                         $sSQL .= "coalesce(importance,0.75-(rank_search::float/40)) as importance, ";
 379                         $sSQL .= "(select max(p.importance*(p.rank_address+2)) from place_addressline s, placex p where s.place_id = min(CASE WHEN placex.rank_search < 28 THEN placex.place_id ELSE placex.parent_place_id END) and p.place_id = s.address_place_id and s.isaddress and p.importance is not null) as addressimportance, ";
 380                         $sSQL .= "(extratags->'place') as extra_place ";
 381                         $sSQL .= "from placex where place_id in ($sPlaceIDs) ";
 382                         $sSQL .= "and (placex.rank_address between $this->iMinAddressRank and $this->iMaxAddressRank ";
 383                         if (14 >= $this->iMinAddressRank && 14 <= $this->iMaxAddressRank) $sSQL .= " OR (extratags->'place') = 'city'";
 384                         if ($this->aAddressRankList) $sSQL .= " OR placex.rank_address in (".join(',',$this->aAddressRankList).")";
 385                         $sSQL .= ") ";
 386                         if ($this->sAllowedTypesSQLList) $sSQL .= "and placex.class in $this->sAllowedTypesSQLList ";
 387                         $sSQL .= "and linked_place_id is null ";
 388                         $sSQL .= "group by osm_type,osm_id,class,type,admin_level,rank_search,rank_address,calculated_country_code,importance";
 389                         if (!$this->bDeDupe) $sSQL .= ",place_id";
 390                         $sSQL .= ",langaddress ";
 391                         $sSQL .= ",placename ";
 392                         $sSQL .= ",ref ";
 393                         $sSQL .= ",extratags->'place' ";
 394
 395                         if (30 >= $this->iMinAddressRank && 30 <= $this->iMaxAddressRank)
 396                         {
 397                                 $sSQL .= " union ";
 398                                 $sSQL .= "select 'T' as osm_type,place_id as osm_id,'place' as class,'house' as type,null as admin_level,30 as rank_search,30 as rank_address,min(place_id) as place_id, min(parent_place_id) as parent_place_id,'us' as country_code,";
 399                                 $sSQL .= "get_address_by_language(place_id, $sLanguagePrefArraySQL) as langaddress,";
 400                                 $sSQL .= "null as placename,";
 401                                 $sSQL .= "null as ref,";
 402                                 $sSQL .= "avg(ST_X(centroid)) as lon,avg(ST_Y(centroid)) as lat, ";
 403                                 $sSQL .= "-0.15 as importance, ";
 404                                 $sSQL .= "(select max(p.importance*(p.rank_address+2)) from place_addressline s, placex p where s.place_id = min(location_property_tiger.parent_place_id) and p.place_id = s.address_place_id and s.isaddress and p.importance is not null) as addressimportance, ";
 405                                 $sSQL .= "null as extra_place ";
 406                                 $sSQL .= "from location_property_tiger where place_id in ($sPlaceIDs) ";
 407                                 $sSQL .= "and 30 between $this->iMinAddressRank and $this->iMaxAddressRank ";
 408                                 $sSQL .= "group by place_id";
 409                                 if (!$this->bDeDupe) $sSQL .= ",place_id";
 410                                 $sSQL .= " union ";
 411                                 $sSQL .= "select 'L' as osm_type,place_id as osm_id,'place' as class,'house' as type,null as admin_level,30 as rank_search,30 as rank_address,min(place_id) as place_id, min(parent_place_id) as parent_place_id,'us' as country_code,";
 412                                 $sSQL .= "get_address_by_language(place_id, $sLanguagePrefArraySQL) as langaddress,";
 413                                 $sSQL .= "null as placename,";
 414                                 $sSQL .= "null as ref,";
 415                                 $sSQL .= "avg(ST_X(centroid)) as lon,avg(ST_Y(centroid)) as lat, ";
 416                                 $sSQL .= "-0.10 as importance, ";
 417                                 $sSQL .= "(select max(p.importance*(p.rank_address+2)) from place_addressline s, placex p where s.place_id = min(location_property_aux.parent_place_id) and p.place_id = s.address_place_id and s.isaddress and p.importance is not null) as addressimportance, ";
 418                                 $sSQL .= "null as extra_place ";
 419                                 $sSQL .= "from location_property_aux where place_id in ($sPlaceIDs) ";
 420                                 $sSQL .= "and 30 between $this->iMinAddressRank and $this->iMaxAddressRank ";
 421                                 $sSQL .= "group by place_id";
 422                                 if (!$this->bDeDupe) $sSQL .= ",place_id";
 423                                 $sSQL .= ",get_address_by_language(place_id, $sLanguagePrefArraySQL) ";
 424                         }
 425
 426                         $sSQL .= "order by importance desc";
 427                         if (CONST_Debug) { echo "<hr>"; var_dump($sSQL); }
 428                         $aSearchResults = $this->oDB->getAll($sSQL);
 429
 430                         if (PEAR::IsError($aSearchResults))
 431                         {
 432                                 failInternalError("Could not get details for place.", $sSQL, $aSearchResults);
 433                         }
 434
 435                         return $aSearchResults;
 436                 }
 437
 438                 /* Perform the actual query lookup.
 439
 440                         Returns an ordered list of results, each with the following fields:
 441                           osm_type: type of corresponding OSM object
 442                                                         N - node
 443                                                         W - way
 444                                                         R - relation
 445                                                         P - postcode (internally computed)
 446                           osm_id: id of corresponding OSM object
 447                           class: general object class (corresponds to tag key of primary OSM tag)
 448                           type: subclass of object (corresponds to tag value of primary OSM tag)
 449                           admin_level: see http://wiki.openstreetmap.org/wiki/Admin_level
 450                           rank_search: rank in search hierarchy
 451                                                         (see also http://wiki.openstreetmap.org/wiki/Nominatim/Development_overview#Country_to_street_level)
 452                           rank_address: rank in address hierarchy (determines orer in address)
 453                           place_id: internal key (may differ between different instances)
 454                           country_code: ISO country code
 455                           langaddress: localized full address
 456                           placename: localized name of object
 457                           ref: content of ref tag (if available)
 458                           lon: longitude
 459                           lat: latitude
 460                           importance: importance of place based on Wikipedia link count
 461                           addressimportance: cumulated importance of address elements
 462                           extra_place: type of place (for admin boundaries, if there is a place tag)
 463                           aBoundingBox: bounding Box
 464                           label: short description of the object class/type (English only)
 465                           name: full name (currently the same as langaddress)
 466                           foundorder: secondary ordering for places with same importance
 467                 */
 468                 function lookup()
 469                 {
 470                         if (!$this->sQuery && !$this->aStructuredQuery) return false;
 471
 472                         $sLanguagePrefArraySQL = "ARRAY[".join(',',array_map("getDBQuoted",$this->aLangPrefOrder))."]";
 473
 474                         $sCountryCodesSQL = false;
 475                         if ($this->aCountryCodes && sizeof($this->aCountryCodes))
 476                         {
 477                                 $sCountryCodesSQL = join(',', array_map('addQuotes', $this->aCountryCodes));
 478                         }
 479
 480                         // Hack to make it handle "new york, ny" (and variants) correctly
 481                         $sQuery = str_ireplace(array('New York, ny','new york, new york', 'New York ny','new york new york'), 'new york city, ny', $this->sQuery);
 482
 483                         // Conflicts between US state abreviations and various words for 'the' in different languages
 484                         if (isset($this->aLangPrefOrder['name:en']))
 485                         {
 486                                 $sQuery = preg_replace('/,\s*il\s*(,|$)/',', illinois\1', $sQuery);
 487                                 $sQuery = preg_replace('/,\s*al\s*(,|$)/',', alabama\1', $sQuery);
 488                                 $sQuery = preg_replace('/,\s*la\s*(,|$)/',', louisiana\1', $sQuery);
 489                         }
 490
 491                         // View Box SQL
 492                         $sViewboxCentreSQL = $sViewboxSmallSQL = $sViewboxLargeSQL = false;
 493                         $bBoundingBoxSearch = false;
 494                         if ($this->aViewBox)
 495                         {
 496                                 $fHeight = $this->aViewBox[0]-$this->aViewBox[2];
 497                                 $fWidth = $this->aViewBox[1]-$this->aViewBox[3];
 498                                 $aBigViewBox[0] = $this->aViewBox[0] + $fHeight;
 499                                 $aBigViewBox[2] = $this->aViewBox[2] - $fHeight;
 500                                 $aBigViewBox[1] = $this->aViewBox[1] + $fWidth;
 501                                 $aBigViewBox[3] = $this->aViewBox[3] - $fWidth;
 502
 503                                 $sViewboxSmallSQL = "ST_SetSRID(ST_MakeBox2D(ST_Point(".(float)$this->aViewBox[0].",".(float)$this->aViewBox[1]."),ST_Point(".(float)$this->aViewBox[2].",".(float)$this->aViewBox[3].")),4326)";
 504                                 $sViewboxLargeSQL = "ST_SetSRID(ST_MakeBox2D(ST_Point(".(float)$aBigViewBox[0].",".(float)$aBigViewBox[1]."),ST_Point(".(float)$aBigViewBox[2].",".(float)$aBigViewBox[3].")),4326)";
 505                                 $bBoundingBoxSearch = $this->bBoundedSearch;
 506                         }
 507
 508                         // Route SQL
 509                         if ($this->aRoutePoints)
 510                         {
 511                                 $sViewboxCentreSQL = "ST_SetSRID('LINESTRING(";
 512                                 $bFirst = true;
 513                                 foreach($this->aRoutePoints as $aPoint)
 514                                 {
 515                                         if (!$bFirst) $sViewboxCentreSQL .= ",";
 516                                         $sViewboxCentreSQL .= $aPoint[1].' '.$aPoint[0];
 517                                         $bFirst = false;
 518                                 }
 519                                 $sViewboxCentreSQL .= ")'::geometry,4326)";
 520
 521                                 $sSQL = "select st_buffer(".$sViewboxCentreSQL.",".(float)($_GET['routewidth']/69).")";
 522                                 $sViewboxSmallSQL = $this->oDB->getOne($sSQL);
 523                                 if (PEAR::isError($sViewboxSmallSQL))
 524                                 {
 525                                         failInternalError("Could not get small viewbox.", $sSQL, $sViewboxSmallSQL);
 526                                 }
 527                                 $sViewboxSmallSQL = "'".$sViewboxSmallSQL."'::geometry";
 528
 529                                 $sSQL = "select st_buffer(".$sViewboxCentreSQL.",".(float)($_GET['routewidth']/30).")";
 530                                 $sViewboxLargeSQL = $this->oDB->getOne($sSQL);
 531                                 if (PEAR::isError($sViewboxLargeSQL))
 532                                 {
 533                                         failInternalError("Could not get large viewbox.", $sSQL, $sViewboxLargeSQL);
 534                                 }
 535                                 $sViewboxLargeSQL = "'".$sViewboxLargeSQL."'::geometry";
 536                                 $bBoundingBoxSearch = $this->bBoundedSearch;
 537                         }
 538
 539                         // Do we have anything that looks like a lat/lon pair?
 540                         if (preg_match('/\\b([NS])[ ]+([0-9]+[0-9.]*)[ ]+([0-9.]+)?[, ]+([EW])[ ]+([0-9]+)[ ]+([0-9]+[0-9.]*)?\\b/', $sQuery, $aData))
 541                         {
 542                                 $fQueryLat = ($aData[1]=='N'?1:-1) * ($aData[2] + $aData[3]/60);
 543                                 $fQueryLon = ($aData[4]=='E'?1:-1) * ($aData[5] + $aData[6]/60);
 544                                 if ($fQueryLat <= 90.1 && $fQueryLat >= -90.1 && $fQueryLon <= 180.1 && $fQueryLon >= -180.1)
 545                                 {
 546                                         $this->setNearPoint(array($fQueryLat, $fQueryLon));
 547                                         $sQuery = trim(str_replace($aData[0], ' ', $sQuery));
 548                                 }
 549                         }
 550                         elseif (preg_match('/\\b([0-9]+)[ ]+([0-9]+[0-9.]*)?[ ]+([NS])[, ]+([0-9]+)[ ]+([0-9]+[0-9.]*)?[ ]+([EW])\\b/', $sQuery, $aData))
 551                         {
 552                                 $fQueryLat = ($aData[3]=='N'?1:-1) * ($aData[1] + $aData[2]/60);
 553                                 $fQueryLon = ($aData[6]=='E'?1:-1) * ($aData[4] + $aData[5]/60);
 554                                 if ($fQueryLat <= 90.1 && $fQueryLat >= -90.1 && $fQueryLon <= 180.1 && $fQueryLon >= -180.1)
 555                                 {
 556                                         $this->setNearPoint(array($fQueryLat, $fQueryLon));
 557                                         $sQuery = trim(str_replace($aData[0], ' ', $sQuery));
 558                                 }
 559                         }
 560                         elseif (preg_match('/(\\[|^|\\b)(-?[0-9]+[0-9]*\\.[0-9]+)[, ]+(-?[0-9]+[0-9]*\\.[0-9]+)(\\]|$|\\b)/', $sQuery, $aData))
 561                         {
 562                                 $fQueryLat = $aData[2];
 563                                 $fQueryLon = $aData[3];
 564                                 if ($fQueryLat <= 90.1 && $fQueryLat >= -90.1 && $fQueryLon <= 180.1 && $fQueryLon >= -180.1)
 565                                 {
 566                                         $this->setNearPoint(array($fQueryLat, $fQueryLon));
 567                                         $sQuery = trim(str_replace($aData[0], ' ', $sQuery));
 568                                 }
 569                         }
 570
 571                         $aSearchResults = array();
 572                         if ($sQuery || $this->aStructuredQuery)
 573                         {
 574                                 // Start with a blank search
 575                                 $aSearches = array(
 576                                         array('iSearchRank' => 0, 'iNamePhrase' => -1, 'sCountryCode' => false, 'aName'=>array(), 'aAddress'=>array(), 'aFullNameAddress'=>array(),
 577                                               'aNameNonSearch'=>array(), 'aAddressNonSearch'=>array(),
 578                                               'sOperator'=>'', 'aFeatureName' => array(), 'sClass'=>'', 'sType'=>'', 'sHouseNumber'=>'', 'fLat'=>'', 'fLon'=>'', 'fRadius'=>'')
 579                                 );
 580
 581                                 // Do we have a radius search?
 582                                 $sNearPointSQL = false;
 583                                 if ($this->aNearPoint)
 584                                 {
 585                                         $sNearPointSQL = "ST_SetSRID(ST_Point(".(float)$this->aNearPoint[1].",".(float)$this->aNearPoint[0]."),4326)";
 586                                         $aSearches[0]['fLat'] = (float)$this->aNearPoint[0];
 587                                         $aSearches[0]['fLon'] = (float)$this->aNearPoint[1];
 588                                         $aSearches[0]['fRadius'] = (float)$this->aNearPoint[2];
 589                                 }
 590
 591                                 // Any 'special' terms in the search?
 592                                 $bSpecialTerms = false;
 593                                 preg_match_all('/\\[(.*)=(.*)\\]/', $sQuery, $aSpecialTermsRaw, PREG_SET_ORDER);
 594                                 $aSpecialTerms = array();
 595                                 foreach($aSpecialTermsRaw as $aSpecialTerm)
 596                                 {
 597                                         $sQuery = str_replace($aSpecialTerm[0], ' ', $sQuery);
 598                                         $aSpecialTerms[strtolower($aSpecialTerm[1])] = $aSpecialTerm[2];
 599                                 }
 600
 601                                 preg_match_all('/\\[([\\w ]*)\\]/u', $sQuery, $aSpecialTermsRaw, PREG_SET_ORDER);
 602                                 $aSpecialTerms = array();
 603                                 if (isset($aStructuredQuery['amenity']) && $aStructuredQuery['amenity'])
 604                                 {
 605                                         $aSpecialTermsRaw[] = array('['.$aStructuredQuery['amenity'].']', $aStructuredQuery['amenity']);
 606                                         unset($aStructuredQuery['amenity']);
 607                                 }
 608                                 foreach($aSpecialTermsRaw as $aSpecialTerm)
 609                                 {
 610                                         $sQuery = str_replace($aSpecialTerm[0], ' ', $sQuery);
 611                                         $sToken = $this->oDB->getOne("select make_standard_name('".$aSpecialTerm[1]."') as string");
 612                                         $sSQL = 'select * from (select word_id,word_token, word, class, type, country_code, operator';
 613                                         $sSQL .= ' from word where word_token in (\' '.$sToken.'\')) as x where (class is not null and class not in (\'place\')) or country_code is not null';
 614                                         if (CONST_Debug) var_Dump($sSQL);
 615                                         $aSearchWords = $this->oDB->getAll($sSQL);
 616                                         $aNewSearches = array();
 617                                         foreach($aSearches as $aSearch)
 618                                         {
 619                                                 foreach($aSearchWords as $aSearchTerm)
 620                                                 {
 621                                                         $aNewSearch = $aSearch;
 622                                                         if ($aSearchTerm['country_code'])
 623                                                         {
 624                                                                 $aNewSearch['sCountryCode'] = strtolower($aSearchTerm['country_code']);
 625                                                                 $aNewSearches[] = $aNewSearch;
 626                                                                 $bSpecialTerms = true;
 627                                                         }
 628                                                         if ($aSearchTerm['class'])
 629                                                         {
 630                                                                 $aNewSearch['sClass'] = $aSearchTerm['class'];
 631                                                                 $aNewSearch['sType'] = $aSearchTerm['type'];
 632                                                                 $aNewSearches[] = $aNewSearch;
 633                                                                 $bSpecialTerms = true;
 634                                                         }
 635                                                 }
 636                                         }
 637                                         $aSearches = $aNewSearches;
 638                                 }
 639
 640                                 // Split query into phrases
 641                                 // Commas are used to reduce the search space by indicating where phrases split
 642                                 if ($this->aStructuredQuery)
 643                                 {
 644                                         $aPhrases = $this->aStructuredQuery;
 645                                         $bStructuredPhrases = true;
 646                                 }
 647                                 else
 648                                 {
 649                                         $aPhrases = explode(',',$sQuery);
 650                                         $bStructuredPhrases = false;
 651                                 }
 652
 653                                 // Convert each phrase to standard form
 654                                 // Create a list of standard words
 655                                 // Get all 'sets' of words
 656                                 // Generate a complete list of all
 657                                 $aTokens = array();
 658                                 foreach($aPhrases as $iPhrase => $sPhrase)
 659                                 {
 660                                         $aPhrase = $this->oDB->getRow("select make_standard_name('".pg_escape_string($sPhrase)."') as string");
 661                                         if (PEAR::isError($aPhrase))
 662                                         {
 663                                                 userError("Illegal query string (not an UTF-8 string): ".$sPhrase);
 664                                                 if (CONST_Debug) var_dump($aPhrase);
 665                                                 exit;
 666                                         }
 667                                         if (trim($aPhrase['string']))
 668                                         {
 669                                                 $aPhrases[$iPhrase] = $aPhrase;
 670                                                 $aPhrases[$iPhrase]['words'] = explode(' ',$aPhrases[$iPhrase]['string']);
 671                                                 $aPhrases[$iPhrase]['wordsets'] = getWordSets($aPhrases[$iPhrase]['words'], 0);
 672                                                 $aTokens = array_merge($aTokens, getTokensFromSets($aPhrases[$iPhrase]['wordsets']));
 673                                         }
 674                                         else
 675                                         {
 676                                                 unset($aPhrases[$iPhrase]);
 677                                         }
 678                                 }
 679
 680                                 // Reindex phrases - we make assumptions later on that they are numerically keyed in order
 681                                 $aPhraseTypes = array_keys($aPhrases);
 682                                 $aPhrases = array_values($aPhrases);
 683
 684                                 if (sizeof($aTokens))
 685                                 {
 686                                         // Check which tokens we have, get the ID numbers
 687                                         $sSQL = 'select word_id,word_token, word, class, type, country_code, operator, search_name_count';
 688                                         $sSQL .= ' from word where word_token in ('.join(',',array_map("getDBQuoted",$aTokens)).')';
 689
 690                                         if (CONST_Debug) var_Dump($sSQL);
 691
 692                                         $aValidTokens = array();
 693                                         if (sizeof($aTokens)) $aDatabaseWords = $this->oDB->getAll($sSQL);
 694                                         else $aDatabaseWords = array();
 695                                         if (PEAR::IsError($aDatabaseWords))
 696                                         {
 697                                                 failInternalError("Could not get word tokens.", $sSQL, $aDatabaseWords);
 698                                         }
 699                                         $aPossibleMainWordIDs = array();
 700                                         $aWordFrequencyScores = array();
 701                                         foreach($aDatabaseWords as $aToken)
 702                                         {
 703                                                 // Very special case - require 2 letter country param to match the country code found
 704                                                 if ($bStructuredPhrases && $aToken['country_code'] && !empty($aStructuredQuery['country'])
 705                                                                 && strlen($aStructuredQuery['country']) == 2 && strtolower($aStructuredQuery['country']) != $aToken['country_code'])
 706                                                 {
 707                                                         continue;
 708                                                 }
 709
 710                                                 if (isset($aValidTokens[$aToken['word_token']]))
 711                                                 {
 712                                                         $aValidTokens[$aToken['word_token']][] = $aToken;
 713                                                 }
 714                                                 else
 715                                                 {
 716                                                         $aValidTokens[$aToken['word_token']] = array($aToken);
 717                                                 }
 718                                                 if (!$aToken['class'] && !$aToken['country_code']) $aPossibleMainWordIDs[$aToken['word_id']] = 1;
 719                                                 $aWordFrequencyScores[$aToken['word_id']] = $aToken['search_name_count'] + 1;
 720                                         }
 721                                         if (CONST_Debug) var_Dump($aPhrases, $aValidTokens);
 722
 723                                         // Try and calculate GB postcodes we might be missing
 724                                         foreach($aTokens as $sToken)
 725                                         {
 726                                                 // Source of gb postcodes is now definitive - always use
 727                                                 if (preg_match('/^([A-Z][A-Z]?[0-9][0-9A-Z]? ?[0-9])([A-Z][A-Z])$/', strtoupper(trim($sToken)), $aData))
 728                                                 {
 729                                                         if (substr($aData[1],-2,1) != ' ')
 730                                                         {
 731                                                                 $aData[0] = substr($aData[0],0,strlen($aData[1]-1)).' '.substr($aData[0],strlen($aData[1]-1));
 732                                                                 $aData[1] = substr($aData[1],0,-1).' '.substr($aData[1],-1,1);
 733                                                         }
 734                                                         $aGBPostcodeLocation = gbPostcodeCalculate($aData[0], $aData[1], $aData[2], $this->oDB);
 735                                                         if ($aGBPostcodeLocation)
 736                                                         {
 737                                                                 $aValidTokens[$sToken] = $aGBPostcodeLocation;
 738                                                         }
 739                                                 }
 740                                                 // US ZIP+4 codes - if there is no token,
 741                                                 //      merge in the 5-digit ZIP code
 742                                                 else if (!isset($aValidTokens[$sToken]) && preg_match('/^([0-9]{5}) [0-9]{4}$/', $sToken, $aData))
 743                                                 {
 744                                                         if (isset($aValidTokens[$aData[1]]))
 745                                                         {
 746                                                                 foreach($aValidTokens[$aData[1]] as $aToken)
 747                                                                 {
 748                                                                         if (!$aToken['class'])
 749                                                                         {
 750                                                                                 if (isset($aValidTokens[$sToken]))
 751                                                                                 {
 752                                                                                         $aValidTokens[$sToken][] = $aToken;
 753                                                                                 }
 754                                                                                 else
 755                                                                                 {
 756                                                                                         $aValidTokens[$sToken] = array($aToken);
 757                                                                                 }
 758                                                                         }
 759                                                                 }
 760                                                         }
 761                                                 }
 762                                         }
 763
 764                                         foreach($aTokens as $sToken)
 765                                         {
 766                                                 // Unknown single word token with a number - assume it is a house number
 767                                                 if (!isset($aValidTokens[' '.$sToken]) && strpos($sToken,' ') === false && preg_match('/[0-9]/', $sToken))
 768                                                 {
 769                                                         $aValidTokens[' '.$sToken] = array(array('class'=>'place','type'=>'house'));
 770                                                 }
 771                                         }
 772
 773                                         // Any words that have failed completely?
 774                                         // TODO: suggestions
 775
 776                                         // Start the search process
 777                                         $aResultPlaceIDs = array();
 778
 779                                         /*
 780                                            Calculate all searches using aValidTokens i.e.
 781                                            'Wodsworth Road, Sheffield' =>
 782
 783                                            Phrase Wordset
 784                                            0      0       (wodsworth road)
 785                                            0      1       (wodsworth)(road)
 786                                            1      0       (sheffield)
 787
 788                                            Score how good the search is so they can be ordered
 789                                          */
 790                                         foreach($aPhrases as $iPhrase => $sPhrase)
 791                                         {
 792                                                 $aNewPhraseSearches = array();
 793                                                 if ($bStructuredPhrases) $sPhraseType = $aPhraseTypes[$iPhrase];
 794                                                 else $sPhraseType = '';
 795
 796                                                 foreach($aPhrases[$iPhrase]['wordsets'] as $iWordSet => $aWordset)
 797                                                 {
 798                                                         // Too many permutations - too expensive
 799                                                         if ($iWordSet > 120) break;
 800
 801                                                         $aWordsetSearches = $aSearches;
 802
 803                                                         // Add all words from this wordset
 804                                                         foreach($aWordset as $iToken => $sToken)
 805                                                         {
 806                                                                 //echo "<br><b>$sToken</b>";
 807                                                                 $aNewWordsetSearches = array();
 808
 809                                                                 foreach($aWordsetSearches as $aCurrentSearch)
 810                                                                 {
 811                                                                         //echo "<i>";
 812                                                                         //var_dump($aCurrentSearch);
 813                                                                         //echo "</i>";
 814
 815                                                                         // If the token is valid
 816                                                                         if (isset($aValidTokens[' '.$sToken]))
 817                                                                         {
 818                                                                                 foreach($aValidTokens[' '.$sToken] as $aSearchTerm)
 819                                                                                 {
 820                                                                                         $aSearch = $aCurrentSearch;
 821                                                                                         $aSearch['iSearchRank']++;
 822                                                                                         if (($sPhraseType == '' || $sPhraseType == 'country') && !empty($aSearchTerm['country_code']) && $aSearchTerm['country_code'] != '0')
 823                                                                                         {
 824                                                                                                 if ($aSearch['sCountryCode'] === false)
 825                                                                                                 {
 826                                                                                                         $aSearch['sCountryCode'] = strtolower($aSearchTerm['country_code']);
 827                                                                                                         // Country is almost always at the end of the string - increase score for finding it anywhere else (optimisation)
 828                                                                                                         // If reverse order is enabled, it may appear at the beginning as well.
 829                                                                                                         if (($iToken+1 != sizeof($aWordset) || $iPhrase+1 != sizeof($aPhrases)) &&
 830                                                                                                                         (!$this->bReverseInPlan || $iToken > 0 || $iPhrase > 0))
 831                                                                                                         {
 832                                                                                                                 $aSearch['iSearchRank'] += 5;
 833                                                                                                         }
 834                                                                                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
 835                                                                                                 }
 836                                                                                         }
 837                                                                                         elseif (isset($aSearchTerm['lat']) && $aSearchTerm['lat'] !== '' && $aSearchTerm['lat'] !== null)
 838                                                                                         {
 839                                                                                                 if ($aSearch['fLat'] === '')
 840                                                                                                 {
 841                                                                                                         $aSearch['fLat'] = $aSearchTerm['lat'];
 842                                                                                                         $aSearch['fLon'] = $aSearchTerm['lon'];
 843                                                                                                         $aSearch['fRadius'] = $aSearchTerm['radius'];
 844                                                                                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
 845                                                                                                 }
 846                                                                                         }
 847                                                                                         elseif ($sPhraseType == 'postalcode')
 848                                                                                         {
 849                                                                                                 // We need to try the case where the postal code is the primary element (i.e. no way to tell if it is (postalcode, city) OR (city, postalcode) so try both
 850                                                                                                 if (isset($aSearchTerm['word_id']) && $aSearchTerm['word_id'])
 851                                                                                                 {
 852                                                                                                         // If we already have a name try putting the postcode first
 853                                                                                                         if (sizeof($aSearch['aName']))
 854                                                                                                         {
 855                                                                                                                 $aNewSearch = $aSearch;
 856                                                                                                                 $aNewSearch['aAddress'] = array_merge($aNewSearch['aAddress'], $aNewSearch['aName']);
 857                                                                                                                 $aNewSearch['aName'] = array();
 858                                                                                                                 $aNewSearch['aName'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
 859                                                                                                                 if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aNewSearch;
 860                                                                                                         }
 861
 862                                                                                                         if (sizeof($aSearch['aName']))
 863                                                                                                         {
 864                                                                                                                 if ((!$bStructuredPhrases || $iPhrase > 0) && $sPhraseType != 'country' && (!isset($aValidTokens[$sToken]) || strlen($sToken) < 4 || strpos($sToken, ' ') !== false))
 865                                                                                                                 {
 866                                                                                                                         $aSearch['aAddress'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
 867                                                                                                                 }
 868                                                                                                                 else
 869                                                                                                                 {
 870                                                                                                                         $aCurrentSearch['aFullNameAddress'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
 871                                                                                                                         $aSearch['iSearchRank'] += 1000; // skip;
 872                                                                                                                 }
 873                                                                                                         }
 874                                                                                                         else
 875                                                                                                         {
 876                                                                                                                 $aSearch['aName'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
 877                                                                                                                 //$aSearch['iNamePhrase'] = $iPhrase;
 878                                                                                                         }
 879                                                                                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
 880                                                                                                 }
 881
 882                                                                                         }
 883                                                                                         elseif (($sPhraseType == '' || $sPhraseType == 'street') && $aSearchTerm['class'] == 'place' && $aSearchTerm['type'] == 'house')
 884                                                                                         {
 885                                                                                                 if ($aSearch['sHouseNumber'] === '')
 886                                                                                                 {
 887                                                                                                         $aSearch['sHouseNumber'] = $sToken;
 888                                                                                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
 889                                                                                                         /*
 890                                                                                                         // Fall back to not searching for this item (better than nothing)
 891                                                                                                         $aSearch = $aCurrentSearch;
 892                                                                                                         $aSearch['iSearchRank'] += 1;
 893                                                                                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
 894                                                                                                          */
 895                                                                                                 }
 896                                                                                         }
 897                                                                                         elseif ($sPhraseType == '' && $aSearchTerm['class'] !== '' && $aSearchTerm['class'] !== null)
 898                                                                                         {
 899                                                                                                 if ($aSearch['sClass'] === '')
 900                                                                                                 {
 901                                                                                                         $aSearch['sOperator'] = $aSearchTerm['operator'];
 902                                                                                                         $aSearch['sClass'] = $aSearchTerm['class'];
 903                                                                                                         $aSearch['sType'] = $aSearchTerm['type'];
 904                                                                                                         if (sizeof($aSearch['aName'])) $aSearch['sOperator'] = 'name';
 905                                                                                                         else $aSearch['sOperator'] = 'near'; // near = in for the moment
 906
 907                                                                                                         // Do we have a shortcut id?
 908                                                                                                         if ($aSearch['sOperator'] == 'name')
 909                                                                                                         {
 910                                                                                                                 $sSQL = "select get_tagpair('".$aSearch['sClass']."', '".$aSearch['sType']."')";
 911                                                                                                                 if ($iAmenityID = $this->oDB->getOne($sSQL))
 912                                                                                                                 {
 913                                                                                                                         $aValidTokens[$aSearch['sClass'].':'.$aSearch['sType']] = array('word_id' => $iAmenityID);
 914                                                                                                                         $aSearch['aName'][$iAmenityID] = $iAmenityID;
 915                                                                                                                         $aSearch['sClass'] = '';
 916                                                                                                                         $aSearch['sType'] = '';
 917                                                                                                                 }
 918                                                                                                         }
 919                                                                                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
 920                                                                                                 }
 921                                                                                         }
 922                                                                                         elseif (isset($aSearchTerm['word_id']) && $aSearchTerm['word_id'])
 923                                                                                         {
 924                                                                                                 if (sizeof($aSearch['aName']))
 925                                                                                                 {
 926                                                                                                         if ((!$bStructuredPhrases || $iPhrase > 0) && $sPhraseType != 'country' && (!isset($aValidTokens[$sToken]) || strlen($sToken) < 4 || strpos($sToken, ' ') !== false))
 927                                                                                                         {
 928                                                                                                                 $aSearch['aAddress'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
 929                                                                                                         }
 930                                                                                                         else
 931                                                                                                         {
 932                                                                                                                 $aCurrentSearch['aFullNameAddress'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
 933                                                                                                                 $aSearch['iSearchRank'] += 1000; // skip;
 934                                                                                                         }
 935                                                                                                 }
 936                                                                                                 else
 937                                                                                                 {
 938                                                                                                         $aSearch['aName'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
 939                                                                                                         //$aSearch['iNamePhrase'] = $iPhrase;
 940                                                                                                 }
 941                                                                                                 if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
 942                                                                                         }
 943                                                                                 }
 944                                                                         }
 945                                                                         if (isset($aValidTokens[$sToken]))
 946                                                                         {
 947                                                                                 // Allow searching for a word - but at extra cost
 948                                                                                 foreach($aValidTokens[$sToken] as $aSearchTerm)
 949                                                                                 {
 950                                                                                         if (isset($aSearchTerm['word_id']) && $aSearchTerm['word_id'])
 951                                                                                         {
 952                                                                                                 if ((!$bStructuredPhrases || $iPhrase > 0) && sizeof($aCurrentSearch['aName']) && strlen($sToken) >= 4)
 953                                                                                                 {
 954                                                                                                         $aSearch = $aCurrentSearch;
 955                                                                                                         $aSearch['iSearchRank'] += 1;
 956                                                                                                         if ($aWordFrequencyScores[$aSearchTerm['word_id']] < CONST_Max_Word_Frequency)
 957                                                                                                         {
 958                                                                                                                 $aSearch['aAddress'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
 959                                                                                                                 if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
 960                                                                                                         }
 961                                                                                                         elseif (isset($aValidTokens[' '.$sToken])) // revert to the token version?
 962                                                                                                         {
 963                                                                                                                 foreach($aValidTokens[' '.$sToken] as $aSearchTermToken)
 964                                                                                                                 {
 965                                                                                                                         if (empty($aSearchTermToken['country_code'])
 966                                                                                                                                         && empty($aSearchTermToken['lat'])
 967                                                                                                                                         && empty($aSearchTermToken['class']))
 968                                                                                                                         {
 969                                                                                                                                 $aSearch = $aCurrentSearch;
 970                                                                                                                                 $aSearch['iSearchRank'] += 1;
 971                                                                                                                                 $aSearch['aAddress'][$aSearchTermToken['word_id']] = $aSearchTermToken['word_id'];
 972                                                                                                                                 if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
 973                                                                                                                         }
 974                                                                                                                 }
 975                                                                                                         }
 976                                                                                                         else
 977                                                                                                         {
 978                                                                                                                 $aSearch['aAddressNonSearch'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
 979                                                                                                                 if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
 980                                                                                                         }
 981                                                                                                 }
 982
 983                                                                                                 if (!sizeof($aCurrentSearch['aName']) || $aCurrentSearch['iNamePhrase'] == $iPhrase)
 984                                                                                                 {
 985                                                                                                         $aSearch = $aCurrentSearch;
 986                                                                                                         $aSearch['iSearchRank'] += 2;
 987                                                                                                         if (preg_match('#^[0-9]+$#', $sToken)) $aSearch['iSearchRank'] += 2;
 988                                                                                                         if ($aWordFrequencyScores[$aSearchTerm['word_id']] < CONST_Max_Word_Frequency)
 989                                                                                                                 $aSearch['aName'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
 990                                                                                                         else
 991                                                                                                                 $aSearch['aNameNonSearch'][$aSearchTerm['word_id']] = $aSearchTerm['word_id'];
 992                                                                                                         $aSearch['iNamePhrase'] = $iPhrase;
 993                                                                                                         if ($aSearch['iSearchRank'] < $this->iMaxRank) $aNewWordsetSearches[] = $aSearch;
 994                                                                                                 }
 995                                                                                         }
 996                                                                                 }
 997                                                                         }
 998                                                                         else
 999                                                                         {
1000                                                                                 // Allow skipping a word - but at EXTREAM cost
1001                                                                                 //$aSearch = $aCurrentSearch;
1002                                                                                 //$aSearch['iSearchRank']+=100;
1003                                                                                 //$aNewWordsetSearches[] = $aSearch;
1004                                                                         }
1005                                                                 }
1006                                                                 // Sort and cut
1007                                                                 usort($aNewWordsetSearches, 'bySearchRank');
1008                                                                 $aWordsetSearches = array_slice($aNewWordsetSearches, 0, 50);
1009                                                         }
1010                                                         //var_Dump('<hr>',sizeof($aWordsetSearches)); exit;
1011
1012                                                         $aNewPhraseSearches = array_merge($aNewPhraseSearches, $aNewWordsetSearches);
1013                                                         usort($aNewPhraseSearches, 'bySearchRank');
1014
1015                                                         $aSearchHash = array();
1016                                                         foreach($aNewPhraseSearches as $iSearch => $aSearch)
1017                                                         {
1018                                                                 $sHash = serialize($aSearch);
1019                                                                 if (isset($aSearchHash[$sHash])) unset($aNewPhraseSearches[$iSearch]);
1020                                                                 else $aSearchHash[$sHash] = 1;
1021                                                         }
1022
1023                                                         $aNewPhraseSearches = array_slice($aNewPhraseSearches, 0, 50);
1024                                                 }
1025
1026                                                 // Re-group the searches by their score, junk anything over 20 as just not worth trying
1027                                                 $aGroupedSearches = array();
1028                                                 foreach($aNewPhraseSearches as $aSearch)
1029                                                 {
1030                                                         if ($aSearch['iSearchRank'] < $this->iMaxRank)
1031                                                         {
1032                                                                 if (!isset($aGroupedSearches[$aSearch['iSearchRank']])) $aGroupedSearches[$aSearch['iSearchRank']] = array();
1033                                                                 $aGroupedSearches[$aSearch['iSearchRank']][] = $aSearch;
1034                                                         }
1035                                                 }
1036                                                 ksort($aGroupedSearches);
1037
1038                                                 $iSearchCount = 0;
1039                                                 $aSearches = array();
1040                                                 foreach($aGroupedSearches as $iScore => $aNewSearches)
1041                                                 {
1042                                                         $iSearchCount += sizeof($aNewSearches);
1043                                                         $aSearches = array_merge($aSearches, $aNewSearches);
1044                                                         if ($iSearchCount > 50) break;
1045                                                 }
1046
1047                                                 //if (CONST_Debug) _debugDumpGroupedSearches($aGroupedSearches, $aValidTokens);
1048
1049                                         }
1050
1051                                 }
1052                                 else
1053                                 {
1054                                         // Re-group the searches by their score, junk anything over 20 as just not worth trying
1055                                         $aGroupedSearches = array();
1056                                         foreach($aSearches as $aSearch)
1057                                         {
1058                                                 if ($aSearch['iSearchRank'] < $this->iMaxRank)
1059                                                 {
1060                                                         if (!isset($aGroupedSearches[$aSearch['iSearchRank']])) $aGroupedSearches[$aSearch['iSearchRank']] = array();
1061                                                         $aGroupedSearches[$aSearch['iSearchRank']][] = $aSearch;
1062                                                 }
1063                                         }
1064                                         ksort($aGroupedSearches);
1065                                 }
1066
1067                                 if (CONST_Debug) var_Dump($aGroupedSearches);
1068
1069                                 if ($this->bReverseInPlan)
1070                                 {
1071                                         $aCopyGroupedSearches = $aGroupedSearches;
1072                                         foreach($aCopyGroupedSearches as $iGroup => $aSearches)
1073                                         {
1074                                                 foreach($aSearches as $iSearch => $aSearch)
1075                                                 {
1076                                                         if (sizeof($aSearch['aAddress']))
1077                                                         {
1078                                                                 $iReverseItem = array_pop($aSearch['aAddress']);
1079                                                                 if (isset($aPossibleMainWordIDs[$iReverseItem]))
1080                                                                 {
1081                                                                         $aSearch['aAddress'] = array_merge($aSearch['aAddress'], $aSearch['aName']);
1082                                                                         $aSearch['aName'] = array($iReverseItem);
1083                                                                         $aGroupedSearches[$iGroup][] = $aSearch;
1084                                                                 }
1085                                                                 //$aReverseSearch['aName'][$iReverseItem] = $iReverseItem;
1086                                                                 //$aGroupedSearches[$iGroup][] = $aReverseSearch;
1087                                                         }
1088                                                 }
1089                                         }
1090                                 }
1091
1092                                 if (CONST_Search_TryDroppedAddressTerms && sizeof($aStructuredQuery) > 0)
1093                                 {
1094                                         $aCopyGroupedSearches = $aGroupedSearches;
1095                                         foreach($aCopyGroupedSearches as $iGroup => $aSearches)
1096                                         {
1097                                                 foreach($aSearches as $iSearch => $aSearch)
1098                                                 {
1099                                                         $aReductionsList = array($aSearch['aAddress']);
1100                                                         $iSearchRank = $aSearch['iSearchRank'];
1101                                                         while(sizeof($aReductionsList) > 0)
1102                                                         {
1103                                                                 $iSearchRank += 5;
1104                                                                 if ($iSearchRank > iMaxRank) break 3;
1105                                                                 $aNewReductionsList = array();
1106                                                                 foreach($aReductionsList as $aReductionsWordList)
1107                                                                 {
1108                                                                         for ($iReductionWord = 0; $iReductionWord < sizeof($aReductionsWordList); $iReductionWord++)
1109                                                                         {
1110                                                                                 $aReductionsWordListResult = array_merge(array_slice($aReductionsWordList, 0, $iReductionWord), array_slice($aReductionsWordList, $iReductionWord+1));
1111                                                                                 $aReverseSearch = $aSearch;
1112                                                                                 $aSearch['aAddress'] = $aReductionsWordListResult;
1113                                                                                 $aSearch['iSearchRank'] = $iSearchRank;
1114                                                                                 $aGroupedSearches[$iSearchRank][] = $aReverseSearch;
1115                                                                                 if (sizeof($aReductionsWordListResult) > 0)
1116                                                                                 {
1117                                                                                         $aNewReductionsList[] = $aReductionsWordListResult;
1118                                                                                 }
1119                                                                         }
1120                                                                 }
1121                                                                 $aReductionsList = $aNewReductionsList;
1122                                                         }
1123                                                 }
1124                                         }
1125                                         ksort($aGroupedSearches);
1126                                 }
1127
1128                                 // Filter out duplicate searches
1129                                 $aSearchHash = array();
1130                                 foreach($aGroupedSearches as $iGroup => $aSearches)
1131                                 {
1132                                         foreach($aSearches as $iSearch => $aSearch)
1133                                         {
1134                                                 $sHash = serialize($aSearch);
1135                                                 if (isset($aSearchHash[$sHash]))
1136                                                 {
1137                                                         unset($aGroupedSearches[$iGroup][$iSearch]);
1138                                                         if (sizeof($aGroupedSearches[$iGroup]) == 0) unset($aGroupedSearches[$iGroup]);
1139                                                 }
1140                                                 else
1141                                                 {
1142                                                         $aSearchHash[$sHash] = 1;
1143                                                 }
1144                                         }
1145                                 }
1146
1147                                 if (CONST_Debug) _debugDumpGroupedSearches($aGroupedSearches, $aValidTokens);
1148
1149                                 $iGroupLoop = 0;
1150                                 $iQueryLoop = 0;
1151                                 foreach($aGroupedSearches as $iGroupedRank => $aSearches)
1152                                 {
1153                                         $iGroupLoop++;
1154                                         foreach($aSearches as $aSearch)
1155                                         {
1156                                                 $iQueryLoop++;
1157
1158                                                 if (CONST_Debug) { echo "<hr><b>Search Loop, group $iGroupLoop, loop $iQueryLoop</b>"; }
1159                                                 if (CONST_Debug) _debugDumpGroupedSearches(array($iGroupedRank => array($aSearch)), $aValidTokens);
1160
1161                                                 // No location term?
1162                                                 if (!sizeof($aSearch['aName']) && !sizeof($aSearch['aAddress']) && !$aSearch['fLon'])
1163                                                 {
1164                                                         if ($aSearch['sCountryCode'] && !$aSearch['sClass'] && !$aSearch['sHouseNumber'])
1165                                                         {
1166                                                                 // Just looking for a country by code - look it up
1167                                                                 if (4 >= $this->iMinAddressRank && 4 <= $this->iMaxAddressRank)
1168                                                                 {
1169                                                                         $sSQL = "select place_id from placex where calculated_country_code='".$aSearch['sCountryCode']."' and rank_search = 4";
1170                                                                         if ($sCountryCodesSQL) $sSQL .= " and calculated_country_code in ($sCountryCodesSQL)";
1171                                                                         $sSQL .= " order by st_area(geometry) desc limit 1";
1172                                                                         if (CONST_Debug) var_dump($sSQL);
1173                                                                         $aPlaceIDs = $this->oDB->getCol($sSQL);
1174                                                                 }
1175                                                         }
1176                                                         else
1177                                                         {
1178                                                                 if (!$bBoundingBoxSearch && !$aSearch['fLon']) continue;
1179                                                                 if (!$aSearch['sClass']) continue;
1180                                                                 $sSQL = "select count(*) from pg_tables where tablename = 'place_classtype_".$aSearch['sClass']."_".$aSearch['sType']."'";
1181                                                                 if ($this->oDB->getOne($sSQL))
1182                                                                 {
1183                                                                         $sSQL = "select place_id from place_classtype_".$aSearch['sClass']."_".$aSearch['sType']." ct";
1184                                                                         if ($sCountryCodesSQL) $sSQL .= " join placex using (place_id)";
1185                                                                         $sSQL .= " where st_contains($sViewboxSmallSQL, ct.centroid)";
1186                                                                         if ($sCountryCodesSQL) $sSQL .= " and calculated_country_code in ($sCountryCodesSQL)";
1187                                                                         if (sizeof($this->aExcludePlaceIDs))
1188                                                                         {
1189                                                                                 $sSQL .= " and place_id not in (".join(',',$this->aExcludePlaceIDs).")";
1190                                                                         }
1191                                                                         if ($sViewboxCentreSQL) $sSQL .= " order by st_distance($sViewboxCentreSQL, ct.centroid) asc";
1192                                                                         $sSQL .= " limit $this->iLimit";
1193                                                                         if (CONST_Debug) var_dump($sSQL);
1194                                                                         $aPlaceIDs = $this->oDB->getCol($sSQL);
1195
1196                                                                         // If excluded place IDs are given, it is fair to assume that
1197                                                                         // there have been results in the small box, so no further
1198                                                                         // expansion in that case.
1199                                                                         if (!sizeof($aPlaceIDs) && !sizeof($this->aExcludePlaceIDs))
1200                                                                         {
1201                                                                                 $sSQL = "select place_id from place_classtype_".$aSearch['sClass']."_".$aSearch['sType']." ct";
1202                                                                                 if ($sCountryCodesSQL) $sSQL .= " join placex using (place_id)";
1203                                                                                 $sSQL .= " where st_contains($sViewboxLargeSQL, ct.centroid)";
1204                                                                                 if ($sCountryCodesSQL) $sSQL .= " and calculated_country_code in ($sCountryCodesSQL)";
1205                                                                                 if ($sViewboxCentreSQL) $sSQL .= " order by st_distance($sViewboxCentreSQL, ct.centroid) asc";
1206                                                                                 $sSQL .= " limit $this->iLimit";
1207                                                                                 if (CONST_Debug) var_dump($sSQL);
1208                                                                                 $aPlaceIDs = $this->oDB->getCol($sSQL);
1209                                                                         }
1210                                                                 }
1211                                                                 else
1212                                                                 {
1213                                                                         $sSQL = "select place_id from placex where class='".$aSearch['sClass']."' and type='".$aSearch['sType']."'";
1214                                                                         $sSQL .= " and st_contains($sViewboxSmallSQL, geometry) and linked_place_id is null";
1215                                                                         if ($sCountryCodesSQL) $sSQL .= " and calculated_country_code in ($sCountryCodesSQL)";
1216                                                                         if ($sViewboxCentreSQL) $sSQL .= " order by st_distance($sViewboxCentreSQL, centroid) asc";
1217                                                                         $sSQL .= " limit $this->iLimit";
1218                                                                         if (CONST_Debug) var_dump($sSQL);
1219                                                                         $aPlaceIDs = $this->oDB->getCol($sSQL);
1220                                                                 }
1221                                                         }
1222                                                 }
1223                                                 else
1224                                                 {
1225                                                         $aPlaceIDs = array();
1226
1227                                                         // First we need a position, either aName or fLat or both
1228                                                         $aTerms = array();
1229                                                         $aOrder = array();
1230
1231                                                         // TODO: filter out the pointless search terms (2 letter name tokens and less)
1232                                                         // they might be right - but they are just too darned expensive to run
1233                                                         if (sizeof($aSearch['aName'])) $aTerms[] = "name_vector @> ARRAY[".join($aSearch['aName'],",")."]";
1234                                                         if (sizeof($aSearch['aNameNonSearch'])) $aTerms[] = "array_cat(name_vector,ARRAY[]::integer[]) @> ARRAY[".join($aSearch['aNameNonSearch'],",")."]";
1235                                                         if (sizeof($aSearch['aAddress']) && $aSearch['aName'] != $aSearch['aAddress'])
1236                                                         {
1237                                                                 // For infrequent name terms disable index usage for address
1238                                                                 if (CONST_Search_NameOnlySearchFrequencyThreshold &&
1239                                                                                 sizeof($aSearch['aName']) == 1 &&
1240                                                                                 $aWordFrequencyScores[$aSearch['aName'][reset($aSearch['aName'])]] < CONST_Search_NameOnlySearchFrequencyThreshold)
1241                                                                 {
1242                                                                         $aTerms[] = "array_cat(nameaddress_vector,ARRAY[]::integer[]) @> ARRAY[".join(array_merge($aSearch['aAddress'],$aSearch['aAddressNonSearch']),",")."]";
1243                                                                 }
1244                                                                 else
1245                                                                 {
1246                                                                         $aTerms[] = "nameaddress_vector @> ARRAY[".join($aSearch['aAddress'],",")."]";
1247                                                                         if (sizeof($aSearch['aAddressNonSearch'])) $aTerms[] = "array_cat(nameaddress_vector,ARRAY[]::integer[]) @> ARRAY[".join($aSearch['aAddressNonSearch'],",")."]";
1248                                                                 }
1249                                                         }
1250                                                         if ($aSearch['sCountryCode']) $aTerms[] = "country_code = '".pg_escape_string($aSearch['sCountryCode'])."'";
1251                                                         if ($aSearch['sHouseNumber']) $aTerms[] = "address_rank between 16 and 27";
1252                                                         if ($aSearch['fLon'] && $aSearch['fLat'])
1253                                                         {
1254                                                                 $aTerms[] = "ST_DWithin(centroid, ST_SetSRID(ST_Point(".$aSearch['fLon'].",".$aSearch['fLat']."),4326), ".$aSearch['fRadius'].")";
1255                                                                 $aOrder[] = "ST_Distance(centroid, ST_SetSRID(ST_Point(".$aSearch['fLon'].",".$aSearch['fLat']."),4326)) ASC";
1256                                                         }
1257                                                         if (sizeof($this->aExcludePlaceIDs))
1258                                                         {
1259                                                                 $aTerms[] = "place_id not in (".join(',',$this->aExcludePlaceIDs).")";
1260                                                         }
1261                                                         if ($sCountryCodesSQL)
1262                                                         {
1263                                                                 $aTerms[] = "country_code in ($sCountryCodesSQL)";
1264                                                         }
1265
1266                                                         if ($bBoundingBoxSearch) $aTerms[] = "centroid && $sViewboxSmallSQL";
1267                                                         if ($sNearPointSQL) $aOrder[] = "ST_Distance($sNearPointSQL, centroid) asc";
1268
1269                                                         $sImportanceSQL = '(case when importance = 0 OR importance IS NULL then 0.75-(search_rank::float/40) else importance end)';
1270                                                         if ($sViewboxSmallSQL) $sImportanceSQL .= " * case when ST_Contains($sViewboxSmallSQL, centroid) THEN 1 ELSE 0.5 END";
1271                                                         if ($sViewboxLargeSQL) $sImportanceSQL .= " * case when ST_Contains($sViewboxLargeSQL, centroid) THEN 1 ELSE 0.5 END";
1272                                                         $aOrder[] = "$sImportanceSQL DESC";
1273                                                         if (sizeof($aSearch['aFullNameAddress']))
1274                                                         {
1275                                                                 $sExactMatchSQL = '(select count(*) from (select unnest(ARRAY['.join($aSearch['aFullNameAddress'],",").']) INTERSECT select unnest(nameaddress_vector))s) as exactmatch';
1276                                                                 $aOrder[] = 'exactmatch DESC';
1277                                                         } else {
1278                                                                 $sExactMatchSQL = '0::int as exactmatch';
1279                                                         }
1280
1281                                                         if (sizeof($aTerms))
1282                                                         {
1283                                                                 $sSQL = "select place_id, ";
1284                                                                 $sSQL .= $sExactMatchSQL;
1285                                                                 $sSQL .= " from search_name";
1286                                                                 $sSQL .= " where ".join(' and ',$aTerms);
1287                                                                 $sSQL .= " order by ".join(', ',$aOrder);
1288                                                                 if ($aSearch['sHouseNumber'] || $aSearch['sClass'])
1289                                                                         $sSQL .= " limit 50";
1290                                                                 elseif (!sizeof($aSearch['aName']) && !sizeof($aSearch['aAddress']) && $aSearch['sClass'])
1291                                                                         $sSQL .= " limit 1";
1292                                                                 else
1293                                                                         $sSQL .= " limit ".$this->iLimit;
1294
1295                                                                 if (CONST_Debug) { var_dump($sSQL); }
1296                                                                 $aViewBoxPlaceIDs = $this->oDB->getAll($sSQL);
1297                                                                 if (PEAR::IsError($aViewBoxPlaceIDs))
1298                                                                 {
1299                                                                         failInternalError("Could not get places for search terms.", $sSQL, $aViewBoxPlaceIDs);
1300                                                                 }
1301                                                                 //var_dump($aViewBoxPlaceIDs);
1302                                                                 // Did we have an viewbox matches?
1303                                                                 $aPlaceIDs = array();
1304                                                                 $bViewBoxMatch = false;
1305                                                                 foreach($aViewBoxPlaceIDs as $aViewBoxRow)
1306                                                                 {
1307                                                                         //if ($bViewBoxMatch == 1 && $aViewBoxRow['in_small'] == 'f') break;
1308                                                                         //if ($bViewBoxMatch == 2 && $aViewBoxRow['in_large'] == 'f') break;
1309                                                                         //if ($aViewBoxRow['in_small'] == 't') $bViewBoxMatch = 1;
1310                                                                         //else if ($aViewBoxRow['in_large'] == 't') $bViewBoxMatch = 2;
1311                                                                         $aPlaceIDs[] = $aViewBoxRow['place_id'];
1312                                                                         $this->exactMatchCache[$aViewBoxRow['place_id']] = $aViewBoxRow['exactmatch'];
1313                                                                 }
1314                                                         }
1315                                                         //var_Dump($aPlaceIDs);
1316                                                         //exit;
1317
1318                                                         if ($aSearch['sHouseNumber'] && sizeof($aPlaceIDs))
1319                                                         {
1320                                                                 $aRoadPlaceIDs = $aPlaceIDs;
1321                                                                 $sPlaceIDs = join(',',$aPlaceIDs);
1322
1323                                                                 // Now they are indexed look for a house attached to a street we found
1324                                                                 $sHouseNumberRegex = '\\\\m'.str_replace(' ','[-,/ ]',$aSearch['sHouseNumber']).'\\\\M';
1325                                                                 $sSQL = "select place_id from placex where parent_place_id in (".$sPlaceIDs.") and housenumber ~* E'".$sHouseNumberRegex."'";
1326                                                                 if (sizeof($this->aExcludePlaceIDs))
1327                                                                 {
1328                                                                         $sSQL .= " and place_id not in (".join(',',$this->aExcludePlaceIDs).")";
1329                                                                 }
1330                                                                 $sSQL .= " limit $this->iLimit";
1331                                                                 if (CONST_Debug) var_dump($sSQL);
1332                                                                 $aPlaceIDs = $this->oDB->getCol($sSQL);
1333
1334                                                                 // If not try the aux fallback table
1335                                                                 if (!sizeof($aPlaceIDs))
1336                                                                 {
1337                                                                         $sSQL = "select place_id from location_property_aux where parent_place_id in (".$sPlaceIDs.") and housenumber = '".pg_escape_string($aSearch['sHouseNumber'])."'";
1338                                                                         if (sizeof($this->aExcludePlaceIDs))
1339                                                                         {
1340                                                                                 $sSQL .= " and place_id not in (".join(',',$this->aExcludePlaceIDs).")";
1341                                                                         }
1342                                                                         //$sSQL .= " limit $this->iLimit";
1343                                                                         if (CONST_Debug) var_dump($sSQL);
1344                                                                         $aPlaceIDs = $this->oDB->getCol($sSQL);
1345                                                                 }
1346
1347                                                                 if (!sizeof($aPlaceIDs))
1348                                                                 {
1349                                                                         $sSQL = "select place_id from location_property_tiger where parent_place_id in (".$sPlaceIDs.") and housenumber = '".pg_escape_string($aSearch['sHouseNumber'])."'";
1350                                                                         if (sizeof($this->aExcludePlaceIDs))
1351                                                                         {
1352                                                                                 $sSQL .= " and place_id not in (".join(',',$this->aExcludePlaceIDs).")";
1353                                                                         }
1354                                                                         //$sSQL .= " limit $this->iLimit";
1355                                                                         if (CONST_Debug) var_dump($sSQL);
1356                                                                         $aPlaceIDs = $this->oDB->getCol($sSQL);
1357                                                                 }
1358
1359                                                                 // Fallback to the road
1360                                                                 if (!sizeof($aPlaceIDs) && preg_match('/[0-9]+/', $aSearch['sHouseNumber']))
1361                                                                 {
1362                                                                         $aPlaceIDs = $aRoadPlaceIDs;
1363                                                                 }
1364
1365                                                         }
1366
1367                                                         if ($aSearch['sClass'] && sizeof($aPlaceIDs))
1368                                                         {
1369                                                                 $sPlaceIDs = join(',',$aPlaceIDs);
1370                                                                 $aClassPlaceIDs = array();
1371
1372                                                                 if (!$aSearch['sOperator'] || $aSearch['sOperator'] == 'name')
1373                                                                 {
1374                                                                         // If they were searching for a named class (i.e. 'Kings Head pub') then we might have an extra match
1375                                                                         $sSQL = "select place_id from placex where place_id in ($sPlaceIDs) and class='".$aSearch['sClass']."' and type='".$aSearch['sType']."'";
1376                                                                         $sSQL .= " and linked_place_id is null";
1377                                                                         if ($sCountryCodesSQL) $sSQL .= " and calculated_country_code in ($sCountryCodesSQL)";
1378                                                                         $sSQL .= " order by rank_search asc limit $this->iLimit";
1379                                                                         if (CONST_Debug) var_dump($sSQL);
1380                                                                         $aClassPlaceIDs = $this->oDB->getCol($sSQL);
1381                                                                 }
1382
1383                                                                 if (!$aSearch['sOperator'] || $aSearch['sOperator'] == 'near') // & in
1384                                                                 {
1385                                                                         $sSQL = "select count(*) from pg_tables where tablename = 'place_classtype_".$aSearch['sClass']."_".$aSearch['sType']."'";
1386                                                                         $bCacheTable = $this->oDB->getOne($sSQL);
1387
1388                                                                         $sSQL = "select min(rank_search) from placex where place_id in ($sPlaceIDs)";
1389
1390                                                                         if (CONST_Debug) var_dump($sSQL);
1391                                                                         $this->iMaxRank = ((int)$this->oDB->getOne($sSQL));
1392
1393                                                                         // For state / country level searches the normal radius search doesn't work very well
1394                                                                         $sPlaceGeom = false;
1395                                                                         if ($this->iMaxRank < 9 && $bCacheTable)
1396                                                                         {
1397                                                                                 // Try and get a polygon to search in instead
1398                                                                                 $sSQL = "select geometry from placex where place_id in ($sPlaceIDs) and rank_search < $this->iMaxRank + 5 and st_geometrytype(geometry) in ('ST_Polygon','ST_MultiPolygon') order by rank_search asc limit 1";
1399                                                                                 if (CONST_Debug) var_dump($sSQL);
1400                                                                                 $sPlaceGeom = $this->oDB->getOne($sSQL);
1401                                                                         }
1402
1403                                                                         if ($sPlaceGeom)
1404                                                                         {
1405                                                                                 $sPlaceIDs = false;
1406                                                                         }
1407                                                                         else
1408                                                                         {
1409                                                                                 $this->iMaxRank += 5;
1410                                                                                 $sSQL = "select place_id from placex where place_id in ($sPlaceIDs) and rank_search < $this->iMaxRank";
1411                                                                                 if (CONST_Debug) var_dump($sSQL);
1412                                                                                 $aPlaceIDs = $this->oDB->getCol($sSQL);
1413                                                                                 $sPlaceIDs = join(',',$aPlaceIDs);
1414                                                                         }
1415
1416                                                                         if ($sPlaceIDs || $sPlaceGeom)
1417                                                                         {
1418
1419                                                                                 $fRange = 0.01;
1420                                                                                 if ($bCacheTable)
1421                                                                                 {
1422                                                                                         // More efficient - can make the range bigger
1423                                                                                         $fRange = 0.05;
1424
1425                                                                                         $sOrderBySQL = '';
1426                                                                                         if ($sNearPointSQL) $sOrderBySQL = "ST_Distance($sNearPointSQL, l.centroid)";
1427                                                                                         else if ($sPlaceIDs) $sOrderBySQL = "ST_Distance(l.centroid, f.geometry)";
1428                                                                                         else if ($sPlaceGeom) $sOrderBysSQL = "ST_Distance(st_centroid('".$sPlaceGeom."'), l.centroid)";
1429
1430                                                                                         $sSQL = "select distinct l.place_id".($sOrderBySQL?','.$sOrderBySQL:'')." from place_classtype_".$aSearch['sClass']."_".$aSearch['sType']." as l";
1431                                                                                         if ($sCountryCodesSQL) $sSQL .= " join placex as lp using (place_id)";
1432                                                                                         if ($sPlaceIDs)
1433                                                                                         {
1434                                                                                                 $sSQL .= ",placex as f where ";
1435                                                                                                 $sSQL .= "f.place_id in ($sPlaceIDs) and ST_DWithin(l.centroid, f.centroid, $fRange) ";
1436                                                                                         }
1437                                                                                         if ($sPlaceGeom)
1438                                                                                         {
1439                                                                                                 $sSQL .= " where ";
1440                                                                                                 $sSQL .= "ST_Contains('".$sPlaceGeom."', l.centroid) ";
1441                                                                                         }
1442                                                                                         if (sizeof($this->aExcludePlaceIDs))
1443                                                                                         {
1444                                                                                                 $sSQL .= " and l.place_id not in (".join(',',$this->aExcludePlaceIDs).")";
1445                                                                                         }
1446                                                                                         if ($sCountryCodesSQL) $sSQL .= " and lp.calculated_country_code in ($sCountryCodesSQL)";
1447                                                                                         if ($sOrderBySQL) $sSQL .= "order by ".$sOrderBySQL." asc";
1448                                                                                         if ($iOffset) $sSQL .= " offset $iOffset";
1449                                                                                         $sSQL .= " limit $this->iLimit";
1450                                                                                         if (CONST_Debug) var_dump($sSQL);
1451                                                                                         $aClassPlaceIDs = array_merge($aClassPlaceIDs, $this->oDB->getCol($sSQL));
1452                                                                                 }
1453                                                                                 else
1454                                                                                 {
1455                                                                                         if (isset($aSearch['fRadius']) && $aSearch['fRadius']) $fRange = $aSearch['fRadius'];
1456
1457                                                                                         $sOrderBySQL = '';
1458                                                                                         if ($sNearPointSQL) $sOrderBySQL = "ST_Distance($sNearPointSQL, l.geometry)";
1459                                                                                         else $sOrderBySQL = "ST_Distance(l.geometry, f.geometry)";
1460
1461                                                                                         $sSQL = "select distinct l.place_id".($sOrderBysSQL?','.$sOrderBysSQL:'')." from placex as l,placex as f where ";
1462                                                                                         $sSQL .= "f.place_id in ( $sPlaceIDs) and ST_DWithin(l.geometry, f.centroid, $fRange) ";
1463                                                                                         $sSQL .= "and l.class='".$aSearch['sClass']."' and l.type='".$aSearch['sType']."' ";
1464                                                                                         if (sizeof($this->aExcludePlaceIDs))
1465                                                                                         {
1466                                                                                                 $sSQL .= " and l.place_id not in (".join(',',$this->aExcludePlaceIDs).")";
1467                                                                                         }
1468                                                                                         if ($sCountryCodesSQL) $sSQL .= " and l.calculated_country_code in ($sCountryCodesSQL)";
1469                                                                                         if ($sOrderBy) $sSQL .= "order by ".$OrderBysSQL." asc";
1470                                                                                         if ($iOffset) $sSQL .= " offset $iOffset";
1471                                                                                         $sSQL .= " limit $this->iLimit";
1472                                                                                         if (CONST_Debug) var_dump($sSQL);
1473                                                                                         $aClassPlaceIDs = array_merge($aClassPlaceIDs, $this->oDB->getCol($sSQL));
1474                                                                                 }
1475                                                                         }
1476                                                                 }
1477
1478                                                                 $aPlaceIDs = $aClassPlaceIDs;
1479
1480                                                         }
1481
1482                                                 }
1483
1484                                                 if (PEAR::IsError($aPlaceIDs))
1485                                                 {
1486                                                         failInternalError("Could not get place IDs from tokens." ,$sSQL, $aPlaceIDs);
1487                                                 }
1488
1489                                                 if (CONST_Debug) { echo "<br><b>Place IDs:</b> "; var_Dump($aPlaceIDs); }
1490
1491                                                 foreach($aPlaceIDs as $iPlaceID)
1492                                                 {
1493                                                         $aResultPlaceIDs[$iPlaceID] = $iPlaceID;
1494                                                 }
1495                                                 if ($iQueryLoop > 20) break;
1496                                         }
1497
1498                                         if (isset($aResultPlaceIDs) && sizeof($aResultPlaceIDs) && ($this->iMinAddressRank != 0 || $this->iMaxAddressRank != 30))
1499                                         {
1500                                                 // Need to verify passes rank limits before dropping out of the loop (yuk!)
1501                                                 $sSQL = "select place_id from placex where place_id in (".join(',',$aResultPlaceIDs).") ";
1502                                                 $sSQL .= "and (placex.rank_address between $this->iMinAddressRank and $this->iMaxAddressRank ";
1503                                                 if (14 >= $this->iMinAddressRank && 14 <= $this->iMaxAddressRank) $sSQL .= " OR (extratags->'place') = 'city'";
1504                                                 if ($this->aAddressRankList) $sSQL .= " OR placex.rank_address in (".join(',',$this->aAddressRankList).")";
1505                                                 $sSQL .= ") UNION select place_id from location_property_tiger where place_id in (".join(',',$aResultPlaceIDs).") ";
1506                                                 $sSQL .= "and (30 between $this->iMinAddressRank and $this->iMaxAddressRank ";
1507                                                 if ($this->aAddressRankList) $sSQL .= " OR 30 in (".join(',',$this->aAddressRankList).")";
1508                                                 $sSQL .= ")";
1509                                                 if (CONST_Debug) var_dump($sSQL);
1510                                                 $aResultPlaceIDs = $this->oDB->getCol($sSQL);
1511                                         }
1512
1513                                         //exit;
1514                                         if (isset($aResultPlaceIDs) && sizeof($aResultPlaceIDs)) break;
1515                                         if ($iGroupLoop > 4) break;
1516                                         if ($iQueryLoop > 30) break;
1517                                 }
1518
1519                                 // Did we find anything?
1520                                 if (isset($aResultPlaceIDs) && sizeof($aResultPlaceIDs))
1521                                 {
1522                                         $aSearchResults = $this->getDetails($aResultPlaceIDs);
1523                                 }
1524
1525                         }
1526                         else
1527                         {
1528                                 // Just interpret as a reverse geocode
1529                                 $iPlaceID = geocodeReverse((float)$this->aNearPoint[0], (float)$this->aNearPoint[1]);
1530                                 if ($iPlaceID)
1531                                         $aSearchResults = $this->getDetails(array($iPlaceID));
1532                                 else
1533                                         $aSearchResults = array();
1534                         }
1535
1536                         // No results? Done
1537                         if (!sizeof($aSearchResults))
1538                         {
1539                                 if ($this->bFallback)
1540                                 {
1541                                         if ($this->fallbackStructuredQuery())
1542                                         {
1543                                                 return $this->lookup();
1544                                         }
1545                                 }
1546
1547                                 return array();
1548                         }
1549
1550                         $aClassType = getClassTypesWithImportance();
1551                         $aRecheckWords = preg_split('/\b/u',$sQuery);
1552                         foreach($aRecheckWords as $i => $sWord)
1553                         {
1554                                 if (!$sWord) unset($aRecheckWords[$i]);
1555                         }
1556
1557                         foreach($aSearchResults as $iResNum => $aResult)
1558                         {
1559                                 if (CONST_Search_AreaPolygons)
1560                                 {
1561                                         // Get the bounding box and outline polygon
1562                                         $sSQL = "select place_id,0 as numfeatures,st_area(geometry) as area,";
1563                                         $sSQL .= "ST_Y(centroid) as centrelat,ST_X(centroid) as centrelon,";
1564                                         $sSQL .= "ST_Y(ST_PointN(ST_ExteriorRing(Box2D(geometry)),4)) as minlat,ST_Y(ST_PointN(ST_ExteriorRing(Box2D(geometry)),2)) as maxlat,";
1565                                         $sSQL .= "ST_X(ST_PointN(ST_ExteriorRing(Box2D(geometry)),1)) as minlon,ST_X(ST_PointN(ST_ExteriorRing(Box2D(geometry)),3)) as maxlon";
1566                                         if ($this->bIncludePolygonAsGeoJSON) $sSQL .= ",ST_AsGeoJSON(geometry) as asgeojson";
1567                                         if ($this->bIncludePolygonAsKML) $sSQL .= ",ST_AsKML(geometry) as askml";
1568                                         if ($this->bIncludePolygonAsSVG) $sSQL .= ",ST_AsSVG(geometry) as assvg";
1569                                         if ($this->bIncludePolygonAsText || $this->bIncludePolygonAsPoints) $sSQL .= ",ST_AsText(geometry) as astext";
1570                                         $sSQL .= " from placex where place_id = ".$aResult['place_id'].' and st_geometrytype(Box2D(geometry)) = \'ST_Polygon\'';
1571                                         $aPointPolygon = $this->oDB->getRow($sSQL);
1572                                         if (PEAR::IsError($aPointPolygon))
1573                                         {
1574                                                 failInternalError("Could not get outline.", $sSQL, $aPointPolygon);
1575                                         }
1576
1577                                         if ($aPointPolygon['place_id'])
1578                                         {
1579                                                 if ($this->bIncludePolygonAsGeoJSON) $aResult['asgeojson'] = $aPointPolygon['asgeojson'];
1580                                                 if ($this->bIncludePolygonAsKML) $aResult['askml'] = $aPointPolygon['askml'];
1581                                                 if ($this->bIncludePolygonAsSVG) $aResult['assvg'] = $aPointPolygon['assvg'];
1582                                                 if ($this->bIncludePolygonAsText) $aResult['astext'] = $aPointPolygon['astext'];
1583
1584                                                 if ($aPointPolygon['centrelon'] !== null && $aPointPolygon['centrelat'] !== null )
1585                                                 {
1586                                                         $aResult['lat'] = $aPointPolygon['centrelat'];
1587                                                         $aResult['lon'] = $aPointPolygon['centrelon'];
1588                                                 }
1589
1590                                                 if ($this->bIncludePolygonAsPoints)
1591                                                 {
1592                                                         // Translate geometary string to point array
1593                                                         if (preg_match('#POLYGON\\(\\(([- 0-9.,]+)#',$aPointPolygon['astext'],$aMatch))
1594                                                         {
1595                                                                 preg_match_all('/(-?[0-9.]+) (-?[0-9.]+)/',$aMatch[1],$aPolyPoints,PREG_SET_ORDER);
1596                                                         }
1597                                                         elseif (preg_match('#MULTIPOLYGON\\(\\(\\(([- 0-9.,]+)#',$aPointPolygon['astext'],$aMatch))
1598                                                         {
1599                                                                 preg_match_all('/(-?[0-9.]+) (-?[0-9.]+)/',$aMatch[1],$aPolyPoints,PREG_SET_ORDER);
1600                                                         }
1601                                                         elseif (preg_match('#POINT\\((-?[0-9.]+) (-?[0-9.]+)\\)#',$aPointPolygon['astext'],$aMatch))
1602                                                         {
1603                                                                 $fRadius = 0.01;
1604                                                                 $iSteps = ($fRadius * 40000)^2;
1605                                                                 $fStepSize = (2*pi())/$iSteps;
1606                                                                 $aPolyPoints = array();
1607                                                                 for($f = 0; $f < 2*pi(); $f += $fStepSize)
1608                                                                 {
1609                                                                         $aPolyPoints[] = array('',$aMatch[1]+($fRadius*sin($f)),$aMatch[2]+($fRadius*cos($f)));
1610                                                                 }
1611                                                                 $aPointPolygon['minlat'] = $aPointPolygon['minlat'] - $fRadius;
1612                                                                 $aPointPolygon['maxlat'] = $aPointPolygon['maxlat'] + $fRadius;
1613                                                                 $aPointPolygon['minlon'] = $aPointPolygon['minlon'] - $fRadius;
1614                                                                 $aPointPolygon['maxlon'] = $aPointPolygon['maxlon'] + $fRadius;
1615                                                         }
1616                                                 }
1617
1618                                                 // Output data suitable for display (points and a bounding box)
1619                                                 if ($this->bIncludePolygonAsPoints && isset($aPolyPoints))
1620                                                 {
1621                                                         $aResult['aPolyPoints'] = array();
1622                                                         foreach($aPolyPoints as $aPoint)
1623                                                         {
1624                                                                 $aResult['aPolyPoints'][] = array($aPoint[1], $aPoint[2]);
1625                                                         }
1626                                                 }
1627                                                 $aResult['aBoundingBox'] = array($aPointPolygon['minlat'],$aPointPolygon['maxlat'],$aPointPolygon['minlon'],$aPointPolygon['maxlon']);
1628                                         }
1629                                 }
1630
1631                                 if ($aResult['extra_place'] == 'city')
1632                                 {
1633                                         $aResult['class'] = 'place';
1634                                         $aResult['type'] = 'city';
1635                                         $aResult['rank_search'] = 16;
1636                                 }
1637
1638                                 if (!isset($aResult['aBoundingBox']))
1639                                 {
1640                                         // Default
1641                                         $fDiameter = 0.0001;
1642
1643                                         if (isset($aClassType[$aResult['class'].':'.$aResult['type'].':'.$aResult['admin_level']]['defdiameter'])
1644                                                         && $aClassType[$aResult['class'].':'.$aResult['type'].':'.$aResult['admin_level']]['defdiameter'])
1645                                         {
1646                                                 $fDiameter = $aClassType[$aResult['class'].':'.$aResult['type'].':'.$aResult['admin_level']]['defzoom'];
1647                                         }
1648                                         elseif (isset($aClassType[$aResult['class'].':'.$aResult['type']]['defdiameter'])
1649                                                         && $aClassType[$aResult['class'].':'.$aResult['type']]['defdiameter'])
1650                                         {
1651                                                 $fDiameter = $aClassType[$aResult['class'].':'.$aResult['type']]['defdiameter'];
1652                                         }
1653                                         $fRadius = $fDiameter / 2;
1654
1655                                         $iSteps = max(8,min(100,$fRadius * 3.14 * 100000));
1656                                         $fStepSize = (2*pi())/$iSteps;
1657                                         $aPolyPoints = array();
1658                                         for($f = 0; $f < 2*pi(); $f += $fStepSize)
1659                                         {
1660                                                 $aPolyPoints[] = array('',$aResult['lon']+($fRadius*sin($f)),$aResult['lat']+($fRadius*cos($f)));
1661                                         }
1662                                         $aPointPolygon['minlat'] = $aResult['lat'] - $fRadius;
1663                                         $aPointPolygon['maxlat'] = $aResult['lat'] + $fRadius;
1664                                         $aPointPolygon['minlon'] = $aResult['lon'] - $fRadius;
1665                                         $aPointPolygon['maxlon'] = $aResult['lon'] + $fRadius;
1666
1667                                         // Output data suitable for display (points and a bounding box)
1668                                         if ($this->bIncludePolygonAsPoints)
1669                                         {
1670                                                 $aResult['aPolyPoints'] = array();
1671                                                 foreach($aPolyPoints as $aPoint)
1672                                                 {
1673                                                         $aResult['aPolyPoints'][] = array($aPoint[1], $aPoint[2]);
1674                                                 }
1675                                         }
1676                                         $aResult['aBoundingBox'] = array((string)$aPointPolygon['minlat'],(string)$aPointPolygon['maxlat'],(string)$aPointPolygon['minlon'],(string)$aPointPolygon['maxlon']);
1677                                 }
1678
1679                                 // Is there an icon set for this type of result?
1680                                 if (isset($aClassType[$aResult['class'].':'.$aResult['type']]['icon'])
1681                                                 && $aClassType[$aResult['class'].':'.$aResult['type']]['icon'])
1682                                 {
1683                                         $aResult['icon'] = CONST_Website_BaseURL.'images/mapicons/'.$aClassType[$aResult['class'].':'.$aResult['type']]['icon'].'.p.20.png';
1684                                 }
1685
1686                                 if (isset($aClassType[$aResult['class'].':'.$aResult['type'].':'.$aResult['admin_level']]['label'])
1687                                                 && $aClassType[$aResult['class'].':'.$aResult['type'].':'.$aResult['admin_level']]['label'])
1688                                 {
1689                                         $aResult['label'] = $aClassType[$aResult['class'].':'.$aResult['type'].':'.$aResult['admin_level']]['label'];
1690                                 }
1691                                 elseif (isset($aClassType[$aResult['class'].':'.$aResult['type']]['label'])
1692                                                 && $aClassType[$aResult['class'].':'.$aResult['type']]['label'])
1693                                 {
1694                                         $aResult['label'] = $aClassType[$aResult['class'].':'.$aResult['type']]['label'];
1695                                 }
1696
1697                                 if ($this->bIncludeAddressDetails)
1698                                 {
1699                                         $aResult['address'] = getAddressDetails($this->oDB, $sLanguagePrefArraySQL, $aResult['place_id'], $aResult['country_code']);
1700                                         if ($aResult['extra_place'] == 'city' && !isset($aResult['address']['city']))
1701                                         {
1702                                                 $aResult['address'] = array_merge(array('city' => array_shift(array_values($aResult['address']))), $aResult['address']);
1703                                         }
1704                                 }
1705
1706                                 // Adjust importance for the number of exact string matches in the result
1707                                 $aResult['importance'] = max(0.001,$aResult['importance']);
1708                                 $iCountWords = 0;
1709                                 $sAddress = $aResult['langaddress'];
1710                                 foreach($aRecheckWords as $i => $sWord)
1711                                 {
1712                                         if (stripos($sAddress, $sWord)!==false) $iCountWords++;
1713                                 }
1714
1715                                 $aResult['importance'] = $aResult['importance'] + ($iCountWords*0.1); // 0.1 is a completely arbitrary number but something in the range 0.1 to 0.5 would seem right
1716
1717                                 $aResult['name'] = $aResult['langaddress'];
1718                                 // secondary ordering (for results with same importance (the smaller the better):
1719                                 //   - approximate importance of address parts
1720                                 $aResult['foundorder'] = -$aResult['addressimportance']/10;
1721                                 //   - number of exact matches from the query
1722                                 if (isset($this->exactMatchCache[$aResult['place_id']]))
1723                                         $aResult['foundorder'] -= $this->exactMatchCache[$aResult['place_id']];
1724                                 else if (isset($this->exactMatchCache[$aResult['parent_place_id']]))
1725                                         $aResult['foundorder'] -= $this->exactMatchCache[$aResult['parent_place_id']];
1726                                 //  - importance of the class/type
1727                                 if (isset($aClassType[$aResult['class'].':'.$aResult['type']]['importance'])
1728                                         && $aClassType[$aResult['class'].':'.$aResult['type']]['importance'])
1729                                 {
1730                                         $aResult['foundorder'] = $aResult['foundorder'] + 0.000001 * $aClassType[$aResult['class'].':'.$aResult['type']]['importance'];
1731                                 }
1732                                 else
1733                                 {
1734                                         $aResult['foundorder'] = $aResult['foundorder'] + 0.001;
1735                                 }
1736                                 $aSearchResults[$iResNum] = $aResult;
1737                         }
1738                         uasort($aSearchResults, 'byImportance');
1739
1740                         $aOSMIDDone = array();
1741                         $aClassTypeNameDone = array();
1742                         $aToFilter = $aSearchResults;
1743                         $aSearchResults = array();
1744
1745                         $bFirst = true;
1746                         foreach($aToFilter as $iResNum => $aResult)
1747                         {
1748                                 if ($aResult['type'] == 'adminitrative') $aResult['type'] = 'administrative';
1749                                 $this->aExcludePlaceIDs[$aResult['place_id']] = $aResult['place_id'];
1750                                 if ($bFirst)
1751                                 {
1752                                         $fLat = $aResult['lat'];
1753                                         $fLon = $aResult['lon'];
1754                                         if (isset($aResult['zoom'])) $iZoom = $aResult['zoom'];
1755                                         $bFirst = false;
1756                                 }
1757                                 if (!$this->bDeDupe || (!isset($aOSMIDDone[$aResult['osm_type'].$aResult['osm_id']])
1758                                                         && !isset($aClassTypeNameDone[$aResult['osm_type'].$aResult['class'].$aResult['type'].$aResult['name'].$aResult['admin_level']])))
1759                                 {
1760                                         $aOSMIDDone[$aResult['osm_type'].$aResult['osm_id']] = true;
1761                                         $aClassTypeNameDone[$aResult['osm_type'].$aResult['class'].$aResult['type'].$aResult['name'].$aResult['admin_level']] = true;
1762                                         $aSearchResults[] = $aResult;
1763                                 }
1764
1765                                 // Absolute limit on number of results
1766                                 if (sizeof($aSearchResults) >= $this->iFinalLimit) break;
1767                         }
1768
1769                         return $aSearchResults;
1770
1771                 } // end lookup()
1772
1773
1774         } // end class
1775
1776
1777 /*
1778                 if (isset($_GET['route']) && $_GET['route'] && isset($_GET['routewidth']) && $_GET['routewidth'])
1779                 {
1780                         $aPoints = explode(',',$_GET['route']);
1781                         if (sizeof($aPoints) % 2 != 0)
1782                         {
1783                                 userError("Uneven number of points");
1784                                 exit;
1785                         }
1786                         $sViewboxCentreSQL = "ST_SetSRID('LINESTRING(";
1787                         $fPrevCoord = false;
1788                 }
1789 */