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 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; }
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 Surface::are_positions_on( DLIList<CubitVector *> &test_position_list, DLIList<CubitBoolean *> &is_on_list ) { CubitVector *test_position; CubitBoolean *is_on; test_position_list.reset(); is_on_list.reset(); for (int i=0; i<test_position_list.size(); i++) { test_position = test_position_list.get_and_step(); is_on = is_on_list.get_and_step(); *is_on = is_position_on( *test_position ); } }
void Surface::closest_points_trimmed(DLIList<CubitVector *> &from_point_list, DLIList<CubitVector *> &point_on_surface_list) { CubitVector *from_point; CubitVector *point_on_surface; from_point_list.reset(); point_on_surface_list.reset(); for (int i=0; i<from_point_list.size(); i++) { from_point = from_point_list.get_and_step(); point_on_surface = point_on_surface_list.get_and_step(); closest_point_trimmed( *from_point, *point_on_surface ); } }
//----------------------------------------------------------------------------- // Purpose : Determines if entities are from the same engine. // // Creator : Tyronne Lim (CAT) // // Creation Date : 08/01/03 //----------------------------------------------------------------------------- CubitBoolean GeometryHealerTool::same_healer_engine( DLIList<TopologyEntity*> &topo_list ) const { GeometryHealerEngine *gePtr1 = get_engine(topo_list.get_and_step()); GeometryHealerEngine *gePtr2; for (int i = 1; i < topo_list.size(); i++) { gePtr2 = get_engine(topo_list.get_and_step()); if (gePtr1 != gePtr2) { return CUBIT_FALSE; } } return CUBIT_TRUE; }
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; }
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 : 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); }
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 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 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; }
//---------------------------------------------------------------- // 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; }
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; }
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 ); } }
//------------------------------------------------------------------------- // 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; }
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(); } }
//------------------------------------------------------------------------- // 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 ); }
void DagDrawingTool::print_dag( ModelEntity* node_ptr, int indent, int depth ) { DLIList<ModelEntity*> relatives; if( depth > 0 ) { node_ptr->get_children( &relatives ); for( int i = relatives.size(); i > 0; i-- ) { ModelEntity* child_ptr = relatives.get_and_step(); print_node( child_ptr, indent, "<>" ); print_dag( child_ptr, indent + 1, depth - 1 ); } } else if( depth < 0 ) { node_ptr->get_parents( &relatives ); for( int i = relatives.size(); i > 0; i-- ) { ModelEntity* parent_ptr = relatives.get_and_step(); print_dag( parent_ptr, indent + 1, depth + 1 ); print_node( parent_ptr, indent, "<>" ); } } }
void Faceter::max_min_edge_ratio( DLIList <DLIList <CubitPoint*>*> &boundary_point_loops, double &ratio, double &cell_size) { double max_edge_length = CUBIT_DBL_MIN; double min_edge_length = CUBIT_DBL_MAX; double sum = 0.0; int total_count = 0; DLIList<CubitPoint*> *loopPtr; CubitPoint *node1, *node2; CubitVector edge; for (int i = boundary_point_loops.size(); i > 0; i--) { loopPtr = boundary_point_loops.get_and_step(); node2 = loopPtr->prev(); for (int j = loopPtr->size(); j > 0; j--) { node1 = node2; node2 = loopPtr->get_and_step(); CubitVector p1 = node1->coordinates(); CubitVector p2 = node2->coordinates(); edge = p2-p1; double edge_length = edge.length_squared(); if (edge_length > max_edge_length) max_edge_length = edge_length; if (edge_length < min_edge_length) min_edge_length = edge_length; total_count++; sum += edge_length; } } if (min_edge_length > CUBIT_RESABS) { ratio = sqrt(max_edge_length/min_edge_length); } else { ratio = sqrt(max_edge_length); } if ( total_count > 0 && sum > 0 ) cell_size = sqrt(sum/total_count); else cell_size = 0.0; }
RefEdge* RefEdge::get_other_curve(RefVertex* common_vertex, RefFace* ref_face_ptr) { DLIList<RefEdge*> curves; ref_face_ptr->ref_edges(curves); for(int ii = curves.size(); ii>0; ii--) { RefEdge* temp_edge = curves.get_and_step(); if((temp_edge->is_directly_related(common_vertex)) && (this != temp_edge)) return temp_edge; } return NULL; }
void PST_Edge::debug_draw_edges( DLIList<PST_Edge*>& edge_list, int color, int boundary_color, bool flush ) { if( !boundary_color ) boundary_color = color; for( int e = edge_list.size(); e--; ) { PST_Edge* edge_ptr = edge_list.get_and_step(); int c = !edge_ptr->forward()->face() || !edge_ptr->reverse()->face() ? boundary_color : color; edge_ptr->debug_draw( c, false ); } if( flush ) GfxDebug::flush(); }
//------------------------------------------------------------------------- // Purpose : Used to be OCCQueryEngine::is_point_in_body // // Special Notes : // // Creator : Jason Kraftcheck // // Creation Date : 05/10/04 //------------------------------------------------------------------------- CubitPointContainment OCCBody::point_containment( const CubitVector &point ) { CubitPointContainment pc_value; OCCLump *lump; int i; for( i=myLumps.size(); i--;) { lump = dynamic_cast<OCCLump*>(myLumps.get_and_step()); pc_value = lump->point_containment( point ); if( pc_value == CUBIT_PNT_INSIDE ) return CUBIT_PNT_INSIDE; else if( pc_value == CUBIT_PNT_BOUNDARY ) return CUBIT_PNT_BOUNDARY; } for(int i = 0; i < mySheetSurfaces.size(); i++) { OCCSurface* surface = mySheetSurfaces.get_and_step(); pc_value = surface->point_containment( point ); if( pc_value == CUBIT_PNT_INSIDE ) return CUBIT_PNT_INSIDE; else if( pc_value == CUBIT_PNT_BOUNDARY ) return CUBIT_PNT_BOUNDARY; } for(int i = 0; i <myShells.size() ; i++) { OCCShell* occ_shell = myShells.get_and_step(); DLIList<TopologyBridge*> children; occ_shell->get_children_virt(children); for(int j = 0; j < children.size(); j++) { OCCSurface* surface = CAST_TO(children.get_and_step(), OCCSurface); pc_value = surface->point_containment( point ); if( pc_value == CUBIT_PNT_INSIDE ) return CUBIT_PNT_INSIDE; else if( pc_value == CUBIT_PNT_BOUNDARY ) return CUBIT_PNT_BOUNDARY; } } return CUBIT_PNT_OUTSIDE; }