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);
}
