/// <summary>
/// Gets the segment curve at the given index.
/// </summary>
/// <param name="index">Index of segment to retrieve.</param>
/// <returns>The segment at the given index or null on failure.</returns>
/// <since>5.0</since>
public Curve SegmentCurve(int index)
{
IntPtr ptr = ConstPointer();
IntPtr pCurve = UnsafeNativeMethods.ON_PolyCurve_SegmentCurve(ptr, index);
return(GeometryBase.CreateGeometryHelper(pCurve, this, index) as Curve);
}
/// <summary>
/// Computes draft curve silhouettes of a shape.
/// </summary>
/// <param name="geometry">Geometry whose silhouettes need to be computed. Can be Brep, BrepFace, Mesh, or Extrusion.</param>
/// <param name="draftAngle">The draft angle in radians. Draft angle can be a positive or negative value.</param>
/// <param name="pullDirection">3d direction for the mold to be pulled in, directed away from the object.</param>
/// <param name="tolerance">
/// Tolerance to use for determining projecting relationships.
/// Surfaces and curves that are closer than tolerance, may be treated as projecting.
/// When in doubt use RhinoDoc.ModelAbsoluteTolerance.
/// </param>
/// <param name="angleToleranceRadians">
/// Angular tolerance to use for determining projecting relationships.
/// A surface normal N that satisfies N o cameraDirection < Sin(angleToleranceRadians) may be considered projecting.
/// When in doubt use RhinoDoc.ModelAngleToleranceRadians.
/// </param>
/// <param name="cancelToken">Computation cancellation token.</param>
/// <returns>Array of silhouette curves.</returns>
/// <since>7.0</since>
public static Silhouette[] ComputeDraftCurve(
GeometryBase geometry,
double draftAngle,
Vector3d pullDirection,
double tolerance,
double angleToleranceRadians,
System.Threading.CancellationToken cancelToken
)
{
IntPtr const_ptr_geometry = geometry.ConstPointer();
ThreadTerminator terminator = null;
if (cancelToken != System.Threading.CancellationToken.None)
{
terminator = new ThreadTerminator();
cancelToken.Register(terminator.RequestCancel);
}
IntPtr ptr_terminator = terminator == null ? IntPtr.Zero : terminator.NonConstPointer();
IntPtr ptr_silhouettes = UnsafeNativeMethods.TLC_Sillhouette3(const_ptr_geometry, draftAngle, pullDirection, tolerance, angleToleranceRadians, ptr_terminator);
Silhouette[] rc = FromClassArray(ptr_silhouettes);
UnsafeNativeMethods.TLC_SilhouetteArrayDelete(ptr_silhouettes);
if (terminator != null)
{
terminator.Dispose();
}
GC.KeepAlive(geometry);
return(rc);
}
public NurbsCurve ToNurbsCurve()
{
IntPtr const_ptr_this = ConstPointer();
IntPtr ptr_nurbs_crv = UnsafeNativeMethods.ON_BezierCurve_GetNurbForm(const_ptr_this);
return(GeometryBase.CreateGeometryHelper(ptr_nurbs_crv, null) as NurbsCurve);
}
/// <summary>
/// Get a cubic, uniform, non-rational, NURBS curve that is on the
/// edge's limit curve.
/// </summary>
/// <param name="clampEnds">
/// If true, the end knots are clamped.
/// Otherwise the end knots are(-2,-1,0,...., k1, k1+1, k1+2).
/// </param>
/// <returns></returns>
/// <since>7.0</since>
public NurbsCurve ToNurbsCurve(bool clampEnds)
{
IntPtr const_ptr_this = ConstPointer();
IntPtr ptr_nurbscurve = UnsafeNativeMethods.ON_SubDEdge_LimitCurve(const_ptr_this, clampEnds);
return(GeometryBase.CreateGeometryHelper(ptr_nurbscurve, null) as NurbsCurve);
}
/// <summary>
/// Removes any nesting of polycurves. If this polycurve has just a single segment, the segment is returned.
/// If, after nest removal, there are adjacent segments which are polylines, they are combined into a single polyline.
/// The new curve may have a different domain from this polycurve. If the start and end segments of a closed input are polylines,
/// the result may have a different seam location since the start and end segments will be combined.
/// </summary>
/// <returns>A new curve that is not necessarily a polycurve if successful, null otherwise. </returns>
/// <seealso cref="RemoveNesting"/>
/// <since>7.0</since>
public Curve CleanUp()
{
IntPtr ptr_const_this = ConstPointer();
IntPtr ptr = UnsafeNativeMethods.RHC_RhinoCleanUpPolyCurve(ptr_const_this);
return(GeometryBase.CreateGeometryHelper(ptr, null) as Curve);
}
/// <summary>
/// Compute silhouettes of a shape for a parallel projection.
/// </summary>
/// <param name="geometry">Geometry whose silhouettes need to be computed. Can be Brep, BrepFace, Mesh, or Extrusion.</param>
/// <param name="silhouetteType">Types of silhouette to compute.</param>
/// <param name="parallelCameraDirection">Direction of parallel camera.</param>
/// <param name="tolerance">Tolerance to use for determining projecting relationships.
/// Surfaces and curves that are closer than tolerance, may be treated as projecting.
/// When in doubt use RhinoDoc.ModelAbsoluteTolerance.</param>
/// <param name="angleToleranceRadians">Angular tolerance to use for determining projecting relationships.
/// A surface normal N that satisfies N o cameraDirection < Sin(angleToleranceRadians) may be considered projecting.
/// When in doubt use RhinoDoc.ModelAngleToleranceRadians.</param>
/// <returns>Array of silhouette curves.</returns>
/// <since>6.0</since>
public static Silhouette[] Compute(
GeometryBase geometry,
SilhouetteType silhouetteType,
Vector3d parallelCameraDirection,
double tolerance,
double angleToleranceRadians)
{
return(Compute(geometry, silhouetteType, parallelCameraDirection, tolerance, angleToleranceRadians, null, System.Threading.CancellationToken.None));
}
/// <summary>
/// Compute silhouettes of a shape for a perspective projection.
/// </summary>
/// <param name="geometry">Geometry whose silhouettes need to be computed. Can be Brep, BrepFace, Mesh, or Extrusion.</param>
/// <param name="silhouetteType">Types of silhouette to compute.</param>
/// <param name="perspectiveCameraLocation">Location of perspective camera.</param>
/// <param name="tolerance">Tolerance to use for determining projecting relationships.
/// Surfaces and curves that are closer than tolerance, may be treated as projecting.
/// When in doubt use RhinoDoc.ModelAbsoluteTolerance.</param>
/// <param name="angleToleranceRadians">Angular tolerance to use for determining projecting relationships.
/// A surface normal N that satisfies N o cameraDirection < Sin(angleToleranceRadians) may be considered projecting.
/// When in doubt use RhinoDoc.ModelAngleToleranceRadians.</param>
/// <returns>Array of silhouette curves.</returns>
/// <since>6.0</since>
public static Silhouette[] Compute(
GeometryBase geometry,
SilhouetteType silhouetteType,
Point3d perspectiveCameraLocation,
double tolerance,
double angleToleranceRadians)
{
return(Compute(geometry, silhouetteType, perspectiveCameraLocation, tolerance, angleToleranceRadians, null, System.Threading.CancellationToken.None));
}
/// <summary>
/// Compute silhouettes of a shape for a specified projection.
/// </summary>
/// <param name="geometry">Geometry whose silhouettes need to be computed. Can be Brep, BrepFace, Mesh, or Extrusion.</param>
/// <param name="silhouetteType">Types of silhouette to compute.</param>
/// <param name="viewport">Projection.</param>
/// <param name="tolerance">Tolerance to use for determining projecting relationships.
/// Surfaces and curves that are closer than tolerance, may be treated as projecting.
/// When in doubt use RhinoDoc.ModelAbsoluteTolerance.</param>
/// <param name="angleToleranceRadians">Angular tolerance to use for determining projecting relationships.
/// A surface normal N that satisfies N o cameraDirection < Sin(angleToleranceRadians) may be considered projecting.
/// When in doubt use RhinoDoc.ModelAngleToleranceRadians.</param>
/// <returns>Array of silhouette curves.</returns>
/// <since>6.0</since>
public static Silhouette[] Compute(
GeometryBase geometry,
SilhouetteType silhouetteType,
ViewportInfo viewport,
double tolerance,
double angleToleranceRadians)
{
return(Compute(geometry, silhouetteType, viewport, tolerance, angleToleranceRadians, null, System.Threading.CancellationToken.None));
}
/// <summary>
/// Constructs a light copy of this object. By "light", it is meant that the same
/// underlying data is used until something is done to attempt to change it. For example,
/// you could have a shallow copy of a very heavy mesh object and the same underlying
/// data will be used when doing things like inspecting the number of faces on the mesh.
/// If you modify the location of one of the mesh vertices, the shallow copy will create
/// a full duplicate of the underlying mesh data and the shallow copy will become a
/// deep copy.
/// </summary>
/// <returns>An object of the same type as this object.
/// <para>This behavior is overridden by implementing classes.</para></returns>
/// <since>5.0</since>
public GeometryBase DuplicateShallow()
{
GeometryBase rc = DuplicateShallowHelper();
if (null != rc)
{
rc.m_shallow_parent = this;
}
return(rc);
}
/// <summary>
/// Computes draft curve silhouettes of a shape.
/// </summary>
/// <param name="geometry">Geometry whose silhouettes need to be computed. Can be Brep, BrepFace, Mesh, or Extrusion.</param>
/// <param name="draftAngle">The draft angle in radians. Draft angle can be a positive or negative value.</param>
/// <param name="pullDirection">3d direction for the mold to be pulled in, directed away from the object.</param>
/// <param name="tolerance">
/// Tolerance to use for determining projecting relationships.
/// Surfaces and curves that are closer than tolerance, may be treated as projecting.
/// When in doubt use RhinoDoc.ModelAbsoluteTolerance.
/// </param>
/// <param name="angleToleranceRadians">
/// Angular tolerance to use for determining projecting relationships.
/// A surface normal N that satisfies N o cameraDirection < Sin(angleToleranceRadians) may be considered projecting.
/// When in doubt use RhinoDoc.ModelAngleToleranceRadians.
/// </param>
/// <returns>Array of silhouette curves.</returns>
/// <since>7.0</since>
public static Silhouette[] ComputeDraftCurve(
GeometryBase geometry,
double draftAngle,
Vector3d pullDirection,
double tolerance,
double angleToleranceRadians
)
{
return(ComputeDraftCurve(geometry, draftAngle, pullDirection, tolerance, angleToleranceRadians, System.Threading.CancellationToken.None));
}
/// <summary>
/// Compute silhouettes of a shape for a specified projection.
/// </summary>
/// <param name="geometry">Geometry whose silhouettes need to be computed. Can be Brep, BrepFace, Mesh, or Extrusion.</param>
/// <param name="silhouetteType">Types of silhouette to compute.</param>
/// <param name="viewport">Projection.</param>
/// <param name="tolerance">Tolerance to use for determining projecting relationships.
/// Surfaces and curves that are closer than tolerance, may be treated as projecting.
/// When in doubt use RhinoDoc.ModelAbsoluteTolerance.</param>
/// <param name="angleToleranceRadians">Angular tolerance to use for determining projecting relationships.
/// A surface normal N that satisfies N o cameraDirection < Sin(angleToleranceRadians) may be considered projecting.
/// When in doubt use RhinoDoc.ModelAngleToleranceRadians.</param>
/// <param name="clippingPlanes">Optional collection of clipping planes.</param>
/// <param name="cancelToken">Computation cancellation token.</param>
/// <returns>Array of silhouette curves.</returns>
/// <since>6.0</since>
public static Silhouette[] Compute(
GeometryBase geometry,
SilhouetteType silhouetteType,
ViewportInfo viewport,
double tolerance,
double angleToleranceRadians,
IEnumerable <Plane> clippingPlanes,
System.Threading.CancellationToken cancelToken)
{
if (viewport.IsParallelProjection)
{
return(Compute(geometry, silhouetteType, viewport.CameraDirection, tolerance, angleToleranceRadians, clippingPlanes, cancelToken));
}
return(Compute(geometry, silhouetteType, viewport.CameraLocation, tolerance, angleToleranceRadians, clippingPlanes, cancelToken));
}
/// <summary>
/// Compute silhouettes of a shape for a perspective projection.
/// </summary>
/// <param name="geometry">Geometry whose silhouettes need to be computed. Can be Brep, BrepFace, Mesh, or Extrusion.</param>
/// <param name="silhouetteType">Types of silhouette to compute.</param>
/// <param name="perspectiveCameraLocation">Location of perspective camera.</param>
/// <param name="tolerance">Tolerance to use for determining projecting relationships.
/// Surfaces and curves that are closer than tolerance, may be treated as projecting.
/// When in doubt use RhinoDoc.ModelAbsoluteTolerance.</param>
/// <param name="angleToleranceRadians">Angular tolerance to use for determining projecting relationships.
/// A surface normal N that satisfies N o cameraDirection < Sin(angleToleranceRadians) may be considered projecting.
/// When in doubt use RhinoDoc.ModelAngleToleranceRadians.</param>
/// <param name="clippingPlanes">Optional collection of clipping planes.</param>
/// <param name="cancelToken">Computation cancellation token.</param>
/// <returns>Array of silhouette curves.</returns>
/// <since>6.0</since>
public static Silhouette[] Compute(
GeometryBase geometry,
SilhouetteType silhouetteType,
Point3d perspectiveCameraLocation,
double tolerance,
double angleToleranceRadians,
IEnumerable <Plane> clippingPlanes,
System.Threading.CancellationToken cancelToken)
{
IntPtr const_ptr_geometry = geometry.ConstPointer();
Plane[] planes = null;
int plane_count = 0;
if (clippingPlanes != null)
{
List <Plane> p = new List <Plane>(clippingPlanes);
plane_count = p.Count;
planes = p.ToArray();
}
ThreadTerminator terminator = null;
IntPtr ptr_terminator = IntPtr.Zero;
if (cancelToken != System.Threading.CancellationToken.None)
{
terminator = new ThreadTerminator();
ptr_terminator = terminator.NonConstPointer();
cancelToken.Register(terminator.RequestCancel);
}
UnsafeNativeMethods.SilEventType s = (UnsafeNativeMethods.SilEventType)silhouetteType;
IntPtr ptr_silhouettes = UnsafeNativeMethods.TLC_Sillhouette2(const_ptr_geometry, s, perspectiveCameraLocation, tolerance, angleToleranceRadians, planes, plane_count, ptr_terminator);
Silhouette[] rc = FromClassArray(ptr_silhouettes);
UnsafeNativeMethods.TLC_SilhouetteArrayDelete(ptr_silhouettes);
if (terminator != null)
{
terminator.Dispose();
}
GC.KeepAlive(geometry);
return(rc);
}
/// <summary>
/// Determines if two geometries equal one another, in pure geometrical shape.
/// This version only compares the geometry itself and does not include any user
/// data comparisons.
/// This is a comparison by value: for two identical items it will be true, no matter
/// where in memory they may be stored.
/// </summary>
/// <param name="first">The first geometry</param>
/// <param name="second">The second geometry</param>
/// <returns>The indication of equality</returns>
/// <since>6.0</since>
public static bool GeometryEquals(GeometryBase first, GeometryBase second)
{
if (first == null && second == null)
{
return(true);
}
if (first == null || second == null)
{
return(false);
}
IntPtr first_ptr = first.ConstPointer();
IntPtr second_ptr = second.ConstPointer();
bool rc = UnsafeNativeMethods.RH_RhinoCompareGeometry(first_ptr, second_ptr);
Runtime.CommonObject.GcProtect(first, second);
return(rc);
}
private Silhouette(IntPtr ptrSilEvent)
{
IntPtr ptr_curve = UnsafeNativeMethods.TLC_SilEvent_ExtractCurve(ptrSilEvent);
Curve = GeometryBase.CreateGeometryHelper(ptr_curve, null) as Curve;
ComponentIndex ci = ComponentIndex.Unset;
var et = UnsafeNativeMethods.TLC_SilEvent_Extract(ptrSilEvent, ref ci);
switch (et)
{
case UnsafeNativeMethods.SilEventType.None:
SilhouetteType = SilhouetteType.None;
break;
case UnsafeNativeMethods.SilEventType.Tangent:
SilhouetteType = SilhouetteType.Tangent;
break;
case UnsafeNativeMethods.SilEventType.Projecting:
SilhouetteType = SilhouetteType.Projecting;
break;
case UnsafeNativeMethods.SilEventType.TanProjects:
SilhouetteType = SilhouetteType.TangentProjects;
break;
case UnsafeNativeMethods.SilEventType.Boundary:
SilhouetteType = SilhouetteType.Boundary;
break;
case UnsafeNativeMethods.SilEventType.Crease:
SilhouetteType = SilhouetteType.Crease;
break;
case UnsafeNativeMethods.SilEventType.DraftCurve:
SilhouetteType = SilhouetteType.DraftCurve;
break;
}
GeometryComponentIndex = ci;
}
/// <summary>
/// Initializes a box that contains a generic piece of geometry.
/// This box will be aligned with an arbitrary plane.
/// </summary>
/// <param name="basePlane">Base plane for aligned bounding box.</param>
/// <param name="geometry">Geometry to box.</param>
/// <since>5.0</since>
public Box(Plane basePlane, GeometryBase geometry)
{
// David: this code is untested.
m_dx = new Interval(+1, -1);
m_dy = new Interval(0, 0);
m_dz = new Interval(0, 0);
m_plane = basePlane;
if (!m_plane.IsValid)
{
return;
}
Transform mapping = Geometry.Transform.ChangeBasis(Plane.WorldXY, m_plane);
BoundingBox bbox = geometry.GetBoundingBox(mapping);
m_dx = new Interval(bbox.Min.m_x, bbox.Max.m_x);
m_dy = new Interval(bbox.Min.m_y, bbox.Max.m_y);
m_dz = new Interval(bbox.Min.m_z, bbox.Max.m_z);
MakeValid();
}
public Curve[] Explode()
{
Runtime.InteropWrappers.SimpleArrayCurvePointer curves = new Runtime.InteropWrappers.SimpleArrayCurvePointer();
IntPtr pConstThis = ConstPointer();
IntPtr pCurveArray = curves.NonConstPointer();
UnsafeNativeMethods.ON_PolyCurve_SegmentCurves(pConstThis, pCurveArray);
int count = UnsafeNativeMethods.ON_CurveArray_Count(pCurveArray);
Curve[] rc = new Curve[count];
for (int i = 0; i < count; i++)
{
IntPtr pConstSegmentCurve = UnsafeNativeMethods.ON_CurveArray_Get(pCurveArray, i);
if (IntPtr.Zero == pConstSegmentCurve)
{
continue;
}
IntPtr pNewCurve = UnsafeNativeMethods.ON_Curve_DuplicateCurve(pConstSegmentCurve);
rc[i] = GeometryBase.CreateGeometryHelper(pNewCurve, null) as Curve;
}
curves.Dispose();
return(rc);
}
/// <summary>
/// Is called when a non-constant operation occurs.
/// </summary>
protected override void OnSwitchToNonConst()
{
m_shallow_parent = null;
base.OnSwitchToNonConst();
}
internal static GeometryBase CreateGeometryHelper(IntPtr pGeometry, object parent, int subobjectIndex)
{
if (IntPtr.Zero == pGeometry)
{
return(null);
}
var type = UnsafeNativeMethods.ON_Geometry_GetGeometryType(pGeometry);
if (type < 0)
{
return(null);
}
GeometryBase rc = null;
switch (type)
{
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Curve: //1
rc = new Curve(pGeometry, parent, subobjectIndex);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_NurbsCurve: //2
rc = new NurbsCurve(pGeometry, parent, subobjectIndex);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PolyCurve: // 3
rc = new PolyCurve(pGeometry, parent, subobjectIndex);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PolylineCurve: //4
rc = new PolylineCurve(pGeometry, parent, subobjectIndex);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_ArcCurve: //5
rc = new ArcCurve(pGeometry, parent, subobjectIndex);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_LineCurve: //6
rc = new LineCurve(pGeometry, parent, subobjectIndex);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Mesh: //7
rc = new Mesh(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Point: //8
rc = new Point(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_TextDot: //9
rc = new TextDot(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Surface: //10
rc = new Surface(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Brep: //11
rc = new Brep(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_NurbsSurface: //12
rc = new NurbsSurface(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_RevSurface: //13
rc = new RevSurface(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PlaneSurface: //14
rc = new PlaneSurface(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_ClippingPlaneSurface: //15
rc = new ClippingPlaneSurface(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Hatch: // 17
rc = new Hatch(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_SumSurface: //19
rc = new SumSurface(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepFace: //20
{
int faceindex = -1;
IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref faceindex);
if (ptr_brep != IntPtr.Zero && faceindex >= 0)
{
Brep b = new Brep(ptr_brep, parent);
rc = b.Faces[faceindex];
}
}
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepEdge: // 21
{
int edgeindex = -1;
IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref edgeindex);
if (ptr_brep != IntPtr.Zero && edgeindex >= 0)
{
Brep b = new Brep(ptr_brep, parent);
rc = b.Edges[edgeindex];
}
}
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_InstanceReference: // 23
rc = new InstanceReferenceGeometry(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Extrusion: //24
rc = new Extrusion(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PointCloud: // 26
rc = new PointCloud(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DetailView: // 27
rc = new DetailView(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Light: //32
rc = new Light(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PointGrid: //33
rc = new Point3dGrid(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_MorphControl: //34
rc = new MorphControl(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepLoop: //35
{
int loopindex = -1;
IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref loopindex);
if (ptr_brep != IntPtr.Zero && loopindex >= 0)
{
Brep b = new Brep(ptr_brep, parent);
rc = b.Loops[loopindex];
}
}
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepTrim: // 36
{
int trimindex = -1;
IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref trimindex);
if (ptr_brep != IntPtr.Zero && trimindex >= 0)
{
Brep b = new Brep(ptr_brep, parent);
rc = b.Trims[trimindex];
}
}
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Leader: // 38
rc = new Leader(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_SubD: // 39
rc = new SubD(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimLinear: //40
rc = new LinearDimension(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimAngular: //41
rc = new AngularDimension(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimRadial: //42
rc = new RadialDimension(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimOrdinate: //43
rc = new OrdinateDimension(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Centermark: //44
rc = new Centermark(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Text: //45
rc = new TextEntity(pGeometry, parent);
break;
default:
rc = new UnknownGeometry(pGeometry, parent, subobjectIndex);
break;
}
return(rc);
}
