Пример #1
0
void gts_surface_suma (GtsSurface * s, 
                        float **NodeListp, int *N_Nodep, int *NodeDimp, 
                        int **FaceSetListp, int *N_FaceSetp, int *FaceSetDimp)
{
  guint n = 0;
  gpointer data[2];
  GtsSurfaceStats stats;
  float *NodeList = NULL;
  int *FaceSetList = NULL;
  
  g_return_if_fail (s != NULL);

  

  gts_surface_stats (s, &stats);
  
  /* get the stats  */
  if (debug) {
   fprintf (stderr,
	   "gts_surface_suma: Number of vertices %u\n",
	   stats.edges_per_vertex.n);
   fprintf (stderr,
	   "gts_surface_suma: Number of triangles %u\n",
	   stats.n_faces);
  }
  NodeList = (float *)calloc( stats.edges_per_vertex.n * 3, sizeof(float));
  FaceSetList = (int *)calloc(stats.n_faces * 3, sizeof(int)); 
  
  if (!NodeList || !FaceSetList) { 
   fprintf(stderr,"Critical Error gts_surface_suma: Could not allocate.\n");
   g_return_if_fail (0);
  }
  
  /* get the nodes */
  n = 0;
  data[0] = (gpointer)NodeList;
  data[1] = (gpointer)&n;
  gts_surface_foreach_vertex (s, (GtsFunc) vertex_load, data);
  
  /* get the facesets */
  n = 0;
  data[0] = (gpointer)FaceSetList;
  data[1] = (gpointer)&n; 
  gts_surface_foreach_face (s, (GtsFunc) face_load , data);
  
  /* don't know what these two are for, 
  assuming it has to do with the ->reserved business in vertex_load and face_load above */
  gts_surface_foreach_vertex (s, (GtsFunc) gts_object_reset_reserved, NULL);  
  gts_surface_foreach_face (s, (GtsFunc) gts_object_reset_reserved, NULL);  
  
  /* set results */
  *N_FaceSetp = (int)stats.n_faces;
  *N_Nodep = (int)stats.edges_per_vertex.n;
  *NodeListp = NodeList;
  *FaceSetListp = FaceSetList;
  *NodeDimp = 3;
  *FaceSetDimp = 3;
  return;
}
Пример #2
0
void gts_triangulate_convex_polygon_test()
{
	int i; 
	gdouble v[5][3] = {
		{0.0, 0.0, 1.0},
		{0.0, 2.0, 2.0},
		{2.0, 3.0, 1.0},
		{4.0, 1.0, 1.0},
		{2.0, 0.0, 0.0}
	};
	
	GtsEdgePool *pool = gts_edge_pool_new(gts_edge_pool_class());
	GtsVertex *vtx[5]; 
	GCList *polygon = NULL;
	GCList *wired = NULL; 
	GtsSurfaceStats sstats; 
	
	for (i = 0; i < 5; ++i) {
		vtx[i] = gts_vertex_new(gts_vertex_class(), v[i][0],v[i][1],v[i][2]); 
		polygon = g_clist_append(polygon, vtx[i]);
	}
	polygon = g_clist_append(polygon, vtx[0]);
	polygon = g_clist_append(polygon, vtx[1]);
	
	wired = g_clist_append(wired, vtx[0]);
	wired = g_clist_append(wired, vtx[1]);
	wired = g_clist_append(wired, vtx[0]);
	wired = g_clist_append(wired, vtx[2]);
	
	
		
	GtsSurface *s = gts_surface_new(gts_surface_class(), 
					gts_face_class(), 
					gts_edge_class(),
					gts_vertex_class());
	
	gts_triangulate_convex_polygon(s, pool, wired);
	g_assert(gts_surface_face_number(s) == 0);

	gts_triangulate_convex_polygon(s, pool, polygon);  

	g_message("gts_surface_face_number = %d", gts_surface_face_number(s));  
	g_assert(gts_surface_face_number(s) == 3);
	gts_surface_stats(s, &sstats);
	
	g_assert(sstats.n_incompatible_faces == 0); 
	g_assert(sstats.n_duplicate_faces == 0);	
	g_assert(sstats.n_duplicate_edges == 0);	
	g_assert(sstats.n_boundary_edges == 5);	
	g_assert(sstats.n_non_manifold_edges == 0);	
	g_assert(sstats.faces_per_edge.min == 1); 
	g_assert(sstats.faces_per_edge.max == 2);	
	
	g_message("Triangulate convex polygon PASS"); 

	gts_object_destroy(GTS_OBJECT(pool)); 
}