void OgrWriter::writeElement(ElementPtr &element, bool debug)
{
//Unfortunately, this check also has to happen in addition to checking hasMoreElements. See
//explanation in ServicesDbReader::readNextElement.
if (element.get())
{
Tags sourceTags = element->getTags();
Tags destTags;
for (Tags::const_iterator it = element->getTags().begin();
it != element->getTags().end(); ++it)
{
if (sourceTags[it.key()] != "")
{
destTags.appendValue(it.key(), it.value());
}
}
// Now that all the empties are gone, update our element
element->setTags(destTags);
if ( debug == true )
{
LOG_DEBUG(element->toString());
}
PartialOsmMapWriter::writePartial(element);
}
}
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);
}
}
bool RemoveRef2Visitor::_hasRef2Tag(ElementPtr e) const
{
for (int i = 0; i < _ref2Keys.size(); i++)
{
if (e->getTags().contains(_ref2Keys[i]))
{
QString v = e->getTags().get(_ref2Keys[i]);
if (!v.isEmpty() && v != "none")
{
return true;
}
}
}
return false;
}
void OgrWriter::writeElement(ElementInputStream& inputStream, bool debug)
{
// Make sure incoming element is in WGS84
assert( inputStream.getProjection()->IsSame(&_wgs84) == true );
ElementPtr nextElement = inputStream.readNextElement();
// TERRY TESTING COULD BE CATASTROPHIC
Tags sourceTags = nextElement->getTags();
Tags destTags;
for (Tags::const_iterator it = nextElement->getTags().begin();
it != nextElement->getTags().end(); ++it)
{
if (sourceTags[it.key()] != "")
{
destTags.appendValue(it.key(), it.value());
}
}
// Now that all the empties are gone, update our element
nextElement->setTags(destTags);
if ( debug == true )
{
LOG_DEBUG(nextElement->toString());
}
PartialOsmMapWriter::writePartial(nextElement);
/*
if ( nextElement->getElementType().getEnum() == ElementType::Node )
{
//LOG_DEBUG("\n" << nextElement->toString());
const long nodeID = nextElement->getId();
if ( (nodeID >= -265198) && (nodeID <= -265167) )
{
LOG_DEBUG("\n" << nextElement->toString());
PartialOsmMapWriter::writePartial(nextElement);
}
}
else if ((nextElement->getElementType().getEnum() == ElementType::Way) &&
(nextElement->getId() == -23189) )
{
LOG_DEBUG("Writing Little Mill Creek -23189");
LOG_DEBUG("\n" << nextElement->toString());
PartialOsmMapWriter::writePartial(nextElement);
}
*/
}
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 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);
}
}
}
}
void ImplicitTagRawRulesDeriver::deriveRawRules(const QStringList inputs,
const QStringList translationScripts,
const QString output)
{
_validateInputs(inputs, translationScripts, output);
LOG_INFO(
"Generating implicit tag rules raw file for inputs: " << inputs <<
", translation scripts: " << translationScripts << ". Writing to output: " << output << "...");
LOG_VARD(_sortParallelCount);
LOG_VARD(_skipFiltering);
LOG_VARD(_translateNamesToEnglish);
_init();
long eligibleFeatureCount = 0;
long totalFeatureCount = 0;
for (int i = 0; i < inputs.size(); i++)
{
boost::shared_ptr<ElementInputStream> inputStream =
_getInputStream(inputs.at(i), translationScripts.at(i));
while (inputStream->hasMoreElements())
{
ElementPtr element = inputStream->readNextElement();
LOG_VART(element);
totalFeatureCount++;
assert(_elementCriterion.get());
if (_skipFiltering || _elementCriterion->isSatisfied(element))
{
QStringList names = element->getTags().getNames();
assert(!names.isEmpty());
//old_name/former_name generally indicates that an element formerly went by the name, so
//not really useful here.
if (names.removeAll("old_name") > 0)
{
LOG_VART("Removed old name tag.");
}
if (names.removeAll("former_name") > 0)
{
LOG_VART("Removed former name tag.");
}
assert(!names.isEmpty());
if (_translateNamesToEnglish)
{
names = ImplicitTagUtils::translateNamesToEnglish(names, element->getTags(), _translator);
}
LOG_VART(names);
//get back only the tags that we'd be interested in applying to future elements implicitly
//based on name
const QStringList kvps = _elementCriterion->getEligibleKvps(element->getTags());
assert(!kvps.isEmpty());
if (kvps.isEmpty())
{
throw HootException("Kvps empty.");
}
//parse whole names and token groups
_parseNames(names, kvps);
eligibleFeatureCount++;
if (eligibleFeatureCount % _statusUpdateInterval == 0)
{
PROGRESS_INFO(
"Parsed " << StringUtils::formatLargeNumber(eligibleFeatureCount) <<
" eligible features / " << StringUtils::formatLargeNumber(totalFeatureCount) <<
" total features.");
}
}
}
_inputReader->finalizePartial();
}
_countFile->close();
LOG_INFO(
"Parsed " << StringUtils::formatLargeNumber(eligibleFeatureCount) <<
" eligible features from " << StringUtils::formatLargeNumber(totalFeatureCount) <<
" total features.");
LOG_INFO(
"Wrote " << StringUtils::formatLargeNumber(_countFileLineCtr) << " lines to count file.");
_sortByTagOccurrence(); //sort in descending count order
_removeDuplicatedKeyTypes();
bool tieCountsNeededResolved = false;
if (_duplicatedWordTagKeyCountsToValues.size() > 0)
{
_resolveCountTies();
tieCountsNeededResolved = true;
}
LOG_INFO(
"Extracted " << StringUtils::formatLargeNumber(_wordKeysToCountsValues.size()) <<
" word/tag associations.");
LOG_INFO("Clearing word/tag associations...");
_wordKeysToCountsValues.clear();
if (tieCountsNeededResolved)
{
_sortByWord(_tieResolvedCountFile);
}
else
{
_sortByWord(_dedupedCountFile);
}
}
bool ToEnglishTranslationVisitor::_translate(const ElementPtr& e,
const QString toTranslateTagKey)
{
bool translationMade = false;
_toTranslateTagKey = toTranslateTagKey;
_toTranslateVal = e->getTags().get(toTranslateTagKey).trimmed();
LOG_VART(_toTranslateVal);
_element = e;
_translatedText = _translatorClient->translate(_toTranslateVal).trimmed();
LOG_VART(_translatedText);
const int strComparison = _translatedText.compare(_toTranslateVal, Qt::CaseInsensitive);
LOG_VART(strComparison);
//If the translator merely returned the same string we passed in as the translated text, then
//no point in using it.
if (!_translatedText.trimmed().isEmpty() && strComparison != 0)
{
LOG_TRACE("Translated: " << _toTranslateVal << " to: " << _translatedText);
_element->getTags()
.appendValue("hoot:translated:" + _toTranslateTagKey + ":en", _translatedText);
QString sourceLang;
LOG_VART(_translatorClient->getSourceLanguages().size());
if (_translatorClient->getDetectedLanguage().trimmed().isEmpty() &&
_translatorClient->getSourceLanguages().at(0) != "detect")
{
assert(_translatorClient->getSourceLanguages().size() == 1);
sourceLang = _translatorClient->getSourceLanguages().at(0);
}
else
{
sourceLang = _translatorClient->getDetectedLanguage();
}
_element->getTags()
.appendValue("hoot:translated:" + _toTranslateTagKey + ":en:source:language", sourceLang);
_numTagTranslationsMade++;
if (_numTagTranslationsMade % _taskStatusUpdateInterval == 0)
{
PROGRESS_DEBUG("Translated " << _numTagTranslationsMade << " tags.");
}
_currentElementHasSuccessfulTagTranslation = true;
translationMade = true;
}
else
{
if (!_translatedText.trimmed().isEmpty())
{
LOG_TRACE(
"Translator returned translation with same value as text passed in. Discarding " <<
"translation; text: " << _translatedText);
}
else
{
LOG_TRACE("Unable to translate text: " << _toTranslateVal);
}
}
_numProcessedTags++;
if (_numProcessedTags % _taskStatusUpdateInterval == 0)
{
PROGRESS_DEBUG("Processed " << _numProcessedTags << " tags.");
}
return translationMade;
}
