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

rewritten best_filtration method to support "dead zone" segment that should not be clipped.

Browse source
This commit is contained in:
rachytski 2011-05-10 00:23:48 +03:00 • committed by Alex Zolotarev
parent 23d89b6acf
commit 495f343473
12 changed files with 303 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

56
map/draw_processor.cpp
View file

@ -14,13 +14,13 @@ using namespace di;
m2::PointD base::g2p(m2::PointD const & pt) const
{
return m_convertor.GtoP(pt);
return m_convertor->GtoP(pt);
}
base_screen::base_screen(ScreenBase const & convertor, m2::RectD const & rect)
: base(convertor)
base_screen::base_screen(params const & p)
: base(p)
{
m_convertor.GtoP(rect, m_rect);
m_convertor->GtoP(*p.m_rect, m_rect);
}
void one_point::operator() (CoordPointT const & p)
@ -29,7 +29,7 @@ void one_point::operator() (CoordPointT const & p)
m2::PointD pt(make_point(p));
if (m_rect.IsPointInside(pt))
if (m_rect->IsPointInside(pt))
{
m_exist = true;
m_point = convert_point(pt);
@ -55,7 +55,7 @@ void path_points::EndPL()
void path_points::simple_filtration(m2::PointD const & pt)
{
if (m_prevPt)
if (m_hasPrevPt)
{
if (!m2::RectD(m_prev, pt).IsIntersect(m_rect))
m_newPL = true;
@ -71,7 +71,7 @@ void path_points::simple_filtration(m2::PointD const & pt)
}
else
{
m_prevPt = true;
m_hasPrevPt = true;
m_length = 0.0;
}
@ -80,32 +80,54 @@ void path_points::simple_filtration(m2::PointD const & pt)
void path_points::best_filtration(m2::PointD const & pt)
{
if (m_prevPt)
if (m_hasPrevPt)
{
m2::PointD prev = m_prev;
m2::PointD curr = pt;
if (!m2::Intersect(m_rect, prev, curr))
m_newPL = true;
else
{
if (!equal_glb_pts(prev, m_prev))
m_newPL = true;
double segLen = curr.Length(prev);
if ((m_startLength != 0) && (m_endLength != 0))
{
if ((m_startLength >= m_length) && (m_startLength < m_length + segLen))
m_startLength = m_length;
if ((m_endLength >= m_length) && (m_endLength < m_length + segLen))
m_endLength = m_length + curr.Length(prev);
}
if ((m_length >= m_startLength) && (m_endLength >= m_length + segLen))
{
/// we're in the dead zone. add without clipping
if (m_newPL)
StartPL(prev);
push_point(curr);
if (!equal_glb_pts(curr, pt))
}
else
{
if (!m2::Intersect(m_rect, prev, curr))
m_newPL = true;
else
{
if (!equal_glb_pts(prev, m_prev))
m_newPL = true;
if (m_newPL)
StartPL(prev);
push_point(curr);
if (!equal_glb_pts(curr, pt))
m_newPL = true;
}
}
m_length += m_prev.Length(pt);
}
else
{
m_prevPt = true;
m_hasPrevPt = true;
m_length = 0.0;
}

119
map/draw_processor.hpp
View file

@ -9,6 +9,8 @@
#include "../std/list.hpp"
#include "../std/limits.hpp"
#include "../yg/glyph_cache.hpp"
class ScreenBase;
namespace get_pts
@ -23,7 +25,7 @@ namespace get_pts
class base
{
protected:
ScreenBase const & m_convertor;
ScreenBase const * m_convertor;
static m2::PointD make_point(CoordPointT const & p)
{
@ -31,7 +33,14 @@ namespace get_pts
}
m2::PointD g2p(m2::PointD const & pt) const;
base(ScreenBase const & convertor) : m_convertor(convertor)
struct params
{
ScreenBase const * m_convertor;
params() : m_convertor()
{}
};
base(params const & p) : m_convertor(p.m_convertor)
{
}
};
@ -40,15 +49,21 @@ namespace get_pts
class base_global : public base
{
protected:
m2::RectD const & m_rect;
m2::RectD const * m_rect;
m2::PointD convert_point(m2::PointD const & pt) const
{
return g2p(pt);
}
base_global(ScreenBase const & convertor, m2::RectD const & rect)
: base(convertor), m_rect(rect)
struct params : base::params
{
m2::RectD const * m_rect;
params() : m_rect(0){}
};
base_global(params const & p)
: base(p), m_rect(p.m_rect)
{
}
};
@ -57,6 +72,7 @@ namespace get_pts
class base_screen : public base
{
protected:
m2::RectD m_rect;
m2::PointD convert_point(m2::PointD const & pt) const
@ -64,10 +80,45 @@ namespace get_pts
return pt;
}
base_screen(ScreenBase const & convertor, m2::RectD const & rect);
struct params : base::params
{
m2::RectD const * m_rect;
params() : m_rect(0)
{}
};
base_screen(params const & p);
};
//@}
template <typename TBase>
class calc_length : public TBase
{
bool m_exist;
m2::PointD m_prevPt;
public:
double m_length;
typedef typename TBase::params params;
calc_length(params const & p) :
TBase(p), m_exist(false), m_length(0)
{}
void operator() (CoordPointT const & p)
{
m2::PointD pt(this->convert_point(this->make_point(p)));
if (m_exist)
m_length += pt.Length(m_prevPt);
m_exist = true;
m_prevPt = pt;
}
bool IsExist() const {return m_exist;}
};
class one_point : public base_global
{
bool m_exist;
@ -75,8 +126,10 @@ namespace get_pts
public:
m2::PointD m_point;
one_point(ScreenBase const & convertor, m2::RectD const & rect)
: base_global(convertor, rect), m_exist(false)
typedef base_global::params params;
one_point(params const & p)
: base_global(p), m_exist(false)
{
}
@ -90,8 +143,10 @@ namespace get_pts
public:
list<TInfo> m_points;
geometry_base(ScreenBase const & convertor, m2::RectD const & rect)
: TBase(convertor, rect)
typedef typename TBase::params params;
geometry_base(params const & p)
: TBase(p)
{
}
@ -110,10 +165,14 @@ namespace get_pts
{
typedef geometry_base<di::PathInfo, base_screen> base_type;
bool m_newPL, m_prevPt;
bool m_newPL, m_hasPrevPt;
m2::PointD m_prev;
double m_length;
double m_startLength;
double m_endLength;
double m_fontSize;
void StartPL(m2::PointD const & pt);
void EndPL();
@ -127,8 +186,22 @@ namespace get_pts
void best_filtration(m2::PointD const & p);
public:
path_points(ScreenBase const & convertor, m2::RectD const & rect)
: base_type(convertor, rect), m_newPL(true), m_prevPt(false), m_length(0.0)
struct params : base_type::params
{
double m_startLength;
double m_endLength;
params() : m_startLength(0), m_endLength(0)
{}
};
path_points(params const & p)
: base_type(p),
m_newPL(true),
m_hasPrevPt(false),
m_length(0.0),
m_startLength(p.m_startLength),
m_endLength(p.m_endLength)
{
}
@ -144,8 +217,11 @@ namespace get_pts
typedef geometry_base<di::AreaInfo, base_screen> base_type;
public:
area_base(ScreenBase const & convertor, m2::RectD const & rect)
: base_type(convertor, rect)
typedef base_type::params params;
area_base(params const & p)
: base_type(p)
{
}
};
@ -154,8 +230,10 @@ namespace get_pts
class area_tess_points : public area_base
{
public:
area_tess_points(ScreenBase const & convertor, m2::RectD const & rect)
: area_base(convertor, rect)
typedef area_base::params params;
area_tess_points(params const & p)
: area_base(p)
{
}
@ -184,8 +262,11 @@ namespace get_pts
}
public:
filter_screenpts_adapter(ScreenBase const & convertor, m2::RectD const & rect)
: TBase(convertor, rect), m_count(0),
typedef typename TBase::params params;
filter_screenpts_adapter(params const & p)
: TBase(p), m_count(0),
m_prev(numeric_limits<CoordT>::min(), numeric_limits<CoordT>::min()), m_center(0, 0)
{
}

8
map/drawer_yg.hpp
View file

@ -65,10 +65,6 @@ class DrawerYG
static void ClearSkinPage(uint8_t pageID);
uint8_t get_text_font_size(rule_ptr_t pRule) const;
uint8_t get_pathtext_font_size(rule_ptr_t pRule) const;
bool filter_text_size(rule_ptr_t pRule) const;
typedef map<string, list<m2::RectD> > org_map_t;
org_map_t m_pathsOrg;
@ -113,4 +109,8 @@ public:
void SetScale(int level);
void Draw(di::DrawInfo const * pInfo, di::DrawRule const * rules, size_t count);
uint8_t get_text_font_size(rule_ptr_t pRule) const;
uint8_t get_pathtext_font_size(rule_ptr_t pRule) const;
bool filter_text_size(rule_ptr_t pRule) const;
};

142
map/framework.cpp
View file

@ -49,12 +49,14 @@ namespace fwork
ScreenBase const & convertor,
shared_ptr<PaintEvent> const & paintEvent,
int scaleLevel,
shared_ptr<yg::gl::RenderState> const & renderState)
shared_ptr<yg::gl::RenderState> const & renderState,
yg::GlyphCache * glyphCache)
: m_rect(r),
m_convertor(convertor),
m_paintEvent(paintEvent),
m_zoom(scaleLevel),
m_renderState(renderState)
m_renderState(renderState),
m_glyphCache(glyphCache)
#ifdef PROFILER_DRAWING
, m_drawCount(0)
#endif
@ -107,9 +109,8 @@ namespace fwork
m_keys.erase(unique(m_keys.begin(), m_keys.end(), equal_key()), m_keys.end());
}
#define GET_POINTS(f, for_each_fun, functor_t, assign_fun) \
#define GET_POINTS(f, for_each_fun, fun, assign_fun) \
{ \
functor_t fun(m_convertor, m_rect); \
f.for_each_fun(fun, m_zoom); \
if (fun.IsExist()) \
{ \
@ -136,50 +137,14 @@ namespace fwork
return true;
}
m_renderState->m_isEmptyModelCurrent = false;
shared_ptr<di::DrawInfo> ptr(new di::DrawInfo(f.GetPreferredDrawableName()));
using namespace get_pts;
bool isExist = false;
switch (type)
{
case GEOM_POINT:
GET_POINTS(f, ForEachPointRef, get_pts::one_point, assign_point)
break;
case GEOM_AREA:
GET_POINTS(f, ForEachTriangleExRef, filter_screenpts_adapter<area_tess_points>, assign_area)
{
// if area feature has any line-drawing-rules, than draw it like line
for (size_t i = 0; i < m_keys.size(); ++i)
if (m_keys[i].m_type == drule::line)
goto draw_line;
break;
}
draw_line:
case GEOM_LINE:
GET_POINTS(f, ForEachPointRef, filter_screenpts_adapter<path_points>, assign_path)
break;
}
// nothing to draw
if (!isExist) return true;
int const layer = f.GetLayer();
DrawerYG * pDrawer = GetDrawer();
// remove duplicating identical drawing keys
PreProcessKeys();
// get drawing rules for the m_keys array
size_t const count = m_keys.size();
buffer_vector<di::DrawRule, reserve_rules_count> rules;
rules.resize(count);
int const layer = f.GetLayer();
for (size_t i = 0; i < count; ++i)
{
int depth = m_keys[i].m_priority;
@ -191,6 +156,97 @@ namespace fwork
sort(rules.begin(), rules.end(), less_depth());
m_renderState->m_isEmptyModelCurrent = false;
shared_ptr<di::DrawInfo> ptr(new di::DrawInfo(f.GetPreferredDrawableName()));
DrawerYG * pDrawer = GetDrawer();
using namespace get_pts;
bool isExist = false;
switch (type)
{
case GEOM_POINT:
{
typedef get_pts::one_point functor_t;
functor_t::params p;
p.m_convertor = &m_convertor;
p.m_rect = &m_rect;
functor_t fun(p);
GET_POINTS(f, ForEachPointRef, fun, assign_point)
break;
}
case GEOM_AREA:
{
typedef filter_screenpts_adapter<area_tess_points> functor_t;
functor_t::params p;
p.m_convertor = &m_convertor;
p.m_rect = &m_rect;
functor_t fun(p);
GET_POINTS(f, ForEachTriangleExRef, fun, assign_area)
{
// if area feature has any line-drawing-rules, than draw it like line
for (size_t i = 0; i < m_keys.size(); ++i)
if (m_keys[i].m_type == drule::line)
goto draw_line;
break;
}
}
draw_line:
case GEOM_LINE:
{
typedef filter_screenpts_adapter<path_points> functor_t;
functor_t::params p;
p.m_convertor = &m_convertor;
p.m_rect = &m_rect;
if (!ptr->m_name.empty())
{
double fontSize = 0;
for (size_t i = 0; i < count; ++i)
{
if (pDrawer->filter_text_size(rules[i].m_rule))
fontSize = pDrawer->get_pathtext_font_size(rules[i].m_rule);
}
if (fontSize != 0)
{
double textLength = m_glyphCache->getTextLength(fontSize, ptr->m_name);
typedef calc_length<base_screen> functor_t;
functor_t::params p1;
p1.m_convertor = &m_convertor;
p1.m_rect = &m_rect;
functor_t fun(p1);
f.ForEachPointRef(fun, m_zoom);
if ((fun.IsExist()) && (fun.m_length > textLength))
{
textLength += 200;
p.m_startLength = (fun.m_length - textLength) / 2;
p.m_endLength = p.m_startLength + textLength;
}
}
}
functor_t fun(p);
GET_POINTS(f, ForEachPointRef, fun, assign_path)
break;
}
}
// nothing to draw
if (!isExist) return true;
// remove duplicating identical drawing keys
PreProcessKeys();
#ifdef PROFILER_DRAWING
m_drawCount += m_keys.size();
#endif
@ -632,7 +688,7 @@ void FrameWork<TModel>::AddRedrawCommandSure()
int scaleLevel
)
{
fwork::DrawProcessor doDraw(selectRect, screen, e, scaleLevel, m_renderQueue.renderStatePtr());
fwork::DrawProcessor doDraw(selectRect, screen, e, scaleLevel, m_renderQueue.renderStatePtr(), m_resourceManager->getGlyphCache());
m_renderQueue.renderStatePtr()->m_isEmptyModelCurrent = true;
try

4
map/framework.hpp
View file

@ -64,6 +64,7 @@ namespace fwork
int m_zoom;
shared_ptr<yg::gl::RenderState> m_renderState;
yg::GlyphCache * m_glyphCache;
#ifdef PROFILER_DRAWING
size_t m_drawCount;
@ -81,7 +82,8 @@ namespace fwork
ScreenBase const & convertor,
shared_ptr<PaintEvent> const & paintEvent,
int scaleLevel,
shared_ptr<yg::gl::RenderState> const & renderState);
shared_ptr<yg::gl::RenderState> const & renderState,
yg::GlyphCache * glyphCache);
bool operator() (FeatureType const & f);
};

5
map/render_queue_routine.cpp
View file

@ -176,8 +176,7 @@ void RenderQueueRoutine::getUpdateAreas(
{
areas.push_back(newRect);
/*
int rectW = (newRect.SizeX() + 9) / 5;
/* int rectW = (newRect.SizeX() + 9) / 5;
int rectH = (newRect.SizeY() + 9) / 5;
m2::RectI r( 2 * rectW, 2 * rectH, 3 * rectW, 3 * rectH);
areas.push_back(r);
@ -205,7 +204,7 @@ void RenderQueueRoutine::getUpdateAreas(
areas.push_back(m2::Offset(r, 0, 2*rectH));
areas.push_back(m2::Offset(r, -rectW, 2*rectH));
areas.push_back(m2::Offset(r, -2*rectW, 2*rectH));
*/
*/
}
}

14
yg/glyph_cache.cpp
View file

@ -7,6 +7,7 @@
#include "ft2_debug.hpp"
#include "../coding/lodepng_io.hpp"
#include "../coding/strutil.hpp"
#include "../base/logging.hpp"
@ -237,6 +238,19 @@ namespace yg
return info;
}
double GlyphCache::getTextLength(double fontSize, string const & text)
{
wstring s = FromUtf8(text);
double len = 0;
for (unsigned i = 0; i < s.size(); ++i)
{
GlyphKey k(s[i], fontSize, false, yg::Color(0, 0, 0, 255));
len += getGlyphMetrics(k).m_xAdvance;
}
return len;
}
void GlyphInfo::dump(const char * /*fileName */)
{
/* gil::lodepng_write_view(fileName,

2
yg/glyph_cache.hpp
View file

@ -72,5 +72,7 @@ namespace yg
shared_ptr<GlyphInfo> const getGlyph(GlyphKey const & key);
/// return control box(could be slightly larger than the precise bound box).
GlyphMetrics const getGlyphMetrics(GlyphKey const & key);
double getTextLength(double fontSize, string const & text);
};
}

31
yg/glyph_layout.cpp
View file

@ -324,4 +324,35 @@ namespace yg
{
return m_entries;
}
m2::RectD const GlyphLayout::limitRect() const
{
bool isFirst = true;
m2::RectD res;
for (unsigned i = m_firstVisible; i < m_lastVisible; ++i)
{
m2::AARectD symRectAA(
m_entries[i].m_pt.Move(m_entries[i].m_metrics.m_height, m_entries[i].m_angle - math::pi / 2),
m_entries[i].m_angle,
m2::RectD(m_entries[i].m_metrics.m_xOffset,
m_entries[i].m_metrics.m_yOffset,
m_entries[i].m_metrics.m_xOffset + m_entries[i].m_metrics.m_width,
m_entries[i].m_metrics.m_yOffset + m_entries[i].m_metrics.m_height));
m2::PointD pts[4];
symRectAA.GetGlobalPoints(pts);
if (isFirst)
res = m2::RectD(pts[0].x, pts[0].y, pts[0].x, pts[0].y);
else
res.Add(pts[0]);
res.Add(pts[1]);
res.Add(pts[2]);
res.Add(pts[3]);
}
return res;
}
}

3
yg/glyph_layout.hpp
View file

@ -1,6 +1,7 @@
#pragma once
#include "defines.hpp"
#include "../geometry/rect2d.hpp"
#include "../std/vector.hpp"
#include "../std/string.hpp"
@ -53,5 +54,7 @@ namespace yg
size_t lastVisible() const;
vector<GlyphLayoutElem> const & entries() const;
m2::RectD const limitRect() const;
};
}

5
yg/resource_manager.cpp
View file

@ -203,6 +203,11 @@ namespace yg
return m_glyphCache.getGlyphMetrics(key);
}
GlyphCache * ResourceManager::getGlyphCache()
{
return &m_glyphCache;
}
void ResourceManager::addFonts(vector<string> const & fontNames)
{
m_glyphCache.addFonts(fontNames);

1
yg/resource_manager.hpp
View file

@ -96,6 +96,7 @@ namespace yg
shared_ptr<GlyphInfo> const getGlyph(GlyphKey const & key);
GlyphMetrics const getGlyphMetrics(GlyphKey const & key);
GlyphCache * getGlyphCache();
void addFonts(vector<string> const & fontNames);