ElementPtr ElementSorter::readNextElement()
{
ElementPtr result;
ConstElementPtr cr;
if (_nodeIndex != _nodeIds.size())
{
cr = _source->getNode(_nodeIds[_nodeIndex++]);
}
else if (_wayIndex != _wayIds.size())
{
cr = _source->getWay(_wayIds[_wayIndex++]);
}
else if (_relationIndex != _relationIds.size())
{
cr = _source->getRelation(_relationIds[_relationIndex++]);
}
if (cr.get())
{
result.reset(cr->clone());
}
return result;
}
virtual void visit(const ConstElementPtr& e)
{
const Tags& t = e->getTags();
const QString REV = MetadataTags::TrainingReview();
const QString MAT = MetadataTags::TrainingMatch();
if (t.contains(MetadataTags::TrainingId()) ||
t.contains(MAT) ||
t.contains(REV))
{
if (t.contains(MetadataTags::TrainingId()) == false ||
t.contains(MAT) == false)
{
LOG_WARN(QString("Element %1 doesn't contain %2 and %3.")
.arg(e->getElementId().toString())
.arg(MetadataTags::TrainingId())
.arg(MAT));
}
if (t[MAT] == "todo")
{
LOG_WARN("Element " << e->getElementId().toString() << " (" <<
t[MetadataTags::TrainingId()] << ") is still marked as todo: ");
}
if (!(t[MAT] == "none" || t[MAT] == "") &&
!(t[REV] == "none" || t[REV] == ""))
{
LOG_WARN("Element " << e->getElementId().toString() << " (" <<
t[MetadataTags::TrainingId()] << ") has both match and review populated.");
LOG_WARN(" '" << t[MAT] << "' and '" <<
t[REV] << "'");
}
}
}
void MaximalSublineStringMatcher::_validateElement(const ConstOsmMapPtr& map, ElementId eid) const
{
ConstElementPtr e = map->getElement(eid);
if (e->getElementType() == ElementType::Relation)
{
ConstRelationPtr r = dynamic_pointer_cast<const Relation>(e);
if (OsmSchema::getInstance().isMultiLineString(*r) == false)
{
throw NeedsReviewException("Internal Error: When matching sublines expected a multilinestring "
"relation not a " + r->getType() + ". A non-multilinestring should never be found here. "
"Please report this to [email protected]");
}
const vector<RelationData::Entry>& entries = r->getMembers();
for (size_t i = 0; i < entries.size(); i++)
{
if (entries[i].getElementId().getType() != ElementType::Way)
{
throw NeedsReviewException("MultiLineString relations can only contain ways when matching "
"sublines.");
}
}
}
if (e->getElementType() == ElementType::Way)
{
ConstWayPtr w = dynamic_pointer_cast<const Way>(e);
if (w->getNodeCount() <= 1)
{
throw NeedsReviewException("Internal Error: Attempting to match against a zero length way.");
}
}
}
bool LinearCriterion::isSatisfied(const ConstElementPtr& e) const
{
bool result = false;
if (e->getElementType() == ElementType::Node)
{
return false;
}
const Tags& t = e->getTags();
if (e->getElementType() == ElementType::Relation)
{
ConstRelationPtr r = boost::dynamic_pointer_cast<const Relation>(e);
result |= r->getType() == MetadataTags::RelationMultilineString();
result |= r->getType() == MetadataTags::RelationRoute();
result |= r->getType() == MetadataTags::RelationBoundary();
}
for (Tags::const_iterator it = t.constBegin(); it != t.constEnd(); ++it)
{
const SchemaVertex& tv = OsmSchema::getInstance().getTagVertex(it.key() + "=" + it.value());
uint16_t g = tv.geometries;
if (g & (OsmGeometries::LineString | OsmGeometries::ClosedWay) && !(g & OsmGeometries::Area))
{
result = true;
break;
}
}
return result;
}
Handle<Value> ElementJs::getCircularError(const Arguments& args) {
HandleScope scope;
ConstElementPtr e = ObjectWrap::Unwrap<ElementJs>(args.This())->getConstElement();
return scope.Close(toV8(e->getCircularError()));
}
void MaximalSublineStringMatcher::_validateElement(const ConstOsmMapPtr& map, ElementId eid) const
{
ConstElementPtr e = map->getElement(eid);
if (e->getElementType() == ElementType::Relation)
{
ConstRelationPtr r = dynamic_pointer_cast<const Relation>(e);
if (OsmSchema::getInstance().isMultiLineString(*r) == false)
{
throw NeedsReviewException("When matching sublines expected a multilinestring relation not"
" a " + r->getType());
}
const vector<RelationData::Entry>& entries = r->getMembers();
for (size_t i = 0; i < entries.size(); i++)
{
if (entries[i].getElementId().getType() != ElementType::Way)
{
throw NeedsReviewException("MultiLineString relations can only contain ways when matching "
"sublines.");
}
}
}
}
bool PoiPolygonMatch::isPoiIsh(ConstElementPtr e)
{
return e->getElementType() == ElementType::Node &&
(OsmSchema::getInstance().getCategories(e->getTags()).intersects(
OsmSchemaCategory::building() | OsmSchemaCategory::poi()) ||
e->getTags().getNames().size() > 0);
}
Handle<Value> ElementJs::getElementId(const Arguments& args) {
HandleScope scope;
ConstElementPtr e = ObjectWrap::Unwrap<ElementJs>(args.This())->getConstElement();
return scope.Close(ElementIdJs::New(e->getElementId()));
}
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());
}
}
Handle<Value> ElementJs::toString(const Arguments& args)
{
HandleScope scope;
ConstElementPtr e = ObjectWrap::Unwrap<ElementJs>(args.This())->getConstElement();
return scope.Close(String::New(e->toString().toUtf8().data()));
}
QString OsmApiDbSqlChangesetFileWriter::_getUpdateValuesWayOrRelationStr(ConstElementPtr element) const
{
return
QString("changeset_id=%2, visible=%3, \"timestamp\"=%5, version=%4 WHERE id=%1;\n")
.arg(element->getId())
.arg(element->getChangeset())
.arg(_getVisibleStr(element->getVisible()))
.arg(element->getVersion())
.arg(OsmApiDb::TIMESTAMP_FUNCTION);
}
QString OsmApiDbSqlChangesetFileWriter::_getInsertValuesWayOrRelationStr(ConstElementPtr element) const
{
return
QString("changeset_id, visible, \"timestamp\", "
"version) VALUES (%1, %2, %3, %5, %4);\n")
.arg(element->getId())
.arg(element->getChangeset())
.arg(_getVisibleStr(element->getVisible()))
.arg(element->getVersion())
.arg(OsmApiDb::TIMESTAMP_FUNCTION);
}
bool HgisPoiCriterion::isSatisfied(const ConstElementPtr& e) const
{
bool result = false;
// See ticket #6853 for a definition of a "HGIS POI"
if (e->getElementType() == ElementType::Node)
{
result =
OsmSchema::getInstance().hasCategory(e->getTags(), OsmSchemaCategory::hgisPoi().toString());
}
return result;
}
void DecomposeBuildingRelationsVisitor::visit(const ConstElementPtr& e)
{
if (e->getElementType() == ElementType::Relation)
{
const shared_ptr<Relation>& r = _map->getRelation(e->getId());
if (r->getType() == "building")
{
_decomposeBuilding(r);
}
}
}
vector<ConstWayPtr> ExtractWaysVisitor::extractWays(const ConstOsmMapPtr& map,
const ConstElementPtr& e)
{
LOG_TRACE("Extracting ways from " << e->getElementId());
vector<ConstWayPtr> result;
ExtractWaysVisitor v(result);
v.setOsmMap(map.get());
e->visitRo(*map, v);
return result;
}
void OsmApiDbSqlChangesetFileWriter::_createNewElement(ConstElementPtr element)
{
const QString elementTypeStr = element->getElementType().toString().toLower();
ElementPtr changeElement = _getChangeElement(element);
//we only grab and assign a new id if we have a new element with a negative id, since we'll be
//writing this directly to the database and negative ids aren't allowed
LOG_TRACE("ID before: " << changeElement->getElementId());
long id;
if (changeElement->getId() < 0)
{
id = _db.getNextId(element->getElementType().getEnum());
}
else
{
id = changeElement->getId();
}
LOG_TRACE("ID after: " << ElementId(changeElement->getElementType(), id));
changeElement->setId(id);
changeElement->setVersion(1);
changeElement->setVisible(true);
changeElement->setChangeset(_changesetId);
LOG_TRACE("Creating: " << changeElement->getElementId());
QString note = "";
LOG_VART(changeElement->getId());
LOG_VART(note);
LOG_VART(changeElement->getVersion());
QString commentStr = "/* create " + elementTypeStr + " " + QString::number(changeElement->getId());
commentStr += "*/\n";
_outputSql.write((commentStr).toUtf8());
const QString values = _getInsertValuesStr(changeElement);
_outputSql.write(
("INSERT INTO " + elementTypeStr + "s (" + elementTypeStr + "_id, " + values).toUtf8());
_outputSql.write(("INSERT INTO current_" + elementTypeStr + "s (id, " + values).toUtf8());
_createTags(changeElement);
switch (changeElement->getElementType().getEnum())
{
case ElementType::Way:
_createWayNodes(boost::dynamic_pointer_cast<const Way>(changeElement));
break;
case ElementType::Relation:
_createRelationMembers(boost::dynamic_pointer_cast<const Relation>(changeElement));
break;
default:
//node
break;
}
}
void KeepBuildingsVisitor::visit(const ConstElementPtr& e)
{
ElementType type = e->getElementType();
long id = e->getId();
if (type != ElementType::Node)
{
boost::shared_ptr<Element> ee = _map->getElement(type, id);
if (BuildingCriterion().isSatisfied(ee->getTags(), type) == false)
{
RemoveElementOp::removeElementNoCheck(_map->shared_from_this(), e->getElementId());
}
}
}
virtual void visit(const ConstElementPtr& e)
{
if (e->getStatus() == _matchStatus && isMatchCandidate(e))
{
checkForMatch(e);
}
}
QString OsmPgCsvWriter::_getTags(const ConstElementPtr& e)
{
QString buffer;
QTextStream stream(&buffer);
stream.setCodec("UTF-8");
const Tags& tags = e->getTags();
QRegExp regex("[\"=>, -]");
for (Tags::const_iterator it = tags.constBegin(); it != tags.constEnd(); ++it)
{
// Comma separated list
if (it != tags.constBegin())
stream << ",";
// Surround the key with quotes if it contains a special character requiring it
if (it.key().contains(regex))
stream << "\"" << QString(it.key()).replace("\"", "\\\"") << "\"";
else
stream << it.key();
stream<< "=>";
// Surround the value with quotes if it contains a special character requiring it
if (it.value().contains(regex))
stream << "\"" << QString(it.value()).replace("\"", "\\\"") << "\"";
else
stream << it.value();
}
return stream.readAll();
}
Handle<Object> ElementJs::New(ConstElementPtr e)
{
HandleScope scope;
Handle<Object> result;
switch (e->getElementType().getEnum())
{
case ElementType::Node:
{
ConstNodePtr n = dynamic_pointer_cast<const Node>(e);
result = NodeJs::New(n);
break;
}
case ElementType::Way:
{
ConstWayPtr w = dynamic_pointer_cast<const Way>(e);
result = WayJs::New(w);
break;
}
case ElementType::Relation:
{
ConstRelationPtr r = dynamic_pointer_cast<const Relation>(e);
result = RelationJs::New(r);
break;
}
default:
throw IllegalArgumentException("Unexpected element type.");
}
return scope.Close(result);
}
void KeepBuildingsVisitor::visit(const ConstElementPtr& e)
{
ElementType type = e->getElementType();
long id = e->getId();
if (type != ElementType::Node)
{
shared_ptr<Element> ee = _map->getElement(type, id);
if (OsmSchema::getInstance().isBuilding(ee->getTags(), type) == false)
{
// @todo This could do bad things if the element is in use.
_map->removeElementNoCheck(type, id);
}
}
}
void TagKeyCountVisitor::visit(const ConstElementPtr& e)
{
if (e->getTags().contains(_key))
{
_keyCount++;
}
}
virtual void visit(const ConstElementPtr& e)
{
if (e->getElementType() == ElementType::Way)
{
WayDiscretizer wd(_map->shared_from_this(), dynamic_pointer_cast<const Way>(e));
wd.discretize(_spacing, _result);
}
}
void OsmApiDbSqlChangesetFileWriter::_createTags(ConstElementPtr element)
{
LOG_TRACE("Creating tags for: " << element->getElementId());
QStringList tableNames = _tagTableNamesForElement(element->getElementId());
Tags tags = element->getTags();
if (_includeDebugTags)
{
tags.set(MetadataTags::HootStatus(), QString::number(element->getStatus().getEnum()));
}
LOG_VART(tags);
if (element->getElementType().getEnum() == ElementType::Relation && !tags.contains("type"))
{
ConstRelationPtr tmp = boost::dynamic_pointer_cast<const Relation>(element);
tags.appendValue("type", tmp->getType());
}
for (Tags::const_iterator it = tags.begin(); it != tags.end(); ++it)
{
QString k = it.key();
QString v = it.value();
if (k != MetadataTags::HootHash())
{
const QString currentTagValues =
QString("(%1_id, k, v) VALUES (%2, '%3', '%4');\n")
.arg(element->getElementId().getType().toString().toLower())
.arg(element->getElementId().getId())
.arg(k.replace('\'', "''"))
.arg(v.replace('\'', "''"));
const QString tagValues =
QString("(%1_id, k, v, version) VALUES (%2, '%3', '%4', %5);\n")
.arg(element->getElementId().getType().toString().toLower())
.arg(element->getElementId().getId())
.arg(k.replace('\'', "''"))
.arg(v.replace('\'', "''"))
.arg(element->getVersion());
_outputSql.write(
(QString("INSERT INTO %1 ").arg(tableNames.at(0)) + currentTagValues).toUtf8());
_outputSql.write((QString("INSERT INTO %1 ").arg(tableNames.at(1)) + tagValues).toUtf8());
}
}
}
void OgrWriter::_writePartial(ElementProviderPtr& provider, const ConstElementPtr& e)
{
if (_translator.get() == 0)
{
throw HootException("You must call open before attempting to write.");
}
if (e->getTags().getInformationCount() > 0)
{
// There is probably a cleaner way of doing this.
// convertToGeometry calls getGeometryType which will throw an exception if it gets a relation
// that it doesn't know about. E.g. "route", "superroute", " turnlanes:turns" etc
shared_ptr<Geometry> g;
try
{
g = ElementConverter(provider).convertToGeometry(e);
}
catch (IllegalArgumentException& err)
{
LOG_WARN("Error converting geometry: " << err.getWhat() << " (" << e->toString() << ")");
g.reset((GeometryFactory::getDefaultInstance()->createEmptyGeometry()));
}
/*
LOG_DEBUG("After conversion to geometry, element is now a " <<
g->getGeometryType() );
*/
Tags t = e->getTags();
t["error:circular"] = QString::number(e->getCircularError());
t["hoot:status"] = e->getStatusString();
for (Tags::const_iterator it = e->getTags().begin(); it != e->getTags().end(); ++it)
{
if (t[it.key()] == "")
{
t.remove(it.key());
}
}
vector<ScriptToOgrTranslator::TranslatedFeature> tf = _translator->translateToOgr(t,
e->getElementType(), g->getGeometryTypeId());
// only write the feature if it wasn't filtered by the translation script.
for (size_t i = 0; i < tf.size(); i++)
{
OGRLayer* layer = _getLayer(tf[i].tableName);
if (layer != 0)
{
_addFeature(layer, tf[i].feature, g);
}
}
}
}
void TranslatedTagCountVisitor::visit(const ConstElementPtr& e)
{
if (e->getTags().getInformationCount() > 0)
{
shared_ptr<Geometry> g = ElementConverter(_map->shared_from_this()).convertToGeometry(e);
Tags t = e->getTags();
t["error:circular"] = QString::number(e->getCircularError());
t["hoot:status"] = e->getStatusString();
// remove all the empty tags.
for (Tags::const_iterator it = e->getTags().begin(); it != e->getTags().end(); ++it)
{
if (t[it.key()] == "")
{
t.remove(it.key());
}
}
QString layerName;
vector<ScriptToOgrTranslator::TranslatedFeature> f = _translator->translateToOgr(t,
e->getElementType(), g->getGeometryTypeId());
// only write the feature if it wasn't filtered by the translation script.
for (size_t i = 0; i < f.size(); i++)
{
_countTags(f[i].feature);
}
}
}
void UniqueNamesVisitor::visit(const ConstElementPtr& e)
{
QStringList names = e->getTags().getNames();
for (int i = 0; i < names.size(); i++)
{
_names.insert(names[i]);
}
}
virtual void visit(const ConstElementPtr& e)
{
QStringList refs;
if (e->getTags().contains(_ref))
{
e->getTags().readValues(_ref, refs);
}
refs.removeAll("todo");
refs.removeAll("none");
if (refs.size() > 0)
{
for (int i = 0; i < refs.size(); i++)
{
_ref2Eid[refs[i]].insert(e->getElementId());
}
}
}
// See the "Calculating Search Radius" section in the user docs for more information.
Meters getSearchRadius(const ConstElementPtr& e)
{
Meters result;
if (_getSearchRadius.IsEmpty())
{
if (_customSearchRadius < 0)
{
//base the radius off of the element itself
result = e->getCircularError() * _candidateDistanceSigma;
}
else
{
//base the radius off some predefined radius
result = _customSearchRadius * _candidateDistanceSigma;
}
}
else
{
if (_searchRadiusCache.contains(e->getElementId()))
{
result = _searchRadiusCache[e->getElementId()];
}
else
{
Isolate* current = v8::Isolate::GetCurrent();
HandleScope handleScope(current);
Context::Scope context_scope(_script->getContext(current));
Handle<Value> jsArgs[1];
int argc = 0;
jsArgs[argc++] = ElementJs::New(e);
LOG_TRACE("Calling getSearchRadius...");
Handle<Value> f = ToLocal(&_getSearchRadius)->Call(getPlugin(), argc, jsArgs);
result = toCpp<Meters>(f) * _candidateDistanceSigma;
_searchRadiusCache[e->getElementId()] = result;
}
}
return result;
}
double NameExtractor::extract(const ConstElementPtr& target, const ConstElementPtr& candidate) const
{
QStringList targetNames = target->getTags().getNames();
targetNames.append(target->getTags().getPseudoNames());
QStringList candidateNames = candidate->getTags().getNames();
candidateNames.append(candidate->getTags().getPseudoNames());
double score = -1;
for (int i = 0; i < targetNames.size(); i++)
{
for (int j = 0; j < candidateNames.size(); j++)
{
double thisScore = _d->compare(targetNames[i], candidateNames[j]);
score = max(thisScore, score);
}
}
if (score == -1)
{
return nullValue();
}
else
{
// LOG_INFO("score: " << score << " weight: " << weight);
// LOG_INFO("target: " << target->toString());
// LOG_INFO("candidate: " << candidate->toString());
// if (candidate->getTags()["REF2"].contains(target->getTags()["REF1"]))
// {
// LOG_INFO(getName() << " | Match: " << score << " | " <<
// target->getTags().getNames().join(";") << " | " <<
// candidate->getTags().getNames().join(";"))
// }
// else
// {
// LOG_INFO(getName() << " | Miss: " << score << " | " <<
// target->getTags().getNames().join(";") << " | " <<
// candidate->getTags().getNames().join(";"))
// }
}
return score;
}
