void DrawingItemGroup::updatePoints()
{
	QRectF rect = boundingRect();
	DrawingItemPoint* itemPoint;
	DrawingItemPoint* leftPoint;
	DrawingItemPoint* rightPoint;

	itemPoint = cornerPoint(Qt::TopLeftCorner);
	if (itemPoint) itemPoint->setPos(rect.topLeft());
	itemPoint = cornerPoint(Qt::BottomRightCorner);
	if (itemPoint) itemPoint->setPos(rect.bottomRight());
	itemPoint = cornerPoint(Qt::TopRightCorner);
	if (itemPoint) itemPoint->setPos(rect.topRight());
	itemPoint = cornerPoint(Qt::BottomLeftCorner);
	if (itemPoint) itemPoint->setPos(rect.bottomLeft());

	itemPoint = point(4); leftPoint = point(0); rightPoint = point(2);
	if (itemPoint && leftPoint && rightPoint) itemPoint->setPos((leftPoint->pos() + rightPoint->pos()) / 2);

	itemPoint = point(5); leftPoint = point(1);
	if (itemPoint && leftPoint && rightPoint) itemPoint->setPos((leftPoint->pos() + rightPoint->pos()) / 2);

	itemPoint = point(6); rightPoint = point(3);
	if (itemPoint && leftPoint && rightPoint) itemPoint->setPos((leftPoint->pos() + rightPoint->pos()) / 2);

	itemPoint = point(7); leftPoint = point(0);
	if (itemPoint && leftPoint && rightPoint) itemPoint->setPos((leftPoint->pos() + rightPoint->pos()) / 2);
}
QPainterPath DArrowRectangle::getBottomCornerPath()
{
    qreal delta = shadowBlurRadius() + shadowDistance();

    QRect rect = this->rect().marginsRemoved(QMargins(delta, delta, delta, delta));

    QPoint cornerPoint(rect.x() + (m_arrowX > 0 ? m_arrowX : rect.width() / 2), rect.y()  + rect.height());
    QPoint topLeft(rect.x(), rect.y());
    QPoint topRight(rect.x() + rect.width(), rect.y());
    QPoint bottomRight(rect.x() + rect.width(), rect.y() + rect.height() - m_arrowHeight);
    QPoint bottomLeft(rect.x(), rect.y() + rect.height() - m_arrowHeight);
    int radius = this->m_radius > (rect.height() / 2 - m_arrowHeight) ? rect.height() / 2 -m_arrowHeight : this->m_radius;

    QPainterPath border;
    border.moveTo(topLeft.x() + radius, topLeft.y());
    border.lineTo(topRight.x() - radius, topRight.y());
    border.arcTo(topRight.x() - 2 * radius, topRight.y(), 2 * radius, 2 * radius, 90, -90);
    border.lineTo(bottomRight.x(), bottomRight.y() - radius);
    border.arcTo(bottomRight.x() - 2 * radius, bottomRight.y() - 2 * radius, 2 * radius, 2 * radius, 0, -90);
    border.lineTo(cornerPoint.x() + m_arrowWidth / 2, cornerPoint.y() - m_arrowHeight);
    border.lineTo(cornerPoint);
    border.lineTo(cornerPoint.x() - m_arrowWidth / 2, cornerPoint.y() - m_arrowHeight);
    border.lineTo(bottomLeft.x() + radius, bottomLeft.y());
    border.arcTo(bottomLeft.x(), bottomLeft.y() - 2 * radius, 2 * radius, 2 * radius, -90, -90);
    border.lineTo(topLeft.x(), topLeft.y() + radius);
    border.arcTo(topLeft.x(), topLeft.y(), 2 * radius, 2 * radius, 180, -90);

    return border;
}
Exemple #3
0
//鼠标移动,箭头实时显示
void FlowWidget::moveArrowShow(int startNum, int dx, int dy)
{
	if (startNum != -1)
	{
		//设置开始点为选择模块的中心点
		QPoint startPoint(flowIcon[startNum]->pos().x() + flowIcon_sizeHalf, flowIcon[startNum]->pos().y() + flowIcon_sizeHalf);
		QPoint cornerPoint(startPoint.x() + dx, startPoint.y());//直角拐弯点
		QPoint endPoint(startPoint.x() + dx, startPoint.y()+dy);
		//设置横线
		lineShow[0].setP1(startPoint);
		lineShow[0].setP2(cornerPoint);
		//竖线
		lineShow[1].setP1(cornerPoint);
		lineShow[1].setP2(endPoint);
		//箭头
		lines[numLine][2].setP1(endPoint);
		lines[numLine][2].setP2(QPoint(endPoint.x() - 5, endPoint.y() - 5));
		lines[numLine][3].setP1(endPoint);
		lines[numLine][3].setP2(QPoint(endPoint.x() + 5, endPoint.y() - 5));
	}
}
double PellegMooreKMeansRules<MetricType, TreeType>::Score(
    const size_t /* queryIndex */,
    TreeType& referenceNode)
{
  // Obtain the parent's blacklist.  If this is the root node, we'll start with
  // an empty blacklist.  This means that after each iteration, we don't need to
  // reset any statistics.
  if (referenceNode.Parent() == NULL ||
      referenceNode.Parent()->Stat().Blacklist().n_elem == 0)
    referenceNode.Stat().Blacklist().zeros(centroids.n_cols);
  else
    referenceNode.Stat().Blacklist() =
        referenceNode.Parent()->Stat().Blacklist();

  // The query index is a fake index that we won't use, and the reference node
  // holds all of the points in the dataset.  Our goal is to determine whether
  // or not this node is dominated by a single cluster.
  const size_t whitelisted = centroids.n_cols -
      arma::accu(referenceNode.Stat().Blacklist());

  distanceCalculations += whitelisted;

  // Which cluster has minimum distance to the node?
  size_t closestCluster = centroids.n_cols;
  double minMinDistance = DBL_MAX;
  for (size_t i = 0; i < centroids.n_cols; ++i)
  {
    if (referenceNode.Stat().Blacklist()[i] == 0)
    {
      const double minDistance = referenceNode.MinDistance(centroids.col(i));
      if (minDistance < minMinDistance)
      {
        minMinDistance = minDistance;
        closestCluster = i;
      }
    }
  }

  // Now, for every other whitelisted cluster, determine if the closest cluster
  // owns the point.  This calculation is specific to hyperrectangle trees (but,
  // this implementation is specific to kd-trees, so that's okay).  For
  // circular-bound trees, the condition should be simpler and can probably be
  // expressed as a comparison between minimum and maximum distances.
  size_t newBlacklisted = 0;
  for (size_t c = 0; c < centroids.n_cols; ++c)
  {
    if (referenceNode.Stat().Blacklist()[c] == 1 || c == closestCluster)
      continue;

    // This algorithm comes from the proof of Lemma 4 in the extended version
    // of the Pelleg-Moore paper (the CMU tech report, that is).  It has been
    // adapted for speed.
    arma::vec cornerPoint(centroids.n_rows);
    for (size_t d = 0; d < referenceNode.Bound().Dim(); ++d)
    {
      if (centroids(d, c) > centroids(d, closestCluster))
        cornerPoint(d) = referenceNode.Bound()[d].Hi();
      else
        cornerPoint(d) = referenceNode.Bound()[d].Lo();
    }

    const double closestDist = metric.Evaluate(cornerPoint,
        centroids.col(closestCluster));
    const double otherDist = metric.Evaluate(cornerPoint, centroids.col(c));

    distanceCalculations += 3; // One for cornerPoint, then two distances.

    if (closestDist < otherDist)
    {
      // The closest cluster dominates the node with respect to the cluster c.
      // So we can blacklist c.
      referenceNode.Stat().Blacklist()[c] = 1;
      ++newBlacklisted;
    }
  }

  if (whitelisted - newBlacklisted == 1)
  {
    // This node is dominated by the closest cluster.
    counts[closestCluster] += referenceNode.NumDescendants();
    newCentroids.col(closestCluster) += referenceNode.NumDescendants() *
        referenceNode.Stat().Centroid();

    return DBL_MAX;
  }

  // Perform the base case here.
  for (size_t i = 0; i < referenceNode.NumPoints(); ++i)
  {
    size_t bestCluster = centroids.n_cols;
    double bestDistance = DBL_MAX;
    for (size_t c = 0; c < centroids.n_cols; ++c)
    {
      if (referenceNode.Stat().Blacklist()[c] == 1)
        continue;

      ++distanceCalculations;

      // The reference index is the index of the data point.
      const double distance = metric.Evaluate(centroids.col(c),
          dataset.col(referenceNode.Point(i)));

      if (distance < bestDistance)
      {
        bestDistance = distance;
        bestCluster = c;
      }
    }

    // Add to resulting centroid.
    newCentroids.col(bestCluster) += dataset.col(referenceNode.Point(i));
    ++counts(bestCluster);
  }

  // Otherwise, we're not sure, so we can't prune.  Recursion order doesn't make
  // a difference, so we'll just return a score of 0.
  return 0.0;
}