void ossimQuadTreeWarpNode::removeVertices() { removeVertex(theUlVertex); removeVertex(theUrVertex); removeVertex(theLrVertex); removeVertex(theLlVertex); }
void ossimQuadTreeWarpNode::clear() { theBoundingRect.makeNan(); theChildren.clear(); theParent = NULL; removeVertex(theUlVertex); removeVertex(theUrVertex); removeVertex(theLrVertex); removeVertex(theLlVertex); }
void Graph::extractFilament(Vertex* v0, Vertex* v1, set<VertexPtr> &heap, vector<Primitive*> &primitives) { //printf("extractFilament %i %i\n", v0->index, v1->index); if(getCycleEdge(v0->index, v1->index)) { if(v0->adjacent.size() >= 3) { removeEdge(v0->index, v1->index); v0 = v1; if(v0->adjacent.size() == 1) v1 = v0->adjacent[0]; } while(v0->adjacent.size() == 1) { v1 = v0->adjacent[0]; if(getCycleEdge(v0->index, v1->index)) { heap.erase(v0); removeEdge(v0->index, v1->index); removeVertex(v0->index); v0 = v1; } else break; } if(v0->adjacent.size() == 0) { heap.erase(v0); removeVertex(v0->index); } } else { Primitive* p = new Primitive(PT_FILAMENT); if(v0->adjacent.size() >= 3) { p->seq.push_back(PrimitiveVertex(v0->x,v0->y,v0->index)); removeEdge(v0->index, v1->index); v0 = v1; if(v0->adjacent.size() == 1) v1 = v0->adjacent[0]; } while(v0->adjacent.size() == 1) { v1 = v0->adjacent[0]; p->seq.push_back(PrimitiveVertex(v0->x,v0->y,v0->index)); heap.erase(v0); removeEdge(v0->index, v1->index); removeVertex(v0->index); v0 = v1; } p->seq.push_back(PrimitiveVertex(v0->x,v0->y,v0->index)); if(v0->adjacent.size() == 0) { heap.erase(v0); removeVertex(v0->index); } primitives.push_back(p); } }
void SpuVoronoiSimplexSolver::reduceVertices (const SpuUsageBitfield& usedVerts) { if ((numVertices() >= 4) && (!usedVerts.usedVertexD)) removeVertex(3); if ((numVertices() >= 3) && (!usedVerts.usedVertexC)) removeVertex(2); if ((numVertices() >= 2) && (!usedVerts.usedVertexB)) removeVertex(1); if ((numVertices() >= 1) && (!usedVerts.usedVertexA)) removeVertex(0); }
void Graph::extractVertex(Vertex* v0, set<VertexPtr> &heap, vector<Primitive*> &primitives) { //printf("extractVertex %i\n", v0->index); Primitive* p = new Primitive(PT_VERTEX); p->seq.push_back(PrimitiveVertex(v0->x,v0->y,v0->index)); heap.erase(v0); removeVertex(v0->index); primitives.push_back(p); }
void MeshBuilder::removeUnusedVertices() { for ( int k = 0 ; k < vertices() ; ) { Vertex* vert = getVertex( k ); if ( 0 == vert->polygons() ) removeVertex( k ); else ++k; } }
void ClosureBuffer::updateList(int windowSize){ for(std::list<VertexTime>::iterator it = _vertexList.begin(); it!= _vertexList.end(); it++){ (*it).time++; } std::list<VertexTime> tmp(_vertexList); for(std::list<VertexTime>::iterator it = tmp.begin(); it!= tmp.end(); it++){ if ((*it).time >= windowSize) removeVertex((*it).v); } }
void graph::removeVertex(const int id) { map<int, vertex*>::iterator itr = nodeMap.find(id); if (itr != nodeMap.end()) { removeVertex(itr->second); } else { cout << "\n Node doesn't exist \n"; } }
void Mesh::assertManifold() { std::map<Vertex*, std::vector<Triangle *> > triRing; // for each triangle for( std::vector<Triangle *>::iterator tit = triangles.begin(); tit != triangles.end(); ++tit ) { Triangle *t = *tit; for( size_t i=0; i<3; ++i ) triRing[ t->v[i] ].push_back( t ); } for( std::map<Vertex*, std::vector<Triangle *> >::iterator it = triRing.begin(); it != triRing.end(); ++it ) { Vertex *v = it->first; if( it->second.size() < 3 ) { printf( "degenerated vertex detected (referenced by less then 3 triangles) -> removed\n" ); // remove all triangles referencing v for( std::vector<Triangle *>::iterator tit = it->second.begin(); tit != it->second.end(); ++tit ) { Triangle *t = *tit; // remove triangle from triangleRings from all reference vertices for( size_t i =0;i<3; ++i ) if( t->v[i] != v ) { triRing[t->v[i]].erase( std::find( triRing[t->v[i]].begin(), triRing[t->v[i]].end(), t ) ); // TODO: check if new degenerate vertices are created } // remove the triangle removeTriangle( t ); } // remove v itsself removeVertex( v ); } } }
void ProfileScene::mousePressEvent(QGraphicsSceneMouseEvent* mouseEvent) { if (!isProfileSelected) { return; } if (mouseEvent->button() == Qt::RightButton){ if(ctrl_pressed){ addVertex(mouseEvent->lastScenePos().toPoint()); } else if (shift_pressed) { //remove point if clicked on a point removeVertex(); } else { moveVertex(); } } }
bool mutate(MutationCfg mcfg) { // delete some nodes; int i; BernoulliDistribution bd(0); bool b; // Delete nodes bd.setProbTrue(mcfg.nodeDeleteProb/nrVertices()); for (i=0;i<nrVertices();i++) { if (bd.draw(b) && b) { cout << "Removing node " << i << endl; removeVertex(i); } } // Add nodes bd.setProbTrue(mcfg.nodeAddProb); bool mustAdd; int nrV = nrVertices(); for (i=0;i<nrV;i++) { if (bd.draw(b) && b) { vector<int> edges; int j; BernoulliDistribution bdH(mcfg.edgeAddProbNewNode); for (j=0;j<nrV;j++) if (bdH.draw(b) && b) edges.push_back(j); if (!edges.empty()) { addVertex(); for (j=0;j<edges.size();j++) addEdge(mVertices.size()-1,edges[j]); } } } return true; }
void FloorScene::mousePressEvent(QGraphicsSceneMouseEvent* mouseEvent) { if (mouseEvent->button() == Qt::RightButton){ if(ctrl_pressed){ addVertex(mouseEvent->lastScenePos().toPoint()); } else if (shift_pressed) { removeVertex(); } else { unsigned int floorPlanSize = mesh->getFloorPlanSize(); // we have have at least one vertex on the floor plan, if we click on it, we can move it // and we draw his profile if (floorPlanSize != 0) { moveVertex(); // else if we do not have any vertices on the floor plan, we create a floor plan } else { QPoint mousePos = mouseEvent->lastScenePos().toPoint(); // no point defined thus we add an initial geometric structure basicCircle(&mousePos, 10); } } } }
int runKarger(Graph *g) { while(g->numVertices > 2){ // pick edge at random Edge *ep = g->edges+(rand()%g->numEdges); //grab the edges 2 vertices Vertex *v1 = ep->endpoint1->sourceVertex; Vertex *v2 = ep->endpoint2->sourceVertex; // printf("Conracting edge (%d,%d)\n", v1->label, v2->label); // add v2's list onto the end of v1 v1->tail->next = v2->head; v2->head->prev = v1->tail; v1->tail = v2->tail; v2->head = NULL; v2->tail = NULL; // loop through linked list, point them all to v1, delete self loops ConnectorElement *curElement = v1->head; while(curElement){ curElement->sourceVertex = v1; Edge *edgeToCheck = curElement->adjacentEdge; curElement = curElement->next; // if I got really unlucky and switched to a connector element that shares // the same edge as the prev element, I need to switch again if(curElement && curElement->adjacentEdge==edgeToCheck){ curElement->sourceVertex = v1; curElement = curElement->next; } // if its a self loop, remove edge if(edgeToCheck->endpoint1->sourceVertex==v1 && edgeToCheck->endpoint2->sourceVertex==v1){ removeEdge(g, edgeToCheck); } } removeVertex(g, v2); } return g->numEdges; }
void ProfileScene::mousePressEvent(QGraphicsSceneMouseEvent* mouseEvent) { float tmpx = mouseEvent->lastScenePos().toPoint().x(); float tmpy = mouseEvent->lastScenePos().toPoint().y(); QRectF thisSize = this->sceneRect(); Utils::adjustCoordinatesSceneTo3D(tmpx, tmpy, thisSize.width(), thisSize.height()); std::cerr << "P: " << tmpx << ", " << tmpy << std::endl; if (!isProfileSelected) { return; } if (mouseEvent->button() == Qt::RightButton){ // if user use right click + ctrl if(mouseEvent->modifiers() == Qt::ControlModifier){ addVertex(mouseEvent->lastScenePos().toPoint()); // if user use right click + shift } else if (mouseEvent->modifiers() == Qt::ShiftModifier) { //remove point if clicked on a point removeVertex(); } else { moveVertex(); } } }
bool HyperGraph::mergeVertices(Vertex* vBig, Vertex* vSmall, bool erase) { VertexIDMap::iterator it=_vertices.find(vBig->id()); if (it==_vertices.end()) return false; it=_vertices.find(vSmall->id()); if (it==_vertices.end()) return false; EdgeSet tmp(vSmall->edges()); bool ok = true; for(EdgeSet::iterator it=tmp.begin(); it!=tmp.end(); ++it){ HyperGraph::Edge* e = *it; for (size_t i=0; i<e->vertices().size(); i++){ Vertex* v=e->vertex(i); if (v==vSmall) ok &= setEdgeVertex(e,i,vBig); } } if (erase) removeVertex(vSmall); return ok; }
bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, int nvp, rcPolyMesh& mesh) { rcAssert(ctx); ctx->startTimer(RC_TIMER_BUILD_POLYMESH); rcVcopy(mesh.bmin, cset.bmin); rcVcopy(mesh.bmax, cset.bmax); mesh.cs = cset.cs; mesh.ch = cset.ch; int maxVertices = 0; int maxTris = 0; int maxVertsPerCont = 0; for (int i = 0; i < cset.nconts; ++i) { // Skip null contours. if (cset.conts[i].nverts < 3) continue; maxVertices += cset.conts[i].nverts; maxTris += cset.conts[i].nverts - 2; maxVertsPerCont = rcMax(maxVertsPerCont, cset.conts[i].nverts); } if (maxVertices >= 0xfffe) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Too many vertices %d.", maxVertices); return false; } rcScopedDelete<unsigned char> vflags = (unsigned char*)rcAlloc(sizeof(unsigned char)*maxVertices, RC_ALLOC_TEMP); if (!vflags) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.verts' (%d).", maxVertices); return false; } memset(vflags, 0, maxVertices); mesh.verts = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxVertices*3, RC_ALLOC_PERM); if (!mesh.verts) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.verts' (%d).", maxVertices); return false; } mesh.polys = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxTris*nvp*2*2, RC_ALLOC_PERM); if (!mesh.polys) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.polys' (%d).", maxTris*nvp*2); return false; } mesh.regs = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxTris, RC_ALLOC_PERM); if (!mesh.regs) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.regs' (%d).", maxTris); return false; } mesh.areas = (unsigned char*)rcAlloc(sizeof(unsigned char)*maxTris, RC_ALLOC_PERM); if (!mesh.areas) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.areas' (%d).", maxTris); return false; } mesh.nverts = 0; mesh.npolys = 0; mesh.nvp = nvp; mesh.maxpolys = maxTris; memset(mesh.verts, 0, sizeof(unsigned short)*maxVertices*3); memset(mesh.polys, 0xff, sizeof(unsigned short)*maxTris*nvp*2); memset(mesh.regs, 0, sizeof(unsigned short)*maxTris); memset(mesh.areas, 0, sizeof(unsigned char)*maxTris); rcScopedDelete<int> nextVert = (int*)rcAlloc(sizeof(int)*maxVertices, RC_ALLOC_TEMP); if (!nextVert) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'nextVert' (%d).", maxVertices); return false; } memset(nextVert, 0, sizeof(int)*maxVertices); rcScopedDelete<int> firstVert = (int*)rcAlloc(sizeof(int)*VERTEX_BUCKET_COUNT, RC_ALLOC_TEMP); if (!firstVert) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'firstVert' (%d).", VERTEX_BUCKET_COUNT); return false; } for (int i = 0; i < VERTEX_BUCKET_COUNT; ++i) firstVert[i] = -1; rcScopedDelete<int> indices = (int*)rcAlloc(sizeof(int)*maxVertsPerCont, RC_ALLOC_TEMP); if (!indices) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'indices' (%d).", maxVertsPerCont); return false; } rcScopedDelete<int> tris = (int*)rcAlloc(sizeof(int)*maxVertsPerCont*3, RC_ALLOC_TEMP); if (!tris) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'tris' (%d).", maxVertsPerCont*3); return false; } rcScopedDelete<unsigned short> polys = (unsigned short*)rcAlloc(sizeof(unsigned short)*(maxVertsPerCont+1)*nvp, RC_ALLOC_TEMP); if (!polys) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'polys' (%d).", maxVertsPerCont*nvp); return false; } unsigned short* tmpPoly = &polys[maxVertsPerCont*nvp]; for (int i = 0; i < cset.nconts; ++i) { rcContour& cont = cset.conts[i]; // Skip null contours. if (cont.nverts < 3) continue; // Triangulate contour for (int j = 0; j < cont.nverts; ++j) indices[j] = j; int ntris = triangulate(cont.nverts, cont.verts, &indices[0], &tris[0]); if (ntris <= 0) { // Bad triangulation, should not happen. /* printf("\tconst float bmin[3] = {%ff,%ff,%ff};\n", cset.bmin[0], cset.bmin[1], cset.bmin[2]); printf("\tconst float cs = %ff;\n", cset.cs); printf("\tconst float ch = %ff;\n", cset.ch); printf("\tconst int verts[] = {\n"); for (int k = 0; k < cont.nverts; ++k) { const int* v = &cont.verts[k*4]; printf("\t\t%d,%d,%d,%d,\n", v[0], v[1], v[2], v[3]); } printf("\t};\n\tconst int nverts = sizeof(verts)/(sizeof(int)*4);\n");*/ ctx->log(RC_LOG_WARNING, "rcBuildPolyMesh: Bad triangulation Contour %d.", i); ntris = -ntris; } // Add and merge vertices. for (int j = 0; j < cont.nverts; ++j) { const int* v = &cont.verts[j*4]; indices[j] = addVertex((unsigned short)v[0], (unsigned short)v[1], (unsigned short)v[2], mesh.verts, firstVert, nextVert, mesh.nverts); if (v[3] & RC_BORDER_VERTEX) { // This vertex should be removed. vflags[indices[j]] = 1; } } // Build initial polygons. int npolys = 0; memset(polys, 0xff, maxVertsPerCont*nvp*sizeof(unsigned short)); for (int j = 0; j < ntris; ++j) { int* t = &tris[j*3]; if (t[0] != t[1] && t[0] != t[2] && t[1] != t[2]) { polys[npolys*nvp+0] = (unsigned short)indices[t[0]]; polys[npolys*nvp+1] = (unsigned short)indices[t[1]]; polys[npolys*nvp+2] = (unsigned short)indices[t[2]]; npolys++; } } if (!npolys) continue; // Merge polygons. if (nvp > 3) { for(;;) { // Find best polygons to merge. int bestMergeVal = 0; int bestPa = 0, bestPb = 0, bestEa = 0, bestEb = 0; for (int j = 0; j < npolys-1; ++j) { unsigned short* pj = &polys[j*nvp]; for (int k = j+1; k < npolys; ++k) { unsigned short* pk = &polys[k*nvp]; int ea, eb; int v = getPolyMergeValue(pj, pk, mesh.verts, ea, eb, nvp); if (v > bestMergeVal) { bestMergeVal = v; bestPa = j; bestPb = k; bestEa = ea; bestEb = eb; } } } if (bestMergeVal > 0) { // Found best, merge. unsigned short* pa = &polys[bestPa*nvp]; unsigned short* pb = &polys[bestPb*nvp]; mergePolys(pa, pb, bestEa, bestEb, tmpPoly, nvp); memcpy(pb, &polys[(npolys-1)*nvp], sizeof(unsigned short)*nvp); npolys--; } else { // Could not merge any polygons, stop. break; } } } // Store polygons. for (int j = 0; j < npolys; ++j) { unsigned short* p = &mesh.polys[mesh.npolys*nvp*2]; unsigned short* q = &polys[j*nvp]; for (int k = 0; k < nvp; ++k) p[k] = q[k]; mesh.regs[mesh.npolys] = cont.reg; mesh.areas[mesh.npolys] = cont.area; mesh.npolys++; if (mesh.npolys > maxTris) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Too many polygons %d (max:%d).", mesh.npolys, maxTris); return false; } } } // Remove edge vertices. for (int i = 0; i < mesh.nverts; ++i) { if (vflags[i]) { if (!canRemoveVertex(ctx, mesh, (unsigned short)i)) continue; if (!removeVertex(ctx, mesh, (unsigned short)i, maxTris)) { // Failed to remove vertex ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Failed to remove edge vertex %d.", i); return false; } // Remove vertex // Note: mesh.nverts is already decremented inside removeVertex()! for (int j = i; j < mesh.nverts; ++j) vflags[j] = vflags[j+1]; --i; } } // Calculate adjacency. if (!buildMeshAdjacency(mesh.polys, mesh.npolys, mesh.nverts, nvp)) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Adjacency failed."); return false; } // Just allocate the mesh flags array. The user is resposible to fill it. mesh.flags = (unsigned short*)rcAlloc(sizeof(unsigned short)*mesh.npolys, RC_ALLOC_PERM); if (!mesh.flags) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.flags' (%d).", mesh.npolys); return false; } memset(mesh.flags, 0, sizeof(unsigned short) * mesh.npolys); if (mesh.nverts > 0xffff) { ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: The resulting mesh has too many vertices %d (max %d). Data can be corrupted.", mesh.nverts, 0xffff); } if (mesh.npolys > 0xffff) { ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: The resulting mesh has too many polygons %d (max %d). Data can be corrupted.", mesh.npolys, 0xffff); } ctx->stopTimer(RC_TIMER_BUILD_POLYMESH); return true; }
//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; }
void MeshBuilder::removeVertices() { for ( int i = vertices()-1 ; i >= 0 ; --i ) removeVertex(i); }
void Graph<T, C, W>::removeVertex(vector<Vertex<T, C, W>* > const &vertexList) { for(auto vertex : vertexList) { removeVertex(*vertex); } }
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; }
// // removes the given vertex and retriangulates the hole which would be made // // The method returns true if the vertex has been removed and false if the vertex has been retained. // bool MeshEx::removeVertexAndReTriangulateNeighbourhood( Vertex *v ) { std::vector<MeshEx::Edge *> boundaryEdges; // boundary edges which form the polygon which has to be triangulated std::vector<MeshEx::Edge *> criticalEdges; // edges which are not only connected to other vertices of the vertexring through boundary edges std::map<MeshEx::Vertex *, EdgeInfoHelper> boundaryRing; // maps incomming and outgoing edge to each vertex of the boundary vertex-ring // gather and prepare information ------------------------------------------------ for( std::vector<Triangle *>::iterator it = v->triangleRing.begin(); it != v->triangleRing.end(); ++it ) { Triangle *t = (*it); Edge *boundaryEdge = t->getOtherEdge( v ); boundaryRing[boundaryEdge->v1].registerEdge( boundaryEdge ); boundaryRing[boundaryEdge->v2].registerEdge( boundaryEdge ); boundaryEdges.push_back( boundaryEdge ); } // align the edges so that for each vertex e1 is the incomming and e2 is the outgoing edge Vertex *first = boundaryRing.begin()->first; Vertex *current = first; Vertex *next = 0; Vertex *prev = 0; do { // we have to be sure that each boundaryRing Vertex has an incomming and outgoing edge if( !boundaryRing[current].e1 || !boundaryRing[current].e2 ) { printf( "error : edge ring around vertex not closed boundary vertex has less than 2 edges (polygon hole?)\n" ); //++g_iterations; return false; } boundaryRing[current].setVertex( current ); next = boundaryRing[current].next; if( boundaryRing[next].e1 != boundaryRing[current].e2 ) boundaryRing[next].swap(); current = next; }while( current != first ); // we have to collect all edges going out from the vertex-ring vertices which are connected to // other vertices of the vertex ring - these will later be used for consistency check #2 (see chapter 4.4 of the paper) // for each vertex of the vertex Ring V for( std::map<Vertex *, EdgeInfoHelper>::iterator it = boundaryRing.begin(); it != boundaryRing.end(); ++it ) { Vertex *rv = it->first; // current vertex of the vertex ring // for each triangle referencing rv... for( std::vector<Triangle *>::iterator tit = rv->triangleRing.begin(); tit != rv->triangleRing.end(); ++tit ) { Triangle *rv_tri = *tit; // ... which doesnt belong to the triangleRing of v if( std::find( v->triangleRing.begin(), v->triangleRing.end(), rv_tri ) == v->triangleRing.end() ) { // collect the edges containing rv... for( size_t i=0; i<3; ++i ) if( rv_tri->e[i]->contains(rv) ) // ...and dont belong to the edgeRing list if( std::find( boundaryEdges.begin(), boundaryEdges.end(), rv_tri->e[i] ) == boundaryEdges.end() ) // store the edge if the node on the other side references another vertex of the vertex-ring if( boundaryRing.find( rv_tri->e[i]->getOtherVertex(rv) ) != boundaryRing.end() ) criticalEdges.push_back( rv_tri->e[i] ); } } } // remove duplicate entries std::sort( criticalEdges.begin(), criticalEdges.end() ); criticalEdges.erase( std::unique(criticalEdges.begin(), criticalEdges.end()), criticalEdges.end() ); // Now we will project the neighbourhood of v onto a plane so that we can employ the greedy // triangulation. For this we will have to find a projection of the neighbourhood of v so that // no edges intersect on that plane. If they would, then the greedy triangulation would introduce // folds which means that the topology would be destroyed. // Looking for a working projection may lead to a number of projection-trials. For the first try // we will take the plane to be the plane defined by the normal of v and (its distance to the origin). // This will do the job most of the time. math::Vec3f normal; // direction of the projection plane math::Vec3f base1; // base vector which builds the 2d-coordinate system math::Vec3f base2; // base vector which builds the 2d-coordinate system float distance; // distance of the plane to the origin CGAL::Orientation boundaryPolygonOrientation; // orientation (clockwise/counterclockwise of the boundary polyon) distance = -math::dotProduct( v->position, normal ); size_t trialCount = 13; // only one trial for now size_t currentTrial = 0; bool success = true; do { // we assume that we will be successfull success = true; switch(currentTrial) { case 0: // first trial: we take the plane defined by the normal of v normal = v->normal; break; // for all other trials we will try one of 12 different directions case 1:normal = math::normalize( math::Vec3f( .8507f, .4472f, .2764f ));break; case 2:normal = math::normalize( math::Vec3f( -.8507f, .4472f, .2764f ));break; case 3:normal = math::normalize( math::Vec3f( .8507f, -.4472f, -.2764f ));break; case 4:normal = math::normalize( math::Vec3f( -.8507f, -.4472f, -.2764f ));break; case 5:normal = math::normalize( math::Vec3f( .5257f, -.4472f, .7236f ));break; case 6:normal = math::normalize( math::Vec3f( .5257f, .4472f, -.7236f ));break; case 7:normal = math::normalize( math::Vec3f( -.5257f, -.4472f, .7236f ));break; case 8:normal = math::normalize( math::Vec3f( -.5257f, .4472f, -.7236f ));break; case 9:normal = math::normalize( math::Vec3f( .0f, .4472f, .8944f ));break; case 10:normal = math::normalize( math::Vec3f( .0f, -1.0f, .0f ));break; case 11:normal = math::normalize( math::Vec3f( .0f, 1.0f, .0f ));break; case 12:normal = math::normalize( math::Vec3f( .0f, -.4472f, -.8944f ));break; }; // compute the basis of the 2d-coordinate system of the plane defined by current normal base1 = math::normalize( math::projectPointOnPlane( normal, distance, boundaryRing.begin()->first->position ) - v->position ); base2 = math::normalize( math::crossProduct( normal, base1 ) ); // project neighbours into the given plane for( std::map<Vertex *, EdgeInfoHelper>::iterator it = boundaryRing.begin(); it != boundaryRing.end(); ++it ) it->second.projected = _get2d( base1, base2, math::projectPointOnPlane( normal, distance, it->first->position ) ); // topologic constistency check #1 (see chapter 4.4 of the paper) // now do the consistency check: test if all edges dont intersect and dont lie over each other // if any edge between the projected vertices intersect -> success = false // test each projected edge of the edge ring against each other edge for( std::vector<Edge *>::iterator it1 = boundaryEdges.begin(); it1 != boundaryEdges.end() - 1; ++it1 ) { for( std::vector<Edge *>::iterator it2 = it1+1; it2 != boundaryEdges.end(); ++it2 ) { Edge *e1 = *it1; Edge *e2 = *it2; math::Vec3f intersectionPoint; // skip if the 2 lines share a common vertex if( e2->contains(e1->v1) || e2->contains(e1->v2) ) continue; math::Vec2f e1_v1_projected = boundaryRing[e1->v1].projected; math::Vec2f e1_v2_projected = boundaryRing[e1->v2].projected; math::Vec2f e2_v1_projected = boundaryRing[e2->v1].projected; math::Vec2f e2_v2_projected = boundaryRing[e2->v2].projected; CGAL::Segment_2<K> line_1( Point( e1_v1_projected.x, e1_v1_projected.y ), Point(e1_v2_projected.x, e1_v2_projected.y) ); CGAL::Segment_2<K> line_2( Point( e2_v1_projected.x, e2_v1_projected.y ), Point(e2_v2_projected.x, e2_v2_projected.y) ); if( CGAL::do_intersect( line_1, line_2 ) ) { success = false; break; } } if( !success ) break; } if( success ) { // // now we do the topology consistency check #2 (see chapter 4.4 of the paper) // this is done by checking all critical edges whether they cross the interior of the // polygon boundary which is formed by the projected vertex ring vertices // to do this we create the 2 polygongs which can be made by using the edge as a divider // the line crosses the interior if both polgons have a counterclockwise orientation // for( std::vector<Edge *>::iterator it = criticalEdges.begin(); it != criticalEdges.end(); ++it ) { Edge *criticalEdge = *it; // setup left polygon // start from v1 and go to v2 Polygon leftPoly; prev = 0; current = criticalEdge->v1; do { leftPoly.push_back( current, boundaryRing[current].projected ); prev = current; current = boundaryRing[current].next; }while( current != criticalEdge->v2 ); leftPoly.push_back( current, boundaryRing[current].projected ); // setup right polygon // start from v2 and go to v1 Polygon rightPoly; prev = 0; current = criticalEdge->v2; do { rightPoly.push_back( current, boundaryRing[current].projected ); prev = current; current = boundaryRing[current].next; }while( current != criticalEdge->v1 ); rightPoly.push_back( current, boundaryRing[current].projected ); // if orientations of both polygons are the same then the critical edge crosses the bounding polygon interior if( leftPoly.orientation() == rightPoly.orientation() ) { printf( "info : unable to triangulate since critical edge(es) would cross the polygon interior - vertex is not removed\n" ); success = false; break; } } } }while( (++currentTrial < trialCount)&&(!success) ); if( !success ) { // we dont remove the vertex since we didnt managed to find a planar // projection of the neighbourhood which would not destroy the topology printf( "info : unable to find planar projection for vertex remove and retriangulation - vertex is not removed\n" ); //++g_iterations; return false; } boundaryPolygonOrientation = CGAL::orientation( Point_3( v->position ), Point_3( v->position + base1 ), Point_3( v->position + base2 ), Point_3( v->position + normal ) ); // execute the result ------------------------------------------------------------ // remove vertex v and the triangle ring around v removeVertex( v ); // compute squared distances // compute the squared distances of all point pairs std::vector<DistanceHelper> sqDistances; // sorted distances of each pair of points for( std::map<Vertex *, EdgeInfoHelper>::iterator it1 = boundaryRing.begin(); it1 != boundaryRing.end(); ++it1 ) for( std::map<Vertex *, EdgeInfoHelper>::iterator it2 = it1; it2 != boundaryRing.end(); ++it2 ) { Vertex *v1 = it1->first; Vertex *v2 = it2->first; if( v1 == v2 ) continue; // we dont want to add pairs, which would build a boundary edge, since those // already exist -> simply check for next or prev vertex in boundaryRing if( (boundaryRing[v1].next == v2)||(boundaryRing[v1].prev == v2) ) continue; sqDistances.push_back( DistanceHelper( it1->first, it2->first ) ); } // sort std::sort( sqDistances.begin(), sqDistances.end() ); // std::list<Polygon *> polygons; // polygons which have to be triangulated std::vector<Edge *> edges( boundaryEdges.begin(), boundaryEdges.end() ); // created edges // create polygon which is made by the boundary edges and put it on polygon list Polygon *boundaryPolygon = new Polygon(); first = boundaryRing.begin()->first; current = first; prev = 0; do { boundaryPolygon->push_back( current, boundaryRing[current].projected ); prev = current; current = boundaryRing[current].next; }while( current != first ); if( boundaryPolygon->orientation() != boundaryPolygonOrientation ) boundaryPolygon->flip(); polygons.push_back( boundaryPolygon ); // for each entry in the sqDistance list // find the polygon on the polygon list which contains h->v1 and h->v2 // check if edge is outside the polygon by checking the orientations of the left and right sides (build left and right polygons) // check if edge intersects with any other existing edge which dont have a point in h->v1 or h->v2 // if checks pass: // create edge -> assign it to the left and right polygons | add it to the list of edges // split the polygon by removing the polygon from polygon list and putting the left and right polygons on the list if it is not a triangle // // if the any polygon remains on the polygon list, throw an error that the triangulation has created a hole in the mesh //std::vector<Edge *> edges( edgeRing.begin(), edgeRing.end() ); // when the mother polygon is already a triangle, then we have sqDistances.size() == 0 // and we have to handle the polygon if( boundaryPolygon->isTriangle() ) { createTriangle( boundaryPolygon->vertices[0], boundaryPolygon->vertices[1], boundaryPolygon->vertices[2], edges ); polygons.clear(); delete boundaryPolygon; //++g_iterations; return true; } for( std::vector<DistanceHelper>::iterator it=sqDistances.begin(); it != sqDistances.end(); ++it ) { DistanceHelper *h = &(*it); Polygon *poly = 0; // polygon which contains both vertices of h std::list<Polygon *>::iterator pit; // find the polygon which contains both vertices of h for( pit = polygons.begin(); pit != polygons.end(); ++pit ) { Polygon *p = *pit; if( p->contains( h->v1 ) && p->contains( h->v2 ) ) { poly = p; break; } } // if no polygon could be found which contains both vertices of h, then // we can skip this one if( !poly ) continue; // test for intersection with all existing edges bool intersection = false; for( std::vector<Edge *>::iterator eit = edges.begin(); eit != edges.end(); ++eit) { Edge *e = (*eit); math::Vec3f intersectionPoint; // ---- test for intersection of the edges projected into 2d plane using cgal ---- // skip if the 2 lines share a common vertex if( e->contains(h->v1) || e->contains(h->v2) ) continue; CGAL::Segment_2<K> line_1( Point( boundaryRing[e->v1].projected.x, boundaryRing[e->v1].projected.y ), Point(boundaryRing[e->v2].projected.x, boundaryRing[e->v2].projected.y) ); CGAL::Segment_2<K> line_2( Point( boundaryRing[h->v1].projected.x, boundaryRing[h->v1].projected.y ), Point(boundaryRing[h->v2].projected.x, boundaryRing[h->v2].projected.y) ); if( CGAL::do_intersect( line_1, line_2 ) ) { intersection = true; break; } } // if there was an intersection, then we can skip this one // since a non-compatible edge would be introduced if( intersection ) continue; // no intersection, get the 2 polygons which would be created from dividing the mother polyon along the edge Polygon *left, *right; left = right = 0; poly->split( left, right, h->v1, h->v2 ); // if the 2 polygons have the same orientation, then we can be sure that // the edge goes through the interior of the polygon if( left->orientation() == right->orientation() ) { // remove the current polygon from the list of polygons polygons.erase( pit ); delete poly; // create the edge h->v1 -> h->v2 Edge *edge = createEdge( h->v1, h->v2 ); edges.push_back( edge ); // and add the left and righ polygon to the list if they are not triangles if( left->isTriangle() ) { // add triangle to the mesh createTriangle( left->vertices[0], left->vertices[1], left->vertices[2], edges ); // remove polygon helper structure delete left; }else polygons.push_back( left ); if( right->isTriangle() ) { // add triangle to the mesh createTriangle( right->vertices[0], right->vertices[1], right->vertices[2], edges ); // remove polygon helper structure delete right; }else polygons.push_back( right ); }else { delete left; delete right; } } if( !polygons.empty() ) printf( "error : hole created during retriangulation\n" ); for( std::list<Polygon *>::iterator pit = polygons.begin(); pit != polygons.end(); ++pit ) delete *pit; polygons.clear(); //++g_iterations; return true; }
bool rcBuildPolyMesh(rcContourSet& cset, int nvp, rcPolyMesh& mesh) { rcTimeVal startTime = rcGetPerformanceTimer(); vcopy(mesh.bmin, cset.bmin); vcopy(mesh.bmax, cset.bmax); mesh.cs = cset.cs; mesh.ch = cset.ch; int maxVertices = 0; int maxTris = 0; int maxVertsPerCont = 0; for (int i = 0; i < cset.nconts; ++i) { maxVertices += cset.conts[i].nverts; maxTris += cset.conts[i].nverts - 2; maxVertsPerCont = rcMax(maxVertsPerCont, cset.conts[i].nverts); } if (maxVertices >= 0xfffe) { if (rcGetLog()) rcGetLog()->log(RC_LOG_ERROR, "rcBuildPolyMesh: Too many vertices %d.", maxVertices); return false; } unsigned char* vflags = 0; int* nextVert = 0; int* firstVert = 0; int* indices = 0; int* tris = 0; unsigned short* polys = 0; vflags = new unsigned char[maxVertices]; if (!vflags) { if (rcGetLog()) rcGetLog()->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.verts' (%d).", maxVertices); goto failure; } memset(vflags, 0, maxVertices); mesh.verts = new unsigned short[maxVertices*3]; if (!mesh.verts) { if (rcGetLog()) rcGetLog()->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.verts' (%d).", maxVertices); goto failure; } mesh.polys = new unsigned short[maxTris*nvp*2]; if (!mesh.polys) { if (rcGetLog()) rcGetLog()->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.polys' (%d).", maxTris*nvp*2); goto failure; } mesh.regs = new unsigned short[maxTris]; if (!mesh.regs) { if (rcGetLog()) rcGetLog()->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.regs' (%d).", maxTris); goto failure; } mesh.nverts = 0; mesh.npolys = 0; mesh.nvp = nvp; memset(mesh.verts, 0, sizeof(unsigned short)*maxVertices*3); memset(mesh.polys, 0xff, sizeof(unsigned short)*maxTris*nvp*2); memset(mesh.regs, 0, sizeof(unsigned short)*maxTris); nextVert = new int[maxVertices]; if (!nextVert) { if (rcGetLog()) rcGetLog()->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'nextVert' (%d).", maxVertices); goto failure; } memset(nextVert, 0, sizeof(int)*maxVertices); firstVert = new int[VERTEX_BUCKET_COUNT]; if (!firstVert) { if (rcGetLog()) rcGetLog()->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'firstVert' (%d).", VERTEX_BUCKET_COUNT); goto failure; } for (int i = 0; i < VERTEX_BUCKET_COUNT; ++i) firstVert[i] = -1; indices = new int[maxVertsPerCont]; if (!indices) { if (rcGetLog()) rcGetLog()->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'indices' (%d).", maxVertsPerCont); goto failure; } tris = new int[maxVertsPerCont*3]; if (!tris) { if (rcGetLog()) rcGetLog()->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'tris' (%d).", maxVertsPerCont*3); goto failure; } polys = new unsigned short[(maxVertsPerCont+1)*nvp]; if (!polys) { if (rcGetLog()) rcGetLog()->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'polys' (%d).", maxVertsPerCont*nvp); goto failure; } unsigned short* tmpPoly = &polys[maxVertsPerCont*nvp]; for (int i = 0; i < cset.nconts; ++i) { rcContour& cont = cset.conts[i]; // Skip empty contours. if (cont.nverts < 3) continue; // Triangulate contour for (int j = 0; j < cont.nverts; ++j) indices[j] = j; int ntris = triangulate(cont.nverts, cont.verts, &indices[0], &tris[0]); if (ntris <= 0) { // Bad triangulation, should not happen. /* for (int k = 0; k < cont.nverts; ++k) { const int* v = &cont.verts[k*4]; printf("\t\t%d,%d,%d,%d,\n", v[0], v[1], v[2], v[3]); if (nBadPos < 100) { badPos[nBadPos*3+0] = v[0]; badPos[nBadPos*3+1] = v[1]; badPos[nBadPos*3+2] = v[2]; nBadPos++; } }*/ ntris = -ntris; } // Add and merge vertices. for (int j = 0; j < cont.nverts; ++j) { const int* v = &cont.verts[j*4]; indices[j] = addVertex((unsigned short)v[0], (unsigned short)v[1], (unsigned short)v[2], mesh.verts, firstVert, nextVert, mesh.nverts); if (v[3] & RC_BORDER_VERTEX) { // This vertex should be removed. vflags[indices[j]] = 1; } } // Build initial polygons. int npolys = 0; memset(polys, 0xff, maxVertsPerCont*nvp*sizeof(unsigned short)); for (int j = 0; j < ntris; ++j) { int* t = &tris[j*3]; if (t[0] != t[1] && t[0] != t[2] && t[1] != t[2]) { polys[npolys*nvp+0] = (unsigned short)indices[t[0]]; polys[npolys*nvp+1] = (unsigned short)indices[t[1]]; polys[npolys*nvp+2] = (unsigned short)indices[t[2]]; npolys++; } } if (!npolys) continue; // Merge polygons. if (nvp > 3) { while (true) { // Find best polygons to merge. int bestMergeVal = 0; int bestPa, bestPb, bestEa, bestEb; for (int j = 0; j < npolys-1; ++j) { unsigned short* pj = &polys[j*nvp]; for (int k = j+1; k < npolys; ++k) { unsigned short* pk = &polys[k*nvp]; int ea, eb; int v = getPolyMergeValue(pj, pk, mesh.verts, ea, eb, nvp); if (v > bestMergeVal) { bestMergeVal = v; bestPa = j; bestPb = k; bestEa = ea; bestEb = eb; } } } if (bestMergeVal > 0) { // Found best, merge. unsigned short* pa = &polys[bestPa*nvp]; unsigned short* pb = &polys[bestPb*nvp]; mergePolys(pa, pb, mesh.verts, bestEa, bestEb, tmpPoly, nvp); memcpy(pb, &polys[(npolys-1)*nvp], sizeof(unsigned short)*nvp); npolys--; } else { // Could not merge any polygons, stop. break; } } } // Store polygons. for (int j = 0; j < npolys; ++j) { unsigned short* p = &mesh.polys[mesh.npolys*nvp*2]; unsigned short* q = &polys[j*nvp]; for (int k = 0; k < nvp; ++k) p[k] = q[k]; mesh.regs[mesh.npolys] = cont.reg; mesh.npolys++; } } // Remove edge vertices. for (int i = 0; i < mesh.nverts; ++i) { if (vflags[i]) { if (!removeVertex(mesh, i, maxTris)) goto failure; for (int j = i; j < mesh.nverts-1; ++j) vflags[j] = vflags[j+1]; --i; } } delete [] vflags; delete [] firstVert; delete [] nextVert; delete [] indices; delete [] tris; // Calculate adjacency. if (!buildMeshAdjacency(mesh.polys, mesh.npolys, mesh.nverts, nvp)) { if (rcGetLog()) rcGetLog()->log(RC_LOG_ERROR, "rcBuildPolyMesh: Adjacency failed."); return false; } rcTimeVal endTime = rcGetPerformanceTimer(); // if (rcGetLog()) // rcGetLog()->log(RC_LOG_PROGRESS, "Build polymesh: %.3f ms", rcGetDeltaTimeUsec(startTime, endTime)/1000.0f); if (rcGetBuildTimes()) rcGetBuildTimes()->buildPolymesh += rcGetDeltaTimeUsec(startTime, endTime); return true; failure: delete [] vflags; delete [] tmpPoly; delete [] firstVert; delete [] nextVert; delete [] indices; delete [] tris; return false; }
int main(int argc,char * argv[]) { int rc; GLMDB_env *genv; printf("opening graph!\n"); rc = openGraph(&genv, "/home/pieter/Downloads/glmdb-blueprints/src/main/native/testdb"); if (rc != 0) { printf("opening graph failure = %i!\n", rc); goto fail; } MDB_txn *txn; MDB_cursor *cursor; rc = mdb_txn_begin(genv->env, NULL, 1, &txn); if (rc != 0) { printf("begin transaction failure = %i!\n", rc); goto fail; } rc = mdb_cursor_open(txn, genv->vertexDb, &cursor); if (rc != 0) { printf("open cursor failure = %i!\n", rc); goto fail; } MDB_val vertexKey; rc = addVertex(cursor, genv->vertexDb, genv->vertexIdSequence++, &vertexKey); if (rc != 0) { printf("add out vertex failure = %i!\n", rc); goto fail; } VertexDbId outVertexDbId = (*((VertexDbId *) (vertexKey.mv_data))); signed long long outVertexId = outVertexDbId.vertexId; char *propertyValue1 = malloc(5); char v1[] = "12345"; memcpy(propertyValue1, v1, 5); rc = setVertexPropertyString(cursor, 0, 0, 5, propertyValue1); if (rc != 0) { printf("setVertexPropertyChar failure = %i!\n", rc); goto fail; } char *propertyValue2 = malloc(5); char v2[] = "12345"; memcpy(propertyValue2, v2, 5); rc = setVertexPropertyString(cursor, 0, 1, 5, propertyValue2); if (rc != 0) { printf("setVertexPropertyChar failure = %i!\n", rc); goto fail; } jint *propertyKeyIdSize = (jint *)malloc(sizeof(int)); jint **propertyKeyId = malloc(sizeof(void *)); rc = getVertexPropertyKeys(cursor, 0, propertyKeyIdSize, propertyKeyId); if (rc != 0 && rc != MDB_NOTFOUND) { goto fail; } int i = 0; for (i = 0; i < 10; i = i + 1) { rc = addVertex(cursor, genv->vertexDb, genv->vertexIdSequence++, &vertexKey); if (rc != 0) { printf("add in vertex failure = %i!\n", rc); goto fail; } VertexDbId inVertexDbId = (*((VertexDbId *) (vertexKey.mv_data))); signed long long inVertexId = inVertexDbId.vertexId; rc = addEdge(txn, genv->vertexDb, genv->edgeDb, genv->edgeIdSequence++, 0, outVertexId, inVertexId); if (rc != 0) { printf("add edge failure = %i!\n", rc); goto fail; } MDB_cursor *edgeCursor; rc = mdb_cursor_open(txn, genv->edgeDb, &edgeCursor); if (rc != 0) { printf("open cursor failure = %i!\n", rc); goto fail; } char *edgePropertyValue2 = malloc(5); char v2[] = "12345"; memcpy(edgePropertyValue2, v2, 5); rc = setEdgePropertyString(edgeCursor, genv->edgeIdSequence - 1, 0, 5, edgePropertyValue2); mdb_cursor_close(edgeCursor); if (rc != 0) { printf("setEdgePropertyChar failure = %i!\n", rc); goto fail; } } mdb_cursor_close(cursor); mdb_txn_commit(txn); rc = mdb_txn_begin(genv->env, NULL, 1, &txn); if (rc != 0) { printf("transaction begin = %i!\n", rc); goto fail; } rc = mdb_cursor_open(txn, genv->vertexDb, &cursor); if (rc != 0) { printf("open cursor failure = %i!\n", rc); goto fail; } rc = getVertex(cursor, 0LL, &vertexKey); if (rc != 0) { printf("get vertex failure = %i!\n", rc); goto fail; } jlong *edgeIdResultC = (jlong *)malloc(sizeof(signed long long)); jlong *outVertexIdC = (jlong *)malloc(sizeof(signed long long)); jlong *inVertexIdC = (jlong *)malloc(sizeof(signed long long)); rc = getFirstEdgefromVertex(cursor, 0, 0, 0LL, edgeIdResultC, outVertexIdC, inVertexIdC); if (rc != 0) { printf("getFirstEdgefromVertex failure = %i!\n", rc); goto fail; } rc = getNextEdgefromVertex(cursor, 0, 0, 0LL, edgeIdResultC, outVertexIdC, inVertexIdC); if (rc != 0) { printf("getNextEdgefromVertex failure = %i!\n", rc); goto fail; } mdb_cursor_close(cursor); mdb_txn_commit(txn); rc = mdb_txn_begin(genv->env, NULL, 1, &txn); if (rc != 0) { printf("transaction begin = %i!\n", rc); goto fail; } printf("before remove traverseVertexDb\n"); traverseVertexDb(genv, txn); printf("before remove traverseEdgeDb\n"); traverseEdgeDb(genv, txn); mdb_txn_commit(txn); rc = mdb_txn_begin(genv->env, NULL, 1, &txn); if (rc != 0) { printf("transaction begin failure = %i!\n", rc); goto fail; } rc = mdb_cursor_open(txn, genv->vertexDb, &cursor); if (rc != 0) { printf("open cursor failure = %i!\n", rc); goto fail; } // rc = removeEdge(txn, genv, 9LL); // printf("rc = %i\n", rc); // rc = removeEdge(txn, genv, 8LL); // printf("rc = %i\n", rc); // rc = removeEdge(txn, genv, 7LL); // printf("rc = %i\n", rc); // rc = removeEdge(txn, genv, 6LL); // printf("rc = %i\n", rc); // rc = removeEdge(txn, genv, 5LL); // printf("rc = %i\n", rc); // rc = removeEdge(txn, genv, 4LL); // printf("rc = %i\n", rc); // rc = removeEdge(txn, genv, 3LL); // printf("rc = %i\n", rc); // rc = removeEdge(txn, genv, 2LL); // printf("rc = %i\n", rc); // rc = removeEdge(txn, genv, 1LL); // printf("rc = %i\n", rc); // rc = removeEdge(txn, genv, 0LL); // printf("rc = %i\n", rc); rc = removeVertex(txn, genv, 10LL); rc = removeVertex(txn, genv, 9LL); rc = removeVertex(txn, genv, 8LL); rc = removeVertex(txn, genv, 7LL); rc = removeVertex(txn, genv, 6LL); rc = removeVertex(txn, genv, 5LL); rc = removeVertex(txn, genv, 4LL); rc = removeVertex(txn, genv, 3LL); rc = removeVertex(txn, genv, 2LL); rc = removeVertex(txn, genv, 1LL); rc = removeVertex(txn, genv, 0LL); // rc = removeVertex(txn, genv, 0LL); // rc = removeVertex(txn, genv, 1LL); // rc = removeVertex(txn, genv, 2LL); // rc = removeVertex(txn, genv, 3LL); // rc = removeVertex(txn, genv, 4LL); // rc = removeVertex(txn, genv, 5LL); // rc = removeVertex(txn, genv, 6LL); // rc = removeVertex(txn, genv, 7LL); // rc = removeVertex(txn, genv, 8LL); // rc = removeVertex(txn, genv, 9LL); // rc = removeVertex(txn, genv, 10LL); printf("before traverseVertexDb\n"); traverseVertexDb(genv, txn); printf("before traverseEdgeDb\n"); traverseEdgeDb(genv, txn); mdb_txn_commit(txn); fail: printf("closing graph!\n"); closeGraph(genv); return 0; }