static void drawElementLabels(drawContext *ctx, GEntity *e,
std::vector<T*> &elements, int forceColor=0,
unsigned int color=0)
{
unsigned col = forceColor ? color : getColorByEntity(e);
glColor4ubv((GLubyte *) & col);
int labelStep = CTX::instance()->mesh.labelSampling;
if(labelStep <= 0) labelStep = 1;
for(unsigned int i = 0; i < elements.size(); i++){
MElement *ele = elements[i];
if(!isElementVisible(ele)) continue;
if(i % labelStep == 0) {
SPoint3 pc = ele->barycenter();
char str[256];
if(CTX::instance()->mesh.labelType == 4)
sprintf(str, "(%g,%g,%g)", pc.x(), pc.y(), pc.z());
else if(CTX::instance()->mesh.labelType == 3)
sprintf(str, "%d", ele->getPartition());
else if(CTX::instance()->mesh.labelType == 2){
int np = e->physicals.size();
int p = np ? e->physicals[np - 1] : 0;
sprintf(str, "%d", p);
}
else if(CTX::instance()->mesh.labelType == 1)
sprintf(str, "%d", e->tag());
else
sprintf(str, "%d", ele->getNum());
glRasterPos3d(pc.x(), pc.y(), pc.z());
ctx->drawString(str);
}
}
}
static void drawTangents(drawContext *ctx, std::vector<T*> &elements)
{
glColor4ubv((GLubyte *) & CTX::instance()->color.mesh.tangents);
for(unsigned int i = 0; i < elements.size(); i++){
MElement *ele = elements[i];
if(!isElementVisible(ele)) continue;
SVector3 t = ele->getEdge(0).tangent();
for(int j = 0; j < 3; j++)
t[j] *= CTX::instance()->mesh.tangents * ctx->pixel_equiv_x / ctx->s[j];
SPoint3 pc = ele->barycenter();
ctx->drawVector(CTX::instance()->vectorType, 0, pc.x(), pc.y(), pc.z(),
t[0], t[1], t[2], CTX::instance()->mesh.light);
}
}
static void drawBarycentricDual(std::vector<T*> &elements)
{
glColor4ubv((GLubyte *) & CTX::instance()->color.fg);
glEnable(GL_LINE_STIPPLE);
glLineStipple(1, 0x0F0F);
gl2psEnable(GL2PS_LINE_STIPPLE);
glBegin(GL_LINES);
for(unsigned int i = 0; i < elements.size(); i++){
MElement *ele = elements[i];
if(!isElementVisible(ele)) continue;
SPoint3 pc = ele->barycenter();
if(ele->getDim() == 2){
for(int j = 0; j < ele->getNumEdges(); j++){
MEdge e = ele->getEdge(j);
SPoint3 p = e.barycenter();
glVertex3d(pc.x(), pc.y(), pc.z());
glVertex3d(p.x(), p.y(), p.z());
}
}
else if(ele->getDim() == 3){
for(int j = 0; j < ele->getNumFaces(); j++){
MFace f = ele->getFace(j);
SPoint3 p = f.barycenter();
glVertex3d(pc.x(), pc.y(), pc.z());
glVertex3d(p.x(), p.y(), p.z());
for(int k = 0; k < f.getNumVertices(); k++){
MEdge e(f.getVertex(k), (k == f.getNumVertices() - 1) ?
f.getVertex(0) : f.getVertex(k + 1));
SPoint3 pe = e.barycenter();
glVertex3d(p.x(), p.y(), p.z());
glVertex3d(pe.x(), pe.y(), pe.z());
}
}
}
}
glEnd();
glDisable(GL_LINE_STIPPLE);
gl2psDisable(GL2PS_LINE_STIPPLE);
}
void GMSH_SimplePartitionPlugin::run()
{
#if defined(HAVE_MESH)
int numSlicesX = (int)SimplePartitionOptions_Number[0].def;
int numSlicesY = (int)SimplePartitionOptions_Number[1].def;
int numSlicesZ = (int)SimplePartitionOptions_Number[2].def;
int createTopology = (int)SimplePartitionOptions_Number[3].def;
std::vector<std::string> exprX(1), exprY(1), exprZ(1);
exprX[0] = SimplePartitionOptions_String[0].def;
exprY[0] = SimplePartitionOptions_String[1].def;
exprZ[0] = SimplePartitionOptions_String[2].def;
GModel *m = GModel::current();
if(!m->getNumMeshElements()){
Msg::Error("Plugin(SimplePartition) requires a mesh");
return;
}
if(numSlicesX < 1 || numSlicesY < 1 || numSlicesZ < 1){
Msg::Error("Number of slices should be strictly positive");
return;
}
m->unpartitionMesh();
SBoundingBox3d bbox = m->bounds();
double pminX = bbox.min()[0], pmaxX = bbox.max()[0];
double pminY = bbox.min()[1], pmaxY = bbox.max()[1];
double pminZ = bbox.min()[2], pmaxZ = bbox.max()[2];
std::vector<double> ppX(numSlicesX + 1);
std::vector<double> ppY(numSlicesY + 1);
std::vector<double> ppZ(numSlicesZ + 1);
std::vector<std::string> variables(1, "t");
std::vector<double> values(1), res(1);
{
mathEvaluator f(exprX, variables);
for(int p = 0; p <= numSlicesX; p++) {
double t = values[0] = (double)p / (double)numSlicesX;
if(f.eval(values, res)) t = res[0];
ppX[p] = pminX + t * (pmaxX - pminX);
}
}
bool emptyX = (ppX[0] == ppX[numSlicesX]);
{
mathEvaluator f(exprY, variables);
for(int p = 0; p <= numSlicesY; p++) {
double t = values[0] = (double)p / (double)numSlicesY;
if(f.eval(values, res)) t = res[0];
ppY[p] = pminY + t * (pmaxY - pminY);
}
}
bool emptyY = (ppY[0] == ppY[numSlicesY]);
{
mathEvaluator f(exprZ, variables);
for(int p = 0; p <= numSlicesZ; p++) {
double t = values[0] = (double)p / (double)numSlicesZ;
if(f.eval(values, res)) t = res[0];
ppZ[p] = pminZ + t * (pmaxZ - pminZ);
}
}
bool emptyZ = (ppZ[0] == ppZ[numSlicesZ]);
std::vector<GEntity *> entities;
m->getEntities(entities);
hashmap<MElement *, unsigned int> elmToPartition;
for(std::size_t i = 0; i < entities.size(); i++) {
GEntity *ge = entities[i];
for(std::size_t j = 0; j < ge->getNumMeshElements(); j++) {
MElement *e = ge->getMeshElement(j);
SPoint3 point = e->barycenter();
int part = 0;
for(int kx = 0; kx < numSlicesX; kx++) {
if(part) break;
for(int ky = 0; ky < numSlicesY; ky++) {
if(part) break;
for(int kz = 0; kz < numSlicesZ; kz++) {
if(part) break;
if((emptyX || (kx == 0 && ppX[0] == point[0]) ||
(ppX[kx] < point[0] && point[0] <= ppX[kx + 1])) &&
(emptyY || (ky == 0 && ppY[0] == point[1]) ||
(ppY[ky] < point[1] && point[1] <= ppY[ky + 1])) &&
(emptyZ || (kz == 0 && ppZ[0] == point[2]) ||
(ppZ[kz] < point[2] && point[2] <= ppZ[kz + 1]))){
part = kx * numSlicesY * numSlicesZ + ky * numSlicesZ + kz + 1;
elmToPartition.insert(std::pair<MElement *, unsigned int>(e, part));
e->setPartition(part); // this will be removed
}
}
}
}
}
}
opt_mesh_partition_create_topology(0, GMSH_SET | GMSH_GUI, createTopology);
int ier = PartitionUsingThisSplit(m, numSlicesX * numSlicesY * numSlicesZ,
elmToPartition);
if(!ier) {
opt_mesh_color_carousel(0, GMSH_SET | GMSH_GUI, 3.);
CTX::instance()->mesh.changed = ENT_ALL;
}
#else
Msg::Error("Gmsh must be compiled with Mesh support to partition meshes");
#endif
}
