OdModelerGeometry.cs

Go to the documentation of this file.

//------------------------------------------------------------------------------
// <auto-generated />
//
// This file was automatically generated by SWIG (http://www.swig.org).
// Version 4.0.2
//
// Do not make changes to this file unless you know what you are doing--modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
 
namespace Teigha.TD {
 
using System;
using System.Runtime.InteropServices;
using Teigha.Core;
 
public class OdModelerGeometry : OdRxObject {
  private Object locker = new Object();
  private HandleRef swigCPtr;
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  public OdModelerGeometry(IntPtr cPtr, bool cMemoryOwn) : base(TD_DbPINVOKE.OdModelerGeometry_SWIGUpcast(cPtr), cMemoryOwn) {
    swigCPtr = new HandleRef(this, cPtr);
  }
 
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] 
  public static HandleRef getCPtr(OdModelerGeometry obj) {
    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
  }
 
  protected override void Dispose(bool disposing) {
    lock(this) {
      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
        if (swigCMemOwn) {
          swigCMemOwn = false;
          TD_DbPINVOKE.delete_OdModelerGeometry(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
      base.Dispose(disposing);
    }
  }
 
  public static OdModelerGeometry cast(OdRxObject pObj) {//  OdSmartPtr<OdModelerGeometry>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TD_DbPINVOKE.OdModelerGeometry_cast(OdRxObject.getCPtr(pObj));
 
          OdModelerGeometry ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdModelerGeometry)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdModelerGeometry),ptr, true));
                ret = (OdModelerGeometry)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdModelerGeometry),ptr, false);
          }
          else
          {
                  ret = (OdModelerGeometry)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdModelerGeometry),ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public new static OdRxClass desc() { 
     OdRxClass ret = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxClass),TD_DbPINVOKE.OdModelerGeometry_desc(),false);  /*createInt 3_2*/
     
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public override OdRxClass isA() { 
     OdRxClass ret = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxClass),TD_DbPINVOKE.OdModelerGeometry_isA(swigCPtr),false);  /*createInt 3_2*/
     
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public override OdRxObject queryX(OdRxClass protocolClass) { 
     OdRxObject ret = (OdRxObject)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxObject),TD_DbPINVOKE.OdModelerGeometry_queryX(swigCPtr, OdRxClass.getCPtr(protocolClass)),false);  /*createInt 3_2*/
     
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public static OdModelerGeometry createObject() {//  OdSmartPtr<OdModelerGeometry>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TD_DbPINVOKE.OdModelerGeometry_createObject();
 
          OdModelerGeometry ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdModelerGeometry)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdModelerGeometry),ptr, true));
                ret = (OdModelerGeometry)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdModelerGeometry),ptr, false);
          }
          else
          {
                  ret = (OdModelerGeometry)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdModelerGeometry),ptr, true);
          }
          
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public virtual OdResult in_(OdStreamBuf pStreamBuf, out int typeVer, bool standardSaveFlag) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_in___SWIG_0(swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), out typeVer, standardSaveFlag);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult in_(OdStreamBuf pStreamBuf, out int typeVer) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_in___SWIG_1(swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), out typeVer);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult in_(OdStreamBuf pStreamBuf) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_in___SWIG_2(swigCPtr, OdStreamBuf.getCPtr(pStreamBuf));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult out_(OdStreamBuf pStreamBuf, int typeVer, bool standardSaveFlag) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_out___SWIG_0(swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), typeVer, standardSaveFlag);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult out_(OdStreamBuf pStreamBuf, int typeVer) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_out___SWIG_1(swigCPtr, OdStreamBuf.getCPtr(pStreamBuf), typeVer);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool brep(OdBrBrep brBrep) {
    bool ret = TD_DbPINVOKE.OdModelerGeometry_brep(swigCPtr, OdBrBrep.getCPtr(brBrep));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getEdgeSubentityGeometry(OdUInt32ValuesArray indexesOfEdgeCalculation, out OdGeCurve3d pEdgeCurve) {
IntPtr p_pEdgeCurve = IntPtr.Zero; /*OUT_PARAM_OBJ PRE*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getEdgeSubentityGeometry(swigCPtr, OdUInt32ValuesArray.getCPtr(indexesOfEdgeCalculation), out p_pEdgeCurve);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
MemoryTransaction mTrans_pEdgeCurve = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_pEdgeCurve != null)
 mTrans_pEdgeCurve.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdGeCurve3d>(typeof(OdGeCurve3d), p_pEdgeCurve, true)); 
 pEdgeCurve = Teigha.Core.Helpers.odCreateObjectInternal<OdGeCurve3d>(typeof(OdGeCurve3d), p_pEdgeCurve, mTrans_pEdgeCurve == null); 
 /*OUT_PARAM_OBJ POST*/
    }
  }
 
  public virtual OdResult setSubentPath(OdBrEntity arg0, OdDbFullSubentPath arg1) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setSubentPath(swigCPtr, OdBrEntity.getCPtr(arg0), OdDbFullSubentPath.getCPtr(arg1));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult generateMesh(OdBrMesh2dFilter filter, OdBrMesh2d mesh2d) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_generateMesh(swigCPtr, OdBrMesh2dFilter.getCPtr(filter), OdBrMesh2d.getCPtr(mesh2d));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool setFACETRES(double facetRes) {
    bool ret = TD_DbPINVOKE.OdModelerGeometry_setFACETRES(swigCPtr, facetRes);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public class NumIsolines : global::System.IDisposable {
    private Object locker = new Object();
    private HandleRef swigCPtr;
    protected bool swigCMemOwn;
    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    public NumIsolines(IntPtr cPtr, bool cMemoryOwn) {
      swigCMemOwn = cMemoryOwn;
      swigCPtr = new HandleRef(this, cPtr);
    }
    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    public static HandleRef getCPtr(NumIsolines obj) {
      return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
    }
  
    ~NumIsolines() {
      Dispose(false);
    }
  
    public void Dispose() {
      Dispose(true);
      global::System.GC.SuppressFinalize(this);
    }
  
    protected virtual void Dispose(bool disposing) {
      lock(this) {
        if (swigCPtr.Handle != global::System.IntPtr.Zero) {
          if (swigCMemOwn) {
            swigCMemOwn = false;
            TD_DbPINVOKE.delete_OdModelerGeometry_NumIsolines(swigCPtr); // NESTED_DTOR_CSHARP
          }
          swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
        }
      }
    }
  
    public UInt32 numU {
      set {
       /*SIMPLETYPE*/
        TD_DbPINVOKE.OdModelerGeometry_NumIsolines_numU_set(swigCPtr, value /*SIMPLETYPE*/);
        if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
       /*SIMPLETYPE*/
        UInt32 ret = TD_DbPINVOKE.OdModelerGeometry_NumIsolines_numU_get(swigCPtr);
        if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public UInt32 numV {
      set {
       /*SIMPLETYPE*/
        TD_DbPINVOKE.OdModelerGeometry_NumIsolines_numV_set(swigCPtr, value /*SIMPLETYPE*/);
        if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
       /*SIMPLETYPE*/
        UInt32 ret = TD_DbPINVOKE.OdModelerGeometry_NumIsolines_numV_get(swigCPtr);
        if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public NumIsolines() : this(TD_DbPINVOKE.new_OdModelerGeometry_NumIsolines(), true) {
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    }
  
  }
 
  public virtual bool worldDraw(OdGiCommonDraw pWd, UInt32 geomType, OdModelerGeometry.NumIsolines pNumIsolines) {
    bool ret = TD_DbPINVOKE.OdModelerGeometry_worldDraw__SWIG_0(swigCPtr, OdGiCommonDraw.getCPtr(pWd), geomType /*SIMPLETYPE*/, OdModelerGeometry.NumIsolines.getCPtr(pNumIsolines));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool worldDraw(OdGiCommonDraw pWd, UInt32 geomType) {
    bool ret = TD_DbPINVOKE.OdModelerGeometry_worldDraw__SWIG_1(swigCPtr, OdGiCommonDraw.getCPtr(pWd), geomType /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool drawSilhouettes(OdGiViewportDraw pVd) {
    bool ret = TD_DbPINVOKE.OdModelerGeometry_drawSilhouettes(swigCPtr, OdGiViewportDraw.getCPtr(pVd));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getCachedSilhouettes(OdGeCurve3dPtrArray cachedSilhouettes) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getCachedSilhouettes(swigCPtr, OdGeCurve3dPtrArray.getCPtr(cachedSilhouettes));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getHlrCurves(SWIGTYPE_p_OdDbModeler__OdHlrCurvesParams params_) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getHlrCurves(swigCPtr, SWIGTYPE_p_OdDbModeler__OdHlrCurvesParams.getCPtr(params_));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getTransformation(OdGeMatrix3d xfm) {
    bool ret = TD_DbPINVOKE.OdModelerGeometry_getTransformation(swigCPtr, OdGeMatrix3d.getCPtr(xfm));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void transformBy(OdGeMatrix3d xfm) {
    TD_DbPINVOKE.OdModelerGeometry_transformBy(swigCPtr, OdGeMatrix3d.getCPtr(xfm));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void createBox(double xLen, double yLen, double zLen) {
    TD_DbPINVOKE.OdModelerGeometry_createBox(swigCPtr, xLen, yLen, zLen);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void createFrustum(double height, double xRadius, double yRadius, double topXRadius) {
    TD_DbPINVOKE.OdModelerGeometry_createFrustum(swigCPtr, height, xRadius, yRadius, topXRadius);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void createSphere(double radius) {
    TD_DbPINVOKE.OdModelerGeometry_createSphere(swigCPtr, radius);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void createTorus(double majorRadius, double minorRadius) {
    TD_DbPINVOKE.OdModelerGeometry_createTorus(swigCPtr, majorRadius, minorRadius);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void createWedge(double xLen, double yLen, double zLen) {
    TD_DbPINVOKE.OdModelerGeometry_createWedge(swigCPtr, xLen, yLen, zLen);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdResult extrude(OdDbRegion pRegion, double height, double taperAngle, bool isSolid) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrude__SWIG_0(swigCPtr, OdDbRegion.getCPtr(pRegion), height, taperAngle, isSolid);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult extrude(OdDbRegion pRegion, double height, double taperAngle) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrude__SWIG_1(swigCPtr, OdDbRegion.getCPtr(pRegion), height, taperAngle);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult revolve(OdDbRegion pRegion, OdGePoint3d axisPoint, OdGeVector3d axisDir, double angleOfRevolution, bool isSolid) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_revolve__SWIG_0(swigCPtr, OdDbRegion.getCPtr(pRegion), OdGePoint3d.getCPtr(axisPoint), OdGeVector3d.getCPtr(axisDir), angleOfRevolution, isSolid);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult revolve(OdDbRegion pRegion, OdGePoint3d axisPoint, OdGeVector3d axisDir, double angleOfRevolution) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_revolve__SWIG_1(swigCPtr, OdDbRegion.getCPtr(pRegion), OdGePoint3d.getCPtr(axisPoint), OdGeVector3d.getCPtr(axisDir), angleOfRevolution);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void ClearColorAttributes() {
    TD_DbPINVOKE.OdModelerGeometry_ClearColorAttributes(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void ClearMaterialAttributes(OdDbSubentIdArraySt aSubents) {
    TD_DbPINVOKE.OdModelerGeometry_ClearMaterialAttributes__SWIG_0(swigCPtr, OdDbSubentIdArraySt.getCPtr(aSubents));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void ClearMaterialAttributes() {
    TD_DbPINVOKE.OdModelerGeometry_ClearMaterialAttributes__SWIG_1(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual void ClearMaterialMapperAttributes() {
    TD_DbPINVOKE.OdModelerGeometry_ClearMaterialMapperAttributes(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public virtual OdModelerGeometry.MaterialState hasMaterials() {
    OdModelerGeometry.MaterialState ret = (OdModelerGeometry.MaterialState)TD_DbPINVOKE.OdModelerGeometry_hasMaterials(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool hasTrueColorAttributes() {
    bool ret = TD_DbPINVOKE.OdModelerGeometry_hasTrueColorAttributes(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getPlane(OdGePlane regionPlane) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getPlane(swigCPtr, OdGePlane.getCPtr(regionPlane));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool setMMPerUnit(double mmPerUnit) {
    bool ret = TD_DbPINVOKE.OdModelerGeometry_setMMPerUnit(swigCPtr, mmPerUnit);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getMMPerUnit(out double mmPerUnit) {
    bool ret = TD_DbPINVOKE.OdModelerGeometry_getMMPerUnit(swigCPtr, out mmPerUnit);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdModelerGeometry.geomType bodyType() {
    OdModelerGeometry.geomType ret = (OdModelerGeometry.geomType)TD_DbPINVOKE.OdModelerGeometry_bodyType(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool explode(OdModelerGeometry.geomType typeThis, OdDbEntityPtrArray entitySet) {
    bool ret = TD_DbPINVOKE.OdModelerGeometry_explode(swigCPtr, (int)typeThis, OdDbEntityPtrArray.getCPtr(entitySet));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult booleanOper(OdDbDatabase database, BoolOperType operation, OdModelerGeometry otherBody, OdModelerGeometry.geomType typeThis, OdModelerGeometry.geomType typeOther) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_booleanOper__SWIG_0(swigCPtr, OdDbDatabase.getCPtr(database), (int)operation, OdModelerGeometry.getCPtr(otherBody), (int)typeThis, (int)typeOther);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult booleanOper(OdDbDatabase database, BoolOperType operation, OdModelerGeometry otherBody, OdModelerGeometry.geomType typeThis, OdModelerGeometry.geomType typeOther, ref OdModelerGeometry /*OUT_PARAM for SMARTPTR*/ result, OdDbEntityPtrArray intersectionEntities) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_result = result == null ? IntPtr.Zero : OdModelerGeometry.getCPtr(result).Handle; 
 IntPtr saved_result = tmp_result; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_booleanOper__SWIG_1(swigCPtr, OdDbDatabase.getCPtr(database), (int)operation, OdModelerGeometry.getCPtr(otherBody), (int)typeThis, (int)typeOther, ref tmp_result /*OUT_PARAM for SMARTPTR*/, OdDbEntityPtrArray.getCPtr(intersectionEntities));
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_result == IntPtr.Zero) result = null; 
 if(tmp_result != IntPtr.Zero && tmp_result != saved_result) 
 { 
 MemoryTransaction mTrans_result = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_result != null)
 mTrans_result.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdModelerGeometry>(typeof(OdModelerGeometry), tmp_result, true)); 
 result = Teigha.Core.Helpers.odCreateObjectInternal<OdModelerGeometry>(typeof(OdModelerGeometry), tmp_result, mTrans_result == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public virtual OdResult booleanOper(OdDbDatabase database, BoolOperType operation, OdModelerGeometry otherBody, OdModelerGeometry.geomType typeThis, OdModelerGeometry.geomType typeOther, ref OdModelerGeometry /*OUT_PARAM for SMARTPTR*/ result) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_result = result == null ? IntPtr.Zero : OdModelerGeometry.getCPtr(result).Handle; 
 IntPtr saved_result = tmp_result; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_booleanOper__SWIG_2(swigCPtr, OdDbDatabase.getCPtr(database), (int)operation, OdModelerGeometry.getCPtr(otherBody), (int)typeThis, (int)typeOther, ref tmp_result /*OUT_PARAM for SMARTPTR*/);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_result == IntPtr.Zero) result = null; 
 if(tmp_result != IntPtr.Zero && tmp_result != saved_result) 
 { 
 MemoryTransaction mTrans_result = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_result != null)
 mTrans_result.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdModelerGeometry>(typeof(OdModelerGeometry), tmp_result, true)); 
 result = Teigha.Core.Helpers.odCreateObjectInternal<OdModelerGeometry>(typeof(OdModelerGeometry), tmp_result, mTrans_result == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public virtual OdResult checkInterference(OdDbDatabase database, OdModelerGeometry otherSolid, bool createNewSolid, out bool solidsInterfere, ref OdDb3dSolid /*OUT_PARAM for SMARTPTR*/ commonVolumeSolid) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_commonVolumeSolid = commonVolumeSolid == null ? IntPtr.Zero : OdDb3dSolid.getCPtr(commonVolumeSolid).Handle; 
 IntPtr saved_commonVolumeSolid = tmp_commonVolumeSolid; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkInterference(swigCPtr, OdDbDatabase.getCPtr(database), OdModelerGeometry.getCPtr(otherSolid), createNewSolid, out solidsInterfere, ref tmp_commonVolumeSolid /*OUT_PARAM for SMARTPTR*/);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_commonVolumeSolid == IntPtr.Zero) commonVolumeSolid = null; 
 if(tmp_commonVolumeSolid != IntPtr.Zero && tmp_commonVolumeSolid != saved_commonVolumeSolid) 
 { 
 MemoryTransaction mTrans_commonVolumeSolid = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_commonVolumeSolid != null)
 mTrans_commonVolumeSolid.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDb3dSolid>(typeof(OdDb3dSolid), tmp_commonVolumeSolid, true)); 
 commonVolumeSolid = Teigha.Core.Helpers.odCreateObjectInternal<OdDb3dSolid>(typeof(OdDb3dSolid), tmp_commonVolumeSolid, mTrans_commonVolumeSolid == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public virtual OdResult getArea(out double regionArea) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getArea(swigCPtr, out regionArea);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getPerimeter(out double arg0) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getPerimeter(swigCPtr, out arg0);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getAreaProp(OdGePoint3d origin, OdGeVector3d xAxis, OdGeVector3d yAxis, out double perimeter, out double area, OdGePoint2d centroid, double[] /*DOUBLE_FIXED_ARRAY*/ momInertia, out double prodInertia, double[] /*DOUBLE_FIXED_ARRAY*/ prinMoments, OdGeVector2d prinAxes, double[] /*DOUBLE_FIXED_ARRAY*/ radiiGyration, OdGePoint2d extentsLow, OdGePoint2d extentsHigh) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getAreaProp(swigCPtr, OdGePoint3d.getCPtr(origin), OdGeVector3d.getCPtr(xAxis), OdGeVector3d.getCPtr(yAxis), out perimeter, out area, OdGePoint2d.getCPtr(centroid), momInertia /*DOUBLE_FIXED_ARRAY*/, out prodInertia, prinMoments /*DOUBLE_FIXED_ARRAY*/, OdGeVector2d.getCPtr(prinAxes), radiiGyration /*DOUBLE_FIXED_ARRAY*/, OdGePoint2d.getCPtr(extentsLow), OdGePoint2d.getCPtr(extentsHigh));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult clear() {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_clear(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult extrudeAlongPath(OdDbRegion region, OdDbCurve path, double taperAngle, bool isSolid) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrudeAlongPath__SWIG_0(swigCPtr, OdDbRegion.getCPtr(region), OdDbCurve.getCPtr(path), taperAngle, isSolid);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult extrudeAlongPath(OdDbRegion region, OdDbCurve path, double taperAngle) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrudeAlongPath__SWIG_1(swigCPtr, OdDbRegion.getCPtr(region), OdDbCurve.getCPtr(path), taperAngle);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult extrudeAlongPath(OdDbRegion region, OdDbCurve path) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrudeAlongPath__SWIG_2(swigCPtr, OdDbRegion.getCPtr(region), OdDbCurve.getCPtr(path));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult imprintEntity(OdDbEntity pEntity) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_imprintEntity(swigCPtr, OdDbEntity.getCPtr(pEntity));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getMassProp(out double volume, OdGePoint3d centroid, double[] /*DOUBLE_FIXED_ARRAY*/ momInertia, double[] /*DOUBLE_FIXED_ARRAY*/ prodInertia, double[] /*DOUBLE_FIXED_ARRAY*/ prinMoments, OdGeVector3d prinAxes, double[] /*DOUBLE_FIXED_ARRAY*/ radiiGyration, OdGeExtents3d extents) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getMassProp(swigCPtr, out volume, OdGePoint3d.getCPtr(centroid), momInertia /*DOUBLE_FIXED_ARRAY*/, prodInertia /*DOUBLE_FIXED_ARRAY*/, prinMoments /*DOUBLE_FIXED_ARRAY*/, OdGeVector3d.getCPtr(prinAxes), radiiGyration /*DOUBLE_FIXED_ARRAY*/, OdGeExtents3d.getCPtr(extents));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getSection(OdGePlane plane, ref OdDbRegion /*OUT_PARAM for SMARTPTR*/ sectionRegion, OdDbEntityPtrArray pSectionCurves) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_sectionRegion = sectionRegion == null ? IntPtr.Zero : OdDbRegion.getCPtr(sectionRegion).Handle; 
 IntPtr saved_sectionRegion = tmp_sectionRegion; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSection__SWIG_0(swigCPtr, OdGePlane.getCPtr(plane), ref tmp_sectionRegion /*OUT_PARAM for SMARTPTR*/, OdDbEntityPtrArray.getCPtr(pSectionCurves));
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_sectionRegion == IntPtr.Zero) sectionRegion = null; 
 if(tmp_sectionRegion != IntPtr.Zero && tmp_sectionRegion != saved_sectionRegion) 
 { 
 MemoryTransaction mTrans_sectionRegion = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_sectionRegion != null)
 mTrans_sectionRegion.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDbRegion>(typeof(OdDbRegion), tmp_sectionRegion, true)); 
 sectionRegion = Teigha.Core.Helpers.odCreateObjectInternal<OdDbRegion>(typeof(OdDbRegion), tmp_sectionRegion, mTrans_sectionRegion == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public virtual OdResult getSection(OdGePlane plane, ref OdDbRegion /*OUT_PARAM for SMARTPTR*/ sectionRegion) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_sectionRegion = sectionRegion == null ? IntPtr.Zero : OdDbRegion.getCPtr(sectionRegion).Handle; 
 IntPtr saved_sectionRegion = tmp_sectionRegion; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSection__SWIG_1(swigCPtr, OdGePlane.getCPtr(plane), ref tmp_sectionRegion /*OUT_PARAM for SMARTPTR*/);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_sectionRegion == IntPtr.Zero) sectionRegion = null; 
 if(tmp_sectionRegion != IntPtr.Zero && tmp_sectionRegion != saved_sectionRegion) 
 { 
 MemoryTransaction mTrans_sectionRegion = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_sectionRegion != null)
 mTrans_sectionRegion.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDbRegion>(typeof(OdDbRegion), tmp_sectionRegion, true)); 
 sectionRegion = Teigha.Core.Helpers.odCreateObjectInternal<OdDbRegion>(typeof(OdDbRegion), tmp_sectionRegion, mTrans_sectionRegion == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public virtual OdResult getSlice(OdGePlane plane, bool getNegHalfToo, ref OdDb3dSolid /*OUT_PARAM for SMARTPTR*/ negHalfSolid) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_negHalfSolid = negHalfSolid == null ? IntPtr.Zero : OdDb3dSolid.getCPtr(negHalfSolid).Handle; 
 IntPtr saved_negHalfSolid = tmp_negHalfSolid; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSlice__SWIG_0(swigCPtr, OdGePlane.getCPtr(plane), getNegHalfToo, ref tmp_negHalfSolid /*OUT_PARAM for SMARTPTR*/);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_negHalfSolid == IntPtr.Zero) negHalfSolid = null; 
 if(tmp_negHalfSolid != IntPtr.Zero && tmp_negHalfSolid != saved_negHalfSolid) 
 { 
 MemoryTransaction mTrans_negHalfSolid = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_negHalfSolid != null)
 mTrans_negHalfSolid.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDb3dSolid>(typeof(OdDb3dSolid), tmp_negHalfSolid, true)); 
 negHalfSolid = Teigha.Core.Helpers.odCreateObjectInternal<OdDb3dSolid>(typeof(OdDb3dSolid), tmp_negHalfSolid, mTrans_negHalfSolid == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public virtual OdResult getSlice(OdDbSurface pSurface, bool bGetNegHalfToo, ref OdDb3dSolid /*OUT_PARAM for SMARTPTR*/ pNegHalfSolid) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_pNegHalfSolid = pNegHalfSolid == null ? IntPtr.Zero : OdDb3dSolid.getCPtr(pNegHalfSolid).Handle; 
 IntPtr saved_pNegHalfSolid = tmp_pNegHalfSolid; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSlice__SWIG_1(swigCPtr, OdDbSurface.getCPtr(pSurface), bGetNegHalfToo, ref tmp_pNegHalfSolid /*OUT_PARAM for SMARTPTR*/);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_pNegHalfSolid == IntPtr.Zero) pNegHalfSolid = null; 
 if(tmp_pNegHalfSolid != IntPtr.Zero && tmp_pNegHalfSolid != saved_pNegHalfSolid) 
 { 
 MemoryTransaction mTrans_pNegHalfSolid = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_pNegHalfSolid != null)
 mTrans_pNegHalfSolid.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDb3dSolid>(typeof(OdDb3dSolid), tmp_pNegHalfSolid, true)); 
 pNegHalfSolid = Teigha.Core.Helpers.odCreateObjectInternal<OdDb3dSolid>(typeof(OdDb3dSolid), tmp_pNegHalfSolid, mTrans_pNegHalfSolid == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public virtual OdResult cleanBody() {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_cleanBody(swigCPtr);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult offsetBody(double offsetDistance) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_offsetBody(swigCPtr, offsetDistance);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult separateBody(OdDb3dSolidPtrArray newSolids) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_separateBody(swigCPtr, OdDb3dSolidPtrArray.getCPtr(newSolids));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createExtrudedObject(OdDbEntity pSweepEnt, OdGeVector3d directionVec, OdDbSweepOptions sweepOptions, bool isSolid, bool bHistoryEnabled) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createExtrudedObject__SWIG_0(swigCPtr, OdDbEntity.getCPtr(pSweepEnt), OdGeVector3d.getCPtr(directionVec), OdDbSweepOptions.getCPtr(sweepOptions), isSolid, bHistoryEnabled);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createExtrudedObject(OdDbEntity pSweepEnt, OdGeVector3d directionVec, OdDbSweepOptions sweepOptions, bool isSolid) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createExtrudedObject__SWIG_1(swigCPtr, OdDbEntity.getCPtr(pSweepEnt), OdGeVector3d.getCPtr(directionVec), OdDbSweepOptions.getCPtr(sweepOptions), isSolid);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createExtrudedObject(OdDbEntity pSweepEnt, OdGeVector3d directionVec, OdDbSweepOptions sweepOptions) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createExtrudedObject__SWIG_2(swigCPtr, OdDbEntity.getCPtr(pSweepEnt), OdGeVector3d.getCPtr(directionVec), OdDbSweepOptions.getCPtr(sweepOptions));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createLoftedObject(OdDbEntityPtrArray crossSectionCurves, OdDbEntityPtrArray guideCurves, OdDbEntity pPathCurve, OdDbLoftOptions loftOptions, bool isSolid) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createLoftedObject__SWIG_0(swigCPtr, OdDbEntityPtrArray.getCPtr(crossSectionCurves), OdDbEntityPtrArray.getCPtr(guideCurves), OdDbEntity.getCPtr(pPathCurve), OdDbLoftOptions.getCPtr(loftOptions), isSolid);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createLoftedObject(OdDbEntityPtrArray crossSectionCurves, OdDbEntityPtrArray guideCurves, OdDbEntity pPathCurve, OdDbLoftOptions loftOptions) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createLoftedObject__SWIG_1(swigCPtr, OdDbEntityPtrArray.getCPtr(crossSectionCurves), OdDbEntityPtrArray.getCPtr(guideCurves), OdDbEntity.getCPtr(pPathCurve), OdDbLoftOptions.getCPtr(loftOptions));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createBlendObject(OdDbEntityPtrArray blendedEdges, OdDbBlendOptions blendOptions, bool isSolid) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createBlendObject__SWIG_0(swigCPtr, OdDbEntityPtrArray.getCPtr(blendedEdges), OdDbBlendOptions.getCPtr(blendOptions), isSolid);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createBlendObject(OdDbEntityPtrArray blendedEdges, OdDbBlendOptions blendOptions) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createBlendObject__SWIG_1(swigCPtr, OdDbEntityPtrArray.getCPtr(blendedEdges), OdDbBlendOptions.getCPtr(blendOptions));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createPyramid(double height, int sides, double radius, double topRadius) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createPyramid__SWIG_0(swigCPtr, height, sides, radius, topRadius);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createPyramid(double height, int sides, double radius) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createPyramid__SWIG_1(swigCPtr, height, sides, radius);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createRevolvedObject(OdDbEntity pRevEnt, OdGePoint3d axisPnt, OdGeVector3d axisDir, double revAngle, double startAngle, OdDbRevolveOptions revolveOptions, bool isSolid, bool bHistoryEnabled) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createRevolvedObject__SWIG_0(swigCPtr, OdDbEntity.getCPtr(pRevEnt), OdGePoint3d.getCPtr(axisPnt), OdGeVector3d.getCPtr(axisDir), revAngle, startAngle, OdDbRevolveOptions.getCPtr(revolveOptions), isSolid, bHistoryEnabled);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createRevolvedObject(OdDbEntity pRevEnt, OdGePoint3d axisPnt, OdGeVector3d axisDir, double revAngle, double startAngle, OdDbRevolveOptions revolveOptions, bool isSolid) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createRevolvedObject__SWIG_1(swigCPtr, OdDbEntity.getCPtr(pRevEnt), OdGePoint3d.getCPtr(axisPnt), OdGeVector3d.getCPtr(axisDir), revAngle, startAngle, OdDbRevolveOptions.getCPtr(revolveOptions), isSolid);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createRevolvedObject(OdDbEntity pRevEnt, OdGePoint3d axisPnt, OdGeVector3d axisDir, double revAngle, double startAngle, OdDbRevolveOptions revolveOptions) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createRevolvedObject__SWIG_2(swigCPtr, OdDbEntity.getCPtr(pRevEnt), OdGePoint3d.getCPtr(axisPnt), OdGeVector3d.getCPtr(axisDir), revAngle, startAngle, OdDbRevolveOptions.getCPtr(revolveOptions));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createSweptObject(OdDbEntity pSweepEnt, OdDbEntity pPathEnt, OdDbSweepOptions sweepOptions, bool isSolid, bool bHistoryEnabled) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createSweptObject__SWIG_0(swigCPtr, OdDbEntity.getCPtr(pSweepEnt), OdDbEntity.getCPtr(pPathEnt), OdDbSweepOptions.getCPtr(sweepOptions), isSolid, bHistoryEnabled);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createSweptObject(OdDbEntity pSweepEnt, OdDbEntity pPathEnt, OdDbSweepOptions sweepOptions, bool isSolid) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createSweptObject__SWIG_1(swigCPtr, OdDbEntity.getCPtr(pSweepEnt), OdDbEntity.getCPtr(pPathEnt), OdDbSweepOptions.getCPtr(sweepOptions), isSolid);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createSweptObject(OdDbEntity pSweepEnt, OdDbEntity pPathEnt, OdDbSweepOptions sweepOptions) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createSweptObject__SWIG_2(swigCPtr, OdDbEntity.getCPtr(pSweepEnt), OdDbEntity.getCPtr(pPathEnt), OdDbSweepOptions.getCPtr(sweepOptions));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult checkCrossSectionCurves(OdDbEntityPtrArray crossSectionCurves, out bool allOpen, out bool allClosed, out bool allPlanar, bool displayErrorMessages) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkCrossSectionCurves__SWIG_0(swigCPtr, OdDbEntityPtrArray.getCPtr(crossSectionCurves), out allOpen, out allClosed, out allPlanar, displayErrorMessages);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult checkCrossSectionCurves(OdDbEntityPtrArray crossSectionCurves, out bool allOpen, out bool allClosed, out bool allPlanar) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkCrossSectionCurves__SWIG_1(swigCPtr, OdDbEntityPtrArray.getCPtr(crossSectionCurves), out allOpen, out allClosed, out allPlanar);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult checkGuideCurves(OdDbEntityPtrArray guideCurves, bool displayErrorMessages) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkGuideCurves__SWIG_0(swigCPtr, OdDbEntityPtrArray.getCPtr(guideCurves), displayErrorMessages);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult checkGuideCurves(OdDbEntityPtrArray guideCurves) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkGuideCurves__SWIG_1(swigCPtr, OdDbEntityPtrArray.getCPtr(guideCurves));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult checkPathCurve(OdDbEntity pPathCurve, bool displayErrorMessages) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkPathCurve__SWIG_0(swigCPtr, OdDbEntity.getCPtr(pPathCurve), displayErrorMessages);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult checkPathCurve(OdDbEntity pPathCurve) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkPathCurve__SWIG_1(swigCPtr, OdDbEntity.getCPtr(pPathCurve));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult checkSweepCurve(OdDbEntity pSweepEnt, out Planarity planarity, OdGePoint3d pnt, OdGeVector3d vec, out bool closed, out double approxArcLen, bool displayErrorMessages) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkSweepCurve__SWIG_0(swigCPtr, OdDbEntity.getCPtr(pSweepEnt), out planarity, OdGePoint3d.getCPtr(pnt), OdGeVector3d.getCPtr(vec), out closed, out approxArcLen, displayErrorMessages);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult checkSweepCurve(OdDbEntity pSweepEnt, out Planarity planarity, OdGePoint3d pnt, OdGeVector3d vec, out bool closed, out double approxArcLen) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkSweepCurve__SWIG_1(swigCPtr, OdDbEntity.getCPtr(pSweepEnt), out planarity, OdGePoint3d.getCPtr(pnt), OdGeVector3d.getCPtr(vec), out closed, out approxArcLen);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult checkSweepPathCurve(OdDbEntity pPathEnt, bool displayErrorMessages) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkSweepPathCurve__SWIG_0(swigCPtr, OdDbEntity.getCPtr(pPathEnt), displayErrorMessages);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult checkSweepPathCurve(OdDbEntity pPathEnt) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkSweepPathCurve__SWIG_1(swigCPtr, OdDbEntity.getCPtr(pPathEnt));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult checkRevolveCurve(OdDbEntity pRevEnt, OdGePoint3d axisPnt, OdGeVector3d axisDir, out bool closed, out bool endPointsOnAxis, out bool planar, bool displayErrorMessages) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkRevolveCurve__SWIG_0(swigCPtr, OdDbEntity.getCPtr(pRevEnt), OdGePoint3d.getCPtr(axisPnt), OdGeVector3d.getCPtr(axisDir), out closed, out endPointsOnAxis, out planar, displayErrorMessages);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult checkRevolveCurve(OdDbEntity pRevEnt, OdGePoint3d axisPnt, OdGeVector3d axisDir, out bool closed, out bool endPointsOnAxis, out bool planar) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_checkRevolveCurve__SWIG_1(swigCPtr, OdDbEntity.getCPtr(pRevEnt), OdGePoint3d.getCPtr(axisPnt), OdGeVector3d.getCPtr(axisDir), out closed, out endPointsOnAxis, out planar);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createFrom(OdDbEntity pFromEntity) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createFrom(swigCPtr, OdDbEntity.getCPtr(pFromEntity));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult convertToRegion(OdDbEntityPtrArray regions) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_convertToRegion(swigCPtr, OdDbEntityPtrArray.getCPtr(regions));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult thicken(double thickness, bool bBothSides, ref OdDb3dSolid /*OUT_PARAM for SMARTPTR*/ pSolid) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_pSolid = pSolid == null ? IntPtr.Zero : OdDb3dSolid.getCPtr(pSolid).Handle; 
 IntPtr saved_pSolid = tmp_pSolid; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_thicken(swigCPtr, thickness, bBothSides, ref tmp_pSolid /*OUT_PARAM for SMARTPTR*/);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_pSolid == IntPtr.Zero) pSolid = null; 
 if(tmp_pSolid != IntPtr.Zero && tmp_pSolid != saved_pSolid) 
 { 
 MemoryTransaction mTrans_pSolid = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_pSolid != null)
 mTrans_pSolid.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDb3dSolid>(typeof(OdDb3dSolid), tmp_pSolid, true)); 
 pSolid = Teigha.Core.Helpers.odCreateObjectInternal<OdDb3dSolid>(typeof(OdDb3dSolid), tmp_pSolid, mTrans_pSolid == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public virtual OdResult intersectWith(OdDbEntity ent, Intersect intType, OdGePoint3dArray points, IntPtr thisGsMarker, IntPtr otherGsMarker) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_intersectWith__SWIG_0(swigCPtr, OdDbEntity.getCPtr(ent), (int)intType, OdGePoint3dArray.getCPtr(points), thisGsMarker /*SIMPLETYPE*/, otherGsMarker /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult intersectWith(OdDbEntity ent, Intersect intType, OdGePlane projPlane, OdGePoint3dArray points, IntPtr thisGsMarker, IntPtr otherGsMarker) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_intersectWith__SWIG_1(swigCPtr, OdDbEntity.getCPtr(ent), (int)intType, OdGePlane.getCPtr(projPlane), OdGePoint3dArray.getCPtr(points), thisGsMarker /*SIMPLETYPE*/, otherGsMarker /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult copySubEntity(OdDbSubentId subentId, ref OdDbEntity /*OUT_PARAM for SMARTPTR*/ newEntity) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_newEntity = newEntity == null ? IntPtr.Zero : OdDbEntity.getCPtr(newEntity).Handle; 
 IntPtr saved_newEntity = tmp_newEntity; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_copySubEntity(swigCPtr, OdDbSubentId.getCPtr(subentId), ref tmp_newEntity /*OUT_PARAM for SMARTPTR*/);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_newEntity == IntPtr.Zero) newEntity = null; 
 if(tmp_newEntity != IntPtr.Zero && tmp_newEntity != saved_newEntity) 
 { 
 MemoryTransaction mTrans_newEntity = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_newEntity != null)
 mTrans_newEntity.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDbEntity>(typeof(OdDbEntity), tmp_newEntity, true)); 
 newEntity = Teigha.Core.Helpers.odCreateObjectInternal<OdDbEntity>(typeof(OdDbEntity), tmp_newEntity, mTrans_newEntity == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public virtual OdResult taperFaces(OdDbSubentIdArray faceSubentIds, OdGePoint3d basePoint, OdGeVector3d draftVector, double draftAngle) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_taperFaces(swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds), OdGePoint3d.getCPtr(basePoint), OdGeVector3d.getCPtr(draftVector), draftAngle);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult removeFaces(OdDbSubentIdArray faceSubentIds) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_removeFaces(swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult offsetFaces(OdDbSubentIdArray faceSubentIds, double offsetDistance) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_offsetFaces(swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds), offsetDistance);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult shellBody(OdDbSubentIdArray faceSubentIds, double offsetDistance) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_shellBody(swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds), offsetDistance);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult transformFaces(OdDbSubentIdArray faceSubentIds, OdGeMatrix3d matrix) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_transformFaces(swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds), OdGeMatrix3d.getCPtr(matrix).Handle);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getSubentPathsAtGsMarker(Teigha.Core.SubentType type, IntPtr gsMark, OdGePoint3d pickPoint, OdGeMatrix3d viewXform, OdDbFullSubentPathArray subentPaths, OdDbObjectIdArray entAndInsertStack) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSubentPathsAtGsMarker__SWIG_0(swigCPtr, (int)type, gsMark /*SIMPLETYPE*/, OdGePoint3d.getCPtr(pickPoint), OdGeMatrix3d.getCPtr(viewXform), OdDbFullSubentPathArray.getCPtr(subentPaths), OdDbObjectIdArray.getCPtr(entAndInsertStack));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getSubentPathsAtGsMarker(Teigha.Core.SubentType type, IntPtr gsMark, OdGePoint3d pickPoint, OdGeMatrix3d viewXform, OdDbFullSubentPathArray subentPaths) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSubentPathsAtGsMarker__SWIG_1(swigCPtr, (int)type, gsMark /*SIMPLETYPE*/, OdGePoint3d.getCPtr(pickPoint), OdGeMatrix3d.getCPtr(viewXform), OdDbFullSubentPathArray.getCPtr(subentPaths));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getGsMarkersAtSubentPath(OdDbFullSubentPath subPath, OdGsMarkerArray gsMarkers) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getGsMarkersAtSubentPath(swigCPtr, OdDbFullSubentPath.getCPtr(subPath), OdGsMarkerArray.getCPtr(gsMarkers));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdDbSubentId internalSubentId(IntPtr ent) {
    OdDbSubentId ret = new OdDbSubentId(TD_DbPINVOKE.OdModelerGeometry_internalSubentId(swigCPtr, ent /*SIMPLETYPE*/), true);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual IntPtr internalSubentPtr(OdDbSubentId id) { 
// test csout
 /*SIMPLETYPE*/
     IntPtr ret = TD_DbPINVOKE.OdModelerGeometry_internalSubentPtr(swigCPtr, OdDbSubentId.getCPtr(id)); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual bool getNurbCurvesCache(OdGeCurve3dPtrArray arg0) {
    bool ret = TD_DbPINVOKE.OdModelerGeometry_getNurbCurvesCache(swigCPtr, OdGeCurve3dPtrArray.getCPtr(arg0));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult setBody(IntPtr arg0) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setBody(swigCPtr, arg0 /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual IntPtr body() { 
// test csout
 /*SIMPLETYPE*/
     IntPtr ret = TD_DbPINVOKE.OdModelerGeometry_body(swigCPtr); 
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public virtual OdResult setSubentColor(OdDbSubentId subentId, OdCmColor color) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setSubentColor(swigCPtr, OdDbSubentId.getCPtr(subentId), OdCmColor.getCPtr(color));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getSubentColor(OdDbSubentId subentId, OdCmColor color) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSubentColor(swigCPtr, OdDbSubentId.getCPtr(subentId), OdCmColor.getCPtr(color));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult setSubentMaterial(OdDbSubentId subentId, OdDbObjectId matId) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setSubentMaterial(swigCPtr, OdDbSubentId.getCPtr(subentId), OdDbObjectId.getCPtr(matId));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getSubentMaterial(OdDbSubentId subentId, out UInt64 matId) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSubentMaterial(swigCPtr, OdDbSubentId.getCPtr(subentId), out matId);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult setSubentMaterialMapper(OdDbSubentId subentId, OdGeMatrix3d mx, out byte projection, out byte tiling, out byte autoTransform) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setSubentMaterialMapper(swigCPtr, OdDbSubentId.getCPtr(subentId), OdGeMatrix3d.getCPtr(mx), out projection, out tiling, out autoTransform);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getSubentMaterialMapper(OdDbSubentId subentId, OdGeMatrix3d mx, out byte projection, out byte tiling, out byte autoTransform) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSubentMaterialMapper(swigCPtr, OdDbSubentId.getCPtr(subentId), OdGeMatrix3d.getCPtr(mx), out projection, out tiling, out autoTransform);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult chamferEdges(OdDbSubentIdArray edgeSubentIds, OdDbSubentId baseFaceSubentId, double baseDist, double otherDist) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_chamferEdges(swigCPtr, OdDbSubentIdArray.getCPtr(edgeSubentIds), OdDbSubentId.getCPtr(baseFaceSubentId), baseDist, otherDist);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult filletEdges(OdDbSubentIdArray edgeSubentIds, OdGeDoubleArray radius, OdGeDoubleArray startSetback, OdGeDoubleArray endSetback) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_filletEdges(swigCPtr, OdDbSubentIdArray.getCPtr(edgeSubentIds), OdGeDoubleArray.getCPtr(radius), OdGeDoubleArray.getCPtr(startSetback), OdGeDoubleArray.getCPtr(endSetback));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createSectionObjects(OdGePlane sectionPlane, OdDbEntityPtrArray sectionObjects) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createSectionObjects(swigCPtr, OdGePlane.getCPtr(sectionPlane), OdDbEntityPtrArray.getCPtr(sectionObjects));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult sliceByPlane(OdGePlane slicePlane, ref OdDbSurface /*OUT_PARAM for SMARTPTR*/ pNegHalfSurface, ref OdDbSurface /*OUT_PARAM for SMARTPTR*/ pNewSurface, bool bNotModifyItself) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_pNegHalfSurface = pNegHalfSurface == null ? IntPtr.Zero : OdDbSurface.getCPtr(pNegHalfSurface).Handle; 
 IntPtr saved_pNegHalfSurface = tmp_pNegHalfSurface; 
 /*OUT_PARAM for SMARTPTR pre*/
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_pNewSurface = pNewSurface == null ? IntPtr.Zero : OdDbSurface.getCPtr(pNewSurface).Handle; 
 IntPtr saved_pNewSurface = tmp_pNewSurface; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_sliceByPlane(swigCPtr, OdGePlane.getCPtr(slicePlane), ref tmp_pNegHalfSurface /*OUT_PARAM for SMARTPTR*/, ref tmp_pNewSurface /*OUT_PARAM for SMARTPTR*/, bNotModifyItself);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_pNegHalfSurface == IntPtr.Zero) pNegHalfSurface = null; 
 if(tmp_pNegHalfSurface != IntPtr.Zero && tmp_pNegHalfSurface != saved_pNegHalfSurface) 
 { 
 MemoryTransaction mTrans_pNegHalfSurface = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_pNegHalfSurface != null)
 mTrans_pNegHalfSurface.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDbSurface>(typeof(OdDbSurface), tmp_pNegHalfSurface, true)); 
 pNegHalfSurface = Teigha.Core.Helpers.odCreateObjectInternal<OdDbSurface>(typeof(OdDbSurface), tmp_pNegHalfSurface, mTrans_pNegHalfSurface == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
if(tmp_pNewSurface == IntPtr.Zero) pNewSurface = null; 
 if(tmp_pNewSurface != IntPtr.Zero && tmp_pNewSurface != saved_pNewSurface) 
 { 
 MemoryTransaction mTrans_pNewSurface = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_pNewSurface != null)
 mTrans_pNewSurface.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDbSurface>(typeof(OdDbSurface), tmp_pNewSurface, true)); 
 pNewSurface = Teigha.Core.Helpers.odCreateObjectInternal<OdDbSurface>(typeof(OdDbSurface), tmp_pNewSurface, mTrans_pNewSurface == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public virtual OdResult sliceBySurface(OdDbSurface pSlicingSurface, ref OdDbSurface /*OUT_PARAM for SMARTPTR*/ pNegHalfSurface, ref OdDbSurface /*OUT_PARAM for SMARTPTR*/ pNewSurface, bool bNotModifyItself) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_pNegHalfSurface = pNegHalfSurface == null ? IntPtr.Zero : OdDbSurface.getCPtr(pNegHalfSurface).Handle; 
 IntPtr saved_pNegHalfSurface = tmp_pNegHalfSurface; 
 /*OUT_PARAM for SMARTPTR pre*/
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_pNewSurface = pNewSurface == null ? IntPtr.Zero : OdDbSurface.getCPtr(pNewSurface).Handle; 
 IntPtr saved_pNewSurface = tmp_pNewSurface; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_sliceBySurface(swigCPtr, OdDbSurface.getCPtr(pSlicingSurface), ref tmp_pNegHalfSurface /*OUT_PARAM for SMARTPTR*/, ref tmp_pNewSurface /*OUT_PARAM for SMARTPTR*/, bNotModifyItself);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_pNegHalfSurface == IntPtr.Zero) pNegHalfSurface = null; 
 if(tmp_pNegHalfSurface != IntPtr.Zero && tmp_pNegHalfSurface != saved_pNegHalfSurface) 
 { 
 MemoryTransaction mTrans_pNegHalfSurface = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_pNegHalfSurface != null)
 mTrans_pNegHalfSurface.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDbSurface>(typeof(OdDbSurface), tmp_pNegHalfSurface, true)); 
 pNegHalfSurface = Teigha.Core.Helpers.odCreateObjectInternal<OdDbSurface>(typeof(OdDbSurface), tmp_pNegHalfSurface, mTrans_pNegHalfSurface == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
if(tmp_pNewSurface == IntPtr.Zero) pNewSurface = null; 
 if(tmp_pNewSurface != IntPtr.Zero && tmp_pNewSurface != saved_pNewSurface) 
 { 
 MemoryTransaction mTrans_pNewSurface = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_pNewSurface != null)
 mTrans_pNewSurface.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDbSurface>(typeof(OdDbSurface), tmp_pNewSurface, true)); 
 pNewSurface = Teigha.Core.Helpers.odCreateObjectInternal<OdDbSurface>(typeof(OdDbSurface), tmp_pNewSurface, mTrans_pNewSurface == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public virtual OdResult extrudeFaces(OdDbSubentIdArray faceSubentIds, double height, double taper) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrudeFaces(swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds), height, taper);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult extrudeFacesAlongPath(OdDbSubentIdArray faceSubentIds, OdDbCurve path) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extrudeFacesAlongPath(swigCPtr, OdDbSubentIdArray.getCPtr(faceSubentIds), OdDbCurve.getCPtr(path));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult ChangeFacesDoubleSidedParam(bool isDoubleSided) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_ChangeFacesDoubleSidedParam(swigCPtr, isDoubleSided);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult convertToNurbSurface(OdDbNurbSurfacePtrArray nurbSurfaceArray) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_convertToNurbSurface(swigCPtr, OdDbNurbSurfacePtrArray.getCPtr(nurbSurfaceArray));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult get(out int iUDegree, out int iVDegree, out bool bRational, out int iUNumControlPoints, out int iVNumControlPoints, OdGePoint3dArray ctrlPtsArr, OdGeDoubleArray weights, OdGeKnotVector uKnots, OdGeKnotVector vKnots) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_get(swigCPtr, out iUDegree, out iVDegree, out bRational, out iUNumControlPoints, out iVNumControlPoints, OdGePoint3dArray.getCPtr(ctrlPtsArr), OdGeDoubleArray.getCPtr(weights), OdGeKnotVector.getCPtr(uKnots), OdGeKnotVector.getCPtr(vKnots));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult set(int iUDegree, int iVDegree, bool bRational, int iUNumControlPoints, int iVNumControlPoints, OdGePoint3dArray ctrlPtsArr, OdGeDoubleArray weights, OdGeKnotVector uKnots, OdGeKnotVector vKnots) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_set(swigCPtr, iUDegree, iVDegree, bRational, iUNumControlPoints, iVNumControlPoints, OdGePoint3dArray.getCPtr(ctrlPtsArr), OdGeDoubleArray.getCPtr(weights), OdGeKnotVector.getCPtr(uKnots), OdGeKnotVector.getCPtr(vKnots));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getNumberOfControlPointsInU(out int iCount) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNumberOfControlPointsInU(swigCPtr, out iCount);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getNumberOfControlPointsInV(out int iCount) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNumberOfControlPointsInV(swigCPtr, out iCount);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getNumberOfKnotsInU(out int iCount) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNumberOfKnotsInU(swigCPtr, out iCount);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getNumberOfKnotsInV(out int iCount) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNumberOfKnotsInV(swigCPtr, out iCount);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getUKnots(OdGeKnotVector knots) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getUKnots(swigCPtr, OdGeKnotVector.getCPtr(knots));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getVKnots(OdGeKnotVector knots) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getVKnots(swigCPtr, OdGeKnotVector.getCPtr(knots));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getDegreeInU(out int iDegree) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getDegreeInU(swigCPtr, out iDegree);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getDegreeInV(out int iDegree) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getDegreeInV(swigCPtr, out iDegree);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult isClosedInU(out bool bIsClosed) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isClosedInU(swigCPtr, out bIsClosed);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult isClosedInV(out bool bIsClosed) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isClosedInV(swigCPtr, out bIsClosed);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult isPeriodicInU(out bool bIsPeriodic) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isPeriodicInU(swigCPtr, out bIsPeriodic);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult isPeriodicInV(out bool bIsPeriodic) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isPeriodicInV(swigCPtr, out bIsPeriodic);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getPeriodInU(out double dPeriod) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getPeriodInU(swigCPtr, out dPeriod);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getPeriodInV(out double dPeriod) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getPeriodInV(swigCPtr, out dPeriod);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult evaluate(double dU, double dV, OdGePoint3d pos) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_evaluate__SWIG_0(swigCPtr, dU, dV, OdGePoint3d.getCPtr(pos));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult evaluate(double dU, double dV, OdGePoint3d pos, OdGeVector3d uDeriv, OdGeVector3d vDeriv) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_evaluate__SWIG_1(swigCPtr, dU, dV, OdGePoint3d.getCPtr(pos), OdGeVector3d.getCPtr(uDeriv), OdGeVector3d.getCPtr(vDeriv));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult evaluate(double dU, double dV, OdGePoint3d pos, OdGeVector3d uDeriv, OdGeVector3d vDeriv, OdGeVector3d uuDeriv, OdGeVector3d uvDeriv, OdGeVector3d vvDeriv) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_evaluate__SWIG_2(swigCPtr, dU, dV, OdGePoint3d.getCPtr(pos), OdGeVector3d.getCPtr(uDeriv), OdGeVector3d.getCPtr(vDeriv), OdGeVector3d.getCPtr(uuDeriv), OdGeVector3d.getCPtr(uvDeriv), OdGeVector3d.getCPtr(vvDeriv));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult evaluate(double dU, double dV, int iDerivDegree, OdGePoint3d point, OdGeVector3dArray derivatives) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_evaluate__SWIG_3(swigCPtr, dU, dV, iDerivDegree, OdGePoint3d.getCPtr(point), OdGeVector3dArray.getCPtr(derivatives));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult isRational(out bool bIsRational) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isRational(swigCPtr, out bIsRational);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult isPlanar(out bool bIsPlanar, OdGePoint3d ptOnSurface, OdGeVector3d normal) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isPlanar(swigCPtr, out bIsPlanar, OdGePoint3d.getCPtr(ptOnSurface), OdGeVector3d.getCPtr(normal));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult isPointOnSurface(OdGePoint3d point, out bool bOnSurface) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_isPointOnSurface(swigCPtr, OdGePoint3d.getCPtr(point), out bOnSurface);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getNormal(double dU, double dV, OdGeVector3d normal) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNormal(swigCPtr, dU, dV, OdGeVector3d.getCPtr(normal));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getNumberOfSpansInU(out int iSpan) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNumberOfSpansInU(swigCPtr, out iSpan);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getNumberOfSpansInV(out int iSpan) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getNumberOfSpansInV(swigCPtr, out iSpan);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getIsolineAtU(double dNumberSegments, OdDbCurvePtrArray lineSegments) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getIsolineAtU(swigCPtr, dNumberSegments, OdDbCurvePtrArray.getCPtr(lineSegments));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getIsolineAtV(double dNumberSegments, OdDbCurvePtrArray lineSegments) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getIsolineAtV(swigCPtr, dNumberSegments, OdDbCurvePtrArray.getCPtr(lineSegments));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult InsertKnot(double dVal, int iUorV) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_InsertKnot(swigCPtr, dVal, iUorV);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult InsertControlPointsAtU(double dU, OdGePoint3dArray vCtrlPts, OdGeDoubleArray vWeights) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_InsertControlPointsAtU(swigCPtr, dU, OdGePoint3dArray.getCPtr(vCtrlPts), OdGeDoubleArray.getCPtr(vWeights));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult InsertControlPointsAtV(double dV, OdGePoint3dArray uCtrlPts, OdGeDoubleArray uWeights) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_InsertControlPointsAtV(swigCPtr, dV, OdGePoint3dArray.getCPtr(uCtrlPts), OdGeDoubleArray.getCPtr(uWeights));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult RemoveControlPointsAtU(int iUDegree) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_RemoveControlPointsAtU(swigCPtr, iUDegree);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult RemoveControlPointsAtV(int iVDegree) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_RemoveControlPointsAtV(swigCPtr, iVDegree);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult rebuild(int iUDegree, int iVDegree, int iNumUCtrlPts, int iNumVCtrlPts, bool bRestore) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_rebuild(swigCPtr, iUDegree, iVDegree, iNumUCtrlPts, iNumVCtrlPts, bRestore);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult modifyPositionAndTangent(double dU, double dV, OdGePoint3d point, OdGeVector3d uDeriv, OdGeVector3d vDeriv) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_modifyPositionAndTangent(swigCPtr, dU, dV, OdGePoint3d.getCPtr(point), OdGeVector3d.getCPtr(uDeriv), OdGeVector3d.getCPtr(vDeriv));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getParameterOfPoint(OdGePoint3d point, out double dU, out double dV) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getParameterOfPoint(swigCPtr, OdGePoint3d.getCPtr(point), out dU, out dV);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getControlPoints(out int iUCount, out int iVCount, OdGePoint3dArray points) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getControlPoints(swigCPtr, out iUCount, out iVCount, OdGePoint3dArray.getCPtr(points));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult setControlPoints(int iUCount, int iVCount, OdGePoint3dArray points) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setControlPoints(swigCPtr, iUCount, iVCount, OdGePoint3dArray.getCPtr(points));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getControlPointAndWeight(int iUIndex, int iVIndex, OdGePoint3d point, out double weight, out bool bIsRational) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getControlPointAndWeight(swigCPtr, iUIndex, iVIndex, OdGePoint3d.getCPtr(point), out weight, out bIsRational);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult setControlPointAndWeight(int iUIndex, int iVIndex, OdGePoint3d point, double weight) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setControlPointAndWeight(swigCPtr, iUIndex, iVIndex, OdGePoint3d.getCPtr(point), weight);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult setColorToSubents(OdCmColor color) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setColorToSubents(swigCPtr, OdCmColor.getCPtr(color));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult setMaterialToSubents(OdDbObjectId materialId) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setMaterialToSubents(swigCPtr, OdDbObjectId.getCPtr(materialId));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult setMaterialResolver(OdMaterialResolver pResolver) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setMaterialResolver(swigCPtr, OdMaterialResolver.getCPtr(pResolver));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult setMaterialMapperToSubents(OdGeMatrix3d mx, out byte projection, out byte tiling, out byte autoTransform) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_setMaterialMapperToSubents(swigCPtr, OdGeMatrix3d.getCPtr(mx), out projection, out tiling, out autoTransform);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult trimSurface(OdDbObjectIdArray toolIds, OdDbObjectIdArray toolCurveIds, OdGeVector3dArray projVectors, OdGePoint3d pickPoint, OdGeVector3d viewVector, bool bAutoExtend, bool bAssociativeEnabled) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_trimSurface(swigCPtr, OdDbObjectIdArray.getCPtr(toolIds), OdDbObjectIdArray.getCPtr(toolCurveIds), OdGeVector3dArray.getCPtr(projVectors), OdGePoint3d.getCPtr(pickPoint), OdGeVector3d.getCPtr(viewVector), bAutoExtend, bAssociativeEnabled);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult projectOnToEntity(OdDbEntity pEntityToProject, OdGeVector3d projectionDirection, OdDbEntityPtrArray projectedEntities) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_projectOnToEntity(swigCPtr, OdDbEntity.getCPtr(pEntityToProject), OdGeVector3d.getCPtr(projectionDirection), OdDbEntityPtrArray.getCPtr(projectedEntities));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createSculptedSolid(OdDbEntityPtrArray limitingBodies, OdIntArray limitingFlags) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createSculptedSolid(swigCPtr, OdDbEntityPtrArray.getCPtr(limitingBodies), OdIntArray.getCPtr(limitingFlags).Handle);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult rayTestEntities(OdGePoint3d rayBasePoint, OdGeVector3d rayDir, double dRayRadius, SWIGTYPE_p_std__vectorT_OdSmartPtrT_OdDbEntity_t_t i_entities, OdDbSubentIdArraySt o_subEntIds, SWIGTYPE_p_std__vectorT_int_t o_indexentities, OdGeDoubleArray parameters) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_rayTestEntities(swigCPtr, OdGePoint3d.getCPtr(rayBasePoint), OdGeVector3d.getCPtr(rayDir), dRayRadius, SWIGTYPE_p_std__vectorT_OdSmartPtrT_OdDbEntity_t_t.getCPtr(i_entities), OdDbSubentIdArraySt.getCPtr(o_subEntIds), SWIGTYPE_p_std__vectorT_int_t.getCPtr(o_indexentities), OdGeDoubleArray.getCPtr(parameters));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult rayTestSolids(OdGePoint3d rayBasePoint, OdGeVector3d rayDir, double dRayRadius, SWIGTYPE_p_std__vectorT_OdSmartPtrT_OdDb3dSolid_t_t i_solids, OdDbSubentIdArraySt o_subEntIds, SWIGTYPE_p_std__vectorT_int_t o_indexsolids, OdGeDoubleArray parameters) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_rayTestSolids(swigCPtr, OdGePoint3d.getCPtr(rayBasePoint), OdGeVector3d.getCPtr(rayDir), dRayRadius, SWIGTYPE_p_std__vectorT_OdSmartPtrT_OdDb3dSolid_t_t.getCPtr(i_solids), OdDbSubentIdArraySt.getCPtr(o_subEntIds), SWIGTYPE_p_std__vectorT_int_t.getCPtr(o_indexsolids), OdGeDoubleArray.getCPtr(parameters));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult rayTest(OdGePoint3d rayBasePoint, OdGeVector3d rayDir, double rayRadius, OdDbSubentIdArraySt subEntIds, OdGeDoubleArray parameters) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_rayTest(swigCPtr, OdGePoint3d.getCPtr(rayBasePoint), OdGeVector3d.getCPtr(rayDir), rayRadius, OdDbSubentIdArraySt.getCPtr(subEntIds), OdGeDoubleArray.getCPtr(parameters));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createFilletSurface(ref OdDbSurface /*OUT_PARAM for SMARTPTR*/ surf1, OdGePoint3d pickPt1, ref OdDbSurface /*OUT_PARAM for SMARTPTR*/ surf2, OdGePoint3d pickPt2, double dRadius, FilletTrimMode trimMode, OdGeVector3d projDir) {
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_surf1 = surf1 == null ? IntPtr.Zero : OdDbSurface.getCPtr(surf1).Handle; 
 IntPtr saved_surf1 = tmp_surf1; 
 /*OUT_PARAM for SMARTPTR pre*/
 /*OUT_PARAM for SMARTPTR pre*/   IntPtr tmp_surf2 = surf2 == null ? IntPtr.Zero : OdDbSurface.getCPtr(surf2).Handle; 
 IntPtr saved_surf2 = tmp_surf2; 
 /*OUT_PARAM for SMARTPTR pre*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createFilletSurface(swigCPtr, ref tmp_surf1 /*OUT_PARAM for SMARTPTR*/, OdGePoint3d.getCPtr(pickPt1), ref tmp_surf2 /*OUT_PARAM for SMARTPTR*/, OdGePoint3d.getCPtr(pickPt2), dRadius, (int)trimMode, OdGeVector3d.getCPtr(projDir));
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
if(tmp_surf1 == IntPtr.Zero) surf1 = null; 
 if(tmp_surf1 != IntPtr.Zero && tmp_surf1 != saved_surf1) 
 { 
 MemoryTransaction mTrans_surf1 = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_surf1 != null)
 mTrans_surf1.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDbSurface>(typeof(OdDbSurface), tmp_surf1, true)); 
 surf1 = Teigha.Core.Helpers.odCreateObjectInternal<OdDbSurface>(typeof(OdDbSurface), tmp_surf1, mTrans_surf1 == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
if(tmp_surf2 == IntPtr.Zero) surf2 = null; 
 if(tmp_surf2 != IntPtr.Zero && tmp_surf2 != saved_surf2) 
 { 
 MemoryTransaction mTrans_surf2 = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_surf2 != null)
 mTrans_surf2.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdDbSurface>(typeof(OdDbSurface), tmp_surf2, true)); 
 surf2 = Teigha.Core.Helpers.odCreateObjectInternal<OdDbSurface>(typeof(OdDbSurface), tmp_surf2, mTrans_surf2 == null); 
 /*OUT_PARAM for SMARTPTR*/ 
 }
    }
  }
 
  public virtual OdResult createNetworkSurface(SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDb3dProfile_t_t uProfiles, SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDb3dProfile_t_t vProfiles) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createNetworkSurface(swigCPtr, SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDb3dProfile_t_t.getCPtr(uProfiles), SWIGTYPE_p_OdArrayT_OdSmartPtrT_OdDb3dProfile_t_t.getCPtr(vProfiles));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult extendEdges(OdDbFullSubentPathArray edgesId, double dExtDist, OdDbSurface.EdgeExtensionType extOption) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_extendEdges(swigCPtr, OdDbFullSubentPathArray.getCPtr(edgesId), dExtDist, (int)extOption);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getObjectMesh(MeshFaceterSettings faceter, OdGePoint3dArray vertexArray, OdInt32Array faceArray, out OdGiFaceData faceData) {
IntPtr p_faceData = IntPtr.Zero; /*OUT_PARAM_OBJ PRE*/
    try {
      OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getObjectMesh(swigCPtr, MeshFaceterSettings.getCPtr(faceter), OdGePoint3dArray.getCPtr(vertexArray), OdInt32Array.getCPtr(faceArray).Handle, out p_faceData);
      if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } finally {
MemoryTransaction mTrans_faceData = MemoryManager.GetMemoryManager().GetCurrentTransaction();
 if(mTrans_faceData != null)
 mTrans_faceData.AddObject(Teigha.Core.Helpers.odCreateObjectInternal<OdGiFaceData>(typeof(OdGiFaceData), p_faceData, true)); 
 faceData = Teigha.Core.Helpers.odCreateObjectInternal<OdGiFaceData>(typeof(OdGiFaceData), p_faceData, mTrans_faceData == null); 
 /*OUT_PARAM_OBJ POST*/
    }
  }
 
  public virtual OdResult getBoundingBox(OdGeExtents3d box) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getBoundingBox(swigCPtr, OdGeExtents3d.getCPtr(box));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult getSectionViewInfo(SWIGTYPE_p_OdDbModeler__OdSectionViewParams params_) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_getSectionViewInfo(swigCPtr, SWIGTYPE_p_OdDbModeler__OdSectionViewParams.getCPtr(params_));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult createCachedCurves(OdGeCurve3dPtrArray pCurves) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_createCachedCurves(swigCPtr, OdGeCurve3dPtrArray.getCPtr(pCurves));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult restoreAttributes(OdModelerGeometry oldmodeler) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_restoreAttributes(swigCPtr, OdModelerGeometry.getCPtr(oldmodeler));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult addSubentitySpecialSettings(AcisDataType addedDT, AcisDataTypeArrFirst addedDTFirst, OdDbSubentId subentId, OdUInt32ValuesArray retArray, UInt32 idx) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_addSubentitySpecialSettings(swigCPtr, (int)addedDT, (int)addedDTFirst, OdDbSubentId.getCPtr(subentId), OdUInt32ValuesArray.getCPtr(retArray), idx /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual bool getFaceMesh(OdGeTrMesh mesh, IntPtr iFace, wrTriangulationParams triangulationParams) {
    bool ret = TD_DbPINVOKE.OdModelerGeometry_getFaceMesh(swigCPtr, OdGeTrMesh.getCPtr(mesh), iFace /*SIMPLETYPE*/, wrTriangulationParams.getCPtr(triangulationParams));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual OdResult auditAcisData(OdDbAuditInfo pInfo, OdRxObject pObj) {
    OdResult ret = (OdResult)TD_DbPINVOKE.OdModelerGeometry_auditAcisData(swigCPtr, OdDbAuditInfo.getCPtr(pInfo), OdRxObject.getCPtr(pObj));
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public virtual void enableAcisAudit(bool bEnable) {
    TD_DbPINVOKE.OdModelerGeometry_enableAcisAudit(swigCPtr, bEnable);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  protected static string getRealClassName(IntPtr ptr) {
    string ret = TD_DbPINVOKE.OdModelerGeometry_getRealClassName(ptr /*SIMPLETYPE*/);
    if (TD_DbPINVOKE.SWIGPendingException.Pending) throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
     public  virtual  IntPtr vb_body() { return this.body(); }
  
  public enum MaterialState {
    kNoMaterials = 0,
    kHasMaterials = 1,
    kUnknown = 2
  }
 
  public enum geomType {
    kUndefined = 0,
    kBody = 1,
    kSolid = 2,
    kRegion = 3,
    kSurface = 4
  }
 
}
 
}