^jY|dZddlmZddlZddlZddlmZddlmZm Z ddl m Z ddl m Z ddlmZmZmZmZmZmZmZmZmZdd lmZdd lmZdd lmZddlZddlm Z!dd l"m#Z#dd l$m%Z%ddl&m'Z'm(Z(ddl)m*Z*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5ddl6m7Z7m8Z8ddl9m:Z:ddl;mZ>m?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGddlHmIZImJZJddlKmLZLddlMmNZNddlOmPZPmQZQmRZRmSZSddlTmUZUmVZVmWZWddlXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`ddlambZbmcZcmdZddd lemfZfdd!lgmhZhmiZimjZjmkZkmlZlmmZmmnZnmoZompZpdd"lqmrZrdd#lsmtZtmuZumvZvdd$lwmxZxdd%lymzZzm{Z{m|Z|dd&l}m~Z~dd'lmZmZmZmZmZmZmZmZmZmZmZmZmZdd(lmZdd)lmZdd*lmZmZdd+lmZdd,lmZmZdd-lmZdd.lmZmZmZdd/lmZmZmZmZdd0lmZmZdd1lmZmZdd2lmZdd3lmZmZmZmZmZmZmZdd4lmZmZmZmZdd5lmZdd6lmZdd7lmZmZdd8lmZmZmZmZmZmZmZmZmZmZdd9lmZmZmZmZmZmZmZmZmZmZd:d;lmZmZmZmZmZmZmZd:dlmZmZerd:d?lmZmZmZmZd:d@lmZd:dAlmZmZe dBCGdDdEZe dBCGdFdGZdZdIZ d[dJZ d\dKZd]dMZd^dNZ d[dOZ d_dPZd`dQZGdRdSeeZGdTdLeeZGdUdHeeZdadbdVZdcdWZdejf dddXZ de dfdYZ y)gas build123d topology name: one_d.py by: Gumyr date: January 07, 2025 desc: This module defines the classes and methods for one-dimensional geometric entities in the build123d CAD library. It focuses on `Edge` and `Wire`, representing essential topological elements like curves and connected sequences of curves within a 3D model. These entities are pivotal for constructing complex shapes, boundaries, and paths in CAD applications. Key Features: - **Edge Class**: - Represents curves such as lines, arcs, splines, and circles. - Supports advanced operations like trimming, offsetting, splitting, and projecting onto shapes. - Includes methods for geometric queries like finding tangent angles, normals, and intersection points. - **Wire Class**: - Represents a connected sequence of edges forming a continuous path. - Supports operations such as closure, projection, and edge manipulation. - **Mixin1D**: - Shared functionality for both `Edge` and `Wire` classes, enabling splitting, extrusion, and 1D-specific operations. This module integrates deeply with OpenCascade, leveraging its robust geometric and topological operations. It provides utility functions to create, manipulate, and query 1D geometric entities, ensuring precise and efficient workflows in 3D modeling tasks. 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) bisect_right)IterableSequence) dataclass) combinations) atan2ceilcopysigncosfloorinfisclosepiradians) TYPE_CHECKING)cast)overload)BOPAlgo_Splitter) BRep_Tool)BRepAdaptor_CompCurveBRepAdaptor_Curve)BRepAlgoAPI_CommonBRepAlgoAPI_Section) BRepBuilderAPI_DisconnectedWireBRepBuilderAPI_EmptyWireBRepBuilderAPI_MakeEdgeBRepBuilderAPI_MakeFaceBRepBuilderAPI_MakePolygonBRepBuilderAPI_MakeVertexBRepBuilderAPI_MakeWireBRepBuilderAPI_NonManifoldWireBRepBuilderAPI_Transform)BRepExtrema_DistShapeShapeBRepExtrema_SupportType)BRepFilletAPI_MakeFillet2d) BRepGProp)BRepLibBRepLib_FindSurface) BRepLProp)BRepOffset_MakeOffset)BRepOffsetAPI_MakeOffset)BRepProj_Projection) BRepToolsBRepTools_WireExplorer)ChFi2d_FilletAlgo) Extrema_ExtPC)GC_MakeArcOfCircleGC_MakeArcOfEllipseGC_MakeArcOfHyperbolaGC_MakeArcOfParabola)GCPnts_AbscissaPointGCPnts_QuasiUniformDeflectionGCPnts_UniformDeflection)Geom_BezierCurveGeom_BSplineCurveGeom_ConicalSurfaceGeom_CylindricalSurface Geom_Line Geom_Plane Geom_SurfaceGeom_TrimmedCurve) Geom2d_Curve Geom2d_LineGeom2d_TrimmedCurve)Geom2dAPI_InterCurveCurve) GeomAbs_C0 GeomAbs_C1 GeomAbs_C2 GeomAbs_C3GeomAbs_Circle GeomAbs_CN GeomAbs_G1 GeomAbs_G2GeomAbs_JoinType)GeomAdaptor_Curve)GeomAPI_InterpolateGeomAPI_PointsToBSplineGeomAPI_ProjectPointOnCurve)#GeomConvert_CompCurveToBSplineCurve)GeomFill_CorrectedFrenetGeomFill_FrenetGeomFill_TrihedronLaw) GeomProjLib) gp_Ax1gp_Ax2gp_Ax3gp_Circgp_Dirgp_Dir2dgp_Elipsgp_Hyprgp_Parabgp_Pntgp_Pnt2dgp_Trsfgp_Vec) GProp_GProps)HLRAlgo_Projector) HLRBRep_AlgoHLRBRep_HLRToShape)ShapeAnalysis_FreeBounds)ShapeFix_ShapeShapeFix_Wireframe)Standard_ConstructionError)TColgp_Array1OfPntTColgp_Array1OfVecTColgp_HArray1OfPnt)TColStd_Array1OfIntegerTColStd_Array1OfRealTColStd_HArray1OfBooleanTColStd_HArray1OfReal)TopAbs_OrientationTopAbs_ShapeEnum)TopExpTopExp_Explorer)TopLoc_Location)TopoDSTopoDS_Compound TopoDS_Edge TopoDS_Face TopoDS_Shape TopoDS_Vertex TopoDS_Wire)TopTools_HSequenceOfShape)TopTools_IndexedDataMapOfShapeListOfShapeTopTools_IndexedMapOfShapeTopTools_ListOfShape)minimize_scalar) ConvexHull)Self deprecated) AngularDirectionCenterOfContinuityLevel FrameMethodGeomTypeKind PositionModeSagittaSideTangency) DEG2RAD TOL_DIGITS TOLERANCEAxisColorLocationPlaneVector VectorLikelogger)_make_2tan_lines_make_2tan_on_arcs_make_2tan_rad_arcs_make_3tan_arcs_make_tan_cen_arcs_make_tan_on_rad_arcs_make_tan_oriented_lines) TOPODSShape ShapeList SkipCleandowncastget_top_level_topods_shapes shapetype topods_dimunwrap_topods_compound)_extrude_topods_shape_make_topods_face_from_wires isclose_b)Vertextopo_explore_common_vertex)CompoundCurvePartSketch)Solid)FaceShellT)frozencDeZdZUdZded<ded<ded<ded<d ed <y ) _WireFilletCornerz5Context needed to fillet a single planar wire corner.WirewirervertexShapeList[Edge] all_edgesconnected_edgesz list[int]connected_edge_indicesN__name__ __module__ __qualname____doc____annotations__Q/opt/ringagent/.cad-venv/lib/python3.12/site-packages/build123d/topology/one_d.pyrrs!? J N$$%%rrc&eZdZUdZded<ded<y)_WireFilletSolutionz-Replacement edges for a filleted wire corner.list[TopoDS_Edge]trimmed_topods_edgesrzfillet_topods_edgeNrrrrrrs7++##rrrc |j}|jfd}t}|std|t |dk7rtd||Dcgc]}|j |}}t ||||Scc}w)z;Collect the topology needed to fillet a single wire corner.cHtfd|jDS)Nc3hK|])}|jjj+ywN)wrappedIsSame).0 edge_vertexrs r z@_analyze_wire_fillet_corner....s.     & &v~~ 6 s/2)anyvertices)edgers rz-_analyze_wire_fillet_corner..sS #}}  rz&Could not find shared vertex on wire: z'Vertex must connect exactly two edges: )rrrrr)edges filter_bystr ValueErrorlenindexr)rrrr vertex_labelers ` r_analyze_wire_fillet_cornerrs I)) O v;L A,PQQ ?q B<.QRR:IJQiooa0JJ  '5  Ks!B ct}|j|jdj|jdjtj jt j|jj}|j|r|j|dk(rytt}}|j|||}t||g|S)z>Try to fillet a planar wire corner with ``ChFi2d_FilletAlgo``.rrNrr)r0InitrrrXYrPnt_srPerform NbResultsrzResultr)cornerradiusfillet_builder vertex_pointtrimmed_topods_edge0trimmed_topods_edge1rs r _solve_wire_fillet_corner_chfi2dr)s '(Nq!))q!))  ??6==#8#89L  " "6 *  # #L 1Q 61< .'..*,@ 24HI- rc0tj|}tj|}tj|}tj|j |t kxs+tj|j |t kS)zCCheck whether an edge has the given vertex as one of its endpoints.)ru FirstVertex_s LastVertex_srrDistancer) topods_edge topods_vertex edge_vertex0 edge_vertex1rs r_topods_edge_contains_vertexrGsu '' 4L&&{3L??=1L %..|.osG GsMbP?c3:K|]}|jdzyw)?Nrrs rrz<_wire_fillet_corner_is_tangent_continuous..qsOt+Osdr r)r tangent_atrcrossrrminmaxrurrr position_atrLENGTHrr distance_to)rtangent0tangent1 sample_lengthreflected_pointsr sample_points r)_wire_fillet_corner_is_tangent_continuousr%gs%%a(33FMMBH%%a(33FMMBH~~h&&2G0F0FGG$NMO8N8NOM y37M&&R    - 4 4V]]5J5J K++M<;N;NOL++ m+\-@-@L v}} 5 9F<

q.ABq!--.>q.AB  Y^]T1 2 33rc t|j|tjtd}|sy|j |j d}g}|jD]}|jDcgc]}||j k7s|c}d |jj |d}ttt|jj}ttj||} |jt! fd| Dt#||j$Scc}w)zIFallback fillet using the ``Geom2dGcc_Circ2d2TanRad`` tangent-arc solver.rsagitta edge_factoryNrc3NK|]}t|jr|ywr)rr)rr other_vertexs rrzD_solve_wire_fillet_corner_geom2dgcc_circ2d2tanrad..s)/l6J6JKs"%r)rrrBOTHrsort_by_distancerrrr rto_pntrcopydeepcopyrnextrr) rr fillet_arcs fillet_arcrconnected_edgev fillet_vertexr r r+s @r1_solve_wire_fillet_corner_geom2dgcc_circ2d2tanradr7s- &     K --fmm>~NqQ  %f]&;&B&B&D E L L N ,DMM.,I<X ## '     1%-- Ts /EEcD|jDcgc]}|j}}tdD]e}|j|j |j |jj k7sI|j|j gtdD]!}|j|||j|<#t|}|jd|jddz|zk(r|jddz}n|jddz}|j||jt}|D]}|j|t} | j|| jt!| j!Scc}w)z?Replace two connected edges with a fillet and rebuild the wire.rrr)rrranger OrientationrReverserrinsertrrAppendr!AddBuildr) rsolutionrall_topods_edgesin insert_indexcombined_edgesr wire_builders r_splice_wire_fillet_cornerrGs 281A1AB BB1X7  ) )! , 8 8 :%%a(00<<> ?  ) )! , 4 4 6 71X   ) )! , 66q9: A $$Q'F,I,I!,Lq,PTU+UU44Q7!; 44Q7!; L(*E*EF)+N'+ k*+*,L^$  !!# $$=CsFct||}t|r|St|}t||}| t ||}|t d|d|t ||S)zHFillet a single planar wire corner with the available 2D fillet solvers.zFillet algorithm failed for z with radius )rr%rrr7rrG)rrrrrr@s r_fillet_wire_cornerrIsv)v 6F08 v;L/?HDVVT*<. fX N   &fh 77rceZdZdZed)dZed*dZed*dZed*dZed+dZ ed+dZ ed+dZ e d,d Z e d-d Zed.d Zed/d Zed0d ZdZd1dZd1dZd2dZej.fd3dZed d4dZ d5 d6dZdej:f d7dZd8dZ d9 d:dZ ej:e!jDdf d;dZ#ej:e!jDdf dd Z-ej:f d?d!Z.dej:df d@d"Z/ dA dBd#Z0 dC dDd$Z1d8d%Z2d&ej:e+jXf dEd'Z3d&ej:f dFd(Z4y)GMixin1Dz+Methods to add to the Edge and Wire classescy)zDimension of Edges and Wiresrrselfs r_dimz Mixin1D._dimsrcn|j tdtj|jS)z#Are the start and end points equal?z/Can't determine if empty Edge or Wire is closed)_wrappedrr IsClosed_srrMs r is_closedzMixin1D.is_closeds/ == NO O##DLL11rc|j td|jjtj k(S)z*Does the Edge/Wire loop forward or reversez/Can't determine direction of empty Edge or Wire)rQrrr:rsTopAbs_FORWARDrMs r is_forwardzMixin1D.is_forwards9 == NO O||'')-?-N-NNNrc*t|}|Dcgc]}t||jdz }}t|d|dd}|j |j }t |tj}|jScc}w)a1 Check if the edge is an interior edge. An interior edge lies between surfaces that are part of the body (internal to the geometry) and does not form part of the exterior boundary. Returns: bool: True if the edge is an interior edge, False otherwise. rrrF) PerformNow) topo_explore_connected_facesoffset_topods_facerrr?rrvrrr)rNtopods_face_pairfoffset_face_pair sectionorface_intersection_resultr s r is_interiorzMixin1D.is_interiors8=>N 9: q$++"3 4  ( Q !1!!4  #,??#4 ##;R^^L}} s Bcvt}tj|j||j S)zEdge or Wire length)rdr'LinearProperties_srMass)rNpropss rrzMixin1D.lengths+$$T\\59zz|rc |j}t|tr$|jjj S|j tk7r td|jjS)a Calculate the radius. Note that when applied to a Wire, the radius is simply the radius of the first edge. Args: Returns: radius Raises: ValueError: if kernel can not reduce the shape to a circular edge z&Shape could not be reduced to a circle) geom_adaptor isinstancerrfirstrGetTyperIrCircleRadius)rNgeoms rrzMixin1D.radiussd  " d1 2::<%%,, , <<>^ +EF F{{}##%%rcy)z>volume - the volume of this Edge or Wire, which is always zerorrMs rvolumezMixin1D.volume4srctjttjttj t i}t|}||t|S)z6Returns the right type of wrapper, given a OCCT object) r TopAbs_VERTEXrrr TopAbs_WIRErrr)clsobjconstructor_lut shape_types rrz Mixin1D.cast;sI   f NND NND  s^ *z*8C=99rctS)z9Unused - only here because Mixin1D is a subclass of Shape)NotImplementedrsrt directions rextrudezMixin1D.extrudeJs rct|ttfr t|S t|}|j |S#t$r}t |d||d}~wwxYw)z5Convert a float or VectorLike into a curve parameter.z$ must be a float or VectorLike, not N)rgintfloatr TypeErrorparam_at_point) edge_wirevaluenamepointexcs r _to_paramzMixin1D._to_paramSsn ec5\ *<  5ME ''..  &.wsK:g&!+Ksz0Only shapes with the same dimension can be addedrr)rgrrrallrrtcastrrrKrrrQr RuntimeErrorrkrhfusercleanr) rNrtopods_summandsoshapessummandsrr summand_edges sum_shapes rrzMixin1D.__add__fs = O &0u%=5'58aTR OKK?KKOP P:I JQU4$; Q 0 J +3LwGMMOLqLL L == 8}!19! C $] 3I  1  -0H!HI  ??!)I),IOO,=(>!(CINN$ JS Q KL#L2LMC 3 3 3Xab\ BIC  .HI 1%DIIx0  1s5'E521E;/F1 F>%F<0F98F9<#G"!G"c$|j|S)zPosition on wire operator @)rrNpositions r __matmul__zMixin1D.__matmul__))rc$|j|S)zTangent on wire operator %)rrs r__mod__zMixin1D.__mod__sx((rc$|j|S)zLocation on wire operator ^ location_atrs r__xor__zMixin1D.__xor__rrcl|j td|tjk(r|j d}|S|tj k(rEt }tj|j|t|j}|S|jj}|S)zCenter of object Return the center based on center_of Args: center_of (CenterOf, optional): centering option. Defaults to CenterOf.GEOMETRY. Returns: Vector: center z$Can't find center of empty edge/wire?)rQrrGEOMETRYrMASSrdr'rbrr CentreOfMass bounding_boxcenter)rN center_ofmiddle propertiess rrzMixin1D.centers == CD D )) )%%c*F (-- '%J  ( (z BJ3356F &&(//1F r) tolerancec g}|g|Dcgc]}|| }}td|Dr tdd}|Dcgc]}|jD]}|} }}td| Dr~| Dcgc]}t |dz|dz} }tdt | dDrC| dj } | dj} t| dj} t| | }|ttd |}td |}|Dcgc]}|jd d }}||z}|D]`}|jtjk(rdnd }|j!t#|Dcgc]}|j%||dz z c}btt'|}i}t |dD];}|d|dz }|d|dz }d |j)|j*z}|||<=|t-t|j/d}|d|dz j1} |d|dz j)| } tt3|t5ddddz | tfd|D}|rnd}||St3|Dcgc]}|j%d c}t5dddt7|z }t ||j8}|j;|}t=|t4sJ|j?|Scc}wcc}}wcc}wcc}wcc}w#t$rd}YwxYwcc}w)acommon_plane Find the plane containing all the edges/wires (including self). If there is no common plane return None. If the edges are coaxial, select one of the infinite number of valid planes. Args: lines (sequence of Edge | Wire): edges in common with self tolerance (float): amount lines can deviate from plane. Defaults to TOLERANCE. Returns: None | Plane: Either the common plane or None Nc3JK|]}t|ttf ywr)rgrr)rlines rrz'Mixin1D.common_plane..sHd:dT4L11Hs!#zOnly Edges or Wires are validc3VK|]!}|jtjk(#ywr) geom_typerLINErrs rrz'Mixin1D.common_plane..s?q{{hmm+?s')rc3DK|]\}}|j|ywr) is_coaxial)ra0a1s rrz'Mixin1D.common_plane..sLR2==$Ls r)z_dirc |jdkSNgd~QJrrs rrz&Mixin1D.common_plane..sDKK44Grc |jdkDSrrrs rrz&Mixin1D.common_plane..st1Crrrr)originrc3BK|]}j|ywr)contains)rpc_planers rrz'Mixin1D.common_plane..sLW--a;Lsstart) rrrrrrrrzrx_dirlistfiltertrim_to_lengthrrrextendr9rsetrrsortedkeys normalizedsumrrr intersectrg shift_origin)rNrlinespointsr all_linesresultlrras_axisrrr normal_linesinfinite_linesshortened_lines num_pointsrB extreme_areassubsetvector1vector2areaextremescommon global_center center_axis plane_originrs ` @r common_planezMixin1D.common_planesl& ""^U^( t/?D( (  HiH H<= =,5 Iqqwwy I! I I I ?Y? ?3<=atAE1q5)=G=L<3KLL ,, ,,gaj)//vU3 >'G STL#$CYONBPQQq//R8QOQ$6I! "&..HMM"AQq  EJ:EVWT%%a:>&:;W  #f+&FM&vq1 - )fQi/ )fQi/gmmG4;;<&, d#  - %VD1C1C1E,F%G%KLHa[8A;.::uLVLL$* >M)2 3AQ]]3  36!Q?  N =&,,7 '' 4 ,///""<00E( !J=R X&   4s9L)L)L.5L4L97L> %M'M MMNc D|j td|j}|/tt |j j dts tdtjdd||j }g}gg}}|D]}|j|d} |j|d} |j| |j| | j| } | j| jd ztzz } | j dk\rdnd } |j| | ztttd |D}t|j!j"}||n|d z }||z }t%t&}t)|||D]x\}} } t || zx}tkr||z}| j+jt-ddd}|jt&j/||||zzz|S) u^ Build a *curvature comb* for a planar (XY) 1D curve. A curvature comb is a set of short line segments (“teeth”) erected perpendicular to the curve that visualize the signed curvature κ(u). Tooth length is proportional to |κ| and the direction encodes the sign (left normal for κ>0, right normal for κ<0). This is useful for inspecting fairness and continuity (C0/C1/C2) of edges and wires. Args: count (int, optional): Number of uniformly spaced samples over the normalized parameter. Increase for a denser comb. Defaults to 100. max_tooth_size (float | None, optional): Maximum tooth height in model units. If None, set to 10% maximum curve dimension. Defaults to None. Raises: ValueError: Empty curve. ValueError: If the curve is not planar on `Plane.XY`. Returns: ShapeList[Edge]: A list of short `Edge` objects (lines) anchored on the curve and oriented along the left normal `n̂ = normalize(t) × +Z`. Notes: - On circles, κ = 1/R so tooth length is constant. - On straight segments, κ = 0 so no teeth are drawn. - At inflection points κ→0 and the tooth flips direction. - At C0 corners the tangent is discontinuous; nearby teeth may jump. C1 yields continuous direction; C2 yields continuous magnitude as well. Example: >>> comb = my_wire.curvature_comb(count=200, max_tooth_size=2.0) >>> show(my_wire, Curve(comb)) z+Can't create curvature_comb for empty curve?abs_tolz0curvature_comb only works for curves on Plane.XYrr)endpointrrgc32K|]}t|ywr)abs)rks rrz)Mixin1D.curvature_comb..Qs+CqCF+Cr)rQrrrrrZrnplinspacerS derivative_atrrrrrsizerrziprr make_line)rNcountmax_tooth_sizeplnu_valueskappastangents curvaturesutangent curvaturerkappasignmax_kappa_size curve_sizescale comb_edgesr pnt_on_curve kappa_dirs rcurvature_combzMixin1D.curvature_combsL == JK K! ;gc#))++&6YOOP P;;q!U5GH!2* (A((A.G**1a0I OOG $   i (MM),ELLGNNA$5 $ABE''Q,3DD MM$, ' (Y+CF+C(CD**,112 ,8Nj2o /t_& !$Xvx!@  AugUU]*6+i7!8L**,226!Q?CI   |\FY.s!--:Wrkeyrrr)rgr~r}_occt_param_atr ExceptionrrrrrDN MagnituderV)rNrorder position_mode comp_curve occt_paramclosest_forwardrclosestu_valuederivative_gp_vec derivativeedge_same_as_wirers @rrzMixin1D.derivative_atfsD, h -6:6I6I-7 3J O Q!'!1$%djjl0WX,,^$%$3t$F!+>*E t $KE&[ eT "u'8'8$$U$3D'' $++-!? G GGE eU # 7 F K K MND(($4';N;PQG NN7>>+ ,d| ,''%;M;OPF NN6==? +(($5(Pln) rNr&gtypecirc return_valueell find_surfacesurfrs rrHzMixin1D.normal_s  == CD D!!# HOO #<<>D!$))+"7"7"9:Lh&& &--/C!#((*"6"6"89L/t||tLL'')D$ +hhj%chhj&:&:&<= !!566rTc |tjtjtjtj tj tji}t|tr|n t|g}t|jdk(rM|jd}|jdd|jddg}t|j} n |j} | Jt} | j||| j!| | j#|t%| j'} t| t(r t+| d} t| t,r t| } n t/d|t0j2k7r|j5d|j5df| jj7fd d } t9| }|Dcgc]}|j5d}}|Dcgc]4}|j;dj=||j5dz 6}}|t0j>k(r|tA|d|dkD} n|tA|d|dk} |r|j5d}|j5d}| j5d}| j5d}||z jBtE|z tFkr-tHjK||}tHjK||}n,tHjK||}tHjK||}t|j| jztM||gz} | j} t| dk(r| dS| Scc}wcc}w) aB2d Offset Offsets a planar edge/wire Args: distance (float): distance from edge/wire to offset kind (Kind, optional): offset corner transition. Defaults to Kind.ARC. side (Side, optional): side to place offset. Defaults to Side.BOTH. closed (bool, optional): if Side!=BOTH, close the LEFT or RIGHT offset. Defaults to True. Raises: RuntimeError: Multiple Wires generated RuntimeError: Unexpected result type Returns: Wire: offset wire rrrnrrT)fullyzUnexpected result typecljtjk(xrtfdDS)Nc3^K|]$}j|z jtk&ywr) arc_centerrr)rptrs rrz6Mixin1D.offset_2d....s%WrQ\\B.66BWs*-)rrrSr)r endpointss`rrz#Mixin1D.offset_2d..s,KK8??2XWYWWr)reverse)'rARCrM GeomAbs_Arc INTERSECTIONGeomAbs_IntersectionTANGENTGeomAbs_Tangentrgrrrtrimrr,rAddWirerrrryrr~rrr,rredges_to_wiresrget_signed_angleLEFTr}rrrrrr)rNrCkindsideclosed kind_dictrrr topods_wireoffset_builderrt offset_wire offset_edgeswireswcenterscanglesself0self1end0end1edge0edge1res @r offset_2dzMixin1D.offset_2dsC4 HH&22   /DD LL*:: "$-t4< tzz|  !::<?DYYsC($))C*=>Eu+--K,,K&&&13IdO,{+x(~++-. c? +(D9C c; 's)K78 8 499 ))!,d.>.>q.ABI&,,.88 9L#<0E389aq}}S)9G9!"33A8H8H8K4KLFtyy #Cq F1I(=$>? #Cq VAY(>$?@ ((+((+"..q1"..q1DL((3x=8IE NN5$7E NN5$7E NN5$7E NN5$7E"JJL;#4#4#66E5>9RR #((* "%l"3q"8|AIkI5:s ;N49N9c|j|}t||j||j}tj ||j |zdz z||j |zdz z }|S)aperpendicular_line Create a line on the given plane perpendicular to and centered on beginning of self Args: length (float): line length u_value (float): position along line between 0.0 and 1.0 plane (Plane, optional): plane containing perpendicular line. Defaults to Plane.XY. Returns: Edge: perpendicular line )rrrr)rrrrrry_dir)rNrrplaner local_planers rperpendicular_linezMixin1D.perpendicular_linesy  ) 8  ~~ K%%.2 2 K%%.2 2  rcb|j||\}}}t|j|S)a_Position At Generate a position along the underlying Wire. Args: position (float): distance or parameter value position_mode (PositionMode, optional): position calculation mode. Defaults to PositionMode.PARAMETER. Returns: Vector: position on the underlying curve )rrr%)rNrredge_curve_adaptorocct_edge_paramrFs rrzMixin1D.position_ats: 261D1D m2 .OQ(..?@@rc ^||j}|jtttfvr t }n t }|j|||j|j|jr|jdk(r tdt|jDcgc].}t|j|j!|dz0c}S| |Dcgc]}|j#||c}St%dcc}wcc}w)auPositions along curve Generate positions along the underlying curve Args: distances (Iterable[float] | None, optional): distance or parameter values. Defaults to None. position_mode (PositionMode, optional): position calculation mode only applies when using distances. Defaults to PositionMode.PARAMETER. deflection (float | None, optional): maximum deflection between the curve and the polygon that results from the computed points. Defaults to None. Returns: list[Vector]: positions along curve rzDeflection calculation failedrz/Either distances or deflection must be provided)rf ContinuityrGrHrJr8r7 Initializer$r#IsDoneNbPointsrr9rr% Parameterrr)rNrNr deflectionr& discretizerrBrOs r positionszMixin1D.positionss",  !?C?P?P?RE!j*j%II-.<=  " "$$&##%   %%';+?+?+AQ+F"#BCC{3356u{{;#8#8Q#?@A   @IJ1D$$Q 6J JJKK  Ks 3D%>D*c|j|s tdt|j|jt |j }|j }|rt}|j|jt}t|D]P}|j||j|j} | |ks:| }tj|} R St!dt|D} | S)zProject onto a face along the specified direction Args: face: Face: direction: VectorLike: closest: bool: (Default value = True) Returns: z3Can't project an empty Edge or Wire onto empty Facec3FK|]}tj|ywr)rKr)rrs rrz"Mixin1D.project..hs%(- U#%s!)rQrr-rrrArr$LoadS1rrLoadS2rr%rKrr) rNr5rzrbldrshapes dist_calcmin_distrdistr[s rprojectzMixin1D.project?s == RS S" LL$,,y(9(@(@(B #'**, 24I   T\\ *H5V< 7  '!!# ((?#H#*<<#6L 7 %%1LV1T%Lrcd}|j tdt}|j|jt |}|r t |n|j }||z j}t |j}t}|jt|j|j|j|j|r t||n t|} |j| |j!|j#t%|} g} | j'| j)| j+fD]3} | j-r| j/|t1| 5g} | j3| j5| j7fD]3} | j-r| j/|t1| 5| D]}t9j:|t<| D]}t9j:|t<t?d| D} t?d| D} | | fS)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 cg}t|tj}|jrKt |j }|j ||j|jrK|Sr)rvrtrrrrrr)compoundrr rs r extract_edgesz2Mixin1D.project_to_viewport..extract_edgessaE'x1A1M1MNH--/ 0 0 23 T" --/ LrzCan't project empty edge/wirec32K|]}t|ywrrrs rrz.Mixin1D.project_to_viewport..s!Aa$q'!Arc32K|]}t|ywrrrs rrz.Mixin1D.project_to_viewport..s ?Qa ?r) rQrrfr>rrrrrXSetAxisrWr.rA SetYDirectionre ProjectorUpdateHiderg VCompoundRg1LineVCompoundOutLineVCompoundIsNullrr HCompoundOutLineHCompoundRg1LineHCompoundr(BuildCurves3d_srr)rNviewport_origin viewport_uplook_atfocusrhidden_line_removalprojection_dircamera_coordinate_system projector hlr_shapes visible_edgesr hidden_edgesrs rproject_to_viewportzMixin1D.project_to_viewportnsI0  == <= =+n - 1%,&/$++-"1G";!G!G!I[)446 #)8  (( ?))+^-B-B-D E  !..{/A/A/CD 6 >"#;<  %%i0""$  "'(;<   "  ' ' )  ' ' )  EE <<>$$]8E?%CD  E  "  ' ' )  ' ' )  DE <<>##M(5/$BC  D" 5D  # #D) 4 5  5D  # #D) 4 5"!A=!AA  ?, ?? |,,rc|j}|jr|jn|j}t |j |S)ziThe start point of this edge Note that circles may have identical start and end points. )rfrVr$r#rr%)rNr&umins r start_pointzMixin1D.start_pointsE !!#)-u##%e>Q>Q>Sekk$'((rrc|j||}|jj||jdzdz}|S)atangent_angle_at Compute the tangent angle at the specified location Args: location_param (float, optional): distance or parameter value. Defaults to 0.5. position_mode (PositionMode, optional): position calculation mode. Defaults to PositionMode.PARAMETER. plane (Plane, optional): plane line was constructed on. Defaults to Plane.XY. Returns: float: angle in degrees between 0 and 360 hv@)rrrpr)rNlocation_paramrr tan_vectorangles rtangent_angle_atzMixin1D.tangent_angle_ats>&__^]C --j%++FLPUU rcD|j|d|jS)atangent_at Find the tangent at a given position on the 1D shape where the position is either a float (or int) parameter or a point that lies on the shape. Args: position (float | VectorLike): distance, parameter value, or point on shape. Defaults to 0.5. position_mode (PositionMode, optional): position calculation mode. Defaults to PositionMode.PARAMETER. Returns: Vector: tangent value r)rr)rNrrs rrzMixin1D.tangent_ats"&!!(A}=HHJJr)returnr}rbool)rr~)rtr|rzVertex | Edge | Wire)rtrrzrrz&Edge | Face | Shell | Solid | Compound)rrKrfloat | VectorLikerrrr~)rNonerr)rzShape | Iterable[Shape]rzEdge | Wire | Curve)rr~rr)rr~rr)rrrr)rzEdge | Wire | Nonerr~rz None | Plane)rN)rr}r float | Nonerr)rrrr}rrrrrr)ư>F)rz(Shape | Vector | Location | Axis | Planerr~r2rrzShapeList | None) rCr~rrrDrrVectorLike | Nonerr) rNIterable[float]rrrDrrrrlist[Location]) rCr~rrrrsrrtrr Edge | Wire)rr~rr~rrrr)rr~rrrr)rNIterable[float] | Nonerrrrrz list[Vector]T)r5rrzrrrrz$Edge | Wire | ShapeList[Edge | Wire])rrrNN) rrrrrrrrrz'tuple[ShapeList[Edge], ShapeList[Edge]])rr~rrrrrr~)rrrrrr)5rrrrpropertyrOrSrVr`rrro classmethodrr{ staticmethodrrrrrrrrrrrrrr9rr(r1rr<rrPrHrrgrr,rrrrrrrrrrrrrrrKrKsr522 OO 6 &&,  : :$. / / /// QQ/b*)*,4+<+<2>GV1(V15:V1 V1r@DQQ0<Q Ql&2&<&< 3$33$ 3  3j) % >,7>,>, >,  >,F'3&<&<$/$6$6#' [[$[" [ ! [  [@'3&<&<$/$6$6#'  " $ "  !    : JXXYY ]J]J]J ]J  ]J  ]J@=BHH&+49 4>J=S=SAA.:A A0-1&2&<&<#' .L).L$.L! .L  .LbBF--%/-:>- --d#,%)" `-#`- `-# `-  `- 1 `-D)!$&2&<&<xx $   2(+&2&<&<K$K$K  KrrKceZdZdZdZ d: d;fd ZeddZ ee jd d e jf d?d Zeeej$d  d@d Zeeej$d  dAdZeeej$d  dBdZee dCdZee dDdZeej$d  dEdZee dFdZee dGdZeeddd dHdZedIdZee jd d e jf dJdZee jdde jf dKdZee jd d e jf dJdZe dL dMdZedNdZedOdPdZe dQ dRd Ze dS dTd!Ze dU dVd"Ze dWd#Ze dXd$ZdYd%Z dZ d[d&Z! d\ d]d'Z"de#f d^d(Z$ d_d)Z%d`d*Z& da dbd+Z'e(jRf dcd,Z*ddd-Z+ded.Z, df dgd/Z-dhdid0Z.e/d1djd2Z0e/d3dkd4Z1dld5Z2dmd6Z3 dnd7Z4edod8Z5dpd9Z6xZ7S)qraAn Edge in build123d is a fundamental element in the topological data structure representing a one-dimensional geometric entity within a 3D model. It encapsulates information about a curve, which could be a line, arc, or other parametrically defined shape. Edge is crucial in for precise modeling and manipulation of curves, facilitating operations like filleting, chamfering, and Boolean operations. It serves as a building block for constructing complex structures, such as wires and faces.rNct|trStt|jj |j jj}t|)||||y)aDBuild an Edge from an OCCT TopoDS_Shape/TopoDS_Edge Args: obj (TopoDS_Edge | Axis, optional): OCCT Edge or Axis. label (str, optional): Defaults to ''. color (Color, optional): Defaults to None. parent (Compound, optional): assembly parent. Defaults to None. rtlabelcolorparentN) rgrrr=rr.rzrArsuper__init__)rNrtrrr __class__s rrz Edge.__init__sm c4 )LL'')MM((* df    rc~|j}|j}|tjk(r7t |j j j}|S|tjk(r7t |jj j}|St|d)z3center of an underlying circle or ellipse geometry.z has no arc center) rrfrrSrrjPositionrrUrVr)rNrrfr[s rrczEdge.arc_center6sNN ((*  '!,"5"5"7"@"@"B"K"K"MNL  (** *!,"6"6"8"A"A"C"L"L"NOL {*<=> >rc|s tdttjt|j|S)a1extrude Extrude a Vertex into an Edge. Args: direction (VectorLike): direction and magnitude of extrusion Raises: ValueError: Unsupported class RuntimeError: Generated invalid result Returns: Edge: extruded shape zCan't extrude empty vertex)rrrxrrrys rr{z Edge.extrudeHs3 9: :FKK 5ckk9 MNOOr)weightsc|t|dkr tdt|dkDr td|r"t|t|k7r td|Dcgc]}t|j}}t dt|}t |D]\}}|j |dz||rStdt|}t |D]#\}} |j |dzt| %t||} n t|} |t| jScc}w)amake_bezier Create a rational (with weights) or non-rational bezier curve. The first and last control points represent the start and end of the curve respectively. If weights are provided, there must be one provided for each control point. Args: cntl_pnts (sequence[VectorLike]): points defining the curve weights (list[float], optional): control point weights list. Defaults to None. Raises: ValueError: Too few control points ValueError: Too many control points ValueError: A weight is required for each control point Returns: Edge: bezier curve rz9At 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 pointr) rrrr.rl enumerateSetValuerpr~r9rr) rsr cntl_pntscntl_pnt cntl_gp_pntspolesrB cntl_gp_pnt pole_weightsweight bezier_curves r make_bezierzEdge.make_bezier\s2, y>A K  y>B IJ J 9~W- !STTBKLhx(//1L L#1c,&78' 5 /NA{ NN1q5+ . / /3w<@L&w/ < 6%%a!eU6]; <+E<@L+E2L*<8==?@@Ms D9rrct|j|}||k(r!|t|j}|S|tj k(}|rt |} t |} nt |} t |} t|| | |j} |t| j}|S)a1make circle Create a circle centered on the origin of plane Args: radius (float): circle radius plane (Plane, optional): base plane. Defaults to Plane.XY. start_angle (float, optional): start of arc angle. Defaults to 360.0. end_angle (float, optional): end of arc angle. Defaults to 360. angular_direction (AngularDirection, optional): arc direction. Defaults to AngularDirection.COUNTER_CLOCKWISE. Returns: Edge: full or partial circle ) rZ to_gp_ax2rrrCOUNTER_CLOCKWISErr2r%) rsrr start_angle end_angleangular_direction circle_gpr[ccwrend circle_geoms r make_circlezEdge.make_circles0EOO-v6 ) #6yAFFHIL$'7'I'IIC ,i( *k*,YsCHNNPK6{CHHJKLr)r(cy)a Create all planar circular arcs of a given radius that are tangent/contacting the two provided objects on the XY plane. Args: tangency_one, tangency_two (tuple[Axis | Edge, PositionConstraint] | Axis | Edge | Vertex | VectorLike): Geometric entities to be contacted/touched by the circle(s) radius (float): arc radius sagitta (LengthConstraint, optional): returned arc selector (i.e. either the short, long or both arcs). Defaults to LengthConstraint.SHORT. Returns: ShapeList[Edge]: tangent arcs Nr)rs tangency_one tangency_tworr(s rmake_constrained_arcszEdge.make_constrained_arcsrcy)a Create all planar circular arcs whose circle is tangent to two objects and whose CENTER lies on a given locus (line/circle/curve) on the XY plane. Args: tangency_one, tangency_two (tuple[Axus | Edge, PositionConstraint] | Axis | Edge | Vertex | VectorLike): Geometric entities to be contacted/touched by the circle(s) center_on (Axis | Edge): center must lie on this object sagitta (LengthConstraint, optional): returned arc selector (i.e. either the short, long or both arcs). Defaults to LengthConstraint.SHORT. Returns: ShapeList[Edge]: tangent arcs Nr)rsrr center_onr(s rrzEdge.make_constrained_arcsrrcy)a< Create planar circular arc(s) on XY tangent to three provided objects. Args: tangency_one, tangency_two, tangency_three (tuple[Axis | Edge, PositionConstraint] | Axis | Edge | Vertex | VectorLike): Geometric entities to be contacted/touched by the circle(s) sagitta (LengthConstraint, optional): returned arc selector (i.e. either the short, long or both arcs). Defaults to LengthConstraint.SHORT. Returns: ShapeList[Edge]: tangent arcs Nr)rsrrtangency_threer(s rrzEdge.make_constrained_arcsrrcy)amake_constrained_arcs Create planar circle(s) on XY whose center is fixed and that are tangent/contacting a single object. Args: tangency_one (tuple[Axis | Edge, PositionConstraint] | Axis | Edge | Vertex | VectorLike): Geometric entity to be contacted/touched by the circle(s) center (VectorLike): center position Returns: ShapeList[Edge]: tangent arcs Nr)rsrrs rrzEdge.make_constrained_arcsrrcy)amake_constrained_arcs Create planar circle(s) on XY that: - are tangent/contacting a single object, and - have a fixed radius, and - have their CENTER constrained to lie on a given locus curve. Args: tangency_one (tuple[Axis | Edge, PositionConstraint] | Axis | Edge | Vertex | VectorLike): Geometric entity to be contacted/touched by the circle(s) radius (float): arc radius center_on (Axis | Edge): center must lie on this object sagitta (LengthConstraint, optional): returned arc selector (i.e. either the short, long or both arcs). Defaults to LengthConstraint.SHORT. Returns: ShapeList[Edge]: tangent arcs Nr)rsrrr s rrzEdge.make_constrained_arcsrrc 4t|dkDr|dnd}t|dkDr|dnd}t|dkDr|dnd}|jd|}|jd|}|jd|}|jdd}|jdd}|jd d} |r+td d j|j |||fD cgc]} | |  } } g} | D]} t | t r| jt| /t | tr| j| Qt | trct | dt r+| jtt| d| dt | dtr| j| t | tr(| jt| | jz | jt| t| d } t| }d|cxkrdkstdtd||dkr td| t | t r t| } |dk(r||| t!| |||dS|dk(r| || t#| | ||dS|dk(r||| t%| ||dS|dk(r||| t'| ||dS|dk(r| | t)| | ||dStdcc} w#t$r}td | |d}~wwxYw)Nrrrrrr rrr Unexpected argument(s): , Invalid tangency: c"t|tSr)rgrxs rrz,Edge.make_constrained_arcs..ps jF6Krrrz Provide 1 to 3 tangency targets.zradius must be > 0.0r')r r(r))r(r))rr))r rr)z4Unsupported or ambiguous combination of constraints.)rpoprjoinrrgrrrrBrrrrrrrrrrr)rsr(argskwargsrrr rrr t tangency_args tangencies tangency_argr tan_counts rrzEdge.make_constrained_arcs:sr#&d)a-tAwT "%d)a-tAwT $'IMatzz.,? zz.,? $4nEHd+Hd+JJ{D1  6tyy7O6PQR R%lNC q}A  CE ) PL,-!!$|"45,-!!,/,.l1ot4%%eDa,q/,R&STl1ot4%%l3,/!!&"69N9N"NO P!!&"67) P2J,KL  O I"">? ?#>? ?  &A+34 4  Z 4%@YI N"!&   N%%#   >fnIDU"JcR R N"!%z&sS S >i38J(yc OPPc 2 P"4\4D EFCO Ps$ K5(K5/K:: LLLcy)aP Create all planar line(s) on the XY plane tangent to two provided curves. Args: tangency_one, tangency_two (tuple[Edge, Tangency] | Axis | Edge): Geometric entities to be contacted/touched by the line(s). Returns: ShapeList[Edge]: tangent lines Nrrsrrs rmake_constrained_lineszEdge.make_constrained_linesrrcy)a Create all planar line(s) on the XY plane tangent to one curve and passing through a fixed point. Args: tangency_one (tuple[Edge, Tangency] | Edge): Geometric entity to be contacted/touched by the line(s). tangency_two (Vector): Fixed point through which the line(s) must pass. Returns: ShapeList[Edge]: tangent lines Nrrs rr zEdge.make_constrained_linesrr)rrzcy)a Create all planar line(s) on the XY plane tangent to one curve with a fixed orientation, defined either by an angle measured from a reference axis or by a direction vector. Args: tangency_one (Edge): edge that line will be tangent to tangency_two (Axis): reference axis from which the angle is measured angle : float, optional Line orientation in degrees (measured CCW from the X-axis). direction : VectorLike, optional Direction vector for the line (only X and Y components are used). Note: one of angle or direction must be provided Returns: ShapeList[Edge]: tangent lines Nr)rsrrrrzs rr zEdge.make_constrained_linesrrct|dkDr|dnd}t|dkDr|dnd}|jd|}|jd|}|jdd}|jdd}| t|nd}|duxs|du}|r+tdd j |j ||fDcgc]}|| } }t| d k7r td g} t | D]\} } t| tr4| dk(r|r| j| n| jt| Jt| tr| j| lt| tr%t| dtr| j|  | jt| t| d } ||t| dtrt| ddts!Jdt| dtsJd| t|}n$|Jt|j |j"}t| dtsJdt%| d| d||St| dttfrJdt| dtrJdt'| d| d|Scc}w#t$r} td | | d} ~ wwxYw)z Create planar line(s) on XY subject to tangency/contact constraints. Supported cases --------------- 1. Tangent to two curves 2. Tangent to one curve and passing through a given point rNrrrrrzrrrz#Provide exactly 2 tangency targets.rc.t|ttfSr)rgrrrs rrz-Edge.make_constrained_lines..sjT6N6Srrz*Internal error - 1st tangency must be Edgez-Internal error - 2nd tangency must be an Axis)r)z7Internal error - 1st tangency can't be an Axis | Vectorz.Internal error - 2nd tangency can't be an Axis)rrrrrrrrgrrrrBrrrr YXrr)rsrrrrrrzis_refrrrrBrrang_rads rr zEdge.make_constrained_liness)#&d)a-tAwT "%d)a-tAwT zz.,? zz.,?  7D)JJ{D1 )2)>F9%D d";it&; 6tyy7O6PQR R%1<$@RqAMR R }  "AB BIK (7 POA|,-6f%%l3%%d<&89,-!!,/,.:l1ot3T!!,/ P!!&"67 P(J,ST    5*Q-/!qM!$d@?@"qM4@?@ !%. ,,, Y[[91 t ?> ?,1 z!}gC  qMD&>  E D E  qM4  < ; <  1 z!}3OOqS* P"4\4D EFCO Ps$?J<J<K K KKct|jj|jj }||kDr5dt z}t |j||j||} nd}t |j||} ||k(r!|t| j} | S|t z|z } |t z|z } |tjk(r| | kr | dtzz } d} | | }}n| | k\r | dtzz} d} | | }}t| ||| j}|t|j} | S)amake ellipse Makes an ellipse centered at the origin of plane. Args: x_radius (float): x radius of the ellipse (along the x-axis of plane) y_radius (float): y radius of the ellipse (along the y-axis of plane) plane (Plane, optional): base plane. Defaults to Plane.XY. start_angle (float, optional): Defaults to 360.0. end_angle (float, optional): Defaults to 360.0. angular_direction (AngularDirection, optional): arc direction. Defaults to AngularDirection.COUNTER_CLOCKWISE. Returns: Edge: full or partial ellipse V@rnrTF)rWrr.rrArr]rRotatedrrrrrr3r%)rsx_radiusy_radiusrrrrax1correction_angle ellipse_gpellipsera2sensealpha1alpha2 ellipse_geoms r make_ellipsezEdge.make_ellipse>s]4U\\((*EKK,>,>,@A h  $g~ !%//"3XxHPP%J # !%//"3XxHJ ) #1*=BBDEG2-'+;;Bg%)99B $4$F$FF8!b&LB!#R8!b&LB!#R.FFEeg 1,?DDFGGrrnr*ct|j|}t||tz|tz|tj k(j }|t|j}|S)aqmake parabola Makes an parabola centered at the origin of plane. Args: focal_length (float): focal length the parabola (distance from the vertex to focus along the x-axis of plane) plane (Plane, optional): base plane. Defaults to Plane.XY. start_angle (float, optional): Defaults to 0.0. end_angle (float, optional): Defaults to 90.0. angular_direction (AngularDirection, optional): arc direction. Defaults to AngularDirection.COUNTER_CLOCKWISE. Returns: Edge: full or partial parabola ) r_rr5rrrr%rr) rs focal_lengthrrrr parabola_gp parabola_geomparabolas r make_parabolazEdge.make_parabolaso2u0,? ,  ' !   !1!C!C C  %'  .}=BBDErc8t|jj|jj }||kDr5dt z}t |j||j||} nd}t |j||} ||k(r!|t| j} | St| |t z|z |t z|z |tjk(j} |t| j} | S)amake hyperbola Makes a hyperbola centered at the origin of plane. Args: x_radius (float): x radius of the hyperbola (along the x-axis of plane) y_radius (float): y radius of the hyperbola (along the y-axis of plane) plane (Plane, optional): base plane. Defaults to Plane.XY. start_angle (float, optional): Defaults to 360.0. end_angle (float, optional): Defaults to 360.0. angular_direction (AngularDirection, optional): arc direction. Defaults to AngularDirection.COUNTER_CLOCKWISE. Returns: Edge: full or partial hyperbola r*rn)rWrr.rrArr^rr+rrr4rrr%) rsr,r-rrrrr.r/ hyperbola_gp hyperbolahyperbola_geoms rmake_hyperbolazEdge.make_hyperbolas4U\\((*EKK,>,>,@A h  $g~ "5??#4hIQQ%L # "5??#4hIL ) #3LAFFHII3g%(88G#&66!%5%G%GG  eg  3NCHHJKIrc|dk(rEttt|jt|j |}nLt tt|jt|j |t z|}|rdnd} t| dztz|j} || jz tt|z } ttddt| j| j} t!| d| d} t#| |}|j%}t'j(|dd ||S) amake_helix Make a helix with a given pitch, height and radius. By default a cylindrical surface is used to create the helix. If the :angle: is set (the apex given in degree) a conical surface is used instead. Args: pitch (float): distance per revolution along normal height (float): total height radius (float): center (VectorLike, optional): Defaults to (0, 0, 0). normal (VectorLike, optional): Defaults to (0, 0, 1). angle (float, optional): conical angle. Defaults to 0.0. lefthand (bool, optional): Defaults to False. Returns: Wire: helix rnrrrrT)theAdjustPeriodic& .>i) MaxSegment)r<rYrr.rAr;rrrr%r rrBrar\r&rCrrr(r)rspitchheightrrrHrlefthand geom_surf line_signline_dirline_len helix_line helix_curve edge_builderrs r make_helixzEdge.make_helixs+> C<&=vf~,,.v0E0E0GH&'I,vf~,,.v0E0E0GHI#B )a-",e4??AXZZ'3wu~+>>!!Q(**hjj1QR ) 8t /{IF "'')   TdC;rc|tt|jt|jjS)aCreate a line between two points Args: point1: VectorLike: that represents the first point point2: VectorLike: that represents the second point Returns: A linear edge between the two provided points )rrr.r)rspoint1point2s rrzEdge.make_line s? #v%%')>)>)@ df  rc $t|jt|}dDcgc]L}tj|j ||j |rd|z n|j |N}}tj|Scc}w)amake line between edges Create a new linear Edge between the two provided Edges. If the Edges are parallel but in the opposite directions one Edge is flipped such that the mid way Edge isn't truncated. Args: first (Edge): first reference Edge second (Edge): second reference Edge middle (float, optional): factional distance between Edges. Defaults to 0.5. Returns: Edge: linear Edge between two Edges )rrr)r is_oppositerrr)rsrhsecondrfliprBpntss r make_mid_wayzEdge.make_mid_way. s E{&&tF|4    NN!!!$f&8&8$QA&N k&! "  ~~t$$  sAB c|Dcgc] }t|}}|rtd|D} tdt|} t |D](\} }| j | dz|j *|t| ||} nt|t||zk7r#tdt|dt|tdt|} t |D]\}}| j |dz|t| | ||} |rt dk(r.t s#@!F1I#@rrNzuThere must be one parameter for each interpolation point (plus one if periodic), or none specified. Parameter count: z, point count: rrzgThere must be one tangent for each interpolation point, or just two end point tangents. Tangent count: zB-spline interpolation failed)rrBrnrrrr.rOrrrLoadrrmrqrrrrr)rsrrperiodic parametersr tolr point_vectorstangent_vectorsrYrBspline_builderparameters_arrayp_indexp_valuetangents_arraytangent_enabled_arrayt_indext_value tangent_vec spline_geoms r make_splinezEdge.make_splineG sV5;;5; ; ##@x#@@O"1c-&89!-0 1HAu MM!a% 0 1  0xEN:3}#5#@A S:'s=7I6JL 5QJH $-j$9 @  ))'A+w? @17GSVWN ?#q(S-?1-D###A&..0B0J0JE'3}+==$J/0M@R?SU"4As?7K!L(@s?+)%)2/(BN$GW)227Q;t@ST-4-@'fhK"++GaK9L9LMN ##N4I5Q $$&<= =$**, *;7<<>??m? %m1= 8LE5    7 8+1c,.?@ $\; 5KE4  d 4 5 7q#n:MN#,^1#E ? E< ) )% > ?)0(;tG} 0C 4EFM!*??YDsG,ctdt|}t|D]1\}}|j|dzt |j 3|rt |g|||d} nt ||||} | js td| j} |t| jS)amake_spline_approx Approximate a spline through the provided points. Args: points (list[Vector]): tol (float, optional): tolerance of the algorithm. Defaults to 1e-3. 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 6. Raises: ValueError: B-spline approximation failed Returns: Edge: spline r)DegMaxTol3D)DegMinr~rzB-spline approximation failed) rnrrrrr.rPrrrrr) rsrr` smoothingmin_degmax_degrYrBrrcrls rmake_spline_approxzEdge.make_spline_approx s8#1c&k2!&) 9HAu MM!a%!5!5!7 8 9 4 )0N5WWCN$$&<= =$**, *;7<<>??rctt|jt|jt|jj }|t |j S)a4Tangent Arc Makes a tangent arc from point start, in the direction of tangent and ends at end. Args: start (VectorLike): start point tangent (VectorLike): start tangent end (VectorLike): end point Returns: Edge: circular arc )r2rr.rr%rr)rsrrrrs rmake_tangent_arczEdge.make_tangent_arc) s_ ) 5M "F7O$;$;VC[=O=O=Q %' *;7<<>??rctt|jt|jt|jj}|t |j S)a6Three Point Arc Makes a three point arc through the provided points Args: point1 (VectorLike): start point point2 (VectorLike): middle point point3 (VectorLike): end point Returns: Edge: a circular arc through the three points )r2rr.r%rr)rsrSrTpoint3rs rmake_three_point_arczEdge.make_three_point_arc? sb ) 6N ! ! #VF^%:%:%S>S>U %' *;7<<>??rcZ|jst|gj}|S|}|S)z Close an Edge)rSrclose)rNr[s rrz Edge.closeW s2~~<--/L Lrc|dkr tdt|Dcgc]}||||z z|dz z z}}|j|}|r|D]}tddd|_|Scc}w)a6Distribute Locations Distribute locations along edge or wire. Args: self: Wire:Edge: count(int): Number of locations to generate start(float): position along Edge|Wire to start. Defaults to 0.0. stop(float): position along Edge|Wire to end. Defaults to 1.0. positions_only(bool): only generate position not orientation. Defaults to False. Returns: list[Location]: locations distributed along Edge|Wire Raises: ValueError: count must be two or greater rzcount must be two or greaterrr)rr9rPr orientation) rNrrstoppositions_onlyrBt_valuesrPrLs rdistribute_locationszEdge.distribute_locations` s2 19;< >X-- -DE Eq)}}Q' y00wN !((*5:7^D$$QU+DD)1!!1%1?O;O7P '')9(9:AACHJ&E'',<(<=DDFHXJ&EBF%GQdooa&8%G%G5:!;&)!;!;(((A $$000&&  ! !=#9#9!#T>TUV>W )22:|L  %HI I34FGLLNO ///3E&H!;s.H .H Hc |j tdt|trt t |j }|jjt|j}tj||jd|jzzz||j|jzz}|j|}| tdt|j j#}t%j&|}t%j(|j |t+|j-d|j-d}|c|j Wt%j(|j |t+|j-d|j-d} t/|| |} n t/||} t1| j3D cgc]N} t | j5| dzj7| j5| dzj9P} } | D cgc]} |j;| } } g}| D]p} |B|j=|t>krS|j=|t>kr;|jA|n)|j=|t>kr|jA|rtC|Scc} wcc} w#t$rYwxYw)afind_intersection_points Determine the points where a 2D edge crosses itself or another 2D edge Args: other (Axis | Edge): curve to compare with tolerance (float, optional): the precision of computing the intersection points. Defaults to TOLERANCE. Raises: ValueError: empty edge Returns: ShapeList[Vector]: list of intersection points z&Can't find intersections of empty edgerz%All objects must be on the same planerr)"rQrrgrrrrraddrrrrzr-rrrrr Surface_sCurveOnPlane_srwr;rDr9rPointr&r%from_local_coordsrrrr)rNrrposself_bbox_w_edger pln_shape edge_surface self_2d_curve edge_2d_curve intersectorrBcrossesr valid_crossesrJs rfind_intersection_pointszEdge.find_intersection_points s$ == EF F eT "/C#00266vc{7O7O7QR NNeoo.>.G.G)GHHeoo(8(A(AAAE !!%( =DE E+EMM:??A  **95 &/&>&> LL    MM!  MM!  '   !:*3*B*B !q!q! +M4}iK4M9MK;//12  ;$$QU+--/1B1B1q51I1K1K1M N  8??!5**1-??  C $((-:!--c2i?%,,S1'', 9%,,S1 ''1 @   s 0AK% K*+A-K// K;:K;cd|dz}|jtjk(r|jd|k(rdg}|Sg}|St |j }g}d}d}t d|z D]^}|j|dz |dzz}|(t||z dkDrtd||z }|d|zz }|}|j|dz |f`tj|} | j} dt| jjdz z} dt!| j"jdz z} g} t | | d zdD]D}tj%d||zdfd||zdf}| j'| j)|F| Dcgc]}|j*}}|Scc}w) zfind_tangent Find the parameter values of self where the tangent is equal to angle. Args: angle (float): target angle in degrees Returns: list[float]: u values between 0.0 and 1.0 rrNrneri,rr)rrrrr}rSr9rr rrrmrr rr%r rrrrr&)rNrrr^tan_pntsprevious_tangentdiscontinuitiesrBr tan_curvetan_curve_bbox min_range max_rangeintercept_pntsrrs r find_tangentzEdge.find_tangent s  >>X]] *$$Q'503NKJE4>>*H)+H# "O3>* 4//C8?S;PP$0,w67#=&.s4Dw4N&OOs_44G#* S' 23 4((2I'335Nu^%7%7%9%9C%?@AItN$6$6$8$83$>?@I,.N9i!mS9 P~~q%!)Q&7#uqy!9LM%%i&H&H&NO P&444H45sF-cZ|j tdt|jS)z$Return the Geom Curve from this Edgez!Can't find adaptor for empty edge)rQrrrrMs rrfzEdge.geom_adaptorC s' == @A A ..rc(t|tsy|j|jk7ry|dz|dzk7s |dz|dzk7ry|j}|j}|jxtj k(ryxtj k(r|j|j}}t|j|jz |kxrt|jt|jk(xrOt|jjt|jjk(Sxtjk(r|j|j} }t|j!| j!z |kxrt|j#| j#z |kxrt|jt| jk(xrOt|jjt| jjk(Sxtj$k(r|j'|j'} } t| j!| j!z |kxrt| j#| j#z |kxrt| jt| jk(xrOt| jjt| jjk(Sxtj(k(r|j+|j+} } t| j-| j-z |kxrt| jt| jk(xrOt| jjt| jjk(Sxtj.k(r|j1|j1}}|j3|j3k7s!|j5|j5k7ryt7d|j5dzD]{}t|j9|t|j9|k7ry|j;sKt|j=||j=|z |k\s{yyxtj>k(r|jA|jA}}|j3|j3k7ry|jC|jCk7ry|j5|j5k7s!|jE|jEk7ryt7d|j5dzD]{}t|j9|t|j9|k7ry|j;sKt|j=||j=|z |k\s{yt7d|jEdzD]X}t|jG||jG|z |k\ry|jI||jI|k7sXyytjJk(r|jM|jM}}t|jO|jOz |k\ryt|jt|jk7ryttQ|jSj}ttQ|jSj}|jU||S t7d|dzD]}||dzz }||z||zk7syy)aKCompare two edges for geometric equality within tolerance. This compares the geometric properties of two edges, not their topological identity. Two independently created edges with the same geometry will return True. Args: other: Edge to compare with tol: Tolerance for numeric comparisons. Defaults to 1e-6. num_interpolation_points: Number of points to sample for unknown curve types. Defaults to 5. Returns: bool: True if edges are geometrically equal within tolerance FrrT)+rgrrrfrrrSrjrrkrrrrTrUrV MajorRadius MinorRadius HYPERBOLA HyperbolaPARABOLAParabolaFocalBEZIERBezierDegreerr9r IsRationalWeightrBSpline IsPeriodicNbKnotsKnot MultiplicityOFFSET OffsetCurveOffsetr BasisCurve geom_equal)rNrr`num_interpolation_pointsga1ga2c1c2e1e2h1h2p1p2b1b2rBs1s2oc1oc2basis1basis2rs rrzEdge.geom_equalI sX,%& >>U__ , 1H%!) $uqy(A!  "nn szz|B biik12S8Wr{{}- 1FFWrwwy2245 @S@S@U9VV "!! B(2>>+;;>+;;?%A59:Aqeai0$%rcd|j}tj|}|tjk(r|j sd|z }|}n*|j s|j |z }||j z }t|||z|jj}|||j fS)aZ Map a position on this edge to its underlying OCCT parameter. This returns the OCCT `BRepAdaptor_CompCurve` for the edge together with the corresponding (non-normalized) curve parameter at the given position. The interpretation of `position` depends on `position_mode`: - ``PositionMode.PARAMETER``: `position` is a normalized curve parameter in [0, 1]. - ``PositionMode.DISTANCE``: `position` is an arc length distance along the edge. Edge orientation (`is_forward`) is taken into account so that positions are measured consistently along the geometric curve. Args: position (float): Position along the edge, either a normalized parameter (0-1) or a distance, depending on `position_mode`. position_mode (PositionMode, optional): How to interpret `position`. Defaults to ``PositionMode.PARAMETER``. Returns: tuple[BRepAdaptor_CompCurve, float, bool]: The curve adaptor for this edge, the corresponding OCCT curve parameter and is_forward. r) rfr6Length_srr9rVrr$r)rNrrrrrrs rrzEdge._occt_param_at s4&&( %..z: L22 2??x<E??;;1t{{*E)  (A(A(C )+ :t66rc|j}tj|}t|||z|jj S)u Map a normalized arc-length position to the underlying OCCT parameter. Returns the native OCCT curve parameter corresponding to the given normalized `position` (0.0 → start, 1.0 → end). For closed/periodic edges, OCCT may return a value **outside** the edge's nominal parameter range `[param_min, param_max]` (e.g., by adding/subtracting multiples of the period). If you require a value folded into the edge's range, apply a modulo with the parameter span. Args: position (float): Normalized arc-length position along the shape, where `0.0` is the start and `1.0` is the end. Values outside `[0.0, 1.0]` are not validated and yield OCCT-dependent results. Returns: float: OCCT parameter (for edges) **or** composite “edgeIndex + fraction” parameter (for wires), as described above. )rfr6rr$r)rNrr&rs rr;z Edge.param_at sK,!!#%..u5# 6H$e&:&:&< )+ rc j tdt|tjj \}}||z }t jfd}t|z jtkr||j ptj|j j }tj }tj|||}|tj|z}|Sj} t| dtstdd| dtj j t#t#} t%j'| } | j)}tj }|j+r|||z |j-zz}tj|||}|tj|z}j/|z jtkr|Sd } t1| D]} d | z}d |z }t1|D]}||z|d z|z}}t3fd ||fddtd z i}|j4|j6tzz|j6tz zz jksst9t#|j6t:ccSt=d)u! Return the normalized parameter (∈ [0.0, 1.0]) of the location on this edge closest to `point`. This method always returns a **normalized** parameter across the edge's full OCCT parameter range, even though the underlying OCP/OCCT queries work in native (non-normalized) parameters. It is robust to several OCCT quirks: 1) Vertex snap (fast path) If `point` coincides (within tolerance) with one of the edge's vertices, that vertex's OCCT parameter is used and normalized to [0, 1]. Note: for a closed edge, a vertex may represent both start and end; the mapping is therefore ambiguous and either end may be chosen. 2) Projection via GeomAPI_ProjectPointOnCurve The OCCT projector's `LowerDistanceParameter()` can legitimately return a value **outside** the edge's [param_min, param_max] (e.g., periodic curves or implementation behavior). The result is wrapped back into range using a modulo by the parameter span and then normalized to [0, 1]. The projected answer is accepted only if re-evaluating the 3D point at that normalized parameter is within tolerance of the input `point`. 3) Fallback numeric search (robust path) If the projector fails the validation, a bounded 1D search is performed over [0, 1] using progressive subdivision and local minimization of the 3D distance ‖edge(u) - point‖. The first minimum found under geometric resolution is returned. Args: point (VectorLike): A point expected to lie on this edge (within tolerance). Raises: ValueError: If `point` is not on the edge within tolerance. ValueError: Can't find param on empty edge RuntimeError: If no parameter can be found (e.g., extremely pathological curves or numerical failure). Returns: float: Normalized parameter in [0.0, 1.0] corresponding to the point's closest location on the edge. zCan't find param on empty edgec4t|z jSr)rr)r5rJs rrz%Edge.param_at_point..F sVAY_. st//2S8@@rboundedxatol)boundsmethodoptionsz-Unable to find parameter, Edge is too complex)rQrrrRange_srrrrr Parameter_srr6rrrrr~rQr.LowerDistanceParameterrPeriodrr9rfunrroundrr)rNr param_min param_max param_rangenearest_vertexrE curve_adaptorr separationr&r max_divisionsdivision intervalssteprBlohirrJs` @rrzEdge.param_at_point sR == => >Um(00> 9)+ T]]_2TU > "S ( &I "0"8"8"D)).*@*@$,,OE-dll;M*33M9eTG +44]C CGN%%c* Q :wse5 JGH H!!$,,A/ eD 002*$,,7  # # %%)"3}7K7K7M!MNE&// y%P'00??   W % + 3 3i ?N" m, >H8 I?D9% >TAET>B(@8$$i!m4 JJ9 459@T8UUf !vxx*==# >  >.JKKrcZt|j|||}|jS)aProject Edge Project an Edge onto a Shape generating new wires on the surfaces of the object one and only one of `direction` or `center` must be provided. Note that one or more wires may be generated depending on the topology of the target object and location/direction of projection. To avoid flipping the normal of a face built with the projected wire the orientation of the output wires are forced to be the same as self. Args: target_object: Object to project onto direction: Parallel projection direction. Defaults to None. center: Conical center of projection. Defaults to None. target_object: Shape: direction: VectorLike: (Default value = None) center: VectorLike: (Default value = None) Returns: : Projected Edge(s) Raises: ValueError: Only one of direction or center must be provided )rproject_to_shaper)rN target_objectrzrprojected_wiress rr zEdge.project_to_shape s,>t*55mYPVW$$&&rc,|j tdt|jtsJt j |}|r|j d}|j d}tj|j||}|j|}|j|}t|j||j}||_ |Stj|jj|_ |S)areversed Return a copy of self with the opposite orientation. Args: reconstruct (bool, optional): rebuild edge instead of setting OCCT flag. Defaults to False. Returns: Edge: reversed zAn empty edge can't be reversedrr)rQrrgrzr/r0r;rrReversedParameterrReversedrrrx)rN reconstruct reversed_edgerhlastr&rs rreversedz Edge.reversed s == >? ?$--555 d+ ==+E--*D%%dmmUDAE++E2E**40D1%..2BD%PUUWK$/M !%+KK 0E0E0G$HM !rzYto_axis is deprecated and will be removed in a future version. Use 'Axis(Edge)' instead.c|jtjk7rtd|jt |j d|j d|j dz S)z"Translate a linear Edge to an Axisz+to_axis is only valid for linear Edges not rr)rrrrrrrMs rto_axisz Edge.to_axis sf >>X]] *=dnn=MN D$$Q')9)9!)$##D%9!!$U3&&w/ +/*=*=g*F'*a'+':':5'A$1 #!!LL$335$224  X./  df  #..q1K?GG)S OOG $ ( ()@)@)C Dq9} T  . $$$66rc|j tdtj||d}t j |}|j Jtj|j |jd|jd}t|}|j|}t|||}|j} t||| } t| j} t| S)altrim_to_length Create a new edge starting at the given normalized parameter of a given length. Args: start (float | VectorLike): 0.0 <= start < 1.0 or point on edge length (float): target length Raise: ValueError: can't trim empty edge Returns: Edge: trimmed edge zCan't trim empty edgerrr)rQrrKrr/r0rrrr;rNr6rr@rr) rNrrr self_copy new_curve adaptor_curverabscissa_pointr! trimmed_curvenew_edges rrzEdge.trim_to_length s == 45 5##D%9MM$'   ,,,%%   t}}Q/q1A *)4 ]]7+ -mVZP"++-*)ZJ *=9>>@H~rc (t|tr t|n|}|j|}|sy|j }t |Dcgc]}|j d|c}}|jtjd}|Scc}w)zQReturn the shortest Edge of self trimmed by other or None if they don't intersectNr) rgrrrrrrmsort_byrr)rNr other_obj intersectionsintersection_pntsrJ self_trimsshortest_trimmed_selfs r trim_to_otherzEdge.trim_to_otherD s &0x%@F5Me y1 *224=NOc !S 1OP !+ 2 24;; ? B$$ Ps Bc^|jtjk(xr|jdkDS)z5Check if edge is infinite (LINE with length > 1e100).g}Ô%IT)rrrrrMs rr+zEdge.is_infinite] s%~~.F4;;3FFrc|js|S|j}|j|jz j }t j |||zz |||zzS)aTrim an infinite line edge to a finite length. OCCT's boolean operations struggle with very long edges (length > 1e100). This method trims such edges to a reasonable size centered at edge.center(). For non-infinite edges, returns self unchanged. Args: half_length: Half-length of the resulting edge Returns: Trimmed edge if infinite, otherwise self )r+rr(rrrr)rN half_lengthrrzs rr,zEdge.trim_infiniteb skK^^%(8(8(::FFH ~~ Y, , Y, ,  r)NNN)rtz TopoDS_Edge | Axis | None | Nonerrr Color | NonerCompound | Noner)rtrrzrrr)rrrlist[float] | Nonerr) rr~rrrr~rr~rrrr) r@tuple[Axis | Edge, Tangency] | Axis | Edge | Vertex | VectorLikerr;rr~r(rrr) rr;rr;r z Axis | Edger(rrr) rr;rr;r r;r(rrr)rr;rrrr)rr;rr~r rrr)r(rrr)r#tuple[Edge, Tangency] | Axis | Edgerr<rr)rtuple[Edge, Tangency] | Edgerrrr) rr=rrrrrzrrrrr)r,r~r-r~rrrr~rr~rrrr) r9r~rrrr~rr~rrrr))rrrrrnF)rGr~rHr~rr~rrrHrrr~rIrrr)rSrrTrrr)r)rhrrWrrr~rr)NFNTr)rlist[VectorLike]rzlist[VectorLike] | Noner^rr_r:r rr`r~rr)NF) roIterable[VectorLike]rprrqr}rrr^rrr)rNr) rr?r`r~rz!tuple[float, float, float] | Nonerr}rr}rr)rrrrrrrr)rSrrTrrrrr)rr)rnrF) rNz Wire | Edgerr}rr~rr~rrrr)g?)rrrr?rr~)rzAxis | Edge | Nonerr~rzShapeList[Vector])rr~rz list[float])rrr)rrr`r~rr}rrrr~rrrz%tuple[BRepAdaptor_Curve, float, bool]rr~rr~rrrr~NN)r rrzrrrrrF)rrrr)rrrr)rrrrrr)rrrr~rr)rNrrz,Shape | Axis | Location | Plane | VectorLiker Edge | Noner)r6r~rr)8rrrrrrrrcrr{rrrrrrrrSHORTrr r7r=rBrQrrZrmr|rrrrrrrrrrfrrr9rr;rr rrrrrmrr3r+r, __classcell__rs@rrrs2  E 15""&  -      B  "PP&CG.A#.A.@.A .A.A`xx".>.P.P %%% %  % , % %%N#==  V W        0#==  V W        2#== V W M      2 V      * V        8 #==hQhQ  hQhQT 9 :     " 2      ( #'+  2    %     4PPPPd xx" .>.P.P@@@ @  @  @,@ @@Dxx .>.P.P """ "  " , " ""H xx" .>.P.P222 2  2  2,2 22h '&> > >  >  >  > > >  > > @  "%%0-1)-`@ `@*`@ `@ ' `@  `@`@ `@`@D +/ L@,L@L@ L@ ( L@  L@ L@L@\7; -@ -@-@5 -@  -@  -@ -@-@^@@)3@:D@ @@*@@)3@=G@ @@.$ #### #  #  #R#& ,0,0#,0 ,0^+/9R('R(;@R( R(h:: :x/() }}}#& }  }@>J=S=S)7)7.:)7 .)7V:ALL(,$( ' '% '" '  'D> %T T % .7`*X%%;% %2GG rc<eZdZdZdZe d% d&dZe d% d'dZe d% d(dZe d% d)dZe d* d+dZfdZed,d-d Ze d. d/d Z ed0d Z ee jfd1d Z ed2d3d Zee jddej df d4dZed5d6dZee jf d7dZe d8dZ d9 d:dZd;dZddZd?dZd.closest_to_end..?s:c!AMM!$44<<!AMM!$44<<rrr)rr)currentunplaced_edges sorted_edgesras @rclosest_to_endz'Wire._make_wire..closest_to_end9s1"..q1L!L ? "rrz8Wire is non manifold (e.g. branching, self intersecting)r) stacklevelz Wire is emptyzEdges are disconnected)rbrrcz list[Edge]rr)rrrrrr!rrr=r>r?rErrorr"warningswarnrrrr) rsrrUre placed_edgesrc next_edgenext_edge_indexrFrErs rr[zWire._make_wire$sV* #U  !IIaL>L"N *4 +=~N "0"6"6y"A##N$6$6$GH! !E.0 -/ 4D||'%%dll3 4 (""$!!#'EE N   "" ##%)AA"?33##%)HH !9::  ""rct}t}|Dcgc]}|jD]}|c}}D]*}|j|j|j,t j ||d|t }t|jD]E}|jtttt|j|dzG|Scc}}w)a combine Combine a list of wires and edges into a list of Wires. Args: wires (Iterable[Wire | Edge]): unsorted tol (float, optional): tolerance. Defaults to 1e-9. Returns: ShapeList[Wire]: Wires Fr)rrrr=rhConnectEdgesToWires_srr9Lengthrrrr~rr%) rsrzr`edges_in wires_outr{rrrBs rcombinez Wire.combinegs -.-/ %91qwwy9!Q9Q9 .D||' - . !66xeYW y'')* UA LLeK)//!a%:P1QRS T U :sC.ctd)z$extrude - invalid operation for Wirez#Wires can't be created by extrusionrrys rr{z Wire.extrudes>??rcHtj||}t|gS)zmake_circle Makes a circle centered at the origin of plane Args: radius (float): circle radius plane (Plane): base plane. Defaults to Plane.XY Returns: Wire: a circle )r)rrr)rsrr circle_edges rrzWire.make_circles&&&vU&; [M""rc t|}td|z }i}g}t|D]V\}}t|D]C}||dz z } |j t |j | dd|| f|||z|z<EXt|} g} i} | jD]+} || dd}|| dd}||k7r||| vr | dg| |<n| |j | d|| vr | dg| |<n| |j | d| j ||| dd| df||| dd| dfft| d| dz dk7st| j}t| j}|| vr||g| |<n| |j||g| j |||d|f|||d|ff.i}| jD]d\}}t|}g}tdt!|dz dD]1}||||dzk7s|j t |||dz3|||<f| Dcgc]<}t"j%||dd|ddz||dd|ddz>}}|jDcgc]3\}}|D])}||j'||dd||dd+5}}}}t)||zd}|Scc}wcc}}}w)amake_convex_hull Create a wire of minimum length enclosing all of the provided edges. Note that edges can't overlap each other. Args: edges (Iterable[Edge]): edges defining the convex hull tolerance (float): allowable error as a fraction of each edge length. Defaults to 1e-3. Raises: ValueError: edges overlap Returns: Wire: convex hull perimeter rrNrT)rU)rr}rr9rrBrr simplicesrrtolistrritemsrrrrrmr)rsrrfragments_per_edge points_lookupr edge_indexrrBrE convex_hullconnecting_edge_data trim_pointssimplicerr start_pntend_pnt trim_datastart_end_pntss_pointsf_pointsrconnecting_edges trim_pairs trim_pair trimmed_edges hull_wires rmake_convex_hullzWire.make_convex_hullsTU  Y/ !*% 0 Y J-. Y/!34 eD$4$4U$;? @%-Ij !  --   NNd1gaj!DGAJ.d1gaj0ADGAJ0N   +4//*;   ' J'   *  " "il+A. il0KA0N     )M9TJ   s AK. 8K3rTctj||||||}||k7rC|rAtj|j|j } t || g} | St |g} | S)amake ellipse Makes an ellipse centered at the origin of plane. Args: x_radius (float): x radius of the ellipse (along the x-axis of plane) y_radius (float): y radius of the ellipse (along the y-axis of plane) plane (Plane, optional): base plane. Defaults to Plane.XY. start_angle (float, optional): _description_. Defaults to 360.0. end_angle (float, optional): _description_. Defaults to 360.0. angular_direction (AngularDirection, optional): arc direction. Defaults to AngularDirection.COUNTER_CLOCKWISE. closed (bool, optional): close the arc. Defaults to True. Returns: Wire: an ellipse )rr7rr(rr) rsr,r-rrrrrt ellipse_edgerrs rr7zWire.make_ellipsesy8(( h{I?P  ) #>>,"8"8":Lr.r)rsrrr5vectorsrFrs r make_polygonzWire.make_polygon9s'//6!9// AJ $ , ,y 8U NN71: &13  .F   V]]_ - .<$$&''0sBc|dz |dz f|dz |dz f|dz |dz f|dz |dz fg}|Dcgc]}|j|}}tj|dScc}w)aSMake Rectangle Make a Rectangle centered on center with the given normal Args: width (float): width (local x) height (float): height (local y) plane (Plane, optional): plane containing rectangle. Defaults to Plane.XY. Returns: Wire: The centered rectangle rT)r)rrr)rswidthrHr corners_localr} corners_worlds r make_rectzWire.make_rectPs(QY # QY $ RZ" % RZ! $  >KK003K K  d ;;LsAcN|r"|\}}||k(r||fS||k(r||fStd|S)z9Order the edges of a chamfer relative to a reference Edgezreference edge not in edgesrt)reference_edgerredge2s rorder_chamfer_edgeszWire.order_chamfer_edgesmsE  LE5&e|#&e|#:; ; rc |j td|}t|j}t |}t }t j|tjtj||D]} | s|j| j} tttt| j!tttt| j#f} t$j'|| \} } | j| j|j)t+j| jt+j| j|||j-|j/}t1|}|j3t|j/}t5|t6s t9dt%t;j<|S)achamfer_2d Apply 2D chamfer to a wire 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 Returns: Wire: chamfered wire zCan't chamfer empty wirez.An internal error occured creating the chamfer)rQrrrr&rruMapShapesAndAncestors_srrqr FindFromKeyrrrzrFirstLastrr AddChamferrxr?rrirrgr{rr. OuterWire_s)rNrC distance2rrrunchamfered_facechamfer_buildervertex_edge_mapr5 edge_listrrrchamfered_face shape_fixs r chamfer_2dzWire.chamfer_2d}s* == 78 88 E45EFCE&& b..  A'33AII>I U;1B(CDEU;1A(BCDE  33NEJLE5}}(U]]-F**KK .KK .  * (..0">2 !)//"34.+6OP PI)).9::rc|jsNtj|j|j }t j ||fd}|S|}|S)z Close a Wirer)rSrrr(rrrr)rNrr[s rrz Wire.closesU~~>>$.."2D4D4D4FGD<<t 5a8L Lrc8t|j}t}|jrjt |j }|j |n |j |_|j||j|jrj|S)z#edges - all the edges in this Shape) r/rrrrr topo_parentrr)rNr rrks rrz Wire.edgess*$,,7%.[ mmoX--/0I((0d6F6F  !   Y ' MMOmmorc|j td|j}|td||j|}|D]x}|j|}|j j |d}t |t |z jtkDrtd|t|||}z|j|}|j} t|jj} | j| z} | jj} |jj!t#} t%j&t)| | dj+}t'|}t|jj|_ |j,|j,k7r|jj/|S)a+fillet_2d Apply 2D fillet to a wire Args: radius (float): vertices (Iterable[Vertex]): vertices to fillet Raises: RuntimeError: Internal error ValueError: empty wire Returns: Wire: filleted wire zCan't fillet an empty wirezWire is not planar rz&Could not find fillet vertex on wire: T)rQrrto_local_coordsrr-rrrrIrlocationrinverserTransformationLocatedrwrxrr#rrVr;)rNrrwire_pln filleted_wirer vertex_localcurrent_vertexglobalized_filleted_wireold_locnew_locgeometry_adjusttrsf base_wire transformed final_wires r fillet_2dzWire.fillet_2ds == 9: :$$&  24&9: :!006  WF#33F;L*335FF|TUVWN~& )==EE Q #I&!RSS/ ~vVM  W*2)C)CM)R +334==1134!//+g5&&557,44<<_=NO kk $Yd ; A A C +& &t}}'='='?@  ??j33 3    & & (rc >|j tdt|j}|j ||j d|j |jtttt|jS)zfix_degenerate_edges Fix a Wire that contains degenerate (very small) edges Args: precision (float): minimum value edge length Returns: Wire: fixed wire zCan't fix an empty edger) rQrrjr SetPrecisionSetMaxTolerance FixSmallEdges FixWireGapsrrr~rr)rN precisionsf_ws rfix_degenerate_edgeszWire.fix_degenerate_edgessy == 67 7!$,,/ )$ T"  E+x '=>??rcZ|j tdt|jS)z(Return the Geom Comp Curve for this Wirez$Can't get geom adaptor of empty wire)rQrrrrMs rrfzWire.geom_adaptor%s' == CD D$T\\22rc|jj|}t|dg}|ddD]S}|d}t|dz|dzz tkr|j |5|j |j U|S)zBReturn the edges in self ordered by wire direction and orientationrrNr)rr-rrrrr)rNrd ordered_edgesr last_edges r order_edgeszWire.order_edges,szz|++D1 !<?"34  $ 6D%b)I9q=4!8+,y8$$T*$$T]]_5  6rct|tsy|j}|j}t|t|k7ryt fdt ||DS)aYCompare two wires for geometric equality within tolerance. This compares the geometric properties of two wires by comparing their constituent edges pairwise. Two independently created wires with the same geometry will return True. Args: other: Wire to compare with tol: Tolerance for numeric comparisons. Defaults to 1e-6. num_interpolation_points: Number of points to sample for unknown curve types. Defaults to 5. Returns: bool: True if wires are geometrically equal within tolerance Fc3JK|]\}}|j|ywr)r)rrrrr`s rrz"Wire.geom_equal..Xs+ B MM"c#; < s #)rgrrrrr)rNrr`redges1edges2s `` rrzWire.geom_equal;sd*%&!!#""$ v;#f+ % ff-   rcx|j}|j|}t|j|}|j r|j dk(r t dtd}d}d}td|j dzD]Y}|j|} | |ks| }|j|j}|j|j}[|-ttt||z j t"kDr t dtt|S)u Return the OCCT comp-curve parameter corresponding to the given wire position. This is *not* the edge composite parameter; it is the parameter of the wire’s BRepAdaptor_CompCurve. rzFailed to find point on curverNr)rfrr1r.rNbExtrr~r9SquareDistancerr%rrrr`rr) rNrr& target_pntextremar closest_pnt closest_paramrBrs rr;z Wire.param_at]s !!#%%h/  1 1 3U;~~7==?a#7>? ?<  q'--/A-. =A))!,Dh%mmA.446 ' a 0 : : <  =  uV[12Z?GG)S>? ?UM**rc|j tdt|}t|}|jJ|j |}t |dtstd|d|dt|j|j}|j|jr|jdk(r td|jd}|tjk(r=tt t#|j%d}|j'dd}n|tj(k(rtt*t#|j%d} t-} t/j0|jt2j4t2j6| tt t#| j9| j;}t=j>| |}tA} t=jB|\} } | jEr| z | jGz| z}|jItJjLk(r| fn| f}tOjP| g|}tS|j}|jUr|jW}t=jX|r|j[F|j]|rnB|tOjPtA|z }|j[|jUr||j^z S) a Return the normalized wire parameter for the point closest to this wire. This method projects the given point onto the wire, finds the nearest edge, and accumulates arc lengths to determine the fractional position along the entire wire. The result is normalized to the interval [0.0, 1.0], where: - 0.0 corresponds to the start of the wire - 1.0 corresponds to the end of the wire Unlike the edge version of this method, the returned value is **not** an OCCT curve parameter, but a normalized parameter across the wire as a whole. Args: point (VectorLike): The point to project onto the wire. Raises: ValueError: Can't find point on empty wire Returns: float: Normalized parameter in [0.0, 1.0] representing the relative position of the projected point along the wire. zCan't find point on empty wirerrrrz from wirezpoint is not on Wirer)0rQrrrrrrrr$rr NbSolutionSupportTypeShape2r%BRepExtrema_IsOnEdgerrzrSupportOnShape2 ParOnEdgeS2BRepExtrema_IsVertexr}rrurrrqrrrrrrrrrr:rsrUr6rr/rr Degenerated_srIsEqualr)rNrrvertex_on_curverr supp_typeclosest_topods_edgeclosest_topods_edge_paramv_hitrrrr param_pairdistance_along_wire wire_explorerrs rrzWire.param_at_points0 == => > 0&&222%%e, Q :wugU:,jIJ J,_-D-DdllS~~7#5#5#71#<34 4--a0 /DD D"'Xg&=&=a&@A# )0(;(;A(>q(A % 1FF F-'2I2I!2L)MNEGIO  * * b.. #(Xo&A&A%&H&N&N&PQ# )2(=(=*) %**=> (001DE 9  # # %*Y6-:N:N:PP) % #..04F4U4UU1 2+Y7  3;;MWJW/t||<   "'//1K&&{3""$""#67 #7#@#@!+.$        "#T[[00rc|tjk(r!|jsd|z }||jz}n|js|j|z }|}|j }|Dcgc]}|j}}g}d}|D]} || z }|j ||dkrd} d} n9||k\rt |dz } || } n t||} | dkDr|| dz nd} || z } || } | jdk(rdn| | jz }| jsd|z }| j|}| j}||| jfScc}w)a Map a position along this wire to the underlying OCCT edge and curve parameter. Unlike the edge version, this method determines which constituent edge of the wire contains the requested position, then returns a curve adaptor for that edge together with the corresponding OCCT parameter. The interpretation of `position` depends on `position_mode`: - ``PositionMode.PARAMETER``: `position` is a normalized parameter in [0, 1] across the entire wire. - ``PositionMode.DISTANCE``: `position` is an arc length distance along the wire. Edge and wire orientation (`is_forward`) is respected so that positions are measured consistently along the wire. Args: position (float): Position along the wire, either a normalized parameter (0-1) or a distance, depending on `position_mode`. position_mode (PositionMode, optional): How to interpret `position`. Defaults to ``PositionMode.PARAMETER``. Returns: tuple[BRepAdaptor_Curve, float]: The curve adaptor for the specific edge at the given position, the corresponding OCCT parameter on that edge and if edge is_forward. rrnrr) rr9rVrrrrrr;rf)rNrrrC self_edgesr edge_lengthscumulative_lengthstotal edge_lengthedge_idx local_distprev_cum target_edge local_fracrrs rrzWire._occt_param_ats}> L22 2??>$++-H??;;1HZZ\ *45Q5 5' -K [ E  % %e , - s?HJ  :*H%h/J#$6AH;Ca<)(Q,7SH!H,J * %%*Ck>P>P1P %%ZJ&..z:(557!?K4J4JJJA6s&Ec |j|s td|&|$t|j}t}n||d}t|}n td|(t |j |j t |}n't |j |j t|}t}|j j}|jr|j} || jk(r|jt| n?|jtttt!| j#|j%|jrt'j(dt+|t+|dkDrg} |j-} |D]}} | j-} |I| | z j}|j/|dk\s=| j| | | z j0f^| j| | |z j0f| j3dt'j(d t+| t| Dcgc]}|d c}}t|Dcgc]}|j5c}}|Scc}wcc}w) aProject Wire Project a Wire onto a Shape generating new wires on the surfaces of the object one and only one of `direction` or `center` must be provided. Note that one or more wires may be generated depending on the topology of the target object and location/direction of projection. To avoid flipping the normal of a face built with the projected wire the orientation of the output wires are forced to be the same as self. Args: target_object: Object to project onto direction: Parallel projection direction. Defaults to None. center: Conical center of projection. Defaults to None. target_object: Shape: direction: VectorLike: (Default value = None) center: VectorLike: (Default value = None) Returns: : Projected wire(s) Raises: ValueError: Only one of direction or center must be provided Nz,Can't project empty Wires or to empty Shapesz*Provide exactly one of direction or centerz!wire generated %d projected wiresrrc |dS)Nrrrs rrz'Wire.project_to_shape..s adrrz8projected, filtered and sorted wire list is of length %d)rQrrrr-rr[r`rr:rrrrrr~rrrrdebugrrrrsortr)rNr rzrdirection_vector center_pointprojection_object output_wirestarget_orientationprojected_wireoutput_wires_distancesplanar_wire_center output_wireoutput_wire_centeroutput_wire_directionr{ cleaned_wiress rr zWire.project_to_shape's@ == KL L  V^%i0;;= !8L  I$5# !&>LIJ J  ' 3 %%()!  !4 %% %! )2 !\\557$$&.668N!^%?%?%AA##D$89##{H^5L5L5N,OPQ  " " $ $$&  8#l:KL | q %' "!% +  %0%7%7%9"#/*-?? jl*-001ABaG.55 +!36H!H P P+11'/,>FF * # ' 'N ' ; LLJ*+ %4J%Kqad%KLL"l"C1779"CD  &L#Ds > J:J?cr|j|s tdt}|jt j |j |jt j |j |j|jj|j S)zAttempt to stitch wires Args: other (Wire): wire to combine Raises: ValueError: Can't stitch empty wires Returns: Wire: stitched wires zCan't stitch empty wires) rQrr!r>rxrrr?rr)rNrrFs rstitchz Wire.stitchs == 78 8.0 T\\23U]]34~~""<#4#4#677rct}|j tdt|j}|j r|j }tj|r|jFtj|\}}tj|tt}t|||}|j|t}|s t!d|j|j rt#|j%} | j's t!dt)| j)S)u0 Collapse this wire into a single BSpline edge (internal use). Concatenates the wire's constituent edges—**in topological order**—into one `Geom_BSplineCurve` using OCP/OCCT's `GeomConvert_CompCurveToBSplineCurve`. Degenerate edges are skipped. The resulting topology is a **single Edge**; former junctions between original edges become **internal spline knots** (C0 corners) but **not vertices**. ⚠️ Not intended for general user workflows. The loss of vertex boundaries can make downstream operations (e.g., splitting at vertices, continuity checks, feature recognition) surprising. This is primarily useful for internal tasks that benefit from a single-curve representation (e.g., length/abscissa queries or parameter mapping along the entire wire). Behavior & caveats: - Orientation and section order follow the wire's topological sequence. - Junctions with only C0 continuity are preserved as spline knots, not as topological vertices. - The returned edge's parameterization is that of the composite BSpline (not a normalized [0,1] wire parameter). - Failure to append any segment or to build the final edge raises an error. Raises: RuntimeError: If any segment cannot be appended to the composite spline or the final BSpline edge cannot be built. ValueError: Empty Wire Returns: Edge: A single edge whose geometry is `GeomType.BSPLINE`. zCan't convert an empty wirezFailed to build bspline.)rRrQrr/rrrrrrrrr~r@r>rrr BSplineCurverr) rNbuilderrrrrr'r*okrPs r _to_bsplinezWire._to_bsplinesB67 == :; ;.t||<   "'//1K&&{3""$#,#4#4[#A Iy!))+uwHI-iINM]I6B"#=>>      " /w/C/C/EF ""$9: :L%%'((rzYto_wire is deprecated and will be removed in a future version. Use 'Wire(Wire)' instead.c|S)zGReturn Wire - used as a pair with Edge.to_wire when self is Wire | EdgerrMs rrz Wire.to_wires  rctj||d}tj||d}t||g\}}|jj |}t |dk(r#|d}|j ||}t|gS|j}||z} ||z} g} d} |D]} | j}| }| |z}|} || ks|| k\r#|| k\r|| kr| j| ?t| |}t| |}||z |z }||z |z }t||z tkDs}| j| j ||t| S)a5Trim a wire between [start, end] normalized over total length. Args: start (float | VectorLike): normalized start position (0.0 to <1.0) or point end (float | VectorLike): normalized end position (>0.0 to 1.0) or point Returns: Wire: trimmed Wire rrrrrn)rKrrrr-rrmrrrrrrr)rNrrrrr ordered_edget_edge total_length start_lenend_lenr cur_lengthredge_len edge_startedge_endtrim_start_len trim_end_lenu0u1s rrmz Wire.trims~##D%9!!$U3% 01 ,,T2  }  "(+L!&&w6F> !{{ l* ,&  ! $$T*"%Y !;"7H5 $z1X="Z/8;rBw<)+!((2r):;) <,M""r)r7NN)rtr~rrrr8rr9)rrrrrr8rr9)rrrrrr8rr9)rrrrrr8rr9)Fr7NN) rIterable[Edge]rUrrrrr8rr9rH)rrrUrrr~)rE)rzzIterable[Wire | Edge]r`r~rShapeList[Wire])rtrrzrrr)rr~rrrr)r)rrrr~rr)r,r~r-r~rrrr~rr~rrrtrrrr)rr@rrrr)rr~rHr~rrrr)rrJrtuple[Edge, Edge]rrr) rCr~rr~rIterable[Vertex]rrJrrrIr>)rr~rrrr)rr~rr)rrrB)rrr`r~rr}rrrErFrDrG)r rrzrrrrr)rrrr)rr)rNrrrrrrr)*rrrrrrrrr[rrr{rrrrrrr7rrrrrrrrrrfrrr;rrr9rr rr rrrmrLrMs@rrr| sE? E""&         ""&         ""&         ""&          ""&           .> D@#@#D8<)05 <@@7.P.P%%% %  %  %,%% %%N((, xx <<< <  <<8 # ,=    (! A;A;A;# A;  A;  A;F 4l@*3 $()      #&    D +DZ1z>J=S=SJKJK.:JK .JK^(,$( nn%n" n  n`8,:)x % 5#rc t}t}|D]*}|j|j|j,tj||d|t }t |jD]A}|jttj|j|dzC|S)zConvert edges to a list of wires. Args: edges: Iterable[Edge]: tol: float: (Default value = 1e-6) Returns: Fr) rrr=rhrnrr9rorrrxr%)rr`rprqrrzrBs rroro)s)*H)+I* << # OODLL )*228S%S&[E 9##% &@ T&++iooa!e&<=>?@ Lrct}|j||t|j|j S)zOffset a topods_face)rTol)r+rrMakeOffsetShaper)r5amountoffsetors rrZrZDs8$&H V;  >> rc ttjttjt tjt tjttji}||n |j}| td|s td|j}t}|jDcgc]}|j|j}}|D]}|j|rt||} | $| j1t!j"| j|} t!j"| j|} t%|} t%|} t'j(| | | | t*t*}|j-|tj}||k\s|j/|t1d|DScc}w)a~ Find edges connected to the given edge with at least the requested continuity. Args: edge: The reference edge to explore from. parent: Optional parent Shape. If None, uses edge.topo_parent. continuity: Minimum required continuity (C0/G0, C1/G1, C2/G2). Returns: ShapeList[Edge]: Connected edges meeting the continuity requirement. edge has no valid parentz edge is emptyc32K|]}t|ywrrrs rrz/topo_explore_connected_edges..s6T!W6r)rErC0rKC1rFrLC2rGrrrrrrrrrrr* Continuity_srrZrr)rr continuitycontinuity_mapgiven_topods_edgerr topods_edgesrcommon_topods_vertexru2curve1curve2actual_continuity actual_levels rtopo_explore_connected_edgesr7Ms" O&&O&&O&&O&&O&& N)Vt/?/?F ~344 )) eO(.||~O!9NAIIOLO#1  # #K 0 .H {/  ! ,$,,8&&';'C'CEVWB&&';'C'C[QB''89F&{3F!* 6 6B 9! *--.?ASASTLz)##K071: 6o6 66?Ps 9G Gc 0|s td||n |j}|s tdt}tj|j t jt j|t}g}|j|j r1|j|j D]}|j|t|jD]/}|jt!j"||dz1|S)zMGiven an edge extracted from a Shape, return the topods_faces connected to itz Can't explore from an empty edger'r)rrrrurrrr TopAbs_FACErContainsrr>r9Extentrrxr)rr edge_face_mapunique_face_map unique_facesr5rBs rrYrYs ;<<)Vt/?/?F 344>?M ""  12OLdll+!--dll; &D    % & ?))+ ,AFKKA(>?@A r)rrrrrr)rrrr~rz_WireFilletSolution | None)rrzrr}rr)rrr rrr)rrrr)rrr@rrr)rrrrrr~rr)r)rrr`r~rr)r5r{r$r~rr|)rrr Shape | Noner-rrrr)rrrr?rzlist[TopoDS_Face]( r __future__rr/rhbisectrcollections.abcrr dataclassesr itertoolsrmathr r r r r rrrrtypingrrrrnumpyr OCP.TopAbsTopAbsr OCP.BOPAlgorOCP.BReprOCP.BRepAdaptorrrOCP.BRepAlgoAPIrrOCP.BRepBuilderAPIrrrrrr r!r"r#OCP.BRepExtremar$r%OCP.BRepFilletAPIr& OCP.BRepGPropr' OCP.BRepLibr(r) OCP.BRepLPropr*OCP.BRepOffsetr+OCP.BRepOffsetAPIr, OCP.BRepProjr- OCP.BRepToolsr.r/ OCP.ChFi2dr0 OCP.Extremar1OCP.GCr2r3r4r5 OCP.GCPntsr6r7r8OCP.Geomr9r:r;r<r=r>r?r@ OCP.Geom2drArBrC OCP.Geom2dAPIrD OCP.GeomAbsrErFrGrHrIrJrKrLrMOCP.GeomAdaptorrN OCP.GeomAPIrOrPrQOCP.GeomConvertrR OCP.GeomFillrSrTrUOCP.GeomProjLibrVOCP.gprWrXrYrZr[r\r]r^r_r`rarbrc OCP.GProprd OCP.HLRAlgore OCP.HLRBReprfrgOCP.ShapeAnalysisrh OCP.ShapeFixrirj OCP.Standardrk OCP.TColgprlrmrn OCP.TColStdrorprqrrrsrt OCP.TopExprurv OCP.TopLocrw OCP.TopoDSrxryrzr{r|r}r~ OCP.TopToolsrrrrscipy.optimizer scipy.spatialrtyping_extensionsrrbuild123d.build_enumsrrrrrrrrrrbuild123d.geometryrrrrrrrrrrconstrained_linesrrrrrrr shape_corerrrrrrrrrutilsrrrzero_drr compositerrrrthree_drtwo_drrrrrrrrr%r7rGrIrKrrrorZr)r7rYrrrr~s1f# .!"MMM (D   P8#4#06,;(%     4   . @ (#)86;3RR <.& +$.         RQ688" $&&& $$$$6 ',<  -:   $3<# #',##L#% #%)<#% #%L8"bKeFmbKJ!r 7; r j;j#7; j#Z%6 "1"4"4?7 ?7 ?7 ?7 ?7F(, $r