Example #1
0
std::string ZDvidUrl::getSplitUrl(
    const std::string &dataName, uint64_t originalLabel,
    const std::string &command) const
{
  std::ostringstream stream;
  if (command.empty()) {
    stream << getDataUrl(dataName) << "/" << originalLabel;
  } else {
    stream << getDataUrl(dataName) << "/" << command << "/" << originalLabel;
  }

  return stream.str();
}
Example #2
0
std::string ZDvidUrl::getKeyUrl(const std::string &name, const std::string &key) const
{
  //new dvid api
//  return GetKeyCommandUrl(getDataUrl(name)) + "/" + key;

  return GetFullUrl(GetKeyCommandUrl(getDataUrl(name)), key);
}
Example #3
0
std::string ZDvidUrl::getTarSupervoxelsUrl()
{
  return getDataUrl(
        ZDvidData::GetName(ZDvidData::ROLE_TAR_SUPERVOXELS,
                           ZDvidData::ROLE_BODY_LABEL,
                           m_dvidTarget.getBodyLabelName()));
}
Example #4
0
std::string ZDvidUrl::getSkeletonUrl(const std::string &bodyLabelName) const
{
  return getDataUrl(
        ZDvidData::GetName(ZDvidData::ROLE_SKELETON,
                           ZDvidData::ROLE_BODY_LABEL,
                           bodyLabelName));
}
Example #5
0
std::string ZDvidUrl::getMeshesTarsUrl()
{
  return getDataUrl(
        ZDvidData::GetName(ZDvidData::ROLE_MESHES_TARS,
                           ZDvidData::ROLE_BODY_LABEL,
                           m_dvidTarget.getBodyLabelName()));
}
Example #6
0
std::string ZDvidUrl::getBodySizeUrl(uint64_t bodyId) const
{
  if (m_dvidTarget.getSegmentationType() == ZDvidData::TYPE_LABELMAP) {
    return GetFullUrl(getDataUrl(m_dvidTarget.getSegmentationName()),
                      "size/" + std::to_string(bodyId));
  }

  return "";
}
Example #7
0
std::string ZDvidUrl::getLabels64Url(
    const std::string &name, int sx, int sy, int sz,
    int x0, int y0, int z0) const
{
  std::ostringstream stream;
  stream << "/raw/0_1_2/" << sx << "_" << sy << "_" << sz << "/"
         << x0 << "_" << y0 << "_" << z0;
  return getDataUrl(name) + stream.str();
}
Example #8
0
std::string ZDvidUrl::getSynapseLabelszBodyUrl(uint64_t bodyId) const
{
  std::string url = getDataUrl(m_dvidTarget.getSynapseLabelszName());

  if (!url.empty()) {
    url += "/count/" + ZString::num2str(bodyId);
  }

  return url;
}
Example #9
0
std::string ZDvidUrl::getSynapseLabelszUrl(int n) const
{
  std::string url = getDataUrl(m_dvidTarget.getSynapseLabelszName());

  if (!url.empty()) {
    url += "/top/" + ZString::num2str(n);
  }

  return url;
}
Example #10
0
std::string ZDvidUrl::getMergeOperationUrl(const std::string &userName) const
{
  std::string key = m_dvidTarget.getLabelBlockName();
  if (!userName.empty()) {
    key += "_" + userName;
  }

  return GetKeyCommandUrl(
        getDataUrl(ZDvidData::GetName(ZDvidData::ROLE_MERGE_OPERATION))) + "/" +
      key;
}
Example #11
0
std::string ZDvidUrl::getDataSyncUrl(
    const std::string &dataName, const std::string &queryString) const
{
  std::string url = GetFullUrl(getDataUrl(dataName), "sync");

  if (!queryString.empty()) {
   url = GetFullUrl(url, "?" + queryString);
  }

  return url;
}
Example #12
0
std::string ZDvidUrl::getSynapseLabelszThresholdUrl(int threshold) const {
    std::string name;

    std::string dataName = m_dvidTarget.getSynapseLabelszName();
    if (!dataName.empty()) {
      name = getDataUrl(dataName);
      name += "/threshold/";
      name += ZString::num2str(threshold);
    }

    return name;
}
Example #13
0
std::string ZDvidUrl::getMergeOperationUrl(const std::string &userName) const
{
  std::string key = m_dvidTarget.getSegmentationName();
  if (key.empty()) {
    return "";
  }

  if (!userName.empty()) {
    key += "_" + userName;
  }

  return GetFullUrl(GetKeyCommandUrl(
        getDataUrl(ZDvidData::GetName(ZDvidData::ROLE_MERGE_OPERATION))), key);
}
Example #14
0
std::string ZDvidUrl::getLabels64Url(
    const std::string &name, int sx, int sy, int sz,
    int x0, int y0, int z0) const
{
  if (name.empty()) {
    return "";
  }

  std::ostringstream stream;
  stream << "/raw/0_1_2/" << sx << "_" << sy << "_" << sz << "/"
         << x0 << "_" << y0 << "_" << z0;
//  return getDataUrl(name) + stream.str();
  return GetFullUrl(getDataUrl(name), stream.str());
}
Example #15
0
std::string ZDvidUrl::getKeyRangeUrl(
    const std::string &name,
    const std::string &key1, const std::string &key2) const
{
  return getDataUrl(name) + "/" + m_keyRangeCommand + "/" + key1 + "/" + key2;

  /*
  std::string url = getDataUrl(name) + "/" + key1;
  if (!key2.empty()) {
    url += "/" + key2;
  }

  return url;
  */
}
Example #16
0
std::string ZDvidUrl::getSparsevolSizeUrl(uint64_t bodyId) const
{
  ZString url;

  if (m_dvidTarget.hasSparsevolSizeApi()) {
    url = getDataUrl(m_dvidTarget.getBodyLabelName());
    if (!url.empty()) {
      url += "/" + ZDvidData::GetName(ZDvidData::ROLE_SPARSEVOL_SIZE);
      url += "/";
      url.appendNumber(bodyId);
    }
  }

  return url;
}
Example #17
0
std::string ZDvidUrl::getCoarseSplitUrl(
    const std::string &dataName, uint64_t originalLabel) const
{
  if (!m_coarseSplitCommand.empty()) {
    return getSplitUrl(dataName, originalLabel, m_coarseSplitCommand);
  }

  return "";

#if 0
  std::ostringstream stream;
  if (m_coarseSplitCommand.empty()) {
    stream << getDataUrl(dataName) << "/" << m_coarseSplitCommand << "/"
           << originalLabel;
  }

  return stream.str();
#endif
}
Example #18
0
std::string ZDvidUrl::getMeshUrl(uint64_t bodyId, int zoom)
{
  return GetFullUrl(
        GetKeyCommandUrl(getDataUrl(m_dvidTarget.getMeshName(zoom))),
        GetMeshKey(bodyId));
#if 0
  std::string url;

  ZString dataUrl = getMeshUrl();
  if (!dataUrl.empty()) {
    if (zoom > 0) {
      dataUrl += "_";
      dataUrl.appendNumber(zoom);
    }
    url = GetFullUrl(GetKeyCommandUrl(dataUrl), GetBodyKey(bodyId));
  }

  return url;
#endif
}
Example #19
0
std::string ZDvidUrl::getGrayscaleUrl() const
{
  return getDataUrl(m_dvidTarget.getGrayScaleName());
//  return getDataUrl(ZDvidData::getName(ZDvidData::ROLE_GRAY_SCALE));
}
Example #20
0
std::string ZDvidUrl::getThumbnailUrl(const std::string &bodyLabelName) const
{
  return getDataUrl(
        ZDvidData::GetName(ZDvidData::ROLE_THUMBNAIL,
                           ZDvidData::ROLE_BODY_LABEL, bodyLabelName));
}
Example #21
0
std::string ZDvidUrl::getSp2bodyUrl() const
{
  return getDataUrl(ZDvidData::GetName(ZDvidData::ROLE_SP2BODY));
}
Example #22
0
std::string ZDvidUrl::getLabelszSyncUrl(const std::string &dataName) const
{
  return GetFullUrl(getDataUrl(dataName), "sync");
}
Example #23
0
std::string ZDvidUrl::getCoarseSparsevolUrl(const std::string &dataName) const
{
  return GetFullUrl(getDataUrl(dataName), m_coarseSparsevolCommand);
//      ZDvidData::GetName(ZDvidData::ROLE_SPARSEVOL_COARSE);
}
Example #24
0
std::string ZDvidUrl::getSupervoxelUrl(const std::string &dataName) const
{
  return GetFullUrl(getDataUrl(dataName), m_supervoxelCommand);
}
Example #25
0
std::string ZDvidUrl::getSparsevolUrl(const std::string &dataName) const
{
  return GetFullUrl(getDataUrl(dataName), m_sparsevolCommand);
}
Example #26
0
std::string ZDvidUrl::getLabelMappingUrl() const
{
  return GetFullUrl(
        getDataUrl(m_dvidTarget.getSegmentationName()), m_labelMappingCommand);
}
Example #27
0
std::string ZDvidUrl::getSynapseUrl() const
{
  return getDataUrl(m_dvidTarget.getSynapseName());
}
Example #28
0
std::string ZDvidUrl::getConfigUrl() const
{
  return getDataUrl("neutu_config");
}
Example #29
0
std::string ZDvidUrl::getAnnotationUrl(const std::string &dataName) const
{
  return getDataUrl(dataName);
}
Example #30
0
std::string ZDvidUrl::getMeshUrl()
{
  return getDataUrl(m_dvidTarget.getMeshName());
}