^j0dZddlmZddlZddlZddlZddlmZmZddl m Z m Z ddl m Z ddlmZmZmZmZddlmZdd lmZddlmZdd lmZmZdd lmZdd lmZdd l m!Z!m"Z"ddl#m$Z$m%Z%m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2m3Z3ddl4m5Z5ddl6m7Z7m8Z8ddl9m:Z:ddl;mZ>ddl?m@Z@ddlAmBZBmCZCmDZDmEZEmFZFmGZGddlHmIZImJZJmKZKmLZLddlMmNZNddlOmPZPmQZQmRZRddlSmTZTddlUmVZVdd lWmXZXmYZYmZZZm[Z[m\Z\dd!l]m^Z^dd"l_m`Z`dd#lambZbdd$lcmdZdmeZedd%lfmgZgmhZhmiZimjZjdd&lkmlZldd'lmmnZnmoZodd(lpmqZqmrZrmsZsdd)lmtZtdd*lumvZvdd+lwmxZxmyZymzZzm{Z{m|Z|dd,l}m~Z~mZmZdd-lmZdd.lmZmZdd/lmZmZmZmZmZmZdd0lmZmZmZmZmZmZmZmZmZd1d2lmZmZmZmZd1d3lmZmZmZmZmZmZmZmZmZmZmZd1d4lmZmZmZmZd1d5lmZerd1d6lmZmZd1d7lmZed8eed9ZGd:d;eeeZGd<d9eeyZGd=d>ee{Zd@d?Zy)Au build123d topology name: two_d.py by: Gumyr date: January 07, 2025 desc: This module provides classes and methods for two-dimensional geometric entities in the build123d CAD library, focusing on the `Face` and `Shell` classes. These entities form the building blocks for creating and manipulating complex 2D surfaces and 3D shells, enabling precise modeling for CAD applications. Key Features: - **Mixin2D**: - Adds shared functionality to `Face` and `Shell` classes, such as splitting, extrusion, and projection operations. - **Face Class**: - Represents a 3D bounded surface with advanced features like trimming, offsetting, and Boolean operations. - Provides utilities for creating faces from wires, arrays of points, Bézier surfaces, and ruled surfaces. - Enables geometry queries like normal vectors, surface centers, and planarity checks. - **Shell Class**: - Represents a collection of connected faces forming a closed surface. - Supports operations like lofting and sweeping profiles along paths. - **Utilities**: - Includes methods for sorting wires into buildable faces and creating holes within faces efficiently. The module integrates deeply with OpenCascade to leverage its powerful CAD kernel, offering robust and extensible tools for surface and shell creation, manipulation, and analysis. license: Copyright 2025 Gumyr Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ) annotationsN)ABCabstractmethod)IterableSequence)degrees) TYPE_CHECKINGAnyLiteralTypeVar)cast)overload) BRep_Builder BRep_Tool)BRepAdaptor_Curve)BRepAlgo)BRepAlgoAPI_CommonBRepAlgoAPI_Section)BRepBuilderAPI_MakeEdgeBRepBuilderAPI_MakeFaceBRepBuilderAPI_MakeWire)BRepClass3d_SolidClassifier)BRepExtrema_DistShapeShape)BRepFeat_SplitShape)BRepFill)BRepFilletAPI_MakeFillet2d) BRepGPropBRepGProp_Face)BRepIntCurveSurface_Inter)BRepOffsetAPI_MakeFillingBRepOffsetAPI_MakePipeShell)BRepPrimAPI_MakeRevol) BRepToolsBRepTools_ReShapeBRepTools_WireExplorer) gce_MakeLin)Geom_BezierSurfaceGeom_BSplineCurveGeom_OffsetSurfaceGeom_RectangularTrimmedSurface Geom_SurfaceGeom_TrimmedCurve) GeomAbs_C0GeomAbs_CurveType GeomAbs_G1 GeomAbs_G2)GeomAdaptor_Surface)GeomAPI_ExtremaCurveCurveGeomAPI_PointsToBSplineSurfaceGeomAPI_ProjectPointOnSurf)GeomLib_IsPlanarSurface) GeomProjLib)gp_Ax1gp_Ax3gp_Plngp_Pntgp_Vec) GProp_GProps) Precision)ShapeAnalysis_Edge)ShapeFix_Solid ShapeFix_Wire)Standard_ConstructionErrorStandard_FailureStandard_NoSuchObjectStandard_TypeMismatch)StdFail_NotDone)TColgp_Array1OfPntTColgp_HArray2OfPnt)TColStd_Array1OfIntegerTColStd_Array1OfRealTColStd_HArray2OfReal)TopAbs_Orientation)TopExp)TopoDS TopoDS_Face TopoDS_Shape TopoDS_Shell TopoDS_Solid))TopTools_IndexedDataMapOfShapeListOfShapeTopTools_ListOfShapeTopTools_SequenceOfShape)interpolate_curve_network)Self deprecated)CenterOfContinuityLevelGeomTypeKeepSortBy Transition) DEG2RAD TOLERANCEAxisColorLocationOrientedBoundBoxPlaneVector VectorLike)EdgeMixin1DWire_split_edge_at_vertex) TOPODSShape ShapeList SkipClean_sew_topods_faces_topods_bool_op_topods_entities_topods_face_normal_atdowncastget_top_level_topods_shapes shapetype)_extrude_topods_shape _make_loft_make_topods_face_from_wiresfind_max_dimension)Vertex)CompoundCurve)SolidTFaceceZdZdZeddZeddZe ddZddZ e ddZ e ddZ e e jf ddZ e jfdd Z ef dd Z d dd Z d dd ZeddZd dZ d! d"dZ d# d$dZy )%Mixin2Dz1Additional methods to add to Face and Shell classcy)zDimension of Faces and Shellsselfs Q/opt/ringagent/.cad-venv/lib/python3.12/site-packages/build123d/topology/two_d.py_dimz Mixin2D._dimsc  tjttjttj t tjttjti}t|}||t|S)z6Returns the right type of wrapper, given a OCCT object) ta TopAbs_VERTEXr{ TopAbs_EDGErh TopAbs_WIRErj TopAbs_FACEr TopAbs_SHELLShellrvrt)clsobjconstructor_lut shape_types rr z Mixin2D.casts[   f NND NND NND OOU  s^ *z*8C=99rctS)z9Unused - only here because Mixin1D is a subclass of Shape)NotImplementedrr directions rextrudezMixin2D.extrudes rc|j tdtj|}t t t |jj|_d|_ |S)zReverse normal operator -Nz Invalid Shape) _wrapped ValueErrorcopydeepcopytcastrlrtwrapped Complemented topo_parent)r new_surfaces r__neg__zMixin2D.__neg__sV == _- -mmD) #FHT\\5N5N5P,QR #' rcy)z-split_by_perimeter and keep inside or outsideNrr perimeterkeeps rsplit_by_perimeterzMixin2D.split_by_perimeterrcy)z.split_by_perimeter and keep inside and outsideNrrs rrzMixin2D.split_by_perimeterrrcy)z,split_by_perimeter and keep inside (default)Nrrs rrzMixin2D.split_by_perimeterrrcd fd }fd}d d}d d}|tjtjtjhvr t d|j s t dt }jD cgc]}|jD]} | } }} |jD]} | sg} | D]W} | j| } | | jD].tfd| jDs&|| 0Y|| | D]}|j|jtj}|j!||j#||j%}||j'}||}||}|j(}|r t+d|jDnd }|r t+d |jDnd }t-||z t-||z k}|tjk(r |r||fS||fS|tjk(r|r|S|S|r|S|Scc} }w)aasplit_by_perimeter Divide the faces of this object into those within the perimeter and those outside the perimeter. Note: this method may fail if the perimeter intersects shape edges. Args: perimeter (Union[Edge,Wire]): closed perimeter keep (Keep, optional): which object(s) to return. Defaults to Keep.INSIDE. Raises: ValueError: perimeter must be closed ValueError: keep must be one of Keep.INSIDE|OUTSIDE|BOTH Returns: Union[Face | Shell | ShapeList[Face] | None, Tuple[Face | Shell | ShapeList[Face] | None]: The result of the split operation. - **Keep.INSIDE**: Returns the inside part as a `Shell` or `Face`, or `None` if no inside part is found. - **Keep.OUTSIDE**: Returns the outside part as a `Shell` or `Face`, or `None` if no outside part is found. - **Keep.BOTH**: Returns a tuple `(inside, outside)` where each element is either a `Shell`, `Face`, or `None` if no corresponding part is found. cg}t|jD]\}|j}|js*|j j j ||j^|S)z0Return objects from TopTools_ListOfShape as list)rangeSizeFirstIsNullappend __class__r RemoveFirst)losshapes_firstrs rgetz'Mixin2D.split_by_perimeter..getsbF388:& " ||~MM$.."5"5e"<=!  " Mrc|syt|dk(r|dSt|Dcgc]}|jc}}t|trj j |St|Scc}w)zgProcess sides to determine if it should be None, a single element, a Shell, or a ShapeList.Nrgr)lenrpr isinstancerPrr rn)sidesspotential_shellrs r process_sidesz1Mixin2D.split_by_perimeter..process_sides&sh5zQQx/E0Jq0JKO/<8~~**?;;U# #1KsA1c|g}|D]}g}|D]r}|jtkDs"tfd|jDr|j |Ot |}|j d|Dt|}|S)z-Split an edge at all given interior vertices.c3NK|]}j|tkywN distance_tor_.0 edge_vertexvertexs r zMMixin2D.split_by_perimeter..split_edge_at_vertices..9s+F'**;79DF"%c32K|]}t|ywr)rh)r split_edges rrzMMixin2D.split_by_perimeter..split_edge_at_vertices..@s(Xjj)9(X)rr_anyverticesrrkextend)edgersegments next_segmentssegment split_edgesrs @rsplit_edge_at_verticesz:Mixin2D.split_by_perimeter..split_edge_at_vertices3svH" ) " 'YG**62Y>#F+2+;+;+=FC&,,W5 "7"HK!(((XK(XXY) )OrcRtfd|Dr|jyy)z7Add vertex if it isn't already represented in the list.c3NK|]}j|tkDywrr)rexistingrs rrzHMixin2D.split_by_perimeter..add_unique_vertex..Fs!U6%%h/);UrN)allr)rrs `radd_unique_vertexz5Mixin2D.split_by_perimeter..add_unique_vertexDs#UHUU'Vrz;keep must be one of Keep.INSIDE, Keep.OUTSIDE, or Keep.BOTHz'perimeter must be a closed Wire or Edgec3NK|]}j|tkDywrrrs rrz-Mixin2D.split_by_perimeter..\s)'**;7)Crc34K|]}|jywrlengthres rrz-Mixin2D.split_by_perimeter..ps#CAHH#Crc34K|]}|jywrrrs rrz-Mixin2D.split_by_perimeter..qs$E!QXX$Er)rrSreturnlist)rrhr list[Vertex]rz list[Edge])rrrr{rNone)r[INSIDEOUTSIDEBOTHr is_closedrTfacesseamsedges intersectrrAppendrrAddBuildLeftRightrsumabs)rrrrrrrperimeter_edgesfaceseamrperimeter_edge seam_verticesseam_intersectionr constructorleftsrightsleftrightperimeter_lengthleft_perimeter_lengthright_perimeter_length left_insiders` @rrzMixin2D.split_by_perimetersg:  $ " (  T\\499= =M  ""FG G24"&**,F$4::F4FFF'oo/ ;N!*,M A$2$<$z2Mixin2D.find_intersection_points..s 1rkeyrrg)rr&rValuerInitMorePntrdto_local_coordsreZrrNextsort enumeratersto_pntzip)rother toleranceintersection_lineintersect_maker intersectionsinter_ptdistanceiintersecting_facesintersecting_pointsfintersecting_normalsresultpntnormals rfind_intersection_pointsz Mixin2D.find_intersection_pointss == I' 6<<>35T\\+Single-object intersection for Face/Shell. Returns same-dimension overlap or crossing geometry: - 2D + 2D → Face (coplanar overlap) + Edge (crossing curves) - 2D + Edge → Edge (on surface) + Vertex (piercing) - 2D + Solid/Compound → delegates to other._intersect(self) Args: other: Shape or geometry object to intersect with tolerance: tolerance for intersection detection include_touched: if True, include boundary contacts (only relevant when Solids are involved) c  |Dcgc]}||jdf}}|Dcgc]}||jdf}}t}|D]/\ t fd|D}|r|j1|Scc}wcc}w)zGFilter section edges, keeping only edges not on common face boundaries.Foptimalc3tK|]/\}}j|xrj|k1ywr)overlapsr)rcece_bboxr edge_bboxrs rrz;Mixin2D._intersect..filter_edges..sI $G&&w ::((, 9: s58) bounding_boxrnrr) section_edges common_edgesrsection_bboxesr1 common_bboxesfiltered is_commonrr3rs @@r filter_edgesz(Mixin2D._intersect..filter_edgess KXXQq!..."?@XNX?K9;R__U_34M #,+H#1 *i (5  !OOD) *OYs BB Fr-c3BK|]}t|ts|ywr)rrrrs rrz%Mixin2D._intersect..#N!*Q:MA#Nc3BK|]}t|ts|ywrrrhr=s rrz%Mixin2D._intersect..r?r@N)r5ShapeList[Edge]r6rCrrC)rrer{rbpositionr`rhrdrrn is_infiniter4 trim_infinitediagonalcenterrr _bool_op_listrexpandrrrrjrr _intersecttouch)rrrinclude_touchedr;resultsbboxcommon common_facessectionrr5r6rr' found_faces found_edgess ` rrKzMixin2D._intersects( eV $5ME x (5>>*E t $KE u %KE * :I   ,'[ eT "u'8'8$$U$3D'' $++-!? G GGE edE] +''%;M;OPF!==?L NN< ((($5(.vertex_on_edges..<Dq}}Q'94D!r)rYrrs` rvertex_on_edgesz&Mixin2D.touch..vertex_on_edges;DeDD Drc0tfd|DS)Nc3FK|]}j|kywrrX)rr%rrYs rrz9Mixin2D.touch..vertex_on_faces..?rZr[r\)rYrrs` rvertex_on_facesz&Mixin2D.touch..vertex_on_faces>r^rcBt|tfd|DS)Nc3:K|]}t|k(ywr)re)rovvecs rrz6Mixin2D.touch..is_duplicate..Cs.is_duplicateAs)C<8<< found_verticesextremar"pnt1pnt2 new_vertexs ` rrLz Mixin2D.touch s=6 E E ='[ edE] +"'k 'k $(OO9e%4%!%.2%a.'..q1'40'..q1 2 $'k )2 N02G  ! !D   NN4<< ( NN5== ) OO ~~GMMOy$@q'"4"4"6":;:A"003D"003D}}T*Y6 !'$&&(DFFH!EJ$J? ( DJJLA+J F ,Z I ,Z9I J +"K-j+Fz2&--j97:D NN5;;tY7 8rcy)zA location from a face or shellNr)rargskwargss r location_atzMixin2D.location_atrrc~tj|jt|j |zS)z6Return a copy of self moved along the normal by amount)rrmovedrb normal_at)ramounts roffsetzMixin2D.offsets-}}T"(($..2BV2K)LMMrc4tj|||||S)aproject_to_viewport Project a shape onto a viewport returning visible and hidden Edges. Args: viewport_origin (VectorLike): location of viewport viewport_up (VectorLike, optional): direction of the viewport y axis. Defaults to (0, 0, 1). look_at (VectorLike, optional): point to look at. Defaults to None (center of shape). focus (float, optional): the focal length for perspective projection Defaults to None (orthographic projection) Returns: tuple[ShapeList[Edge],ShapeList[Edge]]: visible & hidden Edges )riproject_to_viewport)rviewport_origin viewport_uplook_atfocuss rrzMixin2D.project_to_viewports".** /;  rc dfd  d fd }j tdjtj |j j |j}d}d}d} tjj} |jdj|kDrCtjd|dz} j| |d| } | d z} | | z \}}n"|j} |j j }| |kDr| |krg}| |}}|j#|t%d |t'|j( zD]P}|j|d z |z }|j||z }||z }||||\}}|j#|Rtj*||j( }t-||jz } |d z}| d z } | |kDr| |kr| |kDrt/d | dd|r |j0s t/d|s|St3j4j6}|j9d}|j9d }t3j:|j6||}t=j>||}| t/dttA|j}|S)a_wrap_edge Helper method of wrap that handles wrapping edges on surfaces (Face or Shell). Args: planar_edge (Edge): edge to wrap around surface surface_loc (Location): location on surface to wrap snap_to_face (bool,optional): ensure wrapped edge is tight against surface. Defaults to True. tolerance (float, optional): maximum allowed length error during initial wrapping operation. Defaults to 0.001 Raises: RuntimeError: wrapping over surface boundary, try difference surface_loc Returns: Edge: wrapped edge ct|}j|jfd}|d}|j|}|s t dt |fdS)z`Return the intersection point and normal of the closest surface face along directionc&|jSrrX)r%points rr zGMixin2D._wrap_edge.._intersect_surface_normal..s!--.rrz:wrapping over surface boundary, try difference surface_locc&t|dz S)Nr)r)pairrs rr zGMixin2D._wrap_edge.._intersect_surface_normal..ss47U?/Crr)r`faces_intersected_by_axissort_byr* RuntimeErrormin)rraxisrrinterrs` r_intersect_surface_normalz5Mixin2D._wrap_edge.._intersect_surface_normalsm y)D2248@@.E8D11$7E"Pu"CD DrcZt||}|j|}||z S)zBProject a 2D offset from a local surface frame onto the 3D surfaceoriginx_dirz_dir)rdfrom_local_coords) current_pointr)relative_position local_plane world_pointrsurface_x_directiontarget_object_centers r_find_point_on_surfacez2Mixin2D._wrap_edge.._find_point_on_surfacesC $)K &778IJK,[+?? rzCan't wrap around an empty face r)rrT) snap_to_facerrg)periodicrzLength error of z.6fz exceeds tolerance zWrapped edge is invalidz7Projection failed, try setting `snap_to_face` to False.)rrerrertuple[Vector, Vector])rrer)rerrerr)!rrrHrX BOUNDING_BOXx_axisrrsys float_infomax position_atrh make_line _wrap_edgerDz_axisrrintr make_splinerris_validr Surface_srparam_atCurve_sr6 Project_sr)!r planar_edge surface_locrrrplanar_edge_length subdivisions max_loops loop_count length_error to_start_edgewrapped_to_start_edge start_pntr start_normalwrapped_edge_pointsrcurrent_normaldivprevcurrr wrapped_edgesurface_handle first_param last_param curve_handleproj_curve_handleprojected_edgerrrs!` @@@rrzMixin2D._wrap_edges:2 E E&, E " E" ! +1 FL  "  == >? ? ${{8+@+@A)00::(//   ~~))   " "1 % , ,y 8 NN6;?CM$(OO{%4% !.1I7I(<<OA| $,,I&--77LY&: +A46 ,5|>M  & &} 5Q s{7L7L3L/M MN :"..a61- ~$**=9 : ++#k.C.CL1L4G4GGHL A L !OJ/Y&: +A2 ) #"<"44G {S <#8#889 9 #,,T\\:)2215 (11!4  (()=)={JW '11,O  $I  56GHMMOPr)rr)rrOrz#Vertex | Edge | Wire | Face | Shell)rrmrrfrz&Edge | Face | Shell | Solid | Compound)rrV)r Edge | Wirerz"Literal[Keep.INSIDE, Keep.OUTSIDE]r%Face | Shell | ShapeList[Face] | None)rrrzLiteral[Keep.BOTH]rzStuple[Face | Shell | ShapeList[Face] | None, Face | Shell | ShapeList[Face] | None])rrrzLiteral[Keep.INSIDE]rr)rrrr[)rr`rfloatrzlist[tuple[Vector, Vector]])ư>F)rz(Shape | Vector | Location | Axis | PlanerrrMrhrShapeList | None)rNN) rrmrrrSrrTrrrn)r}r r~r rrb)rrrrV))rrrgNN) rrfrrfrVectorLike | Nonerz float | Nonerz'tuple[ShapeList[Edge], ShapeList[Edge]])Trg) rrhrrbrrhrrrrh)__name__ __module__ __qualname____doc__propertyr classmethodr rrrrr[rr_r*rKrLrrrrrrrrrrs=; :: $. / <$<,N< .<< =$=,>= ==CG;;;$;,@; .;; GKkk{.L/8--&+- $-d % k,7k,k, k,  k,` (,(, eee& e & e  eN..N#,%)"  #   #    1  >" III I  I  Irrc\eZdZdZdZe dH dIdZe dJ dKdZdLfd ZedMdZedNdZ edOd Z edPd Z edQd Z edMd Z edRd ZedRdZedSdZedTdZedUdZedTdZedVdZedTdZedWdZedMdZedTdZedXdZe dY dZdZe d[ d\dZeedej>f d]dZ eej>fd^dZ!e"d_dZ#e d`dZ$e dad Z%e db dcd!Z&e dd ded"Z'ee dfd#Z(ee dgd$Z(edWd%Z(e dh did&Z)e djd'Z*edkd(Z+ee,jZf dld)Z.e/j`fdmd*Z1 dY dnd+Z2dod,Z3dpd-Z4dqd.Z5drd/Z6dsdtd0Z7e dYdd1 dud2Z8edd1 dvd3Z8dPd4Z8dwd5Z9edYdxd6Z:edyd7Z:dzd8Z:d{d9Z;dyd:Z< d|d;Z=ed<d}d~d=Z>dWd>Z?d{d?Z@e d dd@ZAe d ddAZAe d ddBZA d ddCZA d ddDZBddEZC d ddFZD d ddGZExZFS)raA Face in build123d represents a 3D bounded surface within the topological data structure. It encapsulates geometric information, defining a face of a 3D shape. These faces are integral components of complex structures, such as solids and shells. Face enables precise modeling and manipulation of surfaces, supporting operations like trimming, filleting, and Boolean operations.g@Ncy)aFBuild a Face from an OCCT TopoDS_Shape/TopoDS_Face Args: obj (TopoDS_Shape | Plane, optional): OCCT Face or Plane. label (str, optional): Defaults to ''. color (Color, optional): Defaults to None. parent (Compound, optional): assembly parent. Defaults to None. Nr)rrlabelcolorparents r__init__z Face.__init__Crrcy)aBuild a planar Face from a boundary Wire with optional hole Wires. Args: outer_wire (Wire): closed perimeter wire inner_wires (Iterable[Wire], optional): holes. Defaults to None. label (str, optional): Defaults to ''. color (Color, optional): Defaults to None. parent (Compound, optional): assembly parent. Defaults to None. Nr)r outer_wire inner_wiresrrrs rrz Face.__init__Trrcd\}}}}}}|rrt|} t|dtr|d}nNt|dtr|dddd| z zz\}}}}n't|dtr|dddd| z zz\}}}}}dj t |jjgd} | rtd| |jd |}|jd |}|jd |}|jd |}|jd |}|jd|}t|tr#t|jj}|_||D cgc]} | jc} ng} td|jg| zDr tdt|j| }t |E||dn|||d|_ycc} w)N)NNNNNNrr, )rrrrrrUnexpected argument(s) rrrrrrc3HK|]}tj| ywr)r IsClosed_s)rws rrz Face.__init__..s&((++s "z*Face can only be created with closed wiresrrrr)rrrdrOrjjoinsetkeys differencerrrrrrrysuperr created_on)rr}r~rrrrrrl_a unknown_argsrinner_topods_wiresrs rrz Face.__init__gs=H: KeUF d)C$q'5)1gDG\2,0!Hw!c'7J,J)UE6DGT*@DRa7GLA= Kvyy   ) )    6|nEF Fjj$ZZ j9 jj <  7E* 7E*Hf- c5 !)#++6;;=C  !4?4KK0q0QS $,,-0BB!!MNN.z/A/ACUVC  "5  )-!1s/G'cP|jy|jjS)a` Calculate the total surface area of the face, including the areas of any holes. This property returns the overall area of the face as if the inner boundaries (holes) were filled in. Returns: float: The total surface area, including the area of holes. Returns 0.0 if the face is empty. )r without_holesarears rarea_without_holeszFace.area_without_holess& == !!#(((rcX|j}t|ttfr'|j }t|ttfr't j t|j}|xtjk(r(t|jjSxtjk(r(t|jjSxtjk(rB|j!}tt#|j%|j'Sxtj(k(r(t|j+jStj,k(rt|jS y)z.Get the rotational axis of a cylinder or torusN) geom_adaptorrr*r) BasisSurfacerm geom_LUT_FACEr1GetTyperZCONEr`ConeCYLINDERCylinderSPHEREPositionr7rb DirectionTORUSTorus REVOLUTION)rsurf geom_typeax3s raxis_of_rotationzFace.axis_of_rotations) "..0 >@RST$$&D >@RST''(;D(A(I(I(KL DIIK,,.//"""DMMO00233 mmoF3<<>3==?CDDDJJL--/00$$DIIK((rc !"|j td|js td|j}|j }|j }|r|Dcgc] }t |}}t j|}t||z tkDr||z jg}n@|Dcgc]#}|j|z j%}}n|jjjtjd} |jj} | rxt!|} | j"} t%t'dD cgc]$} t)j*| | | | dzdz&c} }| |zDcgc]}dD]}||z }}}n| Dcgc]}dD]}||z }}}|Dcgc]}||z j}}t-}|D]!t/|!!j1|"|j3"t4j6 \}}t9|t9|k7r]||bt%t;|t<r|n|g}t%t;|t<r|n|g}t?|t?|k7r|jAtC|!}t%"fd |DjAtC|!}tEd |D}tG||D]<\}}|jI|}|d }n"tEd |jKD}>d k(rbt||z tksy|s|jM!tO!fd|D}|r|jM!|Dcgc]}tC||} }| Scc}wcc}wcc} wcc}}wcc}}wcc}wcc}w)uComputes and returns the axes of symmetry for a planar face. The method determines potential symmetry axes by analyzing the face’s geometry: - It first validates that the face is non-empty and planar. - For faces with inner wires (holes), it computes the centroid of the holes and the face's overall center (COG). - If the holes' centroid significantly deviates from the COG (beyond a specified tolerance), the symmetry axis is taken along the line connecting these points; otherwise, each hole’s center is used to generate a candidate axis. - For faces without holes, candidate directions are derived by sampling midpoints along the outer wire's edges. - If curved edges are present, additional candidate directions are obtained from an oriented bounding box (OBB) constructed around the face. For each candidate direction, the face is split by a plane (defined using the candidate direction and the face’s normal). The top half of the face is then mirrored across this plane, and if the area of the intersection between the mirrored half and the bottom half matches the bottom half’s area within a small tolerance, the direction is accepted as an axis of symmetry. Returns: list[Axis]: A list of Axis objects, each defined by the face's center and a direction vector, representing the symmetry axes of the face. Raises: ValueError: If the face or its underlying representation is empty. ValueError: If the face is not planar. z.Can't determine axes_of_symmetry of empty facez/axes_of_symmetry only supports for planar facesT)reverserrg)r??r)rc3@K|]}|jywr)mirror)rr% split_planes rrz(Face.axes_of_symmetry..9s)*+%)sc34K|]}|jywrrrr%s rrz(Face.axes_of_symmetry..=s:aff:rc34K|]}|jywrrrs rrz(Face.axes_of_symmetry..Cs$JQVV$Jrc3TK|]}|jdtzk!yw)N)dotr_)rd cross_dirs rrz(Face.axes_of_symmetry..Ms(#>?i(2 >9#s%()(rr is_planarrHrrrcombined_centerrr_ normalizedrr filter_byrZLINErccornersrnrrhrrrdcrosssplitr[rtyperrrrr`rrrraddr)#rcogr)shape_inner_wiresr hole_facesholes_centroid cross_dirsr% curved_edges shape_edgesobbr'r" obb_edgesrp mid_points mid_point symmetry_dirstopbottomtop_list bottom_listtop_flipped_list bottom_area flipped_face bottom_face intersectionintersect_areaoppositer  symmetry_axesr!rs# @@raxes_of_symmetryzFace.axes_of_symmetrysN == MN N~~NO Okkm! ,,. +<=a$q'=J=!11*=N>C'(94-3??AB HRR!qxxzC/;;=R R!'')33HMM43P //+113K&t,++%OTUVxX!T^^GAJQ! 0DEX $/#:O?@AE .9R/RQa!eReR RJTUY9s?668UJU%(U #/ 5Ioof-K **[tyy*AKCCyDL({fn 3(=C5IH#j.FFVHUK8}K 00%--d3 .BCK()/7) gd3 *+ :k::K-01A;-O K) k+55kB '%)N!$$J\5G5G5I$J!J  K%>K/09<$!%%i0"#CP# H$%)))4_/ 5b0==!c1= =]>SYSUh>s*'O?(O!1)O&)O+O1O7O<cr|jdd}t||j|jS)zLocation at the center of facer)r)rrdrlocation)rrs rcenter_locationzFace.center_locationVs2!!#s+V4>> :CCCrc Pd}|jrt|j|}|j}t d|Dr|j }d}t |dk(rg}|D]b}|j|Dcgc]}||j vs|c}|D cgc]!}|D cgc]} | jdc} #} }} dt d Dr/d}t |jtjdk(rd }|Scc}wcc} wcc} }w) zgeometry of planar faceNc3VK|]!}|jtjk(#ywr)rrZr&rs rrz Face.geometry..csIA1;;(--/Is')POLYGONrrc3PK|]}|dj|ddk( yw)rrgZN) get_angle)redge_directionss rrz Face.geometry..os2+(*44_Q5GHBNs$& RECTANGLErgSQUARE) r"rdrrrrrr tangent_atgroup_byr\LENGTH) rr' flat_faceflat_face_edgesflat_face_vertices edge_pairsrrrredge_pair_directionss rgeometryz Face.geometry\s$ >>#Dk99$?I'oo/OIII%.%7%7%9""'1,35J"4"))(7R16QZZ\;QQROY0FJDADT__Q/A0,0 /C"-77 FG1L%-F SB0s$D D * D"3D D"D"c|jtjk(rqt|j t sS|j }| td|jj|j|jz S|jtjk(rS|j}| td|jj|j|jz S|jtjk(r|j }| |j tdt!t#|}t%j&|jdj)|}|j+|j\}}}|jj|j|z Sy)a Compute the signed dot product between the face normal and the vector from the underlying geometry's reference point to the face center. For a cylinder, the reference is the cylinder's axis position. For a sphere, it is the sphere's center. For a torus, we derive a reference point on the central circle. Returns: float: The signed value; positive indicates convexity, negative indicates concavity. Returns 0 if the geometry type is unsupported. z$Can't find curvature of empty objectrr)rrZrrrr*rrrrrHrDrrGr radiirbrdrh make_circlelocatedistance_to_with_closest_points)rrloc axis_circlerpnt_on_axis_circles r_curvature_signzFace._curvature_signyst >>X.. .z    !?8 ((D| !GHH>>#''  (EF F >>X__ ,--C{ !GHH>>#''  (DE E >>X^^ +((D|tzz1 !GHH5;'C**4::a=9@@EK'2'R'R ( $A!1>>#'' 8J(JK Krc(|jtkDS)z Determine whether a given face is convex relative to its underlying geometry for supported geometries: cylinder, sphere, torus. Returns: bool: True if convex; otherwise, False. rcr_rs ris_circular_convexzFace.is_circular_convexs##i//rc*|jt kS)z Determine whether a given face is concave relative to its underlying geometry for supported geometries: cylinder, sphere, torus. Returns: bool: True if concave; otherwise, False. rers ris_circular_concavezFace.is_circular_concaves##yj00rcTtj|j}t|t}|j sy|j }|jjs0tt|jj}t|S)zRIs the face planar even though its geom_type may not be PLANE - if so return PlaneN) rrrr5r_IsPlanarPlanrDirectr9r8Ax2rd)rsurfaceplanar_searcherplns rr"zFace.is_planars{%%dll31'9E'')""$||~$$&  2 2 456CSzrcd}|jrft|j|}|jj t j }|dj |dj z }|S)zlength of planar faceNrr)r"rdrrrr`rtrr'rU face_verticess rrz Face.lengthf >>d 33D9I%..088@M"2&((=+;+=+==F rc|jtjk(r<|jj |jj fSy)z:Return the major and minor radii of a torus otherwise NoneN)rrZr r MajorRadius MinorRadiusrs rr\z Face.radiisM >>X^^ +!!#//1!!#//1  rc|jtjtjfvr>h//A A*    !?K $$&--/ /rc`tjjfdS)z+Return the seams contained within this FacecPj|jjSr)IsSeamr)rsaers rr zFace.seams..s 199dll0Sr)r>rr%)rr~s`@rrz Face.seamss%!"zz|%%&STTrc|jtjk(rEt|j t s't |j jSy)z/Return the semi angle of a cone, otherwise NoneN)rrZrrrr*r SemiAnglers r semi_anglezFace.semi_anglesL >>X]] *:    !?4 4,,.88:; ;rcBttjjj }t j |dfd dfd }|j}jDcgc] }|| }}t ||Scc}w)aCreate a planar face from a face's parametric-space boundary. Each boundary edge's pcurve on ``self`` is converted to a normal build123d ``Edge`` on the XY plane, where X is the surface U parameter and Y is the surface V parameter. The original outer/inner wire structure is kept so the result can be displayed with normal build123d/ocp-vscode tooling. Args: source_face: Planar or non-planar face to inspect. Returns: A planar ``Face`` in UV parameter space. ctj|j\}}tj|j||}t |||}|j s t d|j}|jtjk(r#tj|j}t|S)Nz)Unable to convert pcurve to a planar edge) rRange_srCurveOnSurface_srrorrh OrientationrKTopAbs_REVERSEDrMReversed) native_edgerlastpcurve edge_builder topods_edger xy_surfaces ruv_edgezFace.uv_face..uv_edges#++KFKE4// T\\5RVWF26:udSL&&( !LMM&++-K&&(,>,N,NN$kk+*>*>*@A  $ $rct|j}g}|jrY|jt j |j |j|jrYt|Sr) r%rrrrMrhCurrentrrj) source_wire wire_exploreruv_edgesrs ruv_wirezFace.uv_face..uv_wiresm2;3F3FGMH$$& M4I4I4K(L MN""$ $$&> !r)rrh)rrjrrj) rrdXYrrrrrr)rxy_facerrwirerrrs` @@ruv_facez Face.uv_faces*%((*:*:;@@B((1  % "T__./ 151A1A1CDwt}D DJ ,,Es?Bcy)z6volume - the volume of this Face, which is always zerorrrs rvolumez Face.volumesrcd}|jrft|j|}|jj t j }|dj |dj z }|S)zwidth of planar faceNrr)r"rdrrrr`rurrs rwidthz Face.width#rtrc|s tdttjt|j|S)a/extrude Extrude an Edge into a Face. Args: direction (VectorLike): direction and magnitude of extrusion Raises: ValueError: Unsupported class RuntimeError: Generated invalid result Returns: Face: extruded shape zCan't extrude empty object)rrrMrwrrs rrz Face.extrude0s3 9: :FKK 5ckk9 MNOOrc t|dkst|ddkr tdt|dkDst|ddkDr td|r?t|t|k7st|dt|dk7r tdtdt|dt|d}t|D]H\}}t|D]5\}}|j |dz|dzt |j 7J|rxtdt|dt|d}t|D]:\}} t| D]'\}} |j |dz|dzt| )<t||} n t|} |t| tjjS)umake_bezier_surface Construct a Bézier surface from the provided 2d array of points. Args: points (list[list[VectorLike]]): a 2D list of control points weights (list[list[float]], optional): control point weights. Defaults to None. Raises: ValueError: Too few control points ValueError: Too many control points ValueError: A weight is required for each control point Returns: Face: a potentially non-planar face rrz9At least two control points must be provided (start, end)z*The maximum number of control points is 25z0A weight must be provided for each control pointrg)rrrGrSetValuererrJrr'rr= Confusion_sr) rpointsweightspoints_r" row_pointsjrweights_ row_weightsweightbeziers rmake_bezier_surfacezFace.make_bezier_surfaceDs, v;?c&)nq0K  v; s6!9~2IJ J  K3w< '3vay>S_+LOP P%aVaVAYH&v. GMAz%j1 G5  QAve}/C/C/EF G G ,QG aWQZQH"+G"4 C;!*;!7CIAv%%a!eQUE&MBC C(:F'0F*693H3H3JKPPRSSrc d dd d fd }|Dcgc] }|| }}|Dcgc] }|| }}t|||}|t|tjj Scc}wcc}w)a Constructs a Gordon surface from a network of profile and guide curves. Requirements: 1. Profiles and guides may be defined as points or curves. 2. Only the first or last profile or guide may be a point. 3. At least one profile and one guide must be a non-point curve. 4. Each profile must intersect with every guide. 5. Both ends of every profile must lie on a guide. 6. Both ends of every guide must lie on a profile. Args: profiles (Iterable[VectorLike | Edge]): Profiles defined as points or edges. guides (Iterable[VectorLike | Edge]): Guides defined as points or edges. tolerance (float, optional): Tolerance used for surface construction and intersection calculations. Raises: ValueError: input Edge cannot be empty. Returns: Face: the interpolated Gordon surface cNtdd}|jd||jd|tdd}|jdd|jddtdd}|jd|dz|jd|dzt ||||}|S)Nrgrrr)rFrrIrHr()rdegreecontrol_pointsknotsmultiplicitiescurves r create_zero_length_bspline_curvezBFace.make_gordon_surface..create_zero_length_bspline_curves015N  # #Au -  # #Au -(A.E NN1c " NN1c "4Q:N  # #Avz 2  # #Avz 2%ne^VTELrcFt|tttfr6t|}t |j j }|S|s tdt|j }tj|j dd}|jr|jsk|jtjk(sJ|jtj k(s)t#||j%|j'}|S)Nzinput Edge cannot be emptyrrg)rretuplerr:rXYZrrrr IsPeriodicIsClosedrr.GeomAbs_BSplineCurveGeomAbs_BezierCurver,FirstParameter LastParameter)shape_shapesingle_point_curveadaptorrrs r to_geom_curvez/Face.make_gordon_surface..to_geom_curves%&%!:;%E6>>--/0&"*) !=>>' 6G%%emmQ:E##%'*:*:*<??$(9(N(NN??$(9(M(MM)7113W5J5J5LLr)r)rg)rr:rrrr()rzVectorLike | Edge)rUrr=rr) rprofilesguidesrrr ocp_profiles ocp_guidesgordon_bspline_surfacers @rmake_gordon_surfacezFace.make_gordon_surfaceus@*+  #&   $ .;CC e,C C8>?umE*? ?!: * "  #& (=(=(? df  D?s A=BzNThe 'make_plane' method is deprecated and will be removed in a future version.cXt|jj}||S)z/Create a unlimited size Face aligned with planerrr)rplane pln_shapes r make_planezFace.make_planes%,EMM:??A 9~rc|t|j| dz|dz| dz|dzj}||S)aTmake_rect Make a Rectangle centered on center with the given normal Args: width (float, optional): width (local x). height (float, optional): height (local y). plane (Plane, optional): base plane. Defaults to Plane.XY. Returns: Face: The centered rectangle rr)rrheightrrs r make_rectzFace.make_rectsG, MME6C<vgmVc\ $& 9~rcRt|tr|nt|tr t|n|}t|tr|j }n9t|trt d|Dr t |}n tdtd|Dr td|S)z>Normalize and validate the exterior boundary for make_surface.c3<K|]}t|tywrrB)ros rrz/Face._surface_exterior_edges..s? $%Jq$ ? sz(exterior must be a Wire or list of Edgesc3"K|]}|  ywrr)rrs rrz/Face._surface_exterior_edges..s2D4x2s zexterior contains empty edges) rrjrrrrrnrr)exteriornormalized_exterior outside_edgess r_surface_exterior_edgeszFace._surface_exterior_edgess (D) (H-h  )4 0/557M +X 63? )<? < &&9:MGH H 2M2 2<= =rc |j||jS#|$r}t||d}~wwxYw)z3Build a filling surface and convert it into a Face.N)rrmr)rrn error_messagefailure_exceptionserrs r_build_surface_facezFace._build_surface_faces> 7 MMOw}}' '! 7}-3 6 7s%(> 9>ct|j}|D]*}|s td|j|j, ||j S#t $r}t d|d}~wwxYw)z.Add interior wires as holes to a surface face.z$interior_wires contain an empty wireJError adding interior hole in non-planar face with provided interior_wiresN)rrrrrrEr)r surface_faceinterior_wiresmakeface_objectrrs r_add_surface_holeszFace._add_surface_holess 2,2F2FG" .D !GHH    - . ++-. . \  sA A6% A11A6c 2|r|Dcgc] }t|}}nd}tdddddddd d d }|j|D]"}|j|jt $|j |d ttttf}|rE|D]} |jt| |j |dttttf}|r|j||}|j}|js td|Scc}w)aPCreate Non-Planar Face Create a potentially non-planar face bounded by exterior (wire or edges), optionally refined by surface_points with optional holes defined by interior_wires. Args: exterior (Union[Wire, list[Edge]]): Perimeter of face surface_points (list[VectorLike], optional): Points on the surface that refine the shape. Defaults to None. interior_wires (list[Wire], optional): Hole(s) in the face. Defaults to None. Raises: RuntimeError: Internal error building face RuntimeError: Error building non-planar face with provided surface_points RuntimeError: Error adding interior hole RuntimeError: Generated face is invalid Returns: Face: Potentially non-planar face NrrFgh㈵>g-C6?{Gz?皙? ) Degree NbPtsOnCurNbIter AnisotropieTol2dTol3dTolAngTolCurvMaxDeg MaxSegmentsz5Error building non-planar face with provided exteriorz;Error building non-planar face with provided surface_pointsznon planar face is invalid)rer rrrr-rrBrErCrAr:rfixrr) rrsurface_pointsrr5surface_point_vectorsrnrrrs r make_surfacezFace.make_surface!s88 8F$G1VAY$G !$G$( !,% *//9 2D KK j 1 2..  C %*     !. , FEN+ ,22M$#).  L 11,OL#'') $$;< <{%HsDc tdt|dt|d}t|D]H\}}t|D]5\} } |j|dz| dzt | j 7J|rt |g|||d} nt ||||} | js td| j} |t| tjjS)amake_surface_from_array_of_points Approximate a spline surface through the provided 2d array of points. The first dimension correspond to points on the vertical direction in the parameter space of the face. The second dimension correspond to points on the horizontal direction in the parameter space of the face. The 2 dimensions are U,V dimensions of the parameter space of the face. Args: points (list[list[VectorLike]]): a 2D list of points, first dimension is V parameters second is U parameters. tol (float, optional): tolerance of the algorithm. Defaults to 1e-2. smoothing (Tuple[float, float, float], optional): optional tuple of 3 weights use for variational smoothing. Defaults to None. min_deg (int, optional): minimum spline degree. Enforced only when smoothing is None. Defaults to 1. max_deg (int, optional): maximum spline degree. Defaults to 3. Raises: ValueError: B-spline approximation failed Returns: Face: a potentially non-planar face defined by points rgr)DegMaxTol3D)DegMinrrzB-spline approximation failed)rGrrrrerr3rorSurfacerr=rr) rrtol smoothingmin_degmax_degrr" point_rowrrspline_builder spline_geoms r!make_surface_from_array_of_pointsz&Face.make_surface_from_array_of_points}sB&aVaVAYH%f- GLAy%i0 G5  QAve}/C/C/EF G G ;#,33N<sN$$&<= =$,,. *; 8M8M8OPUUWXXrcyrr)redge1edge2s rmake_surface_from_curveszFace.make_surface_from_curves rcyrr)rwire1wire2s rrzFace.make_surface_from_curvesr rcd\}}|r:t|dk7st|dt|dur td|\}}|jd|}|jd|}|jd|}|jd |}|r+t d d j |j t|ttfrt|ttfs tdt|tr;|jtj|j|j}|S|jtj|j|j}|S) armake_surface_from_curves Create a ruled surface out of two edges or two wires. If wires are used then these must have the same number of edges. Args: curve1 (Union[Edge,Wire]): side of surface curve2 (Union[Edge,Wire]): opposite side of surface Returns: Face: potentially non planar surface NNrrrgz>Both curves must be of the same type (both Edge or both Wire).rrr r zUnexpected argument(s): r)rr* TypeErrorpoprrrrrhrjr rShell_srFace_s)rr}r~curve1curve2 return_values rrzFace.make_surface_from_curvessA$ 4yA~d1gd47m!CT"NFFGV,GV,GV,GV, 7 &++-8P7QRS S&4,/z&4QU,7WP  fd #88H$4$4V^^V^^$TUL88HOOFNNFNN$STLrctjttjttj t i}t}|r:|D]5}|j|dj|dj||d7|r4|D]/}|j|j|tj1|r|D]}|jt| |j|tj|j} | j)} | j*r| s t'd| S#tt t"t$f$r} t'd| d} ~ wwxYw)amake_surface_patch Create a potentially non-planar face patch bounded by exterior edges which can be optionally refined using support faces to ensure e.g. tangent surface continuity. Also can optionally refine the surface using surface points. Args: edge_face_constraints (list[tuple[Edge, Face, ContinuityLevel]], optional): Edges defining perimeter of face with adjacent support faces subject to ContinuityLevel. Defaults to None. edge_constraints (list[Edge], optional): Edges defining perimeter of face without adjacent support faces. Defaults to None. point_constraints (list[VectorLike], optional): Points on the surface that refine the shape. Defaults to None. Raises: RuntimeError: Error building non-planar face with provided constraints RuntimeError: Generated face is invalid Returns: Face: Potentially non-planar face rrgrz8Error building non-planar face with provided constraintsNzNon planar face is invalid)rYC0r-C1r/C2r0r rrr:rrMrrmrBrErCrArrr) redge_face_constraintsedge_constraintspoint_constraintscontinuity_dictpatch constraintrrr'rs rmake_surface_patchzFace.make_surface_patchsU@            *+ 3   qM))qM))#JqM2  ( M $,,8J8J(KL M * * &%.) *  KKMU[[]34Ff;< <    ! &    J   s9EE* E%%E*ct|j|j|tzd}||jS)asweep Revolve an Edge around an axis. Args: profile (Edge): the object to sweep angle (float): the angle to revolve through axis (Axis): rotation Axis Returns: Face: resulting face T)r"rr^rmrprofileangler revol_builders rrevolvez Face.revolve4s<&. OO LL GO   =&&())rc t|Dcgc]}|jc}}t|}g}|D]}t|tr%|j t t|g8t|tr)|j t|jqt|tr,|j t dt|dDtdt|d|Scc}w)aGsew faces Group contiguous faces and return them in a list of ShapeList Args: faces (Iterable[Face]): Faces to sew together Raises: RuntimeError: OCCT SewedShape generated unexpected output Returns: list[ShapeList[Face]]: grouped contiguous faces c32K|]}t|ywr)rrs rrz!Face.sew_faces..lsQrrzSewedShape returned a z which was unexpected)rprrurrNrrnrrPrrrQrrrr*)rrr% sewed_shapetop_level_shapes sewn_facestop_level_shapes r sew_faceszFace.sew_facesPs (E(Bq(BC 6{C&(  0 O/;7!!)T/-B,C"DEO\:!!%"8">">"@AO\:!!!1/6!J#,T/-B,CCXY "-)CsC;cFt|jdk7st|jdk7r td|j}|j}|J|Jt |g}t |g}t |j }|j|j dd|jtj||jt|j}tjr|j}|S)aOsweep Sweep a 1D profile along a 1D path. Both the profile and path must be composed of only 1 Edge. Args: profile (Union[Curve,Edge,Wire]): the object to sweep path (Union[Curve,Edge,Wire]): the path to follow when sweeping transition (Transition, optional): handling of profile orientation at C1 path discontinuities. Defaults to Transition.TRANSFORMED. Raises: ValueError: Only 1 Edge allowed in profile & path Returns: Face: resulting face, may be non-planar rgz&Use Shell.sweep for multi Edge objectsF)rrrrrjr!rrSetTransitionModerm_transModeDictrrroclean)rr#path transition profile_edge path_edgebuilderr's rsweepz Face.sweepxs: w}} 1 $DJJL(9Q(>EF F||~ IIK '''$$$ ~&YK -dll; GOOUE2!!%"6"6z"BC gmmo& ??\\^F rcd|tjk(s|tjk(rQ|jrEt }t j |j||j}t#|S|tjk(r)|jj}t#|S|tjk(r`|j\}}}}d||zz}d||zz} t}t} t|jj!|| || t#S)zCenter of Face Return the center based on center_of Args: center_of (CenterOf, optional): centering option. Defaults to CenterOf.GEOMETRY. Returns: Vector: center r)rXMASSGEOMETRYr"r<rSurfaceProperties_sr CentreOfMassrr4rH _uv_boundsr:r;rNormalre) r center_of properties center_pointu_val0u_val1v_val0v_val1u_valv_valr)s rrHz Face.centers  & ** *t~~%J  ) )$,, C%224Ll##(// /,,.557Ll##(++ +-1__-> *FFFF6F?+E6F?+E!8LXF 4<< ( / /ulF Sl##rc|}t|j}t}tj|jt j t j||D]}|j|j} ttj| jttj| jf} tj|| \} } |jtj| jtj| j|||j!|j"j%|j'j)S)aApply 2D chamfer to a face Args: distance (float): chamfer length distance2 (float): chamfer length vertices (Iterable[Vertex]): vertices to chamfer edge (Edge): identifies the side where length is measured. The vertices must be part of the edge Raises: ValueError: Cannot chamfer at this location ValueError: One or more vertices are not part of edge Returns: Face: face with a chamfered corner(s) )rrrRrLMapShapesAndAncestors_srrr FindFromKeyrhrMrLastrjorder_chamfer_edges AddChamferrrr rmr) rr! distance2rrreference_edgechamfer_buildervertex_edge_maprY edge_listrrrs r chamfer_2dzFace.chamfer_2ds#04T\\BCE&& LL"**BNNO  A'33AII>I V[[!234V[[!123E  33NEJLE5  & & EMM* EMM*   & ~~""?#8#8#:;??AArc |Dcgc]}|j|}}|s|S|j}|j}g}|g|D]Y}|Dcgc]&tfd|j Dr(}}|j |r|j ||n|[|j|d|dd} |j| jk7r| } | Scc}wcc}w)zApply 2D fillet to a face Args: radius: float: vertices: Iterable[Vertex]: Returns: Nc3hK|])}|jjj+ywr)rIsSame)r wire_vertexrs rrz!Face.fillet_2d..s.# ''..v~~>s/2rrg) rrrrrr fillet_2drr) rrzrrrrfilleted_wiresrvertices_in_wire filleted_faces ` rrXzFace.fillet_2ds *2PvV^^5OFPPK__& &&( %'.+. D' '+}}     ! !> }668 8*NM3Q sC#C#+C(c@tj|jS)z%Return the Geom Surface for this Face)rrrrs rrzFace.geom_adaptor&s""4<<00rc|j}|jDcgc]}|j|r|}}|D]!}|j|n |j|_#t |Scc}w)z.Extract the inner or hole wires from this Face)rwiresis_samerrn)routerrinnerss rrzFace.inner_wires*sn!!ZZ\B51A!BB SA$($4$4$containsrerrrr_)rrrB_u_val1rD_v_val1gp_pntr)s r is_coplanarzFace.is_coplanar2s+/??+<(t||$++FFFFK NN6&> * EC v7889D rct|j}|jtt |||j S)a Point inside Face Returns whether or not the point is inside a Face within the specified tolerance. Points on the edge of the Face are considered inside. Args: point(VectorLike): tuple or Vector representing 3D point to be tested tolerance(float): tolerance for inside determination. Defaults to 1.0e-6. point: VectorLike: tolerance: float: (Default value = 1.0e-6) Returns: bool: indicating whether or not point is within Face )rrrnr:re IsOnAFace)rrrsolid_classifiers r is_insidezFace.is_inside>s; 7t||D  !7C))++rrcyrr)r surface_pointrs rrzFace.location_atVs rcyrr)rurYrs rrzFace.location_at^srcd\}}}|rit|dttfr|d}nt|dttfr|d}t |dk(rt|dttfr|d}t |jjhd}|rtddj||jd|}|jd |}|jd |}|jd d }||dkr |dkrd \}}n||dks|dkr td|j}|j\} } } } || || | z zz} | || | z zz}n6tt|j|}|j!\} }t#}t%}t%}|j'| ||||t|}t|j)t|j+}|t|j+nt|j+}t-t/|||S)alocation_at Get the location (origin and orientation) on the surface of the face. This method supports two overloads: 1. `location_at(u: float, v: float, *, x_dir: VectorLike | None = None) -> Location` - Specifies the point in normalized UV parameter space of the face. - `u` and `v` are floats between 0.0 and 1.0. - Optionally override the local X direction using `x_dir`. 2. `location_at(surface_point: VectorLike, *, x_dir: VectorLike | None = None) -> Location` - Projects the given 3D point onto the face surface. - The point must be reasonably close to the face. - Optionally override the local X direction using `x_dir`. If no arguments are provided, the location at the center of the face (u=0.5, v=0.5) is returned. Args: u (float): Normalized horizontal surface parameter (optional). v (float): Normalized vertical surface parameter (optional). surface_point (VectorLike): A 3D point near the surface (optional). x_dir (VectorLike, optional): Direction for the local X axis. If not given, the tangent in the U direction is used. Returns: Location: A full 3D placement at the specified point on the face surface. Raises: ValueError: If only one of `u` or `v` is provided or invalid keyword args are passed. Nrrrrrg>rprYrrnrrrnrprYrNrr#Both u & v values must be specifiedr)rrerrrrrrrrrrrr=r4rLowerDistanceParametersr:r;D1r(r$rbrd)rr}r~rnrprYr user_x_dir geom_surfaceu_minu_maxv_minv_maxrFrG projectorr(dudvrrrs rrzFace.location_atcsDB/ q! $q'FH#56 $Q DGc5\2G4yA~*T!WsEl"CG6;;=)44 0  6tyy7N6OPQ Q ?MB JJsA  JJsA ZZ.  QUq1uDAq  "AQBC C%)%6%6%8 %)__%6"ueU  A//EA//E2}%,,. I%<<>LE5h X Xuc2r2r   ,779% :  ) ) +&&(  V5FGGrct|j}|D]}|j|j t|j}|j }|S#t$r}t d|d}~wwxYw)aWMake Holes in Face Create holes in the Face 'self' from interior_wires which must be entirely interior. Note that making holes in faces is more efficient than using boolean operations with solid object. Also note that OCCT core may fail unless the orientation of the wire is correct - use `Wire(forward_wire.wrapped.Reversed())` to reverse a wire. Example: For example, make a series of slots on the curved walls of a cylinder. .. image:: slotted_cylinder.png Args: interior_wires: a list of hole outline wires interior_wires: list[Wire]: Returns: Face: 'self' with holes Raises: RuntimeError: adding interior hole in non-planar face with provided interior_wires RuntimeError: resulting face is not valid rN)rrrrrErr)rrr interior_wirerrs r make_holeszFace.make_holess62$,,?+ 7M    5 5 6 7  4 4 67L $'')  \  sA$$ A>- A99A>cy)anormal_at point on surface Args: surface_point (VectorLike, optional): a point that lies on the surface where the normal. Defaults to the center (None). Returns: Vector: surface normal direction Nr)rrns rrzFace.normal_atrrcy)anormal_at u, v values on Face Args: u (float): the horizontal coordinate in the parameter space of the Face, between 0.0 and 1.0 v (float): the vertical coordinate in the parameter space of the Face, between 0.0 and 1.0 Defaults to the center (None/None) Raises: ValueError: Either neither or both u v values must be provided Returns: Vector: surface normal direction Nr)rrprYs rrzFace.normal_atrrcd\}}}|rit|dttfr|d}nt|dttfr|d}t |dk(rt|dttfr|d}dj t|jjgd}|rtd||jd|}|jd |}|jd |}||dkr |dkrd \}}n$|"td ||fDdk(r td |j}|,|j\}} } } ||| |z zz} | || | z zz} n6tt|j!|}|j#\} } t%}t'}t)|j*j-| | ||t|j/S)a0normal_at Computes the normal vector at the desired location on the face. Args: surface_point (VectorLike, optional): a point that lies on the surface where the normal. Defaults to None. Returns: Vector: surface normal direction rrrrrgr)rnrprYrrnrprYrsc3&K|] }|dk( yw)rNr)rr"s rrz!Face.normal_at..$ s*E19*Esrt)rrerrrrrrrrrrrrr=r4rrur:r;rrr>r$)rr}r~rnrprYrrnrBrCrDrErFrGr}rfr)s rrzFace.normal_at s/ q! $q'FH#56 $Q DGc5\2G4yA~*T!WsEl"CGyy   ) )*E F  6|nEF F ?MB JJsA  JJsA   QUq1uDAq  "s*Eq!f*E'E'JBC C##%  -1__-> *FFFFQ&6/22EQ&6/22E3}%,,.I%<<>LE5t||$++E5&&If~((**rcttj|j}|j ||_|S|j|_|S)z)Extract the perimeter wire from this Face)rjr# OuterWire_srr)rr`s rrzFace.outer_wire< sJY**4<<89$($4$4$re) rrprYrBrCrDrErFrGrfr)s rrzFace.position_atB st*.):&fvo..fvo..t||$++E5&&If~rc dt||g}t|jt||z}t }t |t r tdt |trLt|f|jft}|js|jt|ns|jD]`}t|f|jft}t|D]/}|jtt!j|1b|j#t%|j'|}t } |D]T} t)| j+dk(r%| j-} | 2| j| D| j| V| S)aProject Face to target Object Project a Face onto a Shape generating new Face(s) on the surfaces of the object. A projection with no taper is illustrated below: .. image:: flatProjection.png :alt: flatProjection Note that an array of faces is returned as the projection might result in faces on the "front" and "back" of the object (or even more if there are intermediate surfaces in the projection path). faces "behind" the projection are not returned. Args: target_object (Shape): Object to project onto direction (VectorLike): projection direction Returns: ShapeList[Face]: Face(s) projected on target object ordered by distance z'projection to a vertex is not supportedrg)rzrwrrernrr{rrrqrrrshellsrurrMrr`rHrrr) r target_objectr max_dimensionextruded_topods_selfintersected_shapes topods_shape target_shell topods_shellprojected_shapesr shape_faces rproject_to_shapezFace.project_to_shapeZ s0+D-+@A 4 LL&+m; 7@k mV ,EF F mT **%'-*?*?)ACUCWL &&("))&!. 4 4 6 Q .)+!))+&(  %@ $MQL&--eFLL4N.OPQ  Q077T[[]I8VW4=K' /E5;;=!Q&"ZZ\ )$++J7 ''.  / rzKThe 'to_arcs' method is deprecated and will be removed in a future version.c|j td|jjt j |j |S)ato_arcs Approximate planar face with arcs and straight line segments. This is a utility used internally to convert or adapt a face for Boolean operations. Its purpose is not typically for general use, but rather as a helper within the Boolean kernel to ensure input faces are in a compatible and canonical form. Args: tolerance (float, optional): Approximation tolerance. Defaults to 1e-3. Returns: Face: approximated face z!Cannot approximate an empty shape)rrrr r ConvertFace_sr)rrs rto_arcsz Face.to_arcs s@$ == @A A~~""8#9#9$,, #RSSrcZ|j td|jx}s|Stj|}t }|D]}|j |jt|j|j}tj||_|S)zwithout_holes Remove all of the holes from this face. Returns: Face: A new Face instance identical to the original but without any holes. z&Cannot remove holes from an empty face) rrrrrr$RemoverrtApplyrMr)rrholelessreshaper hole_wiremodified_shapes rrzFace.without_holes s == EF F#//11 1K==&$&$ /I OOI-- . /!(.."?@!;;~6rcp|jrtjdd|jS)z?Return the outerwire, generate a warning if inner_wires presentz!Found holes, returning outer_wirer) stacklevel)rwarningswarnrrs rrz Face.wire s/     MM3   rcyrrr planar_shaperrextension_factors rwrapz Face.wrap rcyrrrs rrz Face.wrap rrcyrrrs rrz Face.wrap rrct|tr|j||d|St|tr|j ||||St|t r|j ||||Stdt|)u8wrap Wrap a planar 2D shape onto a 3D surface. This method conforms a 2D shape defined on the XY plane (Edge, Wire, or Face) to the curvature of a non-planar 3D Face (the target surface), starting at a specified surface location. The operation attempts to preserve the original edge lengths and shape as closely as possible while minimizing the geometric distortion that naturally arises when mapping flat geometry onto curved surfaces. The wrapping process follows the local orientation of the surface and progressively fits each edge along the curvature. To help ensure continuity, the first and last edges are extended and trimmed to close small gaps introduced by distortion. The final shape is tightly aligned to the surface geometry. This method is useful for applying flat features—such as decorative patterns, cutouts, or boundary outlines—onto curved or freeform surfaces while retaining their original proportions. Args: planar_shape (Edge | Wire | Face): flat shape to wrap around surface surface_loc (Location): location on surface to wrap tolerance (float, optional): maximum allowed error. Defaults to 0.001 extension_factor (float, optional): amount to extend the wrapped first and last edges to allow them to cross. Defaults to 0.1 Raises: ValueError: Invalid planar shape Returns: Edge | Wire | Face: wrapped shape Tz2planar_shape must be of type Edge, Wire, Face not ) rrhrrj _wrap_wirer _wrap_facerr*rs rrz Face.wrap sX lD )??<dIN N lD )??k96F  lD )??k96F @L!" $  rc |j}t|}|djjj}t }|D]}|j} | jj| j jzdz } | |z } || |z z} |j| } tt| |j| |j| }t|jtsJ|xj| ddfzc_ tj!|||}|j#||S)uwrap_faces Wrap a sequence of 2D faces onto a 3D surface, aligned along a guiding path. This method places multiple planar `Face` objects (defined in the XY plane) onto a curved 3D surface (`self`), following a given path (Wire or Edge) that lies on or closely follows the surface. Each face is spaced along the path according to its original horizontal (X-axis) position, preserving the relative layout of the input faces. The wrapping process attempts to maintain the shape and size of each face while minimizing distortion. Each face is repositioned to the origin, then individually wrapped onto the surface starting at a specific point along the path. The face's new orientation is defined using the path's tangent direction and the surface normal at that point. This is particularly useful for placing a series of features—such as embossed logos, engraved labels, or patterned tiles—onto a freeform or cylindrical surface, aligned along a reference edge or curve. Args: faces (Iterable[Face]): An iterable of 2D planar faces to be wrapped. path (Wire | Edge): A curve on the target surface that defines the alignment direction. The X-position of each face is mapped to a relative position along this path. start (float, optional): The relative starting point on the path (between 0.0 and 1.0) where the first face should be placed. Defaults to 0.0. Returns: ShapeList[Face]: A list of wrapped face objects, aligned and conformed to the surface. rrrr)rrr4rrtrnrrrbrdrRrrrDrerrr)rrr2start path_length face_listfirst_face_min_x wrapped_facesrrO face_center_xdelta_xrelative_position_on_wire path_positionsurface_location wrapped_faces r wrap_faceszFace.wrap_faces" s)Lkk K $Q<446::<<*3  /D$$&D!XXZZ$((**49M#&66G(-+0E(E % ,,-FGM'!//*CD..7  dmmV4 44 MMgq!_ ,M99T41ABL   .! /$rc@tj|jS)z,Return the u min, u max, v min, v max values)r# UVBounds_srrs rr=zFace._uv_boundsc s##DLL11rc |j|j|||}|jDcgc]}|j||||}}tj ||j g|}|j j} |j|j } | j| dkr| }|Scc}w)a_wrap_face Helper method of wrap that handles wrapping faces on surfaces. Args: planar_face (Face): flat face to wrap around surface surface_loc (Location): location on surface to wrap tolerance (float, optional): maximum allowed error. Defaults to 0.001 extension_factor (float, optional): amount to extend wrapped first and last edges to allow them to cross. Defaults to 0.1 Returns: Face: wrapped face )rrr) rrrrrrDrrrr) r planar_facerrrwrapped_perimeterr wrapped_holesrsurface_normalwrapped_normals rrzFace._wrap_faceg s*!OO  " " $k9>N  !,,.  OOA{I7G H  (( '001() %++55%// 0D0DE   n - 1(=L sB?c J|j}|jj}tj|j }t |jdk(r2|j}|Jt|j||d|gS|j} g} d} | djdtdddk(r|} tddd} nltjtddd| djd}|j||d|}|jd} | djd} t!t#| ||j%| }| D]}|j'| }|j||d|}|jd} t!t#| ||j%| }|jd} | |jd} | j)||j*s t| S| dj-d||\}}| dj-d||\}}t/||}|j1dkr t3d|j5d\}}|j7d}|j7d}||z ||z z }|j9|d }|j7d}|j7d}||z ||z z } |j9d | }!|| d<|!| d<|jd|!jdz j:}"t=}#t?}$| D]}%|$jA|%j |#jC|$|#jE|#j}&tG}'|'jId |"z|'jK|&|'jM|'jOt|'j}(|(jPs t3d |(S) aD_wrap_wire Helper method of wrap that handles wrapping wires on surfaces. Args: planar_wire (Wire): wire to wrap around surface surface_loc (Location): location on surface to wrap tolerance (float, optional): maximum allowed error. Defaults to 0.001 extension_factor (float, optional): amount to extend wrapped first and last edges to allow them to cross. Defaults to 0.1 Raises: RuntimeError: wrapped wire is not valid Returns: Wire: wrapped wire rgNTrrrFz?Extended first/last edges do not intersect; increase extension.rrrzwrapped wire is not valid))rDrrrrrrrrrjr order_edgesrrerhrrbrdr translaterr_extend_spliner2 NbExtremar ParametersrtrimrrrSrrrr@ SetPrecisionLoad FixReorder FixConnectedr))r planar_wirerrrrnrsurface_geometryr planar_edges wrapped_edgesfirst_start_pointedge_surface_pointplanar_edge_end_pointconstruction_linewrapped_construction_lineedge_surface_locationlocal_planar_edger first_edge first_curve last_edge last_curverx param_first param_last u_start_first u_end_first new_start trimmed_first u_start_last u_end_lastnew_end trimmed_last closing_error wire_buildercombined_edgesrraw_wrapped_wire wire_fixer wrapped_wires) rrzFace._wrap_wire sL6$,, )00::$..t||< {  " #q (%**,K* **k4STU U"..0 $& ! ? & &q )VAq!_ ! ($0$<$?@@rct|j}t|j|j|tzd}|t j |jS)asweep Revolve a 1D profile around an axis. Args: profile (Curve | Wire): the object to revolve angle (float): the angle to revolve through axis (Axis): rotation Axis Returns: Shell: resulting shell T)rjrr"rr^rMrrmr"s rr&z Shell.revolve sR&w}}'- OOT\\57?D 6<< 3 3 5677rct|j}tt|jj}t|j}|j |jdd|j tj||jttj|j}tjr|j}|S)asweep Sweep a 1D profile along a 1D path Args: profile (Union[Curve, Edge, Wire]): the object to sweep path (Union[Curve, Edge, Wire]): the path to follow when sweeping transition (Transition, optional): handling of profile orientation at C1 path discontinuities. Defaults to Transition.TRANSFORMED. Returns: Shell: resulting Shell, may be non-planar F)rjrrr!rrr/rmr0rrrMror1)rr#r2r3r6r's rr7z Shell.sweep s(w}}'D&2245-dll; GOOUE2!!%"6"6z"BC v||GMMO45 ??\\^F rct}tj|j|t |j S)zCenter of mass of the shell)r<rLinearProperties_srrer<)rr@s rrHz Shell.center s1!^ $$T\\:>j--/00rrlct|jjfdd}|j|S)alocation_at Get the location (origin and orientation) on the surface of the shell. Args: surface_point (VectorLike): A 3D point near the surface. x_dir (VectorLike, optional): Direction for the local X axis. If not given, the tangent in the U direction is used. Returns: Location: A full 3D placement at the specified point on the shell surface. c&|jSrrX)r%rns rr z#Shell.location_at.. sammM.Jrrrl)rrr)rrnrrs ` rrzShell.location_at s7&zz|##$JKAN U;;rr)rz+TopoDS_Shell | Face | Iterable[Face] | Nonerrrrrrr)rrjrrfrr)F)rzIterable[Vertex | Wire]rrhrr)r#z Curve | Wirer$rrr`rr)r#rr2rrrr)rnrfrrrrb)rrrrrrrrrrrr&r]rr7rHrrrs@rrr, s+  E <@""& & 8& &  &  & T  RR"AA&888 8  882 )) $"  B1$( <!<! <   OCP.ShapeFixr?r@ OCP.StandardrArBrCrD OCP.StdFailrE OCP.TColgprFrG OCP.TColStdrHrIrJrK OCP.TopExprL OCP.TopoDSrMrNrOrPrQ OCP.TopToolsrRrSrT ocp_gordonrUtyping_extensionsrVrWbuild123d.build_enumsrXrYrZr[r\r]build123d.geometryr^r_r`rarbrcrdrerfone_drhrirjrk shape_corerlrmrnrorprqrrrsrtrurvutilsrwrxryrzzero_dr{ compositer|r}three_dr~rrrrrrrrrOs5n# #.77 ,-!C 86,!83=T1NNNM/ 0'99"#06 (> *TT 1.   >=     * CtV${ c5={ |s7; sl?A