
    Og	T                       U d dl mZ d dlmZmZmZmZ d dlmZm	Z	 d dl
Z
d dlZd dlZd dlmZ d dlmZmZmZmZmZmZmZ ddlmZ erd d	lmZ g d
ZdZ ed      Zej>                  dz  Z  G d de      Z! G d de      Z" G d de      Z#dZ$de%d<    G d d      Z& G d de&      Z' G d d      Z( G d de(      Z) G d d e(      Z*d2d!Z+d2d"Z,d2d#Z-e#j\                  e+e#j^                  e,e#j`                  e-iZ1 G d$ d%      Z2d3d&Z3e#j^                  f	 	 	 	 	 d4d'Z4	 	 	 	 	 	 d5d(Z5 G d) d*ejl                        Z7 G d+ d,e2      Z8 G d- d.e2      Z9	 d6	 	 	 	 	 	 	 d7d/Z:d8d0Z;	 	 	 	 	 	 	 	 	 	 d9d1Z<y):    )annotations)IterableTYPE_CHECKINGTypeVarOptional)EnumautoN)TextEntityAlignment)Vec2Vec3UVecBoundingBoxBoundingBox2dAbstractBoundingBoxMatrix44   )genetic_algorithm)GenericLayoutType)ItemFlatItemBoxEnvelopeAbstractPackerPacker
FlatPackerRotationTypePickStrategyshuffle_packpack_item_subset
export_dxfg.B}TT   c                  d    e Zd ZdZ e       Z e       Z e       Z e       Z e       Z	 e       Z
y)r   zQRotation type of an item:

    - W = width
    - H = height
    - D = depth

    N)__name__
__module____qualname____doc__r	   WHDHWDHDWDHWDWHWDH     \/var/www/html/public_html/myphp/venv/lib/python3.12/site-packages/ezdxf/addons/binpacking.pyr   r   H   s3     &C
&C
&C
&C
&C
&Cr/   r   c                  6    e Zd Z e       Z e       Z e       Zy)AxisN)r$   r%   r&   r	   WIDTHHEIGHTDEPTHr.   r/   r0   r2   r2   Y   s    FEVFFEr/   r2   c                  :    e Zd ZdZ e       Z e       Z e       Zy)r   z)Order of how to pick items for placement.N)r$   r%   r&   r'   r	   SMALLER_FIRSTBIGGER_FIRSTSHUFFLEr.   r/   r0   r   r   _   s    3FM6LfGr/   r   )r   r   r   tuple[float, float, float]START_POSITIONc                      e Zd ZdZ	 d	 	 	 	 	 	 	 ddZd Zd Zedd       ZddZ	d Z
edd       Zej                  dd	       Zedd
       Zej                  dd       ZddZddZddZy)r   z3D container item.c                    || _         t        |      | _        t        |      | _        t        |      | _        t        |      | _        t        j                  | _        t        | _
        d | _        y N)payloadfloatwidthheightdepthweightr   r(   _rotation_typer;   	_position_bbox)selfr?   rA   rB   rC   rD   s         r0   __init__zItem.__init__m   sS     5\
Fm5\
Fm*..'48
r/   c                   t        | j                         d| j                   d| j                   d| j                   d| j
                   dt        | j                         d| j                   d| j                          dS )N(x
, weight: ) pos() rt() vol())	strr?   rA   rB   rC   rD   positionrotation_type
get_volumerH   s    r0   __str__zItem.__str__~   sz    4<< !4::,a}Adjj\ J{{m6#dmm*<)= >$$%VDOO,=+>aA	
r/   c                ,    t        j                   |       S )zXReturns a copy, all copies have a reference to the same payload
        object.
        )copyrV   s    r0   rY   z	Item.copy   s     yyr/   c                R    | j                   | j                          | j                   S r>   )rG   _update_bboxrV   s    r0   bboxz	Item.bbox   s"    ::zzr/   c                    t        | j                        }t        ||t        | j                               z   g      | _        y r>   )r   rF   r   get_dimensionrG   rH   v1s     r0   r[   zItem._update_bbox   s4    $..! "b40B0B0D+E&E!FG
r/   c                    d | _         y r>   )rG   rV   s    r0   _taintzItem._taint   s	    
r/   c                    | j                   S r>   )rE   rV   s    r0   rT   zItem.rotation_type   s    """r/   c                2    || _         | j                          y r>   )rE   rb   rH   values     r0   rT   zItem.rotation_type   s    #r/   c                    | j                   S )zReturns the position of then lower left corner of the item in the
        container, the lower left corner is the origin (0, 0, 0).
        )rF   rV   s    r0   rS   zItem.position   s    
 ~~r/   c                2    || _         | j                          y r>   )rF   rb   re   s     r0   rS   zItem.position   s    r/   c                N    | j                   | j                  z  | j                  z  S )zReturns the volume of the item.rA   rB   rC   rV   s    r0   rU   zItem.get_volume       zzDKK'$**44r/   c                   | j                   }|t        j                  k(  r#| j                  | j                  | j
                  fS |t        j                  k(  r#| j                  | j                  | j
                  fS |t        j                  k(  r#| j                  | j
                  | j                  fS |t        j                  k(  r#| j
                  | j                  | j                  fS |t        j                  k(  r#| j
                  | j                  | j                  fS |t        j                  k(  r#| j                  | j
                  | j                  fS t        |      )z?Returns the item dimension according the :attr:`rotation_type`.)rT   r   r(   rA   rB   rC   r)   r*   r+   r,   r-   
ValueError)rH   rts     r0   r^   zItem.get_dimension   s   !!!::t{{DJJ66<###;;

DJJ66<###;;

DJJ66<###::t{{DJJ66<###::tzz4;;66<###::tzz4;;66nr/   c                   | j                   \  }}}| j                  }|t        j                  k(  rt	        j
                  |||      S |t        j                  k(  r>t	        j                  t              t	        j
                  || j                  z   ||      z  S |t        j                  k(  rQt	        j                  t        dt              t	        j
                  || j                  z   || j                  z   |      z  S |t        j                  k(  r?t	        j                  t               t	        j
                  || j                  z   ||      z  S |t        j                  k(  r7t	        j                  dt        t              t	        j
                  |||      z  S |t        j                   k(  r>t	        j"                  t              t	        j
                  ||| j                  z   |      z  S t%        |      )zReturns the transformation matrix to transform the source entity
        located with the minimum extension corner of its bounding box in
        (0, 0, 0) to the final location including the required rotation.
        r   )rS   rT   r   r(   r   	translater)   z_rotatePI_2rB   r*   
xyz_rotaterC   r+   y_rotater,   r-   x_rotate	TypeError)rH   rL   yzrn   s        r0   get_transformationzItem.get_transformation   s   
 --1a!!!%%aA..!!!$$T*X-?-?DKKA.   !!!&&tQ58J8JDKKTZZ9   !!!$$dU+h.@.@DJJ1/   !!!&&q$58J8J1a9   !!!$$T*X-?-?1tzz>1.   mr/   N        )rA   r@   rB   r@   rC   r@   rD   r@   )returnr   r|   None)r|   r   )rf   r   r|   r~   )r|   r:   )rf   r:   r|   r~   r|   r@   )r|   r   )r$   r%   r&   r'   rI   rW   rY   propertyr\   r[   rb   rT   setterrS   rU   r^   ry   r.   r/   r0   r   r   j   s     9 9 	9
 9 9"
  
H # #     __ 5"r/   r   c                  @     e Zd ZdZ	 d	 	 	 	 	 d fdZddZd Z xZS )r   zU2D container item, inherited from :class:`Item`. Has a default depth of
    1.0.
    c                ,    t         |   |||d|       y Ng      ?superrI   )rH   r?   rA   rB   rD   	__class__s        r0   rI   zFlatItem.__init__   s     	%f=r/   c                    t        | j                        }t        ||t        | j                               z   g      | _        y r>   )r   rF   r   r^   rG   r_   s     r0   r[   zFlatItem._update_bbox   s4    $..!"BT$2D2D2F-G(G#HI
r/   c                    t        | j                         d| j                   d| j                   d| j                   dt        | j
                         d| j                   d| j                          dS )NrK   rL   rM   rN   rO   ) area(rQ   )rR   r?   rA   rB   rD   rS   rT   rU   rV   s    r0   rW   zFlatItem.__str__   so    4<< !4::,a} ={{m6#dmm*<)= >$$%WT__->,?qB	
r/   rz   )rA   r@   rB   r@   rD   r@   r}   )r$   r%   r&   r'   rI   r[   rW   __classcell__r   s   @r0   r   r      s;     > > 	>
 >J
r/   r   c                      e Zd Zef	 	 	 	 	 	 	 ddZd Zd Zd Zd Ze	dd       Z
ddZddZdd	Zdd
ZddZddZddZy)Binc                <   || _         t        |      | _        | j                  dk  rt        d      t        |      | _        | j                  dk  rt        d      t        |      | _        | j
                  dk  rt        d      t        |      | _        g | _        y )Nr{   zinvalid widthzinvalid heightzinvalid depth)namer@   rA   rm   rB   rC   
max_weightitems)rH   r   rA   rB   rC   r   s         r0   rI   zBin.__init__   s     	5\
::_--Fm;;#-..5\
::_--
+!#
r/   c                ,    t        | j                        S r>   lenr   rV   s    r0   __len__zBin.__len__  s    4::r/   c                ,    t        | j                        S r>   )iterr   rV   s    r0   __iter__zBin.__iter__  s    DJJr/   c                d    t        j                   |       }t        | j                        |_        |S )zReturns a copy.)rY   listr   rH   boxs     r0   rY   zBin.copy  s$    iio$	
r/   c                8    | j                   j                          y)z#Reset the container to empty state.N)r   clearrV   s    r0   resetz	Bin.reset  s    

r/   c                .    t        | j                         S r>   r   rV   s    r0   is_emptyzBin.is_empty"  s    tzz?""r/   c                    t        | j                         d| j                  dd| j                  dd| j                  dd| j
                   d| j                         ddS )NrK   .3frL   , max_weight:rP   rQ   )rR   r   rA   rB   rC   r   get_capacityrV   s    r0   rW   zBin.__str__&  si    499~a

3/qS0A4::cBR S//* +$$&s+1.	
r/   c                   |j                   }||_         |\  }}}| j                         D ]  }||_        |j                         \  }}	}
| j                  ||z   k  s$| j
                  ||	z   k  s| j                  ||
z   k  rU|j                  t        fd| j                  D              r| j                         |j                  z   | j                  k  s| j                  j                  |        y ||_         y)Nc              3  T   K   | ]  }j                  |j                         ! y wr>   )has_intersectionr\   ).0i	item_bboxs     r0   	<genexpr>zBin.put_item.<locals>.<genexpr>;  s      Oq	22166:Os   %(TF)rS   	rotationsrT   r^   rA   rB   rC   r\   anyr   get_total_weightrD   r   append)rH   itempivotvalid_item_positionrL   rw   rx   rT   whdr   s              @r0   put_itemzBin.put_item-  s    "mm1a "^^- 	M!.D((*GAq!zzAE!T[[1q5%8DJJQ<N		IODJJOO))+dkk9T__L

!!$'	 ,r/   c                N    | j                   | j                  z  | j                  z  S )z+Returns the maximum fill volume of the bin.rj   rV   s    r0   r   zBin.get_capacityD  rk   r/   c                :    t        d | j                  D              S )z-Returns the total weight of all fitted items.c              3  4   K   | ]  }|j                     y wr>   )rD   r   r   s     r0   r   z'Bin.get_total_weight.<locals>.<genexpr>J  s     644;;6   sumr   rV   s    r0   r   zBin.get_total_weightH  s    64::666r/   c                :    t        d | j                  D              S )z-Returns the total volume of all fitted items.c              3  <   K   | ]  }|j                           y wr>   rU   r   s     r0   r   z'Bin.get_total_volume.<locals>.<genexpr>N       <4??$<   r   rV   s    r0   get_total_volumezBin.get_total_volumeL      <<<<r/   c                d    	 | j                         | j                         z  S # t        $ r Y yw xY w)zReturn the fill ratio.r{   )r   r   ZeroDivisionErrorrV   s    r0   get_fill_ratiozBin.get_fill_ratioP  s6    	((*T->->-@@@  		s    # 	//c                    t         S r>   )r   rV   s    r0   r   zBin.rotationsW  s    r/   N)rA   r@   rB   r@   rC   r@   r   r@   r|   boolr|   rR   )r   r   r   r:   r|   r   r   r|   zIterable[RotationType])r$   r%   r&   UNLIMITED_WEIGHTrI   r   r   rY   r   r   r   rW   r   r   r   r   r   r   r.   r/   r0   r   r      s     -$ $ 	$
 $ $*  # #
.57=r/   r   c                      e Zd ZdZy)r   z)3D container inherited from :class:`Bin`.N)r$   r%   r&   r'   r.   r/   r0   r   r   [  s    3r/   r   c                  B     e Zd ZdZef	 	 	 	 	 d fdZddZddZ xZS )r   z)2D container inherited from :class:`Bin`.c                ,    t         |   |||d|       y r   r   )rH   r   rA   rB   r   r   s        r0   rI   zEnvelope.__init__d  s     	ufc:>r/   c           
         t        | j                         d| j                  dd| j                  dd| j                   d| j                         dd
S )NrK   r   rL   r   r   rQ   )rR   r   rA   rB   r   r   rV   s    r0   rW   zEnvelope.__str__m  s\    499~a

3/qS0A B//* +%%',A/	
r/   c                B    t         j                  t         j                  fS r>   )r   r(   r)   rV   s    r0   r   zEnvelope.rotationst  s    !1!111r/   )rA   r@   rB   r@   r   r@   r   r   )	r$   r%   r&   r'   r   rI   rW   r   r   r   s   @r0   r   r   a  s8    3 -? ? 	?
 ?
2r/   r   c                P    | j                  d        |j                  d        y )Nc                "    | j                         S r>   r   bs    r0   <lambda>z _smaller_first.<locals>.<lambda>{      ANN, r/   )keyc                "    | j                         S r>   r   r   s    r0   r   z _smaller_first.<locals>.<lambda>|      Q\\^ r/   sortbinsr   s     r0   _smaller_firstr   x  s"     	II,I-	JJ+J,r/   c                T    | j                  d d       |j                  d d       y )Nc                "    | j                         S r>   r   r   s    r0   r   z_bigger_first.<locals>.<lambda>  r   r/   T)r   reversec                "    | j                         S r>   r   r   s    r0   r   z_bigger_first.<locals>.<lambda>  r   r/   r   r   s     r0   _bigger_firstr     s$    II,dI;	JJ+TJ:r/   c                X    t        j                  |        t        j                  |       y r>   )randomshuffler   s     r0   _shuffler     s    
NN4
NN5r/   c                      e Zd ZddZd Zedd       Zedd       ZddZddZ	ddZ
ddZdd	Zdd
ZddZddZej"                  fddZddZddZedd       Zy)r   c                .    g | _         g | _        d| _        y )NT)r   r   _init_staterV   s    r0   rI   zAbstractPacker.__init__  s    !	!#
r/   c                j   | j                   rt        d      t        d | j                  D              st        d      | j	                         }| j                  D cg c]  }|j                          c}|_        | j                  D cg c]  }|j                          c}|_        |S c c}w c c}w )z=Copy packer in init state to apply different pack strategies.zcannot copy packed statec              3  4   K   | ]  }|j                     y wr>   )r   r   r   s     r0   r   z&AbstractPacker.copy.<locals>.<genexpr>  s     5C3<<5r   z#bins contain data in unpacked state)	is_packedrv   allr   r   rY   r   )rH   packerr   r   s       r0   rY   zAbstractPacker.copy  s    >>677549955ABB!-1YY7csxxz704

;		; 8;s   B+
B0c                    | j                    S )zYReturns ``True`` if packer is packed, each packer can only be used
        once.
        )r   rV   s    r0   r   zAbstractPacker.is_packed  s    
 ####r/   c                    | j                   S )zReturns the unfitted items.)r   rV   s    r0   unfitted_itemszAbstractPacker.unfitted_items  s     zzr/   c                    d}| j                   rd| j                          }| j                  j                   dt	        | j
                         d| S )N z, fill ratio: z, z bins)r   r   r   r$   r   r   )rH   fills     r0   rW   zAbstractPacker.__str__  sO    >>#D$7$7$9#:;D..))*"S^,<E$HHr/   c                    | j                   rt        d      |j                  st        d      | j                  j	                  |       y)zAppend a container.z"cannot append bins to packed statezcannot append bins with contentN)r   rv   r   r   r   r   s     r0   
append_binzAbstractPacker.append_bin  s:    >>@AA||=>>		r/   c                h    | j                   rt        d      | j                  j                  |       y)zAppend a item.z#cannot append items to packed stateN)r   rv   r   r   )rH   r   s     r0   append_itemzAbstractPacker.append_item  s'    >>ABB

$r/   c                T    | j                         }|dk(  ry| j                         |z  S )z"Return the fill ratio of all bins.r{   )r   r   )rH   total_capacitys     r0   r   zAbstractPacker.get_fill_ratio  s/    **,S $$&77r/   c                :    t        d | j                  D              S )z,Returns the maximum fill volume of all bins.c              3  <   K   | ]  }|j                           y wr>   r   r   s     r0   r   z.AbstractPacker.get_capacity.<locals>.<genexpr>  s     ;#3##%;r   r   r   rV   s    r0   r   zAbstractPacker.get_capacity  s    ;;;;r/   c                :    t        d | j                  D              S )z9Returns the total weight of all fitted items in all bins.c              3  <   K   | ]  }|j                           y wr>   )r   r   s     r0   r   z2AbstractPacker.get_total_weight.<locals>.<genexpr>       ?c3'')?r   r  rV   s    r0   r   zAbstractPacker.get_total_weight      ?TYY???r/   c                :    t        d | j                  D              S )z9Returns the total volume of all fitted items in all bins.c              3  <   K   | ]  }|j                           y wr>   )r   r   s     r0   r   z2AbstractPacker.get_total_volume.<locals>.<genexpr>  r  r   r  rV   s    r0   r   zAbstractPacker.get_total_volume  r	  r/   c                :    t        d | j                  D              S )z/Returns the total volume of all unfitted items.c              3  <   K   | ]  }|j                           y wr>   r   r   s     r0   r   z5AbstractPacker.get_unfitted_volume.<locals>.<genexpr>  r   r   r   rV   s    r0   get_unfitted_volumez"AbstractPacker.get_unfitted_volume  r   r/   c                    t        |   | j                  | j                         | j                  | j                  t	        | j                               y)z<Pack items into bins. Distributes all items across all bins.N)PICK_STRATEGYr   r   _packr   )rH   picks     r0   packzAbstractPacker.pack  s4    dDIItzz2

499d4::./r/   c                    d| _         |D ]7  }|D ]0  }| j                  ||      s| j                  j                  |       2 9 y)z;Pack items into bins, removes packed items from self.items!FN)r   pack_to_binr   remove)rH   r   r   r   r   s        r0   r  zAbstractPacker._pack  sJ      	,C ,##C.JJ%%d+,	,r/   c                   |j                   s|j                  |t              S | j                         D ]  }|j                   D ]  }|j	                         \  }}}|j
                  \  }}	}
|t        j                  k(  r	||z   |	|
f}nC|t        j                  k(  r	||	|z   |
f}n'|t        j                  k(  r	||	|
|z   f}nt        |      |j                  ||      s  y  y)NTF)r   r   r;   _axisr^   rS   r2   r3   r4   r5   rv   )rH   r   r   axisplaced_itemr   r   r   rL   rw   rx   r   s               r0   r  zAbstractPacker.pack_to_bin  s    yy<<n55JJL 	 D"yy  %3351a%..1a4::%UAqMET[[(AqMETZZ'1q5ME#D/)<<e, 	  r/   c                     t         S r>   )r2   r.   r/   r0   r  zAbstractPacker._axis  s    r/   Nr}   r   )r|   
list[Item]r   )r   r   r|   r~   )r   r   r|   r~   r   )r   zIterable[Bin]r   zIterable[Item]r|   r~   )r   r   r   r   r|   r   r|   zIterable[Axis])r$   r%   r&   rI   rY   r   r   r   rW   r   r   r   r   r   r   r  r   r8   r  r  r  staticmethodr  r.   r/   r0   r   r     s     
	 $ $  I 8<@@= %11 0,(  r/   r   c                    |dk  rt        d      d}| }t        |      D ]K  }| j                         }|j                  t        j
                         |j                         }||kD  sH|}|}M |S )zrRandom shuffle packing. Returns a new packer with the best packing result,
    the input packer is unchanged.
    r   zexpected attempts >= 1r{   )rm   rangerY   r  r   r9   r   )r   attempts
best_ratiobest_packer_
new_packer	new_ratios          r0   r   r     sy     !|122JK8_ %[[]
,,---/	z!"J$K% r/   c                    | j                   du sJ t        | j                  |      \  }}|| _        | j                  |       | j                  j	                  |       y)zwPack a subset of `packer.items`, which are chosen by an iterable
    yielding a True or False value for each item.
    FN)r   get_item_subsetr   r  extend)r   pickerstrategychosenrejectss        r0   r   r     sQ     u$$$%fllF;OFGFL
KK
LL r/   c                    g }g }d}t        | |      D ]/  \  }}|dz  }|r|j                  |       |j                  |       1 |t        |       k  r|j                  | |d        ||fS )zyReturns a subset of `items`, where items are chosen by an iterable
    yielding a True or False value for each item.
    r   r   N)zipr   r   r)  )r   r*  r,  r-  countr   r  s          r0   r(  r(  "  s{     FGE%( !
d
MM$NN4 ! s5zuUV}%7?r/   c                  $    e Zd ZddZddZddZy)SubSetEvaluatorc                    || _         y r>   )r   )rH   r   s     r0   rI   zSubSetEvaluator.__init__8  s	    r/   c                D    | j                  |      }|j                         S r>   )
run_packerr   rH   dnar   s      r0   evaluatezSubSetEvaluator.evaluate;  s    %$$&&r/   c                R    | j                   j                         }t        ||       |S r>   )r   rY   r   r6  s      r0   r5  zSubSetEvaluator.run_packer?  s#    !!#%r/   N)r   r   )r7  ga.DNAr|   r@   )r7  r:  r|   r   )r$   r%   r&   rI   r8  r5  r.   r/   r0   r2  r2  7  s    'r/   r2  c                  P    e Zd ZdZef	 	 	 	 	 	 	 	 	 	 	 ddZ	 d	 	 	 	 	 	 	 	 	 ddZy)r   z13D Packer inherited from :class:`AbstractPacker`.c                F    t        |||||      }| j                  |       |S )z Add a 3D :class:`Box` container.)r   r   )rH   r   rA   rB   rC   r   r   s          r0   add_binzPacker.add_binH  s'     $vuj9
r/   c                F    t        |||||      }| j                  |       |S )zAdd a 3D :class:`Item` to pack.)r   r   )rH   r?   rA   rB   rC   rD   r   s          r0   add_itemzPacker.add_itemU  s)     GUFE6:r/   N)r   rR   rA   r@   rB   r@   rC   r@   r   r@   r|   r   rz   )
rA   r@   rB   r@   rC   r@   rD   r@   r|   r   )r$   r%   r&   r'   r   r=  r?  r.   r/   r0   r   r   E  s    ; -  	
   
&   	
   
r/   r   c                  Z    e Zd ZdZef	 	 	 	 	 	 	 	 	 ddZ	 d	 	 	 	 	 	 	 ddZed	d       Zy)
r   zz2D Packer inherited from :class:`AbstractPacker`. All containers and
    items used by this packer must have a depth of 1.c                D    t        ||||      }| j                  |       |S )z%Add a 2D :class:`Envelope` container.)r   r   )rH   r   rA   rB   r   envelopes         r0   r=  zFlatPacker.add_bing  s%     D%<!r/   c                D    t        ||||      }| j                  |       |S )z#Add a 2D :class:`FlatItem` to pack.)r   r   )rH   r?   rA   rB   rD   r   s         r0   r?  zFlatPacker.add_items  s'     7r/   c                 B    t         j                  t         j                  fS r>   )r2   r3   r4   r.   r/   r0   r  zFlatPacker._axis  s    zz4;;&&r/   N)
r   rR   rA   r@   rB   r@   r   r@   r|   r   rz   )rA   r@   rB   r@   rD   r@   r|   r   r  )	r$   r%   r&   r'   r   r=  r?  r  r  r.   r/   r0   r   r   c  s    9 -

 
 	

 
 

" 
 
 	

 
 

 ' 'r/   r   c           	        ddl m} t        |      }t               }d}|j                  |j                  |j
                  |j                  |j                  f}|D ]  }t        j                  |j                  |j                  |j                        }	t        | |d|	       |j                  D ]*  }
t        | |
d||   |	       |dz  }|t!        |      k\  s)d}, ||z  } y )Nr   )colorsFRAMEITEMSr   )ezdxfrF  r   REDGREENBLUEMAGENTACYANr   rp   rL   rw   rx   
_add_framer   	_add_meshr   )layoutr   offsetrF  
offset_vecstartindexrgbr   mr   s              r0   r    r      s     fJFEE::v||V[[&..&++
NC uww963+II 	DfdGSZ;QJEC 		
 	r/   c                     fd}d|id\  }}}t        |j                        }t        |j                        }	t        |j                        }
||f||f||	f||	f||fg}t	        ||dd        D ])  \  \  }}\  }} ||||f|||f        ||||
f|||
f       + |d d D ]  \  }} ||||f|||
f         j                  |j                  d      }|j                  |dz   |	dz
  |
f       |j                         y )	Nc                P    j                  | |      }|j                         y )N)
dxfattribs)add_line	transform)r`   v2lineattribsrQ  rW  s      r0   r[  z_add_frame.<locals>.add_line  s#    r2':qr/   layer)r{   r{   r{   r         ?rB   rZ  g      ?)	r@   rA   rB   rC   r/  add_textr   set_placementr\  )rQ  r   r`  rW  r[  x0y0z0x1y1z1cornerssxsyexeyrL   rw   textr_  s   `  `               @r0   rO  rO    s>    G JBB	syy	B	szz	B	syy	B	R	R	R	R	RG "'712;7 -R(2r"b"B|,"b"B|,-  )1!QaBZ() ??388DW?EDT	28R01NN1r/   c                   ddl m} ||d} |d      }|j                         \  }}	}
|j                  ||	|
       |j                  \  }}}|j                  |||       |j                  | ||       | j                  t        |j                        ddd	i
      }|	|kD  r"d|j                  _        t        j                  }nt        j                  }|j                  |dz   |dz   ||
z   f|       |j!                  |       y )Nr   )cube)r`  colorF)center)matrixrb  r`  TEXTrc  Z   )align)ezdxf.render.formsrs  r^   scalerS   rp   render_polyfacerd  rR   r?   dxfrotationr
   TOP_LEFTBOTTOM_LEFTre  r\  )rQ  r   r`  rt  rW  rs  r_  meshrm  rn  szrL   rw   rx   rq  ry  s                   r0   rP  rP    s     ( G uD##%JBBJJr2rmmGAq!NN1a3??DLL$GV3D  D 
Bw#,,#//D!d(AF35ANN1r/   )r   r   r   r   r|   r~   )r   r   r!  intr|   r   )r   r   r*  r   r|   r~   )r   r  r*  r   r|   ztuple[list[Item], list[Item]]))r   r   r   )rQ  'GenericLayoutType'r   z	list[Bin]rR  r   r|   r~   )rQ  r  r   r   r`  rR   rW  r   )
rQ  r  r   r   r`  rR   rt  r  rW  r   )=
__future__r   typingr   r   r   r   enumr   r	   rY   mathr   ezdxf.enumsr
   
ezdxf.mathr   r   r   r   r   r   r   r   r   gaezdxf.eztypesr   __all__r   r!   pirr   r   r2   r   r;   __annotations__r   r   r   r   r   r   r   r   r7   r8   r9   r  r   r   r   r(  	Evaluatorr2  r   r   r    rO  rP  r.   r/   r0   <module>r     s  0 #      ,   &/  CLww{4 "4 4  .7* 6u up
t 
4\ \~	# 	2s 2.-; }(n nb& 8D7P7P
!
!$,
!	
!'"*bll ^ <' 'D BK'0:>	(8'+47@CHPr/   