SOrientedBoundingBox GEdge::getOBB()
{
if (!_obb) {
std::vector<SPoint3> vertices;
if(getNumMeshVertices() > 0) {
int N = getNumMeshVertices();
for (int i = 0; i < N; i++) {
MVertex* mv = getMeshVertex(i);
vertices.push_back(mv->point());
}
// Don't forget to add the first and last vertices...
SPoint3 pt1(getBeginVertex()->x(), getBeginVertex()->y(), getBeginVertex()->z());
SPoint3 pt2(getEndVertex()->x(), getEndVertex()->y(), getEndVertex()->z());
vertices.push_back(pt1);
vertices.push_back(pt2);
}
else if(geomType() != DiscreteCurve && geomType() != BoundaryLayerCurve){
Range<double> tr = this->parBounds(0);
// N can be choosen arbitrarily, but 10 points seems reasonable
int N = 10;
for (int i = 0; i < N; i++) {
double t = tr.low() + (double)i / (double)(N - 1) * (tr.high() - tr.low());
GPoint p = point(t);
SPoint3 pt(p.x(), p.y(), p.z());
vertices.push_back(pt);
}
}
else {
SPoint3 dummy(0, 0, 0);
vertices.push_back(dummy);
}
_obb = SOrientedBoundingBox::buildOBB(vertices);
}
return SOrientedBoundingBox(_obb);
}
int gmshEdge::minimumMeshSegments () const
{
int np;
if(geomType() == Line)
np = GEdge::minimumMeshSegments();
else if(geomType() == Circle || geomType() == Ellipse)
np = (int)(fabs(c->Circle.t1 - c->Circle.t2) *
(double)CTX::instance()->mesh.minCircPoints / M_PI) - 1;
else
np = CTX::instance()->mesh.minCurvPoints - 1;
return std::max(np, meshAttributes.minimumMeshSegments);
}
int OCCEdge::minimumDrawSegments() const
{
if(geomType() == Line)
return GEdge::minimumDrawSegments();
else
return CTX::instance()->geom.numSubEdges * GEdge::minimumDrawSegments();
}
void GRegion::writeGEO(FILE *fp)
{
if(geomType() == DiscreteVolume) return;
if(l_faces.size()){
fprintf(fp, "Surface Loop(%d) = ", tag());
for(std::list<GFace*>::iterator it = l_faces.begin(); it != l_faces.end(); it++) {
if(it != l_faces.begin())
fprintf(fp, ", %d", (*it)->tag());
else
fprintf(fp, "{%d", (*it)->tag());
}
fprintf(fp, "};\n");
fprintf(fp, "Volume(%d) = {%d};\n", tag(), tag());
}
if(meshAttributes.method == MESH_TRANSFINITE){
fprintf(fp, "Transfinite Volume {%d}", tag());
if(meshAttributes.corners.size()){
fprintf(fp, " = {");
for(unsigned int i = 0; i < meshAttributes.corners.size(); i++){
if(i) fprintf(fp, ",");
fprintf(fp, "%d", meshAttributes.corners[i]->tag());
}
fprintf(fp, "}");
}
fprintf(fp, ";\n");
if(meshAttributes.QuadTri != NO_QUADTRI )
fprintf(fp, "TransfQuadTri {%d};\n", tag());
}
}
char GEntity::getVisibility()
{
if(CTX::instance()->hideUnselected && !CTX::instance()->pickElements &&
!getSelection() && geomType() != ProjectionFace)
return false;
return _visible;
}
SBoundingBox3d GEdge::bounds() const
{
SBoundingBox3d bbox;
if(geomType() != DiscreteCurve && geomType() != BoundaryLayerCurve){
Range<double> tr = parBounds(0);
const int N = 10;
for(int i = 0; i < N; i++){
double t = tr.low() + (double)i / (double)(N - 1) * (tr.high() - tr.low());
GPoint p = point(t);
bbox += SPoint3(p.x(), p.y(), p.z());
}
}
else{
for(unsigned int i = 0; i < mesh_vertices.size(); i++)
bbox += mesh_vertices[i]->point();
}
return bbox;
}
void GEdge::writeGEO(FILE *fp)
{
if(!getBeginVertex() || !getEndVertex() || geomType() == DiscreteCurve) return;
if(geomType() == Line){
fprintf(fp, "Line(%d) = {%d, %d};\n",
tag(), getBeginVertex()->tag(), getEndVertex()->tag());
}
else{
// approximate other curves by splines
Range<double> bounds = parBounds(0);
double umin = bounds.low();
double umax = bounds.high();
fprintf(fp, "p%d = newp;\n", tag());
int N = minimumDrawSegments();
for(int i = 1; i < N; i++){
double u = umin + (double)i / N * (umax - umin);
GPoint p = point(u);
fprintf(fp, "Point(p%d + %d) = {%.16g, %.16g, %.16g};\n",
tag(), i, p.x(), p.y(), p.z());
}
fprintf(fp, "Spline(%d) = {%d", tag(), getBeginVertex()->tag());
for(int i = 1; i < N; i++)
fprintf(fp, ", p%d + %d", tag(), i);
fprintf(fp, ", %d};\n", getEndVertex()->tag());
}
if(meshAttributes.method == MESH_TRANSFINITE){
fprintf(fp, "Transfinite Line {%d} = %d",
tag() * (meshAttributes.typeTransfinite > 0 ? 1 : -1),
meshAttributes.nbPointsTransfinite);
if(meshAttributes.typeTransfinite){
if(std::abs(meshAttributes.typeTransfinite) == 1)
fprintf(fp, " Using Progression ");
else
fprintf(fp, " Using Bump ");
fprintf(fp, "%g", meshAttributes.coeffTransfinite);
}
fprintf(fp, ";\n");
}
if(meshAttributes.reverseMesh)
fprintf(fp, "Reverse Line {%d};\n", tag());
}
int gmshEdge::minimumDrawSegments () const
{
int n = List_Nbr(c->Control_Points) - 1;
if(!n) n = GEdge::minimumDrawSegments();
if(geomType() == Line && !c->geometry)
return n;
else
return CTX::instance()->geom.numSubEdges * n;
}
SBoundingBox3d GRegion::bounds() const
{
SBoundingBox3d res;
if(geomType() != DiscreteVolume){
std::list<GFace*>::const_iterator it = l_faces.begin();
for(; it != l_faces.end(); it++)
res += (*it)->bounds();
}
else{
for(unsigned int i = 0; i < mesh_vertices.size(); i++)
res += mesh_vertices[i]->point();
}
return res;
}
int OCCEdge::minimumMeshSegments() const
{
int np;
if(geomType() == Line)
np = GEdge::minimumMeshSegments();
else
np = CTX::instance()->mesh.minCurvPoints - 1;
// if the edge is closed, ensure that at least 3 points are
// generated in the 1D mesh (4 segments, one of which is
// degenerated)
if (getBeginVertex() == getEndVertex()) np = std::max(4, np);
return std::max(np, meshAttributes.minimumMeshSegments);
}
bool GEdge::computeDistanceFromMeshToGeometry (double &d2, double &dmax)
{
d2 = 0.0; dmax = 0.0;
if (geomType() == Line) return true;
if (!lines.size())return false;
IntPt *pts;
int npts;
lines[0]->getIntegrationPoints(2*lines[0]->getPolynomialOrder(), &npts, &pts);
for (unsigned int i = 0; i < lines.size(); i++){
MLine *l = lines[i];
double t[256];
for (int j=0; j< l->getNumVertices();j++){
MVertex *v = l->getVertex(j);
if (v->onWhat() == getBeginVertex()){
t[j] = getLowerBound();
}
else if (v->onWhat() == getEndVertex()){
t[j] = getUpperBound();
}
else {
v->getParameter(0,t[j]);
}
}
for (int j=0;j<npts;j++){
SPoint3 p;
l->pnt(pts[j].pt[0],0,0,p);
double tinit = l->interpolate(t,pts[j].pt[0],0,0);
GPoint pc = closestPoint(p, tinit);
if (!pc.succeeded())continue;
double dsq =
(pc.x()-p.x())*(pc.x()-p.x()) +
(pc.y()-p.y())*(pc.y()-p.y()) +
(pc.z()-p.z())*(pc.z()-p.z());
d2 += pts[i].weight * fabs(l->getJacobianDeterminant(pts[j].pt[0],0,0)) * dsq;
dmax = std::max(dmax,sqrt(dsq));
}
}
d2 = sqrt(d2);
return true;
}
void OCCEdge::writeGEO(FILE *fp)
{
if(geomType() == Circle){
gp_Pnt center;
if(curve.IsNull()){
center = Handle(Geom_Circle)::DownCast(curve2d)->Location();
}
else{
center = Handle(Geom_Circle)::DownCast(curve)->Location();
}
// GEO supports only circle arcs < Pi
if(s1 - s0 < M_PI){
fprintf(fp, "p%d = newp;\n", tag());
fprintf(fp, "Point(p%d + 1) = {%.16g, %.16g, %.16g};\n",
tag(), center.X(), center.Y(), center.Z());
fprintf(fp, "Circle(%d) = {%d, p%d + 1, %d};\n",
tag(), getBeginVertex()->tag(), tag(), getEndVertex()->tag());
}
else
GEdge::writeGEO(fp);
}
else
GEdge::writeGEO(fp);
}