C++ Point2D::x方法代码示例

// Tests the version of the constructor that takes a vector of points
// with a small sample of points
TEST_F(SplineTest, constructor_from_points_small_case) {
    std::vector<Point2D> points = {{1, 1}, {3, 3}, {2, 4}, {5, 1}};
    Spline spline(points);

    // Check the start and end points of the spline
    // (ie. check that the spline passes through the start and end points)
    EXPECT_EQ(Point2D(1, 1), spline(0));
    EXPECT_EQ(Point2D(5, 1), spline(1));

    // Check the values at the interpolation points
    // (ie. check that the spline passes through the interpolation points)
    EXPECT_EQ(Point2D(3, 3), spline.getPointAtZeroToNIndex(1));
    EXPECT_EQ(Point2D(2, 4), spline.getPointAtZeroToNIndex(2));
    EXPECT_EQ(Point2D(5, 1), spline.getPointAtZeroToNIndex(3));

    // Check a couple points in between interpolation points
    Point2D p;

    // Point between the (1,1) and (3,3) interpolation points
    p = spline.getPointAtZeroToNIndex(0.5);
    EXPECT_GE(p.x(), 1);
    EXPECT_LE(p.x(), 3);
    EXPECT_GE(p.y(), 1);
    EXPECT_LE(p.y(), 3);

    // Point between the (2,4) and (5,1) interpolation points
    p = spline.getPointAtZeroToNIndex(2.5);
    EXPECT_GE(p.x(), 2);
    EXPECT_LE(p.x(), 5);
    EXPECT_GE(p.y(), 1);
    EXPECT_LE(p.y(), 4);
}

void Viewer::DrawBox(const Point2D &x1, const Point2D &x2) {
  glBegin(GL_LINE_LOOP);
  glVertex2f(x1.x(), x1.y());
  glVertex2f(x1.x(), x2.y());
  glVertex2f(x2.x(), x2.y());
  glVertex2f(x2.x(), x1.y());
  glEnd();
}

void Viewer::DrawQuad(const Point2D &x1, const Point2D &x2) {
  glBegin(GL_QUADS);
  glVertex2f(x1.x(), x1.y());
  glVertex2f(x1.x(), x2.y());
  glVertex2f(x2.x(), x2.y());
  glVertex2f(x2.x(), x1.y());
  glEnd();
}

void Viewer::DrawCross(const Point2D &x, const LA::Vector2f &size) {
  glBegin(GL_LINES);
  glVertex2f(x.x() - size.x(), x.y());
  glVertex2f(x.x() + size.x(), x.y());
  glVertex2f(x.x(), x.y() - size.y());
  glVertex2f(x.x(), x.y() + size.y());
  glEnd();
}

TEST_F(TerrainBlockTest, data) {
    Point2D<int> southWestPixel(position.x() * 256, (position.y() + 1) * 256);
    Point2D<int> northEastPixel((position.x() + 1) * 256, position.y() * 256);
    
    Point2D<double> southWest = GeoPoint::fromPixel(southWestPixel, zoomLevel, 256).toWebMercator();
    Point2D<double> northEast = GeoPoint::fromPixel(northEastPixel, zoomLevel, 256).toWebMercator();

    double referenceArea = (float(northEast.x()) - float(southWest.x())) * (float(northEast.y()) - float(southWest.y()));
    
    const std::vector<float>& vertexBuffer = terrainBlock->vertexBuffer();
    const auto& indexBuffer = TerrainBlock::indexBuffer();
    
    ASSERT_EQ(75, vertexBuffer.size());
    ASSERT_EQ(96, indexBuffer.size());
    
    auto readPolygon = [&](int startPosition) -> std::tuple<Point3D<float>, Point3D<float>, Point3D<float>> {
        return std::make_tuple(Point3D<float>(vertexBuffer[indexBuffer[startPosition] * 3],
                                              vertexBuffer[indexBuffer[startPosition] * 3 + 1],
                                              vertexBuffer[indexBuffer[startPosition] * 3 + 2]),
                               Point3D<float>(vertexBuffer[indexBuffer[startPosition + 1] * 3],
                                              vertexBuffer[indexBuffer[startPosition + 1] * 3 + 1],
                                              vertexBuffer[indexBuffer[startPosition + 1] * 3 + 2]),
                               Point3D<float>(vertexBuffer[indexBuffer[startPosition + 2] * 3],
                                              vertexBuffer[indexBuffer[startPosition + 2] * 3 + 1],
                                              vertexBuffer[indexBuffer[startPosition + 2] * 3 + 2]));
    };
    
    double terrainBlockArea = 0;
    
    std::unordered_set<long> heights;
    
    for (int i = 0; i < indexBuffer.size(); i += 3) {
        auto polygon = readPolygon(i);
        const Point3D<float>& p1 = std::get<0>(polygon);
        const Point3D<float>& p2 = std::get<1>(polygon);
        const Point3D<float>& p3 = std::get<2>(polygon);
        
        EXPECT_FALSE(p1 == p2);
        EXPECT_FALSE(p1 == p3);
        EXPECT_FALSE(p2 == p3);
        
        terrainBlockArea += triangleArea(p1, p2, p3);
        
        long h1 = lround(p1.z());
        long h2 = lround(p2.z());
        long h3 = lround(p3.z());
        EXPECT_NE(0, h1);
        EXPECT_NE(0, h2);
        EXPECT_NE(0, h3);
        heights.insert(h1);
        heights.insert(h2);
        heights.insert(h3);
    }
    
    EXPECT_FLOAT_EQ(referenceArea, terrainBlockArea);
    EXPECT_EQ(62 - 55 + 1, heights.size());
}

  // ********************* SQUARE **********************
  Square::Square(Point2D origin, double length, double angle){
    this->isconvex=true;
    this->vertexes.reserve(4);
    vertexes.push_back(origin);
    double c(std::cos(angle));
    double s(std::sin(angle));
    vertexes.push_back(Point2D(origin.x()+length*c,
			       origin.y()+length*s));
    vertexes.push_back(Point2D(origin.x()+length*(c-s),
			       origin.y()+length*(c+s)));
    vertexes.push_back(Point2D(origin.x()-length*s,
			       origin.y()+length*c));
  }

void ViewportPainter::drawPoint(Point2D & point) {
    if(point.getTime() != "-1") {
      QString text("t = " + point.getTime());
      QRect rect(point.x()+TEXT_OFFSET_X, point.y()-TEXT_OFFSET_Y,10*text.length()+2*TEXT_MARGIN,15+2*TEXT_MARGIN);
      this->setBrush(QColor(255, 255, 255, 255));
      this->drawRect(rect);
      this->drawText(rect,Qt::AlignHCenter|Qt::AlignVCenter,text);
    }
    if(point.selected())
      this->setBrush(QColor(255, 0, 0, 255));
    else
      this->setBrush(QColor(255, 248, 133, 255));
    this->drawEllipse(point.x()-POINT_SIZE/2,point.y()-POINT_SIZE/2,POINT_SIZE,POINT_SIZE);
}

double Point2D::distance(Point2D another) {

    double dx = x() - another.x();
    double dy = y() - another.y();

    return sqrt( dx*dx + dy*dy);

};

Point2D Point2D::moveby(Point2D shift_pt) {

    double new_x = x() + shift_pt.x();
    double new_y = y() + shift_pt.y();

    return Point2D(new_x, new_y);

};

bool Rectangle::add_point(const Point2D& p){
    if(is_point_within(p)){
        Point2D currPnt;
        bool newPnt = true;
        for(int x = 0; x <m_points_contained.size(); x++){
            currPnt = m_points_contained[x];
            if(currPnt.x() == p.x() && currPnt.y() == p.y())
                newPnt = false;
        }
        if(newPnt){
            m_points_contained.push_back(p);
            return true;
        }
        else return false;
    }
    else return false;
}

void TerrainBlockTest::SetUp() {
    srtmFactory = std::make_unique<TempSRTMFileFactory>();
    
    srtmFactory->createFile(southWestPoint, [&](TempSRTMFileFactory::WriteValueCallback writeValue) {
        Point2D<int> southWestPixel(position.x() * 256, (position.y() + 1) * 256);
        Point2D<int> northEastPixel((position.x() + 1) * 256, position.y() * 256);
        Point2D<double> southWest = GeoPoint::fromPixel(southWestPixel, zoomLevel, 256);
        Point2D<double> northEast = GeoPoint::fromPixel(northEastPixel, zoomLevel, 256);
        
        short counter = 10;
        
        for (int y = (southWest.y() - southWestPoint.y()) * HeightMap::POINTS_IN_DEGREE;
             y <= ceil((northEast.y() - southWestPoint.y()) * HeightMap::POINTS_IN_DEGREE);
             y++) {
            for (int x = (southWest.x() - southWestPoint.x()) * HeightMap::POINTS_IN_DEGREE;
                 x <= ceil((northEast.x() - southWestPoint.x()) * HeightMap::POINTS_IN_DEGREE);
                 x++) {
                writeValue(y, x, counter += 10);
            }
        }
        
        writeValue(0, HeightMap::POINTS_IN_DEGREE, 0);
    });
    
    heightGrid = std::make_unique<HeightGrid>(srtmFactory->tmpDirectory(), [](int latitude, int longitude){});
    terrainBlock = std::make_unique<TerrainBlock>(Point3D<int>(position.x(), position.y(), zoomLevel), *heightGrid);
}

void Point2D::rotate(double const& radiant, Point2D const& center, bool filled)
/* Bool Filled = true führt zu ausgeülltem Kreis. sollte viellcht in Klasse Kreis überladen werden?
 Oder eine adapter Klasse shape eingeführt werden.
 Diese benötigt diese Art der Drehung für die Darstellung. Derzeit.
 Ansonsten wird nur die Kontur gemalt. */
{ double x,y = 0;
    if ( !filled ) {
        x = -center.x()+x_;
        y = -center.y()+y_;
    } else {
        x = center.x()-x_;
        y = center.y()-y_;
    }
    Point2D r{x,y};
    r.rotate(radiant);
    x_ = r.x() + center.x();
    y_ = r.y() + center.y();
}

Point3D::Point3D(Point2D pt2d, double z, bool valid = true) {

    _valid = valid;

    _x = pt2d.x();
    _y = pt2d.y();
    _z = z;

};

void ViewportPainter::drawBezierCurve(BezierCurve & curve) {
    Point2D * beginPoint = curve.getBeginPoint();
    Point2D * endPoint = curve.getEndPoint();
    Point2D * controlPoint = curve.getControlPoint();
    
    // Plus tard dessin de la courbe :
    // this->drawArc(beginPoint->x(),beginPoint->y(),endPoint->x()-beginPoint->x(),endPoint->y()-beginPoint->y(),0*16,360*16);
      
    this->drawLine(beginPoint->x(),beginPoint->y(),endPoint->x(),endPoint->y());
    
    // Dessin du vecteur
    /*this->setPen(QColor(255, 120, 0, 255));
    this->drawPoint(*controlPoint);
    this->drawLine(beginPoint->x(),beginPoint->y(),controlPoint->x(),controlPoint->y());
    // Dessiner la fleche du vecteur
    //this->drawLine(controlPoint->x(),controlPoint->y());
    //this->drawLine(controlPoint->x(),controlPoint->y());
    this->setPen(QColor(0, 0, 0, 255));*/
}

	void LaserLauncher::draw(void) const
	{
		using namespace ImageHandle;

		const auto count{get_count()};
		const auto angle{this->angle()};

		const Point2D P{d->d * Point2D(-sin(angle), cos(angle))};
		gp::DrawRotaGraphF(gp::level(11), pos().x(), pos().y(), 0.08, angle, shaft, true);
		gp::DrawRotaGraphF(gp::level(11), pos().x() - P.x(), pos().y() - P.y(), 0.08, angle, right_shell, true);
		gp::DrawRotaGraphF(gp::level(11), pos().x() + P.x(), pos().y() + P.y(), 0.08, angle, left_shell, true);
	}