kirylkaveryn/organicmaps
1
Fork 0
forked from organicmaps/organicmaps-tmp
Code Pull requests Activity

[drape] styles extracting

Browse source
This commit is contained in:
ExMix 2014-01-24 14:30:25 +03:00 • committed by Alex Zolotarev
parent 4afa6a1aef
commit e0bff29400
5 changed files with 480 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
drape_frontend/backend_renderer.cpp
View file

@ -22,6 +22,7 @@ namespace df
, m_contextFactory(oglcontextfactory)
{
///{ Temporary initialization
m_model.InitClassificator();
Platform::FilesList maps;
Platform & pl = GetPlatform();
pl.GetFilesByExt(pl.WritableDir(), DATA_FILE_EXTENSION, maps);

3
drape_frontend/drape_frontend.pro
View file

@ -6,6 +6,7 @@ DEPENDENCIES = drape base
ROOT_DIR = ..
include($$ROOT_DIR/common.pri)
INCLUDEPATH *= $$ROOT_DIR/3party/protobuf/src
DEFINES += DRAW_INFO
SOURCES += \
@ -24,6 +25,7 @@ SOURCES += \
read_manager.cpp \
tile_info.cpp \
coverage_update_descriptor.cpp \
stylist.cpp \
line_shape.cpp
HEADERS += \
@ -44,4 +46,5 @@ HEADERS += \
area_shape.hpp \
read_manager.hpp \
coverage_update_descriptor.hpp \
stylist.hpp \
line_shape.hpp

346
drape_frontend/stylist.cpp Normal file
View file

@ -0,0 +1,346 @@
#include "stylist.hpp"
#include "../indexer/feature.hpp"
#include "../indexer/feature_visibility.hpp"
#include "../indexer/drawing_rules.hpp"
#include "../indexer/drules_include.hpp"
#include "../indexer/scales.hpp"
namespace df
{
namespace
{
enum Type
{
Line = 1,
Area = Line << 1,
Symbol = Area << 1,
Caption = Symbol << 1,
Circle = Caption << 1,
PathText = Circle << 1,
Waymarker = PathText << 1,
CountOfType = PathText + 1
};
inline drule::rule_type_t Convert(Type t)
{
switch (t)
{
case Line : return drule::line;
case Area : return drule::area;
case Symbol : return drule::symbol;
case Caption : return drule::caption;
case Circle : return drule::circle;
case PathText : return drule::pathtext;
case Waymarker: return drule::waymarker;
default:
return drule::count_of_rules;
}
}
// ==================================== //
inline bool IsTypeOf(drule::Key const & key, int flags)
{
int currentFlag = Line;
while (currentFlag < CountOfType)
{
Type type = Type(flags & currentFlag);
if (type != 0 && key.m_type == Convert(type))
return true;
currentFlag <<= 1;
}
return false;
}
bool IsMiddleTunnel(int const layer, double const depth)
{
return layer != feature::LAYER_EMPTY && depth < 19000;
}
double CalcPopulationRank(FeatureType const & f)
{
uint32_t population = f.GetPopulation();
if (population != 1)
{
double const maxPopulation = 3.0E6;
return min(maxPopulation, (double)population) / (maxPopulation * 4);
}
return 0.0;
}
class KeyFunctor
{
public:
KeyFunctor(FeatureType const & f,
feature::EGeomType type,
int const zoomLevel,
int const keyCount,
bool isNameExists)
: m_f(f)
, m_geomType(type)
, m_zoomLevel(zoomLevel)
, m_isNameExists(isNameExists)
{
m_rules.reserve(keyCount);
Init();
}
void operator() (drule::Key const & key)
{
double depth = key.m_priority;
if (IsMiddleTunnel(m_depthLayer, depth) &&
IsTypeOf(key, Line | Area | Waymarker))
{
double const layerPart = m_depthLayer * drule::layer_base_priority;
double const depthPart = fmod(depth, drule::layer_base_priority);
depth = layerPart + depthPart;
}
if (IsTypeOf(key, Caption | Symbol | Circle | PathText))
{
depth += m_priorityModifier;
if (m_geomType == feature::GEOM_POINT) ++depth;
}
else if (IsTypeOf(key, Area))
depth -= m_priorityModifier;
drule::BaseRule const * dRule = drule::rules().Find(key);
m_rules.push_back(make_pair(dRule, depth));
bool isNonEmptyCaption = IsTypeOf(key, Caption) && m_isNameExists;
m_pointStyleFinded |= (IsTypeOf(key, Symbol | Circle) || isNonEmptyCaption);
m_lineStyleFinded |= IsTypeOf(key, Line);
m_auxCaptionFinded |= (dRule->GetCaption(1) != 0);
}
bool m_pointStyleFinded;
bool m_lineStyleFinded;
bool m_iconFinded;
bool m_captionWithoutOffsetFinded;
bool m_auxCaptionFinded;
buffer_vector<Stylist::rule_wrapper_t, 8> m_rules;
private:
void Init()
{
m_population = m_f.GetPopulation();
m_depthLayer = m_f.GetLayer();
if (m_depthLayer == feature::LAYER_TRANSPARENT_TUNNEL)
m_depthLayer = feature::LAYER_EMPTY;
if (m_geomType == feature::GEOM_POINT)
m_priorityModifier = m_population / 7E9;
else
{
m2::RectD const r = m_f.GetLimitRect(m_zoomLevel);
m_priorityModifier = min(1.0, r.SizeX() * r.SizeY() * 10000.0);
}
}
private:
FeatureType const & m_f;
feature::EGeomType m_geomType;
int const m_zoomLevel;
bool const m_isNameExists;
double m_priorityModifier;
int m_depthLayer;
uint32_t m_population;
};
const uint8_t CoastlineFlag = 1;
const uint8_t AreaStyleFlag = 1 << 1;
const uint8_t LineStyleFlag = 1 << 2;
const uint8_t PointStyleFlag = 1 << 3;
}
// ==================================== //
CaptionDescription::CaptionDescription()
: m_populationRank(0.0) {}
void CaptionDescription::Init(const FeatureType & f,
const int zoomLevel)
{
f.GetPreferredNames(m_mainText, m_auxText);
m_roadNumber = f.GetRoadNumber();
m_houseNumber = f.GetHouseNumber();
m_populationRank = CalcPopulationRank(f);
SwapCaptions(zoomLevel);
DiscardLongCaption(zoomLevel);
}
void CaptionDescription::FormatCaptions(const FeatureType & f,
feature::EGeomType type,
bool auxCaptionExists)
{
if (auxCaptionExists == false &&
m_auxText.empty() == false &&
type != feature::GEOM_LINE)
{
f.GetReadableName(m_mainText);
if (m_mainText == m_auxText)
m_auxText.clear();
}
if (m_houseNumber.empty() == false)
{
if (m_mainText.empty() == true || m_houseNumber.find(m_mainText) != string::npos)
m_houseNumber.swap(m_mainText);
else
m_mainText += ("(" + m_houseNumber + ")");
}
}
string const & CaptionDescription::GetMainText() const
{
return m_mainText;
}
string const & CaptionDescription::GetAuxText() const
{
return m_auxText;
}
string const & CaptionDescription::GetRoadNumber() const
{
return m_roadNumber;
}
double CaptionDescription::GetPopulationRank() const
{
return m_populationRank;
}
bool CaptionDescription::IsNameExists() const
{
return !m_mainText.empty() || !m_houseNumber.empty();
}
void CaptionDescription::SwapCaptions(const int zoomLevel)
{
if (zoomLevel <= scales::GetUpperWorldScale() &&
m_auxText.empty() == false)
{
m_mainText.swap(m_auxText);
m_auxText.clear();
}
}
void CaptionDescription::DiscardLongCaption(const int zoomLevel)
{
if (zoomLevel < 5 && m_mainText.size() > 50)
m_mainText.clear();
}
// ==================================== //
Stylist::Stylist()
: m_state(0)
{
}
bool Stylist::IsCoastLine() const
{
return (m_state & CoastlineFlag) != 0;
}
bool Stylist::AreaStyleExists() const
{
return (m_state & AreaStyleFlag) != 0;
}
bool Stylist::LineStyleExists() const
{
return (m_state & LineStyleFlag) != 0;
}
bool Stylist::PointStyleExists() const
{
return (m_state & PointStyleFlag) != 0;
}
CaptionDescription const & Stylist::GetCaptionDescription() const
{
return m_captionDescriptor;
}
void Stylist::ForEachRule(const Stylist::rule_callback_t & fn)
{
typedef rules_t::const_iterator const_iter;
for (const_iter it = m_rules.begin(); it != m_rules.end(); ++it)
fn(*it);
}
void Stylist::RaiseCoastlineFlag()
{
m_state |= CoastlineFlag;
}
void Stylist::RaiseAreaStyleFlag()
{
m_state |= AreaStyleFlag;
}
void Stylist::RaiseLineStyleFlag()
{
m_state |= LineStyleFlag;
}
void Stylist::RaisePointStyleFlag()
{
m_state |= PointStyleFlag;
}
CaptionDescription & Stylist::GetCaptionDescriptionImpl()
{
return m_captionDescriptor;
}
// ==================================== //
bool InitStylist(FeatureType const & f,
int const zoomLevel,
Stylist & s)
{
drule::KeysT keys;
pair<int, bool> geomType = feature::GetDrawRule(f, zoomLevel, keys);
if (keys.empty())
return false;
drule::MakeUnique(keys);
if (geomType.second)
s.RaiseCoastlineFlag();
feature::EGeomType mainGeomType = feature::EGeomType(geomType.first);
switch (mainGeomType) {
case feature::GEOM_POINT: s.RaisePointStyleFlag();
break;
case feature::GEOM_LINE : s.RaiseLineStyleFlag();
break;
case feature::GEOM_AREA : s.RaiseAreaStyleFlag();
break;
default:
ASSERT(false, ());
return false;
}
CaptionDescription & descr = s.GetCaptionDescriptionImpl();
descr.Init(f, zoomLevel);
KeyFunctor keyFunctor(f, mainGeomType, zoomLevel, keys.size(), descr.IsNameExists());
for_each(keys.begin(), keys.end(), keyFunctor);
s.m_rules.swap(keyFunctor.m_rules);
descr.FormatCaptions(f, mainGeomType, keyFunctor.m_auxCaptionFinded);
return true;
}
}

84
drape_frontend/stylist.hpp Normal file
View file

@ -0,0 +1,84 @@
#pragma once
#include "../indexer/feature_data.hpp"
#include "../base/buffer_vector.hpp"
#include "../std/function.hpp"
#include "../std/string.hpp"
class FeatureType;
namespace drule { class BaseRule; }
namespace df
{
struct CaptionDescription
{
CaptionDescription();
void Init(FeatureType const & f,
int const zoomLevel);
void FormatCaptions(FeatureType const & f,
feature::EGeomType type,
bool auxCaptionExists);
const string & GetMainText() const;
const string & GetAuxText() const;
const string & GetRoadNumber() const;
double GetPopulationRank() const;
bool IsNameExists() const;
private:
void SwapCaptions(int const zoomLevel);
void DiscardLongCaption(int const zoomLevel);
private:
string m_mainText;
string m_auxText;
string m_roadNumber;
string m_houseNumber;
double m_populationRank;
};
class Stylist
{
public:
Stylist();
bool IsCoastLine() const;
bool AreaStyleExists() const;
bool LineStyleExists() const;
bool PointStyleExists() const;
CaptionDescription const & GetCaptionDescription() const;
typedef pair<drule::BaseRule const *, double> rule_wrapper_t;
typedef function<void (rule_wrapper_t const &)> rule_callback_t;
void ForEachRule(rule_callback_t const & fn);
private:
friend bool InitStylist(FeatureType const &,
int const,
Stylist &);
void RaiseCoastlineFlag();
void RaiseAreaStyleFlag();
void RaiseLineStyleFlag();
void RaisePointStyleFlag();
CaptionDescription & GetCaptionDescriptionImpl();
private:
typedef buffer_vector<rule_wrapper_t, 8> rules_t;
rules_t m_rules;
uint8_t m_state;
CaptionDescription m_captionDescriptor;
};
bool InitStylist(FeatureType const & f,
int const zoomLevel,
Stylist & s);
}

81
drape_frontend/tile_info.cpp
View file

@ -1,5 +1,7 @@
#include "tile_info.hpp"
#include "stylist.hpp"
#include "../map/feature_vec_model.hpp"
#include "../indexer/mercator.hpp"
@ -36,7 +38,7 @@ namespace
}
df::LineShape * CreateFakeLine1()
{
{
vector<m2::PointF> points;
const float magn = 4;
@ -58,39 +60,39 @@ namespace
points.push_back(m2::PointF(0,0));
return new df::LineShape(points, Extract(0xFF00FF00), .5f, 0.5f);
}
}
}
namespace df
{
{
TileInfo::TileInfo(TileKey const & key)
: m_key(key)
{}
: m_key(key)
{}
m2::RectD TileInfo::GetGlobalRect() const
{
double const worldSizeDevisor = 1 << m_key.m_zoomLevel;
double const rectSizeX = (MercatorBounds::maxX - MercatorBounds::minX) / worldSizeDevisor;
double const rectSizeY = (MercatorBounds::maxY - MercatorBounds::minY) / worldSizeDevisor;
m2::RectD TileInfo::GetGlobalRect() const
{
double const worldSizeDevisor = 1 << m_key.m_zoomLevel;
double const rectSizeX = (MercatorBounds::maxX - MercatorBounds::minX) / worldSizeDevisor;
double const rectSizeY = (MercatorBounds::maxY - MercatorBounds::minY) / worldSizeDevisor;
m2::RectD tileRect(m_key.m_x * rectSizeX,
m_key.m_y * rectSizeY,
(m_key.m_x + 1) * rectSizeX,
(m_key.m_y + 1) * rectSizeY);
m2::RectD tileRect(m_key.m_x * rectSizeX,
m_key.m_y * rectSizeY,
(m_key.m_x + 1) * rectSizeX,
(m_key.m_y + 1) * rectSizeY);
return tileRect;
}
return tileRect;
}
void TileInfo::ReadFeatureIndex(model::FeaturesFetcher const & model)
{
{
if (DoNeedReadIndex())
{
threads::MutexGuard guard(m_mutex);
{
threads::MutexGuard guard(m_mutex);
CheckCanceled();
model.ForEachFeatureID(GetGlobalRect(), *this, m_key.m_zoomLevel);
sort(m_featureInfo.begin(), m_featureInfo.end());
}
}
}
namespace
{
@ -99,26 +101,26 @@ m2::RectD TileInfo::GetGlobalRect() const
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)
{
CheckCanceled();
vector<size_t> indexes;
{
CheckCanceled();
vector<size_t> indexes;
RequestFeatures(memIndex, indexes);
vector<FeatureID> featuresToRead;
@ -136,14 +138,23 @@ m2::RectD TileInfo::GetGlobalRect() const
bool TileInfo::operator ()(FeatureType const & f)
{
return true;
}
Stylist s;
InitStylist(f, m_key.m_zoomLevel, s);
void TileInfo::operator ()(FeatureID const & id)
{
m_featureInfo.push_back(id);
CheckCanceled();
}
if (s.PointStyleExists())
ASSERT(s.AreaStyleExists() == false && s.LineStyleExists() == false, ());
if (s.LineStyleExists())
ASSERT(s.AreaStyleExists() == false && s.PointStyleExists() == false, ());
return true;
}
void TileInfo::operator ()(FeatureID const & id)
{
m_featureInfo.push_back(id);
CheckCanceled();
}
//====================================================//