void RemoveUnknown1Visitor::visit(const shared_ptr<Element>& e)
{
if (e->getStatus() == Status::Unknown1)
{
RecursiveElementRemover(e->getElementId()).apply(_map->shared_from_this());
}
}
void PertyRemoveRandomElementVisitor::visit(const ConstElementPtr& e)
{
boost::uniform_real<> uni(0.0, 1.0);
if (uni(*_rng) <= _p)
{
RecursiveElementRemover(ElementId(e->getElementType(), e->getId())).apply(_map->shared_from_this());
}
}
virtual void visit(const shared_ptr<Element>& e)
{
if (_criterion->isSatisfied(e))
{
NotCriterion nc(_criterion);
RecursiveElementRemover(e->getElementId(), &nc).apply(_map->shared_from_this());
}
}
void RemoveDuplicateAreaVisitor::_removeOne(shared_ptr<Element> e1, shared_ptr<Element> e2)
{
if (e1->getTags().size() > e2->getTags().size())
{
RecursiveElementRemover(e2->getElementId()).apply(_map->shared_from_this());
}
else if (e1->getTags().size() < e2->getTags().size())
{
RecursiveElementRemover(e1->getElementId()).apply(_map->shared_from_this());
}
else if (e1->getId() < e2->getId())
{
RecursiveElementRemover(e1->getElementId()).apply(_map->shared_from_this());
}
else
{
RecursiveElementRemover(e2->getElementId()).apply(_map->shared_from_this());
}
}
virtual void visit(ElementType type, long id)
{
ElementId eid(type, id);
ElementPtr e = _map->getElement(eid);
if (e->getTags().get("REF1") != _ref && e->getTags().get("REF2") != _ref)
{
RecursiveElementRemover(eid).apply(_map);
}
}
void DecomposeBuildingRelationsVisitor::_decomposeBuilding(const shared_ptr<Relation>& r)
{
Tags baseTags = r->getTags();
const vector<RelationData::Entry> members = r->getMembers();
for (size_t i = 0; i < members.size(); ++i)
{
ElementId eid = members[i].getElementId();
r->removeElement(eid);
if (eid.getType() == ElementType::Node)
{
LOG_WARN("Unexpected node encountered in building relation. " << r->getElementId());
continue;
}
// we're dropping the outline. We only care about the parts.
else if (members[i].getRole() == "outline")
{
continue;
}
else if (members[i].getRole() != "part")
{
LOG_WARN("Encountered an unexpected role in a building relation. " << r->getElementId());
}
// ok, we've got a building part. Recompose it as a building.
shared_ptr<Element> e = _map->getElement(members[i].getElementId());
Tags t = baseTags;
t.addTags(e->getTags());
// don't need the building:part tag anymore.
t.remove("building:part");
if (!t.contains("building"))
{
t["building"] = "yes";
}
e->setTags(t);
}
// remove the building relation
RecursiveElementRemover(r->getElementId()).apply(_map->shared_from_this());
}
void RemoveElementsVisitor::visit(const ConstElementPtr& e)
{
assert(_filter);
ElementType type = e->getElementType();
long id = e->getId();
const shared_ptr<Element>& ee = _map->getElement(type, id);
if (_filter->isSatisfied(ee))
{
if (_recursive)
{
RecursiveElementRemover(ee->getElementId()).apply(_map->shared_from_this());
}
else
{
_map->removeElement(ElementId(type, id));
}
}
}
void PoiPolygonMerger::apply(const OsmMapPtr& map,
vector< pair<ElementId, ElementId> >& replaced) const
{
////
// See "Hootenanny - POI to Building" powerpoint for more details.
////
// merge all POI tags first, but keep Unknown1 and Unknown2 separate. It is implicitly assumed
// that since they're in a single group they all represent the same entity.
Tags poiTags1 = _mergePoiTags(map, Status::Unknown1);
Tags poiTags2 = _mergePoiTags(map, Status::Unknown2);
// Get all the building parts for each status
vector<ElementId> buildings1 = _getBuildingParts(map, Status::Unknown1);
vector<ElementId> buildings2 = _getBuildingParts(map, Status::Unknown2);
// Merge all the building parts together into a single building entity using the typical building
// merge process.
ElementId finalBuildingEid = _mergeBuildings(map, buildings1, buildings2, replaced);
ElementPtr finalBuilding = map->getElement(finalBuildingEid);
Tags finalBuildingTags = finalBuilding->getTags();
if (poiTags1.size())
{
finalBuildingTags = TagMergerFactory::getInstance().mergeTags(poiTags1, finalBuildingTags,
finalBuilding->getElementType());
}
if (poiTags2.size())
{
finalBuildingTags = TagMergerFactory::getInstance().mergeTags(finalBuildingTags,
poiTags2, finalBuilding->getElementType());
}
finalBuilding->setTags(finalBuildingTags);
// do some book keeping to remove the POIs and mark them as replaced.
for (set< pair<ElementId, ElementId> >::const_iterator it = _pairs.begin(); it != _pairs.end();
++it)
{
const pair<ElementId, ElementId>& p = *it;
if (p.first.getType() == ElementType::Node)
{
replaced.push_back(pair<ElementId, ElementId>(p.first, finalBuildingEid));
// clear the tags just in case it is part of a way
if (map->containsElement(p.first))
{
map->getElement(p.first)->getTags().clear();
RecursiveElementRemover(p.first).apply(map);
}
}
if (p.second.getType() == ElementType::Node)
{
replaced.push_back(pair<ElementId, ElementId>(p.second, finalBuildingEid));
// clear the tags just in case it is part of a way
if (map->containsElement(p.second))
{
map->getElement(p.second)->getTags().clear();
RecursiveElementRemover(p.second).apply(map);
}
}
}
}
