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() ); } }
//============================================================================= //Function: get_facet_points (PUBLIC) //Description: return the list of facet points on this chollacurve //Notes: inclusive = true will return end points as well, otherwise only // interior points will be returned //Author: sjowen //Date: 9/11/2009 //============================================================================= void ChollaCurve::get_facet_points( DLIList<CubitPoint *> &point_list, CubitBoolean inclusive) { FacetEntity *fe_ptr; CubitFacetEdge *edge_ptr; CubitPoint *pts[2]; for (int ii=0; ii<curveEdgeList.size(); ii++) { fe_ptr = curveEdgeList.get_and_step(); edge_ptr = dynamic_cast<CubitFacetEdge *> (fe_ptr); assert(edge_ptr != NULL); for (int jj=0; jj<2; jj++) { pts[jj] = edge_ptr->point(jj); if (inclusive) { point_list.append(pts[jj]); } else { if (pts[jj] != startPoint && pts[jj] != endPoint) { point_list.append(pts[jj]); } } } } point_list.uniquify_ordered(); }
//----------------------------------------------------------------------------- // 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); }
//------------------------------------------------------------------------- // 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; }
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 ); } }
//------------------------------------------------------------------------- // 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()); }
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 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 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); } }
//================================================================================== //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; }
/*! 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; } } } }
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; }
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); } } } }
//------------------------------------------------------------------------- // 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; }
CubitStatus SplitSurfaceVirtual::split_surface_virtual( RefFace *ref_face_ptr, DLIList<CubitVector*> &locations, DLIList<DLIList<CubitVector*>*> &vec_lists ) { // find the splitting curves. SplitSurfaceTool sst; DLIList<Curve*> curve_list; CubitStatus err = sst.calculate_split_curves( ref_face_ptr, locations, vec_lists, curve_list ); GMem gmem; int num_points; DLIList<CubitVector*> segments; // loop over all the curves int i; for (i = 0; i < curve_list.size(); i++) { Curve* curve_ptr = curve_list.get_and_step(); // get the curve facets err = curve_ptr->get_geometry_query_engine()-> get_graphics( curve_ptr, num_points, &gmem ); // load the graphics points into a CubitVector for insert_curve --num_points; int j; for (j = 0; j < num_points; j++) { const GPoint& p = gmem.point_list()[j]; segments.append( new CubitVector( p.x, p.y, p.z ) ); } } // add last point to the end of the list const GPoint& p = gmem.point_list()[num_points]; segments.append( new CubitVector(p.x, p.y, p.z ) ); // now partition the surface DLIList<RefEdge*> new_edges; RefFace* new_surf = PartitionTool::instance()->insert_edge( ref_face_ptr, segments, false, new_edges ); //DLIList<Curve*> new_curves; //Surface* new_surf = PartitionEngine::instance().insert_curve( old_surf, segments, new_curves ); // called routines allocate memory. Clean up for them. while( curve_list.size() ) delete curve_list.pop(); //while( new_curves.size() ) // delete new_curves.pop(); return CUBIT_SUCCESS; }
//------------------------------------------------------------------------- // Purpose : get bounding box // // Special Notes : // // Creator : Jason Kraftcheck // // Creation Date : 02/14/03 //------------------------------------------------------------------------- CubitBox PartitionBody::bounding_box() const { DLIList<TopologyBridge*> lumps; real_body()->get_children_virt(lumps); CubitBox result = dynamic_cast<Lump*>(lumps.step_and_get())->bounding_box(); for( int i = 1; i < lumps.size(); i++ ) result |= dynamic_cast<Lump*>(lumps.step_and_get())->bounding_box(); return result; }
void DagDrawingTool::get_relatives( DLIList<ModelEntity*>& source_set, DLIList<ModelEntity*>& result_set, int direction ) { DLIList<ModelEntity*> temp_set; result_set.clean_out(); for( int i = 0; i < source_set.size(); i++ ) { get_relatives( source_set.get_and_step(), temp_set, direction ); result_set.merge_unique( temp_set ); } }
int TDUniqueId::find_td_unique_id(const int temp_id, DLIList<ToolDataUser*> &td_list, const RefEntity *related_entity) { td_list.clean_out(); int unique_id = temp_id; //if we are not doing an undo and importing and merging within a file... if( !GSaveOpen::performingUndo && GeometryQueryTool::importingSolidModel && !GeometryQueryTool::mergeGloballyOnImport) { //see if the old id maps to a new id...if so, use the new id UIDMap old_uid_to_new_uid_map = CAUniqueId::get_old_to_new_uid_map(); UIDMap::iterator iter; iter = old_uid_to_new_uid_map.find( unique_id ); if( iter != old_uid_to_new_uid_map.end() ) unique_id = (*iter).second; } std::pair<TDUIDList::iterator, TDUIDList::iterator> bounds_pair = unique_id_list().equal_range(unique_id); TDUIDList::iterator it = bounds_pair.first, upper = bounds_pair.second; if(it == unique_id_list().end()) return 0; if ((*it).first == unique_id ) { // the lower bound key is equal to unique_id, so this id is in the list // look for duplicate id's, return one that's directly related // get all td's with that id for (; it != upper; it++) { bool related = true; ToolDataUser *temp_tdu = (*it).second->owner_entity(); if (NULL != related_entity) { TopologyEntity *topo_ent = CAST_TO(temp_tdu, TopologyEntity); RefEntity* temp_entity = const_cast<RefEntity*>(related_entity); if (!topo_ent || !topo_ent->is_directly_related(CAST_TO(temp_entity, TopologyEntity))) related = false; } if (related) td_list.append(temp_tdu); } } return td_list.size(); }
int OCCSurface::get_loops( DLIList<OCCLoop*>& result_list ) { TopTools_IndexedMapOfShape M; TopExp::MapShapes(*myTopoDSFace, TopAbs_WIRE, M); int ii; for (ii=1; ii<=M.Extent(); ii++) { TopologyBridge *loop = OCCQueryEngine::instance()->occ_to_cgm(M(ii)); result_list.append_unique(dynamic_cast<OCCLoop*>(loop)); } return result_list.size(); }
DagNodeRow::DagNodeRow( DLIList<ModelEntity*>& node_list ) { length_ = node_list.size(); array_ = 0; if( length_ > 0 ) { array_ = new ModelEntity*[length_]; node_list.reset(); for( int i = 0; i < length_; i++ ) array_[i] = node_list.get_and_step(); } }
//============================================================================= //Function: get_vertices (PUBLIC) //Description: get the list of ChollaPoints on this surface //Author: sjowen //Date: 09/11/09 //============================================================================= void ChollaSurface::get_vertices( DLIList<ChollaPoint *> &chpt_list ) { chpt_list.clean_out(); ChollaCurve *chcurv_ptr; for (int ii=0; ii<curveList.size(); ii++) { chcurv_ptr = curveList.get_and_step(); DLIList<ChollaPoint *> chc_pts = chcurv_ptr->get_points(); chpt_list += chc_pts; } chpt_list.uniquify_unordered(); }
//---------------------------------------------------------------- // 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; }
//------------------------------------------------------------------------- // Purpose : Disconnect input surfaces from "this" shell // // Special Notes : // // Creator : Corey Ernst // // Creation Date : 08/31/04 //------------------------------------------------------------------------- void FacetShell::disconnect_surfaces( DLIList<FacetSurface*> &surfs_to_disconnect ) { for (int i = surfs_to_disconnect.size(); i--; ) { FacetSurface* surface = surfs_to_disconnect.get_and_step(); if( mySurfs.move_to( dynamic_cast<Surface*>(surface) ) ) mySurfs.change_to(NULL); if (surface) surface->remove_shell(this); } mySurfs.remove_all_with_value( NULL ); }
GeomDataObserver* GeomDataObserver::get( RefEntity* on_this ) { DLIList<CubitObserver*> list; GeomDataObserver* eo = NULL; on_this->get_observer_list(list); for (int i = list.size(); i--; ) { if ( (eo = dynamic_cast<GeomDataObserver*>(list.step_and_get()) )) break; } return eo; }
void PointGridSearch::get_neighborhood_points_sorted( DLIList<CubitPoint*> &point_list, const CubitVector& center, double cut_off) { point_list.clean_out(); DLIList<CubitPoint*> temp_point_list; int i; for (int k = boundingCellMinimumZ; k <= boundingCellMaximumZ; k++) { int kn = numberGridCellsY * k; for (int j = boundingCellMinimumY; j <= boundingCellMaximumY; j++) { int jn = numberGridCellsX * (kn + j); for ( i = boundingCellMinimumX; i <= boundingCellMaximumX; i++) { int in = jn + i; if (neighborhoodList[in]) { temp_point_list += *(neighborhoodList[in]); } } } } // evaluate point distance to center ... remove those larger than cut_off SDLByDouble sorted_index_list; IndexedDouble *ID; CubitVector vec; cut_off *= cut_off; temp_point_list.reset(); for ( i = 0; i < temp_point_list.size(); i++) { vec = center - temp_point_list.get_and_step()->coordinates(); double distance = vec.length_squared(); if (distance < cut_off) { ID = new IndexedDouble( i, distance ); sorted_index_list.append( ID ); } } sorted_index_list.sort(); temp_point_list.reset(); for ( i = 0; i < sorted_index_list.size(); i++ ) { ID = sorted_index_list.get_and_step(); point_list.append( temp_point_list.next( ID->index() ) ); delete ID; } }
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 ); }