OgaUddlmZddlmZmZmZmZmZmZm Z m Z ddl m Z ddl mZddlZddlZddlZddlZddlmZmZmZmZmZmZddlmZddlmZmZmZm Z m!Z!erdd l"m#Z#d Z$eejJejJZ&d Z'd Z(Gd dejRZ*Gdde+Z,Gdde,Z-Gdde,Z.ej^dGddZ0ej^dGddZ1d2d3dZ2ej^dGddZ3GddZ4Gd d!Z5 d4d"Z6 d5d#Z7 d6 d7d$Z8 d8d%Z9d9d&Z: d6 d:d'Z;ee5egee e1ed)< d6 d;d*Z?dd,ZAd?d@d-ZBd.ZCe$fd/d0 dAd1ZDy)B) annotations)IteratorSequence TYPE_CHECKINGCallableAnyUnionOptionalTuple) TypeAlias) defaultdictN)Vec2Vec3Bezier3PBezier4P intersection_ray_cubic_bezier_2dquadratic_to_cubic_bezier)const)PathLineToMoveToCurve3ToCurve4To) DXFPolygong-C6? c eZdZdZdZdZdZdZy)IntersectionTyperrN)__name__ __module__ __qualname__NONEREGULARSTARTEND COLLINEARZ/var/www/html/public_html/myphp/venv/lib/python3.12/site-packages/ezdxf/render/hatching.pyrr(s DG E CIr+rceZdZdZy) HatchingErrorz3Base exception class of the :mod:`hatching` module.Nr"r#r$__doc__r*r+r,r.r.0=r+r.ceZdZdZy)HatchLineDirectionErrorz3Hatching direction is undefined or a (0, 0) vector.Nr/r*r+r,r3r36r1r+r3ceZdZdZy)DenseHatchingLinesErrorzCVery small hatching distance which creates too many hatching lines.Nr/r*r+r,r5r5<sMr+r5T)frozenc,eZdZUded<ded<ded<y)LinerstartendfloatdistanceN)r"r#r$__annotations__r*r+r,r8r8Bs K IOr+r8cPeZdZUdZej Zded<eZ ded<eZ ded<y) IntersectionzRepresents an intersection.rtyperp0p1N) r"r#r$r0rr%r@r= NONE_VEC2rArBr*r+r,r?r?Is*%-22D 2BBr+r?c.t||kry|dkDryy)Nrr)abs)r<abs_tols r, side_of_linerIRs 8}w#~ r+cTeZdZUdZded<ded<ded< d dZd dZy ) HatchLinea,Represents 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 directionr;r<c|j}t||z }t||z }|dk(r:|dk(rttj||Sttj |S|dk(rttj |S||k7r>t||z ||z z }ttj|j||StS)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) r<rIr?rr)r'r(rGr&lerp) selfabdist_adist_b line_distanceside_aside_bfactors r,intersect_linezHatchLine.intersect_lineis. f}45f}45 Q;{#$4$>$>1EE#$4$:$:A>> q[ 0 4 4a8 8 v &=0Vf_EFF 0 8 8!&&F:KL L~r+ct|j|j|jz|Dcgc]!}ttj |t #c}Scc}w)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 )rrLrMr?rr&rC)rPcurveps r,intersect_cubic_bezier_curvez&HatchLine.intersect_cubic_bezier_curvesQ6 T[[4>>95  )111i @   s&AN) rQrrRrrSr;rTr;returnr?)r[rr^zSequence[Intersection])r"r#r$r0r=rYr]r*r+r,rKrKZsS LOO$ $ $ $  $  $L  r+rKcHeZdZdZddZd dZd dZd dZ d dZy) 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 c|j|_|j|_||_tj|Dcgc] }t |c}|_ycc}wN)rLrMpatternmathfsumrGpattern_length)rP hatch_linerces r,__init__zPatternRenderer.__init__sF '' #-- "ii(AAQ(AB(AsAcT|j|j|j|zzzSrb)rLrMrf)rPindexs r,sequence_originzPatternRenderer.sequence_origins%{{T^^t/B/BU/JKKKr+c#K|j|ry|j}|dkr||fy|j}|j||z dkr||}}|j}|j||z }|j||z }t ||\}} t ||\} } || k(r|j || | Ed{y| dkDr |j || |Ed{|dz }|| kr$|j|Ed{|dz }|| kr$| dkDr|j |d| Ed{yy7u7V757 w)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& .>rEr)iscloserfrMdotrLdivmodrender_offset_to_offsetrender_full_pattern) rPr9r:lengthrMrLs_diste_dists_indexs_offsete_indexe_offsets r,renderzPatternRenderer.rendersx ==  $$ D=*  NN ==u % +e3Euv~.sV|,"662"662 g 33GXxP P P  c>33   qLG//8 8 8 qLG c>33    Q  9 sNB?D?D7 D?"D9#"D?D;D?D?0D=1D?9D?;D?=D?c#K|j}|j|}|jD],}|dk(r||f||t|zz}|dkDr||f|}.ywNrE)rMrlrcrG)rPrkrM start_pointdash end_points r,rrz#PatternRenderer.render_full_patternsnNN **51 LL (Ds{!;..')c$i*?? #:%y00'  (sAAc#K|j}|j|}|||zz}d}|jD]H}|t|z }||kr|dk(r||f#||t ||zz} |dkDr|| f||k\ry| }Jywr|)rMrlrcrGmin) rPrkrwryrMrLr}r<r~rs r,rqz'PatternRenderer.render_offset_to_offsetsNN %%e,y833 LL (D D !H("s{!;.."YXx1H%HH #:%y00x''  (sBBN)rgrKrcSequence[float])rkr;r^r)r9rr:rr^Iterator[tuple[Vec2, Vec2]])rkr;r^r)rkr;rwr;ryr;r^r) r"r#r$r0rirlrzrrrqr*r+r,r`r`sC,C L0d (((&+(7<( $(r+r`cJeZdZdZdef ddZdZd dZd dZd dZ y) HatchBaseLineaA 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 Nch||_ |j|_||_| j |j|z |_t|j|kr td|j|jz|_ |r||_ yg|_ y#t$r t dwxYw)Nzhatch baseline has no directionzhatching lines are too narrow) rL normalizerMZeroDivisionErrorr3offsetdetnormal_distancerGr5_end line_pattern)rPrLrMrrmin_hatch_line_distances r,rizHatchBaseLine.__init__(s  M&002DN (.wmmDNNV4K&L t## $'> >)*IJ JKK$..0 9E2! M)*KL L Ms BB1c|jjd|jd|jd|jdS)Nz(origin=z , direction=z , offset=)) __class__r"rLrMr)rPs r,__repr__zHatchBaseLine.__repr__<sB~~&&'x ?*)DKK?! E r+c||jz }t|j|j|zz|j|S)z>Returns the :class:`HatchLine` at the given signed `distance`.)rrKrLrrM)rPr<rXs r,rgzHatchBaseLine.hatch_lineBs7D000t{{V';;T^^XVVr+cX|j|z j|j|z S)zbReturns the signed normal distance of the given `point` from this hatch baseline. )rLrr)rPpoints r,signed_distancezHatchBaseLine.signed_distanceGs'  e#((U):;;r+cLt|j||jS)zEReturns the :class:`PatternRenderer` for the given signed `distance`.)r`rgr)rPr<s r,pattern_rendererzHatchBaseLine.pattern_rendererNstx8$:K:KLLr+)rLrrMrrrrzOptional[list[float]])r<r;r^rK)rrr^r;)r<r;r^r`) r"r#r$r0MIN_HATCH_LINE_DISTANCErirrgrrr*r+r,rrsU0/3 7 NNN N , N( W <Mr+rc|dk7sJ|Dcgc]}||z  }}ttjt|}ttjt |}t ||Dcgc]}||z c}Scc}wcc}w)zTReturns all hatch line distances in the range of the given point distances. rE)intrdceilmaxrrange)point_distancesrdnormal_factorsmax_line_numbermin_line_numbernums r,hatch_line_distancesrSs c !! !3BCaa/)CNC$))C$789O$))C$789O-2?O-T UcOc ! UUD Vs B6 B c#Kt|}|dkry|dj|dr |dz}|dkry||dz }|j|}t|D]}||}|j|}t ||f|j D]i}|j |} | j||||} | jtjk7sF| jtjk7sd| |fk|}|}yw)a Yields 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!NrrFr) lenrnrrrrrgrYr@rr%r)) baselinepolygoncount prev_point dist_prevrkr dist_pointhatch_line_distancergips r,intersect_polygonr`s" LE qyqz'"+&   19 #J((4Iu--e4 #7  #X%=%=$  . ",,-@AJ** B+000GG/999--- .   )sCC>C>/C>c#DKt||t|Ed{y7w)aYields 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#Kt|D]B}t|trq|jDcgc]}|j |}}t ||j D]/}|j|}|j|D]}||f 1tj|\}} |j |} |j | } t | | f|j D]i}|j|}|j|| | | }|jtjk7sF|jtjk7sd||fkEycc}ww)aYields 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_pointsrrrrgr]rgeneraterYr@rr%r)) rpath path_elementr\ distancesrrgrrQrRrSrTs r,intersect_pathrse't,2 lH -5A5P5P01((+I(<833( 2#&001DE $AA,O2B1112  2==.DAq--a0F--a0F'; (":":( 2#&001DE ..q!VVDGG/444#3#=#==111 22s.EEC"E+E Ec#6Kt|dk(ry|j}|}|jD]}|j}t |t r|j |s||f|}nt |tr|j |s||fnkt |tr&t||j|j|fn5t |tr%t||j|f}t||}|j |s||fyyw)Nr)rr9commandsr:rrrnrrrctrl1ctrl2rrctrlr)rr9 path_startcommandr:curve3s r,rrs 4yA~ JJEJ==? kk gv &%%e,Z''J  (s1C*   *E7=='--EF F  *ugllC89F+F3 3    e $Z %sDDc#DKt||t|Ed{y7w)u@Yields 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#Ktt}|D]_}|r |ry|||D]F\}}|jtjk7sJ|t |t j|Ha|jD]\}}|r |ryt} t} t||D]r} | tur| j} | j} $| jj| r | j} Lt| | || j} | j} t| tust| | |yw)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 listr@rr%round KEY_NDIGITSappenditemsrC_line_segmentsr9r:rnr8) r geometriesintersection_funcrpointsgeometryrr<verticesr9r:lines r,rrs0/:$.?F<  -hA |j}|turd}|}W|rt|||| }|}nyw)Nr c@|jjtSrb)rAr SORT_NDIGITS)r\s r,z _line_segments..@s < 8r+)keyFT) rsortrCr@rr%r)rAr8)rr<insiderrrs r,rr=s 8}q MM8M9 FJ  77&++ +rww:J:T:T/T   "FJ  z5(3 3  sBBc #K|j|jjryt|jjdk(ry|j }|jj j}t||}t||D]}t||D]}|j|j}|j|j|jD]{\} } |j rR|j#| j$| j&|f|j#| j$| j&|fft)| t)| f}yw)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)rcdxf solid_fillrlinesocs elevationzhatch_boundary_pathspattern_baselinesrrr<rzr9r: transformto_wcsxyr) rfilter_text_boxesrrrrrrrsrhs r, hatch_entityrSs0*'++"8"8 7?? !Q& ++-C %%''I *; 1gtAw&&  ' ''sE&E(cRddlm}g}|jj|jj D]l}|r|j tjzr#||}|jD]/}t|s|j|j|1n|S)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.pathrrrendering_pathsr hatch_stylepath_type_flagsrBOUNDARY_PATH_TEXTBOX sub_pathsrcloser)rrrloopsboundaryrsub_paths r,rr|s 4 EMM11'++2I2IJ' !9!9Ers#   (#  ??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+