C++ ZIntPoint::getZ方法代码示例

ZIntPoint operator / (const ZIntPoint &pt1, const ZIntPoint &pt2)
{
  if (pt2.getX() == 0 || pt2.getY() == 0 || pt2.getZ() == 0) {
    return ZIntPoint(0, 0, 0);
  }

  return ZIntPoint(pt1.getX() / pt2.getX(), pt1.getY() / pt2.getY(),
                   pt1.getZ() / pt2.getZ());
}

std::string ZDvidUrl::getSynapseMoveUrl(
    const ZIntPoint &from, const ZIntPoint &to) const
{
  std::ostringstream stream;

  stream << m_annotationMoveCommand << "/"
         << from.getX() << "_" << from.getY() << "_" << from.getZ() << "/"
         << to.getX() << "_" << to.getY() << "_" << to.getZ();



  return GetFullUrl(getSynapseUrl(), stream.str());
}

/**********************ZDvidBlockGrid::Location**********************/
ZBlockGrid::Location ZBlockGrid::getLocation(int x, int y, int z) const
{
  ZBlockGrid::Location location;

  x -= m_minPoint.getX();
  y -= m_minPoint.getY();
  z -= m_minPoint.getZ();

  ZIntPoint blockIndex;
  if (x >= 0) {
    blockIndex.setX(x / m_blockSize.getX());
  } else {
    blockIndex.setX(x / m_blockSize.getX() - 1);
  }

  if (y >= 0) {
    blockIndex.setY(y / m_blockSize.getY());
  } else {
    blockIndex.setY(y / m_blockSize.getY() - 1);
  }

  if (z >= 0) {
    blockIndex.setZ(z / m_blockSize.getZ());
  } else {
    blockIndex.setZ(z / m_blockSize.getZ() - 1);
  }

  location.setBlockIndex(blockIndex);

  location.setLocalPosition(x - blockIndex.getX() * m_blockSize.getX(),
                            y - blockIndex.getY() * m_blockSize.getY(),
                            z - blockIndex.getZ() * m_blockSize.getZ());

  return location;
}

int ZBlockGrid::getHashIndex(const ZIntPoint &blockIndex) const
{
  int index = -1;

  if (IS_IN_OPEN_RANGE(blockIndex.getX(), -1, m_size.getX()) &&
      IS_IN_OPEN_RANGE(blockIndex.getY(), -1, m_size.getY()) &&
      IS_IN_OPEN_RANGE(blockIndex.getZ(), -1, m_size.getZ())) {
    //ZIntPoint adjustedBlockIndex = blockIndex - m_grid.getFirstCorner();
    int area = m_size.getX() * m_size.getY();
    int width = m_size.getX();
    index = area * blockIndex.getZ() + width * blockIndex.getY() +
        blockIndex.getX();
  }

  return index;
}

ZObject3dScan ZDvidInfo::getBlockIndex(const ZObject3dScan &obj) const
{
  ZIntPoint gridSize = m_endBlockIndex - m_startBlockIndex + 1;
  size_t area = ((size_t) gridSize.getX()) * gridSize.getY();
  size_t blockNumber = area * gridSize.getZ();
  std::vector<bool> isAdded(blockNumber, false);

  //std::set<ZIntPoint> blockSet;
  //ZIntPointArray blockArray;
  ZObject3dScan blockObj;

  for (size_t i = 0; i < obj.getStripeNumber(); ++i) {
#ifdef _DEBUG_2
    if (i % 10000 == 0) {
      std::cout << i << "/" << obj.getStripeNumber() << std::endl;
    }
#endif
    const ZObject3dStripe &stripe = obj.getStripe(i);
    int y = stripe.getY();
    int z = stripe.getZ();
    if (y > 0 && z > 0 && y < m_startCoordinates[1] + m_stackSize[1] &&
        z < m_startCoordinates[2] + m_stackSize[2]) {
      for (int j = 0; j < stripe.getSegmentNumber(); ++j) {
        int x0 = stripe.getSegmentStart(j);
        int x1 = stripe.getSegmentEnd(j);
        if (x0 < 0) {
          x0 = 0;
        } else if (x0 >= m_startCoordinates[0] + m_stackSize[0]) {
          x0 = m_startCoordinates[0] + m_stackSize[0] - 1;
        }

        if (x1 < 0) {
          x1 = 0;
        } else if (x1 >= m_startCoordinates[0] + m_stackSize[0]) {
          x1 = m_startCoordinates[0] + m_stackSize[0] - 1;
        }

        ZIntPoint block1 = getBlockIndex(x0, y, z);
        size_t blockIndex1 = area * block1.getZ() +
            gridSize.getY() * block1.getY() + block1.getX();
        ZIntPoint block2 = getBlockIndex(x1, y, z);
        size_t blockIndex2 = area * block2.getZ() +
            gridSize.getY() * block2.getY() + block2.getX();

        if (!isAdded[blockIndex1] || !isAdded[blockIndex2]) {
          blockObj.addSegment(
                block1.getZ(), block1.getY(), block1.getX(), block2.getX(), false);
          isAdded[blockIndex1] = true;
          isAdded[blockIndex2] = true;
        }
      }
    }
  }

  //blockArray.append(blockSet.begin(), blockSet.end());
  blockObj.canonize();

  return blockObj;
}

bool ZIntPoint::operator < (const ZIntPoint &pt) const
{
  if (getZ() < pt.getZ()) {
    return true;
  } else if (getZ() > pt.getZ()) {
    return false;
  } else {
    if (getY() < pt.getY()) {
      return true;
    } else if (getY() > pt.getY()) {
      return false;
    } else {
      if (getX() < pt.getX()) {
        return true;
      }
    }
  }

  return false;
}

ZIntPoint ZBlockGrid::getBlockPosition(const ZIntPoint &blockIndex) const
{
  int x = blockIndex.getX() * m_blockSize.getX();
  int y = blockIndex.getY() * m_blockSize.getY();
  int z = blockIndex.getZ() * m_blockSize.getZ();

  x += m_minPoint.getX();
  y += m_minPoint.getY();
  z += m_minPoint.getZ();

  return ZIntPoint(x, y, z);
}

Geo3d_Scalar_Field* ZNeuronTracer::extractLineSeed(
    const Stack *mask, const Stack *dist, int minObjSize)
{
  Object_3d_List *objList = Stack_Find_Object_N(
        const_cast<Stack*>(mask), NULL, 1, minObjSize, 26);
  ZObject3dArray objArray;
  objArray.append(objList);

  Geo3d_Scalar_Field *field = Make_Geo3d_Scalar_Field(objArray.size());
  for (size_t i = 0; i < objArray.size(); ++i) {
    ZObject3d *obj = objArray[i];
    ZIntPoint pt = obj->getCentralVoxel();
    field->points[i][0] = pt.getX();
    field->points[i][1] = pt.getY();
    field->points[i][2] = pt.getZ();
    field->values[i] = sqrt(
          C_Stack::value(dist, pt.getX(), pt.getY(), pt.getZ()));
  }

  return field;
}

ZSwcTree* ZSwcGenerator::createSwc(const ZIntCuboidFace &face, double radius)
{
  if (!face.isValid()) {
    return NULL;
  }

  ZPointArray ptArray;
  for (int i = 0; i < 4; ++i) {
    ZIntPoint pt = face.getCornerCoordinates(i);
    ptArray.append(ZPoint(pt.getX(), pt.getY(), pt.getZ()));
  }
  ptArray.append(ptArray[0]);

  return createSwc(ptArray, radius, true);
}

std::string ZDvidUrl::getSynapseUrl(const ZIntPoint &pos) const
{
  return getSynapseUrl(pos.getX(), pos.getY(), pos.getZ());
}

std::string ZDvidUrl::getBookmarkUrl(
    const ZIntPoint &pt, int width, int height, int depth) const
{
  return getBookmarkUrl(pt.getX(), pt.getY(), pt.getZ(), width, height, depth);
}

std::string ZDvidUrl::getBookmarkKeyUrl(const ZIntPoint &pt) const
{
  return getBookmarkKeyUrl(pt.getX(), pt.getY(), pt.getZ());
}

void ZCircle::set(const ZIntPoint &center, double r)
{
  set(center.getX(), center.getY(), center.getZ(), r);
}

void ZBlockGrid::setBlockSize(const ZIntPoint &s)
{
  setBlockSize(s.getX(), s.getY(), s.getZ());
}

bool ZIntPoint::operator ==(const ZIntPoint &pt) const
{
  return getX() == pt.getX() && getY() == pt.getY() && getZ() == pt.getZ();
}