xBrepFace.py

"""
200619: Created.
200629: Bug fix.
200729: Import-related update.
200810: Added a couple of functions.
210114: Removed raise for when createPoint3dOnInterior doesn't find a point.
210209: Now won't raise an error when 2 curves do not close in splitFace.
210407: Added more support for new-in-V7's BrepFace.PerFaceColor.
210412: Added more times fEdgeLen_Min is used in splitFace.
210503: Now, curves on SENW are ignored for retrim when underlying surface is not being replaced.
210929: is3dPointOnFace now converts non-NurbsSurfaces into NurbsSurfaces on ClosestPoint fails.
220317: Updated to use a new overload.  Import-related update.
"""

import Rhino
import Rhino.DocObjects as rd
import Rhino.Geometry as rg
import scriptcontext as sc

from System import Guid
from System import Random

import xCurve
import xSurface


def formatDistance(fDistance):
    if fDistance is None:
        return "(No deviation was provided.)"
    if fDistance == 0.0:
        return "Exactly zero"
    if fDistance < 10.0**(-(sc.doc.DistanceDisplayPrecision-3)):
        return "{:.1e}".format(fDistance)
    else:
        return "{:.{}f}".format(fDistance, sc.doc.ModelDistanceDisplayPrecision)


def createPoint3dOnInterior(rgFace, fMinDistFromBorder=None, bDebug=False):
    """
    Parameters:
        rgFace: BrepFace
        fMinDistFromBorder: float or (None to loop through various)
    Returns:
        Point3d on success, None on failure
    """
    
    fMinDistFromBorder_In = fMinDistFromBorder
    
    rgB_1F = rgFace.DuplicateFace(duplicateMeshes=False)
    rgB_1F.Faces.ShrinkFaces()
    rgB_1F.Compact() # Is this cecessary to remove duplicate surfaces?
    rgSrf_Shrunk = rgB_1F.Surfaces[0]
    
    domU_Shrunk = rgSrf_Shrunk.Domain(0)
    domV_Shrunk = rgSrf_Shrunk.Domain(1)

    #areaMassProp = rg.AreaMassProperties.Compute(rgFace.DuplicateFace(True)) # Otherwise, Compute uses underlying Surface for BrepFace.
    #if areaMassProp is None:
    #    print "Face[{}]'s AreaMassProperties cannot be calculated.".format(
    #        rgFace.FaceIndex)
    #    u = domU_Shrunk.Mid
    #    v = domV_Shrunk.Mid
    #else:
    #    ptCentrdW = areaMassProp.Centroid
    #    bSuccess, u, v = rgFace.ClosestPoint(ptCentrdW)

    u_Shrunk = domU_Shrunk.Mid
    v_Shrunk = domV_Shrunk.Mid

    # To3dCurve will include curves of seams.  This is advantageous in this circumstance.
    rgCrvs_fromLoops = [loop.To3dCurve() for loop in rgFace.Loops]

    rand = Random()

    if fMinDistFromBorder_In is None:
        rangeTol = (
            10.0*sc.doc.ModelAbsoluteTolerance,
            sc.doc.ModelAbsoluteTolerance,
            0.5*sc.doc.ModelAbsoluteTolerance
            )
    else:
        rangeTol = fMinDistFromBorder_In,

    for fMinDistFromBorder in rangeTol:
        for i in xrange(1000):
            pt = rgSrf_Shrunk.PointAt(u_Shrunk, v_Shrunk)
            
            b, u, v = rgFace.ClosestPoint(pt)
            if not b: raise ValueError("ClosestPoint failed in createPointOnFace.")
            
            ptFaceRel = rgFace.IsPointOnFace(u, v)
            #sc.doc.Objects.AddPoint(pt); sc.doc.Views.Redraw()

            if bDebug: sEval = "ptFaceRel"; print sEval+':',eval(sEval)

            if ptFaceRel == rg.PointFaceRelation.Interior:
                # If point is not at least fMinDistFromBorder from border (all edges),
                # continue searching.
                for c in rgCrvs_fromLoops:
                    b, t = c.ClosestPoint(pt)
                    if not b: raise ValueError("ClosestPoint failed in createPointOnFace.")
    
                    dist = pt.DistanceTo(c.PointAt(t))
                    if dist < fMinDistFromBorder:
                        break # to get another u and v.
                else: # Good point
                    for c in rgCrvs_fromLoops: c.Dispose()
                    rgB_1F.Dispose()
                    if bDebug: sEval = "i"; print sEval+':',eval(sEval)
                    return pt
    
            # Get new parameters for point.
            u_Shrunk = rand.NextDouble() * domU_Shrunk.Length + domU_Shrunk.Min
            v_Shrunk = rand.NextDouble() * domV_Shrunk.Length + domV_Shrunk.Min

    from System.Drawing import Color
    attr = rd.ObjectAttributes()
    attr.LayerIndex = sc.doc.Layers.CurrentLayerIndex
    attr.ColorSource = rd.ObjectColorSource.ColorFromObject
    attr.ObjectColor = Color.Red
    sc.doc.Objects.AddBrep(rgFace.DuplicateFace(duplicateMeshes=True), attributes=attr)

    print "Failed to find an interior point on face." \
        "  Its monoface has been added to the document."

    #sc.doc.Views.Redraw()
    #raise ValueError(
    #    "Failed to find an interior point on face[{}].".format(
    #        rgFace.FaceIndex))


def is3dPointOnFace(rgFace, pt, fTolerance=None):
    """
    Returns:
        False when the point is at least fTolerance from the face's underlying surface.
        Otherwise, rg.PointFaceRelation.Interior or Boundary.
    """
    
    if fTolerance is None:
        fTolerance = sc.doc.ModelAbsoluteTolerance
    
    b, u, v = rgFace.ClosestPoint(pt) # ClosestPoint is a Surface method and ignores edges of BrepFaces.
    if not b:
        s = "ClosestPoint on {} failed ".format(rgFace.UnderlyingSurface().GetType().Name)
        s += "at {:.15g},{:.15g},{:.15g}.".format(pt.X, pt.Y, pt.Z)
        if isinstance(rgFace.UnderlyingSurface(), rg.NurbsSurface):
            print s
            return

        ns = rgFace.UnderlyingSurface().ToNurbsSurface()
        b, u, v = ns.ClosestPoint(pt)
        ns.Dispose()
        if not b:
            s += "  It also failed for the NurbsSurface equivalent."
            print s
            return
        s += "  But NurbsSurface equivalent passed."
        print s

    dist = rgFace.PointAt(u,v).DistanceTo(pt)
    if dist > fTolerance:
        # Point isn't even on underlying surface.
        return False

    try:
        ptFaceRel = rgFace.IsPointOnFace(u, v, fTolerance) # Overload added to RhinoCommon 7.0.
    except:
        ptFaceRel = isParameterPointOnFace_beforeV7(
            rgFace, u, v, fTolerance)

    return ptFaceRel


def isParameterPointOnFace_beforeV7(rgFace, u, v, f3dTolerance=None):
    """
    Hard-coded (3D) tolerance of IsPointOnFace up through at least V6.28 (7/17/2020)
    is Rhino.RhinoMath.SqrtEpsilon.
    Request to add tolerance parameter:
    https://discourse.mcneel.com/t/wish-add-tolerance-parameter-to-ispointonface/106801
    Until tolerance parameter is added to IsPointOnFace,
    check False values against distance from closest edge.
    """
    
    if f3dTolerance is None:
        f3dTolerance = sc.doc.ModelAbsoluteTolerance
    
    ptAt = rgFace.PointAt(u, v)
    # Note that this Point3d will already be pulled to the face.
    # For true 3D point check, use is3dPointOnFace instead.
    
    ptFaceRel = rgFace.IsPointOnFace(u, v)
    
    if ptFaceRel == rg.PointFaceRelation.Boundary:
        return rg.PointFaceRelation.Boundary
    
    for iE in rgFace.AdjacentEdges():
        bSuccess, t = rgFace.Brep.Edges[iE].ClosestPoint(
            testPoint=ptAt,
            maximumDistance=f3dTolerance)
        if not bSuccess:
            continue
        pt_onEdge = rgFace.Brep.Edges[iE].PointAt(t)
        dist_toCrv = ptAt.DistanceTo(other=pt_onEdge)
        if dist_toCrv <= f3dTolerance:
            return rg.PointFaceRelation.Boundary
    else:
        # No distances smaller than f3dTolerance found.
        return ptFaceRel # Exterior or boundary.


def splitFace(rgFace, **kwargs):
    """
    Parameters:
        rgFace
        rgSrf_Replacement: If None, use UnderlyingSurface of BrepFace.
        rgCrvs_Splitters_Replacement: If None, use 3D curves of rgFace loops.
        fSplitTol
        bTrimToSegs
        fEdgeLen_Min
        bOutputTrimmingCrvs
        bEcho
        bDebug
    Returns on success:
        rg.Brep
    Returns on fail:
        None
    """


    def setOpt(key, value): return kwargs[key] if key in kwargs else value

    rgSrf_Replacement = setOpt('rgSrf_Replacement', None)
    rgCrvs_Splitters_Replacement = setOpt('rgCrvs_Splitters_Replacement', None)
    fSplitTol = setOpt('fSplitTol', sc.doc.ModelAbsoluteTolerance)
    bTrimToSegs = setOpt('bTrimToSegs', True)
    fEdgeLen_Min = setOpt('fEdgeLen_Min', 2.0*sc.doc.ModelAbsoluteTolerance)
    bOutputTrimmingCrvs = setOpt('bOutputTrimmingCrvs', False)
    bEcho = setOpt('bEcho', True)
    bDebug = setOpt('bDebug', True)


    if bDebug: print "Function splitFace():"
    
    rgF_In = rgFace

    rgSrf_toSplit = rgF_In.UnderlyingSurface() if rgSrf_Replacement is None else rgSrf_Replacement
    
    # Reject surfaces that contain natural edges < 2 * fSplitTol.
    for iDir, t in zip(
        (0, 0, 1, 1),
        (rgSrf_toSplit.Domain(1).T0, rgSrf_toSplit.Domain(1).T1,
            rgSrf_toSplit.Domain(0).T0, rgSrf_toSplit.Domain(1).T1,),
    ):
        isoCrv = rgSrf_toSplit.IsoCurve(iDir, t)
        fLength = isoCrv.GetLength()
        isoCrv.Dispose()
        if 0.0 < fLength <= 2.0 * sc.doc.ModelAbsoluteTolerance:
            return


    fEdgeDevs = []
    for idxE in rgF_In.AdjacentEdges():
        fEdgeDev = rgF_In.Brep.Edges[idxE].Tolerance
        if fEdgeDev is not None:
            fEdgeDevs.append(fEdgeDev)
    fMaxEdgeDev = max(fEdgeDevs)


    def trimIsSenw(rgTrim):
        return (rgTrim.IsoStatus == Rhino.Geometry.IsoStatus.South or
                rgTrim.IsoStatus == Rhino.Geometry.IsoStatus.East or
                rgTrim.IsoStatus == Rhino.Geometry.IsoStatus.North or
                rgTrim.IsoStatus == Rhino.Geometry.IsoStatus.West)


    # Although splits may be successful if trims include seams,
    # they are avoided for cleaner input.  Otherwise, this could be used:
    # rgCrvs_fromLoops = [loop.To3dCurve() for loop in rgFace_In.Loops]

    rgCrvs_fromLoops = []
    for iL in range(rgF_In.Loops.Count):
        rgL = rgF_In.Loops[iL]
        cs_ofLoop = []
        for iT in range(rgL.Trims.Count):
            rgT = rgL.Trims[iT]
            if rgT.TrimType == rg.BrepTrimType.Seam: continue
            if rgT.TrimType == rg.BrepTrimType.Singular: continue
            if rgT.TrimType not in (
                rg.BrepTrimType.Boundary, rg.BrepTrimType.Mated
            ):
                print rgT.TrimType

            if rgSrf_Replacement is None:
                # Ignore curves on SENW.
                if trimIsSenw(rgT):
                    if bDebug: print "SENW curve ignored."
                    continue

            cs_ofLoop.append(rgT.Edge.DuplicateCurve())
        
        #for c in cs_ofLoop: sc.doc.Objects.AddCurve(c)
        #sc.doc.Views.Redraw(); 1/0
        
        cs_WIP = []
        for c in cs_ofLoop:
            fLength = c.GetLength()
            if fLength > max(fSplitTol, fEdgeLen_Min):
                # Before including fEdgeLen_Min, adjacent LineCurves would
                # sometimes become PolylineCurves from JoinCurves, with
                # entire PolylineCurve counted as 1 segment.
                cs_WIP.append(c)
            else:
                c.Dispose()
        
        cs_ofLoop = cs_WIP[:]
        
        fJoinTol = max(2.0*fMaxEdgeDev, 2.0*fSplitTol, fEdgeLen_Min)
        
        rgCrvs_Joined = rg.Curve.JoinCurves(
            cs_ofLoop,
            joinTolerance=fJoinTol)

        #for c in rgCrvs_Joined: sc.doc.Objects.AddCurve(c)
        #    sc.doc.Views.Redraw(); 1/0

        for c in rgCrvs_Joined:
        #    if not c.IsClosed:
        #        if len(cs_ofLoop) == 2:
        #            print "Loop may be thin and didn't close."
        #            return
        #        
        #        sc.doc.Objects.AddCurve(c); sc.doc.Views.Redraw()
        #        raise ValueError("Curve is not closed.")
            rgCrvs_fromLoops.append(c)

    #for c in rgCrvs_fromLoops: sc.doc.Objects.AddCurve(c)
    #sc.doc.Views.Redraw()
    #return

    rgCrvs_Splitters_WIP = [c.Duplicate() for c in rgCrvs_fromLoops]

    rc = xCurve.getCurvesToSplitSurface(
        rgCrvs_Splitters_WIP, rgSrf_toSplit, fSplitTol)
    if not rc:
        rgB_Out = rgSrf_toSplit.ToBrep()
        if Rhino.RhinoApp.ExeVersion >= 7:
            rgB_Out.Faces[0].PerFaceColor = rgF_In.PerFaceColor
        return rgB_Out

    for c in rgCrvs_Splitters_WIP: c.Dispose()
    rgCrvs_Splitters_WIP = rc

    iCt_CrvsWithShortEdgesRemoved = 0
    if fEdgeLen_Min:
        for c in rgCrvs_Splitters_WIP:
            if c.RemoveShortSegments(fEdgeLen_Min):
                iCt_CrvsWithShortEdgesRemoved += 1

    if bTrimToSegs:
        segs = xCurve.duplicateSegments(rgCrvs_Splitters_WIP)
        if segs:
            for c in rgCrvs_Splitters_WIP: c.Dispose()
            rgCrvs_Splitters_WIP = segs

    rgCrvs_Splitters = rgCrvs_Splitters_WIP

    if bDebug or bOutputTrimmingCrvs: map(sc.doc.Objects.AddCurve, rgCrvs_Splitters)
    if bDebug: sc.doc.Objects.AddSurface(rgSrf_toSplit)

    rc = xSurface.splitSurfaceIntoBrep(
        rgSrf_toSplit,
        rgCrvs_Splitters,
        fTolerance=fSplitTol,
        bTryOtherTolsOnFail=True,
        bDebug=bDebug)
    if rc is None:
        if bEcho: print "Split failed."
        return
    rgB_Out = rc
    if Rhino.RhinoApp.ExeVersion >= 7:
        for rgF in rgB_Out.Faces:
            rgF.PerFaceColor = rgF_In.PerFaceColor
    return rgB_Out


def retrimFace(rgFace, **kwargs):
    """
    Parameters:
        rgFace,
        rgSrf_Replacement=None, # If None, UnderlyingSurface of BrepFace is used.
        rgCrvs_Splitters_Replacement=None, # If None, 3D curves of rgFace loops are used.
        fSplitTol=sc.doc.ModelAbsoluteTolerance,
        bTrimToSegs=True,
        fEdgeLen_Min=2.0*sc.doc.ModelAbsoluteTolerance,
        bOutputSplitOnFail=False,
        bOutputTrimmingCrvs=False,
        bEcho=True,
        bDebug=False)
    Returns on success:
        rg.Brep
    Returns on fail:
        None
    """


    def setOpt(key, value): return kwargs[key] if key in kwargs else value

    rgSrf_Replacement = setOpt('rgSrf_Replacement', None)
    rgCrvs_Splitters_Replacement = setOpt('rgCrvs_Splitters_Replacement', None)
    fSplitTol = setOpt('fSplitTol', sc.doc.ModelAbsoluteTolerance)
    bTrimToSegs = setOpt('bTrimToSegs', True)
    fEdgeLen_Min = setOpt('fEdgeLen_Min', 2.0*sc.doc.ModelAbsoluteTolerance)
    bOutputSplitOnFail = setOpt('bOutputSplitOnFail', False)
    bOutputTrimmingCrvs = setOpt('bOutputTrimmingCrvs', False)
    bEcho = setOpt('bEcho', True)
    bDebug = setOpt('bDebug', False)


    def faceAtPoint(rgBrep, pt_onFace, bDebug=False):
        """
        Returns face index.
        """
        for idxF, rgFace in enumerate(rgBrep.Faces):
            b, u, v = rgFace.ClosestPoint(pt_onFace)
            if not b: raise ValueError("ClosestPoint returned None.")
            ptFaceRel = rgFace.IsPointOnFace(u, v)
            if ptFaceRel == rg.PointFaceRelation.Interior:
                return idxF
        sc.doc.Objects.AddBrep(rgBrep); sc.doc.Views.Redraw()
        raise ValueError("Face with point on its interior not found.")


    if bDebug: print "Function retrimFace():"
    
    rgFace_In = rgFace

    rgB_Split = splitFace(
        rgFace=rgFace_In,
        rgSrf_Replacement=rgSrf_Replacement,
        rgCrvs_Splitters_Replacement=rgCrvs_Splitters_Replacement,
        fSplitTol=fSplitTol,
        bTrimToSegs=bTrimToSegs,
        fEdgeLen_Min=fEdgeLen_Min,
        bOutputSplitOnFail=bOutputSplitOnFail,
        bOutputTrimmingCrvs=bOutputTrimmingCrvs,
        bEcho=bEcho,
        bDebug=bDebug)

    if rgB_Split is None:
        if bEcho: print "Split rejected/failed."
        return


    pt_onFace_In = createPoint3dOnInterior(rgFace_In)
    if not pt_onFace_In:
        if bOutputSplitOnFail: sc.doc.Objects.AddBrep(rgB_Split)
        rgB_Split.Dispose()
        return


    idxF_Pos = faceAtPoint(rgB_Split, pt_onFace_In)
    if idxF_Pos is None:
        if bOutputSplitOnFail: sc.doc.Objects.AddBrep(rgB_Split)
        rgB_Split.Dispose()
        return


    rgBrep_Retrmd = rgB_Split.Faces[idxF_Pos].DuplicateFace(duplicateMeshes=False)

    rgB_Split.Dispose()

    return rgBrep_Retrmd


def createModifiedFace(rgFace_In, surfaceFunc, bDebug=False):
    """
    Parameters:
        rgFace_In,
        surfaceFunc,
        bDebug,
    Returns on success:
        tuple(
            rg.Brep,
            float(Surface deviation from input))
        str(Feedback)
    Returns on fail:
        None,
        str(Feedback)
    """


    rgB_1F_In = rgFace_In.DuplicateFace(duplicateMeshes=True)
    area_In = rgB_1F_In.GetArea()
    rgB_1F_In.Dispose()
    if area_In <= (10.0*sc.doc.ModelAbsoluteTolerance)**2:
        return None, "Area of face is too small to process."

    rgSrf_In = rgFace_In.UnderlyingSurface()


    res, sLog = surfaceFunc(rgSrf_In)

    if not res:
        return None, sLog

    ns_Res, srf_dev = res

    if not ns_Res:
        return None, "NurbsSurface not created."
    if not ns_Res.IsValid:
        return None, "Invalid Surface geometry after Fit."

    if rgFace_In.IsSurface:
        rgBrep1_BeforeTrim = ns_Res.ToBrep()
        if not rgBrep1_BeforeTrim.IsValid:
            return None, "Invalid brep geometry after ToBrep."

        # Success.
        return (rgBrep1_BeforeTrim, srf_dev), "Trim skipped because face IsSurface."

    rgBrep1_AfterTrim = retrimFace(
        rgFace_In,
        rgSrf_Replacement=ns_Res, # If None, UnderlyingSurface of BrepFace is used.
        rgCrvs_Splitters_Replacement=None, # If None, 3D curves of rgFace loops are used.
        fSplitTol=sc.doc.ModelAbsoluteTolerance,
        bTrimToSegs=True,
        fEdgeLen_Min=2.0*sc.doc.ModelAbsoluteTolerance,
        bOutputSplitOnFail=False,
        bOutputTrimmingCrvs=False,
        bDebug=bDebug)

    if rgBrep1_AfterTrim is None:
        # Check areas.
        rgBrep1_BeforeTrim = ns_Res.ToBrep()

        area_Out = rgBrep1_BeforeTrim.GetArea()
        area_Diff = abs(area_In-area_Out)
        if area_Diff <= (10.0*sc.doc.ModelAbsoluteTolerance)**2:
            return (rgBrep1_BeforeTrim, srf_dev), "Face not trimmed because it is almost IsSurface."

        if bDebug:
            if not rgBrep1_BeforeTrim.IsValid:
                return None, "Invalid brep geometry after ToBrep.  (Split fail)."
            attrRed = rd.ObjectAttributes()
            attrRed.LayerIndex = sc.doc.Layers.CurrentLayerIndex
            attrRed.ColorSource = rd.ObjectColorSource.ColorFromObject
            attrRed.ObjectColor = Color.Red
            gBrep1 = sc.doc.Objects.AddBrep(rgBrep1_BeforeTrim, attrRed)
            if gBrep1 == Guid.Empty:
                return None, "Untrimmed monoface brep could not be added to document."
            return None, "Trim fail.  Split brep added."
        return None, "Trim fail."

    if not rgBrep1_AfterTrim.IsValid:
        if bDebug:
            rgBrep1_BeforeTrim = ns_Res.ToBrep()
            if not rgBrep1_BeforeTrim.IsValid:
                return None, "Invalid brep geometry after ToBrep.  (Split fail)."
            attrRed = rd.ObjectAttributes()
            attrRed.LayerIndex = sc.doc.Layers.CurrentLayerIndex
            attrRed.ColorSource = rd.ObjectColorSource.ColorFromObject
            attrRed.ObjectColor = Color.Red
            gBrep1 = sc.doc.Objects.AddBrep(rgBrep1_BeforeTrim, attrRed)
            if gBrep1 == Guid.Empty:
                return None, "Untrimmed monoface brep could not be added to document."
        return None, "Trim fail."

    # Success.
    return (rgBrep1_AfterTrim, srf_dev), None