//------------------------------------------------------------------------- // 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()); }
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; }
//------------------------------------------------------------------------- // 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; }
//------------------------------------------------------------------------- // 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); } }
//------------------------------------------------------------------------- // Purpose : facet_surface: facets the surface. // // Special Notes : // // Creator : David White // // Creation Date : 03/01/02 //------------------------------------------------------------------------- CubitStatus Faceter::facet_surface(DLIList <CubitFacet*> &results, DLIList <CubitPoint*> &point_list) { if ( DEBUG_FLAG(129) ) { GfxDebug::clear(); GfxDebug::draw_ref_face_edges(thisRefFacePtr); GfxDebug::flush(); int debug = 0; if ( debug ) { GfxDebug::mouse_xforms(); GfxDebug::flush(); } } if ( thisRefFacePtr->number_of_Loops() > 1 ) return CUBIT_FAILURE; //Get the ordered boundary loops. int ii, jj; DLIList <DLIList<CubitPoint*>*> boundary_point_loops; DLIList <CubitPoint*> *tmp_list_ptr; CubitStatus stat = get_boundary_points( boundary_point_loops ); if ( stat != CUBIT_SUCCESS ) { //clean up the data... for ( ii = boundary_point_loops.size(); ii > 0; ii-- ) { tmp_list_ptr = boundary_point_loops.pop(); for ( jj = tmp_list_ptr->size(); jj > 0; jj-- ) delete tmp_list_ptr->pop(); delete tmp_list_ptr; } return stat; } //Set up the gridsearch. double ratio = gridCellScale, cell_size = 0.0; max_min_edge_ratio(boundary_point_loops, ratio, cell_size); if (ratio <= gridCellScale) { ratio = gridCellScale; } //Get all of the points into a single list. for ( ii = boundary_point_loops.size(); ii > 0; ii-- ) { tmp_list_ptr = boundary_point_loops.get_and_step(); for ( jj = tmp_list_ptr->size(); jj > 0; jj-- ) { globalPointList->append(tmp_list_ptr->get_and_step()); } } gridSearchPtr = new PointGridSearch(*globalPointList, cell_size, ratio); //fill in the grid... for ( ii = globalPointList->size(); ii > 0; ii-- ) gridSearchPtr->add_point(globalPointList->get_and_step()); //Now start faceting. stat = facet_loop( boundary_point_loops.get(), results ); //clean up the data... for ( ii = boundary_point_loops.size(); ii > 0; ii-- ) delete boundary_point_loops.pop(); if ( stat != CUBIT_SUCCESS ) { //clean the data and return.. for ( ii = results.size(); ii > 0; ii-- ) delete results.pop(); for ( ii = globalPointList->size(); ii > 0; ii-- ) delete globalPointList->pop(); return stat; } //Didn't add any points... point_list += *globalPointList; return CUBIT_SUCCESS; }
CubitStatus Faceter::get_curve_facets( RefEdge* curve, DLIList<CubitPoint*>& segments ) const { //const double COS_ANGLE_TOL = 0.965925826289068312213715; // cos(15) const double COS_ANGLE_TOL = 0.984807753012208020315654; // cos(10) //const double COS_ANGLE_TOL = 0.996194698091745545198705; // cos(5) GMem curve_graphics; const double dist_tol = GEOMETRY_RESABS; const double dist_tol_sqr = dist_tol*dist_tol; Curve* curve_ptr = curve->get_curve_ptr(); curve_ptr->get_geometry_query_engine()->get_graphics( curve_ptr, &curve_graphics ); GPoint* gp = curve_graphics.point_list(); CubitPoint* last = (CubitPoint*) new FaceterPointData( gp->x, gp->y, gp->z ); ((FaceterPointData*)last)->owner(dynamic_cast<RefEntity*>(curve)); CubitVector lastv = last->coordinates(); segments.append( last ); GPoint* end = gp + curve_graphics.pointListCount - 1; for( gp++; gp < end; gp++ ) { CubitVector pos( gp->x, gp->y, gp->z ); CubitVector step1 = (pos - lastv); double len1 = step1.length(); if( len1 < dist_tol ) continue; GPoint* np = gp + 1; CubitVector next( np->x, np->y, np->z ); CubitVector step2 = next - pos; double len2 = step2.length(); if( len2 < dist_tol ) continue; double cosine = (step1 % step2) / (len1 * len2); if( cosine > COS_ANGLE_TOL ) continue; last = new FaceterPointData( pos ); ((FaceterPointData*)last)->owner(dynamic_cast<RefEntity*>(curve)); segments.append( last ); lastv = last->coordinates(); } CubitVector last_pos( gp->x, gp->y, gp->z ); segments.last(); while( (last_pos - (segments.get()->coordinates())).length_squared() < dist_tol_sqr ) { delete segments.pop(); segments.last(); } CubitPoint *tmp_point = (CubitPoint*) new FaceterPointData( last_pos ); segments.append( tmp_point ); ((FaceterPointData*)tmp_point)->owner( dynamic_cast<RefEntity*>(curve) ); // Now check if the segment list is reversed wrt the curve direction. segments.reset(); double u1, u2; if( segments.size() > 2 ) { u1 = curve->u_from_position( (segments.next(1)->coordinates()) ); u2 = curve->u_from_position( (segments.next(2)->coordinates()) ); } else { u1 = curve->u_from_position( (segments.get()->coordinates() ) ); u2 = curve->u_from_position( (segments.next()->coordinates()) ); } if( (u2 < u1) && (curve->start_param() <= curve->end_param()) ) segments.reverse(); //Make sure we don't have duplicate points. int jj; CubitVector curr, prev; for ( jj = segments.size(); jj > 0; jj-- ) { prev = segments.prev()->coordinates(); curr = segments.get_and_step()->coordinates(); if ( prev.about_equal(curr) ) { PRINT_DEBUG_129("Points on curve %d within tolerance...\n", curve->id()); segments.back(); delete segments.remove(); } } return CUBIT_SUCCESS; }
//------------------------------------------------------------------------- // Purpose : Save attributes on first underlying entity // // Special Notes : // // Creator : Jason Kraftcheck // // Creation Date : 06/30/03 //------------------------------------------------------------------------- void CompositeGeom::write_attributes( GeometryEntity* geom_ptr ) { DLIList<CubitSimpleAttrib> list; if (geom_ptr) { // Special case for point-curves (no real curves to write // attirbutes to.) Write to passed entity instead. assert(entityList.size() == 0); // clean up any attributes from the previous write geom_ptr->get_simple_attribute(COMPOSITE_DATA_ATTRIB_NAME,list); while (list.size()) { CubitSimpleAttrib csa = list.pop(); geom_ptr->remove_simple_attribute_virt(csa); } } else { geom_ptr = entityList[0].entity; // clean up any attributes from the previous write for (int i = 0; i < entityList.size(); i++) { entityList[i].entity->get_simple_attribute(COMPOSITE_DATA_ATTRIB_NAME,list); while (list.size()) { CubitSimpleAttrib csa = list.pop(); entityList[i].entity->remove_simple_attribute_virt(csa); } } } CubitString name = COMPOSITE_DATA_ATTRIB_NAME; int count = entityList.size(); CubitSimpleAttrib attrib; for (CompositeAttrib* ptr = listHead; ptr; ptr = ptr->next) { attrib.string_data_list().push_back(name); attrib.int_data_list().push_back(count); ptr->append_to_csa(attrib); //append the name attribute on all the rest of the entities too. This //is so that if a one gets split, the results each get the name as well: //jack --> jack and jack@A if( ptr->name() == "ENTITY_NAME" ) { for( int k=1; k<entityList.size(); k++ ) entityList[k].entity->append_simple_attribute_virt( attrib ); } geom_ptr->append_simple_attribute_virt(attrib); attrib.string_data_list().clear(); attrib.int_data_list().clear(); attrib.double_data_list().clear(); } }
//------------------------------------------------------------------------- // Purpose : Remove all child partition geometry (body deleted) // // Special Notes : // // Creator : Jason Kraftcheck // // Creation Date : 04/04/03 //------------------------------------------------------------------------- void PartitionBody::destroy_all_children() { DLIList<PartitionLump*> lumps; DLIList<PartitionSurface*> surfs; DLIList<PartitionCoEdge*> coedges; DLIList<PartitionCurve*> curves; DLIList<PartitionPoint*> points; DLIList<PartitionEntity*> sub_geom, split_geom; for ( SubEntitySet* ptr = childList; ptr; ptr = ptr->next_in_body() ) { ptr->get_sub_entities( sub_geom ); ptr->get_lower_order( split_geom ); sub_geom += split_geom; split_geom.clean_out(); while( sub_geom.size() ) { PartitionEntity* ent = sub_geom.pop(); if ( PartitionPoint* point = dynamic_cast<PartitionPoint*>(ent) ) points.append(point); else if( PartitionCoEdge* coedge = dynamic_cast<PartitionCoEdge*>(ent) ) coedges.append(coedge); else if( PartitionCurve* curve = dynamic_cast<PartitionCurve*>(ent) ) curves.append(curve); else if( PartitionSurface* surf = dynamic_cast<PartitionSurface*>(ent) ) surfs.append(surf); else if ( PartitionLump* lump = dynamic_cast<PartitionLump*>(ent) ) lumps.append(lump); else assert(0); } } while( lumps.size() ) { PartitionLump* lump = lumps.pop(); while( PartitionShell* shell = lump->first_shell() ) { lump->remove(shell); shell->remove_all_surfaces(); delete shell; } delete lump; } while( surfs.size() ) { PartitionSurface* surf = surfs.pop(); while( PartitionLoop* loop = surf->next_loop(NULL) ) { surf->remove(loop); loop->remove_all_coedges(); delete loop; } delete surf; } while( coedges.size() ) { PartitionCoEdge* coedge = coedges.pop(); if (coedge->get_curve() != NULL) coedge->get_curve()->remove( coedge ); delete coedge; } while( curves.size() ) { PartitionCurve* curve = curves.pop(); assert( !curve->next_coedge(NULL) ); delete curve; } while( points.size() ) { PartitionPoint* point = points.pop(); assert( !point->num_curves() ); delete point; } // All child SubEntitySets should have been deleted when they // became empty, and should be removed from the list in this // body as they are destroyed. However, when the last SubEntitySet // in this body is destroyed, this body will be destroyed as well. // So don't do this check! //assert(!childList); }
CubitStatus SimplifyTool::simplify_curves_in_volume( DLIList<RefEdge*> ref_edge_list, double angle_in, DLIList<RefEdge*> respect_edge_list, DLIList<RefVertex*> respect_vertex_list, CubitBoolean respect_imprints, CubitBoolean local_normals, CubitBoolean preview) { if(local_normals){ PRINT_WARNING("When simplifying curves, 'local_normals' is currently ignored.\n"); } if(ref_edge_list.size()==0) { PRINT_ERROR("No curves specified for simplification\n"); return CUBIT_FAILURE; } else if(ref_edge_list.size() == 1) { PRINT_ERROR("Only one curve specified for simplification\n"); return CUBIT_FAILURE; } RefVolume* ref_volume = ref_edge_list.get()->ref_volume(); if (NULL == ref_volume) { PRINT_WARNING("Simplifying free curves is not supported.\n"); return CUBIT_FAILURE; } DLIList<RefEdge*> seed_edges; DLIList<RefVertex*> preview_vertices; DLIList<RefVertex*> preview_removed; if(preview) ref_volume->ref_vertices(preview_vertices); int j,k; int new_edge_count = 0; int combined_edge_count = 0; ProgressTool *prog_ptr = 0; if(ref_edge_list.size() > 100 ) { char title[200]; if(preview) sprintf(title, "Previewing Volume %d",ref_volume->id()); else sprintf(title, "Simplifying Curves in Volume %d",ref_volume->id()); prog_ptr = AppUtil::instance()->progress_tool(); assert(prog_ptr != NULL); prog_ptr->start(0,100, title); } int start_edge_count = ref_edge_list.size(); while(ref_edge_list.size()) { DLIList<RefEdge*> composite_edges; seed_edges.append_unique(ref_edge_list.pop()); for ( j = ref_edge_list.size(); j--; ) ref_edge_list.get_and_step()->marked( CUBIT_FALSE ); while(seed_edges.size()) { RefEdge *seed_ref_edge = seed_edges.pop(); seed_ref_edge->marked(CUBIT_TRUE); composite_edges.append(seed_ref_edge); // Get the vertices DLIList<RefVertex*> ref_vertex_list; seed_ref_edge->ref_vertices( ref_vertex_list ); RefVertex *ref_vertex_ptr; RefEdge *ref_edge_ptr; for( k = ref_vertex_list.size(); k--; ) { ref_vertex_ptr = ref_vertex_list.get_and_step(); // Don't go propagate across surface splits if the user asks for it GeometryFeatureTool* gft = GeometryFeatureTool::instance(); if( respect_imprints && gft->feature_type(ref_vertex_ptr) == GeometryFeatureEngine::FEATURE_IMPRINT) continue; // Don't cross a curve if we want it respected if(respect_vertex_list.is_in_list(ref_vertex_ptr)) continue; DLIList<RefEdge*> attached_ref_edges; ref_vertex_ptr->ref_edges( attached_ref_edges ); attached_ref_edges.remove(seed_ref_edge); ref_edge_ptr = attached_ref_edges.size()!=0?attached_ref_edges.get():0; // keep the face if we want it respected if(attached_ref_edges.size() == 1 && respect_edge_list.is_in_list(attached_ref_edges.get())) continue; // Don't consider ref_faces that are already in the list if( attached_ref_edges.size() == 1 && !ref_edge_ptr->marked()) { DLIList<RefVolume*> ref_volumes; ref_edge_ptr->ref_volumes( ref_volumes ); if( !ref_volumes.size() || ref_volumes.size()==1 ) { // Only add the ref_face if it meets the feature angle criteria if(composite_curves(seed_ref_edge,ref_edge_ptr,angle_in)) { ref_edge_ptr->marked( CUBIT_TRUE ); seed_edges.append(ref_edge_ptr); composite_edges.append(ref_edge_ptr); } } } } } composite_edges.uniquify_unordered(); ref_edge_list -= composite_edges; if(!preview && composite_edges.size()>1) { DLIList<RefVertex*> result_vertices; DLIList<RefEdge*> result_edges; CompositeTool::instance()->composite( composite_edges, result_edges, &result_vertices); combined_edge_count +=composite_edges.size(); for(int m = result_edges.size();m--;) result_edges.get_and_step()->marked(CUBIT_TRUE); new_edge_count+=result_edges.size(); } else if(preview) { int edge_count = composite_edges.size(); for(int i =0;i<edge_count;i++) { RefEdge* cur_comp_edge = composite_edges[i]; DLIList<RefVertex*> refvertices; for(int j =0;j<edge_count;j++) { if(i==j) continue; composite_edges[j]->ref_vertices(refvertices); } refvertices.uniquify_unordered(); DLIList<RefVertex*> temp_refvertices; cur_comp_edge->ref_vertices(temp_refvertices); refvertices.intersect_unordered(temp_refvertices); preview_removed+=refvertices; } } if(prog_ptr) { double frac = 1.0-(double)ref_edge_list.size()/(double)start_edge_count; prog_ptr->percent(frac); } } if(prog_ptr) { prog_ptr->end(); prog_ptr = 0; } if(preview) { preview_vertices -=preview_removed; for(int c = preview_vertices.size();c--;) GfxDebug::draw_ref_vertex(preview_vertices.get_and_step(),7); } else if(combined_edge_count>new_edge_count) { PRINT_INFO("Simplified %d curves into %d curves\n", combined_edge_count, new_edge_count); } // make sure to set all of the surface markers to false DLIList<RefEdge*> marked_edge_list; ref_volume->ref_edges(marked_edge_list); for(int i =0;i<marked_edge_list.size();i++) marked_edge_list[i]->marked(CUBIT_FALSE); return CUBIT_SUCCESS; }