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);
}
}
}
Handle<Value> ElementJs::getCircularError(const Arguments& args) {
HandleScope scope;
ConstElementPtr e = ObjectWrap::Unwrap<ElementJs>(args.This())->getConstElement();
return scope.Close(toV8(e->getCircularError()));
}
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].");
}
}
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);
}
}
}
}
Meters getSearchRadius(const ConstElementPtr& e)
{
if (_getSearchRadius.IsEmpty())
{
return e->getCircularError() * _candidateDistanceSigma;
}
else
{
Handle<Value> jsArgs[1];
int argc = 0;
jsArgs[argc++] = ElementJs::New(e);
Handle<Value> f = _getSearchRadius->Call(getPlugin(), argc, jsArgs);
return toCpp<Meters>(f);
}
}
// 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;
}