void computeIntersection(const std::string& wkt1,
	                         const std::string& wkt2,
	                         int expectedIntersectionNum,
	                         const std::vector<Coordinate>& intPt,
	                         double distanceTolerance)
                // throws ParseException
        {
		GeomPtr g1(reader.read(wkt1));
		GeomPtr g2(reader.read(wkt2));

		LineString* l1ptr = dynamic_cast<LineString*>(g1.get());
		LineString* l2ptr = dynamic_cast<LineString*>(g2.get());

		ensure(0 != l1ptr);
		ensure(0 != l2ptr);

		LineString& l1 = *l1ptr;
		LineString& l2 = *l2ptr;

	        std::vector<Coordinate> pt;
		pt.push_back(l1.getCoordinateN(0));
		pt.push_back(l1.getCoordinateN(1));
		pt.push_back(l2.getCoordinateN(0));
		pt.push_back(l2.getCoordinateN(1));

		computeIntersection(pt, expectedIntersectionNum,
		                    intPt, distanceTolerance);
        }
예제 #2
0
파일: vplStroke.cpp 프로젝트: msahlen/vpl
    void Stroker::miterJoiner(Stroker* stroker,
                              const Vector& point,
                              const Vector& beforeNormal,
                              const Vector& afterNormal)
    {
        Vector realPoint = point;
        Vector after = afterNormal;
        Vector before = beforeNormal;

        stroker->inverseScale_.transform(after);
        stroker->inverseScale_.transform(before);
        stroker->inverseScale_.transform(realPoint);

        DynamicArray<float>* outer = &stroker->outerPoints_;
        DynamicArray<float>* inner = &stroker->innerPoints_;

        Winding winding = stroker->determineWinding(before,after);

        if(winding == cCounterclockwise)
        {
            swap(outer,inner);
            before.invert();
            after.invert();
        }

        // Undo perpendiculate
        Vector prevDir(-before.y_,before.x_);
        Vector dir(-after.y_,after.x_);
        Vector intersection;

        dir.invert();

        bool intersectionExists = computeIntersection(realPoint + before,
                                                      realPoint + after,
                                                      prevDir,dir,
                                                      intersection);

        if(intersectionExists)
        {
            float angle = computeAngle(dir,prevDir);
            float limit = 1/sin(angle/2);
           
            if(limit > stroker->miterLimit_)
            {
                stroker->bevelJoiner(stroker,point,beforeNormal,afterNormal);
                return;
            }

            stroker->scale_.transform(intersection);
            stroker->scale_.transform(after);

            stroker->addPoint(outer,intersection);
            stroker->addPoint(outer,point + after);
            
            stroker->innerJoiner(inner,point,after);
        }
        else
            stroker->bevelJoiner(stroker,point,beforeNormal,afterNormal);

    }
	void object::test<2>()
	{         
                computeIntersection(
                                "LINESTRING (588743.626135934 4518924.610969561, 588732.2822865889 4518925.4314047815)",
                                "LINESTRING (588739.1191384895 4518927.235700594, 588731.7854614238 4518924.578370095)",
                                1,
                                "POINT (588733.8306132929 4518925.319423238)",
                                0);
	}
	void object::test<1>()
	{         
                computeIntersection(
                                "LINESTRING (588750.7429703881 4518950.493668233, 588748.2060409798 4518933.9452804085)",
                                "LINESTRING (588745.824857241 4518940.742239175, 588748.2060437313 4518933.9452791475)",
                                1,
                                "POINT (588748.2060416829 4518933.945284994)",
                                0);
	}
예제 #5
0
void SkeletonSketcher::jointSkeleton(osgViewer::View* view, const osgGA::GUIEventAdapter& ea)
{
  QMutexLocker locker(&mutex_);

  osg::Vec3 position = computeIntersection(view, ea, false);
  if (position.isNaN())
    return;

  current_path_->push_back(position);
  if (current_path_->size() == 2)
  {
    boost::SkeletonGraph& skeleton_graph = *skeleton_graph_;
    size_t skeleton_size = boost::num_vertices(skeleton_graph);

    double min_distance_1 = std::numeric_limits<double>::max();
    double min_distance_2 = std::numeric_limits<double>::max();
    size_t min_idx_1 = 0;
    size_t min_idx_2 = 0;
    for (size_t i = 0; i < skeleton_size; ++ i)
    {
      double distance_1 = (skeleton_graph[i]-current_path_->at(0)).length2();
      double distance_2 = (skeleton_graph[i]-current_path_->at(1)).length2();

      if (min_distance_1 > distance_1)
      {
        min_distance_1 = distance_1;
        min_idx_1 = i;
      }
      if (min_distance_2 > distance_2)
      {
        min_distance_2 = distance_2;
        min_idx_2 = i;
      }
    }

    boost::add_edge(min_idx_1, min_idx_2, skeleton_graph);

    current_path_->clear();
  }

  //if (current_path_->size() == 2)
  //{
  //  boost::SkeletonGraph& skeleton_graph = *skeleton_graph_;
  //  boost::add_vertex(current_path_->at(0), skeleton_graph);
  //  boost::add_vertex(current_path_->at(1), skeleton_graph);

  //  boost::add_edge(boost::num_vertices(skeleton_graph)-1, boost::num_vertices(skeleton_graph)-2, skeleton_graph);

  //  current_path_->clear();
  //}

  expire();

  return;
}
	void object::test<4>()
	{         
	   std::vector<Coordinate> intPt;
	   intPt.push_back(Coordinate(4348437.0557510145, 5552597.375203926));
		
                computeIntersection(
                                "LINESTRING (4348433.262114629 5552595.478385733, 4348440.849387404 5552599.272022122 )",
                                "LINESTRING (4348433.26211463  5552595.47838573,  4348440.8493874   5552599.27202212  )",
                                1,
                                intPt, 0);
	}
	void object::test<3>()
	{         
	   std::vector<Coordinate> intPt;
	   intPt.push_back(Coordinate(2089426.5233462777, 1180182.3877339689));
	   intPt.push_back(Coordinate(2085646.6891757075, 1195618.7333999649));
		
           computeIntersection(
                                "LINESTRING ( 2089426.5233462777 1180182.3877339689, 2085646.6891757075 1195618.7333999649 )",
                                "LINESTRING ( 1889281.8148903656 1997547.0560044837, 2259977.3672235999 483675.17050843034 )",
                                2,
                                intPt, 0);
	}
	void object::test<5>()
	{         
	   std::vector<Coordinate> pt;
	   pt.push_back(Coordinate(4348433.262114629, 5552595.478385733));
	   pt.push_back(Coordinate(4348440.849387404, 5552599.272022122));
	   pt.push_back(Coordinate(4348433.26211463,  5552595.47838573));
	   pt.push_back(Coordinate(4348440.8493874,   5552599.27202212));

	   std::vector<Coordinate> intPt;
	   intPt.push_back(Coordinate(4348437.0557510145, 5552597.375203926));
		
	   computeIntersection( pt, 1, intPt, 0);
	}
예제 #9
0
파일: main.c 프로젝트: dronus/Schlizzer
// compute intersection of a triangle with a z plane
// the triangle vertices must be ordered in z 
Segment computeSegment(Triangle& t, float z)
{
	Vertex** vs=t.vertices;
	
	// two vertices to return
	Segment segment;
	
	segment.neighbours[0]=NULL;
	segment.neighbours[1]=NULL;
	segment.orderIndex=-1;

	// triangle vertices are always ordered by z
	assert(vs[0]->z<=vs[1]->z);
	assert(vs[1]->z<=vs[2]->z);	

	// ensure the triangles are correctly assigned to the layers
	assert(z>=vs[0]->z);
	assert(z<=vs[2]->z);

	// so we just need to check the second vertex to decide which edges
	// get intersected.	
	if(z<vs[1]->z){
		segment.vertices[0]=computeIntersection(*vs[0],*vs[1],z);
		segment.vertices[1]=computeIntersection(*vs[0],*vs[2],z);
	}else{
		segment.vertices[0]=computeIntersection(*vs[1],*vs[2],z);
		segment.vertices[1]=computeIntersection(*vs[0],*vs[2],z);
	}

	Vertex n=t.normal;
	n.z=0; 	        // project normal to z plane
	n=normalize(n); // renormalize z
	segment.normal=n;	
	
	return segment;
}
예제 #10
0
bool Object::intersects(Ray const & ray, Intersection * intersection) {
  // We first move the ray to object space before computing the intersection
  Ray localRay(ray.from - this->position, ray.direction);

  if(this->hasRotation) {
    localRay.from = this->rotationMatrix * localRay.from;
    // No need to normalize because the rotation matrix already is
    localRay.direction = this->rotationMatrix * localRay.direction;
  }

  bool hasIntersection = computeIntersection(localRay, intersection);

  // Move back to world coordinates
  if(intersection != NULL) {
    if(this->hasRotation) {
      intersection->position = (this->rotationMatrixT * intersection->position);
      intersection->normal = (this->rotationMatrixT * intersection->normal);
    }
    intersection->position += this->position;
  }

  return hasIntersection;
}
	void computeIntersection(const std::string& wkt1,
	                         const std::string& wkt2,
	                         int expectedIntersectionNum,
	                         const std::string& expectedWKT,
	                         double distanceTolerance)
                //throws ParseException
        {
		GeomPtr g1(reader.read(wkt1));
		GeomPtr g2(reader.read(wkt2));

		LineString* l1ptr = dynamic_cast<LineString*>(g1.get());
		LineString* l2ptr = dynamic_cast<LineString*>(g2.get());

		ensure(0 != l1ptr);
		ensure(0 != l2ptr);

		LineString& l1 = *l1ptr;
		LineString& l2 = *l2ptr;

	        std::vector<Coordinate> pt;
		pt.push_back(l1.getCoordinateN(0));
		pt.push_back(l1.getCoordinateN(1));
		pt.push_back(l2.getCoordinateN(0));
		pt.push_back(l2.getCoordinateN(1));

                GeomPtr g(reader.read(expectedWKT));

		std::auto_ptr<CoordinateSequence> cs ( g->getCoordinates() );

	        std::vector<Coordinate> intPt;
		for (size_t i=0; i<cs->size(); ++i)
			intPt.push_back(cs->getAt(i));

                computeIntersection(pt, expectedIntersectionNum,
		                    intPt, distanceTolerance);
        }
IGL_INLINE void igl::copyleft::boolean::mesh_boolean_cork(
  const Eigen::PlainObjectBase<DerivedVA > & VA,
  const Eigen::PlainObjectBase<DerivedFA > & FA,
  const Eigen::PlainObjectBase<DerivedVB > & VB,
  const Eigen::PlainObjectBase<DerivedFB > & FB,
  const MeshBooleanType & type,
  Eigen::PlainObjectBase<DerivedVC > & VC,
  Eigen::PlainObjectBase<DerivedFC > & FC)
{
  CorkTriMesh A,B,C;
  // pointer to output so it's easy to redirect on degenerate cases
  CorkTriMesh *ret = &C;
  to_cork_mesh(VA,FA,A);
  to_cork_mesh(VB,FB,B);
  switch(type)
  {
    case MESH_BOOLEAN_TYPE_UNION:
      if(A.n_triangles == 0)
      {
        ret = &B;
      }else if(B.n_triangles == 0)
      {
        ret = &A;
      }else
      {
        computeUnion(A,B,ret);
      }
      break;
    case MESH_BOOLEAN_TYPE_INTERSECT:
      if(A.n_triangles == 0 || B.n_triangles == 0)
      {
        ret->n_triangles = 0;
        ret->n_vertices = 0;
      }else
      {
        computeIntersection(A,B,ret);
      }
      break;
    case MESH_BOOLEAN_TYPE_MINUS:
      if(A.n_triangles == 0)
      {
        ret->n_triangles = 0;
        ret->n_vertices = 0;
      }else if(B.n_triangles == 0)
      {
        ret = &A;
      }else
      {
        computeDifference(A,B,ret);
      }
      break;
    case MESH_BOOLEAN_TYPE_XOR:
      if(A.n_triangles == 0)
      {
        ret = &B;
      }else if(B.n_triangles == 0)
      {
        ret = &A;
      }else
      {
        computeSymmetricDifference(A,B,&C);
      }
      break;
    case MESH_BOOLEAN_TYPE_RESOLVE:
      resolveIntersections(A,B,&C);
      break;
    default:
      assert(false && "Unknown type");
      return;
  }
  from_cork_mesh(*ret,VC,FC);
  freeCorkTriMesh(&A);
  freeCorkTriMesh(&B);
  freeCorkTriMesh(&C);
}
예제 #13
0
void ValueRange::computeIntersection (ValueRangeAccess dst, const ConstValueRangeAccess& a, const ConstValueRangeAccess& b)
{
	DE_ASSERT(dst.getType() == a.getType() && dst.getType() == b.getType());

	if (a.getType().isStruct())
	{
		int numMembers = (int)a.getType().getMembers().size();
		for (int ndx = 0; ndx < numMembers; ndx++)
			computeIntersection(dst.member(ndx), a.member(ndx), b.member(ndx));
	}
	else if (a.getType().isArray())
	{
		int numElements = (int)a.getType().getNumElements();
		for (int ndx = 0; ndx < numElements; ndx++)
			computeIntersection(dst.arrayElement(ndx), a.arrayElement(ndx), b.arrayElement(ndx));
	}
	else
	{
		int numElements = (int)a.getType().getNumElements();
		switch (a.getType().getBaseType())
		{
			case VariableType::TYPE_FLOAT:
				for (int ndx = 0; ndx < numElements; ndx++)
				{
					float aMin = a.component(ndx).getMin().asFloat();
					float aMax = a.component(ndx).getMax().asFloat();
					float bMin = b.component(ndx).getMin().asFloat();
					float bMax = b.component(ndx).getMax().asFloat();

					dst.component(ndx).getMin() = de::max(aMin, bMin);
					dst.component(ndx).getMax() = de::min(aMax, bMax);
				}
				break;

			case VariableType::TYPE_INT:
			case VariableType::TYPE_SAMPLER_2D:
			case VariableType::TYPE_SAMPLER_CUBE:
				for (int ndx = 0; ndx < numElements; ndx++)
				{
					int aMin = a.component(ndx).getMin().asInt();
					int aMax = a.component(ndx).getMax().asInt();
					int bMin = b.component(ndx).getMin().asInt();
					int bMax = b.component(ndx).getMax().asInt();

					dst.component(ndx).getMin() = de::max(aMin, bMin);
					dst.component(ndx).getMax() = de::min(aMax, bMax);
				}
				break;

			case VariableType::TYPE_BOOL:
				for (int ndx = 0; ndx < numElements; ndx++)
				{
					bool aMin = a.component(ndx).getMin().asBool();
					bool aMax = a.component(ndx).getMax().asBool();
					bool bMin = b.component(ndx).getMin().asBool();
					bool bMax = b.component(ndx).getMax().asBool();

					dst.component(ndx).getMin() = aMin || bMin;
					dst.component(ndx).getMax() = aMax && bMax;
				}
				break;

			default:
				DE_ASSERT(DE_FALSE);
		}
	}
}
예제 #14
0
void ValueRange::computeIntersection (ValueRange& dst, const ConstValueRangeAccess& a, const ConstValueRangeAccess& b)
{
	computeIntersection(dst.asAccess(), a, b);
}