^jBdZddlmZddlZddlZddlmZmZm Z ddl m Z ddl m Z mZmZmZmZmZmZddlmZmZddlZddlZddlmZdd lmZdd lmZm Z m!Z!dd l"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+dd l,m-Z-dd l.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4ddl5m6Z6m7Z7m8Z8m9Z9m:Z:ddl;mGdde6Z?Gdde:Z@Gdde7ZAGdde@ZBGddeAZCGddeAZDGddeAZEGdd eAZFGd!d"e?ZGGd#d$e?ZHGd%d&eAZIGd'd(eAZJGd)d*eAZKGd+d,eAZLGd-d.eAZMGd/d0eAZNGd1d2e@ZOGd3d4eAZPGd5d6eAZQGd7d8eAZRGd9d:eAZSGd;deAZUGd?d@eAZVGdAdBeAZWGdCdDeAZXGdEdFeAZYedGGdHdIeAZZedJGdKdLeAZ[edMGdNdOeAZ\edPGdQdReAZ]y)Ta Curve Objects name: objects_curve.py by: Gumyr date: March 22nd 2023 desc: This python module contains objects (classes) that create 1D Curves. license: Copyright 2023 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)CallableIterableSequence)product)atan2copysigncosdegreesradianssinsqrt)Literaloverload)minimize) deprecated) WorkplaneListflatten_sequencevalidate_inputs) AngularDirectionContinuityLevelGeomTypeKeep LengthModeModeSagittaSideTangency) BuildLine) TOLERANCEAxisLocationPlaneVector VectorLike)CurveEdgeFaceVertexWire)Shape ShapeListctjd}|mt|tr\t|tr|j ||yt|t t fr!|j|jd|iyyyy)zHelper function to add a curve to the context. Args: curve (Edge | Wire | Curve): curve to add to the context (either a Wire or an Edge) mode (Mode): combination mode F)logNmoder0)r _get_context isinstancer'_add_to_contextr&r*edges)curver0contexts P/opt/ringagent/.cad-venv/lib/python3.12/site-packages/build123d/objects_curve.py_add_curve_to_contextr8=sv!* 6 65 AGz'9= eT "  # #E # 5 t} - #G # #U[[] > >. >cVeZdZdZej gZejfdfd Z xZ S)BaseCurveObjectzBaseCurveObject specialized for Curve. Args: curve (Wire): wire to create mode (Mode, optional): combination mode. Defaults to Mode.ADD cjt|||jt| |jyyNr8wrappedsuper__init__selfr5r0 __class__s r7rAzBaseCurveObject.__init__W-eT* == $ G U]] + %r9)r5r&r0r __name__ __module__ __qualname____doc__r_tag _applies_torADDrA __classcell__rDs@r7r;r;Ms'>>"K26((,,r9r;cVeZdZdZej gZejfdfd Z xZ S)BaseLineObjectzBaseLineObject specialized for Wire. Args: curve (Wire): wire to create mode (Mode, optional): combination mode. Defaults to Mode.ADD cjt|||jt| |jyyr=r>rBs r7rAzBaseLineObject.__init__hrEr9)r5r*r0rrFrOs@r7rQrQ^s'>>"K15,,r9rQcVeZdZdZej gZejfdfd Z xZ S)BaseEdgeObjectzBaseEdgeObject specialized for Edge. Args: curve (Edge): edge to create mode (Mode, optional): combination mode. Defaults to Mode.ADD cPt||t| |jyr=)r8r@rAr?rBs r7rAzBaseEdgeObject.__init__yseT* 'r9)r5r'r0rrFrOs@r7rTrTos'>>"K15((r9rTceZdZdZej gZeddZdde jf dfd Z e d dZ xZS) Airfoila3 Create an airfoil described by a 4-digit (or fractional) NACA airfoil (e.g. '2412' or '2213.323'). The NACA four-digit wing sections define the airfoil_code by: - First digit describing maximum camber as percentage of the chord. - Second digit describing the distance of maximum camber from the airfoil leading edge in tenths of the chord. - Last two digits describing maximum thickness of the airfoil as percent of the chord. Args: airfoil_code : str The NACA 4-digit (or fractional) airfoil code (e.g. '2213.323'). n_points : int Number of points per upper/lower surface. finite_te : bool If True, enforces a finite trailing edge (default False). mode (Mode, optional): combination mode. Defaults to Mode.ADD c|t|jddj}d|vrX|jdd\}}t |ddz }t |ddz }t t |dd d d|dz }n3t |ddz }t |ddz }t |dd dz }|||fS) zR Parse NACA 4-digit (or fractional) airfoil code into parameters. NACA.rd N02)strreplacestripsplitintfloat)valuesint_part frac_partmpts r7 parse_naca4zAirfoil.parse_naca4s J  vr * 0 0 2 !8"#''#q/ HiHQK 3&AHQK 2%AXab\*2.a {; ""=y=I  NN7Q;! DM"G]#;>"K&XX J)J)J) J)  J)X55r9rWcdeZdZdZej gZdejd dfdZ xZ S)BezieraLine Object: Bezier Curve Create a non-rational bezier curve defined by a sequence of points and include optional weights to create a rational bezier curve. The number of weights must match the number of control points. Args: cntl_pnts (sequence[VectorLike]): points defining the curve weights (list[float], optional): control point weights. Defaults to None mode (Mode, optional): combination mode. Defaults to Mode.ADD N)weightsr0ctj|}t||t|}t j |}t j|d|i}t|%||y)Nrr/) rr1rrrlocalizer' make_bezierr@rA) rCrr0 cntl_pntsr6 cntl_pnt_listpollsr5rDs r7rAzBezier.__init__ s` %.$:$:4$@&()4 && 6  %99 T*r9)rr%rzlist[float] | Noner0rrFrOs@r7rrsH >>"K '+XX + +$ + + +r9rcleZdZdZej ddejf dfd ZxZ S) BlendCurveuNLine Object: BlendCurve Create a smooth Bézier-based transition curve between two existing edges. The blend is constructed as a cubic (C1) or quintic (C2) Bézier curve whose control points are determined from the position, first derivative, and (for C2) second derivative of the input curves at the chosen endpoints. Optional scalar multipliers can be applied to the endpoint tangents to control the "tension" of the blend. Args: curve0 (Edge): First curve to blend from. curve1 (Edge): Second curve to blend to. continuity (ContinuityLevel, optional): Desired geometric continuity at the join: - ContinuityLevel.C0: position match only (straight line) - ContinuityLevel.C1: match position and tangent direction (cubic Bézier) - ContinuityLevel.C2: match position, tangent, and curvature (quintic Bézier) Defaults to ContinuityLevel.C2. end_points (tuple[VectorLike, VectorLike] | None, optional): Pair of points specifying the connection points on `curve0` and `curve1`. Each must coincide (within TOLERANCE) with the start or end of the respective curve. If None, the closest pair of endpoints is chosen. Defaults to None. tangent_scalars (tuple[float, float] | None, optional): Scalar multipliers applied to the first derivatives at the start of `curve0` and the end of `curve1` before computing control points. Useful for adjusting the pull/tension of the blend without altering the base curves. Defaults to (1.0, 1.0). mode (Mode, optional): Boolean operation mode when used in a BuildLine context. Defaults to Mode.ADD. Raises: ValueError: `tangent_scalars` must be a pair of float values. ValueError: If specified `end_points` are not coincident with the start or end of their respective curves. Example: >>> blend = BlendCurve(curve_a, curve_b, ContinuityLevel.C1, tangent_scalars=(1.2, 0.8)) >>> show(blend) Nc.|dn|}t|dk7r td|4tt|j |j dn|}||f} ddg} t |D]z\} } | | j d} | | j d}t| }|| z jtkrd| | <U||z jtkrd| | <qtd|j | d}|j | d}|j| dd|dz}|j| dd|dz}|tjk(r t||}n|tjk(r||d z z}||d z z }||||g}t|}nl|j| dd}|j| dd}||d z z}|d|zd z z|d z z}||d z z }|d|zd z z |d z z}||||||g}t|}t |E|| y) N)?rr_z+tangent_scalars must be a (start, end) pairc0|dj|dS)Nrr\) distance_to)pairs r7z%BlendCurve.__init__..Xsa!4!4T!W!=r9keyrr\z8end_points must be at either the start or end of a curversrrr/)len ValueErrorminrvertices enumerate position_atr$lengthr derivative_atrC0LineC1rr@rA)rCcurve0curve1 continuity end_pointstangent_scalarsr0 tan_scalarsend_pntscurves end_paramsiend_pntcurve_start_pnt curve_end_pnt given_end_pnt start_posend_pos start_deriv end_deriv joining_curve cntl_pnt1 cntl_pnt4r start_curvend_curv cntl_pnt2 cntl_pnt3rDs r7rAzBlendCurve.__init__Ds%4$;j { q JK K! )6??+<==   &,V$4V #H- JAw$Qi33A6O"1I11!4M"7OM/77)C ! 1 -/77)C ! 1  N n&&z!}5 $$Z]3 **:a=!<{1~M ((A:[^K ++ + G4M ?-- -!K!O3I)a-/I"Iy'BI"I.M--jmQ?J++JqM1=H!K!O3I!Q_$99JOKI)a-/I1y=A"552 EI I#I.M T2r9) rr'rr'rrrz$tuple[VectorLike, VectorLike] | Nonerztuple[float, float] | Noner0r) rGrHrIrJrC2rrMrArNrOs@r7rrsm(\'6&8&8;?6:XXu3u3u3$ u3 9 u3 4 u3u3u3r9rcVeZdZdZddej f dfd ZxZS)BSplineaWLine Object: BSpline An exact B-spline edge defined directly from control points and knot data. BSpline creates an exact B-spline from control points, a knot sequence, and optional weights. Control points define the control polygon that pulls the curve, but the curve does not generally pass through them. Knots define the parameter-space structure of the spline: they determine where polynomial spans begin and end and how smoothly those spans join. Repeated knot values indicate knot multiplicity. For a spline of degree p, a knot with multiplicity m has continuity C^(p-m) at that location, so increasing multiplicity reduces smoothness. Repeating the first and last knots degree + 1 times creates a clamped spline that starts and ends at the first and last control points. Optional weights create a rational B-spline, allowing some control points to pull more strongly than others and enabling exact representation of conic sections.` Unlike :class:`~build123d.objects_curve.Spline`, which creates an interpolated curve through a set of points using ``GeomAPI_Interpolate``, ``BSpline`` preserves the supplied spline definition by building the underlying OCCT ``Geom_BSplineCurve`` from its poles, knot vector, optional weights, degree, and periodic flag. Args: control_points (Iterable[VectorLike]): Control points (poles) defining the spline shape. These are not generally points on the curve. knots (Iterable[float]): Knot sequence for the spline. Repeated knot values are allowed and are converted internally into unique knot values plus multiplicities as required by OCCT. degree (int): Polynomial degree of the spline. weights (Iterable[float] | None, optional): Optional per-control-point weights for rational B-splines. If omitted, the spline is non-rational. periodic (bool, optional): Whether to create a periodic spline. Defaults to ``False``. mode (Mode, optional): Builder combination mode. Defaults to ``Mode.ADD``. NFctj|}t||tjt j |||||}t |!||y)N)rrvr/) rr1rr' make_bsplinerrr@rA) rCcontrol_pointsknotsdegreerrvr0r6splinerDs r7rAzBSpline.__init__s]%.$:$:4$@&""  " "N 3     d+r9) rzIterable[VectorLike]rzIterable[float]rrerIterable[float] | Nonervrr0r)rGrHrIrJrrMrArNrOs@r7rrs\$V+/XX,,,, , ( ,  ,,,r9rcleZdZdZej gZejf dfd Z xZ S) CenterArcusLine Object: Center Arc Create a circular arc defined by a center point and radius. Args: center (VectorLike): center point of arc radius (float): arc radius start_angle (float): arc starting angle from x-axis arc_size (float | Shape | Axis | Location | Plane | VectorLike): angular size of arc or an arc limit. When a limit object is provided instead of a numeric angular size, CenterArc constructs the valid arc(s) from the given start point, trims them at their first intersection with the limit, and returns the one requiring the shortest travel from the start. Therefore, one can only generate arcs < 180° using a limit. If neither valid arc intersects the limit, a ValueError is raised. mode (Mode, optional): combination mode. Defaults to Mode.ADD c,tj|}t||tj|}|t j }n4tjtjjd}||_ t|tr t|n|} t| ttfrV| dkDrt j"nt j$} | dzdz} || z} | dk(r| n|}t'j(|||| | } n|j*j-t/d|j0||z}tj|}||_ ||_t'j(||} | j3d}| j5| }|j5| }||t7d|t9||fDcgc]}|| c}j;t&j<d} t>|| |ycc}w) Nrgv@) start_angle end_angleangular_directionrrrT reconstructz&CenterArc doesn't intersect arc limit r/)!rr1rrrr#XY copy_modulecopy workplanesoriginr2rr$rerfrCOUNTER_CLOCKWISE CLOCKWISEr' make_circlex_dirrotater!z_dirreversed trim_to_otherrr,sort_byrr@rA)rCcenterradiusrarc_sizer0r6 center_pointcircle_workplane arc_factor arc_directionnormalized_arc_sizerarcstart_radius_vector circle_planearc2 trimmed_arc trimmed_arc2arDs r7rAzCenterArc.__init__s %.$:$:4$@&$--f5 ?$xx *//**,77:  #/)3Hh)GVH%X j3, />!22%//  $.#5"> #&99I':e'C)K"" '#"/ C!&&--$4$:$:;[ '++,<=L".L !4L ""6<8C<>"KXX @)@)@) @) G @)  @) @)@)r9rceZdZdZej gZeejde jd ddZ eejde jd ddZ eejde jd ddZ ed e jd  dd Z ed e jd  dd Z fdZ xZ S)ConstrainedArcsaLine Object: Arc(s) constrained by other geometric objects. The result is always a Curve containing one or more Edges. If you need to access Edge-specific properties or methods (such as ``arc_center``), extract the edge or edges first:: result = ConstrainedArcs(...) arc = result.edge() # extract the Edge center = arc.arc_center # now Edge methods are available Note that in Builder mode the ``selector`` parameter must be provided or all results will be combined into the BuildLine context. In Algebra mode the selector can be applied as a parameter or in the normal way to the ConstrainedArcs object. The content of the selector is the same in both cases. Examples: An arc built from three edge constraints. Algebra:: l4 = PolarLine((0, 0), 4, 60) l5 = PolarLine((0, 0), 4, 40) a3 = CenterArc((0, 0), 4, 0, 90) ex_a3 = ( ConstrainedArcs(l4, l5, a3, sagitta=Sagitta.BOTH).edges().sort_by(Edge.length)[0] ) Builder:: with BuildLine() as arc_ex3: l4 = PolarLine((0, 0), 4, 60) l5 = PolarLine((0, 0), 4, 40) a3 = CenterArc((0, 0), 4, 0, 90) ex_a3 = ConstrainedArcs( l4, l5, a3, sagitta=Sagitta.BOTH, selector=lambda arcs: arcs.sort_by(Edge.length)[0], ) c|Sr=arcss r7rzConstrainedArcs.r9)sagittaselectorr0cy)a5 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. selector (Callable, optional): typically a lambda which chooses one or more of the results. Defaults to lambda arcs: arcs. mode (Mode, optional): combination mode. Defaults to Mode.ADD. Example: Accept all results (default behaviour):: a1 = CenterArc((-5, 0), 4, 0, 360) a2 = CenterArc((5, 0), 3, 0, 360) arcs = ConstrainedArcs(a1, a2, radius=10, selector=lambda arcs: arcs) Nr)rC tangency_one tangency_tworrrr0s r7rAzConstrainedArcs.__init__r9c|Sr=rrs r7rzConstrainedArcs.rr9cy)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[Axis | 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. selector (Callable, optional): typically a lambda which chooses one or more of the results. Defaults to lambda arcs: arcs. mode (Mode, optional): combination mode. Defaults to Mode.ADD. Example: Pick just the first result:: l2 = PolarLine((0, 0), 4, -20, length_mode=LengthMode.HORIZONTAL) l3 = Line((4, -2), (4, 2)) arcs = ConstrainedArcs( l2, l3, center_on=Axis((3, 0), (0, 1)), selector=lambda arcs: arcs[0] ) Nr)rCrr center_onrrr0s r7rAzConstrainedArcs.__init__r r9c|Sr=rrs r7rzConstrainedArcs.rr9cy)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. selector (Callable, optional): typically a lambda which chooses one or more of the results. Defaults to lambda arcs: arcs. mode (Mode, optional): combination mode. Defaults to Mode.ADD. Example: Pick the shortest one:: l4 = PolarLine((0, 0), 4, 60) l5 = PolarLine((0, 0), 4, 40) a3 = CenterArc((0, 0), 4, 0, 90) arcs = ConstrainedArcs( l4, l5, a3, sagitta=Sagitta.BOTH, selector=lambda arcs: arcs.sort_by(Edge.length)[0] ) Nr)rCrrtangency_threerrr0s r7rAzConstrainedArcs.__init__r r9c|Sr=rrs r7rzConstrainedArcs.rr9rr0cy)a 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 selector (Callable, optional): typically a lambda which chooses one or more of the results. Defaults to lambda arcs: arcs. mode (Mode, optional): combination mode. Defaults to Mode.ADD. Example: Pick the only result:: arcs = ConstrainedArcs(Axis.Y, center=(-2, 1), selector=lambda arcs: arcs[0]) Nr)rCrrrr0s r7rAzConstrainedArcs.__init__r r9c|Sr=rrs r7rzConstrainedArcs.rr9cy)a 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 selector (Callable, optional): typically a lambda which chooses one or more of the results. Defaults to lambda arcs: arcs. mode (Mode, optional): combination mode. Defaults to Mode.ADD. Example: There is only one result so a selector isn't helpful:: l6 = PolarLine((0, 0), 5, -20) l7 = Line((3, -2), (3, 2)) arcs = ConstrainedArcs(l6, radius=1, center_on=l7) Nr)rCrrr#rr0s r7rAzConstrainedArcs.__init__r r9chtj|}t|||jdd}|jdtj }t j|i|}||}||s tdt|t r|gn|}t|}t |1||y)Nrc|Sr=rrs r7rz*ConstrainedArcs.__init__..Estr9r07selector must return an Edge or list of Edges, not Noner/) rr1rpoprrMr'make_constrained_arcsrr2r&r@rA) rCargskwargsr6rr0r selected_arcsr5rDs r7rAzConstrainedArcs.__init__<s %.$:$:4$@&::j*;<zz&$((+))4:6:!  VW W *->]OM m$ T*r9) r@tuple[Axis | Edge, Tangency] | Axis | Edge | Vertex | VectorLikerr4rrfrrr3Callable[[ShapeList[Edge]], Edge | ShapeList[Edge]]r0r) rr4rr4r#z Axis | Edgerrrr5r0r) rr4rr4r&r4rrrr5r0r)rr4rr%rr5r0r) rr4rrfr#r'rr5r0r)rGrHrIrJrrKrLrrSHORTrrMrArNrOs@r7rrRs)V>>"K #== XX" V" W"  "  "  " " " H#== XX$ V$ W$  $  $  $ $ $ L#== XX' V' W' M ' '  ' ' ' R XX V       > XX# V#  #  #  # # # J++r9rceZdZdZej gZedejd d dZ edejd d dZ edddejd  dd Z dfd Z xZ S)ConstrainedLinesaLine Object: Lines(s) constrained by other geometric objects. The result is always a Curve containing one or more Edges. If you need to access Edge-specific properties or methods (such as ``length``), extract the edge or edges first:: result = ConstrainedLines(...) lines = result.edges() # extract the Edges length = lines[1].length # now Edge methods are available Note that in Builder mode the ``selector`` parameter must be provided or all results will be combined into the BuildLine context. In Algebra mode the selector can be applied as a parameter or in the normal way to the ConstrainedArcs object. The content of the selector is the same in both cases. c|Sr=rliness r7rzConstrainedLines.q%r9r(cy)a 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). selector (Callable, optional): typically a lambda which chooses one or more of the results. Defaults to lambda lines: lines. mode (Mode, optional): combination mode. Defaults to Mode.ADD. Example: Accept all results (default behaviour):: a1 = CenterArc((-5, 0), 4, 0, 360) a2 = CenterArc((5, 0), 3, 0, 360) lines = ConstrainedLines(a1, a2, selector=lambda lines: lines) NrrCrrrr0s r7rAzConstrainedLines.__init__ir r9c|Sr=rr:s r7rzConstrainedLines.r<r9cy)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 (VectorLike): Fixed point through which the line(s) must pass. selector (Callable, optional): typically a lambda which chooses one or more of the results. Defaults to lambda lines: lines. mode (Mode, optional): combination mode. Defaults to Mode.ADD. Example: Pick just the first result:: a1 = CenterArc((-5, 0), 4, 0, 360) lines = ConstrainedLines(a1, (0, 6), selector=lambda lines: lines[0]) Nrr>s r7rAzConstrainedLines.__init__r r9Nc|Sr=rr:s r7rzConstrainedLines.r<r9)angle directionrr0cy)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 selector (Callable, optional): typically a lambda which chooses one or more of the results. Defaults to lambda lines: lines. mode (Mode, optional): combination mode. Defaults to Mode.ADD. Example: Pick the arc whose midpoint is closest to a given point:: a1 = CenterArc((-5, 0), 4, 0, 360) lines = ConstrainedLines( a1, Axis.Y, angle=30, selector=lambda lines: lines.sort_by_distance((0, 0))[0], ) Nr)rCrrrBrCrr0s r7rAzConstrainedLines.__init__r r9chtj|}t|||jdd}|jdtj }t j|i|}||}||s tdt|t r|gn|}t|}t |1||y)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 rc|Sr=rr:s r7rz+ConstrainedLines.__init__..sr9r0Nr.r/) rr1rr/rrMr'make_constrained_linesrr2r&r@rA) rCr1r2r6rr0r;selected_linesr5rDs r7rAzConstrainedLines.__init__s%.$:$:4$@&::j*=>zz&$((+++T4 @^ n n% T*r9)r#tuple[Edge, Tangency] | Axis | EdgerrIrr5r0r)rtuple[Edge, Tangency] | Edgerr%rr5r0r) rrJrr!rB float | NonerCVectorLike | Nonerr5r0r)rr) rGrHrIrJrrKrLrrrMrArNrOs@r7r8r8Vs  >>"K  XX 9 :     : XX 2 !     > #'+ XX' 2' '  ' % '  ' ' ' R++r9r8c~eZdZdZej gZeje jf dfd Z xZ S)DoubleTangentArcaLine Object: Double Tangent Arc Create a circular arc defined by a point/tangent pair and another line find a tangent to. The arc specified with TOP or BOTTOM depends on the geometry and isn't predictable. Contains a solver. Args: pnt (VectorLike): start point tangent (VectorLike): tangent at start point other (Curve | Edge | Wire): line object to tangent keep (Keep, optional): specify which arc if more than one, TOP or BOTTOM. Defaults to Keep.TOP mode (Mode, optional): combination mode. Defaults to Mode.ADD Raises: RunTimeError: no double tangent arcs found c  tj|}t|||tjtj fvrt d|tj|tj|j}tj"tjjd}nDtj|zjj}| t d| }td|j } dj#j%j&z} fd} g} dD]} |j)| | }t+| d|d d| fgt, }|j.d}||zz}tj0|t3|| j4 }j7|\}}}|t,kDrt|j9|}t||j9|}|j;|d s| j=|t?| dk(r tAd |tjk(r| dd} n|tj k(r| dd} t5}| D]%}j7|\}}}tC||' dddjE}tG|tsJtH|||y#1swY=xYw)Nz1Only the TOP or BOTTOM options are supported not rz-DoubleTangentArc only works on a single planerr^cX||dzz}j|}t||z S)Nr)rabs)rperpendicular_bisectorr separationarc_ptothers r7funcz'DoubleTangentArc.__init__..func#s74vay@@F**62JzF*+ +r9)Zrq Nelder-Meadx0r1methodboundstolrg?zNo double tangent arcs foundr\rutangentr/)&rr1rrTOPBOTTOMrrr normalizedrr'r common_planer4r!r bounding_boxadddiagonalrrr rrr#rCdistance_to_with_closest_points tangent_at is_parallelappendr RuntimeError TangentArcedger2r@rA)rCpntrarUkeepr0r6 arc_tangent workplane rotation_axismax_sizerV arc_centersrBrRresult arc_radius arc_centercircledistp1p2 other_axis circle_axisdoubler_ double_edgerTrDs ` @r7rAzDoubleTangentArc.__init__s%.$:$:4$@& $++. .PQUPVWX X'',#,,W5@@B  % % ' 3%224??BIQvv /CDQQI  !PQQ" IY 8 **,008AAA ,   /E%0%7%7 u%M "+$h( F !J"8:"EEJ%%E*M4K4KLF!@@HLD"bib%"2"22"67Jr6#4#4R#89K%%k48"":./ /2 { q => > 488 %a*K T[[ %bc*K [ >"KXXXX N1 N1N1# N1  N1  N1N1r9rNceZdZdZej gZ ddddejd dfdZ xZ S) EllipticalCenterArcuZLine Object: Elliptical Center Arc Create an elliptical arc defined by a center point, x- and y- radii. Args: center (VectorLike): ellipse center 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) start_angle (float, optional): arc start angle from x-axis. Defaults to 0.0 end_angle (float | None): arc end angle from x-axis. Defaults to None arc_size (float | Shape | Axis | Location | Plane | VectorLike): angular size of arc (negative to change direction) or an arc limit. When a limit object is provided instead of a numeric angular size, EllipticalCenterArc constructs the valid arc(s) from the given start point, trims them at their first intersection with the limit, and returns the one requiring the shortest travel from the start. Therefore, one can only generate arcs < 180° using a limit. If neither valid arc intersects the limit, a ValueError is raised. rotation (float, optional): angle to rotate arc. Defaults to 0.0 angular_direction (AngularDirection | None): arc direction. Defaults to None. mode (Mode, optional): combination mode. Defaults to Mode.ADD rqNV@rrotationrr0c tj|} t| |d} | d} |} tjdt d| d} |} tjdt dt j|}| tj}n4tjt jjd}||_ t|j|j}t!|t"r t%|n|}| rNt!|t&t(fs t+dt-j.||||  j1||}nt!|t&t(frV||z} |dk\rt2j4nt2j6} t-j.||||| | j1||}nt-j.||| j1||}|j9|}|j;d j9|}||t+d |t=||fDcgc]}|| c}j?t,j@d}tB||| ycc}w)NFThThe 'end_angle' parameter is deprecated and will be removed in a future version. Use 'arc_size' instead.r_ stacklevelpThe 'angular_direction' parameter is deprecated and will be removed in a future version. Use 'arc_size' instead.rznEllipticalCenterArc limit arc_size can't be used with deprecated 'end_angle' or 'angular_direction' parametersx_radiusy_radiusplanerrr)rrrrz0EllipticalCenterArc doesn't intersect arc limit r/)#rr1rwarningswarnDeprecationWarningrrr#rrrrrr!rr2rr$rerfrr' make_ellipserrrrrrr,rrr@rA)rCrrrrrrrrr0r6deprecated_parameterend_arC center_pntellipse_workplane rotate_axisrr5 trimmed_curvetrimmed_curve2rrDs r7rAzEllipticalCenterArc.__init__us%.$:$:4$@&$  #' E MM+"    (#' )I MMG"  #++F3 ? %  + 0 0**,77:! $. ,335F5L5LM )3Hh)GVH%X j3,7 D %%!!''"+ f[(+  S%L 1*,E?!22%//  %%!!''"+ f[(+ %%!!'f[(+  "// ;M"^^^=KKJWN$)? FxjQ*N;Mqq}Mgdkk"1&E T*Ns <JJrqN)rr%rrfrrfrrfrrKrrrrfrAngularDirection | Noner0rrrrFrOs@r7rrVs8>>"K!"& d+JN59XXd+d+d+ d+  d+  d+Gd+d+3d+d+ d+d+r9rczeZdZdZej gZddejd dfdZ xZ S)EllipticalStartArcaLine Object: EllipticalStartArc Create a circular arc defined by a start point/tangent pair, radius and arc size. Args: start_pnt (VectorLike): start point start_tangent (VectorLike): tangent at start point 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) arc_size (float): angular size of arc (negative to change direction) start_angle (float): angular position of the start point major_axis_dir (VectorLike): direction of ellipse x-axis mode (Mode, optional): combination mode. Defaults to Mode.ADD Note: One of start_angle or major_axis_dir must be provided. N)rmajor_axis_dirr0cd d} tj|} t| |tj|}| t j } n4tjtjjd} || _ t|trCt|dk(r5t|j| j dj#}nt|j#}| j$} |t'|} | || j#}| t)| z}|t+| z}||z|| j-|zz ||z||zzz }|j#}| j-|}|||t+| zzz ||t)| zzz }n|| t|| j#}| j-|}| || }|j/|}|j/|}t1||z ||z } |||t+| zzz ||t)| zzz }t3| }n t5dt ||| }||z}|dk\rt6j8nt6j:}t=j>||||||}t@|||y) NcP|j}|||j|zz Sr=)rddot)vns r7 proj_to_planez2EllipticalStartArc.__init__..proj_to_planes$ Aq1558|# #r9rr_T is_directionz5Either start_angle or major_axis_dir must be provided)rrr/)rr$rr$rr$)"rr1rrrr#rrrrrr2tuplerr$ transformreverse_transformrdrr r r crossrrr rrrrr'rr@rA)rC start_pnt start_tangentrrrrrr0rr6rs pln_normalstart_angle_rad pln_tangenta_radiusb_radiusr pln_x_dir pln_y_dir pln_origin pln_x_radius pln_y_radiusplnrrCr rDs r7rAzEllipticalStartArc.__init__s $%.$:$:4$@&!**95  ?I#(()C)C)E)P)PQR)STI$  mU +M0Ba0G}%966TJ  #=1<<>M__  "%k2O' zBMMOK y3#77H#o"66H;&Z5E5Ek5R)SSH$x('::>?@x#o*>>?@   '%f^&>?@x#o*>>?@  "/2KTU UJizB(* 1}  . .!++   h[)Y  4(r9)rr%rr%rrfrrfrrfrrKrrLr0rrFrOs@r7rrs$>>"K%),0XXY)Y)"Y) Y)  Y)  Y)"Y)*Y)Y)Y)r9rceZdZdZej gZ ddddejd dfdZ xZ S) ParabolicCenterArcaLine Object: Parabolic Center Arc Create a parabolic arc defined by a vertex point and focal length (distance from focus to vertex). Args: vertex (VectorLike): parabola vertex focal_length (float): focal length the parabola (distance from the vertex to focus along the x-axis of plane) start_angle (float, optional): arc start angle. Defaults to 0.0 end_angle (float | None, optional): arc end angle. Defaults to None arc_size (float | Shape | Axis | Location | Plane | VectorLike): angular size of arc (negative to change direction) or an arc limit. When a limit object is provided instead of a numeric angular size, ParabolicCenterArc constructs candidate arcs from the given start point, trims them at their first intersection with the limit, and returns the one requiring the shortest travel from the start. If neither valid arc intersects the limit, a ValueError is raised. rotation (float, optional): angle to rotate arc. Defaults to 0.0 angular_direction (AngularDirection | None, optional): arc direction. Defaults to None mode (Mode, optional): combination mode. Defaults to Mode.ADD rqNrrc.tj|} t| |d} | d} |} tjdt d| d} |} tjdt dt j|} | tj}n4tjt jjd}| |_ t|j|j}t!|t"r t%|n|}| rMt!|t&t(fs t+dt-j.|||  j1||}n(t!|t&t(frU||z} |dk\rt2j4nt2j6} t-j.|||| | j1||}nt-j.||||d zt2j4 j1||}|j9|}|j;d j9|}||t+d |t=||fDcgc]}|| c}j?t,j@d}tB||| ycc}w)NFTrr_rrrzmParabolicCenterArc limit arc_size can't be used with deprecated 'end_angle' or 'angular_direction' parameters) focal_lengthrrrrf@rz/ParabolicCenterArc doesn't intersect arc limit r/)#rr1rrrrrrr#rrrrrr!rr2rr$rerfrr' make_parabolarrrrrrr,rrr@rA)rCvertexrrrrrrr0r6rrrC vertex_pntparabola_workplanerrr5rrrrDs r7rAzParabolicCenterArc.__init__ks%.$:$:4$@&$  #' E MM+"    (#' )I MMG"  #++F3 ?!& !,!1!1**,77:" %/!-446H6N6NO )3Hh)GVH%X j3,7 D &&)('"+  f[(+  S%L 1*,E?!22%//  &&)('"+  f[(+ &&)('%-"2"D"D  f[(+ "// ;M"^^^=KKJWN$)? EhZP*N;Mqq}Mgdkk"1&E T*Ns JJr)rr%rrfrrfrrKrrrrfrrr0rrFrOs@r7rrMs6>>"K !"& c+JN59XXc+c+c+ c+  c+Gc+c+3c+c+c+r9rceZdZdZej gZ ddddejd dfdZ xZ S) HyperbolicCenterArcaFLine Object: Hyperbolic Center Arc Create a hyperbolic arc defined by a center point and focal length (distance from focus to vertex). Args: center (VectorLike): hyperbola center 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) start_angle (float, optional): arc start angle from x-axis. Defaults to 0.0 end_angle (float | None, optional): arc end angle from x-axis. Defaults to None arc_size (float | Shape | Axis | Location | Plane | VectorLike): angular size of arc (negative to change direction) or an arc limit. When a limit object is provided instead of a numeric angular size, HyperbolicCenterArc constructs candidate arcs from the given start point, trims them at their first intersection with the limit, and returns the one requiring the shortest travel from the start. If neither valid arc intersects the limit, a ValueError is raised. rotation (float, optional): angle to rotate arc. Defaults to 0.0 angular_direction (AngularDirection | None, optional): arc direction. Defaults to None mode (Mode, optional): combination mode. Defaults to Mode.ADD rqNrrc4tj|} t| |d} | d} |} tjdt d| d} |} tjdt dt j|}| tj}n4tjt jjd}||_ t|j|j}t!|t"r t%|n|}| rNt!|t&t(fs t+dt-j.||||  j1||}n*t!|t&t(frV||z} |dk\rt2j4nt2j6} t-j.||||| | j1||}nt-j.|||||d zt2j4 j1||}|j9|}|j;d j9|}||t+d |t=||fDcgc]}|| c}j?t,j@d}tB||| ycc}w)NFTrr_rrrznHyperbolicCenterArc limit arc_size can't be used with deprecated 'end_angle' or 'angular_direction' parametersrrrz0HyperbolicCenterArc doesn't intersect arc limit r/)#rr1rrrrrrr#rrrrrr!rr2rr$rerfrr'make_hyperbolarrrrrrr,rrr@rA)rCrrrrrrrrr0r6rrrCrhyperbola_workplanerrr5rrrrDs r7rAzHyperbolicCenterArc.__init__s%.$:$:4$@&$  #' E MM+"    (#' )I MMG"  #++F3 ?"'(( "-"2"2**,77:# &0".557J7P7PQ )3Hh)GVH%X j3,7 D ''!!)'"+ f[(+  S%L 1*,E?!22%//  ''!!)'"+ f[(+ ''!!)'%-"2"D"D f[(+ "// ;M"^^^=KKJWN$)? FxjQ*N;Mqq}Mgdkk"1&E T*Ns JJr)rr%rrfrrfrrfrrKrrrrfrrr0rrFrOs@r7rrs6>>"K!"& g+JN59XXg+g+g+ g+  g+  g+Gg+g+3g+g+g+r9rc|eZdZdZej gZddddejf dfd Z xZ S)HelixaALine Object: Helix Create a helix defined by pitch, height, and radius. The helix may have a taper defined by cone_angle. If cone_angle is not 0, radius is the initial helix radius at center. cone_angle > 0 increases the final radius. cone_angle < 0 decreases the final radius. Args: pitch (float): distance between loops height (float): helix height radius (float): helix radius center (VectorLike, optional): center point. Defaults to (0, 0, 0) direction (VectorLike, optional): direction of central axis. Defaults to (0, 0, 1) cone_angle (float, optional): conical angle from direction. Defaults to 0 lefthand (bool, optional): left handed helix. Defaults to False mode (Mode, optional): combination mode. Defaults to Mode.ADD r)rrr\rFc tj|} t| |tj|} t j |||| |||} t |!| |y)Nr/) rr1rrrr' make_helixr@rA) rCpitchheightrrrC cone_anglelefthandr0r6rhelixrDs r7rAzHelix.__init__ps`%.$:$:4$@&"++F3  66:y*h  T*r9)rrfrrfrrfrr%rCr%rrfrrr0rrFrOs@r7rrYs(>>"K' )XX+++ +  +  +++++r9rcheZdZdZej gZdejd dfdZ xZ S)FilletPolylineaLine Object: Fillet Polyline Create a sequence of straight lines defined by successive points that are filleted to a given radius. Args: pts (VectorLike | Iterable[VectorLike]): sequence of two or more points radius (float | Iterable[float]): radius to fillet at each vertex or a single value for all vertices. A radius of 0 will create a sharp corner (vertex without fillet). close (bool, optional): close end points with extra Edge and corner fillets. Defaults to False mode (Mode, optional): combination mode. Defaults to Mode.ADD Raises: ValueError: Two or more points not provided ValueError: radius must be non-negative Fcloser0c  tj|}t||t|}t |dt |dz j t krd}|jdt|dkr tdt|ttfr|gt|z}nft|}t|t|t| dzz k7r4tdt|dt|t| dzz d|D]}|dks td |d tj|} t!t| d z D cgc]!} t#j$| | | | d z#} } |rO| ddz| dd zz j d kDr1| j't#j$| dd z| ddzt)| } g} | D]m}| j+Dcic]!}|t |t |z j #}}| j't-|j/d ddo| Dcic]4}|| j1Dcgc]}||j+vs|c}6}}}g}t3|j/D]\} \}}t|dk7r|| t| z }|dk(r|j'dA|Dchc]}|j+D] }||k7s | !}}}t#j$|}t5t)||gzj7||g}|j'|j1j9t:j<d|rqg}t!t|D]U} || d z }|| }| d z }| }|| |} n|d z} || |}!n|dz}!|j't#j$| |!Wg}"ng}t!t|d z D][} || d z}#|| }| }| d z}$| | |d z} n|d z} |# | |$d z}!n|#dz}!|j't#j$| |!]|dt#j$| dz| d }%nt#j$| dz|ddz}%|dt#j$| d| d z}&nt#j$|dd z| d z}&|%|&g}"|D'cgc]}'|'|' }(}'t)|"|z|(z})t>*||)|ycc} wcc}wcc}wcc}}wcc}}wcc}'w)NrruTr_z'FilletPolyline requires two or more ptszradius list length (z) must match angle count ()zradius z must be non-negativer\h㈵>c |dS)Nr\r)rs r7rz)FilletPolyline.__init__..s 1Q4r9rr/)!rr1rrr$rr r/rrr2rerfrrrranger'rrlr*rsorteditemsr4rr( fillet_2d filter_byrCIRCLEr@rA)+rCrrr0ptsr6points radius_listr lines_ptsr new_edges wire_of_linesordered_verticespntsrdistanceevertex_to_edgesfilletsrr4current_radiusveother_vertices third_edge fillet_faceinterior_edges prev_fillet curr_filletprev_idxcurr_idxstart_ptend_pt end_edges next_filletnext_idx start_edgeend_edgefactual_filletsnew_wirerDs+ r7rAzFilletPolyline.__init__s%.$:$:4$@&!3' 6!9 vbz 2 2 : :Y FE JJrN v;?FG G fsEl +!(S[0Kv,K;3v;Y!1C#CC K()*F ce)nq&889<  EA1u 71#-B!CDD E"**F3 3y>A-.  NN9Q<1q5)9 :  ilQ&2)::BBTI   T^^IbMA,=y|a?OP QY *, XD?L?U?U?W:;F4L61:-555H  # #F8>>+;$PQR$STU$V W  X&  =..0FaA4EF F  &("+O,A,A,C"D R A5zQ(SU^);HH"VH {002<x.HF(1_F%%dnnXv&FG H"I N3w>*:2*> PQ@QR>>'"+/=1;LM#X.I&-> !>> N2^CD -[ G $"D?sB&T94&T>U,UUU1UUUUU)r!VectorLike | Iterable[VectorLike]rzfloat | Iterable[float]rrr0rrFrOs@r7rrsX(>>"K XX U./U.(U. U.  U.U.r9rcheZdZdZej gZejf dfd Z xZ S)JernArcaLine Object: Jern Arc Create a circular arc defined by a start point/tangent pair, radius and arc size or arc limit. Args: start (VectorLike): start point tangent (VectorLike): tangent at start point radius (float): arc radius arc_size (float | Shape | Axis | Location | Plane | VectorLike): angular size of arc (negative to change direction) or an arc limit. When a limit object is provided instead of a numeric angular size, JernArc constructs the valid tangent arc(s) from the given start point and tangent, trims them at their first intersection with the limit, and returns the one requiring the shortest travel from the start. If neither valid arc intersects the limit, a ValueError is raised. mode (Mode, optional): combination mode. Defaults to Mode.ADD Attributes: start (Vector): start point end_of_arc (Vector): end point of arc center_point (Vector): center of arc c@tj|}t||tj|}||_|t j}n4tjtjjd}||_ t|trCt|dk(r5t|j!|j"dj%}nt|j%}t|t&r t|n|} t| t(t*frt-d| } | } nd} d} ||j/t1||j2| dzt5|zz} | || z j/t1||j2| z} t5| dk\rtj|}| |_ |j |jz |_t9j:||}||j/t1||j2| dzt5|zz}tj|}||_ |j |jz |_t9j:||}|j=dj?|dkr*|jAd }nt9jB||| }t| t(t*fst|jE| }jE| }||tGd |tI||fDcgc]}|| c}jKt8jL}|d}|jN|_(|jSd|_*tV||| ycc}w) Nrr_Trrr\hrWrz$JernArc doesn't intersect arc limit r/)-rr1rrrstartr#rrrrrr2rrr$rrrdrrerfr rr!rrQrr'rrjrrmake_tangent_arcrrr,rrryrr end_of_arcr@rA)rCrrarrr0r6jern_workplanerrr arc_untrimed_sizerr r r  center_point2 circle_plane2rrrrrrDs r7rAzJernArc.__init__OsA%.$:$:4$@&&&u- ?"XXN(--**,77:N!& gu %#g,!*;w>;;$O  #7O668M)3Hh)GVH%X j3, /$S*5M * M # }33 ,, -}r/A K  "U\%9$A$A ,, -/@%    !S (&++N;L".L !%l.A.A!AL ""6<8C!M$8$8UN001M>B3F%F %M(,,^>"KXX M)M)M) M) G M)  M)M)r9rcXeZdZdZej gZejddfdZ xZ S)raLine Object: Line Create a straight line defined by two points. Args: pts (VectorLike | Iterable[VectorLike]): sequence of two points mode (Mode, optional): combination mode. Defaults to Mode.ADD Raises: ValueError: Two point not provided r/cBt|}t|dk7r tdtj|}t ||t j|}|Dcgc] }t|}}tj|d|d}t |1||ycc}w)Nr_zLine requires two ptsrr\r/) rrrrr1rrrr$r'rr@rA) rCr0rrr6points_localizedrlrnew_edgerDs r7rAz Line.__init__s!3' v;! 45 5$-$:$:4$@&(116:(891VAY9 9>>)A, ! = -:sBrrr0rrFrOs@r7rrs' >>"KMQXX . .r9rcdeZdZdZej gZejf dfd Z xZ S)IntersectingLinea`Intersecting Line Object: Line Create a straight line defined by a point/direction pair and another line to intersect. Args: start (VectorLike): start point direction (VectorLike): direction to make line other (Edge): line object to intersect mode (Mode, optional): combination mode. Defaults to Mode.ADD ctj|}t||tj|}tj|j }t ||}|jDcgc]}|j|D]}|} }}| s td| D cgc]} || z j} } t| } tj|||| zz} t|=| |ycc}}wcc} w)NzNo intersections foundr/)rr1rrrrdr!r4find_intersection_pointsrrrr'rr@rA)rCrrCrUr0r6axisrorintersection_pntsrl distancesrrrDs r7rAzIntersectingLine.__init__s%.$:$:4$@&&&u-!**95@@B E9% ++- 1N1Nt1T ,-A   !56 61BCAeai''C CY>>%V1C)CD - Ds :C>-D)rr%rCr%rUrr0rrFrOs@r7rrsO >>"KXX ...# .  ..r9rceZdZdZej gZddeje jf dfd Z xZ S) PolarLineafLine Object: Polar Line Create a straight line defined by a start point, length, and angle. The length can specify the DIAGONAL, HORIZONTAL, or VERTICAL component of the triangle defined by the angle. Alternatively, the length parameter can contain a limit to the length of the line in the form of another object. If the PolarLine doesn't contact the limit an error will be generated. Example: p = PolarLine(start=(2, 0), length=Axis.Y, angle=135) Args: start (VectorLike): start point length (float | Shape | Axis | Location | Plane | VectorLike): line length (float) or limit limit angle (float, optional): angle from the local x-axis direction (VectorLike, optional): vector direction to determine angle length_mode (LengthMode, optional): how length defines the line. Defaults to LengthMode.DIAGONAL mode (Mode, optional): combination mode. Defaults to Mode.ADD Raises: ValueError: Either angle or direction must be provided ValueError: Polar line doesn't intersect length limit Nc tj|}t||tj|}|t j }n4tjtjjd}|@tj|j} tdddj| }n>|1|jjtd|j |} n t#dt%|t&r t|n|} | xxt(dx\nxt*dx\nn|t,j.k(r| | z} nZ|t,j0k(r$| t3| t5t7|z z} n#| t3| t9t7|z z} t;j<||| z} nxt>dxl\| jAjC|jD} t;j<||| | zz}|jG| }|t#d||} nxtdx\n-xt dx\nxtHdx\nxtdx\nnnt|| }|jK| }t%|tr2||z jM| tNkDrt;j<||} nt#d|tP| |y)Nrr\rz*Either angle or direction must be providedrz*Polar line doesn't intersect length limit r/)*rr1rrrr#rrrrrdr$ get_anglerrr!rrr2rrfrerDIAGONAL HORIZONTALrQr r r r'rr+rfrgrhrr" intersectrr r@rA)rCrrrBrC length_moder0r6polar_workplanedirection_localized length_factor length_vectorr max_length long_edge trimmed_edge polar_axiscontactrDs r7rAzPolarLine.__init__s%.$:$:4$@&&&u- ?#hhO)..**,77:O  "/"8"8"C"N"N"P 1aO--.ABE  "1"7"7">">Y 5 56#  IJ J*4VX*FvF  535*"5"55$7-$GM J$9$99$7#%GEN(;;;%M%8#%GEN(;;;%M >>%1FG*779==eDMM  NN5#6#CC  )66}E '$DVHM('%'JHJ9!%)<= $..}=w/ 5--.ABYN#~~eW=H$DVHM -r9) rr%rrrBrKrCrLr!rr0r) rGrHrIrJrrKrLrrrrMrArNrOs@r7rrs{<>>"K #'+","5"5XXF.F.EF. F. % F.  F.F.F.r9rcdeZdZdZej gZdejd dfdZ xZ S)PolylineaLine Object: Polyline Create a sequence of straight lines defined by successive points. Args: pts (VectorLike | Iterable[VectorLike]): sequence of two or more points close (bool, optional): close by generating an extra Edge. Defaults to False mode (Mode, optional): combination mode. Defaults to Mode.ADD Raises: ValueError: Two or more points not provided Frc *tj|}t||t|}t |dkr t dt j|}tt |dz Dcgc]!}tj||||dz#}}|rO|ddz|ddzz jdkDr1|jtj|ddz|ddzt |9tj |d|ycc}w)Nr_z!Polyline requires two or more ptsr\rrurr/)rr1rrrrrrrr'rrrlr@rAr*combine) rCrr0rr6rrrrrDs r7rAzPolyline.__init__as %.$:$:4$@&!3' v;?@A A!**F3 3y>A-.  NN9Q<1q5)9 :   ilQ&2)::BBTI   T^^IbMA,=y|a?OP Q i03$? s/&D)rrrrr0rrFrOs@r7r,r,QsM >>"K XX @/@@ @@r9r,cjeZdZdZej gZdejf dfd Z xZ S) RadiusArcaLine Object: Radius Arc Create a circular arc defined by two points and a radius. Args: start_point (VectorLike): start point end_point (VectorLike): end point radius (float): arc radius short_sagitta (bool): If True selects the short sagitta (height of arc from chord), else the long sagitta crossing the center. Defaults to True mode (Mode, optional): combination mode. Defaults to Mode.ADD Raises: ValueError: Insufficient radius to connect end points Tcbtj|}t||tj||\}}|j |j dz } |r!t|t|dz| dzz z } n!t| t|dz| dzz z } |dkDrt||| tj} nt||| tj} | j} t| tsJt |E| |y#t$r} td| d} ~ wwxYw)Ng@r_z6Arc radius is not large enough to reach the end point.rr/)rr1rrrsubrrQrr SagittaArcrPRIVATEror2r'r@rA)rC start_point end_pointr short_sagittar0r6rendrr exceptionr arc_edgerDs r7rAzRadiusArc.__init__s%.$:$:4$@&"++KC s&&, f+VQY-B(CCv;,fai&!).C)DD A:UCt||DCUC' EC88:(D))) - H  sAD D. D))D.) r5r%r6r%rrfr7rr0rrFrOs@r7r0r0zs\ >>"K#XX . . . .  .  . .r9r0cdeZdZdZej gZejf dfd Z xZ S)r3aeLine Object: Sagitta Arc Create a circular arc defined by two points and the sagitta (height of the arc from chord). Args: start_point (VectorLike): start point end_point (VectorLike): end point sagitta (float): arc height from chord between points mode (Mode, optional): combination mode. Defaults to Mode.ADD cntj|}t||tj||\}}||zdz}|t j } n4tjtjjd} ||z jt|z} | jt| j| j|dkDrdnd} || z} t!|| |t"j$} | j'} t)| t*sJt,|]| |y)Ng?rrWrXr/)rr1rrrr#rrrrrdrQrr!rr ThreePointArcrr4ror2r'r@rA)rCr5r6rr0r6rr8 mid_pointsagitta_workplanesagitta_vector sag_pointr r:rDs r7rAzSagittaArc.__init__s%.$:$:4$@&"++KC s5[C' ? %  + 0 0**,77:! #&+!9!9!;c'l!J'.. "))+<+B+B CA+B3  . E9c E88:(D))) -r9)r5r%r6r%rrfr0rrFrOs@r7r3r3sO >>"KXX ... .  ..r9r3cpeZdZdZej gZdddejd dfdZ xZ S)SplineaLine Object: Spline Create a spline defined by a sequence of points, optionally constrained by tangents. Tangents and tangent scalars must have length of 2 for only the end points or a length of the number of points. Args: pts (VectorLike | Iterable[VectorLike]): sequence of two or more points tangents (Iterable[VectorLike], optional): tangent directions. Defaults to None tangent_scalars (Iterable[float], optional): tangent scales. Defaults to None periodic (bool, optional): make the spline periodic (closed). Defaults to False mode (Mode, optional): combination mode. Defaults to Mode.ADD NF)tangentsrrvr0c t|}tj|}t||t j |}|r1|D cgc]%} t j | j '} } nd} ||dgtt|z} n| t|ng} tj|D cgc]} t| tr| nt| c} | r=t| | D cgc]%\} }t| tr| |zn t| |z'c}} nd||du}t|=||ycc} wcc} wcc}} w)Nr)rDrvscaler/)rrr1rrrrdrrr'rr2r$r}r@rA)rCrDrrvr0rrr6 spline_ptsraspline_tangentsscalarsrlrmrhrrDs r7rAzSpline.__init__sI"3'$-$:$:4$@&"++V4 LTAH &&w/::<O#O  O$;ec$x.11G/>/Jd?+PRG!!AK LA*Q'QVQZ 7 L #!$OW =1(62AE QF !T)   d+1 Ms*D01!D5%*D: ) rrrDzIterable[VectorLike] | Nonerrrvrr0rrFrOs@r7rCrCsb >>"K 1526XX ',/',.',0 ',  ',  ',',r9rCcheZdZdZej gZdejd dfdZ xZ S)rnaLine Object: Tangent Arc Create a circular arc defined by two points and a tangent. Args: pts (VectorLike | Iterable[VectorLike]): sequence of two points tangent (VectorLike): tangent to constrain arc tangent_from_first (bool, optional): apply tangent to first point. Applying tangent to end point will flip the orientation of the arc. Defaults to True mode (Mode, optional): combination mode. Defaults to Mode.ADD Raises: ValueError: Two points are required T)tangent_from_firstr0cht|}tj|}t||t |dk7r t dt j|}t j|j}|rdnd} tj|| d||| d} t |1| |y)Nr_ztangent_arc requires two points)rru)rurrr\r/) rrr1rrrrrrdr'rr@rA) rCrarKr0rrr6arc_ptsrr point_indicesr rDs r7rAzTangentArc.__init__+ s"3'$-$:$:4$@& v;! >? ?((&1#,,W5@@B #57 ## M!$ %{GM!>"K $(XX )/))! )  ))r9rncXeZdZdZej gZejddfdZ xZ S)r=a/Line Object: Three Point Arc Create a circular arc defined by three points. Args: pts (VectorLike | Iterable[VectorLike]): sequence of three points mode (Mode, optional): combination mode. Defaults to Mode.ADD Raises: ValueError: Three points must be provided r/ctj|}t||t|}t |dk7r t dt j|}tj|}t|-||y)Nrsz#ThreePointArc requires three pointsr/) rr1rrrrrrr'make_three_point_arcr@rA)rCr0rr6rrr rDs r7rAzThreePointArc.__init__R ss$-$:$:4$@&!3' v;! BC C(116:'')9: 4(r9rrFrOs@r7r=r=C s' >>"KMQXX ) )r9r=zuThe 'PointArcTangentLine' object is deprecated and will be removed in a future version. Use ConstrainedLines instead.czeZdZdZej gZeje jf dfd Z xZ S)PointArcTangentLineaLine Object: Point Arc Tangent Line Create a straight, tangent line from a point to a circular arc. Args: point (VectorLike): intersection point for tangent arc (Curve | Edge | Wire): circular arc to tangent, must be GeomType.CIRCLE side (Side, optional): side of arcs to place tangent arc center, LEFT or RIGHT. Defaults to Side.LEFT mode (Mode, optional): combination mode. Defaults to Mode.ADD c `tjdtjdi}tj|}t |||j tjk7r tdtj|}|btj||jj|}| tdt!|j"|j%} n4t'j(tjj*d} |j} |j,} || z } | j.| kr td| j1| j2} t5| j.dz| dzz }tj| |fj1| j2}|||z| z}tj| t7t9|z| t;t9|zf| z}tj||}t<|}||y) Nrur\zArc must have GeomType.CIRCLE.z1PointArcTangentLine only works on a single plane.r_rz/Cannot find tangent for point on or inside arc.r_) rLEFTRIGHTrr1r geom_typerrrrrr'rryrer#rnormalrrrrrget_signed_anglerrr r r r@rA)rCpointr sider0 side_signr6 tangent_pointcoplanersryrmidlinephi other_legrrBr rarDs r7rAzPointArcTangentLine.__init__r s IIr JJ %.$:$:4$@& ==HOO +=> >%..u5 ?nn]CNNCPPQTUG !TUUgnnCJJLAI#(()C)C)E)P)PQR)STI^^ *, >>V #NO O &&y7*VQY67 && ':;LL OO $%'#-  " "#gen--vGEN8K/KL   .. : $'r9)rZr%r rr[rr0r rGrHrIrJrrKrLrrUrrMrArNrOs@r7rSrS_ sV >>"K YYXX 6(6(!6( 6(  6(6(r9rSzsThe 'PointArcTangentArc' object is deprecated and will be removed in a future version. Use ConstrainedArcs instead.c~eZdZdZej gZeje jf dfd Z xZ S)PointArcTangentArcaLine Object: Point Arc Tangent Arc Create an arc defined by a point/tangent pair and another line which the other end is tangent to. Args: point (VectorLike): starting point of tangent arc direction (VectorLike): direction at starting point of tangent arc arc (Union[Curve, Edge, Wire]): ending arc, must be GeomType.CIRCLE side (Side, optional): select which arc to keep Defaults to Side.LEFT mode (Mode, optional): combination mode. Defaults to Mode.ADD Raises: ValueError: Arc must have GeomType.CIRCLE ValueError: Point is already tangent to arc RuntimeError: No tangent arc found ctj|}t||jtj k7r t dtj|tj|j}|[tj|zj}| t dt|jj} n4t!j"tjj$d} t'|j)| j*dj} j,z } | j.j0k(r t d| j.j0kr t3d| j5| j6} j,z j9| } | | zj,z}|z j9| }|t:j<k(rd nd }||zj0k(r t d |dkrd nd }t?|j0krd }|d z}| d kDr| }n|d z}||j<k(r| }n|}d jAjCjDz}dfd }tG| j| j6}| jI||}tK|d||fdd|fgtL}|jNd}||zz}||k(r tQdj,|z j}||j5| j6z}||z|z}t?j0|j,z j.z tLkDr tQdjS|}|j5|j.tLkDr tQdtU|| tV ||y)NzArc must have GeomType.CIRCLEz0PointArcTangentArc only works on a single plane.r_rTrz%Cannot find tangent for point on arc.z%Point inside arc not yet implemented.rur\z2Point is already tangent to arc, use tangent line.rXic||dzz}j|z jjz }|dk(rt||z }|S|dk(rt||z jdzz}S)Nrr\rur_)ryrrrQ)rrR minimize_typerrStargetr  arc_points r7rVz)PointArcTangentArc.__init__..func s}!7&)!CCF..6199CJJFJ!Z&01M"$Z&03::>ABMr9rYrqrZz0Arc radius very large. Can tangent line be used?z-No tangent arc found, no tangent point found.z5No tangent arc found, found tangent out of tolerance.r`r/)rgzLiteral[-1, 1])-rr1rrWrrrrrrdr'rrer#rrXrrrr$rrryrrNotImplementedErrorrrrrrUrQrfrgrhr!rrr rrmrjrnr@rA)!rCrZrCr r[r0r6 wp_tangentr^rsrrr_ tangent_perp ref_scaleref ref_to_point keep_signr\arc_typerBrurVrtrRrwtangent_radiustangent_centertangent_normal tangent_dirr]arc_dirrirDs! ` @r7rAzPointArcTangentArc.__init__ s%.$:$:4$@& ==HOO +<= =!**51 "++I6AAC ?nnY J0FGTTG !STTgnnCJJLAI#(()C)C)E)P)PQR)STI 9  Yy22Y F Z\  cnn, >>SZZ 'DE E >>SZZ '%&MN N #((9 ^^i/44k\B +%6!C,,\: $))+B | #szz 1QR R &)Ar | szz )HOE1}OEtyy %:$#**,00;DDD Y--y? !,!3!3M5!I ((3 (O$   !"%;n%LL X %QR R..>9EEG!5!5ioo!FF &7.H  szz]S^^;CCC Dy PNO O../   W % , ,y 8VW WM;G 4(r9) rZr%rCr%r rr[rr0rrbrOs@r7rdrd sg $>>"KYYXX |)|)|)! |)  |)  |)|)r9rdzsThe 'ArcArcTangentLine' object is deprecated and will be removed in a future version. Use ConstrainedLines instead.ceZdZdZej gZeje je jf dfd Z xZS)ArcArcTangentLineaLine Object: Arc Arc Tangent Line Create a straight line tangent to two arcs. Args: start_arc (Curve | Edge | Wire): starting arc, must be GeomType.CIRCLE end_arc (Curve | Edge | Wire): ending arc, must be GeomType.CIRCLE side (Side): side of arcs to place tangent arc center, LEFT or RIGHT. Defaults to Side.LEFT keep (Keep): which tangent arc to keep, INSIDE or OUTSIDE. Defaults to Keep.INSIDE mode (Mode, optional): combination mode. Defaults to Mode.ADD c ^tj|}t|||jtj k7r t d|jtj k7r t d|D|j|}| t dt|j|j}n4tjtjjd}|tj k(rdnd} ||g} | D cgc]} | j"} } | D cgc]} | j$} } | d| dz }|j&t)| d| dz kr t d|t*j,k(rF|j&t/| kr t d |j&t/| k(r t d |j1|j2}|t*j,k(r | d| dzn | d| dz }t5|j&d z|d zz }tj6||fj1|j2}| |z|z}g}t9t;| D]{}|t*j,k(r|d z|zn|}|j=tj6| |t?tA|z| |tCtA|zf| |z}tEjF|d|d}tH|||ycc} wcc} w) N$Start arc must have GeomType.CIRCLE."End arc must have GeomType.CIRCLE.z/ArcArcTangentLine only works on a single plane.r_rr\ruz4Cannot find tangent when one arc contains the other.z0Cannot find INSIDE tangent for overlapping arcs.z,Cannot find INSIDE tangent for tangent arcs.r_)&rr1rrWrrrrer#rrXrrrrrrUryrrrQrINSIDEsumrYrrrrrrlr r r r'rr@rA)rC start_arcend_arcr[rqr0r6r^rsr\rr rradiir_r`rrarrBr rrarDs r7rAzArcArcTangentLine.__init__X s%.$:$:4$@&   (// 1CD D    /AB B ?,,W5G !RSSgnnI4D4D4FGI#(()C)C)E)P)PQR)STI*A 7#,01S#..11'+,,,)fQi' >>SqE!H!45 5ST T 4;; ~~E * !STT~~U+ !OPP&&y7(, (;qE!H$qERSHAT*VQY67 && ':;LL OO E!C' s4y! A'+t{{':AGeOE   &&1XGEN 33U1XGEN@S5ST)  ..1y|< $'S2,s L%%L*) rrrrr[rrqrr0rrGrHrIrJrrKrLrrUrr}rrMrArNrOs@r7rxrxC sn >>"K YY[[XX F(&F(%F( F(  F(  F(F(r9rxzqThe 'ArcArcTangentArc' object is deprecated and will be removed in a future version. Use ConstrainedArcs instead.ceZdZdZej gZeje je jfde jf dfd Z xZS)ArcArcTangentArca.Line Object: Arc Arc Tangent Arc Create an arc tangent to two arcs and a radius. keep specifies tangent arc position with a Keep pair: (placement, type) - placement: start_arc is tangent INSIDE or OUTSIDE the tangent arc. BOTH is a special case for overlapping arcs with type INSIDE - type: tangent arc is INSIDE or OUTSIDE start_arc and end_arc Args: start_arc (Curve | Edge | Wire): starting arc, must be GeomType.CIRCLE end_arc (Curve | Edge | Wire): ending arc, must be GeomType.CIRCLE radius (float): radius of tangent arc side (Side): side of arcs to place tangent arc center, LEFT or RIGHT. Defaults to Side.LEFT keep (Keep | tuple[Keep, Keep]): which tangent arc to keep, INSIDE or OUTSIDE. Defaults to (Keep.INSIDE, Keep.INSIDE) short_sagitta (bool): If True selects the short sagitta (height of arc from chord), else the long sagitta crossing the center. Defaults to True mode (Mode, optional): combination mode. Defaults to Mode.ADD Tct|tr||fn|\}} tj|} t | ||tj k(r| tj k7r td|jtjk7r td|jtjk7r td| D|j|} | tdt| j|j} n4tj t#jj$d} ||g} | Dcgc]}|j&}}| Dcgc]}|j(}}|t*j,k(rdnd}|tj.k(rdnd}|d|dkrdnd}|d|dz }||j1| j2z}|j4t6kr td t9|j4t;|z t6kr| tj k(r td t9|j4t9|d|dz z t6kr|tj k(r td d }d}ddg}d}|j4t9|d|dz kDrV| tj.k(rC||dz|z||dz|zg}||g}|j4||d|dzzz d z }|dkrdn|}n|j4|d|dzkDrv| tj k(rct9|d||zzt9|d||zz g}|tj.k(rddgnddg}|j4||d|dz zz d z }n|j4t9|d|dz krd}|tj.k(r[|d||zz|d||zz g}|j4 ||dzz ||dzzd z }|j4||dzz ||dzzd z }nk|tj k(rWt9|d|z t9|d|z g}|j4 |dz|dzd z }|j4|dz|dzd z }|d|dkrddg}nddg}nd}|tj k(r?t9|d|z t9|d|z g}|j4 |dz|dzd z }n|tj.k(r8|d||zz|d||zz g}|j4||dzz ||dzzd z }nJ|tj k(r7|d||zz |d||zzg}|j4||dzz||dzz d z }||k\rtd|d|||krtd|d|Dcgc]}| j=|}}t?tA| Dcgc]I}tCjDtCjF||jH||jJ|K}}tMtCjN|Dcgc]i}| jQtStUtCjV|jXtUtCjV|jZkc}}|j]t_|d||} t?tA| Dcgc]3}||||||ztS| ||z jazz5}!}|t*j,k(r|!jcte|!d|!d||tfjh}tk|j&|j(ddtfjh}"|"jm|\}#}#}$|"jo|$j1|jo|$j4t6kDr%te|!d|!d| |tfjh}tp%|||ycc}wcc}wcc}wcc}wcc}wcc}w)NzEKeep.BOTH can only be used in configuration: (Keep.BOTH, Keep.INSIDE)rzr{z.ArcArcTangentArc only works on a single plane.r_rr\ruz(Cannot find tangent for concentric arcs.zNCannot find tangent type Keep.INSIDE for non-overlapping arcs already tangent.zZCannot find tangent placement Keep.INSIDE for completely overlapping arcs already tangent.rqr_z4The arc radius is too small. Should be greater than r[z1The arc radius is too large. Should be less than )rr7r0rr/):r2rrr1rBOTHr}rrWrrrer#rrXrrrrryrrrUOUTSIDErrrr rQr~to_local_coordsrrsympyCirclePointXYr, intersectionfrom_local_coordsr$rfNrrrr!rdreverser0rr4rrirjr@rA)&rCrrrr[rqr7r0keep_placement keep_typer6r^rsrr rrr\rpr_signr_rX min_radius max_radiusx_sign pick_index ref_radiirllocalr ref_circlesref_intersectionsryr  start_circlerrZrDs& r7rAzArcArcTangentArc.__init__ s5?tT4JT4LPT! $-$:$:4$@& TYY &9 +CW    (// 1CD D    /AB B ?,,W5G !QRRgnnI4D4D4FGI#(()C)C)E)P)PQR)STI7#,01S#..11'+,,,*A '4<<7AR Ahq)r)fQi'W]]9??;; >>I %GH H w~~E * +i 7I>Ca58 34 4dll9R"U1X-6 E!H8Lv8UVI+F!..9a588K+LLPQQJ(1n*J ^^eAhq1 1i4;;6NE!Hy6112E!Hy6112I!/$,, >aWRGF!..9a588K+LLPQQJ ^^s58eAh#67 7J-"1X7qFVO9ST ^^OfuQx&77&58:KK NNVeAh%66%(9JJ  4;;. qF!23SqF9J5KL &~~oa858CqH %nnuQx7%(BaG 8eAh& !WFWFJ* qF!23SqF9J5KL &~~oa858CqH 4<</"1X7qFVO9ST NNVeAh%66%(9JJ  4;;."1X7qFVO9ST NNVeAh%66%(9JJ   FzlRST   !jF&:CJ>!**1->>3t9%  LLU1XZZq>"KYY*.++t{{)C"XXI$&I$%I$ I$  I$ ' I$I$I$I$r9r)r5zEdge | Wire | Curver0r)^rJ __future__rrrrcollections.abcrrr itertoolsrmathrr r r r r rtypingrrnumpyrwrscipy.optimizertyping_extensionsrbuild123d.build_commonrrrbuild123d.build_enumsrrrrrrrrrbuild123d.build_linerbuild123d.geometryr r!r"r#r$r%build123d.topologyr&r'r(r)r*build123d.topology.shape_corer+r,r8r;rQrTrWrrrrrr8rNrrrrrrrrrrr,r0r3rCrnr=rSrdrxrrr9r7rs|8#88BBB$ #(SS   +SS>>: ? ,e,",T," (T ( x5nx5v+^+>`3`3F:,n:,zV)V)rA+oA+HU+U+pe1~e1PC+.C+Ln)n)bA+A+HE+.E+P)+N)+Xl.^l.^h)nh)V.>.>&.~&.Rg.g.T&@~&@R3.3.l+.+.\8,^8,v')')T)N)8 %E(.E( E(P $Q)Q) Q)h %W(W( W(t $c$~c$ c$r9