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] << "'");
}
}
}
/**
* Returns true if e1, e2 is in the correct ordering for matching. This does a few things:
*
* - Avoid comparing e1 to e2 and e2 to e1
* - The Unknown1/Input1 is always e1. This is a requirement for some of the older code.
* - Gives a consistent ordering to allow backwards compatibility with system tests.
*/
bool isCorrectOrder(const ConstElementPtr& e1, const ConstElementPtr& e2)
{
if (e1->getStatus().getEnum() == e2->getStatus().getEnum())
{
return e1->getElementId() < e2->getElementId();
}
else
{
return e1->getStatus().getEnum() < e2->getStatus().getEnum();
}
}
Handle<Value> ElementJs::getElementId(const Arguments& args) {
HandleScope scope;
ConstElementPtr e = ObjectWrap::Unwrap<ElementJs>(args.This())->getConstElement();
return scope.Close(ElementIdJs::New(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;
}
WaySublineMatchString MaximalSublineStringMatcher::findMatch(const ConstOsmMapPtr& map,
const ConstElementPtr& e1, const ConstElementPtr& e2, Meters maxRelevantDistance) const
{
assert(_maxAngle >= 0);
if (maxRelevantDistance == -1)
{
maxRelevantDistance = e1->getCircularError() + e2->getCircularError();
}
// make sure the inputs are legit. If either element isn't legit then throw a NeedsReviewException
_validateElement(map, e1->getElementId());
_validateElement(map, e2->getElementId());
// extract the ways from the elements. In most cases it will return a vector of 1, but
// multilinestrings may contain multiple ways
vector<ConstWayPtr> ways1 = ExtractWaysVisitor::extractWays(map, e1);
vector<ConstWayPtr> ways2 = ExtractWaysVisitor::extractWays(map, e2);
if ((ways1.size() > 4 && ways2.size() > 4) || (ways1.size() + ways2.size() > 7))
{
throw NeedsReviewException("Elements contain too many ways and the computational complexity "
"is unreasonable.");
}
// Try with all combinations of forward and reversed ways. This is very expensive for
// multilinestrings with lots of ways in them. Though those shouldn't be common.
vector<bool> reversed1(ways1.size(), false), reversed2(ways2.size(), false);
ScoredMatch scoredResult = _findBestMatch(map, maxRelevantDistance, ways1, ways2, reversed1,
reversed2);
// convert the best match into a WaySublineStringMatch and return.
try
{
WaySublineMatchString result = scoredResult.matches;
// this likely shouldn't be necessary. See #4593
result.removeEmptyMatches();
return result;
}
catch(OverlappingMatchesException &e)
{
throw NeedsReviewException("Internal Error: Multiple overlapping way matches were found within "
"one set of ways. Please report this to [email protected].");
}
}
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;
}
bool isMatchCandidate(ConstElementPtr e)
{
if (_matchCandidateCache.contains(e->getElementId()))
{
return _matchCandidateCache[e->getElementId()];
}
if (_filter && !_filter->isSatisfied(e))
{
return false;
}
Isolate* current = v8::Isolate::GetCurrent();
HandleScope handleScope(current);
Context::Scope context_scope(_script->getContext(current));
Persistent<Object> plugin(current, getPlugin(_script));
Handle<String> isMatchCandidateStr = String::NewFromUtf8(current, "isMatchCandidate");
if (ToLocal(&plugin)->Has(isMatchCandidateStr) == false)
{
throw HootException("Error finding 'isMatchCandidate' function.");
}
Handle<Value> value = ToLocal(&plugin)->Get(isMatchCandidateStr);
if (value->IsFunction() == false)
{
throw HootException("isMatchCandidate is not a function.");
}
Handle<Function> func = Handle<Function>::Cast(value);
Handle<Value> jsArgs[2];
int argc = 0;
jsArgs[argc++] = getOsmMapJs();
jsArgs[argc++] = ElementJs::New(e);
Handle<Value> f = func->Call(ToLocal(&plugin), argc, jsArgs);
bool result = f->BooleanValue();
_matchCandidateCache[e->getElementId()] = result;
return result;
}
MatchClassification MultiaryScoreCache::getScore(ConstElementPtr e1, ConstElementPtr e2)
{
_lastExplainText.clear();
OsmMapPtr tmp(new OsmMap(_map->getProjection()));
tmp->addElement(ElementPtr(e1->clone()));
tmp->addElement(ElementPtr(e2->clone()));
boost::scoped_ptr<Match> m(
_matchCreator->createMatch(tmp, e1->getElementId(), e2->getElementId()));
// default to a hard miss.
MatchClassification result(0, 1, 0);
// if the MatchCreator returns a valid match class, use that as the score.
if (m)
{
result = m->getClassification();
_lastExplainText = m->explain();
}
return result;
}
void TranslationVisitor::visit(const ConstElementPtr& ce)
{
// this is a hack to get around the visitor interface. The visitor interface should probably be
// redesigned into ConstElementVisitor and ElementVisitor.
ElementPtr e = _map->getElement(ce->getElementId());
Tags& tags = e->getTags();
if (tags.getNonDebugCount() > 0)
{
if (_toOgr)
{
GeometryTypeId gtype = ElementConverter::getGeometryType(e, false);
vector<Tags> allTags = _togr->translateToOgrTags(tags, e->getElementType(), gtype);
if (allTags.size() > 0)
{
if (allTags.size() > 1)
{
LOG_WARN("More than one feature was returned, only keeping the first feature.");
}
e->setTags(allTags[0]);
}
}
else
{
QByteArray layerName;
if (tags.contains(OsmSchema::layerNameKey()))
{
layerName = tags[OsmSchema::layerNameKey()].toUtf8();
}
_t.translateToOsm(tags, layerName.data());
if (tags.contains(_circularErrorKey))
{
e->setCircularError(tags.getDouble(_circularErrorKey));
tags.remove(_circularErrorKey);
tags.remove(_accuracyKey);
}
else if (tags.contains(_accuracyKey))
{
e->setCircularError(tags.getDouble(_accuracyKey));
tags.remove(_circularErrorKey);
tags.remove(_accuracyKey);
}
}
}
}
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)
{
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());
}
}
}
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 AddUuidVisitor::visit(const ConstElementPtr& e)
{
boost::shared_ptr<Element> ee = _map->getElement(e->getElementId());
ee->getTags()[_key] = UuidHelper::createUuid().toString();
}