RedAuburn/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

[search] Limit POI to street match with 100 meters.

Browse source
This commit is contained in:
vng 2016-02-02 12:55:01 +03:00 • committed by Sergey Yershov
parent 436d63fa6b
commit 468bb16a78
8 changed files with 48 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
search/house_detector.cpp
View file

@ -669,7 +669,7 @@ void HouseDetector::ReadHouse(FeatureType const & f, Street * st, ProjectionCalc
m2::PointD const pt = isNew ? f.GetLimitRect(FeatureType::BEST_GEOMETRY).Center() : it->second->GetPosition();
HouseProjection pr;
if (calc.GetProjection(pt, pr))
if (calc.GetProjection(pt, pr) && pr.m_distMeters <= m_houseOffsetM)
{
pr.m_streetDistance =
st->GetPrefixLength(pr.m_segIndex) + st->m_points[pr.m_segIndex].Length(pr.m_proj);
@ -692,15 +692,15 @@ void HouseDetector::ReadHouse(FeatureType const & f, Street * st, ProjectionCalc
}
}
void HouseDetector::ReadHouses(Street * st, double offsetMeters)
void HouseDetector::ReadHouses(Street * st)
{
if (st->m_housesReaded)
return;
//offsetMeters = max(HN_MIN_READ_OFFSET_M, min(GetApprLengthMeters(st->m_number) / 2, offsetMeters));
ProjectionOnStreetCalculator calc(st->m_points, offsetMeters);
m_loader.ForEachInRect(st->GetLimitRect(offsetMeters),
ProjectionOnStreetCalculator calc(st->m_points);
m_loader.ForEachInRect(st->GetLimitRect(m_houseOffsetM),
bind(&HouseDetector::ReadHouse<ProjectionOnStreetCalculator>, this, _1, st, ref(calc)));
st->m_length = st->GetLength();
@ -711,13 +711,13 @@ void HouseDetector::ReadAllHouses(double offsetMeters)
{
m_houseOffsetM = offsetMeters;
for (StreetMapT::iterator it = m_id2st.begin(); it != m_id2st.end(); ++it)
ReadHouses(it->second, offsetMeters);
for (auto const & e : m_id2st)
ReadHouses(e.second);
for (size_t i = 0; i < m_streets.size(); ++i)
for (auto & st : m_streets)
{
if (!m_streets[i].IsHousesReaded())
m_streets[i].FinishReadingHouses();
if (!st.IsHousesReaded())
st.FinishReadingHouses();
}
}

4
search/house_detector.hpp
View file

@ -245,7 +245,7 @@ class HouseDetector
template <class ProjectionCalcT>
void ReadHouse(FeatureType const & f, Street * st, ProjectionCalcT & calc);
void ReadHouses(Street * st, double offsetMeters);
void ReadHouses(Street * st);
void SetMetres2Mercator(double factor);
@ -259,7 +259,7 @@ public:
/// @return number of different joined streets.
int MergeStreets();
static int const DEFAULT_OFFSET_M = ProjectionOnStreetCalculator::kDefaultMaxDistMeters;
static int const DEFAULT_OFFSET_M = 200;
void ReadAllHouses(double offsetMeters = DEFAULT_OFFSET_M);
void GetHouseForName(string const & houseNumber, vector<HouseResult> & res);

29
search/projection_on_street.cpp
View file

@ -4,14 +4,9 @@
#include "geometry/robust_orientation.hpp"
#include "base/assert.hpp"
namespace search
{
namespace
{
} // namespace
// ProjectionOnStreet ------------------------------------------------------------------------------
ProjectionOnStreet::ProjectionOnStreet()
@ -20,11 +15,15 @@ ProjectionOnStreet::ProjectionOnStreet()
}
// ProjectionOnStreetCalculator --------------------------------------------------------------------
ProjectionOnStreetCalculator::ProjectionOnStreetCalculator(vector<m2::PointD> const & points,
double maxDistMeters)
: m_maxDistMeters(maxDistMeters)
ProjectionOnStreetCalculator::ProjectionOnStreetCalculator(vector<m2::PointD> const & points)
{
Init(points);
size_t const count = points.size();
if (count < 2)
return;
m_segProjs.resize(count - 1);
for (size_t i = 0; i + 1 != count; ++i)
m_segProjs[i].SetBounds(points[i], points[i + 1]);
}
bool ProjectionOnStreetCalculator::GetProjection(m2::PointD const & point,
@ -49,17 +48,7 @@ bool ProjectionOnStreetCalculator::GetProjection(m2::PointD const & point,
}
}
return (proj.m_segIndex < kInvalidIndex && proj.m_distMeters <= m_maxDistMeters);
return (proj.m_segIndex < kInvalidIndex);
}
void ProjectionOnStreetCalculator::Init(vector<m2::PointD> const & points)
{
size_t const count = points.size();
if (count < 2)
return;
m_segProjs.resize(count - 1);
for (size_t i = 0; i + 1 != count; ++i)
m_segProjs[i].SetBounds(points[i], points[i + 1]);
}
} // namespace search

7
search/projection_on_street.hpp
View file

@ -29,9 +29,7 @@ struct ProjectionOnStreet
class ProjectionOnStreetCalculator
{
public:
static int constexpr kDefaultMaxDistMeters = 200;
ProjectionOnStreetCalculator(vector<m2::PointD> const & points, double maxDistMeters);
explicit ProjectionOnStreetCalculator(vector<m2::PointD> const & points);
// Finds nearest point on the street to the |point|. If such point
// is located within |m_maxDistMeters|, stores projection in |proj|
@ -40,9 +38,6 @@ public:
bool GetProjection(m2::PointD const & point, ProjectionOnStreet & proj) const;
private:
void Init(vector<m2::PointD> const & points);
vector<m2::ProjectionToSection<m2::PointD>> m_segProjs;
double const m_maxDistMeters;
};
} // namespace search

2
search/v2/features_layer_matcher.cpp
View file

@ -10,8 +10,6 @@ namespace search
{
namespace v2
{
// static
double const FeaturesLayerMatcher::kBuildingRadiusMeters = 50;
FeaturesLayerMatcher::FeaturesLayerMatcher(Index & index, my::Cancellable const & cancellable)
: m_context(nullptr)

26
search/v2/features_layer_matcher.hpp
View file

@ -57,7 +57,8 @@ class FeaturesLayerMatcher
{
public:
static uint32_t const kInvalidId = numeric_limits<uint32_t>::max();
static double const kBuildingRadiusMeters;
static int const kMatchPoiToBuildingRadiusMeters = 50;
static int const kMatchPoiToStreetRadiusMeters = 100;
FeaturesLayerMatcher(Index & index, my::Cancellable const & cancellable);
void SetContext(MwmContext * context);
@ -84,7 +85,7 @@ public:
break;
case SearchModel::SEARCH_TYPE_STREET:
ASSERT(child.m_type == SearchModel::SEARCH_TYPE_POI ||
child.m_type == SearchModel::SEARCH_TYPE_BUILDING,
child.m_type == SearchModel::SEARCH_TYPE_BUILDING,
("Invalid child layer type:", child.m_type));
if (child.m_type == SearchModel::SEARCH_TYPE_POI)
MatchPOIsWithStreets(child, parent, forward<TFn>(fn));
@ -138,7 +139,7 @@ private:
continue;
double const distMeters = feature::GetMinDistanceMeters(buildingFt, poiCenters[j]);
if (distMeters <= kBuildingRadiusMeters)
if (distMeters <= kMatchPoiToBuildingRadiusMeters)
{
fn(pois[j], buildings[i]);
isPOIProcessed[j] = true;
@ -161,13 +162,13 @@ private:
for (size_t i = 0; i < pois.size(); ++i)
{
m_context->ForEachFeature(
MercatorBounds::RectByCenterXYAndSizeInMeters(poiCenters[i], kBuildingRadiusMeters),
MercatorBounds::RectByCenterXYAndSizeInMeters(poiCenters[i], kMatchPoiToBuildingRadiusMeters),
[&](FeatureType & ft)
{
if (HouseNumbersMatch(strings::MakeUniString(ft.GetHouseNumber()), queryTokens))
{
double const distanceM = MercatorBounds::DistanceOnEarth(feature::GetCenter(ft), poiCenters[i]);
if (distanceM < kBuildingRadiusMeters)
if (distanceM < kMatchPoiToBuildingRadiusMeters)
fn(pois[i], ft.GetID().m_index);
}
});
@ -191,6 +192,9 @@ private:
{
for (auto const & street : GetNearbyStreets(poiId))
{
if (street.m_distanceMeters > kMatchPoiToStreetRadiusMeters)
break;
uint32_t const streetId = street.m_id.m_index;
if (binary_search(streets.begin(), streets.end(), streetId))
fn(poiId, streetId);
@ -202,7 +206,8 @@ private:
for (uint32_t streetId : streets)
{
BailIfCancelled(m_cancellable);
m_loader.ForEachInVicinity(streetId, pois, bind(fn, _1, streetId));
m_loader.ForEachInVicinity(streetId, pois, kMatchPoiToStreetRadiusMeters,
bind(fn, _1, streetId));
}
}
@ -308,11 +313,12 @@ private:
// house-to-street table was generated by using high-precision
// centers of features.
m2::PointD const center = feature::GetCenter(feature);
if (!calculator.GetProjection(center, proj))
continue;
if (GetMatchingStreet(houseId, feature) == streetId)
if (calculator.GetProjection(center, proj) &&
proj.m_distMeters <= ReverseGeocoder::kLookupRadiusM &&
GetMatchingStreet(houseId, feature) == streetId)
{
fn(houseId, streetId);
}
}
}
}

2
search/v2/street_vicinity_loader.cpp
View file

@ -69,7 +69,7 @@ void StreetVicinityLoader::LoadStreet(uint32_t featureId, Street & street)
interval.first, interval.second, m_scale);
}
street.m_calculator = make_unique<ProjectionOnStreetCalculator>(points, m_offsetMeters);
street.m_calculator = make_unique<ProjectionOnStreetCalculator>(points);
}
} // namespace v2
} // namespace search

14
search/v2/street_vicinity_loader.hpp
View file

@ -49,8 +49,12 @@ public:
// Calls |fn| on each index in |sortedIds| where sortedIds[index]
// belongs to the street's vicinity.
template <typename TFn>
void ForEachInVicinity(uint32_t streetId, vector<uint32_t> const & sortedIds, TFn const & fn)
void ForEachInVicinity(uint32_t streetId, vector<uint32_t> const & sortedIds,
double offsetMeters, TFn const & fn)
{
// Passed offset param should be less than the cached one, or the cache is invalid otherwise.
ASSERT_LESS_OR_EQUAL(offsetMeters, m_offsetMeters, ());
Street const & street = GetStreet(streetId);
if (street.IsEmpty())
return;
@ -65,10 +69,12 @@ public:
FeatureType ft;
m_context->GetFeature(id, ft);
if (!calculator.GetProjection(feature::GetCenter(ft, FeatureType::WORST_GEOMETRY), proj))
continue;
fn(id);
if (calculator.GetProjection(feature::GetCenter(ft, FeatureType::WORST_GEOMETRY), proj) &&
proj.m_distMeters <= offsetMeters)
{
fn(id);
}
}
}