GeometryModifyTool.cpp

Go to the documentation of this file.

//-------------------------------------------------------------------------
// Filename      : GeometryModifyTool.cpp
//
// Purpose       : The tool used to create and modify geometry
//
// Special Notes :
//
// Creator       : Tim Tautges
//
// Creation Date : 2/01
//
//-------------------------------------------------------------------------

#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <math.h>
#include <sstream>
//#include <iostream>

#include "GeometryModifyTool.hpp"
#include "CubitDefines.h"
#include "GeometryDefines.h"
#include "GeometryEntity.hpp"
#include "GeometryQueryTool.hpp"
#include "MergeTool.hpp"
#include "SurfaceOverlapTool.hpp"
#include "GeometryQueryEngine.hpp"
#include "OldUnmergeCode.hpp"
#include "GeometryModifyEngine.hpp"
#include "AnalyticGeometryTool.hpp"
#include "DAG.hpp"
#include "TopologyBridge.hpp"
#include "ModelQueryEngine.hpp"
#include "CADefines.hpp"
#include "GeomMeasureTool.hpp"
#include "LocalToleranceTool.hpp"

#include "RefEntity.hpp"
#include "RefEntityFactory.hpp"
#include "RefEntityName.hpp"
#include "BasicTopologyEntity.hpp"
#include "RefVertex.hpp"
#include "RefEdge.hpp"
#include "RefFace.hpp"
#include "RefVolume.hpp"

#include "CoVertex.hpp"
#include "CoEdge.hpp"
#include "CoFace.hpp"
#include "CoVolume.hpp"

#include "Chain.hpp"
#include "Loop.hpp"
#include "Shell.hpp"
#include "Body.hpp"

#include "Lump.hpp"
#include "Surface.hpp"
#include "Curve.hpp"
#include "Point.hpp"
#include "BodySM.hpp"
#include "ShellSM.hpp"
#include "LoopSM.hpp"
#include "CoEdgeSM.hpp"

#include "CubitAttrib.hpp"
#include "CubitVector.hpp"
#include "CubitPlane.hpp"
#include "CubitTransformMatrix.hpp"
#include "GfxPreview.hpp"
#include "AppUtil.hpp"

#include "DLIList.hpp"

#include "CubitMessage.hpp"
#include "SettingHandler.hpp"

#include "CastTo.hpp"
#include "CpuTimer.hpp"

#include "BridgeManager.hpp"
#include "SplitSurfaceTool.hpp"
#include "OffsetSplitTool.hpp"
#include "AutoMidsurfaceTool.hpp"
#include "TDSurfaceOverlap.hpp"
#include "GfxDebug.hpp"

#include "CubitUndo.hpp"

/* Work around stupid #define hz equal to HZ on IBM */
#ifdef hz
#  undef hz
#endif
#ifdef PROE
#include "CompositeTool.hpp"
#endif

GeometryModifyTool* GeometryModifyTool::instance_ = 0;
CubitBoolean GeometryModifyTool::allEdgesImprint = CUBIT_TRUE;
CubitBoolean GeometryModifyTool::groupImprint = CUBIT_TRUE;
CubitBoolean GeometryModifyTool::newIds = CUBIT_FALSE;
CubitBoolean GeometryModifyTool::sepAfterWebcut = CUBIT_TRUE;
CubitBoolean GeometryModifyTool::booleanRegularize = CUBIT_TRUE;
CubitBoolean GeometryModifyTool::uniteMixedModels = CUBIT_TRUE;
CubitBoolean GeometryModifyTool::oldNames = CUBIT_FALSE;
CubitBoolean GeometryModifyTool::meshAutodelete = CUBIT_TRUE;
CubitBoolean GeometryModifyTool::meshAutodeleteRemesh = CUBIT_FALSE;
RefEntity* GeometryModifyTool::copyingEntity = NULL;

CubitStatus prepare_surface_sweep(
                              DLIList<BodySM*> &blank_bodies,
                              DLIList<Surface*> &surfaces,
                              const CubitVector& sweep_vector,
                              bool sweep_perp,
                              bool through_all,
                              bool outward,
                              bool up_to_next,
                              Surface *stop_surf,
                              Curve *curve_to_sweep_along,
                              BodySM* &cutting_tool_ptr ,
                              const CubitVector* point = NULL,
                              double *angle = NULL);
  // prepare for webcut with swept_surfaces. if point and angle is known,
  // do surface sweep rotated; or if curve_to_sweep_along is known, do
  // sweep along curve; then if sweep_perp is true, do perpendicular sweep
  // of the surfaces; lastly do sweep along vector.

CubitStatus webcut_w_cylinder( DLIList<BodySM*> &webcut_body_list,
                               double radius,
                               const CubitVector &axis,
                               const CubitVector &center,
                               DLIList<BodySM*>& neighbor_imprint_list,
                               DLIList<BodySM*>& results_list,
                               ImprintType imprint_type = NO_IMPRINT );
  //- webcuts a body using a cylinder given the input parameters.

//-------------------------------------------------------------------------
// Purpose       : Controls access and creation of the sole instance of this
//                 class.
//
// Special Notes :
//
// Creator       : Xuechen Liu
//
// Creation Date : 07/11/96
//-------------------------------------------------------------------------

GeometryModifyTool* GeometryModifyTool::instance(GeometryModifyEngine *GMEPtr)
{
     // Check to see if we have created an instance of the class
     // If not, proceed to create one.

   if (instance_ == 0)
   {
        // When creating the instance, we should always have a valid
        // SMEPtr. If not, complain.

     instance_ = new GeometryModifyTool (GMEPtr) ;

        // check to make sure there's a ref entity factory extant
     //RefEntityFactory *factory =
     RefEntityFactory::instance();
   }

     // If there is an existing instance of the class, check if there
     // was a request to set default solid modeling engine. If so, be nice
     // to the calling routine :) :) and kindly set the default solid
     // modeling engine.

   else if ( GMEPtr != NULL && instance_->gmeList.move_to(GMEPtr)) {
     delete instance_->gmeList.remove();
     instance_->gmeList.insert(GMEPtr);
   }

     // Return the a pointer to the instance of the class.

   return instance_ ;
}

//-------------------------------------------------------------------------
// Purpose       : Destructor.
//
// Special Notes :
//
// Creator       : Xuechen Liu
//
// Creation Date : 07/11/96
//-------------------------------------------------------------------------
GeometryModifyTool::~GeometryModifyTool ()
{
   instance_ = NULL;
     //Kill the geometry modify engine(s)
   int i;
   for (i = gmeList.size(); i > 0; i--)
     delete gmeList.get_and_step();

   gmeList.clean_out();
}

//-------------------------------------------------------------------------
// Purpose       : Deletes instance variable
//
// Special Notes :
//
// Creator       : Corey Ernst
//
// Creation Date : 12/31/07
//-------------------------------------------------------------------------
void GeometryModifyTool::delete_instance()
{
  if( NULL != instance_ )
  {
    delete instance_;
    instance_ = NULL;
  }
}

//-------------------------------------------------------------------------
// Purpose       : Creates a Body corresponding to a sphere with the
//                 given radius
//
// Special Notes :
//
// Creator       : Jihong Ma
//
// Creation Date : 09/18/96
//-------------------------------------------------------------------------
Body* GeometryModifyTool::sphere(double radius,
                                 int x_shift,
                                 int y_shift,
                                 int z_shift,
                                 double inner_radius,
                                 bool delete_side )
{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

     // First make sure the radius is not zero or less
   if ( radius <= 0.0 )
   {
      PRINT_ERROR("In GeometryModifyTool::sphere\n"
                  "       Cannot make a sphere of radius %f\n",
                  radius);
      return NULL ;
   }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  GeometryModifyEngine *gme = gmeList.get();

  BodySM* body_sm = gme->sphere(radius);

  if (x_shift != 0 || y_shift != 0 || z_shift != 0)
  {
    BodySM *brick = gme->brick( 2.0 * radius,
                                2.0 * radius,
                                2.0 * radius);

    CubitVector delta( x_shift * radius,
                       y_shift * radius,
                       z_shift * radius );

    gme->get_gqe()->translate( brick, delta );

    DLIList<BodySM*> new_sms;
    DLIList<BodySM*> from_bodies(1);
    from_bodies.append( body_sm );
    bool keep_old = true;
    CubitStatus bool_status;
    if( delete_side == false )
       bool_status = gme->intersect( brick, from_bodies, new_sms, keep_old );
    else
    {
      DLIList<BodySM*> tool_bodies(1);
      tool_bodies.append( brick );
      bool imprint = false;
      bool_status = gme->subtract( tool_bodies, from_bodies, new_sms, imprint, keep_old );
    }

    //delete the old bodies
    gme->get_gqe()->delete_solid_model_entities( body_sm );
    gme->get_gqe()->delete_solid_model_entities( brick );

    if( bool_status == CUBIT_FAILURE || new_sms.size() == 0 )
    {
      PRINT_ERROR("Problems creating sphere.\n" );
      return NULL ;
    }

    body_sm = new_sms.get();
  }

  Body *new_body = NULL;
  BodySM* inner_body_sm = NULL;
  if( inner_radius )
  {
    inner_body_sm = gme->sphere(inner_radius);
    DLIList<BodySM*> new_sms;
    DLIList<BodySM*> from_bodies(1);
    DLIList<BodySM*> tool_bodies(1);
    from_bodies.append( body_sm );
    tool_bodies.append( inner_body_sm );
    bool imprint = false;
    bool keep_old = true;
    CubitStatus subtract_status =
       gme->subtract( tool_bodies, from_bodies, new_sms, imprint, keep_old );

     //delete the old bodies
    gme->get_gqe()->delete_solid_model_entities( body_sm );
    gme->get_gqe()->delete_solid_model_entities( inner_body_sm );

    if( subtract_status == CUBIT_FAILURE || new_sms.size() == 0 )
    {
      PRINT_ERROR("Problems creating sphere with inner radius.\n" );
      return NULL ;
    }

    body_sm = new_sms.get();
  }

  if (!body_sm)
  {
     PRINT_ERROR("In GeometryModifyTool::sphere\n"
                 "       Problems building a volume from the sphere.\n");
  }
  else
    new_body = GeometryQueryTool::instance()->make_Body(body_sm);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

  return new_body;
}

//-------------------------------------------------------------------------
// Purpose       : Creates a Body corresponding to a brick with given width,
//                 depth, and height.
//
// Special Notes :
//
// Creator       : Jihong Ma
//
// Creation Date : 09/18/96
//-------------------------------------------------------------------------
Body* GeometryModifyTool::brick(double width, double depth, double height)
{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

     // First make sure that none of the input values are zero or less
   if ( width <= GEOMETRY_RESABS || depth <= GEOMETRY_RESABS || height <= GEOMETRY_RESABS )
   {
      PRINT_ERROR("In GeometryModifyTool::brick\n"
                  "    Cannot make a cuboid of size %f x %f x %f\n"
                  "       All dimensions must be > 0.0\n",
                  width, depth, height);
      return NULL;
   }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

   Body *new_body = NULL;
   BodySM* bodyPtr = gmeList.get()->brick(width, depth, height);

   if (bodyPtr == NULL)
   {
      PRINT_ERROR("In GeometryModifyTool::brick\n"
                  "       Problem creating a brick.\n") ;
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(bodyPtr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

   return new_body;
}

#ifdef KCM_MESH_TO_GEOM
//-------------------------------------------------------------------------
// Purpose       : Create breps from mesh entities.
//
// Special Notes :
//
// Creator       : Brett Clark
//
// Creation Date : 12/21/2010
//-------------------------------------------------------------------------
CubitStatus GeometryModifyTool::mesh2brep(std::vector<double> &xvals,
                        std::vector<double> &yvals,
                        std::vector<double> &zvals,
                        std::vector<unsigned int> &tri_connectivity,
                        DLIList<BodySM*> &new_body_sms)
{
  if (0 == gmeList.size())
  {
    PRINT_WARNING("No active geometry engine.\n");
    return CUBIT_FAILURE;
  }

  return gmeList.get()->mesh2brep(xvals, yvals, zvals, tri_connectivity, new_body_sms);
}
#endif

//-------------------------------------------------------------------------
// Purpose       : Creates a Body corresponding to a brick at given location,
//                 orientation, and size.
//
// Special Notes : If one of the dimensions is zero, a planar sheet is created.
//
// Creator       : Steve Storm
//
// Creation Date : 10/09/2000
//-------------------------------------------------------------------------
Body* GeometryModifyTool::brick(const CubitVector &center,
                                const CubitVector axes[3],
                                const CubitVector &extension)
{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

   double width = 2.0*extension.x();
   double height = 2.0*extension.y();
   double depth = 2.0*extension.z();
     // First make sure that entity creation is possible.  Allow at most
     // only one of the dimensions to be zero - in which case a planar
     // sheet is created.
   if ( width < 0.0 || height < 0.0 || depth < 0.0 )
   {
      PRINT_ERROR( "Cannot make a brick of size %f x %f x %f\n"
                   "     Negative dimensions are not allowed.\n",
                   width, height, depth );
      return NULL ;
   }

   int wz = width < GEOMETRY_RESABS;
   int hz = height < GEOMETRY_RESABS;
   int dz = depth < GEOMETRY_RESABS;
   if( wz || hz || dz )
   {
      if( (wz + hz + dz) > 1 )
      {
         PRINT_ERROR( "Cannot make a sheet of size %f x %f x %f\n"
            "     At least two dimensions must be nonzero.\n",
            width, height, depth );
         return NULL ;
      }

      // Make a sheet body instead of a cuboid
      CubitVector sheet_axes[2];
      if( wz )
      {
         sheet_axes[0] = axes[1];
         sheet_axes[1] = axes[2];
         return planar_sheet( center, sheet_axes, height, depth );
      }
      else if( hz )
      {
         sheet_axes[0] = axes[2];
         sheet_axes[1] = axes[0];
         return planar_sheet( center, sheet_axes, depth, width );
      }
      else
      {
         sheet_axes[0] = axes[0];
         sheet_axes[1] = axes[1];
         return planar_sheet( center, sheet_axes, width, height );
      }
   }
   else
   {
      if( CubitUndo::get_undo_enabled() )
        CubitUndo::save_state();

      BodySM* bodyPtr = gmeList.get()->brick(center, axes, extension) ;
      Body *new_body = NULL;
      if (bodyPtr == NULL)
      {
         PRINT_ERROR("In GeometryTool::brick\n"
            "       Problem creating a brick.\n") ;
      }
      else
        new_body = GeometryQueryTool::instance()->make_Body(bodyPtr);

      if( CubitUndo::get_undo_enabled() )
      {
        if( new_body )
          CubitUndo::note_result_body( new_body );
        else
          CubitUndo::remove_last_undo();
      }

      return new_body;
   }
}

//-------------------------------------------------------------------------
// Purpose       : Creates a Body corresponding to a prism with height,
//                 sides, major, minor radii
//
//
// Special Notes :
//
// Creator       : Jihong Ma
//
// Creation Date : 09/18/96
//-------------------------------------------------------------------------
Body* GeometryModifyTool::prism( double height, int sides, double major, double minor)
{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

     // First make sure that the input values make sense
   if ( major < minor ||
        major <= GEOMETRY_RESABS || minor <= GEOMETRY_RESABS ||
        height <= GEOMETRY_RESABS || sides < 3 )
   {
      PRINT_ERROR("In GeometryModifyTool::prism\n"
                  "   Cannot make a prism of major-radius = %f,"
                  " minor-radius = %f, height = %f, and"
                  " number of sides = %d\n"
                  "   All dimensions must be > 0.0, the major-radius\n"
                  " should be greater than or equal to the minor-"
                  "radius,\n and the number of sides should be greater"
                  " than 2.\n", major, minor, height, sides);

      return NULL;
   }

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

     // Create a Body that represents the prism
   BodySM* bodyPtr = gmeList.get()->prism(height,  sides, major, minor) ;
   Body *new_body = NULL;
   if (bodyPtr == NULL)
   {
      PRINT_ERROR("In GeometryModifyTool::prism\n"
                  "       Problems building a volume from the prism.\n") ;
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(bodyPtr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

   return new_body;
}

//-------------------------------------------------------------------------
// Purpose       : Creates a Body corresponding to a pyramid with given
//                 height, major, minor,top, sides
//
// Special Notes :
//
// Creator       : Jihong Ma
//
// Creation Date : 09/18/96
//-------------------------------------------------------------------------
Body* GeometryModifyTool::pyramid  ( double height, int sides, double major,
                             double minor,  double top)
{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

     // First make sure that the input values make sense
   if ( major < minor ||
        major <= GEOMETRY_RESABS || minor <= GEOMETRY_RESABS ||
        height <= GEOMETRY_RESABS || top < 0.0 || sides < 3  )
   {
      PRINT_ERROR("In GeometryModifyTool::pyramid\n"
                  "    Cannot make a pyramid of major-radius = %f,"
                  " minor-radius = %f, height = %f,"
                  " top %f, and number of sides = %d\n"
                  "     All dimensions must be > 0.0, the major-radius"
                  " should be greater than the minor-radius, the "
                  "number of sides should be greater than 2.\n",
                  major, minor, height, top, sides);
      return NULL;
   }

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

     // Create a Body that represents the prism
   BodySM* bodyPtr = gmeList.get()->pyramid ( height, sides, major, minor, top);
   Body *new_body = NULL;
   if (bodyPtr == NULL)
   {
      PRINT_ERROR("In GeometryModifyTool::pyramid\n"
                  "      Problems building a volume from the pyramid.\n");
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(bodyPtr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

   return new_body;
}

//-------------------------------------------------------------------------
// Purpose       : Creates a Body corresponding to a frustum of a cone with
//                 height,
//                 input radius in x-direction at base
//                 input radius in y-direction at base
//                 input radius in x-direction at top
//
// Special Notes :
//
// Creator       : Jihong Ma
//
// Creation Date : 09/18/96
//-------------------------------------------------------------------------
Body* GeometryModifyTool::cylinder ( double hi, double r1, double r2, double r3 )
{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

     // First make sure that the input values make sense
   if ( hi <= GEOMETRY_RESABS || r1 <= GEOMETRY_RESABS ||
        r2 <= GEOMETRY_RESABS || r3 < 0.0 )
   {
      PRINT_ERROR("In GeometryModifyTool::cylinder\n"
                  " Cannot make a frustum of a cone with height = %f,"
                  " lower x-direction radius = %f,"
                  " lower y-direction radius = %f, and "
                  "top radius = %f\n"
                  "       All dimensions must be > 0.0\n",
                  hi, r1, r2, r3);
      return NULL;
   }

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

     // Create a Body that represents the prism
   BodySM* bodyPtr = gmeList.get()->cylinder( hi, r1, r2, r3);
   Body *new_body = NULL;

   if (bodyPtr == NULL)
   {
      PRINT_ERROR("In GeometryModifyTool::cylinder\n"
                  "       Problems building a volume from the conical frustum.\n");
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(bodyPtr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

   return new_body;
}

//-------------------------------------------------------------------------
// Purpose       : Creates a Body corresponding to a torus with major_radius
//                 and minor_radius
//
//
// Special Notes :
//
// Creator       : Jihong Ma
//
// Creation Date : 09/18/96
//-------------------------------------------------------------------------
Body* GeometryModifyTool::torus( double r1, double r2 )
{   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }


     // First make sure that the input values make sense
   if ( r1 <= r2 || r1 <= GEOMETRY_RESABS || r2 <= 0.0)
   {
      PRINT_ERROR("In GeometryModifyTool::torus\n"
                  "  Cannot make a torus of major-radius = %f and"
                  " minor-radius = %f\n",
                  r1, r2);
      return NULL;
   }

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

     // Create a Body that represents the torus
   BodySM* bodyPtr = gmeList.get()->torus(r1, r2) ;
   Body *new_body = NULL;

   if (bodyPtr == NULL)
   {
      PRINT_ERROR("In GeometryModifyTool::torus\n"
                  "       Problems building a volume from the torus.\n") ;
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(bodyPtr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

   return new_body;
}

//-------------------------------------------------------------------------
// Purpose       : Creates a planar sheet with the given corner locations.
//
// Special Notes :
//
// Creator       : Steve Storm
//
// Creation Date : 05/10/05
//-------------------------------------------------------------------------
Body* GeometryModifyTool::planar_sheet( const CubitVector& p1,
                                        const CubitVector& p2,
                                        const CubitVector& p3,
                                        const CubitVector& p4 )
{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

  // Create a Body that represents the sheet
  BodySM* body_ptr = gmeList.get()->planar_sheet(p1, p2, p3, p4) ;
  Body *new_body = NULL;
  if( body_ptr == NULL )
  {
    PRINT_ERROR("In GeometryTool::planar_sheet\n"
      "       Problems building a volume from the sheet.\n") ;
  }
  else
    new_body = GeometryQueryTool::instance()->make_Body(body_ptr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

  return new_body;
}

//-------------------------------------------------------------------------
// Purpose       : Creates a planar sheet with the given input location,
//                 orientation and size.
//
// Special Notes :
//
// Creator       : Steve Storm
//
// Creation Date : 10/09/00
//-------------------------------------------------------------------------
Body* GeometryModifyTool::planar_sheet ( const CubitVector &center,
                                         const CubitVector axes[2],
                                         double width, double height )
{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

   CubitVector p1, p2, p3, p4;

   // Get the corners of the sheet
   center.next_point( axes[0], width/2.0, p1 );
   p1.next_point( axes[1], -height/2.0, p1 );
   p1.next_point( axes[1], height, p2 );
   p2.next_point( axes[0], -width, p3 );
   p3.next_point( axes[1], -height, p4 );

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

   // Create a Body that represents the sheet
   BodySM* body_ptr = gmeList.get()->planar_sheet(p1, p2, p3, p4) ;
   Body *new_body = NULL;

   if( body_ptr == NULL )
   {
      PRINT_ERROR("In GeometryTool::planar_sheet\n"
         "       Problems building a volume from the sheet.\n") ;
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(body_ptr);

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

  return new_body;
}

//-------------------------------------------------------------------------
// Purpose       : Creates a planar sheet with the minimal amount of area
//                 to cut through the given 3D bounding box.  The sheet
//                 can be extended optionally to make it larger than this
//                 minimal size.
//
// Special Notes : extension_types: 0-none, 1-percentage, 2-absolute
//
// Creator       : Steve Storm
//
// Creation Date : 10/19/98
//-------------------------------------------------------------------------
Body* GeometryModifyTool::planar_sheet ( const CubitPlane& plane,
                                         const CubitBox& bounding_box,
                                         int extension_type,
                                         double extension )
{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

   CubitVector p1, p2, p3, p4;

   // Get the corners of the sheet
   if( AnalyticGeometryTool::instance()->
      min_pln_box_int_corners( plane, bounding_box, extension_type,
                               extension, p1, p2, p3, p4 ) == CUBIT_FAILURE )
      return NULL;

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

   // Create a Body that represents the sheet
   BodySM* body_ptr = gmeList.get()->planar_sheet(p1, p2, p3, p4) ;
   Body *new_body = NULL;

   if( body_ptr == NULL )
   {
      PRINT_ERROR("In GeometryModifyTool::planar_sheet\n"
         "       Problems building a volume from the sheet.\n") ;
   }
   else
     new_body = GeometryQueryTool::instance()->make_Body(body_ptr);

   if( CubitUndo::get_undo_enabled() )
   {
     if( new_body )
       CubitUndo::note_result_body( new_body );
     else
       CubitUndo::remove_last_undo();
   }

   return new_body;
}

Body* GeometryModifyTool::create_body( VolumeFacets& volume, std::map<FacetShapes*, RefEntity*>& entity_map,
                                       const FacetPointSet& points, int interp_order)
{
  GeometryModifyEngine* engine = gmeList.get();
  if (!engine->supports_facets())
    return NULL;

  Body* new_body = NULL;

  if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

  std::map<FacetShapes*, GeometryEntity*> geom_entity_map;
  BodySM* body_sm = engine->create_body(volume, geom_entity_map, points, interp_order);
  if(body_sm)
  {
    new_body = GeometryQueryTool::instance()->make_Body(body_sm);
    // map information back to caller
    std::map<FacetShapes*, GeometryEntity*>::iterator geom_iter;
    for (geom_iter = geom_entity_map.begin(); geom_iter != geom_entity_map.end(); geom_iter++)
      entity_map[geom_iter->first] = dynamic_cast<RefEntity*>(geom_iter->second->topology_entity());
  }

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body )
      CubitUndo::note_result_body( new_body );
    else
      CubitUndo::remove_last_undo();
  }

  return new_body;
}

RefVertex* GeometryModifyTool::make_RefVertex( RefVertex *vertex ) const
{
  if ( vertex == NULL )
  {
    PRINT_ERROR("Vertex is NULL\n");
    return NULL;
  }

  TopologyBridge* bridge = 0;
  GeometryModifyEngine* engine = get_engine(vertex, &bridge);
  if (engine == NULL)
  {
     PRINT_ERROR( "%s (vertex %d) does not have a modify engine.\n",
                  vertex->entity_name().c_str(),
                  vertex->id() );
     return 0;
  }

  CubitVector point = vertex->coordinates();

  // Call the default GeometryModifyEngine to create a new TBPoint
  TBPoint* point_ptr = engine->make_Point(point);

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  // Use the TBPoint to create a RefVertex
  RefVertex* ref_vertex_ptr = RefEntityFactory::instance()->construct_RefVertex(point_ptr) ;

  if( CubitUndo::get_undo_enabled() )
  {
    if( ref_vertex_ptr )
      CubitUndo::note_result_entity( ref_vertex_ptr );
    else
      CubitUndo::remove_last_undo();
  }

  //transfer the names
  DLIList<CubitString> names;
  vertex->entity_names( names );

  int i;
  for( i=names.size(); i--; )
  {
    CubitString tmp_name = names.get_and_step();
    ref_vertex_ptr->entity_name( tmp_name );
  }

  // Send a message to the model indicating the vertex was created
  AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::FREE_REF_ENTITY_GENERATED, ref_vertex_ptr));

  // Return the newly created RefVertex
  return ref_vertex_ptr ;
}


//-------------------------------------------------------------------------
// Purpose       : This function takes a type information and a location
//                 to create a RefVertex. The underlying representation
//                 of the RefVertex is determined by the default
//                 GeometryModifyEngine.
//
// Special Notes :
//
// Creator       : Raikanta Sahu
//
// Creation Date : 03/27/97
//-------------------------------------------------------------------------

RefVertex* GeometryModifyTool::make_RefVertex(
                                        CubitVector const& point, int color) const
{
   if (0 == gmeList.size())
   {
      PRINT_WARNING("No active geometry engine.\n");
      return NULL;
   }

     // Call the default GeometryModifyEngine to create a new TBPoint
   TBPoint* point_ptr = gmeList.get()->make_Point(point);

     // If we get a NULL pointer, give a warning message and return
     // a NULL pointer.
   if ( point_ptr == NULL )
   {
      PRINT_WARNING("In GeometryModifyTool::make_RefVertex\n"
                    "         Got a NULL pointer to a TBPoint.\n"
                    "         Cannot make a RefVertex.\n") ;
      return (RefVertex *)NULL ;
   }

   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state();

     // Use the TBPoint to create a RefVertex
   RefVertex* ref_vertex_ptr = RefEntityFactory::instance()->construct_RefVertex(point_ptr) ;

  if( CubitUndo::get_undo_enabled() )
  {
    if( ref_vertex_ptr )
      CubitUndo::note_result_entity( ref_vertex_ptr );
    else
      CubitUndo::remove_last_undo();
  }

   ref_vertex_ptr->color(color);

     // Send a message to the model indicating the vertex was created
   AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::FREE_REF_ENTITY_GENERATED, ref_vertex_ptr));

     // Return the newly created RefVertex
   return ref_vertex_ptr ;
}

Body *GeometryModifyTool::make_Body(Surface *surface) const
{
  // make a Body from a Surface
  BodySM *body_sm = surface->bodysm();

  GeometryModifyEngine* gme = get_engine(surface);

  if (gme && !body_sm)
    body_sm = gme->make_BodySM(surface);

  assert(body_sm != 0);

  return GeometryQueryTool::instance()->make_Body(body_sm);
}

//-------------------------------------------------------------------------
// Purpose       : This function takes RefEdge type information, too
//
// Creator       : David White
//
// Creation Date : 10/9/97
//-------------------------------------------------------------------------
RefEdge* GeometryModifyTool::make_RefEdge(RefEdge *ref_edge_ptr,
                                          bool copy_attribs,
                                          std::map< RefEntity*, RefEntity* > *old_to_new_map ) const
{
  if ( ref_edge_ptr == NULL )
  {
    PRINT_ERROR("curve is NULL\n");
    return (RefEdge*)NULL;
  }

  TopologyBridge* bridge = 0;
  GeometryModifyEngine* engine = get_engine(ref_edge_ptr, &bridge);
  Curve *old_curve = dynamic_cast<Curve*>(bridge);
  if (engine == NULL)
  {
     PRINT_ERROR( "%s (curve %d) does not have a modify engine.\n",
                  ref_edge_ptr->entity_name().c_str(),
                  ref_edge_ptr->id() );
     return 0;
  }

  Curve *tmp_curve;
  if( copy_attribs )
  {
    DLIList<RefEntity*> tmp_list;
    tmp_list.append( ref_edge_ptr );
    TopologyBridge *curve_bridge;
    prepare_for_copy( ref_edge_ptr, curve_bridge );
    tmp_curve = CAST_TO( curve_bridge, Curve);
  }
  else
    tmp_curve = old_curve;

  std::map<TopologyBridge*, TopologyBridge*> old_tb_to_new_tb;
  Curve *new_curve = NULL;
  if( old_to_new_map )
    new_curve = engine->make_Curve( tmp_curve, &old_tb_to_new_tb );
  else 
    new_curve = engine->make_Curve( tmp_curve );

  if (!new_curve)
  {
    if( copy_attribs )
      clean_up_from_copy_failure( old_curve );
    return (RefEdge *)NULL;
  }

  TopologyBridge *new_curve_bridge;
  if( copy_attribs )
  {
    new_curve_bridge = new_curve;
    finish_copy( new_curve_bridge, old_curve );
    new_curve = CAST_TO( new_curve_bridge, Curve);
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  // Complete the task of linking this new Curve into the rest of the
  // geometry datastructures and return the new RefEdge.
  RefEdge *new_ref_edge = GeometryQueryTool::instance()->make_free_RefEdge(new_curve);

  if( old_to_new_map )
     create_old_to_new_ref_ent_map( old_curve, new_curve, *old_to_new_map, old_tb_to_new_tb );

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::note_result_entity( new_ref_edge );

  return new_ref_edge;
}

CubitStatus GeometryModifyTool::prepare_for_copy( RefEntity *ref_ent,
                                                  TopologyBridge *&top_bridge )
{
  //save attribute settings
  CGMApp::instance()->save_current_attribute_states();

  CGMApp::instance()->attrib_manager()->auto_flag(1);
  // Groups are saved directly in the Cubit file, not with attributes
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_GROUP, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_GROUP, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_GROUP, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_GROUP, CUBIT_FALSE);

  // The mesh container is only used for the Exodus save/resore method
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_MESH_CONTAINER, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_MESH_CONTAINER, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_MESH_CONTAINER, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_MESH_CONTAINER, CUBIT_FALSE);

  // Genesis Entities are saved directly in the Cubit file, not with attributes
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_GENESIS_ENTITY, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_GENESIS_ENTITY, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_GENESIS_ENTITY, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_GENESIS_ENTITY, CUBIT_FALSE);

  //Don't save out entity ids
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_ENTITY_ID, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_ENTITY_ID, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_ENTITY_ID, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_ENTITY_ID, CUBIT_FALSE);

  //Don't save out graphics
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_GRAPHICS_OPTS, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_GRAPHICS_OPTS, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_GRAPHICS_OPTS, CUBIT_FALSE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_GRAPHICS_OPTS, CUBIT_FALSE);

  //Flag to say "we're copying" attributes
  copyingEntity = ref_ent;

  //Get all children
  DLIList<RefEntity*> child_list;
  ref_ent->get_all_child_ref_entities( child_list );

  //Puts attributes on all the entities
  child_list.append( ref_ent );
  CubitAttribUser::auto_update_cubit_attrib( child_list );

  //Prepare virtual
  TopologyEntity *topo_ptr = dynamic_cast<TopologyEntity*>( ref_ent );
  top_bridge = topo_ptr->bridge_manager()->topology_bridge();
  DLIList<TopologyBridge*> bridge_list;
  bridge_list.append( top_bridge );
  GeometryQueryTool::instance()->ige_export_geom( bridge_list );

  //Should only have 1 bridge in the list
  assert( bridge_list.size() == 1 );
  TopologyBridge *tmp_bridge_after = bridge_list.get();
  if( top_bridge != tmp_bridge_after)
    top_bridge = tmp_bridge_after;

  //Done copying attributes
  copyingEntity = NULL;

  return CUBIT_SUCCESS;

}

CubitStatus GeometryModifyTool::clean_up_from_copy_failure( TopologyBridge *old_bridge )
{
  //Remove attributes on underlying entities of virtual geometry
  //entities which do not have corresponding RefEntities.
  DLIList<TopologyBridge*> bridge_list;
  bridge_list.append( old_bridge );
  GeometryQueryTool::instance()->ige_remove_attributes( bridge_list );

  //Remove attributes on original entity and children
  DLIList<RefEntity*> child_list;
  RefEntity *ref_ent = CAST_TO( old_bridge->topology_entity(), RefEntity );
  ref_ent->get_all_child_ref_entities( child_list );
  //child_list.append( ref_ent );
  CubitAttribUser::clear_all_simple_attrib( child_list );
  child_list.clean_out();
  child_list.append( ref_ent );
  CubitAttribUser::clear_all_simple_attrib( child_list );

  CGMApp::instance()->restore_previous_attribute_states();

return CUBIT_SUCCESS;
}

CubitStatus GeometryModifyTool::finish_copy( TopologyBridge *&new_bridge,
                                             TopologyBridge *old_bridge )
{
  //Remove attributes on underlying entities of virtual geometry
  //entities which do not have corresponding RefEntities.
  DLIList<TopologyBridge*> bridge_list;
  bridge_list.append( old_bridge );
  GeometryQueryTool::instance()->ige_remove_attributes( bridge_list );

  //Remove attributes on original entity and children
  DLIList<RefEntity*> child_list;
  RefEntity *ref_ent = CAST_TO( old_bridge->topology_entity(), RefEntity );
  ref_ent->get_all_child_ref_entities( child_list );
  //child_list.append( ref_ent );
  CubitAttribUser::clear_all_simple_attrib( child_list );
  child_list.clean_out();
  child_list.append( ref_ent );
  CubitAttribUser::clear_all_simple_attrib( child_list );


  //Restore virtual
  //Could create virtual geometry here so the Topology Bridge can change
  bridge_list.clean_out();
  bridge_list.append( new_bridge );
  TopologyBridge *tmp_bridge_before = new_bridge;
  GeometryQueryTool::instance()->ige_import_geom( bridge_list );
  assert( bridge_list.size() == 1 );
  if( tmp_bridge_before != bridge_list.get() )
    new_bridge = bridge_list.get();

  //make the RefEntities
  Curve *curve = NULL;
  Surface *surface = NULL;
  Lump *lump = NULL;
  BodySM *body = NULL;

  RefEntity *new_ref_ent = NULL;
  if( (curve = CAST_TO( new_bridge, Curve ) ) != NULL )
    new_ref_ent = GeometryQueryTool::instance()->make_RefEdge( curve );
  else if( (surface = CAST_TO( new_bridge, Surface) ) != NULL )
    new_ref_ent = GeometryQueryTool::instance()->make_RefFace( surface );
  else if( (lump = CAST_TO( new_bridge, Lump) ) != NULL )
    new_ref_ent = GeometryQueryTool::instance()->make_Body( lump->bodysm() );
  else if( (body = CAST_TO( new_bridge, BodySM) ) != NULL )
    new_ref_ent = GeometryQueryTool::instance()->make_Body( body );

  //actuate the attributes on everything
  child_list.clean_out();
  new_ref_ent->get_all_child_ref_entities( child_list );
  child_list.append( new_ref_ent );
  GeometryQueryTool::import_actuate( child_list );

  //Remove attributes on new entity and children
  child_list.clean_out();
  new_ref_ent->get_all_child_ref_entities( child_list );
  CubitAttribUser::clear_all_simple_attrib( child_list );
  child_list.clean_out();
  child_list.append( new_ref_ent );
  CubitAttribUser::clear_all_simple_attrib( child_list );

  CGMApp::instance()->restore_previous_attribute_states();
  return CUBIT_SUCCESS;
}
#ifdef PROE
CubitStatus GeometryModifyTool::prepare_for_topology_update( BodySM* old_bodysm )
{
  DLIList<BodySM*> old_bodysms;
  old_bodysms.append(old_bodysm);

  do_attribute_setup();
  push_attributes_before_modify( old_bodysms );

  return CUBIT_SUCCESS;
}
CubitStatus GeometryModifyTool::finish_topology_update( BodySM* new_bodysm,
                                                        Body* old_body )
{
  DLIList<Body*> input_bodies,result_bodies;
  DLIList<BodySM*> new_bodysms, old_bodysms;
  input_bodies.append(old_body);
  new_bodysms.append(new_bodysm);
  old_bodysms.clean_out();

  DLIList<int> merged_surface_ids;
  DLIList<int> merged_curve_ids;


  get_merged_curve_and_surface_ids( input_bodies, merged_surface_ids, merged_curve_ids );
  //Store information about what surfaces were originally merged
  //
  //This fixes a problem caused by the lack of support
  //for automatically remerging surfaces that contain any
  //virtual geometry.
  //This should be removed if this issue is ever fixed - AHH
  std::map< int , DLIList<Surface*> > merged_map;
  for(int i=0; i< merged_surface_ids.size(); i++ )
    {
    int refface_id = merged_surface_ids.get_and_step();
    RefFace* old_merged_refface = RefEntityFactory::instance()->get_ref_face( refface_id );
    if( old_merged_refface && old_merged_refface->bridge_manager()->number_of_bridges() > 1 )
      {
      DLIList<Surface*> merged_surfsms;
      DLIList<TopologyBridge*> bridge_list;
      old_merged_refface->bridge_manager()->get_bridge_list( bridge_list );
      for(int j=0; j< bridge_list.size(); j++ )
        {
        Surface* merging_surf = CAST_TO(bridge_list.get_and_step(),Surface);
        if( merging_surf )
          merged_surfsms.append_unique( merging_surf );
        }
      merged_map[ refface_id ] = merged_surfsms;
      }
    }
  //*/
  /*
  //check to see if any curves have been orphaned inside virtual geometry
  DLIList<TBPoint*> point_list;
  new_bodysm->points( point_list );
  CubitBoolean loop = CUBIT_TRUE;
  while( loop )
    {
    for(i=0; i< point_list.size(); i++)
      {
      //loop all the points and see if any will be on only one live curve
      TBPoint* curr_point = point_list.get_and_step();
      DLIList<Curve*> curves_on_point;
      DLIList<Curve*> curves_to_keep;
      curr_point->curves( curves_on_point );
      for(int j=0; j< curves_on_point.size(); j++)
        {
        Curve* curr_curve = curves_on_point.get_and_step();
        DLIList<CubitSimpleAttrib*> attrib_list;
        CubitSimpleAttrib* attrib = CompositeEngine::find_attribute_by_name( curr_curve, "COMPOSITE_GEOM" );
        if( attrib )
          {
          attrib_list.append(attrib);
          }
        else
          curves_to_keep.append_unique( curr_curve );
        //curr_curve->get_simple_attribute( "COMPOSITE_GEOM", attrib_list );
        //if ( !attrib_list.size() )
          //curves_to_keep.append_unique( curr_curve );
        }
      //if all but one curve on this point will be removed we need to remove the other one too
      if( curves_to_keep.size() == 1 )
        {
        CubitString name("COMPOSITE_GEOM");
        DLIList<CubitString*> string_list;
        string_list.append( &name );
        CubitSimpleAttrib geom_attrib( &string_list, 0, 0 );
        curves_to_keep.get()->append_simple_attribute_virt( &geom_attrib );
        curr_point->append_simple_attribute_virt( &geom_attrib );
        loop = CUBIT_FALSE;
        }
      else if( curves_to_keep.size() == 0 )
        {
        DLIList<CubitSimpleAttrib*> attrib_list;
        curr_point->get_simple_attribute( "COMPOSIT_GEOM", attrib_list );
        if( !attrib_list.size() )
          {
          CubitString name("COMPOSITE_GEOM");
          DLIList<CubitString*> string_list;
          string_list.append( &name );
          CubitSimpleAttrib geom_attrib( &string_list, 0, 0 );
          curr_point->append_simple_attribute_virt( &geom_attrib );
          loop = CUBIT_TRUE;
          }
        }
      }
    if( loop )
      loop = CUBIT_FALSE;
    else
      loop = CUBIT_TRUE;
    }
  */
  GeometryModifyEngine* gme = GeometryModifyTool::instance()->get_engine(old_body);

  restore_vg_after_modify(new_bodysms, input_bodies, gme);


  DLIList<RefVolume*> volume_list;

  int i;
  for(i=new_bodysms.size(); i--;)
  {
    BodySM *bsm = new_bodysms.get_and_step();
    Body *body = dynamic_cast<Body*>(bsm->topology_entity());
    if(body)
    {
      // Append to the total list of volumes.
      body->ref_volumes(volume_list);
    }
  }
  // get all child entities (only get entities below volumes)
  DLIList<RefEntity*> child_list, ref_ent_list;
  CAST_LIST_TO_PARENT(volume_list, ref_ent_list);
  RefEntity::get_all_child_ref_entities( ref_ent_list, child_list );

  // Only push the id attributes if we are doing persistent ids.
  for(i=child_list.size(); i--;)
  {
  child_list.get_and_step()->auto_actuate_cubit_attrib(CUBIT_FALSE,CUBIT_TRUE);
  }

  remove_pushed_attributes(new_bodysms, input_bodies);

  finish_sm_op( input_bodies, new_bodysms , result_bodies);

  fixup_merged_entities( merged_surface_ids, merged_curve_ids);

  //Look for RefEdges that are orphaned inside of virtual surfaces
  CubitBoolean loop = CUBIT_TRUE;
  DLIList<RefVertex*> vertex_list;
  while(loop)
    {
    loop = CUBIT_FALSE;
    vertex_list.clean_out();
    for(i=0; i< volume_list.size(); i++)
      {
      RefVolume* curr_volume = volume_list.get_and_step();
      curr_volume->ref_vertices( vertex_list );
      }
    for(i=0; i< vertex_list.size(); i++)
      {
      RefVertex* curr_vertex = vertex_list.get_and_step();
      DLIList<RefEdge*> edges_on_vertex;
      curr_vertex->ref_edges( edges_on_vertex );
      edges_on_vertex.uniquify_unordered();
      if( edges_on_vertex.size() == 1 )
        {
        RefEdge* edge_to_remove = edges_on_vertex.get();
        CompositeTool::instance()->remove_edge(edge_to_remove);
        loop = CUBIT_TRUE;
        break;
        }
      }
    }
  //Force merge faces that were missed by finish_sm_op
  //
  //This fixes a problem caused by the lack of support
  //for automatically remerging surfaces that contain any
  //virtual geometry.
  //This should be removed if this issue is ever fixed - AHH
  for(i=0; i< merged_surface_ids.size(); i++)
    {
    int refface_id = merged_surface_ids.get_and_step();
    DLIList<RefFace*> ref_faces_to_remerge;
    if(merged_map.find( refface_id ) != merged_map.end())
      {
      DLIList<Surface*> merged_surfsms = merged_map[ refface_id ];
      for(int k=0; k< merged_surfsms.size(); k++)
        {
        Surface* merging_surf = merged_surfsms.get_and_step();
        RefFace* merging_refface = CAST_TO(merging_surf->topology_entity(),RefFace);
        if(merging_refface)
          ref_faces_to_remerge.append_unique(merging_refface);
        }
      }
    if( ref_faces_to_remerge.size() == 2 )
      {
      RefFace* first_remerge_face = ref_faces_to_remerge.get_and_step();
      RefFace* second_remerge_face = ref_faces_to_remerge.get_and_step();
      int first_id = first_remerge_face->id();
      int second_id = second_remerge_face->id();
      MergeTool::instance()->force_merge( first_remerge_face , second_remerge_face );
      PRINT_WARNING("Remerging Surfaces %i and %i\n",first_id,second_id);
      }
    }
  //*/
  //do_attribute_cleanup();

  return CUBIT_SUCCESS;
}

#endif
GeometryModifyEngine*
GeometryModifyTool::make_RefEdge_common( RefVertex* start_vertex,
                                         RefVertex* end_vertex,
                                         TBPoint*& start_point,
                                         TBPoint*& end_point,
                                         RefFace* ref_face,
                                         Surface** surface ) const
{
  DLIList<TopologyEntity*> entity_list(3);
  DLIList<TopologyBridge*> bridge_list(3);
  TopologyBridge* bridge = 0;
  GeometryModifyEngine* gme = 0;
  start_point = end_point = 0;

  bool new_start_point = start_vertex->get_parents() > 0;
  bool new_end_point = end_vertex->get_parents() > 0;

  if (ref_face)
    entity_list.append( ref_face );
  if (!new_start_point)
    entity_list.append( start_vertex );
  if (!new_end_point)
    entity_list.append( end_vertex );

  if (entity_list.size())
    gme = common_modify_engine( entity_list, bridge_list );

  if (gme)
  {
    bridge_list.reset();
    if (ref_face)
      *surface = dynamic_cast<Surface*>(bridge_list.get_and_step());
    if (!new_start_point)
      start_point = dynamic_cast<TBPoint*>(bridge_list.get_and_step());
    if (!new_end_point)
      end_point = dynamic_cast<TBPoint*>(bridge_list.get_and_step());
  }
  else if (ref_face)
  {
    gme = get_engine( ref_face, &bridge );
    if (!gme)
    {
      PRINT_ERROR("No modify engine for surface %d\n", ref_face->id()) ;
      return 0;
    }
    *surface = dynamic_cast<Surface*>(bridge);
    GeometryQueryEngine* gqe = bridge->get_geometry_query_engine();
    if (!new_start_point)
      start_point = dynamic_cast<TBPoint*>( start_vertex->
                                  bridge_manager()->topology_bridge( gqe ) );
    if (!new_end_point)
      end_point = dynamic_cast<TBPoint*>( end_vertex->
                                  bridge_manager()->topology_bridge( gqe ) );
  }
  else if (!new_start_point && (gme = get_engine( start_vertex, &bridge )))
  {
    start_point = dynamic_cast<TBPoint*>(bridge);
    if (!new_end_point)
      end_point = dynamic_cast<TBPoint*>( end_vertex->bridge_manager()->
                    topology_bridge( bridge->get_geometry_query_engine() ) );
  }
  else if (!new_end_point && (gme = get_engine( end_vertex, &bridge )))
  {
    end_point = dynamic_cast<TBPoint*>(bridge);
  }
  else
  {
    gme = get_gme();
  }


  if (!start_point)
    start_point = gme->make_Point( start_vertex->coordinates() );
  if (!end_point)
    end_point = gme->make_Point( end_vertex->coordinates());

  return gme;
}

//-------------------------------------------------------------------------
// Purpose       : This function uses the vertices and surface to create
//                 a curve along this surface.  The solid modeler will actually
//                 do most of the work.
// Note          : The optional third vertex will not be part of the curve,
//                 it is used for interpolation purposes.
//
// Creator       : David White
//
// Creation Date : 10/9/97
//
// Rewriting for new GeometryQueryTool interface - J.Kraftcheck 9/03
//-------------------------------------------------------------------------
RefEdge* GeometryModifyTool::make_RefEdge(RefVertex *ref_vertex_1,
                                    RefVertex *ref_vertex_2,
                                    RefFace* ref_face_ptr,
                                    RefVertex const* ref_vertex_3 ) const
{
      //make sure that the vertices are on the ref-face.
   CubitVector vert_1 = ref_vertex_1->coordinates();
   CubitVector vert_2 = ref_vertex_2->coordinates();

   ref_face_ptr->move_to_surface(vert_1);
   ref_face_ptr->move_to_surface(vert_2);

   GeometryQueryEngine *gqe = ref_face_ptr->get_geometry_query_engine();

   if (!ref_vertex_1->coordinates().within_tolerance(vert_1, gqe->get_sme_resabs_tolerance()))
   {
      PRINT_ERROR("vertices must lie within tolerance to the given"
                  " surface.\n"
                  "%s (Vertex %d) does not lie on %s (Surface %d).\n",
                  ref_vertex_1->entity_name().c_str(),
                  ref_vertex_1->id(),
                  ref_face_ptr->entity_name().c_str(),
                  ref_face_ptr->id() );
      return (RefEdge*)NULL;
   }
   else if (!ref_vertex_2->coordinates().within_tolerance(vert_2, gqe->get_sme_resabs_tolerance() ))
   {
      PRINT_ERROR("vertices must lie within tolerance to the given"
                  " surface.\n"
                  "%s (Vertex %d) does not lie on %s (Surface %d).\n",
                  ref_vertex_2->entity_name().c_str(),
                  ref_vertex_2->id(),
                  ref_face_ptr->entity_name().c_str(),
                  ref_face_ptr->id() );
      return (RefEdge*)NULL;
   }
     //Now let us find the points on the surface.  We want to
     //create them as we go for accuracy.

      // Get the GME of the first RefVertex.
   GeometryModifyEngine* GMEPtr = 0;

     // Extract the end Points to be used to make the RefEdge
   TBPoint* point_ptr1 = NULL;
   TBPoint* point_ptr2 = NULL;
   Surface* surface_ptr = NULL;

   // Look for a common GeometryModifyEngine
  GMEPtr = make_RefEdge_common( ref_vertex_1, ref_vertex_2,
                                point_ptr1, point_ptr2,
                                ref_face_ptr, &surface_ptr );

  //If we did not find a common GeometryModifyEngine, fail
  if( ! GMEPtr )
  {
    PRINT_ERROR("Surface %d, vertex %d and vertex %d do not "
      "belong to the same geometric modeling engine.\n", ref_face_ptr->id(),
      ref_vertex_1->id(), ref_vertex_2->id() );

    return 0;
  }

   CubitVector *third_vector_ptr = NULL;
   CubitVector third_vector;
   if ( ref_vertex_3 != NULL )
   {
      third_vector = ref_vertex_3->coordinates();
      third_vector_ptr = &third_vector;
      ref_face_ptr->move_to_surface( third_vector );
   }

     // Make sure that we get back valid Points
   assert ( point_ptr1 != NULL && point_ptr2 != NULL );
   
   if( CubitUndo::get_undo_enabled() )
   {
     //if endpoints are free vertices, need to save them out
     DLIList<RefVertex*> verts_to_save;
     verts_to_save.append( ref_vertex_1 );
     verts_to_save.append( ref_vertex_2 );
     bool save_only_if_free = true;
     CubitUndo::save_state_with_cubit_file( verts_to_save, save_only_if_free );
   }

     // Request the GME to create a Curve using the Points
   Curve *curve_ptr;
   curve_ptr = GMEPtr->make_Curve( point_ptr1,
                          point_ptr2,
                          surface_ptr,
                          third_vector_ptr);


     // If we get a NULL pointer, give a warning message and return
     // a NULL pointer.
   if ( curve_ptr == NULL )
   {
      PRINT_WARNING("In GeometryModifyTool::make_RefEdge\n"
                    "\tProblems making a spline curve from Vertex %d and %d\n"
                    "\tand the input list of positions.\n",
                    ref_vertex_1->id(), ref_vertex_2->id());
      return (RefEdge *)NULL ;
   }
  

     // Complete the task of linking this new Curve into the rest of the
     // geometry datastructures and return the new RefEdge.
   RefEdge *new_edge = GeometryQueryTool::instance()->make_free_RefEdge(curve_ptr);
   if( CubitUndo::get_undo_enabled() )
   {
     if( new_edge )
       CubitUndo::note_result_entity( new_edge );
   }
   return new_edge;
}

RefEdge* GeometryModifyTool::make_elliptical_RefEdge( RefVertex *vert1,
                                                      RefVertex *vert2,
                                                      CubitVector center_point,
                                                      double start_angle,
                                                      double end_angle,
                                                      CubitSense sense) const
{
  GeometryModifyEngine* GMEPtr = 0;

  // Extract the Points to be used to make the RefEdge
  TBPoint* point_ptr1 = NULL;
  TBPoint* point_ptr2 = NULL;

  // Look for a common geometric modeling engine to use
  GMEPtr = make_RefEdge_common( vert1, vert2,
                                point_ptr1, point_ptr2 );
  if (!GMEPtr)
    return 0;

  // Make sure that we get back valid Points
  assert ( point_ptr1 != NULL && point_ptr2 != NULL ) ;

  if( CubitUndo::get_undo_enabled() )
  {
    //if endpoints are free vertices, need to save them out
    DLIList<RefVertex*> verts_to_save;
    verts_to_save.append( vert1 );
    verts_to_save.append( vert2 );
    bool save_only_if_free = true;
    CubitUndo::save_state_with_cubit_file( verts_to_save, save_only_if_free );
  }

  // Request the GME to create a Curve using the Points
  Curve* curve_ptr = GMEPtr->make_elliptical_Curve(point_ptr1,
                                                   point_ptr2,
                                                   center_point,
                                                   start_angle,
                                                   end_angle,
                                                   sense);

  // If we get a NULL pointer, give a warning message and return
  // a NULL pointer.
  if ( curve_ptr == NULL )
  {
    PRINT_WARNING("In GeometryModifyTool::make_elliptical_RefEdge\n"
                  "         Got a NULL pointer to a Curve.\n"
                  "         Problems making RefEdge from RefVertex %d and %d\n",
                  vert1->id(), vert2->id());
    return (RefEdge *)NULL ;
  }

  // Complete the task of linking this new Curve into the rest of the
  // geometry datastructures and return the new RefEdge.
  RefEdge *new_edge = GeometryQueryTool::instance()->make_free_RefEdge( curve_ptr );
  if( CubitUndo::get_undo_enabled() )
  {
    if( new_edge )
      CubitUndo::note_result_entity( new_edge );
  }

  return new_edge;
}






//-------------------------------------------------------------------------
// Purpose       : This function takes RefEdge type information, two
//                 RefVertices, and a list of positions in space (represented
//                 by CubitVectors) to create a RefEdge. The RefVertices must
//                 be associated with the same GeometryModifyEngine.
//                 The return value can be a NULL pointer, if the RefEdge
//                 cannot be succesfully made for some reason.
//
// Special Notes : The interpolated curve is a spline curve.
//                 If the input refface_ptr is not NULL, the points are first
//                 moved to the surface before interpolation.
//
// Creator       : Malcolm Panthaki
//
// Creation Date : 05/15/97
//
// Rewriting for new GeometryQueryTool interface - J.Kraftcheck 9/03
//-------------------------------------------------------------------------
RefEdge* GeometryModifyTool::make_RefEdge(GeometryType ref_edge_type,
                                    RefVertex *ref_vertex_1,
                                    RefVertex *ref_vertex_2,
                                    DLIList<CubitVector*>& vector_list,
                                    RefFace* refface_ptr) const
{
   GeometryModifyEngine* GMEPtr = 0;

     // Extract the end Points to be used to make the RefEdge
   TBPoint* point_ptr1 = NULL;
   TBPoint* point_ptr2 = NULL;
   Surface* surface_ptr = NULL;

   // Look for a common GeometryModifyEngine
  GMEPtr = make_RefEdge_common( ref_vertex_1, ref_vertex_2,
                                point_ptr1, point_ptr2,
                                refface_ptr, &surface_ptr );
  if (!GMEPtr)
    return 0;

     // Make sure that we get back valid Points
   assert ( point_ptr1 != NULL && point_ptr2 != NULL );

   if( CubitUndo::get_undo_enabled() )
   {
     //if endpoints are free vertices, need to save them out
     DLIList<RefVertex*> verts_to_save;
     verts_to_save.append( ref_vertex_1 );
     verts_to_save.append( ref_vertex_2 );
     bool save_only_if_free = true;
     CubitUndo::save_state_with_cubit_file( verts_to_save, save_only_if_free );
   }

     // Request the GME to create a Curve using the Points
   Curve* curve_ptr = GMEPtr->make_Curve(ref_edge_type,
                                         point_ptr1,
                                         point_ptr2,
                                         vector_list,
                                         refface_ptr ? refface_ptr->get_surface_ptr() : 0);

     // If we get a NULL pointer, give a warning message and return
     // a NULL pointer.
   if ( curve_ptr == NULL )
   {
      PRINT_WARNING("In GeometryModifyTool::make_RefEdge\n"
                    "         Got a NULL pointer to a Curve.\n"
                    "         Problems making a spline RefEdge from RefVertex %d and %d\n"
                    "         and the input list of positions.\n",
                    ref_vertex_1->id(), ref_vertex_2->id());
      return (RefEdge *)NULL ;
   }

     // Complete the task of linking this new Curve into the rest of the
     // geometry datastructures and return the new RefEdge.
   RefEdge *new_edge = GeometryQueryTool::instance()->make_free_RefEdge(curve_ptr);
   if( CubitUndo::get_undo_enabled() )
   {
     if( new_edge )
       CubitUndo::note_result_entity( new_edge );
   }
   return new_edge;
}

//-------------------------------------------------------------------------
// Purpose       : This function takes a type information, two
//                 RefVertices, an intermediate position, and a sense
//                 information to create a RefEdge. The RefVertices must
//                 be associated with the same GeometryModifyEngine.
//                 The return value can be a NULL pointer, if the RefEdge
//                 cannot be succesfully made for some reason.
//
// Special Notes :
//
// Creator       : Raikanta Sahu
//
// Creation Date : 03/27/97
//-------------------------------------------------------------------------
RefEdge* GeometryModifyTool::make_RefEdge(GeometryType ref_edge_type,
                                    RefVertex *ref_vertex_1,
                                    RefVertex *ref_vertex_2,
                                    CubitVector const* intermediate_point ) const
{
   GeometryModifyEngine* GMEPtr = 0;

     // Extract the Points to be used to make the RefEdge
   TBPoint* point_ptr1 = NULL;
   TBPoint* point_ptr2 = NULL;

    // Look for a common geometric modeling engine to use
  GMEPtr = make_RefEdge_common( ref_vertex_1, ref_vertex_2,
                                point_ptr1, point_ptr2 );
  if (!GMEPtr)
    return 0;

     // Make sure that we get back valid Points
   assert ( point_ptr1 != NULL && point_ptr2 != NULL ) ;

   if( CubitUndo::get_undo_enabled() )
   {
     //if endpoints are free vertices, need to save them out
     DLIList<RefVertex*> verts_to_save;
     verts_to_save.append( ref_vertex_1 );
     verts_to_save.append( ref_vertex_2 );
     bool save_only_if_free = true;
     CubitUndo::save_state_with_cubit_file( verts_to_save, save_only_if_free );
   }

     // Request the GME to create a Curve using the Points
   Curve* curve_ptr = GMEPtr->make_Curve(ref_edge_type,
                                         point_ptr1,
                                         point_ptr2,
                                         intermediate_point );

     // If we get a NULL pointer, give a warning message and return
     // a NULL pointer.
   if ( curve_ptr == NULL )
   {
      PRINT_WARNING("In GeometryModifyTool::make_RefEdge\n"
                    "         Got a NULL pointer to a Curve.\n"
                    "         Problems making RefEdge from RefVertex %d and %d\n",
                    ref_vertex_1->id(), ref_vertex_2->id());
      return (RefEdge *)NULL ;
   }

     // Complete the task of linking this new Curve into the rest of the
     // geometry datastructures and return the new RefEdge.
   RefEdge *new_edge = GeometryQueryTool::instance()->make_free_RefEdge( curve_ptr );
   if( CubitUndo::get_undo_enabled() )
   {
     if( new_edge )
       CubitUndo::note_result_entity( new_edge );
   }
   return new_edge;
}

//-------------------------------------------------------------------------
// Purpose       : This function creates a RefFace from an existing RefFace.
//                 The new face is a sheet body, double sided face with no
//                 volume to the body.
//
// Special Notes :
//
// Creator       : Raikanta Sahu
//
// Creation Date : 03/27/97
//-------------------------------------------------------------------------

RefFace* GeometryModifyTool::make_RefFace(RefFace *from_ref_face,                                    
                                    std::map< RefEntity*, RefEntity* > *old_to_new_map ) const
{
   GeometryModifyEngine* GME_ptr = get_engine(from_ref_face);

   if (!GME_ptr)
   {
      PRINT_ERROR("Cannot create surface from another virtual surface.\n");
      return NULL;
   }
     //From the surface create a new surface.
   TopologyBridge* bridge = 0;
   GeometryModifyEngine* engine = get_engine(from_ref_face, &bridge);
   Surface* old_surface_ptr = dynamic_cast<Surface*>(bridge);
   if ( engine == NULL )
   {
      PRINT_ERROR("%s (surface %d) does not have a modify engine.\n",
                  from_ref_face->entity_name().c_str(),
                  from_ref_face->id() );
      return (RefFace*)NULL;
   }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  //this list will get all the TB's what we'll be copying
  TopologyBridge *top_bridge = old_surface_ptr;

  
  //if( !extended_from )
  {
    prepare_for_copy( from_ref_face, top_bridge );
  }

  Surface *tmp_surface = CAST_TO( top_bridge, Surface );
  std::map< TopologyBridge*, TopologyBridge* > old_tb_to_new_tb;
  Surface* new_surface_ptr = engine->make_Surface( tmp_surface, &old_tb_to_new_tb );

  if (!new_surface_ptr)
  {
    PRINT_ERROR("Surface copy failed.\n");
    //if( !extended_from )
      clean_up_from_copy_failure( old_surface_ptr );

   if( CubitUndo::get_undo_enabled() )
        CubitUndo::remove_last_undo();

    return 0;
  }
  
  //if( !extended_from  )
  {
    TopologyBridge *top_bridge_new = new_surface_ptr;
    finish_copy( top_bridge_new, old_surface_ptr );
    new_surface_ptr = CAST_TO( top_bridge_new, Surface );
  }

  Body *new_Body = make_Body(new_surface_ptr);
  DLIList<RefFace*> ref_faces;
  new_Body->ref_faces(ref_faces);
  assert(ref_faces.size() > 0);
  
  if( old_to_new_map )
    create_old_to_new_ref_ent_map( tmp_surface, new_surface_ptr, *old_to_new_map, old_tb_to_new_tb );

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_Body )
      CubitUndo::note_result_body( new_Body );
    else
      CubitUndo::remove_last_undo();
  }

  return ref_faces.get();
}

//-------------------------------------------------------------------------
// Purpose       : This function creates a sheet body by extending out a
//                 set of surfaces.  The sheet body is a double sided face
//                 with no volume.
//
// Special Notes :
//
// Creator       : Steve Storm
//
// Creation Date : 02/28/08
//-------------------------------------------------------------------------
Body*
GeometryModifyTool::make_extended_sheet( DLIList<RefFace*> &ref_face_list,
                                         CubitBox *clip_box_ptr,
                                         bool preview ) const
{
  if( !ref_face_list.size() )
    return 0;

  GfxPreview::clear();

  // Check for virtual geometry
  DLIList<RefEntity*> ref_ent_list;
  CAST_LIST_TO_PARENT(ref_face_list, ref_ent_list);
  if ( GeometryQueryTool::instance()->contains_intermediate_geometry(ref_ent_list) )
  {
    PRINT_ERROR("EXTENDING surfaces containing virtual geometry is not\n"
      "       allowed. Delete virtual geometry on these surfaces\n"
      "       before operation.\n" );
    return 0;
  }

  // Look for a common GeometryModifyEngine for all of the RefFaces
  int count = ref_face_list.size();
  DLIList<TopologyBridge*> bridge_list(count);
  DLIList<TopologyEntity*> entity_list(count);
  CAST_LIST_TO_PARENT( ref_face_list, entity_list );

  GeometryModifyEngine* GME_ptr =
    common_modify_engine( entity_list, bridge_list );
  if(! GME_ptr )
  {
     PRINT_ERROR("Cannot construct an extended sheet using surfaces that\n"
                 "       do not share a common geometry engine.\n");
     return 0;
  }

  DLIList<Surface*> surface_list(count);
  CAST_LIST( bridge_list, surface_list, Surface );
  
  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  BodySM *bodySM_ptr = GME_ptr->make_extended_sheet( surface_list,
    clip_box_ptr, preview );

  if( !bodySM_ptr )
    CubitUndo::remove_last_undo();

  if( bodySM_ptr )
  {
    Body *tmp_body = GeometryQueryTool::instance()->make_Body(bodySM_ptr);

    if( CubitUndo::get_undo_enabled() )
    {
      if( tmp_body )
        CubitUndo::note_result_entity( tmp_body );
      else 
        CubitUndo::remove_last_undo();
    }

    return tmp_body;
  }
  else
    return 0;
}

//-------------------------------------------------------------------------
// Purpose       : This function takes a type information and a list of
//                 RefEdges to create a Body with just one RefFace. The
//                 underlying representation of the RefFace is determined
//                 by the GeometryModifyEngine of the RefEdges. All the
//                 RefEdges in the list must be associated with the same
//                 GeometryModifyEngine. The return value can be a
//                 NULL pointer, if the RefFace cannot be succesfully
//                 made for some reason.
//
// Special Notes :
//
// Creator       : David White
//
// Creation Date : 10/23/97
//-------------------------------------------------------------------------

RefFace* GeometryModifyTool::make_RefFace(GeometryType ref_face_type,
                                    DLIList<RefEdge*>& ref_edge_list,
                                    bool is_free_face,
                                    RefFace *ref_face_ptr,
                                    bool check_edges ) const
{
    //Look for a common GeometryModifyEngine for all of
    //the RefEdges.

  const int count = ref_edge_list.size() + (ref_face_ptr ? 1 : 0);
  DLIList<TopologyBridge*> bridge_list(count);
  DLIList<TopologyEntity*> entity_list(count);
  CAST_LIST_TO_PARENT( ref_edge_list, entity_list );
  if( ref_face_ptr ) entity_list.append( ref_face_ptr );

  GeometryModifyEngine* GME_ptr =
    common_modify_engine( entity_list, bridge_list );
  if(! GME_ptr )
  {
     PRINT_ERROR("Cannot construct a Surface using entities that do "
                 "not share a common geometry engine.\n");
     return 0;
  }

   Surface* old_surface_ptr = 0;
   if (ref_face_ptr)
    old_surface_ptr = dynamic_cast<Surface*>(bridge_list.pop());

   //Collect all the names on vertices to propagate after you create
   //the surface
   DLIList<CubitVector> vertex_coordinates;
   DLIList<CubitString> vertex_names;
   DLIList<RefEdge*> free_ref_edges;
   int kk;
   for( kk=ref_edge_list.size(); kk--; )
   {
     DLIList<CubitString> tmp_names;
     RefEdge *tmp_edge = ref_edge_list.get_and_step();

     if( tmp_edge->num_parent_ref_entities() == 0 )
       free_ref_edges.append( tmp_edge );

     RefVertex *s_vertex = tmp_edge->start_vertex();
     RefVertex *e_vertex = tmp_edge->end_vertex();
     int jj;

     s_vertex->entity_names( tmp_names );
     for( jj=tmp_names.size(); jj--; )
     {
       CubitVector tmp_vec = tmp_edge->start_vertex()->coordinates();
       CubitString name = tmp_names.get_and_step();
       vertex_coordinates.append( tmp_vec );
       vertex_names.append( name );
     }

     tmp_names.clean_out();
     e_vertex->entity_names( tmp_names );
     for( jj=tmp_names.size(); jj--; )
     {
       CubitVector tmp_vec = tmp_edge->end_vertex()->coordinates();
       CubitString name = tmp_names.get_and_step();
       vertex_coordinates.append( tmp_vec );
       vertex_names.append( name );
     }
   }

   DLIList<Curve*> curve_list(ref_edge_list.size());
   CAST_LIST( bridge_list, curve_list, Curve );

     // Use the Curves to create a Surface
   Surface* surface_ptr = GME_ptr->make_Surface(ref_face_type, curve_list,
                                                old_surface_ptr, check_edges) ;

   if (surface_ptr == NULL) {
     PRINT_ERROR("Couldn't make new RefFace.\n");
     return NULL;
   }

   GeometryQueryTool* const gqt = GeometryQueryTool::instance();

   RefFace* result_face = gqt->make_free_RefFace(surface_ptr, is_free_face);
   gqt->cleanout_deactivated_geometry();

   //send out events for free curves saying that their 'free' status has
   //be changed

  for( kk=0; kk<free_ref_edges.size(); kk++ )
  {
    RefEdge *free_edge = free_ref_edges.get_and_step();
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOP_LEVEL_ENTITY_DESTRUCTED, free_edge));
    CGMHistory::Event evt(CGMHistory::TOP_LEVEL_ENTITY_DELETED, free_edge );
    GeometryQueryTool::instance()->history().add_event(evt);
  }


   //look for a vertex at the same location of the original
   //vertex(s).  Add the name to this new vertex.
   DLIList<RefVertex*> tmp_verts;
   result_face->ref_vertices( tmp_verts);
   for( kk=vertex_coordinates.size(); kk--; )
   {
     CubitVector tmp_coord = vertex_coordinates.get_and_step();
     CubitString tmp_name = vertex_names.get_and_step();

     int jj;
     for( jj=tmp_verts.size(); jj--; )
     {
       RefVertex *tmp_vert = tmp_verts.get_and_step();
       if( tmp_coord.distance_between( tmp_vert->coordinates() ) < GEOMETRY_RESABS )
       {
         //add the name if it doesn't already exist
         RefEntityName::instance()->add_refentity_name( tmp_vert, tmp_name );
       }
     }
   }

   return result_face;
}

//-------------------------------------------------------------------------
// Purpose       : This function takes a list of RefVolumes to create a
//                 Body. The underlying representation of the Body is
//                 determined by the GeometryModifyEngine of the
//                 RefVolumes. All the RefVolumes in the list must be
//                 associated with the same GeometryModifyEngine. The
//                 return value can be a NULL pointer, if the RefFace
//                 cannot be succesfully made for some reason.
//
// Special Notes :
//
// Creator       : Raikanta Sahu
//
// Creation Date : 03/29/97
//-------------------------------------------------------------------------

Body* GeometryModifyTool::make_Body(DLIList<RefVolume*>& ref_volume_list) const
{
  DLIList<TopologyEntity*> topo_list;
  DLIList<Lump*> lump_list;
  DLIList<TopologyBridge*> bridge_list;
  CAST_LIST_TO_PARENT( ref_volume_list, topo_list );
  GeometryModifyEngine* GME_ptr =
    common_modify_engine( topo_list, bridge_list, CUBIT_FALSE );
  if( ! GME_ptr )
  {
    PRINT_ERROR("The specified volumes do not belong to the same "
      "geometry engine, and therefore cannot be used to form a "
      "single body.");
    return 0;
  }
  CAST_LIST( bridge_list, lump_list, Lump );
  assert( ref_volume_list.size() == lump_list.size() );


     // Use the Lumps to create a BodySM
   BodySM* bodySM_ptr = GME_ptr->make_BodySM(lump_list) ;

     // If we get a NULL pointer, give a warning message and return
     // a NULL pointer.
   if ( bodySM_ptr == NULL )
   {
      PRINT_WARNING("In GeometryModifyTool::make_Body\n"
                    "         Got a NULL pointer to a BodySM.\n"
                    "         Cannot make a Body.\n") ;
      return (Body *)NULL;
   }

   return GeometryQueryTool::instance()->make_Body(bodySM_ptr);
}

//-------------------------------------------------------------------------
// Purpose       : This function creates a sheet body from an existing
//                 RefFace.
//
// Special Notes :
//
// Creator       : Raikanta Sahu
//
// Creation Date : 03/29/97
//-------------------------------------------------------------------------

Body* GeometryModifyTool::make_Body(RefFace *from_ref_face,                              
                              std::map< RefEntity*, RefEntity* > *old_to_new_map ) const
{
     // Given the arguments, make a RefFace.
   RefFace* new_ref_face = this->make_RefFace(from_ref_face,
                                              old_to_new_map );
   if (!new_ref_face)
   {
      return (Body *)NULL;
   }

   DLIList<Body*> bodies;
   new_ref_face->bodies(bodies);

   if (!bodies.size()) {
     GeometryEntity *ge_ptr = new_ref_face->get_geometry_entity_ptr();
     Surface *surf_ptr = CAST_TO(ge_ptr, Surface);
     assert(surf_ptr != 0);

     BodySM *body_sm = gmeList.get()->make_BodySM(surf_ptr);
     return GeometryQueryTool::instance()->make_Body(body_sm);
   }

   else return bodies.get();
}
//-------------------------------------------------------------------------
// Purpose       : This function takes a type information and a list of
//                 RefEdges to create a Body that has just one RefFace.
//                 The underlying representation of the Body is
//                 determined by the GeometryModifyEngine of the
//                 RefEdges. All the RefEdges in the list must be
//                 associated with the same GeometryModifyEngine. The
//                 return value can be a NULL pointer, if the Body cannot
//                 be succesfully made for some reason.
//
// Special Notes :
//
// Creator       : Raikanta Sahu
//
// Creation Date : 03/29/97
//-------------------------------------------------------------------------

Body* GeometryModifyTool::make_Body(GeometryType ref_face_type,
                              DLIList<RefEdge*>& ref_edge_list,
                              RefFace *ref_face_ptr) const
{
   if( CubitUndo::get_undo_enabled() )
     CubitUndo::save_state_with_cubit_file( ref_edge_list );

   bool is_free_face = false;

     // Given the arguments, make a RefFace.
   RefFace* new_ref_face = this->make_RefFace(ref_face_type,
                                              ref_edge_list,
                                              is_free_face,
                                              ref_face_ptr);

   if( new_ref_face == NULL )
      return NULL;

      // If new_ref_face doesn't have a body, create one.
   DLIList<Body*> bodies;
   new_ref_face->bodies(bodies);

   if (!bodies.size()) {
     Surface *surf_ptr = new_ref_face->get_surface_ptr();
     assert(surf_ptr != 0);
     GeometryModifyEngine* engine = get_engine(surf_ptr);
     assert(engine != 0);

     BodySM *body_sm = engine->make_BodySM(surf_ptr);
     Body* body = GeometryQueryTool::instance()->make_Body(body_sm);
     bodies.append( body );
   }

   if( CubitUndo::get_undo_enabled() )
   {
     if( bodies.size() )
       CubitUndo::note_result_entity( bodies.get() );
     else
      CubitUndo::remove_last_undo();
   }

     // Return the body containing the new RefFace.
   return bodies.get();
}

//-------------------------------------------------------------------------
// Purpose       : The following functions copy the input Body to create
//                 a new one.  Some transformations may be applied to the
//                 newly copied Body before returning it:
//                    copy
//                    copy_and_move
//                    copy_and_rotate
//
// Special Notes :
//
// Creator       : Malcolm J. Panthaki
//
// Creation Date : 10/1/96
//-------------------------------------------------------------------------
Body* GeometryModifyTool::copy_body ( Body* bodyPtr, 
  std::map< RefEntity*, RefEntity* > *old_to_new_map )
{
   BodySM* body_sm = bodyPtr->get_body_sm_ptr();
   if (!body_sm)
   {
     PRINT_ERROR("Body %d is invalid -- no attached BodySM.\n", bodyPtr->id());
     return 0;
   }

   //this list will get all the TB's what we'll be copying
   DLIList<RefEntity*> tmp_list;
   tmp_list.append( bodyPtr );
   TopologyBridge *top_bridge;
   prepare_for_copy( bodyPtr, top_bridge );

   BodySM *tmp_body_sm = CAST_TO( top_bridge, BodySM );

   GeometryModifyEngine* GMEPtr = get_engine(tmp_body_sm);
   if ( GMEPtr == NULL )
   {
     clean_up_from_copy_failure( top_bridge );
     PRINT_ERROR("Cannot copy volume %d\n"
                 "     Copy is supported for bodies based on solid "
                 "models only\n", bodyPtr->ref_volume()->id() );
     return NULL ;
   }
   std::map<TopologyBridge*, TopologyBridge*> old_tb_to_new_tb;  

   BodySM *new_bodysm = GMEPtr->copy_body(tmp_body_sm, &old_tb_to_new_tb );

   if (!new_bodysm)
   {
     clean_up_from_copy_failure( top_bridge );
     PRINT_ERROR("Failed to copy volume %d\n", bodyPtr->ref_volume()->id());
     return 0;
   }

   TopologyBridge *top_bridge_new = new_bodysm;
   finish_copy( top_bridge_new, body_sm );

   new_bodysm = CAST_TO( top_bridge_new, BodySM );
   Body *body_new = GeometryQueryTool::instance()->make_Body(new_bodysm);

   if( old_to_new_map )
     create_old_to_new_ref_ent_map( body_sm, new_bodysm, *old_to_new_map, old_tb_to_new_tb );

   return body_new;
}

//-------------------------------------------------------------------------
// Purpose       : Check if bodies can be webcut
//
// Special Notes :
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 10/10/03
//-------------------------------------------------------------------------
CubitStatus GeometryModifyTool::okay_to_modify(
                                 DLIList<Body*>& webcut_body_list,
                                 const char* op ) const
{
  CubitStatus ret = CUBIT_SUCCESS;

  Body *b = webcut_body_list.get();
  if(b)
  {
    GeometryModifyEngine *gme = get_engine(b);
    if(gme)
    {
      if(!gme->supports_interoperability() &&
          contains_intermediate_geom(webcut_body_list))
      {
        PRINT_ERROR("Intermixing real and virtual geometry operations using the current solid modeling kernel is not allowed.\n");
        ret = CUBIT_FAILURE;
      }
    }
  }

  if(ret == CUBIT_SUCCESS)
  {
    // If the operation is not one of the ones below...
    if(strcmp(op, "WEBCUT") &&
      strcmp(op, "CHOP") &&
      strcmp(op, "UNITE") &&
      strcmp(op, "TWEAK") &&
      strcmp(op, "IMPRINT") &&
      strcmp(op, "REGULARIZE") &&
      strcmp(op, "SPLIT_SURFACE") &&
      strcmp(op, "REMOVE_TOPOLOGY") &&
      strcmp(op, "SPLIT") &&
      strcmp(op, "NON_UNIFORM_SCALE"))
    {
      if (contains_intermediate_geom(webcut_body_list))
      {
        PRINT_ERROR("Performing %s on volumes containing virtual geometry is not allowed.\n", op);
        ret = CUBIT_FAILURE;
      }
    }
    else
    {
      if(contains_partitions(webcut_body_list))
      {
        PRINT_ERROR("Performing %s on volumes containing virtual partitions is not allowed.\n", op);
        ret = CUBIT_FAILURE;
      }
    }
  }

  return ret;
}


//-------------------------------------------------------------------------
// Purpose       : Common code for finishing webcut operations.
//
// Special Notes :
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 09/25/03
//-------------------------------------------------------------------------
CubitStatus GeometryModifyTool::finish_webcut( DLIList<Body*>& webcut_body_list,
                                               DLIList<BodySM*>& result_body_sms,
                                               CubitBoolean merge,
                                               CubitStatus status,
                                               DLIList<Body*>& result_list,
                                               DLIList<int> *merged_surface_ids,
                                               DLIList<int> *merged_curve_ids,
                                               CubitBoolean print_info) const
{
   if (!finish_sm_op(webcut_body_list, result_body_sms, result_list,(bool)print_info))
     status = CUBIT_FAILURE;

   DLIList<Body*> temp_result_list;
   if (status)
   {
     status = separate_body_after_webcut( result_list, temp_result_list);
     result_list = temp_result_list;
   }

   if( merged_surface_ids && merged_curve_ids )
     fixup_merged_entities( *merged_surface_ids, *merged_curve_ids );

   if (merge && status)
   {
     DLIList<Body*> temp_results(result_list);
     status = MergeTool::instance()->merge_bodies( temp_results );
   }
   return status;
}


//-------------------------------------------------------------------------
// Purpose       : Complete solid modeling operation on bodies
//
// Special Notes :
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 09/25/03
//-------------------------------------------------------------------------
CubitStatus GeometryModifyTool::finish_sm_op( DLIList<Body*>& input_bodies,
                                              DLIList<BodySM*>& new_bodies,
                                              DLIList<Body*>& result_bodies,
                                              bool print_info ) const
{
  int i;
  GeometryQueryTool* gqt = GeometryQueryTool::instance();

  DLIList<int> updated_ids, created_ids, destroyed_ids;
  DLIList<int> updated_vol_ids, created_vol_ids, destroyed_vol_ids;

  // traverse the body object and remove any meshes from modified objects
  int b;
  for (b = 0; b < input_bodies.size(); b++) {
      Body* body = input_bodies.get_and_step();
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_ENTITY_MODIFIED, body));
  }

    // Remove dead bodies
  input_bodies.reset();
  for (i = input_bodies.size(); i--;)
  {
    Body* body = input_bodies.step_and_get();

    BodySM* bodysm = body->get_body_sm_ptr();
    if (!bodysm)
    {
        // If the body was destroyed, update the list
      destroyed_ids.append( body->id() );

      DLIList<RefVolume*> temp_vols;
      body->ref_volumes( temp_vols );
      for( int nv = temp_vols.size(); nv > 0; nv-- )
      {
        if( !temp_vols.get()->get_lump_ptr() )
          destroyed_vol_ids.append( temp_vols.get_and_step()->id() );
      }

      input_bodies.change_to(0);
      gqt->destroy_dead_entity(body);
    }
    else
    {
      remove_dead_entity_names( body );
    }
  }
  gqt->cleanout_deactivated_geometry();

    // Create new bodies
  new_bodies.last();
  for (i = new_bodies.size(); i--; )
  {
    BodySM* bodysm = new_bodies.step_and_get();
    bool newbody = bodysm->owner() == 0;
    Body* body = gqt->make_Body(bodysm);
    result_bodies.append(body);

    if (newbody)
    {
      created_ids.append(body->id());

      DLIList<RefVolume*> temp_vols;
      body->ref_volumes( temp_vols );
      for( int nv = temp_vols.size(); nv > 0; nv-- )
      {
        created_vol_ids.append( temp_vols.get_and_step()->id() );
      }
    }
    else
    {
      updated_ids.append(body->id());

      DLIList<RefVolume*> temp_vols;
      body->ref_volumes( temp_vols );
      for( int nv = temp_vols.size(); nv > 0; nv-- )
      {
        updated_vol_ids.append( temp_vols.get_and_step()->id() );
      }
    }
  }
  gqt->cleanout_deactivated_geometry();

  if (print_info)
  {
    if( DEBUG_FLAG( 153 ) )
    {
      if (created_ids.size())
         CubitUtil::list_entity_ids( "Created body(s): ", created_ids );
      if (updated_ids.size())
         CubitUtil::list_entity_ids( "Updated body(s): ", updated_ids );
      if (destroyed_ids.size())
         CubitUtil::list_entity_ids( "Destroyed body(s): ", destroyed_ids );
    }

    if (created_vol_ids.size())
       CubitUtil::list_entity_ids( "Created volume(s): ", created_vol_ids );
    if (updated_vol_ids.size())
       CubitUtil::list_entity_ids( "Updated volume(s): ", updated_vol_ids );
    if (destroyed_vol_ids.size())
       CubitUtil::list_entity_ids( "Destroyed volume(s): ", destroyed_vol_ids );
  }

  return CUBIT_SUCCESS;
}



//-------------------------------------------------------------------------
// Purpose       : Webcut a body with a cylinder given the input parameters.
// Special Notes :
//
// Creator       : David White
//
// Creation Date : 10/28/97
//-------------------------------------------------------------------------
CubitStatus GeometryModifyTool::webcut_with_cylinder(
                                       DLIList<Body*>& webcut_body_list,
                                       double radius,
                                       const CubitVector &axis,
                                       const CubitVector &center,
                                       DLIList<Body*>& results_list,
                                       DLIList<Body*> &neighboring_bodies,
                                       ImprintType imprint_type,
                                       CubitBoolean merge,
                                       CubitBoolean preview)
{
  if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
    return CUBIT_FAILURE;

  GfxPreview::clear();

  CubitStatus rval = CUBIT_SUCCESS;

  if (preview)
  {
    // find the bounding box for the cylinder
    CubitBox bounding_box;
    Body* body_ptr = webcut_body_list.get_and_step();
    bounding_box = body_ptr->bounding_box();

    int i;
    for( i=1; i<webcut_body_list.size(); i++ )
    {
       body_ptr = webcut_body_list.get_and_step();
       bounding_box |= body_ptr->bounding_box();
    }

    int color = CUBIT_BLUE_INDEX;
    GfxPreview::draw_cylinder(axis, center, bounding_box, (float) radius, color);
    GfxPreview::flush();
    return rval;
  }

  if( CubitUndo::get_undo_enabled() )
  {
    DLIList<Body*> bodies_to_save;
    bodies_to_save += webcut_body_list;
    bodies_to_save += neighboring_bodies;
    CubitUndo::save_state_with_cubit_file( bodies_to_save );
  }

  const int count = webcut_body_list.size();
  DLIList<BodySM*> result_sm_list;
  DLIList<Body*> body_list(webcut_body_list);
  DLIList<BodySM*> engine_body_sms(count);
  DLIList<Body*> engine_bodies(count);
  GeometryModifyEngine* gme = 0;

  if(!preview)
    do_attribute_setup();

  while ( (gme = group_bodies_by_engine(body_list, engine_bodies, engine_body_sms)) )
  {
    //get all bodysms that we might modify in this operation
    DLIList<BodySM*> neighbor_imprint_list;
    DLIList<BodySM*> bodies_sm_to_modify;
    DLIList<Body*> bodies_to_modify;
    bodies_to_modify += engine_bodies;
    int i;
    for( i=neighboring_bodies.size(); i--; )
    {
      Body *tmp_body = neighboring_bodies.get_and_step();
      BodySM *tmp_body_sm = tmp_body->get_body_sm_ptr();
      if( gme == get_engine(tmp_body_sm ) )
      {
        neighbor_imprint_list.append( tmp_body_sm );
        bodies_to_modify.append( tmp_body );
      }
    }

    DLIList<int> merged_surface_ids;
    DLIList<int> merged_curve_ids;

    if(!preview)
    {
      bodies_sm_to_modify += neighbor_imprint_list;

      push_attributes_before_modify( bodies_sm_to_modify );
      //get all the child entities that have been merged
      get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
    }

    // note that preview actually gets handled before this point
    CubitStatus status = webcut_w_cylinder(engine_body_sms, radius, axis,
              center, neighbor_imprint_list, result_sm_list, imprint_type );

    if ( status != CUBIT_FAILURE )
    {
      if(!preview)
      {
        restore_vg_after_modify(result_sm_list, bodies_to_modify, gme);
        remove_pushed_attributes(result_sm_list, bodies_to_modify);
      }
      status = finish_webcut( engine_bodies, result_sm_list, merge, status,
                              results_list, &merged_surface_ids, &merged_curve_ids );
    }
    else
    {
      if(!preview)
        remove_pushed_attributes(result_sm_list, engine_bodies);
    }


    engine_bodies.clean_out();
    engine_body_sms.clean_out();
    result_sm_list.clean_out();

    if ( status == CUBIT_FAILURE )
    {
      rval = CUBIT_FAILURE;
      break;
    }
  }

  if(!preview)
    do_attribute_cleanup();

  if( CubitUndo::get_undo_enabled() )
  {
    if( rval == CUBIT_SUCCESS )
      CubitUndo::note_result_bodies( results_list );
    else
      CubitUndo::remove_last_undo();
  }

  return rval;
}
//*************************************************************************************************************************************
//-------------------------------------------------------------------------
// Purpose       : Webcut a body with a cone given the input parameters.
// Special Notes :
//
// Creator       : Ajoy
//
// Creation Date : 04/23/2012
//-------------------------------------------------------------------------
CubitStatus GeometryModifyTool::webcut_with_Cone(
                                       DLIList<Body*>& webcut_body_list,
                                       DLIList<BodySM*> &webcut_bodySM_list,
                                       double outer_radius,double inner_radius,
                                       CubitVector& AxisPt1,
                                       CubitVector& AxisPt2,
                                       DLIList<Body*>& results_list,
                                       DLIList<Body*> &neighboring_bodies,
                                       ImprintType imprint_type,
                                       CubitBoolean merge,
                                       CubitBoolean preview)
{
    if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
        return CUBIT_FAILURE;

    CubitStatus rval = CUBIT_SUCCESS;


    GfxPreview::clear();


    // find the height
    double dHeight  =  sqrt( (AxisPt2.x()-AxisPt1.x()) * (AxisPt2.x()-AxisPt1.x())+
                            (AxisPt2.y()-AxisPt1.y()) * (AxisPt2.y()-AxisPt1.y())+
                            (AxisPt2.z()-AxisPt1.z()) * (AxisPt2.z()-AxisPt1.z()) );

    // Find the Tan Angle
    double Diff        = fabs(outer_radius - inner_radius);
           Diff       /= dHeight;
    double dTanAngle   = atan ( Diff ) ;

    if (preview)
    {
        // find the bounding box for the cylinder
        CubitBox bounding_box;
        Body* body_ptr = webcut_body_list.get_and_step();
        bounding_box = body_ptr->bounding_box();

        int i;
        for( i=1; i<webcut_body_list.size(); i++ )
        {
            body_ptr = webcut_body_list.get_and_step();
            bounding_box |= body_ptr->bounding_box();
        }

        CubitVector axis;
        axis.x( AxisPt2.x()-AxisPt1.x() ); axis.y( AxisPt2.y()-AxisPt1.y() );
        axis.z( AxisPt2.z()-AxisPt1.z() );


        CubitVector start;
        CubitVector end;
        double dExtendedOuterRadius;
        double dExtendedInnerRadius;


        // Now extend the 2 end points to extend beyond the BBox limits. In case it converges, stop at the Apex.

         FindExtendedPoints( AxisPt1 , AxisPt2 , outer_radius , inner_radius , axis, dHeight , bounding_box ,
                             dTanAngle, start , end, dExtendedOuterRadius , dExtendedInnerRadius );

        int color = CUBIT_BLUE_INDEX;
        GfxPreview::draw_frustum(axis, start, end, dExtendedOuterRadius, dExtendedInnerRadius ,bounding_box , color);
        GfxPreview::flush();
        return rval;
    }

    if( CubitUndo::get_undo_enabled() )
    {
        DLIList<Body*> bodies_to_save;
        bodies_to_save += webcut_body_list;
        bodies_to_save += neighboring_bodies;
        CubitUndo::save_state_with_cubit_file( bodies_to_save );
    }

    const int count = webcut_body_list.size();
    DLIList<BodySM*> result_sm_list;
    DLIList<Body*> body_list(webcut_body_list);
    DLIList<BodySM*> engine_body_sms(count);
    DLIList<Body*> engine_bodies(count);
    GeometryModifyEngine* gme = 0;

    if(!preview)
        do_attribute_setup();

    while ( (gme = group_bodies_by_engine(webcut_body_list, engine_bodies, engine_body_sms)) )
    {
        //get all bodysms that we might modify in this operation
        DLIList<BodySM*> neighbor_imprint_list;
        DLIList<BodySM*> bodies_sm_to_modify;
        DLIList<Body*> bodies_to_modify;
        bodies_to_modify += engine_bodies;
        int i;
        for( i=neighboring_bodies.size(); i--; )
        {
            Body *tmp_body = neighboring_bodies.get_and_step();
            BodySM *tmp_body_sm = tmp_body->get_body_sm_ptr();
            if( gme == get_engine(tmp_body_sm ) )
            {
                neighbor_imprint_list.append( tmp_body_sm );
                bodies_to_modify.append( tmp_body );
            }
        }


        DLIList<BodySM*> Body_to_Cut_SM;

        for( i = 0 ;i<webcut_body_list.size(); i++  )
        {
            Body* body           = webcut_body_list.get_and_step();
            BodySM *Body_To_Cut  = body->get_body_sm_ptr();

            Body_to_Cut_SM.append( Body_To_Cut ) ;
        }



        DLIList<int> merged_surface_ids;
        DLIList<int> merged_curve_ids;

        if(!preview)
        {
            bodies_sm_to_modify += neighbor_imprint_list;

            push_attributes_before_modify( bodies_sm_to_modify );
            //get all the child entities that have been merged
            get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
        }


        // Get the overall bounding box of the bodies list
        Body* body_ptr = NULL;
        CubitBox bounding_box;
        if(body_list.size())
        {
            body_ptr  = body_list.get_and_step();
            bounding_box = body_ptr->bounding_box();
            for( i=1; i<webcut_body_list.size(); i++ )
            {
                body_ptr = body_list.get_and_step();
                bounding_box |= body_ptr->bounding_box();
            }
        }



        // Get the Geometry engine
        GeometryModifyEngine* gme =
            GeometryModifyTool::instance()->get_engine( body_ptr );


        //CubitStatus status = CreateCircularBody(webcut_body_list );

        CubitStatus status = CUBIT_SUCCESS;


        CubitVector axis;
        axis.x( AxisPt2.x()-AxisPt1.x() ); axis.y( AxisPt2.y()-AxisPt1.y() );
        axis.z( AxisPt2.z()-AxisPt1.z() );




        // Set The important deciders.

        bool bIfReverseAxis = false;
        if( outer_radius < inner_radius )
        {
            bIfReverseAxis = true;
        }


        //**************************************//
        // find the extension of the narrow end.
        //**************************************//

        // For this find the extended end point, at the smaller end
        // and assign zero radius, setting that point to be the AxisPt2.

        // Will be done only if outerRad is bigger than innerRad
        // Else set a bool to remember that, the inner_radius is set as the outer.

        CubitVector endpt ;
        if( outer_radius > inner_radius )
        {
            //EndPt  = FindExtendedEndPt( outer_radius , inner_radius , AxisPt2 , axis,  dHeight );


            double Diff     = (outer_radius - inner_radius);
            Diff    /= dHeight;
            double dAngle   = atan ( Diff ) ;
            axis.normalize();

            double dTan         = tan( dAngle );
            double dExtendvalue = inner_radius / dTan;

            endpt.x( ( axis.x() * dExtendvalue )  + AxisPt2.x() );
            endpt.y( ( axis.y() * dExtendvalue )  + AxisPt2.y() );
            endpt.z( ( axis.z() * dExtendvalue )  + AxisPt2.z() );



            dHeight = sqrt( (endpt.x() - AxisPt1.x()) * (endpt.x() - AxisPt1.x())+
                (endpt.y() - AxisPt1.y()) * (endpt.y() - AxisPt1.y())+
                (endpt.z() - AxisPt1.z()) * (endpt.z() - AxisPt1.z()) );

            AxisPt2.x( endpt.x() );
            AxisPt2.y( endpt.y() );
            AxisPt2.z( endpt.z() );
        }
        else
        {
            // reverse the axis.

            axis.x( -axis.x());
            axis.y( -axis.y());
            axis.z( -axis.z());

            //endpt  = FindExtendedendpt( inner_radius , outer_radius , AxisPt1 , axis,  dHeight );


            double Diff     = (inner_radius - outer_radius);
            Diff    /= dHeight;
            double dAngle   = atan ( Diff ) ;
            axis.normalize();

            double dTan        = tan( dAngle );
            double dExtendvalue = outer_radius / dTan;

            endpt.x( ( axis.x() * dExtendvalue )  + AxisPt1.x() );
            endpt.y( ( axis.y() * dExtendvalue )  + AxisPt1.y() );
            endpt.z( ( axis.z() * dExtendvalue )  + AxisPt1.z() );




            dHeight = sqrt( (endpt.x() - AxisPt2.x()) * (endpt.x() - AxisPt2.x())+
                (endpt.y() - AxisPt2.y()) * (endpt.y() - AxisPt2.y())+
                (endpt.z() - AxisPt2.z()) * (endpt.z() - AxisPt2.z()) );

            AxisPt1.x( endpt.x() );
            AxisPt1.y( endpt.y() );
            AxisPt1.z( endpt.z() );

             // reset the axis.

            axis.x( -axis.x());
            axis.y( -axis.y());
            axis.z( -axis.z());

        }



        //*****************************************//
        // Now find the extension of the bigger end.
        //*****************************************//

        //CubitVector EndPt ;
        double dExtendedRadius;
        if( outer_radius > inner_radius )
        {
            // reverse the axis.
            axis.x( -axis.x());
            axis.y( -axis.y());
            axis.z( -axis.z());


            //EndPt  = FindExtendedStartPt( bounding_box , outer_radius , inner_radius , AxisPt1 , axis,  dHeight , dTanAngle , dExtendedRadius );



            CubitVector Extended_Start_Pt;

            // Find the Difference between the Max and thre min values in all 3 directions.
            // Incase the point is within the box limits, then add the difference values
            // in all 3 directions , witht he " Axis " as the direction vector and extend the point.

            // After that find the Radius of this bigger end.

            CubitVector DiffVec;

            axis.normalize();

            DiffVec.x( fabs( bounding_box.max_x() - bounding_box.min_x() ));
            DiffVec.y( fabs( bounding_box.max_y() - bounding_box.min_y() ));
            DiffVec.z( fabs( bounding_box.max_z() - bounding_box.min_z() ));

            // Extend the start Pt

            Extended_Start_Pt.x( AxisPt1.x() + ( axis.x() * DiffVec.x() ) );
            Extended_Start_Pt.y( AxisPt1.y() + ( axis.y() * DiffVec.y() ) );
            Extended_Start_Pt.z( AxisPt1.z() + ( axis.z() * DiffVec.z() ) );


            // Find the length

            double dLength = sqrt( (( AxisPt1.x() - Extended_Start_Pt.x()) *  (AxisPt1.x() - Extended_Start_Pt.x()) ) +
                (( AxisPt1.y() - Extended_Start_Pt.y()) *  (AxisPt1.y() - Extended_Start_Pt.y()) ) +
                (( AxisPt1.z() - Extended_Start_Pt.z()) *  (AxisPt1.z() - Extended_Start_Pt.z()) ) );



            // Find the Extended Radius

            dExtendedRadius = outer_radius + ( tan( dTanAngle ) * dLength ) ;


            dHeight = sqrt( (Extended_Start_Pt.x() - AxisPt2.x()) * (Extended_Start_Pt.x() - AxisPt2.x())+
                (Extended_Start_Pt.y() - AxisPt2.y()) * (Extended_Start_Pt.y() - AxisPt2.y())+
                (Extended_Start_Pt.z() - AxisPt2.z()) * (Extended_Start_Pt.z() - AxisPt2.z()) );

            if( dExtendedRadius == 0 )
                dExtendedRadius = outer_radius;

            AxisPt1.x( Extended_Start_Pt.x() );
            AxisPt1.y( Extended_Start_Pt.y() );
            AxisPt1.z( Extended_Start_Pt.z() );

            // reverse the axis.
            axis.x( -axis.x());
            axis.y( -axis.y());
            axis.z( -axis.z());

        }
        else
        {
            //EndPt  = FindExtendedStartPt( bounding_box ,  inner_radius , outer_radius , AxisPt2 , axis,  dHeight , dTanAngle , dExtendedRadius );




            CubitVector Extended_Start_Pt;

            // Find the Difference between the Max and thre min values in all 3 directions.
            // Incase the point is within the box limits, then add the difference values
            // in all 3 directions , witht he " Axis " as the direction vector and extend the point.

            // After that find the Radius of this bigger end.

            CubitVector DiffVec;

            axis.normalize();

            DiffVec.x( fabs( bounding_box.max_x() - bounding_box.min_x() ));
            DiffVec.y( fabs( bounding_box.max_y() - bounding_box.min_y() ));
            DiffVec.z( fabs( bounding_box.max_z() - bounding_box.min_z() ));

            // Extend the start Pt

            Extended_Start_Pt.x( AxisPt2.x() + ( axis.x() * DiffVec.x() ) );
            Extended_Start_Pt.y( AxisPt2.y() + ( axis.y() * DiffVec.y() ) );
            Extended_Start_Pt.z( AxisPt2.z() + ( axis.z() * DiffVec.z() ) );


            // Find the length

            double dLength = sqrt( (( AxisPt2.x() - Extended_Start_Pt.x()) *  (AxisPt2.x() - Extended_Start_Pt.x()) ) +
                (( AxisPt2.y() - Extended_Start_Pt.y()) *  (AxisPt2.y() - Extended_Start_Pt.y()) ) +
                (( AxisPt2.z() - Extended_Start_Pt.z()) *  (AxisPt2.z() - Extended_Start_Pt.z()) ) );



            // Find the Extended Radius

            dExtendedRadius = inner_radius + ( tan( dTanAngle ) * dLength ) ;


            dHeight = sqrt( (Extended_Start_Pt.x() - AxisPt1.x()) * (Extended_Start_Pt.x() - AxisPt1.x())+
                (Extended_Start_Pt.y() - AxisPt1.y()) * (Extended_Start_Pt.y() - AxisPt1.y())+
                (Extended_Start_Pt.z() - AxisPt1.z()) * (Extended_Start_Pt.z() - AxisPt1.z()) );

            AxisPt2.x( Extended_Start_Pt.x() );
            AxisPt2.y( Extended_Start_Pt.y() );
            AxisPt2.z( Extended_Start_Pt.z() );

            if( dExtendedRadius == 0 )
                dExtendedRadius = outer_radius;

        }



        //Create the cylinder

        BodySM* bodySM_Ptr = NULL;
        outer_radius       = dExtendedRadius;
        inner_radius       = 0;
        bodySM_Ptr         = gmeList.get()->cylinder( dHeight, outer_radius, outer_radius, inner_radius );


        if( !bodySM_Ptr )
        {
            return CUBIT_FAILURE;
        }


        DLIList<Curve*> curve_list;

        bodySM_Ptr->curves(curve_list);

        // infor for the Frustum Axis

        CubitVector Frustum_Axis;

        Frustum_Axis.x(0);
        Frustum_Axis.y(0);
        Frustum_Axis.z(dHeight);




        if( bIfReverseAxis )
            axis.z( -axis.z() );


        // Get Cross product for the resultant vector, which will be the axis for rotation
        CubitVector cross;
        cross = Frustum_Axis * axis;


        // 2. Find the Angle Between them
        CubitVector Angle;
        double dAngle  = Angle.vector_angle( Frustum_Axis , axis );



        //Now find the angle and the axis to rotate about...

        dAngle = 180.0*dAngle/CUBIT_PI;

        if( bIfReverseAxis )
            dAngle = 360 - dAngle ;



        // 3. Rotate the body for the received cross product axis ( cross ) as the axis
        // and for the angle, dAngle
        //GeometryQueryTool::instance()->rotate( cutting_tool_ptr , cross , dAngle );

        GeometryQueryEngine* engine = bodySM_Ptr->get_geometry_query_engine();
        CubitStatus result = engine->rotate( bodySM_Ptr, cross, dAngle );


        // 4. Now find the mid-point of the specified 2 vertices, and assign that as the
        //    2'nd parameter, for the Pt at which the center of the, created frustum should lie.

        CubitVector Pt;
        Pt.x( (AxisPt1.x() + AxisPt2.x() )/2  );
        Pt.y( (AxisPt1.y() + AxisPt2.y() )/2  );
        Pt.z( (AxisPt1.z() + AxisPt2.z() )/2  );



        // 5 . Now move the body to the location of the target_center.

        CubitTransformMatrix xform;
        xform.translate( Pt );
        result = engine->translate( bodySM_Ptr, Pt );




        if (!result )
        {
            if(!preview)
            {
                restore_vg_after_modify(result_sm_list, bodies_to_modify, gme);
                remove_pushed_attributes(result_sm_list, bodies_to_modify);
            }
            status = finish_webcut( engine_bodies, result_sm_list, merge, status,
                results_list, &merged_surface_ids, &merged_curve_ids );
        }
        else
        {
            if(!preview)
                remove_pushed_attributes(result_sm_list, engine_bodies);
        }

        if ( !result )
        {
            rval = CUBIT_FAILURE;
            engine_bodies.clean_out();
            engine_body_sms.clean_out();
            result_sm_list.clean_out();
            return rval;
        }

        DLIList<BodySM*> results_list_SM;
        DLIList<BodySM*> neighboring_bodies_SM;
        // Use the BODY to perform webcut
        rval = gme->webcut(engine_body_sms, bodySM_Ptr,
            neighboring_bodies_SM, results_list_SM, imprint_type, preview );

        if( GeometryQueryTool::instance()->history().is_tracking() )
        {
            if( rval == CUBIT_SUCCESS )
            {
                gme->get_gqe()->delete_solid_model_entities(bodySM_Ptr);
            }
        }

        // if we're doing the real thing (not preview) finish the process
        if (!preview)
        {
            restore_vg_after_modify(results_list_SM, body_list, gme);
            remove_pushed_attributes(results_list_SM, body_list);
            rval = finish_webcut( bodies_to_modify, results_list_SM, merge,
                rval, results_list);
            do_attribute_cleanup();

            //GeometryQueryTool::instance()->delete_Body( cutting_tool_ptr );
            GeometryQueryEngine* gqe = bodySM_Ptr->get_geometry_query_engine();
            gqe->delete_solid_model_entities(bodySM_Ptr);
        }

        if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
        {
            if( rval == CUBIT_SUCCESS )
                CubitUndo::note_result_bodies( results_list );
            else
                CubitUndo::remove_last_undo();
        }

        engine_bodies.clean_out();
        engine_body_sms.clean_out();
        result_sm_list.clean_out();
    }
    return rval;
}
//************************************************************************************************************************************************************
void GeometryModifyTool::do_attribute_setup(void)
{
  //save attribute settings
  CGMApp::instance()->save_current_attribute_states();

  //Turn off all attributes
  CubitAttribManager *attrib_manager = CGMApp::instance()->attrib_manager();
  attrib_manager->set_all_auto_update_flags( CUBIT_FALSE );
  attrib_manager->set_all_auto_actuate_flags( CUBIT_FALSE );
  attrib_manager->set_all_auto_write_flags( CUBIT_FALSE );
  attrib_manager->set_all_auto_read_flags( CUBIT_FALSE );

  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_ENTITY_NAME, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_ENTITY_NAME, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_ENTITY_NAME, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_ENTITY_NAME, CUBIT_TRUE);

  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_MESH_OUTPUT_GROUP, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_MESH_OUTPUT_GROUP, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_MESH_OUTPUT_GROUP, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_MESH_OUTPUT_GROUP, CUBIT_TRUE);


  // enable update, actuate, write, read for composite attributes
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_COMPOSITE_VG, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_COMPOSITE_VG, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_COMPOSITE_VG, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_COMPOSITE_VG, CUBIT_TRUE);
  // enable update, actuate, write, read for partition attributes
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_PARTITION_VG, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_PARTITION_VG, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_PARTITION_VG, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_PARTITION_VG, CUBIT_TRUE);
  // enable update, actuate, write, read for entity ids
  // We will use these ID atts to make sure the ref entities associated with unmodified
  // virtual bridges will maintain the same ids after real operations.
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_ENTITY_ID, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_ENTITY_ID, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_ENTITY_ID, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_ENTITY_ID, CUBIT_TRUE);
  // enable metadata attributes
  CGMApp::instance()->attrib_manager()->set_auto_update_flag(CA_ASSEMBLY_DATA, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_actuate_flag(CA_ASSEMBLY_DATA, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_write_flag(CA_ASSEMBLY_DATA, CUBIT_TRUE);
  CGMApp::instance()->attrib_manager()->set_auto_read_flag(CA_ASSEMBLY_DATA, CUBIT_TRUE);
}

void GeometryModifyTool::do_attribute_cleanup(void)
{

  CGMApp::instance()->restore_previous_attribute_states();
}

// Pushes virtual geometry and boundary condition
//attributes down to the underlying solid model topology
void GeometryModifyTool::push_attributes_before_modify(DLIList<BodySM*> &old_sms)
{
  // Get all of the ref entities involved and push CA_ENTITY_ID attributes
  // on to them.  This will help us maintain ids on virtual that doesn't
  // get modified by the real operation.
  int i;
  DLIList<RefVolume*> volume_list;

  for(i=old_sms.size(); i--;)
  {
    BodySM *bsm = old_sms.get_and_step();
    Body *body = dynamic_cast<Body*>(bsm->topology_entity());
    if(body)
    {
      // Append to the total list of volumes.
      body->ref_volumes(volume_list);
    }
  }
  // get all child entities (only get entities below volumes)
  DLIList<RefEntity*> child_list, ref_ent_list;
  CAST_LIST_TO_PARENT(volume_list, ref_ent_list);
  RefEntity::get_all_child_ref_entities( ref_ent_list, child_list );

  //by including the volumes we can propagate the bcs on them
  //across webcuts
  child_list+=ref_ent_list;


  // Only push the id attributes if we are doing persistent ids.
  if(!get_new_ids())
    CubitAttribUser::auto_update_cubit_attrib(child_list);

  DLIList<TopologyBridge*> top_bridges;
  CAST_LIST_TO_PARENT(old_sms, top_bridges);
  GeometryQueryTool::instance()->ige_export_geom(top_bridges);
}

// Push imprint specific attributes down to the underlying solid model
// topology prior to imprinting.
void GeometryModifyTool::push_imprint_attributes_before_modify(DLIList<BodySM*> &body_sms)
{
  GeometryQueryTool::instance()->ige_push_imprint_attributes_before_modify(body_sms);
}

void GeometryModifyTool::push_named_attributes_to_curves_and_points(DLIList<TopologyBridge*> &tb_list,
                                                             const char *name_in)
{
  GeometryQueryTool::instance()->ige_push_named_attributes_to_curves_and_points(tb_list, name_in);
}

// Cleanup imprint attributes that were pushed onto the underlying solid
// model topology.
void GeometryModifyTool::remove_imprint_attributes_after_modify(DLIList<BodySM*> &old_sms,
                                                                DLIList<BodySM*> &new_sms)
{
  GeometryQueryTool::instance()->ige_remove_imprint_attributes_after_modify(old_sms, new_sms);
}

#ifdef CAT
CubitStatus GeometryModifyTool::webcut_across_translate(
                                          DLIList<Body*> &webcut_body_list,
                                          RefFace *ref_face_top,
                                          RefFace *ref_face_bottom,
                                          DLIList<Body*> &results_list,
                                          ImprintType imprint_type,
                                          CubitBoolean merge,
                                          CubitBoolean preview)
{
  if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
    return CUBIT_FAILURE;

  DLIList<Body*> original_body_list = webcut_body_list;
  const int count = webcut_body_list.size() + 2;
  DLIList<TopologyEntity*> entity_list(count);
  DLIList<TopologyBridge*> bridge_list(count);
  CAST_LIST_TO_PARENT(webcut_body_list, entity_list);
  entity_list.append( ref_face_top );
  entity_list.append( ref_face_bottom );
  GeometryModifyEngine* gme = common_modify_engine( entity_list, bridge_list );

  if ( !gme )
  {
     PRINT_ERROR("Performing WEBCUTS on volumes containing geometry from\n"
                 "different modeling engines is not allowed.\n"
                 "Delete uncommon geometry on these volumes before operation.\n\n");
     return CUBIT_FAILURE;
  }

  Surface* surface_bottom = dynamic_cast<Surface*>(bridge_list.pop());
  Surface* surface_top    = dynamic_cast<Surface*>(bridge_list.pop());
  DLIList<BodySM*> result_sm_list, webcut_sm_list(bridge_list.size());
  CAST_LIST(bridge_list, webcut_sm_list, BodySM);

  if (!preview)
  {
    do_attribute_setup();
    push_attributes_before_modify(webcut_sm_list);
  }

  DLIList<BodySM*> neighbor_list;
  CubitStatus result_val = gme->webcut_across_translate (
    webcut_sm_list, surface_top, surface_bottom, result_sm_list, neighbor_list, imprint_type, preview );

  // if we're doing the real thing (not preview) finish the process
  if (!preview)
  {
    restore_vg_after_modify(result_sm_list, original_body_list, gme);
    remove_pushed_attributes(result_sm_list, original_body_list);
    result_val = finish_webcut( webcut_body_list, result_sm_list, merge,
                                result_val, results_list);
    do_attribute_cleanup();
  }

  return result_val;
}
#endif

//-------------------------------------------------------------------------
// Purpose       : This functions webcuts a list of bodies using a loop
//                 of curves
//
// Special Notes :
//
// Creator       : Eric W. Nielsen
//
// Creation Date : 12/20/99
//-------------------------------------------------------------------------
CubitStatus GeometryModifyTool::webcut_with_curve_loop(
                                         DLIList<Body*>& webcut_body_list,
                                         DLIList<RefEdge*>& refedge_list,
                                         DLIList<Body*>& results_list,
                                         DLIList<Body*> &neighboring_bodies,
                                         ImprintType imprint_type,
                                         CubitBoolean merge,
                                         CubitBoolean preview)

{
  if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
    return CUBIT_FAILURE;

  GfxPreview::clear();

   int i;
   const int count = webcut_body_list.size() + refedge_list.size();
   DLIList<TopologyEntity*> entity_list(count);
   DLIList<TopologyBridge*> bridge_list(count);
   CAST_LIST_TO_PARENT(webcut_body_list, entity_list);
   refedge_list.reset();
   for (i = refedge_list.size(); i--; )
     entity_list.append(refedge_list.get_and_step());
   GeometryModifyEngine* gme = common_modify_engine( entity_list, bridge_list );

   if ( !gme )
   {
      PRINT_ERROR("Performing WEBCUTS on volumes containing geometry from\n"
                  "different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

   if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
   {
     DLIList<Body*> bodies_to_save;
     bodies_to_save += webcut_body_list;
     bodies_to_save += neighboring_bodies;
     CubitUndo::save_state_with_cubit_file( bodies_to_save );
   }

   DLIList<BodySM*> body_sm_list(webcut_body_list.size()), result_sm_list;
   DLIList<Curve*> curve_list(refedge_list.size());
   CAST_LIST(bridge_list, body_sm_list, BodySM);
   CAST_LIST(bridge_list, curve_list, Curve);
   assert(body_sm_list.size() == webcut_body_list.size());
   assert(curve_list.size() == refedge_list.size());

   DLIList<int> merged_surface_ids;
   DLIList<int> merged_curve_ids;
   DLIList<BodySM*> neighbor_imprint_list;
   DLIList<Body*> bodies_to_modify;

   //make copies of the curves.
   DLIList<Curve*> copied_curves;
   Curve* temp_curve = NULL;
   for (int i = curve_list.size(); i--;)
     {
       temp_curve = gme->make_Curve(curve_list.get_and_step());
       if(temp_curve != NULL)
         copied_curves.append(temp_curve);
     }

   //make a face out of the curves
   Surface * surf = gme->make_Surface(PLANE_SURFACE_TYPE, copied_curves, NULL, false );
   if (surf == NULL)
     {
       PRINT_ERROR("webcut tool surface is not created from occ.\n");
       return CUBIT_FAILURE;
     }


   //get cutting tool BodySM.
   BodySM* cutting_tool_ptr = gme->make_BodySM(surf);
   assert(cutting_tool_ptr );

   if (!preview)
   {
     int i;
     for( i=neighboring_bodies.size(); i--; )
     {
       Body *neighbor_body = neighboring_bodies.get_and_step();
       BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
       GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

       if( gme == neighbor_gme )
         neighbor_imprint_list.append( tmp_body );
     }

     do_attribute_setup();
     DLIList<BodySM*> bodies_sm_to_modify;
     bodies_sm_to_modify += body_sm_list;
     bodies_sm_to_modify += neighbor_imprint_list;
     push_attributes_before_modify( bodies_sm_to_modify );
     bodies_to_modify += webcut_body_list;
     bodies_to_modify += neighboring_bodies;
     get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
   }


   CubitStatus result_val = gme->webcut(
                     body_sm_list, cutting_tool_ptr,
                     neighbor_imprint_list,
                     result_sm_list,
                     imprint_type, preview) ;

   // Delete the BodySM that was created to be used as a tool
   gme->get_gqe()->delete_solid_model_entities(cutting_tool_ptr) ;

   // finish up if we're doing the real thing
   if (!preview)
   {
     restore_vg_after_modify(result_sm_list, bodies_to_modify, gme);
     remove_pushed_attributes(result_sm_list, bodies_to_modify);

     result_val = finish_webcut( webcut_body_list, result_sm_list, merge,
                                 result_val, results_list,
                                 &merged_surface_ids, &merged_curve_ids );
     do_attribute_cleanup();
   }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( result_val == CUBIT_SUCCESS )
      CubitUndo::note_result_bodies( results_list );
    else
      CubitUndo::remove_last_undo();
  }

   return result_val;
}

//-------------------------------------------------------------------------
// Purpose       : This functions webcuts a list of bodies through a plane
//                 defined by a refFace. The newly created bodies are
//                 merged and imprinted depeding on the respective flags.
//
// Special Notes :
//
// Creator       : Raikanta Sahu
//
// Creation Date : 12/16/96
//-------------------------------------------------------------------------

CubitStatus GeometryModifyTool::webcut_with_surface(
                                      DLIList<Body*>& webcut_body_list,
                                      RefFace* refFace,
                                      DLIList<Body*>& results_list,
                                      DLIList<Body*> &neighboring_bodies,
                                      ImprintType imprint_type,
                                      CubitBoolean merge,
                                      CubitBoolean preview)
{
  //make sure that this refface is planar, or you'll get unexpected results
  if( refFace->geometry_type() != PLANE_SURFACE_TYPE )
  {
    PRINT_ERROR("Surface %d is not planar.\n", refFace->id() );
    return CUBIT_FAILURE;
  }

     // Using the face, get three positions (CubitVectors :) :) )
     // The positions can be used by a GeometryModifyEngine to generate its
     // own webcutting tool and perform the webcut.
   CubitVector vector1 = refFace->position_from_u_v(0, 1) ;
   CubitVector vector3 = refFace->position_from_u_v(1, 0) ;
   CubitVector vector2 = refFace->position_from_u_v(0, 0) ;

   CubitStatus result_val = this->webcut_with_plane(webcut_body_list, vector1,
                                  vector2, vector3, results_list, neighboring_bodies,
                                  imprint_type, merge, preview) ;

   return result_val;
}

//-------------------------------------------------------------------------
// Purpose       : This functions webcuts a list of bodies using a plane
//                 defined by a refFace. The newly created bodies are
//                 merged and imprinted depending on the respective flags.
//
// Special Notes :
//
// Creator       : Raikanta Sahu
//
// Creation Date : 12/16/96
//-------------------------------------------------------------------------

CubitStatus GeometryModifyTool::webcut_with_body(
                                   DLIList<Body*>& webcut_body_list,
                                   Body* tool_body,
                                   DLIList<Body*>& results_list,
                                   DLIList<Body*> &neighboring_bodies,
                                   ImprintType imprint_type,
                                   CubitBoolean merge,
                                   CubitBoolean preview)
{

  CubitStatus ret;

  if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
    return CUBIT_FAILURE;

  CubitBox tool_bounding_box = tool_body->bounding_box();
  remove_bodies_outside_bounding_box( webcut_body_list, tool_bounding_box );

  if( webcut_body_list.size() == 0 )
  {
    PRINT_INFO("Tool does not intersect any bodies/volumes.\n");
    return CUBIT_FAILURE;
  }

  DLIList<BodySM*> body_sm_list(webcut_body_list.size()), result_sm_list;
  BodySM* tool_sm = tool_body->get_body_sm_ptr();
  GeometryModifyEngine* gme = 0;
  if (!tool_sm || !(gme = get_engine(tool_sm)))
  {
    PRINT_DEBUG_153("No modify engine available for body %d.\n", tool_body->id());
    PRINT_ERROR("No modify engine available for volume %d.\n", tool_body->ref_volume()->id());
    return CUBIT_FAILURE;
  }

  webcut_body_list.reset();
  int i;
  for (i = webcut_body_list.size(); i--; )
  {
    Body* body_ptr = webcut_body_list.get_and_step();
    BodySM* sm_ptr = body_ptr->get_body_sm_ptr();
    if (!sm_ptr || get_engine(sm_ptr) != gme)
    {
      PRINT_DEBUG_153("ERROR: Body %d does not belong to the same geometric engine "
                  "as body %d\n", body_ptr->id(), tool_body->id());
      PRINT_ERROR("Volume %d does not belong to the same geometric engine "
                  "as volume %d\n", body_ptr->ref_volume()->id(), tool_body->ref_volume()->id());
      return CUBIT_FAILURE;
    }

    body_sm_list.append(sm_ptr);
  }

  DLIList<int> merged_surface_ids;
  DLIList<int> merged_curve_ids;
  DLIList<BodySM*> neighbor_imprint_list;
  DLIList<Body*> bodies_to_modify;

  if (!preview)
  {
    if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
    {
      DLIList<Body*> bodies_to_save;
      bodies_to_save += webcut_body_list;
      bodies_to_save += neighboring_bodies;
      CubitUndo::save_state_with_cubit_file( bodies_to_save );
    }

    int i;
    for( i=neighboring_bodies.size(); i--; )
    {
      Body *neighbor_body = neighboring_bodies.get_and_step();
      BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
      GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

      if( gme == neighbor_gme )
        neighbor_imprint_list.append( tmp_body );
    }

    do_attribute_setup();
    DLIList<BodySM*> bodies_sm_to_modify;
    bodies_sm_to_modify += body_sm_list;
    bodies_sm_to_modify += neighbor_imprint_list;
    push_attributes_before_modify( bodies_sm_to_modify );
    bodies_to_modify += webcut_body_list;
    bodies_to_modify += neighboring_bodies;
    get_merged_curve_and_surface_ids( bodies_to_modify, merged_surface_ids, merged_curve_ids );
  }


  int count = gme->webcut(body_sm_list, tool_sm,
                          neighbor_imprint_list,
                          result_sm_list, imprint_type, preview);

  // finish up if we're doing the real thing
  if (!preview)
  {
    restore_vg_after_modify(result_sm_list, bodies_to_modify, gme);
    remove_pushed_attributes(result_sm_list, bodies_to_modify );

    ret = finish_webcut(webcut_body_list, result_sm_list, merge,
                          count > 0 ? CUBIT_SUCCESS : CUBIT_FAILURE,
                          results_list, &merged_surface_ids, &merged_curve_ids );

    do_attribute_cleanup();
  }
  else
    ret = count > 0 ? CUBIT_SUCCESS : CUBIT_FAILURE;

  if( preview == CUBIT_FALSE && CubitUndo::get_undo_enabled() )
  {
    if( ret == CUBIT_SUCCESS )
      CubitUndo::note_result_bodies( results_list );
    else
      CubitUndo::remove_last_undo();
  }

  return ret;
}

CubitStatus GeometryModifyTool::section(
                                   DLIList<Body*> &section_body_list,
                                   const CubitVector &point_1,
                                   const CubitVector &point_2,
                                   const CubitVector &point_3,
                                   DLIList<Body*> &new_body_list,
                                   CubitBoolean keep_normal_side,
                                   CubitBoolean keep_old )
{
  if( section_body_list.size() == 0 )
    return CUBIT_FAILURE;

  if (!okay_to_modify( section_body_list, "SECTION" ))
    return CUBIT_FAILURE;
   CubitStatus rval = CUBIT_SUCCESS;

   const int count = section_body_list.size();
   DLIList<BodySM*> result_sm_list;
   DLIList<Body*> body_list(section_body_list);
   DLIList<BodySM*> engine_body_sms(count);
   DLIList<Body*> engine_bodies(count);
   GeometryModifyEngine* gme = 0;

   if( CubitUndo::get_undo_enabled() )
   {
     if( keep_old )
       CubitUndo::save_state();
     else
       CubitUndo::save_state_with_cubit_file( section_body_list );
   }

   while ( (gme = group_bodies_by_engine(body_list, engine_bodies, engine_body_sms)) )
   {
      //get all the child entities that have been merged
      DLIList<int> merged_surface_ids;
      DLIList<int> merged_curve_ids;
      get_merged_curve_and_surface_ids( engine_bodies, merged_surface_ids, merged_curve_ids );

      CubitStatus result = gme->section( engine_body_sms,
                                         point_1, point_2, point_3,
                                         result_sm_list,
                                         keep_normal_side, keep_old );

      if (!finish_sm_op( engine_bodies, result_sm_list, new_body_list ))
        result = CUBIT_FAILURE;
      if (!result)
        rval = CUBIT_FAILURE;

      if( merged_surface_ids.size() || merged_curve_ids.size() )
        fixup_merged_entities( merged_surface_ids, merged_curve_ids);

      engine_body_sms.clean_out();
      engine_bodies.clean_out();
      result_sm_list.clean_out();
   }

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body_list.size() ) //if there are new bodies...something succeeded
      CubitUndo::note_result_bodies( new_body_list );
    else
      CubitUndo::remove_last_undo();
  }

   return rval;
}

CubitStatus
GeometryModifyTool::offset_curves( DLIList<RefEdge*>& ref_edge_list,
                                   DLIList<RefEdge*>& output_edge_list,
                                   double offset_distance,
                                   const CubitVector& offset_direction,
                                   int gap_type )
{
  // Make sure all curves are from same geometry engine
  DLIList<TopologyEntity*> entity_list(ref_edge_list.size());
  DLIList<TopologyBridge*> bridge_list(ref_edge_list.size());
  CAST_LIST_TO_PARENT(ref_edge_list, entity_list);
  GeometryModifyEngine* gme_ptr = common_modify_engine(entity_list, bridge_list);
  if ( !gme_ptr )
  {
    PRINT_ERROR("Can't create offset curves that don't all originate from same\n"
      "       modeling engine.\n");
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  DLIList<Curve*> curve_list(bridge_list.size()), result_list;
  CAST_LIST(bridge_list, curve_list, Curve);
  assert(curve_list.size() == ref_edge_list.size());

  CubitStatus rval = gme_ptr->offset_curves( curve_list, result_list,
                        offset_distance, offset_direction, gap_type );
  assert( rval || !result_list.size() );
  result_list.reset();

  DLIList<RefEntity*> created_edges;
  output_edge_list.clean_out();
  for (int i = result_list.size(); i--; )
  {
    RefEdge *new_edge = GeometryQueryTool::instance()->make_free_RefEdge(result_list.get_and_step());
    created_edges.append( new_edge );
    output_edge_list.append( new_edge );
  }

  if( CubitUndo::get_undo_enabled() )
  {
    if( created_edges.size() )
      CubitUndo::note_result_entities( created_edges );
    else
      CubitUndo::remove_last_undo();
  }

  return rval;
}

// Compute the transformation requried to align my_face with target_face
// with respecct to reference_body_ptr.  Then perform the transformation
// on all entities in entities_to_move
CubitStatus GeometryModifyTool::align_entities( RefFace *source_face,  
  RefFace *target_face,
  DLIList<RefEntity*> &entities_to_move,
  bool reverse,
  CubitVector &my_center,
  CubitVector &axis_of_rot,
  CubitVector &target_center,
  double &angle,
  bool preview)
{
  // Initialize angle to zero, so we are passing back a valid
  // value if we never need to rotate the body
  angle = 0.0;

  //Align the body, which contains my_face, with the target_face.

  //Essentially we want to align the body at my_face with the target_face.
  my_center = source_face->center_point();
  target_center = target_face->center_point();
  
  CubitVector my_vector = source_face->normal_at( my_center );
  CubitVector target_vector = target_face->normal_at( target_center );

  if( CubitUndo::get_undo_enabled() && !preview )
  {
    DLIList<RefEntity*> free_ents_to_save;
    DLIList<Body*> align_list(entities_to_move.size());
    for ( int k=0; k<entities_to_move.size(); k++ )
    {
      RefEntity *ref_ent = entities_to_move[k];      
      Body *tmp_body = dynamic_cast<Body*>(ref_ent);
      if( tmp_body )       
        align_list.append( tmp_body );              
      else
        free_ents_to_save.append( ref_ent );       
    }     
    CubitUndo::save_state_with_cubit_file( align_list, &free_ents_to_save );
  }

  axis_of_rot = my_vector * target_vector;

  if( axis_of_rot.length() < CUBIT_RESABS )  
  {
    CubitVector v1,v2;
    my_vector.orthogonal_vectors(v1, v2 );
    axis_of_rot = v1;    
  }

  if( axis_of_rot.length() > CUBIT_RESABS )
  {
    angle = axis_of_rot.vector_angle( my_vector, target_vector );

    //Now we have the angle and the axis to rotate about...
    angle = 180.0*angle/CUBIT_PI;
    
    if( angle > 90 )
      angle = angle - 180;

    if( reverse )
      angle += 180;
  }
  CubitVector origin(0.,0.,0.);

  if (preview)
  {    
    preview_align( -my_center, target_center, angle, axis_of_rot, entities_to_move );     
  }
  else 
  {   
    //Move the body so that the center of my_face
    //is at the origin.   
    DLIList<RefEntity*> entities_transformed;
    GeometryQueryTool::instance()->translate( entities_to_move,
      -my_center.x(),
      -my_center.y(),
      -my_center.z(),
      false,
      entities_transformed);

    //If the axis length is zero we dont want to do a rotation,
    //they are already parallel..  
    if (axis_of_rot.length() > CUBIT_RESABS )
    {    
      //Now rotate the body about the axis.
      GeometryQueryTool::instance()->rotate(entities_to_move, origin, 
        axis_of_rot, angle, false, entities_transformed,
        false);
    }
    //Now move the body to the location of the target_center.    
    GeometryQueryTool::instance()->translate( entities_to_move,
      target_center.x(),
      target_center.y(),
      target_center.z(),
      false,
      entities_transformed,
      preview);
  }

  //That should do it.
  return CUBIT_SUCCESS;
}

CubitStatus GeometryModifyTool::align_entities( DLIList<RefEntity*> &entities_to_align,
                                           CubitVector &pos_to_align,
                                           CubitVector &pos_to_align_to,
                                           CubitVector &axis_origin,
                                           CubitVector &axis_of_rot,
                                           double &angle_of_rotation,
                                           bool preview)
{
  //project pos_to_align to axis
  axis_of_rot.normalize();
  CubitVector tmp_vec = pos_to_align - axis_origin;  
  double dot_prod = tmp_vec%axis_of_rot;
  CubitVector int_pt1 = axis_origin + (dot_prod*axis_of_rot);

  //project pos_to_align_to to axis
  tmp_vec = pos_to_align_to - axis_origin;  
  dot_prod = tmp_vec%axis_of_rot;
  CubitVector int_pt2 = axis_origin + (dot_prod*axis_of_rot);

  //determine angle of rotation
  tmp_vec = pos_to_align - int_pt1;
  CubitVector tmp_vec2 = pos_to_align_to - int_pt2;
  angle_of_rotation = axis_of_rot.vector_angle( tmp_vec, tmp_vec2 );
  angle_of_rotation *= 180.0/CUBIT_PI;
  
  if( angle_of_rotation < CUBIT_RESABS )
  {
    PRINT_WARNING("Points already aligned.\n");
    return CUBIT_SUCCESS;
  }

  if( CubitUndo::get_undo_enabled() && !preview )
  {
    DLIList<RefEntity*> free_ents_to_save;
    DLIList<Body*> align_list(entities_to_align.size());
    for ( int k=0; k<entities_to_align.size(); k++ )
    {
      RefEntity *ref_ent = entities_to_align[k];      
      Body *tmp_body = dynamic_cast<Body*>(ref_ent);
      if( tmp_body )       
        align_list.append( tmp_body );              
      else
        free_ents_to_save.append( ref_ent );       
    }     
    CubitUndo::save_state_with_cubit_file( align_list, &free_ents_to_save );
  }

  CubitVector translation_vector( int_pt1 );

  if( preview )
  {    
    preview_align( -translation_vector, translation_vector, 
      angle_of_rotation, axis_of_rot, entities_to_align );     
  }
  else
  {
    //translate to origin
    DLIList<RefEntity*> entities_transformed;
    GeometryQueryTool::instance()->translate( entities_to_align,
      -translation_vector.x(),
      -translation_vector.y(),
      -translation_vector.z(),
      false,
      entities_transformed);

    //rotate to align
    CubitVector origin(0,0,0);
    GeometryQueryTool::instance()->rotate( entities_to_align, origin, axis_of_rot, angle_of_rotation, false, 
      entities_transformed, false );

    //translate back
    GeometryQueryTool::instance()->translate( entities_to_align,
      translation_vector.x(),
      translation_vector.y(),
      translation_vector.z(),
      false,
      entities_transformed);      
  }

  //That should do it.
  return CUBIT_SUCCESS;  
}

CubitStatus GeometryModifyTool::align_entities( DLIList<RefEntity*>& reference_entities,
                                                DLIList<RefEntity*> &entities_to_move,
                                                CubitVector align_to_vec,                                                 
                                                CubitVector &my_center,                                           
                                                CubitVector &axis_of_rot,
                                                double &angle,                                           
                                                bool preview)
{
   DLIList<RefFace*> ref_face_list;
   DLIList<RefVertex*> ref_vertex_list;

   CAST_LIST(reference_entities, ref_face_list, RefFace);
   CAST_LIST(reference_entities, ref_vertex_list, RefVertex);

   angle = 0.0;   

   CubitVector translation_vector;
   CubitVector axis_of_rotation;
   CubitVector vector_to_rotate;

   if( ref_face_list.size() == 1 &&
       ref_vertex_list.size() == 0 )
   {   
     //now form the axis of rotation
     RefFace *my_face = ref_face_list.get_and_step();
     translation_vector = my_face->center_point();     
     my_center = translation_vector;
     vector_to_rotate = my_face->normal_at( translation_vector );     
     axis_of_rot = align_to_vec * vector_to_rotate;
   }
   else if( ref_face_list.size() == 0 &&
            ref_vertex_list.size() == 2 )
   {
     RefVertex *vertex_1 = ref_vertex_list.get_and_step();
     RefVertex *vertex_2 = ref_vertex_list.get_and_step();     

     //now form the axis of rotation
     translation_vector = vertex_1->coordinates();
     my_center = vertex_1->coordinates();     
     vector_to_rotate = vertex_2->coordinates() - vertex_1->coordinates();     
     axis_of_rot = align_to_vec * vector_to_rotate;
   }   

   if( axis_of_rot.length() < CUBIT_RESABS )  
   {
    double dot_prod = align_to_vec%vector_to_rotate;
    //normals could be 180 degrees from one another
    if( dot_prod < 0 ) 
    {
      CubitVector v1,v2;
      align_to_vec.orthogonal_vectors(v1, v2 );
      axis_of_rot = v1;
    }
  }

   if( CubitUndo::get_undo_enabled() && !preview )
   {
     DLIList<RefEntity*> free_ents_to_save;
     DLIList<Body*> align_list(entities_to_move.size());
     for ( int k=0; k<entities_to_move.size(); k++ )
     {
       RefEntity *ref_ent = entities_to_move[k];      
       Body *tmp_body = dynamic_cast<Body*>(ref_ent);
       if( tmp_body )       
         align_list.append( tmp_body );              
       else
         free_ents_to_save.append( ref_ent );       
     }     
     CubitUndo::save_state_with_cubit_file( align_list, &free_ents_to_save );
   }

   //determine the angle of rotation   
   angle = axis_of_rot.vector_angle( vector_to_rotate, align_to_vec );
   angle = 180.0*angle/CUBIT_PI;

   if( preview )
   {
     preview_align( -translation_vector, translation_vector, 
                  angle, axis_of_rot, entities_to_move );     
   }
   else
   {
     //translate to origin
     DLIList<RefEntity*> entities_transformed;
     GeometryQueryTool::instance()->translate( entities_to_move,
       -translation_vector.x(),
       -translation_vector.y(),
       -translation_vector.z(),
       false,
       entities_transformed);

     //rotate to align
     CubitVector origin(0,0,0);
     GeometryQueryTool::instance()->rotate( entities_to_move, origin, axis_of_rot, angle, false, 
       entities_transformed, false );

     //translate back
     GeometryQueryTool::instance()->translate( entities_to_move,
       translation_vector.x(),
       translation_vector.y(),
       translation_vector.z(),
       false,
       entities_transformed);      
   }

   //That should do it.
   return CUBIT_SUCCESS;  
}

void GeometryModifyTool::preview_align( CubitVector translation_to_origin,
                                        CubitVector origin_to_target,
                                        double angle_of_rotation,
                                        CubitVector axis_of_rotation,
                                        DLIList<RefEntity*> &entities )
{
  CubitTransformMatrix prev_xform;
  prev_xform.translate(translation_to_origin);

  CubitTransformMatrix rot_mat;
  rot_mat.rotate( angle_of_rotation, axis_of_rotation );

  CubitTransformMatrix mov_mat;
  mov_mat.translate( origin_to_target );

  for( int k=0; k<entities.size(); k++ )
  {
    RefEntity *tmp_ent = entities[k];           
    TopologyEntity *te = dynamic_cast<TopologyEntity*>(tmp_ent);
    if( NULL == te )
      continue;

    DLIList<RefEdge*> edges;
    te->ref_edges(edges);      
    for (int i = 0; i < edges.size(); i++)
    {
      GMem poly;
      if( CUBIT_SUCCESS == edges[i]->get_graphics(poly) )
      {
        poly.transform(prev_xform);
        poly.transform(rot_mat);
        poly.transform(mov_mat);
        GfxPreview::draw_polyline(poly.point_list(), poly.point_list_size(), CUBIT_BLUE_INDEX);
      }
      else if( edges[i]->start_vertex() == edges[i]->end_vertex() )
      {
        CubitVector tmp_pt = edges[i]->start_vertex()->coordinates();
        tmp_pt = prev_xform*tmp_pt;
        tmp_pt = rot_mat*tmp_pt;
        tmp_pt = mov_mat*tmp_pt;       
        GfxPreview::draw_point( tmp_pt, CUBIT_BLUE_INDEX);
      }
    }
  }
}



CubitStatus GeometryModifyTool::sweep_setup(
                         const char* name,
                         DLIList<RefEntity*>& input_entity_list,
                         DLIList<Body*>& output_body_list,
                         GeometryModifyEngine*& output_engine,
                         CubitBoolean& changed_new_ids,
                         DLIList<GeometryEntity*>& output_geom_list,
                         bool keep_old,
                         DLIList<RefEdge*>* input_edge_list,
                         DLIList<Curve*>* output_curve_list )
{
  int i;

  if (input_entity_list.size() == 0)
    return CUBIT_FAILURE;

  DLIList<RefFace*> ref_face_list;
  DLIList<RefEdge*> ref_edge_list;
  CAST_LIST( input_entity_list, ref_face_list, RefFace );
  CAST_LIST( input_entity_list, ref_edge_list, RefEdge );
  if( ref_face_list.size() && ref_edge_list.size() )
  {
    PRINT_ERROR( "Currently cannot sweep curves and surfaces at the same time\n" );
    return CUBIT_FAILURE;
  }

  if( (ref_face_list.size()+ref_edge_list.size()) != input_entity_list.size() )
  {
    PRINT_ERROR( "Can only sweep surfaces or curves\n" );
    return CUBIT_FAILURE;
  }

  // Currently faces to be swept have to belong to different bodies.  It
  // doesn't work well to sweep multiple faces from the same body (also
  // current implementation in AGE crashes).
  if( ref_face_list.size() && false == keep_old )
  {
    int free_surf_cnt = 0; // Number of free surfaces being swept
    DLIList<Body*> body_list;
    RefFace *ref_face_ptr;
    for( i=ref_face_list.size(); i--; )
    {
      ref_face_ptr = ref_face_list.get_and_step();
      DLIList<Body*> tmp_body_list;
      ref_face_ptr->bodies( tmp_body_list );
      if( tmp_body_list.size() > 1 )
      {
        PRINT_ERROR( "Surface %d belongs to more than one volume; cannot sweep.\n",
          ref_face_ptr->id() );
        return CUBIT_FAILURE;
      }

      if( tmp_body_list.size() > 0 )
        body_list.append_unique( tmp_body_list.get() );
      else
        free_surf_cnt++;
    }

    if( body_list.size()+free_surf_cnt != ref_face_list.size() )
    {
      //if each is a sheet body, and every surface is in the list,
      //it is ok to sweep it

      //PRINT_ERROR("The surfaces to be swept cannot belong to the same volume\n");
      //return CUBIT_FAILURE;

      for( int k=body_list.size(); k--; )
      {
        Body *tmp_body = body_list.get_and_step();
        DLIList<RefFace*> tmp_ref_faces;
        tmp_body->ref_faces( tmp_ref_faces );

        //all surfaces must be swept
        if( tmp_body->is_sheet_body() )
        {
          tmp_ref_faces -= ref_face_list;
          if( tmp_ref_faces.size() )
          {
            PRINT_ERROR( "When sweeping a sheet body, all surfaces must be specified\n");
            return CUBIT_FAILURE;
          }
        }
        else // only 1 surface can be swept
        {
          int num_surfaces_before = tmp_ref_faces.size();
          tmp_ref_faces -= ref_face_list;

          if( (num_surfaces_before - tmp_ref_faces.size() ) > 1 )
          {
            PRINT_ERROR( "The surfaces to be swept cannot belong to the same volume\n" );
            return CUBIT_FAILURE;
          }
        }
      }
    }

    output_body_list = body_list;
  }

  // Make sure all entities are from same modify engine
  DLIList<TopologyEntity*> te_list;
  CAST_LIST(input_entity_list, te_list, TopologyEntity);

  // This is for sweeping along a curve list
  if (input_edge_list)
  {
    input_edge_list->reset();
    for( i=input_edge_list->size(); i--; )
      te_list.append( input_edge_list->get_and_step() );
  }

  DLIList<TopologyBridge*> bridge_list( te_list.size() );
  output_engine = common_modify_engine( te_list, bridge_list );
  if( output_engine == NULL )
  {
     PRINT_ERROR("Can't sweep with entities from different modeling engines.\n");
     return CUBIT_FAILURE;
  }

  // Check for virtual anywhere in participating bodies.  This will catch cases where
  // the result from sweeping would interact with some virtual somewhere. bwc 12/22/05.
  for(i=output_body_list.size(); i--;)
  {
     if(GeometryQueryTool::instance()->contains_intermediate_geometry(
        output_body_list.get_and_step()))
     {
        PRINT_ERROR("Can't sweep faces of bodies containing virtual geometry.\n");
        return CUBIT_FAILURE;
     }
  }

  changed_new_ids = CUBIT_FALSE;

  TopologyBridge* bridge_ptr;
  bridge_list.reset();
  for( i=input_entity_list.size(); i--; )
  {
    bridge_ptr = bridge_list.get_and_step();
    GeometryEntity* geom_ptr = dynamic_cast<GeometryEntity*>(bridge_ptr);
    output_geom_list.append(geom_ptr);
  }

  if( input_edge_list )
  {
    for( i=input_edge_list->size(); i--; )
    {
      bridge_ptr = bridge_list.get_and_step();
      Curve* curve_ptr = dynamic_cast<Curve*>(bridge_ptr);
      output_curve_list->append(curve_ptr);
    }
  }

  return CUBIT_SUCCESS;
}

CubitStatus GeometryModifyTool::sweep_finish(
                                     const char* const,
                                     DLIList<Body*>& input_body_list,
                                     DLIList<BodySM*>& new_body_list,
                                     DLIList<Body*>& output_body_list,
                                     CubitBoolean changed_new_ids )
{
  int i;
  DLIList<BodySM*> regen_list( new_body_list );
  GeometryQueryTool *gqt = GeometryQueryTool::instance();

  input_body_list.reset();
  for (i = input_body_list.size(); i--; )
  {
    Body* body = input_body_list.get_and_step();
    BodySM* bodysm = body->get_body_sm_ptr();
    if (bodysm)
    {
      regen_list.append_unique(bodysm);
      remove_dead_entity_names(body);
      output_body_list.append( body );
    }
    else
    {
      gqt->destroy_dead_entity(body);
    }
  }
  gqt->cleanout_deactivated_geometry();

  regen_list.reset();
  for (i = regen_list.size(); i--; )
  {
    BodySM* bodysm = regen_list.get_and_step();
    Body* body = gqt->make_Body(bodysm);
    output_body_list.append_unique( body );
    PRINT_INFO("%s volume %d\n",
      new_body_list.is_in_list(bodysm) ? "Created swept" : "Updated",
      body->ref_volume()->id());
  }

  if (changed_new_ids) set_new_ids(CUBIT_FALSE);
  gqt->cleanout_deactivated_geometry();

  return CUBIT_SUCCESS;
}





CubitStatus GeometryModifyTool::sweep_rotational(
                                        DLIList<RefEntity*>& ref_ent_list,
                                        const CubitVector& point,
                                        const CubitVector& sweep_axis,
                                        double angle,
                                        DLIList<Body*>& output_body_list,
                                        CubitBoolean anchor_entity,
                                        CubitBoolean keep_old,
                                        int steps,
                                        double draft_angle,
                                        int draft_type,
                                        CubitBoolean switchside,
                                        CubitBoolean make_solid,
                                        CubitBoolean rigid)
{
  DLIList<Body*> body_list;
  DLIList<GeometryEntity*> geom_list;
  GeometryModifyEngine* gePtr1 = 0;
  CubitBoolean change_newids;
  if (!sweep_setup("rotational", ref_ent_list, body_list, gePtr1,
                   change_newids, geom_list, keep_old))
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    DLIList<RefEdge*> edge_list;
    DLIList<RefFace*> face_list;

    CAST_LIST( ref_ent_list, edge_list, RefEdge );
    CAST_LIST( ref_ent_list, face_list, RefFace );

    DLIList<RefEdge*> free_edges;
    for(int i=0;i<edge_list.size();i++)
    {
      RefEdge* edge= edge_list[i];
      if(edge->num_parent_ref_entities()==0)
      {
        free_edges.append(edge);
      }
    }

    if(free_edges.size())
      CubitUndo::save_state_with_cubit_file( free_edges );
    else if( edge_list.size() || keep_old )
      CubitUndo::save_state();
    else
     //Faces will get consumed so you have to save out original entities
      CubitUndo::save_state_with_cubit_file( face_list );
  }

  DLIList<BodySM*> result_list;
  CubitStatus status = gePtr1->sweep_rotational( geom_list,
                                                 result_list,
                                                 point,
                                                 sweep_axis,
                                                 angle,
                                                 steps,
                                                 draft_angle,
                                                 draft_type,
                                                 switchside,
                                                 make_solid,
                                                 rigid,
                                                 anchor_entity,
                                                 keep_old );

  if( keep_old )
    body_list.clean_out();

  if (!sweep_finish("rotational", body_list, result_list, output_body_list, change_newids))
    status = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    if( status == CUBIT_FAILURE )
      CubitUndo::remove_last_undo();
    else
      CubitUndo::note_result_bodies( output_body_list );
  }

  return status;
}


CubitStatus GeometryModifyTool::sweep_helical( DLIList<RefEntity*>& ref_ent_list,
                                               CubitVector &location,
                                               CubitVector &direction,
                                               double &thread_distance,
                                               double &angle,
                                               bool right_handed,
                                               CubitBoolean anchor_entity,
                                               CubitBoolean keep_old,
                                               DLIList<Body*>& output_body_list)
{
  DLIList<Body*> body_list;
  DLIList<GeometryEntity*> geom_list;
  GeometryModifyEngine* gePtr1 = 0;
  CubitBoolean change_newids;
  if (!sweep_setup("translational", ref_ent_list, body_list, gePtr1,
                   change_newids, geom_list, keep_old))
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    DLIList<RefEdge*> edge_list;
    DLIList<RefFace*> face_list;

    CAST_LIST( ref_ent_list, edge_list, RefEdge );
    CAST_LIST( ref_ent_list, face_list, RefFace );

    //Edges aren't consumed, so there's nothing to save out
    if( edge_list.size() || keep_old )
      CubitUndo::save_state();
    else
     //Faces will get consumed so you have to save out original entities
      CubitUndo::save_state_with_cubit_file( face_list );
  }

  DLIList<BodySM*> result_list;
  CubitStatus status = gePtr1->
    sweep_helical( geom_list, result_list, location,
                   direction, thread_distance, angle, right_handed, anchor_entity, keep_old );

  if( keep_old )
    body_list.clean_out();

  if (!sweep_finish("translational", body_list, result_list, output_body_list, change_newids))
    status = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    if( status == CUBIT_FAILURE )
      CubitUndo::remove_last_undo();
    else
      CubitUndo::note_result_bodies( output_body_list );
  }

  return status;





}

CubitStatus GeometryModifyTool::sweep_translational(
                                         DLIList<RefEntity*>& ref_ent_list,
                                         const CubitVector& sweep_vector,
                                         double draft_angle,
                                         int draft_type,
                                         CubitBoolean switchside,
                                         CubitBoolean rigid,
                                         CubitBoolean anchor_entity,
                                         CubitBoolean keep_old,
                                         DLIList<Body*>& output_body_list)
{
  DLIList<Body*> body_list;
  DLIList<GeometryEntity*> geom_list;
  GeometryModifyEngine* gePtr1 = 0;
  CubitBoolean change_newids;
  if (!sweep_setup("translational", ref_ent_list, body_list, gePtr1,
                   change_newids, geom_list, keep_old))
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    DLIList<RefEdge*> edge_list;
    DLIList<RefFace*> face_list;

    CAST_LIST( ref_ent_list, edge_list, RefEdge );
    CAST_LIST( ref_ent_list, face_list, RefFace );

    //find any free edges
    DLIList<RefEdge*> free_edges;
    for( int k=edge_list.size(); k--; )
    {
      RefEdge *tmp_edge = edge_list.get_and_step();
      if( tmp_edge->num_parent_ref_entities() == 0 )
        free_edges.append( tmp_edge );
    }    

    if( free_edges.size() ) 
      //Free edges will get consumed..save them out 
      CubitUndo::save_state_with_cubit_file( free_edges );
    else if( edge_list.size() || keep_old )
      CubitUndo::save_state();
    else
     //Faces will get consumed so you have to save out original entities
      CubitUndo::save_state_with_cubit_file( face_list );
  }

  DLIList<BodySM*> result_list;
  CubitStatus status = gePtr1->
    sweep_translational( geom_list,
                         result_list,
                         sweep_vector,
                         draft_angle,
                         draft_type,
                         switchside,
                         rigid,
                         anchor_entity,
                         keep_old);

  if( keep_old )
    body_list.clean_out();

  if (!sweep_finish("translational", body_list, result_list, output_body_list, change_newids))
    status = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    if( status == CUBIT_FAILURE )
      CubitUndo::remove_last_undo();
    else
      CubitUndo::note_result_bodies( output_body_list );
  }

  return status;
}

//Author:: Jonathan Bugman
//Sept 10, 2006
CubitStatus GeometryModifyTool::sweep_curve_target(CubitPlane ref_plane,
                                             DLIList<RefEntity*>& ref_ent_list)
{
    double distance1;
    double distance2;
    double distance3;
    double temp_counter=0;
    CubitVector begin_point;
    CubitVector target_begin_point;
    CubitVector get_mid_point;
    CubitVector target_mid_point;
    CubitVector end_point;
    CubitVector target_end_point;
    DLIList<RefEdge*> edge_list;
    CAST_LIST(ref_ent_list, edge_list, RefEdge);
    CubitVector result;
    double max_distance_for_edge=0;
    CubitVector max_result;
    //make sure that there are actually edges in list
    if(edge_list.size() > 0)
    {
        //this part of the code steps through all edges that could be
        //selected by user and finds the largest distance of all edges from three
        //points: midpoint, endpoint, and beginpoint
        for (int i=0;i<edge_list.size();i++)
        {
            //find the midpoint vector of the edge
            edge_list[i]->mid_point(get_mid_point);

            //Project the midpoint onto the specified plane
            target_mid_point = ref_plane.project(get_mid_point);

            //Calculate the distance between the mid_point, and target_point
            distance1 = target_mid_point.distance_between(get_mid_point);

            //the next two blocks are just copies of the above three steps
            double fraction_along_curve = 1;
            edge_list[i]->position_from_fraction(fraction_along_curve, end_point);
            target_end_point = ref_plane.project(end_point);
            distance2 = target_end_point.distance_between(end_point);

            fraction_along_curve = 0;
            edge_list[i]->position_from_fraction(fraction_along_curve, begin_point);
            target_begin_point = ref_plane.project(begin_point);
            distance3 = target_begin_point.distance_between(begin_point);

            //see which of the three distances is greater for that edge
            //and compare its distance to the other edges that have already been calculated
            //saving the vector of the largest distance
            if (distance1>distance2 && distance1>distance3)
            {
                result = 2*(target_mid_point - get_mid_point);
                max_distance_for_edge=distance1;
                if (max_distance_for_edge>temp_counter)
                {
                    temp_counter=max_distance_for_edge;
                    max_result=result;
                }
            }
            else if (distance2>distance3)
            {
                result = 2*(target_end_point - end_point);
                max_distance_for_edge=distance2;
                if (max_distance_for_edge>temp_counter)
                {
                    temp_counter=max_distance_for_edge;
                    max_result=result;
                }
            }
            else
            {
                result = 2*(target_begin_point - begin_point);
                max_distance_for_edge=distance3;
                if (max_distance_for_edge>temp_counter)
                {
                    temp_counter=max_distance_for_edge;
                    max_result=result;
                }
            }
        }

        //using the 'facet edges' defined by the drawing geometry take the leading
        //and trailing edge projection vectors of this small edge.  With that,
        //calc the dot product and if negative, the vectors are opposite of each
        //other meaning the curve travels through the plane and the sweep function will fail
        for (int ii=0;ii<edge_list.size();ii++)
        {
            Curve *facet_curve;
            facet_curve=edge_list[ii]->get_curve_ptr();
            CubitStatus response;
            GMem g_mem;

            //get number of points and their locations
            //on the curve as defined by the drawing geometry algorithm
            response = facet_curve->get_geometry_query_engine()->
                get_graphics( facet_curve, &g_mem );
            int num_points = g_mem.pointListCount;

            if (response==CUBIT_FAILURE || num_points == 0)
            {
                PRINT_WARNING("Facet Curve calling function failed\n" );
            }

            GPoint *point_data = g_mem.point_list();

            for (int jj=0; jj < (num_points-1); jj++)
            {
                //get first points vectors
                CubitVector point_1;
                point_1.x(point_data[jj].x);
                point_1.y(point_data[jj].y);
                point_1.z(point_data[jj].z);
                //get second points vectors
                CubitVector point_2;
                point_2.x(point_data[jj+1].x);
                point_2.y(point_data[jj+1].y);
                point_2.z(point_data[jj+1].z);
                //project the two points onto target plane
                CubitVector target_point_1;
                target_point_1 = ref_plane.project(point_1);
                CubitVector target_point_2;
                target_point_2 = ref_plane.project(point_2);
                //calc vector from point on curve to point on surface
                CubitVector vec_1 = point_1 - target_point_1;
                CubitVector vec_2 = point_2 - target_point_2;
                //make them unit vectors
                vec_1.normalize();
                vec_2.normalize();
                //calculate dot product
                double dot = vec_1.x()*vec_2.x()+vec_1.y()*vec_2.y()+vec_1.z()*vec_2.z();
                //check to see if dot product sign is zero
                //the and statement checks for if the first or last vertex of the edge
                //which may be sitting on the surface, this is alright
                //and should still be able to sweep
//              if (dot<0 && (jj+1!=num_points || jj==0))
                if (dot<0 && (jj!=(num_points-2) || jj==0))
                {
                    PRINT_ERROR( "The edge is traveling through the plane\n" );
                    PRINT_ERROR( "and thus forces the sweep direction to switch\n" );
                    PRINT_ERROR( "direction. Try splitting the edge.\n" );
                    return CUBIT_FAILURE;
                }
            }
        }
        DLIList<BodySM*> webcut_results_list;
        DLIList<Body*> body_list;
        DLIList<BodySM*> sweep_result_list;
        DLIList<GeometryEntity*> geom_list;
        GeometryModifyEngine* gePtr1 = 0;
        CubitBoolean change_newids;

        if (!sweep_setup("translational", ref_ent_list , body_list, gePtr1,
            change_newids, geom_list, false))
            return CUBIT_FAILURE;

        //below block is default settings to be fed into sweep_translational
        CubitBoolean rigid = CUBIT_FALSE;
        CubitBoolean switchside = CUBIT_FALSE;
        int draft_type = 0;
        double draft_angle=0.0;

        //sweep the curve through and hopefully past the target surface
        CubitStatus status = gePtr1->sweep_translational( geom_list,sweep_result_list,
            max_result,draft_angle, draft_type,switchside,rigid);

        if (status == 0)
        {
            PRINT_ERROR( "Sweep operation failed!\n" );
            //delete sweep_result_list memory
            gePtr1->get_gqe()->delete_solid_model_entities(sweep_result_list);
            return CUBIT_FAILURE;
        }

        //below lines are used to define the ref_plane with three points for webcut input
        //find normal vector to user specified plane
        CubitVector vec1 = ref_plane.normal();
        CubitVector vec2;
        CubitVector vec3;
        //get orthogonal vectors of the normal vector
        vec1.orthogonal_vectors(vec2, vec3);
        //place the orthogonal vectors at a point on the plane as opposed to the origin
        vec2=vec2+target_mid_point;
        vec3=vec3+target_mid_point;

                DLIList<BodySM*> neighbor_imprint_list;
        //do a webcut with a plane created from the three projected points above
        CubitStatus status2 = gePtr1->webcut(sweep_result_list,target_mid_point,
            vec2,vec3, neighbor_imprint_list, webcut_results_list);

        if (status2 == 0)
        {
            PRINT_ERROR( "Sweep operation worked; however, webcut operation failed.\n" );
            //delete memory since it failed
            gePtr1->get_gqe()->delete_solid_model_entities(sweep_result_list);
            return CUBIT_FAILURE;
        }

        if (webcut_results_list.size()==0)
        {
            PRINT_ERROR( "Number of bodies from webcut is zero, unable to perform rest of sweep operation\n" );
            //delete memory since it failed
            gePtr1->get_gqe()->delete_solid_model_entities(sweep_result_list);
            return CUBIT_FAILURE;
        }

        CubitVector created_curve_mid;
        CubitVector user_mid;
        DLIList<BodySM*> keep_bodies_list;
        DLIList<Curve*> curve_list;

        //generate a list of curves from the webcut_results_list
        for (int counter = 0;counter < webcut_results_list.size(); counter++)
        {
            BodySM* OO = webcut_results_list[counter];
            OO->curves(curve_list);
        }

        //step through each of the user specified edges
        for (int edge_counter = 0; edge_counter < edge_list.size(); edge_counter++)
        {
            //find the midpoint of a user specified edge
            edge_list[edge_counter]->position_from_fraction(.5,user_mid);
            double min_dist=DBL_MAX;
            double distance;
            Curve* closest_curve=0;

            //step through all of the curves
            for (int counter2 = 0; counter2 < curve_list.size(); counter2++)
            {
                //find the midpoint of the created curve
                curve_list[counter2]->position_from_fraction(.5,created_curve_mid);
                //calculate the distance between the two midpoints
                distance=created_curve_mid.distance_between(user_mid);

                //find the minimum distance between all the curves
                if (distance<min_dist)
                {
                    //reset the min_distance
                    min_dist=distance;
                    //keep track of which curve is associated with the shortest distance
                    closest_curve=curve_list[counter2];
                }
            }
            //find the parent body of the minimum distance curve
            BodySM* body_sm = closest_curve->bodysm();
            //append that body to a keep list
            keep_bodies_list.append(body_sm);
        }
        //delete bodies which repeat (useful only when in granite engine)
    keep_bodies_list.uniquify_ordered();
        //subtract the keep_list from the webcut_results_list
        webcut_results_list -=keep_bodies_list;
        //delete webcut_results_list memory
        gePtr1->get_gqe()->delete_solid_model_entities(webcut_results_list);

                if( CubitUndo::get_undo_enabled() )
                  CubitUndo::save_state();

        //builds ref bodies
    DLIList<Body*> output_body_list;
        if (!sweep_finish("translational", body_list, keep_bodies_list, output_body_list, change_newids))
        {
            gePtr1->get_gqe()->delete_solid_model_entities(keep_bodies_list);
            status = CUBIT_FAILURE;
        }

    if( CubitUndo::get_undo_enabled())
    {
      if( status == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else
        CubitUndo::note_result_bodies( output_body_list );
    }
    }
    else
    {
        PRINT_ERROR( "No edge(s) found - sweep creation failed.\n" );
        return CUBIT_FAILURE;
    }

    return CUBIT_SUCCESS;
}
// Author: Derek Quam
// Dec. 1, 2008
CubitStatus GeometryModifyTool::sweep_surface_target(RefFace *face,
                                                     Body *target_body,
                                                     CubitVector distance,
                                                     CubitPlane stop_plane,
                                                     double magnitude)
{
  //  Declare local variables
  Surface *source_surf;
  bool set_dist = true, set_plane = true, set_mag = true;
  CubitVector direction;
  CubitStatus status;
  DLIList<Body*> body_list;
  DLIList<GeometryEntity*> geom_list;
  GeometryModifyEngine* gePtr1 = 0;
  CubitBoolean change_newids;
  DLIList<RefEntity*> ref_ent_list;
  ref_ent_list.append(face);

  // Check to make sure the target body is a solid
  if (target_body->is_sheet_body())
  {
    PRINT_ERROR("Target body must be a solid body.\n");
    return CUBIT_FAILURE;
  }

  // Set up the sweep
  if (!sweep_setup("target", ref_ent_list, body_list, gePtr1,
                    change_newids, geom_list, false))
    return CUBIT_FAILURE;

  // Get the Surface * from the RefFace *
  source_surf = face->get_surface_ptr();

  // Check if the direction vector and stop plane were specified
  if (distance.length() < 0.0001)
    set_dist = false;
  if (stop_plane.normal().length() < 0.0001)
    set_plane = false;
  if (magnitude < 0.0001)
    set_mag = false;

  // Calculate the direction of the sweep
  if (!set_dist)
    direction = face->normal_at(face->center_point());
  else
    direction = distance;
  direction.normalize();

  double length = 0.0;
  if (!set_mag && !set_plane)
  {
    CubitVector center_body = target_body->center_point();
    CubitVector center_face = face->center_point();
    length = center_face.distance_between(center_body);
  }
  else if (set_plane)
  {
    length = stop_plane.intersect(face->center_point(), direction).distance_between(face->center_point());
  }
  else
  {
    length = magnitude;
  }
  if (set_mag && length > magnitude)
    length = magnitude;
  direction *= length;

  DLIList<BodySM*> new_bodies;
  status = gePtr1->sweep_to_body(source_surf, target_body->get_body_sm_ptr(), direction, new_bodies );

  if (status != CUBIT_SUCCESS)
    return status;

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state();

  // Make all the new bodies
  DLIList<Body*> output_body_list;
  if (!sweep_finish("target", body_list, new_bodies, output_body_list, change_newids))
    status = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
    {
      if( status == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else
      {
        //For some reason the ouput_body_list contains one of the original
        //volumes that we do not want to delete when we are performing an 
        //undo on the sweep. So we remove that original volume from the 
        //"to undo" list.
        Body* to_delete = output_body_list[1];
        output_body_list.clean_out();
        output_body_list.append(to_delete);
        CubitUndo::note_result_bodies( output_body_list );
      }
    }

  /*
  for (int i = 0; i < new_bodies.size(); i++)
    GeometryQueryTool::instance()->make_Body(new_bodies.get_and_step());
    */


  return CUBIT_SUCCESS;
}

// Author: Andrew Rout and Derek Quam
// Nov. 14, 2008
CubitStatus GeometryModifyTool::sweep_curve_target(DLIList<RefEdge*>& edge_list,
                                                   Body *target_body,
                                                   DLIList<Body*> &out_bodies,
                                                   CubitVector distance,
                                                   CubitPlane stop_plane,
                                                   bool unite)
{
  DLIList<BodySM*> new_bodies;
  DLIList<Curve*> curve_list;
  bool set_dist = true, set_plane = true;
  double larDist = 1.0;
  CubitVector dir = distance;
  CubitStatus status;

  // Check to make sure the target body is a sheetbody
  if (!target_body->is_sheet_body())
  {
    PRINT_ERROR("Target body must be a sheet body.\n");
    return CUBIT_FAILURE;
  }

  // Get the Curve *'s from the RefEdge *'s
  for (int i = 0; i < edge_list.size(); i++)
  {
    edge_list[i]->get_curve_ptr()->set_saved_id(edge_list[i]->id());
    curve_list.append(edge_list[i]->get_curve_ptr());
  }
  // Check if the direction vector and stop plane were specified
  if (distance.length() < 0.0001)
    set_dist = false;
  if (stop_plane.normal().length() < 0.0001)
    set_plane = false;

  // Check inputs
  if (!set_plane && !set_dist)
  {
    PRINT_ERROR("User must specify a stop plane, a direction, or both.\n");
    return CUBIT_FAILURE;
  }

  // Calculate the direction vector
  double begDist, midDist, endDist;
  for (int i = 0; i < edge_list.size(); i++)
  {
    CubitVector beg, mid, end, begP, midP, endP;
    RefEdge *temp = edge_list.get_and_step();

    // Retrieve the beginning, middle, and end coordinates of the edge
    beg = temp->start_coordinates();
    temp->mid_point(mid);
    end = temp->end_coordinates();

    if (set_plane)
    {
      // Project the start, mid, and end point onto the stop plane
      begP = stop_plane.project(beg);
      midP = stop_plane.project(mid);
      endP = stop_plane.project(end);

      // Calculate the distance between the points
      begDist = beg.distance_between(begP);
      midDist = mid.distance_between(midP);
      endDist = end.distance_between(endP);
    }
    else  // No stop plane specified
    {
      begDist = beg.distance_between(target_body->center_point());
      midDist = mid.distance_between(target_body->center_point());
      endDist = end.distance_between(target_body->center_point());
    }

    // Find the largest distance
    if (begDist > larDist)
      larDist = begDist;
    if (midDist > larDist)
      larDist = midDist;
    if (endDist > larDist)
      larDist = endDist;

    // Make sure the plane normal is pointing the right way
    if (set_plane)
    {
      double planeNorm = stop_plane.normal().interior_angle(beg-begP);
      if (planeNorm <= 90 || planeNorm >= 270)
        stop_plane.reverse();
    }

    if (!set_dist)
      dir += (midP-mid);

  } // End for loop
  if (!set_dist)
    dir /= edge_list.size();

  // Unitize the direction vector
  dir /= dir.length();

  // Add the magnitude to the direction vector and check for intersection with the stop plane
  dir *= larDist;
  if (set_plane)
  {
    double angle = dir.interior_angle(stop_plane.normal());
    if (angle >= 90 && angle <= 270)
      PRINT_WARNING("Direction vector does not intersect stop plane!\n");
  }

  // Call the geometry function
  status = get_gme()->sweep_to_body(curve_list, target_body->get_body_sm_ptr(), dir, new_bodies, unite);

  if (status != CUBIT_SUCCESS)
    return CUBIT_FAILURE;

  // Make all the new bodies
  for (int i = 0; i < new_bodies.size(); i++)
  {
    out_bodies.append(GeometryQueryTool::instance()->make_Body(new_bodies.get_and_step()));
    PRINT_INFO("Created volume in body %d\n", out_bodies[i]->id());
  }

  return CUBIT_SUCCESS;
}

//Author: Jonathan Bugman
//Sept 10, 2006
CubitStatus GeometryModifyTool::sweep_surface_target(CubitPlane ref_plane,
                                    DLIList<RefEntity*>& ref_ent_list)
{
    DLIList<RefFace*> surface_list;
    CAST_LIST(ref_ent_list, surface_list, RefFace);
    double distance1;
    double distance2;
    double distance3;
    double temp_counter=0;
    CubitVector begin_point;
    CubitVector target_begin_point;
    CubitVector get_mid_point;
    CubitVector target_mid_point;
    CubitVector end_point;
    CubitVector target_end_point;
    CubitVector result;
    double max_distance_for_edge=0;
    CubitVector max_result;
    DLIList<RefEdge*> surf_edge_list;

    //make sure that only one surface has been selected
    if(surface_list.size() == 0)
    {
        PRINT_ERROR( "No surface found - sweep surface to target failed.\n" );
        return CUBIT_FAILURE;
    }

    //make sure that there are actually surfaces in list
    else if(surface_list.size() > 1)
    {
        PRINT_ERROR( "You can only use this operation \n with one surface selected at a time\n" );
        return CUBIT_FAILURE;
    }
    else
    {
        //this part of the code steps through all edges that could be
        //selected by user and finds the largest distance of all edges from three
        //points: midpoint, endpoint, and beginpoint
        for (int i=0;i<surface_list.size();i++)
        {
            surface_list[i]->ref_edges(surf_edge_list);
            for (int j=0;j<surf_edge_list.size();j++)
            {
                //get midpoint of edge on surface
                surf_edge_list[j]->mid_point(get_mid_point);
                //Project the midpoint of each surface edge onto the specified plane
                target_mid_point = ref_plane.project(get_mid_point);

                //Calculate the distance between the mid_point, and target_point
                distance1 = target_mid_point.distance_between(get_mid_point);

                //the next two blocks are just copies of the above three steps

                int fraction_along_curve = 1;
                surf_edge_list[j]->position_from_fraction(fraction_along_curve, end_point);
                target_end_point = ref_plane.project(end_point);
                distance2 = target_end_point.distance_between(end_point);

                fraction_along_curve = 0;
                surf_edge_list[j]->position_from_fraction(fraction_along_curve, begin_point);
                target_begin_point = ref_plane.project(begin_point);
                distance3 = target_begin_point.distance_between(begin_point);

                //see which of the three distances is greater of the edge
                //and compare its distance to the other edges
                if (distance1>distance2 && distance1>distance3)
                {
                    result = 2*(target_mid_point - get_mid_point);
                    max_distance_for_edge=distance1;
                    if (max_distance_for_edge>temp_counter)
                    {
                        temp_counter = max_distance_for_edge;
                        max_result=result;

                    }
                }
                else if (distance2>distance3)
                {
                    result = 2*(target_end_point - end_point);
                    max_distance_for_edge=distance2;
                    if (max_distance_for_edge>temp_counter)
                    {
                        temp_counter = max_distance_for_edge;
                        max_result=result;

                    }
                }
                else
                {
                    result = 2*(target_begin_point - begin_point);
                    max_distance_for_edge=distance3;
                    if (max_distance_for_edge>temp_counter)
                    {
                        temp_counter = max_distance_for_edge;
                        max_result=result;

                    }
                }
                //just checking to make sure the user didn't specify a surface as both
                //a target surface and sweeping surface which would result in a CUBIT crash
                if (i==surface_list.size()-1 && j==surf_edge_list.size()-1 &&
                    max_distance_for_edge < 0.000000000000001)
                {
                    PRINT_ERROR( "The sweep distance is less than the geometry tolerance\n" );
                    PRINT_ERROR( "This may be caused by selecting the same\n");
                    PRINT_ERROR( "sweep surface and target surface\n" );
                    return CUBIT_FAILURE;
                }
            }
        }
        //using the facet edges defined by the drawing geometry code; take the leading
        //and trailing edge vectors of each facet edge;  With that, calc the dot product
        //and if negative (meaning the vector directions switched) the curve travels
        //through the plane and the sweep function will fail
        surface_list.reset();
        surf_edge_list.clean_out();
        for (int kk=0;kk<surface_list.size();kk++)
        {
            surface_list[kk]->ref_edges(surf_edge_list);
            for (int ii=0;ii<surf_edge_list.size();ii++)
            {
                Curve *facet_curve;
                facet_curve=surf_edge_list[ii]->get_curve_ptr();
                CubitStatus response;
                GMem g_mem;

                //get number of points and their locations
                //on the curve as defined by the drawing geometry algorithm
                response = facet_curve->get_geometry_query_engine()->
                    get_graphics( facet_curve, &g_mem );

        int num_points = g_mem.pointListCount;

                if (response==CUBIT_FAILURE || num_points == 0)
                {
                    PRINT_WARNING("Unable to preview a curve\n" );
                }

                GPoint *point_data = g_mem.point_list();

                for (int jj=0; jj < (num_points-1); jj++)
                {
                    //get first points vectors
                    CubitVector point_1;
                    point_1.x(point_data[jj].x);
                    point_1.y(point_data[jj].y);
                    point_1.z(point_data[jj].z);
                    //get second points vectors
                    CubitVector point_2;
                    point_2.x(point_data[jj+1].x);
                    point_2.y(point_data[jj+1].y);
                    point_2.z(point_data[jj+1].z);
                    //project the two points onto target plane
                    CubitVector target_point_1;
                    target_point_1 = ref_plane.project(point_1);
                    CubitVector target_point_2;
                    target_point_2 = ref_plane.project(point_2);
                    //calc vector from point on curve to point on surface
                    CubitVector vec_1 = point_1 - target_point_1;
                    CubitVector vec_2 = point_2 - target_point_2;
                    //make them unit vectors
                    vec_1.normalize();
                    vec_2.normalize();
                    //double dot = DotProduct(vec_1,vec_2);
                    //calculate dot product
                    double dot = vec_1.x()*vec_2.x()+vec_1.y()*vec_2.y()+vec_1.z()*vec_2.z();

                    //check to see if dot product sign is zero
                    //the and statement checks for if the first or last vertex of the edge
                    //which may be sitting on the surface, this is alright
                    //and should still be able to sweep
                    if (dot<0 && 0<jj && jj<(num_points-2))
                    {
                        PRINT_ERROR( "The surface is traveling through the plane\n" );
                        PRINT_ERROR( "and thus forces the sweep direction to switch\n" );
                        PRINT_ERROR( "direction. Try splitting the surface.\n" );
                        return CUBIT_FAILURE;
                    }
                }
            }
        }

        DLIList<Body*> body_list;
        DLIList<GeometryEntity*> geom_list;
        GeometryModifyEngine* gePtr1 = 0;
        CubitBoolean change_newids;

        if (!sweep_setup("translational", ref_ent_list, body_list, gePtr1,
            change_newids, geom_list, false ))
            return CUBIT_FAILURE;

    if( CubitUndo::get_undo_enabled())
      //Faces will get consumed so you have to save out original entities
      CubitUndo::save_state_with_cubit_file( surface_list );

        DLIList<BodySM*> sweep_result_list;

        //below block is default settings to be fed into sweep_translational
        CubitBoolean rigid = CUBIT_FALSE;
        CubitBoolean switchside = CUBIT_FALSE;
        int draft_type = 0;
        double draft_angle=0.0;

        //find normal vector to user specified plane
        CubitVector vec1 = ref_plane.normal();
        CubitVector vec2;
        CubitVector vec3;
        //get orthogonal vectors of the normal vector
        vec1.orthogonal_vectors(vec2, vec3);
        //place the orthogonal vectors at a point on the plane as opposed to the origin
        vec2=vec2+target_mid_point;
        vec3=vec3+target_mid_point;
        DLIList<BodySM*> webcut_results_list;
        //get a point on the first user specified surface before it gets consumed in the sweep_translational function
        CubitVector mid_point_surface;
        mid_point_surface = surface_list[0]->center_point();

        //sweep the curve down through and hopefully past the target surface
        CubitStatus status = gePtr1->sweep_translational( geom_list,sweep_result_list,
            max_result,draft_angle, draft_type,switchside,rigid,CUBIT_FALSE,CUBIT_FALSE);

        if (status == 0)
        {
            //If in here, sweep_translational failed so delete result_list and
            //print an error to the screen for the user
            gePtr1->get_gqe()->delete_solid_model_entities(sweep_result_list);
            PRINT_ERROR( "Error occured in the sweep operation.\n" );

                        if( CubitUndo::get_undo_enabled())
                          CubitUndo::remove_last_undo();
            return CUBIT_FAILURE;
        }

                DLIList<BodySM*> neighbor_imprint_list;
        //do a webcut with a plane created from the three projected points
        CubitStatus status2 = gePtr1->webcut(sweep_result_list,target_mid_point,
            vec2,vec3,neighbor_imprint_list, webcut_results_list);

        if (status2 == 0)
        {
            //If in here, webcut operation failed so delete result_list and
            //print an error to the screen for the user
            gePtr1->get_gqe()->delete_solid_model_entities(sweep_result_list);
            gePtr1->get_gqe()->delete_solid_model_entities(webcut_results_list);
            PRINT_ERROR( "Error occured in the webcut operation.\n" );

                        if( CubitUndo::get_undo_enabled())
                          CubitUndo::remove_last_undo();
            return CUBIT_FAILURE;
        }

        DLIList<BodySM*> keep_bodies_list = webcut_results_list;
        int bodies_deleted_counter=0;
        CubitVector target_mid_point_volume;
        CubitVector mid_point_volume;
        CubitVector target_mid_point_surface;
        double volume_size;

        //project the mid_point of user specified surface onto target plane
        target_mid_point_surface = ref_plane.project(mid_point_surface);
        //calculate vector between the two points and then normalize
        CubitVector vec_1 = mid_point_surface - target_mid_point_surface;
        vec_1.normalize();

        //step through the
        for (int counter=0;counter<webcut_results_list.size();counter++)
        {
            //find the geometric midpoint of the body and project that point on the target plane
            webcut_results_list[counter]->mass_properties(mid_point_volume,volume_size);
            target_mid_point_volume = ref_plane.project(mid_point_volume);
            //generate a vector between the two points and then normalize
            CubitVector vec_2 = mid_point_volume - target_mid_point_volume;
            vec_2.normalize();

            //calculate the dot product
            double dot = vec_1.x()*vec_2.x()+vec_1.y()*vec_2.y()+vec_1.z()*vec_2.z();

            //if a negative dot product delete it because it is on the opposite side of the target plane
            if (dot < 0)
            {
                keep_bodies_list.remove(webcut_results_list[counter]);
                bodies_deleted_counter = bodies_deleted_counter + 1;
            }

        }

        //test to see if all bodies have been deleted and if so let the user know
        if (bodies_deleted_counter == webcut_results_list.size())
        {
            PRINT_ERROR( "All sweeped surfaces deleted - sweep_target failed.\n" );
            PRINT_ERROR( "This may be due to granite engine limitations and/or\n" );
            PRINT_ERROR( "angle between curve and target surface\n" );

                        if( CubitUndo::get_undo_enabled())
                          CubitUndo::remove_last_undo();
            return CUBIT_FAILURE;
        }

        //delete webcut_results_list since it is no longer of use
        webcut_results_list -= keep_bodies_list;
        gePtr1->get_gqe()->delete_solid_model_entities(webcut_results_list);

        //builds ref bodies
    DLIList<Body*> output_body_list;
        if (!sweep_finish("translational", body_list, keep_bodies_list, output_body_list, change_newids))
            status = CUBIT_FAILURE;

    if( CubitUndo::get_undo_enabled())
    {
      if( status == CUBIT_FAILURE )
        CubitUndo::remove_last_undo();
      else
        CubitUndo::note_result_bodies( output_body_list );
    }

    }
    return CUBIT_SUCCESS;
}


CubitStatus GeometryModifyTool::sweep_perpendicular( DLIList<RefEntity*>& ref_ent_list,
                                                     double distance,
                                                     double draft_angle,
                                                     int draft_type,
                                                     CubitBoolean switchside,
                                                     CubitBoolean rigid,
                                                     CubitBoolean anchor_entity,
                                                     CubitBoolean keep_old,
                                                     DLIList<Body*>& output_body_list)
{
  DLIList<Body*> body_list;
  DLIList<GeometryEntity*> geom_list;
  GeometryModifyEngine* gePtr1 = 0;
  CubitBoolean change_newids;
  if (!sweep_setup("translational", ref_ent_list, body_list, gePtr1,
                   change_newids, geom_list, keep_old))
    return CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    DLIList<RefEdge*> edge_list;
    DLIList<RefFace*> face_list;

    CAST_LIST( ref_ent_list, edge_list, RefEdge );
    CAST_LIST( ref_ent_list, face_list, RefFace );

    //Edges aren't consumed, so there's nothing to save out
    if( edge_list.size() || keep_old )
      CubitUndo::save_state();
    else
     //Faces will get consumed so you have to save out original entities
      CubitUndo::save_state_with_cubit_file( face_list );
  }

  DLIList<BodySM*> result_list;
  CubitStatus status = gePtr1->
    sweep_perpendicular( geom_list,
                         result_list,
                         distance,
                         draft_angle,
                         draft_type,
                         switchside,
                         rigid,
                         anchor_entity,
                         keep_old );

  if( keep_old )
    body_list.clean_out();

  if (!sweep_finish("perpendicular", body_list, result_list, output_body_list, change_newids))
    status = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    if( status == CUBIT_FAILURE )
      CubitUndo::remove_last_undo();
    else
      CubitUndo::note_result_bodies( output_body_list );
  }

  return status;
}
CubitStatus GeometryModifyTool::sweep_along_curve(DLIList<RefEntity*>& ref_ent_list,
                                                  DLIList<RefEdge*>& ref_edge_list,
                                                  DLIList<Body*>& output_body_list,
                                                  CubitBoolean anchor_entity,
                                                  CubitBoolean keep_old,
                                                  double draft_angle,
                                                  int draft_type,
                                                  CubitBoolean rigid)

{
  DLIList<GeometryEntity*> geom_list(ref_ent_list.size());
  DLIList<Curve*> curve_list(ref_edge_list.size());
  DLIList<Body*> body_list(ref_ent_list.size());
  GeometryModifyEngine* engine_ptr = 0;
  CubitBoolean changed_new_ids = CUBIT_FALSE;
  CubitStatus status = sweep_setup( "along_curve",
                                    ref_ent_list,
                                    body_list,
                                    engine_ptr,
                                    changed_new_ids,
                                    geom_list,
                                    keep_old,
                                    &ref_edge_list,
                                    &curve_list );
  if (status != CUBIT_SUCCESS)
  return status;

  if( CubitUndo::get_undo_enabled())
  {
    DLIList<RefEdge*> edge_list;
    DLIList<RefFace*> face_list;

    CAST_LIST( ref_ent_list, edge_list, RefEdge );
    CAST_LIST( ref_ent_list, face_list, RefFace );

    //Edges aren't consumed, so there's nothing to save out
    if( keep_old )
      CubitUndo::save_state();
    else
    {
      bool free_curves = false;
      for( int i=edge_list.size(); i--; )
      {
        if( edge_list.get_and_step()->num_parent_ref_entities() == 0 )
        {
          free_curves = true;
          break;
        }
      }

      DLIList<Body*> bodies_to_save;
      DLIList<RefEntity*> free_surfaces;
      for( int i=face_list.size(); i--; )
      {
        RefFace *ref_face = face_list.get_and_step();

        if( ref_face->num_parent_ref_entities() == 0 )
          free_surfaces.append( ref_face );
        else
          bodies_to_save.append_unique( ref_face->ref_volume()->body() );
      }
      //Faces will get consumed so you have to save out original entities
      if( bodies_to_save.size() || free_surfaces.size() )
        CubitUndo::save_state_with_cubit_file( bodies_to_save, &free_surfaces );
      else if(free_curves )
        CubitUndo::save_state_with_cubit_file( edge_list );
      else
        CubitUndo::save_state();
    }
  }

  DLIList<BodySM*> result_list;
  status = engine_ptr->sweep_along_curve( geom_list,
                                          result_list,
                                          curve_list,
                                          draft_angle,
                                          draft_type,
                                          rigid,
                                          anchor_entity,
                                          keep_old);

  if( keep_old )
    body_list.clean_out();

  if (!sweep_finish("along_curve", body_list, result_list, output_body_list, changed_new_ids))
  status = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled())
  {
    if( status == CUBIT_FAILURE )
      CubitUndo::remove_last_undo();
    else
      CubitUndo::note_result_bodies( output_body_list );
  }

  return status;
}

void GeometryModifyTool::initialize_settings() {


  SettingHandler::instance()->add_setting("Group Imprint",
                      GeometryModifyTool::set_group_imprint,
                      GeometryModifyTool::get_group_imprint);

  SettingHandler::instance()->add_setting("NonRegImprint",
                      GeometryModifyTool::set_all_edges_imprint,
                      GeometryModifyTool::get_all_edges_imprint);

  SettingHandler::instance()->add_setting("New Ids",
                      GeometryModifyTool::set_new_ids,
                      GeometryModifyTool::get_new_ids);

  SettingHandler::instance()->add_setting("Separate After Webcut",
                      GeometryModifyTool::set_sep_after_webcut_setting,
                      GeometryModifyTool::get_sep_after_webcut_setting);

  SettingHandler::instance()->add_setting("old names",
            GeometryModifyTool::set_old_names,
            GeometryModifyTool::get_old_names);
}



// ********** END PUBLIC FUNCTIONS         **********

// ********** BEGIN PROTECTED FUNCTIONS    **********

//-------------------------------------------------------------------------
// Purpose       : Constructor of the GeometryModifyTool class.
//
// Special Notes :
//
// Creator       : Xuechen Liu
//
// Creation Date : 07/11/96
//-------------------------------------------------------------------------
GeometryModifyTool::GeometryModifyTool(GeometryModifyEngine*gme_ptr)
{
  if (gme_ptr) gmeList.append(gme_ptr);
}

//-------------------------------------------------------------------------
// Purpose       : This functions webcuts a list of bodies through a plane.
//                 The newly created bodies are and merged depeding on the
//                 respective flags.
//
// Special Notes :
//
// Creator       : Raikanta Sahu
//
// Creation Date : 12/17/96
//-------------------------------------------------------------------------

CubitStatus GeometryModifyTool::webcut_with_brick(
                                           DLIList<Body*>& webcut_body_list,
                                           const CubitVector &center,
                                           const CubitVector axes[3],
                                           const CubitVector &extension,
                                           DLIList<Body*> &results_list,
                                           DLIList<Body*> &neighboring_bodies,
                                           ImprintType imprint_type,
                                           CubitBoolean merge,
                                           CubitBoolean preview)
{
   // Make sure that entity creation is possible.  Allow at most
   // only one of the dimensions to be zero - in which case a planar
   // sheet is used to do the cutting.
   double width = 2.0*extension.x();
   double height = 2.0*extension.y();
   double depth = 2.0*extension.z();
   if ( width < 0.0 || height < 0.0 || depth < 0.0 )
   {
      PRINT_ERROR( "Cannot make a brick of size %f x %f x %f\n"
                   "     Negative dimensions are not allowed.\n",
                   width, height, depth );
      return CUBIT_FAILURE ;
   }

   BodySM *cutting_tool_ptr = NULL;
   CubitBoolean is_sheet_body = CUBIT_FALSE;
   CubitVector p1, p2, p3, p4;
   int wz = width < GEOMETRY_RESABS;
   int hz = height < GEOMETRY_RESABS;
   int dz = depth < GEOMETRY_RESABS;
   int num_zero_dim = wz + hz + dz;
   if( num_zero_dim > 0 )
   {
      if( num_zero_dim > 1 )
      {
         PRINT_ERROR( "Cannot make a sheet of size %f x %f x %f\n"
            "     At least two dimensions must be nonzero.\n",
            width, height, depth );
         return CUBIT_FAILURE ;
      }

      // Make a sheet body instead of a cuboid
      CubitVector sheet_axes[2];
      if( wz )
      {
         sheet_axes[0] = axes[1];
         sheet_axes[1] = axes[2];
         width = depth;
      }
      else if( hz )
      {
         sheet_axes[0] = axes[2];
         sheet_axes[1] = axes[0];
         height = depth;
      }
      else
      {
         sheet_axes[0] = axes[0];
         sheet_axes[1] = axes[1];
      }

      // Get the corners of the sheet ready
      center.next_point( axes[0], width/2.0, p1 );
      p1.next_point( axes[1], -height/2.0, p1 );
      p1.next_point( axes[1], height, p2 );
      p2.next_point( axes[0], -width, p3 );
      p3.next_point( axes[1], -height, p4 );
   }

   if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
     return CUBIT_FAILURE;

   CubitVector tmp_vec( center.x()+width, center.y()+height, center.z()+depth );
   CubitBox tmp_box(tmp_vec);
   tmp_vec.set( center.x()-width, center.y()-height, center.z()-depth );
   tmp_box |= tmp_vec;
   remove_bodies_outside_bounding_box( webcut_body_list, tmp_box );

   if( webcut_body_list.size() == 0 )
   {
     PRINT_INFO("Tool does not intersect any bodies/volumes.\n");
     return CUBIT_FAILURE;
   }

   if( CubitUndo::get_undo_enabled() )
   {
     DLIList<Body*> bodies_to_save;
     bodies_to_save += webcut_body_list;
     bodies_to_save += neighboring_bodies;
     CubitUndo::save_state_with_cubit_file( bodies_to_save );
   }

   CubitStatus rval = CUBIT_SUCCESS;

   const int count = webcut_body_list.size();
   DLIList<BodySM*> result_sm_list;
   DLIList<Body*> body_list(webcut_body_list);
   DLIList<BodySM*> engine_body_sms(count);
   DLIList<Body*> engine_bodies(count);
   GeometryModifyEngine* gme = 0;

   while ( (gme = group_bodies_by_engine(body_list, engine_bodies, engine_body_sms)) )
   {
     DLIList<int> merged_surface_ids;
     DLIList<int> merged_curve_ids;
     DLIList<BodySM*> neighbor_imprint_list;
     if (!preview)
     {
       int i;
       for( i=neighboring_bodies.size(); i--; )
       {
         Body *neighbor_body = neighboring_bodies.get_and_step();
         BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
         GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

         if( gme == neighbor_gme )
         {
           neighbor_imprint_list.append( tmp_body );
           engine_bodies.append( neighbor_body );
         }
       }

       do_attribute_setup();
       DLIList<BodySM*> bodies_to_modify;
       bodies_to_modify += engine_body_sms;
       bodies_to_modify += neighbor_imprint_list;
       push_attributes_before_modify( bodies_to_modify );
       get_merged_curve_and_surface_ids( engine_bodies, merged_surface_ids, merged_curve_ids );
     }

     // Create the brick to cut with
    if (is_sheet_body)
      cutting_tool_ptr = gme->planar_sheet(p1,p2,p3,p4);
    else
      cutting_tool_ptr = gme->brick( center, axes, extension );
    if( cutting_tool_ptr == NULL )
       return CUBIT_FAILURE;

    CubitStatus status = gme->webcut (
      engine_body_sms, cutting_tool_ptr,
      neighbor_imprint_list,
      result_sm_list, imprint_type, preview );

    // Delete the BodySM that was created to be used as a tool
    gme->get_gqe()->delete_solid_model_entities(cutting_tool_ptr) ;

      // just continue the loop if previewing
      if (preview)
      {
        rval = status;
        continue;
      }

      restore_vg_after_modify(result_sm_list, engine_bodies, gme);
      remove_pushed_attributes(result_sm_list, engine_bodies);

      status = finish_webcut( engine_bodies, result_sm_list, merge, status, results_list,
                              &merged_surface_ids, &merged_curve_ids );

      if (!status)
        rval = CUBIT_FAILURE;

      engine_bodies.clean_out();
      engine_body_sms.clean_out();
      result_sm_list.clean_out();
   }

   if (!preview)
     do_attribute_cleanup();

   if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
   {
     if( results_list.size() ) //if there are new bodies...something succeeded
       CubitUndo::note_result_bodies( results_list );
     else
       CubitUndo::remove_last_undo();
   }

   return rval;
}

CubitStatus GeometryModifyTool::webcut_with_planar_sheet(
                                           DLIList<Body*>& webcut_body_list,
                                           const CubitVector &center,
                                           const CubitVector axes[2],
                                           double width, double height,
                                           DLIList<Body*> &results_list,
                                           DLIList<Body*> &neighboring_bodies,
                                           ImprintType imprint_type,
                                           CubitBoolean merge,
                                           CubitBoolean preview)
{
   if ( width <= GEOMETRY_RESABS || height <= GEOMETRY_RESABS )
   {
      PRINT_ERROR( "Cannot webcut with a sheet of size %f x %f\n"
                   "     Negative or zero dimensions are not allowed.\n",
                   width, height );
      return CUBIT_FAILURE ;
   }

   if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
     return CUBIT_FAILURE;

   CubitStatus rval = CUBIT_SUCCESS;

  if( CubitUndo::get_undo_enabled() )
  {
    DLIList<Body*> bodies_to_save;
    bodies_to_save += webcut_body_list;
    bodies_to_save += neighboring_bodies;
    CubitUndo::save_state_with_cubit_file( bodies_to_save );
  }

   const int count = webcut_body_list.size();
   DLIList<BodySM*> result_sm_list;
   DLIList<Body*> body_list(webcut_body_list);
   DLIList<BodySM*> engine_body_sms(count);
   DLIList<Body*> engine_bodies(count);
   GeometryModifyEngine* gme = 0;

   while ( (gme = group_bodies_by_engine(body_list, engine_bodies, engine_body_sms)) )
   {
     DLIList<int> merged_surface_ids;
     DLIList<int> merged_curve_ids;
     DLIList<BodySM*> neighbor_imprint_list;
     if (!preview)
     {
       int i;
       for( i=neighboring_bodies.size(); i--; )
       {
         Body *neighbor_body = neighboring_bodies.get_and_step();
         BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
         GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

         if( gme == neighbor_gme )
         {
           neighbor_imprint_list.append( tmp_body );
           engine_bodies.append( neighbor_body );
         }
       }

       do_attribute_setup();
       DLIList<BodySM*> bodies_sms_to_modify;
       bodies_sms_to_modify += engine_body_sms;
       bodies_sms_to_modify += neighbor_imprint_list;
       push_attributes_before_modify( bodies_sms_to_modify );
       get_merged_curve_and_surface_ids( engine_bodies, merged_surface_ids, merged_curve_ids );
     }

     // Create the planar sheet to cut with
     CubitVector p1, p2, p3, p4;

     // Get the corners of the sheet
     center.next_point( axes[0], width/2.0, p1 );
     p1.next_point( axes[1], -height/2.0, p1 );
     p1.next_point( axes[1], height, p2 );
     p2.next_point( axes[0], -width, p3 );
     p3.next_point( axes[1], -height, p4 );

     BodySM *cutting_tool_ptr = gme->planar_sheet(p1,p2,p3,p4);
     if( cutting_tool_ptr == NULL )
        return CUBIT_FAILURE;

     CubitStatus status = gme->webcut (
       engine_body_sms, cutting_tool_ptr,
       neighbor_imprint_list,
       result_sm_list, imprint_type, preview );

     // Delete the BodySM that was created to be used as a tool
     gme->get_gqe()->delete_solid_model_entities(cutting_tool_ptr) ;

      // just continue the loop if previewing
      if (preview)
      {
        rval = status;
        continue;
      }

      restore_vg_after_modify(result_sm_list, engine_bodies, gme);
      remove_pushed_attributes(result_sm_list, engine_bodies);

      status = finish_webcut( engine_bodies, result_sm_list, merge, status, results_list,
                              &merged_surface_ids, &merged_curve_ids );
      if (!status)
        rval = CUBIT_FAILURE;

      engine_bodies.clean_out();
      engine_body_sms.clean_out();
      result_sm_list.clean_out();
   }

   if (!preview)
     do_attribute_cleanup();

  if( preview == CUBIT_FALSE && CubitUndo::get_undo_enabled() )
  {
    if( rval == CUBIT_SUCCESS )
      CubitUndo::note_result_bodies( results_list );
    else
      CubitUndo::remove_last_undo();
  }

   return rval;
}

CubitStatus GeometryModifyTool::webcut_with_plane(
                                    DLIList<Body*>& webcut_body_list,
                                    const CubitVector &vector1,
                                    const CubitVector &vector2,
                                    const CubitVector &vector3,
                                    DLIList<Body*>& results_list,
                                    DLIList<Body*> &neighboring_bodies,
                                    ImprintType imprint_type,
                                    CubitBoolean merge,
                                    CubitBoolean preview)
{
  if (!okay_to_modify( webcut_body_list, "WEBCUT" ))
    return CUBIT_FAILURE;

  GfxPreview::clear();

  CubitStatus rval = CUBIT_SUCCESS;
  if (preview)
  {
    GeometryModifyTool::plane_preview(webcut_body_list, vector1, vector2, vector3);
    return rval;
  }

  //remove bodies that won't intersect plane bounding box
  remove_bodies_outside_bounding_box( webcut_body_list, vector1, vector2, vector3 );

  if( webcut_body_list.size() == 0 )
  {
    PRINT_INFO("Tool does not intersect any bodies/volumes.\n");
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    DLIList<Body*> bodies_to_save;
    bodies_to_save += webcut_body_list;
    bodies_to_save += neighboring_bodies;
    CubitUndo::save_state_with_cubit_file( bodies_to_save );
  }

  const int count = webcut_body_list.size();
  DLIList<BodySM*> temp_sm_list(webcut_body_list.size());
  DLIList<BodySM*> result_sm_list;
  DLIList<Body*> body_list(webcut_body_list);
  DLIList<BodySM*> engine_body_sms(count);
  DLIList<Body*> engine_bodies(count);
  GeometryModifyEngine* gme = 0;

  // all preview stuff handled before this point
  if(!preview)
    do_attribute_setup();

  while ( (gme = group_bodies_by_engine(body_list, engine_bodies, engine_body_sms)) )
  {

    //get all the child entities that have been merged
    DLIList<int> merged_surface_ids;
    DLIList<int> merged_curve_ids;
    DLIList<BodySM*> neighbor_imprint_list;

    if (!preview)
    {
      int i;
      for( i=neighboring_bodies.size(); i--; )
      {
        Body *neighbor_body = neighboring_bodies.get_and_step();
        BodySM *tmp_body = neighbor_body->get_body_sm_ptr();
        GeometryModifyEngine *neighbor_gme = get_engine( tmp_body );

        if( gme == neighbor_gme )
        {
          neighbor_imprint_list.append( tmp_body );
          engine_bodies.append( neighbor_body );
        }
      }

      DLIList<BodySM*> bodies_sms_to_modify;
      bodies_sms_to_modify += engine_body_sms;
      bodies_sms_to_modify += neighbor_imprint_list;
      push_attributes_before_modify( bodies_sms_to_modify );
      get_merged_curve_and_surface_ids( engine_bodies, merged_surface_ids, merged_curve_ids );
    }

    CubitStatus status = gme->webcut(engine_body_sms, vector1, vector2,
              vector3, neighbor_imprint_list, result_sm_list, imprint_type, preview );

    if ( status != CUBIT_FAILURE )
    {
      if(!preview)
      {
        restore_vg_after_modify(result_sm_list, engine_bodies, gme);
        remove_pushed_attributes(result_sm_list, engine_bodies);
      }
      status = finish_webcut( engine_bodies, result_sm_list, merge, status, results_list,
                              &merged_surface_ids, &merged_curve_ids );
    }
    else
    {
      if(!preview)
        remove_pushed_attributes(result_sm_list, engine_bodies);
    }

    engine_bodies.clean_out();
    engine_body_sms.clean_out();
    result_sm_list.clean_out();

    if ( status == CUBIT_FAILURE )
    {
      rval = CUBIT_FAILURE;
      break;
    }
  }

  if( CubitUndo::get_undo_enabled() && preview == CUBIT_FALSE )
  {
    if( rval == CUBIT_SUCCESS )
      CubitUndo::note_result_bodies( results_list );
    else
      CubitUndo::remove_last_undo();
  }

  if(!preview)
    do_attribute_cleanup();

  return rval;
}

void GeometryModifyTool::remove_pushed_attributes(DLIList<BodySM*> &new_sms,
                                                        DLIList<Body*> &old_bodies)
{
  DLIList<TopologyBridge*> old_bridges(old_bodies.size());
  DLIList<TopologyBridge*> new_bridges(new_sms.size());
  CAST_LIST(new_sms, new_bridges, TopologyBridge);

  // Get bridges for all of the old Bodies.
  int k;
  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);
      DLIList<TopologyBridge*> bridge_list;
      bridge_list.append(tb);
      // Add any bodies with composites to the new_sms list so that
      // make_Body gets called on them.  This will make sure that the
      // virtual gets ref entities properly built.
      if(this->contains_composites(bridge_list))
      {
        BodySM *bsm = dynamic_cast<BodySM*>(tb);
        if(bsm)
          new_sms.append_unique(bsm);
      }
    }
  }

  // Make a list including all of the bridges passed in.
  DLIList<TopologyBridge*> all_bridges;
  all_bridges = new_bridges;
  for(k=old_bridges.size(); k--;)
    all_bridges.append_unique(old_bridges.get_and_step());   
  
  
  //Remove ENTITY_ID attributes off non-virtual entities
  DLIList<CubitSimpleAttrib> list;
  for( k=all_bridges.size(); k--; )
  {
    TopologyBridge *top_bridge = all_bridges.get_and_step();    
    GeometryModifyEngine *gme = get_engine(top_bridge);    
    DLIList<TopologyBridge*> children;
    gme->get_possible_invalid_tbs(all_bridges, children);

    for( int j=children.size(); j--; )
    {
      TopologyBridge *tmp_bridge = children.get_and_step();
      if( !GeometryQueryTool::instance()->is_intermediate_geometry( tmp_bridge ) )
      {
        tmp_bridge->get_simple_attribute( "ENTITY_ID", list );
        while( list.size() )    
          tmp_bridge->remove_simple_attribute_virt(list.pop());
      }
    }
  }    

  // At this point we don't need any more attributes on the underlying
  // entities so make sure they are cleaned up.
  GeometryQueryTool::instance()->ige_remove_attributes( all_bridges );
}

CubitStatus GeometryModifyTool::restore_vg_after_modify(DLIList<BodySM*> &new_sms,
                                                        DLIList<Body*> &old_bodies,
                                                        GeometryModifyEngine *gme)
{
  DLIList<TopologyBridge*> old_bridges(old_bodies.size());
  DLIList<TopologyBridge*> new_bridges(new_sms.size());
  CAST_LIST(new_sms, new_bridges, TopologyBridge);

  // Get bridges for all of the old Bodies.
  int k;
  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);
      DLIList<TopologyBridge*> bridge_list;
      bridge_list.append(tb);
      // Add any bodies with composites to the new_sms list so that
      // make_Body gets called on them.  This will make sure that the
      // virtual gets ref entities properly built.
      if(this->contains_composites(bridge_list))
      {
        BodySM *bsm = dynamic_cast<BodySM*>(tb);
        if(bsm)
          new_sms.append_unique(bsm);
      }
    }
  }

  // Make a list including all of the bridges passed in.
  DLIList<TopologyBridge*> all_bridges;
  all_bridges = new_bridges;
  for(k=old_bridges.size(); k--;)
    all_bridges.append_unique(old_bridges.get_and_step());

  DLIList<TopologyBridge*> tbs_to_check;
  if(gme)
    gme->get_possible_invalid_tbs(all_bridges, tbs_to_check);

  DLIList<Surface*> all_surfs;
  DLIList<Curve*> all_curves;
  DLIList<TBPoint*> all_points;
  if(tbs_to_check.size() > 0)
  {
    for(k=tbs_to_check.size(); k--;)
    {
      TopologyBridge *tb = tbs_to_check.get_and_step();
      Surface *surf = dynamic_cast<Surface*>(tb);
      if(surf)
        all_surfs.append(surf);
      else
      {
        Curve *cur = dynamic_cast<Curve*>(tb);
        if(cur)
          all_curves.append(cur);
        else
        {
          TBPoint *pt = dynamic_cast<TBPoint*>(tb);
          if(pt)
            all_points.append(pt);
        }
      }
    }
  }

  // This function has been changed to blown away any virtual (really only doing
  // composites right now).  The virtual will rebuilt from the attributes stored
  // on the  entities.
  GeometryQueryTool::instance()->ige_remove_modified(all_surfs, all_curves, all_points);

  //Restore virtual
  GeometryQueryTool::instance()->ige_import_geom( all_bridges );

  return CUBIT_SUCCESS;
}

GeometryModifyEngine* GeometryModifyTool::group_bodies_by_engine(
                                  DLIList<Body*>& remaining_bodies,
                                  DLIList<Body*>& engine_bodies,
                                  DLIList<BodySM*>& engine_body_sms ) const
{
  int i = remaining_bodies.size();
  remaining_bodies.reset();
  GeometryModifyEngine* engine = 0;

  if (i == 0)
    return 0;

    // Skip over any bodies that don't have a modify engine.
  while (i--)
  {
    Body* body = remaining_bodies.get();
    TopologyBridge* bridge = 0;
    engine = get_engine(body, &bridge);
    if (engine)
    {
      remaining_bodies.change_to(0);
      engine_bodies.append(body);
      engine_body_sms.append(dynamic_cast<BodySM*>(bridge));
      remaining_bodies.step();
      break;
    }
    remaining_bodies.step();
  }

  // catch case where no engine was found
  if (0 == engine)
  {
    PRINT_WARNING("No geometry modify engine found for this operation.");
    return engine;
  }


    // Get remaining bodies with same modify engine.
  while (i--)
  {
    Body* body = remaining_bodies.get();
    TopologyBridge* bridge = 0;
    if (get_engine(body, &bridge) == engine)
    {
      remaining_bodies.change_to(0);
      engine_bodies.append(body);
      engine_body_sms.append(dynamic_cast<BodySM*>(bridge));
    }
    remaining_bodies.step();
  }

  remaining_bodies.remove_all_with_value(0);
  return engine;
}




// ********** END PRIVATE FUNCTIONS        **********

// ********** BEGIN HELPER CLASSES         **********
// ********** END HELPER CLASSES           **********

// ********** BEGIN EXTERN FUNCTIONS       **********
// ********** END EXTERN FUNCTIONS         **********

// ********** BEGIN STATIC FUNCTIONS       **********
// ********** END STATIC FUNCTIONS         **********

CubitStatus GeometryModifyTool::unite( DLIList<BodySM*> &body_sm_list,
                                       DLIList<BodySM*> &new_body_sm_list,
                                       bool keep_old)
{
  //this assumes that all bodies have the same modify engine
  GeometryModifyEngine *gme = get_engine( body_sm_list.get() );
  CubitStatus result = gme->unite(body_sm_list, new_body_sm_list, keep_old);
  return result;
}

CubitStatus
GeometryModifyTool::unite( DLIList<Body*> &bodies,
                           DLIList<Body*> &new_body_list,
                           bool keep_old )
{
  if( bodies.size() <= 1 )
  {
    PRINT_WARNING("There is only one volume in the list. Nothing modified.\n");
    return CUBIT_FAILURE;
  }
  if (!okay_to_modify( bodies, "UNITE" ))
    return CUBIT_FAILURE;

  int i;
  const int count = bodies.size();
  DLIList<TopologyEntity*> entity_list(count);
  DLIList<TopologyBridge*> bridge_list(count);
  bodies.reset();
  for (i = bodies.size(); i--; )
    entity_list.append_unique(bodies.get_and_step());
  GeometryModifyEngine* gme = common_modify_engine( entity_list, bridge_list );

  if( !gme )
  {
    PRINT_ERROR("Performing UNITE with volumes containing geometry from\n"
      "different modeling engines is not allowed.\n"
      "Delete uncommon geometry on these volumes before operation.\n\n");
    return CUBIT_FAILURE;
  }

  // Cubit can't mesh mixed sheet/solid bodies that are united together. If
  // required, separate the unite between these types.
  CubitStatus result;
  if( GeometryModifyTool::instance()->unite_mixed_models() )
    result = unite_all( gme, bodies, new_body_list, keep_old );
  else
    result = unite_separately( gme, bodies, new_body_list, keep_old );

  if( result == CUBIT_FAILURE )
    PRINT_ERROR("UNITE failed\n");

  return result;
}

CubitStatus
GeometryModifyTool::unite_separately( GeometryModifyEngine *gme_ptr,
                                      DLIList<Body*> &bodies,
                                      DLIList<Body*> &new_body_list,
                                      bool keep_old )
{
  // Cubit can't mesh mixed sheet/solid bodies that are united together. Sort
  // based on these types.
  int i;
  Body *body_ptr;
  DLIList<Body*> solid_body_list;
  DLIList<Body*> sheet_body_list;
  bodies.reset();
  for( i=bodies.size(); i--; )
  {
    body_ptr = bodies.get_and_step();

    if( body_ptr->is_sheet_body() )
      sheet_body_list.append( body_ptr );
    else
      solid_body_list.append( body_ptr );
  }

  if( sheet_body_list.size() == 1 && solid_body_list.size() == 1 )
  {
    PRINT_ERROR( "Cannot unite solid and sheet bodies together\n" );
    return CUBIT_FAILURE;
  }

  // Setup undo
  if( CubitUndo::get_undo_enabled() )
  {
    if( keep_old )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( bodies );
  }

  // Unite solids with each other, and sheets with each other separately
  CubitStatus result1 = CUBIT_SUCCESS;
  CubitStatus result2 = CUBIT_SUCCESS;
  if( solid_body_list.size() > 1 )
    result1 = unite_private( gme_ptr, solid_body_list, new_body_list, keep_old );
  if( sheet_body_list.size() > 1 )
    result2 = unite_private( gme_ptr, sheet_body_list, new_body_list, keep_old );

  // Finish undo
  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body_list.size() )
      CubitUndo::note_result_bodies( new_body_list );
    else
      CubitUndo::remove_last_undo();
  }

  // Return success if both unites successful
  if( result1 == CUBIT_SUCCESS && result2 == CUBIT_SUCCESS )
    return CUBIT_SUCCESS;

  // Return success if either unite was successful
  if( ( solid_body_list.size() > 1 && result1 == CUBIT_SUCCESS ) ||
      ( sheet_body_list.size() > 1 && result2 == CUBIT_SUCCESS ) )
  {
    // Give warning if one or the other failed
    if( result1 == CUBIT_FAILURE )
      PRINT_WARNING( "Unite of solid volumes failed\n" );
    if( result2 == CUBIT_FAILURE )
      PRINT_WARNING( "Unite of sheet bodies failed\n" );

    return CUBIT_SUCCESS;
  }

  return CUBIT_FAILURE;
}

CubitStatus
GeometryModifyTool::unite_all( GeometryModifyEngine *gme_ptr,
                               DLIList<Body*> &bodies,
                               DLIList<Body*> &new_body_list,
                               bool keep_old )
{
  // Setup undo
  if( CubitUndo::get_undo_enabled() )
  {
    if( keep_old )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( bodies );
  }

  // Unite solids with each other, and sheets with each other separately
  CubitStatus result = unite_private( gme_ptr, bodies, new_body_list, keep_old );

  // Finish undo
  if( CubitUndo::get_undo_enabled() )
  {
    if( new_body_list.size() )
      CubitUndo::note_result_bodies( new_body_list );
    else
      CubitUndo::remove_last_undo();
  }

  return result;
}

// Private workhorse function for unite
CubitStatus
GeometryModifyTool::unite_private( GeometryModifyEngine *gme_ptr,
                                   DLIList<Body*> &body_list,
                                   DLIList<Body*> &new_body_list,
                                   bool keep_old )
{
  if( !body_list.size() )
    return CUBIT_SUCCESS;

  int i, j;
  Body *body_ptr;
  CubitStatus result;

  // Give 1st body all the names of all bodies being united
  std::list<CubitString> names_list;
  DLIList<CubitString> entity_names;

  body_list.reset();
  for( i=body_list.size(); i--; )
  {
    body_ptr = body_list.get_and_step();

    // See if body has names
    if( body_ptr->num_names() )
    {
      // Put the names in a list
      body_ptr->entity_names( entity_names );
      entity_names.reset();

      // Loop through names
      for( j=entity_names.size(); j--; )
        names_list.push_back( entity_names.get_and_step() );

      entity_names.clean_out();
      body_ptr->remove_entity_names();
    }
  }

  do_attribute_setup();

  DLIList<TopologyEntity*> entity_list(body_list.size());
  DLIList<TopologyBridge*> bridge_list(body_list.size());
  body_list.reset();
  for( i=body_list.size(); i--; )
    entity_list.append_unique(body_list.get_and_step());
  common_modify_engine( entity_list, bridge_list );

  DLIList<BodySM*> body_sm_list(body_list.size());
  CAST_LIST(bridge_list, body_sm_list, BodySM);

  push_attributes_before_modify(body_sm_list);

  DLIList<int> merged_surface_ids;
  DLIList<int> merged_curve_ids;

  get_merged_curve_and_surface_ids( body_list, merged_surface_ids, merged_curve_ids );

  DLIList<BodySM*> new_body_sm_list;
  result = unite( body_sm_list, new_body_sm_list, keep_old );

  restore_vg_after_modify( new_body_sm_list, body_list, gme_ptr );
  remove_pushed_attributes( new_body_sm_list, body_list );

  DLIList<Body*> result_list;
  if( !finish_sm_op(body_list, new_body_sm_list, result_list) )
    result = CUBIT_FAILURE;

  if( keep_old == CUBIT_FALSE )
    fixup_merged_entities( merged_surface_ids, merged_curve_ids );

  do_attribute_cleanup();

  if( result )
  {
    new_body_list += result_list;

    for( j=result_list.size(); j--; )
    {
      //Add names to 1st body
      std::list<CubitString>::iterator iter, end = names_list.end();
      for (iter = names_list.begin(); iter != end; ++iter)
        result_list.get_and_step()->entity_name( *iter );
    }
  }

  return result;
}

CubitStatus GeometryModifyTool::chop( DLIList<Body*> &bodies,
                                      DLIList<Body*> &intersectBodies,
                                      DLIList<Body*> &outsideBodies,
                                      Body*& leftoversBody,
                                      bool keep_old,
                                      bool nonreg )
{
   leftoversBody = 0;
   if (bodies.size() <= 1)
   {
      PRINT_WARNING("There is only one body in the list. Nothing modified\n");
      return CUBIT_FAILURE;
   }
   if (!okay_to_modify( bodies, "CHOP" ))
     return CUBIT_FAILURE;

  int i;
  const int count = bodies.size();
  DLIList<Body*> original_body_list = bodies;
  DLIList<TopologyEntity*> entity_list(count);
  DLIList<TopologyBridge*> bridge_list(count);
  bodies.reset();
  for (i = bodies.size(); i--; )
    entity_list.append_unique(bodies.get_and_step());
  GeometryModifyEngine* gme = common_modify_engine( entity_list, bridge_list );

  if ( !gme )
  {
      PRINT_ERROR("Performing CHOP with volumes containing geometry\n"
                  " from different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
  }

   DLIList<BodySM*> body_sm_list;
   CAST_LIST( bridge_list, body_sm_list, BodySM );
   DLIList<BodySM*> intersect_bodies, outside_bodies;
   BodySM *leftovers_body = 0;

   if( CubitUndo::get_undo_enabled() )
   {
     if( keep_old )
       CubitUndo::save_state();
     else
     {
       //Get all the bodies associated with the vertex
       CubitUndo::save_state_with_cubit_file( bodies );
     }
   }

   DLIList<int> merged_surface_ids;
   DLIList<int> merged_curve_ids;
   DLIList<Body*> tmp_bodies(1);
   tmp_bodies.append( bodies.get() );
   if( keep_old == CUBIT_FALSE )
     get_merged_curve_and_surface_ids( tmp_bodies, merged_surface_ids, merged_curve_ids );

   do_attribute_setup();

   // Push attributes down onto the blank body (first one in list).
   DLIList<BodySM*> tmp_body_sm_list;
   body_sm_list.reset();
   tmp_body_sm_list.append(body_sm_list.get());
   push_attributes_before_modify(tmp_body_sm_list);

   CubitStatus result = gme->chop( body_sm_list, intersect_bodies,
                          outside_bodies, leftovers_body, keep_old, nonreg );

   if( result == CUBIT_FAILURE )
   {
     if( CubitUndo::get_undo_enabled() )
       CubitUndo::remove_last_undo();

     PRINT_ERROR("CHOP failed\n");
     remove_pushed_attributes(tmp_body_sm_list, tmp_bodies);
     do_attribute_cleanup();
     return CUBIT_FAILURE;
   }

   DLIList<BodySM*> all_sms = intersect_bodies;
   all_sms += outside_bodies;

   restore_vg_after_modify(all_sms, tmp_bodies, gme);
   remove_pushed_attributes(all_sms, tmp_bodies);

   DLIList<Body*> result_bodies;

   body_sm_list.clean_out();
   body_sm_list += intersect_bodies;

   CubitStatus stat = finish_sm_op(bodies, body_sm_list, result_bodies);

   if( CubitUndo::get_undo_enabled() )
   {
     if( stat == CUBIT_SUCCESS )
       CubitUndo::note_result_bodies( result_bodies );
     else
       CubitUndo::remove_last_undo();
   }

   if( stat == CUBIT_FAILURE )
   {
     if( CubitUndo::get_undo_enabled() )
       CubitUndo::remove_last_undo();

     PRINT_ERROR("CHOP failed\n");
     do_attribute_cleanup();
     return CUBIT_FAILURE;
   }
   intersectBodies += result_bodies;
   bodies.clean_out();

   body_sm_list.clean_out();
   body_sm_list += outside_bodies;
   result_bodies.clean_out();
   if (!finish_sm_op(bodies, body_sm_list, result_bodies))
   {
     if( CubitUndo::get_undo_enabled() )
       CubitUndo::remove_last_undo();

     PRINT_ERROR("CHOP failed\n");
     do_attribute_cleanup();
     return CUBIT_FAILURE;
   }
   outsideBodies += result_bodies;

   if( leftovers_body )
   {
     body_sm_list.clean_out();
     body_sm_list.append( leftovers_body );
     result_bodies.clean_out();
     if (!finish_sm_op(bodies, body_sm_list, result_bodies))
     {
       if( CubitUndo::get_undo_enabled() )
         CubitUndo::remove_last_undo();

       PRINT_ERROR("CHOP failed\n");
       do_attribute_cleanup();
       return CUBIT_FAILURE;
     }
     leftoversBody = result_bodies.get();

   }

   if( keep_old == CUBIT_FALSE )
     fixup_merged_entities( merged_surface_ids, merged_curve_ids);

  if( CubitUndo::get_undo_enabled() )
  {
    if( leftoversBody )
    {
      DLIList<Body*> tmp_list(1);
      tmp_list.append( leftoversBody );
      CubitUndo::note_result_bodies( tmp_list );
    }
    CubitUndo::note_result_bodies( intersectBodies );
    CubitUndo::note_result_bodies( outsideBodies );
  }

  do_attribute_cleanup();
  return CUBIT_SUCCESS;
}

CubitStatus GeometryModifyTool::hollow( DLIList<Body*>& bodies,
                                        DLIList<RefFace*> faces_to_remove,
                                        DLIList<Body*>& new_bodies,
                                        double depth)
{
  if (bodies.size() <= 0 || faces_to_remove.size() <= 0)
  {
     PRINT_WARNING("Needs at least one body and one face. Nothing modified\n");
     return CUBIT_FAILURE;
  }

  if (!okay_to_modify( bodies, "HOLLOW" ))
    return CUBIT_FAILURE;

  // Get the GeometryEngine for each Body of the list to check
  // if they are the same and if they are GeometryModifyEngine

  const int count = bodies.size();
  DLIList<TopologyEntity*> entity_list(count);
  DLIList<TopologyBridge*> bridge_list(count);
  CAST_LIST_TO_PARENT(bodies, entity_list);
  GeometryModifyEngine* gme = common_modify_engine( entity_list, bridge_list );

  if (!gme)
  {
     PRINT_ERROR("Performing THICKEN with volumes containing geometry\n"
                 " from different modeling engines is not allowed.\n"
                 "Delete uncommon geometry on these volumes before operation.\n\n");
     return CUBIT_FAILURE;
  }

  DLIList<BodySM*> new_sms(count);
  DLIList<BodySM*> body_sms(count);
  CAST_LIST(bridge_list, body_sms, BodySM);

  if( CubitUndo::get_undo_enabled() )
  {
    CubitUndo::save_state_with_cubit_file( bodies );
  }

  DLIList <Surface*> surfs_to_remove;
  for(int i = 0 ; i < faces_to_remove.size(); i++)
  {
    Surface* surf = faces_to_remove.get_and_step()->get_surface_ptr();
    if(surf)
      surfs_to_remove.append(surf);
  }


  DLIList<int> merged_surface_ids;
  DLIList<int> merged_curve_ids;
  get_merged_curve_and_surface_ids( bodies, merged_surface_ids, merged_curve_ids );
  do_attribute_setup();

  // Push attributes down onto the bodies to be hollowed
  push_attributes_before_modify( body_sms );

  CubitStatus result = gme->hollow( body_sms, surfs_to_remove, new_sms, depth);

   if( result == CUBIT_FAILURE )
   {
     if( CubitUndo::get_undo_enabled() )
       CubitUndo::remove_last_undo();

     PRINT_ERROR("Hollow failed\n");
     remove_pushed_attributes(body_sms, bodies);
     do_attribute_cleanup();
     return CUBIT_FAILURE;
   }

  // check for resued entities, they have been moved and we need to notify observers
  DLIList<RefEntity*> entities_to_update;
  int i;
  for(i=0; i<new_sms.size(); i++)
  {
    BodySM* bodysm = new_sms.get_and_step();
    DLIList<TopologyBridge*> to_check;
    DLIList<TopologyBridge*> tmp;
    DLIList<Surface*> surfs;
    bodysm->surfaces(surfs);
    DLIList<Curve*> curves;
    bodysm->curves(curves);
    DLIList<TBPoint*> points;
    bodysm->points(points);
    to_check.append(bodysm);
    to_check.append(bodysm->lump());
    CAST_LIST_TO_PARENT(surfs, tmp);
    to_check += tmp;
    CAST_LIST_TO_PARENT(curves, tmp);
    to_check += tmp;
    CAST_LIST_TO_PARENT(points, tmp);
    to_check += tmp;

    int k;
    for(k=0; k<to_check.size(); k++)
      if(BridgeManager* m = to_check.get_and_step()->bridge_manager())
        if(TopologyEntity* t = m->topology_entity())
          entities_to_update.append(CAST_TO(t, RefEntity));

  }

  restore_vg_after_modify( new_sms, bodies, gme );
  remove_pushed_attributes( new_sms, bodies );

  result = finish_sm_op(bodies, new_sms, new_bodies);
  fixup_merged_entities( merged_surface_ids, merged_curve_ids);

  if (CUBIT_FAILURE == result) {
    if( CubitUndo::get_undo_enabled() )
      CubitUndo::remove_last_undo();

    PRINT_ERROR("Hollow failed\n");
    do_attribute_cleanup();
    return CUBIT_FAILURE;
  }
  else if( CubitUndo::get_undo_enabled() ) {
    CubitUndo::note_result_bodies( new_bodies );
  }

  do_attribute_cleanup();
  return CUBIT_SUCCESS;
}

CubitStatus GeometryModifyTool::thicken( DLIList<Body*>& bodies,
                                         DLIList<Body*>& new_bodies,
                                         double depth,
                                         bool both )
{
  if (bodies.size() <= 0)
  {
     PRINT_WARNING("There is only one body in the list. Nothing modified\n");
     return CUBIT_FAILURE;
  }

  if (!okay_to_modify( bodies, "THICKEN" ))
    return CUBIT_FAILURE;

  // Get the GeometryEngine for each Body of the list to check
  // if they are the same and if they are GeometryModifyEngine

  const int count = bodies.size();
  DLIList<TopologyEntity*> entity_list(count);
  DLIList<TopologyBridge*> bridge_list(count);
  CAST_LIST_TO_PARENT(bodies, entity_list);
  GeometryModifyEngine* gme = common_modify_engine( entity_list, bridge_list );

  if (!gme)
  {
     PRINT_ERROR("Performing THICKEN with volumes containing geometry\n"
                 " from different modeling engines is not allowed.\n"
                 "Delete uncommon geometry on these volumes before operation.\n\n");
     return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() )
    CubitUndo::save_state_with_cubit_file( bodies );

  DLIList<BodySM*> new_sms(count);
  DLIList<BodySM*> body_sms(count);
  CAST_LIST(bridge_list, body_sms, BodySM);
  CubitStatus result = gme->thicken( body_sms, new_sms, depth, both);

  // check for resued entities, they have been moved and we need to notify observers
  DLIList<RefEntity*> entities_to_update;
  int i;
  for(i=0; i<new_sms.size(); i++)
  {
    BodySM* bodysm = new_sms.get_and_step();
    DLIList<TopologyBridge*> to_check;
    DLIList<TopologyBridge*> tmp;
    DLIList<Surface*> surfs;
    bodysm->surfaces(surfs);
    DLIList<Curve*> curves;
    bodysm->curves(curves);
    DLIList<TBPoint*> points;
    bodysm->points(points);
    to_check.append(bodysm);
    to_check.append(bodysm->lump());
    CAST_LIST_TO_PARENT(surfs, tmp);
    to_check += tmp;
    CAST_LIST_TO_PARENT(curves, tmp);
    to_check += tmp;
    CAST_LIST_TO_PARENT(points, tmp);
    to_check += tmp;

    int k;
    for(k=0; k<to_check.size(); k++)
      if(BridgeManager* m = to_check.get_and_step()->bridge_manager())
        if(TopologyEntity* t = m->topology_entity())
          entities_to_update.append(CAST_TO(t, RefEntity));

  }

  if (!finish_sm_op(bodies, new_sms, new_bodies))
    result = CUBIT_FAILURE;

  if( CubitUndo::get_undo_enabled() )
  {
    if( new_bodies.size() )
      CubitUndo::note_result_bodies( new_bodies );
    else
      CubitUndo::remove_last_undo();
  }

  // Update graphics
  while (entities_to_update.size())
  {
    RefEntity* entity = entities_to_update.pop();
    AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::GEOMETRY_MODIFIED, entity));
  }

  return result;
}


CubitStatus GeometryModifyTool::validate_normals(DLIList<Body*>& bodies,
                                                 RefFace *surf_ref,
                                                 bool reverse)
{
   if (bodies.size() <= 0)
   {
      PRINT_WARNING("There are no entities in the list. Nothing modified\n");
      return CUBIT_FAILURE;
   }

   DLIList<RefEntity*> temp;
   CAST_LIST_TO_PARENT(bodies, temp);
   if ( !same_modify_engine(temp, CUBIT_TRUE))
   {
      PRINT_ERROR("Performing VALIDATE NORMALS with volumes containing geometry\n"
            "      from different modeling engines is not allowed. Delete uncommon\n"
            "      geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

   // Get the GeometryEngine for each Body of the list to check
   // if they are the same and if they are GeometryModifyEngine
   GeometryModifyEngine* gePtr1 = get_engine(bodies.get());
   GeometryModifyEngine* gePtr2;
   Body* Body_ptr = NULL;
   bodies.reset();
   for( int i = bodies.size(); i > 0; i--)
   {
      Body_ptr = bodies.get_and_step();
      gePtr2 = get_engine(Body_ptr);
      if (gePtr1 != gePtr2)
      {
         PRINT_ERROR("In GeometryModifyTool::validate_normals\n"
            "  Volumes are associated with different GMEs. \n");
         return CUBIT_FAILURE;
      }
      if ( gePtr2 == NULL)
      {
         PRINT_ERROR("In GeometryModifyTool::validate_normals\n"
            "       Body %d is not associated with a SME.\n",
            Body_ptr->id());
         return CUBIT_FAILURE;
      }
   }


   DLIList<RefFace*> ref_face_list;
   DLIList<RefFace*> free_face_list;
   DLIList<RefFace*> bad_face_list;

   //gather all the faces from all the bodies
   bodies.reset();
   for( int i=bodies.size(); i--; )
   {
     Body* BodyPtr = bodies.get_and_step();
     BodyPtr->ref_faces(free_face_list);
   }

   RefFace *ref_face_ptr;
   RefFace *inter_face_ptr;

   if(surf_ref != NULL)   // getting the starting surface
   {
     ref_face_ptr = surf_ref;
   }
   else
   {
     ref_face_ptr = free_face_list.get_and_step();
   }

   ref_face_list.append(ref_face_ptr);
   free_face_list.remove(ref_face_ptr);
   free_face_list.reset();

   while(free_face_list.size())
   {
      DLIList<RefEdge*> curve_list;
      ref_face_ptr->ref_edges(curve_list);
      free_face_list.reset();
      for(int jj=free_face_list.size(); jj > 0; jj--)  // getting a new searching surface
      {
         inter_face_ptr = free_face_list.get_and_step();
         DLIList<RefEdge*> inter_curve_list;
         inter_face_ptr->ref_edges(inter_curve_list);
         curve_list.reset();
        // PRINT_INFO("base face %d working on face %d\n", ref_face_ptr->id(),inter_face_ptr->id());

         for (int k= curve_list.size(); k > 0; k--)  // looping through all of the surface curves
         {
            RefEdge *ref_check_curve = curve_list.step_and_get();
            inter_curve_list.reset();

            for (int kk = inter_curve_list.size(); kk > 0; kk--)
            {
               RefEdge *check_curve = inter_curve_list.step_and_get();

               if(ref_check_curve == check_curve)  // finding if a surface is connected
               {
                  DLIList<CoEdge*> coedge_list;
                  check_curve->co_edges(coedge_list);

                  CoEdge* first_coedge = coedge_list.get_and_step();
                  CoEdge* second_coedge = coedge_list.get_and_step();

                  if((first_coedge->get_sense() == second_coedge->get_sense() &&
                     !bad_face_list.is_in_list(ref_face_ptr) ) ||
                     (first_coedge->get_sense() != second_coedge->get_sense() &&
                     bad_face_list.is_in_list(ref_face_ptr) ))    // finding if a surface has a fliped normal
                  {
                     bad_face_list.append(inter_face_ptr);
                     PRINT_INFO("Surface %d is not consistent\n", inter_face_ptr->id());
                  }

                  ref_face_list.append(inter_face_ptr);  // adding to the searched list
                  free_face_list.remove(inter_face_ptr); // removing from the unsearched list
               }

            }

         }

      }

      ref_face_list.remove(ref_face_ptr);     // removeing from the searched list
      ref_face_list.last();
      if(ref_face_list.size() <= 0)
      {
         PRINT_ERROR("In GeometryModifyTool::validate_normals\n"
            "       all surfaces must be connected\n");
         return CUBIT_FAILURE;
      }
      ref_face_ptr = ref_face_list.get();
  }

  if (reverse && bad_face_list.size())
  {
     //CubitStatus result = gePtr1->flip_normals(bad_face_list);
     CubitStatus result = GeometryModifyTool::instance()->reverse(bad_face_list);
     if ( result == CUBIT_FAILURE )
     {
       return CUBIT_FAILURE;
    }
  }
  else if(!bad_face_list.size())
  {
    PRINT_INFO("All surfaces are consistent\n");
  }
  return CUBIT_SUCCESS;
}



CubitStatus GeometryModifyTool::subtract( Body* tool_body, DLIList<Body*> &from_bodies,
                                          DLIList<Body*> &new_bodies,
                                          bool imprint,
                                          bool keep_old )
{
  DLIList<Body*> temp_body_list;
  temp_body_list.append(tool_body);
  return subtract(temp_body_list, from_bodies, new_bodies, imprint, keep_old);
}


CubitStatus GeometryModifyTool::subtract( DLIList<Body*>  &tool_body_list,
                                          DLIList<Body*> &from_bodies,
                                          DLIList<Body*> &new_bodies,
                                          bool imprint,
                                          bool keep_old )
{
   if(tool_body_list.size() == 0 )
       return CUBIT_FAILURE;
   if(from_bodies.size() == 0 )
       return CUBIT_FAILURE;
   DLIList<Body*> tem_bodies(tool_body_list);

   // cannot subtract from self
   int old_size = from_bodies.size();
   from_bodies -= tool_body_list;
   if (from_bodies.size() != old_size)
   {
     PRINT_WARNING("Cannot subtract body from itself.  Ignoring \"from\" body.\n");
     if (!from_bodies.size())
       return CUBIT_FAILURE;
   }

   tem_bodies += from_bodies;
   if (!okay_to_modify( tem_bodies, "SUBTRACT" ))
     return CUBIT_FAILURE;

   DLIList<BodySM*> tool_sms(tool_body_list.size());
   DLIList<BodySM*> from_sms(from_bodies.size());
   GeometryModifyEngine* gme = common_modify_engine( tool_body_list, tool_sms );
   GeometryModifyEngine* gme2 = common_modify_engine( from_bodies, from_sms );
   if (!gme || gme != gme2)
   {
      PRINT_ERROR("Performing SUBTRACTION with volumes containing geometry\n"
                  "from different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

   if( CubitUndo::get_undo_enabled() )
   {
     if( keep_old )
       CubitUndo::save_state();
     else
     {
       //Get all the bodies associated with the vertex
       DLIList<Body*> bodies;
       bodies += tool_body_list;
       bodies += from_bodies;
       CubitUndo::save_state_with_cubit_file( bodies );
     }
   }

   DLIList<int> merged_surface_ids;
   DLIList<int> merged_curve_ids;
   if( keep_old == CUBIT_FALSE )
     get_merged_curve_and_surface_ids( from_bodies, merged_surface_ids, merged_curve_ids );


     // Do the subtract operation
   DLIList<BodySM*> new_sms;
   CubitStatus result = gme->subtract(tool_sms, from_sms, new_sms, imprint, keep_old );

   if( CubitUndo::get_undo_enabled() && result == CUBIT_FAILURE )
     CubitUndo::remove_last_undo();

   CubitStatus result2 = finish_sm_op(tem_bodies, new_sms, new_bodies);

   if( CubitUndo::get_undo_enabled() )
   {
     if( result == CUBIT_SUCCESS )
       CubitUndo::note_result_bodies( new_bodies );
     else
       CubitUndo::remove_last_undo();
   }

   if ( result == CUBIT_FAILURE || result2 == CUBIT_FAILURE)
   {
     PRINT_ERROR("Subtract FAILED\n" );
     return CUBIT_FAILURE;
   }

   if( keep_old == CUBIT_FALSE )
     fixup_merged_entities( merged_surface_ids, merged_curve_ids);

   return CUBIT_SUCCESS;
}

CubitStatus GeometryModifyTool::intersect( DLIList<Body*> &from_bodies,
                                           DLIList<Body*> &new_bodies,
                                           bool keep_old,
                                           bool preview)
{
  DLIList<Body*> tem_bodies = from_bodies;
  if (!okay_to_modify( tem_bodies, "INTERSECT" ))
    return CUBIT_FAILURE;

  GfxPreview::clear();

  DLIList<BodySM*> from_sm_list(tem_bodies.size());
  GeometryModifyEngine* engine = common_modify_engine(tem_bodies, from_sm_list);
  if ( NULL == engine )
  {
    PRINT_ERROR("Performing INTERSECTION with volumes containing geometry\n"
                "from different modeling engines is not allowed.\n"
                "Delete uncommon geometry on these volumes before operation.\n\n");
    return CUBIT_FAILURE;
  }

  if( !preview && CubitUndo::get_undo_enabled() )
  {
    if( keep_old )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( from_bodies );
  }

  DLIList<int> merged_surface_ids;
  DLIList<int> merged_curve_ids;
  if( !preview && (keep_old == CUBIT_FALSE) )
    get_merged_curve_and_surface_ids( from_bodies, merged_surface_ids, merged_curve_ids );

  GeometryModifyEngine* gme_ptr = get_engine(from_sm_list.get());
  GeometryQueryEngine* gqe_ptr = gme_ptr->get_gqe();

  DLIList<BodySM*> all_new_bodysms;
  int i,j;
  for( i=0; i<from_sm_list.size(); i++ )
  {
    from_sm_list.reset();
    from_sm_list.step(i);
    BodySM *body1 = from_sm_list.get_and_step();

    for(j=i+1; j<from_sm_list.size(); j++ )
    {
      BodySM *body2 = from_sm_list.get_and_step();

      if( body1 == body2 )
        continue;

      //copy the bodies
      BodySM *body1_copy = gme_ptr->copy_body( body1 );
      BodySM *body2_copy = gme_ptr->copy_body( body2 );

      DLIList<BodySM*> tmp_sm_list(1);
      tmp_sm_list.append( body2_copy );
      DLIList<BodySM*> new_sms;

      CubitStatus result =
          engine->intersect(body1_copy, tmp_sm_list, new_sms, true, preview );

      //delete the copies
      gqe_ptr->delete_solid_model_entities( body1_copy );
      gqe_ptr->delete_solid_model_entities( body2_copy );

      if (!preview)
      {
        if ( result == CUBIT_FAILURE || new_sms.size() == 0 )
        {
          RefEntity* ref_ent1 = dynamic_cast<RefEntity*>(body1->topology_entity());
          RefEntity* ref_ent2 = dynamic_cast<RefEntity*>(body2->topology_entity());

          PRINT_WARNING("INTERSECTION of %s with %s failed\n",
            ref_ent1->entity_name().c_str(),
            ref_ent2->entity_name().c_str() );
          continue;

        }

        all_new_bodysms += new_sms;
      }
    }
  }

  if (!preview)
  {
    //now make all the RefEntities
    all_new_bodysms.reset();
    for( i=all_new_bodysms.size(); i--; )
    {
      Body *new_body = GeometryQueryTool::instance()->make_Body(all_new_bodysms.get_and_step());
      if( new_body )
        new_bodies.append( new_body );
    }

    if( CubitUndo::get_undo_enabled() )
    {
      if( all_new_bodysms.size() )
        CubitUndo::note_result_bodies( new_bodies );
      else
        CubitUndo::remove_last_undo();
    }

    if( keep_old == CUBIT_FALSE )
      fixup_merged_entities( merged_surface_ids, merged_curve_ids);
  }

  return CUBIT_SUCCESS;
}



CubitStatus GeometryModifyTool::intersect( Body *tool_body_ptr,
                                           DLIList<Body*> &from_bodies,
                                           DLIList<Body*> &new_bodies,
                                           bool keep_old,
                                           bool preview)
{
  if(tool_body_ptr == NULL )
    return CUBIT_FAILURE;
  if(from_bodies.size() == 0 || from_bodies.get() == NULL )
    return CUBIT_FAILURE;

  GfxPreview::clear();

  DLIList<Body*> tem_bodies = from_bodies;
  tem_bodies.append( tool_body_ptr );
  if (!okay_to_modify( tem_bodies, "INTERSECT" ))
    return CUBIT_FAILURE;

  DLIList<BodySM*> from_sm_list(tem_bodies.size());
  GeometryModifyEngine* engine = common_modify_engine(tem_bodies, from_sm_list);
  if ( NULL == engine )
  {
    PRINT_ERROR("Performing INTERSECTION with volumes containing geometry\n"
                "from different modeling engines is not allowed.\n"
                "Delete uncommon geometry on these volumes before operation.\n\n");
    return CUBIT_FAILURE;
  }

  BodySM* tool_sm = from_sm_list.pop();


  //cannot intersect tool with itself
  from_sm_list.remove_all_with_value( tool_sm );
  if( from_sm_list.size() == 0 )
  {
    PRINT_ERROR("Cannot intersect volume %d from itself\n",
                 tool_body_ptr->ref_volume()->id() );
    return CUBIT_FAILURE;
  }

  if( !preview && CubitUndo::get_undo_enabled() )
  {
    if( keep_old )
      CubitUndo::save_state();
    else
    {
      DLIList<Body*> bodies;
      bodies.append( tool_body_ptr );
      bodies += from_bodies;
      CubitUndo::save_state_with_cubit_file( bodies );
    }
  }

  DLIList<int> merged_surface_ids;
  DLIList<int> merged_curve_ids;
  if( !preview && (keep_old == CUBIT_FALSE) )
    get_merged_curve_and_surface_ids( from_bodies, merged_surface_ids, merged_curve_ids );

     // Do the intersect operation
  DLIList<BodySM*> new_sms;
  CubitStatus result =
      engine->intersect(tool_sm, from_sm_list, new_sms, keep_old, preview );

  if (!preview)
  {
    result = finish_sm_op(tem_bodies, new_sms, new_bodies);

    if( CubitUndo::get_undo_enabled() )
    {
      if( result == CUBIT_SUCCESS )
        CubitUndo::note_result_bodies( new_bodies );
      else
        CubitUndo::remove_last_undo();
    }

    if ( result == CUBIT_FAILURE )
    {
      PRINT_ERROR("Intersect FAILED\n" );
      return CUBIT_FAILURE;
    }

    if( keep_old == CUBIT_FALSE )
      fixup_merged_entities( merged_surface_ids, merged_curve_ids);
  }

  return CUBIT_SUCCESS;
}

CubitStatus GeometryModifyTool::imprint( DLIList<Body*> &from_body_list,
                                         DLIList<Body*> &new_body_list,
                                         CubitBoolean keep_old )
{
  if( from_body_list.size() == 1 )
  {
    PRINT_WARNING("Need more than 1 body or volume to imprint.\n");
    return CUBIT_FAILURE;
  }

   if (get_group_imprint() == CUBIT_FALSE)
   {
     CubitStatus result = imprint_singly( from_body_list, new_body_list, keep_old );
     return result;
   }

     // Check the GeometryEngine for each of the Body's; check to
     // make sure they're all the same
   from_body_list.reset();
   if (!okay_to_modify( from_body_list, "IMPRINT" ))
     return CUBIT_FAILURE;

     //Check for repeats in each individual list and for overlap
     //between the two lists.
   from_body_list.uniquify_ordered();

   DLIList<BodySM*> from_sms(from_body_list.size()), new_sms;
   GeometryModifyEngine* gePtr1 = common_modify_engine(from_body_list, from_sms);
   if ( !gePtr1 )
   {
      PRINT_ERROR("Performing IMPRINT with volumes containing geometry\n"
                  "from different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

   if( CubitUndo::get_undo_enabled() )
   {
     if( keep_old )
       CubitUndo::save_state();
     else
       CubitUndo::save_state_with_cubit_file( from_body_list );
   }

   int process_composites = 0;
   if(contains_composites(from_body_list))
     process_composites = 1;

   if(process_composites)
   {
      // Push virtual attributes down to solid model topology before
      // doing the imprint.
      do_attribute_setup();
      push_attributes_before_modify(from_sms);
      // This must be done after pushing the vg atts because it uses them.
      DLIList<TopologyBridge*> tb_list;
      CAST_LIST(from_sms, tb_list, TopologyBridge);
      push_named_attributes_to_curves_and_points(tb_list, "IMPRINTER");
      push_named_attributes_to_curves_and_points(tb_list, "ORIGINAL");
   }

   CubitStatus result =  gePtr1->imprint(from_sms, new_sms, keep_old);

   int i, j;
   if(process_composites)
   {
     if(result == CUBIT_SUCCESS)
     {
        // Analyze the results and adjust virtual attributes as necessary.
       DLIList<TopologyBridge*> tb_list;
       CAST_LIST(new_sms, tb_list, TopologyBridge);
        GeometryQueryTool::instance()->ige_attribute_after_imprinting(tb_list, from_body_list);

        // Clean up attributes.
        remove_imprint_attributes_after_modify(from_sms, new_sms);

        // Restore the virtual geometry.
        restore_vg_after_modify(new_sms, from_body_list, gePtr1);
     }
     remove_pushed_attributes(new_sms, from_body_list);
   }

   if (get_old_names() == CUBIT_FALSE)
   {
     if (!finish_sm_op(from_body_list, new_sms, new_body_list))
       result = CUBIT_FAILURE;

     if( CubitUndo::get_undo_enabled() )
     {
       if( result == CUBIT_SUCCESS )
         CubitUndo::note_result_bodies( new_body_list );
       else
         CubitUndo::remove_last_undo();
     }

     if(process_composites)
       do_attribute_cleanup();

     return result;
   }

   if(process_composites)
     do_attribute_cleanup();

   // If old_names is true, need to make sure things are deleted in
   // the correct order so that entities get the same @A type extension
   // on their names.

   // Update existing bodies.
   from_body_list.reset();
   for (i = from_body_list.size(); i--; )
   {
     Body* body = from_body_list.get();
     BodySM* body_sm = body->get_body_sm_ptr();
     if (!body_sm)
     {
       GeometryQueryTool::instance()->destroy_dead_entity(body);
       from_body_list.change_to(0);
     }
     else
     {
       remove_dead_entity_names(body);
       GeometryQueryTool::instance()->make_Body(body_sm);
     }
     from_body_list.step();
   }

      // Construct new bodies
   new_sms.reset();
   for (j = new_sms.size(); j--; )
   {
     BodySM* body_sm = new_sms.get_and_step();
     Body* body = GeometryQueryTool::instance()->make_Body(body_sm);
     new_body_list.append(body);
   }
   GeometryQueryTool::instance()->cleanout_deactivated_geometry();

   if( CubitUndo::get_undo_enabled() )
   {
     if( result == CUBIT_SUCCESS )
       CubitUndo::note_result_bodies( new_body_list );
     else
       CubitUndo::remove_last_undo();
   }

   return result;
}

CubitStatus GeometryModifyTool::scale( Body *&body,
                                      const CubitVector& point,
                                       const CubitVector& factors,
                                       bool check_to_transform,
                                       bool preview /*=false*/,
                                       bool reset_preview /*true*/)
{
  if( check_to_transform )
    if (!GeometryQueryTool::instance()->okay_to_transform( body ))
      return CUBIT_FAILURE;

  DLIList<Body*> body_list;
  body_list.append(body);
  if (!okay_to_modify( body_list, "NON_UNIFORM_SCALE" ))
    return CUBIT_FAILURE;

  if(reset_preview)
    GfxPreview::clear();

  if (preview)
  {
    DLIList<RefEdge*> edges;
    body->ref_edges(edges);

    //set up the matrices
    CubitTransformMatrix pre_mat, scale_mat, post_mat;
    pre_mat.translate(-point);    
    scale_mat.scale_about_origin(factors);   
    post_mat.translate(point);

    for (int i = 0; i < edges.size(); i++)
    {
      GMem poly;

      if( CUBIT_SUCCESS == edges[i]->get_graphics(poly) )
      {
        poly.transform(pre_mat);
        poly.transform(scale_mat);
        poly.transform(post_mat);
        GfxPreview::draw_polyline(poly.point_list(), poly.point_list_size(), CUBIT_BLUE_INDEX);
      }
      else if( edges[i]->start_vertex() == edges[i]->end_vertex() )
      {       
        CubitVector tmp_pt = edges[i]->start_vertex()->coordinates();
        tmp_pt = pre_mat*tmp_pt;
        tmp_pt = scale_mat*tmp_pt;
        tmp_pt = post_mat*tmp_pt;          
        GfxPreview::draw_point( tmp_pt, CUBIT_BLUE_INDEX);
      }      
    }
    GfxPreview::flush();
    return CUBIT_SUCCESS;
  }

  do_attribute_setup();

  BodySM* bodysm = body->get_body_sm_ptr();
  DLIList<BodySM*> body_sm_list;
  body_sm_list.append(bodysm);

  push_attributes_before_modify(body_sm_list);

  GeometryModifyEngine* engine = get_engine( bodysm );
  CubitStatus result;
  if( !engine )
  {
    GeometryQueryEngine* tmp_engine = bodysm->get_geometry_query_engine();
    result = tmp_engine->translate( bodysm, -point );
    result = tmp_engine->scale( bodysm, factors );
    result = tmp_engine->translate( bodysm, point );

  }
  else
  {
    GeometryQueryEngine* tmp_engine = bodysm->get_geometry_query_engine();
    result = tmp_engine->translate( bodysm, -point );
    result = engine->scale( bodysm, factors );
    result = tmp_engine->translate( bodysm, point );
  }

  // The bodysm pointer may get changed depending on the underlying
  // engine.  Make sure to put the most current pointer in the list
  // for further processing.
  body_sm_list.clean_out();
  body_sm_list.append(bodysm);
  // The old body will probably have stale data at this point
  // so don't send it down for further processing.
  body_list.clean_out();

  restore_vg_after_modify( body_sm_list, body_list, engine );
  remove_pushed_attributes( body_sm_list, body_list );

  //for non-uniform scaling, topology can change...need to update stuff
  if( factors.x() != factors.y() ||
      factors.y() != factors.z() ||
      factors.z() != factors.x() )
    body = GeometryQueryTool::instance()->make_Body(bodysm);

  do_attribute_cleanup();

  if (result)
  {

    CubitTransformMatrix pre_mat;
    pre_mat.translate(-point);

    CubitTransformMatrix scale_mat;
    scale_mat.scale_about_origin(factors);

    CubitTransformMatrix post_mat;
    post_mat.translate(point);
    GeometryQueryTool::instance()->notify_intermediate_of_transform( body, pre_mat );
    GeometryQueryTool::instance()->notify_intermediate_of_transform( body, scale_mat );
    GeometryQueryTool::instance()->notify_intermediate_of_transform( body, post_mat );
    GeometryQueryTool::instance()->notify_observers_of_transform( body );
  }
  else
    PRINT_ERROR("Scale of %s (%s %d) failed.\n",
      body->entity_name().c_str(), body->class_name(), body->id() );

  return result;
}



CubitStatus GeometryModifyTool::imprint_singly( DLIList<Body*> &from_body_list,
                                                DLIList<Body*> &new_body_list,
                                                CubitBoolean keep_old )
{

     // Check the GeometryEngine for each of the Body's; check to
     // make sure they're all the same
   from_body_list.reset();
   if (!okay_to_modify( from_body_list, "IMPRINT" ))
     return CUBIT_FAILURE;

     //Check for repeats in each individual list and for overlap
     //between the two lists.
   from_body_list.uniquify_ordered();

   DLIList<BodySM*> from_sms(from_body_list.size());
   GeometryModifyEngine* gePtr1 = common_modify_engine(from_body_list, from_sms);
   if ( !gePtr1 )
   {
      PRINT_ERROR("Performing IMPRINT with volumes containing geometry\n"
                  "from different modeling engines is not allowed.\n"
                  "Delete uncommon geometry on these volumes before operation.\n\n");
      return CUBIT_FAILURE;
   }

   CubitBoolean reset_new_ids = CUBIT_FALSE;
   if (get_new_ids() == CUBIT_FALSE) {
     PRINT_WARNING("New ids must be TRUE when group imprint FALSE; "
                   "setting new ids TRUE for this operation only.\n");
     set_new_ids(CUBIT_TRUE);
     reset_new_ids = CUBIT_TRUE;
   }

     // do the imprinting; bounding box should be checked in
     // SMEEngine function
   new_body_list = from_body_list;
   GeometryQueryTool* gqt = GeometryQueryTool::instance();

   if( CubitUndo::get_undo_enabled() )
   {
     if( keep_old )
       CubitUndo::save_state();
     else
       CubitUndo::save_state_with_cubit_file( from_body_list );
   }

   int i;
   for (i = 0; i < new_body_list.size(); i++) {
     for (int j = 1; j < new_body_list.size()-i; j++) {
       new_body_list.reset();
       new_body_list.step(i);
       Body *body_1 = new_body_list.get();
       Body *body_2 = new_body_list.next(j);
       Body *newBodyPtr1 = NULL;
       Body *newBodyPtr2 = NULL;

       if (body_1 == body_2) {
         PRINT_WARNING("Can't imprint a volume with itself.\n");

         if (reset_new_ids == CUBIT_TRUE) set_new_ids(CUBIT_FALSE);

         return CUBIT_FAILURE;
       }

       BodySM *new_sm_1, *new_sm_2;
       CubitStatus status = gePtr1->imprint(body_1->get_body_sm_ptr(),
                                            body_2->get_body_sm_ptr(),
                                            new_sm_1, new_sm_2,
                                            keep_old);

       if ( status != CUBIT_FAILURE &&
            (new_sm_1 != NULL ||
             new_sm_2 != NULL) )
       {
         from_body_list.reset();
         from_body_list.step(i);

           //put the new ones in the new list and
           //remove the olds ones.
         if ( new_sm_1 != NULL )
         {
           if (!body_1->get_body_sm_ptr())
             gqt->destroy_dead_entity(body_1);
           newBodyPtr1 = gqt->make_Body(new_sm_1);
           new_body_list.change_to(newBodyPtr1);
           from_body_list.change_to(0);
         }
         else
           gqt->make_Body(body_1->get_body_sm_ptr());

         new_body_list.step(j);
         from_body_list.step(j);
         if ( new_sm_2 != NULL )
         {
           if (!body_2->get_body_sm_ptr())
             gqt->destroy_dead_entity(body_2);
           newBodyPtr2 = gqt->make_Body(new_sm_2);
           new_body_list.change_to(newBodyPtr2);
           from_body_list.change_to(NULL);
         }
         else
           gqt->make_Body(body_2->get_body_sm_ptr());
       }
       gqt->cleanout_deactivated_geometry();
     }
   }

   from_body_list.remove_all_with_value(NULL);
   Body *temp_body;
   for (i = from_body_list.size(); i > 0; i--)
   {
     temp_body = from_body_list.get_and_step();
     while (new_body_list.move_to(temp_body)) new_body_list.remove();
   }

   if( CubitUndo::get_undo_enabled() )
   {
     if( new_body_list.size() )
       CubitUndo::note_result_bodies( new_body_list );
     else
       CubitUndo::remove_last_undo();
   }

   PRINT_INFO("\n");
   if( DEBUG_FLAG( 153 ) )
   {
     PRINT_INFO( "  New Body(ies) created:");
     new_body_list.reset();
     for (i = 0; i < new_body_list.size(); i++)
     {
       if (i != 0) PRINT_INFO( ",");
       PRINT_INFO( " %d", new_body_list.get_and_step()->id());
     }
     PRINT_INFO("\n");
     PRINT_INFO( "  Original Body(ies) retained:");
     from_body_list.reset();
     for (i = 0; i < from_body_list.size(); i++)
     {
       if (i != 0) PRINT_INFO( ",");
       PRINT_INFO( " %d", from_body_list.get_and_step()->id());
     }
     PRINT_INFO("\n");
   }

   PRINT_INFO( "  New Volume(s) created:");
   new_body_list.reset();
   DLIList<RefVolume*> new_vol_list;
   for (i = 0; i < new_body_list.size(); i++)
   {
     DLIList<RefVolume*> t2;
     new_body_list.get_and_step()->ref_volumes( t2 );
     new_vol_list += t2;
   }

   for( i = 0; i < new_vol_list.size(); i++ )
   {
     if (i != 0) PRINT_INFO( ",");
     PRINT_INFO( " %d", new_vol_list.get_and_step()->id());
   }
   PRINT_INFO("\n");

   PRINT_INFO( "  Original Volume(s) retained:");
   from_body_list.reset();
   DLIList<RefVolume*> from_vol_list;
   for (i = 0; i < from_body_list.size(); i++)
   {
     DLIList<RefVolume*> t2;
     from_body_list.get_and_step()->ref_volumes( t2 );
     from_vol_list += t2;
   }

   for( i = 0; i < from_vol_list.size(); i++ )
   {
     if (i != 0) PRINT_INFO( ",");
     PRINT_INFO( " %d", from_vol_list.get_and_step()->id());
   }
   PRINT_INFO("\n");

   if (reset_new_ids) set_new_ids(CUBIT_FALSE);

   return CUBIT_SUCCESS;
}


CubitStatus GeometryModifyTool::imprint( DLIList<Body*> &body_list,
                                         DLIList<RefEdge*> &ref_edge_list,
                                         DLIList<Body*>& new_body_list,
                                         CubitBoolean keep_old_body,
                                         CubitBoolean show_messages)
{
  // Check the GeometryEngine for each of the bodies; check to
  // make sure they're all the same
  body_list.reset();
  int i;

  if (!okay_to_modify( body_list, "IMPRINT" ))
    return CUBIT_FAILURE;

  const int count = body_list.size() + ref_edge_list.size();
  DLIList<TopologyEntity*> entity_list(count);
  DLIList<TopologyBridge*> bridge_list(count);
  CAST_LIST_TO_PARENT(body_list, entity_list);
  ref_edge_list.reset();
  for (i = ref_edge_list.size(); i--;)
    entity_list.append(ref_edge_list.get_and_step());

  GeometryModifyEngine* gePtr1 = common_modify_engine(entity_list, bridge_list);

  DLIList<BodySM*> body_sm_list(body_list.size());
  DLIList<Curve*> curve_list(ref_edge_list.size());
  CAST_LIST(bridge_list, body_sm_list, BodySM);
  CAST_LIST(bridge_list, curve_list, Curve);

  if ( !gePtr1 ||
      body_sm_list.size() != body_list.size() ||
      curve_list.size() != ref_edge_list.size() )
  {
    PRINT_ERROR("Performing IMPRINT with volumes containing geometry from\n"
                "different modeling engines is not allowed.\n"
                "Delete uncommon geometry on these volumes before operation.\n\n");
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( body_list );
  }

  int process_composites = 0;
  if(contains_composites(body_list))
    process_composites = 1;

  if(process_composites)
  {
    // Turn certain attributes on.
    do_attribute_setup();
    // Push virtual attributes down to solid model topology before
    // doing the imprint.
    push_attributes_before_modify(body_sm_list);
    // Put "ORIGINAL" attributes on the bodies being imprinted and
    // the curves as these originally existed.
    DLIList<TopologyBridge*> tb_list;
    CAST_LIST(body_sm_list, tb_list, TopologyBridge);
    push_named_attributes_to_curves_and_points(tb_list, "ORIGINAL");
    tb_list.clean_out();
    CAST_LIST(curve_list, tb_list, TopologyBridge);
    push_named_attributes_to_curves_and_points(tb_list, "ORIGINAL");
  }

  DLIList<BodySM*> new_sm_list;
  // The bridges doing the imprinting often get split during the process but
  // because of the way we are making copies, the IMPRINTER attribute doesn't
  // get propagated to them.  temporary_bridges will be filled in with any
  // additional IMPRINTER bridges we need to consider below when deciding whether to
  // keep composite attributes.
  DLIList<TopologyBridge*> temporary_bridges;
  CubitStatus status = gePtr1->imprint( body_sm_list, curve_list,
            new_sm_list, temporary_bridges, keep_old_body, show_messages);

  temporary_bridges.uniquify_ordered();

  if(status == CUBIT_FAILURE)
  {
    if(process_composites)
    {
      remove_pushed_attributes(new_sm_list, body_list);
      do_attribute_cleanup();
    }

    while(temporary_bridges.size())
    {
      TopologyBridge* bridge = temporary_bridges.pop();
      bridge->get_geometry_query_engine()->delete_topology_bridge(bridge);
    }

    return status;
  }
  else
  {
    if(process_composites)
    {
      DLIList<TopologyBridge*> tb_list;
      // Analyze the results and adjust virtual attributes as necessary.
      CAST_LIST(new_sm_list, tb_list, TopologyBridge);
      // The bridges coming back in temporary_bridges may not have IMPRINTER
      // attributes on them becuase of the way they were generated below.  Make
      // sure they get IMPRINTER attributes.
      push_named_attributes_to_curves_and_points(temporary_bridges, "IMPRINTER");
      tb_list += temporary_bridges;
      GeometryQueryTool::instance()->ige_attribute_after_imprinting(tb_list, body_list);

      // Clean up attributes.
      remove_imprint_attributes_after_modify(body_sm_list, new_sm_list);

      // Restore the virtual geometry.
      restore_vg_after_modify(new_sm_list, body_list, gePtr1);
      remove_pushed_attributes(new_sm_list, body_list);
    }
  }

  while(temporary_bridges.size())
  {
    TopologyBridge* bridge = temporary_bridges.pop();
    bridge->get_geometry_query_engine()->delete_topology_bridge(bridge);
  }

  status = finish_sm_op(body_list, new_sm_list, new_body_list);

  if(process_composites)
    do_attribute_cleanup();

   if( CubitUndo::get_undo_enabled() )
   {
     if( status == CUBIT_SUCCESS )
       CubitUndo::note_result_bodies( new_body_list );
     else
       CubitUndo::remove_last_undo();
   }

   return status;
}

CubitStatus GeometryModifyTool::imprint( DLIList<RefFace*> &ref_face_list,
                                         DLIList<RefEdge*> &ref_edge_list,
                                         DLIList<Body*>& new_body_list,
                                         CubitBoolean keep_old_body )
{
  for(int j=0;j<ref_edge_list.size();j++)
  {
    RefEdge* edge=ref_edge_list[j];
    if(edge->get_arc_length()<=edge->get_geometry_query_engine()->get_sme_resabs_tolerance())
    {

      PRINT_ERROR( "Curve %d has zero length.\n To imprint curve as a hard point use the vertex of the curve.\n",edge->id() );
      return CUBIT_FAILURE;

    }
  }

  //get the owning bodies of the faces and edges
  DLIList<Body*> body_list;
  int j;
  for(j=ref_face_list.size(); j--;)
    ref_face_list.get_and_step()->bodies( body_list );
  for(j=ref_edge_list.size(); j--;)
    ref_edge_list.get_and_step()->bodies( body_list );
  body_list.uniquify_ordered();
  if (!okay_to_modify( body_list, "IMPRINT" ))
    return CUBIT_FAILURE;

  DLIList<TopologyEntity*> temp_list, temp_list_2, body_me_list;
  CAST_LIST_TO_PARENT(ref_face_list, temp_list);
  CAST_LIST_TO_PARENT(ref_edge_list, temp_list_2);
  temp_list += temp_list_2;
  ModelQueryEngine::instance()->query_model(temp_list, DagType::body_type(), body_me_list );

  DLIList<Surface*> surf_list(ref_face_list.size());
  DLIList<Curve*> curve_list(ref_edge_list.size());
  GeometryModifyEngine* gePtr1 = common_modify_engine( ref_face_list,ref_edge_list,surf_list,
                             curve_list,true);
  if ( !gePtr1 )
  {
    PRINT_ERROR("Performing IMPRINT with volumes containing geometry from\n"
            "different modeling engines is not allowed.\n"
            "Delete uncommon geometry on these volumes before operation.\n\n");
    return CUBIT_FAILURE;
  }

  if( CubitUndo::get_undo_enabled() )
  {
    if( keep_old_body )
      CubitUndo::save_state();
    else
      CubitUndo::save_state_with_cubit_file( ref_face_list );
  }

  int process_composites = 0;
  if(contains_composites(body_list))
    process_composites = 1;

  int i;
  DLIList<BodySM*> body_sm_list;
  if(process_composites)
  {
    // Turn certain attributes on.
    do_attribute_setup();
    for(i=body_list.size(); i--;)
      body_sm_list.append_unique(body_list.get_and_step()->get_body_sm_ptr());
    // Push virtual attributes down to solid model topology before
    // doing the imprint.
    push_attributes_before_modify(body_sm_list);
    // Put "ORIGINAL" attributes on the bodies being imprinted and
    // the curves as these originally existed.
    DLIList<TopologyBridge*> tmp_tb_list;
    CAST_LIST(surf_list, tmp_tb_list, TopologyBridge);
    push_named_attributes_to_curves_and_points(tmp_tb_list, "ORIGINAL");
  }

  DLIList<BodySM*> new_sm_list;
  // The bridges doing the imprinting often get split during the process but
  // because of the way we are making copies, the IMPRINTER attribute doesn't
  // get propagated to them.  temporary_bridges will be filled in with any
  // additional IMPRINTER bridges we need to consider below when deciding whether to
  // keep composite attributes.
  DLIList<TopologyBridge*> temporary_bridges;
  CubitStatus status = gePtr1->imprint( surf_list, curve_list, temporary_bridges,
                                         new_sm_list, keep_old_body );
  temporary_bridges.uniquify_ordered();

  if(process_composites)
  {
    // Analyze the results and adjust virtual attributes as necessary.
    DLIList<TopologyBridge*> tb_list;
    CAST_LIST(new_sm_list, tb_list, TopologyBridge);
    // The bridges coming back in temporary_bridges may not have IMPRINTER
    // attributes on them becuase of the way they were generated below.  Make
    // sure they get IMPRINTER attributes.
    push_named_attributes_to_curves_and_points(temporary_bridges, "IMPRINTER");
    tb_list += temporary_bridges;
    GeometryQueryTool::instance()->ige_attribute_after_imprinting(tb_list, body_list);

    // Clean up attributes.
    remove_imprint_attributes_after_modify(body_sm_list, new_sm_list);

    restore_vg_after_modify(body_sm_list, body_list, gePtr1);
    remove_pushed_attributes(body_sm_list, body_list);
  }

  while(temporary_bridges.size())
  {
    TopologyBridge* bridge = temporary_bridges.pop();
    bridge->get_geometry_query_engine()->delete_topology_bridge(bridge);
  }

  CubitStatus status2 = finish_sm_op(body_list, new_sm_list, new_body_list);

  if(process_composites)
    do_attribute_cleanup();

  if( CubitUndo::get_undo_enabled() )
   {
     if( status == CUBIT_SUCCESS )
       CubitUndo::note_result_bodies( new_body_list );
     else
       CubitUndo::remove_last_undo();
   }

   if( status == CUBIT_SUCCESS && status2 == CUBIT_SUCCESS)
     return status;

   else
     return CUBIT_FAILURE;
}

CubitStatus GeometryModifyTool::imprint( DLIList<Surface*> &surface_list,
                                         DLIList<DLIList<Curve*>*> &curve_lists_list,
                                         Body*& /*new_body*/,
                                         CubitBoolean keep_old_body,
                                         CubitBoolean expand)
{
  int i;
  DLIList<Curve*> *curve_list_ptr;

  // Check to see if any curves exist - if none, just exit
  int have_curves = 0;
  for( i=curve_lists_list.size(); i--; )
  {
    curve_list_ptr = curve_lists_list.get_and_step();
    for(int j=0;j<curve_list_ptr->size();j++)
    {
      Curve* curve=(*curve_list_ptr)[j];
      if(curve->get_arc_length()<=curve->get_geometry_query_engine()->get_sme_resabs_tolerance())
      {
        RefEdge* edge = dynamic_cast<RefEdge*>(curve->topology_entity());
        if(edge)
        {
          PRINT_ERROR( "Curve %d has zero length.\n To imprint as a hard point use the vertex of the curve.\n",edge->id() );
          return CUBIT_FAILURE;
        }
        else
        {
          return CUBIT_FAILURE;
        }
      }
      else
      {
        have_curves++;
        break;
      }
    }
  }
  if( !have_curves )
    return CUBIT_SUCCESS;

  // Get parent bodies
  DLIList<Body*> old_body_list;
  surface_list.reset();
  for( i=surface_list.size(); i--; )
  {
    Surface *surf_ptr = surface_list.get_and_step();
    RefEntity* ref_ent = dynamic_cast<RefEntity*>(surf_ptr->topology_entity());
    RefFace *ref_face_ptr = CAST_TO( ref_ent, RefFace );

    if( ref_face_ptr )
    {
      DLIList<Body*> body_list;
      ref_face_ptr->bodies( body_list );
      old_body_list.merge_unique( body_list );
    }
  }

  if( old_body_list.size() > 1 )
  {
    PRINT_ERROR( "This operation requires all surfaces to be from the same volume\n" );
    // Note: this restriction could be pretty easily lifted by sorting the
    //       input lists and calling the GeometryModifyEngine for each body
    //       separately, or having engines handle this.
    return CUBIT_FAILURE;
  }


  // In order to support imprinting on composite surfaces we will
  // get any surfaces underlying the surfaces passed in.  For now
  // we will only do this if a single surface is coming in but
  // it could be extended for multiple surfaces as well.
  DLIList<Surface*> new_surface_list;
  if(surface_list.size() == 1)
  {
    GeometryQueryEngine *gqe = surface_list.get()->get_geometry_query_engine();
    DLIList<TopologyBridge*> tbs;
    gqe->get_underlying_surfaces(surface_list.get(), tbs);
    if(tbs.size() > 0)
    {
      for(int k=tbs.size(); k--;)
        new_surface_list.append(dynamic_cast<Surface*>(tbs.get_and_step()));
    }
    else
      new_surface_list.append(surface_list.get());
  }
  else
    new_surface_list = surface_list;

  // Check engines - must all be the same
  GeometryModifyEngine* gme;
  new_surface_list.reset();
  gme = get_engine( new_surface_list.get() );
  for( i=new_surface_list.size(); i--; )
  {
    Surface *surf_ptr = new_surface_list.get_and_step();
    GeometryModifyEngine* gme2 = get_engine( surf_ptr );
    if( gme != gme2 )
    {
      PRINT_ERROR( "All surfaces being imprinted must be from the same geometry engine\n" );
      return CUBIT_FAILURE;
    }
  }

  int j;
  for( i=curve_lists_list.size(); i--; )
  {
    curve_list_ptr = curve_lists_list.get_and_step();
    for( j=curve_list_ptr->size(); j--; )
    {
      Curve *curve_ptr = curve_list_ptr->get_and_step();
      GeometryModifyEngine* gme2 = get_engine( curve_ptr );
      if( gme != gme2 )
      {
        PRINT_ERROR( "Curves used to imprint must be from same geometry engine as Surface\n" );
        return CUBIT_FAILURE;
      }
    }
  }

   if( CubitUndo::get_undo_enabled() )
   {
     if( keep_old_body )
       CubitUndo::save_state();
     else
       CubitUndo::save_state_with_cubit_file( old_body_list );
   }

  int process_composites = 0;
  if(contains_composites(old_body_list))
    process_composites = 1;

  BodySM* new_body_sm = 0;
  DLIList<BodySM*> body_sm_list;

  DLIList<TopologyBridge*> tb_list;
  if(process_composites)
  {
    do_attribute_setup();
    for(i=old_body_list.size(); i--;)
      body_sm_list.append_unique(old_body_list.get_and_step()->get_body_sm_ptr());
    push_attributes_before_modify(body_sm_list);
 //   push_imprint_attributes_before_modify(body_sm_list);
    DLIList<TopologyBridge*> tmp_tb_list;
    CAST_LIST(new_surface_list, tmp_tb_list, TopologyBridge);
    push_named_attributes_to_curves_and_points(tmp_tb_list, "ORIGINAL");

    for(i=curve_lists_list.size(); i>0; i--)
    {
      DLIList<Curve*> *cur_list = curve_lists_list.get_and_step();
      for(j=cur_list->size(); j>0; j--)
      {
        Curve *cur_curve = cur_list->get_and_step();
        tb_list.append(cur_curve);
      }
    }
    push_named_attributes_to_curves_and_points(tb_list, "IMPRINTER");
  }

  CubitStatus status = gme->imprint( new_surface_list, curve_lists_list,
    new_body_sm, keep_old_body, expand);

  DLIList<Body*> new_body_list;
  DLIList<BodySM*> new_sm_list;
  new_sm_list.append( new_body_sm );

  if(process_composites)
  {
    // Analyze the results and adjust virtual attributes as necessary.
       DLIList<TopologyBridge*> tmp_tb_list;
       CAST_LIST(new_sm_list, tmp_tb_list, TopologyBridge);
       tb_list += tmp_tb_list;
    GeometryQueryTool::instance()->ige_attribute_after_imprinting(tb_list, old_body_list);

    // Clean up attributes.
    remove_imprint_attributes_after_modify(body_sm_list, new_sm_list);

    restore_vg_after_modify(body_sm_list, old_body_list, gme);
    remove_pushed_attributes(body_sm_list, old_body_list);
  }