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

BoundsT -> Bounds, CellIdT -> CellId

Browse source
This commit is contained in:
tatiana-kondakova 2018-03-13 12:18:58 +03:00 • committed by Vladimir Byko-Ianko
parent d972e38f6f
commit 0f89595283
2 changed files with 35 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
indexer/cell_coverer.hpp
View file

@ -11,16 +11,16 @@
constexpr int SPLIT_RECT_CELLS_COUNT = 512;
template <typename BoundsT, typename CellIdT>
inline size_t SplitRectCell(CellIdT const & id, m2::RectD const & rect,
array<pair<CellIdT, m2::RectD>, 4> & result)
template <typename Bounds, typename CellId>
inline size_t SplitRectCell(CellId const & id, m2::RectD const & rect,
array<pair<CellId, m2::RectD>, 4> & result)
{
size_t index = 0;
for (int8_t i = 0; i < 4; ++i)
{
CellIdT const child = id.Child(i);
auto const child = id.Child(i);
double minCellX, minCellY, maxCellX, maxCellY;
CellIdConverter<BoundsT, CellIdT>::GetCellBounds(child, minCellX, minCellY, maxCellX, maxCellY);
CellIdConverter<Bounds, CellId>::GetCellBounds(child, minCellX, minCellY, maxCellX, maxCellY);
m2::RectD const childRect(minCellX, minCellY, maxCellX, maxCellY);
if (rect.IsIntersect(childRect))
@ -29,22 +29,22 @@ inline size_t SplitRectCell(CellIdT const & id, m2::RectD const & rect,
return index;
}
template <typename BoundsT, typename CellIdT>
inline void CoverRect(m2::RectD rect, size_t cellsCount, int maxDepth, vector<CellIdT> & result)
template <typename Bounds, typename CellId>
inline void CoverRect(m2::RectD rect, size_t cellsCount, int maxDepth, vector<CellId> & result)
{
ASSERT(result.empty(), ());
{
// Cut rect with world bound coordinates.
if (!rect.Intersect({BoundsT::minX, BoundsT::minY, BoundsT::maxX, BoundsT::maxY}))
if (!rect.Intersect(Bounds::FullRect()))
return;
ASSERT(rect.IsValid(), ());
}
CellIdT const commonCell = CellIdConverter<BoundsT, CellIdT>::Cover2PointsWithCell(
auto const commonCell = CellIdConverter<Bounds, CellId>::Cover2PointsWithCell(
rect.minX(), rect.minY(), rect.maxX(), rect.maxY());
priority_queue<CellIdT, buffer_vector<CellIdT, SPLIT_RECT_CELLS_COUNT>,
typename CellIdT::GreaterLevelOrder>
priority_queue<CellId, buffer_vector<CellId, SPLIT_RECT_CELLS_COUNT>,
typename CellId::GreaterLevelOrder>
cellQueue;
cellQueue.push(commonCell);
@ -52,7 +52,7 @@ inline void CoverRect(m2::RectD rect, size_t cellsCount, int maxDepth, vector<Ce
while (!cellQueue.empty() && cellQueue.size() + result.size() < cellsCount)
{
CellIdT id = cellQueue.top();
auto id = cellQueue.top();
cellQueue.pop();
while (id.Level() > maxDepth)
@ -64,8 +64,8 @@ inline void CoverRect(m2::RectD rect, size_t cellsCount, int maxDepth, vector<Ce
break;
}
array<pair<CellIdT, m2::RectD>, 4> arr;
size_t const count = SplitRectCell<BoundsT>(id, rect, arr);
array<pair<CellId, m2::RectD>, 4> arr;
size_t const count = SplitRectCell<Bounds>(id, rect, arr);
if (cellQueue.size() + result.size() + count <= cellsCount)
{
@ -85,11 +85,11 @@ inline void CoverRect(m2::RectD rect, size_t cellsCount, int maxDepth, vector<Ce
for (; !cellQueue.empty(); cellQueue.pop())
{
CellIdT id = cellQueue.top();
auto id = cellQueue.top();
while (id.Level() < maxDepth)
{
array<pair<CellIdT, m2::RectD>, 4> arr;
size_t const count = SplitRectCell<BoundsT>(id, rect, arr);
array<pair<CellId, m2::RectD>, 4> arr;
size_t const count = SplitRectCell<Bounds>(id, rect, arr);
ASSERT_GREATER(count, 0, ());
if (count > 1)
break;

36
indexer/cell_id.hpp
View file

@ -24,33 +24,33 @@ struct Bounds
//typedef Bounds<-180, -90, 180, 90> OrthoBounds;
template <typename BoundsT, typename CellIdT>
template <typename Bounds, typename CellId>
class CellIdConverter
{
public:
static double XToCellIdX(double x)
{
return (x - BoundsT::minX) / StepX();
return (x - Bounds::minX) / StepX();
}
static double YToCellIdY(double y)
{
return (y - BoundsT::minY) / StepY();
return (y - Bounds::minY) / StepY();
}
static double CellIdXToX(double x)
{
return (x*StepX() + BoundsT::minX);
return (x*StepX() + Bounds::minX);
}
static double CellIdYToY(double y)
{
return (y*StepY() + BoundsT::minY);
return (y*StepY() + Bounds::minY);
}
static CellIdT ToCellId(double x, double y)
static CellId ToCellId(double x, double y)
{
uint32_t const ix = static_cast<uint32_t>(XToCellIdX(x));
uint32_t const iy = static_cast<uint32_t>(YToCellIdY(y));
CellIdT id = CellIdT::FromXY(ix, iy, CellIdT::DEPTH_LEVELS - 1);
CellId id = CellId::FromXY(ix, iy, CellId::DEPTH_LEVELS - 1);
#if 0 // DEBUG
pair<uint32_t, uint32_t> ixy = id.XY();
ASSERT(Abs(ixy.first - ix) <= 1, (x, y, id, ixy));
@ -63,10 +63,10 @@ public:
return id;
}
static CellIdT Cover2PointsWithCell(double x1, double y1, double x2, double y2)
static CellId Cover2PointsWithCell(double x1, double y1, double x2, double y2)
{
CellIdT id1 = ToCellId(x1, y1);
CellIdT id2 = ToCellId(x2, y2);
CellId id1 = ToCellId(x1, y1);
CellId id2 = ToCellId(x2, y2);
while (id1 != id2)
{
id1 = id1.Parent();
@ -83,30 +83,30 @@ public:
return id1;
}
static m2::PointD FromCellId(CellIdT id)
static m2::PointD FromCellId(CellId id)
{
pair<uint32_t, uint32_t> const xy = id.XY();
return m2::PointD(CellIdXToX(xy.first), CellIdYToY(xy.second));
}
static void GetCellBounds(CellIdT id,
static void GetCellBounds(CellId id,
double & minX, double & minY, double & maxX, double & maxY)
{
pair<uint32_t, uint32_t> const xy = id.XY();
uint32_t const r = id.Radius();
minX = (xy.first - r) * StepX() + BoundsT::minX;
maxX = (xy.first + r) * StepX() + BoundsT::minX;
minY = (xy.second - r) * StepY() + BoundsT::minY;
maxY = (xy.second + r) * StepY() + BoundsT::minY;
minX = (xy.first - r) * StepX() + Bounds::minX;
maxX = (xy.first + r) * StepX() + Bounds::minX;
minY = (xy.second - r) * StepY() + Bounds::minY;
maxY = (xy.second + r) * StepY() + Bounds::minY;
}
private:
inline static double StepX()
{
return double(BoundsT::maxX - BoundsT::minX) / CellIdT::MAX_COORD;
return double(Bounds::maxX - Bounds::minX) / CellId::MAX_COORD;
}
inline static double StepY()
{
return double(BoundsT::maxY - BoundsT::minY) / CellIdT::MAX_COORD;
return double(Bounds::maxY - Bounds::minY) / CellId::MAX_COORD;
}
};