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

Remove old code for binary drawing rules processing.

Browse source 
Add primary, secondary caption styles getting.
This commit is contained in:
vng 2011-11-24 18:37:12 +03:00 • committed by Alex Zolotarev
parent 6b307e22fe
commit 3171e698c3
17 changed files with 211 additions and 2070 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

103
generator/classif_routine.cpp
View file

@ -1,103 +0,0 @@
#include "classif_routine.hpp"
#include "osm2type.hpp"
#include "../indexer/classificator.hpp"
#include "../indexer/drawing_rules.hpp"
#include "../indexer/scales.hpp"
#include "../platform/platform.hpp"
#include "../coding/file_reader_stream.hpp"
#include "../base/logging.hpp"
namespace classificator
{
void parse_osm_types(int start, int end, string const & path)
{
for (int i = start; i <= end; ++i)
{
char buf[5] = { 0 };
sprintf(buf, "%d", i);
string const inFile = path + buf + ".xml";
ftype::ParseOSMTypes(inFile.c_str(), i);
}
}
/*
class DoFindSymbol
{
string m_name;
public:
DoFindSymbol(string const & name) : m_name(name) {}
void operator() (int s, int t, int i, drule::BaseRule const * p)
{
if (s == 17 && t == drule::symbol)
{
string name;
p->GetSymbol(name);
if (name == m_name)
{
LOG(LINFO, ("Found rule with index = ", i));
}
}
}
};
*/
void GenerateAndWrite(string const & path)
{
using namespace drule;
// Experimental - add drawing rules in program.
// // 1. Read rules.
// string const name = "drawing_rules.bin";
// ReaderPtrStream rulesS(GetPlatform().GetReader(name));
// ReadRules(rulesS);
// // 2. Find spesial rule.
// //rules().ForEachRule(DoFindSymbol("supermarket"));
// // 3. Append rules.
// //int const color = 0;
// int const color = 0xB5D6F1;
// //double const pixWidth = 1.5;
// for (int i = 0; i <= scales::GetUpperScale(); ++i)
// {
// //size_t const ind = rules().AddLineRule(i, color, pixWidth);
// size_t const ind = rules().AddAreaRule(i, color);
// LOG_SHORT(LINFO, ("Scale = ", i, "; Index = ", ind));
// }
// //size_t const ind = rules().AddSymbolRule(17, "supermarket");
// //LOG_SHORT(LINFO, ("Index = ", ind));
// // 4. Write rules.
// WriteRules((path + name).c_str());
// // 5. Exit.
// return;
// 1. generic types
parse_osm_types(0, 11, path + "styles/caption-z");
parse_osm_types(6, 17, path + "styles/osm-map-features-z");
// 2. POI (not used)
//parse_osm_types(12, 17, path + "styles/osm-POI-features-z");
// 3. generate map
string const inFile = path + "styles/mapswithme.xml";
for (int i = 0; i <= 17; ++i)
ftype::ParseOSMTypes(inFile.c_str(), i);
drule::WriteRules(string(path + "drawing_rules.bin"));
classif().PrintClassificator(string(path + "classificator.txt").c_str());
}
void PrepareForFeatureGeneration()
{
classif().SortClassificator();
}
}

9
generator/classif_routine.hpp
View file

@ -1,9 +0,0 @@
#pragma once
#include "../std/string.hpp"
namespace classificator
{
void GenerateAndWrite(string const & dir);
void PrepareForFeatureGeneration();
}

2
generator/generator.pro
View file

@ -20,7 +20,6 @@ SOURCES += \
update_generator.cpp \
statistics.cpp \
osm2type.cpp \
classif_routine.cpp \
borders_generator.cpp \
osm_xml_parser.cpp \
borders_loader.cpp \
@ -46,7 +45,6 @@ HEADERS += \
polygonizer.hpp \
world_map_generator.hpp \
osm2type.hpp \
classif_routine.hpp \
borders_generator.hpp \
osm_xml_parser.hpp \
borders_loader.hpp \

16
generator/generator_tool/generator_tool.cpp
View file

@ -4,14 +4,12 @@
#include "../update_generator.hpp"
#include "../borders_generator.hpp"
#include "../borders_loader.hpp"
#include "../classif_routine.hpp"
#include "../dumper.hpp"
#include "../statistics.hpp"
#include "../unpack_mwm.hpp"
#include "../generate_info.hpp"
#include "../../indexer/classificator_loader.hpp"
#include "../../indexer/drawing_rules.hpp"
#include "../../indexer/data_header.hpp"
#include "../../indexer/features_vector.hpp"
#include "../../indexer/index_builder.hpp"
@ -96,18 +94,6 @@ int main(int argc, char ** argv)
// Make a classificator
if (FLAGS_generate_classif)
{
//classificator::GenerateAndWrite(path);
/// This is temporary code for rules dumping.
//@{
classificator::Load();
string buffer;
drule::ConvertToProtocolBuffers(buffer);
FileWriter w(path + "drules_proto.txt");
w.Write(buffer.c_str(), buffer.size());
//@}
}
// Generating intermediate files
@ -127,7 +113,7 @@ int main(int argc, char ** argv)
FLAGS_calc_statistics || FLAGS_dump_types || FLAGS_dump_prefixes)
{
classificator::Load();
classificator::PrepareForFeatureGeneration();
classif().SortClassificator();
}
// Generate dat file

399
generator/osm2type.cpp
View file

@ -2,26 +2,19 @@
#include "xml_element.hpp"
#include "../indexer/classificator.hpp"
#include "../indexer/drawing_rules.hpp"
#include "../indexer/feature_visibility.hpp"
#include "../coding/parse_xml.hpp"
#include "../coding/file_reader.hpp"
#include "../base/assert.hpp"
#include "../base/string_utils.hpp"
#include "../base/math.hpp"
#include "../std/fstream.hpp"
#include "../std/bind.hpp"
#include "../std/vector.hpp"
#include "../std/set.hpp"
#include "../std/algorithm.hpp"
#include <QtCore/QString>
namespace ftype {
namespace ftype
{
namespace
{
/// get value of mark (1 == "yes", -1 == "no", 0 == not a "yes\no")
@ -46,394 +39,6 @@ namespace ftype {
return 0;
}
class OSMTypesStream
{
/// @name processing elements definitions
//@{
struct element_t
{
element_t() : pObj(0) {}
string name;
map<string, string> attr;
ClassifObject * pObj;
};
vector<element_t> m_elements;
element_t & current() { return m_elements.back(); }
int m_priority;
//@}
/// check if element is a draw rule (commonly it's a leaf in xml)
static bool is_draw_rule(string const & e)
{
static char const * rules[] = { "line", "tunnel", "area", "symbol", "caption", "text",
"circle", "pathText", "wayMarker" };
return strings::IsInArray(rules, e);
}
uint8_t get_rule_type()
{
int count = static_cast<int>(m_elements.size()) - 2;
ASSERT ( count >= 0, (count) );
string e;
while (e.empty() && count >= 0)
{
e = m_elements[count].attr["e"];
--count;
}
ASSERT ( !e.empty(), () );
strings::SimpleTokenizer it(e, "|");
uint8_t ret = 0;
while (it)
{
string const & s = *it;
if (s == "node")
ret |= drule::node;
else if (s == "way")
ret |= drule::way;
++it;
}
ASSERT ( ret != 0, () );
return static_cast<drule::rule_geo_t>(ret);
}
/// check if it's our element to parse
static bool is_our_element(string const & e)
{
static char const * elems[] = { "rules", "rule", "else", "layer",
// addclass appear in small scales (6-11)
// don't skip it during parsing, but we don't process it like a rule
"addclass" };
return (strings::IsInArray(elems, e) || is_draw_rule(e));
}
/// check if it's processing key
static bool is_valid_key(string const & k)
{
static char const * bad[] = { "osmarender:render", "osmarender:rendername",
"osmarender:renderref", "addr:housenumber" };
return (!k.empty() && !strings::IsInArray(bad, k));
}
static bool is_valid_value(string const & v)
{
return !v.empty();
}
/// check if key is a 'mark'
static bool is_mark_key(string const & k)
{
static char const * mark[] = { "bridge", "tunnel", "area", "lock", "oneway", "junction",
"embankment", "cutting", "motorroad", "cycleway",
"bicycle", "horse", "capital", "fee" };
return strings::IsInArray(mark, k);
}
static bool process_feature_like_mark_from_root(string const & /*k*/, string const & v)
{
static char const * mark[] = { "turning_circle", "dyke", "dike", "levee", "embankment" };
return strings::IsInArray(mark, v);
}
static bool process_feature_like_mark(string const & k, string const & v)
{
return (k == "highway" && (v == "construction" || v == "disused"));
}
/// check if skip whole element by it's key
static bool is_skip_element_by_key(string const & k)
{
static char const * skip[] = { "addr:housenumber", "fixme" };
return strings::IsInArray(skip, k);
}
/// skip element and all it's sub-elements
bool m_forceSkip;
public:
OSMTypesStream() : m_priority(0), m_forceSkip(false) {}
void CharData(string const &) {}
bool Push(string const & name)
{
if (!m_forceSkip && is_our_element(name))
{
m_elements.push_back(element_t());
current().name = name;
return true;
}
return false;
}
public:
void AddAttr(string name, string value)
{
// make lower case for equivalent string comparison
strings::MakeLowerCase(name);
strings::MakeLowerCase(value);
if ((name == "k") && is_skip_element_by_key(value))
m_forceSkip = true;
else
current().attr[name] = value;
}
ClassifObject * get_root() { return classif().GetMutableRoot(); }
void Pop(string const & /*element*/)
{
if (!m_forceSkip)
add_type_recursive(get_root(), 0, vector<string>());
else
m_forceSkip = false;
m_elements.pop_back();
}
private:
vector<string> make_concat(vector<string> const & v, int intV, string const & s)
{
if (intV == 1)
{
vector<string> vv;
vv.reserve(v.size() + 1);
bool inserted = false;
for (size_t i = 0; i < v.size(); ++i)
{
if (!(v[i] < s) && !inserted)
{
inserted = true;
vv.push_back(s);
}
vv.push_back(v[i]);
}
if (!inserted) vv.push_back(s);
return vv;
}
else return v;
}
/// get parent of object (p) in created chain of elements
ClassifObject * get_parent_of(size_t i, ClassifObject * p)
{
ASSERT ( i > 0, () );
while (--i > 0)
if (m_elements[i].pObj == p) break;
ASSERT ( i > 0, () );
while (--i > 0)
if (m_elements[i].pObj)
return m_elements[i].pObj;
return get_root();
}
void clear_states(size_t start)
{
for (size_t i = start; i < m_elements.size(); ++i)
m_elements[i].pObj = 0;
}
void add_type_recursive(ClassifObject * pParent,
size_t start,
std::vector<string> const & marks)
{
for (size_t i = start; i < m_elements.size(); ++i)
{
element_t & e = m_elements[i];
if (e.pObj) continue;
if (e.name == "rule")
{
// process rule
string k = e.attr["k"];
if (!is_valid_key(k)) continue;
string v = e.attr["v"];
if (!is_valid_value(v)) continue;
strings::SimpleTokenizer iK(k, "|");
if (iK.IsLast())
{
// process one key
ASSERT ( *iK == k, () );
int intV = get_mark_value(k, v);
if (is_mark_key(k) && (intV != 0))
{
// key is a mark, so save it and go futher
add_type_recursive(pParent, i + 1, make_concat(marks, intV, k));
clear_states(i);
}
else
{
// buildings assume as feature type
bool lets_try = (k == "building" && intV == 1);
// default access is yes. If "no" - make additional feature type
if (!lets_try && (k == "access" && intV == -1))
{
lets_try = true;
intV = 0;
v = "no-access";
}
if (!lets_try && intV != 0)
{
// skip this keys, because they are dummy
continue;
}
else
{
// add root or criterion
if (pParent == get_root())
{
pParent = pParent->Add(k);
e.pObj = pParent;
// use m_elements[1] to hold first parent of futher creation objects
// need for correct working "get_parent_of" function
m_elements[1].pObj = pParent;
}
else
{
// avoid recursion like this:
// <k = "x", v = "a|b|c">
// <k = "x", v = "a">
// <k = "x", v = "b">
// <k = "x", v = "c">
ClassifObject * ppParent = get_parent_of(i, pParent);
if (k != ppParent->GetName())
{
// do not set criterion like base object
if (k != pParent->GetName() &&
!process_feature_like_mark(pParent->GetName(), k))
pParent->AddCriterion(k);
}
else
pParent = ppParent;
}
// process values
strings::SimpleTokenizer iV(v, "|");
while (iV)
{
bool const b1 = process_feature_like_mark_from_root(k, *iV);
if (b1 || process_feature_like_mark(k, *iV))
{
// process value like mark, so save it and go futher
add_type_recursive(
b1 ? get_root() : pParent, i + 1, make_concat(marks, 1, *iV));
clear_states(i);
}
else
{
ClassifObject * p = pParent;
if (intV == 0)
p = pParent->Add(*iV);
e.pObj = p;
add_type_recursive(p, i + 1, marks);
clear_states(i);
}
++iV;
}
}
}
}
else
{
char const * aTry[] = { "natural", "landuse" };
while (iK)
{
// let's try to add root keys
bool addMode = (pParent == get_root() && strings::IsInArray(aTry, *iK));
ClassifObject * p = (addMode ? pParent->Add(*iK) : pParent->Find(*iK));
if (p && (get_mark_value(*iK, v) == 0))
{
if (p->IsCriterion()) p = pParent;
strings::SimpleTokenizer iV(v, "|");
while (iV)
{
ClassifObject * pp = (addMode ? p->Add(*iV) : p->Find(*iV));
if (pp)
{
e.pObj = pp;
add_type_recursive(pp, i + 1, marks);
clear_states(i);
}
++iV;
}
}
++iK;
}
}
return; // processed to the end - exit
}
else if (is_draw_rule(e.name))
{
ASSERT ( i == m_elements.size()-1, ("drawing rules should be leavs") );
// process draw rule
if (pParent != get_root())
{
if (!marks.empty())
{
// make final mark string
string res;
for (size_t i = 0; i < marks.size(); ++i)
{
if (!res.empty()) res += '-';
res += marks[i];
}
pParent = pParent->Add(res);
}
vector<drule::Key> keys;
drule::rules().CreateRules(e.name, get_rule_type(), e.attr, keys);
// if no "layer" tag, then atoi returns 0 - it's ok for us
// 1000 - is a base count of rules for layer
int const layer = atoi(e.attr["layer"].c_str()) * drule::layer_base_priority;
for (size_t i = 0; i < keys.size(); ++i)
keys[i].SetPriority(layer + m_priority++);
for_each(keys.begin(), keys.end(), bind(&ClassifObject::AddDrawRule, pParent, _1));
}
}
}
}
};
}
void ParseOSMTypes(char const * fPath, int scale)
{
drule::rules().SetParseFile(fPath, scale);
FileReader reader(fPath);
ReaderSource<FileReader> source(reader);
OSMTypesStream stream;
ParseXML(source, stream);
}
namespace
{
bool is_skip_tag(string const & k)
{
// skip "cycleway's" tags because they interfer to set a valid types like "highway's"

2
generator/osm2type.hpp
View file

@ -7,8 +7,6 @@ struct XMLElement;
namespace ftype
{
void ParseOSMTypes(char const * fPath, int scale);
/// Get the types, name and layer for feature with the tree of tags.
bool GetNameAndType(XMLElement * p, FeatureParams & params);
}

4
indexer/classificator.cpp
View file

@ -81,9 +81,7 @@ void ClassifObject::LoadPolicy::Serialize(string const & s)
drule::Key key;
key.fromString(s);
#ifndef USE_PROTO_STYLES
p->m_drawRule.push_back(key);
#endif
//p->m_drawRule.push_back(key);
// mark as visible in rule's scale
p->m_visibility[key.m_scale] = true;

8
indexer/classificator_loader.cpp
View file

@ -52,15 +52,11 @@ namespace classificator
p.GetReader("types.txt"));
//LOG(LINFO, ("Reading of drawing rules"));
#ifdef USE_PROTO_STYLES
// Load from protobuffer text file.
string buffer;
ReaderType(p.GetReader("drules_proto.txt")).ReadAsString(buffer);
drule::rules().LoadFromProto(buffer);
#else
ReaderPtrStream rulesS(p.GetReader("drawing_rules.bin"));
drule::ReadRules(rulesS);
#endif
drule::rules().LoadFromTextProto(buffer);
LOG(LINFO, ("Reading of classificator finished"));
}

2
indexer/drawing_rule_def.hpp
View file

@ -4,8 +4,6 @@
#include "../std/vector.hpp"
#define USE_PROTO_STYLES 1
namespace drule
{
class Key

1367
indexer/drawing_rules.cpp
View file

File diff suppressed because it is too large Load diff

77
indexer/drawing_rules.hpp
View file

@ -10,17 +10,17 @@
#include "../std/string.hpp"
class ReaderPtrStream;
class FileWriterStream;
class LineDefProto;
class AreaRuleProto;
class SymbolRuleProto;
class CaptionDefProto;
class CircleRuleProto;
namespace drule
{
typedef map<string, string> AttrsMapType;
class BaseRule
{
string m_class; // for debug use only, can be removed
mutable buffer_vector<uint32_t, 8> m_id1, m_id2;
char m_type; // obsolete for new styles, can be removed
@ -30,11 +30,8 @@ namespace drule
BaseRule() : m_type(node | way)
{
}
virtual ~BaseRule() {}
/// @todo Rewrite this. Make an array of IDs.
//@{
void CheckSize(buffer_vector<uint32_t, 8> & v, size_t s) const
{
if (v.size() < s)
@ -88,34 +85,15 @@ namespace drule
for (size_t i = 0; i < m_id2.size(); ++i)
MakeEmptyID2(i);
}
//@}
void SetClassName(string const & cl) { m_class = cl; }
void SetType(char type) { m_type = type; }
inline char GetType() const { return m_type; }
bool IsEqualBase(BaseRule const * p) const { return (m_type == p->m_type); }
void ReadBase(ReaderPtrStream & ar);
void WriteBase(FileWriterStream & ar) const;
virtual bool IsEqual(BaseRule const * p) const = 0;
virtual void Read(ReaderPtrStream & ar) = 0;
virtual void Write(FileWriterStream & ar) const = 0;
/// @name This functions can tell us about the type of rule.
//@{
virtual int GetColor() const { return -1; } ///< path "line" color
virtual int GetFillColor() const { return -1; } ///< fill "area" color
virtual double GetTextHeight() const { return -1.0; } ///< text height of "caption"
virtual double GetRadius() const { return -1; } ///< radius "circle"
virtual void GetSymbol(string &) const {} ///< name of "symbol"
//@}
virtual unsigned char GetAlpha() const { return 255; }
virtual unsigned char GetStrokeAlpha() const { return 255; }
virtual double GetWidth() const { return -1; }
virtual void GetPattern(vector<double> &, double &) const {}
virtual LineDefProto const * GetLine() const { return 0; }
virtual AreaRuleProto const * GetArea() const { return 0; }
virtual SymbolRuleProto const * GetSymbol() const { return 0; }
virtual CaptionDefProto const * GetCaption(int) const { return 0; }
virtual CircleRuleProto const * GetCircle() const { return 0; }
};
class RulesHolder
@ -128,42 +106,18 @@ namespace drule
typedef map<int32_t, array<vector<uint32_t>, count_of_rules> > rules_map_t;
rules_map_t m_rules;
/// @name temporary for search rules parameters by 'class' attribute
//@{
string m_file;
int m_currScale;
//@}
void PushAttributes(string objClass, AttrsMapType & attrs);
Key CreateRuleImpl1(string const & name, uint8_t type, string const & clValue,
AttrsMapType const & attrs, bool isMask);
Key CreateRuleImpl2(string const & name, uint8_t type, string const & clName,
AttrsMapType const & attrs);
public:
~RulesHolder();
size_t AddRule(int scale, rule_type_t type, BaseRule * p);
size_t AddLineRule(int scale, int color, double pixWidth);
size_t AddAreaRule(int scale, int color);
size_t AddSymbolRule(int scale, string const & sym);
void Clean();
void SetParseFile(char const * fPath, int scale);
void CreateRules(string const & name, uint8_t type,
AttrsMapType const & attrs, vector<Key> & v);
void ClearCaches();
BaseRule const * Find(Key const & k) const;
int GetScale() const { return m_currScale; }
void Read(ReaderPtrStream & s);
void Write(FileWriterStream & s);
void LoadFromProto(string const & buffer);
void ClearCaches();
void LoadFromTextProto(string const & buffer);
template <class ToDo> void ForEachRule(ToDo toDo)
{
@ -182,10 +136,5 @@ namespace drule
}
};
void WriteRules(string const & fPath);
void ReadRules(ReaderPtrStream & s);
RulesHolder & rules();
void ConvertToProtocolBuffers(string & res);
}

6
map/draw_processor.cpp
View file

@ -360,11 +360,11 @@ namespace fwork
if (!ptr->m_name.empty())
{
double fontSize = 0;
uint8_t fontSize = 0;
for (size_t i = 0; i < count; ++i)
{
if (pDrawer->filter_text_size(rules[i].m_rule))
fontSize = max((uint8_t)fontSize, pDrawer->get_text_font_size(rules[i].m_rule));
if (!pDrawer->filter_text_size(rules[i].m_rule))
fontSize = max(fontSize, pDrawer->get_text_font_size(rules[i].m_rule));
}
if (fontSize != 0)

160
map/drawer_yg.cpp
View file

@ -1,4 +1,5 @@
#include "drawer_yg.hpp"
#include "proto_to_yg_styles.hpp"
#include "../std/bind.hpp"
@ -9,14 +10,13 @@
#include "../yg/screen.hpp"
#include "../yg/skin.hpp"
#include "../yg/resource_manager.hpp"
#include "../yg/circle_info.hpp"
#include "../yg/pen_info.hpp"
#include "../geometry/screenbase.hpp"
#include "../base/logging.hpp"
#include "../base/buffer_vector.hpp"
DrawerYG::Params::Params()
: m_dynamicPagesCount(2),
m_textPagesCount(2),
@ -120,41 +120,16 @@ void DrawerYG::drawSymbol(m2::PointD const & pt, string const & symbolName, yg::
void DrawerYG::drawCircle(m2::PointD const & pt, rule_ptr_t pRule, yg::EPosition pos, int depth)
{
double const radius = min(max(pRule->GetRadius() * m_scale, 3.0), 6.0) * m_visualScale;
int const lineC = pRule->GetColor();
double const width = (lineC != -1) ? min(max(pRule->GetWidth() * m_scale * m_visualScale, 1.0), 3.0) : 1.0;
yg::CircleInfo ci(radius,
yg::Color::fromXRGB(pRule->GetFillColor(), pRule->GetAlpha()),
lineC != -1,
width,
yg::Color::fromXRGB(lineC, pRule->GetStrokeAlpha()));
yg::CircleInfo ci;
ConvertStyle(pRule->GetCircle(), m_visualScale, ci);
m_pScreen->drawCircle(pt, ci, pos, depth);
}
void DrawerYG::drawSymbol(m2::PointD const & pt, rule_ptr_t pRule, yg::EPosition pos, int depth)
{
// Use BaseRule::m_id to cache for point draw rule.
// This rules doesn't mix with other rule-types.
// uint32_t id = pRule->GetID(m_threadID);
string name;
pRule->GetSymbol(name);
/* if (id == drule::BaseRule::empty_id)
{
id = m_pSkin->mapSymbol(name.c_str());
if (id != drule::BaseRule::empty_id)
pRule->SetID(m_threadID, id);
else
{
//ASSERT ( false, ("Can't find symbol by id = ", (name)) );
return;
}
}*/
ConvertStyle(pRule->GetSymbol(), name);
m_pScreen->drawSymbol(pt, name, pos, depth);
}
@ -180,18 +155,11 @@ void DrawerYG::drawPath(di::PathInfo const & info, di::DrawRule const * rules, s
// collect yg::PenInfo into array and pack them as a whole
for (size_t i = 0; i < count; ++i)
{
rule_ptr_t pRule = rules[i].m_rule;
vector<double> pattern;
double offset;
pRule->GetPattern(pattern, offset);
ConvertStyle(rules[i].m_rule->GetLine(), m_visualScale, penInfos[i]);
for (size_t j = 0; j < pattern.size(); ++j)
pattern[j] *= m_scale * m_visualScale;
if (rules[i].m_transparent)
penInfos[i].m_color.a = 100;
penInfos[i] = yg::PenInfo(
yg::Color::fromXRGB(pRule->GetColor(), rules[i].m_transparent ? 100 : pRule->GetAlpha()),
max(pRule->GetWidth() * m_scale, 1.0) * m_visualScale,
pattern.empty() ? 0 : &pattern[0], pattern.size(), offset * m_scale);
styleIDs[i] = m_pSkin->invalidHandle();
}
@ -218,75 +186,54 @@ void DrawerYG::drawArea(vector<m2::PointD> const & pts, rule_ptr_t pRule, int de
// DO NOT cache 'id' in pRule, because one rule can use in drawPath and drawArea.
// Leave CBaseRule::m_id for drawPath. mapColor working fast enough.
uint32_t const id = m_pSkin->mapColor(yg::Color::fromXRGB(pRule->GetFillColor(), pRule->GetAlpha()));
yg::Color color;
ConvertStyle(pRule->GetArea(), color);
uint32_t const id = m_pSkin->mapColor(color);
ASSERT ( id != -1, () );
m_pScreen->drawTrianglesList(&pts[0], pts.size()/*, res*/, id, depth);
}
namespace
{
double const min_text_height_filtered = 2;
double const min_text_height = 12; // 8
//double const min_text_height_mask = 9.99; // 10
}
uint8_t DrawerYG::get_text_font_size(rule_ptr_t pRule) const
{
double const h = pRule->GetTextHeight() * m_scale;
return my::rounds(max(h, min_text_height) * m_visualScale);
return GetFontSize(pRule->GetCaption(0)) * m_visualScale;
}
bool DrawerYG::filter_text_size(rule_ptr_t pRule) const
{
return pRule->GetTextHeight() * m_scale <= min_text_height_filtered;
}
yg::FontDesc DrawerYG::get_text_font(rule_ptr_t pRule) const
{
int c = pRule->GetFillColor();
yg::Color color = (c != -1 ? yg::Color::fromXRGB(c, pRule->GetAlpha()) :
yg::Color(0, 0, 0, 0));
// to prevent white text on white outline
//if (color == yg::Color(255, 255, 255, 255))
// color = yg::Color(0, 0, 0, 0);
c = pRule->GetColor();
bool const hasStroke = (c != -1);
yg::Color strokeColor = (hasStroke ? yg::Color::fromXRGB(c, pRule->GetStrokeAlpha()) :
yg::Color(255, 255, 255, 255));
return yg::FontDesc(get_text_font_size(pRule), color, hasStroke, strokeColor);
if (pRule->GetCaption(0))
return (GetFontSize(pRule->GetCaption(0)) < 3);
else
{
// this rule is not a caption at all
return true;
}
}
void DrawerYG::drawText(m2::PointD const & pt, di::DrawInfo const * pInfo, rule_ptr_t pRule, yg::EPosition pos, int depth)
{
yg::FontDesc fontDesc(get_text_font(pRule));
fontDesc.SetRank(pInfo->m_rank);
yg::FontDesc font;
ConvertStyle(pRule->GetCaption(0), m_visualScale, font);
font.SetRank(pInfo->m_rank);
yg::FontDesc smallFontDesc(fontDesc);
smallFontDesc.m_size *= 0.75;
yg::FontDesc smallFont;
if (pRule->GetCaption(1))
{
ConvertStyle(pRule->GetCaption(1), m_visualScale, smallFont);
smallFont.SetRank(pInfo->m_rank);
}
if (!filter_text_size(pRule))
m_pScreen->drawTextEx(
fontDesc,
smallFontDesc,
pt,
pos,
pInfo->m_name,
pInfo->m_secondaryName,
depth,
true,
true);
m_pScreen->drawTextEx(font, smallFont, pt, pos,
pInfo->m_name, pInfo->m_secondaryName,
depth, true, true);
}
bool DrawerYG::drawPathText(di::PathInfo const & info, di::DrawInfo const * pInfo, rule_ptr_t pRule, int depth)
{
yg::FontDesc primaryFont(get_text_font(pRule));
yg::FontDesc font;
ConvertStyle(pRule->GetCaption(0), m_visualScale, font);
return m_pScreen->drawPathText(primaryFont,
return m_pScreen->drawPathText(font,
&info.m_path[0],
info.m_path.size(),
pInfo->GetPathName(),
@ -334,12 +281,6 @@ double DrawerYG::VisualScale() const
void DrawerYG::SetScale(int level)
{
m_level = level;
#ifdef USE_PROTO_STYLES
m_scale = 1.0;
#else
m_scale = scales::GetM2PFactor(level);
#endif
}
void DrawerYG::Draw(di::DrawInfo const * pInfo, di::DrawRule const * rules, size_t count)
@ -353,13 +294,11 @@ void DrawerYG::Draw(di::DrawInfo const * pInfo, di::DrawRule const * rules, size
for (unsigned i = 0; i < count; ++i)
{
rule_ptr_t pRule = rules[i].m_rule;
string symbol;
pRule->GetSymbol(symbol);
bool const hasSymbol = !symbol.empty();
bool const isCaption = pRule->GetTextHeight() >= 0.0;
bool const hasSymbol = pRule->GetSymbol() != 0;
bool const isCaption = pRule->GetCaption(0) != 0;
if (!isCaption && isPath && !hasSymbol && (pRule->GetColor() != -1))
if (!isCaption && isPath && !hasSymbol && (pRule->GetLine() != 0))
pathRules.push_back(rules[i]);
}
@ -378,28 +317,16 @@ void DrawerYG::Draw(di::DrawInfo const * pInfo, di::DrawRule const * rules, size
rule_ptr_t pRule = rules[i].m_rule;
int const depth = rules[i].m_depth;
bool const isCaption = pRule->GetTextHeight() >= 0.0;
string symbol;
pRule->GetSymbol(symbol);
bool const hasSymbol = !symbol.empty();
bool const isCircle = (pRule->GetRadius() != -1);
bool const isCaption = pRule->GetCaption(0) != 0;
bool const hasSymbol = pRule->GetSymbol() != 0;
bool const isCircle = pRule->GetCircle() != 0;
if (!isCaption)
{
// path is drawn separately in the code above
// draw path
//if (isPath && !isSymbol && (pRule->GetColor() != -1))
//{
// for (list<di::PathInfo>::const_iterator i = pInfo->m_pathes.begin(); i != pInfo->m_pathes.end(); ++i)
// drawPath(*i, pRule, depth);
//}
// draw area
if (isArea)
{
bool const isFill = pRule->GetFillColor() != -1;
bool const isFill = pRule->GetArea() != 0;
bool const hasSym = hasSymbol && ((pRule->GetType() & drule::way) != 0);
for (list<di::AreaInfo>::const_iterator i = pInfo->m_areas.begin(); i != pInfo->m_areas.end(); ++i)
@ -437,12 +364,7 @@ void DrawerYG::Draw(di::DrawInfo const * pInfo, di::DrawRule const * rules, size
if (isPath && !isArea && isN && !filter_text_size(pRule))
{
for (list<di::PathInfo>::const_iterator i = pInfo->m_pathes.begin(); i != pInfo->m_pathes.end(); ++i)
{
if (filter_text_size(pRule))
continue;
drawPathText(*i, pInfo, pRule, depth);
}
}
// draw point text

4
map/drawer_yg.hpp
View file

@ -69,7 +69,6 @@ class DrawerYG
{
typedef di::DrawRule::rule_ptr_t rule_ptr_t;
double m_scale;
double m_visualScale;
int m_level;
size_t m_threadID;
@ -125,7 +124,6 @@ public:
void Draw(di::DrawInfo const * pInfo, di::DrawRule const * rules, size_t count);
uint8_t get_text_font_size(rule_ptr_t pRule) const;
yg::FontDesc get_text_font(rule_ptr_t pRule) const;
bool filter_text_size(rule_ptr_t pRule) const;
uint8_t get_text_font_size(rule_ptr_t pRule) const;
};

13
map/map.pro
View file

@ -3,6 +3,7 @@
TARGET = map
TEMPLATE = lib
CONFIG += staticlib
INCLUDEPATH += ../3party/protobuf/src
ROOT_DIR = ..
DEPENDENCIES = search yg indexer geometry coding base expat
@ -40,7 +41,8 @@ HEADERS += \
benchmark_render_policy_mt.hpp \
ruler.hpp \
measurement_utils.hpp \
partial_render_policy.hpp
partial_render_policy.hpp \
proto_to_yg_styles.hpp \
SOURCES += \
feature_vec_model.cpp \
@ -71,16 +73,11 @@ SOURCES += \
ruler.cpp \
measurement_utils.cpp \
window_handle.cpp \
partial_render_policy.cpp
partial_render_policy.cpp \
proto_to_yg_styles.cpp \
!iphone*:!bada*:!android* {
HEADERS += qgl_render_context.hpp
SOURCES += qgl_render_context.cpp
QT += opengl
}

88
map/proto_to_yg_styles.cpp Normal file
View file

@ -0,0 +1,88 @@
#include "proto_to_yg_styles.hpp"
#include "../indexer/drules_struct.pb.h"
#include "../std/algorithm.hpp"
namespace
{
yg::Color ConvertColor(int c)
{
return yg::Color::fromXRGB(c, 255 - (c >> 24));
}
double ConvertWidth(double w, double scale)
{
return max(w, 1.0) * scale;
}
}
void ConvertStyle(LineDefProto const * pSrc, double scale, yg::PenInfo & dest)
{
double offset = 0.0;
vector<double> v;
if (pSrc->has_dashdot())
{
DashDotProto const & dd = pSrc->dashdot();
int const count = dd.dd_size();
v.reserve(count);
for (int i = 0; i < count; ++i)
v.push_back(dd.dd(i) * scale);
if (dd.has_offset())
offset = dd.offset() * scale;
}
dest = yg::PenInfo(
ConvertColor(pSrc->color()),
ConvertWidth(pSrc->width(), scale),
v.empty() ? 0 : &v[0], v.size(), offset);
}
void ConvertStyle(AreaRuleProto const * pSrc, yg::Color & dest)
{
dest = ConvertColor(pSrc->color());
}
void ConvertStyle(SymbolRuleProto const * pSrc, string & dest)
{
dest = pSrc->name();
}
void ConvertStyle(CircleRuleProto const * pSrc, double scale, yg::CircleInfo & dest)
{
dest = yg::CircleInfo(min(max(pSrc->radius(), 3.0), 6.0) * scale,
ConvertColor(pSrc->color()));
if (pSrc->has_border())
{
yg::PenInfo pen;
ConvertStyle(&(pSrc->border()), scale, pen);
dest.m_isOutlined = true;
dest.m_outlineColor = pen.m_color;
dest.m_outlineWidth = pen.m_w;
}
}
void ConvertStyle(CaptionDefProto const * pSrc, double scale, yg::FontDesc & dest)
{
uint8_t const h = max(static_cast<int>(pSrc->height() * scale), 12);
dest = yg::FontDesc(h, ConvertColor(pSrc->color()));
if (pSrc->has_stroke_color())
{
dest.m_isMasked = true;
dest.m_maskColor = ConvertColor(pSrc->stroke_color());
}
}
uint8_t GetFontSize(CaptionDefProto const * pSrc)
{
return pSrc->height();
}

21
map/proto_to_yg_styles.hpp Normal file
View file

@ -0,0 +1,21 @@
#pragma once
#include "../yg/pen_info.hpp"
#include "../yg/circle_info.hpp"
#include "../yg/font_desc.hpp"
class LineDefProto;
class AreaRuleProto;
class SymbolRuleProto;
class CaptionDefProto;
class CircleRuleProto;
void ConvertStyle(LineDefProto const * pSrc, double scale, yg::PenInfo & dest);
void ConvertStyle(AreaRuleProto const * pSrc, yg::Color & dest);
void ConvertStyle(SymbolRuleProto const * pSrc, string & dest);
void ConvertStyle(CircleRuleProto const * pSrc, double scale, yg::CircleInfo & dest);
void ConvertStyle(CaptionDefProto const * pSrc, double scale, yg::FontDesc & dest);
uint8_t GetFontSize(CaptionDefProto const * pSrc);