自学教程：C++ AddVertex函数代码示例

// adds an arc to the given center, start point, pen width, and angle (degrees).bool VRML_LAYER::AppendArc( double aCenterX, double aCenterY, double aRadius,                            double aStartAngle, double aAngle, int aContourID ){    if( aContourID < 0 || (unsigned int) aContourID >= contours.size() )    {        error = "AppendArc(): invalid contour (out of range)";        return false;    }    aAngle = aAngle / 180.0 * M_PI;    aStartAngle = aStartAngle / 180.0 * M_PI;    int nsides = calcNSides( aRadius, aAngle );    double da = aAngle / nsides;    bool fail = false;    if( aAngle > 0 )    {        aAngle += aStartAngle;        for( double ang = aStartAngle; ang < aAngle; ang += da )            fail |= !AddVertex( aContourID, aCenterX + aRadius * cos( ang ),                                aCenterY + aRadius * sin( ang ) );    }    else    {        aAngle += aStartAngle;        for( double ang = aStartAngle; ang > aAngle; ang += da )            fail |= !AddVertex( aContourID, aCenterX + aRadius * cos( ang ),                                aCenterY + aRadius * sin( ang ) );    }    return !fail;}

bool add(int which_poly, int x, int y) {     bool res = false;    vertex *v;     v = (vertex*)malloc(sizeof(vertex));     v->x = x;     v->y = y;    v->alpha = 0.;    v->internal = false;    v->linkTag = 0;    if (which_poly == 1)     { 	v->next = s_size+1 ;	res = AddVertex(s,s_size,v);    }     else if (which_poly == 2)     { 	v->next = c_size+1 ;	res = AddVertex(c,c_size,v);    }     else {	printf("%d is not a valid polygon index./n",which_poly);	exit(1);    }    free(v);    return res;}

Mesh::Mesh(Program &program)	: Drawable(program)	, vbuffer(-1)	, nbuffer(-1)	, tbuffer(-1)	, fbuffer(-1)	, texture(NULL){	AddVertex(-1.0, -1.0, -1.0);	AddVertex(-1.0, 1.0, -1.0);	AddVertex(1.0, 1.0, -1.0);	AddVertex(1.0, -1.0, -1.0);	AddTexcoord(0, 1);	AddTexcoord(0, 0);	AddTexcoord(1, 0);	AddTexcoord(1, 1);	AddColour(1.0, 0.0, 0.0);	AddColour(0.0, 1.0, 0.0);	AddColour(0.0, 0.0, 1.0);	AddColour(1.0, 1.0, 1.0);	AddNormal(0.0, 0.0, 1.0);	AddNormal(0.0, 0.0, 1.0);	AddNormal(0.0, 0.0, 1.0);	AddNormal(0.0, 0.0, 1.0);	AddFace(0, 1, 2);	AddFace(2, 3, 0);	InitBuffers();}

	void CDX9Renderer::Box(const rect& r, cr_float angle, point hotspot, const color& c)	{		// No support for textured lines		SetTexture(NULL);		quad q((r - hotspot).rotate_to_quad(angle, r.topleft()));		BeginBatch(batch_linestrip);		CBatch_Draw* draw_op = reinterpret_cast<CBatch_Draw*>(batch.back());		D3DCOLOR color = c.getD3DCOLOR();		// 4 vertices and use 5th index to repeat first vertex closing the strip as a box		AddVertex(color, q.tl, 0.0f, 0.0f);		AddVertex(color, q.tr, 0.0f, 0.0f);		AddVertex(color, q.br, 0.0f, 0.0f);		AddVertex(color, q.bl, 0.0f, 0.0f);		unsigned short index = draw_op->vertex_count;		AddIndex(index);		AddIndex(index + 1);		AddIndex(index + 2);		AddIndex(index + 3);		AddIndex(index);		draw_op->vertex_count += 4;		draw_op->index_count += 5;	}

void Mesh::ReadVertexData(FILE *fp, int num, bool have_normals, bool have_tex){	double n[3];	double v[3];	double t[2];	char buf[1024];	for(int i = 0; i < num; i++)	{		fgets(buf, 1024, fp);		if(have_normals && have_tex)		{			sscanf(buf, "%lf %lf %lf %lf %lf %lf %lf %lf", v, v+1, v+2, n, n+1, n+2, t, t+1);			AddVertex(v);			AddNormal(n);			AddTexcoord(t);		}		else if(have_normals)		{			sscanf(buf, "%lf %lf %lf %lf %lf %lf", v, v+1, v+2, n, n+1, n+2);			AddVertex(v);			AddNormal(n);		}		else if(have_tex)		{			sscanf(buf, "%lf %lf %lf %lf %lf", v, v+1, v+2, t, t+1);			AddVertex(v);			AddTexcoord(t);		}		else		{			sscanf(buf, "%lf %lf %lf", v, v+1, v+2);			AddVertex(v);		}	}}

void CircleEvaluator::Evaluate() {    // Add the vertexes specified    double x;    double y;    double pi = 3.14159265;    // We parametrically evaluate the circle    // x = sin(t)    // y = cos(t)    // t goes from 0 to 2pi    // 0 degrees = 0rad, 90 degrees = pi/2rad, etc.    double startRad = m_StartArcDegrees / 180 * pi;    double endRad = m_EndArcDegrees / 180 * pi;    double radPerPoint = m_DegreesPerPoint / 180 * pi;    if (startRad > endRad)        endRad += 2*pi;    double currentRad = startRad;    do {        x = m_Radius*sin(currentRad) + m_XOrigin;        y = m_Radius*cos(currentRad) + m_YOrigin;        AddVertex(x,y);        currentRad += radPerPoint;    } while (currentRad < endRad);    x = m_Radius*sin(endRad) + m_XOrigin;    y = m_Radius*cos(endRad) + m_YOrigin;    AddVertex(x, y);}

bool CFuzzyMembershipFunction::InitTriangle (long x1, long x2, long x3){  if ((x1 < x2) && (x2 < x3))  {    CFuzzyElement FE;    DeleteVertices();    // Left vertex.    FE.SetValue(x1);    FE.SetMembership(0.0);    AddVertex(FE);    // Peak vertex.    FE.SetValue(x2);    FE.SetMembership(1.0);    AddVertex(FE);    // Right vertex.    FE.SetValue(x3);    FE.SetMembership(0.0);    AddVertex(FE);    return true;  }  return false;}

/** * @function BuildManifold */void HP2D::BuildManifold( Vertex* _v0 ) {		Vertex* va;    std::vector<Vertex*> S;	std::vector<Vertex*> B;	printf("Build Manifold /n");	AddVertex( _v0 );		EnQueue( _v0 );	while( mQ.size() != 0 ) {		va = DeQueue();		S = Successors( va );		for( unsigned int i = 0; i < S.size(); ++i ) {			AddVertex( S[i] );			AddEdge( va, S[i] );			if( S[i]->GetDist() < DIST_MAX ) {						EnQueue( S[i] );			}			B = GetAdjacent2( va );			for( unsigned j = 0; j < B.size(); ++j ) {				if( CheckPosNeighbors( B[j], S[i] ) == true ) {					AddEdge( S[i], B[j] );				}			}		}			}}

    /** Add triangle to connectivity information */    int32 AddTriangle( const FVector &a, const FVector &b, const FVector &c )    {        // Map vertices        int32 VertexA = AddVertex( a );        int32 VertexB = AddVertex( b );        int32 VertexC = AddVertex( c );        // Make sure triangle is not degenerated        if ( VertexA!=VertexB && VertexB!=VertexC && VertexC!=VertexA )        {            // Setup connectivity info            int32 TriangleIndex = Triangles.Num();            Vertices[ VertexA ].AddTriangleLink( TriangleIndex );            Vertices[ VertexB ].AddTriangleLink( TriangleIndex );            Vertices[ VertexC ].AddTriangleLink( TriangleIndex );            // Create triangle            new ( Triangles ) FMeshConnectivityTriangle( VertexA, VertexB, VertexC );            return TriangleIndex;        }        else        {            // Degenerated triangle            return INDEX_NONE;        }    }

// adds a circle the existing list; if 'hole' is true the contour is// a hole. Returns true if OK.bool VRML_LAYER::AddCircle( double x, double y, double rad, int csides, bool hole ){    int pad = NewContour();    if( pad < 0 )    {        error = "AddCircle(): failed to add a contour";        return false;    }    if( csides < 6 )        csides = CalcNSides( rad, maxdev );    // even numbers give prettier results    if( csides & 1 )        csides += 1;    double da = M_PI * 2.0 / csides;    bool fail = false;    if( hole )    {        for( double angle = 0; angle < M_PI * 2; angle += da )            fail |= !AddVertex( pad, x + rad * cos( angle ), y - rad * sin( angle ) );    }    else    {        for( double angle = 0; angle < M_PI * 2; angle += da )            fail |= !AddVertex( pad, x + rad * cos( angle ), y + rad * sin( angle ) );    }    return !fail;}

int AdjList::AddEdge(const Vertex& from, const Vertex& to, int cost){	if(!hasVertex(from))	{		AddVertex(from);	}		if(!hasVertex(to))	{		AddVertex(to);	}		for(auto& vinfo: m_vinfoList)	{		if(from == vinfo.m_vertex)		{			for(const auto& edge: vinfo.m_edges)			{				if(edge.m_to == to)				{					return -1; // already added				}			}			vinfo.m_edges.push_back({to, cost});			return GRAPH_OK;		}	}	return GRAPH_ERROR_VERTEX_NOT_FOUND;}

void Scene::Extrude (int n, float* x, float* y, float depth, 		     const Trafo& P, const ColorB* color){  int n1 = n-1, n2 = 2*n-2;       // add front and back polygonal with n vertices  // the back polygonal has reverse orientation  Facet &front = AddFacet(n),        &back  = AddFacet(n);      if (color) {    front.SetColor(*color);    back.SetColor(*color);  }  // create vertices and link them to facets  int i;  for (i = 0; i < n; i++) {     front(i) = &AddVertex( P * Vertex(x[i],y[i],0.0) );    back(i)  = &AddVertex( P * Vertex(x[n1-i],y[n1-i],-depth) );    if (color) {      front[i].SetColor(*color);      back[i].SetColor(*color);    }  }  // create n facets for the sides and link the vertices  for (i = 0; i < n; i++) {     Facet &side = AddFacet(4, front(i), back(n1-i),			   back((n2-i)%n), front((i+1)%n) );    if (color) side.SetColor(*color);  }}

void kexCpuVertList::AddLine(float x1, float y1, float z1,                          float x2, float y2, float z2,                          byte r, byte g, byte b, byte a) {        *(roverIndices++) = vertexCount; indiceCount++;    AddVertex(x1, y1, z1, 0, 0, r, g, b, a);    *(roverIndices++) = vertexCount; indiceCount++;    AddVertex(x2, y2, z2, 0, 0, r, g, b, a);}

void CSimpleUGraph< ObjT, Compare >::AddEdge( const ObjT &oV1, const ObjT & oV2 ){  typename boost::graph_traits<Graph>::edge_descriptor e;  bool bAdded;  AddVertex( oV1 );   // should lazy these two - check to see if vertex is there first  AddVertex( oV2 );  Vertex u = oDataToVertexMap[ oV1 ];  Vertex v = oDataToVertexMap[ oV2 ];  boost::tie( e, bAdded ) = add_edge( v, u, oBoostGraph );    // add edge}

/// <summary>/// Helper function to create a face for the base octahedron./// </summary>/// <param name="mesh">Mesh</param>/// <param name="p1">Vertex 1.</param>/// <param name="p2">Vertex 2.</param>/// <param name="p3">Vertex 3.</param>void AddBaseTriangle(D3DVECTOR& p1, D3DVECTOR& p2, D3DVECTOR& p3){    AddVertex(p1.x, p1.y, p1.z, p1.x, p1.y, p1.z, 0, 0);    AddVertex(p2.x, p2.y, p2.z, p2.x, p2.y, p2.z, 0, 0);    AddVertex(p3.x, p3.y, p3.z, p3.x, p3.y, p3.z, 0, 0);        AddIndex(nextIndex++);    AddIndex(nextIndex++);    AddIndex(nextIndex++);}

/* Read network from the training file */void ReadData(){  FILE *fin;  char name_v1[MAX_STRING], name_v2[MAX_STRING], str[2 * MAX_STRING + 10000];  int vid;  double weight;  fin = fopen(network_file, "rb");  if (fin == NULL)  {    printf("ERROR: network file not found!/n");    exit(1);  }  num_edges = 0;  while (fgets(str, sizeof(str), fin)) num_edges++;  fclose(fin);  printf("Number of edges: %lld          /n", num_edges);  edge_source_id = (int *)malloc(num_edges*sizeof(int));  edge_target_id = (int *)malloc(num_edges*sizeof(int));  edge_weight = (double *)malloc(num_edges*sizeof(double));  if (edge_source_id == NULL || edge_target_id == NULL || edge_weight == NULL)  {    printf("Error: memory allocation failed!/n");    exit(1);  }  fin = fopen(network_file, "rb");  num_vertices = 0;  for (int k = 0; k != num_edges; k++)  {    fscanf(fin, "%s %s %lf", name_v1, name_v2, &weight);    if (k % 10000 == 0)    {      printf("Reading edges: %.3lf%%%c", k / (double)(num_edges + 1) * 100, 13);      fflush(stdout);    }    vid = SearchHashTable(name_v1);    if (vid == -1) vid = AddVertex(name_v1);    vertex[vid].degree += weight;    edge_source_id[k] = vid;    vid = SearchHashTable(name_v2);    if (vid == -1) vid = AddVertex(name_v2);    vertex[vid].degree += weight;    edge_target_id[k] = vid;    edge_weight[k] = weight;  }  fclose(fin);  printf("Number of vertices: %d          /n", num_vertices);}

void LoadMeshInstanceIntoToy(CConversionScene* pScene, CConversionMeshInstance* pMeshInstance, const Matrix4x4& mParentTransformations){	if (!pMeshInstance->IsVisible())		return;	CConversionMesh* pMesh = pMeshInstance->GetMesh();	for (size_t m = 0; m < pScene->GetNumMaterials(); m++)	{		for (size_t j = 0; j < pMesh->GetNumFaces(); j++)		{			size_t k;			CConversionFace* pFace = pMesh->GetFace(j);			if (pFace->m == ~0)				continue;			CConversionMaterial* pMaterial = NULL;			CConversionMaterialMap* pConversionMaterialMap = pMeshInstance->GetMappedMaterial(pFace->m);			if (!pConversionMaterialMap)				continue;			if (!pConversionMaterialMap->IsVisible())				continue;			if (pConversionMaterialMap->m_iMaterial != m)				continue;			while (g_asTextures.size() <= pConversionMaterialMap->m_iMaterial)			{				g_asTextures.push_back(pScene->GetMaterial(pConversionMaterialMap->m_iMaterial)->GetDiffuseTexture());				g_aaflData.push_back();			}			size_t iMaterial = pConversionMaterialMap->m_iMaterial;			CConversionVertex* pVertex0 = pFace->GetVertex(0);			for (k = 2; k < pFace->GetNumVertices(); k++)			{				CConversionVertex* pVertex1 = pFace->GetVertex(k-1);				CConversionVertex* pVertex2 = pFace->GetVertex(k);				AddVertex(iMaterial, mParentTransformations * pMesh->GetVertex(pVertex0->v), pMesh->GetUV(pVertex0->vu));				AddVertex(iMaterial, mParentTransformations * pMesh->GetVertex(pVertex1->v), pMesh->GetUV(pVertex1->vu));				AddVertex(iMaterial, mParentTransformations * pMesh->GetVertex(pVertex2->v), pMesh->GetUV(pVertex2->vu));			}		}	}}

//-----------------------------------------------------------------------------bool SimpleMesh::AddFace(const std::vector<Vector3<float> > &verts){  unsigned int ind1, ind2, ind3;  AddVertex(verts.at(0), ind1);  AddVertex(verts.at(1), ind2);  AddVertex(verts.at(2), ind3);  Face tri(ind1, ind2, ind3);  mFaces.push_back(tri);  // Compute and assign a normal  mFaces.back().normal = FaceNormal(mFaces.size() - 1);  return true;}

bool CFuzzyMembershipFunction::Read (std::istream& stream){  // Check the fuzzy membership function type type  EFileTypes FileType;  stream.read((char*)&FileType, sizeof(FileType));  if (FileType != fFuzzyMembershipFunction)  {    return false;  }  // Read in number of characters in the name.  unsigned short NumCharsInName;  stream.read((char*)&NumCharsInName, sizeof(NumCharsInName));  // Read in name one character at a time.  m_Name.erase();  for (unsigned short s = 0; s < NumCharsInName; s++)  {    m_Name += stream.get();  }  // Read in Tnorm.  stream.read((char*)&m_Tnorm,sizeof(m_Tnorm));  // Read in Tconorm.  stream.read((char*)&m_Tconorm,sizeof(m_Tconorm));  // Read in number of CFuzzyElements in the membership function.  long NumVertices;  stream.read((char*)&NumVertices, sizeof(NumVertices));  // Read in each CFuzzyElement.  CFuzzyElement FE;  for (long v = 0; v < NumVertices; v++)  {    // Read in value.     long Value;    stream.read((char*)&Value, sizeof(Value));    FE.SetValue(Value);    // Read in membership.    double Membership;    stream.read((char*)&Membership, sizeof(Membership));    FE.SetMembership(Membership);    // Read in Tnorm.     ETnormOperations Tnorm;    stream.read((char*)&Tnorm,sizeof(Tnorm));    FE.SetTnorm(Tnorm);    // Read in Tconorm.    ETconormOperations Tconorm;    stream.read((char*)&Tconorm,sizeof(Tconorm));    FE.SetTconorm(Tconorm);    AddVertex(FE);  }  return true;}

int LoadSU2Vertices(FILE *FilHdl, Mesh *Msh){	int iVer, d, ref;	double crd[3], bufDbl;	char str[1024];		rewind(FilHdl);		Msh->NbrVer = GetSU2KeywordValue (FilHdl, "NPOIN=");		if ( Msh->NbrVer > Msh->MaxNbrVer ) {		printf("  ## ERROR: LoadSU2Vertices: INCONSISTENT NUMBER OF VERTICES./n");		return 0;	}	  for (iVer=1; iVer<=Msh->NbrVer; iVer++) {		    crd[2] = 0;		    for (d=0; d<Msh->Dim; d++) {      fscanf(FilHdl, "%lf", &bufDbl);      crd[d] = bufDbl;    }        fscanf(FilHdl, "%d", &ref);    fgets (str, sizeof str, FilHdl);    		AddVertex(Msh, iVer, crd);  }		return 1;}

void ProgressiveMesh(std::vector<float3> &vert, std::vector<tridata> &tri,                     std::vector<int> &map, std::vector<int> &permutation){	AddVertex(vert);  // put input data into our data structures	AddFaces(tri);	ComputeAllEdgeCollapseCosts(); // cache all edge collapse costs	permutation.resize(vertices.size());  // allocate space	map.resize(vertices.size());          // allocate space	// reduce the object down to nothing:	while (vertices.size() > 0) {		// get the next vertex to collapse		Vertex *mn = MinimumCostEdge();		// keep track of this vertex, i.e. the collapse ordering		permutation[mn->id] = vertices.size() - 1;		// keep track of vertex to which we collapse to		map[vertices.size() - 1] = (mn->collapse) ? mn->collapse->id : -1;		// Collapse this edge		Collapse(mn,mn->collapse);	}	// reorder the map Array based on the collapse ordering	for (unsigned int i = 0; i<map.size(); i++) {		map[i] = (map[i]==-1)?0:permutation[map[i]];	}	// The caller of this function should reorder their vertices	// according to the returned "permutation".}

void Model::AddCylinder(float radius, float height){	const double M_PI = 3.14159265358979;	int round = 6;	uint16_t startIndex = GetNextVertexIndex();	for(int i = 0; i <= round; i++)	{		double sangle = i * M_PI * 2. / round;		for (int t = -1; t <= 1; t += 2)		{			Vector3f v = Vector3f(cos(sangle) * radius, sin(sangle) * radius, t * height);			AddVertex(Vertex(v, Color(127, 0, 127, 255), float(i), float(t), Vector3f(cos(sangle), sin(sangle), 0)));		}	}	// Renumber indices	for (uint16_t s = 0; s < round; s++)	{		uint16_t s1 = s + 1;		auto get = [&](uint16_t s, uint16_t t){			return s * 2 + t + startIndex;		};		AddTriangle(get(s, 0),			get(s, 1),			get(s1, 0));		AddTriangle(get(s1, 0),			get(s, 1),			get(s1, 1));	}}

int main(){	scanf("%d", &ivc);	for (int i = 0; i < ivc; i++)	{		int x, y;		scanf("%d%d", &x, &y);		AddVertex(x, y);	}	scanf("%d", &iec);	for (int i = 0; i < iec; i++)	{		int u, v;		scanf("%d%d", &u, &v);		AddEdge(u, v);		AddEdge(v, u);	}	scanf("%d%d", &s, &t);	Bellman_Ford();	printf("%.2lf", V[t].shortest);	return 0;}