void PST_Edge::points( DLIList<PST_Edge*>& edges, DLIList<PST_Point*>& points ) { int e; for( e = edges.size(); e--; ) { PST_Edge* edge_ptr = edges.get_and_step(); edge_ptr->start_point()->private_mark_ = 1; edge_ptr->end_point()->private_mark_ = 1; } for( e = edges.size(); e--; ) { PST_Edge* edge_ptr = edges.get_and_step(); PST_Point* sp = edge_ptr->start_point(); PST_Point* ep = edge_ptr->end_point(); if( sp->private_mark_ ) { sp->private_mark_ = 0; points.append( sp ); } if( ep->private_mark_ ) { ep->private_mark_ = 0; points.append( ep ); } } }
void OCCBody::get_TopoDS_Shape(TopoDS_Shape *& shape) { if (myTopoDSShape && !myTopoDSShape->IsNull()) { assert(myTopoDSShape->ShapeType() == TopAbs_COMPOUND); shape = myTopoDSShape; } else { DLIList<Lump*> lumps = this->lumps(); DLIList<OCCShell*> shells = this->shells(); DLIList<OCCSurface*> surfaces = this->my_sheet_surfaces(); if(lumps.size() + shells.size() + surfaces.size() == 1) { if(lumps.size() == 1) { OCCLump* lump = CAST_TO(lumps.get(), OCCLump); assert(lump != NULL); shape = CAST_TO(lump, OCCLump)->get_TopoDS_Solid(); } else if(shells.size() == 1) shape = shells.get()->get_TopoDS_Shell(); else shape = surfaces.get()->get_TopoDS_Face(); } else shape = NULL; } }
/*! This function is like merge_unique(), except that the type of object stored by \a merge_list is not the same as this list's type. The type of object stored in the other list must be able to be static_cast<> to this list's type. \param merge_list The list whose elements will be incorporated into this list. \param merge_list_unique A flag indicating whether to skip a check for uniqueness between elements of \a merge_list. \sa merge_unique() */ template<typename Y> inline void casting_merge_unique(const DLIList<Y>& merge_list, bool merge_list_unique = false) { // Save the current index of the merge_list int old_size = size(); int i, j, check_index; X new_item; // The resulting list will be at least as large as the larger of the two lists. // Reserve space so we don't have to reallocate so often. Note that if // this list is already bigger than merge_list, the reserve won't // make the list shorter. reserve(merge_list.size()); for ( i = 0; i < merge_list.size(); i++) { // Get the item from the merge_list and insert it into "this" // list if it doesn't already exist there. new_item = static_cast<X>(merge_list[i]); check_index = merge_list_unique ? old_size : size(); // Append the new item and then remove it if necessary. append(new_item); for ( j = 0; j < check_index; j++ ) { if ( listArray[j] == new_item ) { listArray.resize(listArray.size()-1); break; } } } }
void PST_Edge::edges( DLIList<PST_Point*>& pts, DLIList<PST_Edge*>& edges ) { int p; for( p = pts.size(); p--; ) { PST_Point* pt = pts.get_and_step(); PST_Edge* edge = pt->edge(); if( edge ) do { edge->private_mark_ = 1; edge = edge->next( pt ); } while( edge != pt->edge() ); } for( p = pts.size(); p--; ) { PST_Point* pt = pts.get_and_step(); PST_Edge* edge = pt->edge(); if( edge ) do { if( edge->private_mark_ ) { edge->private_mark_ = 0; edges.append( edge ); } edge = edge->next( pt ); } while( edge != pt->edge() ); } }
void PST_Edge::edges( DLIList<PST_Face*>& faces, DLIList<PST_Edge*>& edges ) { int f; for( f = faces.size(); f--; ) { PST_CoEdge* first = faces.get_and_step()->first_coedge(); PST_CoEdge* coedge = first; do { coedge->edge()->private_mark_ = 1; coedge = coedge->next(); } while( coedge != first ); } for( f = faces.size(); f--; ) { PST_CoEdge* first = faces.get_and_step()->first_coedge(); PST_CoEdge* coedge = first; do { if( coedge->edge()->private_mark_ ) { coedge->edge()->private_mark_ = 0; edges.append( coedge->edge() ); } coedge = coedge->next(); } while( coedge != first ); } }
void PST_Edge::faces( DLIList<PST_Edge*>& edges, DLIList<PST_Face*>& faces ) { int e; for( e = edges.size(); e--; ) { PST_Edge* edge_ptr = edges.get_and_step(); if( edge_ptr->forward()->face() ) edge_ptr->forward()->face()->private_mark_ = 1; if( edge_ptr->reverse()->face() ) edge_ptr->reverse()->face()->private_mark_ = 1; } for( e = edges.size(); e--; ) { PST_Edge* edge_ptr = edges.get_and_step(); PST_Face* fface_ptr = edge_ptr->forward()->face(); PST_Face* rface_ptr = edge_ptr->reverse()->face(); if( fface_ptr && fface_ptr->private_mark_ ) { fface_ptr->private_mark_ = 0; faces.append( fface_ptr ); } if( rface_ptr && rface_ptr->private_mark_ ) { rface_ptr->private_mark_ = 0; faces.append( rface_ptr ); } } }
//---------------------------------------------------------------- // Function: private function to update the core compound and // for any movement of the body. // Note: input shape must have the same number of Compound // as the body's lumps number. // Author: Jane Hu //---------------------------------------------------------------- CubitStatus OCCBody::update_OCC_entity( BRepBuilderAPI_ModifyShape *aBRepTrsf, BRepAlgoAPI_BooleanOperation *op) { assert(aBRepTrsf != NULL || op != NULL); TopoDS_Compound compsolid; TopoDS_Shape shape; shape = aBRepTrsf->Shape(); if(aBRepTrsf && myTopoDSShape) { compsolid = TopoDS::Compound(shape); if(OCCQueryEngine::instance()->OCCMap->IsBound(*myTopoDSShape) ) OCCQueryEngine::instance()->update_OCC_map(*myTopoDSShape, shape); else if (!shape.IsEqual(*myTopoDSShape)) set_TopoDS_Shape(compsolid); } //Boolean operation works only on one lump body //set the lumps DLIList<Lump *> lumps; lumps = this->lumps(); for (int i = 1; i <= lumps.size(); i++) { OCCLump *lump = CAST_TO(lumps.get_and_step(), OCCLump); lump->update_OCC_entity(aBRepTrsf, op); } for(int i = 0; i < mySheetSurfaces.size(); i++) { OCCSurface* surface = mySheetSurfaces.get_and_step(); surface->update_OCC_entity(aBRepTrsf, op); } for(int i = 0; i <myShells.size() ; i++) { OCCShell* occ_shell = myShells.get_and_step(); occ_shell->update_OCC_entity(aBRepTrsf,op); } if (aBRepTrsf && !compsolid.IsNull()) set_TopoDS_Shape(compsolid); update_bounding_box(); //unset marks. DLIList<OCCCurve*> curves; DLIList<OCCPoint*> points; get_all_curves(curves); get_all_points(points); for(int i = 0; i < curves.size(); i++) curves.get_and_step()->set_myMarked(CUBIT_FALSE); for(int i = 0; i < points.size(); i++) points.get_and_step()->set_myMarked(CUBIT_FALSE); return CUBIT_SUCCESS; }
//------------------------------------------------------------------------- // Purpose : Returns the volume of the Lump // // Special Notes : // // Creator : // // Creation Date : //------------------------------------------------------------------------- double FacetLump::measure() { DLIList<CubitFacet*> bounding_facets; DLIList<CubitPoint*> bounding_points; DLIList<FacetSurface*> surfaces; Surface *curr_surface; FacetSurface *facet_surface; //if this is a sheet body... return 0.0 //Body *tmp_body = CAST_TO(myBodyPtr->topology_entity(), Body); if( is_sheet() ) return 0.0; int ii; get_surfaces(surfaces); if (surfaces.size() > 0) { for ( ii = surfaces.size(); ii > 0; ii-- ) { curr_surface = surfaces.get_and_step(); facet_surface = CAST_TO(curr_surface, FacetSurface); if ( facet_surface == NULL ) { PRINT_ERROR("Facet lump has surfaces that aren't facets?"); return 1; } facet_surface->get_my_facets(bounding_facets, bounding_points); } } double volume, curr_facet_area, summation = 0.0; CubitFacet *curr_facet; CubitVector normal_of_curr_facet, vector_of_point; CubitPoint *point_1, *point_2, *point_3; for( int jj = bounding_facets.size(); jj > 0; jj-- ) { curr_facet = bounding_facets.get_and_step(); curr_facet_area = curr_facet->area(); // Current facet's area normal_of_curr_facet = curr_facet->normal(); // Current facet's normal curr_facet->points(point_1, point_2, point_3); // Current facet's points vector_of_point = point_1->coordinates(); // One point's vector summation += ( double(vector_of_point % normal_of_curr_facet) * curr_facet_area); } volume = summation / 3; return volume; }
void SimplifyTool::process_rounds(RefVolume* ref_volume, double min_radius, double max_radius) { DLIList<RefEdge*> edges; ref_volume->ref_edges(edges); DLIList<RefFace*> rounds; // a edge must have curvature within the tolerance for(int j = edges.size();j--;) { RefEdge* edge = edges.get_and_step(); CubitVector loc,tan,curv; edge->closest_point(edge->curve_center(),loc,&tan,&curv); double curv_mag = curv.length(); if(curv_mag > GEOMETRY_RESABS && 1.0/curv_mag >= min_radius && 1.0/curv_mag <= max_radius) { DLIList<RefFace*> new_rounds; edge->ref_faces(new_rounds); rounds+=new_rounds; } } rounds.uniquify_unordered(); for(int i = rounds.size();i--;) { // cull any flat surfaces RefFace* curr_face = rounds.get_and_step(); double curve_0,curve_1; curr_face->get_principal_curvatures(curr_face->center_point(),curve_0,curve_1); curve_0 = fabs(curve_0); curve_1 = fabs(curve_1); if((curve_0 > GEOMETRY_RESABS && 1.0/curve_0 >= min_radius && 1.0/curve_0 <= max_radius) || (curve_1 > GEOMETRY_RESABS && 1.0/curve_1 >= min_radius && 1.0/curve_1 <= max_radius)) { GfxDebug::highlight_ref_face(curr_face); } } }
void CubitUtil::list_entity_ids( const char *pre_string, const DLIList<CubitEntity*> &entity_list, int width, const char *post_string, int sort, int unique, int tab, const char *sep_string, const char *post_string_none ) { DLIList <int> id_list( entity_list.size() ); for ( int i=0; i<entity_list.size(); i++ ) id_list.append( entity_list.next(i)->id() ); list_entity_ids( pre_string, id_list, width, post_string, sort, unique, tab, sep_string, post_string_none ); }
CubitStatus SimplifyTool::simplify_volumes(DLIList<RefVolume*> ref_volume_list, double surf_angle_in, DLIList<RefFace*> respect_face_list, DLIList<RefEdge*> respect_edge_list, CubitBoolean respect_rounds, CubitBoolean respect_imprints, CubitBoolean local_normals, CubitBoolean preview) { ref_volume_list.uniquify_unordered(); for(int i = ref_volume_list.size();i--;) simplify_volume( ref_volume_list.get_and_step(), surf_angle_in, respect_face_list, respect_edge_list, respect_rounds, respect_imprints, local_normals, preview); if(preview) GfxDebug::flush(); return CUBIT_SUCCESS; }
//----------------------------------------------------------------------------- // Purpose : Determines if entities are from the same engine. // // Creator : Tyronne Lim (CAT) // // Creation Date : 08/01/03 //----------------------------------------------------------------------------- CubitBoolean GeometryHealerTool::same_healer_engine( DLIList<RefEntity*> &ref_entity_list, CubitBoolean check_children ) const { DLIList<RefEntity*> complete_entity_list; //Check the check_children option and check all the children if necessary if (check_children) { //Make a complete list of all the RefEntities and their children DLIList<RefEntity*> temp = ref_entity_list; RefEntity* ref_entity_ptr; for (int i = 0; i < ref_entity_list.size(); i++) { ref_entity_ptr = ref_entity_list.get_and_step(); complete_entity_list.clean_out(); ref_entity_ptr->get_all_child_ref_entities(complete_entity_list); temp += complete_entity_list; } complete_entity_list.clean_out(); complete_entity_list.merge_unique(temp); } //Now make sure all the RefEntities are from the same geometry engine DLIList<TopologyEntity*> te_list; CAST_LIST(complete_entity_list, te_list, TopologyEntity); return same_healer_engine(te_list); }
CubitBoolean AutoMidsurfaceTool::check_surf_pairs(double min_thick, double max_thick, DLIList<RefFace*> check_list, Body* body_in ) { double total_area = 0.0; DLIList<RefVolume*> vol_list; body_in->ref_volumes(vol_list); double total_vol = 0; for(int vol_cnt = 0; vol_cnt < vol_list.size(); vol_cnt++) { CubitVector cg; double temp_volume; vol_list[vol_cnt]->mass_properties(cg,temp_volume); total_vol += temp_volume; } for(int i = 0;i<check_list.size();i++) total_area += check_list[i]->area(); total_area/=2.0; if(min_thick*total_area < total_vol && max_thick*total_area > total_vol) return CUBIT_TRUE; return CUBIT_FALSE; }
//================================================================================== //Function: skin_1d (PUBLIC) //Description: creates a skin of the given facet entities. //================================================================================== CubitStatus ChollaSkinTool::skin_1d(DLIList<FacetEntity*> &facet_list, ChollaCurve *&facet_curve_mesh_ptr) { CubitStatus rv = CUBIT_SUCCESS; // create a ChollaCurve if we have to (only if this is a 1D facet) if (!facet_curve_mesh_ptr) { FacetEntity *edge_ptr = facet_list.get(); TDGeomFacet *td_gm = TDGeomFacet::get_geom_facet( edge_ptr ); facet_curve_mesh_ptr = new ChollaCurve( td_gm->get_block_id() ); // associate all of the tooldata on the faces of this surf with the // new ChollaCurve int ii; for (ii=0; ii<facet_list.size(); ii++) { edge_ptr = facet_list.get_and_step(); facet_curve_mesh_ptr->add_facet( edge_ptr ); td_gm = TDGeomFacet::get_geom_facet( edge_ptr ); td_gm->add_cholla_curve( facet_curve_mesh_ptr ); } } // Note: the start and end points of this curve will be defined in // ChollaCurve::split_curve. The BlockPointMesh objects at these points // will be defined in MeshGeometryCreator::classify_node return rv; }
void DagDrawingTool::printDag(DLIList<ModelEntity*> &entity_list, int depth) { int i; for (i = entity_list.size(); i > 0; i--) { printDag(entity_list.get_and_step(), depth); } }
void OCCSurface::get_parents_virt( DLIList<TopologyBridge*>& parents ) { if(myShell) //shell or sheet body { parents.append(myShell); return; } OCCQueryEngine* oqe = (OCCQueryEngine*) get_geometry_query_engine(); OCCBody * body = NULL; DLIList <OCCBody* > *bodies = oqe->BodyList; TopTools_IndexedDataMapOfShapeListOfShape M; for(int i = 0; i < bodies->size(); i++) { body = bodies->get_and_step(); TopExp::MapShapesAndAncestors(*(body->get_TopoDS_Shape()), TopAbs_FACE, TopAbs_SHELL, M); if(!M.Contains(*(get_TopoDS_Face()))) continue; const TopTools_ListOfShape& ListOfShapes = M.FindFromKey(*(get_TopoDS_Face())); if (!ListOfShapes.IsEmpty()) { TopTools_ListIteratorOfListOfShape it(ListOfShapes) ; for (;it.More(); it.Next()) { TopoDS_Shell Shell = TopoDS::Shell(it.Value()); int k = oqe->OCCMap->Find(Shell); parents.append((OCCShell*)(oqe->OccToCGM->find(k))->second); } } } }
CubitStatus point_project() { GeometryQueryTool *gti = GeometryQueryTool::instance(); const char *argv = "box-w-hole.brep"; CubitStatus status = read_geometry(1, &argv); if (status == CUBIT_FAILURE) exit(1); DLIList<Body*> test_bodies; gti->bodies(test_bodies); DLIList<Surface*> surfaces; BodySM* body = test_bodies.get()->get_body_sm_ptr(); body->surfaces(surfaces); Surface* surf; for (int i = 0 ; i < surfaces.size(); i++) { surf = surfaces.get_and_step(); double d = surf->measure(); if (d < 82.1 && d > 81.9) break; } CubitVector point(1,1,-5); CubitVector on_surf; surf->closest_point_trimmed(point, on_surf); assert (fabs(on_surf.z() + 5) < 0.0001); assert (on_surf.y() < 1.001 && on_surf.y() > 0.999); assert (on_surf.x() < 2.122 && on_surf.x() > 2.121 ); CubitVector p1(0, 1.5, -6 ); surf->closest_point_trimmed(p1, on_surf); assert (fabs(on_surf.z() + 5) < 0.0001); assert (on_surf.y() < 2.122 && on_surf.y() > 2.121); assert (on_surf.x() < 0.0001 && on_surf.x() > -0.0001 ); return CUBIT_SUCCESS; }
//------------------------------------------------------------------------- // Purpose : Get named attributes // // Special Notes : // // Creator : Jason Kraftcheck // // Creation Date : 03/03/03 //------------------------------------------------------------------------- void CompositeGeom::get_attributes( const char* name, DLIList<CubitSimpleAttrib>& list ) { if (entityList.size() == 1) { // handle 8.1 attribs on single-entity 'composites' list.clean_out(); entityList[0].entity->get_simple_attribute(COMPOSITE_DATA_ATTRIB_NAME,list); while (list.size()) { CubitSimpleAttrib attrib = list.pop(); if (attrib.int_data_list()[0] == 1) { entityList[0].entity->remove_simple_attribute_virt(attrib); std::vector<CubitString> s(attrib.string_data_list().begin()+1, attrib.string_data_list().end()); std::vector<int> i(attrib.int_data_list().begin()+1, attrib.int_data_list().end()); CubitSimpleAttrib new_attrib(&s, &attrib.double_data_list(), &i); entityList[0].entity->append_simple_attribute_virt(new_attrib); } } entityList[0].entity->get_simple_attribute(name, list); } for (CompositeAttrib* ptr = listHead; ptr; ptr = ptr->next) if (ptr->name() == name) list.append(ptr->csa()); }
//------------------------------------------------------------------------- // Purpose : Insert an entry // // Special Notes : // // Creator : Jason Kraftcheck // // Creation Date : 12/19/01 //------------------------------------------------------------------------- CubitStatus CompositeGeom::insert( int index, GeometryEntity* geom_ptr, CubitSense sense ) { if( index < 0 ) { assert( index >= 0 ); index = 0; } else if( index > entityList.size() ) { assert( index <= entityList.size() ); index = entityList.size(); } CompositeEntry ent; ent.entity = geom_ptr; ent.sense = sense; ent.dist_sqr = ent.measure = 0.; //force 0th surface to be one that has the composite attrib on it. DLIList<CubitSimpleAttrib> list; geom_ptr->get_simple_attribute(COMPOSITE_DATA_ATTRIB_NAME,list); if( list.size() ) index = 0; entityList.insert( ent, index ); update_cached_data(); return CUBIT_SUCCESS; }
//------------------------------------------------------------------------- // Purpose : Get all attributes // // Special Notes : // // Creator : Jason Kraftcheck // // Creation Date : 06/18/02 //------------------------------------------------------------------------- void CompositeGeom::get_attributes( DLIList<CubitSimpleAttrib>& list ) { // special case: single-entity 'composite' if (entityList.size() == 1) { TopologyBridge* entity = entityList[0].entity; entity->get_simple_attribute(list); // handle 8.1 attribs on single-entity 'composites' for (int i = list.size(); i--; ) { const CubitSimpleAttrib& attrib = list.step_and_get(); if (attrib.character_type() == COMPOSITE_DATA_ATTRIB_NAME && attrib.int_data_list()[0] == 1) { entity->remove_simple_attribute_virt(attrib); CubitSimpleAttrib newattrib = attrib; newattrib.string_data_list().erase(newattrib.string_data_list().begin()); newattrib.int_data_list().erase(newattrib.int_data_list().begin()); entity->append_simple_attribute_virt(newattrib); } } } for (CompositeAttrib* ptr = listHead; ptr; ptr = ptr->next) list.append(ptr->csa()); }
void OCCBody::remove_simple_attribute_virt(const CubitSimpleAttrib &csa) { DLIList<Lump*> my_lumps; my_lumps = lumps(); DLIList<OCCShell*> shells = this->shells(); DLIList<OCCSurface*> surfaces = this->my_sheet_surfaces(); if (myTopoDSShape != NULL) { OCCAttribSet::remove_attribute(csa, *myTopoDSShape); return; } else if (my_lumps.size() == 1) { OCCLump* lump = CAST_TO(my_lumps.get(), OCCLump); TopoDS_Solid* solid = lump->get_TopoDS_Solid(); OCCAttribSet::remove_attribute(csa, *solid); if(!csa.isEmpty()) csa_list.remove(csa); else csa_list.clean_out(); return; } else if(shells.size() == 1) { TopoDS_Shell * shell = shells.get()->get_TopoDS_Shell(); OCCAttribSet::remove_attribute(csa, *shell); if(!csa.isEmpty()) csa_list.remove(csa); else csa_list.clean_out(); return; } else if(surfaces.size() == 1) { TopoDS_Face* surf = surfaces.get()->get_TopoDS_Face(); OCCAttribSet::remove_attribute(csa, *surf); if(!csa.isEmpty()) csa_list.remove(csa); else csa_list.clean_out(); return; } }
void PointGridSearch::bounding_range(DLIList<CubitPoint*>& point_list) { if ( !point_list.size() ) return; // initialize min and max range values to the first point coordinates boundingRangeMinimum = point_list.get()->coordinates(); boundingRangeMaximum = point_list.get_and_step()->coordinates(); // find the min and max coordinates that completely encloses the // point list for (int i = 1; i < point_list.size(); i++) bounding_range(point_list.get_and_step()); }
void CAMergePartner::merge_prepare(DLIList<RefEntity*> &merge_list) { DLIList<CubitAttrib*> my_ca_list; CAMergePartner *my_camp_ptr; RefEntity* re_ptr; // get all the merge partner attributes that are on my owner attribOwnerEntity->find_cubit_attrib_type(CA_MERGE_PARTNER, my_ca_list); merge_list.clean_out(); DLIList<ToolDataUser*> td_list, temp_td_list; int i; for (i = my_ca_list.size(); i > 0; i--) { my_camp_ptr = CAST_TO(my_ca_list.get(),CAMergePartner); my_ca_list.step(); td_list.clean_out(); // get all the objects with this unique id (which is also the merge id) TDUniqueId::find_td_unique_id(my_camp_ptr->merge_id(), temp_td_list); td_list += temp_td_list; } // now put those entities into the merge_list for (i = td_list.size(); i > 0; i--) { re_ptr = CAST_TO(td_list.get(), RefEntity); if (re_ptr) { CubitAttrib *tmp_attrib = re_ptr->get_cubit_attrib( CA_MERGE_PARTNER, CUBIT_FALSE ); if( tmp_attrib ) merge_list.append(re_ptr); } td_list.step(); } // Now get bridge sense for each entity in list. // Add this entity to list, too. merge_list.append( attribOwnerEntity ); for( i = merge_list.size(); i--; ) { RefEntity* ent = merge_list.get_and_step(); TopologyEntity* te = dynamic_cast<TopologyEntity*>(ent); if( te->bridge_manager()->number_of_bridges() != 1 ) continue; my_ca_list.clean_out(); ent->find_cubit_attrib_type(CA_MERGE_PARTNER, my_ca_list); assert( my_ca_list.size() < 2); if( !my_ca_list.size() ) continue; my_camp_ptr = dynamic_cast<CAMergePartner*>(my_ca_list.get()); if( my_camp_ptr->bridge_sense() == CUBIT_UNKNOWN ) continue; } merge_list.pop(); // take attribOwnerEntity back off list return; }
CubitStatus SimplifyTool::simplify_surfaces(DLIList<RefFace*> ref_face_list, double angle_in, DLIList<RefFace*> respect_face_list, DLIList<RefEdge*> respect_edge_list, CubitBoolean respect_rounds, CubitBoolean respect_imprints, CubitBoolean local_normals, CubitBoolean preview) { CubitStatus status = CUBIT_FAILURE; ref_face_list.uniquify_unordered(); while(ref_face_list.size()) { DLIList<RefFace*> ref_faces_in_volume; ref_face_list.reset(); RefFace* cur_face = ref_face_list.get_and_step(); RefVolume* cur_vol = cur_face->ref_volume(); ref_faces_in_volume.append(cur_face); for(int i =1;i<ref_face_list.size();i++) { RefFace* face = ref_face_list.get_and_step(); if(face->ref_volume() == cur_vol) ref_faces_in_volume.append(face); } if(ref_faces_in_volume.size()>1) { status = simplify_surfaces_in_volume( ref_faces_in_volume, angle_in, respect_face_list, respect_edge_list, respect_rounds, respect_imprints, local_normals, preview); } ref_face_list -= ref_faces_in_volume; } if(preview) GfxDebug::flush(); return CUBIT_SUCCESS; }
//------------------------------------------------------------------------- // Purpose : Check if shell is a sheet. // // Special Notes : // // Creator : Jason Kraftcheck // // Creation Date : 01/15/04 //------------------------------------------------------------------------- CubitBoolean Shell::is_sheet() { DLIList<RefFace*> faces; ref_faces(faces); while (faces.size()) if ( ! faces.pop()->is_nonmanifold(this) ) return CUBIT_FALSE; return CUBIT_TRUE; }
//---------------------------------------------------------------- // Function: to update the core Surface // for any movement or Boolean operation of the body. // Author: Jane Hu //---------------------------------------------------------------- CubitStatus OCCSurface::update_OCC_entity( BRepBuilderAPI_Transform *aBRepTrsf, BRepAlgoAPI_BooleanOperation *op) { assert(aBRepTrsf != NULL || op != NULL); TopoDS_Shape shape; if (aBRepTrsf) shape = aBRepTrsf->ModifiedShape(*get_TopoDS_Face()); else { TopTools_ListOfShape shapes; shapes.Assign(op->Modified(*get_TopoDS_Face())); if(shapes.Extent() == 0) shapes.Assign(op->Generated(*get_TopoDS_Face())); if (shapes.Extent() == 1) shape = shapes.First(); else if(shapes.Extent() > 1) { //update all attributes first. TopTools_ListIteratorOfListOfShape it; it.Initialize(shapes); for(; it.More(); it.Next()) { shape = it.Value(); OCCQueryEngine::instance()->copy_attributes(*get_TopoDS_Face(), shape); } shape = shapes.First(); } else if(op->IsDeleted(*get_TopoDS_Face())) ; else return CUBIT_SUCCESS; } TopoDS_Face surface; if(!shape.IsNull()) surface = TopoDS::Face(shape); if (aBRepTrsf) { //set the loops DLIList<OCCLoop *> loops; this->get_loops(loops); for (int i = 1; i <= loops.size(); i++) { OCCLoop *loop = loops.get_and_step(); loop->update_OCC_entity(aBRepTrsf, op); } OCCQueryEngine::instance()->update_OCC_map(*myTopoDSFace, surface); } else if(op) update_OCC_entity(*myTopoDSFace, surface, op); return CUBIT_SUCCESS; }
//------------------------------------------------------------------------- // Purpose : Clean out composite attributes. // // Special Notes : // // Creator : Jason Kraftcheck // // Creation Date : 07/01/03 //------------------------------------------------------------------------- void CompositeGeom::clean_up_attribs( GeometryEntity* ent ) { DLIList<CubitSimpleAttrib> list; ent->get_simple_attribute(COMPOSITE_DATA_ATTRIB_NAME,list); while (list.size()) { CubitSimpleAttrib csa = list.pop(); ent->remove_simple_attribute_virt(csa); } }
int PST_Edge::validate( DLIList<PST_Edge*>& edges, CubitBoolean print ) { DLIList<PST_Face*> faces; PST_Edge::faces( edges, faces ); int result = 0; for( int f = faces.size(); f--; ) result += faces.get_and_step()->validate(print); return result; }
//------------------------------------------------------------------------- // Purpose : Find the parents of a list of nodes at a specified level // in the DAG, relative to the node. // // Special Notes : // // Creator : Jason Kraftcheck // // Creation Date : 09/16/97 //------------------------------------------------------------------------- CubitStatus DAG::get_parents_at_level( DLIList<ModelEntity*>& child_list, int level, DLIList<ModelEntity*>& result_set ) { assert( level > 0 ); if( child_list.size( ) < 1 ) return CUBIT_FAILURE; DLIList<ModelEntity*> parent_list; // children of all parents DLIList<ModelEntity*> current_node_parents; //Get a list of all the parents one level up from //the nodes in child_list. for( int i = 0; i < child_list.size( ); i++ ) { ModelEntity* current = child_list.get_and_step( ); current_node_parents.clean_out( ); current->get_parents( ¤t_node_parents ); for( int j = 0; j < current_node_parents.size( ); j++ ) { parent_list.append_unique( current_node_parents.get_and_step( ) ); } } //If we found no parents, return failure. if( parent_list.size( ) < 1 ) return CUBIT_FAILURE; //If level 1, then return the list of parents. if( level == 1 ) { result_set = parent_list; return CUBIT_SUCCESS; } //Otherwise get next level down by recursion. else { return get_parents_at_level( parent_list, level - 1, result_set ); } }
//------------------------------------------------------------------------- // Purpose : Get the bounding box of the object. // // Special Notes : // //------------------------------------------------------------------------- CubitBox FacetLump::bounding_box() const { CubitBox my_box, temp_box; DLIList<FacetSurface*> surfaces; int ii; const_cast<FacetLump*>(this)->get_surfaces(surfaces); if (surfaces.size() > 0) { Surface* surface = surfaces.get_and_step(); my_box = surface->bounding_box(); for ( ii = surfaces.size(); ii > 1; ii-- ) { surface = surfaces.get_and_step(); temp_box = surface->bounding_box(); //unite the boxes.. my_box |= temp_box; } } return my_box; }