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 );
}
