void MeshPartition::extractToVtkGrid(vtkUnstructuredGrid *new_grid) { checkLNodes(); allocateGrid(new_grid, m_Cells.size(), m_Nodes.size()); for (int i_nodes = 0; i_nodes < m_Nodes.size(); ++i_nodes) { vec3_t x; m_Grid->GetPoints()->GetPoint(m_Nodes[i_nodes], x.data()); new_grid->GetPoints()->SetPoint(i_nodes, x.data()); copyNodeData(m_Grid, m_Nodes[i_nodes], new_grid, i_nodes); } foreach (vtkIdType id_cell, m_Cells) { /* vtkIdType N_pts, *pts; vtkIdType type_cell = m_Grid->GetCellType(id_cell); m_Grid->GetCellPoints(id_cell, N_pts, pts); QVector<vtkIdType> new_pts(N_pts); for (int i = 0; i < N_pts; ++i) { new_pts[i] = m_LNodes[pts[i]]; } // update for polyhedral cells here vtkIdType id_new_cell = new_grid->InsertNextCell(type_cell, N_pts, new_pts.data()); */ vtkIdType id_new_cell = copyCell(m_Grid, id_cell, new_grid, m_LNodes); copyCellData(m_Grid, id_cell, new_grid, id_new_cell); }
/*! An alternative Constructor of the Map Class used for the obstacle expansion. * @param width_in is the width of the map grid to be allocated. * @param height_in is the height of the map grid to be allocated. * @param pixelRes is the underlying pixel/m resolution of the map. * @param negate_in specifies if the white pixels are empty or occupied in the map. */ Map::Map(int width_in, int height_in , float pixelRes,bool negate_in): negate(negate_in), pixbuf(NULL), drawingPixBuf(NULL), width(width_in), height(height_in), mapRes(pixelRes), grid(NULL), mapFileName("mapFromInterface.") { // GError* error = NULL; allocateGrid(); this->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, width_in, height_in); // pixbuf = gdk_pixbuf_new_from_file("casarea_sub.jpeg", &error); this->drawingPixBuf = gdk_pixbuf_copy(this->pixbuf); };
void GuiDeleteBadAspectTris::operate() { double threshold = m_Ui.doubleSpinBox->value(); QList<vtkIdType> new_cells; for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) { if (isVolume(id_cell,m_Grid)) EG_ERR_RETURN("The grid contains volume cells"); vtkIdType type_cell = m_Grid->GetCellType(id_cell); if (type_cell == VTK_TRIANGLE) { vtkIdType *pts, N_pts; m_Grid->GetCellPoints(id_cell, N_pts, pts); vec3_t x[3]; for (int i = 0; i < 3; ++i) { m_Grid->GetPoint(pts[i], x[i].data()); }; double l1 = (x[1]-x[0]).abs(); double l2 = (x[2]-x[1]).abs(); double l3 = (x[0]-x[2]).abs(); double l_min = min(l1,min(l2,l3)); double l_max = max(l1,max(l2,l3)); double ratio = l_max/l_min; if (ratio <= threshold) { new_cells.append(id_cell); }; } else { new_cells.append(id_cell); }; }; EG_VTKSP(vtkUnstructuredGrid, new_grid); allocateGrid(new_grid, new_cells.size(), m_Grid->GetNumberOfPoints()); for (vtkIdType id_node = 0; id_node < m_Grid->GetNumberOfPoints(); ++id_node) { vec3_t x; m_Grid->GetPoints()->GetPoint(id_node, x.data()); new_grid->GetPoints()->SetPoint(id_node, x.data()); copyNodeData(m_Grid, id_node, new_grid, id_node); }; foreach (vtkIdType id_cell, new_cells) { vtkIdType *pts, N_pts; m_Grid->GetCellPoints(id_cell, N_pts, pts); vtkIdType type_cell = m_Grid->GetCellType(id_cell); vtkIdType id_new_cell = new_grid->InsertNextCell(type_cell, N_pts, pts); copyCellData(m_Grid, id_cell, new_grid, id_new_cell); };
void PolyMolecule::writeVtkFile(QString file_name) { EG_VTKSP(vtkUnstructuredGrid, grid); allocateGrid(grid, m_Faces.size(), m_Nodes.size()); EG_VTKSP(vtkDoubleArray, normals); normals->SetNumberOfComponents(3); normals->SetNumberOfTuples(m_Nodes.size()); normals->SetName("N"); EG_VTKSP(vtkDoubleArray, badness); badness->SetNumberOfComponents(1); badness->SetNumberOfTuples(m_Nodes.size()); badness->SetName("badness"); for (int i = 0; i < m_Nodes.size(); ++i) { vec3_t x = getXNode(i); grid->GetPoints()->SetPoint(i, x.data()); normals->SetTuple(i, m_NodeNormals[i].data()); badness->SetValue(i, double(m_N2BadFaces[i].size())); } grid->GetPointData()->AddArray(normals); grid->GetPointData()->AddArray(badness); for (int i = 0; i < m_Faces.size(); ++i) { QVector<vtkIdType> pts(m_Faces[i].size()); for (int j = 0; j < m_Faces[i].size(); ++j) { pts[j] = m_Faces[i][j]; } grid->InsertNextCell(VTK_POLYGON, m_Faces[i].size(), pts.data()); } EG_VTKSP(vtkXMLUnstructuredGridWriter, vtu); file_name = GuiMainWindow::pointer()->getCwd() + "/" + file_name + ".vtu"; vtu->SetFileName(qPrintable(file_name)); vtu->SetDataModeToBinary(); vtu->SetInputData(grid); vtu->Write(); }
Grid *readGridFromBinaryFile(char *file_name) { FILE *fp; Grid *grid; char *file_base; int zip_status; checkUnzipFile(file_name,&zip_status,&file_base); /* open file and allocate Grid */ fp = fopen(file_base,"r"); grid = allocateGrid(); if( fp != NULL) { fread(&(grid->num_dims), sizeof(int), 1, fp); fread(grid->x_lo, sizeof(LSMLIB_REAL), 3, fp); fread(grid->x_hi, sizeof(LSMLIB_REAL), 3, fp); fread(grid->x_lo_ghostbox, sizeof(LSMLIB_REAL), 3, fp); fread(grid->x_hi_ghostbox, sizeof(LSMLIB_REAL), 3, fp); fread(grid->grid_dims, sizeof(int), 3, fp); fread(grid->grid_dims_ghostbox, sizeof(int), 3, fp); fread(grid->dx, sizeof(LSMLIB_REAL), 3, fp); fread(&(grid->num_gridpts), sizeof(int), 1, fp); fread(&(grid->ilo_gb), sizeof(int), 1, fp); fread(&(grid->ihi_gb), sizeof(int), 1, fp); fread(&(grid->jlo_gb), sizeof(int), 1, fp); fread(&(grid->jhi_gb), sizeof(int), 1, fp); fread(&(grid->klo_gb), sizeof(int), 1, fp); fread(&(grid->khi_gb), sizeof(int), 1, fp); fread(&(grid->ilo_fb), sizeof(int), 1, fp); fread(&(grid->ihi_fb), sizeof(int), 1, fp); fread(&(grid->jlo_fb), sizeof(int), 1, fp); fread(&(grid->jhi_fb), sizeof(int), 1, fp); fread(&(grid->klo_fb), sizeof(int), 1, fp); fread(&(grid->khi_fb), sizeof(int), 1, fp); fread(&(grid->ilo_D1_fb), sizeof(int), 1, fp); fread(&(grid->ihi_D1_fb), sizeof(int), 1, fp); fread(&(grid->jlo_D1_fb), sizeof(int), 1, fp); fread(&(grid->jhi_D1_fb), sizeof(int), 1, fp); fread(&(grid->klo_D1_fb), sizeof(int), 1, fp); fread(&(grid->khi_D1_fb), sizeof(int), 1, fp); fread(&(grid->ilo_D2_fb), sizeof(int), 1, fp); fread(&(grid->ihi_D2_fb), sizeof(int), 1, fp); fread(&(grid->jlo_D2_fb), sizeof(int), 1, fp); fread(&(grid->jhi_D2_fb), sizeof(int), 1, fp); fread(&(grid->klo_D2_fb), sizeof(int), 1, fp); fread(&(grid->khi_D2_fb), sizeof(int), 1, fp); fread(&(grid->ilo_D3_fb), sizeof(int), 1, fp); fread(&(grid->ihi_D3_fb), sizeof(int), 1, fp); fread(&(grid->jlo_D3_fb), sizeof(int), 1, fp); fread(&(grid->jhi_D3_fb), sizeof(int), 1, fp); fread(&(grid->klo_D3_fb), sizeof(int), 1, fp); fread(&(grid->khi_D3_fb), sizeof(int), 1, fp); fread(&(grid->num_nb_levels), sizeof(int), 1, fp); fread(&(grid->mark_gb), sizeof(unsigned char), 1, fp); fread(&(grid->mark_D1), sizeof(unsigned char), 1, fp); fread(&(grid->mark_D2), sizeof(unsigned char), 1, fp); fread(&(grid->mark_D3), sizeof(unsigned char), 1, fp); fread(&(grid->mark_fb), sizeof(unsigned char), 1, fp); fread(&(grid->beta), sizeof(LSMLIB_REAL), 1, fp); fread(&(grid->gamma), sizeof(LSMLIB_REAL), 1, fp); fclose(fp); zipFile(file_base,zip_status); free(file_base); } else { printf("\nCould not open file %s",file_base); } return grid; }
Grid *createGridSetDx( int num_dims, LSMLIB_REAL dx, LSMLIB_REAL *x_lo, LSMLIB_REAL *x_hi, LSMLIB_SPATIAL_DERIVATIVE_ACCURACY_TYPE accuracy) { int i; LSMLIB_REAL diff; Grid *g; int num_ghostcells = lsmlib_num_ghostcells[accuracy]; g = allocateGrid(); if( (num_dims == 2) || (num_dims == 3) ) { g->num_dims = num_dims; } else { printf("\nInvalid grid dimension %d, set to default 2.\n", num_dims); g->num_dims = 2; } /* set up grid */ g->num_gridpts = 1; for(i = 0; i < g->num_dims; i++) { (g->dx)[i] = dx; /* compute grid dimensions */ diff = ( x_hi[i] - x_lo[i] ); g->grid_dims[i] = rint( diff/(dx) ); /* set x_lo and x_hi consistent with dx and grid_dims */ g->x_lo[i] = x_lo[i]; g->x_hi[i] = x_lo[i] + (g->grid_dims)[i]*dx; /* add 'num_ghostcells' layers of voxels on each side */ (g->grid_dims_ghostbox)[i] = (g->grid_dims)[i] + 2*num_ghostcells; (g->x_lo_ghostbox)[i]= (g->x_lo)[i] - num_ghostcells*((g->dx)[i]); (g->x_hi_ghostbox)[i]= (g->x_hi)[i] + num_ghostcells*((g->dx)[i]); (g->num_gridpts) *= (g->grid_dims_ghostbox)[i]; } if( g->num_dims == 2 ) { /* put fake values for the third dimension */ (g->x_lo)[2] = 0; (g->x_hi)[2] = 0; (g->x_lo_ghostbox)[2] = 0; (g->x_hi_ghostbox)[2] = 0; (g->grid_dims)[2] = 1; (g->grid_dims_ghostbox)[2] = 1; (g->dx)[2] = 0; } setIndexSpaceLimits(accuracy,g); return g; }
Grid *readGridFromAsciiFile(char *file_name) { Grid *grid; FILE *fp; float x_lo_float[3], x_hi_float[3]; float x_lo_ghostbox_float[3], x_hi_ghostbox_float[3]; float dx_float[3], beta_float, gamma_float; char *line[80]; char *file_base; int zip_status; checkUnzipFile(file_name,&zip_status,&file_base); /* open file and allocate Grid */ fp = fopen(file_base,"r"); grid = allocateGrid(); fscanf(fp, "Number of dimensions: %d\n", &(grid->num_dims)); if (grid->num_dims == 2) { fscanf(fp, "Geometric limits (without ghostcells): [%g,%g] x [%g,%g]\n", &(x_lo_float[0]), &(x_hi_float[0]), &(x_lo_float[1]), &(x_hi_float[1])); grid->x_lo[0] = x_lo_float[0]; grid->x_hi[0] = x_hi_float[0]; grid->x_lo[1] = x_lo_float[1]; grid->x_hi[1] = x_hi_float[1]; fscanf(fp,"Geometric limits (with ghostcells): [%g,%g] x [%g,%g]\n", &(x_lo_ghostbox_float[0]), &(x_hi_ghostbox_float[0]), &(x_lo_ghostbox_float[1]), &(x_hi_ghostbox_float[1])); grid->x_lo_ghostbox[0] = x_lo_ghostbox_float[0]; grid->x_hi_ghostbox[0] = x_hi_ghostbox_float[0]; grid->x_lo_ghostbox[1] = x_lo_ghostbox_float[1]; grid->x_hi_ghostbox[1] = x_hi_ghostbox_float[1]; fscanf(fp,"Grid size (without ghostcells): %d x %d\n", &((grid->grid_dims)[0]), &((grid->grid_dims)[1])); fscanf(fp,"Grid size (with ghostcells): %d x %d\n", &((grid->grid_dims_ghostbox)[0]), &((grid->grid_dims_ghostbox)[1])); fscanf(fp,"Grid spacing: dx = %g, dy = %g \n", &(dx_float[0]), &(dx_float[1])); grid->dx[0] = dx_float[0]; grid->dx[1] = dx_float[1]; } else { fscanf(fp, "Geometric limits (without ghostcells): [%g,%g] x [%g,%g] x [%g,%g]\n", &(x_lo_float[0]), &(x_hi_float[0]), &(x_lo_float[1]), &(x_hi_float[1]), &(x_lo_float[2]), &(x_hi_float[2])); grid->x_lo[0] = x_lo_float[0]; grid->x_hi[0] = x_hi_float[0]; grid->x_lo[1] = x_lo_float[1]; grid->x_hi[1] = x_hi_float[1]; grid->x_lo[2] = x_lo_float[2]; grid->x_hi[2] = x_hi_float[2]; fscanf(fp,"Geometric limits (with ghostcells): [%g,%g] x [%g,%g] x [%g,%g]\n", &(x_lo_ghostbox_float[0]), &(x_hi_ghostbox_float[0]), &(x_lo_ghostbox_float[1]), &(x_hi_ghostbox_float[1]), &(x_lo_ghostbox_float[2]), &(x_hi_ghostbox_float[2])); grid->x_lo_ghostbox[0] = x_lo_ghostbox_float[0]; grid->x_hi_ghostbox[0] = x_hi_ghostbox_float[0]; grid->x_lo_ghostbox[1] = x_lo_ghostbox_float[1]; grid->x_hi_ghostbox[1] = x_hi_ghostbox_float[1]; grid->x_lo_ghostbox[2] = x_lo_ghostbox_float[2]; grid->x_hi_ghostbox[2] = x_hi_ghostbox_float[2]; fscanf(fp,"Grid size (without ghostcells): %d x %d x %d\n", &((grid->grid_dims)[0]), &((grid->grid_dims)[1]), &((grid->grid_dims)[2])); fscanf(fp,"Grid size (with ghostcells): %d x %d x %d\n", &((grid->grid_dims_ghostbox)[0]), &((grid->grid_dims_ghostbox)[1]), &((grid->grid_dims_ghostbox)[2])); fscanf(fp,"Grid spacing: dx = %g, dy = %g, dz = %g\n", &(dx_float[0]), &(dx_float[1]), &(dx_float[2])); grid->dx[0] = dx_float[0]; grid->dx[1] = dx_float[1]; grid->dx[2] = dx_float[2]; } fscanf(fp, "Total number of grid points: %d\n", &(grid->num_gridpts)); /* fscanf(fp,"%s\n",line); */ if (grid->num_dims == 2) { fscanf(fp, "Ghost box: [%d,%d] x [%d,%d]\n", &(grid->ilo_gb), &(grid->ihi_gb), &(grid->jlo_gb), &(grid->jhi_gb)); fscanf(fp, "Fill box: [%d,%d] x [%d,%d]\n", &(grid->ilo_fb), &(grid->ihi_fb), &(grid->jlo_fb), &(grid->jhi_fb)); fscanf(fp, "1st order differences fill box: [%d,%d] x [%d,%d]\n", &(grid->ilo_D1_fb), &(grid->ihi_D1_fb), &(grid->jlo_D1_fb), &(grid->jhi_D1_fb)); fscanf(fp, "2nd order differences fill box: [%d,%d] x [%d,%d]\n", &(grid->ilo_D2_fb), &(grid->ihi_D2_fb), &(grid->jlo_D2_fb), &(grid->jhi_D2_fb)); fscanf(fp, "3rd order differences fill box: [%d,%d] x [%d,%d]\n", &(grid->ilo_D3_fb), &(grid->ihi_D3_fb), &(grid->jlo_D3_fb), &(grid->jhi_D3_fb)); } else { fscanf(fp, "Ghost box: [%d,%d] x [%d,%d] x [%d,%d]\n", &(grid->ilo_gb), &(grid->ihi_gb), &(grid->jlo_gb), &(grid->jhi_gb), &(grid->klo_gb), &(grid->khi_gb)); fscanf(fp, "Fill box: [%d,%d] x [%d,%d] x [%d,%d]\n", &(grid->ilo_fb), &(grid->ihi_fb), &(grid->jlo_fb), &(grid->jhi_fb), &(grid->klo_fb), &(grid->khi_fb)); fscanf(fp, "1st order differences fill box: [%d,%d] x [%d,%d] x [%d,%d]\n", &(grid->ilo_D1_fb), &(grid->ihi_D1_fb), &(grid->jlo_D1_fb), &(grid->jhi_D1_fb), &(grid->klo_D1_fb), &(grid->khi_D1_fb)); fscanf(fp, "2nd order differences fill box: [%d,%d] x [%d,%d] x [%d,%d]\n", &(grid->ilo_D2_fb), &(grid->ihi_D2_fb), &(grid->jlo_D2_fb), &(grid->jhi_D2_fb), &(grid->klo_D2_fb), &(grid->khi_D2_fb)); fscanf(fp, "3rd order differences fill box: [%d,%d] x [%d,%d] x [%d,%d]\n", &(grid->ilo_D3_fb), &(grid->ihi_D3_fb), &(grid->jlo_D3_fb), &(grid->jhi_D3_fb), &(grid->klo_D3_fb), &(grid->khi_D3_fb)); } fscanf(fp, "Number of narrow band levels (local method) %d\n", &(grid->num_nb_levels)); fscanf(fp, "Boundary layer marks (local method) gb %c D1 %c D2 %c D3 %c fb %c\n", &(grid->mark_gb), &(grid->mark_D1),&(grid->mark_D2), &(grid->mark_D3),&(grid->mark_fb)); fscanf(fp, "Narrow band width (local method) beta(inner) %g gamma(outer) %g\n", &beta_float, &gamma_float); grid->beta = beta_float; grid->gamma = gamma_float; fclose(fp); zipFile(file_base,zip_status); free(file_base); return grid; }
Grid *copyGrid(Grid *grid) { Grid *new_grid; int i; new_grid = allocateGrid(); new_grid->num_dims = grid->num_dims; for(i = 0; i < 3; i++) { new_grid->x_lo[i] = grid->x_lo[i]; new_grid->x_hi[i] = grid->x_hi[i]; new_grid->x_lo_ghostbox[i] = grid->x_lo_ghostbox[i]; new_grid->x_hi_ghostbox[i] = grid->x_hi_ghostbox[i]; new_grid->grid_dims[i] = grid->grid_dims[i]; new_grid->grid_dims_ghostbox[i] = grid->grid_dims_ghostbox[i]; new_grid->dx[i] = grid->dx[i]; } new_grid->num_gridpts = grid->num_gridpts; new_grid->ilo_gb = grid->ilo_gb; new_grid->ihi_gb = grid->ihi_gb; new_grid->jlo_gb = grid->jlo_gb; new_grid->jhi_gb = grid->jhi_gb; new_grid->klo_gb = grid->klo_gb; new_grid->khi_gb = grid->khi_gb; new_grid->ilo_fb = grid->ilo_fb; new_grid->ihi_fb = grid->ihi_fb; new_grid->jlo_fb = grid->jlo_fb; new_grid->jhi_fb = grid->jhi_fb; new_grid->klo_fb = grid->klo_fb; new_grid->khi_fb = grid->khi_fb; new_grid->ilo_D1_fb = grid->ilo_D1_fb; new_grid->ihi_D1_fb = grid->ihi_D1_fb; new_grid->jlo_D1_fb = grid->jlo_D1_fb; new_grid->jhi_D1_fb = grid->jhi_D1_fb; new_grid->klo_D1_fb = grid->klo_D1_fb; new_grid->khi_D1_fb = grid->khi_D1_fb; new_grid->ilo_D2_fb = grid->ilo_D2_fb; new_grid->ihi_D2_fb = grid->ihi_D2_fb; new_grid->jlo_D2_fb = grid->jlo_D2_fb; new_grid->jhi_D2_fb = grid->jhi_D2_fb; new_grid->klo_D2_fb = grid->klo_D2_fb; new_grid->khi_D2_fb = grid->khi_D2_fb; new_grid->ilo_D3_fb = grid->ilo_D3_fb; new_grid->ihi_D3_fb = grid->ihi_D3_fb; new_grid->jlo_D3_fb = grid->jlo_D3_fb; new_grid->jhi_D3_fb = grid->jhi_D3_fb; new_grid->klo_D3_fb = grid->klo_D3_fb; new_grid->khi_D3_fb = grid->khi_D3_fb; new_grid->num_nb_levels = grid->num_nb_levels; new_grid->mark_gb = grid->mark_gb; new_grid->mark_D1 = grid->mark_D1; new_grid->mark_D2 = grid->mark_D2; new_grid->mark_D3 = grid->mark_D3; new_grid->mark_fb = grid->mark_fb; new_grid->beta = grid->beta; new_grid->gamma = grid->gamma; return new_grid; }
Grid *createGridSetGridDims( int num_dims, int *grid_dims, LSMLIB_REAL *x_lo, LSMLIB_REAL *x_hi, LSMLIB_SPATIAL_DERIVATIVE_ACCURACY_TYPE accuracy) { Grid *g; int i; int num_ghostcells = lsmlib_num_ghostcells[accuracy]; g = allocateGrid(); /* set number of dimensions for grid */ if( (num_dims == 2) || (num_dims == 3) ) { g->num_dims = num_dims; } else { fprintf(stderr, "\nInvalid number of dimensions (%d). ", num_dims); fprintf(stderr, "Using to default value of 2.\n"); g->num_dims = 2; } /* set grid parameters */ g->num_gridpts = 1; for(i = 0; i < g->num_dims; i++) { (g->grid_dims)[i] = grid_dims[i]; g->x_hi[i] = x_hi[i]; g->x_lo[i] = x_lo[i]; (g->dx)[i] = ( (g->x_hi)[i] - (g->x_lo)[i] )/(g->grid_dims)[i]; /* add 'num_ghostcells' layers of voxels on each side */ (g->grid_dims_ghostbox)[i] = (g->grid_dims)[i] + 2*num_ghostcells; (g->x_lo_ghostbox)[i]= (g->x_lo)[i] - num_ghostcells*((g->dx)[i]); (g->x_hi_ghostbox)[i]= (g->x_hi)[i] + num_ghostcells*((g->dx)[i]); (g->num_gridpts) *= (g->grid_dims_ghostbox)[i]; } /* for 2D problems, use fake values for the third dimension */ if( g->num_dims == 2 ) { (g->x_lo)[2] = 0; (g->x_hi)[2] = 0; (g->x_lo_ghostbox)[2] = 0; (g->x_hi_ghostbox)[2] = 0; (g->grid_dims)[2] = 1; (g->grid_dims_ghostbox)[2] = 1; (g->dx)[2] = 0; } setIndexSpaceLimits(accuracy,g); return g; }
void BrlcadReader::processStlFile(QString file_name, bool append_to_list) { vtkSTLReader *stl = vtkSTLReader::New(); stl->MergingOn(); stl->SetFileName(file_name.toAscii().data()); stl->Update(); EG_VTKSP(vtkPolyData, poly); poly->DeepCopy(stl->GetOutput()); poly->BuildCells(); double L = 1e99; for (vtkIdType cellId = 0; cellId < poly->GetNumberOfCells(); ++cellId) { vtkIdType *pts, Npts; poly->GetCellPoints(cellId, Npts, pts); for (int i = 0; i < Npts; ++i) { vec3_t x1, x2; poly->GetPoints()->GetPoint(pts[i], x1.data()); if (i == Npts - 1) { poly->GetPoints()->GetPoint(pts[0], x2.data()); } else { poly->GetPoints()->GetPoint(pts[i+1], x2.data()); } L = min(L, (x1-x2).abs()); } } EG_VTKSP(vtkEgPolyDataToUnstructuredGridFilter, poly2ugrid); poly2ugrid->SetInput(poly); poly2ugrid->Update(); EG_VTKSP(vtkUnstructuredGrid, grid); allocateGrid(grid, poly2ugrid->GetOutput()->GetNumberOfCells(), poly2ugrid->GetOutput()->GetNumberOfPoints()); for (vtkIdType id_node = 0; id_node < poly2ugrid->GetOutput()->GetNumberOfPoints(); ++id_node) { vec3_t x; poly2ugrid->GetOutput()->GetPoints()->GetPoint(id_node, x.data()); grid->GetPoints()->SetPoint(id_node, x.data()); } for (vtkIdType id_cell = 0; id_cell < poly2ugrid->GetOutput()->GetNumberOfCells(); ++id_cell) { vtkIdType N_pts, *pts; vtkIdType type_cell = poly2ugrid->GetOutput()->GetCellType(id_cell); poly2ugrid->GetOutput()->GetCellPoints(id_cell, N_pts, pts); grid->InsertNextCell(type_cell, N_pts, pts); } EG_VTKDCC(vtkIntArray, cell_code, grid, "cell_code"); EG_VTKDCC(vtkIntArray, orgdir, grid, "cell_orgdir"); EG_VTKDCC(vtkIntArray, voldir, grid, "cell_voldir"); EG_VTKDCC(vtkIntArray, curdir, grid, "cell_curdir"); for (vtkIdType id_cell = 0; id_cell < grid->GetNumberOfCells(); ++id_cell) { cell_code->SetValue(id_cell, 9999); orgdir->SetValue(id_cell, 0); voldir->SetValue(id_cell, 0); curdir->SetValue(id_cell, 0); } if (append_to_list) { SetBoundaryCode set_bc; set_bc.setGrid(grid); set_bc.setAllSurfaceCells(); int bc_max = 1; bool done = false; do { vtkIdType id_start = -1; for (vtkIdType id_cell = 0; id_cell < grid->GetNumberOfCells(); ++id_cell) { if (cell_code->GetValue(id_cell) == 9999) { id_start = id_cell; break; } } if (id_start == -1) { done = true; } else { set_bc.setFeatureAngle(20.0); set_bc.setBC(bc_max); set_bc.setProcessAll(true); set_bc.setSelectAllVisible(false); set_bc.setOnlyPickedCell(false); set_bc.setOnlyPickedCellAndNeighbours(false); set_bc.setStart(id_start); set_bc(); ++bc_max; } } while (!done); cout << "file: " << qPrintable(file_name) << endl; for (int bc = 1; bc < bc_max; ++bc) { QList<vtkIdType> cells; for (vtkIdType id_cell = 0; id_cell < grid->GetNumberOfCells(); ++id_cell) { if (cell_code->GetValue(id_cell) == bc) { cells.append(id_cell); } } vtkUnstructuredGrid *new_grid = vtkUnstructuredGrid::New(); QString bc_txt; bc_txt.setNum(bc); if (bc_max >= 10) { bc_txt = bc_txt.rightJustified(2, '0'); } QFileInfo file_info(file_name); m_BCNames[new_grid] = file_info.baseName() + "." + bc_txt; cout << " " << qPrintable(file_info.baseName() + "." + bc_txt) << endl; makeCopy(grid, new_grid, cells); m_Grids.append(new_grid); } } else { makeCopy(grid, m_Grid); } }
/*! This method is used to read the image file and copy it to a * pixel buffer which will then be used to greate the underlying grid representation * of the map. */ int Map::readMapFile(char * filename) { guchar* pixels; guchar* p; int rowstride, n_channels, bps; GError* error = NULL; int i,j,k; double occ; int color_sum; double color_avg; this->mapFileName = filename; g_type_init(); printf("\nMapFile loading image file: %s...", this->mapFileName); fflush(stdout); // Read the image if(!(pixbuf = gdk_pixbuf_new_from_file(this->mapFileName, &error))) { printf("\nfailed to open image file %s", this->mapFileName); return(-1); } this->drawingPixBuf = gdk_pixbuf_copy(this->pixbuf); this->width = gdk_pixbuf_get_width(pixbuf); this->height = gdk_pixbuf_get_height(pixbuf); allocateGrid(); rowstride = gdk_pixbuf_get_rowstride(pixbuf); bps = gdk_pixbuf_get_bits_per_sample(pixbuf)/8; n_channels = gdk_pixbuf_get_n_channels(pixbuf); if(gdk_pixbuf_get_has_alpha(pixbuf)) n_channels++; // Read data pixels = gdk_pixbuf_get_pixels(pixbuf); int count =0; for(j = 0; j < this->height; j++) { for (i = 0; i < this->width; i++) { p = pixels + j*rowstride + i*n_channels*bps; color_sum = 0; for(k=0;k<n_channels;k++) color_sum += *(p + (k * bps)); color_avg = color_sum / (double)n_channels; if(this->negate) occ = color_avg / 255.0; else occ = (255 - color_avg) / 255.0; if(occ < 0.1) { this->grid[i][j] = 0; } else { this->grid[i][j] = 1; count++; } } } printf("\nMapFile read a %d X %d map, at %.3f m/pix",this->width, this->height, this->mapRes); fflush(stdout); return(0); };
void FillPlane::createEdgesOnPlane(vtkUnstructuredGrid *edge_grid) { vtkIdType num_edges = 0; vtkIdType num_nodes = 0; QVector<bool> is_edge_node(m_Grid->GetNumberOfPoints(), false); for (vtkIdType id_face = 0; id_face < m_Grid->GetNumberOfCells(); ++id_face) { vtkIdType num_pts, *pts; if (isSurface(id_face, m_Grid)) { m_Grid->GetCellPoints(id_face, num_pts, pts); for (int i = 0; i < num_pts; ++i) { if (m_Part.c2cGG(id_face, i) == -1) { vtkIdType id_node1 = pts[i]; vtkIdType id_node2 = pts[0]; if (i < num_pts - 1) { id_node2 = pts[i + 1]; } vec3_t x1, x2; m_Grid->GetPoint(id_node1, x1.data()); m_Grid->GetPoint(id_node2, x2.data()); if (isWithinTolerance(x1) && isWithinTolerance(x2)) { is_edge_node[id_node1] = true; is_edge_node[id_node2] = true; ++num_edges; } } } } } QVector<vtkIdType> node_map(m_Grid->GetNumberOfPoints(), -1); for (vtkIdType id_node1 = 0; id_node1 < m_Grid->GetNumberOfPoints(); ++id_node1) { if (is_edge_node[id_node1]) { node_map[id_node1] = num_nodes; ++num_nodes; } } m_NodeMap.resize(num_nodes); allocateGrid(edge_grid, 2*num_edges, num_nodes, false); for (vtkIdType id_node1 = 0; id_node1 < m_Grid->GetNumberOfPoints(); ++id_node1) { if (node_map[id_node1] != -1) { m_NodeMap[node_map[id_node1]] = id_node1; vec3_t x; m_Grid->GetPoint(id_node1, x.data()); edge_grid->GetPoints()->SetPoint(node_map[id_node1], x.data()); } } for (vtkIdType id_face = 0; id_face < m_Grid->GetNumberOfCells(); ++id_face) { vtkIdType num_pts, *pts; if (isSurface(id_face, m_Grid)) { m_Grid->GetCellPoints(id_face, num_pts, pts); for (int i = 0; i < num_pts; ++i) { if (m_Part.c2cGG(id_face, i) == -1) { vtkIdType id_node1 = pts[i]; vtkIdType id_node2 = pts[0]; if (i < num_pts - 1) { id_node2 = pts[i + 1]; } if (is_edge_node[id_node1] && is_edge_node[id_node2]) { vtkIdType pts[2]; pts[0] = node_map[id_node1]; pts[1] = node_map[id_node2]; edge_grid->InsertNextCell(VTK_LINE, 2, pts); } } } } } }
void StlReader::operate() { QFileInfo file_info(GuiMainWindow::pointer()->getFilename()); QString file_name; if (m_FileNameSet) { file_name = m_FileName; } else { readInputFileName(file_info.completeBaseName() + ".stl"); if (isValid()) { file_name = getFileName(); } else { return; } } EG_VTKSP(vtkSTLReader, stl); stl->MergingOn(); stl->SetFileName(qPrintable(file_name)); stl->Update(); EG_VTKSP(vtkPolyData, poly); poly->DeepCopy(stl->GetOutput()); poly->BuildCells(); double L = 1e99; for (vtkIdType cellId = 0; cellId < poly->GetNumberOfCells(); ++cellId) { vtkIdType *pts, Npts; poly->GetCellPoints(cellId, Npts, pts); for (int i = 0; i < Npts; ++i) { vec3_t x1, x2; poly->GetPoints()->GetPoint(pts[i], x1.data()); if (i == Npts - 1) { poly->GetPoints()->GetPoint(pts[0], x2.data()); } else { poly->GetPoints()->GetPoint(pts[i+1], x2.data()); } L = min(L, (x1-x2).abs()); } } if (m_Tolerance < 0) { m_Tolerance = QInputDialog::getText(NULL, "enter STL tolerance", "tolerance", QLineEdit::Normal, "1e-10").toDouble(); } cout << "cleaning STL geometry:" << endl; EG_VTKSP(vtkCleanPolyData, poly_clean); EG_VTKSP(vtkFeatureEdges, topo_check); double bounds[6]; poly->GetBounds(bounds); poly_clean->ToleranceIsAbsoluteOn(); poly_clean->ConvertLinesToPointsOn(); poly_clean->ConvertPolysToLinesOn(); poly_clean->SetInputData(poly); topo_check->SetInputConnection(poly_clean->GetOutputPort()); topo_check->BoundaryEdgesOn(); topo_check->ManifoldEdgesOff(); topo_check->FeatureEdgesOff(); topo_check->NonManifoldEdgesOn(); bool check_passed; int count = 0; do { ++count; cout << " tolerance = " << m_Tolerance << endl; poly_clean->SetAbsoluteTolerance(m_Tolerance); topo_check->Update(); m_Tolerance *= 1.5; check_passed = topo_check->GetOutput()->GetNumberOfPoints() == 0; } while (m_Tolerance < 1 && !check_passed && count < m_MaxNumCleanIter); if (check_passed) { cout << "The STL geometry seems to be clean." << endl; } else { cout << "The STL geometry could not be cleaned." << endl; } // with a tolerance of " << 0.5*L << endl; EG_VTKSP(vtkEgPolyDataToUnstructuredGridFilter, poly2ugrid); poly2ugrid->SetInputConnection(poly_clean->GetOutputPort()); poly2ugrid->Update(); allocateGrid(m_Grid, poly2ugrid->GetOutput()->GetNumberOfCells(), poly2ugrid->GetOutput()->GetNumberOfPoints()); for (vtkIdType id_node = 0; id_node < poly2ugrid->GetOutput()->GetNumberOfPoints(); ++id_node) { vec3_t x; poly2ugrid->GetOutput()->GetPoints()->GetPoint(id_node, x.data()); m_Grid->GetPoints()->SetPoint(id_node, x.data()); } for (vtkIdType id_cell = 0; id_cell < poly2ugrid->GetOutput()->GetNumberOfCells(); ++id_cell) { vtkIdType N_pts, *pts; vtkIdType type_cell = poly2ugrid->GetOutput()->GetCellType(id_cell); poly2ugrid->GetOutput()->GetCellPoints(id_cell, N_pts, pts); m_Grid->InsertNextCell(type_cell, N_pts, pts); } EG_VTKDCC(vtkIntArray, bc, m_Grid, "cell_code"); EG_VTKDCC(vtkIntArray, orgdir, m_Grid, "cell_orgdir"); EG_VTKDCC(vtkIntArray, voldir, m_Grid, "cell_voldir"); EG_VTKDCC(vtkIntArray, curdir, m_Grid, "cell_curdir"); for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) { bc->SetValue(id_cell, 1); orgdir->SetValue(id_cell, 0); voldir->SetValue(id_cell, 0); curdir->SetValue(id_cell, 0); } if (check_passed) { CorrectSurfaceOrientation corr_surf; corr_surf.setGrid(m_Grid); corr_surf(); FixCadGeometry cad_fix; cad_fix.setGrid(m_Grid); cad_fix(); } }
void RestrictToAvailableVolumeCells::operate() { QList<vtkIdType> vol_cells, surf_cells; for (vtkIdType id_cell = 0; id_cell < m_Grid->GetNumberOfCells(); ++id_cell) { if (isVolume(id_cell, m_Grid)) { vol_cells.append(id_cell); } } foreach (vtkIdType id_cell, vol_cells) { for (int i = 0; i < m_Part.c2cGSize(id_cell); ++i) { vtkIdType id_neigh = m_Part.c2cGG(id_cell, i); if (id_neigh >= 0) { if (isSurface(id_neigh, m_Grid)) { surf_cells.append(id_neigh); } } } } MeshPartition vol_part(m_Grid); vol_part.setCells(vol_cells + surf_cells); EG_VTKSP(vtkUnstructuredGrid, new_grid1); vol_part.extractToVtkGrid(new_grid1); MeshPartition new_part1(new_grid1, true); QList<QVector<vtkIdType> > new_faces; for (vtkIdType id_cell = 0; id_cell < new_grid1->GetNumberOfCells(); ++id_cell) { if (isVolume(id_cell, new_grid1)) { for (int i = 0; i < new_part1.c2cGSize(id_cell); ++i) { vtkIdType id_neigh = new_part1.c2cGG(id_cell, i); if (id_neigh == -1) { QVector<vtkIdType> pts; getFaceOfCell(new_grid1, id_cell, i, pts); new_faces.append(pts); } } } } EG_VTKSP(vtkUnstructuredGrid, new_grid2); allocateGrid(new_grid2, new_grid1->GetNumberOfCells() + new_faces.size(), new_grid1->GetNumberOfPoints()); EG_VTKDCC(vtkIntArray, cell_code1, new_grid1, "cell_code"); EG_VTKDCC(vtkIntArray, cell_code2, new_grid2, "cell_code"); for (vtkIdType id_node = 0; id_node < new_grid1->GetNumberOfPoints(); ++id_node) { vec3_t x; new_grid1->GetPoint(id_node, x.data()); new_grid2->GetPoints()->SetPoint(id_node, x.data()); copyNodeData(new_grid1, id_node, new_grid2, id_node); } int bc_new = 0; for (vtkIdType id_cell = 0; id_cell < new_grid1->GetNumberOfCells(); ++id_cell) { copyCell(new_grid1, id_cell, new_grid2); copyCellData(new_grid1, id_cell, new_grid2, id_cell); if (isSurface(id_cell, new_grid1)) { bc_new = max(bc_new, cell_code1->GetValue(id_cell) + 1); } else { cell_code2->SetValue(id_cell, 0); } } foreach (QVector<vtkIdType> face, new_faces) { vtkIdType type = VTK_POLYGON; if (face.size() == 3) { type = VTK_TRIANGLE; } else if (face.size() == 4) { type = VTK_QUAD; } vtkIdType id_cell = new_grid2->InsertNextCell(type, face.size(), face.data()); cell_code2->SetValue(id_cell, bc_new); }
void CreateCadTesselation::scan(bool create_grid, int interlaces) { m_Dx = (m_X2[0] - m_X1[0])/(m_Ni-1); m_Dy = (m_X2[1] - m_X1[1])/(m_Nj-1); m_Dz = (m_X2[2] - m_X1[2])/(m_Nk-1); EG_VTKSP(vtkImageData, gdata); gdata->SetDimensions(m_Ni, m_Nj, m_Nk); EG_VTKSP(vtkFloatArray, g); g->SetName("g"); g->SetNumberOfValues(m_Ni*m_Nj*m_Nk); gdata->GetPointData()->AddArray(g); for (int i = 0; i < m_Ni; ++i) { for (int j = 0; j < m_Nj; ++j) { for (int k = 0; k < m_Nk; ++k) { if (preserveFluid()) { g->SetValue(getIdx(i,j,k), 1); } else { g->SetValue(getIdx(i,j,k), 0); } } } } m_XScan1 = m_X2; m_XScan2 = m_X1; vec3_t x_in, x_out, n_in, n_out; int progress = 0; m_GeometryFound = false; double dxi = m_Dx/(interlaces + 1); double dyi = m_Dy/(interlaces + 1); double dzi = m_Dz/(interlaces + 1); double shift = 1e-6; // scan ij plane -> k direction // xy plane -> z direction for (int i = 0; i < m_Ni; ++i) { for (int j = 0; j < m_Nj; ++j) { vec3_t x0 = getX(i,j,0); for (int i_il = 0; i_il <= interlaces; ++i_il) { for (int j_il = 0; j_il <= interlaces; ++j_il) { vec3_t x = x0; x[0] += i_il*dxi; x[1] += j_il*dyi; int k_last = 0; while (shootRay(x, vec3_t(0,0,1), x_in, x_out, n_in, n_out)) { m_GeometryFound = true; m_XScan1[2] = min(m_XScan1[2], x_in[2]); m_XScan2[2] = max(m_XScan2[2], x_out[2]); int k1 = int((x_in[2] - m_X1[2])/m_Dz) + 1; int k2 = int((x_out[2] - m_X1[2])/m_Dz); if (preserveFluid()) { for (int k = k_last; k < min(m_Nk-1,k1); ++k) { g->SetValue(getIdx(i,j,k), 0); } } else { for (int k = max(0,k1); k <= min(m_Nk-1,k2); ++k) { g->SetValue(getIdx(i,j,k), 1); } } x = x_out; x[2] += shift*m_Dz; k_last = min(m_Nk-1,k2+1); } if (preserveFluid()) { for (int k = k_last; k <= m_Nk-1; ++k) { g->SetValue(getIdx(i,j,k), 0); } } } } } progress += m_Nj; GuiMainWindow::pointer()->setProgress(progress); } // scan ik plane -> j direction // xz plane -> y direction for (int i = 0; i < m_Ni; ++i) { for (int k = 0; k < m_Nk; ++k) { vec3_t x0 = getX(i,0,k); for (int i_il = 0; i_il <= interlaces; ++i_il) { for (int k_il = 0; k_il <= interlaces; ++k_il) { vec3_t x = x0; x[0] += i_il*dxi; x[2] += k_il*dzi; int j_last = 0; /* if (fabs(x0[0]) < 1.5 && fabs(x0[2]) < 1.5 && create_grid) { cout << x0 << endl; } */ while (shootRay(x, vec3_t(0,1,0), x_in, x_out, n_in, n_out)) { m_GeometryFound = true; m_XScan1[1] = min(m_XScan1[1], x_in[1]); m_XScan2[1] = max(m_XScan2[1], x_out[1]); int j1 = int((x_in[1]-m_X1[1])/m_Dy) + 1; int j2 = int((x_out[1]-m_X1[1])/m_Dy); if (preserveFluid()) { for (int j = j_last; j < min(m_Nj-1,j1); ++j) { g->SetValue(getIdx(i,j,k), 0); } } else { for (int j = max(0,j1); j <= min(m_Nj-1,j2); ++j) { g->SetValue(getIdx(i,j,k), 1); } } x = x_out; x[1] += shift*m_Dy; j_last = min(m_Nj-1,j2+1); } if (preserveFluid()) { for (int j = j_last; j <= m_Nj-1; ++j) { g->SetValue(getIdx(i,j,k), 0); } } } } } progress += m_Nk; GuiMainWindow::pointer()->setProgress(progress); } // scan jk plane -> i direction // yz plane -> x direction for (int j = 0; j < m_Nj; ++j) { for (int k = 0; k < m_Nk; ++k) { vec3_t x0 = getX(0,j,k); for (int j_il = 0; j_il <= interlaces; ++j_il) { for (int k_il = 0; k_il <= interlaces; ++k_il) { vec3_t x = x0; x[1] += j_il*dyi; x[2] += k_il*dzi; int i_last = 0; while (shootRay(x, vec3_t(1,0,0), x_in, x_out, n_in, n_out)) { m_GeometryFound = true; m_XScan1[0] = min(m_XScan1[0], x_in[0]); m_XScan2[0] = max(m_XScan2[0], x_out[0]); int i1 = int((x_in[0]-m_X1[0])/m_Dx) + 1; int i2 = int((x_out[0]-m_X1[0])/m_Dx); if (preserveFluid()) { for (int i = i_last; i < min(m_Ni-1,i1); ++i) { g->SetValue(getIdx(i,j,k), 0); } } else { for (int i = max(0,i1); i <= min(m_Ni-1,i2); ++i) { g->SetValue(getIdx(i,j,k), 1); } } x = x_out; x[0] += shift*m_Dx; i_last = min(m_Ni-1,i2+1); } if (preserveFluid()) { for (int i = i_last; i <= m_Ni-1; ++i) { g->SetValue(getIdx(i,j,k), 0); } } } } } progress += m_Nk; GuiMainWindow::pointer()->setProgress(progress); } if (create_grid) { GuiMainWindow::pointer()->resetProgress("smoothing", m_Ni*m_Nj*m_Nk*m_NumIterations); // smooth image data int progress = 0; for (int iter = 1; iter <= m_NumIterations; ++iter) { for (int i = 1; i < m_Ni-1; ++i) { for (int j = 1; j < m_Nj-1; ++j) { for (int k = 1; k < m_Nk-1; ++k) { int idx = getIdx(i,j,k); bool preserve = false; if (m_PreservationType == 1 && g->GetValue(idx) > 0.999) { preserve = true; } if (m_PreservationType == 2 && g->GetValue(idx) < 0.001) { preserve = true; } if (!preserve) { double g_new = 0; g_new += g->GetValue(getIdx(i+1,j,k)); g_new += g->GetValue(getIdx(i-1,j,k)); g_new += g->GetValue(getIdx(i,j+1,k)); g_new += g->GetValue(getIdx(i,j-1,k)); g_new += g->GetValue(getIdx(i,j,k+1)); g_new += g->GetValue(getIdx(i,j,k-1)); g_new *= 1.0/6.0; g->SetValue(idx, g_new); } } } progress += m_Nj*m_Nk; GuiMainWindow::pointer()->setProgress(progress); } } // write image data for testing and reporting purposes EG_VTKSP(vtkXMLImageDataWriter, vti); QString file_name = GuiMainWindow::pointer()->getCwd() + "/g.vti"; vti->SetFileName(qPrintable(file_name)); vti->SetDataModeToBinary(); vti->SetInputData(gdata); vti->Write(); gdata->GetPointData()->SetActiveScalars("g"); EG_VTKSP(vtkContourFilter, contour); contour->SetInputData(gdata); contour->SetNumberOfContours(1); double g_level = 0.5; if (m_PreservationType == 1) { g_level = 0.5; } if (m_PreservationType == 2) { g_level = 0.5; } contour->SetValue(0, g_level); EG_VTKSP(vtkTriangleFilter, tri); tri->SetInputConnection(contour->GetOutputPort()); EG_VTKSP(vtkDecimatePro, decimate); decimate->PreserveTopologyOn(); decimate->SetTargetReduction(m_TargetReduction); decimate->SetFeatureAngle(GeometryTools::deg2rad(45)); decimate->SetInputConnection(tri->GetOutputPort()); decimate->Update(); allocateGrid(m_Grid, decimate->GetOutput()->GetNumberOfPolys(), decimate->GetOutput()->GetNumberOfPoints()); for (vtkIdType id_node = 0; id_node < m_Grid->GetNumberOfPoints(); ++id_node) { vec3_t x; decimate->GetOutput()->GetPoint(id_node, x.data()); x[0] = m_X1[0] + x[0]*m_Dx; x[1] = m_X1[1] + x[1]*m_Dx; x[2] = m_X1[2] + x[2]*m_Dx; m_Grid->GetPoints()->SetPoint(id_node, x.data()); } EG_VTKDCC(vtkIntArray, cell_code, m_Grid, "cell_code"); for (vtkIdType id_cell = 0; id_cell < decimate->GetOutput()->GetNumberOfPolys(); ++id_cell) { EG_GET_CELL(id_cell, decimate->GetOutput()); vtkIdType id_new_cell = m_Grid->InsertNextCell(type_cell, num_pts, pts); cell_code->SetValue(id_new_cell, 1); } } }
void BlenderReader::operate() { try { QFileInfo file_info(GuiMainWindow::pointer()->getFilename()); readInputFileName(file_info.completeBaseName() + ".begc", false); if (isValid()) { // read raw data from exported file QFile file(getFileName()); file.open(QIODevice::ReadOnly | QIODevice::Text); QTextStream f(&file); QList<vec3_t> rnodes; QList<QVector<int> > rfaces; int num_parts; f >> num_parts; QVector<QString> part_name(num_parts); for (int i_part = 0; i_part < num_parts; ++i_part) { f >> part_name[i_part]; } QVector<QString> sorted_part_name = part_name; qSort(sorted_part_name); QVector<int> part_bc(part_name.size()); for (int i_part = 0; i_part < num_parts; ++i_part) { part_bc[i_part] = sorted_part_name.indexOf(part_name[i_part]) + 1; } for (int i_part = 0; i_part < num_parts; ++i_part) { int num_nodes, num_faces; f >> num_nodes >> num_faces; for (int i = 0; i < num_nodes; ++i) { vec3_t x; f >> x[0] >> x[1] >> x[2]; rnodes.push_back(x); } for (int i = 0; i < num_faces; ++i) { int N; f >> N; QVector<int> face(N+1); face[0] = i_part; for (int j = 0; j < N; ++j) { f >> face[j+1]; } rfaces.push_back(face); } } QVector<vec3_t> nodes(rnodes.size()); qCopy(rnodes.begin(), rnodes.end(), nodes.begin()); QVector<QVector<int> > faces(rfaces.size()); qCopy(rfaces.begin(), rfaces.end(), faces.begin()); // find smallest edge length double L = 1e99; foreach (QVector<int> face, faces) { for (int i = 1; i < face.size(); ++i) { int n1 = face[i]; int n2 = face[1]; if (i < face.size() - 1) { n2 = face[i+1]; } double l = (nodes[n1] - nodes[n2]).abs(); L = min(l, L); } } cout << "smallest edge length is " << L << endl; // delete duplicate nodes PointFinder finder; finder.setPoints(nodes); QList<vec3_t> non_dup; QVector<int> o2n(nodes.size()); int num_non_dup = 0; for (int i = 0; i < nodes.size(); ++i) { o2n[i] = num_non_dup; bool dup = false; QVector<int> close_points; finder.getClosePoints(nodes[i], close_points); foreach (int j, close_points) { if (i > j) { double l = (nodes[i] - nodes[j]).abs(); if (l < m_RelativeTolerance*L || l == 0) { o2n[i] = o2n[j]; dup = true; break; } } } if (!dup) { non_dup.push_back(nodes[i]); ++num_non_dup; } } EG_VTKSP(vtkUnstructuredGrid, new_grid); allocateGrid(new_grid, faces.size(), non_dup.size()); EG_VTKDCC(vtkIntArray, cell_code, new_grid, "cell_code"); EG_VTKDCC(vtkIntArray, orgdir, new_grid, "cell_orgdir"); EG_VTKDCC(vtkIntArray, voldir, new_grid, "cell_voldir"); EG_VTKDCC(vtkIntArray, curdir, new_grid, "cell_curdir"); vtkIdType id_node = 0; foreach (vec3_t x, non_dup) { new_grid->GetPoints()->SetPoint(id_node, x.data()); ++id_node; } foreach (QVector<int> face, faces) { if (face.size() == 4) { vtkIdType pts[3]; pts[0] = o2n[face[1]]; pts[1] = o2n[face[2]]; pts[2] = o2n[face[3]]; vtkIdType id_cell = new_grid->InsertNextCell(VTK_TRIANGLE, 3, pts); cell_code->SetValue(id_cell, part_bc[face[0]]); orgdir->SetValue(id_cell, 0); voldir->SetValue(id_cell, 0); curdir->SetValue(id_cell, 0); } if (face.size() == 5) { vtkIdType pts[4]; pts[0] = o2n[face[1]]; pts[1] = o2n[face[2]]; pts[2] = o2n[face[3]]; pts[3] = o2n[face[4]]; vtkIdType id_cell = new_grid->InsertNextCell(VTK_QUAD, 4, pts); cell_code->SetValue(id_cell, part_bc[face[0]]); orgdir->SetValue(id_cell, 0); voldir->SetValue(id_cell, 0); curdir->SetValue(id_cell, 0); } } if (m_Append) { EG_BUG; MeshPartition new_part(new_grid); new_part.setAllCells(); m_Part.addPartition(new_part); } else { makeCopy(new_grid, m_Grid); } UpdateNodeIndex(m_Grid); UpdateCellIndex(m_Grid); // check and set the boundary names if required int update_required = true; QSet<int> old_bcs = GuiMainWindow::pointer()->getAllBoundaryCodes(); if (old_bcs.size() == part_name.size()) { QSet<QString> old_names; foreach (int bc, old_bcs) { old_names.insert(GuiMainWindow::pointer()->getBC(bc).getName()); } QSet<QString> new_names; foreach (QString name, part_name) { new_names.insert(name); }