lib/Geocode.php

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