root/cgm/trunk/geom/virtual/CompositeEngine.cpp

#include <assert.h>

#include "CompositeEngine.hpp"
#include "PartitionEngine.hpp"

#include "DLIList.hpp"
#include "TDUniqueId.hpp"
#include "CubitTransformMatrix.hpp"

#include "CompositePoint.hpp"
#include "CompositeCurve.hpp"
#include "CompositeCoEdge.hpp"
#include "CompositeLoop.hpp"
#include "CompositeSurface.hpp"
#include "CompositeShell.hpp"
#include "CompositeLump.hpp"
#include "CompositeBody.hpp"

#include "PartitionPoint.hpp"
#include "SegmentedCurve.hpp"

#include "CADefines.hpp"

#include "VGLoopTool.hpp"
#include "Body.hpp"

#include "GeometryQueryTool.hpp"

typedef VGLoopTool<CompositeSurface,
                   CompositeLoop,
                   CompositeCoEdge,
                   CompositeCurve,
                   CompositePoint> CompLoopTool;

CompositeEngine::~CompositeEngine() {}

CompositeEngine& CompositeEngine::instance()
{
  static CompositeEngine* instance_ = new CompositeEngine();
  return *instance_;
}

// This function goes through all of the curves and vertices and
// removes any named attributes specified below.
void CompositeEngine::remove_imprint_attributes_after_modify( DLIList<BodySM*> &old_sms,
                                DLIList<BodySM*> &new_sms )
{
  int k, m, q, w, g, b, s, t;
  CubitString name("IMPRINT_PREEXISTING");
  DLIList<CubitString*> string_list;
  string_list.append( &name );
  CubitSimpleAttrib geom_attrib( &string_list, 0, 0 );

  DLIList<BodySM*> all_sms = old_sms;
  all_sms += new_sms;
  DLIList<TopologyBridge*> top_bridges;
  CAST_LIST_TO_PARENT(all_sms, top_bridges);
  for(k=top_bridges.size(); k--;)
  {
    TopologyBridge *cur_body = top_bridges.get_and_step();
    DLIList<TopologyBridge*> lumps;
    cur_body->get_children_virt(lumps);
    for(m=lumps.size(); m--;)
    {
      TopologyBridge *cur_lump = lumps.get_and_step();
      DLIList<TopologyBridge*> shells;
      cur_lump->get_children_virt(shells);
      for(q=shells.size(); q--;)
      {
        TopologyBridge *cur_shell = shells.get_and_step();
        DLIList<TopologyBridge*> surfaces;
        cur_shell->get_children_virt(surfaces);
        for(w=surfaces.size(); w--;)
        {
          TopologyBridge *cur_surface = surfaces.get_and_step();
          DLIList<TopologyBridge*> loops;
          cur_surface->get_children_virt(loops);
          for(g=loops.size(); g--;)
          {
            TopologyBridge *cur_loop = loops.get_and_step();
            DLIList<TopologyBridge*> coedges;
            cur_loop->get_children_virt(coedges);
            for(b=coedges.size(); b--;)
            {
              TopologyBridge *cur_coedge = coedges.get_and_step();
              DLIList<TopologyBridge*> curves;
              cur_coedge->get_children_virt(curves);
              for(s=curves.size(); s--;)
              {
                TopologyBridge *cur_curve = curves.get_and_step();
                DLIList<CubitSimpleAttrib*> list;
                cur_curve->get_simple_attribute("IMPRINT_PREEXISTING",list);
                if(list.size() != 0)
                  cur_curve->remove_simple_attribute_virt(list.get());
                DLIList<TopologyBridge*> pts;
                cur_curve->get_children_virt(pts);
                for(t=pts.size(); t--;)
                {
                  TopologyBridge *cur_pt = pts.get_and_step();
                  list.clean_out();
                  cur_pt->get_simple_attribute("IMPRINT_PREEXISTING",list);
                  if(list.size() != 0)
                    cur_pt->remove_simple_attribute_virt(list.get());
                }
              }
            }
          }
        }
      }
    }
  }
}

// This function pushes specified named attributes onto all curves
// and vertices.
void CompositeEngine::push_imprint_attributes_before_modify
                     ( DLIList<BodySM*> &bodies )
{
  int k, m, q, w, g, b, s, t;
  CubitString name("IMPRINT_PREEXISTING");
  DLIList<CubitString*> string_list;
  string_list.append( &name );
  CubitSimpleAttrib geom_attrib( &string_list, 0, 0 );

  DLIList<TopologyBridge*> top_bridges;
  CAST_LIST_TO_PARENT(bodies, top_bridges);
  for(k=top_bridges.size(); k--;)
  {
    TopologyBridge *cur_body = top_bridges.get_and_step();
    DLIList<TopologyBridge*> lumps;
    cur_body->get_children_virt(lumps);
    for(m=lumps.size(); m--;)
    {
      TopologyBridge *cur_lump = lumps.get_and_step();
      DLIList<TopologyBridge*> shells;
      cur_lump->get_children_virt(shells);
      for(q=shells.size(); q--;)
      {
        TopologyBridge *cur_shell = shells.get_and_step();
        DLIList<TopologyBridge*> surfaces;
        cur_shell->get_children_virt(surfaces);
        for(w=surfaces.size(); w--;)
        {
          TopologyBridge *cur_surface = surfaces.get_and_step();
          DLIList<TopologyBridge*> loops;
          cur_surface->get_children_virt(loops);
          for(g=loops.size(); g--;)
          {
            TopologyBridge *cur_loop = loops.get_and_step();
            DLIList<TopologyBridge*> coedges;
            cur_loop->get_children_virt(coedges);
            for(b=coedges.size(); b--;)
            {
              TopologyBridge *cur_coedge = coedges.get_and_step();
              DLIList<TopologyBridge*> curves;
              cur_coedge->get_children_virt(curves);
              for(s=curves.size(); s--;)
              {
                TopologyBridge *cur_curve = curves.get_and_step();
                DLIList<CubitSimpleAttrib*> list;
                cur_curve->get_simple_attribute("COMPOSITE_GEOM",list);
                if(list.size() == 0)
                  append_attrib( cur_curve, &geom_attrib );
                DLIList<TopologyBridge*> pts;
                cur_curve->get_children_virt(pts);
                for(t=pts.size(); t--;)
                {
                  TopologyBridge *cur_pt = pts.get_and_step();
                  list.clean_out();
                  cur_pt->get_simple_attribute("COMPOSITE_GEOM",list);
                  if(list.size() == 0)
                    append_attrib( cur_pt, &geom_attrib );
                }
              }
            }
          }
        }
      }
    }
  }
}

// Function to apply/remove COMPOSITE_GEOM attributes as necessary based
// on imprinting.
void CompositeEngine::attribute_after_imprinting( DLIList<TopologyBridge*> &new_tbs,
                                                    DLIList<TopologyBridge*> &att_tbs,
                                                    DLIList<BodySM*> &new_sms,
                                                        DLIList<Body*> &old_bodies)
{
  DLIList<TopologyBridge*> old_bridges(old_bodies.size());
  DLIList<TopologyBridge*> new_bridges(new_sms.size());
  DLIList<TopologyBridge*> all_bodies;
  CAST_LIST(new_sms, new_bridges, TopologyBridge);

  all_bodies = new_bridges;
  int k, m, q, w, g, b, s, t;
  for(k = old_bodies.size(); k>0; k--)
  {
    Body *body = old_bodies.get_and_step();
    TopologyBridge *tb = body->bridge_manager()->topology_bridge();
    if(tb)
    {
      old_bridges.append(tb);
      all_bodies.append_unique(tb);
    }
  }

  DLIList<DLIList<TopologyBridge*>*> lists_of_curves;
  DLIList<DLIList<TopologyBridge*>*> lists_of_points;

  // Get lists of curves and points for each body in the
  // list all_bodies.
  all_bodies.reset();
  for(k=all_bodies.size(); k--;)
  {
    DLIList<TopologyBridge*> *new_curve_list = new DLIList<TopologyBridge*>;
    DLIList<TopologyBridge*> *new_point_list = new DLIList<TopologyBridge*>;
    lists_of_curves.append(new_curve_list);
    lists_of_points.append(new_point_list);
    TopologyBridge *cur_body = all_bodies.get_and_step();
    DLIList<TopologyBridge*> lumps;
    cur_body->get_children_virt(lumps);
    for(m=lumps.size(); m--;)
    {
      TopologyBridge *cur_lump = lumps.get_and_step();
      DLIList<TopologyBridge*> shells;
      cur_lump->get_children_virt(shells);
      for(q=shells.size(); q--;)
      {
        TopologyBridge *cur_shell = shells.get_and_step();
        DLIList<TopologyBridge*> surfaces;
        cur_shell->get_children_virt(surfaces);
        for(w=surfaces.size(); w--;)
        {
          TopologyBridge *cur_surface = surfaces.get_and_step();
          DLIList<TopologyBridge*> loops;
          cur_surface->get_children_virt(loops);
          for(g=loops.size(); g--;)
          {
            TopologyBridge *cur_loop = loops.get_and_step();
            DLIList<TopologyBridge*> coedges;
            cur_loop->get_children_virt(coedges);
            for(b=coedges.size(); b--;)
            {
              TopologyBridge *cur_coedge = coedges.get_and_step();
              DLIList<TopologyBridge*> curves;
              cur_coedge->get_children_virt(curves);
              for(s=curves.size(); s--;)
              {
                TopologyBridge *cur_curve = curves.get_and_step();
                new_curve_list->append_unique(cur_curve);
                DLIList<TopologyBridge*> pts;
                cur_curve->get_children_virt(pts);
                for(t=pts.size(); t--;)
                {
                  TopologyBridge *cur_pt = pts.get_and_step();
                  new_point_list->append_unique(cur_pt);
                }
              }
            }
          }
        }
      }
    }
  }


  int i, j, h;
  CubitSense rel_sense;
  double geom_factor = GeometryQueryTool::get_geometry_factor();

  // This code will look at all of the topology bridges that have
  // COMPOSITE_GEOM attributes on them and determine whether to 
  // keep these attributes, remove them, or pass them on to bridges
  // on other volumes based on the expected results from the imprinting operation.

  // Loop twice, once for the curves and then once for the points.
  for(h=0; h<2; h++)
  {
    for(i=att_tbs.size(); i--;)
    {
      TopologyBridge *att_tb = att_tbs.get_and_step();
      Curve *att_cur = dynamic_cast<Curve*>(att_tb);
      Point *att_pt = dynamic_cast<Point*>(att_tb);
      Curve *match_cur;
      Point *match_pt;

      // Force curves to be done first.
      if(h==0 && att_cur)
      {
        match_cur = NULL;
        CubitBox att_box = att_cur->bounding_box();

        // First check the list of new bridges as the corresponding
        // curve will often be there.
        for(j=new_tbs.size(); !match_cur && j; j--)
        {
          TopologyBridge *new_tb = new_tbs.get_and_step();
          Curve *new_cur = dynamic_cast<Curve*>(new_tb);
          if(new_cur && new_cur != att_cur)
          {
            CubitBox new_box = new_cur->bounding_box();
            if(att_box.overlap(GEOMETRY_RESABS, new_box))
            {
              if(this->about_spatially_equal(new_cur, att_cur, rel_sense, geom_factor, 0))
              {
                match_cur = new_cur;
                process_curves_after_imprint(att_cur, new_cur, new_sms);
              }
            }
          }
        }

        // If we didn't find a matching curve in the new bridge list
        // look at all of the rest of the curves.
        if(!match_cur)
        {
          BodySM *att_body = att_cur->bodysm();
          all_bodies.reset();
          lists_of_curves.reset();
          for(j=all_bodies.size(); !match_cur && j; j--)
          {
            TopologyBridge *cur_body = all_bodies.get_and_step();
            DLIList<TopologyBridge*> *curves = lists_of_curves.get_and_step();
            BodySM *cur_bodysm = cur_body->bodysm();

            // Don't look at curves from the same body.
            if(att_body != cur_bodysm)
            {
              for(m=curves->size(); !match_cur && m; m--)
              {
                TopologyBridge *curtb = curves->get_and_step();
                Curve *cur = dynamic_cast<Curve*>(curtb);
                if(cur && cur != att_cur)
                {
                  CubitBox new_box = cur->bounding_box();
                  if(att_box.overlap(GEOMETRY_RESABS, new_box))
                  {
                    if(this->about_spatially_equal(cur, att_cur, rel_sense, geom_factor, 0))
                    {
                      match_cur = cur;
                      process_curves_after_imprint(att_cur, cur, new_sms);
                    }
                  }
                }
              }
            }
          }
        }
      }

      // Force points to be done second.
      else if(h==1 && att_pt)
      {
        match_pt = NULL;
        CubitBox att_box = att_pt->bounding_box();

        // First check the list of new bridges as the corresponding
        // point will often be there.
        for(j=new_tbs.size(); !match_pt && j; j--)
        {
          TopologyBridge *new_tb = new_tbs.get_and_step();
          Point *new_pt = dynamic_cast<Point*>(new_tb);
          if(new_pt && new_pt != att_pt)
          {
            CubitBox new_box = new_pt->bounding_box();
            if(att_box.overlap(GEOMETRY_RESABS, new_box))
            {
              if(GeometryQueryTool::instance()->about_spatially_equal(new_pt->coordinates(), 
                                    att_pt->coordinates(), geom_factor))
              {
                match_pt = new_pt;
                process_points_after_imprint(att_pt, new_pt, new_sms);
              }
            }
          }
        }
        // If we didn't find a matching point in the new bridge list
        // look at all of the rest of the points.
        if(!match_pt)
        {
          BodySM *att_body = att_pt->bodysm();
          all_bodies.reset();
          lists_of_points.reset();
          for(j=all_bodies.size(); !match_pt && j; j--)
          {
            TopologyBridge *cur_body = all_bodies.get_and_step();
            DLIList<TopologyBridge*> *points = lists_of_points.get_and_step();
            BodySM *cur_bodysm = cur_body->bodysm();
            
            // Don't look at points from the same body.
            if(att_body != cur_bodysm)
            {
              for(m=points->size(); !match_pt && m; m--)
              {
                TopologyBridge *curtb = points->get_and_step();
                Point *pt = dynamic_cast<Point*>(curtb);
                if(pt && pt != att_pt)
                {
                  CubitBox new_box = pt->bounding_box();
                  if(att_box.overlap(GEOMETRY_RESABS, new_box))
                  {
                    if(GeometryQueryTool::instance()->about_spatially_equal(pt->coordinates(), 
                                          att_pt->coordinates(), geom_factor))
                    {
                      match_pt = pt;
                      process_points_after_imprint(att_pt, pt, new_sms);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

void CompositeEngine::process_curves_after_imprint(Curve *att_cur, 
                                                   Curve *other_cur,
                                                   DLIList<BodySM*> &new_sms)
{
  DLIList<CubitSimpleAttrib*> list;

  other_cur->get_simple_attribute("IMPRINT_PREEXISTING",list);
  if(list.size() == 0)
  {
    // This is a new bridge created by imprinting this hidden bridge.  In 
    // this case we need to add a COMPOSITE_GEOM attribute to the new bridge
    // so we don't see a resulting imprinted bridge from the hidden bridge.
    list.clean_out();
    att_cur->get_simple_attribute("COMPOSITE_GEOM",list);
    other_cur->append_simple_attribute_virt(new CubitSimpleAttrib(list.get()));
  }
  else
  {
    // This bridge existed before the imprint operation.  Therefore it
    // could also have a COMPOSITE_GEOM attribute on it.  Check this.
    list.clean_out();
    other_cur->get_simple_attribute("COMPOSITE_GEOM",list);
    if(list.size() == 0)
    {
      // It doesn't have a COMPOSITE_GEOM attribute so we need to remove
      // the COMPOSITE_GEOM from att_bridge because the hidden nature gets
      // wiped out by the imprinting process.
      att_cur->get_simple_attribute("COMPOSITE_GEOM",list);
      att_cur->remove_simple_attribute_virt(list.get());
      BodySM *bsm = att_cur->bodysm();
      if(bsm)
        new_sms.append_unique(bsm);
      TBOwner *bridge_owner = att_cur->owner();
      CompositeCurve *cc_bridge_owner = dynamic_cast<CompositeCurve*>(bridge_owner);
      if(cc_bridge_owner)
      {
        TBOwner *cc_owner = cc_bridge_owner->owner();
        HiddenEntitySet *hes = dynamic_cast<HiddenEntitySet*>(cc_owner);
        if(hes)
        {
          CompositeSurface *cs = dynamic_cast<CompositeSurface*>(hes->owner());
          if(cs)
            cs->HadBridgeRemoved = 1;
            // This is currently how we are notifying the owning CompositeSurface
            // that it needs to be deactivated and rebuilt.  It really has 
            // nothing to do with the bridge being removed though.  Bad.
        }
      }
    }
    else
    {
      // This bridge was also hidden so do nothing.
    }
  }
}

void CompositeEngine::process_points_after_imprint(Point *att_pt, 
                                                   Point *other_pt,
                                                   DLIList<BodySM*> &new_sms)
{
  int i;
  DLIList<CubitSimpleAttrib*> list;

  other_pt->get_simple_attribute("IMPRINT_PREEXISTING",list);
  if(list.size() == 0)
  {
    // This is a new bridge created by imprinting this hidden bridge.  In 
    // this case we need to add a COMPOSITE_GEOM attribute to the new bridge
    // if possible so we don't see a resulting imprinted bridge from the hidden bridge.
    int num_visible_curves = 0;
    DLIList<TopologyBridge*> curves;
    att_pt->get_parents_virt(curves);
    for(i=curves.size(); i--;)
    {
      list.clean_out();
      TopologyBridge *c = curves.get_and_step();
      c->get_simple_attribute("COMPOSITE_GEOM", list);
      if(list.size() == 0)
        num_visible_curves++;
    }
    if(num_visible_curves > 2)
    {
      list.clean_out();
      att_pt->get_simple_attribute("COMPOSITE_GEOM",list);
      att_pt->remove_simple_attribute_virt(list.get());
      BodySM *bsm = att_pt->bodysm();
      if(bsm)
        new_sms.append_unique(bsm);
      TBOwner *bridge_owner = att_pt->owner();
      CompositePoint *cp_bridge_owner = dynamic_cast<CompositePoint*>(bridge_owner);
      if(cp_bridge_owner)
      {
        TBOwner *cp_owner = cp_bridge_owner->owner();
        HiddenEntitySet *hes = dynamic_cast<HiddenEntitySet*>(cp_owner);
        if(hes)
        {
          CompositeCurve *cc = dynamic_cast<CompositeCurve*>(hes->owner());
          if(cc)
            cc->HadBridgeRemoved = 1;
            // This is currently how we are notifying the owning CompositeCurve
            // that it needs to be deactivated and rebuilt.  It really has 
            // nothing to do with the bridge being removed though.  Bad.
        }
      }
    }
    else
    {
      list.clean_out();
      att_pt->get_simple_attribute("COMPOSITE_GEOM",list);
      other_pt->append_simple_attribute_virt(new CubitSimpleAttrib(list.get()));
    }
  }
  else
  {
    // This bridge existed before the imprint operation.  Therefore it
    // could also have a COMPOSITE_GEOM attribute on it.  Check this.
    list.clean_out();
    other_pt->get_simple_attribute("COMPOSITE_GEOM",list);
    if(list.size() == 0)
    {
      // It doesn't have a COMPOSITE_GEOM attribute so we need to remove
      // the COMPOSITE_GEOM from att_bridge because the hidden nature gets
      // wiped out by the imprinting process.
      att_pt->get_simple_attribute("COMPOSITE_GEOM",list);
      att_pt->remove_simple_attribute_virt(list.get());
      BodySM *bsm = att_pt->bodysm();
      if(bsm)
        new_sms.append_unique(bsm);
      TBOwner *bridge_owner = att_pt->owner();
      CompositePoint *cp_bridge_owner = dynamic_cast<CompositePoint*>(bridge_owner);
      if(cp_bridge_owner)
      {
        TBOwner *cp_owner = cp_bridge_owner->owner();
        HiddenEntitySet *hes = dynamic_cast<HiddenEntitySet*>(cp_owner);
        if(hes)
        {
          CompositeCurve *cc = dynamic_cast<CompositeCurve*>(hes->owner());
          if(cc)
            cc->HadBridgeRemoved = 1;
            // This is currently how we are notifying the owning CompositeCurve
            // that it needs to be deactivated and rebuilt.  It really has 
            // nothing to do with the bridge being removed though.  Bad.
        }
      }
    }
    else
    {
      // This bridge was also hidden so do nothing.
    }
  }
}

// This is a copy of the function in MergeTool with the difference that it
// accepts a layer flag to dictate at which level the topology is traversed
// (solid modeler level or virtual level).
CubitBoolean CompositeEngine::about_spatially_equal( Curve *curve_1, Curve *curve_2,
                                               CubitSense &relative_sense, 
                                               double tolerance_factor,
                                               int layer)
{
  if( curve_1 == curve_2 )
    return CUBIT_TRUE;

  relative_sense = CUBIT_FORWARD;
  const double ONE_THIRD = 1.0/3.0;

  // Find the point 1/3 along curve_1 
  CubitVector test_point_1, test_point_2;
  if( curve_1->position_from_fraction( ONE_THIRD, test_point_1 ) != CUBIT_SUCCESS )
    return CUBIT_FALSE;

  // See if the 1/3 point on curve_1 lies on curve_2
  if ( curve_2->closest_point_trimmed(test_point_1, test_point_2)
       != CUBIT_SUCCESS )
  {
    return CUBIT_FALSE;
  }

  if ( GeometryQueryTool::instance()->
       about_spatially_equal(test_point_1, test_point_2, tolerance_factor )
       != CUBIT_SUCCESS )
  {
    return CUBIT_FALSE;
  }
  
  CubitVector tangent_1, tangent_2;
  if( curve_1->closest_point(test_point_2, test_point_1, &tangent_1) != CUBIT_SUCCESS )
    return CUBIT_FALSE;
  if( curve_2->closest_point(test_point_1, test_point_2, &tangent_2) != CUBIT_SUCCESS )
    return CUBIT_FALSE;

  //If one of the curves is zero-length, it will have a zero
  //tangent vector.
  double len_product = tangent_1.length() * tangent_2.length();
  if( len_product > CUBIT_DBL_MIN )
  {
    double dot_product = (tangent_1 % tangent_2);
    if (dot_product < 0)
    relative_sense = CUBIT_REVERSED;
  }
  else
  {
    //If one of the tangents is zero-length, one of the curves had
    //better be as well.
    assert( (curve_1->measure() * curve_2->measure()) < CUBIT_RESABS );
  }

  //compare the start and end vertices to be spatially equal.
  DLIList<Point*> curve_1_points(2), curve_2_points(2);
  DLIList<TopologyBridge*> c1pts, c2pts;
  curve_1->get_children(c1pts, false, layer);
  curve_2->get_children(c2pts, false, layer);
  CAST_LIST( c1pts, curve_1_points, Point );
  CAST_LIST( c2pts, curve_2_points, Point );

  if( curve_1->bridge_sense() == CUBIT_REVERSED )
    curve_1_points.reverse();
  if( curve_2->bridge_sense() == CUBIT_REVERSED )
    curve_2_points.reverse();

  Point* curve_1_start = curve_1_points.get(); 
  curve_1_points.last();
  Point* curve_1_end =  curve_1_points.get();

  Point* curve_2_start = curve_2_points.get(); 
  curve_2_points.last();
  Point* curve_2_end =  curve_2_points.get();

  if (relative_sense == CUBIT_REVERSED)
    std::swap(curve_2_start, curve_2_end);

  if (curve_1_start == curve_1_end ||curve_2_start == curve_2_end)
  {
    CubitVector c1start = curve_1_start->coordinates();
    CubitVector c2start = curve_2_start->coordinates();
    if ((curve_1_start != curve_1_end) ||
        (curve_2_start != curve_2_end) ||
        !GeometryQueryTool::instance()->about_spatially_equal(c1start, c2start, tolerance_factor))
      return CUBIT_FALSE;
  }
  else
  {
    CubitVector c1start = curve_1_start->coordinates();
    CubitVector c1end = curve_1_end->coordinates();
    CubitVector c2start = curve_2_start->coordinates();
    CubitVector c2end = curve_2_end->coordinates();
    if ((curve_1_start == curve_2_end) ||
        (curve_1_end == curve_2_start) ||
        !GeometryQueryTool::instance()->about_spatially_equal(c1start, c2start, tolerance_factor ) ||
        !GeometryQueryTool::instance()->about_spatially_equal(c1end, c2end, tolerance_factor ))
      return CUBIT_FALSE;
  }

  return CUBIT_TRUE;

}

// This function will try to determine if virtual topology bridges have
// been modified and if so will deactivate them so that they can be 
// rebuilt later using the COMPOSITE_GEOM attributes on the underlying
// solid model topology.
void CompositeEngine::remove_modified(DLIList<TopologyBridge*>& geometry_list)
{
  clean_out_deactivated_geometry();

  int i, j, k, m, n, w;
  int deactivate;
  int something_changed = 1;
  DLIList<Point*> already_deactivated_points;
  DLIList<Curve*> already_deactivated_curves;
  DLIList<Surface*> already_deactivated_surfs;

  while(something_changed)
  {
    something_changed = 0;

    for (i=geometry_list.size(); i--; )
    {
      // This code will first look for portions of the left over virtual
      // topology layer that need to be blown away (deactivated).  It
      // will put its findings in lists.  Then it will loop through
      // and actualy deactivate everything.
      TopologyBridge* geom_bridge = geometry_list.get_and_step();

      DLIList<Surface*> surfaces;
      DLIList<Curve*> curves;
      DLIList<Point*> points;
      DLIList<Point*> deactivated_points;
      DLIList<Curve*> deactivated_curves;
      DLIList<Surface*> deactivated_surfs;

      geom_bridge->surfaces(surfaces);
      geom_bridge->curves(curves);
      geom_bridge->points(points);

      // Look for composite points that are out of date.
      while(points.size())
      {
        CompositePoint *p = dynamic_cast<CompositePoint*>(points.pop());
        if(p && !already_deactivated_points.is_in_list(p))
        {
          Point *real_point = p->get_point();

          deactivate = 0;

          if(p->HadBridgeRemoved)
            deactivate = 1;

          // Check the curve attached to this point and make sure the
          // virtual layer still matches the solid model layer.
          if(!deactivate)
          {
            // Get the curves at this point using the virtual layer.
            DLIList<Curve*> curves_referenced_by_virtual;
            DLIList<Curve*> crvs;
            p->curves(crvs);
            for(j=crvs.size(); j--;)
            {
              Curve *c = crvs.get_and_step();
              CompositeCurve *cc = dynamic_cast<CompositeCurve*>(c);
              if(cc)
              {
                int num_curves = cc->num_curves();
                for(k=0; k<num_curves; ++k)
                {
                  Curve *cur_c = cc->get_curve(k);
                  DLIList<TopologyBridge*> pts;
                  cur_c->get_children(pts, false, 0);
                  if(pts.is_in_list(real_point))
                    curves_referenced_by_virtual.append_unique(cur_c);
                }
              }
              else
                curves_referenced_by_virtual.append_unique(c);
            }

            // Get the curves refernced by the solid model layer.
            DLIList<Curve*> curves_referenced_by_solid_model_layer;
            DLIList<TopologyBridge*> sm_crvs;
            real_point->get_parents_virt(sm_crvs);
            CAST_LIST(sm_crvs, curves_referenced_by_solid_model_layer, Curve);

            // Now check to make sure all of the curves referenced from the virtual
            // layer show up in the ones referenced by the solid model layer.  If
            // they don't we know something has been modified and this CompositePoint
            // is no longer valid.
            for(j=curves_referenced_by_virtual.size(); j && !deactivate; j--)
            {
              Curve *c = curves_referenced_by_virtual.get_and_step();
              if(!curves_referenced_by_solid_model_layer.is_in_list(c))
                deactivate = 1;
            }
          }

          if(deactivate)
            deactivated_points.append_unique(p);
        }
      }

      // Look for composite curves that are out of date.
      for(w=curves.size(); w--;)
      {
        Curve *current_curve = curves.get_and_step();
        CompositeCurve *cur = dynamic_cast<CompositeCurve*>(current_curve);
        if(cur && !already_deactivated_curves.is_in_list(cur))
        {
          deactivate = 0;

          if(cur->HadBridgeRemoved)
            deactivate = 1;

          // Deactivate this curve if any of its points have been 
          // deactivated.
          if(!deactivate)
          {
            DLIList<Point*> hidden_pts;
            DLIList<Point*> boundary_pts;

            cur->get_hidden_points(hidden_pts);
            for(j=hidden_pts.size(); j && !deactivate; j--)
            {
              Point *pt = hidden_pts.get_and_step();
              if(deactivated_points.is_in_list(pt))
                deactivate = 1;
            }

            cur->points(boundary_pts);
            for(j=boundary_pts.size(); j && !deactivate; j--)
            {
              Point *pt = boundary_pts.get_and_step();
              if(deactivated_points.is_in_list(pt))
                deactivate = 1;
            }
          }

          // Deactivate this curve if the coedges stored at the
          // virtual layer are out of sync with the solid model layer.
          if(!deactivate)
          {
            // Get all of the coedges seen from the virtual layer.
            DLIList<CoEdgeSM*> virt_coedges;
            DLIList<TopologyBridge*> coedge_list;
            cur->get_parents(coedge_list);
            for(j=coedge_list.size(); j--;)
            {
              CoEdgeSM *csm = dynamic_cast<CoEdgeSM*>(coedge_list.get_and_step());
              if(csm)
              {
                CompositeCoEdge *cce = dynamic_cast<CompositeCoEdge*>(csm);
                if(cce)
                {
                  int num_coedges = cce->num_coedges();
                  for(k=0; k<num_coedges; k++)
                  {
                    CoEdgeSM *cur_coedge = cce->get_coedge(k);
                    virt_coedges.append_unique(cur_coedge);
                  }
                }
                else
                  virt_coedges.append_unique(csm);
              }
            }

            // Get all of the coedges seen from the solid model layer.
            DLIList<CoEdgeSM*> real_coedges;
            int num_curves = cur->num_curves();
            for(j=0; j<num_curves; j++)
            {
              Curve *cur_c = cur->get_curve(j);
              DLIList<TopologyBridge*> tb_list;
              cur_c->get_parents_virt(tb_list);
              for(k=tb_list.size(); k--;)
              {
                CoEdgeSM *cur_ce = dynamic_cast<CoEdgeSM*>(tb_list.get_and_step());
                if(cur_ce)
                  real_coedges.append_unique(cur_ce);
              }
            }

            // Now make sure all of the coedges seen from the virtual layer actually
            // still exist in the solid model layer.
            for(j=virt_coedges.size(); j && !deactivate; j--)
            {
              if(!real_coedges.is_in_list(virt_coedges.get_and_step()))
                deactivate = 1;
            }
          }

          // Deactivate this curve if any of the points seen from the virtual
          // layer are out of date.
          if(!deactivate)
          {
            DLIList<Point*> points_referenced_by_virtual;
            DLIList<Point*> points_referenced_by_solid_model_layer;

            // Get all of the hidden points in virtual layer.
            DLIList<Point*> hidden_pts;
            cur->get_hidden_points(hidden_pts);
            for(j=hidden_pts.size(); j--;)
            {
              Point *cur_point = hidden_pts.get_and_step();
              CompositePoint *cur_cpoint = dynamic_cast<CompositePoint*>(cur_point);
              if(cur_cpoint)
                cur_point = cur_cpoint->get_point();
              points_referenced_by_virtual.append_unique(cur_point);
            }

            // Get the end points in virtual layer.
            DLIList<Point*> end_pts;
            cur->points(end_pts);
            for(j=end_pts.size(); j--;)
            {
              Point *cur_point = end_pts.get_and_step();
              CompositePoint *cur_cpoint = dynamic_cast<CompositePoint*>(cur_point);
              if(cur_cpoint)
                cur_point = cur_cpoint->get_point();
              points_referenced_by_virtual.append_unique(cur_point);
            }
            
            // Get the points of all of the curves from the solid model layer.
            int num_curves = cur->num_curves();
            for(j=0; j<num_curves; ++j)
            {
              DLIList<TopologyBridge*> pts;
              Curve *c = cur->get_curve(j);
              c->get_children(pts, false, 0);
              for(k=pts.size(); k--;)
                points_referenced_by_solid_model_layer.
                        append_unique(dynamic_cast<Point*>(pts.get_and_step()));
            }

            // Now that we have gathered all of the info we can check to make sure
            // that all of the points in the virtual layer actually exist in the
            // solid model layer.
            for(j=points_referenced_by_virtual.size(); j && !deactivate; j--)
            {
              Point *cur_point = points_referenced_by_virtual.get_and_step();
              if(!points_referenced_by_solid_model_layer.is_in_list(cur_point))
                deactivate = 1;
            }
          }

          // Check to see if there is a hidden entity that doesn't have a 
          // COMPOSITE_GEOM attribute.  This can happen if the geometry 
          // modification operation cut the body right through a hidden 
          // entity without splitting it.  In this case a merge_owner event
          // gets triggered and the COMPOSITE_GEOM attribute gets removed
          // from the hidden entity.  In this case we want to remove the
          // composite.
          if(!deactivate)
          {
            DLIList<Point*> hidden_points;
            cur->get_hidden_points(hidden_points);
            for(j=hidden_points.size(); j>0 && !deactivate; j--)
            {
              DLIList<CubitSimpleAttrib*> att_list;
              hidden_points.get_and_step()->get_simple_attribute("COMPOSITE_GEOM", att_list);
              if(att_list.size() == 0)
                deactivate = 1;
            }
          }

          // This block checks to see if any of the hidden points in 
          // a composite curve are the endpoints of an actual curve of
          // the passed in geometry list.  This can happen if the hidden
          // curve of a composite surface was cut by a real operation and
          // an end point of the original hidden curve was a hidden point
          // in a composite curve.  In this case we want to deactivate the
          // composite curve.  If the composite curve is still valid it will 
          // get reconstructed by the composite attributes later. 
          if(!deactivate)
          {
            DLIList<Point*> hidden;
            cur->get_hidden_points(hidden);
            for (j=hidden.size(); j && !deactivate; j--)
            {
              Point *pt = hidden.pop();
              DLIList<TopologyBridge*> point_curves;
              pt->get_parents_virt(point_curves);
              for(k=point_curves.size(); k && !deactivate; k--)
              {
                Curve *c = dynamic_cast<Curve*>(point_curves.get_and_step());
                if(c && c != current_curve && curves.is_in_list(c))
                  deactivate = 1;
              }
            }
          }

          // Check to see if the existing CompositeCurve end points match the
          // underlying geometry end points.  In some geometry modification
          // operations I found that a curve can be modified in place so that 
          // the underlying entity was changed but owner attribute wasn't blown
          // away.  As a result you end up with the same toplogy bridge which can
          // be out of date.  The case I saw was where the Point in the CompositePoint
          // at one of the ends of the CompositeCurve was out of date and didn't
          // match the new Point that was created during the geometry modification.
          if(!deactivate)
          {
            // Not quite sure how to handle multiple curve cases yet so we
            // will do our best for now.
            if(cur->num_curves() == 1)
            {
              DLIList<TopologyBridge*> underlying_points;
              cur->get_curve(0)->get_children_virt(underlying_points);
              if(underlying_points.size() == 2)
              {
                Point *p1 = dynamic_cast<Point*>(underlying_points.get_and_step());
                Point *p2 = dynamic_cast<Point*>(underlying_points.get());

                CompositePoint *cp1 = cur->start_point();
                CompositePoint *cp2 = cur->end_point();

                if(!cp1 || !cp2)
                  deactivate = 1;
                else
                {
                  Point *cpp1 = cp1->get_point();
                  Point *cpp2 = cp2->get_point();
                  if((p1 != cpp1 && p2 != cpp1) || (p1 != cpp2 && p2 != cpp2))
                    deactivate = 1;
                }
              }
            }
          }

          if(deactivate)
            deactivated_curves.append_unique(cur);

        }
      }

      // Look for composite surfaces that are out of date.
      while (surfaces.size())
      {
        CompositeSurface* csurf = dynamic_cast<CompositeSurface*> (surfaces.pop());
        if (csurf && !already_deactivated_surfs.is_in_list(csurf))
        {
          deactivate = 0;

          // If one of the surfaces was removed from the compGeom list we
          // suspect this composite surface was modified so we need to remove it.
          if(csurf->HadBridgeRemoved)
            deactivate = 1;

          // Deactivate this surface if any of its curves were deactivated.
          if(!deactivate)
          {
            DLIList<Curve*> hidden_curves;
            DLIList<Curve*> boundary_curves;

            csurf->get_hidden_curves(hidden_curves);
            for(j=hidden_curves.size(); j && !deactivate; j--)
            {
              Curve *curve = hidden_curves.get_and_step();
              if(deactivated_curves.is_in_list(curve))
                deactivate = 1;
            }

            csurf->curves(boundary_curves);
            for(j=boundary_curves.size(); j && !deactivate; j--)
            {
              Curve *curve = boundary_curves.get_and_step();
              if(deactivated_curves.is_in_list(curve))
                deactivate = 1;
            }
          }

          // Deactivate this surface if any of its curves seen from the
          // virtual layer are out of date.
          if(!deactivate)
          {
            DLIList<Curve*> curves_referenced_by_virtual;
            DLIList<Curve*> curves_referenced_by_solid_model_layer;

            // Get all of the hidden curves in virtual layer.
            DLIList<Curve*> hidden_curves;
            csurf->get_hidden_curves(hidden_curves);
            for(j=hidden_curves.size(); j--;)
            {
              Curve *cur_curve = hidden_curves.get_and_step();
              CompositeCurve *cur_ccurve = dynamic_cast<CompositeCurve*>(cur_curve);
              if(cur_ccurve)
              {
                for(k=cur_ccurve->num_curves()-1; k>-1; k--)
                {
                  Curve *cur = cur_ccurve->get_curve(k);
                  curves_referenced_by_virtual.append_unique(cur);
                }
              }
              else
                curves_referenced_by_virtual.append_unique(cur_curve);
            }

            // Get the boundary curves in virtual layer.
            DLIList<Curve*> end_curves;
            csurf->curves(end_curves);
            for(j=end_curves.size(); j--;)
            {
              Curve *cur_curve = end_curves.get_and_step();
              CompositeCurve *cur_ccurve = dynamic_cast<CompositeCurve*>(cur_curve);
              if(cur_ccurve)
              {
                for(k=cur_ccurve->num_curves()-1; k>-1; k--)
                {
                  Curve *cur = cur_ccurve->get_curve(k);
                  curves_referenced_by_virtual.append_unique(cur);
                }
              }
              else
                curves_referenced_by_virtual.append_unique(cur_curve);
            }
            
            // Get the curves of all of the surfaces from the solid model layer.
            int num_surfs = csurf->num_surfs();
            for(j=0; j<num_surfs; ++j)
            {
              Surface *s = csurf->get_surface(j);
              DLIList<TopologyBridge*> loops;
              s->get_children(loops, false, 0);
              for(k=loops.size(); k--;)
              {
                LoopSM *cur_loop = dynamic_cast<LoopSM*>(loops.get_and_step());
                DLIList<TopologyBridge*> coedges;
                cur_loop->get_children(coedges, false, 0);
                for(m=coedges.size(); m--;)
                {
                  CoEdgeSM *cur_coedge = dynamic_cast<CoEdgeSM*>(coedges.get_and_step());
                  DLIList<TopologyBridge*> crvs;
                  cur_coedge->get_children(crvs, false, 0);
                  for(n=crvs.size(); n--;)
                  {
                    Curve *cur_curve = dynamic_cast<Curve*>(crvs.get_and_step());
                    curves_referenced_by_solid_model_layer.append_unique(cur_curve);
                  }
                }
              }
            }

            // Now that we have gathered all of the info we can check to make sure
            // that all of the curves in the virtual layer actually exist in the
            // solid model layer.
            if(curves_referenced_by_virtual.size() != 
              curves_referenced_by_solid_model_layer.size())
            {
              deactivate = 1;
            }
            else
            {
              for(j=curves_referenced_by_virtual.size(); j && !deactivate; j--)
              {
                Curve *cur_curve = curves_referenced_by_virtual.get_and_step();
                if(!curves_referenced_by_solid_model_layer.is_in_list(cur_curve))
                  deactivate = 1;
              }
            }
          }

          // Check to see if there is a hidden entity that doesn't have a 
          // COMPOSITE_GEOM attribute.  This can happen if the geometry 
          // modification operation cut the body right through a hidden 
          // entity without splitting it.  In this case a merge_owner event
          // gets triggered and the COMPOSITE_GEOM attribute gets removed
          // from the hidden entity.  In this case we want to remove the
          // composite.
          if(!deactivate)
          {
            DLIList<Curve*> hidden_curves;
            csurf->get_hidden_curves(hidden_curves);
            for(j=hidden_curves.size(); j>0 && !deactivate; j--)
            {
              DLIList<CubitSimpleAttrib*> att_list;
              hidden_curves.get_and_step()->get_simple_attribute("COMPOSITE_GEOM", att_list);
              if(att_list.size() == 0)
                deactivate = 1;
            }
          }

          if(deactivate)
            deactivated_surfs.append_unique(csurf);
        }
      }

      already_deactivated_points += deactivated_points;
      already_deactivated_curves += deactivated_curves;
      already_deactivated_surfs += deactivated_surfs;

      something_changed += deactivated_surfs.size() + deactivated_curves.size() +
        deactivated_points.size();

      // Now actually deactivate the out of date composite surfs.
      for(j=deactivated_surfs.size(); j--;)
      {
        CompositeSurface *csurf = dynamic_cast<CompositeSurface*>(deactivated_surfs.get_and_step());

        // We have to also deactivate the boundary curves.  When we deactivate
        // the CompositeSurface it removes all of the CompositeCoEdges associated
        // with it.  However, it doesn't deactivate the composite curves associated
        // with the composite coedges.  Therefore you can end up with a regular
        // CoEdge pointing to a CompositeCurve and if the CompositeCurve has more
        // than 1 curve in it later calls to replace_surface (which will in turn
        // call replace_curve) will fail.
        DLIList<Curve*> boundary_curves;
        csurf->curves(boundary_curves);
        for (k=boundary_curves.size(); k--; )
        {
          CompositeCurve* c = dynamic_cast<CompositeCurve*>(boundary_curves.get_and_step());
          assert(NULL != c);

          notify_deactivated(c);
        }

        notify_deactivated(csurf);

        DLIList<Curve*> hidden;
        csurf->get_hidden_curves(hidden);
        for (k=hidden.size(); k--; )
        {
          CompositeCurve* hcurve = dynamic_cast<CompositeCurve*>(hidden.pop());
          assert(NULL != hcurve);

          notify_deactivated(hcurve);

          if(hcurve->num_curves() == 1)
          {
            Curve *c = hcurve->get_curve(0);
            DLIList<TopologyBridge*> end_pts;
            c->get_children(end_pts, false, 0);
            for(m=end_pts.size(); m--;)
            {
              Point *cur_p = dynamic_cast<Point*>(end_pts.get_and_step());
              if(cur_p)
              {
                CompositePoint* cp = dynamic_cast<CompositePoint*>(cur_p->owner());
                if(cp)
                  cur_p = (Point*)cp;
                TBOwner *own = cur_p->owner();
                HiddenEntitySet *hes = dynamic_cast<HiddenEntitySet*>(own);
                if(hes)
                {
                  CompositeCurve *cc = dynamic_cast<CompositeCurve*>(hes->owner());
                  if(cc)
                  {
                    notify_deactivated(cc);

                    DLIList<Point*> hidden_pts;
                    cc->get_hidden_points(hidden_pts);
                    for (n=hidden_pts.size(); n--; )
                    {
                      CompositePoint *hpoint = dynamic_cast<CompositePoint*>(hidden_pts.pop());
                      assert(NULL != hpoint);
                      notify_deactivated(hpoint);
                    }
                  }
                }
              }
            }
          }
        }
      }

      // Now actually deactivate the out of date composite curves.
      for(j=deactivated_curves.size(); j--;)
      {
        CompositeCurve *ccurve = dynamic_cast<CompositeCurve*>(deactivated_curves.get_and_step());

        notify_deactivated(ccurve);

        int j;
        DLIList<Point*> hidden;
        ccurve->get_hidden_points(hidden);
        for (j=hidden.size(); j--; )
        {
          CompositePoint *hpoint = dynamic_cast<CompositePoint*>(hidden.pop());
          assert(NULL != hpoint);
          notify_deactivated(hpoint);
        }
      }

      // Now actually deactivate the out of date composite points.
      for(j=deactivated_points.size(); j--;)
      {
        CompositePoint* cpoint = dynamic_cast<CompositePoint*> (deactivated_points.pop());
        notify_deactivated(cpoint);
      }
    }
  }
}

//-------------------------------------------------------------------------
// Purpose       : Constructor
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 08/25/03
//-------------------------------------------------------------------------
CompositeEngine::CompositeEngine()
{
  CubitStatus result = GeometryQueryTool::instance()->
    register_intermediate_engine( this );
  assert(result == CUBIT_SUCCESS);
}

//-------------------------------------------------------------------------
// Purpose       : Get composite-level query results from
//                 query of underlying topology.
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 03/13/02
//-------------------------------------------------------------------------
/*
void CompositeEngine::fix_up_query_results( DLIList<TopologyBridge*>& list,
                                            bool keep_hidden )
{
  DLIList<TopologyBridge*> tmp_list;
  int i;
  
  list.reset();
  for( i = list.size(); i--; )
  {
    TopologyBridge* bridge = list.get();
    TBOwnerSet* set = dynamic_cast<TBOwnerSet*>(bridge->owner());
    if( set )
    {
      tmp_list.clean_out();
      set->get_owners( tmp_list );
      if( tmp_list.size() )
      {
        tmp_list.reset();
        list.change_to( tmp_list.get_and_step() );
        for( int j = 1; j < tmp_list.size(); j++ )
          list.insert( tmp_list.get_and_step() );
      }
      else
      {
        list.change_to(0);
      }
    }
    list.step();
  }
  
  list.remove_all_with_value( 0 );
  
  list.reset();
  for( i = list.size(); i--; )
  {
    TopologyBridge* bridge = list.get();
    TopologyBridge *next = 0;
    while( next = dynamic_cast<TopologyBridge*>(bridge->owner()) )
      bridge = next;
    
    if( !keep_hidden && dynamic_cast<HiddenEntitySet*>(bridge->owner()) )
    {
      list.change_to(0);
    }
    else if( list.get() != bridge )
    {
      if( list.is_in_list( bridge ) )
        list.change_to(0);
      else
        list.change_to(bridge);
    }
    
    list.step();
  }
  
  list.remove_all_with_value( 0 );
}
*/


//-------------------------------------------------------------------------
// Purpose       : Combine two curves
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 03/13/02
//-------------------------------------------------------------------------
CompositeCurve* CompositeEngine::composite( Curve* keep_curve,
                                            Curve* dead_curve,
                                            Point* keep_point,
                                            bool remove_partition )
{
  if( keep_curve == dead_curve )
  {
    PRINT_ERROR("Cannot remove vertex from single-vertex curve.\n");
    return 0;
  }
  
  CompositeCurve* result = 0;
  CompositeCurve* ckeep = dynamic_cast<CompositeCurve*>(keep_curve);
  CompositeCurve* cdead = dynamic_cast<CompositeCurve*>(dead_curve);
  bool replaced1 = false;
  bool replaced2 = false;
  
  if( !ckeep )
  {
    ckeep = replace_curve( keep_curve );
    replaced1 = true;
  }
  if( !cdead )
  {
    cdead = replace_curve( dead_curve );
    replaced2 = true;
  }
  
  CompositePoint* comppoint = dynamic_cast<CompositePoint*>(keep_point);
  if( keep_point && !comppoint )
  {
    comppoint = dynamic_cast<CompositePoint*>(keep_point->owner());
    assert( comppoint!= NULL );
  }
  
  if( !ckeep || !cdead || 
      !(result = combine(ckeep, cdead, comppoint, remove_partition)) )
  {
    if( replaced1 && ckeep )
    {
      Curve* s = remove_composite( ckeep );
      assert( s != 0 );
    }
    if( replaced2 && cdead )
    {
      Curve* s = remove_composite( cdead );
      assert( s != 0 );
    }
  }
  
  return result;
}

//-------------------------------------------------------------------------
// Purpose       : Replace a "point" curve with a composite
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 11/26/02
//-------------------------------------------------------------------------
CompositePoint* CompositeEngine::replace_point( Point* point )
{
  assert( !dynamic_cast<CompositePoint*>(point) );
  return new CompositePoint( point );
}

//-------------------------------------------------------------------------
// Purpose       : Replace a "real" curve with a composite
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 03/13/02
//-------------------------------------------------------------------------
CompositeCurve* CompositeEngine::replace_curve( Curve* curve )
{
#ifdef BOYD17
  DLIList<TopologyBridge*> points, coedges, loops;
#endif
  DLIList<TopologyBridge*> points, coedges;
  //curve->get_children_virt( points );
  //fix_up_query_results(points);
  curve->get_children( points, true, COMPOSITE_LAYER );

  if(points.size() > 2)
    return 0;
    
  points.reset();
  Point* start_pt = dynamic_cast<Point*>(points.get_and_step());
  Point*   end_pt = dynamic_cast<Point*>(points.get_and_step());

  CompositeCurve* composite = dynamic_cast<CompositeCurve*>(curve);
  
  if(!composite)
    composite = new CompositeCurve( curve );
  else
  {
    if(composite->num_curves() > 1)
    {
      PRINT_ERROR("Error replacing existing composite curve with more than one underlying curve\n");
      return 0;
    }
  }

  CompositePoint* start = dynamic_cast<CompositePoint*>(start_pt);
  if( !start ) 
    start = replace_point( start_pt );
  CompositePoint* end = 0;
  if ( end_pt == start_pt )
    end = start;
  else if ( !(end = dynamic_cast<CompositePoint*>(end_pt)) )
    end = replace_point( end_pt );
  assert( start && end );

  composite->start_point( start );
  composite->  end_point(   end );

  DLIList<TopologyBridge*> existing_composite_coedges;
  if(dynamic_cast<CompositeCurve*>(curve))
  {
    dynamic_cast<CompositeCurve*>(curve)->get_curve(0)->get_parents_virt(coedges);
    curve->get_parents_virt(existing_composite_coedges);
  }
  else
  {
    curve->get_parents_virt( coedges );
  }
  for( int i = coedges.size(); i--; )
  {
    CoEdgeSM* coedge = dynamic_cast<CoEdgeSM*>(coedges.get_and_step());
    assert(coedge);
    CompositeCoEdge* ccoedge = NULL;
    for(int h=existing_composite_coedges.size(); h>0; h--)
    {
      CompositeCoEdge *temp = dynamic_cast<CompositeCoEdge*>(existing_composite_coedges.get_and_step());
      if(temp->get_coedge(0) == coedge)
      {
        ccoedge = temp;
        h = 0;
      }
    }
    if(!ccoedge)
    {
      ccoedge = new CompositeCoEdge( coedge );
      if( composite->get_sense(0) == CUBIT_REVERSED )
        ccoedge->reverse();
      
      assert( ccoedge->get_curve() == 0 );
      composite->add( ccoedge );
    }
  }
  
  return composite;
}


//-------------------------------------------------------------------------
// Purpose       : Replace a "real" surface with a composite
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 03/13/02
//-------------------------------------------------------------------------
CompositeSurface* CompositeEngine::replace_surface( Surface* surface )
{
  DLIList<TopologyBridge*> loops, coedges, curves;
  int i, j;
  if( dynamic_cast<CompositeSurface*>(surface) )
    return 0;
  
  CompositeSurface* compsurf = new CompositeSurface( surface );
  //surface->get_children_virt( loops );
  //fix_up_query_results(loops);
  surface->get_children( loops, false, COMPOSITE_LAYER );
  loops.reset();
  for( i = loops.size();i--; )
  {
    TopologyBridge* loop_bridge = loops.get_and_step();
    CompositeLoop* comploop = new CompositeLoop();
    compsurf->add( comploop );
    if( loop_bridge->owner() )
    {
      loop_bridge->owner()->swap_bridge( loop_bridge, comploop, false );
      loop_bridge->owner(0);
    }
    //compsurf->hidden_entities().hide( loop_bridge );
    
    coedges.clean_out();
    //loop_bridge->get_children_virt( coedges );
    //fix_up_query_results(coedges);
    loop_bridge->get_children( coedges, false, COMPOSITE_LAYER );
    
    coedges.reset();
    CompositeCoEdge* prev = 0;
    for( j = coedges.size(); j--; )
    {
      CoEdgeSM* coedge = dynamic_cast<CoEdgeSM*>(coedges.get_and_step());
      CompositeCoEdge* comp_coedge = dynamic_cast<CompositeCoEdge*>(coedge);
      if( !comp_coedge )
      {
        curves.clean_out();
        //coedge->get_children_virt( curves );
        //fix_up_query_results(curves);
        coedge->get_children(curves, false, COMPOSITE_LAYER);
        assert( curves.size() == 1 );
        replace_curve( dynamic_cast<Curve*>(curves.get()) );
        comp_coedge = dynamic_cast<CompositeCoEdge*>(coedge->owner());
        assert( comp_coedge!= NULL );
      }
      else
      {
        /*
        PRINT_INFO("\nStart: %lf %lf %lf", comp_coedge->start_point()->coordinates().x(),
          comp_coedge->start_point()->coordinates().y(), comp_coedge->start_point()->coordinates().z());
        PRINT_INFO("\nEnd: %lf %lf %lf", comp_coedge->end_point()->coordinates().x(),
          comp_coedge->end_point()->coordinates().y(), comp_coedge->end_point()->coordinates().z());
       */
      }
      comploop->insert_after( comp_coedge, prev );
      prev = comp_coedge;
    }
  }
  
  return compsurf;
}
      


//-------------------------------------------------------------------------
// Purpose       : Replace a "real" lump with a composite
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 07/19/02
//-------------------------------------------------------------------------
CompositeLump* CompositeEngine::replace_lump( Lump* lump )
{
  DLIList<TopologyBridge*> shells, surfaces;
  int i, j;
  if( dynamic_cast<CompositeLump*>(lump) )
    return 0;
  
  CompositeLump* complump = new CompositeLump( lump );
  //lump->get_children_virt( shells );
  //fix_up_query_results(shells);
  lump->get_children(shells, false, COMPOSITE_LAYER);
  shells.reset();
  for( i = shells.size();i--; )
  {
    CompositeShell* compshell = new CompositeShell();
    complump->add( compshell );
    TopologyBridge* shell_bridge = shells.get_and_step();
    if( shell_bridge->owner() )
    {
      shell_bridge->owner()->swap_bridge(shell_bridge, compshell, false);
      shell_bridge->owner(0);
    }
    //complump->hidden_entities().hide( shell_bridge );
    
    
    surfaces.clean_out();
    //shell_bridge->get_children_virt( surfaces );
    //fix_up_query_results(surfaces);
    shell_bridge->get_children(surfaces, false, COMPOSITE_LAYER);
    
    surfaces.reset();
    for( j = surfaces.size(); j--; )
    {
      Surface* surface = dynamic_cast<Surface*>(surfaces.get_and_step());
      CompositeSurface* compsurf = dynamic_cast<CompositeSurface*>(surface);
      if( !compsurf )
      {
        compsurf = replace_surface( surface );
        assert( compsurf!= NULL );
      }

      compshell->add( compsurf, CUBIT_FORWARD );
    }
  }
  
  return complump;
}
      


//-------------------------------------------------------------------------
// Purpose       : Replace a "real" bodysm with a composite
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 07/19/02
//-------------------------------------------------------------------------
CompositeBody* CompositeEngine::replace_body( BodySM* body )
{
  DLIList<TopologyBridge*> lumps;
  int i;
  if( dynamic_cast<CompositeBody*>(body) )
    return 0;
  
  CompositeBody* compbody = new CompositeBody( );
  compbody->add(body);
  body->get_children( lumps, false, COMPOSITE_LAYER );
  lumps.reset();
  for( i = lumps.size();i--; )
  {
    Lump* lump = dynamic_cast<Lump*>(lumps.get_and_step());
    CompositeLump* complump = dynamic_cast<CompositeLump*>(lump);
    if( !complump )
      complump = replace_lump( lump );
    compbody->add( complump );
  }
  
  return compbody;
}

Point* CompositeEngine::remove_composite( CompositePoint* composite )
{
  assert( composite->next_curve() == 0 );
  assert( !dynamic_cast<HiddenEntitySet*>(composite->owner()) );
  Point* result = composite->get_point();
  delete composite;
  return result;
}



//-------------------------------------------------------------------------
// Purpose       : Reomve a 1-curve composite
//
// Special Notes : Inverse of replace_curve(..)
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 03/13/02
//-------------------------------------------------------------------------
Curve* CompositeEngine::remove_composite( CompositeCurve* composite )
{
  assert( composite->num_curves() == 1 && 
          !composite->has_parent_composite_surface() &&
          !dynamic_cast<HiddenEntitySet*>(composite->owner()) &&
          !composite->is_stitched() );

  CompositeCoEdge* coedge = 0;
  while( (coedge = composite->first_coedge()) )
  {
    assert( !coedge->get_loop() && coedge->num_coedges() == 1 );
    composite->remove( coedge );
    CoEdgeSM* real_coedge = coedge->get_coedge(0);
    coedge->remove_coedge( 0 );
    if( coedge->owner() )
      coedge->owner()->swap_bridge( coedge, real_coedge, false );
    delete coedge;
  }
  
  CompositePoint* sp = composite->start_point();
  CompositePoint* ep = composite->end_point();
  Curve* curve = composite->get_curve( 0 );
  bool reversed = composite->get_sense(0) == CUBIT_REVERSED;
  composite->remove_curve(0);
  if( composite->owner() )
    composite->owner()->swap_bridge( composite, curve, reversed );
 
  composite->start_point(0);
  composite->end_point(0);
  delete composite;
  
  if( ! sp->next_curve() )
    remove_composite(sp);
  if( ep != sp && !ep->next_curve() )
    remove_composite(ep);
  
  // we must notify the graphics of the modify from "real" to virtual -- KGM
  // I realize that this is not where the other notifies are completed but there
  // is no knowledge of the change later on. 
  CubitObservable* observer = dynamic_cast<CubitObservable*>(curve->topology_entity());
  if (observer)
  {
    observer->notify_all_observers(GEOMETRY_MODIFIED);
  }

  return curve;
}


//-------------------------------------------------------------------------
// Purpose       : Remove a 1-surface composite
//
// Special Notes : inverse of replace_surface(..)
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 03/13/02
//-------------------------------------------------------------------------
Surface* CompositeEngine::remove_composite( CompositeSurface* composite )
{
  assert( ! composite->has_hidden_entities() );
  assert( composite->next_co_surface(0) == 0 );
  CompositeLoop* loop;
  CompositeCoEdge* coedge;
  CompositeCurve* curve;
  
  while( (loop = composite->first_loop()) )
  {
    composite->remove( loop );
    while( (coedge = loop->first_coedge()) )
    {
      loop->remove(coedge);
      curve = coedge->get_curve();
      if( curve->num_curves() == 1 &&
          !curve->has_parent_composite_surface() &&
          !curve->is_stitched()) 
        remove_composite(curve);
    }
    delete loop;
  }
  
  Surface* surface = composite->get_surface( 0 );
  bool reversed = composite->get_sense(0) == CUBIT_REVERSED;
  composite->remove_surface(0);
  if( composite->owner() )
    composite->owner()->swap_bridge( composite, surface, reversed );
  delete composite;
  
  return surface;
}

//-------------------------------------------------------------------------
// Purpose       : Remove a 1-lump composite
//
// Special Notes : inverse of replace_lump(..)
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 07/19/02
//-------------------------------------------------------------------------
Lump* CompositeEngine::remove_composite( CompositeLump* composite )
{
  assert( composite->num_lumps() == 1 );
  assert( composite->get_body() == 0 );
  
  for( CompositeShell* shell = composite->first_shell();
       shell != 0;
       shell = composite->next_shell( shell ) )
  {
    composite->remove( shell );
    while( shell->first_co_surf() )
    {
      CompositeCoSurf* cos = shell->first_co_surf();
      CompositeSurface* surface = cos->get_surface();
      shell->remove( cos );
      surface->remove( cos );
      delete cos;
      
      if( surface->next_co_surface() == 0 &&
          !surface->has_hidden_entities() )
        remove_composite( surface );
    }
    delete shell;
  }
  
  Lump* result = composite->get_lump( 0 );
  composite->remove_bridge(result);
  if( composite->owner() )
    composite->owner()->swap_bridge( composite, result, false );
  delete composite;
  
  return result;
}


//-------------------------------------------------------------------------
// Purpose       : Remove a 1-body composite
//
// Special Notes : inverse of replace_body(..)
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 07/19/02
//-------------------------------------------------------------------------
BodySM* CompositeEngine::remove_composite( CompositeBody* composite )
{
  assert( composite->num_bodies() == 1 );
  
  while( CompositeLump* lump = composite->next_lump() )
  {
    composite->remove( lump );
    remove_composite( lump );
  }
  
  BodySM* result = composite->get_body( 0 );
  composite->remove_bridge(result);
  if( composite->owner() )
    composite->owner()->swap_bridge( composite, result, false );
  delete composite;
  
  return result;
}

  
//-------------------------------------------------------------------------
// Purpose       : Combine two curves into a composite
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 03/13/02
//-------------------------------------------------------------------------
CompositeCurve* CompositeEngine::combine( CompositeCurve* keep, 
                                          CompositeCurve* dead,
                                          CompositePoint* keep_point,
                                          bool remove_partitions )
{
  if( keep->start_point() == keep->end_point() ||
      dead->start_point() == dead->end_point() )
    return 0;
  
    // find the point to remove by compositing.
  CompositePoint* common = keep->common_point( dead );
  if (!common)
    return 0;
    
  if (keep_point && common == keep_point)
  {
    common = keep->other_point(common);
    if (dead->other_point(common) != keep_point)
      return 0;
  }
  
  bool prepend = (common == keep->start_point());
  bool reverse = ((common == dead->end_point()) != prepend);
  
    // Order coedges such that each coedge from the 
    // dead curve is grouped with the corresponding
    // coedge from the curve to be kept.
  DLIList<CompositeCoEdge*> dead_coedges, sorted_coedges;
  CompositeCoEdge* coedge;
  for( coedge = dead->first_coedge();
       coedge != 0;
       coedge = dead->next_coedge( coedge ) )
    dead_coedges.append( coedge );
  
  int keep_count = 0;
  CompositeCoEdge *keep_coedge = NULL;
  for( keep_coedge = keep->first_coedge();
       keep_coedge != 0;
       keep_coedge = keep->next_coedge( keep_coedge ) )
  {
    keep_count++;
    LoopSM* keep_loop = keep_coedge->get_parent_loop();
    CubitSense keep_sense = keep_coedge->sense();
    
    for( int j = dead_coedges.size(); j--;  )
    {
      CompositeCoEdge* dead_coedge = dead_coedges.step_and_get();
      if( dead_coedge->get_parent_loop() == keep_loop &&
         (reverse == (keep_sense != dead_coedge->sense()) ) )
      {
        dead_coedges.extract();
        sorted_coedges.append( dead_coedge );
        break;
      }
    }
  }
  
    // If not all coedges were paired up, can't proceed.
  if( sorted_coedges.size() != keep_count )
    return 0;
  
    // If dead is reversed wrt keep, reverse it such that
    // both curves have the same relative sense.
  if( reverse )
  {
    dead->reverse();
    for( coedge = dead->first_coedge();
         coedge != 0;
         coedge = dead->next_coedge( coedge) )
      coedge->reverse();
  }
  
    // Combine the CoEdges
  sorted_coedges.reset();
  for ( keep_coedge = keep->first_coedge();
        keep_coedge != 0;
        keep_coedge = keep->next_coedge( keep_coedge ) )
  {
    CompositeCoEdge* dead_coedge = sorted_coedges.get_and_step();
    keep_coedge->combine( dead_coedge, prepend );
    
    if ( dead_coedge->owner() )
      dead_coedge->owner()->remove_bridge( dead_coedge );
    delete dead_coedge;
  }
  
  
    // hide point
  keep->hidden_entities().hide( common );
  
    // combine curves
  keep->combine( dead, prepend );
  if (prepend)
    keep->start_point( dead->other_point( common ) );
  else
    keep->end_point( dead->other_point( common ) );
  
  if (dead->owner())
    dead->owner()->remove_bridge(dead);
  dead->start_point(0);
  dead->end_point(0);
  delete dead;
  
  if( remove_partitions )
    remove_partition_point( common );
  
  return keep;
}


//-------------------------------------------------------------------------
// Purpose       : Restore hidden point 
//
// Special Notes : May create point-curve if point is hidden by a surface.
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 02/27/04
//-------------------------------------------------------------------------
CubitStatus CompositeEngine::restore_point( Point* point )
{
  HiddenEntitySet* set;
  
  CompositePoint* comp = dynamic_cast<CompositePoint*>(point);
  if (!comp)
    comp = dynamic_cast<CompositePoint*>(point->owner());
  if (!comp)
    return CUBIT_FAILURE;
  
  set = dynamic_cast<HiddenEntitySet*>(comp->owner());
  if (!set)
    return CUBIT_FAILURE;
  
  if (dynamic_cast<CompositeCurve*>(set->owner()))
  {
    point = comp->get_point();
    if (!restore_point_in_curve(comp))
      return CUBIT_FAILURE;
    
      // check if we still have a composite point
      // if this was the only point splitting the curve,
      // then the composite point will have been destroyed.
    comp = dynamic_cast<CompositePoint*>(point->owner());
    if (!comp)
      return CUBIT_SUCCESS;
    
      // If the point is no longer hidden, we're done.
    set = dynamic_cast<HiddenEntitySet*>(comp->owner());
    if (!set)
      return CUBIT_SUCCESS;
  }
  
    // Need to create point-curve?
  if (dynamic_cast<CompositeSurface*>(set->owner()))
  {
    if (!restore_point_in_surface(comp))
      return CUBIT_FAILURE;
    
      // If the point is no longer hidden, we're done.
    set = dynamic_cast<HiddenEntitySet*>(comp->owner());
    if (!set)
      return CUBIT_SUCCESS;
  }
  
    // Something went wrong.
  return CUBIT_FAILURE;
}
    


//-------------------------------------------------------------------------
// Purpose       : Restore a point removed when a curve was composited
//                 (split a composite point)
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 03/13/02
//-------------------------------------------------------------------------
CubitStatus CompositeEngine::restore_point_in_curve( Point* point )
{
    // find CompositePoint
  CompositePoint* comppoint = dynamic_cast<CompositePoint*>(point);
  if( !comppoint )
    comppoint = dynamic_cast<CompositePoint*>(point->owner());
  if( !comppoint )
    return CUBIT_FAILURE;

  // find CompositeCurve.
  HiddenEntitySet* hs = dynamic_cast<HiddenEntitySet*>(comppoint->owner());
  if( !hs )
    return CUBIT_FAILURE;
  CompositeCurve* compcurve = dynamic_cast<CompositeCurve*>(hs->owner());
  if( !compcurve )
    return CUBIT_FAILURE;
  
    // find which curves in the composite contain the point
  DLIList<TopologyBridge*> points;
  int index = -1;
  for( int i = 0; i < compcurve->num_curves() && index < 0; i++ )
  {
    Curve* curve = compcurve->get_curve(i);
    points.clean_out();
    curve->get_children( points, true, COMPOSITE_LAYER );
    for( int j = points.size(); j--; )
    {
      Point* pt = dynamic_cast<Point*>(points.get_and_step());
      assert( pt!= NULL );
      if( pt == comppoint )
      {
        index = i;
        break;
      }
    }
  }
  
  assert( index >= 0 );
  Curve *curve1, *curve2;
  return split( compcurve, index, curve1, curve2 );
}


  
  
  

//-------------------------------------------------------------------------
// Purpose       : Split a composite at the index-th point (after the
//                 index-th underlying curve)
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 03/13/02
//-------------------------------------------------------------------------
CubitStatus CompositeEngine::split( CompositeCurve* curve, int index,
                                    Curve*& result1, Curve*& result2 )
{
  result1 = result2 = 0;
  
    // Split the composite geometry
  CompositeCurve* new_curve = curve->split( curve->get_curve(index) );
  if( !new_curve )
    return CUBIT_FAILURE;
  HiddenEntitySet* ownerSet = dynamic_cast<HiddenEntitySet*>(curve->owner());
  if( ownerSet )
    ownerSet->hide(new_curve);
  
    // Split owning CoEdges
  for( CompositeCoEdge* old_coe = curve->first_coedge();
       old_coe != 0;
       old_coe = curve->next_coedge( old_coe ) )
  {
    CompositeCoEdge* new_coe = old_coe->split( index );
    assert( new_coe != NULL );
    new_curve->add( new_coe );
    if( ownerSet )
      ownerSet->hide(new_coe);
    
    if( old_coe->get_loop() )
        old_coe->get_loop()->insert_after( new_coe, old_coe );
  }
  
    // update end point of original curve
  DLIList<TopologyBridge*> children;
  int last = curve->num_curves() - 1;
  Curve* last_curve = curve->get_curve(last);
  children.clean_out();
  last_curve->get_children( children, true, COMPOSITE_LAYER );
  assert( children.size() == 2 );
  children.reset();
  if( curve->get_sense(last) == CUBIT_FORWARD )
    children.step();
  CompositePoint* endpt = dynamic_cast<CompositePoint*>(children.get());
  assert( !!endpt );
  CompositePoint* oldendpt = curve->end_point();
  curve->end_point( endpt );
  
    // attach start and end point to new curve
  children.clean_out();
  Curve* first_curve = new_curve->get_curve(0);
  first_curve->get_children( children, true, COMPOSITE_LAYER );
  assert( children.size() == 2 );
  children.reset();
  if( new_curve->get_sense(0) == CUBIT_REVERSED )
    children.step();
  CompositePoint* startpt = dynamic_cast<CompositePoint*>(children.get());
  assert( startpt!= NULL );
  new_curve->start_point( startpt );
  new_curve->end_point( oldendpt );

    // unhide restored (split) point
  HiddenEntitySet& old_hidden = curve->hidden_entities();
  old_hidden.restore( curve->end_point() );
  old_hidden.restore( new_curve->start_point() );
  if( ownerSet )
  {
    ownerSet->hide(curve->end_point());
    if(new_curve->start_point() != curve->end_point() )
      ownerSet->hide(new_curve->start_point());
  }
  
    // move other hidden points from old curve to new curve
    // as needed
  for( int j = 0; j < new_curve->num_curves(); j++ )
  {
    Curve* r_curve = new_curve->get_curve(j);
    children.clean_out();
    r_curve->get_children( children, true, COMPOSITE_LAYER );
    Point* sp = dynamic_cast<Point*>(children.get_and_step() );
    Point* ep = dynamic_cast<Point*>(children.get_and_step() );
    assert( sp && ep && sp != ep );
    if( old_hidden.restore( sp ) )
      new_curve->hidden_entities().hide( sp );
    if( old_hidden.restore( ep ) )
      new_curve->hidden_entities().hide( ep );
  }

    // Remove composite geometry if a 'composite' of one curve
  result1 = curve;
  result2 = new_curve;
  if( curve->num_curves() == 1 && !ownerSet &&
      !curve->has_parent_composite_surface() )
    result1 = remove_composite( curve );
  if( new_curve->num_curves() == 1 && !ownerSet && 
      !new_curve->has_parent_composite_surface() )
    result2 = remove_composite( new_curve );
    
  return CUBIT_SUCCESS;
}


//-------------------------------------------------------------------------
// Purpose       : Create a composite surface by removing a curve
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 03/13/02
//-------------------------------------------------------------------------
CompositeSurface* CompositeEngine::remove_curve( Curve* dead_curve,
                                                 bool remove_partitions,
                                                 Surface* survivor )
{
  DLIList<TopologyBridge*> temp, coedges, loops, surfaces, curves,
                           surf1_shells, surf2_shells;
  
  if( dynamic_cast<CompositeCurve*>(dead_curve->owner()) )
    dead_curve = dynamic_cast<Curve*>(dead_curve->owner());
  
    // If this is a null-geometry composite curve (a composite
    // point-curve without a corresponding real point-curve),
    // just destroy it and hide the defining point.
  CompositeCurve* compcurve = dynamic_cast<CompositeCurve*>(dead_curve);
  if (compcurve && compcurve->num_curves() == 0)
  {
    CompositeSurface* surf = compcurve->first_coedge()->get_loop()->get_surface();
    CompositePoint* geom_pt = destroy_point_curve(compcurve);
    surf->hidden_entities().hide(geom_pt);
    return surf;
  }
  
    // Get two coedges to remove, and put curve(s) in 'curves'
  dead_curve->get_parents_virt( coedges );
  if( coedges.size() != 2 )  
    return 0;
  
  coedges.reset();
  TopologyBridge* coedge1 = coedges.get_and_step();
  TopologyBridge* coedge2 = coedges.get_and_step();
  
    // Get surfaces corresponding to loops
  loops.clean_out();
  coedge1->get_parents_virt( loops );
  assert( loops.size() == 1 );
  surfaces.clean_out();
  loops.get()->get_parents_virt( surfaces );
  assert( surfaces.size() == 1 );
  Surface* surface1 = dynamic_cast<Surface*>(surfaces.get());
  
  loops.clean_out();
  coedge2->get_parents_virt( loops );
  assert( loops.size() == 1 );
  surfaces.clean_out();
  loops.get()->get_parents_virt( surfaces );
  assert( surfaces.size() == 1 );
  Surface* surface2 = dynamic_cast<Surface*>(surfaces.get());
  
  if (surface2 == survivor)
    std::swap(surface1,surface2);
  
    // Make sure surfaces have same parent shells
  surface1->get_parents_virt( surf1_shells );
  surface2->get_parents_virt( surf2_shells );
  if( surf1_shells != surf2_shells )
    return 0;
  
    // get/make composites of surfaces
  bool created_surf1 = false, created_surf2 = false;
  CompositeSurface* compsurf1 = dynamic_cast<CompositeSurface*>(surface1);
  if( ! compsurf1 )
  {
    compsurf1 = replace_surface( surface1 );
    created_surf1 = true;
  }
  
  CompositeSurface* compsurf2 = 0;
  if( surface2 == surface1 )
  {
    compsurf2 = compsurf1;
  }
  else
  {
    compsurf2 = dynamic_cast<CompositeSurface*>(surface2);
    if( !compsurf2 )
    {
      compsurf2 = replace_surface( surface2 );
      created_surf2 = true;
    }
  }
  assert( compsurf1 && compsurf2 );
  
    // get composite(s) of curve(s)
  compcurve = dynamic_cast<CompositeCurve*>(dead_curve);
  if( !compcurve) 
    compcurve = dynamic_cast<CompositeCurve*>(dead_curve->owner());
  assert( !!compcurve );
  
    // Get composite coedges
  CompositeCoEdge *compcoedge1 = dynamic_cast<CompositeCoEdge*>(coedge1);
  if (!compcoedge1)
    compcoedge1 = dynamic_cast<CompositeCoEdge*>(coedge1->owner());
  CompositeCoEdge *compcoedge2 = dynamic_cast<CompositeCoEdge*>(coedge2);
  if (!compcoedge2)
    compcoedge2 = dynamic_cast<CompositeCoEdge*>(coedge2->owner());
  
    // combine the composite surfaces (not loops yet.)
  if( compsurf1 != compsurf2 )
  {
      // If second surface has opposite sense, fix it so
      // that both have the same sense.
    if( compcoedge2->sense() == compcoedge1->sense() )
    {
      bool b_reverse_coedges = true; // automatically handle reversing the coedges for the loop
      compsurf2->reverse_sense();
      for( CompositeLoop* loop = compsurf2->first_loop();
           loop != 0;
           loop = compsurf2->next_loop( loop ) )
        loop->reverse(b_reverse_coedges);
    }
    
      // Move all loops from old surface to new
    while( CompositeLoop* loop = compsurf2->first_loop() )
    {
      compsurf2->remove( loop );
      compsurf1->add( loop );
    }
    
      // Combine the set of underlying, real surfaces
    compsurf1->combine( compsurf2 );
    if( compsurf2->owner() )
      compsurf2->owner()->remove_bridge( compsurf2 );
    delete compsurf2;
    compsurf2 = 0;
  }
  
  CompositeLoop* loop1 = compcoedge1->get_loop();
  CompositeLoop* loop2 = compcoedge2->get_loop();
    // same loop => remove sipe || split loop
  if( loop1 == loop2 ) 
  {
      // split loop
    if( loop1->next_coedge( compcoedge1 ) != compcoedge2 &&
        loop1->prev_coedge( compcoedge1 ) != compcoedge2 )
    {
      loop2 = new CompositeLoop();
      CompositeCoEdge* coedge = loop1->next_coedge( compcoedge1 );
      CompositeCoEdge* prev = 0;
      while( coedge != compcoedge2 )
      {
        loop1->remove( coedge );
        loop2->insert_after( coedge, prev );
        prev = coedge;
        coedge = loop1->next_coedge( compcoedge1 );
      }
      compsurf1->add( loop2 );
    }
      
    loop1->remove( compcoedge1 );
    loop1->remove( compcoedge2 );
    if( loop1->num_coedges() == 0 )
    {
      compsurf1->remove( loop1 );
      delete loop1;
    }
  }
    // stitch loops
  else 
  {
    CompositeCoEdge* coedge;
    
      // insert coedges
    while( loop2->num_coedges() > 1 )  // all but the dead one
    {
      coedge = loop2->next_coedge( compcoedge2 );
      loop2->remove( coedge );
      loop1->insert_before( coedge, compcoedge1 );
    }
    loop1->remove( compcoedge1 );
    loop2->remove( compcoedge2 );
    assert( loop2->num_coedges() == 0 );
    if( loop2->get_surface() )
      loop2->get_surface()->remove( loop2 );
    delete loop2;
    
      // If loops only had one coedge each, then we
      // just removed a hole.
    if( loop1->num_coedges() == 0 )
    {
      if( loop1->get_surface() )
        loop1->get_surface()->remove( loop1 );
      delete loop1;
    }
  }
  
  compsurf1->hidden_entities().hide( compcoedge1 );
  compsurf1->hidden_entities().hide( compcoedge2 );
  
    // clean up dead curve(s) and points
  curves.clean_out();
  compcurve->start_point()->get_parents_virt( curves );
  if( curves.size() == 1 )
    compsurf1->hidden_entities().hide( compcurve->start_point() );
  curves.clean_out();
  compcurve->end_point()->get_parents_virt( curves );
  if( curves.size() == 1 )
    compsurf1->hidden_entities().hide( compcurve->end_point() );
  compsurf1->hidden_entities().hide( compcurve );
  
  if( remove_partitions )
    remove_partition_curves( compcurve );
  
  return compsurf1;
}


static void cme_hide_surface( HiddenEntitySet& set,
                              CompositeSurface* surface )
{
  set.hide( surface );
  CompositeLoop* loop = 0;
  while (NULL != (loop = surface->next_loop( loop )))
  {
    set.hide( loop );
    CompositeCoEdge* coedge = loop->first_coedge();
    do {
      set.hide( coedge );
      
      bool hide_curve = true;
      CompositeCurve* curve = coedge->get_curve();
      CompositeCoEdge* curve_coedge = 0;
      while ((curve_coedge = curve->next_coedge( curve_coedge )))
        if (curve_coedge->owner() != &set)
          { hide_curve = false; break; }
      
      if (hide_curve)
      {
        set.hide( curve );
        int num_pts = 1 + (curve->start_point() == curve->end_point());
        for (int i = 0; i < num_pts; i++)
        {
          CompositePoint* pnt = i ? curve->end_point() : curve->start_point();
          bool hide_pnt = true;
          CompositeCurve* pnt_curve = 0;
          while ((pnt_curve = pnt->next_curve( pnt_curve )))
            if (pnt_curve->owner() != &set)
              { hide_pnt = false; break; }
          
          if (hide_pnt)
            set.hide( pnt );
        }
      }
    } while((coedge = loop->next_coedge(coedge)) != loop->first_coedge());
  }
}

static void cme_unhide_surface( CompositeSurface* surf )
{
  HiddenEntitySet* set = dynamic_cast<HiddenEntitySet*>(surf->owner());
  assert( !!set );
  set->restore( surf );
  CompositeLoop* loop = 0;
  while (NULL != (loop = surf->next_loop( loop )))
  {
    set->restore( loop );
    CompositeCoEdge* coedge = loop->first_coedge();
    do {
      if (coedge->owner() == set)
      {
        CompositeCurve* curve = coedge->get_curve();
        set->restore( coedge );
        set->restore( curve );
        if (curve->start_point()->owner() == set)
          set->restore( curve->start_point() );
        if (curve->end_point()->owner() == set)
          set->restore( curve->end_point() );
      }
    } while ((coedge = loop->next_coedge(coedge)) != loop->first_coedge());
  }
}
  


//-------------------------------------------------------------------------
// Purpose       : Create composite volume by removing a surface
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 06/10/04
//-------------------------------------------------------------------------
CompositeLump* CompositeEngine::remove_surface( Surface* dead_surf,
                                                Surface* stitch_partner,
                                                bool /*remove_partitions*/  )
{
  bool okay = true;
  Surface* sptr;
  if ((sptr = dynamic_cast<Surface*>(dead_surf->owner())))
    dead_surf = sptr;
  if ((sptr = dynamic_cast<Surface*>(stitch_partner->owner())))
    stitch_partner = sptr;
  
    // Get composite surfaces
  bool replaced_1 = false, replaced_2 = false;
  CompositeSurface *surf1 = 0, *surf2 = 0;
  if (NULL == (surf1 = dynamic_cast<CompositeSurface*>(dead_surf)))
  {
    surf1 = replace_surface( dead_surf );
    replaced_1 = true;
  }
  if (NULL == stitch_partner)
  {
    surf2 = surf1;
  }
  else if (NULL == (surf2 = dynamic_cast<CompositeSurface*>(stitch_partner)))
  {
    surf2 = replace_surface( stitch_partner );
    replaced_2 = true;
  }  
  
    // Check if surfaces are stitched
  if (surf2 != surf1)
  {
    std::set<CompositeLoop*> used_loops;
    CompositeLoop* loop = 0;
    while (NULL != (loop = surf1->next_loop(loop)))
    {
      CompositeCoEdge* coedge1 = loop->first_coedge();
      CompositeCurve* curve = coedge1->get_curve();
      CompositeCoEdge* coedge2 = 0;
      while (NULL != (coedge2 = curve->next_coedge(coedge2)))
        if (coedge2->get_loop() &&
            coedge2->get_loop()->get_surface() == surf2)
          break;
      
      if (!coedge2) 
      {
        break;
        okay = false;
      }
      
      CompositeLoop* loop2 = coedge2->get_loop();
      if (used_loops.insert( loop2 ).second == false)
      {
        okay = false;
        break;
      }
      
      CompositeCoEdge* coedge = coedge1;
      while ((coedge = loop->next_coedge(coedge)) != coedge1)
      {
        curve = coedge->get_curve();
        coedge2 = 0;
        while (NULL != (coedge2 = curve->next_coedge(coedge2)))
          if (coedge2->get_loop() == loop2)
            break;
        
        if (!coedge2)
        {
          okay = false;
          break;
        }
      }
    }
    surf1->stitch( surf2 );
    
    if (!okay)
    {
      if (replaced_1)
        remove_composite( surf1 );
      if (replaced_2)
        remove_composite( surf2 );
      return 0;
    }
  }
  
    // Replace volumes/bodies with composites, combine bodies if necessary
  bool combined_bodies = false;
  bool replaced_body = false;
  DLIList<BodySM*> body_list;
  surf1->bodysms( body_list );
  if (body_list.size() != 1)
    return 0;
  
  BodySM* body1 = body_list.pop();
  BodySM* body2 = 0;
  CompositeBody* body = 0;
  
  if (surf2)
  {
    surf2->bodysms( body_list );
    if (body_list.size() != 1)
      return 0;
    body2 = body_list.pop();
  }
  
  if (body2 && body2 != body1)
  {
    body = combine_bodies( body1, body2 );
    combined_bodies = true;
  }
  else
  {
    if (NULL == (body = dynamic_cast<CompositeBody*>(body1)) &&
        NULL == (body = dynamic_cast<CompositeBody*>(body1->owner())))
    {
      body = replace_body( body1 );
      replaced_body = true;
    }
  }
  
  if (!body)
    return 0;
  
    // Get CoSurfaces to combine must be exactly two of them.
  CompositeCoSurf *cosurf1 = 0, *cosurf2 = 0;
  cosurf1 = surf1->next_co_surface(NULL);
  cosurf2 = surf1->next_co_surface(cosurf1);
  if (!cosurf1)
  {
    okay = false;
  }
  else if (cosurf2)
  {
    if (surf2 || surf1->next_co_surface(cosurf2))
      okay = false;
  }
  else if (surf2)
  {
    cosurf2 = surf2->next_co_surface(NULL);
    if (!cosurf2 || surf2->next_co_surface(cosurf2))
      okay = false;
  }
  if (!okay)
  {
//    if (replaced_body)
//      restore_body( body );
    return 0;
  }
  
  
    // combine the composite lumps (not shells yet.)
  CompositeLump* lump1 = cosurf1->get_shell()->get_lump();
  CompositeLump* lump2 = cosurf2->get_shell()->get_lump();
  if( lump1 != lump2 )
  {
    
      // Move all shells from old lump to new
    while( CompositeShell* shell = lump2->first_shell() )
    {
      lump2->remove( shell );
      lump1->add( shell );
    }
    
      // Combine the set of underlying, real lumps
    lump1->combine( lump2 );
    if( lump2->owner() )
      lump2->owner()->remove_bridge( lump2 );
    body->remove(lump2);
    delete lump2;
    lump2 = 0;
  }
  
    // remove surface(s)
  CompositeShell* shell1 = cosurf1->get_shell();
  CompositeShell* shell2 = cosurf2->get_shell();
  cme_hide_surface( lump1->hidden_entities(), surf1 );
  if (surf2)
    cme_hide_surface( lump1->hidden_entities(), surf2 );
  delete cosurf1;
  delete cosurf2;

  if (shell1 != shell2)
  {
    while (CompositeCoSurf* cosurf = shell2->next_co_surf(0))
    {
      shell2->remove( cosurf );
      shell1->add( cosurf );
    }
    lump1->remove( shell2 );
    delete shell2;
  }
  else // if (shell1 == shell2)
  {
    shell2 = split_shell( shell1 );
    if (shell2)
      lump1->add( shell2 );
  }
  
  return lump1;
}


//-------------------------------------------------------------------------
// Purpose       : Test if a CompositeShell needs to be split, and
//                 split it
//
// Special Notes : Copied from PartitionEngine::split_shell
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 06/11/04
//-------------------------------------------------------------------------
CompositeShell* CompositeEngine::split_shell( CompositeShell* shell_to_split )
{
  std::map<CompositeSurface*, int> marks;

    // Make sure all cosurface surface marks are cleared
#ifdef BOYD17
  DLIList<CompositeCoEdge*> coedge_list;
#endif
  CompositeCoSurf* cosurf = 0;
  while( (cosurf = shell_to_split->next_co_surf( cosurf )) )
    marks[cosurf->get_surface()] = 0;
  
    // Identify non-manifold surfaces, marking them either
    // with a 2 if they can be used to split the volume
    // (if they are part of a connected patch for which the
    // bounadary of that patch intersects the volume boundary
    // at all curves) or a 3 if they are other non-manifold
    // surfaces.  This will get a bit tricky if there are
    // non-manifold surfaces hanging off of the patch of
    // split surfaces.
  
    // First for all non-manifold surfaces, if the surface has
    // a curve that is not shared with any other surface, mark
    // it with a 3.  Otherwise mark it with a 2.
  cosurf = 0;
  DLIList<CompositeSurface*> surf_stack;
  while ( (cosurf = shell_to_split->next_co_surf(cosurf)) )
  {
    CompositeSurface* surf = cosurf->get_surface();
      // If we haven't done this surface yet and it is non-manifold
    if ( !marks[surf] && surf->find_next(cosurf) )
    {
      marks[surf] = 2;
      bool no_free_curve = true;
      CompositeLoop* loop = 0;
      while( no_free_curve && (loop = surf->next_loop(loop)) ) 
      {
        CompositeCoEdge* coedge = loop->first_coedge();
        do 
        {
          CompositeCurve* curve = coedge->get_curve();
            // If the curve has more than one coedge, it 
            // is not a free curve (this also accounts for
            // the case where the curve is a non-manifold 
            // curve on the surface interioir -- e.g. a sipe)
          if ( !curve->next_coedge(coedge) && 
               curve->next_coedge(0) == coedge )
          {
            no_free_curve = false;
            break;
          }
          coedge = loop->next_coedge(coedge);
        } while( coedge != loop->first_coedge() );
      }
      
      if( !no_free_curve )
      {
        marks[surf] = 3;
        surf_stack.append( surf );
      }
    }
  }
  
    // Now for each surface we marked with a three, traverse
    // and mark adjacent surfaces until we come to a curve
    // connected to more that two surfaces.
  while( surf_stack.size() ) 
  {
    CompositeSurface* surf = surf_stack.pop();
    CompositeLoop* loop = 0;
    while ( (loop = surf->next_loop(loop)) )
    {
      CompositeCoEdge* coedge = loop->first_coedge();
      do 
      {
        CompositeCurve* curve = coedge->get_curve();
        int split_count = 0;
        int boundary_count = 0;
        CompositeCoEdge* curve_coe = 0;
        while ( (curve_coe = curve->next_coedge(curve_coe) ) != NULL )
        {
          CompositeSurface* curve_surf = curve_coe->get_loop()->get_surface();
          switch ( marks[curve_surf] ) 
          {
            case 0: boundary_count++; break;
            case 2: split_count++;    break;
          }
        }
        
        if ( split_count == 1 && !boundary_count )
        {
          curve_coe = 0;
          while ( (curve_coe = curve->next_coedge(curve_coe) ) != NULL )
          {
            CompositeSurface* curve_surf = curve_coe->get_loop()->get_surface();
            if ( marks[curve_surf] == 2 )
            {
              marks[curve_surf] = 3;
              surf_stack.append(curve_surf);
            }
          }
        }
        
        coedge = loop->next_coedge( coedge );
      } while( coedge != loop->first_coedge() );
    }
  }
  
    // Now build a new shell by traversing cofaces, marking
    // each with that will go in a new shell with a 1.
  
    // Start with any cosurf that does not have a free
    // non-manifold surface (marked with a 3).  We'll handle
    // free non-manifold surfaces later.
  std::set<CompositeCoSurf*> marked_cosurfs;
  DLIList<CompositeCoSurf*> cosurf_stack;
  cosurf = 0;
  while ( (cosurf = shell_to_split->next_co_surf(cosurf)) )
    if ( marks[cosurf->get_surface()] != 3 )
      break;
  if ( cosurf )
  {
    marked_cosurfs.insert(cosurf);
    cosurf_stack.append( cosurf );
  }
  
    // Traverse over adjacent cosurfaces, marking them with a 1
  while (cosurf_stack.size())
  {
    cosurf = cosurf_stack.pop();
    CompositeSurface* surf = cosurf->get_surface();
    CompositeLoop* loop = 0;
    while ( (loop = surf->next_loop(loop)) )
    {
      CompositeCoEdge* coedge = loop->first_coedge();
      do
      {
        CompositeCurve* curve = coedge->get_curve();
        CompositeCoEdge* curve_coe = 0;
        CompositeCoSurf *boundary_cosurf = 0, *split_cosurf = 0;
        int split_cosurf_count = 0;
        while ( (curve_coe = curve->next_coedge(curve_coe)) )
        {
          if ( curve_coe == coedge )
            continue;
          
          bool same_coe_sense = curve_coe->sense() == coedge->sense();
          CompositeSurface* curve_surf = curve_coe->get_loop()->get_surface();
          CompositeCoSurf* curve_cosurf = 0;
          while ( (curve_cosurf = curve_surf->next_co_surface(curve_cosurf)) )
          {
            if ( curve_cosurf->get_shell() != shell_to_split )
              continue;
            
            bool same_cos_sense = curve_cosurf->sense() == cosurf->sense();
            if ( same_cos_sense == same_coe_sense )
              continue;
            
              // Always choose split surface first if we
              // found one
            if ( marks[curve_cosurf->get_surface()] == 2 ) {
              split_cosurf_count++;
              split_cosurf = curve_cosurf;
            }
            
              // Skip other non-manifold surfaces.  We'll
              // handle those later.
            else if( marks[curve_cosurf->get_surface()] != 3 )
              boundary_cosurf = curve_cosurf;
          }
        }
        
        CompositeCoSurf* next_cosurf = split_cosurf ? split_cosurf : boundary_cosurf;
        if ( marked_cosurfs.find(next_cosurf) == marked_cosurfs.end()
             && split_cosurf_count < 2 )
        {
          marked_cosurfs.insert(next_cosurf);
          cosurf_stack.append(next_cosurf);
        }
      
        coedge = loop->next_coedge(coedge);
      } while( coedge != loop->first_coedge() );
    } // end while (loop)
  } // end while (cosurf_stack.size())
    
  
    // build lists of cosurfaces, one for each shell and
    // one of other non-manifold surfaces
  DLIList<CompositeCoSurf*> marked_list, unmarked_list, other_list;
  while( (cosurf = shell_to_split->next_co_surf(0)) )
  {
    shell_to_split->remove(cosurf);
    if ( marks[cosurf->get_surface()] == 3 )
      other_list.append( cosurf );
    else if( marked_cosurfs.find(cosurf) != marked_cosurfs.end() )
      marked_list.append( cosurf );
    else
      unmarked_list.append( cosurf );
  }
  
    // If one of marked_list or unmarked_list is empty,
    // we can't split the shell yet.  Put cofaces back in
    // shell and exit.
  if ( !marked_list.size() || !unmarked_list.size() )
  {
    marked_list += unmarked_list;
    marked_list += other_list;
    marked_list.reverse();
    while ( marked_list.size() )
    {
      cosurf = marked_list.pop();
      shell_to_split->add( cosurf );
    }
    return 0;
  }
  
    // Put unmarked list back in old shell
  unmarked_list.reverse();
  while ( unmarked_list.size() )
  {
    cosurf = unmarked_list.pop();
    shell_to_split->add(cosurf);
  }
  
    // Put marked list in new shell
  CompositeShell* new_shell = new CompositeShell;
  marked_list.reverse();
  while ( marked_list.size() )
  {
    cosurf = marked_list.pop();
    new_shell->add(cosurf);
  }
  
    // Now sort out other non-manifold surfaces
  
    // Clear marks and get list of surface from cosurfaces
  surf_stack.clean_out();
  while( other_list.size() )
  {
    cosurf = other_list.pop();
    CompositeSurface* surf = cosurf->get_surface();
    if ( marks[surf] )
      surf_stack.append(surf);
  }
  
  insert_nonmanifold_surfaces( surf_stack, shell_to_split, new_shell );
  return new_shell;
}
 
//-------------------------------------------------------------------------
// Purpose       : After a shell is split, determine which of the two
//                 resulting shells each non-manifold surface belongs in.
//
// Special Notes : Copied from PartitionEngine::insert_nonmanifold_surfaces
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 06/11/04
//-------------------------------------------------------------------------
void CompositeEngine::insert_nonmanifold_surfaces( 
                                   DLIList<CompositeSurface*>& surf_stack,
                                   CompositeShell* shell1,
                                   CompositeShell* shell2 )
{
  DLIList<CompositeSurface*> known_list(surf_stack.size()), 
                           unknown_list(surf_stack.size());
  
  CompositeCoSurf* cosurf;
  CompositeSurface* surf;
  CompositeLoop* loop;
  CompositeCoEdge *coedge, *curve_coe;
  CompositeCurve* curve;
  
    // Loop until we've placed all the surfaces in one
    // shell or the other.
  while ( surf_stack.size() )
  {
    bool did_some = false;
    
      // Put any surfaces for which we immediately
      // know the shell into the appropriate shell.
      // Put others in known_list or unknown_list
      // depending on if we can determine which shell
      // they go in using a geometric comparison.
    known_list.clean_out();
    unknown_list.clean_out();

      // Take all surfaces out of stack in this loop.
      // We might put some back in after the loop (thus
      // the outer loop.)
    while ( surf_stack.size() )
    {
      surf = surf_stack.pop();
      
      CompositeShell* known_shell = 0;
      bool found_shell = false;
      loop = 0;
      while ( (loop = surf->next_loop(loop)) )
      {
        coedge = loop->first_coedge();
        do
        {
          curve = coedge->get_curve();
          curve_coe = 0;
          while ( (curve_coe = curve->next_coedge(curve_coe)) )
          {
            CompositeSurface* surf = curve_coe->get_loop()->get_surface();
            cosurf = 0;
            while ( (cosurf = surf->next_co_surface( cosurf )) )
            {
              if( cosurf->get_shell() == shell1 ||
                  cosurf->get_shell() == shell2 )
              {
                found_shell = true;
                if ( known_shell && known_shell != cosurf->get_shell() )
                  known_shell = 0;
                else
                  known_shell = cosurf->get_shell();
              }
            }
          }
        
          coedge = loop->next_coedge(coedge);
        } while( coedge != loop->first_coedge() );
      } // end while(loop)
        
        // This surface does not intersect the shell at
        // any curve.  We can't do this one yet.
      if ( !found_shell )
      {
        unknown_list.append( surf );
        continue;
      }
      
        // This surface intersected both shells at some
        // curves, but did not have a curve that intersected
        // only one shell.  We can do this one geometricly
        // if we have to.
      if ( !known_shell )
      {
        known_list.append( surf );
        continue;
      }
      
        // If we got this far, then the surface had at least
        // one curve that intersected only one of the shells.
        // We know it goes in that shell.
      did_some = true;
      CompositeCoSurf* cosurf1 = surf->find_first((CompositeShell*)0);
      CompositeCoSurf* cosurf2 = surf->find_next(cosurf1);
      known_shell->add(cosurf1);
      known_shell->add(cosurf2);
    
    } // while(surf_stack)  -- the inside one
    
      // Unknown_list always goes back in surf_stack to
      // try again.
    surf_stack += unknown_list;
    
      // If we did some surfaces, then put the rest back
      // in surf_stack and try again.  If they intersect
      // one of the surfaces we did place in this iteration,
      // we can avoid needing to do geometric checks.
    if ( did_some )
    {
      surf_stack += known_list;
      continue;
    }
    
      // If known_list is empty, somethings wrong (we're
      // going to loop forever.)  Abort the loop and try
      // to recover as best we can.
    if( !known_list.size() )
      break;
    
      // choose a single surface in do a geometric comparison
      // for, and put the rest back in surf_stack
    surf = known_list.pop();
    surf_stack += known_list;
    
    bool in_shell = false;
    if ( ! inside_shell( shell2, surf, in_shell ) )
    {
        // if inside_shell failed, abort.
      surf_stack.append(surf);
      break;
    }
    
    CompositeShell* shell = in_shell ? shell2 : shell1;
    shell->add(surf->find_first((CompositeShell*)0));
    shell->add(surf->find_first((CompositeShell*)0));
  }
  
    // something went wrong
  if( surf_stack.size() )
  {
    PRINT_ERROR("Internal error splitting volume at %s:%d\n"
                "Topology may be invalid.  Please report this.\n",
                __FILE__, __LINE__);
    while( surf_stack.size() ) 
    {
      CompositeSurface* surf = surf_stack.pop();
      cosurf = 0;
      while( (cosurf = surf->next_co_surface(cosurf)) )
        if( !cosurf->get_shell() )
          shell1->add(cosurf);
    }
  }
}


CubitStatus CompositeEngine::inside_shell( CompositeShell* const shell,
                                           CompositeSurface* const surf,
                                           bool& result )
{
    // Find the curve and coedge at which the nonmanifold surface
    // intersects the shells
  CompositeLoop* loop = 0;
  CompositeCoEdge *nonman_coedge = 0;
  while ( !nonman_coedge && (loop = surf->next_loop(loop)) )
  {
    CompositeCoEdge* loop_coedge = loop->first_coedge();
    do 
    {
        // Check if this curve is the curve of intersection
        // Iterate through curve coedges.
      CompositeCurve* curve = loop_coedge->get_curve();
      CompositeCoEdge* curve_coedge = 0;
      while ( (curve_coedge = curve->next_coedge(curve_coedge)) )
      {
        
        CompositeSurface* coedge_surf = curve_coedge->get_loop()->get_surface();
        if( coedge_surf->find_first(shell) )
        {
          nonman_coedge = curve_coedge;
          break;
        }
      }
    
      loop_coedge = loop->next_coedge(loop_coedge);
    } while( !nonman_coedge && loop_coedge != loop->first_coedge