void PyramidBrush::setNormals(ofMesh& mesh) { int nV = mesh.getNumVertices(); int nT = mesh.getNumIndices() / 3; vector<ofPoint> norm(nV); for(int t=0; t < nT; t++) { int i1 = mesh.getIndex(3*t); int i2 = mesh.getIndex(3*t + 1); int i3 = mesh.getIndex(3*t + 2); const ofPoint &v1 = mesh.getVertex(i1); const ofPoint &v2 = mesh.getVertex(i2); const ofPoint &v3 = mesh.getVertex(i3); ofPoint dir = ( (v2 - v1).crossed(v3 - v1)).normalized(); norm[i1] += dir; norm[i2] += dir; norm[i3] += dir; } for(int i = 0; i < nV; i++) { norm[i].normalize(); } mesh.clearNormals(); mesh.addNormals(norm); }
//Universal function which sets normals for the triangle mesh void ofxOcean::setNormals( ofMesh &mesh ){ //The number of the vertices int nV = mesh.getNumVertices(); //The number of the triangles int nT = mesh.getNumIndices() / 3; vector<ofPoint> norm( nV ); //Array for the normals //Scan all the triangles. For each triangle add its //normal to norm's vectors of triangle's vertices for (int t=0; t<nT; t++) { //Get indices of the triangle t int i1 = mesh.getIndex( 3 * t ); int i2 = mesh.getIndex( 3 * t + 1 ); int i3 = mesh.getIndex( 3 * t + 2 ); //Get vertices of the triangle const ofPoint &v1 = mesh.getVertex( i1 ); const ofPoint &v2 = mesh.getVertex( i2 ); const ofPoint &v3 = mesh.getVertex( i3 ); //Compute the triangle's normal ofPoint dir = ( (v2 - v1).getCrossed( v3 - v1 ) ).getNormalized(); //Accumulate it to norm array for i1, i2, i3 norm[ i1 ] += dir; norm[ i2 ] += dir; norm[ i3 ] += dir; } //Normalize the normal's length for (int i=0; i<nV; i++) { norm[i].normalize(); } //Set the normals to mesh mesh.clearNormals(); mesh.addNormals( norm ); }
//-------------------------------------------------------------- //Universal function which sets normals for the triangle mesh void setNormals( ofMesh &mesh ){ int nV = mesh.getNumVertices();//640 int nT = mesh.getNumIndices() / 3;//213 vector<ofPoint> norm( nV ); for (int t=0; t<nT; t++) { int i1 = mesh.getIndex( 3 * t ); int i2 = mesh.getIndex( 3 * t + 1 ); int i3 = mesh.getIndex( 641 ); const ofPoint &v1 = mesh.getVertex( i1 ); const ofPoint &v2 = mesh.getVertex( i2 ); const ofPoint &v3 = mesh.getVertex( i3 ); //Compute the triangle's normal ofPoint dir = ( (v2 - v1).crossed( v3 - v1 ) ).normalized(); norm[ i1 ] += dir; norm[ i2 ] += dir; norm[ i3 ] += dir; } //Normalize the normal's length for (int i=0; i<nV; i++) { norm[i].normalize(); } //Set the normals to mesh mesh.clearNormals(); mesh.addNormals( norm ); }
void buildNormalsAverage(ofMesh& mesh) { vector<ofIndexType>& indices = mesh.getIndices(); vector<ofVec3f> normals(mesh.getNumVertices()); for(int i = 0; i < indices.size(); i += 3) { int i0 = indices[i + 0], i1 = indices[i + 1], i2 = indices[i + 2]; ofVec3f normal = getNormal(mesh.getVertices()[i0], mesh.getVertices()[i1], mesh.getVertices()[i2]); normals[i0] += normal; normals[i1] += normal; normals[i2] += normal; } for(int i = 0; i < normals.size(); i++) { normals[i].normalize(); } mesh.addNormals(normals); }
void CloudsVisualSystem3DModelLoader::facetMesh( ofMesh& smoothedMesh, ofMesh& targetMesh ) { //get our vertex, uv and face info vector<ofVec3f>& v = smoothedMesh.getVertices(); vector<ofVec2f>& uv = smoothedMesh.getTexCoords(); vector<ofIndexType>& indices = smoothedMesh.getIndices(); bool hasTC = smoothedMesh.getNumTexCoords(); //use these to store our new mesh info vector<ofVec3f> facetedVertices( indices.size() ); vector<ofVec3f> facetedNormals( indices.size() ); vector<ofVec2f> facetedTexCoords; if(hasTC){ facetedTexCoords.resize( indices.size() ); } vector<ofIndexType> facetedIndices( indices.size() ); //store vertex and uv data for (int i=0; i < indices.size(); i++) { facetedIndices[i] = i; facetedVertices[i] = v[indices[i]]; if(hasTC) facetedTexCoords[i] = uv[indices[i]]; } //calculate our face normals ofVec3f n; for (int i=0; i < facetedIndices.size(); i+=3) { n = normalFrom3Points( facetedVertices[i], facetedVertices[i+1], facetedVertices[i+2]); facetedNormals[i] = n; facetedNormals[i+1] = n; facetedNormals[i+2] = n; } //setup our faceted mesh. this should still work if our targetMesh is our smoothMesh targetMesh.clear(); targetMesh.addVertices( facetedVertices ); targetMesh.addNormals( facetedNormals ); if(hasTC) targetMesh.addTexCoords( facetedTexCoords ); targetMesh.addIndices( facetedIndices ); }
void getCellMesh(voro::voronoicell &_c, ofPoint _pos, ofMesh& mesh ){ if( _c.p ) { ofPoint centroid = getCellCentroid(_c,_pos); int i,j,k,l,m,n; // Vertex // double *ptsp=_c.pts; vector<ofPoint> vertices; vector<ofPoint> normals; for(i = 0; i < _c.p; i++, ptsp+=3){ ofPoint newPoint; newPoint.x = _pos.x + ptsp[0]*0.5; newPoint.y = _pos.y + ptsp[1]*0.5; newPoint.z = _pos.z + ptsp[2]*0.5; vertices.push_back(newPoint); ofPoint newNormal; newNormal = _pos - newPoint;//centroid ; newNormal = newNormal.normalize(); normals.push_back(newNormal); } // ofMesh mesh; mesh.setMode(OF_PRIMITIVE_TRIANGLES ); mesh.addVertices(vertices); mesh.addNormals(normals); // Index // for(i = 1; i < _c.p; i++){ for(j = 0; j < _c.nu[i]; j++) { k = _c.ed[i][j]; if( k >= 0 ) { _c.ed[i][j]=-1-k; l = _c.cycle_up( _c.ed[i][ _c.nu[i]+j], k); m = _c.ed[k][l]; _c.ed[k][l]=-1-m; while(m!=i) { n = _c.cycle_up( _c.ed[k][ _c.nu[k]+l],m); mesh.addTriangle(i, k, m); k=m; l=n; m=_c.ed[k][l]; _c.ed[k][l]=-1-m; } } } } // return mesh; } // return ofMesh(); };
void CloudsVisualSystem3DModelLoader::smoothMesh( ofMesh& facetedMesh, ofMesh& targetMesh, int precision) { cout << "smoothing mesh" << endl; //get our vertex, uv and face info vector<ofVec3f>& v = facetedMesh.getVertices(); vector<ofVec2f>& uv = facetedMesh.getTexCoords(); vector<ofIndexType>& indices = facetedMesh.getIndices(); bool hasTC = facetedMesh.getNumTexCoords(); //use these to store our new mesh info map<string, unsigned int> mergeMap; vector<ofVec3f> smoothVertices; vector<ofVec3f> smoothNormals; vector<ofVec2f> smoothTexCoords; vector<ofIndexType> smoothIndices; //merge our vertices by pointing near by vertices to the same index for (int i=0; i<v.size(); i++) { mergeMap[ vec3ToString( v[i], precision ) ] = i; } //fill our smoothed vertex array with merged vertices & tex coords smoothVertices.resize( mergeMap.size() ); if(hasTC) smoothTexCoords.resize( mergeMap.size() ); int smoothVertexCount = 0; for (map<string, unsigned int>::iterator it = mergeMap.begin(); it != mergeMap.end(); it++) { smoothVertices[smoothVertexCount] = v[it->second]; if(hasTC) smoothTexCoords[smoothVertexCount] = uv[it->second]; it->second = smoothVertexCount;//store our new vertex index smoothVertexCount++; } //reconstruct our faces by reassigning their indices to the merged vertices smoothIndices.resize( indices.size() ); for (int i=0; i<indices.size(); i++) { //use our old vertex poisition to retrieve our new index smoothIndices[i] = mergeMap[ vec3ToString( v[ indices[i] ], precision ) ]; } //calculate our normals smoothNormals.resize( smoothVertices.size() ); ofVec3f n; for (int i=0; i<smoothIndices.size(); i+=3) { n = normalFrom3Points( smoothVertices[smoothIndices[i]], smoothVertices[smoothIndices[i+1]], smoothVertices[smoothIndices[i+2]] ); smoothNormals[smoothIndices[i]] += n; smoothNormals[smoothIndices[i+1]] += n; smoothNormals[smoothIndices[i+2]] += n; } for (int i=0; i<smoothNormals.size(); i++) { smoothNormals[i].normalize(); } //setup our smoothed mesh. this should still work if our targetMesh is our facetedMesh targetMesh.clear(); targetMesh.addVertices( smoothVertices ); targetMesh.addNormals( smoothNormals ); if(hasTC) targetMesh.addTexCoords( smoothTexCoords ); targetMesh.addIndices( smoothIndices ); }