]> git.openstreetmap.org Git - nominatim.git/commitdiff
Merge remote-tracking branch 'upstream/master'
authorSarah Hoffmann <lonvia@denofr.de>
Mon, 26 Mar 2018 18:57:29 +0000 (20:57 +0200)
committerSarah Hoffmann <lonvia@denofr.de>
Mon, 26 Mar 2018 18:57:29 +0000 (20:57 +0200)
1  2 
lib/Geocode.php
lib/lib.php
website/reverse.php

diff --combined lib/Geocode.php
index 184fd0f540974795178540d178a9f69133419924,d00104178fe7459de78789977c82b9fff7ca9565..017d7ad9a3924984cacecd253e6b95dc1327ffa3
@@@ -19,7 -19,7 +19,7 @@@ class Geocod
      protected $bIncludeAddressDetails = false;
  
      protected $aExcludePlaceIDs = array();
 -    protected $bReverseInPlan = false;
 +    protected $bReverseInPlan = true;
  
      protected $iLimit = 20;
      protected $iFinalLimit = 10;
          $this->loadStructuredAddressElement($sPostalCode, 'postalcode', 5, 11, array(5, 11));
          $this->loadStructuredAddressElement($sCountry, 'country', 4, 4, false);
  
-         if (sizeof($this->aStructuredQuery) > 0) {
+         if (!empty($this->aStructuredQuery)) {
              $this->sQuery = join(', ', $this->aStructuredQuery);
              if ($this->iMaxAddressRank < 30) {
                  $this->sAllowedTypesSQLList = '(\'place\',\'boundary\')';
  
          $aParams = $this->aStructuredQuery;
  
-         if (sizeof($aParams) == 1) return false;
+         if (count($aParams) == 1) return false;
  
          $aOrderToFallback = array('postalcode', 'street', 'city', 'county', 'state');
  
                                      $sPhraseType,
                                      $iToken == 0 && $iPhrase == 0,
                                      $iPhrase == 0,
-                                     $iToken + 1 == sizeof($aWordset)
-                                       && $iPhrase + 1 == sizeof($aPhrases)
+                                     $iToken + 1 == count($aWordset)
+                                       && $iPhrase + 1 == count($aPhrases)
                                  );
  
                                  foreach ($aNewSearches as $oSearch) {
                      usort($aNewWordsetSearches, array('Nominatim\SearchDescription', 'bySearchRank'));
                      $aWordsetSearches = array_slice($aNewWordsetSearches, 0, 50);
                  }
-                 //var_Dump('<hr>',sizeof($aWordsetSearches)); exit;
+                 //var_Dump('<hr>',count($aWordsetSearches)); exit;
  
                  $aNewPhraseSearches = array_merge($aNewPhraseSearches, $aNewWordsetSearches);
                  usort($aNewPhraseSearches, array('Nominatim\SearchDescription', 'bySearchRank'));
              $iSearchCount = 0;
              $aSearches = array();
              foreach ($aGroupedSearches as $iScore => $aNewSearches) {
-                 $iSearchCount += sizeof($aNewSearches);
+                 $iSearchCount += count($aNewSearches);
                  $aSearches = array_merge($aSearches, $aNewSearches);
                  if ($iSearchCount > 50) break;
              }
-             //if (CONST_Debug) _debugDumpGroupedSearches($aGroupedSearches, $aValidTokens);
          }
  
          // Revisit searches, drop bad searches and give penalty to unlikely combinations.
  
      public function lookup()
      {
+         Debug::newFunction('Geocode::lookup');
          if (!$this->sQuery && !$this->aStructuredQuery) return array();
  
+         Debug::printDebugArray('Geocode', $this);
          $oCtx = new SearchContext();
  
          if ($this->aRoutePoints) {
              $oCtx->setCountryList($this->aCountryCodes);
          }
  
+         Debug::newSection('Query Preprocessing');
          $sNormQuery = $this->normTerm($this->sQuery);
+         Debug::printVar('Normalized query', $sNormQuery);
          $sLanguagePrefArraySQL = getArraySQL(
              array_map('getDBQuoted', $this->aLangPrefOrder)
          );
                      $aSpecialTermsRaw,
                      PREG_SET_ORDER
                  );
+                 if (!empty($aSpecialTermsRaw)) {
+                     Debug::printVar('Special terms', $aSpecialTermsRaw);
+                 }
                  foreach ($aSpecialTermsRaw as $aSpecialTerm) {
                      $sQuery = str_replace($aSpecialTerm[0], ' ', $sQuery);
                      if (!$sSpecialTerm) {
                  $sSQL = 'SELECT class, type FROM word ';
                  $sSQL .= '   WHERE word_token in (\' '.$sToken.'\')';
                  $sSQL .= '   AND class is not null AND class not in (\'place\')';
-                 if (CONST_Debug) var_Dump($sSQL);
+                 Debug::printSQL($sSQL);
                  $aSearchWords = chksql($this->oDB->getAll($sSQL));
                  $aNewSearches = array();
                  foreach ($aSearches as $oSearch) {
                  $bStructuredPhrases = false;
              }
  
+             Debug::printDebugArray('Search context', $oCtx);
+             Debug::printDebugArray('Base search', $aSearches[0]);
+             Debug::printVar('Final query phrases', $aInPhrases);
              // Convert each phrase to standard form
              // Create a list of standard words
              // Get all 'sets' of words
              // Generate a complete list of all
+             Debug::newSection('Tokenization');
              $aTokens = array();
              $aPhrases = array();
              foreach ($aInPhrases as $iPhrase => $sPhrase) {
                  }
              }
  
-             if (sizeof($aTokens)) {
+             Debug::printDebugTable('Phrases', $aPhrases);
+             Debug::printVar('Tokens', $aTokens);
+             if (!empty($aTokens)) {
                  // Check which tokens we have, get the ID numbers
                  $sSQL = 'SELECT word_id, word_token, word, class, type, country_code, operator, search_name_count';
                  $sSQL .= ' FROM word ';
                  $sSQL .= ' WHERE word_token in ('.join(',', array_map('getDBQuoted', $aTokens)).')';
  
-                 if (CONST_Debug) var_Dump($sSQL);
+                 Debug::printSQL($sSQL);
  
                  $aValidTokens = array();
                  $aDatabaseWords = chksql(
                      }
                      $aWordFrequencyScores[$aToken['word_id']] = $aToken['search_name_count'] + 1;
                  }
-                 if (CONST_Debug) var_Dump($aPhrases, $aValidTokens);
  
                  // US ZIP+4 codes - if there is no token, merge in the 5-digit ZIP code
                  foreach ($aTokens as $sToken) {
                          $aValidTokens[' '.$sToken] = array(array('class' => 'place', 'type' => 'house', 'word_token' => ' '.$sToken));
                      }
                  }
+                 Debug::printGroupTable('Valid Tokens', $aValidTokens);
  
                  // Any words that have failed completely?
                  // TODO: suggestions
+                 Debug::newSection('Search candidates');
  
                  $aGroupedSearches = $this->getGroupedSearches($aSearches, $aPhrases, $aValidTokens, $bStructuredPhrases);
  
                      // because order in the address doesn't matter.
                      $aPhrases = array_reverse($aPhrases);
                      $aPhrases[0]->invertWordSets();
-                     if (sizeof($aPhrases) > 1) {
-                         $aPhrases[sizeof($aPhrases)-1]->invertWordSets();
+                     if (count($aPhrases) > 1) {
+                         $aPhrases[count($aPhrases)-1]->invertWordSets();
                      }
                      $aReverseGroupedSearches = $this->getGroupedSearches($aSearches, $aPhrases, $aValidTokens, false);
  
                      $sHash = serialize($aSearch);
                      if (isset($aSearchHash[$sHash])) {
                          unset($aGroupedSearches[$iGroup][$iSearch]);
-                         if (sizeof($aGroupedSearches[$iGroup]) == 0) unset($aGroupedSearches[$iGroup]);
+                         if (empty($aGroupedSearches[$iGroup])) unset($aGroupedSearches[$iGroup]);
                      } else {
                          $aSearchHash[$sHash] = 1;
                      }
                      if ($iQueryLoop > 20) break;
                  }
  
-                 if (sizeof($aResults) && ($this->iMinAddressRank != 0 || $this->iMaxAddressRank != 30)) {
+                 if (!empty($aResults) && ($this->iMinAddressRank != 0 || $this->iMaxAddressRank != 30)) {
                      // Need to verify passes rank limits before dropping out of the loop (yuk!)
                      // reduces the number of place ids, like a filter
                      // rank_address is 30 for interpolated housenumbers
                      $aFilteredIDs = array();
                      if ($aFilterSql) {
                          $sSQL = join(' UNION ', $aFilterSql);
-                         if (CONST_Debug) var_dump($sSQL);
+                         Debug::printSQL($sSQL);
                          $aFilteredIDs = chksql($this->oDB->getCol($sSQL));
                      }
  
                      $aResults = $tempIDs;
                  }
  
-                 if (sizeof($aResults)) break;
+                 if (!empty($aResults)) break;
                  if ($iGroupLoop > 4) break;
                  if ($iQueryLoop > 30) break;
              }
  
              $oLookup = $oReverse->lookupPoint($oCtx->sqlNear, false);
  
-             if (CONST_Debug) var_dump('Reverse search', $aLookup);
+             Debug::printVar('Reverse search', $oLookup);
  
              if ($oLookup) {
                  $aResults = array($oLookup->iId => $oLookup);
          }
  
          // No results? Done
-         if (!sizeof($aResults)) {
+         if (empty($aResults)) {
              if ($this->bFallback) {
                  if ($this->fallbackStructuredQuery()) {
                      return $this->lookup();
              if (!preg_match('/[\pL\pN]/', $sWord)) unset($aRecheckWords[$i]);
          }
  
-         if (CONST_Debug) {
-             echo '<i>Recheck words:<\i>';
-             var_dump($aRecheckWords);
-         }
+         Debug::printVar('Recheck words', $aRecheckWords);
  
          foreach ($aSearchResults as $iIdx => $aResult) {
              // Default
                      $aResult['foundorder'] += 0.01;
                  }
              }
-             if (CONST_Debug) var_dump($aResult);
              $aSearchResults[$iIdx] = $aResult;
          }
          uasort($aSearchResults, 'byImportance');
+         Debug::printVar('Pre-filter results', $aSearchResults);
  
          $aOSMIDDone = array();
          $aClassTypeNameDone = array();
          $aToFilter = $aSearchResults;
          $aSearchResults = array();
  
-         if (CONST_Debug) var_dump($aToFilter);
          $bFirst = true;
          foreach ($aToFilter as $aResult) {
              $this->aExcludePlaceIDs[$aResult['place_id']] = $aResult['place_id'];
              }
  
              // Absolute limit on number of results
-             if (sizeof($aSearchResults) >= $this->iFinalLimit) break;
+             if (count($aSearchResults) >= $this->iFinalLimit) break;
          }
  
-         if (CONST_Debug) var_dump($aSearchResults);
+         Debug::printVar('Post-filter results', $aSearchResults);
          return $aSearchResults;
      } // end lookup()
+     public function debugInfo()
+     {
+         return array(
+                 'Query' => $this->sQuery,
+                 'Structured query' => $this->aStructuredQuery,
+                 'Name keys' => Debug::fmtArrayVals($this->aLangPrefOrder),
+                 'Include address' => $this->bIncludeAddressDetails,
+                 'Excluded place IDs' => Debug::fmtArrayVals($this->aExcludePlaceIDs),
+                 'Try reversed query'=> $this->bReverseInPlan,
+                 'Limit (for searches)' => $this->iLimit,
+                 'Limit (for results)'=> $this->iFinalLimit,
+                 'Country codes' => Debug::fmtArrayVals($this->aCountryCodes),
+                 'Bounded search' => $this->bBoundedSearch,
+                 'Viewbox' => Debug::fmtArrayVals($this->aViewBox),
+                 'Route points' => Debug::fmtArrayVals($this->aRoutePoints),
+                 'Route width' => $this->aRouteWidth,
+                 'Max rank' => $this->iMaxRank,
+                 'Min address rank' => $this->iMinAddressRank,
+                 'Max address rank' => $this->iMaxAddressRank,
+                 'Address rank list' => Debug::fmtArrayVals($this->aAddressRankList)
+                );
+     }
  } // end class
diff --combined lib/lib.php
index d7ccf2d2943e83da87f2eb146827a76b67253f28,3c70d1de7c822d0c6b15e7a6d7cec29be2fda1df..fa71d296277ef35a71f047c94673f870f8f34d86
@@@ -14,7 -14,7 +14,7 @@@ function getProcessorCount(
  {
      $sCPU = file_get_contents('/proc/cpuinfo');
      preg_match_all('#processor\s+: [0-9]+#', $sCPU, $aMatches);
-     return sizeof($aMatches[0]);
+     return count($aMatches[0]);
  }
  
  
@@@ -585,10 -585,10 +585,10 @@@ function geometryText2Points($geometry_
          //
          preg_match_all('/(-?[0-9.]+) (-?[0-9.]+)/', $aMatch[1], $aPolyPoints, PREG_SET_ORDER);
          //
 -    } elseif (preg_match('#MULTIPOLYGON\\(\\(\\(([- 0-9.,]+)#', $geometry_as_text, $aMatch)) {
 +/*    } elseif (preg_match('#MULTIPOLYGON\\(\\(\\(([- 0-9.,]+)#', $geometry_as_text, $aMatch)) {
          //
          preg_match_all('/(-?[0-9.]+) (-?[0-9.]+)/', $aMatch[1], $aPolyPoints, PREG_SET_ORDER);
 -        //
 +        */
      } elseif (preg_match('#POINT\\((-?[0-9.]+) (-?[0-9.]+)\\)#', $geometry_as_text, $aMatch)) {
          //
          $aPolyPoints = createPointsAroundCenter($aMatch[1], $aMatch[2], $fRadius);
diff --combined website/reverse.php
index 9660f36d8c7231e3d27e5f78f2ecc115ef73e509,4ce5833f6129bb9a884a5ae6ee0708e7ac29f2fd..822081ef7d4caff8973550e909400db78865d599
@@@ -41,7 -41,7 +41,7 @@@ if ($sOsmType && $iOsmId > 0) 
  
      if ($oLookup) {
          $aPlaces = $oPlaceLookup->lookup(array($oLookup->iId => $oLookup));
-         if (sizeof($aPlaces)) {
+         if (!empty($aPlaces)) {
              $aPlace = reset($aPlaces);
          }
      }
@@@ -65,7 -65,6 +65,7 @@@ if (isset($aPlace)) 
      $aPlace = [];
  }
  
 +logEnd($oDB, $hLog, sizeof($aPlace)?1:0);
  
  if (CONST_Debug) {
      var_dump($aPlace);