C++ Point3dVector::size方法代码示例

  bool circularEqual(const Point3dVector& points1, const Point3dVector& points2, double tol)
  {
    unsigned N = points1.size();
    if (N != points2.size()){
      return false;
    }

    if (N == 0){
      return true;
    }

    bool result = false;

    // look for a common starting point
    for (unsigned i = 0; i < N; ++i){
      if (getDistance(points1[0], points2[i]) <= tol){

        result = true;

        // check all other points
        for (unsigned j = 0; j < N; ++j){
          if (getDistance(points1[j], points2[(i + j) % N]) > tol){
            result = false;
            break;
          }
        }
      }

      if (result){
        return result;
      }
    }

    return result;
  }

  /// compute centroid from surface as Point3dVector
  OptionalPoint3d getCentroid(const Point3dVector& points)
  {
    OptionalPoint3d result;

    if (points.size() >= 3){
      // convert to face coordinates
      Transformation alignFace = Transformation::alignFace(points);
      Point3dVector surfacePoints = alignFace.inverse()*points;

      unsigned N = surfacePoints.size();
      double A = 0;
      double cx = 0;
      double cy = 0;
      for (unsigned i = 0; i < N; ++i){
        double x1, x2, y1, y2;
        if (i == N-1){
          x1 = surfacePoints[i].x();
          x2 = surfacePoints[0].x();
          y1 = surfacePoints[i].y();
          y2 = surfacePoints[0].y();
        }else{
          x1 = surfacePoints[i].x();
          x2 = surfacePoints[i+1].x();
          y1 = surfacePoints[i].y();
          y2 = surfacePoints[i+1].y();
        }

        double dA = (x1*y2-x2*y1);
        A += 0.5*dA;
        cx += (x1+x2)*dA;
        cy += (y1+y2)*dA;
      }

      if (A > 0){
        // centroid in face coordinates
        Point3d surfaceCentroid(cx/(6.0*A), cy/(6.0*A), 0.0);

        // centroid
        result = alignFace*surfaceCentroid;
      }
    }
    return result;
  }

TEST(Radiance, ForwardTranslator_SurfaceOnlyOnGround)
{
  Model model;
  Building building = model.getUniqueModelObject<Building>();

  Space space(model);

  Point3dVector vertices;
  vertices.push_back(Point3d(0,0,0));
  vertices.push_back(Point3d(1,0,0));
  vertices.push_back(Point3d(1,1,0));
  vertices.push_back(Point3d(0,1,0));
  Surface surface(vertices, model);

  surface.setSpace(space);

  Point3dVector polygon = ForwardTranslator::getPolygon(surface);
  EXPECT_EQ(vertices.size(), polygon.size());

  BOOST_FOREACH(const Point3d& vertex, polygon){
    LOG_FREE(::Info, "Radiance", vertex);
  }

TEST_F(ModelFixture, IlluminanceMap_SpaceSetTransformation)
{
  Model model;
  Space space(model);
  IlluminanceMap map(model);
  map.setXLength(2);
  map.setYLength(2);
  map.setNumberofXGridPoints(2);
  map.setNumberofYGridPoints(2);
  map.setOriginXCoordinate(1);
  map.setOriginYCoordinate(0);
  map.setOriginZCoordinate(2);
  map.setSpace(space);

  Point3dVector testPoints = map.referencePoints();
  ASSERT_EQ(4u, testPoints.size());
  EXPECT_DOUBLE_EQ(0, testPoints[0].x());
  EXPECT_DOUBLE_EQ(0, testPoints[0].y());
  EXPECT_DOUBLE_EQ(0, testPoints[0].z());
  EXPECT_DOUBLE_EQ(2, testPoints[3].x());
  EXPECT_DOUBLE_EQ(2, testPoints[3].y());
  EXPECT_DOUBLE_EQ(0, testPoints[3].z());

  testPoints = space.transformation()*map.transformation()*map.referencePoints();
  EXPECT_DOUBLE_EQ(1, testPoints[0].x());
  EXPECT_DOUBLE_EQ(0, testPoints[0].y());
  EXPECT_DOUBLE_EQ(2, testPoints[0].z());
  EXPECT_DOUBLE_EQ(3, testPoints[3].x());
  EXPECT_DOUBLE_EQ(2, testPoints[3].y());
  EXPECT_DOUBLE_EQ(2, testPoints[3].z());

  EXPECT_TRUE(space.setTransformation(Transformation::translation(Vector3d(1,0,0))));

  testPoints = space.transformation()*map.transformation()*map.referencePoints();
  EXPECT_DOUBLE_EQ(2, testPoints[0].x());
  EXPECT_DOUBLE_EQ(0, testPoints[0].y());
  EXPECT_DOUBLE_EQ(2, testPoints[0].z());
  EXPECT_DOUBLE_EQ(4, testPoints[3].x());
  EXPECT_DOUBLE_EQ(2, testPoints[3].y());
  EXPECT_DOUBLE_EQ(2, testPoints[3].z());

  EXPECT_TRUE(space.setTransformation(Transformation::translation(Vector3d(1,0,0))*Transformation::rotation(Vector3d(0,0,1),-openstudio::degToRad(90))));

  testPoints = space.transformation()*map.transformation()*map.referencePoints();
  EXPECT_DOUBLE_EQ(1, testPoints[0].x());
  EXPECT_DOUBLE_EQ(-1, testPoints[0].y());
  EXPECT_DOUBLE_EQ(2, testPoints[0].z());
  EXPECT_DOUBLE_EQ(3, testPoints[3].x());
  EXPECT_DOUBLE_EQ(-3, testPoints[3].y());
  EXPECT_DOUBLE_EQ(2, testPoints[3].z());
}

 // compute Newall vector from Point3dVector, direction is same as outward normal
 // magnitude is twice the area
 OptionalVector3d getNewallVector(const Point3dVector& points)
 {
   OptionalVector3d result;
   unsigned N = points.size();
   if (N >= 3){
     Vector3d vec;
     for (unsigned i = 1; i < N-1; ++i){
       Vector3d v1 = points[i] - points[0];
       Vector3d v2 = points[i+1] - points[0];
       vec += v1.cross(v2);
     }
    result = vec;
  }
  return result;
 }

  /// reorder points to upper-left-corner convention
  Point3dVector reorderULC(const Point3dVector& points)
  {
    unsigned N = points.size();
    if (N < 3){
      return Point3dVector();
    }

    // transformation to align face
    Transformation t = Transformation::alignFace(points);
    Point3dVector facePoints = t.inverse()*points;

    // find ulc index in face coordinates
    double maxY = std::numeric_limits<double>::min();
    double minX = std::numeric_limits<double>::max();
    unsigned ulcIndex = 0;
    for(unsigned i = 0; i < N; ++i){
      OS_ASSERT(std::abs(facePoints[i].z()) < 0.001);
      if ((maxY < facePoints[i].y()) || ((maxY < facePoints[i].y() + 0.00001) && (minX > facePoints[i].x()))){
        ulcIndex = i;
        maxY = facePoints[i].y();
        minX = facePoints[i].x();
      }
    }

    // no-op
    if (ulcIndex == 0){
      return points;
    }

    // create result
    Point3dVector result;
    std::copy (points.begin() + ulcIndex, points.end(), std::back_inserter(result));
    std::copy (points.begin(), points.begin() + ulcIndex, std::back_inserter(result));
    OS_ASSERT(result.size() == N);
    return result;
  }

  std::vector<Point3d> removeColinear(const Point3dVector& points, double tol)
  {
    unsigned N = points.size();
    if (N < 3){
      return points;
    }

    std::vector<Point3d> result;
    Point3d lastPoint = points[0];
    result.push_back(lastPoint);

    for (unsigned i = 1; i < N; ++i){
      Point3d currentPoint = points[i];
      Point3d nextPoint = points[0];
      if (i < N-1){
        nextPoint = points[i+1];
      }

      Vector3d a = (currentPoint - lastPoint);
      Vector3d b = (nextPoint - currentPoint);

      // if these fail to normalize we have zero length vectors (e.g. adjacent points)
      if (a.normalize()){
        if (b.normalize()){

          Vector3d c = a.cross(b);
          if (c.length() >= tol){
            // cross product is significant
            result.push_back(currentPoint);
            lastPoint = currentPoint;
          }else{
            // see if dot product is near -1
            double d = a.dot(b);
            if (d <= -1.0 + tol){
              // this is a line reversal
              result.push_back(currentPoint);
              lastPoint = currentPoint;
            }
          }
        }
      }
    }

    return result;
  }

  std::vector<std::vector<Point3d> > computeTriangulation(const Point3dVector& vertices, const std::vector<std::vector<Point3d> >& holes, double tol)
  {
    std::vector<std::vector<Point3d> > result;

    // check input
    if (vertices.size () < 3){
      return result;
    }

    boost::optional<Vector3d> normal = getOutwardNormal(vertices);
    if (!normal || normal->z() > -0.999){
      return result;
    }

    for (const auto& hole : holes){
      normal = getOutwardNormal(hole);
      if (!normal || normal->z() > -0.999){
        return result;
      }
    }

    std::vector<Point3d> allPoints;

    // PolyPartition does not support holes which intersect the polygon or share an edge
    // if any hole is not fully contained we will use boost to remove all the holes
    bool polyPartitionHoles = true;
    for (const std::vector<Point3d>& hole : holes){
      if (!within(hole, vertices, tol)){
        // PolyPartition can't handle this
        polyPartitionHoles = false;
        break;
      }
    }

    if (!polyPartitionHoles){
      // use boost to do all the intersections
      std::vector<std::vector<Point3d> > allFaces = subtract(vertices, holes, tol);
      std::vector<std::vector<Point3d> > noHoles;
      for (const std::vector<Point3d>& face : allFaces){
        std::vector<std::vector<Point3d> > temp = computeTriangulation(face, noHoles);
        result.insert(result.end(), temp.begin(), temp.end());
      }
      return result;
    }

    // convert input to vector of TPPLPoly
    std::list<TPPLPoly> polys;

    TPPLPoly outerPoly; // must be counter-clockwise, input vertices are clockwise
    outerPoly.Init(vertices.size());
    outerPoly.SetHole(false);
    unsigned n = vertices.size();
    for(unsigned i = 0; i < n; ++i){

      // should all have zero z coordinate now
      double z = vertices[n-i-1].z();
      if (abs(z) > tol){
        LOG_FREE(Error, "utilities.geometry.computeTriangulation", "All points must be on z = 0 plane for triangulation methods");
        return result;
      }

      Point3d point = getCombinedPoint(vertices[n-i-1], allPoints, tol);
      outerPoly[i].x = point.x();
      outerPoly[i].y = point.y();
    }
    outerPoly.SetOrientation(TPPL_CCW);
    polys.push_back(outerPoly);


    for (const std::vector<Point3d>& holeVertices : holes){

      if (holeVertices.size () < 3){
        LOG_FREE(Error, "utilities.geometry.computeTriangulation", "Hole has fewer than 3 points, ignoring");
        continue;
      }

      TPPLPoly innerPoly; // must be clockwise, input vertices are clockwise
      innerPoly.Init(holeVertices.size());
      innerPoly.SetHole(true);
      //std::cout << "inner :";
      for(unsigned i = 0; i < holeVertices.size(); ++i){

        // should all have zero z coordinate now
        double z = holeVertices[i].z();
        if (abs(z) > tol){
          LOG_FREE(Error, "utilities.geometry.computeTriangulation", "All points must be on z = 0 plane for triangulation methods");
          return result;
        }

        Point3d point = getCombinedPoint(holeVertices[i], allPoints, tol);
        innerPoly[i].x = point.x();
        innerPoly[i].y = point.y();
      }
      innerPoly.SetOrientation(TPPL_CW);
      polys.push_back(innerPoly);
    }

    // do partitioning
    TPPLPartition pp;
    std::list<TPPLPoly> resultPolys;
//.........这里部分代码省略.........

TEST_F(ModelFixture, IlluminanceMap_Transformation)
{
  Model model;
  IlluminanceMap map(model);
  map.setXLength(2);
  map.setYLength(2);
  map.setNumberofXGridPoints(2);
  map.setNumberofYGridPoints(2);
  map.setOriginXCoordinate(1);
  map.setOriginYCoordinate(0);
  map.setOriginZCoordinate(2);

  Point3dVector testPoints = map.referencePoints();
  ASSERT_EQ(4u, testPoints.size());
  EXPECT_NEAR(0, testPoints[0].x(), 0.000001);
  EXPECT_NEAR(0, testPoints[0].y(), 0.000001);
  EXPECT_NEAR(0, testPoints[0].z(), 0.000001);
  EXPECT_NEAR(2, testPoints[3].x(), 0.000001);
  EXPECT_NEAR(2, testPoints[3].y(), 0.000001);
  EXPECT_NEAR(0, testPoints[3].z(), 0.000001);

  testPoints = map.transformation()*map.referencePoints();
  EXPECT_NEAR(1, testPoints[0].x(), 0.000001);
  EXPECT_NEAR(0, testPoints[0].y(), 0.000001);
  EXPECT_NEAR(2, testPoints[0].z(), 0.000001);
  EXPECT_NEAR(3, testPoints[3].x(), 0.000001);
  EXPECT_NEAR(2, testPoints[3].y(), 0.000001);
  EXPECT_NEAR(2, testPoints[3].z(), 0.000001);

  Transformation transformation = Transformation::translation(Vector3d(1,0,2));
  EXPECT_TRUE(map.setTransformation(transformation));
  EXPECT_TRUE(transformation.matrix() == map.transformation().matrix());

  testPoints = map.referencePoints();
  ASSERT_EQ(4u, testPoints.size());
  EXPECT_NEAR(0, testPoints[0].x(), 0.000001);
  EXPECT_NEAR(0, testPoints[0].y(), 0.000001);
  EXPECT_NEAR(0, testPoints[0].z(), 0.000001);
  EXPECT_NEAR(2, testPoints[3].x(), 0.000001);
  EXPECT_NEAR(2, testPoints[3].y(), 0.000001);
  EXPECT_NEAR(0, testPoints[3].z(), 0.000001);

  testPoints = map.transformation()*map.referencePoints();
  EXPECT_NEAR(1, testPoints[0].x(), 0.000001);
  EXPECT_NEAR(0, testPoints[0].y(), 0.000001);
  EXPECT_NEAR(2, testPoints[0].z(), 0.000001);
  EXPECT_NEAR(3, testPoints[3].x(), 0.000001);
  EXPECT_NEAR(2, testPoints[3].y(), 0.000001);
  EXPECT_NEAR(2, testPoints[3].z(), 0.000001);

  transformation = Transformation::translation(Vector3d(1,0,2))*Transformation::rotation(Vector3d(0,0,1),-openstudio::degToRad(90));
  EXPECT_TRUE(map.setTransformation(transformation));
  EXPECT_TRUE(transformation.matrix() == map.transformation().matrix()) << transformation.matrix() << std::endl << map.transformation().matrix();

  testPoints = map.referencePoints();
  ASSERT_EQ(4u, testPoints.size());
  EXPECT_NEAR(0, testPoints[0].x(), 0.000001);
  EXPECT_NEAR(0, testPoints[0].y(), 0.000001);
  EXPECT_NEAR(0, testPoints[0].z(), 0.000001);
  EXPECT_NEAR(2, testPoints[3].x(), 0.000001);
  EXPECT_NEAR(2, testPoints[3].y(), 0.000001);
  EXPECT_NEAR(0, testPoints[3].z(), 0.000001);

  testPoints = map.transformation()*map.referencePoints();
  EXPECT_NEAR(1, testPoints[0].x(), 0.000001);
  EXPECT_NEAR(0, testPoints[0].y(), 0.000001);
  EXPECT_NEAR(2, testPoints[0].z(), 0.000001);
  EXPECT_NEAR(3, testPoints[3].x(), 0.000001);
  EXPECT_NEAR(-2, testPoints[3].y(), 0.000001);
  EXPECT_NEAR(2, testPoints[3].z(), 0.000001);

}