Exemplo n.º 1
0
//
// Refine a grid into a TIN_TILgE with error < e
//
void refineTile(TIN_TILE *tt, double e, short delaunay, short useNodata) {  
  BOOL complete;    // is maxE < e
  complete = 0;
  TRIANGLE *t1, *t2, *t3, *s;

  int refineCount = 0;

  // Read points for initial two triangles into a file
  initTilePoints(tt,e,useNodata);
  
  // While there still is a triangle with max error > e
  while(PQ_extractMin(tt->pq, &s)){

    // Triangles should no longer be marked for deletion since they
    // are being deleted from the PQ
    if(s->p1p2 == NULL && s->p1p3 == NULL && s->p2p3 == NULL){
      printf(strcat("skipping deleted triangle: err=",ELEV_TYPE_PRINT_CHAR),
	     s->maxErrorValue);
      fflush(stdout);
      assert(0);
      removeTri(s);
    }

    assert(s); 
    refineCount++;

    // malloc the point with max error as it will become a corner
    R_POINT* maxError = (R_POINT*)malloc(sizeof(R_POINT));
    assert(maxError);	
    maxError->x = s->maxE->x;
    maxError->y = s->maxE->y;
    maxError->z = s->maxE->z;

    // Add point to the correct point pointer array
    assert(tt->bPointsCount < tt->ncols && 
	   tt->rPointsCount < tt->nrows && 
	   tt->bPointsCount < (tt->ncols * tt->nrows)-(tt->ncols + tt->nrows));
    if(maxError->x == (tt->iOffset + tt->nrows-1) ){
      tt->bPoints[tt->bPointsCount]=maxError;
      tt->bPointsCount++;
    }
    else if(maxError->y == (tt->jOffset + tt->ncols-1) ){
      tt->rPoints[tt->rPointsCount]=maxError;
      tt->rPointsCount++;
    }
    else{
      tt->points[tt->pointsCount]=maxError;
      tt->pointsCount++;
    }

    // Debug - print the point being added
#ifdef REFINE_DEBUG 
    {
      TRIANGLE *snext;
      R_POINT err = findError(s->maxE->x, s->maxE->y, s->maxE->z, s); 
      printf("Point (%6d,%6d,%6d) error=%10ld \t", 
	     s->maxE->x, s->maxE->y, s->maxE->z, err );
      printTriangleCoords(s);
      fflush(stdout);

      if(err != s->maxErrorValue){
	printf("Died err= %ld maxE= %ld \n",err,s->maxErrorValue);
	exit(1);
      }

      PQ_min(tt->pq, &snext); 
      assert(s->maxErrorValue >= snext->maxErrorValue); 
    }
#endif
    // Check for collinear points. We make the valid assumption that
    // MaxE cannot be collinear with > 1 tri
    int area12,area13,area23;

    area12 = areaSign(s->p1, s->p2, maxError);
    area13 = areaSign(s->p1, maxError, s->p3);
    area23 = areaSign(maxError, s->p2, s->p3);

    // If p1 p2 is collinear with MaxE
    if (!area12){
      fixCollinear(s->p1,s->p2,s->p3,s,e,maxError,tt,delaunay);
      tt->numTris++;
    }
    else if (!area13){
      fixCollinear(s->p1,s->p3,s->p2,s,e,maxError,tt,delaunay);
      tt->numTris++;
    }
    else if (!area23){
      fixCollinear(s->p2,s->p3,s->p1,s,e,maxError,tt,delaunay);
      tt->numTris++;
    }
    else {
      // add three new triangles
      t1 = addTri(tt,s->p1, s->p2, maxError,s->p1p2,NULL,NULL);
      t2 = addTri(tt,s->p1, maxError, s->p3,t1,s->p1p3,NULL);
      t3 = addTri(tt,maxError, s->p2, s->p3,t1,t2,s->p2p3);
      DEBUG{triangleCheck(s,t1,t2,t3);}

      tt->numTris += 2;

      // create poinlists from the original tri (this will yeild the max error)
      distrPoints(t1,t2,t3,s,NULL,e,tt);
      DEBUG{checkPointList(t1);checkPointList(t2);checkPointList(t3);}  

      // Enforce delaunay on three new edges of the new triangles if
      // specified
      if(delaunay){
	// we enforce on the edge that does not have maxE as an
	// endpoint, so the 4th argument to enforceDelaunay should
	// always be the maxE point to s for that particular tri
	enforceDelaunay(t1,t1->p1,t1->p2,t1->p3,e,tt);
	enforceDelaunay(t2,t2->p1,t2->p3,t2->p2,e,tt);
	enforceDelaunay(t3,t3->p2,t3->p3,t3->p1,e,tt);
      }
    }
    
    // remove original tri
    removeTri(s);
    //DEBUG{printTin(tt);}

    extern int displayValid;
    displayValid = 0;

  } 
  s = tt->t;
 
  // The number of points added is equal to the number of refine loops
  tt->numPoints += refineCount;
  
  /* The number of points should be equal to the sum of all points
     arrays (one center and possible 4 boundary). Since the arrays
     have overlap of corner points we subtract the overlaps */
  int pts = 0;
  pts = tt->pointsCount + tt->rPointsCount + tt->bPointsCount - 1;
  if(tt->top != NULL)
    pts += tt->top->bPointsCount - 2;
  if(tt->left != NULL)
    pts += tt->left->rPointsCount - 2;
  //assert(tt->numPoints == pts); fix

  // Sort the point arrays for future use and binary searching
  qsort(tt->rPoints,tt->rPointsCount,sizeof(R_POINT*),(void *)QS_compPoints);
  qsort(tt->bPoints,tt->bPointsCount,sizeof(R_POINT*),(void *)QS_compPoints);
  qsort(tt->points,tt->pointsCount,sizeof(R_POINT*),(void *)QS_compPoints);

  // We are done with the pq
  PQ_free(tt->pq);

}
Exemplo n.º 2
0
/* Delete the min element; same as PQ_extractMin, but ignore the value extracted;
   return value: 1 if exists a min, 0 if not  */
int  PQ_deleteMin(PQueue* pq) {
    
  assert(pq && pq->elements); 
  elemType dummy;
  return PQ_extractMin(pq, &dummy);
}