Пример #1
0
/*----------------------------------------------------------------------*
 |  get point view (private)                                 mwgee 10/05|
 *----------------------------------------------------------------------*/
void MOERTEL::Overlap::PointView(std::vector<Teuchos::RCP<MOERTEL::Point> >& points)
{
    // allocate vector of ptrs
    points.resize(SizePointPolygon());

    // get the point views
    int count=0;
    std::map<int,Teuchos::RCP<MOERTEL::Point> >::iterator pcurr;
    for (pcurr=p_.begin(); pcurr != p_.end(); ++pcurr)
    {
        points[count] = pcurr->second;
        ++count;
    }
    if (count != SizePointPolygon())
    {
        std::stringstream oss;
        oss << "***ERR*** MOERTEL::Overlap::PointView:\n"
            << "***ERR*** number of point wrong\n"
            << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n";
        throw ReportError(oss);
    }
    return;
}
Пример #2
0
/*----------------------------------------------------------------------*
 |  make a triangulization of a polygon (private)             mwgee 10/05|
 *----------------------------------------------------------------------*/
bool MOERTEL::Overlap::Triangulation()
{
  // we have a polygon that is in clockwise order at this moment

  // if more than 3 points, find a center point
  int np = SizePointPolygon();
  if (np<3)
  {
	std::cout << "***ERR*** MOERTEL::Overlap::Triangulization:\n"
         << "***ERR*** # point in polygon < 3 ... very strange!!!\n"
         << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n";
    exit(EXIT_FAILURE);
  }
  if (np>3) // we have to add a center point
  {
    double xi[2];
	std::vector<Teuchos::RCP<MOERTEL::Point> > points; PointView(points);

#if 1 // compute center point xi as centroid
    Centroid(xi,points,np);    
    //std::cout << "Centroid xi : " << xi[0] << " / " << xi[1] << endl; fflush(stdout);
#endif
    
#if 0 // compute center point as nodal avergage
    xi[0] = xi[1] = 0.0;
    for (int i=0; i<np; ++i)
    {
      const double* pxi = points[i]->Xi();
      xi[0] += pxi[0];
      xi[1] += pxi[1];
    }
    xi[0] /= np;
    xi[1] /= np;
    //std::cout << "Nodal    xi : " << xi[0] << " / " << xi[1] << endl << endl; fflush(stdout);
#endif
    
    // create a point -1 as center point and add it to the polygon
    AddPointtoPolygon(-1,xi);
    points.clear();
  } // if (np>3)
  
  np = SizePointPolygon();
  std::vector<Teuchos::RCP<MOERTEL::Point> >  points; PointView(points);

  // create a MOERTEL::Node for every point
  int dof[3]; dof[0] = dof[1] = dof[2] = -1;
  
  // find real world coords for all points
  // find real world normal for all points
  // note that the polygon is in slave segment parameter space and is
  // completely contained in the slave segment. we can therefore use
  // slave segment values to interpolate polgon point values
  for (int i=0; i<np; ++i)
  {
    double x[3]; x[0] = x[1] = x[2] = 0.0;
    double n[3]; n[0] = n[1] = n[2] = 0.0;
    double val[20];
    sseg_.EvaluateFunction(0,points[i]->Xi(),val,sseg_.Nnode(),NULL);
    MOERTEL::Node** snodes = sseg_.Nodes();
    for (int j=0; j<sseg_.Nnode(); ++j)
      for (int k=0; k<3; ++k)
      {
        x[k] += val[j]*snodes[j]->X()[k];
        n[k] += val[j]*snodes[j]->N()[k];
      }
    const double length = MOERTEL::length(n,3);
    for (int j=0; j<3; ++j) n[j] /= length;
    // create a node with this coords and normal;
    MOERTEL::Node* node = new MOERTEL::Node(points[i]->Id(),x,3,dof,false,OutLevel());
    node->SetN(n);
    // set node in point
    points[i]->SetNode(node);
#if 0
	std::cout << *points[i];
#endif
  }  

  // find projection values for all points in polygon on mseg
  {
    double mxi[2];
	double gap;
    MOERTEL::Projector projector(inter_.IsOneDimensional(),OutLevel());
    for (int i=0; i<np; ++i)
    {
	  Teuchos::RCP<MOERTEL::Node> node = points[i]->Node();
      projector.ProjectNodetoSegment_NodalNormal(*node,mseg_,mxi,gap);
      // create a projected node and set it in node
      MOERTEL::ProjectedNode* pnode = new MOERTEL::ProjectedNode(*node,mxi,&mseg_);
      node->SetProjectedNode(pnode);
	  node->SetGap(gap);
#if 0
	  std::cout << "-------------------------------------------------------\n";
      if (mseg_.Nnode()==3)
      {
        if (mxi[0]<=1. && mxi[1]<=abs(1.-mxi[0]) && mxi[0]>=0. && mxi[1]>=0.)
          std::cout << "OVERLAP: point " << points[i]->Id() << " is in mseg, mxi " << mxi[0] << " / " << mxi[1] << endl;
        else
          std::cout << "OVERLAP: point " << points[i]->Id() << " is NOT in mseg, mxi " << mxi[0] << " / " << mxi[1] << endl;
      }
      else if (mseg_.Nnode()==4)
      {
        if (mxi[0]<=1.001 && mxi[0]>=-1.001 && mxi[1]<=1.001 && mxi[1]>=-1.001)
          std::cout << "OVERLAP: point " << points[i]->Id() << " is in mseg, mxi " << mxi[0] << " / " << mxi[1] << endl;
        else
          std::cout << "OVERLAP: point " << points[i]->Id() << " is NOT in mseg, mxi " << mxi[0] << " / " << mxi[1] << endl;
      }
      else
      {
		std::cout << "***ERR*** MOERTEL::Overlap::Triangulization:\n"
             << "***ERR*** # nodes " << mseg_.Nnode() << " of master segment is unknown\n"
             << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n";
        exit(EXIT_FAILURE);
      }
	  std::cout << "-------------------------------------------------------\n";
#endif

    }
  }

  // if we plan to interpolate function values at the gaussian points we need the
  // function values at the points
  if (exactvalues_==false)
  {
    // every point has 3 values of the 3 shape functions of the elements:
    // max 4 values from function 0 from sseg
    // max 4 values from function 1 from sseg
    // max 4 values from function 0 from mseg
    for (int i=0; i<np; ++i)
    {
      double val[20];
      int nmval = mseg_.Nnode();
      int nsval = sseg_.Nnode();
      // evaluate function 0 from sseg
      sseg_.EvaluateFunction(0,points[i]->Xi(),val,nsval,NULL);
      points[i]->StoreFunctionValues(0,val,nsval);
      // evaluate function 1 from sseg
      sseg_.EvaluateFunction(1,points[i]->Xi(),val,nsval,NULL);
      points[i]->StoreFunctionValues(1,val,nsval);
      // evaluate function 0 from mseg
      mseg_.EvaluateFunction(0,points[i]->Node()->GetProjectedNode()->Xi(),val,nmval,NULL);
      points[i]->StoreFunctionValues(2,val,nmval);
    }
  }
  
  // create the triangle elements from polygon with centerpoint
  // In case of np==3, there is no centerpoint
  if (np>3)
  {
    // the polygon is in clockwise order, center point is points[0] and has
    // id = -1
    if (points[0]->Id() != -1)
    {
	  std::cout << "***ERR*** MOERTEL::Overlap::Triangulization:\n"
           << "***ERR*** points[0]->Id() is not -1\n"
           << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n";
      exit(EXIT_FAILURE);
    }
    int nodeid[3];
    MOERTEL::Segment_BiLinearTri* tmp;
    MOERTEL::Function_LinearTri* func = new Function_LinearTri(OutLevel());
    for (int i=2; i<np; ++i)
    {
      // there are np-1 triangles
      // triangle ids go from 0 to np-2
      // a triangle is defined by nodes 0, i, i-1
      // *this class takes ownership of triangle
      nodeid[0]   = points[0]->Id();
      nodeid[1]   = points[i]->Id();
      nodeid[2]   = points[i-1]->Id();
      tmp = new MOERTEL::Segment_BiLinearTri(i-2,3,nodeid,OutLevel());
      // set a linear shape function to this triangle
      tmp->SetFunction(0,func);
      // add triangle to the *this class
      AddSegment(tmp->Id(),tmp);
    }
    // add the last triangle defined by nodes 0, 1, np-1 separately
    // *this class takes ownership of triangle
    nodeid[0]   = points[0]->Id();
    nodeid[1]   = points[1]->Id();
    nodeid[2]   = points[np-1]->Id();
    tmp = new MOERTEL::Segment_BiLinearTri(np-2,3,nodeid,OutLevel());
    // set a linear shape function to this triangle
    tmp->SetFunction(0,func);
    // add triangle to the *this class
    AddSegment(tmp->Id(),tmp);
    if (func) delete func; func = NULL;
  }
  else if (np==3) // single triangle without centerpoint
  {
    int nodeid[3];
    MOERTEL::Segment_BiLinearTri* tmp;
    MOERTEL::Function_LinearTri* func = new Function_LinearTri(OutLevel());
    nodeid[0] = points[0]->Id();
    nodeid[1] = points[2]->Id();
    nodeid[2] = points[1]->Id();
    // *this class takes ownership of triangle
    tmp = new MOERTEL::Segment_BiLinearTri(0,3,nodeid,OutLevel());
    // set a linear shape function to this triangle
    tmp->SetFunction(0,func);
    // add triangle the *this class
    AddSegment(tmp->Id(),tmp);
    if (func) delete func; func = NULL;
  }
  else
  {
	std::cout << "***ERR*** MOERTEL::Overlap::Triangulization:\n"
         << "***ERR*** # point in polygon < 3 ... very strange!!!\n"
         << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n";
    exit(EXIT_FAILURE);
  }
  
  // create ptr topology between triangle and nodes in points
  std::vector<MOERTEL::Node*> nodes(np);
  for (int i=0; i<np; ++i) nodes[i] = points[i]->Node().get();
  
  // loop segments and set ptr to nodes in them
  std::map<int,Teuchos::RCP<MOERTEL::Segment> >::iterator curr;
  for (curr=s_.begin(); curr != s_.end(); ++curr)
    curr->second->GetPtrstoNodes(nodes);
  
  nodes.clear();
  
  points.clear();
  
  return true;
}
Пример #3
0
/*----------------------------------------------------------------------*
 |  perform clipping algorithm (private)                     mwgee 10/05|
 *----------------------------------------------------------------------*/
bool MOERTEL::Overlap::Clipelements()
{
  if (!havemxi_ || !havesxi_ || !havelines_ || !havesxim_ || !havelinem_)
  {
	std::cout << "***ERR*** MOERTEL::Overlap::Clipelements:\n"
         << "***ERR*** initialization of Overlap class missing\n"
         << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n";
    exit(EXIT_FAILURE);
  }
  
  const int nmnode = mseg_.Nnode();
  const int nsnode = sseg_.Nnode();
  
  // put all mseg nodes in polygon
  for (int i=0; i<nmnode; ++i)
    AddPointtoPolygon(100+i,&mline_[i][0]);
  
  //for (int i=0; i<nmnode; ++i)
  //  std::cout << "mline_[" << i << "][0] " << mline_[i][0] << " mline_[" << i << "][1] " << mline_[i][1] 
  //       << " mline_[" << i << "][2] " << mline_[i][2] << " mline_[" << i << "][3] " << mline_[i][3] << endl;
  //===========================================================================

  // loop edges of slave segment and clip the master edges
  // add all intersection points that can be found
  for (int clipedge=0; clipedge<nsnode; ++clipedge)
  {
    // point on that clip edge (dim 2)
    double* PE = &sline_[clipedge][0];
    // the outward normal to the clip edge (dim 2)
    double* N = &sn_[clipedge][0];

    // loop edges of master segment and clip them against the clip edge
    // add all intersections
    for (int medge=0; medge<nmnode; ++medge)
    {
      bool ok;
      // start point of medge with id 100+medge
      double* P0 = &mline_[medge][0];
      //int id0 = 100+medge;
      
      // end point of medge has id 100+(medge+1 < 3)
      double* P1 = &mline_[medge][2];
      
      // find intersection between medge and clipedge
      // if there's an intersection, put it in the polygon
      // the id is 10*clipedge+medge
      double xi[2];
      ok = Clip_Intersect(N,PE,P0,P1,xi);
      if (ok)
      {
        //std::cout << "OVERLAP Clipelements: adding intersection point " << 10*clipedge+medge << endl;
        AddPointtoPolygon(10*clipedge+medge,xi);
      }
    } // for (int medge=0; medge<3; ++medge)
  } // for (int clipedge=0; clipedge<3; ++clipedge)
  
  //===========================================================================

  // loop all clipedges and clip all points incl intersections 
  // that are in the polygon
  // throw away all points that are not inside
  {
    int np = SizePointPolygon();
    
	std::vector<Teuchos::RCP<MOERTEL::Point> > point;
    PointView(point);
    int p;
    for (p=0; p<np; ++p)
    {
      bool ok = true;
      //std::cout << "OVERLAP Clipelements: now clipping point " << point[p]->Id() << endl;
      const double* P = point[p]->Xi();
      for (int clipedge=0; clipedge<nsnode; ++clipedge)
      {
        // point on that clip edge (dim 2)
        double* PE = &sline_[clipedge][0];
        // the outward normal to the clip edge (dim 2)
        double* N = &sn_[clipedge][0];
        
        // clip point P against this edge
        ok = Clip_TestPoint(N,PE,P,1.0e-10);
        // leave point in
        if (ok) continue;
        // remove this point
        else
        {
          ok = false;
          break;
        }
      } // for (int clipedge=0; clipedge<3; ++clipedge)
      
      // if not found inside, remove point
      if (!ok)
      {
        //std::cout << "OVERLAP Clipelements: removing point " << point[p]->Id() << endl;
        RemovePointfromPolygon(point[p]->Id(),P);
      }
            
    } // for (int p=0; p<np; ++p)
    point.clear();
  }

  //===========================================================================
  // loop all slave nodes and clip against master element.
  // put those slave nodes that are inside master element into polygon
  // Note that this works in master segment coords and the node that is put in
  // is put in with slave segment coords as the polygon is completely in
  // slave segment coords
  // master point have ids 100,101,102
  // slave points have ids 1000,1001,1002
  // edge intersections have ids sedge*10+medge
  
  // try only to put slave points in if the polygon is not empty
  int np = SizePointPolygon();
  if (np)
  {
    for (int i=0; i<nsnode; ++i)
    {
      bool ok = true;
      // get the slave point in master coords
      double* P = sxim_[i];
      // loop master clip edges
      for (int clipedge=0; clipedge<nmnode; ++clipedge)
      {
        // point on master clipedge
        double* PE = &mlinem_[clipedge][0];
        // the outward normal to the clip edge (dim 2)
        double* N = &mn_[clipedge][0];
        
        // clip point P against this edge
        ok = Clip_TestPoint(N,PE,P,1.0e-5);
        // put point in
        if (ok) continue;
        else
        {
          ok = false;
          break;
        }
      } // for (int clipedge=0; clipedge<3; ++clipedge)
      // don't put point in
      if (!ok)
        continue;
      else
      {
        //std::cout << "OVERLAP Clipelements: inserting slave point " << 1000+i << " xi="
        //     << sxi_[i][0] << "/" << sxi_[i][1] << endl;
        AddPointtoPolygon(1000+i,sxi_[i]);
      }
    } // for (int i=0; i<3; ++i)
  }

  //===========================================================================
  //===========================================================================
  //===========================================================================
  
#if 0
  // make printout of the polygon so far
  {
    int np    = SizePointPolygon();
	std::vector<Teuchos::RCP<MOERTEL::Point> > point; PointView(point);
    for (int p=0; p<np; ++p)
    {
	  std::cout << "OVERLAP Clipelements: point " << setw(3) << point[p]->Id() 
           << " xi " << point[p]->Xi()[0] 
           << "/" << point[p]->Xi()[1] << endl;
    }
    point.clear();
  }
#endif

  //===========================================================================
  // count how many corner nodes of mseg are in and how many
  // intersections there are
  np = SizePointPolygon();

  //===========================================================================
  // if there are no points, there is still the chance that all slave points
  // are inside the master element
  if (!np)
  {
    for (int i=0; i<3; ++i)
    {
      bool ok = true;
      // get the slave point in master coords
      double* P = sxim_[i];
      
      for (int clipedge=0; clipedge<3; ++clipedge)
      {
        // point on master clipedge
        double* PE = &mlinem_[clipedge][0];
        // the outward normal to the clip edge (dim 2)
        double* N = &mn_[clipedge][0];
        
        // clip point P against this edge
        ok = Clip_TestPoint(N,PE,P,1.0e-5);
        // put point in
        if (ok) continue;
        else
        {
          ok = false;
          break;
        }
      } // for (int clipedge=0; clipedge<3; ++clipedge)
      // don't put point in
      if (!ok)
        continue;
      else
      {
        //std::cout << "OVERLAP Clipelements: inserting slave point " << 1000+i << " xi="
        //     << sxi_[i][0] << "/" << sxi_[i][1] << endl;
        AddPointtoPolygon(1000+i,sxi_[i]);
      }
      
    } // for (int i=0; i<3; ++i)
    
    //=========================================================================
    // check again how many points there are inside
    np = SizePointPolygon();
    if (np>2); // all slave points are in master segment, just continue
    else if (np && np <= 2)
    {
      if (inter_.OutLevel()>8)
        std::cout << "MOERTEL: ***WRN*** MOERTEL::Overlap::Clipelements:\n"
             << "MOERTEL: ***WRN*** " << np << " slave nodes seem to be in master segment but no overlap detected\n"
             << "MOERTEL: ***WRN*** file/line: " << __FILE__ << "/" << __LINE__ << "\n";
      return false;
    }
    else // with none or less then 3 points in we assume no overlap
      return false;
  }

  //===========================================================================
  // maybe its a good idea to collapse intersections with nodes (that are in)
  // that are really close to each other
  if (p_.size()>3)
    CollapsePoints(p_,1.0e-5);

#if 0
  // make printout of the polygon so far
  {
	std::cout << "--------------------------------------------\n";
    int np    = SizePointPolygon();
	std::vector<Teuchos::RCP<MOERTEL::Point> > point; PointView(point);
    for (int p=0; p<np; ++p)
    {
	  std::cout << "OVERLAP Clipelements: point " << setw(3) << point[p]->Id() 
           << " xi " << point[p]->Xi()[0] 
           << "/" << point[p]->Xi()[1] << endl;
    }
    point.clear();
  }
#endif

  //===========================================================================
  // check again
  np = SizePointPolygon();
  if (np && np<3)
  {
    if (OutLevel()>8)
      std::cout << "MOERTEL: ***WRN*** MOERTEL::Overlap::Clipelements:\n"
           << "MOERTEL: ***WRN*** " << np << " nodes in polygon but could not detect overlap\n"
           << "MOERTEL: ***WRN*** file/line: " << __FILE__ << "/" << __LINE__ << "\n";
    return false;
  }
  else if (!np)
    return false;

  //===========================================================================
  // finish the polygon
  ConvexHull(p_);  
  
  return true;
}
Пример #4
0
bool MOERTEL::Overlap::ClipelementsSH() {

  if (!havemxi_ || !havesxi_ || !havelines_ || !havesxim_ || !havelinem_){

			std::stringstream oss;
				oss << "***ERR*** MOERTEL::Overlap::Clipelements:\n"
					<< "***ERR*** initialization of Overlap class missing\n"
					<< "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n";
			throw ReportError(oss);

  }
  
  const int nmnode = mseg_.Nnode();
  const int nsnode = sseg_.Nnode();
  bool ok = true;
  double eps = 1.0e-10; // GAH EPSILON


  // I am reading http://cs.fit.edu/~wds/classes/graphics/Clip/clip/clip.html and 
  // http://en.wikipedia.org/wiki/Sutherland–Hodgman_algorithm as I write this code.

  // I assume that the master segment is convex. It should be if this is a mesh. Secondly, the
  // slave segment is a square in its parametric space -1 <= \xi <= 1 and -1 <= \eta <= 1. It need
  // only be convex.

  // For the Sutherland-Hodgman algorithm, the slave segment is used for the clip polygon.

  // Start with an input list of polygon vertices, in the slave coordinate system. Note that these points
  // are ordered around the polygon, as i is the line number of the boundaries of the master seg.

  std::vector<double> s_poly_xi, s_poly_eta, t_poly_xi, t_poly_eta;

  // Put all the corners of the master segment into the polygon

  for (int i=0; i<nmnode; ++i) { // loop over the corners of the master seg

	s_poly_xi.push_back(mline_[i][0]); 
	s_poly_eta.push_back(mline_[i][1]);

  }

  // Clip that poly against the slave poly one edge at a time

  for (int clipedge = 0; clipedge < nsnode; ++clipedge) {

	// point on that clip edge (dim 2)
	double* PE = &sline_[clipedge][0];

	// the outward normal to the clip edge (dim 2)
	double* N = &sn_[clipedge][0];

	ok = buildPoly(s_poly_xi, s_poly_eta, t_poly_xi, t_poly_eta, PE, N);

	if(!ok){

		// there is no intersection between polys. However, it is possible that the
		// slave poly is completely contained within the master
		
		break;

	}

	// The target vectors now become the source vectors
	
	s_poly_xi = t_poly_xi;
	s_poly_eta = t_poly_eta;

  } // for (int clipedge=0; clipedge<3; ++clipedge)

  if(ok){ // We have a target polygon

		double xi[2];

		// Compress the polygon by removing adjacent points less than epsilon apart

		for(unsigned int p = t_poly_xi.size() - 1; p >= 1; p--){

			xi[0] = t_poly_xi[p] - t_poly_xi[p - 1];
			xi[1] = t_poly_eta[p] - t_poly_eta[p - 1];

			double dist = MOERTEL::length(xi, 2);

			if(dist <= eps){ // remove the point p

				t_poly_xi.erase(t_poly_xi.begin() + p);
				t_poly_eta.erase(t_poly_eta.begin() + p);

			}
		}

		// Check the last point too

		if(t_poly_xi.size() >= 2){
		
			xi[0] = t_poly_xi[t_poly_xi.size() - 1] - t_poly_xi[0];
			xi[1] = t_poly_eta[t_poly_xi.size() - 1] - t_poly_eta[0];

			double dist = MOERTEL::length(xi, 2);

			if(dist <= eps){ // remove the point p

				t_poly_xi.erase(t_poly_xi.end() - 1);
				t_poly_eta.erase(t_poly_eta.end() - 1);

			}
		}

		// Do we still have a polygon? If not, just move on

		if(t_poly_xi.size() < 3){

			return false;

		}

		// Store it in the polygon

		for (unsigned int p = 0; p < t_poly_xi.size(); ++p) {

			xi[0] = t_poly_xi[p];
			xi[1] = t_poly_eta[p];

			AddPointtoPolygon(p, xi);

		}

#if 0
		// make printout of the polygon so far
		{
		int np    = SizePointPolygon();
		std::vector<Teuchos::RCP<MOERTEL::Point> > point; PointView(point);

		std::cout << "Master is in slave" << std::endl;

		for (int p=0; p<np; ++p) {

			std::cout << "OVERLAP Clipelements: point " << std::setw(3) << point[p]->Id()
						<< " xi " << point[p]->Xi()[0]
						<< "/" << point[p]->Xi()[1] << std::endl;
		}
		point.clear();
		}
#endif
  
		return true;

  }

  //===========================================================================

  // We come down here if there is no polygon from the above. This could mean that the slave segment is
  // completely inside the master segment.
  
	std::vector<int> s_node_id;

	for (int i=0; i<nsnode; ++i) {

		bool ok = true;

		// get the slave point in master coords
		double* P = sxim_[i];

		// loop master clip edges
		for (int clipedge=0; clipedge<nmnode; ++clipedge) {

			// point on master clipedge
			double* PE = &mlinem_[clipedge][0];

			// the outward normal to the clip edge (dim 2)
			double* N = &mn_[clipedge][0];
        
			// clip point P against this edge
			// GAH - EPSILON clip test point
			ok = Clip_TestPoint(N,PE,P,1.0e-5);

			// put point in
			if (ok) 
				continue;
			else {
				ok = false;
				break;
			}
		} // for (int clipedge=0; clipedge<3; ++clipedge)

		// We will be here, with ok == true only if the point is inside ALL clip edges

		// don't put point in
		if (!ok)
			continue;
		else { // Point is inside ALL clip edges

			s_node_id.push_back(i);
		}
	} // for (int i=0; i<3; ++i)

	if(s_node_id.size() < static_cast<unsigned int>(nsnode)){ // Slave poly does not lie within master either. 
															// There is no overlap. Move on.

/* The reasoning here is that zero of the master polygon was found in the slave (no nodes). If the slave is completely
 * within the master, then all 4 nodes need to cleanly show up inside the master. If they do not, chances are only
 * a corner or edge of the master is touched.
 */

		return false;

	}

	// Slave is completely in master. Put the slave in the polygon
	
	for(unsigned int i = 0; i < s_node_id.size(); i++){

		//std::cout << "OVERLAP Clipelements: inserting slave point " << 1000+i << " xi="
		//     << sxi_[i][0] << "/" << sxi_[i][1] << endl;
		AddPointtoPolygon(i,sxi_[i]);

	}

#if 0
		// make printout of the polygon so far
		{
		int np    = SizePointPolygon();
		std::vector<Teuchos::RCP<MOERTEL::Point> > point; PointView(point);

		std::cout << "Slave is in master" << std::endl;

		for (int p=0; p<np; ++p) {

			std::cout << "OVERLAP Clipelements: point " << std::setw(3) << point[p]->Id()
						<< " xi " << point[p]->Xi()[0]
						<< "/" << point[p]->Xi()[1] << std::endl;
		}
		point.clear();
		}
#endif

	return true;
}