Пример #1
0
void SoColorShape::storeTriangle(const SbVec3f&  point1, const SbVec3f&  point2, const SbVec3f&  point3, 
                                 const SbVec3f& normal1, const SbVec3f& normal2, const SbVec3f& normal3,
                                 const int& colorIndex1) 
{

   // liegt das Dreieck komplett draußen, wenn ja, nicht speichern!
   if (colorIndex1 != 0) {
      // Schwerpunkt und Position im Array bestimmen
      SbVec3f barycenter;
      float baryX, baryY, baryZ;
      barycenter = point1 - _offSet;
      barycenter += point2 - _offSet;
      barycenter += point3 - _offSet;

      // durch 3 weil bestehend aus 3 Vektoren
      barycenter = barycenter / 3.0;
      // durch HASH_PARTITION weil aufteilen 
      barycenter = barycenter / float(HASH_PARTITION);
      barycenter.getValue(baryX, baryY, baryZ);

      int arrayPosition;
      arrayPosition = ((int)fabs(baryX)) +
         ((int)fabs(baryY)) * _extentX + 
         ((int)fabs(baryZ)) * _extentX * _extentY;

      // Eckpunkte abspeichern und Indices besorgen
      const Vertex *vertex1, *vertex2, *vertex3;
      vertex1 = insertVertex(point1, normal1, colorIndex1, arrayPosition);
      vertex2 = insertVertex(point2, normal2, colorIndex1, arrayPosition);
      vertex3 = insertVertex(point3, normal3, colorIndex1, arrayPosition);

      // Kanten finden bzw. anlegen
      Edge *edge1, *edge2, *edge3;
      edge3 = generateEdge(vertex1, vertex2, arrayPosition);
      edge1 = generateEdge(vertex2, vertex3, arrayPosition);
      edge2 = generateEdge(vertex3, vertex1, arrayPosition);

      // Dreieck ablegen
      Triangle* tri = new Triangle;
      tri->vertex1 = vertex1;
      tri->vertex2 = vertex2;
      tri->vertex3 = vertex3;
      tri->edge1 = edge1;
      tri->edge2 = edge2;
      tri->edge3 = edge3;
      _triangleSet[arrayPosition].insert(tri);

      // Den Kanten die Dreiecke zuweisen
      if (edge1->triangle1 == 0) edge1->triangle1 = tri;
      else edge1->triangle2 = tri;
      if (edge2->triangle1 == 0) edge2->triangle1 = tri;
      else edge2->triangle2 = tri;
      if (edge3->triangle1 == 0) edge3->triangle1 = tri;
      else edge3->triangle2 = tri;
   }
}
void insertPhraseVertices(
  HSentenceVertices & topLeft,
  HSentenceVertices & topRight,
  HSentenceVertices & bottomLeft,
  HSentenceVertices & bottomRight,
  int startF, int startE, int endF, int endE)
{

  insertVertex(topLeft, startF, startE);
  insertVertex(topRight, endF, startE);
  insertVertex(bottomLeft, startF, endE);
  insertVertex(bottomRight, endF, endE);
}
Пример #3
0
// inserts a new edge joining u to v
// pre: 1<=u<=getOrder(), 1<=v<=getOrder()
void addEdge(Graph G, int u, int v){
    if( 1>u || u>getOrder(G) ){
        printf("Graph Error: vertex u is not in |V(G)|");
        exit(1);
    }
    if( 1>v || v>getOrder(G) ){
        printf("Graph Error: vertex v is not in |V(G)|");
        exit(1);
    }

    insertVertex(G->adj[u], v);
    insertVertex(G->adj[v], u);
    G->size++;
}
Пример #4
0
void OptimizedPolyList::vertex(const Point3F& p,
                               const Point3F& normal,
                               const Point2F& uv0,
                               const Point2F& uv1)
{
   mIndexList.push_back(insertVertex(p, normal, uv0, uv1));
}
Пример #5
0
Graph::Graph(const vector<double> &V, const vector<double> &E) {
	for(unsigned v = 0; v < V.size(); v += 2)
		insertVertex(V[v], V[v+1], v/2);

	for(unsigned e = 0; e < E.size(); e += 2)
		insertEdge(E[e], E[e+1]);
}
Пример #6
0
void My3DViewer::setAztec(MyGLWidget* m){
	aztec=m;
	connect(splitQuad, SIGNAL(clicked()), aztec, SLOT(splitQuad()));
	connect(deleteVertex, SIGNAL(clicked()), aztec, SLOT(deleteVertex()));
	connect(insertEdge, SIGNAL(clicked()), aztec, SLOT(insertEdge()));
	connect(incrementSharpness, SIGNAL(clicked()), aztec, SLOT(incSharpness()));
	connect(decrementSharpness, SIGNAL(clicked()), aztec, SLOT(decSharpness()));
	connect(forcePlanarity, SIGNAL(clicked()), aztec, SLOT(toggleForcePlanarity()));
	connect(insertVertex, SIGNAL(clicked()), aztec, SLOT(insertVertex()));
	connect(smooth, SIGNAL(clicked()), aztec, SLOT(smooth()));
	connect(extrude, SIGNAL(clicked()), aztec, SLOT(extrude2()));

	connect(faceButton, SIGNAL(clicked()), aztec, SLOT(enterFaceMode()));
	connect(objectButton, SIGNAL(clicked()), aztec, SLOT(enterObjectMode()));
	connect(vertexButton, SIGNAL(clicked()), aztec, SLOT(enterVertexMode()));
	connect(edgeButton, SIGNAL(clicked()), aztec, SLOT(enterEdgeMode()));
	connect(cpButton, SIGNAL(clicked()), aztec, SLOT(enterCPMode()));

	connect(snapToFace, SIGNAL(clicked()), aztec, SLOT(snapToFace()));
	connect(snapToEdge, SIGNAL(clicked()), aztec, SLOT(snapToEdge()));
	connect(snapToVertex, SIGNAL(clicked()), aztec, SLOT(snapToVertex()));

	//Connect mouse move events
	connect(aztec, SIGNAL(sendMouseEvent(QMouseEvent*)), this, SLOT(moveEvent(QMouseEvent*)));

		//errors
	connect(aztec, SIGNAL(error(char*)), this, SLOT(throwError(char*)));
	
}
Пример #7
0
void AdjecencyList::fileRead(string fileName) {
    ifstream file;
    string currentLine;

    file.open(fileName.c_str()); //open the file

    assert(file.is_open()); //make sure file is open

    //insert all vertices and edges into matrix
    while(!file.eof()) {
        vector<string> data;
        getline(file, currentLine);

        //split contents up into a vector, splitting them on a space
        stringstream str;
        str << currentLine;
        int counter = 0;
        int edgeWeight = 0;
        while (getline(str, currentLine, ' ')) {
            counter++;
            if (counter != 3) {
                data.push_back(currentLine);
            }
            else {
                edgeWeight = atoi(currentLine.c_str());
            }
        }

        /**
        now that we have the data, we need to insert it into the matrix & reference
        */

        //add all new vertices, it will do nothing if the vertex already exists
        for (int i = 0; i < data.size(); i++) {
            GraphNode node;
            node.value = data.at(i);
            insertVertex(node);
        }

        //also insert the first node's connections (edges)
        for (int i = 1; i < data.size(); i++) {

            //loop will not even be entered if there is only 1 vertex input, (a point)
            GraphNode headNode;
            headNode.value = data.at(0);

            GraphNode connectionNode;
            connectionNode.value = data.at(i);
            insertEdge(headNode, connectionNode, edgeWeight);
        }
    }
    file.close();
} //read a graph from a file, and assemble it into a list
main()
{
	int choice,u,origin,destin;
	
	while(1)
	{
		
		printf("1.Insert a Vertex\n");
		printf("2.Insert an Edge\n");
		printf("3.Delete a Vertex\n");
		printf("4.Delete an Edge\n");
		printf("5.Display\n");
		printf("6.Exit\n");
		printf("Enter your choice : ");
		scanf("%d",&choice);
		system("cls");
			
		switch(choice)
		{
		 case 1:
			printf("Enter a vertex to be inserted : ");
			scanf("%d",&u);
			insertVertex(u);
			break;
		 case 2:
			printf("Enter an Edge to be inserted : ");
			scanf("%d %d",&origin,&destin);
			insertEdge(origin,destin);
			break;
		 case 3:
			printf("Enter a vertex to be deleted : ");
			scanf("%d",&u);
			/*This function deletes all edges coming to this vertex*/
			deleteIncomingEdges(u);
			/*This function deletes the vertex from the vertex list*/
			deleteVertex(u);
			break;
		 case 4:
			printf("Enter an edge to be deleted : ");
			scanf("%d %d",&origin,&destin);
			deleteEdge(origin,destin);
			break;
		 case 5:
			display();
			break;
		 case 6:
			exit(1);
		 default:
			printf("Wrong choice\n");
			break;
		 }/*End of switch*/
	}/*End of while*/
}/*End of main()*/
Пример #9
0
/**
 * Constructor to create a random, connected graph.
 * @param isWeighted - specifies whether the graph is a weighted graph or not
 * @param numVertices - the number of vertices the graph will have
 * @param seed - a random seed to create the graph with
 */
Graph::Graph(bool isWeighted, int numVertices, unsigned long seed)
    : graph(VertexMap()),
      vertexLabels(VertexLabelMap()),
      random(Random(seed)),
      weighted(isWeighted),
      vertexCounter(0)
{
    if (numVertices < 2)
        error("numVertices too low");

    vector<Vertex> vertices;
    for (int i = 0; i < numVertices; ++i) {
        Vertex next = insertVertex();
        vertices.push_back(next);
    }

    // make sure all vertices are connected
    random.shuffle(vertices);
    Vertex cur = vertices[0];
    for (size_t i = 0; i < vertices.size() - 1; ++i) {
        Vertex next = vertices[i + 1];
        insertEdge(cur, next);
        if (weighted) {
            int weight = random.nextInt();
            setEdgeWeight(cur, next, weight);
        }
        cur = next;
    }

    // keep the graph from being overpopulated with edges,
    //  while still maintaining a little randomness
    int numFailures = 0;
    int idx = 0;
    random.shuffle(vertices);
    while (numFailures < 2) {
        if (!insertEdge(vertices[idx], vertices[idx + 1])) {
            ++numFailures;
        } else {
            // if insertEdge() succeeded...
            if (isWeighted)
                setEdgeWeight(vertices[idx], vertices[idx + 1],
                              random.nextInt());
            ++idx;
            if (idx >= numVertices - 2) {
                idx = 0;
                random.shuffle(vertices);
            }
        }
    }
}
Пример #10
0
int main()
{
	int i, j;
	printf("Enter the number of vertices in the graph :\n");
	scanf("%d", &V);
	vertex *graph = createGraph(V);
	insertEdge(1, 2, graph);
	insertEdge(2, 3, graph);
	printf("Number of edges in the graph :  %d\n", E);
	printList(graph);
	insertVertex(&graph);
	insertEdge(4, 1, graph);
	printf("Number of edges in the graph :  %d\n", E);
	printList(graph);
}
Пример #11
0
void Graph::addArc(Edge* e) {
	// Cria uma lista de ponteiro para Edge e pega o vertice fonte
	vector<Edge*>* list;
	Vertex *v = e->getSource();
	
	// Se o vertice não está na lista de adjacencia, insere-o
	if(edges->find(v) == edges->end()) {
		insertVertex(v);
	}
	
	list = edges->find(v)->second;
	
	// Insere o Edge no local correto
	list->push_back(e);
}
Пример #12
0
//--------------------------------------------------------------------------
//Summary:
//		insert vertex and relative edge
//Parameter:
//		_vertexList[in]: vertex list and create edge
//------------------------------------------------------------------------
void CLandsideGraph::insertVertexAndEdge( LandsideTrafficGraphVertexList& _vertexList )
{
	int iSourceIndex,iDestIndex;
	double weight;
	LandsideTrafficGraphEdge edgeS2D;

	//////////////////////////////////////////////////////////////////////////
	// because is undirect graph, so shall add two edge between two vertex
	LandsideTrafficGraphVertex vertexS = _vertexList[0];
	LandsideTrafficGraphVertex vertexD = _vertexList[1];
	weight = GetWeight(vertexS,vertexD);	
	{
		insertVertex( vertexS, iSourceIndex );
		insertVertex( vertexD, iDestIndex );

		edgeS2D.SetSourceSegment(iSourceIndex);
		edgeS2D.SetDestSegment(iDestIndex);
		edgeS2D.SetWeight(weight);
		insertEdge( edgeS2D );
	}

	for( unsigned i=1; i<_vertexList.size()-1; i++ )
	{
		vertexS = vertexD;
		vertexD = _vertexList[i+1];
		weight = GetWeight(vertexS,vertexD);	

		iSourceIndex = iDestIndex;
		insertVertex( vertexD, iDestIndex );

		edgeS2D.SetSourceSegment(iSourceIndex);
		edgeS2D.SetDestSegment(iDestIndex);
		edgeS2D.SetWeight(weight);
		insertEdge( edgeS2D );
	}
}
Пример #13
0
Graph::Graph(const vector<const Intersection> &isecns, const vector<const Road> &roads) {
	for(unsigned i = 0; i < isecns.size(); i++)
		insertVertex(isecns[i][0], isecns[i][1], i);

	for(unsigned i = 0; i < roads.size(); i++) {
		int i1 = roads[i].getIntersection(0);
		int i2 = roads[i].getIntersection(1);
		/*
		if(i1 == i2) {
			printf("lol\n");
			continue;
		}
		*/
		insertEdge(i1, i2);
	}
}
int QgsVectorLayerEditUtils::insertSegmentVerticesForSnap( const QList<QgsSnappingResult>& snapResults )
{
  if ( !L->hasGeometryType() )
    return 1;

  int returnval = 0;
  QgsPoint layerPoint;

  QList<QgsSnappingResult>::const_iterator it = snapResults.constBegin();
  for ( ; it != snapResults.constEnd(); ++it )
  {
    if ( it->snappedVertexNr == -1 ) // segment snap
    {
      layerPoint = it->snappedVertex;
      if ( !insertVertex( layerPoint.x(), layerPoint.y(), it->snappedAtGeometry, it->afterVertexNr ) )
      {
        returnval = 3;
      }
    }
  }
  return returnval;
}
Пример #15
0
U32 OptimizedPolyList::addPoint(const Point3F& p)
{
   return insertVertex(p);
}
Пример #16
0
//main/////////////////////////////////////////////////////////////////////////////////////////////////////////
int main(){
    mapa m;
    grafo g = inicializaGrafo(&g, &m);
    int i, i1, i2, i3;

    char esc[20];       //comando a ser digitado

    int FM = 1;
    while (FM == 1){

        scanf("%s", esc);  //lerá o comando até o primeiro espaço, para depois ler até o proximo espaço, e assim por diante
        int escI = identificaComando(esc);  //identifica o comando digitado
        switch(escI){
            case _CV:   //cria vértice
                scanf("%d", &i1);
                insertVertex(&g, &m, i1);
                break;

            case _DV:   //destrói vértice
                scanf("%d", &i1);
                removeVertex(&g, i1, &m);
                break;

            case _CA:   //cria aresta
                scanf("%d %d %d", &i1, &i2, &i3);
                insertEdge(&g, i1, i2, &m, i3);
                break;

            case _DA:   //destrói aresta
                scanf("%d", &i1);
                removeEdge(&g, i1, &m);
                break;

            case _TV:   //troca vértice
                scanf("%d %d", &i1, &i2);
                replaceVertex(i1, i2, m);
                break;

            case _TA:   //troca aresta
                scanf("%d %d", &i1, &i2);
                replaceEdge(i1, i2, m);
                break;

            case _IG:   //imprime grafo
                printf("%d\n", g.nvertices);
                for (i = 0; i < m.indiceVert; i++){
                    vertice *v = pegaVertRef(m, i+1);
                    if (v != NULL){
                        printf("%d ", i+1);
                        printf("%d\n", v->conteudo);
                    }
                }

                printf("%d\n", g.narestas);
                for (i = 0; i < m.indiceAres; i++){
                    aresta *a = pegaAresRef(m, i+1);
                    if (a != NULL){
                        printf("%d ", i+1);
                        vertice *vT = a->dir;
                        printf("%d ", pegaVertInd(m, vT));
                        vT = a->esq;
                        printf("%d ", pegaVertInd(m, vT));
                        printf("%d\n", a->conteudo);
                    }
                }
                break;

            case _CM:   //caminho mínimo
                scanf("%d %d", &i1, &i2);
                dijkstra(&g, m, i1, i2);
                break;

            case _FM:   //fim
                FM = 0;
                break;

        }
    }
    return 0;
}
Пример #17
0
int main(int argc, char const *argv[]) {
	int running = 1, cost = 0, i, j;
	char input[BUFFER_SIZE], *aft;
	char vertex, dest, option;
	Graph *g = NULL;
	createGraph(&g);

	#ifdef DEV

	insertVertex(g, 'a');
	insertVertex(g, 'b');
	insertVertex(g, 'c');
	insertVertex(g, 'd');
	insertVertex(g, 'e');
	insertVertex(g, 'f');
	insertEdge(g, 'a', 'b', 100);
	insertEdge(g, 'a', 'c', 300);
	insertEdge(g, 'a', 'a', 100);
	insertEdge(g, 'd', 'b', 70);
	insertEdge(g, 'f', 'c', 10);
	insertEdge(g, 'a', 'f', 10);
	insertEdge(g, 'a', 'f', 20);
	insertEdge(g, 'a', 'a', 100);
	displayGraph(g);
	greedySearch(g, 'a');
	destroyGraph(g);
	#else

        while (running) {
                memset(input, 0, BUFFER_SIZE);
                printf("\n1 - inserir vertice\n");
                printf("2 - inserir aresta\n");
                printf("3 - remover vertice\n");
                printf("4 - remover aresta\n");
                printf("5 - imprimir grafo\n");
                printf("6 - Busca Gulosa\n");
                printf("7 - sair\n");
                printf("\n$");

                scanf(" %c", &option);
                switch (option) {
                case '1':
                        printf("Digite um id para o novo no (apenas um caracter)\n");
                        printf(">>");
                        scanf(" %c", &vertex);
                        if (!insertVertex(g, vertex)) {
                                printf("Vertice inserido!\n");
                                printf("Digite os vizinhos (exemplo:b10 c20 d30) obs: caso o valor nao seja indicado o default sera 0\n");
                                getchar();
                                fgets(input, BUFFER_SIZE, stdin);
                                for(i = 0; i < strlen(input); i++) {
                                        if(isalpha(input[i])) {
                                                dest = input[i];
                                                for(j = i+1; j <= strlen(input); j++) {
                                                        if(isdigit(input[j])) {
                                                                cost = strtod(&input[j], &aft);
                                                                i = (aft - input) -1;
                                                                if(!insertEdge(g, vertex, dest, cost))
                                                                        printf("Aresta inserida [%c] - [%c] com custo %d!\n", vertex, dest, cost);
                                                                break;
                                                        }
                                                        if(isalpha(input[j]) || input[j] == '\0') {
                                                                if(!insertEdge(g, vertex, dest, 0))
                                                                        printf("Aresta inserida [%c] - [%c] com custo 0!\n", vertex, dest);
                                                                break;
                                                        }
                                                }
                                        }
                                }
                        }

                        break;
                case '2':
                        printf("Digite um par de vertices e um custo para a nova aresta (exemplo: A B 100)\n");
                        printf(">>");
                        scanf(" %c %c %d", &vertex, &dest, &cost);
                        if(!insertEdge(g, vertex, dest, cost))
                                printf("Aresta inserida!\n");
                        break;
                case '3':
                        printf("Digite o id do vertice a ser deletado\n");
                        printf(">>");
                        scanf(" %c", &vertex);
                        if(!removeVertex(g, vertex))
                                printf("vertice removido\n");
                        break;
                case '4':
                        printf("Digite o par de vertices e o custo da aresta (exemplo: A B 100)\n");
                        printf(">>");
                        scanf(" %c %c %d", &vertex, &dest, &cost);
                        if(!removeEdge(g, vertex, dest, cost))
                                printf("aresta removida!\n");
                        break;
                case '5':
                        displayGraph(g);
                        break;
                case '6':
                        printf("Digite um vertice para inicio da busca\n");
                        printf(">>");
                        scanf(" %c", &vertex);
                        greedySearch(g, vertex);
                        break;

                case '7':
                        printf("Ate logo\n");
                        running = 0;
                        destroyGraph(g);
                        break;
                default:
                        printf("Opcao invalida\n");
                        break;
                }
        }
	#endif
	return 0;
}
Пример #18
0
bool DVRClipGeometry::buildTriangledGeometry(void)
{
    // create triangles 
    for(TriangleIterator triangleIt  = geometry->beginTriangles(); 
                         triangleIt != geometry->endTriangles  ();
                       ++triangleIt)
    {
        DVRTriangle newTriangle;
        
        for(UInt32 i = 0; i < 3; i++)
        {
            Int32 vertexIndex = triangleIt.getPositionIndex(i);
            
            vertexIndex = insertVertex(vertexIndex);

            newTriangle.vertices[i] = vertexIndex;
            
            _mfVertices[vertexIndex].adjacentTriangles.push_back(
                _mfTriangles.size());

            newTriangle.cutPnt  [i] = 0.0;
            newTriangle.cutPoint[i] = 0.0;
        }
        
        // compute normal and check orientation
        newTriangle.normal = 
            (_mfVertices[newTriangle.vertices[0]].pos -
             _mfVertices[newTriangle.vertices[1]].pos).cross(
                 _mfVertices[newTriangle.vertices[0]].pos -
                 _mfVertices[newTriangle.vertices[2]].pos);

        newTriangle.normal.normalize();
    
        if(newTriangle.normal.dot(triangleIt.getNormal(0)) < 0.0)
            newTriangle.normal.negate();      
    
        _mfTriangles.push_back(newTriangle);
    }

    // find neighbouring triangles
    for(UInt32 i = 0; i < _mfTriangles.size(); i++)
    {
        Int32 *vertices = _mfTriangles[i].vertices;   

        for(UInt32 l = 0; l < 3; l++)
        {
            const DVRVertex &v0 = _mfVertices[vertices[l]];
            const DVRVertex &v1 = _mfVertices[vertices[(l + 1) % 3]];
            
            for(UInt32 j = 0; j < v0.adjacentTriangles.size(); j++)
            {
                for(UInt32 k = 0; k < v1.adjacentTriangles.size(); k++)
                {
                    if(v0.adjacentTriangles[j] == v1.adjacentTriangles[k] &&
                       v0.adjacentTriangles[j] != i                       && 
                       v1.adjacentTriangles[k] != i                         )
                    {	  
                        if(_mfTriangles[i].neighbours[l] != -1)
                        {
                            SLOG << "Error: Could not build clip geometry"
                                 << std::endl
                                 << "        one triangle edge shared by more "
                                 << "than two triangles" 
                                 << std::endl;

                            return false;
                        }
                        
                        _mfTriangles[i].neighbours[l] = 
                            v1.adjacentTriangles[k];
                    }
                }
            }
        }
    }
    
    // check for non-closed geometry
    UInt32 checkCount = 0; 

    for(UInt32 i = 0; i < _mfTriangles.size(); i++)
    {
        for(UInt32 j = 0; j < 3; j++)
        {
            if(_mfTriangles[i].neighbours[j] == -1)
            {
                checkCount++;
            }
        }
    }

    if(checkCount > 0)
    {
        SLOG << "Error: Could not build clip geometry" 
             << std::endl
             << checkCount
             << "open edges found!"
             << std::endl;

        return false;
    }
    
    return true;
}
Пример #19
0
//----------------------------------------------------------
void ofPolyline::insertVertex(float x, float y, float z, int index) {
    insertVertex(ofPoint(x, y, z), index);
}