ha%SSKJr SSKJrJrJrJrJrJrJ r J r SSK J r SSK Jr SSKrSSKrSSKrSSKrSSKJrJrJrJrJrJr SSKJr SSKJrJrJrJ r J!r! \(aSS K"J#r# S r$\"\RJ\RJ5r&S r'S r("S S\RR5r*"SS\+5r,"SS\,5r-"SS\,5r.\R^"SS9"SS55r0\R^"SS9"SS55r1S2S3Sjjr2\R^"SS9"SS55r3"SS5r4"S S!5r5S4S"jr6S5S#jr7S6S7S$jjr8S8S%jr9S9S&jr:S6S:S'jjr;\\5\/\\ \1\<44r=S(\>S)'S6S;S*jjr?SS,jjrAS?S@S-jjrBS.rC\$4S/S0.SAS1jjjrDg)B) annotations)IteratorSequence TYPE_CHECKINGCallableAnyUnionOptionalTuple) TypeAlias) defaultdictN)Vec2Vec3Bezier3PBezier4P intersection_ray_cubic_bezier_2dquadratic_to_cubic_bezier)const)PathLineToMoveToCurve3ToCurve4To) DXFPolygong-C6? c(\rSrSrSrSrSrSrSrSr g) IntersectionType(rrN) __name__ __module__ __qualname____firstlineno__NONEREGULARSTARTEND COLLINEAR__static_attributes__r#G/var/www/html/env/lib/python3.13/site-packages/ezdxf/render/hatching.pyrr(s DG E CIr.rc\rSrSrSrSrg) HatchingError0z3Base exception class of the :mod:`hatching` module.r#Nr$r%r&r'__doc__r-r#r.r/r1r10=r.r1c\rSrSrSrSrg)HatchLineDirectionError6z3Hatching direction is undefined or a (0, 0) vector.r#Nr3r#r.r/r7r76r5r.r7c\rSrSrSrSrg)DenseHatchingLinesError<zCVery small hatching distance which creates too many hatching lines.r#Nr3r#r.r/r:r:<sMr.r:T)frozenc4\rSrSr%S\S'S\S'S\S'Srg) LineBrstartendfloatdistancer#N)r$r%r&r'__annotations__r-r#r.r/r>r>Bs K IOr.r>cX\rSrSr%Sr\R rS\S'\ r S\S'\ r S\S'Sr g ) IntersectionIzRepresents an intersection.rtyperp0p1r#N) r$r%r&r'r4rr(rHrD NONE_VEC2rIrJr-r#r.r/rFrFIs*%-22D 2BBr.rFc2[U5U:agUS:agg)Nrr )abs)rCabs_tols r/ side_of_linerQRs 8}w#~ r.c`\rSrSr%SrS\S'S\S'S\S'S SjrS S jrS rg ) HatchLineZaRepresents a single hatch line. Args: origin: the origin of the hatch line as :class:`~ezdxf.math.Vec2` instance direction: the hatch line direction as :class:`~ezdxf.math.Vec2` instance, must not (0, 0) distance: the normal distance to the base hatch line as float rorigin directionrBrCcURn[X5- 5n[XE- 5nUS:Xa:US:Xa[[RX5$[[R U5$US:Xa[[R U5$Xg:wa;[X5- X4- - 5n[[RURX(55$[5$)aReturns the :class:`Intersection` of this hatch line and the line defined by the points `a` and `b`. The arguments `dist_a` and `dist_b` are the signed normal distances of the points `a` and `b` from the hatch baseline. The normal distances from the baseline are easy to calculate by the :meth:`HatchBaseLine.signed_distance` method and allow a fast intersection calculation by a simple point interpolation. Args: a: start point of the line as :class:`~ezdxf.math.Vec2` instance b: end point of the line as :class:`~ezdxf.math.Vec2` instance dist_a: normal distance of point `a` to the hatch baseline as float dist_b: normal distance of point `b` to the hatch baseline as float r) rCrQrFrr,r*r+rOr)lerp) selfabdist_adist_b line_distanceside_aside_bfactors r/intersect_lineHatchLine.intersect_lineis. f45f45 Q;{#$4$>$>EE#$4$:$:A>> q[ 0 4 4a8 8  &0V_EFF 0 8 8!&&:KL L~r.c[URURUR-U5Vs/sH"n[[R U[ 5PM$ sn$s snf)uReturns 0 to 3 :class:`Intersection` points of this hatch line with a cubic Bèzier curve. Args: curve: the cubic Bèzier curve as :class:`ezdxf.math.Bezier4P` instance )rrUrVrFrr)rK)rYcurveps r/intersect_cubic_bezier_curve&HatchLine.intersect_cubic_bezier_curvesZ6 T[[4>>95  )111i @   s)Ar#N) rZrr[rr\rBr]rBreturnrF)rerrizSequence[Intersection]) r$r%r&r'r4rDrbrgr-r#r.r/rSrSZsS LOO$ $ $ $  $  $L  r.rScZ\rSrSrSrS SjrS SjrS SjrS SjrSSjr Sr g )PatternRenderera The hatch pattern of a DXF entity has one or more :class:`HatchBaseLine` instances with an origin, direction, offset and line pattern. The :class:`PatternRenderer` for a certain distance from the baseline has to be acquired from the :class:`HatchBaseLine` by the :meth:`~HatchBaseLine.pattern_renderer` method. The origin of the hatch line is the starting point of the line pattern. The offset defines the origin of the adjacent hatch line and doesn't have to be orthogonal to the hatch line direction. **Line Pattern** The line pattern is a sequence of floats, where a value > 0.0 is a dash, a value < 0.0 is a gap and value of 0.0 is a point. Args: hatch_line: :class:`HatchLine` pattern: the line pattern as sequence of float values cURUlURUlX l[R"UVs/sHn[ U5PM sn5Ulgs snfN)rUrVpatternmathfsumrOpattern_length)rY hatch_lineroes r/__init__PatternRenderer.__init__sH '' #-- "ii(AAQ(AB(AsAcTURURURU---$rn)rUrVrr)rYindexs r/sequence_originPatternRenderer.sequence_origins%{{T^^t/B/BU/JKKKr.c## URU5(agURnUS:aX4v gURnURX!- 5S:aX!p!URnURX- 5nURX%- 5n[ Xc5up[ Xs5upX:XaUR XU 5ShvN gU S:a UR UU U5ShvN US- nX:a%URU5ShvN US- nX:aM%U S:aUR USU 5ShvN ggNxNXN7N 7f)aYields the pattern lines as pairs of :class:`~ezdxf.math.Vec2` instances from the start- to the end point on the hatch line. For points the start- and end point are the same :class:`~ezdxf.math.Vec2` instance and can be tested by the ``is`` operator. The start- and end points should be located collinear at the hatch line of this instance, otherwise the points a projected onto this hatch line. Ng& .>rMr )iscloserrrVdotrUdivmodrender_offset_to_offsetrender_full_pattern) rYr@rAlengthrVrUs_diste_dists_indexs_offsete_indexe_offsets r/renderPatternRenderer.renders[ ==   $$ D=*  NN == % +3u~.s|,"62"62  33GxP P P  c>33   qLG//8 8 8 qLG c>33    Q  9 sNB;D>=D6>!D>D8 "D>D:D>D>/D<0D>8D>:D><D>c## URnURU5nURH-nUS:XaX34v MX2[U5--nUS:aX54v UnM/ g7fNrM)rVryrorO)rYrxrV start_pointdash end_points r/r#PatternRenderer.render_full_patternsbNN **51 LLDs{!..'c$i*?? #:%00' !sAAc# # URnURU5nXTU--nSnURHInU[U5- nXr:aMUS:XaXf4v M%XT[ Xs5--n US:aXi4v Xs:a gU nMK g7fr)rVryrorOmin) rYrxrrrVrUrrCrrs r/r'PatternRenderer.render_offset_to_offsetsNN %%e,833 LLD D !H"s{!.."X1H%HH #:%00'' !sBB)rVrUrorrN)rsrSroSequence[float])rxrBrir)r@rrArriIterator[tuple[Vec2, Vec2]])rxrBrir)rxrBrrBrrBrir) r$r%r&r'r4ruryrrrr-r#r.r/rkrksC,C L0d (((&+(7<( $(r.rkc\\rSrSrSrS\4S SjjrSrS SjrS Sjr S Sjr S r g) HatchBaseLineiaWA hatch baseline defines the source line for hatching a geometry. A complete hatch pattern of a DXF entity can consist of one or more hatch baselines. Args: origin: the origin of the hatch line as :class:`~ezdxf.math.Vec2` instance direction: the hatch line direction as :class:`~ezdxf.math.Vec2` instance, must not (0, 0) offset: the offset of the hatch line origin to the next or to the previous hatch line line_pattern: line pattern as sequence of floats, see also :class:`PatternRenderer` min_hatch_line_distance: minimum hatch line distance to render, raises an :class:`DenseHatchingLinesError` exception if the distance between hatch lines is smaller than this value Raises: HatchLineDirectionError: hatch baseline has no direction, (0, 0) vector DenseHatchingLinesError: hatching lines are too narrow NcpXlUR5UlX0lU*R URU- 5Ul[UR5U:a [S5eURUR-Ul U(aX@l g/Ul g![a [ S5ef=f)Nzhatch baseline has no directionzhatching lines are too narrow) rU normalizerVZeroDivisionErrorr7offsetdetnormal_distancerOr:_end line_pattern)rYrUrVrrmin_hatch_line_distances r/ruHatchBaseLine.__init__(s  M&002DN (.wmmDNNV4K&L t## $'> >)*IJ JKK$..0 9E2! M)*KL L Ms BB5cURRSUR<SUR<SUR<S3$)Nz(origin=z , direction=z , offset=)) __class__r$rUrVr)rYs r/__repr__HatchBaseLine.__repr__<sB~~&&'x ?*)DKK?! E r.cXR- n[URURU--URU5$)z>Returns the :class:`HatchLine` at the given signed `distance`.)rrSrUrrV)rYrCras r/rsHatchBaseLine.hatch_lineBs5000t{{V';;T^^XVVr.cXURU- RURU- 5$)zRReturns the signed normal distance of the given `point` from this hatch baseline. )rUrr)rYpoints r/signed_distanceHatchBaseLine.signed_distanceGs'  e#((U):;;r.cL[URU5UR5$)zEReturns the :class:`PatternRenderer` for the given signed `distance`.)rkrsr)rYrCs r/pattern_rendererHatchBaseLine.pattern_rendererNstx8$:K:KLLr.)rrVrrrrU)rUrrVrrrrzOptional[list[float]])rCrBrirS)rrrirB)rCrBrirk) r$r%r&r'r4MIN_HATCH_LINE_DISTANCErurrsrrr-r#r.r/rrsU0/3 7 NNN N , N( W <Mr.rc*US:wdeUVs/sHo"U- PM nn[[R"[U555n[[R"[ U555n[ XT5Vs/sHoaU-PM sn$s snfs snf)zLReturns all hatch line distances in the range of the given point distances. rM)intrpceilmaxrrange)point_distancesrdnormal_factorsmax_line_numbermin_line_numbernums r/hatch_line_distancesrSs c !! !3BC?a/)?NC$))C$789O$))C$789O-2?-T U-Tcc !-T UUD Vs B :Bc## [U5nUS:agUSRUS5(a US-nUS:agXS- nURU5n[U5HnXnURU5n[ XG4UR 5HmnUR U5n U RUUUU5n U R[R:wdMHU R[R:wdMhX4v Mo UnUnM g7f)zYields all intersection points of the hatch defined by the `baseline` and the given `polygon`. Returns the intersection point and the normal-distance from the baseline, intersection points with the same normal-distance lay on the same hatch line. r"NrrNr ) lenr|rrrrrsrbrHrr(r,) baselinepolygoncount prev_point dist_prevrxr dist_pointhatch_line_distancersips r/intersect_polygonr`s LE qyqz'"+&&   19 #J((4Iu--e4 #7  #X%=%=$ ",,-@AJ** B+000GG/999--$   )sCD D 7D c#B# [X[U5ShvN gN7f)a<Yields all pattern lines for all hatch lines generated by the given :class:`HatchBaseLine`, intersecting the given 2D polygons as :class:`Line` instances. The `polygons` should represent a single entity with or without holes, the order of the polygons and their winding orientation (cw or ccw) is not important. Entities which do not intersect or overlap should be handled separately! Each polygon is a sequence of :class:`~ezdxf.math.Vec2` instances, they are treated as closed polygons even if the last vertex is not equal to the first vertex. The hole detection is done by a simple inside/outside counting algorithm and far from perfect, but is able to handle ordinary polygons well. The terminate function WILL BE CALLED PERIODICALLY AND should return ``True`` to terminate execution. This can be used to implement a timeout, which can be required if using a very small hatching distance, especially if you get the data from untrusted sources. Args: baseline: :class:`HatchBaseLine` polygons: multiple sequences of :class:`~ezdxf.path.Vec2` instances of a single entity, the order of exterior- and hole paths and the winding orientation (cw or ccw) of paths is not important terminate: callback function which is called periodically and should return ``True`` to terminate the hatching function N)_hatch_geometryr)rpolygons terminates r/hatch_polygonsrsDx3DiPPP c## [U5GHOn[U[5(avURVs/sHo0R U5PM nn[ X@R 5H1nURU5nURU5HnXu4v M M3 M[R"U5upUR U5n UR U 5n [ X4UR 5HknURU5nURXX5nUR[R:wdMFUR[R:wdMfXu4v Mm GMR gs snf7f)zYields all intersection points of the hatch defined by the `baseline` and the given single `path`. Returns the intersection point and the normal-distance from the baseline, intersection points with the same normal-distance lay on the same hatch line. N)_path_elements isinstancercontrol_pointsrrrrsrgrgeneraterbrHrr(r,) rpath path_elementrf distancesrrsrrZr[r\r]s r/intersect_pathrsE't, lH - -5A5P5P5P((+5P (<33(#&001DE $AA,OB11P (==.DA--a0F--a0F'; (":":(#&001DE ..qVDGG/444#3#=#==11(-s3E(E#C!E(4E(E(c#x# [U5S:XagURnUnUR5HnURn[ U[ 5(aUR U5(dX4v UnO[ U[5(aUR U5(dX4v Os[ U[5(a%[XRURU45v O9[ U[5(a$[XRU45n[U5v UnM UR U5(dX4v gg7f)Nr)rr@commandsrArrr|rrrctrl1ctrl2rrctrlr)rr@ path_startcommandrAcurve3s r/rrs 4yA~ JJEJ==?kk gv & &%%e,,''J  ( (s1C1C*   * *E=='--EF F  * *ullC89F+F3 3#   e $ $ %sD8D:c#B# [X[U5ShvN gN7f)uYields all pattern lines for all hatch lines generated by the given :class:`HatchBaseLine`, intersecting the given 2D :class:`~ezdxf.path.Path` instances as :class:`Line` instances. The paths are handled as projected into the xy-plane the z-axis of path vertices will be ignored if present. Same as the :func:`hatch_polygons` function, but for :class:`~ezdxf.path.Path` instances instead of polygons build of vertices. This function **does not flatten** the paths into vertices, instead the real intersections of the Bézier curves and the hatch lines are calculated. For more information see the docs of the :func:`hatch_polygons` function. Args: baseline: :class:`HatchBaseLine` paths: sequence of :class:`~ezdxf.path.Path` instances of a single entity, the order of exterior- and hole paths and the winding orientation (cw or ccw) of the paths is not important terminate: callback function which is called periodically and should return ``True`` to terminate the hatching function N)rr)rpathsrs r/ hatch_pathsrs4x JJJrr IFuncTypec## [[5nUHknU(aU"5(a gU"X5HGupgUR[R:wdeU[ U[ 5RU5 MI Mm UR5HupxU(aU"5(a g[n [n [X5Hzn U [LaU Rn U Rn M&U RRU 5(aU Rn MT[XU5v U Rn U Rn M| U [LdM[XU5v M g7f)a,Returns all pattern lines intersecting the given geometries. The intersection_func() should yield all intersection points between a HatchBaseLine() and as given geometry. The terminate function should return ``True`` to terminate execution otherwise ``False``. Can be used to implement a timeout. N)r listrHrr(round KEY_NDIGITSappenditemsrK_line_segmentsr@rAr|r>) r geometriesintersection_funcrpointsgeometryrrCverticesr@rAlines r/rrs/:$.?F  -hALB77.333 33 5;/ 0 7 7 ;B%lln  "86D ! hhzz!!#&&hh5x00 hh7  !u8, ,%-s EE  E c#\# [U5S:agURSS9 Sn[nUHznUR[R :XdUR[R :XaMAURnU[LaSnUnM\U(a[X5U5v U(+nUnM| g7f)Nr!c@URR[5$rn)rIr SORT_NDIGITS)rfs r/ _line_segments..@s < 8r.)keyFT) rsortrKrHrr(r,rIr>)rrCinsiderrrs r/rr=s 8}q MM8M9 FJ 77&++ +rww:J:T:T/T   "FJ  z(3 3 sB*B,c ## URbURR(ag[URR5S:XagUR 5nURR Rn[X5n[XS9Hn[Xe5HnURUR5nURURUR5HupUR (aRUR#U R$U R&U45UR#U R$U R&U454v [)U 5[)U 54v M M M g7f)aYields the hatch pattern of the given HATCH or MPOLYGON entity as 3D lines. Each line is a pair of :class:`~ezdxf.math.Vec3` instances as start- and end vertex, points are represented as lines of zero length, which means the start vertex is equal to the end vertex. The function yields nothing if `polygon` has a solid- or gradient filling or does not have a usable pattern assigned. Args: polygon: :class:`~ezdxf.entities.Hatch` or :class:`~ezdxf.entities.MPolygon` entity filter_text_boxes: ignore text boxes if ``True`` jiggle_origin: move pattern line origins a small amount to avoid intersections in corner points which causes errors in patterns Nr jiggle_origin)rodxf solid_fillrlinesocs elevationzhatch_boundary_pathspattern_baselinesrrrCrr@rA transformto_wcsxyr) rfilter_text_boxesrrrrrrrsrts r/ hatch_entityrSs*'++"8"8 7?? !Q& ++-C %%''I  1gtAw&& B1LsE1E3c|SSKJn /nURRURR 5HnU(a$UR [R-(aM.U"U5nUR5H6n[U5(dMUR5 URU5 M8 M U$)zReturns the hatch boundary paths as :class:`ezdxf.path.Path` instances of HATCH and MPOLYGON entities. Ignores text boxes if argument `filter_text_boxes` is ``True``. r)from_hatch_boundary_path) ezdxf.pathr rrendering_pathsr hatch_stylepath_type_flagsrBOUNDARY_PATH_TEXTBOX sub_pathsrcloser)rrr loopsboundaryrsub_paths r/rr|s 4 EMM11'++2I2IJ !9!9ErFrQrSrkrrrrrrrrBrrDrrrrrrr#r.r/r3s#   (#  ??1 488 $   t|| I  m  m  d#$  d#$ d#A A $A Hr(r(j<M<M~ V$ V7< V V))&4)))^/3"Q"Q&"Q,"Q "QJ#2#2#'#2)#2L 6/3KK K,K K: C(5u)<#=>> 9/3 )-)-)-!)-, )-  )-X0&' &'&'! &'R&-&=(  ( ( "(  (  ( r.