C++ endPoint函数代码示例

void ArrowLine::drawShape(QPainter &p)
{
    p.setPen(darkGray);
    QCanvasLine::drawShape(p);

    double angle = computeAngle(startPoint().x(),
                                startPoint().y(),
                                endPoint().x(),
                                endPoint().y());
    QPointArray pts(3);

    QWMatrix m;
    int x, y;
    m.rotate(angle);
    m.map(-5, -2, &x, &y);
    pts.setPoint(0, x, y);
    m.map(-5, 2, &x, &y);
    pts.setPoint(1, x, y);
    m.map(0, 0, &x, &y);
    pts.setPoint(2, x, y);

    pts.translate(endPoint().x(), endPoint().y());

    p.setBrush(QColor(darkGray));
    p.drawPolygon(pts);
}

void AMBeamSelectPage::initializePage()
{
	AMViewPage::initializePage();

	disconnect(view(), SIGNAL(mousePressed(QPointF)), viewWizard(), SLOT(addPoint(QPointF)));
	disconnect(view(), SIGNAL(mouseLeftReleased(QPointF)), viewWizard(), SLOT(endPoint()));
	connect(view(), SIGNAL(mousePressed(QPointF)), viewWizard(), SLOT(addPoint(QPointF)));
	connect(view(), SIGNAL(mouseLeftReleased(QPointF)), viewWizard(), SLOT(endPoint()));
}

////////////////// PathInfo //////////////////
PathInfo::PathInfo(const Unit* owner, const float destX, const float destY, const float destZ, bool useStraightPath) :
    m_pathPolyRefs(NULL), m_polyLength(0), m_type(PATHFIND_BLANK), m_useStraightPath(useStraightPath),
    m_sourceUnit(owner), m_navMesh(NULL), m_navMeshQuery(NULL)
{
    PathNode endPoint(destX, destY, destZ);
    setEndPosition(endPoint);

    float x,y,z;
    m_sourceUnit->GetPosition(x, y, z);
    PathNode startPoint(x, y, m_sourceUnit->GetMap()->GetHeight(x,y,z,100.0f));
    setStartPosition(startPoint);

    PATH_DEBUG("++ PathInfo::PathInfo for %u \n", m_sourceUnit->GetGUID());

    uint32 mapId = m_sourceUnit->GetMapId();
    MMAP::MMapManager* mmap = MMAP::MMapFactory::createOrGetMMapManager();
    m_navMesh = mmap->GetNavMesh(mapId);
    m_navMeshQuery = mmap->GetNavMeshQuery(mapId);

    if (m_navMesh && m_navMeshQuery)
    {
        BuildPolyPath(startPoint, endPoint);
    }
    else
    {
        BuildShortcut();
        m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);
    }
}

void PD_2DXYPS::DrawXAxes(const double& yVal,
                               const double& yaxOffset)
{
    Point2D stPoint(convXaxisMin, yVal + yaxOffset);
    Point2D endPoint(convXaxisMax, yVal + yaxOffset);
    DrawLine(stPoint, endPoint);
}

	void KviCanvasLine::draw(QPainter &p)
	{
		if(isEnabled())
		{
			p.setPen(pen());
			p.drawLine(startPoint(),endPoint());
		}

		if(isSelected())
		{
			p.setRasterOp(NotROP);
			p.setPen(QPen(DotLine));
			p.drawLine(startPoint(),endPoint());
			p.setRasterOp(CopyROP);
		}
	}

void Tranceiver::connect(String ipAddr) {
	semaphore.Acquire();

	//create socket
	socket=new Socket();
	socket->Construct(NET_SOCKET_AF_IPV4,
			NET_SOCKET_TYPE_STREAM, NET_SOCKET_PROTOCOL_TCP);

	unsigned long blockingModeSocket=0;
	socket->Ioctl(NET_SOCKET_FIONBIO, blockingModeSocket);

	//Connect to TCP Server
	Ip4Address ipAddress(ipAddr);
	NetEndPoint endPoint(ipAddress, PORT);
	result r=socket->Connect(endPoint);

	if(r!=E_SUCCESS) {
		AppLogException("CommandCenter : Connect Error");
	}

	//Create Packet Object
	packetSender=new PacketSender(socket);
	screenSender=new ScreenSender(socket);
	packetReceiver=new PacketReceiver(socket);

	//Start PacketReciever
	packetReceiver->setPacketListener(this);
	packetReceiver->Construct();
	packetReceiver->flag=true;
	packetReceiver->Start();

	//mServerConnectionListener->onServerConnected(ipAddr);

	semaphore.Release();
}

double LikelihoodField::computeWeight(const std::vector<double>& measurement, const std::vector<double>& state, const Grid<double>& map){
	double q = 1;
	//Get location of range finder in global coordinates
	std::vector<double> locationRF = this->rf->getLocation(state);
	std::vector<double> endPoint(2);
	//Temporary variables
	double z,minDist,dist,sample, beamAngle;
	for(int i = 0; i < (int)measurement.size(); i++){
		//Current measurement
		z = measurement[i];
		beamAngle = this->rf->getBeamAngle(i);
		if (z != this->rf->getErrorValue()){
			//Compute end position of current beam
			endPoint[0] = locationRF[0] + z * cos(beamAngle + state[2]);
			endPoint[1] = locationRF[1] + z * sin(beamAngle + state[2]);
			//Find nearest occupied cell in map
			minDist = 0;
			for(int j = 0; j < map.getNumberCells(); j++){
				Cell<double> c = map.getCell(j);
				if(c.value > this->parameters[4]){
					dist = c.getDistanceToCenter(endPoint);
					if(dist < minDist || minDist == 0)
						minDist = dist;
				}
			}
			//Update probability of measurement
			sample = Tools::probNormal(minDist, this->parameters[0]);
			q = q * (this->parameters[1] * sample + this->parameters[2]/this->parameters[3]);
		}
	}
	return q;
}

RTRVector3D RTRSegment::pointAt(int coordinate, double val) const
{
    //TODO Not finished... I want to sleep!!
    double ratio = (val - beginningPoint(coordinate)) / (endPoint(coordinate) - beginningPoint(coordinate));
    RTRVector3D ret = beginningPoint + (endPoint - beginningPoint) * ratio;
    ret(coordinate) = val;
    return ret;
}

void
VNode::render() const
{
    glColor3f(0,1,0);
    glLineWidth(MaxWidth);
    DrawLine( m_location, endPoint() );
    int numChildren = (int)m_children.size();
    for(int i=0; i<numChildren; ++i)
        m_children[i]->render();
}

bool QgsCurve::isClosed() const
{
  if ( numPoints() == 0 )
    return false;

  //don't consider M-coordinates when testing closedness
  QgsPointV2 start = startPoint();
  QgsPointV2 end = endPoint();
  return ( qgsDoubleNear( start.x(), end.x(), 1E-8 ) &&
           qgsDoubleNear( start.y(), end.y(), 1E-8 ) &&
           qgsDoubleNear( start.z(), end.z(), 1E-8 ) );
}

int server()
{
	printf("Give me the printer Number : 0 or 1");
	int no;
	scanf("%d",&no);

	char buffer[256] = { '\0' };

	    // Create a local endpoint.
	if(no==0)
	    sprintf(buffer, "tcp://58.198.176.121:5555");
	else
		sprintf(buffer, "tcp://58.198.176.121:5557");


	    Theron::EndPoint endPoint("server", buffer);

	    // Connect to the remote endpoint.

	    	sprintf(buffer, "tcp://58.198.176.121:5556");
	    	if (!endPoint.Connect(buffer))
	    	{
	    		printf("ERROR: Connection failed - check networking is enabled.\n");
	    		return 1;
	    	}



	    // The framework and receiver are tied to the endpoint.
	    if(no==0)
	    {
	    	//Theron::Receiver receiver(endPoint, "receiver");

	    	Theron::Framework framework(endPoint);

	    	Printer printer(no,framework, "printer");
	    	Printer1 printer1(no,framework, "printer1");
	    	//receiver.Wait();
	    	while(1);

	    }
	    else
	    {
	    	Theron::Receiver receiver(endPoint, "receiver1");
	    	Theron::Framework framework(endPoint);

	    	Printer printer1(no,framework,"printer");
	    	receiver.Wait();

	    }


}

int client()
{
	  char buffer[256] = { '\0' };

	    // Create a local endpoint.
	    sprintf(buffer, "tcp://58.198.176.121:5556");
	    Theron::EndPoint endPoint("client", buffer);

	    // Connect to the remote endpoint.
	    sprintf(buffer, "tcp://58.198.176.121:5555");
	    if (!endPoint.Connect(buffer))
	    {
	        printf("ERROR: Connection failed - check networking is enabled.\n");
	        return 1;
	    }
	    else
	    {
	    	printf("Connected to %s\n",buffer);
	    }
	    sprintf(buffer, "tcp://58.198.176.121:5557");
	    if (!endPoint.Connect(buffer))
	    {
	        printf("ERROR: Connection failed - check networking is enabled.\n");
	        return 1;
	    }
	    else
	    {
	    	printf("Connected to %s\n",buffer);
	    }

	    // The framework is tied to the endpoint.
	    Theron::Framework framework(endPoint);

	    // Send messages to the server in a loop until the user enters 'exit'.
	    // Note that if the server hasn't started listening yet it may miss the first messages!
	    printf("Enter lines of text (max 256 chars per line). Type 'exit' to end.\n");

	    while (strcmp(buffer, "exit") != 0)
	    {
	        // Send the text in a messages to the remote 'printer' actor using its unique name.
	        gets(buffer);
	        framework.Send(
	            TextMessage(buffer),
	            Theron::Address(),
	            Theron::Address("printer"));

	        framework.Send(
	  	            double(28.234),
	  	            Theron::Address(),
	  	            Theron::Address("printer1"));
	    }
}

void
VNode::grow(const Vector2& targetPoint, bool& reachedTarget,
            VINENODES& newChildren, VINENODES& staleChildren)
{
    incrementGrowth();
    setEndPoint();

    float distance = sqrt( pow((targetPoint.X - endPoint().X),2) + pow((targetPoint.Y - endPoint().Y),2) );
    reachedTarget = bool(distance <= GrowthIncrement);

    if(!reachedTarget)
    {
        if(maxLengthReached())
        {
            staleChildren.push_back(this);
            addRandomizedChildren(endPoint(), targetPoint);
            int sz = (int)m_children.size();
            for( int i=0; i<sz; ++i )
                newChildren.push_back(m_children[i]);
        }
    }
}

QgsAbstractGeometry *QgsCurve::boundary() const
{
  if ( isEmpty() )
    return nullptr;

  if ( isClosed() )
    return nullptr;

  QgsMultiPoint *multiPoint = new QgsMultiPoint();
  multiPoint->addGeometry( new QgsPoint( startPoint() ) );
  multiPoint->addGeometry( new QgsPoint( endPoint() ) );
  return multiPoint;
}

/**
 * Return whether on seq. line.
 * Takes into account destruction box if shown.
 *
 * @param p The point to investigate.
 * @return  Non-zero if point is on this sequence line.
 */
int SeqLineWidget::onWidget(const QPoint & p)
{
    int nOnWidget = 0;
    QPoint sp = startPoint();
    QPoint ep = endPoint();
    //see if on widget ( for message creation )
    if( sp.x() - m_nMouseDownEpsilonX < p.x()
            && ep.x() + m_nMouseDownEpsilonX > p.x()
            && sp.y() < p.y() && ep.y() + 3 > p.y() )
    {
        nOnWidget = 1;
    }
    return nOnWidget;
}