C++ Match::getClassification方法代码示例

void RemoveDuplicateReviewsOp::apply(shared_ptr<OsmMap>& map)
{
    _map = map;

    // go through all the relations to get duplicate reviews
    const RelationMap& relations = map->getRelationMap();
    QMap< set<ElementId>, QList<ReviewMarker::ReviewUid> > membersToReview;
    for (RelationMap::const_iterator it = relations.begin(); it != relations.end(); it++)
    {
        ElementId eid = ElementId::relation(it->first);
        if (ReviewMarker::isReviewUid(map, eid))
        {
            membersToReview[ReviewMarker::getReviewElements(map, eid)].append(eid);
        }
    }

    //loop through dupplicate reviews
    QMap< set<ElementId>, QList<ReviewMarker::ReviewUid> >::iterator it = membersToReview.begin();
    while (it != membersToReview.end())
    {
        set<ElementId> eids = it.key();

        //remove duplicate reviews
        QList<ReviewMarker::ReviewUid> duplicateReviews = it.value();

        //Only remove reviews and process if there is more than one review
        // See discussion here: https://github.com/ngageoint/hootenanny/issues/81#issuecomment-162980656
        if (eids.size() == 2 && duplicateReviews.size() > 1)
        {
            for (int i = 0; i < duplicateReviews.size(); i++)
            {
                ReviewMarker::removeElement(map, duplicateReviews[i]);
            }

            ElementId beid = *eids.begin();
            ElementId eeid = *eids.rbegin();

            OsmMapPtr copy(new OsmMap());
            CopySubsetOp(map, beid, eeid).apply(copy);
            copy->getElement(beid)->setStatus(Status::Unknown1);
            copy->getElement(eeid)->setStatus(Status::Unknown2);

            Match* match = MatchFactory::getInstance().createMatch(copy, beid, eeid);
            if (match && match->getType() != MatchType::Miss)
            {
                QString explain = match->explain();
                if (match->getType() == MatchType::Match)
                {
                    if (explain.isEmpty())
                    {
                        explain = "Multiple overlapping high confidence reviews";
                    }
                    else
                    {
                        explain = "Multiple overlapping high confidence reviews: " + explain;
                    }
                }
                ReviewMarker::mark(map, map->getElement(beid), map->getElement(eeid),
                                   explain, match->getMatchName(), match->getClassification().getReviewP());
            }
        }
        ++it;
    }
}

bool ScriptMatch::isConflicting(const Match& other, const ConstOsmMapPtr& map) const
{
  if (_neverCausesConflict)
  {
    return false;
  }

  bool conflicting = true;

  const ScriptMatch* hm = dynamic_cast<const ScriptMatch*>(&other);
  if (hm == 0)
  {
    return true;
  }
  if (hm == this)
  {
    return false;
  }

  // See ticket #5272
  if (getClassification().getReviewP() == 1.0 || other.getClassification().getReviewP() == 1.0)
  {
    return true;
  }

  ElementId sharedEid;
  if (_eid1 == hm->_eid1 || _eid1 == hm->_eid2)
  {
    sharedEid = _eid1;
  }

  if (_eid2 == hm->_eid1 || _eid2 == hm->_eid2)
  {
    // both eids should never be the same.
    assert(sharedEid.isNull());
    sharedEid = _eid2;
  }

  // if the matches don't share at least one eid then it isn't a conflict.
  if (sharedEid.isNull())
  {
    return false;
  }

  // assign o1 and o2 to the non-shared eids
  ElementId o1 = _eid1 == sharedEid ? _eid2 : _eid1;
  ElementId o2 = hm->_eid1 == sharedEid ? hm->_eid2 : hm->_eid1;

  bool foundCache = false;
  bool cacheConflict = false;
  QHash<ConflictKey, bool>::const_iterator cit1 = _conflicts.find(hm->_getConflictKey());
  if (cit1 != _conflicts.end())
  {
    foundCache = true;
    cacheConflict = cit1.value();
  }
  QHash<ConflictKey, bool>::const_iterator cit2 = hm->_conflicts.find(_getConflictKey());
  if (cit2 != hm->_conflicts.end())
  {
    foundCache = true;
    cacheConflict = cit2.value();
  }

  if (foundCache)
  {
    conflicting = cacheConflict;
  }
  else
  {
    try
    {
      // we need to check for a conflict in two directions. Is it conflicting if we merge the shared
      // EID with this class first, then is it a conflict if we merge with the other EID first.
      if (_isOrderedConflicting(map, sharedEid, o1, o2) ||
          hm->_isOrderedConflicting(map, sharedEid, o2, o1))
      {
        conflicting = true;
      }
      else
      {
        conflicting = false;
      }
    }
    catch (const NeedsReviewException& e)
    {
      conflicting = true;
    }
    _conflicts[hm->_getConflictKey()] = conflicting;
  }

  return conflicting;
}