C++ Point2d::set方法代码示例

float mglnrel::ptToBeeline2(
    const Point2d& a, const Point2d& b, const Point2d& pt, Point2d& ptPerp)
{
    // 两点重合
    if (a == b)
    {
        ptPerp = a;
        return a.distanceTo(pt);
    }
    // 竖直线
    else if (mgEquals(a.x, b.x))
    {
        ptPerp.set(a.x, pt.y);
        return fabsf(a.x - pt.x);
    }
    // 水平线
    else if (mgEquals(a.y, b.y))
    {
        ptPerp.set(pt.x, a.y);
        return fabsf(a.y - pt.y);
    }
    else
    {
        float t1 = ( b.y - a.y ) / ( b.x - a.x );
        float t2 = -1.f / t1;
        ptPerp.x = ( pt.y - a.y + a.x * t1 - pt.x * t2 ) / ( t1 - t2 );
        ptPerp.y = a.y + (ptPerp.x - a.x) * t1;
        return pt.distanceTo(ptPerp);
    }
}

// http://blog.csdn.net/cyg0810/article/details/7765894
int mgcurv::crossTwoCircles(Point2d& pt1, Point2d& pt2,
                            const Point2d& c1, float r1, const Point2d& c2, float r2)
{
    point_t p1, p2;
    point_t ca(c1.x, c1.y);
    point_t cb(c2.x, c2.y);
    int n = _crossTwoCircles(p1, p2, ca, r1, cb, r2);
    
    pt1.set((float)p1.x, (float)p1.y);
    pt2.set((float)p2.x, (float)p2.y);
    
    return n;
}

 virtual bool load(MgStorage* s) {
     pt.set(s->readFloat("x", pt.x), s->readFloat("y", pt.y));
     vec.set(s->readFloat("w", vec.x), s->readFloat("h", vec.y));
     stroke = s->readBool("stroke", stroke);
     fill = s->readBool("fill", fill);
     return true;
 }

void Game::SpectatorsCheers(){
	Point2d corner;
	// The cheering will last for 2 seconds
	if (clock() - cheer_start < 2000 && cheer_start != 0){
		frames_to_cheer++;
		if (frames_to_cheer == FRAMES_TO_CHEER_LIMIT){
			// The changes of colors for the spectators will 
			// happen once on FRAMES_TO_CHEER_LIMIT frames, 
			// which in our case is 10
			(m_last_scored == 0)?corner.set(-21.0f, 16.5f):corner.set(-21.0f, -1.0f);
			RemoveSpectators(m_last_scored);
			DrawSpectators(corner, m_last_scored);
			frames_to_cheer = 0;
		}
	}
}

void Game::DrawSpectators(Point2d corner, int team){
	const int columns = 5; 
	int rows = 14;
	Circle spectator(10, SPECTATOR_CIRCLE_RAY);
	float randr, randg;
	for(int i=0; i < columns; ++i){
		corner.set(corner.x + SPECTATOR_CIRCLE_RAY*2 + 0.1f,
					corner.y - SPECTATOR_CIRCLE_RAY*2 + 0.43f);
		for(int j=0; j < rows; ++j){
			if (team == 0){
				randr = (float)rand()/(3*RAND_MAX);
				randg = (float)rand()/RAND_MAX;
				spectator.SetColor(RGBcolor(randr, randg, 1.0f));
			}
			else if (team == 1){
				randg = (float)rand()/RAND_MAX; 
				spectator.SetColor(RGBcolor(1.0f, randg, 0.09f));
			}
			spectator.DrawCircle(m_system, Point2d(corner.x, 
					corner.y - (SPECTATOR_CIRCLE_RAY*2 + 0.1f)*j));
			if (team == 0){
				spectators1.push_back(spectator.GetObject());
			}
			else {
				spectators2.push_back(spectator.GetObject());
			}
		}
		rows--;
	}
}

int mgcurv::crossLineCircle(Point2d& pt1, Point2d& pt2, const Point2d& a,
                            const Point2d& b, const Point2d& c, float r)
{
    if (a == b) {
        return 0;
    }
    
    point_t p1, p2;
    point_t a1(a.x - c.x, a.y - c.y);
    point_t b1(b.x - c.x, b.y - c.y);
    int n = _crossLineCircle(p1, p2, a1, b1, r);
    
    pt1.set((float)p1.x + c.x, (float)p1.y + c.y);
    pt2.set((float)p2.x + c.x, (float)p2.y + c.y);
    
    return n;
}

/**
 * calculate if this line intersects with the provided Line l
 * Point2d * intersection output of the intersection point
 */
bool Line::intersect( const Line* l, Point2d & intersection ) {
  const Line* p, *q;
  /* compare length of lines and assign pointers */
  if( this->length() < l->length() ) {
    p = l;
    q = this;
  }
  else {
    p = this;
    q = l;
  } /* p is now the line longer or the same length then q */

  float ccwpa = p->ccw( q->getA() );
  float ccwpb = p->ccw( q->getB() );
  float ccwqa = q->ccw( p->getA() );
  float ccwqb = q->ccw( p->getB() );

  /* check collinearity of the two lines */
  if( fabs( ccwpa ) <= FLT_EPSILON && fabs( ccwpb ) <= FLT_EPSILON ) { /* lines are collinear */
    return false; /* if they are collinear, just return false. */
  }

  /* lines are not collinear -> check for intersection or(!) contact */
  if( ( ( ccwpa * ccwpb ) <= FLT_EPSILON )
      && ( ( ccwqa * ccwqb ) <= FLT_EPSILON ) ) {

    //calculate the point
    float den = ( p->getA().getX() - p->getB().getX() )
        * ( q->getA().getY() - q->getB().getY() )
        - ( p->getA().getY() - p->getB().getY() )
            * ( q->getA().getX() - q->getB().getX() );

    if( fabs( den ) <= FLT_EPSILON )
      return false;

    float x = ( ( p->getA().getX() * p->getB().getY()
        - p->getA().getY() * p->getB().getX() )
        * ( q->getA().getX() - q->getB().getX() )
        - ( p->getA().getX() - p->getB().getX() )
            * ( q->getA().getX() * q->getB().getY()
                - q->getA().getY() * q->getB().getX() ) ) / den;

    float y = ( ( p->getA().getX() * p->getB().getY()
        - p->getA().getY() * p->getB().getX() )
        * ( q->getA().getY() - q->getB().getY() )
        - ( p->getA().getY() - p->getB().getY() )
            * ( q->getA().getX() * q->getB().getY()
                - q->getA().getY() * q->getB().getX() ) ) / den;
    intersection.set( x, y );

    return true;
  }

  return false;
}

bool GiTransform::zoomScale(float viewScale, const Point2d* pxAt, bool adjust)
{
    // 检查显示比例
    if (!adjust && ScaleOutRange(viewScale, m_impl))
        return false;
    viewScale = mgMax(viewScale, m_impl->minViewScale);
    viewScale = mgMin(viewScale, m_impl->maxViewScale);

    // 得到放缩中心点的客户区坐标
    Point2d ptAt (m_impl->cxWnd * 0.5f,  m_impl->cyWnd * 0.5f);
    if (pxAt != NULL)
        ptAt.set(pxAt->x, pxAt->y);

    // 得到放缩中心点在放缩前的世界坐标
    Point2d ptAtW (ptAt * m_impl->matD2W);

    // 计算新显示比例下显示窗口中心的世界坐标
    Point2d ptW;
    float w2dx = m_impl->w2dx / m_impl->viewScale * viewScale;
    float w2dy = m_impl->w2dy / m_impl->viewScale * viewScale;
    ptW.x = ptAtW.x + (m_impl->cxWnd * 0.5f - ptAt.x) / w2dx;
    ptW.y = ptAtW.y - (m_impl->cyWnd * 0.5f - ptAt.y) / w2dy;

    // 检查新显示比例下显示窗口的世界坐标范围是否在极限范围内
    float halfw = m_impl->cxWnd / w2dx * 0.5f;
    float halfh = m_impl->cyWnd / w2dy * 0.5f;
    Box2d box (ptW, 2 * halfw, 2 * halfh);

    if (!AdjustCenterIn(adjust, box, m_impl->rectLimitsW, ptW, halfw, halfh)) {
        return false;
    }
    if (halfw - 3 > m_impl->rectLimitsW.width() / 2
        && halfh - 3 > m_impl->rectLimitsW.height() / 2)    // 显示比例太小
    {
        viewScale *= mgMin(2 * (halfw - 3) / m_impl->rectLimitsW.width(),
            2 * (halfh - 3) / m_impl->rectLimitsW.height());
        viewScale = mgMin(viewScale, m_impl->maxViewScale);
    }

    return m_impl->zoomNoAdjust(ptW, viewScale);
}

bool GiTransform::zoomScale(float viewScale, const Point2d* pxAt, bool adjust)
{
    // 检查显示比例
    if (!adjust && ScaleOutRange(viewScale, m_impl))
        return false;
    viewScale = mgMax(viewScale, m_impl->minViewScale);
    viewScale = mgMin(viewScale, m_impl->maxViewScale);

    // 得到放缩中心点的客户区坐标
    Point2d ptAt (m_impl->cxWnd * 0.5f,  m_impl->cyWnd * 0.5f);
    if (pxAt != NULL)
        ptAt.set(pxAt->x, pxAt->y);

    // 得到放缩中心点在放缩前的世界坐标
    Point2d ptAtW (ptAt * m_impl->matD2W);

    // 计算新显示比例下显示窗口中心的世界坐标
    Point2d ptW;
    float w2dx = m_impl->w2dx / m_impl->viewScale * viewScale;
    float w2dy = m_impl->w2dy / m_impl->viewScale * viewScale;
    ptW.x = ptAtW.x + (m_impl->cxWnd * 0.5f - ptAt.x) / w2dx;
    ptW.y = ptAtW.y - (m_impl->cyWnd * 0.5f - ptAt.y) / w2dy;

    // 检查新显示比例下显示窗口的世界坐标范围是否在极限范围内
    float halfw = m_impl->cxWnd / w2dx * 0.5f;
    float halfh = m_impl->cyWnd / w2dy * 0.5f;
    Box2d box (ptW, 2 * halfw, 2 * halfh);
    if (!m_impl->rectLimitsW.isEmpty() && !m_impl->rectLimitsW.contains(box))
    {
        if (adjust)
            AdjustCenterW(ptW, halfw, halfh, m_impl->rectLimitsW);
        else
            return false;
    }

    return m_impl->zoomNoAdjust(ptW, viewScale);
}

bool GiTransform::zoomTo(const Box2d& rectWorld, const RECT_2D* rcTo, bool adjust)
{
    // 如果图形范围的宽或高接近于零，就返回
    if (rectWorld.isEmpty())
        return false;

    // 计算像素到毫米的比例
    const float d2mmX = m_impl->viewScale / m_impl->w2dx;
    const float d2mmY = m_impl->viewScale / m_impl->w2dy;

    // 计算目标窗口区域(毫米)
    float w = 0, h = 0;
    Point2d ptCen;

    if (rcTo != NULL) {
        w = fabsf(static_cast<float>(rcTo->right - rcTo->left));
        h = fabsf(static_cast<float>(rcTo->bottom - rcTo->top));
        ptCen.x = (rcTo->left + rcTo->right) * 0.5f;
        ptCen.y = (rcTo->top + rcTo->bottom) * 0.5f;
    }
    if (w < 4 || h < 4) {
        w = (float)m_impl->cxWnd;
        h = (float)m_impl->cyWnd;
        ptCen.set(w * 0.5f, h * 0.5f);
        w -= 8;
        h -= 8;
    }
    if (w < 4 || h < 4)
        return false;
    w *= d2mmX;
    h *= d2mmY;
    ptCen.scaleBy(d2mmX, d2mmY);

    // 计算新显示比例 (中心不变，缩小窗口区域使得宽高比例和图形范围相同)
    float scale;
    if (h * rectWorld.width() > w * rectWorld.height()) {
        //h = w * rectWorld.height() / rectWorld.width();
        scale = w / rectWorld.width();
    }
    else {
        //w = h * rectWorld.width() / rectWorld.height();
        scale = h / rectWorld.height();
    }

    // 检查显示比例
    if (!adjust && ScaleOutRange(scale, m_impl))
        return false;
    scale = mgMax(scale, m_impl->minViewScale);
    scale = mgMin(scale, m_impl->maxViewScale);

    // 计算在新显示比例下显示窗口中心的世界坐标
    Point2d ptW;
    ptW.x = rectWorld.center().x + (m_impl->cxWnd * d2mmX * 0.5f - ptCen.x) / scale;
    ptW.y = rectWorld.center().y - (m_impl->cyWnd * d2mmY * 0.5f - ptCen.y) / scale;

    // 检查新显示比例下显示窗口的世界坐标范围是否在极限范围内
    float halfw = m_impl->cxWnd * d2mmX  / scale * 0.5f;
    float halfh = m_impl->cyWnd * d2mmY  / scale * 0.5f;
    Box2d box (ptW, 2 * halfw, 2 * halfh);

    if (!AdjustCenterIn(adjust, box, m_impl->rectLimitsW, ptW, halfw, halfh)) {
        return false;
    }

    return m_impl->zoomNoAdjust(ptW, scale);
}

void Matrix2d::getCoordSystem(Vector2d& e0, Vector2d& e1, Point2d& origin) const
{
    e0.set(m11, m12);
    e1.set(m21, m22);
    origin.set(dx, dy);
}