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

[drape] rebase fixes

Browse source
This commit is contained in:
ExMix 2014-01-27 13:28:09 +03:00 • committed by Alex Zolotarev
parent e0bff29400
commit 45705dea1f
6 changed files with 205 additions and 199 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

254
drape_frontend/read_manager.cpp
View file

@ -12,165 +12,165 @@
namespace df
{
namespace
{
struct LessCoverageCell
{
bool operator()(shared_ptr<TileInfo> const & l, TileKey const & r) const
namespace
{
return l->GetTileKey() < r;
struct LessCoverageCell
{
bool operator()(shared_ptr<TileInfo> const & l, TileKey const & r) const
{
return l->GetTileKey() < r;
}
bool operator()(TileKey const & l, shared_ptr<TileInfo> const & r) const
{
return l < r->GetTileKey();
}
};
TileKey TileInfoPtrToTileKey(shared_ptr<TileInfo> const & p)
{
return p->GetTileKey();
}
}
bool operator()(TileKey const & l, shared_ptr<TileInfo> const & r) const
ReadManager::ReadManager(double visualScale, int w, int h,
EngineContext & context,
model::FeaturesFetcher & model)
: m_context(context)
, m_model(model)
{
return l < r->GetTileKey();
m_scalesProcessor.SetParams(visualScale, ScalesProcessor::CalculateTileSize(w, h));
m_pool.Reset(new threads::ThreadPool(ReadCount(), bind(&ReadManager::OnTaskFinished, this, _1)));
}
};
TileKey TileInfoPtrToTileKey(shared_ptr<TileInfo> const & p)
{
return p->GetTileKey();
}
}
ReadManager::ReadManager(double visualScale, int w, int h,
EngineContext & context,
model::FeaturesFetcher & model)
: m_context(context)
, m_model(model)
{
m_scalesProcessor.SetParams(visualScale, ScalesProcessor::CalculateTileSize(w, h));
m_pool.Reset(new threads::ThreadPool(ReadCount(), bind(&ReadManager::OnTaskFinished, this, _1)));
}
void ReadManager::OnTaskFinished(threads::IRoutine * task)
{
delete task;
}
void ReadManager::UpdateCoverage(const ScreenBase & screen, CoverageUpdateDescriptor & updateDescr)
{
if (screen == m_currentViewport)
return;
set<TileKey> tiles;
GetTileKeys(tiles, screen);
if (MustDropAllTiles(screen))
void ReadManager::OnTaskFinished(threads::IRoutine * task)
{
delete task;
}
void ReadManager::UpdateCoverage(const ScreenBase & screen, CoverageUpdateDescriptor & updateDescr)
{
if (screen == m_currentViewport)
return;
set<TileKey> tiles;
GetTileKeys(tiles, screen);
if (MustDropAllTiles(screen))
{
for_each(m_tileInfos.begin(), m_tileInfos.end(), bind(&ReadManager::CancelTileInfo, this, _1));
m_tileInfos.clear();
for_each(tiles.begin(), tiles.end(), bind(&ReadManager::PushTaskBackForTileKey, this, _1));
updateDescr.DoDropAll();
}
else
{
// Find rects that go out from viewport
buffer_vector<tileinfo_ptr, 8> outdatedTiles;
set_difference(m_tileInfos.begin(), m_tileInfos.end(),
tiles.begin(), tiles.end(),
back_inserter(outdatedTiles), LessCoverageCell());
// Find rects that go in into viewport
buffer_vector<TileKey, 8> inputRects;
set_difference(tiles.begin(), tiles.end(),
m_tileInfos.begin(), m_tileInfos.end(),
back_inserter(inputRects), LessCoverageCell());
for_each(outdatedTiles.begin(), outdatedTiles.end(), bind(&ReadManager::ClearTileInfo, this, _1));
buffer_vector<TileKey, 16> outdatedTileKeys;
transform(outdatedTiles.begin(), outdatedTiles.end(),
back_inserter(outdatedTileKeys), &TileInfoPtrToTileKey);
updateDescr.DropTiles(outdatedTileKeys.data(), outdatedTileKeys.size());
for_each(m_tileInfos.begin(), m_tileInfos.end(), bind(&ReadManager::PushTaskFront, this, _1));
for_each(inputRects.begin(), inputRects.end(), bind(&ReadManager::PushTaskBackForTileKey, this, _1));
}
m_currentViewport = screen;
}
void ReadManager::Resize(const m2::RectI & rect)
{
m_currentViewport.OnSize(rect);
}
void ReadManager::Stop()
{
for_each(m_tileInfos.begin(), m_tileInfos.end(), bind(&ReadManager::CancelTileInfo, this, _1));
m_tileInfos.clear();
for_each(tiles.begin(), tiles.end(), bind(&ReadManager::PushTaskBackForTileKey, this, _1));
updateDescr.DoDropAll();
m_pool->Stop();
m_pool.Destroy();
}
else
size_t ReadManager::ReadCount()
{
// Find rects that go out from viewport
buffer_vector<tileinfo_ptr, 8> outdatedTiles;
set_difference(m_tileInfos.begin(), m_tileInfos.end(),
tiles.begin(), tiles.end(),
back_inserter(outdatedTiles), LessCoverageCell());
// Find rects that go in into viewport
buffer_vector<TileKey, 8> inputRects;
set_difference(tiles.begin(), tiles.end(),
m_tileInfos.begin(), m_tileInfos.end(),
back_inserter(inputRects), LessCoverageCell());
for_each(outdatedTiles.begin(), outdatedTiles.end(), bind(&ReadManager::ClearTileInfo, this, _1));
buffer_vector<TileKey, 16> outdatedTileKeys;
transform(outdatedTiles.begin(), outdatedTiles.end(),
back_inserter(outdatedTileKeys), &TileInfoPtrToTileKey);
updateDescr.DropTiles(outdatedTileKeys.data(), outdatedTileKeys.size());
for_each(m_tileInfos.begin(), m_tileInfos.end(), bind(&ReadManager::PushTaskFront, this, _1));
for_each(inputRects.begin(), inputRects.end(), bind(&ReadManager::PushTaskBackForTileKey, this, _1));
return max(GetPlatform().CpuCores() - 2, 1);
}
m_currentViewport = screen;
}
void ReadManager::Resize(const m2::RectI & rect)
{
m_currentViewport.OnSize(rect);
}
void ReadManager::GetTileKeys(set<TileKey> & out, ScreenBase const & screen) const
{
out.clear();
void ReadManager::Stop()
{
for_each(m_tileInfos.begin(), m_tileInfos.end(), bind(&ReadManager::CancelTileInfo, this, _1));
m_tileInfos.clear();
int const tileScale = m_scalesProcessor.GetTileScaleBase(screen);
// equal for x and y
double const range = MercatorBounds::maxX - MercatorBounds::minX;
double const rectSize = range / (1 << tileScale);
m_pool->Stop();
m_pool.Destroy();
}
m2::AnyRectD const & globalRect = screen.GlobalRect();
m2::RectD const & clipRect = globalRect.GetGlobalRect();
size_t ReadManager::ReadCount()
{
return max(GetPlatform().CpuCores() - 2, 1);
}
int const minTileX = static_cast<int>(floor(clipRect.minX() / rectSize));
int const maxTileX = static_cast<int>(ceil(clipRect.maxX() / rectSize));
int const minTileY = static_cast<int>(floor(clipRect.minY() / rectSize));
int const maxTileY = static_cast<int>(ceil(clipRect.maxY() / rectSize));
void ReadManager::GetTileKeys(set<TileKey> & out, ScreenBase const & screen) const
{
out.clear();
for (int tileY = minTileY; tileY < maxTileY; ++tileY)
for (int tileX = minTileX; tileX < maxTileX; ++tileX)
{
double const left = tileX * rectSize;
double const top = tileY * rectSize;
int const tileScale = m_scalesProcessor.GetTileScaleBase(screen);
// equal for x and y
double const range = MercatorBounds::maxX - MercatorBounds::minX;
double const rectSize = range / (1 << tileScale);
m2::RectD currentTileRect(left, top,
left + rectSize, top + rectSize);
m2::AnyRectD const & globalRect = screen.GlobalRect();
m2::RectD const & clipRect = globalRect.GetGlobalRect();
if (globalRect.IsIntersect(m2::AnyRectD(currentTileRect)))
out.insert(TileKey(tileX, tileY, tileScale));
}
}
int const minTileX = static_cast<int>(floor(clipRect.minX() / rectSize));
int const maxTileX = static_cast<int>(ceil(clipRect.maxX() / rectSize));
int const minTileY = static_cast<int>(floor(clipRect.minY() / rectSize));
int const maxTileY = static_cast<int>(ceil(clipRect.maxY() / rectSize));
bool ReadManager::MustDropAllTiles(ScreenBase const & screen) const
{
const int oldScale = m_scalesProcessor.GetTileScaleBase(m_currentViewport);
const int newScale = m_scalesProcessor.GetTileScaleBase(screen);
return (oldScale != newScale) || !m_currentViewport.GlobalRect().IsIntersect(screen.GlobalRect());
}
for (int tileY = minTileY; tileY < maxTileY; ++tileY)
for (int tileX = minTileX; tileX < maxTileX; ++tileX)
{
double const left = tileX * rectSize;
double const top = tileY * rectSize;
m2::RectD currentTileRect(left, top,
left + rectSize, top + rectSize);
if (globalRect.IsIntersect(m2::AnyRectD(currentTileRect)))
out.insert(TileKey(tileX, tileY, tileScale));
}
}
bool ReadManager::MustDropAllTiles(ScreenBase const & screen) const
{
const int oldScale = m_scalesProcessor.GetTileScaleBase(m_currentViewport);
const int newScale = m_scalesProcessor.GetTileScaleBase(screen);
return (oldScale != newScale) || !m_currentViewport.GlobalRect().IsIntersect(screen.GlobalRect());
}
void ReadManager::PushTaskBackForTileKey(TileKey const & tileKey)
{
void ReadManager::PushTaskBackForTileKey(TileKey const & tileKey)
{
tileinfo_ptr tileInfo(new TileInfo(tileKey));
m_tileInfos.insert(tileInfo);
m_pool->PushBack(new ReadMWMTask(tileInfo, m_memIndex, m_model, m_context));
}
m_tileInfos.insert(tileInfo);
m_pool->PushBack(new ReadMWMTask(tileInfo, m_memIndex, m_model, m_context));
}
void ReadManager::PushTaskFront(tileinfo_ptr const & tileToReread)
{
m_pool->PushFront(new ReadMWMTask(tileToReread, m_memIndex, m_model, m_context));
}
{
m_pool->PushFront(new ReadMWMTask(tileToReread, m_memIndex, m_model, m_context));
}
void ReadManager::CancelTileInfo(tileinfo_ptr tileToCancel)
{
{
tileToCancel->Cancel(m_memIndex);
}
void ReadManager::ClearTileInfo(tileinfo_ptr & tileToClear)
{
CancelTileInfo(tileToClear);
m_tileInfos.erase(tileToClear);
}
m_tileInfos.erase(tileToClear);
}
}

1
drape_frontend/read_manager.hpp
View file

@ -45,7 +45,6 @@ namespace df
void PushTaskFront(tileinfo_ptr const & tileToReread);
private:
MemoryFeatureIndex m_memIndex;
EngineContext & m_context;

1
drape_frontend/read_mwm_task.cpp
View file

@ -4,7 +4,6 @@
namespace df
{
ReadMWMTask::ReadMWMTask(weak_ptr<TileInfo> const & tileInfo,
MemoryFeatureIndex & memIndex,
model::FeaturesFetcher & model,

64
drape_frontend/tile_info.cpp
View file

@ -38,7 +38,7 @@ namespace
}
df::LineShape * CreateFakeLine1()
{
{
vector<m2::PointF> points;
const float magn = 4;
@ -60,11 +60,28 @@ namespace
points.push_back(m2::PointF(0,0));
return new df::LineShape(points, Extract(0xFF00FF00), .5f, 0.5f);
}
}
struct IDsAccumulator
{
IDsAccumulator(vector<FeatureID> & ids, vector<df::FeatureInfo> const & src)
: m_ids(ids)
, m_src(src)
{
}
void operator()(size_t index)
{
ASSERT_LESS(index, m_src.size(), ());
m_ids.push_back(m_src[index].m_id);
}
vector<FeatureID> & m_ids;
vector<df::FeatureInfo> const & m_src;
};
}
namespace df
{
{
TileInfo::TileInfo(TileKey const & key)
: m_key(key)
{}
@ -94,27 +111,6 @@ namespace df
}
}
namespace
{
struct IDsAccumulator
{
IDsAccumulator(vector<FeatureID> & ids, vector<FeatureInfo> const & src)
: m_ids(ids)
, m_src(src)
{
}
void operator()(size_t index)
{
ASSERT_LESS(index, m_src.size(), ());
m_ids.push_back(m_src[index].m_id);
}
vector<FeatureID> & m_ids;
vector<FeatureInfo> const & m_src;
};
}
void TileInfo::ReadFeatures(model::FeaturesFetcher const & model,
MemoryFeatureIndex & memIndex,
EngineContext & context)
@ -123,10 +119,22 @@ namespace df
vector<size_t> indexes;
RequestFeatures(memIndex, indexes);
vector<FeatureID> featuresToRead;
for_each(indexes.begin(), indexes.end(), IDsAccumulator(featuresToRead, m_featureInfo));
if (!indexes.empty() && m_key == TileKey(0,0,3))
{
context.BeginReadTile(m_key);
{
context.InsertShape(m_key, MovePointer<MapShape>(CreateFakeShape1()));
context.InsertShape(m_key, MovePointer<MapShape>(CreateFakeShape2()));
context.InsertShape(m_key, MovePointer<MapShape>(CreateFakeLine1()));
context.InsertShape(m_key, MovePointer<MapShape>(CreateFakeLine2()));
}
context.EndReadTile(m_key);
}
model.ReadFeatures(*this, featuresToRead);
// vector<FeatureID> featuresToRead;
// for_each(indexes.begin(), indexes.end(), IDsAccumulator(featuresToRead, m_featureInfo));
// model.ReadFeatures(*this, featuresToRead);
}
void TileInfo::Cancel(MemoryFeatureIndex & memIndex)

82
drape_frontend/tile_info.hpp
View file

@ -19,41 +19,41 @@ class FeatureType;
namespace df
{
class EngineContext;
class EngineContext;
struct TileKey
{
public:
TileKey() : m_x(-1), m_y(-1), m_zoomLevel(-1) {}
TileKey(int x, int y, int zoomLevel)
: m_x(x), m_y(y), m_zoomLevel(zoomLevel) {}
bool operator < (const TileKey & other) const
struct TileKey
{
if (m_zoomLevel != other.m_zoomLevel)
return m_zoomLevel < other.m_zoomLevel;
if (m_y != other.m_y)
return m_y < other.m_y;
public:
TileKey() : m_x(-1), m_y(-1), m_zoomLevel(-1) {}
TileKey(int x, int y, int zoomLevel)
: m_x(x), m_y(y), m_zoomLevel(zoomLevel) {}
return m_x < other.m_x;
}
bool operator < (const TileKey & other) const
{
if (m_zoomLevel != other.m_zoomLevel)
return m_zoomLevel < other.m_zoomLevel;
if (m_y != other.m_y)
return m_y < other.m_y;
bool operator == (const TileKey & other) const
return m_x < other.m_x;
}
bool operator == (const TileKey & other) const
{
return m_x == other.m_x &&
m_y == other.m_y &&
m_zoomLevel == other.m_zoomLevel;
}
int m_x;
int m_y;
int m_zoomLevel;
};
class TileInfo : private noncopyable
{
return m_x == other.m_x &&
m_y == other.m_y &&
m_zoomLevel == other.m_zoomLevel;
}
int m_x;
int m_y;
int m_zoomLevel;
};
class TileInfo : private noncopyable
{
public:
DECLARE_EXCEPTION(ReadCanceledException, RootException);
public:
DECLARE_EXCEPTION(ReadCanceledException, RootException);
TileInfo(TileKey const & key);
@ -63,23 +63,23 @@ public:
EngineContext & context);
void Cancel(MemoryFeatureIndex & memIndex);
m2::RectD GetGlobalRect() const;
TileKey const & GetTileKey() const { return m_key; }
m2::RectD GetGlobalRect() const;
TileKey const & GetTileKey() const { return m_key; }
void operator ()(FeatureID const & id);
bool operator ()(FeatureType const & f);
bool operator <(TileInfo const & other) const { return m_key < other.m_key; }
private:
private:
void RequestFeatures(MemoryFeatureIndex & memIndex, vector<size_t> & featureIndexes);
void CheckCanceled();
bool DoNeedReadIndex() const;
void CheckCanceled();
bool DoNeedReadIndex() const;
private:
TileKey m_key;
vector<FeatureInfo> m_featureInfo;
private:
TileKey m_key;
vector<FeatureInfo> m_featureInfo;
bool m_isCanceled;
threads::Mutex m_mutex;
};
bool m_isCanceled;
threads::Mutex m_mutex;
};
}

2
drape_head/drape_surface.cpp
View file

@ -65,7 +65,7 @@ void DrapeSurface::CreateEngine()
sizeChanged(0);
m_timerID = startTimer(1000 / 30);
//m_timerID = startTimer(1000 / 30);
}
void DrapeSurface::sizeChanged(int)