/// <summary>
/// Constructs a rolling ball fillet between two surfaces.
/// </summary>
/// <param name="surfaceA">A first surface.</param>
/// <param name="uvA">A point in the parameter space of FaceA near where the fillet is expected to hit the surface.</param>
/// <param name="surfaceB">A second surface.</param>
/// <param name="uvB">A point in the parameter space of FaceB near where the fillet is expected to hit the surface.</param>
/// <param name="radius">A radius value.</param>
/// <param name="tolerance">A tolerance value used for approximating and intersecting offset surfaces.</param>
/// <returns>A new array of rolling ball fillet surfaces; this array can be empty on failure.</returns>
/// <exception cref="ArgumentNullException">If surfaceA or surfaceB are null.</exception>
public static Surface[] CreateRollingBallFillet(Surface surfaceA, Point2d uvA, Surface surfaceB, Point2d uvB, double radius, double tolerance)
{
if (surfaceA == null) throw new ArgumentNullException("surfaceA");
if (surfaceB == null) throw new ArgumentNullException("surfaceB");
IntPtr pConstSurfaceA = surfaceA.ConstPointer();
IntPtr pConstSurfaceB = surfaceB.ConstPointer();
using (Runtime.InteropWrappers.SimpleArraySurfacePointer srfs = new Rhino.Runtime.InteropWrappers.SimpleArraySurfacePointer())
{
IntPtr pSurfaces = srfs.NonConstPointer();
UnsafeNativeMethods.RHC_RhinoSimpleRollingBallFillet2(pConstSurfaceA, uvA,
pConstSurfaceB, uvB, radius, tolerance, pSurfaces);
return srfs.ToNonConstArray();
}
}
/// <summary>
/// Constructs a periodic surface from a base surface and a direction.
/// </summary>
/// <param name="baseSurface">A base surface.</param>
/// <param name="direction">0 is first parameter, 1 is second parameter.</param>
/// <returns>A new surface; or null on error.</returns>
public static Surface CreatePeriodicSurface(Surface baseSurface, int direction)
{
IntPtr pConstSurface = baseSurface.ConstPointer();
IntPtr pNewSurf = UnsafeNativeMethods.TL_Surface_MakePeriodic(pConstSurface, direction);
return GeometryBase.CreateGeometryHelper(pNewSurf, null) as Surface;
}
/// <summary>
/// Finds a curve by offsetting an existing curve normal to a surface.
/// The caller is responsible for ensuring that the curve lies on the input surface.
/// </summary>
/// <param name="surface">Surface from which normals are calculated.</param>
/// <param name="height">offset distance (distance from surface to result curve)</param>
/// <returns>
/// Offset curve at distance height from the surface. The offset curve is
/// interpolated through a small number of points so if the surface is irregular
/// or complicated, the result will not be a very accurate offset.
/// </returns>
public Curve OffsetNormalToSurface(Surface surface, double height)
{
IntPtr pConstThis = ConstPointer();
IntPtr pConstSurface = surface.ConstPointer();
IntPtr pOffsetCurve = UnsafeNativeMethods.RHC_RhinoOffsetCurveNormal(pConstThis, pConstSurface, height);
return GeometryBase.CreateGeometryHelper(pOffsetCurve, null) as Curve;
}
/// <summary>
/// Splits a curve into pieces using a surface.
/// </summary>
/// <param name="cutter">A cutting surface or polysurface.</param>
/// <param name="tolerance">A tolerance for computing intersections.</param>
/// <returns>An array of curves. This array can be empty.</returns>
public Curve[] Split(Surface cutter, double tolerance)
{
IntPtr pConstThis = ConstPointer();
IntPtr pConstSurface = cutter.ConstPointer();
using (Rhino.Runtime.InteropWrappers.SimpleArrayCurvePointer pieces = new SimpleArrayCurvePointer())
{
IntPtr pPieces = pieces.NonConstPointer();
UnsafeNativeMethods.RHC_RhinoCurveSplit(pConstThis, pConstSurface, tolerance, pPieces);
return pieces.ToNonConstArray();
}
}
/// <summary>
/// Compute the VolumeMassProperties for a single Surface.
/// </summary>
/// <param name="surface">Surface to measure.</param>
/// <returns>The VolumeMassProperties for the given Surface or null on failure.</returns>
/// <exception cref="System.ArgumentNullException">When surface is null.</exception>
public static VolumeMassProperties Compute(Surface surface)
{
if (surface == null)
throw new ArgumentNullException("surface");
IntPtr pSurface = surface.ConstPointer();
const double relativeTolerance = 1.0e-6;
const double absoluteTolerance = 1.0e-6;
IntPtr rc = UnsafeNativeMethods.ON_Surface_MassProperties(false, pSurface, relativeTolerance, absoluteTolerance);
return IntPtr.Zero == rc ? null : new VolumeMassProperties(rc, false);
}
/// <summary>
/// Constructs a periodic surface from a base surface and a direction.
/// </summary>
/// <param name="baseSurface">A base surface.</param>
/// <param name="direction">0 is first parameter, 1 is second parameter.</param>
/// <returns>A new surface; or null on error.</returns>
public static Surface CreatePeriodicSurface(Surface baseSurface, int direction)
{
IntPtr const_ptr_surface = baseSurface.ConstPointer();
IntPtr ptr_new_surface = UnsafeNativeMethods.TL_Surface_MakePeriodic(const_ptr_surface, direction);
return CreateGeometryHelper(ptr_new_surface, null) as Surface;
}
/// <summary>
/// Constructs a rolling ball fillet between two surfaces.
/// </summary>
/// <param name="surfaceA">A first surface.</param>
/// <param name="flipA">A value that indicates whether A should be used in flipped mode.</param>
/// <param name="surfaceB">A second surface.</param>
/// <param name="flipB">A value that indicates whether B should be used in flipped mode.</param>
/// <param name="radius">A radius value.</param>
/// <param name="tolerance">A tolerance value.</param>
/// <returns>A new array of rolling ball fillet surfaces; this array can be empty on failure.</returns>
/// <exception cref="ArgumentNullException">If surfaceA or surfaceB are null.</exception>
public static Surface[] CreateRollingBallFillet(Surface surfaceA, bool flipA, Surface surfaceB, bool flipB, double radius, double tolerance)
{
if (surfaceA == null) throw new ArgumentNullException("surfaceA");
if (surfaceB == null) throw new ArgumentNullException("surfaceB");
IntPtr const_ptr_surface_a = surfaceA.ConstPointer();
IntPtr const_ptr_surface_b = surfaceB.ConstPointer();
using (Runtime.InteropWrappers.SimpleArraySurfacePointer srfs = new Runtime.InteropWrappers.SimpleArraySurfacePointer())
{
IntPtr ptr_surfaces = srfs.NonConstPointer();
UnsafeNativeMethods.RHC_RhinoSimpleRollingBallFillet(const_ptr_surface_a, flipA,
const_ptr_surface_b, flipB, radius, tolerance, ptr_surfaces);
return srfs.ToNonConstArray();
}
}