//=================================================================================== // Function: locate_point_in_uv (Public) // Description: same as title (the_point must have coords (u,v,0.0)) // Author: chynes // Date: 7/10/02 //=================================================================================== CubitStatus FacetParamTool:: locate_point_in_uv(FacetSurface *surf, const CubitVector &the_point, CubitFacet *&tri_ptr) { CubitStatus rv = CUBIT_SUCCESS; DLIList<CubitFacet *> facet_list; int tool_id = surf->get_eval_tool()->tool_id(); surf->get_eval_tool()->get_facets(facet_list); tri_ptr = facet_list.get(); // loop until we find something CubitPoint *p0, *p1, *p2; double aa, bb, cc; double u0, u1, u2, v0, v1, v2; CubitBoolean found = CUBIT_FALSE; while(!found && rv == CUBIT_SUCCESS) { tri_ptr->points(p0, p1, p2); p0->get_uv(tri_ptr, u0, v0); p1->get_uv(tri_ptr, u1, v1); p2->get_uv(tri_ptr, u2, v2); aa = DETERM(the_point.x(), the_point.y(), u1, v1, u2, v2); bb = DETERM(u0, v0, the_point.x(), the_point.y(), u2, v2); cc = DETERM(u0, v0, u1, v1, the_point.x(), the_point.y()); if (aa > -INSIDE_TOL && bb > -INSIDE_TOL && cc > -INSIDE_TOL) { found = CUBIT_TRUE; // this is the one } else { // set up to check the next logical neighbor if (aa <= bb && aa <= cc) { int edge_index = 1; tri_ptr = tri_ptr->adjacent( edge_index, &tool_id ); } else if (bb <= aa && bb <= cc) { int edge_index = 2; tri_ptr = tri_ptr->adjacent( edge_index, &tool_id ); } else { int edge_index = 0; tri_ptr = tri_ptr->adjacent( edge_index, &tool_id); } // check to see if we've left the triangulation if (tri_ptr == NULL) { rv = exhaustive_locate_point_in_uv(surf, the_point, tri_ptr ); found = CUBIT_TRUE; } } } return rv; }
//=========================================================================== //Function Name: intersect // //Member Type: PUBLIC //Description: intersect the edge with a segment. Assumes segment and edge // are on the same plane (project to facet plane first) //=========================================================================== CubitStatus CubitFacetEdge::intersect( CubitVector &aa, CubitVector &bb, // end point of segment CubitVector &norm, // normal of the common plane CubitVector &qq, // return the intersection point CubitBoolean &does_intersect ) // return status of intersection { CubitPoint *pt0 = this->point(0); CubitPoint *pt1 = this->point(1); double P0[2], P1[2], AA[2], BB[2]; CubitVector absnorm(fabs(norm.x()), fabs(norm.y()), fabs(norm.z())); if (absnorm.x() >= absnorm.y() && absnorm.x() >= absnorm.z()) { P0[0] = pt0->coordinates().y(); P0[1] = pt0->coordinates().z(); P1[0] = pt1->coordinates().y(); P1[1] = pt1->coordinates().z(); AA[0] = aa.y(); AA[1] = aa.z(); BB[0] = bb.y(); BB[1] = bb.z(); } else if (absnorm.y() >= absnorm.x() && absnorm.y() >= absnorm.z()) { P0[0] = pt0->coordinates().z(); P0[1] = pt0->coordinates().x(); P1[0] = pt1->coordinates().z(); P1[1] = pt1->coordinates().x(); AA[0] = aa.z(); AA[1] = aa.x(); BB[0] = bb.z(); BB[1] = bb.x(); } else { P0[0] = pt0->coordinates().x(); P0[1] = pt0->coordinates().y(); P1[0] = pt1->coordinates().x(); P1[1] = pt1->coordinates().y(); AA[0] = aa.x(); AA[1] = aa.y(); BB[0] = bb.x(); BB[1] = bb.y(); } double QQ[4], s; int ninter = intersect_2D_segments(P0, P1, AA, BB, QQ); if (ninter != 1) { does_intersect = CUBIT_FALSE; return CUBIT_SUCCESS; } does_intersect = CUBIT_TRUE; double dx = P1[0] - P0[0]; double dy = P1[1] - P0[1]; if (fabs(dx) > fabs(dy)) s = (QQ[0] - P0[0]) / dx; else s = (QQ[1] - P0[1]) / dy; qq = pt0->coordinates() + s * (pt1->coordinates() - pt0->coordinates()); return CUBIT_SUCCESS; }
template <class Z> KDDTreeNode<Z> *KDDTree<Z>::recursive_balance (DIMENSION dim, int left, int right, KDDTreeNode<Z>** array, KDDTreeNode<Z>* parent) { if (left > right) { return NULL; } else { KDDTreeNode<Z>* P; int K; if (left != right) { K = modifind (dim, left, right, array); P = array[K]; } else { K = left; P = array[left]; } myNodeList.push (P); P->safetyBox.reset (P->boundingBox); for (int i = left; i <= right; i++) { CubitVector imin = array[i]->safetyBox.minimum(); CubitVector imax = array[i]->safetyBox.maximum(); CubitVector pmin = P->safetyBox.minimum(); CubitVector pmax = P->safetyBox.maximum(); if (imin.x() < pmin.x()) pmin.x (imin.x()); if (imin.y() < pmin.y()) pmin.y (imin.y()); if (imin.z() < pmin.z()) pmin.z (imin.z()); if (imax.x() > pmax.x()) pmax.x (imax.x()); if (imax.y() > pmax.y()) pmax.y (imax.y()); if (imax.z() > pmax.z()) pmax.z (imax.z()); P->safetyBox.reset (pmin, pmax); } DIMENSION nextDim; switch (dim) { case DIMX: nextDim = DIMY; break; case DIMY: nextDim = DIMZ; break; default: nextDim = DIMX; } P->set_disc (dim); P->parent = parent; P->left = recursive_balance (nextDim, left, K - 1, array, P); P->right = recursive_balance (nextDim, K + 1, right, array, P); return P; } }
//------------------------------------------------------------------------- // Purpose : Compute and return the bounding box for this sphere. // // Special Notes : // //------------------------------------------------------------------------- CubitBox SphereEvaluator::bounding_box( void ) const { CubitVector center = mTmatrix * mEvalData.center; CubitVector min( center.x() - mEvalData.radius, center.y() - mEvalData.radius, center.z() - mEvalData.radius ); CubitVector max( center.x() + mEvalData.radius, center.y() + mEvalData.radius, center.z() + mEvalData.radius ); CubitBox thebbox( min, max ); return thebbox; }
CubitStatus OCCSurface::principal_curvatures( CubitVector const& location, double& curvature_1, double& curvature_2, CubitVector* closest_location ) { BRepAdaptor_Surface asurface(*myTopoDSFace); gp_Pnt p(location.x(), location.y(), location.z()), newP(0.0, 0.0, 0.0); double minDist=0.0, u, v; int i; BRepLProp_SLProps SLP(asurface, 2, Precision::PConfusion()); Extrema_ExtPS ext(p, asurface, Precision::Approximation(), Precision::Approximation()); if (ext.IsDone() && (ext.NbExt() > 0)) { for ( i = 1 ; i <= ext.NbExt() ; i++ ) { if ( (i==1) || (p.Distance(ext.Point(i).Value()) < minDist) ) { minDist = p.Distance(ext.Point(i).Value()); newP = ext.Point(i).Value(); ext.Point(i).Parameter(u, v); SLP.SetParameters(u, v); } } } if (closest_location != NULL) *closest_location = CubitVector(newP.X(), newP.Y(), newP.Z()); if (SLP.IsCurvatureDefined()) { curvature_1 = SLP.MinCurvature(); curvature_2 = SLP.MaxCurvature(); } return CUBIT_SUCCESS; }
CubitPointContainment OCCSurface::point_containment( const CubitVector &point ) { TopoDS_Face *face = get_TopoDS_Face(); gp_Pnt p(point.x(), point.y(), point.z()); double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); //It's checking the state of the projected point of THIS Point BRepClass_FaceClassifier face_classifier; face_classifier.Perform(*face, p, tol); TopAbs_State state = face_classifier.State(); //if surface is part of a periodic TopoDS_Face, it'll check the point //againt the whole periodic Face, even it outside the occsurface //boundary, if it's on its periodic extension, it'll return as in. if (state == TopAbs_IN) { //double check if the point is projected on the surface CubitVector closest_point; this->closest_point_trimmed(point, closest_point); if(point.distance_between(closest_point) < tol) return CUBIT_PNT_INSIDE; else return CUBIT_PNT_OUTSIDE; } else if (state == TopAbs_OUT) return CUBIT_PNT_OUTSIDE; else if (state == TopAbs_ON) return CUBIT_PNT_BOUNDARY; return CUBIT_PNT_UNKNOWN; }
//=================================================================================== // Function: transform_to_xyz_local (Priavate) // Description: same as title // Author: Shiraj Khan // Date: 1/21/2003 //=================================================================================== CubitStatus LoopParamTool::transform_to_xyz_local(CubitVector &xyz_location, CubitVector &uv_location) { // Multiply by transformation matrix CubitVector vect; vect.x( uv_location.x() * Du.x() + uv_location.y() * Dv.x() ); vect.y( uv_location.x() * Du.y() + uv_location.y() * Dv.y() ); vect.z( uv_location.x() * Du.z() + uv_location.y() * Dv.z() ); // Translate from origin xyz_location = vect + uvCenter; return CUBIT_SUCCESS; }
double SurfaceOverlapFacet::distance_from_position( CubitVector &position ) { double s,t; Point3 tmp_point; tmp_point.x = position.x(); tmp_point.y = position.y(); tmp_point.z = position.z(); return agt->MinPointTriangle( tmp_point, this->t, s, t ); }
//-------------------------------------------------------------------------- //Algorithm: min_dist_sq //Description: Finds the minimum distance squared between the given // point and the box. If the point is on or in the box, the // min distance is zero. //-------------------------------------------------------------------------- template <class Z> MY_INLINE double RStarTree<Z>::min_dist_sq(CubitVector &q, CubitBox &b_box) { CubitVector b_min, b_max; b_min = b_box.minimum(); b_max = b_box.maximum(); double dist; CubitVector r; if ( q.x() < b_min.x() ) r.x(b_min.x()); else if ( q.x() > b_max.x() ) r.x(b_max.x()); else r.x(q.x()); if ( q.y() < b_min.y() ) r.y(b_min.y()); else if ( q.y() > b_max.y() ) r.y(b_max.y()); else r.y(q.y()); if ( q.z() < b_min.z() ) r.z(b_min.z()); else if ( q.z() > b_max.z() ) r.z(b_max.z()); else r.z(q.z()); dist = (q-r).length_squared(); return dist; }
//=========================================================================== //Function Name: closest_point // //Member Type: PUBLIC //Description: return the closest point on segment defined by the edge //=========================================================================== CubitStatus CubitFacetEdge::closest_point(const CubitVector &point, CubitVector &closest_point ) { //CubitStatus rv = CUBIT_SUCCESS; CubitPoint *pt0 = this->point(0); CubitPoint *pt1 = this->point(1); // the edge vector CubitVector e0 ( pt1->x() - pt0->x(), pt1->y() - pt0->y(), pt1->z() - pt0->z() ); double elen = e0.normalize(); // vector from vert0 to point CubitVector v0 ( point.x() - pt0->x(), point.y() - pt0->y(), point.z() - pt0->z() ); // project to edge double len = v0%e0; if (len <= 0.0) { closest_point = pt0->coordinates(); } else if( len >= elen ) { closest_point = pt1->coordinates(); } else { closest_point.x ( pt0->x() + e0.x() * len ); closest_point.y ( pt0->y() + e0.y() * len ); closest_point.z ( pt0->z() + e0.z() * len ); } return CUBIT_SUCCESS; }
//=================================================================================== // Function: exhaustive_locate_point_in_uv (Public) // Description: same as title // Author: chynes // Date: 7/10/02 //=================================================================================== CubitStatus FacetParamTool:: exhaustive_locate_point_in_uv(FacetSurface *surf, const CubitVector &the_point, CubitFacet *&tri_ptr) { CubitStatus rv = CUBIT_SUCCESS; DLIList<CubitFacet *> facet_list; surf->get_eval_tool()->get_facets(facet_list); // loop until we find something CubitPoint *p0, *p1, *p2; int ii; double aa, bb, cc; double u0, u1, u2, v0, v1, v2; CubitBoolean found = CUBIT_FALSE; for(ii = 0; ii < facet_list.size() && !found; ii++) { tri_ptr = facet_list.get_and_step(); tri_ptr->points(p0, p1, p2); p0->get_uv(tri_ptr, u0, v0); p1->get_uv(tri_ptr, u1, v1); p2->get_uv(tri_ptr, u2, v2); aa = DETERM(the_point.x(), the_point.y(), u1, v1, u2, v2); bb = DETERM(u0, v0, the_point.x(), the_point.y(), u2, v2); cc = DETERM(u0, v0, u1, v1, the_point.x(), the_point.y()); if (aa > -INSIDE_TOL && bb > -INSIDE_TOL && cc > -INSIDE_TOL) { found = CUBIT_TRUE; // this is the one } } if (!found) { rv = CUBIT_FAILURE; tri_ptr = NULL; } return rv; }
//------------------------------------------------------------------------- // Purpose : make arbitrary parameterization // // Special Notes : // // Creator : Jason Kraftcheck // // Creation Date : 07/06/98 //------------------------------------------------------------------------- void ParamCubitPlane::make_parameterization() { //Choose the zero-point for the parameterization //as close to the origin as possible. // p_.set( 0.0, 0.0, 0.0); // move_to_plane( p_ ); is_plane_valid_ = CUBIT_TRUE; const CubitVector temp_p(0.0, 0.0, 0.0); CubitStatus s = closest_point( temp_p, p_ ); assert( s == CUBIT_SUCCESS ); CubitVector n = normal(); CubitVector p1; p1 = p_; double x = fabs( n.x() ); double y = fabs( n.y() ); double z = fabs( n.z() ); //Choose a direction from the zero point (p_) for //the second point as the direction of the smallest //component of the normal. The third point defining //the plane will be defined by the cross product of //the vector from the zero_point to this point and //the normal vector of the plane. if( (x <= y) && (x <= z) ) { p1.x( p1.x() + 1 ); } else if( (y <= x) && (y <= z) ) { p1.y( p1.y() + 1 ); } else { p1.z( p1.z() + 1 ); } move_to_plane( p1 ); s_ = p1 - p_; t_ = -(s_ * n); n_ = s_ * t_; double n_len = n_.length(); if( 1000 * CUBIT_DBL_MIN > n_len ) n_epsilon_ = CUBIT_DBL_MIN; else n_epsilon_ = n_len / 1000; is_plane_valid_= CUBIT_TRUE; }
//=================================================================================== // Function: transform_to_uv_local (Private) // Description: It transforms points from the Best Fit plane plane to UV space // Author: Shiraj Khan // Date: 1/21/2003 //=================================================================================== CubitStatus LoopParamTool::transform_to_uv_local(CubitVector &xyz_location, CubitVector &uv_location) { // Translate to local origin at center CubitVector vect = xyz_location - uvCenter; // Multiply by transpose (inverse) of transformation vector uv_location.x( vect % Du ); uv_location.y( vect % Dv ); uv_location.z( 1.0 ); return CUBIT_SUCCESS; }
//------------------------------------------------------------------------- // Purpose : Computes the closest_point on the surface to the input // location. Optionally, it also computes and returns // the normal to the surface at closest_location and the // principal curvatures(1-min, 2-max) // //------------------------------------------------------------------------- CubitStatus OCCSurface::closest_point( CubitVector const& location, CubitVector* closest_location, CubitVector* unit_normal_ptr, CubitVector* curvature_1, CubitVector* curvature_2) { BRepAdaptor_Surface asurface(*myTopoDSFace); gp_Pnt p(location.x(), location.y(), location.z()), newP(0.0, 0.0, 0.0); double minDist=0.0, u, v; int i; BRepLProp_SLProps SLP(asurface, 2, Precision::PConfusion()); Extrema_ExtPS ext(p, asurface, Precision::Approximation(), Precision::Approximation()); if (ext.IsDone() && (ext.NbExt() > 0)) { for ( i = 1 ; i <= ext.NbExt() ; i++ ) { if ( (i==1) || (p.Distance(ext.Point(i).Value()) < minDist) ) { minDist = p.Distance(ext.Point(i).Value()); newP = ext.Point(i).Value(); ext.Point(i).Parameter(u, v); SLP.SetParameters(u, v); } } if (closest_location != NULL) *closest_location = CubitVector(newP.X(), newP.Y(), newP.Z()); if (unit_normal_ptr != NULL) { gp_Dir normal; //normal of a RefFace point to outside of the material if (SLP.IsNormalDefined()) { normal = SLP.Normal(); CubitSense sense = get_geometry_sense(); if(sense == CUBIT_REVERSED) normal.Reverse() ; *unit_normal_ptr = CubitVector(normal.X(), normal.Y(), normal.Z()); } } gp_Dir MaxD, MinD; if (SLP.IsCurvatureDefined()) { SLP.CurvatureDirections(MaxD, MinD); if (curvature_1 != NULL) *curvature_1 = CubitVector(MinD.X(), MinD.Y(), MinD.Z()); if (curvature_2 != NULL) *curvature_2 = CubitVector(MaxD.X(), MaxD.Y(), MaxD.Z()); } } return CUBIT_SUCCESS; }
//- "insert_node" //- Dynamically insert the data into the k-d tree //- //- Algorithm INSERT (From Bentley): //- This algoritm is passed an object "data" of class "Z", //- which has a bounding_box() method. If there is already //- a node in the tree with equal bounding box center point, //- it is put in the right subtree. //- I0. [Create new node] Create a node P with the bounding box //- specified, and set P.LEFT <- null, P.RIGHT <- null, and //- P.DISC <- null. //- I1. [Check for null tree] If ROOT = null, then set ROOT <- P //- and return CUBIT_SUCCESS; otherwise, set Q <- ROOT (Q //- will move down the tree). //- I2. [Compare] Compare the nodes and set the child in the //- correct direction to T. //- I3. [Move down] Set Q <- child of Q and go to I2. //- I4. [Insert new node in tree] Set the child of Q to P, then //- set the children of P to null. Set the discriminator of //- P to be the discriminator after that in Q. //- template <class Z> CubitStatus KDDTree<Z>::insert_node (KDDTreeNode<Z>* P) { KDDTreeNode<Z> *F = NULL; // father node KDDTreeNode<Z> *T; // temp node if (root == NULL) { root = P; P->set_disc (DIMX); } else { T = root; DIRECTION direction = DIR_NULL; while (T != NULL) { F = T; // remember the father direction = P->compare (T); CubitVector tmin = T->safetyBox.minimum(); CubitVector tmax = T->safetyBox.maximum(); CubitVector pmin = P->safetyBox.minimum(); CubitVector pmax = P->safetyBox.maximum(); if (pmin.x() < tmin.x()) tmin.x (pmin.x()); if (pmin.y() < tmin.y()) tmin.y (pmin.y()); if (pmin.z() < tmin.z()) tmin.z (pmin.z()); if (pmax.x() > tmax.x()) tmax.x (pmax.x()); if (pmax.y() > tmax.y()) tmax.y (pmax.y()); if (pmax.z() > tmax.z()) tmax.z (pmax.z()); T->safetyBox.reset (tmin, tmax); T = T->get_child (direction); } F->set_child (P, direction); P->set_disc (F->next_disc()); P->parent = F; } myNodeList.push (P); return CUBIT_SUCCESS; }
//------------------------------------------------------------------------- // Purpose : Computes the closest_point on the trimmed surface to the // input location. // // Special Notes : //------------------------------------------------------------------------- void OCCSurface::closest_point_trimmed( CubitVector from_point, CubitVector& point_on_surface) { BRepAdaptor_Surface asurface(*myTopoDSFace); gp_Pnt p(from_point.x(), from_point.y(), from_point.z()), newP(0.0, 0.0, 0.0); double minDist=0.0; int i; Extrema_ExtPS ext(p, asurface, Precision::Approximation(), Precision::Approximation()); if (ext.IsDone() && (ext.NbExt() > 0)) { for ( i = 1 ; i <= ext.NbExt() ; i++ ) { if ( (i==1) || (p.Distance(ext.Point(i).Value()) < minDist) ) { minDist = p.Distance(ext.Point(i).Value()); newP = ext.Point(i).Value(); } } } point_on_surface = CubitVector(newP.X(), newP.Y(), newP.Z()); }
//- Finds the minimum distance squared between the given point and the box. If //- the point is on or in the box, the min distance is zero. template <class Z> double KDDTree<Z>::min_dist_sq (CubitVector &q, CubitBox &b_box) { CubitVector b_min = b_box.minimum(); CubitVector b_max = b_box.maximum(); CubitVector r; //// set "r" in the x-dim if (q.x () < b_min.x ()) { r.x (b_min.x ()); } else if (q.x () > b_max.x ()) { r.x (b_max.x ()); } else { r.x (q.x ()); } //// set "r" in the y-dim if (q.y () < b_min.y ()) { r.y (b_min.y ()); } else if (q.y () > b_max.y ()) { r.y (b_max.y ()); } else { r.y (q.y ()); } //// set "r" in the z-dim if (q.z () < b_min.z ()) { r.z (b_min.z ()); } else if (q.z () > b_max.z ()) { r.z (b_max.z ()); } else { r.z (q.z ()); } double dist = (q-r).length_squared(); return dist; }
void CompositePoint::print_debug_info( const char* prefix, bool brief ) const { if( prefix == 0 ) prefix = ""; #ifdef TOPOLOGY_BRIDGE_IDS PRINT_INFO("%sCompositePoint %d : %s %d\n", prefix, get_id(), realPoint ? fix_type_name(typeid(*realPoint).name()) : "NO REAL POINT", realPoint ? realPoint->get_id() : 0 ); #else PRINT_INFO("%sCompositePoint %p : %s %p\n", prefix, this, realPoint ? fix_type_name(typeid(*realPoint).name()) : "NO REAL POINT", realPoint); #endif if ( !brief ) { CubitVector p = coordinates(); PRINT_INFO("%s (%f,%f,%f)\n", prefix, p.x(), p.y(), p.z() ); } }
//=================================================================================== // Function: transform_to_xyz (Public) // Description: same as title // Author: chynes // Date: 7/10/02 //=================================================================================== CubitStatus PeriodicParamTool::transform_to_xyz(CubitVector &xyz_location, const CubitVector &uv_location) { double u = uv_location.x(); if (mirrorSurface) { u = -u; } if (u > uPeriod) { u = u - uPeriod; } double v = uv_location.y(); if (v > vPeriod) { v = v - vPeriod; } xyz_location = refSurf->position_from_u_v(u,v); return CUBIT_SUCCESS; }
//------------------------------------------------------------------------- // Purpose : This function returns the {u, v} coordinates of the point // on the Surface closest to the input point (specified in // global space). The closest_location is also returned. // // Special Notes : // //------------------------------------------------------------------------- CubitStatus OCCSurface::u_v_from_position( CubitVector const& location, double& u, double& v, CubitVector* closest_location ) { BRepAdaptor_Surface asurface(*myTopoDSFace); Handle(Geom_Surface) surface = BRep_Tool::Surface(*myTopoDSFace); gp_Pnt p(location.x(), location.y(), location.z()), newP(0.0, 0.0, 0.0); GeomAPI_ProjectPointOnSurf projection( p, surface); if(projection.NbPoints() > 0) { if(projection.LowerDistance() < Precision::Confusion() ) { projection.LowerDistanceParameters(u, v); return CUBIT_SUCCESS; } } double minDist=0.0; int i; Extrema_ExtPS ext(p, asurface, Precision::Confusion(), Precision::Confusion()); if (ext.IsDone() && (ext.NbExt() > 0)) { for ( i = 1 ; i <= ext.NbExt() ; i++ ) { if ( (i==1) || (p.Distance(ext.Point(i).Value()) < minDist) ) { minDist = p.Distance(ext.Point(i).Value()); newP = ext.Point(i).Value(); ext.Point(i).Parameter(u, v); } } } if (closest_location != NULL) *closest_location = CubitVector(newP.X(), newP.Y(), newP.Z()); if (ext.IsDone() && (ext.NbExt() > 0)) return CUBIT_SUCCESS; Handle(ShapeAnalysis_Surface) su = new ShapeAnalysis_Surface(surface); gp_Pnt2d suval = su->ValueOfUV(p, BRep_Tool::Tolerance(*myTopoDSFace)); suval.Coord(u, v); return CUBIT_SUCCESS; }
bool CamalPaveDriver::prepareCGMEvaluator() { // // we will have to mesh every geo edge separately, and we have to ensure that the number of mesh edges // for a face is even. // pretty tough to do. Initially, we have to decide loops, number of edges on each face, etc // first build //int err; // get the triangles and the vertices from moab set /*iBase_EntityHandle *triangles = NULL; int triangles_alloc = 0; iBase_EntityHandle *vert_adj = NULL; int vert_adj_alloc = 0, vert_adj_size; int numTriangles; int * offsets = NULL, offsets_alloc = 0, indices_size; int * indices = NULL, indices_alloc = 0, offsets_size; iMesh_getAdjEntIndices(_meshIface, _set, iBase_FACE, iMesh_TRIANGLE, iBase_VERTEX, &triangles, &triangles_alloc, &numTriangles, &vert_adj, &vert_adj_alloc, &vert_adj_size, &indices, &indices_alloc, &indices_size, &offsets, &offsets_alloc, &offsets_size, &err); ERRORR("Couldn't get connectivity for triangles.", 1);*/ MBRange triangles; MBErrorCode rval = _mb->get_entities_by_type( 0 /* root set, as above, we know */, MBTRI, triangles); // get all the nodes MBRange vertices; rval = _mb->get_adjacencies(triangles, 0, false, vertices, MBInterface::UNION); // first, create CubitPointData list, from the coordinates in one array /* get the coordinates in one array */ /*int vert_coords_alloc = 0, vertex_coord_size; double * xyz = NULL; iMesh_getVtxArrCoords(_meshIface, vert_adj, vert_adj_size, iBase_INTERLEAVED, &xyz, &vert_coords_alloc, &vertex_coord_size, &err); ERRORR("Couldn't get coordinates for vertices.", 1);*/ // here, we use Cholla from CGM // we need to replace it with something equivalent, but simpler // the first try would be some tags in MOAB // create the cubit point data // initialize CGM AppUtil::instance()->startup(0, NULL); CGMApp::instance()->startup(0, NULL); // Initialize the GeometryTool GeometryQueryTool *gqt = GeometryQueryTool::instance(); FacetModifyEngine *fme = FacetModifyEngine::instance(); int vert_adj_size = vertices.size(); int numTriangles = triangles.size(); DLIList<CubitFacet*> f_list(numTriangles); DLIList<CubitPoint*> p_list(vert_adj_size); double * xyz = new double [3*vert_adj_size]; rval = _mb-> get_coords(vertices, xyz); //std::map<MBEntityHandle, CubitPoint *> mapPoints; //MBRange::iterator it = vertices.begin(); for (int i = 0; i < vert_adj_size; i++/*, it++*/) { double * pCoord = &xyz[3 * i]; CubitPointData * newPoint = new CubitPointData(pCoord[0], pCoord[1], pCoord[2]); p_list.append(newPoint); //mapPoints[*it] = newPoint;// or maybe we should use finding the index in MBRange?? } // yes // define all the triangles, to see what we have for (MBRange::iterator it = triangles.begin(); it!=triangles.end(); it++) { MBEntityHandle tri = *it; int nnodes; const MBEntityHandle * conn3;// _mb->get_connectivity(tri, conn3, nnodes); assert(nnodes == 3); int vtri[3];// indices for triangles int ii = 0; for (ii = 0; ii < 3; ii++) vtri[ii] = vertices.index(conn3[ii]); // vtri[ii] = indices[offsets[j] + ii]; CubitFacetData * triangle = new CubitFacetData(p_list[vtri[0]], p_list[vtri[1]], p_list[vtri[2]]); f_list.append(triangle); } DLIList<LoopSM*> my_loops; DLIList<Surface*> surf_list; CubitStatus result; //double angle = 0.01;// very small, negligible; is this radians or degrees? result = fme->build_facet_surface(NULL, f_list, p_list, _angle, 4, true, false, surf_list); if (surf_list.size() == 0 || result != CUBIT_SUCCESS) { PRINT_ERROR("Problems building mesh based surfaces.\n"); return result; } else PRINT_INFO("Constructed %d surfaces.\n", surf_list.size()); //Now build the shell. If we had it set up right this would be //in a loop. We need to store list of DLBlockSurfaceLists on each //blockvolumemesh to store the shell information. But that will //be saved for later. ShellSM *shell_ptr; result = fme->make_facet_shell(surf_list, shell_ptr); if (shell_ptr == NULL || result != CUBIT_SUCCESS) { PRINT_ERROR("Problems building mesh based shell entity.\n"); return result; } #if 1 DLIList<ShellSM*> shell_list; shell_list.append(shell_ptr); Lump *lump_ptr; result = fme->make_facet_lump(shell_list, lump_ptr); if (lump_ptr == NULL || result != CUBIT_SUCCESS) { PRINT_ERROR("Problems building mesh based lump entity.\n"); return result; } DLIList<Lump*> lump_list; lump_list.append(lump_ptr); BodySM *bodysm_ptr; Body *body_ptr; result = fme->make_facet_body(lump_list, bodysm_ptr); body_ptr = GeometryQueryTool::instance()->make_Body(bodysm_ptr); if (body_ptr == NULL || result != CUBIT_SUCCESS) { PRINT_ERROR("Problems building mesh based body entity.\n"); return result; } if (!body_ptr) { exit(1); } PRINT_INFO("Body successfully created.\n"); #endif PRINT_INFO("Number of vertices = %d\n", gqt->num_ref_vertices()); PRINT_INFO("Number of edges = %d\n", gqt->num_ref_edges()); PRINT_INFO("Number of faces = %d\n", gqt->num_ref_faces()); // print vertex positions DLIList<RefVertex*> verts; gqt->ref_vertices(verts); int i; for (i = 0; i < verts.size(); i++) { RefVertex * vert = verts[i]; CubitVector coords = vert->coordinates(); PRINT_INFO("Vertex %d: %4.2f, %4.2f, %4.2f.\n", vert->id(), coords.x(), coords.y(), coords.z()); } // print edges and faces DLIList<RefEdge*> refEdges; gqt->ref_edges(refEdges); for (i = 0; i < refEdges.size(); i++) { RefEdge * edg = refEdges[i]; PRINT_INFO("Edge %d: %d %d\n", edg->id(), edg->start_vertex()->id(), edg->end_vertex ()->id() ); } DLIList<RefFace*> refFaces; gqt->ref_faces(refFaces); for (i = 0; i < refFaces.size(); i++) { RefFace * face = refFaces[i]; DLIList< Loop * > loop_list ; face->ordered_loops (loop_list ) ; DLIList< RefEdge * > ordered_edge_list; loop_list[0]->ordered_ref_edges (ordered_edge_list); //DLIList< RefVertex* > *listV = ref_vert_loop_list[0]; PRINT_INFO("face %d: loop 0 size %d\n", face->id(), ordered_edge_list.size() ); for (int j=0; j<ordered_edge_list.size(); j++) { PRINT_INFO(" %d", ordered_edge_list[j]->id() ); } PRINT_INFO("\n"); } return true; }