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; }