Method MergeToolUses

Modules/Multilabel/src/mitkLabel.cpp:564–603

}

void mitk::Label::MergeToolUses(const Label* other)
{
  if (nullptr == other)
    mitkThrow() << "Invalid call of Label::MergeToolUses. Passed label is null.";

  const auto otherType = other->GetAlgorithmType();
  if (otherType == AlgorithmType::Undefined)
    return; // the source declared no origin: nothing meaningful to propagate

  // Mix the algorithm type (same rule as AddToolUse), so even a source that carries a type but no
  // named tool (e.g. a vendor MANUAL label) still influences the merged result.
  const auto currentType = this->GetAlgorithmType();
  if (currentType == AlgorithmType::Undefined)
    this->SetAlgorithmType(otherType);
  else if (currentType != otherType)
    this->SetAlgorithmType(AlgorithmType::SEMIAUTOMATIC);

  if (!other->HasAlgorithmName())
    return;

  const std::string otherName = other->GetAlgorithmName();
  const std::string internalPrefix = DEFAULT_ALGORITHM_NAME + PREFIX_SEPARATOR;
  const std::string toolChain = otherName.starts_with(internalPrefix)
                                  ? otherName.substr(internalPrefix.size())
                                  : otherName;
  if (toolChain.empty() || toolChain == DEFAULT_ALGORITHM_NAME)
    return; // bare prefix only: the type mix above is the whole story

  // Replay each recorded tool name so the target's chain reflects the merged origin. AddToolUse
  // de-duplicates against names already present and re-affirms the type mix harmlessly.
  std::string::size_type start = 0;
  while (start != std::string::npos)
  {
    const auto sep = toolChain.find(TOOL_SEPARATOR, start);
    const auto token = toolChain.substr(start, sep == std::string::npos ? std::string::npos : sep - start);
    if (!token.empty())
      this->AddToolUse(otherType, token);
    start = sep == std::string::npos ? std::string::npos : sep + TOOL_SEPARATOR.size();
  }
}


void mitk::Label::Update(const Label* templateLabel, bool updateLabelValue)