% Input: resolved places, routes, and measured extents. % Output: TikZ nodes and paths for wires, legs, strings, strokes, and glyphs. % Owned state: the placed-record table and the per-picture ink registers. % Invariants: ink reads frozen records; it resolves no address and moves no place. % Next stage: tenkz-kernel-annotate decides where a name or a mark may stand. % SPDX-License-Identifier: Apache-2.0 % Copyright the TNLean project; see LICENSE for the full terms. % % tenkz-kernel-ink.code.tex is the ink stage: index wires, direction marks, measured closure contours, % physical legs, strings, declared strokes, mark stations, atom glyphs. % % Split out of tenkz-kernel.code.tex without changing a line of content; % the stages load in the order tenkz-kernel.code.tex lists them, and the % golden event and pixel streams are unchanged by the move. % Load guard. It stands before \ExplSyntaxOn deliberately: a guarded exit % never reaches the trailing \ExplSyntaxOff, so a guard inside expl3 syntax % would leave the caller's catcodes changed -- ignoring spaces rather than % erroring. Guarding first leaves them exactly as they were found, whether % the caller had expl3 syntax on or off. \ifcsname tenkzkernel\endcsname \expandafter\endinput \fi \ExplSyntaxOn % % The record is a centreline envelope, not the exact painted silhouette: a % dashed or dotted style still walks the continuous path, so the audit reads % every off-dash gap as ink too (over-report, never under-report -- TNLOG.md % section 3). The same doctrine covers the direction-mark cover emitted % below and the trace halo's widened stroke: none of them reproduce the % decorated ink stroke-for-stroke, all of them are honest not to understate % it. \tl_new:N \l__tenkz_kernel_ink_route_tl \tl_new:N \l__tenkz_kernel_ink_final_tl \tl_new:N \l__tenkz_kernel_ink_seg_tl \tl_new:N \l__tenkz_kernel_ink_pts_tl \tl_new:N \l__tenkz_kernel_ink_move_tl \tl_new:N \l__tenkz_kernel_ink_last_tl \tl_new:N \l__tenkz_kernel_ink_origin_tl \tl_new:N \l__tenkz_kernel_ink_stroke_tl \tl_new:N \g__tenkz_kernel_ink_width_tl \int_new:N \l__tenkz_kernel_ink_drawn_int \seq_new:N \l__tenkz_kernel_ink_seq \prop_new:N \l__tenkz_kernel_ink_origin_prop % route sid -> origin word % The stroke the record carries is the width the renderer resolves, not the % base metric: a document may restyle a wire class, and the audit must hold % the label band against the ink actually laid. Reading that back used to % replay the public style a second time in a throwaway group, so a restyle % built on a stateful hook -- `bond/.append style={/utils/exec={...}}` -- % ran its action once for measurement and once more for the real stroke. % This key instead rides the SAME option list the real path draws with, as % its last token: TikZ resolves every earlier key first, so `\pgflinewidth` % is the width that path actually strokes with, read exactly once, as part % of the one real execution (#6330 review). \tikzset { tenkz~ink~capture~width/.code= { \tl_gset:Ne \g__tenkz_kernel_ink_width_tl { \dim_to_decimal_in_sp:n { \pgflinewidth / 2 } } } } \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink_flush:nn #1#2 { \int_compare:nNnT { \l__tenkz_kernel_ink_drawn_int } > { 0 } { \__tenkz_kernel_event:n { wire-ink|picture=k\int_use:N \g__tenkz_kernel_picture_int |name=#1|origin=#2 |stroke=\tl_use:N \l__tenkz_kernel_ink_stroke_tl |points=\tl_use:N \l__tenkz_kernel_ink_pts_tl } } \tl_clear:N \l__tenkz_kernel_ink_pts_tl \int_zero:N \l__tenkz_kernel_ink_drawn_int } % One segment of the walk: the pinned spath3 exposes each segment as its % starting move plus one action. A move that does not repeat the previous % end opens a new component, which closes the record of the one before it. \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink_segment:nnn #1#2#3 { \tl_set:Nn \l__tenkz_kernel_ink_seg_tl {#1} \tl_set:Ne \l__tenkz_kernel_ink_move_tl { \dim_to_decimal_in_sp:n { \tl_item:nn {#1} {2} } , \dim_to_decimal_in_sp:n { \tl_item:nn {#1} {3} } } \tl_if_eq:NNF \l__tenkz_kernel_ink_move_tl \l__tenkz_kernel_ink_last_tl { \__tenkz_kernel_r_wire_ink_flush:nn {#2} {#3} \tl_set_eq:NN \l__tenkz_kernel_ink_pts_tl \l__tenkz_kernel_ink_move_tl \tl_set_eq:NN \l__tenkz_kernel_ink_last_tl \l__tenkz_kernel_ink_move_tl } \spath_finalaction:NV \l__tenkz_kernel_ink_final_tl \l__tenkz_kernel_ink_seg_tl \tl_if_eq:NNTF \l__tenkz_kernel_ink_final_tl \c_spath_lineto_tl { \tl_set:Ne \l__tenkz_kernel_ink_last_tl { \dim_to_decimal_in_sp:n { \tl_item:nn {#1} {5} } , \dim_to_decimal_in_sp:n { \tl_item:nn {#1} {6} } } \tl_put_right:Ne \l__tenkz_kernel_ink_pts_tl { ; \tl_use:N \l__tenkz_kernel_ink_last_tl } \int_incr:N \l__tenkz_kernel_ink_drawn_int } { \tl_if_eq:NNT \l__tenkz_kernel_ink_final_tl \c_spath_curveto_tl { \tl_set:Ne \l__tenkz_kernel_ink_last_tl { \dim_to_decimal_in_sp:n { \tl_item:nn {#1} {11} } , \dim_to_decimal_in_sp:n { \tl_item:nn {#1} {12} } } \tl_put_right:Ne \l__tenkz_kernel_ink_pts_tl { ;c: \dim_to_decimal_in_sp:n { \tl_item:nn {#1} {5} } , \dim_to_decimal_in_sp:n { \tl_item:nn {#1} {6} } , \dim_to_decimal_in_sp:n { \tl_item:nn {#1} {8} } , \dim_to_decimal_in_sp:n { \tl_item:nn {#1} {9} } , \tl_use:N \l__tenkz_kernel_ink_last_tl } \int_incr:N \l__tenkz_kernel_ink_drawn_int } % a bare move ends here; its point stands as the open start } } % An after-atom physical trace strokes its return directly, without joining % the queued index class. The path is still saved first -- unregistered, % purely as the measured object -- and the stroke replays that saved path, % so the auditor and the renderer read one resolved route here too. % One authority for the trace halo's half-width in scaled points: both % trace emission paths widen their band by this same number, so a change % to the halo sum lands once. \cs_new:Npn \__tenkz_kernel_r_trace_halo_sp: { \dim_to_decimal_in_sp:n { ( \__tenkz_dim:n {wirewidth} + \__tenkz_dim:n {crossgap} ) / 2 } } \cs_new_protected:Npn \__tenkz_kernel_r_trace_stroke:nn #1#2 { \__tenkz_kernel_r_sid:nN {#1} \l__tenkz_kernel_r_sid_tl \exp_args:NV \__tenkz_kernel_r_trace_stroke_aux:nn \l__tenkz_kernel_r_sid_tl {#2} } \cs_new_protected:Npn \__tenkz_kernel_r_trace_stroke_aux:nn #1#2 { \path [ spath/save = {#1}, rounded~corners = \__tenkz_dim:n {corner} ] #2 ; % A trace paints two layers: a foreground stroke inheriting the % restylable `bond` style and a paper preaction halo of the fixed sum % wirewidth + crossgap (tenkz-core.code.tex, the `trace` style). The % record must dominate the union of the two (#6359): the capture key % rides the one real stroke to read the resolved foreground width, and % the recorded band is the wider of that and the halo, so neither a % label erased in the halo's annulus nor one standing on a widened % foreground's outer ink can evade the audit. \__tenkz_render_stroke:nn { trace , spath/use = {#1} , tenkz~ink~capture~width } { } \tl_set:Ne \l__tenkz_kernel_ink_stroke_tl { \fp_eval:n { max ( \g__tenkz_kernel_ink_width_tl , \__tenkz_kernel_r_trace_halo_sp: ) } } \__tenkz_kernel_r_wire_ink_event:nn {#1} { trace } } \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink_event:nn #1#2 { \tl_set_eq:Nc \l__tenkz_kernel_ink_route_tl { \l__tikzspath_prefix_tl #1 } \spath_segments_to_seq:NV \l__tenkz_kernel_ink_seq \l__tenkz_kernel_ink_route_tl \tl_clear:N \l__tenkz_kernel_ink_pts_tl \tl_clear:N \l__tenkz_kernel_ink_last_tl \int_zero:N \l__tenkz_kernel_ink_drawn_int \seq_map_inline:Nn \l__tenkz_kernel_ink_seq { \__tenkz_kernel_r_wire_ink_segment:nnn {##1} {#1} {#2} } \__tenkz_kernel_r_wire_ink_flush:nn {#1} {#2} } % ---------- direction-mark ink ------------------------------------------------------------------- % `dir marks`/`dir marks reversed` draws a Straight Barb as a postaction the % walk above never sees, since it records the underlying centreline, not % the decoration painted over it -- a label can sit squarely on the visible % arrowhead with no ink beneath it in the record (#6330 review). The % barb's exact silhouette is not reproduced here: that would mean replaying % the decorated path a second time, the very duplication the style-replay % thread of the same review forbids. Instead this covers it honestly, on % the same envelope doctrine as a dashed wire's gap: a short segment, % centred on the mark's own arc-length station, along the route's local % direction there, stroked to the barb's own configured reach. The % station is arc length along the route's resolved geometry -- straight % segments exactly, a cubic by sub-chords of the true curve whose count % the control net's own deviation bound chooses, the residual widening % the cover wherever the count's ceiling binds, so the cover sits on a % bowed segment's drawn bow rather than on the chord between its ends, % at any size (#6360) -- read off the SAME points sequence the % centreline walk above just built, so no path is re-saved and no style % is re-executed. \fp_new:N \l__tenkz_kernel_ink_mark_total_fp \fp_new:N \l__tenkz_kernel_ink_mark_target_fp \fp_new:N \l__tenkz_kernel_ink_mark_run_fp \fp_new:N \l__tenkz_kernel_ink_mark_len_fp \fp_new:N \l__tenkz_kernel_ink_mark_step_fp \fp_new:N \l__tenkz_kernel_ink_mark_ox_fp \fp_new:N \l__tenkz_kernel_ink_mark_oy_fp \fp_new:N \l__tenkz_kernel_ink_mark_cax_fp \fp_new:N \l__tenkz_kernel_ink_mark_cay_fp \fp_new:N \l__tenkz_kernel_ink_mark_cbx_fp \fp_new:N \l__tenkz_kernel_ink_mark_cby_fp \fp_new:N \l__tenkz_kernel_ink_mark_wx_fp \fp_new:N \l__tenkz_kernel_ink_mark_wy_fp \bool_new:N \l__tenkz_kernel_ink_mark_cubic_bool \fp_new:N \l__tenkz_kernel_ink_mark_resid_fp \fp_new:N \l__tenkz_kernel_ink_mark_found_resid_fp \fp_new:N \l__tenkz_kernel_ink_mark_found_len_fp \fp_new:N \l__tenkz_kernel_ink_mark_lerr_fp \fp_new:N \l__tenkz_kernel_ink_mark_flat_fp \seq_new:N \l__tenkz_kernel_ink_mark_stack_seq \tl_new:N \l__tenkz_kernel_ink_mark_piece_tl \tl_new:N \l__tenkz_kernel_ink_mark_step_tl \fp_new:N \l__tenkz_kernel_ink_mark_max_fp \fp_new:N \l__tenkz_kernel_ink_mark_may_fp \fp_new:N \l__tenkz_kernel_ink_mark_mbx_fp \fp_new:N \l__tenkz_kernel_ink_mark_mby_fp \fp_new:N \l__tenkz_kernel_ink_mark_mcx_fp \fp_new:N \l__tenkz_kernel_ink_mark_mcy_fp \fp_new:N \l__tenkz_kernel_ink_mark_dax_fp \fp_new:N \l__tenkz_kernel_ink_mark_day_fp \fp_new:N \l__tenkz_kernel_ink_mark_dbx_fp \fp_new:N \l__tenkz_kernel_ink_mark_dby_fp \fp_new:N \l__tenkz_kernel_ink_mark_mmx_fp \fp_new:N \l__tenkz_kernel_ink_mark_mmy_fp \fp_new:N \l__tenkz_kernel_ink_mark_px_fp \fp_new:N \l__tenkz_kernel_ink_mark_py_fp \fp_new:N \l__tenkz_kernel_ink_mark_qx_fp \fp_new:N \l__tenkz_kernel_ink_mark_qy_fp \fp_new:N \l__tenkz_kernel_ink_mark_mx_fp \fp_new:N \l__tenkz_kernel_ink_mark_my_fp \fp_new:N \l__tenkz_kernel_ink_mark_ux_fp \fp_new:N \l__tenkz_kernel_ink_mark_uy_fp \fp_new:N \l__tenkz_kernel_ink_mark_frac_fp \fp_new:N \l__tenkz_kernel_ink_mark_barb_fp \tl_new:N \l__tenkz_kernel_ink_mark_frac_tl \bool_new:N \l__tenkz_kernel_ink_mark_found_bool \bool_new:N \l__tenkz_kernel_ink_mark_drawn_bool % Convert a value already carried in an fp register to the stream's own % integer-scaled-point spelling, exactly as every other coordinate here is % written. \cs_new:Npn \__tenkz_kernel_r_fp_to_sp:N #1 { \dim_to_decimal_in_sp:n { \fp_to_decimal:N #1 pt } } % One segment's start/end, exactly as spath3 hands it back: `#1` is one % element of the already-populated `\l__tenkz_kernel_ink_seq`. A bare move % (no action) sets the drawn flag false and contributes nothing. \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink_mark_bounds:n #1 { \tl_set:Nn \l__tenkz_kernel_ink_seg_tl {#1} \spath_finalaction:NV \l__tenkz_kernel_ink_final_tl \l__tenkz_kernel_ink_seg_tl \tl_if_eq:NNTF \l__tenkz_kernel_ink_final_tl \c_spath_lineto_tl { \fp_set:Nn \l__tenkz_kernel_ink_mark_px_fp { \dim_to_fp:n { \tl_item:nn {#1} {2} } } \fp_set:Nn \l__tenkz_kernel_ink_mark_py_fp { \dim_to_fp:n { \tl_item:nn {#1} {3} } } \fp_set:Nn \l__tenkz_kernel_ink_mark_qx_fp { \dim_to_fp:n { \tl_item:nn {#1} {5} } } \fp_set:Nn \l__tenkz_kernel_ink_mark_qy_fp { \dim_to_fp:n { \tl_item:nn {#1} {6} } } \bool_set_false:N \l__tenkz_kernel_ink_mark_cubic_bool \fp_zero:N \l__tenkz_kernel_ink_mark_resid_fp \bool_set_true:N \l__tenkz_kernel_ink_mark_drawn_bool } { \tl_if_eq:NNTF \l__tenkz_kernel_ink_final_tl \c_spath_curveto_tl { \fp_set:Nn \l__tenkz_kernel_ink_mark_ox_fp { \dim_to_fp:n { \tl_item:nn {#1} {2} } } \fp_set:Nn \l__tenkz_kernel_ink_mark_oy_fp { \dim_to_fp:n { \tl_item:nn {#1} {3} } } \fp_set:Nn \l__tenkz_kernel_ink_mark_cax_fp { \dim_to_fp:n { \tl_item:nn {#1} {5} } } \fp_set:Nn \l__tenkz_kernel_ink_mark_cay_fp { \dim_to_fp:n { \tl_item:nn {#1} {6} } } \fp_set:Nn \l__tenkz_kernel_ink_mark_cbx_fp { \dim_to_fp:n { \tl_item:nn {#1} {8} } } \fp_set:Nn \l__tenkz_kernel_ink_mark_cby_fp { \dim_to_fp:n { \tl_item:nn {#1} {9} } } \fp_set:Nn \l__tenkz_kernel_ink_mark_wx_fp { \dim_to_fp:n { \tl_item:nn {#1} {11} } } \fp_set:Nn \l__tenkz_kernel_ink_mark_wy_fp { \dim_to_fp:n { \tl_item:nn {#1} {12} } } \bool_set_true:N \l__tenkz_kernel_ink_mark_cubic_bool \bool_set_true:N \l__tenkz_kernel_ink_mark_drawn_bool } { \bool_set_false:N \l__tenkz_kernel_ink_mark_drawn_bool } } } % The unit direction of the segment just bounded, reused by both branches % of the settling step below. \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink_mark_unit: { \fp_set:Nn \l__tenkz_kernel_ink_mark_ux_fp { \l__tenkz_kernel_ink_mark_len_fp > 0 ? ( \l__tenkz_kernel_ink_mark_qx_fp - \l__tenkz_kernel_ink_mark_px_fp ) / \l__tenkz_kernel_ink_mark_len_fp : 1 } \fp_set:Nn \l__tenkz_kernel_ink_mark_uy_fp { \l__tenkz_kernel_ink_mark_len_fp > 0 ? ( \l__tenkz_kernel_ink_mark_qy_fp - \l__tenkz_kernel_ink_mark_py_fp ) / \l__tenkz_kernel_ink_mark_len_fp : 0 } } \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink_mark_seg:n #1 { \bool_if:NTF \l__tenkz_kernel_ink_mark_cubic_bool { \tl_set:Nn \l__tenkz_kernel_ink_mark_step_tl {#1} \seq_clear:N \l__tenkz_kernel_ink_mark_stack_seq \seq_push:Ne \l__tenkz_kernel_ink_mark_stack_seq { {0} { \fp_use:N \l__tenkz_kernel_ink_mark_ox_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_oy_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_cax_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_cay_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_cbx_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_cby_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_wx_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_wy_fp } } \bool_until_do:nn { \seq_if_empty_p:N \l__tenkz_kernel_ink_mark_stack_seq } { \seq_pop:NN \l__tenkz_kernel_ink_mark_stack_seq \l__tenkz_kernel_ink_mark_piece_tl \exp_last_unbraced:NV \__tenkz_kernel_r_wire_ink_mark_piece:nnnnnnnnn \l__tenkz_kernel_ink_mark_piece_tl } } { #1 } } % One stacked piece: emit it as a chord when its interior controls sit % within tolerance of that chord (or at the depth cap), else split it at % the parameter midpoint and stack the far half over the near one. \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink_mark_piece:nnnnnnnnn #1#2#3#4#5#6#7#8#9 { % chord and flatness: the larger distance of the two controls from % the chord, taken as plain point distance when the chord degenerates \fp_set:Nn \l__tenkz_kernel_ink_mark_len_fp { sqrt ( ( (#8) - (#2) ) ^ 2 + ( (#9) - (#3) ) ^ 2 ) } \fp_set:Nn \l__tenkz_kernel_ink_mark_flat_fp { \fp_compare:nNnTF { \l__tenkz_kernel_ink_mark_len_fp } > { 0 } { max ( abs ( ( (#8) - (#2) ) * ( (#3) - (#5) ) - ( (#9) - (#3) ) * ( (#2) - (#4) ) ) / \l__tenkz_kernel_ink_mark_len_fp , abs ( ( (#8) - (#2) ) * ( (#3) - (#7) ) - ( (#9) - (#3) ) * ( (#2) - (#6) ) ) / \l__tenkz_kernel_ink_mark_len_fp ) } { max ( sqrt ( ( (#4) - (#2) ) ^ 2 + ( (#5) - (#3) ) ^ 2 ) , sqrt ( ( (#6) - (#2) ) ^ 2 + ( (#7) - (#3) ) ^ 2 ) ) } } \bool_lazy_or:nnTF { \int_compare_p:nNn {#1} > { 5 } } { \fp_compare_p:nNn { \l__tenkz_kernel_ink_mark_flat_fp } < { max ( \dim_to_fp:n { \__tenkz_dim:n {barblen} } / 8 , 1 / 20 ) } } { % emitted: the piece is one chord; the sandwich prices its % arc-length loss exactly (polygon minus chord), and its % flatness stands ready for the found-station residual \fp_set:Nn \l__tenkz_kernel_ink_mark_px_fp {#2} \fp_set:Nn \l__tenkz_kernel_ink_mark_py_fp {#3} \fp_set:Nn \l__tenkz_kernel_ink_mark_qx_fp {#8} \fp_set:Nn \l__tenkz_kernel_ink_mark_qy_fp {#9} \fp_set:Nn \l__tenkz_kernel_ink_mark_resid_fp { \l__tenkz_kernel_ink_mark_flat_fp } \fp_add:Nn \l__tenkz_kernel_ink_mark_lerr_fp { sqrt ( ( (#4) - (#2) ) ^ 2 + ( (#5) - (#3) ) ^ 2 ) + sqrt ( ( (#6) - (#4) ) ^ 2 + ( (#7) - (#5) ) ^ 2 ) + sqrt ( ( (#8) - (#6) ) ^ 2 + ( (#9) - (#7) ) ^ 2 ) - \l__tenkz_kernel_ink_mark_len_fp } \tl_use:N \l__tenkz_kernel_ink_mark_step_tl } { % split at the parameter midpoint (de Casteljau) and stack the % far half under the near one, so the walk stays in route order \__tenkz_kernel_r_wire_ink_mark_split:nnnnnnnnn {#1} {#2} {#3} {#4} {#5} {#6} {#7} {#8} {#9} } } \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink_mark_split:nnnnnnnnn #1#2#3#4#5#6#7#8#9 { \fp_set:Nn \l__tenkz_kernel_ink_mark_max_fp { ( (#2) + (#4) ) / 2 } \fp_set:Nn \l__tenkz_kernel_ink_mark_may_fp { ( (#3) + (#5) ) / 2 } \fp_set:Nn \l__tenkz_kernel_ink_mark_mbx_fp { ( (#4) + (#6) ) / 2 } \fp_set:Nn \l__tenkz_kernel_ink_mark_mby_fp { ( (#5) + (#7) ) / 2 } \fp_set:Nn \l__tenkz_kernel_ink_mark_mcx_fp { ( (#6) + (#8) ) / 2 } \fp_set:Nn \l__tenkz_kernel_ink_mark_mcy_fp { ( (#7) + (#9) ) / 2 } \fp_set:Nn \l__tenkz_kernel_ink_mark_dax_fp { ( \l__tenkz_kernel_ink_mark_max_fp + \l__tenkz_kernel_ink_mark_mbx_fp ) / 2 } \fp_set:Nn \l__tenkz_kernel_ink_mark_day_fp { ( \l__tenkz_kernel_ink_mark_may_fp + \l__tenkz_kernel_ink_mark_mby_fp ) / 2 } \fp_set:Nn \l__tenkz_kernel_ink_mark_dbx_fp { ( \l__tenkz_kernel_ink_mark_mbx_fp + \l__tenkz_kernel_ink_mark_mcx_fp ) / 2 } \fp_set:Nn \l__tenkz_kernel_ink_mark_dby_fp { ( \l__tenkz_kernel_ink_mark_mby_fp + \l__tenkz_kernel_ink_mark_mcy_fp ) / 2 } \fp_set:Nn \l__tenkz_kernel_ink_mark_mmx_fp { ( \l__tenkz_kernel_ink_mark_dax_fp + \l__tenkz_kernel_ink_mark_dbx_fp ) / 2 } \fp_set:Nn \l__tenkz_kernel_ink_mark_mmy_fp { ( \l__tenkz_kernel_ink_mark_day_fp + \l__tenkz_kernel_ink_mark_dby_fp ) / 2 } % far half first, so the near half pops first \seq_push:Ne \l__tenkz_kernel_ink_mark_stack_seq { { \int_eval:n { #1 + 1 } } { \fp_use:N \l__tenkz_kernel_ink_mark_mmx_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_mmy_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_dbx_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_dby_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_mcx_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_mcy_fp } {#8} {#9} } \seq_push:Ne \l__tenkz_kernel_ink_mark_stack_seq { { \int_eval:n { #1 + 1 } } {#2} {#3} { \fp_use:N \l__tenkz_kernel_ink_mark_max_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_may_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_dax_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_day_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_mmx_fp } { \fp_use:N \l__tenkz_kernel_ink_mark_mmy_fp } } } % One segment of the settling pass: extend the running length by this % segment, or, once the target arc length falls inside it, interpolate the % station point and stop moving past it. Every segment before the target % settles also leaves its own end as a fallback station, so a target that % lands past the last segment by rounding still resolves to the route's own % end rather than to nothing. \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink_mark_settle: { \fp_set:Nn \l__tenkz_kernel_ink_mark_len_fp { sqrt( ( \l__tenkz_kernel_ink_mark_qx_fp - \l__tenkz_kernel_ink_mark_px_fp ) ^ 2 + ( \l__tenkz_kernel_ink_mark_qy_fp - \l__tenkz_kernel_ink_mark_py_fp ) ^ 2 ) } \fp_compare:nNnTF { \l__tenkz_kernel_ink_mark_run_fp + \l__tenkz_kernel_ink_mark_len_fp } < { \l__tenkz_kernel_ink_mark_target_fp } { \fp_add:Nn \l__tenkz_kernel_ink_mark_run_fp { \l__tenkz_kernel_ink_mark_len_fp } \fp_set_eq:NN \l__tenkz_kernel_ink_mark_mx_fp \l__tenkz_kernel_ink_mark_qx_fp \fp_set_eq:NN \l__tenkz_kernel_ink_mark_my_fp \l__tenkz_kernel_ink_mark_qy_fp \__tenkz_kernel_r_wire_ink_mark_unit: } { \fp_set:Nn \l__tenkz_kernel_ink_mark_step_fp { \l__tenkz_kernel_ink_mark_len_fp > 0 ? ( \l__tenkz_kernel_ink_mark_target_fp - \l__tenkz_kernel_ink_mark_run_fp ) / \l__tenkz_kernel_ink_mark_len_fp : 0 } \fp_set:Nn \l__tenkz_kernel_ink_mark_mx_fp { \l__tenkz_kernel_ink_mark_px_fp + \l__tenkz_kernel_ink_mark_step_fp * ( \l__tenkz_kernel_ink_mark_qx_fp - \l__tenkz_kernel_ink_mark_px_fp ) } \fp_set:Nn \l__tenkz_kernel_ink_mark_my_fp { \l__tenkz_kernel_ink_mark_py_fp + \l__tenkz_kernel_ink_mark_step_fp * ( \l__tenkz_kernel_ink_mark_qy_fp - \l__tenkz_kernel_ink_mark_py_fp ) } \__tenkz_kernel_r_wire_ink_mark_unit: \fp_set_eq:NN \l__tenkz_kernel_ink_mark_found_resid_fp \l__tenkz_kernel_ink_mark_resid_fp \fp_set_eq:NN \l__tenkz_kernel_ink_mark_found_len_fp \l__tenkz_kernel_ink_mark_len_fp \bool_set_true:N \l__tenkz_kernel_ink_mark_found_bool } } % Write the barb's own cover: a segment of the barb's configured length, % centred on the found station along its local direction, stroked to that % same length -- generous enough to clear a Straight Barb's lateral spread % on any bearing, honest in the same direction a dash gap's over-report is. \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink_mark_emit: { % The found segment's residual chord deviation widens the cover: it % is zero wherever the subdivision met its bound, and exactly the % proven gap where a pathological cubic outran the ceiling, so a % label on the true curve intersects the emitted band at any size. % The cover widens by the found piece's flatness and the walk's % accumulated sandwich loss. A found piece shorter than the barb % cannot vouch for its own direction -- a small near-cusp passes the % flatness floor with a sideways tangent -- so such a station is % covered isotropically, the barb's own length joining the width. % The sum is clamped inside TeX's dimension range: a pathological % accumulation saturates the cover instead of overflowing the page. \fp_set:Nn \l__tenkz_kernel_ink_mark_barb_fp { min ( \dim_to_fp:n { \c_max_dim } / 4 , \dim_to_fp:n { \__tenkz_dim:n {barblen} } + 2 * \l__tenkz_kernel_ink_mark_found_resid_fp + 2 * \l__tenkz_kernel_ink_mark_lerr_fp + \fp_compare:nNnTF { \l__tenkz_kernel_ink_mark_found_len_fp } < { \dim_to_fp:n { \__tenkz_dim:n {barblen} } } { \dim_to_fp:n { \__tenkz_dim:n {barblen} } } { 0 } ) } \fp_set:Nn \l__tenkz_kernel_ink_mark_px_fp { \l__tenkz_kernel_ink_mark_mx_fp - \l__tenkz_kernel_ink_mark_barb_fp / 2 * \l__tenkz_kernel_ink_mark_ux_fp } \fp_set:Nn \l__tenkz_kernel_ink_mark_py_fp { \l__tenkz_kernel_ink_mark_my_fp - \l__tenkz_kernel_ink_mark_barb_fp / 2 * \l__tenkz_kernel_ink_mark_uy_fp } \fp_set:Nn \l__tenkz_kernel_ink_mark_qx_fp { \l__tenkz_kernel_ink_mark_mx_fp + \l__tenkz_kernel_ink_mark_barb_fp / 2 * \l__tenkz_kernel_ink_mark_ux_fp } \fp_set:Nn \l__tenkz_kernel_ink_mark_qy_fp { \l__tenkz_kernel_ink_mark_my_fp + \l__tenkz_kernel_ink_mark_barb_fp / 2 * \l__tenkz_kernel_ink_mark_uy_fp } \__tenkz_kernel_event:n { wire-ink|picture=k\int_use:N \g__tenkz_kernel_picture_int |name=\tl_use:N \l__tenkz_kernel_r_sid_tl |origin=mark |stroke=\__tenkz_kernel_r_fp_to_sp:N \l__tenkz_kernel_ink_mark_barb_fp |points=\__tenkz_kernel_r_fp_to_sp:N \l__tenkz_kernel_ink_mark_px_fp ,\__tenkz_kernel_r_fp_to_sp:N \l__tenkz_kernel_ink_mark_py_fp ;\__tenkz_kernel_r_fp_to_sp:N \l__tenkz_kernel_ink_mark_qx_fp ,\__tenkz_kernel_r_fp_to_sp:N \l__tenkz_kernel_ink_mark_qy_fp } } % The two-pass walk: total the route's arc length, then find the point at % the wire's stashed station fraction of that total. A degenerate route % (zero drawn length) writes nothing -- there is no barb to cover. \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink_mark_walk: { \fp_zero:N \l__tenkz_kernel_ink_mark_total_fp \fp_zero:N \l__tenkz_kernel_ink_mark_lerr_fp \seq_map_inline:Nn \l__tenkz_kernel_ink_seq { \__tenkz_kernel_r_wire_ink_mark_bounds:n {##1} \bool_if:NT \l__tenkz_kernel_ink_mark_drawn_bool { \__tenkz_kernel_r_wire_ink_mark_seg:n { \fp_add:Nn \l__tenkz_kernel_ink_mark_total_fp { sqrt( ( \l__tenkz_kernel_ink_mark_qx_fp - \l__tenkz_kernel_ink_mark_px_fp ) ^ 2 + ( \l__tenkz_kernel_ink_mark_qy_fp - \l__tenkz_kernel_ink_mark_py_fp ) ^ 2 ) } } } } \fp_compare:nNnT { \l__tenkz_kernel_ink_mark_total_fp } > { 0 } { \fp_set:Nn \l__tenkz_kernel_ink_mark_target_fp { \l__tenkz_kernel_ink_mark_frac_fp * \l__tenkz_kernel_ink_mark_total_fp } \fp_zero:N \l__tenkz_kernel_ink_mark_run_fp % the accumulator keeps the total pass's sum and the settling % pass adds its walked prefix on top: the station shift is % bounded by the target's error (the full total) plus the run's % (the prefix), and the sum of the two is exactly what stands % here at emit time \fp_zero:N \l__tenkz_kernel_ink_mark_found_resid_fp \fp_set:Nn \l__tenkz_kernel_ink_mark_found_len_fp { \dim_to_fp:n { \c_max_dim } } \bool_set_false:N \l__tenkz_kernel_ink_mark_found_bool \seq_map_inline:Nn \l__tenkz_kernel_ink_seq { \bool_if:NF \l__tenkz_kernel_ink_mark_found_bool { \__tenkz_kernel_r_wire_ink_mark_bounds:n {##1} \bool_if:NT \l__tenkz_kernel_ink_mark_drawn_bool { \__tenkz_kernel_r_wire_ink_mark_seg:n { \bool_if:NF \l__tenkz_kernel_ink_mark_found_bool { \__tenkz_kernel_r_wire_ink_mark_settle: } } } } } \__tenkz_kernel_r_wire_ink_mark_emit: } } % Entry point: a wire with no stashed station drew no direction mark, and % writes nothing. \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink_mark:n #1 { \prop_get:NnNTF \l__tenkz_kernel_r_dir_mark_prop {#1} \l__tenkz_kernel_ink_mark_frac_tl { \fp_set:Nn \l__tenkz_kernel_ink_mark_frac_fp { \l__tenkz_kernel_ink_mark_frac_tl } \__tenkz_kernel_r_wire_ink_mark_walk: } { } } \cs_new_protected:Npn \__tenkz_kernel_r_wire_stroke:nn #1#2 { \tl_set:Ne \l__tenkz_kernel_r_wire_style_tl { #1 , \tl_use:N \l__tenkz_kernel_r_wire_ink_tl } \exp_args:NV \__tenkz_kernel_r_sid:nN \l__tenkz_kernel_r_wire_record_tl \l__tenkz_kernel_r_sid_tl \exp_args:NV \__tenkz_string_save_route:nn \l__tenkz_kernel_r_sid_tl {#2} % The origin names the reach doctrine that put the ink down. A caller % that knows better -- the open-port leg -- states its origin before % the stroke; every other route reads it off its own style word. The % record itself is written later, at the stroke pass, from the saved % path as crossing surgery leaves it; only the origin is minuted here. \tl_if_empty:NT \l__tenkz_kernel_ink_origin_tl { \tl_set:Ne \l__tenkz_kernel_ink_origin_tl { \str_case:nnF {#1} { { physical~leg } { physical-leg } { trace } { trace } } { bond } } } \prop_put:NVV \l__tenkz_kernel_ink_origin_prop \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_ink_origin_tl \tl_clear:N \l__tenkz_kernel_ink_origin_tl \prop_put:NVV \l__tenkz_kernel_r_sid_record_prop \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_wire_record_tl \prop_put:NVV \l__tenkz_kernel_r_index_sid_prop \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_wire_record_tl \prop_put:NVV \l__tenkz_kernel_r_index_style_prop \l__tenkz_kernel_r_wire_record_tl \l__tenkz_kernel_r_wire_style_tl \seq_put_right:NV \l__tenkz_kernel_r_index_routes_seq \l__tenkz_kernel_r_wire_record_tl } \cs_new_protected:Npn \__tenkz_kernel_r_wire_queue:n #1 { \__tenkz_model_get:nnN {#1} {kind} \l__tenkz_kernel_r_tl \str_if_eq:VnT \l__tenkz_kernel_r_tl {string} { \seq_put_right:Nn \l__tenkz_kernel_r_strings_seq {#1} } } \cs_new_protected:Npn \__tenkz_kernel_r_wire:n #1 { \tl_set:Nn \l__tenkz_kernel_r_wire_record_tl {#1} \__tenkz_model_get:nnN {#1} {kind} \l__tenkz_kernel_r_tl \str_if_eq:VnTF \l__tenkz_kernel_r_tl {string} { } { % Settle the endpoint dependency graph before emitting this wire's % ink. This predeclares any curve named by an `on w t` end while % leaving unrelated string event order unchanged. \__tenkz_kernel_settle:n {#1} \__tenkz_kernel_r_wire_ink:nN {#1} \l__tenkz_kernel_r_wire_ink_tl \__tenkz_model_get:nnN {#1} {origin} \l__tenkz_kernel_r_tl \quark_if_no_value:NTF \l__tenkz_kernel_r_tl { \__tenkz_kernel_r_wire_ends:n {#1} } { \str_case:VnF \l__tenkz_kernel_r_tl { {grid} { \__tenkz_kernel_r_wire_grid:n {#1} } {open} { \__tenkz_model_get:nnN {#1} {physical-axis} \l__tenkz_kernel_r_tl \str_if_eq:VnTF \l__tenkz_kernel_r_tl {transverse} { \__tenkz_kernel_r_wire_physical_axis_open:n {#1} } { \__tenkz_kernel_r_wire_ends:n {#1} } } {port-open} { \__tenkz_kernel_r_wire_port_open:n {#1} } {trace} { \__tenkz_kernel_r_wire_trace:n {#1} } {cup} { \__tenkz_kernel_r_wire_cup:n {#1} } % A skin wire settles here so its endpoint geometry is ready, % but its ink belongs over the carrying glyph. {skin} { } % A policy leg is a record of the frame's outward index; the % leg pass below measures its reach and inks it. {policy-leg} { } } { \msg_error:nnee {tenkz}{kernel-render-todo} { origin = \tl_use:N \l__tenkz_kernel_r_tl } {#1} } } } } % A row-zero physical opening on a plane consumes the same frame-owned axis % as picture physical policy. It therefore starts at the glyph's transverse % support point rather than inventing an authored numeric port. \cs_new_protected:Npn \__tenkz_kernel_r_wire_physical_axis_open:n #1 { \__tenkz_model_get:nnN {#1} {from-host} \l__tenkz_kernel_physical_axis_host_tl \__tenkz_model_get:nnN {#1} {from-axis} \l__tenkz_kernel_r_b_tl \quark_if_no_value:NF \l__tenkz_kernel_physical_axis_host_tl { \exp_args:NVV \__tenkz_kernel_r_physical_axis:nnNN \l__tenkz_kernel_physical_axis_host_tl \l__tenkz_kernel_r_b_tl \l__tenkz_kernel_leg_dir_tl \l__tenkz_kernel_r_physical_anchor_tl \exp_args:NVV \__tenkz_kernel_r_glyph_anchor_or_site_xy:nnNN \l__tenkz_kernel_physical_axis_host_tl \l__tenkz_kernel_r_physical_anchor_tl \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \fp_set:Nn \l__tenkz_kernel_r_reach_fp { \__tenkz_metric_ratio:n {physleg} } % A plane transverse leg leaves the sheet, not its perimeter. \bool_if:NF \l__tenkz_kernel_r_basis_plane_bool { \exp_args:NVV \__tenkz_kernel_r_physical_enclosure:nn \l__tenkz_kernel_physical_axis_host_tl \l__tenkz_kernel_r_b_tl } \fp_set:Nn \l__tenkz_kernel_r_xb_fp { \l__tenkz_kernel_r_x_fp + \l__tenkz_kernel_r_reach_fp * cosd( \l__tenkz_kernel_leg_dir_tl ) } \fp_set:Nn \l__tenkz_kernel_r_yb_fp { \l__tenkz_kernel_r_y_fp + \l__tenkz_kernel_r_reach_fp * sind( \l__tenkz_kernel_leg_dir_tl ) } \__tenkz_kernel_r_wire_stroke:nn { physical~leg } { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yb_fp } } } } % A declared port that no wire consumes owns a short open leg. Its type % selects the existing reach doctrine; its authored face is transported by % the same complete carrier basis used by attached wires and labels. \cs_new_protected:Npn \__tenkz_kernel_r_wire_port_open:n #1 { \__tenkz_kernel_r_port_open_geometry:n {#1} \__tenkz_kernel_r_port_box_register:n {#1} % An unconsumed declared port grows a stub the occupancy table never % charted: neither the host's own station promise nor that of the % neighbor the stub grows toward can stand. \__tenkz_kernel_r_label_blind:V \l__tenkz_kernel_port_record_tl \exp_args:NV \__tenkz_kernel_atom_rc:nNNN \l__tenkz_kernel_port_record_tl \l__tenkz_kernel_lab_row_tl \l__tenkz_kernel_lab_col_tl \l__tenkz_kernel_lab_cell_bool \bool_if:NT \l__tenkz_kernel_lab_cell_bool { \__tenkz_kernel_r_face_side:n { \tl_use:N \l__tenkz_kernel_port_face_tl } \__tenkz_kernel_r_label_blind_neighbor:eee { \tl_use:N \l__tenkz_kernel_lab_row_tl } { \tl_use:N \l__tenkz_kernel_lab_col_tl } { \tl_use:N \l__tenkz_kernel_r_face_side_tl } } \fp_set_eq:NN \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_port_x_fp \fp_set_eq:NN \l__tenkz_kernel_r_y_fp \l__tenkz_kernel_r_port_y_fp \fp_set_eq:NN \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_port_tip_x_fp \fp_set_eq:NN \l__tenkz_kernel_r_yb_fp \l__tenkz_kernel_r_port_tip_y_fp \tl_set_eq:NN \l__tenkz_kernel_r_leg_turn_tl \l__tenkz_kernel_r_port_turn_tl \tl_set:Ne \l__tenkz_kernel_r_pts_tl { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yb_fp } } \tl_set:Ne \l__tenkz_kernel_r_tl { \str_if_eq:VnTF \l__tenkz_kernel_port_type_tl {physical} { physical~leg } { bond } } \tl_set:Nn \l__tenkz_kernel_ink_origin_tl { port } \exp_args:NVV \__tenkz_kernel_r_wire_stroke:nn \l__tenkz_kernel_r_tl \l__tenkz_kernel_r_pts_tl \seq_put_right:Nn \l__tenkz_kernel_r_port_label_routes_seq {#1} } \cs_new_protected:Npn \__tenkz_kernel_r_port_open_label:n #1 { \__tenkz_model_get:nnN {#1} {port-label} \l__tenkz_kernel_port_label_tl \quark_if_no_value:NF \l__tenkz_kernel_port_label_tl { \__tenkz_kernel_r_port_open_geometry:n {#1} \__tenkz_render_labelnode:nnn { tenkz~audited~label , anchor = \exp_args:NV \__tenkz_render_label_anchor:n \l__tenkz_kernel_r_port_turn_tl , inner~sep = \__tenkz_dim:n {labelclear} } { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_port_tip_x_fp } { \l__tenkz_kernel_r_port_tip_y_fp } } { $ \tl_use:N \l__tenkz_kernel_port_label_tl $ } } } \fp_new:N \l__tenkz_kernel_r_port_xmin_fp \fp_new:N \l__tenkz_kernel_r_port_xmax_fp \fp_new:N \l__tenkz_kernel_r_port_ymin_fp \fp_new:N \l__tenkz_kernel_r_port_ymax_fp \tl_new:N \l__tenkz_kernel_r_port_host_tl \cs_new_protected:Npn \__tenkz_kernel_r_port_box_register:n #1 { \fp_set:Nn \l__tenkz_kernel_r_port_xmin_fp { min(\l__tenkz_kernel_r_port_x_fp,\l__tenkz_kernel_r_port_tip_x_fp) } \fp_set:Nn \l__tenkz_kernel_r_port_xmax_fp { max(\l__tenkz_kernel_r_port_x_fp,\l__tenkz_kernel_r_port_tip_x_fp) } \fp_set:Nn \l__tenkz_kernel_r_port_ymin_fp { min(\l__tenkz_kernel_r_port_y_fp,\l__tenkz_kernel_r_port_tip_y_fp) } \fp_set:Nn \l__tenkz_kernel_r_port_ymax_fp { max(\l__tenkz_kernel_r_port_y_fp,\l__tenkz_kernel_r_port_tip_y_fp) } \__tenkz_model_get:nnN {#1} {host} \l__tenkz_kernel_r_port_host_tl \__tenkz_kernel_r_sid:nN {#1} \l__tenkz_kernel_r_sid_tl % Distinct outward ports on one opaque carrier share only their hidden % carrier interior. Keep the complete semantic paths for `on w t`, while % telling crossing police that this topology-owned overlap is intentional. \prop_get:NVN \l__tenkz_kernel_r_port_host_routes_prop \l__tenkz_kernel_r_port_host_tl \l__tenkz_kernel_r_tl \quark_if_no_value:NTF \l__tenkz_kernel_r_tl { \prop_put:NVV \l__tenkz_kernel_r_port_host_routes_prop \l__tenkz_kernel_r_port_host_tl \l__tenkz_kernel_r_sid_tl } { \exp_args:NV \clist_map_inline:nn \l__tenkz_kernel_r_tl { \exp_args:NV \__tenkz_string_touch:nn \l__tenkz_kernel_r_sid_tl {##1} } \tl_put_right:Ne \l__tenkz_kernel_r_tl {,\tl_use:N \l__tenkz_kernel_r_sid_tl} \prop_put:NVV \l__tenkz_kernel_r_port_host_routes_prop \l__tenkz_kernel_r_port_host_tl \l__tenkz_kernel_r_tl } \prop_map_inline:Nn \l__tenkz_kernel_r_port_box_prop { \__tenkz_kernel_r_port_box_compare:nnnnn {##1} ##2 } \prop_put:NVx \l__tenkz_kernel_r_port_box_prop \l__tenkz_kernel_r_sid_tl { { \fp_use:N \l__tenkz_kernel_r_port_xmin_fp } { \fp_use:N \l__tenkz_kernel_r_port_xmax_fp } { \fp_use:N \l__tenkz_kernel_r_port_ymin_fp } { \fp_use:N \l__tenkz_kernel_r_port_ymax_fp } } } \cs_new_protected:Npn \__tenkz_kernel_r_port_box_compare:nnnnn #1#2#3#4#5 { \bool_lazy_or:nnT { \fp_compare_p:nNn { \l__tenkz_kernel_r_port_xmax_fp } < {#2} || \fp_compare_p:nNn {#3} < { \l__tenkz_kernel_r_port_xmin_fp } } { \fp_compare_p:nNn { \l__tenkz_kernel_r_port_ymax_fp } < {#4} || \fp_compare_p:nNn {#5} < { \l__tenkz_kernel_r_port_ymin_fp } } { \exp_args:NV \__tenkz_string_disjoint:nn \l__tenkz_kernel_r_sid_tl {#1} } } % Cup records already own the paired row or column indices. Rendering only % turns those resolved endpoints into an outboard half-ellipse. % All four sides stroke the same cubic between the resolved endpoints: both % control points sit the stub distance outboard along the side's outward % axis. The side branch supplies that offset term for each axis; the other % axis receives the empty term. \cs_new_protected:Npn \__tenkz_kernel_r_wire_cup_stroke:nn #1#2 { \__tenkz_kernel_r_wire_stroke:nn { bond } { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } .. controls \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp #1 } { \l__tenkz_kernel_r_y_fp #2 } and \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_xb_fp #1 } { \l__tenkz_kernel_r_yb_fp #2 } .. \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yb_fp } } } \cs_new_protected:Npn \__tenkz_kernel_r_wire_cup:n #1 { \__tenkz_model_get:nnN {#1} {side} \l__tenkz_kernel_r_tl \str_case:VnF \l__tenkz_kernel_r_tl { {west} { \__tenkz_model_get:nnN {#1} {top} \l__tenkz_kernel_r_row_tl \__tenkz_model_get:nnN {#1} {bottom} \l__tenkz_kernel_r_col_tl \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_row_tl } {1} \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_col_tl } {1} \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \__tenkz_kernel_r_wire_cup_stroke:nn { - \__tenkz_metric_ratio:n {stub} } { } } {east} { \__tenkz_model_get:nnN {#1} {top} \l__tenkz_kernel_r_row_tl \__tenkz_model_get:nnN {#1} {bottom} \l__tenkz_kernel_r_col_tl \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_row_tl } { \l__tenkz_kernel_r_cols_int } \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_col_tl } { \l__tenkz_kernel_r_cols_int } \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \__tenkz_kernel_r_wire_cup_stroke:nn { + \__tenkz_metric_ratio:n {stub} } { } } {north} { \__tenkz_model_get:nnN {#1} {left} \l__tenkz_kernel_r_row_tl \__tenkz_model_get:nnN {#1} {right} \l__tenkz_kernel_r_col_tl \__tenkz_kernel_r_frame_xy:nnNN {1} { \l__tenkz_kernel_r_row_tl } \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \__tenkz_kernel_r_frame_xy:nnNN {1} { \l__tenkz_kernel_r_col_tl } \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \__tenkz_kernel_r_wire_cup_stroke:nn { } { + \__tenkz_metric_ratio:n {stub} } } {south} { \__tenkz_model_get:nnN {#1} {left} \l__tenkz_kernel_r_row_tl \__tenkz_model_get:nnN {#1} {right} \l__tenkz_kernel_r_col_tl \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_rows_int } { \l__tenkz_kernel_r_row_tl } \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_rows_int } { \l__tenkz_kernel_r_col_tl } \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \__tenkz_kernel_r_wire_cup_stroke:nn { } { - \__tenkz_metric_ratio:n {stub} } } } { \msg_error:nnee {tenkz}{kernel-render-todo} { cup ~ side = \tl_use:N \l__tenkz_kernel_r_tl } {#1} } } % A bond between two unoccupied cells is rail territory: the wrap records % own that ink, and without them the cells are bare crossings of nothing. % A grid bond inks when either endpoint cell carries a live atom. The % occupancy table holds the cells the body claimed; a frame-populated % non-wire cell carries the atom the frame put there, and Section 2.2 makes % its bond the same declared contraction, so it inks on the same rule. A % wire-row cell populates nothing: its rail segment still waits for an % authored neighbour, and an all-empty wire row still draws no ink. \cs_new_protected:Npn \__tenkz_kernel_r_wire_grid:n #1 { \bool_set_false:N \l_tmpa_bool \clist_map_inline:nn {from, to} { \__tenkz_model_get:nnN {#1} {##1} \l__tenkz_kernel_r_tl \tl_set:Ne \l__tenkz_kernel_r_end_tl { \__tenkz_kernel_node_item:Nn \l__tenkz_kernel_r_tl {row} - \__tenkz_kernel_node_item:Nn \l__tenkz_kernel_r_tl {col} } \prop_if_in:NVT \l__tenkz_kernel_cell_prop \l__tenkz_kernel_r_end_tl { \bool_set_true:N \l_tmpa_bool } \prop_if_in:NVT \l__tenkz_kernel_populated_cell_prop \l__tenkz_kernel_r_end_tl { \bool_set_true:N \l_tmpa_bool } } \bool_if:NT \l_tmpa_bool { \__tenkz_kernel_r_wire_ends:n {#1} } } \cs_new_protected:Npn \__tenkz_kernel_r_wire_end_xy:nNN #1#2#3 { \__tenkz_kernel_r_node:n {#1} \__tenkz_kernel_r_xy:nNN {#1} #2 #3 \str_if_eq:eeT { \__tenkz_kernel_node_item:nn {#1} {kind} } {port} { \__tenkz_kernel_r_port_record:nN {#1} \l__tenkz_kernel_r_tl \quark_if_no_value:NF \l__tenkz_kernel_r_tl { \exp_args:NV \__tenkz_kernel_atom_rc:nNNN \l__tenkz_kernel_r_tl \l__tenkz_kernel_r_row_tl \l__tenkz_kernel_r_col_tl \l_tmpa_bool % Bare physical ports meet their glyphless host, whether a % wire consumes them or the policy leaves an open leg. \str_if_eq:eeT { \__tenkz_kernel_node_item:nn {#1} {port-type} } {physical} { \exp_args:NV \__tenkz_kernel_hull_resolve_skin:n \l__tenkz_kernel_r_tl \str_if_eq:VnT \l__tenkz_kernel_hull_skin_tl {none} { \prop_if_in:NVF \l__tenkz_kernel_skin_pairing_host_prop \l__tenkz_kernel_r_tl { \exp_args:NV \__tenkz_kernel_r_xy:nNN \l__tenkz_kernel_r_tl #2 #3 \bool_set_true:N \l_tmpa_bool } } } \bool_if:NF \l_tmpa_bool { \__tenkz_kernel_r_hull_port_xy:nVNN {#1} \l__tenkz_kernel_r_tl #2 #3 } } } } \cs_generate_variant:Nn \__tenkz_kernel_r_wire_end_xy:nNN { VNN } \cs_new_protected:Npn \__tenkz_kernel_r_wire_ends:n #1 { \bool_set_false:N \l__tenkz_kernel_r_from_bool \bool_set_false:N \l__tenkz_kernel_r_to_bool \__tenkz_model_get:nnN {#1} {from} \l__tenkz_kernel_r_end_tl \quark_if_no_value:NF \l__tenkz_kernel_r_end_tl { \__tenkz_kernel_r_wire_end_xy:VNN \l__tenkz_kernel_r_end_tl \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \bool_set_true:N \l__tenkz_kernel_r_from_bool } \__tenkz_model_get:nnN {#1} {to} \l__tenkz_kernel_r_end_tl \quark_if_no_value:NF \l__tenkz_kernel_r_end_tl { \__tenkz_kernel_r_wire_end_xy:VNN \l__tenkz_kernel_r_end_tl \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \bool_set_true:N \l__tenkz_kernel_r_to_bool } \bool_if:NF \l__tenkz_kernel_r_from_bool { \__tenkz_model_get:nnN {#1} {from-open} \l__tenkz_kernel_r_end_tl \quark_if_no_value:NF \l__tenkz_kernel_r_end_tl { \str_if_eq:eeTF { \__tenkz_kernel_r_frame_word: } {plane} { \fp_set_eq:NN \l__tenkz_kernel_r_xc_fp \l__tenkz_kernel_r_xb_fp \fp_set_eq:NN \l__tenkz_kernel_r_yc_fp \l__tenkz_kernel_r_yb_fp \exp_args:NV \__tenkz_kernel_r_open_tip_affine_xy:nNN \l__tenkz_kernel_r_end_tl \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp } { \fp_set:Nn \l__tenkz_kernel_r_x_fp { \l__tenkz_kernel_r_xb_fp + \__tenkz_metric_ratio:n {stub} * cosd(\__tenkz_kernel_r_compass:n {\l__tenkz_kernel_r_end_tl}) } \fp_set:Nn \l__tenkz_kernel_r_y_fp { \l__tenkz_kernel_r_yb_fp + \__tenkz_metric_ratio:n {stub} * sind(\__tenkz_kernel_r_compass:n {\l__tenkz_kernel_r_end_tl}) } } \bool_set_true:N \l__tenkz_kernel_r_from_bool } } \bool_if:NF \l__tenkz_kernel_r_to_bool { \__tenkz_model_get:nnN {#1} {to-open} \l__tenkz_kernel_r_end_tl \quark_if_no_value:NF \l__tenkz_kernel_r_end_tl { \str_if_eq:eeTF { \__tenkz_kernel_r_frame_word: } {plane} { \fp_set_eq:NN \l__tenkz_kernel_r_xc_fp \l__tenkz_kernel_r_x_fp \fp_set_eq:NN \l__tenkz_kernel_r_yc_fp \l__tenkz_kernel_r_y_fp \exp_args:NV \__tenkz_kernel_r_open_tip_affine_xy:nNN \l__tenkz_kernel_r_end_tl \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp } { \fp_set:Nn \l__tenkz_kernel_r_xb_fp { \l__tenkz_kernel_r_x_fp + \__tenkz_metric_ratio:n {stub} * cosd(\__tenkz_kernel_r_compass:n {\l__tenkz_kernel_r_end_tl}) } \fp_set:Nn \l__tenkz_kernel_r_yb_fp { \l__tenkz_kernel_r_y_fp + \__tenkz_metric_ratio:n {stub} * sind(\__tenkz_kernel_r_compass:n {\l__tenkz_kernel_r_end_tl}) } } \bool_set_true:N \l__tenkz_kernel_r_to_bool } } \bool_lazy_and:nnT { \l__tenkz_kernel_r_from_bool } { \l__tenkz_kernel_r_to_bool } { % an ellipsis endpoint keeps daylight: the wire stops short of the dots \clist_map_inline:nn {from, to} { \__tenkz_kernel_r_dots_trim:nn {#1} {##1} } \__tenkz_model_get:nnN {#1} {port-type} \l__tenkz_kernel_port_type_tl \tl_set:Ne \l__tenkz_kernel_r_tl { \str_if_eq:VnTF \l__tenkz_kernel_port_type_tl {physical} { physical~leg } { bond } } \__tenkz_model_get:nnN {#1} {route} \l__tenkz_kernel_r_end_tl \str_if_eq:VnTF \l__tenkz_kernel_r_end_tl {arc} { \__tenkz_kernel_r_arc_controls:n {#1} \exp_args:NVV \__tenkz_kernel_r_wire_stroke:nn \l__tenkz_kernel_r_tl \l__tenkz_kernel_r_arc_path_tl } { \exp_args:NV \__tenkz_kernel_r_wire_stroke:nn \l__tenkz_kernel_r_tl { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yb_fp } } } } } % The control frame of an arc route. The word's contract sentence % (LANGUAGE-1.0 section 2.4) is the geometry: the curve leaves and enters % along its ends' faces. A port states the angle its ink leaves at, so its % control point stands outside that face; an open end states the direction % its tip projects, so its control point stands back along it; any other % end -- an anchor, a cell, a waypoint -- has no face to honour and answers % the chord, so an arc between two faceless ends is the straight bond it % always drew. % % The control distance is derived, not chosen: the drawn curve is the one % cubic that closes the circular arc the two tangents admit. A turn of % Delta between the leaving and the arriving direction closes a circle % whose cubic takes its controls at (4/3) tan(Delta/4) of the radius, and % the chord subtends Delta, so per unit chord the distance is % (4/3) tan(Delta/4) / (2 sin(Delta/2)): a quarter turn closes a quarter % circle, a same-face fold closes a half circle, and the straight limit % is a third of the chord, which leaves a faceless arc's controls on the % chord itself. % % One pair of faces no single curve can honour: two ports facing away % from each other along the chord's own line. Every control point then % lies on that line and any one cubic retraces itself, so the route is % drawn as a wrap instead -- a half-circle fold out of each face joined % by a run parallel to the chord, standing half a chord to the side of % it, on the side the from-turn names. The travel tangents at both ends % still honour the faces exactly. % % Reads the trimmed endpoints from the x/y and xb/yb registers and leaves % the finished path in \l__tenkz_kernel_r_arc_path_tl; the wrap flag and % its two run stations stay readable for the early on-wire resolver. % The per-unit-chord control distance that closes the circular arc a % turn of #1 degrees admits: (4/3) tan(#1/4) of the radius, and the % chord subtends #1. The straight limit is a third of the chord. \cs_new_protected:Npn \__tenkz_kernel_r_arc_close:nN #1#2 { \fp_set:Nn #2 { \fp_compare:nNnTF {#1} > { 1 } { ( 4 * tand ( (#1) / 4 ) ) / ( 6 * sind ( (#1) / 2 ) ) } { ( 1 / 3 ) } } } \cs_new_protected:Npn \__tenkz_kernel_r_arc_controls:n #1 { \fp_set:Nn \l__tenkz_kernel_r_arc_a_fp { atand ( \l__tenkz_kernel_r_yb_fp - \l__tenkz_kernel_r_y_fp , \l__tenkz_kernel_r_xb_fp - \l__tenkz_kernel_r_x_fp ) } % the from end leaves forward along the chord when it has no face \fp_set_eq:NN \l__tenkz_kernel_r_arc_t_fp \l__tenkz_kernel_r_arc_a_fp \fp_set:Nn \l__tenkz_kernel_r_arc_s_fp {1} \__tenkz_kernel_r_arc_end:nn {#1} {from} \fp_set_eq:NN \l__tenkz_kernel_r_arc_tf_fp \l__tenkz_kernel_r_arc_t_fp % the to end arrives forward along the chord when it has no face \fp_set_eq:NN \l__tenkz_kernel_r_arc_t_fp \l__tenkz_kernel_r_arc_a_fp \fp_set:Nn \l__tenkz_kernel_r_arc_s_fp {-1} \__tenkz_kernel_r_arc_end:nn {#1} {to} % the leaving direction (the from side is always forward: a port % leaves outward and the chord preset leaves forward, so the side % sign is spent) and the arriving direction \fp_set_eq:NN \l__tenkz_kernel_r_arc_af_fp \l__tenkz_kernel_r_arc_tf_fp \fp_set:Nn \l__tenkz_kernel_r_arc_ab_fp { \l__tenkz_kernel_r_arc_t_fp + 90 * ( 1 + \l__tenkz_kernel_r_arc_s_fp ) } % each tangent's signed turn off the chord, folded into (-180, 180] \fp_set:Nn \l__tenkz_kernel_r_arc_px_fp { ( \l__tenkz_kernel_r_arc_af_fp - \l__tenkz_kernel_r_arc_a_fp ) - 360 * round ( ( \l__tenkz_kernel_r_arc_af_fp - \l__tenkz_kernel_r_arc_a_fp ) / 360 ) } \fp_set:Nn \l__tenkz_kernel_r_arc_py_fp { ( \l__tenkz_kernel_r_arc_a_fp - \l__tenkz_kernel_r_arc_ab_fp ) - 360 * round ( ( \l__tenkz_kernel_r_arc_a_fp - \l__tenkz_kernel_r_arc_ab_fp ) / 360 ) } \bool_lazy_and:nnTF { \fp_compare_p:nNn { abs ( \l__tenkz_kernel_r_arc_px_fp ) } > {135} } { \fp_compare_p:nNn { abs ( \l__tenkz_kernel_r_arc_py_fp ) } > {135} } { \bool_set_true:N \l__tenkz_kernel_r_arc_wrap_bool \__tenkz_kernel_r_arc_wrap: } { \bool_set_false:N \l__tenkz_kernel_r_arc_wrap_bool % the turn between the leaving and the arriving direction, folded % into [0, 180] \fp_set:Nn \l__tenkz_kernel_r_arc_delta_fp { abs ( \l__tenkz_kernel_r_arc_ab_fp - \l__tenkz_kernel_r_arc_af_fp - 360 * round ( ( \l__tenkz_kernel_r_arc_ab_fp - \l__tenkz_kernel_r_arc_af_fp ) / 360 ) ) } \__tenkz_kernel_r_arc_close:nN { \l__tenkz_kernel_r_arc_delta_fp } \l__tenkz_kernel_r_arc_d_fp \fp_set:Nn \l__tenkz_kernel_r_arc_d_fp { \l__tenkz_kernel_r_arc_d_fp * sqrt ( ( \l__tenkz_kernel_r_xb_fp - \l__tenkz_kernel_r_x_fp ) ^ 2 + ( \l__tenkz_kernel_r_yb_fp - \l__tenkz_kernel_r_y_fp ) ^ 2 ) } \fp_set:Nn \l__tenkz_kernel_r_arc_cax_fp { \l__tenkz_kernel_r_x_fp + \l__tenkz_kernel_r_arc_d_fp * cosd ( \l__tenkz_kernel_r_arc_af_fp ) } \fp_set:Nn \l__tenkz_kernel_r_arc_cay_fp { \l__tenkz_kernel_r_y_fp + \l__tenkz_kernel_r_arc_d_fp * sind ( \l__tenkz_kernel_r_arc_af_fp ) } \fp_set:Nn \l__tenkz_kernel_r_arc_cbx_fp { \l__tenkz_kernel_r_xb_fp + \l__tenkz_kernel_r_arc_s_fp * \l__tenkz_kernel_r_arc_d_fp * cosd ( \l__tenkz_kernel_r_arc_t_fp ) } \fp_set:Nn \l__tenkz_kernel_r_arc_cby_fp { \l__tenkz_kernel_r_yb_fp + \l__tenkz_kernel_r_arc_s_fp * \l__tenkz_kernel_r_arc_d_fp * sind ( \l__tenkz_kernel_r_arc_t_fp ) } \tl_set:Ne \l__tenkz_kernel_r_arc_path_tl { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } ~ .. ~ controls ~ \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_arc_cax_fp } { \l__tenkz_kernel_r_arc_cay_fp } ~ and ~ \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_arc_cbx_fp } { \l__tenkz_kernel_r_arc_cby_fp } ~ .. ~ \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yb_fp } } } } % The wrap: both faces point away from each other along the chord's own % line, so every tangency-honouring control lies on that line and one % cubic can only retrace it. The route instead folds out of each face % and joins the two folds by a run parallel to the chord, half a chord % to the side of it, on the side the from-turn names; each fold's % control distance follows its own subtended turn through the shared % closure factor, and the travel tangents at the ends honour the faces % exactly. The run stations and the two fold distances stay in their % registers for the early on-wire resolver. \cs_new_protected:Npn \__tenkz_kernel_r_arc_wrap: { % half the chord, and the side of it the run stands on. The side is % the one the from-turn names; the antiparallel tie -- both turns at % 180 exactly, the headline opposed pair -- is not left to the fold's % rounding: it stands on the right of travel, the south of an % eastward chord, by stated convention. \fp_set:Nn \l__tenkz_kernel_r_arc_h_fp { sqrt ( ( \l__tenkz_kernel_r_xb_fp - \l__tenkz_kernel_r_x_fp ) ^ 2 + ( \l__tenkz_kernel_r_yb_fp - \l__tenkz_kernel_r_y_fp ) ^ 2 ) / 2 } \fp_set:Nn \l__tenkz_kernel_r_arc_side_fp { \l__tenkz_kernel_r_arc_a_fp + 90 * \fp_compare:nNnTF { abs ( \l__tenkz_kernel_r_arc_px_fp ) } < { 359 / 2 } { \fp_compare:nNnTF { \l__tenkz_kernel_r_arc_px_fp } < {0} { (-1) } { 1 } } { (-1) } } % each fold's control distance follows its own subtended turn -- the % same quantity that admitted it to this branch -- through the shared % closure factor, so a near-threshold wrap is not over-bulged by the % half-circle constant \__tenkz_kernel_r_arc_close:nN { abs ( \l__tenkz_kernel_r_arc_px_fp ) } \l__tenkz_kernel_r_arc_done_fp \fp_set:Nn \l__tenkz_kernel_r_arc_done_fp { \l__tenkz_kernel_r_arc_done_fp * \l__tenkz_kernel_r_arc_h_fp } \__tenkz_kernel_r_arc_close:nN { abs ( \l__tenkz_kernel_r_arc_py_fp ) } \l__tenkz_kernel_r_arc_dtwo_fp \fp_set:Nn \l__tenkz_kernel_r_arc_dtwo_fp { \l__tenkz_kernel_r_arc_dtwo_fp * \l__tenkz_kernel_r_arc_h_fp } \fp_set:Nn \l__tenkz_kernel_r_arc_mx_fp { \l__tenkz_kernel_r_x_fp + \l__tenkz_kernel_r_arc_h_fp * cosd ( \l__tenkz_kernel_r_arc_side_fp ) } \fp_set:Nn \l__tenkz_kernel_r_arc_my_fp { \l__tenkz_kernel_r_y_fp + \l__tenkz_kernel_r_arc_h_fp * sind ( \l__tenkz_kernel_r_arc_side_fp ) } \fp_set:Nn \l__tenkz_kernel_r_arc_nx_fp { \l__tenkz_kernel_r_xb_fp + \l__tenkz_kernel_r_arc_h_fp * cosd ( \l__tenkz_kernel_r_arc_side_fp ) } \fp_set:Nn \l__tenkz_kernel_r_arc_ny_fp { \l__tenkz_kernel_r_yb_fp + \l__tenkz_kernel_r_arc_h_fp * sind ( \l__tenkz_kernel_r_arc_side_fp ) } \tl_set:Ne \l__tenkz_kernel_r_arc_path_tl { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } ~ .. ~ controls ~ \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp + \l__tenkz_kernel_r_arc_done_fp * cosd ( \l__tenkz_kernel_r_arc_af_fp ) } { \l__tenkz_kernel_r_y_fp + \l__tenkz_kernel_r_arc_done_fp * sind ( \l__tenkz_kernel_r_arc_af_fp ) } ~ and ~ \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_arc_mx_fp - \l__tenkz_kernel_r_arc_done_fp * cosd ( \l__tenkz_kernel_r_arc_a_fp ) } { \l__tenkz_kernel_r_arc_my_fp - \l__tenkz_kernel_r_arc_done_fp * sind ( \l__tenkz_kernel_r_arc_a_fp ) } ~ .. ~ \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_arc_mx_fp } { \l__tenkz_kernel_r_arc_my_fp } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_arc_nx_fp } { \l__tenkz_kernel_r_arc_ny_fp } ~ .. ~ controls ~ \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_arc_nx_fp + \l__tenkz_kernel_r_arc_dtwo_fp * cosd ( \l__tenkz_kernel_r_arc_a_fp ) } { \l__tenkz_kernel_r_arc_ny_fp + \l__tenkz_kernel_r_arc_dtwo_fp * sind ( \l__tenkz_kernel_r_arc_a_fp ) } ~ and ~ \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_xb_fp + \l__tenkz_kernel_r_arc_dtwo_fp * cosd ( \l__tenkz_kernel_r_arc_ab_fp + 180 ) } { \l__tenkz_kernel_r_yb_fp + \l__tenkz_kernel_r_arc_dtwo_fp * sind ( \l__tenkz_kernel_r_arc_ab_fp + 180 ) } ~ .. ~ \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yb_fp } } } % One end's bearing and side for the arc frame: a port answers its face % outward (the control stands off the glyph), carried to the page through % its host's own basis, and an end that is not a port leaves the caller's % chord preset standing. An open end also answers the chord, and exactly: % an open tip projects from its neighbouring routed point along the open % word's resolved ray, so the chord between the two resolved ends IS that % ray, in every frame, with no direction of its own to transform. \cs_new_protected:Npn \__tenkz_kernel_r_arc_end:nn #1#2 { \__tenkz_model_get:nnN {#1} {#2} \l__tenkz_kernel_r_arc_tl \quark_if_no_value:NF \l__tenkz_kernel_r_arc_tl { \str_if_eq:eeT { \__tenkz_kernel_node_item:Nn \l__tenkz_kernel_r_arc_tl {kind} } {port} { \exp_args:NV \__tenkz_kernel_port_node_record:nN \l__tenkz_kernel_r_arc_tl \l__tenkz_kernel_r_arc_host_tl \quark_if_no_value:NF \l__tenkz_kernel_r_arc_host_tl { \tl_set:Ne \l__tenkz_kernel_r_arc_face_tl { \__tenkz_kernel_r_compass:n { \__tenkz_kernel_node_item:Nn \l__tenkz_kernel_r_arc_tl {face} } } \exp_args:NVV \__tenkz_kernel_r_page_face:nnN \l__tenkz_kernel_r_arc_host_tl \l__tenkz_kernel_r_arc_face_tl \l__tenkz_kernel_r_arc_face_tl \fp_set:Nn \l__tenkz_kernel_r_arc_t_fp { \l__tenkz_kernel_r_arc_face_tl } \fp_set:Nn \l__tenkz_kernel_r_arc_s_fp {1} } } } } \cs_new_protected:Npn \__tenkz_kernel_r_wire_port_labels:n #1 { \clist_map_inline:nn {from,to} { \__tenkz_kernel_r_wire_port_label:nn {#1} {##1} } } \cs_new_protected:Npn \__tenkz_kernel_r_wire_port_label:nn #1#2 { \__tenkz_model_get:nnN {#1} {#2} \l__tenkz_kernel_port_node_tl \quark_if_no_value:NF \l__tenkz_kernel_port_node_tl { \str_if_eq:eeT { \__tenkz_kernel_node_item:Nn \l__tenkz_kernel_port_node_tl {kind} } {port} { \prop_get:NeN \l__tenkz_kernel_node_prop { \l__tenkz_kernel_port_node_tl / port-label } \l__tenkz_kernel_port_label_tl \quark_if_no_value:NF \l__tenkz_kernel_port_label_tl { \__tenkz_kernel_r_port_record:nN { \tl_use:N \l__tenkz_kernel_port_node_tl } \l__tenkz_kernel_port_record_tl \__tenkz_kernel_r_hull_port_xy:VVNN \l__tenkz_kernel_port_node_tl \l__tenkz_kernel_port_record_tl \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \tl_set:Ne \l__tenkz_kernel_port_face_tl { \__tenkz_kernel_node_item:Nn \l__tenkz_kernel_port_node_tl {face} } \exp_args:NVV \__tenkz_kernel_r_page_face:nnN \l__tenkz_kernel_port_record_tl \l__tenkz_kernel_port_face_tl \l__tenkz_kernel_r_leg_turn_tl \__tenkz_render_labelnode:nnn { tenkz~audited~label , anchor = \exp_args:NV \__tenkz_render_label_anchor:n \l__tenkz_kernel_r_leg_turn_tl , inner~sep = \__tenkz_dim:n {labelclear} } { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } } { $ \tl_use:N \l__tenkz_kernel_port_label_tl $ } } } } } \cs_new_protected:Npn \__tenkz_kernel_r_dots_trim:nn #1#2 { \__tenkz_model_get:nnN {#1} {#2} \l__tenkz_kernel_r_b_tl \quark_if_no_value:NF \l__tenkz_kernel_r_b_tl { \exp_args:NV \__tenkz_kernel_r_endpoint_atom:nN \l__tenkz_kernel_r_b_tl \l__tenkz_kernel_r_c_tl \quark_if_no_value:NF \l__tenkz_kernel_r_c_tl { \__tenkz_kernel_atom_skin_base:nN { \tl_use:N \l__tenkz_kernel_r_c_tl } \l__tenkz_kernel_r_c_tl \str_if_eq:VnT \l__tenkz_kernel_r_c_tl {dots} { \__tenkz_kernel_r_retract:n {#2} } } } } % Resolve the atom that owns an endpoint independently of the endpoint's % geometric production. Cell and semantic-port nodes are two views of the % same carrier ownership used by trimming, labels, and attachment topology. \cs_new_protected:Npn \__tenkz_kernel_r_endpoint_atom:nN #1#2 { \tl_set:Nn #2 { \q_no_value } \str_case:en { \__tenkz_kernel_r_item:nn {#1} {kind} } { {cell} { \prop_get:NeN \l__tenkz_kernel_cell_prop { \__tenkz_kernel_r_item:nn {#1} {row} - \__tenkz_kernel_r_item:nn {#1} {col} } #2 } {port} { \__tenkz_kernel_port_node_record:nN {#1} #2 } } } % pull endpoint #1 toward the other endpoint by wireclear \cs_new_protected:Npn \__tenkz_kernel_r_retract:n #1 { \fp_set:Nn \l__tenkz_kernel_r_xc_fp { \l__tenkz_kernel_r_xb_fp - \l__tenkz_kernel_r_x_fp } \fp_set:Nn \l__tenkz_kernel_r_yc_fp { \l__tenkz_kernel_r_yb_fp - \l__tenkz_kernel_r_y_fp } \fp_set:Nn \l__tenkz_kernel_r_reach_fp { sqrt( \l__tenkz_kernel_r_xc_fp ^ 2 + \l__tenkz_kernel_r_yc_fp ^ 2 ) } \fp_compare:nNnF { \l__tenkz_kernel_r_reach_fp } = { 0 } { \str_if_eq:nnTF {#1} {from} { \fp_add:Nn \l__tenkz_kernel_r_x_fp { \l__tenkz_kernel_r_xc_fp / \l__tenkz_kernel_r_reach_fp * \__tenkz_metric_ratio:n {wireclear} } \fp_add:Nn \l__tenkz_kernel_r_y_fp { \l__tenkz_kernel_r_yc_fp / \l__tenkz_kernel_r_reach_fp * \__tenkz_metric_ratio:n {wireclear} } } { \fp_sub:Nn \l__tenkz_kernel_r_xb_fp { \l__tenkz_kernel_r_xc_fp / \l__tenkz_kernel_r_reach_fp * \__tenkz_metric_ratio:n {wireclear} } \fp_sub:Nn \l__tenkz_kernel_r_yb_fp { \l__tenkz_kernel_r_yc_fp / \l__tenkz_kernel_r_reach_fp * \__tenkz_metric_ratio:n {wireclear} } } } } % Traced rails: the closure record draws the whole rail, running past the % outermost site by wrapreach on each traced side. % % The envelope of the rows a return passes: the westmost west reach % point, the eastmost east reach point, and the extreme row-line % ordinates, every one measured through the live frame. A sheared frame % offsets adjacent rows in page x, so a return that led out by flat % multiples of the trace reach could land inside a passed row's own % descent; taking the frame-transformed extremes keeps the stated % clearance in page space on every supported frame. \fp_new:N \l__tenkz_kernel_r_wrap_wx_fp \fp_new:N \l__tenkz_kernel_r_wrap_ex_fp \fp_new:N \l__tenkz_kernel_r_wrap_ylo_fp \fp_new:N \l__tenkz_kernel_r_wrap_yhi_fp \cs_new_protected:Npn \__tenkz_kernel_r_wrap_envelope:nn #1#2 { \fp_set:Nn \l__tenkz_kernel_r_wrap_wx_fp {inf} \fp_set:Nn \l__tenkz_kernel_r_wrap_ex_fp {-inf} \fp_set:Nn \l__tenkz_kernel_r_wrap_ylo_fp {inf} \fp_set:Nn \l__tenkz_kernel_r_wrap_yhi_fp {-inf} \int_step_inline:nnn {#1} {#2} { \__tenkz_kernel_r_frame_xy:nnNN {##1} { 1 - \__tenkz_metric_ratio:n {wrapreach} } \l__tenkz_kernel_r_xc_fp \l__tenkz_kernel_r_yc_fp \fp_set:Nn \l__tenkz_kernel_r_wrap_wx_fp { min ( \l__tenkz_kernel_r_wrap_wx_fp , \l__tenkz_kernel_r_xc_fp ) } \fp_set:Nn \l__tenkz_kernel_r_wrap_ylo_fp { min ( \l__tenkz_kernel_r_wrap_ylo_fp , \l__tenkz_kernel_r_yc_fp ) } \fp_set:Nn \l__tenkz_kernel_r_wrap_yhi_fp { max ( \l__tenkz_kernel_r_wrap_yhi_fp , \l__tenkz_kernel_r_yc_fp ) } \__tenkz_kernel_r_frame_xy:nnNN {##1} { \l__tenkz_kernel_r_cols_int + \__tenkz_metric_ratio:n {wrapreach} } \l__tenkz_kernel_r_xc_fp \l__tenkz_kernel_r_yc_fp \fp_set:Nn \l__tenkz_kernel_r_wrap_ex_fp { max ( \l__tenkz_kernel_r_wrap_ex_fp , \l__tenkz_kernel_r_xc_fp ) } } } % How far a passed row hangs its open indices on the return's side. Daylight % separates a closure from a row's outermost ink, and what that ink is, is the % row's own business: a bare row hangs nothing, and an open index hangs a leg % and, when it carries a name, the band that name occupies past the tip. % % Every tip is resolved, not budgeted. An open index reaches a row through % three productions -- an authored port, a leg the picture's physical policy % grew, and an opening the picture asked for at a cell or a boundary -- and % each of them can put its tip somewhere a metric alone does not predict: a % leg lengthened to reach a waypoint, an enclosure it pierces or a crossing % it must clear; a plane opening started at the glyph's own outward support % point rather than at the site; a bearing that is the frame's transverse % page vector rather than the host's local north; a face that points % diagonally, whose outward ordinate is its reach times the sine of its % bearing. So the scan asks each production for the tip it draws and reads % that tip's outward ordinate, exactly as \__tenkz_kernel_r_mark_rail:n does % for the bar it steps past the same ink. Only a name's band stays budgeted: % a label is measured after this pass, and \__tenkz_metric_ratio:n % {dotlabelband} is the band the renderer reserves for it. % % Those productions write the coordinate registers the reach itself is % computed in, so the scan saves them, runs, and puts them back. \fp_new:N \l__tenkz_kernel_r_trace_ink_fp \fp_new:N \l__tenkz_kernel_r_trace_pass_fp \fp_new:N \l__tenkz_kernel_r_trace_stand_fp \fp_new:N \l__tenkz_kernel_r_trace_ink_reach_fp \fp_new:N \l__tenkz_kernel_r_trace_ink_sign_fp \fp_new:N \l__tenkz_kernel_r_trace_ink_base_fp \tl_new:N \l__tenkz_kernel_r_trace_ink_lo_tl \tl_new:N \l__tenkz_kernel_r_trace_ink_hi_tl \tl_new:N \l__tenkz_kernel_r_trace_ink_host_tl \tl_new:N \l__tenkz_kernel_r_trace_ink_row_tl \tl_new:N \l__tenkz_kernel_r_trace_ink_col_tl \tl_new:N \l__tenkz_kernel_r_trace_ink_face_tl \tl_new:N \l__tenkz_kernel_r_trace_ink_slot_tl \tl_new:N \l__tenkz_kernel_r_trace_ink_type_tl \tl_new:N \l__tenkz_kernel_r_trace_ink_side_tl \tl_new:N \l__tenkz_kernel_r_trace_ink_label_tl \bool_new:N \l__tenkz_kernel_r_trace_ink_bool % A name an opening carries on the endpoint it consumed. The port pass moves % an authored label onto the port node when a picture-level or cell-level % opening takes that port over, so the wire record has none and the node has % one. \cs_new_protected:Npn \__tenkz_kernel_r_trace_ink_end_label:n #1 { \clist_map_inline:nn {from, to} { \quark_if_no_value:NT \l__tenkz_kernel_r_trace_ink_label_tl { \__tenkz_model_get:nnN {#1} {##1} \l__tenkz_kernel_r_trace_ink_side_tl \quark_if_no_value:NF \l__tenkz_kernel_r_trace_ink_side_tl { \prop_get:NeN \l__tenkz_kernel_node_prop { \tl_use:N \l__tenkz_kernel_r_trace_ink_side_tl / port-label } \l__tenkz_kernel_r_trace_ink_label_tl } } } } % The resolved tip stands in \l__tenkz_kernel_r_port_tip_y_fp and its host in % the row register: take its outward ordinate when the row is one the return % passes, and add the band a name occupies past it. \cs_new_protected:Npn \__tenkz_kernel_r_trace_ink_take:n #1 { \bool_lazy_all:nT { { \int_compare_p:nNn { \l__tenkz_kernel_r_trace_ink_row_tl } > { \l__tenkz_kernel_r_trace_ink_lo_tl - 1 } } { \int_compare_p:nNn { \l__tenkz_kernel_r_trace_ink_row_tl } < { \l__tenkz_kernel_r_trace_ink_hi_tl + 1 } } } { \fp_set:Nn \l__tenkz_kernel_r_trace_ink_reach_fp { \l__tenkz_kernel_r_trace_ink_sign_fp * ( \l__tenkz_kernel_r_port_tip_y_fp - \l__tenkz_kernel_r_trace_ink_base_fp ) } \fp_compare:nNnT { \l__tenkz_kernel_r_trace_ink_reach_fp } > {0} { \__tenkz_model_get:nnN {#1} {port-label} \l__tenkz_kernel_r_trace_ink_label_tl % An opening that consumed an authored port keeps that port's % name on the endpoint node rather than on the wire, and the % label pass reads it from there; so does this, or the return % would clear a named index and run through its name. \quark_if_no_value:NT \l__tenkz_kernel_r_trace_ink_label_tl { \__tenkz_kernel_r_trace_ink_end_label:n {#1} } \quark_if_no_value:NF \l__tenkz_kernel_r_trace_ink_label_tl { \tl_if_empty:NF \l__tenkz_kernel_r_trace_ink_label_tl { \fp_add:Nn \l__tenkz_kernel_r_trace_ink_reach_fp { \__tenkz_metric_ratio:n {dotlabelband} } } } \fp_set:Nn \l__tenkz_kernel_r_trace_ink_fp { max ( \l__tenkz_kernel_r_trace_ink_fp , \l__tenkz_kernel_r_trace_ink_reach_fp ) } } } } % An authored port: the port geometry leaves its tip where the leg pass will % ink it, lane plan, lengthening and all. \cs_new_protected:Npn \__tenkz_kernel_r_trace_port_ink:n #1 { \__tenkz_model_get:nnN {#1} {host} \l__tenkz_kernel_r_trace_ink_host_tl \quark_if_no_value:NF \l__tenkz_kernel_r_trace_ink_host_tl { \exp_args:NV \__tenkz_kernel_r_record_carrier:nNNN \l__tenkz_kernel_r_trace_ink_host_tl \l__tenkz_kernel_r_trace_ink_row_tl \l__tenkz_kernel_r_trace_ink_col_tl \l__tenkz_kernel_r_trace_ink_bool \bool_if:NT \l__tenkz_kernel_r_trace_ink_bool { % A glyph that spans wires stands on several rows, and a port % whose face is a south one is placed on the last of them. The % carrier answers with the anchor row, so the span moves such a % port to the row it is actually drawn from; otherwise that row's % own return would scan past its deepest index. South is the % whole quadrant, read through the classifier the placement reads % it through, not the one bearing that points straight down. \__tenkz_model_get:nnN {#1} {port-face} \l__tenkz_kernel_r_trace_ink_face_tl \exp_args:Ne \__tenkz_kernel_r_face_side:n { \exp_args:NV \__tenkz_kernel_r_compass:n \l__tenkz_kernel_r_trace_ink_face_tl } \str_if_eq:VnT \l__tenkz_kernel_r_face_side_tl {s} { \exp_args:NV \__tenkz_kernel_r_span:nNN \l__tenkz_kernel_r_trace_ink_host_tl \l__tenkz_kernel_r_trace_ink_slot_tl \l__tenkz_kernel_r_trace_ink_type_tl \tl_set:Ne \l__tenkz_kernel_r_trace_ink_row_tl { \int_eval:n { \l__tenkz_kernel_r_trace_ink_row_tl + \l__tenkz_kernel_r_trace_ink_type_tl - 1 } } } \__tenkz_kernel_r_port_open_geometry:n {#1} \__tenkz_kernel_r_trace_ink_take:n {#1} } } } % A policy leg: the leg geometry and the tip reading the annotation layering % takes, which follows a lane corridor through its bend when the leg has one. \cs_new_protected:Npn \__tenkz_kernel_r_trace_policy_ink:n #1 { \__tenkz_model_get:nnN {#1} {host} \l__tenkz_kernel_r_trace_ink_host_tl \__tenkz_model_get:nnN {#1} {face} \l__tenkz_kernel_r_trace_ink_face_tl \__tenkz_model_get:nnN {#1} {col} \l__tenkz_kernel_r_trace_ink_slot_tl \bool_lazy_all:nT { { ! \quark_if_no_value_p:N \l__tenkz_kernel_r_trace_ink_host_tl } { ! \quark_if_no_value_p:N \l__tenkz_kernel_r_trace_ink_face_tl } { ! \quark_if_no_value_p:N \l__tenkz_kernel_r_trace_ink_slot_tl } } { \exp_args:NV \__tenkz_kernel_atom_rc:nNNN \l__tenkz_kernel_r_trace_ink_host_tl \l__tenkz_kernel_r_trace_ink_row_tl \l__tenkz_kernel_r_trace_ink_col_tl \l__tenkz_kernel_r_trace_ink_bool \bool_if:NT \l__tenkz_kernel_r_trace_ink_bool { % A south face belongs to the host's last spanned row, whether % the picture's policy grew the leg or an author wrote the port. \exp_args:Ne \__tenkz_kernel_r_face_side:n { \exp_args:NV \__tenkz_kernel_r_compass:n \l__tenkz_kernel_r_trace_ink_face_tl } \str_if_eq:VnT \l__tenkz_kernel_r_face_side_tl {s} { \exp_args:NV \__tenkz_kernel_r_span:nNN \l__tenkz_kernel_r_trace_ink_host_tl \l__tenkz_kernel_r_trace_ink_side_tl \l__tenkz_kernel_r_trace_ink_type_tl \tl_set:Ne \l__tenkz_kernel_r_trace_ink_row_tl { \int_eval:n { \l__tenkz_kernel_r_trace_ink_row_tl + \l__tenkz_kernel_r_trace_ink_type_tl - 1 } } } % the record stores the spanned cell; the slot is its offset from % the host's anchor column \tl_set:Ne \l__tenkz_kernel_r_trace_ink_slot_tl { \int_eval:n { \l__tenkz_kernel_r_trace_ink_slot_tl - \l__tenkz_kernel_r_trace_ink_col_tl + 1 } } \__tenkz_kernel_r_leg_geometry:VVV \l__tenkz_kernel_r_trace_ink_host_tl \l__tenkz_kernel_r_trace_ink_face_tl \l__tenkz_kernel_r_trace_ink_slot_tl \bool_if:NT \l__tenkz_kernel_leg_geom_bool { \__tenkz_kernel_r_leg_tip_y: \__tenkz_kernel_r_trace_ink_take:n {#1} } } } } % An opening the picture asked for. It carries no host: one end is a port % node or a cell, and the other is the free end the wire renderer stands off % -- one open index along the compass word the record names, or, on a % projected plane, the tip that renderer resolves through the frame. The row % is the row the anchored end stands in. \cs_new_protected:Npn \__tenkz_kernel_r_trace_open_end:nnn #1#2#3 { \__tenkz_model_get:nnN {#1} {#2} \l__tenkz_kernel_r_trace_ink_side_tl \quark_if_no_value:NF \l__tenkz_kernel_r_trace_ink_side_tl { \__tenkz_kernel_r_wire_end_xy:VNN \l__tenkz_kernel_r_trace_ink_side_tl \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \__tenkz_model_get:nnN {#1} {#3} \l__tenkz_kernel_r_trace_ink_face_tl \quark_if_no_value:NF \l__tenkz_kernel_r_trace_ink_face_tl { \str_if_eq:eeTF { \__tenkz_kernel_r_frame_word: } {plane} { \fp_set_eq:NN \l__tenkz_kernel_r_xc_fp \l__tenkz_kernel_r_x_fp \fp_set_eq:NN \l__tenkz_kernel_r_yc_fp \l__tenkz_kernel_r_y_fp \exp_args:NV \__tenkz_kernel_r_open_tip_affine_xy:nNN \l__tenkz_kernel_r_trace_ink_face_tl \l__tenkz_kernel_r_port_tip_x_fp \l__tenkz_kernel_r_port_tip_y_fp } { \fp_set:Nn \l__tenkz_kernel_r_port_tip_y_fp { \l__tenkz_kernel_r_y_fp + \__tenkz_metric_ratio:n {stub} * sind ( \__tenkz_kernel_r_compass:n { \l__tenkz_kernel_r_trace_ink_face_tl } ) } } \__tenkz_kernel_r_trace_ink_take:n {#1} } } } \cs_new_protected:Npn \__tenkz_kernel_r_trace_open_ink:n #1 { \__tenkz_model_get:nnN {#1} {physical-axis} \l__tenkz_kernel_r_trace_ink_type_tl \str_if_eq:VnTF \l__tenkz_kernel_r_trace_ink_type_tl {transverse} { % The plane route inks a leg from the glyph's own outward support % point along the frame's physical axis; the renderer that draws it % answers where its tip stands. \__tenkz_model_get:nnN {#1} {from-host} \l__tenkz_kernel_r_trace_ink_host_tl \quark_if_no_value:NF \l__tenkz_kernel_r_trace_ink_host_tl { \exp_args:NV \__tenkz_kernel_r_record_carrier:nNNN \l__tenkz_kernel_r_trace_ink_host_tl \l__tenkz_kernel_r_trace_ink_row_tl \l__tenkz_kernel_r_trace_ink_col_tl \l__tenkz_kernel_r_trace_ink_bool \bool_if:NT \l__tenkz_kernel_r_trace_ink_bool { % The renderer's own two steps, taken without its third: it % resolves the axis, starts at the glyph's support point and % runs one leg along that axis -- and then strokes. Asking % it to stroke here would lay a second copy of the leg and % save it under the closure's own path name, so the reach is % read from the resolution and the ink left to the leg pass. % The enclosure reach is part of the resolution: a leg that % pierces a contour is drawn out to it, and a scan that % stopped at the bare leg would let the return stand inside % the ink. \__tenkz_model_get:nnN {#1} {from-axis} \l__tenkz_kernel_r_trace_ink_face_tl \exp_args:NVV \__tenkz_kernel_r_physical_axis:nnNN \l__tenkz_kernel_r_trace_ink_host_tl \l__tenkz_kernel_r_trace_ink_face_tl \l__tenkz_kernel_leg_dir_tl \l__tenkz_kernel_r_physical_anchor_tl \exp_args:NVV \__tenkz_kernel_r_glyph_anchor_or_site_xy:nnNN \l__tenkz_kernel_r_trace_ink_host_tl \l__tenkz_kernel_r_physical_anchor_tl \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \fp_set:Nn \l__tenkz_kernel_r_reach_fp { \__tenkz_metric_ratio:n {physleg} } % A plane transverse leg leaves the sheet, not its perimeter. \bool_if:NF \l__tenkz_kernel_r_basis_plane_bool { \exp_args:NVV \__tenkz_kernel_r_physical_enclosure:nn \l__tenkz_kernel_r_trace_ink_host_tl \l__tenkz_kernel_r_trace_ink_face_tl } \fp_set:Nn \l__tenkz_kernel_r_port_tip_y_fp { \l__tenkz_kernel_r_y_fp + \l__tenkz_kernel_r_reach_fp * sind( \l__tenkz_kernel_leg_dir_tl ) } \__tenkz_kernel_r_trace_ink_take:n {#1} } } } { \__tenkz_kernel_r_trace_open_row:n {#1} \bool_if:NT \l__tenkz_kernel_r_trace_ink_bool { \__tenkz_kernel_r_trace_open_end:nnn {#1} {to} {from-open} \__tenkz_kernel_r_trace_open_end:nnn {#1} {from} {to-open} } } } % The row an opening's anchored end stands in. A cell-level physical opening % and a north boundary opening stand on the first row, a south one on the % last, and an interface opening on the row its face names: `upper' hangs % from the row above the interface, `lower' from the row below it. A west or % east opening leaves along its own row and hangs nothing on a return's side, % so its bearing takes it out of the answer rather than its row. \cs_new_protected:Npn \__tenkz_kernel_r_trace_open_row:n #1 { \bool_set_true:N \l__tenkz_kernel_r_trace_ink_bool \__tenkz_model_get:nnN {#1} {interface} \l__tenkz_kernel_r_trace_ink_type_tl \quark_if_no_value:NTF \l__tenkz_kernel_r_trace_ink_type_tl { \__tenkz_model_get:nnN {#1} {side} \l__tenkz_kernel_r_trace_ink_side_tl \quark_if_no_value:NTF \l__tenkz_kernel_r_trace_ink_side_tl { \tl_set:Nn \l__tenkz_kernel_r_trace_ink_row_tl {1} } { \str_case:VnF \l__tenkz_kernel_r_trace_ink_side_tl { {south} { \tl_set:Ne \l__tenkz_kernel_r_trace_ink_row_tl { \int_use:N \l__tenkz_kernel_r_rows_int } } {north} { \tl_set:Nn \l__tenkz_kernel_r_trace_ink_row_tl {1} } } { \__tenkz_model_get:nnN {#1} {row} \l__tenkz_kernel_r_trace_ink_row_tl \quark_if_no_value:NT \l__tenkz_kernel_r_trace_ink_row_tl { \bool_set_false:N \l__tenkz_kernel_r_trace_ink_bool } } } } { \__tenkz_model_get:nnN {#1} {face} \l__tenkz_kernel_r_trace_ink_side_tl \str_if_eq:VnTF \l__tenkz_kernel_r_trace_ink_side_tl {lower} { \tl_set:Ne \l__tenkz_kernel_r_trace_ink_row_tl { \int_eval:n { \l__tenkz_kernel_r_trace_ink_type_tl + 1 } } } { \tl_set_eq:NN \l__tenkz_kernel_r_trace_ink_row_tl \l__tenkz_kernel_r_trace_ink_type_tl } } } % The answer for one range of rows, remembered. A traced row's reach is read % by the stroke that draws its rail, by every name that owes the rail a step, % and by the annotation layering once per wire in the picture; a row's records % do not change under the render, so the walks the answer costs are paid once % per range and per picture rather than once per reader. A range names its % closed row -- the rows a return passes run from that row outward -- so the % key is complete. % % The scan runs the productions that draw the ink, and those write the % coordinate registers the reach is computed in. They are saved here and put % back, so the caller sees the reach it asked for and nothing else. \prop_new:N \g__tenkz_kernel_r_trace_ink_prop \tl_new:N \l__tenkz_kernel_r_trace_ink_key_tl \tl_new:N \l__tenkz_kernel_r_trace_ink_seen_tl \fp_new:N \l__tenkz_kernel_r_trace_keep_x_fp \fp_new:N \l__tenkz_kernel_r_trace_keep_y_fp \fp_new:N \l__tenkz_kernel_r_trace_keep_xb_fp \fp_new:N \l__tenkz_kernel_r_trace_keep_yb_fp \fp_new:N \l__tenkz_kernel_r_trace_keep_xc_fp \fp_new:N \l__tenkz_kernel_r_trace_keep_yc_fp \fp_new:N \l__tenkz_kernel_r_trace_keep_reach_fp \fp_new:N \l__tenkz_kernel_r_trace_keep_wx_fp \fp_new:N \l__tenkz_kernel_r_trace_keep_ex_fp \fp_new:N \l__tenkz_kernel_r_trace_keep_ylo_fp \fp_new:N \l__tenkz_kernel_r_trace_keep_yhi_fp \tl_new:N \l__tenkz_kernel_r_trace_keep_b_tl \tl_new:N \l__tenkz_kernel_r_trace_keep_c_tl \tl_new:N \l__tenkz_kernel_r_trace_keep_row_tl \tl_new:N \l__tenkz_kernel_r_trace_keep_col_tl \cs_new_protected:Npn \__tenkz_kernel_r_trace_ink_keep: { \fp_set_eq:NN \l__tenkz_kernel_r_trace_keep_x_fp \l__tenkz_kernel_r_x_fp \fp_set_eq:NN \l__tenkz_kernel_r_trace_keep_y_fp \l__tenkz_kernel_r_y_fp \fp_set_eq:NN \l__tenkz_kernel_r_trace_keep_xb_fp \l__tenkz_kernel_r_xb_fp \fp_set_eq:NN \l__tenkz_kernel_r_trace_keep_yb_fp \l__tenkz_kernel_r_yb_fp \fp_set_eq:NN \l__tenkz_kernel_r_trace_keep_xc_fp \l__tenkz_kernel_r_xc_fp \fp_set_eq:NN \l__tenkz_kernel_r_trace_keep_yc_fp \l__tenkz_kernel_r_yc_fp \fp_set_eq:NN \l__tenkz_kernel_r_trace_keep_reach_fp \l__tenkz_kernel_r_reach_fp \fp_set_eq:NN \l__tenkz_kernel_r_trace_keep_wx_fp \l__tenkz_kernel_r_wrap_wx_fp \fp_set_eq:NN \l__tenkz_kernel_r_trace_keep_ex_fp \l__tenkz_kernel_r_wrap_ex_fp \fp_set_eq:NN \l__tenkz_kernel_r_trace_keep_ylo_fp \l__tenkz_kernel_r_wrap_ylo_fp \fp_set_eq:NN \l__tenkz_kernel_r_trace_keep_yhi_fp \l__tenkz_kernel_r_wrap_yhi_fp \tl_set_eq:NN \l__tenkz_kernel_r_trace_keep_b_tl \l__tenkz_kernel_r_b_tl \tl_set_eq:NN \l__tenkz_kernel_r_trace_keep_c_tl \l__tenkz_kernel_r_c_tl \tl_set_eq:NN \l__tenkz_kernel_r_trace_keep_row_tl \l__tenkz_kernel_r_row_tl \tl_set_eq:NN \l__tenkz_kernel_r_trace_keep_col_tl \l__tenkz_kernel_r_col_tl } \cs_new_protected:Npn \__tenkz_kernel_r_trace_ink_restore: { \fp_set_eq:NN \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_trace_keep_x_fp \fp_set_eq:NN \l__tenkz_kernel_r_y_fp \l__tenkz_kernel_r_trace_keep_y_fp \fp_set_eq:NN \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_trace_keep_xb_fp \fp_set_eq:NN \l__tenkz_kernel_r_yb_fp \l__tenkz_kernel_r_trace_keep_yb_fp \fp_set_eq:NN \l__tenkz_kernel_r_xc_fp \l__tenkz_kernel_r_trace_keep_xc_fp \fp_set_eq:NN \l__tenkz_kernel_r_yc_fp \l__tenkz_kernel_r_trace_keep_yc_fp \fp_set_eq:NN \l__tenkz_kernel_r_reach_fp \l__tenkz_kernel_r_trace_keep_reach_fp \fp_set_eq:NN \l__tenkz_kernel_r_wrap_wx_fp \l__tenkz_kernel_r_trace_keep_wx_fp \fp_set_eq:NN \l__tenkz_kernel_r_wrap_ex_fp \l__tenkz_kernel_r_trace_keep_ex_fp \fp_set_eq:NN \l__tenkz_kernel_r_wrap_ylo_fp \l__tenkz_kernel_r_trace_keep_ylo_fp \fp_set_eq:NN \l__tenkz_kernel_r_wrap_yhi_fp \l__tenkz_kernel_r_trace_keep_yhi_fp \tl_set_eq:NN \l__tenkz_kernel_r_b_tl \l__tenkz_kernel_r_trace_keep_b_tl \tl_set_eq:NN \l__tenkz_kernel_r_c_tl \l__tenkz_kernel_r_trace_keep_c_tl \tl_set_eq:NN \l__tenkz_kernel_r_row_tl \l__tenkz_kernel_r_trace_keep_row_tl \tl_set_eq:NN \l__tenkz_kernel_r_col_tl \l__tenkz_kernel_r_trace_keep_col_tl } \cs_new_protected:Npn \__tenkz_kernel_r_trace_row_ink:nn #1#2 { \tl_set:Ne \l__tenkz_kernel_r_trace_ink_key_tl { \int_use:N \g__tenkz_kernel_picture_int - #1 - #2 } \prop_get:NVNTF \g__tenkz_kernel_r_trace_ink_prop \l__tenkz_kernel_r_trace_ink_key_tl \l__tenkz_kernel_r_trace_ink_seen_tl { \fp_set:Nn \l__tenkz_kernel_r_trace_ink_fp { \l__tenkz_kernel_r_trace_ink_seen_tl } } { \fp_zero:N \l__tenkz_kernel_r_trace_ink_fp \tl_set:Nn \l__tenkz_kernel_r_trace_ink_lo_tl {#1} \tl_set:Nn \l__tenkz_kernel_r_trace_ink_hi_tl {#2} \fp_set_eq:NN \l__tenkz_kernel_r_trace_ink_sign_fp \l__tenkz_kernel_r_yc_fp \fp_set_eq:NN \l__tenkz_kernel_r_trace_ink_base_fp \l__tenkz_kernel_r_y_fp \__tenkz_kernel_r_trace_ink_keep: \__tenkz_model_map_wires_origin:nN {port-open} \__tenkz_kernel_r_trace_port_ink:n \__tenkz_model_map_wires_origin:nN {policy-leg} \__tenkz_kernel_r_trace_policy_ink:n \__tenkz_model_map_wires_origin:nN {open} \__tenkz_kernel_r_trace_open_ink:n \__tenkz_kernel_r_trace_ink_restore: \prop_gput:NVe \g__tenkz_kernel_r_trace_ink_prop \l__tenkz_kernel_r_trace_ink_key_tl { \fp_use:N \l__tenkz_kernel_r_trace_ink_fp } } } % The side and reach of a traced row's return. Reads the closed row from % \l__tenkz_kernel_r_row_tl and the row's west reach-point ordinate from % \l__tenkz_kernel_r_y_fp; leaves the arc angles in the b/c registers, the % outward sign in \l__tenkz_kernel_r_yc_fp, the passed-row count less one in % \l__tenkz_kernel_r_xc_fp, the passed rows' envelope in the wrap registers, % the passed rows' open-index depth in \l__tenkz_kernel_r_trace_ink_fp, and % the reach in \l__tenkz_kernel_r_reach_fp. The closure stroke and the % annotation layering of \__tenkz_kernel_r_mark_rails:n both read the rail % through this one function, so the two cannot drift. The ink scan reads the % outward sign, and the envelope walk borrows the sign register as scratch for % the frame answers it collects, so the scan runs after the sign is restated. \cs_new_protected:Npn \__tenkz_kernel_r_trace_side_reach: { \int_compare:nNnTF { 2 * \l__tenkz_kernel_r_row_tl } < { \l__tenkz_kernel_r_rows_int + 1 } { \tl_set:Nn \l__tenkz_kernel_r_b_tl {90} \tl_set:Nn \l__tenkz_kernel_r_c_tl {0} \__tenkz_kernel_r_wrap_envelope:nn {1} { \l__tenkz_kernel_r_row_tl } \fp_set:Nn \l__tenkz_kernel_r_xc_fp { \l__tenkz_kernel_r_row_tl - 1 } \fp_set:Nn \l__tenkz_kernel_r_yc_fp {1} \__tenkz_kernel_r_trace_row_ink:nn {1} { \l__tenkz_kernel_r_row_tl } } { \tl_set:Nn \l__tenkz_kernel_r_b_tl {270} \tl_set:Nn \l__tenkz_kernel_r_c_tl {360} \__tenkz_kernel_r_wrap_envelope:nn { \l__tenkz_kernel_r_row_tl } { \l__tenkz_kernel_r_rows_int } \fp_set:Nn \l__tenkz_kernel_r_xc_fp { \l__tenkz_kernel_r_rows_int - \l__tenkz_kernel_r_row_tl } \fp_set:Nn \l__tenkz_kernel_r_yc_fp {-1} \__tenkz_kernel_r_trace_row_ink:nn { \l__tenkz_kernel_r_row_tl } { \l__tenkz_kernel_r_rows_int } } % Two separate distances used to wear one name. The innermost return % passes the row's own ink, and what a row hangs on its outward side is % an open index -- a leg, and the band its name occupies when it has one. % The trace reach is shorter than a bare physical leg, so the return % crossed the very indices it was drawn beside and each of them read as % ending on the contraction that closes their row. The leg is the open % index and its length is its own contract; the return is the closure, % and a closure placed beyond a row's outermost ink is exactly what the % metric table's one daylight measures. So the return yields, by one % daylight beyond the deepest open index the rows it passes hang on its % side. % % Where they hang nothing there is still a row line to clear, and the % return keeps its own trace reach beyond the outermost of them. The two % demands are read against the same origin -- the ink scan measures every % tip outward from this row's own ordinate -- so the standoff is the % greater of them and not their sum. Every further return crossed then % adds one trace reach, which is what that reach measures here: the paper % between two returns, not the drop of the first below its row. % % The outward extreme of the passed row lines is the signed maximum, so % one formula serves both sides. \fp_set:Nn \l__tenkz_kernel_r_trace_pass_fp { max ( \l__tenkz_kernel_r_yc_fp * \l__tenkz_kernel_r_wrap_yhi_fp , \l__tenkz_kernel_r_yc_fp * \l__tenkz_kernel_r_wrap_ylo_fp ) - \l__tenkz_kernel_r_yc_fp * \l__tenkz_kernel_r_y_fp } \fp_set:Nn \l__tenkz_kernel_r_trace_stand_fp { max ( \__tenkz_metric_ratio:n {pairtracereach} + \l__tenkz_kernel_r_trace_pass_fp , \l__tenkz_kernel_r_trace_ink_fp + \__tenkz_metric_ratio:n {daylight} ) } \fp_set:Nn \l__tenkz_kernel_r_reach_fp { \l__tenkz_kernel_r_trace_stand_fp + \l__tenkz_kernel_r_xc_fp * \__tenkz_metric_ratio:n {pairtracereach} } } % The outward step a label owes its row's return. A label band shallower % than the trace reach puts every name that speaks to the traced side across % the return that closes its own row: on the sources' own MPO trace the site % names crossed the rail and the figure read as a strip of text over a wire. % Section 6 of the language settles the direction: a named placement is % honoured, and honouring it grows the host's contour on that side rather % than putting the label on ink. The step is the rail's own reach, read % through the one function the stroke reads, so a label and the rail it % clears cannot drift. Only a row closed west-to-east on a frame whose rows % are lines of the page owes the step; a ring closes at the frame radius and % grows no band beneath its row. \fp_new:N \l__tenkz_kernel_r_label_step_fp \tl_new:N \l__tenkz_kernel_r_label_b_tl \tl_new:N \l__tenkz_kernel_r_label_c_tl \fp_new:N \l__tenkz_kernel_r_label_keep_fp \cs_new_protected:Npn \__tenkz_kernel_r_trace_label_step:nn #1#2 { \fp_zero:N \l__tenkz_kernel_r_label_step_fp \bool_lazy_all:nT { { \str_if_eq_p:ee { \prop_item:Nn \l__tenkz_kernel_policy_prop {west} } {trace} } { \str_if_eq_p:ee { \prop_item:Nn \l__tenkz_kernel_policy_prop {east} } {trace} } { ! \str_if_eq_p:ee { \__tenkz_kernel_r_frame_word: } {circle} } { \int_compare_p:nNn {#1} > {0} } { \int_compare_p:nNn {#1} < { \l__tenkz_kernel_r_rows_int + 1 } } } { \tl_set_eq:NN \l__tenkz_kernel_r_label_b_tl \l__tenkz_kernel_r_b_tl \tl_set_eq:NN \l__tenkz_kernel_r_label_c_tl \l__tenkz_kernel_r_c_tl \fp_set_eq:NN \l__tenkz_kernel_r_label_keep_fp \l__tenkz_kernel_r_y_fp \tl_set:Nn \l__tenkz_kernel_r_row_tl {#1} \__tenkz_kernel_r_frame_xy:nnNN {#1} { 1 - \__tenkz_metric_ratio:n {wrapreach} } \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \__tenkz_kernel_r_trace_side_reach: \fp_compare:nNnT { \l__tenkz_kernel_r_yc_fp * sind(#2) } > {0} { \fp_set:Nn \l__tenkz_kernel_r_label_step_fp { \l__tenkz_kernel_r_yc_fp * \l__tenkz_kernel_r_reach_fp } } \fp_set_eq:NN \l__tenkz_kernel_r_y_fp \l__tenkz_kernel_r_label_keep_fp \tl_set_eq:NN \l__tenkz_kernel_r_b_tl \l__tenkz_kernel_r_label_b_tl \tl_set_eq:NN \l__tenkz_kernel_r_c_tl \l__tenkz_kernel_r_label_c_tl } } % The two virtual ends a west-east closure joins. The closure record already % carries them: \__tenkz_kernel_port_closure_consume:n materializes the west % port of the row's first cell and the east port of its last one before any % authored descriptor can refine them. Reading those ends here is what makes % the closure one contour. A rail that began at its own reach point instead % stopped one wrap reach short of the site it closes onto, so on the row's % centreline no ink ran between the rail and the chain and the periodic % chain read as open -- the drawn figure denied the contraction its record % asserts. A row whose first or last cell carries no port (an unplaced or % sealed cell) has no virtual end to meet, and the rail keeps its reach point. \fp_new:N \l__tenkz_kernel_r_wrap_lx_fp \fp_new:N \l__tenkz_kernel_r_wrap_ly_fp \fp_new:N \l__tenkz_kernel_r_wrap_rx_fp \fp_new:N \l__tenkz_kernel_r_wrap_ry_fp \bool_new:N \l__tenkz_kernel_r_wrap_lend_bool \bool_new:N \l__tenkz_kernel_r_wrap_rend_bool \bool_new:N \l__tenkz_kernel_r_wrap_llead_bool \bool_new:N \l__tenkz_kernel_r_wrap_rlead_bool % Which end an endpoint is, is settled by the port's own face and not by the % slot the record happens to hold it in. \__tenkz_kernel_port_closure_consume:n % fills `from` before `to`, so a row whose west boundary cell carries no port % puts the EAST port in `from`: reading the slots in order then called the % east station the row's west end, led the rail out of it across the whole % row, and drew a west lead where the row has no west site. A port node % records the face it was minted on -- 180 for the west end, 0 for the east % one -- and that is the reading taken here. \cs_new_protected:Npn \__tenkz_kernel_r_wrap_end:nn #1#2 { \__tenkz_model_get:nnN {#1} {#2} \l__tenkz_kernel_r_end_tl \quark_if_no_value:NF \l__tenkz_kernel_r_end_tl { \str_if_eq:eeTF { \__tenkz_kernel_node_item:nn { \l__tenkz_kernel_r_end_tl } {face} } {0} { \__tenkz_kernel_r_wire_end_xy:VNN \l__tenkz_kernel_r_end_tl \l__tenkz_kernel_r_wrap_rx_fp \l__tenkz_kernel_r_wrap_ry_fp \bool_set_true:N \l__tenkz_kernel_r_wrap_rend_bool } { \__tenkz_kernel_r_wire_end_xy:VNN \l__tenkz_kernel_r_end_tl \l__tenkz_kernel_r_wrap_lx_fp \l__tenkz_kernel_r_wrap_ly_fp \bool_set_true:N \l__tenkz_kernel_r_wrap_lend_bool } } } \cs_new_protected:Npn \__tenkz_kernel_r_wrap_ends:n #1 { \bool_set_false:N \l__tenkz_kernel_r_wrap_lend_bool \bool_set_false:N \l__tenkz_kernel_r_wrap_rend_bool \__tenkz_kernel_r_wrap_end:nn {#1} {from} \__tenkz_kernel_r_wrap_end:nn {#1} {to} % A flat rail reaches its end with a straight lead; a ring's sector % already starts and finishes there and takes none. \bool_set_eq:NN \l__tenkz_kernel_r_wrap_llead_bool \l__tenkz_kernel_r_wrap_lend_bool \bool_set_eq:NN \l__tenkz_kernel_r_wrap_rlead_bool \l__tenkz_kernel_r_wrap_rend_bool } % ---------- the measured contour of a traced closure ------------------------------------------- % The audit cannot see a wire: the geometry stage measures glyphs and labels, % and a closure that stops short of the row it closes therefore passes a HARD % label and geometry gate untouched. A west-east closure publishes its own % contour so that gate has something exact to read: the row's two virtual % ends, and the polyline the stroke laid between them, in scaled points on % the picture's own axes -- the units the measured label and glyph boxes % already use. Each rounded corner enters as its two tangent points and the % arc's mid-point, so the reported contour lies inside the ink and claims no % clearance the drawing does not have. The record carries the stroke it is % drawn with -- half the wire width, the half-stroke reach a measured glyph % already publishes -- because the polyline is the centreline of a wire that % is not thin: a name that clears the centreline by less than that stands on % the wire. \tl_new:N \l__tenkz_kernel_r_rail_tl \cs_new_protected:Npn \__tenkz_kernel_r_rail_pt:nn #1#2 { \tl_if_empty:NF \l__tenkz_kernel_r_rail_tl { \tl_put_right:Nn \l__tenkz_kernel_r_rail_tl { ; } } \tl_put_right:Ne \l__tenkz_kernel_r_rail_tl { \dim_to_decimal_in_sp:n { \__tenkz_kernel_r_pt:n {#1} } , \dim_to_decimal_in_sp:n { \__tenkz_kernel_r_pt:n {#2} } } } \cs_new:Npn \__tenkz_kernel_r_rail_end:NNN #1#2#3 { \bool_if:NTF #1 { \dim_to_decimal_in_sp:n { \__tenkz_kernel_r_pt:n {#2} } , \dim_to_decimal_in_sp:n { \__tenkz_kernel_r_pt:n {#3} } } { none } } % The outward standoff the return owes the rows it passes, signed and % measured from its own row line: the greater of one daylight beyond the % deepest open index those rows hang on its side and one trace reach beyond % the outermost of the row lines themselves. The sign is the side the return % runs, so a reader holds the rail to a distance on a named side rather than % to a magnitude on either. A flat rail runs out of the row line and answers % with that signed page distance; a ring's sector stands off no row line and % answers with the word for a closure that has none. The record publishes % the standoff beside the contour so a reader of the stream can hold the % drawn ink to the clearance the metric table declares, which is the reading % a wire's own ink cannot supply: a wire carries no measured box. \tl_new:N \l__tenkz_kernel_r_rail_clear_tl % The flat rail, read from the registers the stroke itself read, in the order % the stroke laid them: the leads, the two descents, and the run between the % corners. Half a trace reach is the corner radius, and one minus the cosine % of 45 degrees places the mid-point of a quarter turn. \cs_new_protected:Npn \__tenkz_kernel_r_rail_flat: { \tl_set:Ne \l__tenkz_kernel_r_rail_clear_tl { \dim_to_decimal_in_sp:n { \__tenkz_kernel_r_pt:n { \l__tenkz_kernel_r_yc_fp * \l__tenkz_kernel_r_trace_stand_fp } } } \tl_clear:N \l__tenkz_kernel_r_rail_tl \bool_if:NT \l__tenkz_kernel_r_wrap_llead_bool { \__tenkz_kernel_r_rail_pt:nn { \l__tenkz_kernel_r_wrap_lx_fp } { \l__tenkz_kernel_r_wrap_ly_fp } } \__tenkz_kernel_r_rail_pt:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } \__tenkz_kernel_r_rail_pt:nn { \l__tenkz_kernel_r_wrap_wx_fp } { \l__tenkz_kernel_r_y_fp } \__tenkz_kernel_r_rail_pt:nn { \l__tenkz_kernel_r_wrap_wx_fp } { \l__tenkz_kernel_r_y_fp + \l__tenkz_kernel_r_yc_fp * ( \l__tenkz_kernel_r_reach_fp - \__tenkz_metric_ratio:n {pairtracereach} / 2 ) } \__tenkz_kernel_r_rail_pt:nn { \l__tenkz_kernel_r_wrap_wx_fp + ( 1 - cosd(45) ) * \__tenkz_metric_ratio:n {pairtracereach} / 2 } { \l__tenkz_kernel_r_y_fp + \l__tenkz_kernel_r_yc_fp * ( \l__tenkz_kernel_r_reach_fp - ( 1 - cosd(45) ) * \__tenkz_metric_ratio:n {pairtracereach} / 2 ) } \__tenkz_kernel_r_rail_pt:nn { \l__tenkz_kernel_r_wrap_wx_fp + \__tenkz_metric_ratio:n {pairtracereach} / 2 } { \l__tenkz_kernel_r_y_fp + \l__tenkz_kernel_r_yc_fp * \l__tenkz_kernel_r_reach_fp } \__tenkz_kernel_r_rail_pt:nn { \l__tenkz_kernel_r_wrap_ex_fp - \__tenkz_metric_ratio:n {pairtracereach} / 2 } { \l__tenkz_kernel_r_yb_fp + \l__tenkz_kernel_r_yc_fp * \l__tenkz_kernel_r_reach_fp } \__tenkz_kernel_r_rail_pt:nn { \l__tenkz_kernel_r_wrap_ex_fp - ( 1 - cosd(45) ) * \__tenkz_metric_ratio:n {pairtracereach} / 2 } { \l__tenkz_kernel_r_yb_fp + \l__tenkz_kernel_r_yc_fp * ( \l__tenkz_kernel_r_reach_fp - ( 1 - cosd(45) ) * \__tenkz_metric_ratio:n {pairtracereach} / 2 ) } \__tenkz_kernel_r_rail_pt:nn { \l__tenkz_kernel_r_wrap_ex_fp } { \l__tenkz_kernel_r_yb_fp + \l__tenkz_kernel_r_yc_fp * ( \l__tenkz_kernel_r_reach_fp - \__tenkz_metric_ratio:n {pairtracereach} / 2 ) } \__tenkz_kernel_r_rail_pt:nn { \l__tenkz_kernel_r_wrap_ex_fp } { \l__tenkz_kernel_r_yb_fp } \__tenkz_kernel_r_rail_pt:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yb_fp } \bool_if:NT \l__tenkz_kernel_r_wrap_rlead_bool { \__tenkz_kernel_r_rail_pt:nn { \l__tenkz_kernel_r_wrap_rx_fp } { \l__tenkz_kernel_r_wrap_ry_fp } } } % The ring sector, sampled at sixteenths of its own extent: a chord of a % sixteenth of a quarter turn stands well inside the stroke it stands for. % The sector is the whole closure: a ring takes no lead, because a station % and a reach point both stand on the frame circle, so the sector already % starts and finishes on whatever the row has at either side. \cs_new_protected:Npn \__tenkz_kernel_r_rail_arc: { \tl_set:Nn \l__tenkz_kernel_r_rail_clear_tl {arc} \tl_clear:N \l__tenkz_kernel_r_rail_tl \int_step_inline:nnn {0} {16} { \__tenkz_kernel_r_rail_pt:nn { \l__tenkz_kernel_r_reach_fp * cosd ( \l__tenkz_kernel_r_xc_fp + ##1 * ( \l__tenkz_kernel_r_yc_fp - \l__tenkz_kernel_r_xc_fp ) / 16 ) } { \l__tenkz_kernel_r_reach_fp * sind ( \l__tenkz_kernel_r_xc_fp + ##1 * ( \l__tenkz_kernel_r_yc_fp - \l__tenkz_kernel_r_xc_fp ) / 16 ) } } } \cs_new_protected:Npn \__tenkz_kernel_r_rail_record:n #1 { \__tenkz_model_get:nnN {#1} {name} \l__tenkz_kernel_r_tl \__tenkz_kernel_event:n { closure-rail|picture=k\int_use:N \g__tenkz_kernel_picture_int |name=\tl_use:N \l__tenkz_kernel_r_tl |row=\tl_use:N \l__tenkz_kernel_r_row_tl |side=west-east |west=\__tenkz_kernel_r_rail_end:NNN \l__tenkz_kernel_r_wrap_lend_bool \l__tenkz_kernel_r_wrap_lx_fp \l__tenkz_kernel_r_wrap_ly_fp |east=\__tenkz_kernel_r_rail_end:NNN \l__tenkz_kernel_r_wrap_rend_bool \l__tenkz_kernel_r_wrap_rx_fp \l__tenkz_kernel_r_wrap_ry_fp |stroke=\dim_to_decimal_in_sp:n { \__tenkz_dim:n {wirewidth} / 2 } |clear=\tl_use:N \l__tenkz_kernel_r_rail_clear_tl |points=\tl_use:N \l__tenkz_kernel_r_rail_tl } } \cs_new_protected:Npn \__tenkz_kernel_r_wire_trace:n #1 { \__tenkz_model_get:nnN {#1} {side} \l__tenkz_kernel_r_tl \str_case:VnF \l__tenkz_kernel_r_tl { {west-east} { % Resolving the ends walks the port nodes and so writes the row % and column registers; take them before the row is read. \__tenkz_kernel_r_wrap_ends:n {#1} \__tenkz_model_get:nnN {#1} {row} \l__tenkz_kernel_r_row_tl \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_row_tl } { 1 - \__tenkz_metric_ratio:n {wrapreach} } \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_row_tl } { \l__tenkz_kernel_r_cols_int + \__tenkz_metric_ratio:n {wrapreach} } \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \bool_lazy_and:nnTF { \str_if_eq_p:ee { \__tenkz_kernel_r_frame_word: } {circle} } { \int_compare_p:nNn { \l__tenkz_kernel_r_cols_int } > {1} } { % The two reach points straddle the frame's closing sector. % Follow that short sector at the frame radius; joining them % directly cuts a chord through the ring. % % On a ring the row's own virtual ends stand on the frame % circle, so the sector that joins them IS the closure: it % starts and finishes on the two sites and needs no straight % lead. Reading the ends also repairs the sector's extent. % A wrap reach beyond half a station puts the two reach % points on the wrong side of one another, and the arc % between them then ran backwards through a sliver of the % closing sector instead of across it. Each end is read on % its own, and a ring never takes a lead: a station and a % reach point both stand on the frame circle, so the sector % spans whatever the row has at either side. A row with one % station closes from that station round to the other side's % reach point, and is spared the straight chord a lead would % otherwise have cut across the ring. \bool_if:NT \l__tenkz_kernel_r_wrap_lend_bool { \fp_set_eq:NN \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_wrap_lx_fp \fp_set_eq:NN \l__tenkz_kernel_r_y_fp \l__tenkz_kernel_r_wrap_ly_fp } \bool_if:NT \l__tenkz_kernel_r_wrap_rend_bool { \fp_set_eq:NN \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_wrap_rx_fp \fp_set_eq:NN \l__tenkz_kernel_r_yb_fp \l__tenkz_kernel_r_wrap_ry_fp } \bool_set_false:N \l__tenkz_kernel_r_wrap_llead_bool \bool_set_false:N \l__tenkz_kernel_r_wrap_rlead_bool \fp_set:Nn \l__tenkz_kernel_r_reach_fp { sqrt ( \l__tenkz_kernel_r_x_fp ^ 2 + \l__tenkz_kernel_r_y_fp ^ 2 ) } \fp_set:Nn \l__tenkz_kernel_r_xc_fp { atand ( \l__tenkz_kernel_r_y_fp , \l__tenkz_kernel_r_x_fp ) } \fp_set:Nn \l__tenkz_kernel_r_yc_fp { atand ( \l__tenkz_kernel_r_yb_fp , \l__tenkz_kernel_r_xb_fp ) } % PGF reads the numeric difference literally. Unwrap the % second frame answer to the nearest copy of its angle, so a % closure crossing -180 degrees takes the short sector. \fp_sub:Nn \l__tenkz_kernel_r_yc_fp { 360 * round ( ( \l__tenkz_kernel_r_yc_fp - \l__tenkz_kernel_r_xc_fp ) / 360 , 0 ) } \__tenkz_kernel_r_wire_stroke:nn { bond } { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } arc [ start~angle = \fp_use:N \l__tenkz_kernel_r_xc_fp , end~angle = \fp_use:N \l__tenkz_kernel_r_yc_fp , radius = \__tenkz_kernel_r_pt:n { \l__tenkz_kernel_r_reach_fp } ] } \__tenkz_kernel_r_rail_arc: \__tenkz_kernel_r_rail_record:n {#1} } { % A flat row closes the way the sources draw it: the rail % leaves both ends, swings past the row by the trace reach, % and runs back. Joining the two reach points directly % would lay the closure along the row it closes. A traced % row inside a multi-row picture closes around its own row % only, so the return keeps to the row's outward side -- % the side with fewer rows between it and the picture edge, % below on a tie, which leaves the single-row rail exactly % where it runs today. Where n > 0 rows lie on that side, % the rail runs one trace reach past the outward extreme of % their frame-transformed row lines per return crossed, and % leads out by the same count of trace reaches beyond the % envelope of their west and east reach points before it % turns. Both the depth and the lead read the passed rows % through the frame, so on a sheared frame -- whose rows % stand offset in page x -- nested returns still clear one % another by one trace reach in page space, and the rail % crosses no row, no inter-row pairing, and no other return % between its reach points. % Each side branch of \__tenkz_kernel_r_trace_side_reach: % states only its constants: the arc angles, the outward % sign, the rows passed, and the envelope range. The % reach and lead arithmetic is written once there, so a % change to it cannot reach one side and miss the other. \__tenkz_kernel_r_trace_side_reach: \fp_sub:Nn \l__tenkz_kernel_r_wrap_wx_fp { \l__tenkz_kernel_r_xc_fp * \__tenkz_metric_ratio:n {pairtracereach} } \fp_add:Nn \l__tenkz_kernel_r_wrap_ex_fp { \l__tenkz_kernel_r_xc_fp * \__tenkz_metric_ratio:n {pairtracereach} } \__tenkz_kernel_r_wire_stroke:nn { bond } { \bool_if:NT \l__tenkz_kernel_r_wrap_llead_bool { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_wrap_lx_fp } { \l__tenkz_kernel_r_wrap_ly_fp } -- } \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } \fp_compare:nNnF { \l__tenkz_kernel_r_wrap_wx_fp } = { \l__tenkz_kernel_r_x_fp } { -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_wrap_wx_fp } { \l__tenkz_kernel_r_y_fp } } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_wrap_wx_fp } { \l__tenkz_kernel_r_y_fp + \l__tenkz_kernel_r_yc_fp * ( \l__tenkz_kernel_r_reach_fp - \__tenkz_metric_ratio:n {pairtracereach} / 2 ) } arc [ start~angle = 180 , end~angle = \tl_use:N \l__tenkz_kernel_r_b_tl , radius = \__tenkz_kernel_r_pt:n { \__tenkz_metric_ratio:n {pairtracereach} / 2 } ] -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_wrap_ex_fp - \__tenkz_metric_ratio:n {pairtracereach} / 2 } { \l__tenkz_kernel_r_yb_fp + \l__tenkz_kernel_r_yc_fp * \l__tenkz_kernel_r_reach_fp } arc [ start~angle = \tl_use:N \l__tenkz_kernel_r_b_tl , end~angle = \tl_use:N \l__tenkz_kernel_r_c_tl , radius = \__tenkz_kernel_r_pt:n { \__tenkz_metric_ratio:n {pairtracereach} / 2 } ] \fp_compare:nNnF { \l__tenkz_kernel_r_wrap_ex_fp } = { \l__tenkz_kernel_r_xb_fp } { -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_wrap_ex_fp } { \l__tenkz_kernel_r_yb_fp } } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yb_fp } \bool_if:NT \l__tenkz_kernel_r_wrap_rlead_bool { -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_wrap_rx_fp } { \l__tenkz_kernel_r_wrap_ry_fp } } } \__tenkz_kernel_r_rail_flat: \__tenkz_kernel_r_rail_record:n {#1} } } {north-south} { \__tenkz_model_get:nnN {#1} {col} \l__tenkz_kernel_r_col_tl \__tenkz_kernel_r_frame_xy:nnNN { 1 - \__tenkz_metric_ratio:n {wrapreach} } { \l__tenkz_kernel_r_col_tl } \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_rows_int + \__tenkz_metric_ratio:n {wrapreach} } { \l__tenkz_kernel_r_col_tl } \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \__tenkz_kernel_r_wire_stroke:nn { bond } { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yb_fp } } } {interface} { \__tenkz_model_get:nnN {#1} {interface} \l__tenkz_kernel_r_row_tl \__tenkz_model_get:nnN {#1} {col} \l__tenkz_kernel_r_col_tl \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_row_tl } { \l__tenkz_kernel_r_col_tl } \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_row_tl + 1 } { \l__tenkz_kernel_r_col_tl } \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \__tenkz_kernel_r_wire_stroke:nn { bond } { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yb_fp } } } {physical} { \__tenkz_model_get:nnN {#1} {physical-axis} \l__tenkz_kernel_r_b_tl \str_if_eq:VnTF \l__tenkz_kernel_r_b_tl {transverse} { \seq_put_right:Nn \l__tenkz_kernel_r_after_atom_seq {#1} } { \int_compare:nNnTF { \l__tenkz_kernel_r_rows_int } = {1} { \seq_put_right:Nn \l__tenkz_kernel_r_after_atom_seq {#1} } { \__tenkz_kernel_r_wire_pair_trace:n {#1} } } } % A trace needs two opposing sides. The model retains a one-sided % request as an auditable sealed-boundary record, but it owns no ink. {west} { } {east} { } {north} { } {south} { } } { \msg_error:nnee {tenkz}{kernel-render-todo} { trace ~ side = \tl_use:N \l__tenkz_kernel_r_tl } {#1} } } % A multi-row physical trace joins the limiting rows. Its circular turns % use pairtracereach, while the atoms later cover the stroke ends. \cs_new_protected:Npn \__tenkz_kernel_r_wire_pair_trace:n #1 { \__tenkz_model_get:nnN {#1} {col} \l__tenkz_kernel_r_col_tl \__tenkz_kernel_r_frame_xy:nnNN {1} { \l__tenkz_kernel_r_col_tl } \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_rows_int } { \l__tenkz_kernel_r_col_tl } \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \fp_set:Nn \l__tenkz_kernel_r_reach_fp { \__tenkz_metric_ratio:n {pairtracereach} } \fp_set:Nn \l__tenkz_kernel_r_xc_fp { \l__tenkz_kernel_r_x_fp + \l__tenkz_kernel_r_reach_fp } \__tenkz_kernel_r_wire_stroke:nn { trace } { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp + \__tenkz_metric_ratio:n {physleg} } arc [ start~angle = 180 , end~angle = 0 , radius = \__tenkz_kernel_r_pt:n { \l__tenkz_kernel_r_reach_fp / 2 } ] -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_xc_fp } { \l__tenkz_kernel_r_yb_fp - \__tenkz_metric_ratio:n {physleg} } arc [ start~angle = 360 , end~angle = 180 , radius = \__tenkz_kernel_r_pt:n { \l__tenkz_kernel_r_reach_fp / 2 } ] -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yb_fp } } } % ---------- physical legs ---------------------------------------------------------------------- % A leg referenced by a declared crossing becomes an engine path (saved, % policed, gapped); its ink waits for the surgery. Every other leg draws % now. The leg's reach: physleg, or past its highest declared crossing. \bool_new:N \l__tenkz_kernel_leg_plan_collect_bool \bool_new:N \l__tenkz_kernel_leg_planned_bool \tl_new:N \l__tenkz_kernel_leg_plan_result_tl \tl_new:N \l__tenkz_kernel_leg_plan_cid_tl \tl_new:N \l__tenkz_kernel_leg_member_tl \fp_new:N \l__tenkz_kernel_leg_bendx_fp \fp_new:N \l__tenkz_kernel_leg_bendy_fp \cs_new_protected:Npn \__tenkz_kernel_r_legs: { \__tenkz_kernel_leg_plan_reset: \bool_set_true:N \l__tenkz_kernel_leg_plan_collect_bool \__tenkz_kernel_r_legs_walk: \__tenkz_kernel_leg_plan_resolve: \bool_set_false:N \l__tenkz_kernel_leg_plan_collect_bool \__tenkz_kernel_r_legs_walk: } \cs_new_protected:Npn \__tenkz_kernel_r_legs_walk: { \__tenkz_model_map_ids:nn {atom} { \__tenkz_model_get:nnN {##1} {skin} \l__tenkz_kernel_r_b_tl \str_if_eq:VnF \l__tenkz_kernel_r_b_tl {dots} { \__tenkz_kernel_policy_faces:nn {##1} { \__tenkz_kernel_r_leg:nn {##1} {####1} } } } } \cs_new_protected:Npn \__tenkz_kernel_r_physical_enclosure_affine: { \__tenkz_kernel_hull_reach_linear:NnnnN \l__tenkz_kernel_leg_obst_seq { \l__tenkz_kernel_leg_gx_tl } { \l__tenkz_kernel_leg_gy_tl } { ( \l__tenkz_kernel_leg_pad_tl + \l__tenkz_kernel_leg_depth_tl ) * \__tenkz_metric_ratio:n {daylight} * \l__tenkz_kernel_leg_tl } \l__tenkz_kernel_leg_reach_tl \fp_set:Nn \l__tenkz_kernel_r_reach_fp { max( \l__tenkz_kernel_r_reach_fp , ( \l__tenkz_kernel_leg_reach_tl - \l__tenkz_kernel_leg_gx_tl * \l__tenkz_kernel_r_x_fp - \l__tenkz_kernel_leg_gy_tl * \l__tenkz_kernel_r_y_fp ) / ( \l__tenkz_kernel_leg_gx_tl * cosd( \l__tenkz_kernel_leg_dir_tl ) + \l__tenkz_kernel_leg_gy_tl * sind( \l__tenkz_kernel_leg_dir_tl ) ) ) } } % Extend a physical ray through every declared enclosure containing its host. % In-plane cardinal policy legs use the affine chart's dual basis exactly. % The plane frame's independent transverse ray, and mixed-carrier contours, % use the page-direction support fold instead. \cs_new_protected:Npn \__tenkz_kernel_r_physical_enclosure:nn #1#2 { \__tenkz_model_map_ids:nn {mark} { \__tenkz_model_get:nnN {##1} {form} \l__tenkz_kernel_leg_tl \str_if_eq:VnT \l__tenkz_kernel_leg_tl {enclosure} { \__tenkz_model_get:nnN {##1} {members} \l__tenkz_kernel_leg_tl \quark_if_no_value:NF \l__tenkz_kernel_leg_tl { \exp_args:NNV \seq_set_from_clist:Nn \l__tenkz_kernel_leg_sel_seq \l__tenkz_kernel_leg_tl \seq_if_in:NnT \l__tenkz_kernel_leg_sel_seq {#1} { % A contour with nested contours stands further out; the % pierced leg tracks it by the same containment depth. \tl_set:Ne \l__tenkz_kernel_leg_depth_tl { \__tenkz_kernel_mark_depth:n {##1} } \tl_set:Nn \l__tenkz_kernel_leg_pad_tl {2} \__tenkz_kernel_hull_obstacles:NN \l__tenkz_kernel_leg_sel_seq \l__tenkz_kernel_leg_obst_seq \__tenkz_kernel_hull_scale:NN \l__tenkz_kernel_leg_sel_seq \l__tenkz_kernel_leg_tl \__tenkz_kernel_hull_basis:NNNNN \l__tenkz_kernel_leg_sel_seq \l__tenkz_kernel_hull_ex_tl \l__tenkz_kernel_hull_ey_tl \l__tenkz_kernel_hull_nx_tl \l__tenkz_kernel_hull_ny_tl \__tenkz_geom_frame_if_affine:nTF {kpic} { \str_if_eq:eeTF { \__tenkz_kernel_r_frame_word: } {plane} { \__tenkz_kernel_r_leg_enclosure_orthogonal: } { \bool_if:NTF \l__tenkz_kernel_hull_chart_bool { \__tenkz_kernel_hull_basis_dual: \str_case:nnF {#2} { {n} { \tl_set_eq:NN \l__tenkz_kernel_leg_gx_tl \l__tenkz_kernel_hull_vx_tl \tl_set_eq:NN \l__tenkz_kernel_leg_gy_tl \l__tenkz_kernel_hull_vy_tl \__tenkz_kernel_r_physical_enclosure_affine: } {s} { \tl_set:Ne \l__tenkz_kernel_leg_gx_tl { -\l__tenkz_kernel_hull_vx_tl } \tl_set:Ne \l__tenkz_kernel_leg_gy_tl { -\l__tenkz_kernel_hull_vy_tl } \__tenkz_kernel_r_physical_enclosure_affine: } } { \__tenkz_kernel_r_leg_enclosure_orthogonal: } } { \__tenkz_kernel_r_leg_enclosure_orthogonal: } } } { \__tenkz_kernel_r_leg_enclosure_orthogonal: } } } } } } % An unbonded virtual port whose host sits inside a region window is cut by % that window's boundary: the stub runs one clearance past the contour of % the innermost enclosure containing its host, and no further. An outer % window does not meet a bond its inner neighbour already cut, so only the % minimal containing selections are folded; two windows over one selection % are both minimal and the outer one wins the fold. Physical rays keep % their established pierce-through-every-window reach. \tl_new:N \l__tenkz_kernel_venc_host_tl \seq_new:N \l__tenkz_kernel_venc_seq \seq_new:N \l__tenkz_kernel_venc_sel_seq \seq_new:N \l__tenkz_kernel_venc_probe_seq \bool_new:N \l__tenkz_kernel_venc_bool \cs_new_protected:Npn \__tenkz_kernel_r_virtual_enclosure:n #1 { \tl_set:Nn \l__tenkz_kernel_venc_host_tl {#1} \seq_clear:N \l__tenkz_kernel_venc_seq \__tenkz_model_map_marks_form:nN {enclosure} \__tenkz_kernel_r_virtual_enclosure_collect:n \seq_map_inline:Nn \l__tenkz_kernel_venc_seq { \__tenkz_kernel_r_virtual_enclosure_minimal:n {##1} } } \cs_new_protected:Npn \__tenkz_kernel_r_virtual_enclosure_collect:n #1 { \__tenkz_kernel_mark_members:nN {#1} \l__tenkz_kernel_venc_sel_seq \seq_if_in:NVT \l__tenkz_kernel_venc_sel_seq \l__tenkz_kernel_venc_host_tl { \seq_put_right:Nn \l__tenkz_kernel_venc_seq {#1} } } \cs_new_protected:Npn \__tenkz_kernel_r_virtual_enclosure_minimal:n #1 { \__tenkz_kernel_mark_members:nN {#1} \l__tenkz_kernel_venc_sel_seq \bool_set_false:N \l__tenkz_kernel_venc_bool \seq_map_inline:Nn \l__tenkz_kernel_venc_seq { \str_if_eq:nnF {##1} {#1} { \__tenkz_kernel_mark_members:nN {##1} \l__tenkz_kernel_venc_probe_seq % a strict subset is a subset with strictly fewer members: the % canonical membership holds no repetitions \int_compare:nNnT { \seq_count:N \l__tenkz_kernel_venc_probe_seq } < { \seq_count:N \l__tenkz_kernel_venc_sel_seq } { \__tenkz_kernel_seq_subset:NNN \l__tenkz_kernel_venc_probe_seq \l__tenkz_kernel_venc_sel_seq \l__tenkz_kernel_depth_bool \bool_if:NT \l__tenkz_kernel_depth_bool { \bool_set_true:N \l__tenkz_kernel_venc_bool \seq_map_break: } } } } \bool_if:NF \l__tenkz_kernel_venc_bool { \__tenkz_kernel_r_virtual_enclosure_reach:n {#1} } } \cs_new_protected:Npn \__tenkz_kernel_r_virtual_enclosure_reach:n #1 { \__tenkz_kernel_mark_members:nN {#1} \l__tenkz_kernel_venc_sel_seq \__tenkz_kernel_hull_obstacles:NN \l__tenkz_kernel_venc_sel_seq \l__tenkz_kernel_leg_obst_seq \__tenkz_kernel_hull_scale:NN \l__tenkz_kernel_venc_sel_seq \l__tenkz_kernel_leg_tl \tl_set:Ne \l__tenkz_kernel_leg_depth_tl { \__tenkz_kernel_mark_depth:n {#1} } % The boundary that cuts the index owns its end: the stub runs to the % window contour and stops on it, claiming a cut rather than a crossing. \tl_set:Nn \l__tenkz_kernel_leg_pad_tl {1} % A stub leaves through one contour side. On an affine chart the side a % cardinal face crosses is read off the dual basis exactly, as in-plane % cardinal policy legs do; a non-cardinal face and a chartless selection % keep the page-direction support fold. \__tenkz_kernel_hull_basis:NNNNN \l__tenkz_kernel_venc_sel_seq \l__tenkz_kernel_hull_ex_tl \l__tenkz_kernel_hull_ey_tl \l__tenkz_kernel_hull_nx_tl \l__tenkz_kernel_hull_ny_tl \__tenkz_geom_frame_if_affine:nTF {kpic} { \bool_if:NTF \l__tenkz_kernel_hull_chart_bool { \__tenkz_kernel_hull_basis_dual: \str_case:enF { \__tenkz_kernel_r_compass:n { \tl_use:N \l__tenkz_kernel_port_face_tl } } { {0} { \tl_set_eq:NN \l__tenkz_kernel_leg_gx_tl \l__tenkz_kernel_hull_ux_tl \tl_set_eq:NN \l__tenkz_kernel_leg_gy_tl \l__tenkz_kernel_hull_uy_tl \__tenkz_kernel_r_physical_enclosure_affine: } {90} { \tl_set_eq:NN \l__tenkz_kernel_leg_gx_tl \l__tenkz_kernel_hull_vx_tl \tl_set_eq:NN \l__tenkz_kernel_leg_gy_tl \l__tenkz_kernel_hull_vy_tl \__tenkz_kernel_r_physical_enclosure_affine: } {180} { \tl_set:Ne \l__tenkz_kernel_leg_gx_tl { -\l__tenkz_kernel_hull_ux_tl } \tl_set:Ne \l__tenkz_kernel_leg_gy_tl { -\l__tenkz_kernel_hull_uy_tl } \__tenkz_kernel_r_physical_enclosure_affine: } {270} { \tl_set:Ne \l__tenkz_kernel_leg_gx_tl { -\l__tenkz_kernel_hull_vx_tl } \tl_set:Ne \l__tenkz_kernel_leg_gy_tl { -\l__tenkz_kernel_hull_vy_tl } \__tenkz_kernel_r_physical_enclosure_affine: } } { \__tenkz_kernel_r_leg_enclosure_orthogonal: } } { \__tenkz_kernel_r_leg_enclosure_orthogonal: } } { \__tenkz_kernel_r_leg_enclosure_orthogonal: } } % The canonical name of the leg leaving face #1 of the cell held in the leg's % own row and column registers, left in #2. Every consumer -- the model % record, the engine path, the crossing operand, the address -- spells the % leg through this one production. \cs_new_protected:Npn \__tenkz_kernel_leg_name:nN #1#2 { \tl_set:Ne #2 { leg-#1-\tl_use:N \l__tenkz_kernel_leg_row_tl -\tl_use:N \l__tenkz_kernel_leg_col_tl } } % One ink walk per exposed slot: the legs of a spanning atom leave one per % spanned cell, exactly where the same slots' authored ports would. \cs_new_protected:Npn \__tenkz_kernel_r_leg:nn #1#2 { \__tenkz_kernel_policy_leg_map:nnn {#1} {#2} { \__tenkz_kernel_r_leg_slot:nnn {#1} {#2} {##1} } } % The resolved geometry of one policy-leg slot: the leg's name, bearing, % base point (page registers), and reach -- the maximum over the bare % physical ray, every enclosure it pierces, every route lane crossing it, % and every declared crossing. The leg pass inks from these values -- after % \__tenkz_kernel_r_leg_plan_apply: has put a lane corridor in their place % where one was planned -- and the annotation layering of % \__tenkz_kernel_r_mark_rails:n reads the same two productions, so what a % mark steps past and what the picture draws cannot drift apart. \bool_new:N \l__tenkz_kernel_leg_geom_bool \cs_new_protected:Npn \__tenkz_kernel_r_leg_geometry:nnn #1#2#3 { % The host's own slot span, resolved here rather than inherited from the % leg pass's loop, so a reader outside that pass -- the annotation % layering -- takes the bearing this host's slot has and not the span the % previous host left in the register. \__tenkz_kernel_policy_leg_span:nN {#1} \l__tenkz_kernel_policy_span_tl \__tenkz_kernel_atom_rc:nNNN {#1} \l__tenkz_kernel_leg_row_tl \l__tenkz_kernel_leg_col_tl \l_tmpa_bool \bool_lazy_and:nnTF { \bool_if_p:N \l_tmpa_bool } { ! \quark_if_no_value_p:N \l__tenkz_kernel_policy_span_tl } { \bool_set_true:N \l__tenkz_kernel_leg_geom_bool } { \bool_set_false:N \l__tenkz_kernel_leg_geom_bool } \bool_if:NT \l__tenkz_kernel_leg_geom_bool { \tl_set:Ne \l__tenkz_kernel_leg_col_tl { \int_eval:n { \l__tenkz_kernel_leg_col_tl + #3 - 1 } } \__tenkz_kernel_leg_name:nN {#2} \l__tenkz_kernel_leg_name_tl % A spanning atom's slots read the frame at their own spanned cell: % its local bearing and its cell point, which is where the same % slot's authored port stands. The one bearing production keeps the % ink, the signature, and the route classifier in agreement. \__tenkz_kernel_policy_slot_bearing:nnnN {#1} {#2} {#3} \l__tenkz_kernel_leg_dir_tl \bool_set_false:N \l__tenkz_kernel_leg_planned_bool \bool_if:NT \l__tenkz_kernel_r_basis_plane_bool { \bool_set_true:N \l__tenkz_kernel_leg_planned_bool % A barren `none` host has no glyph face to probe. Its physical % leg retains the established centre-origin fallback and stays % outside the affine lane planner. \__tenkz_kernel_hull_resolve_skin:n {#1} \str_if_eq:VnT \l__tenkz_kernel_hull_skin_tl {none} { \prop_if_in:NnF \l__tenkz_kernel_skin_pairing_host_prop {#1} { \bool_set_false:N \l__tenkz_kernel_leg_planned_bool } } } \bool_if:NTF \l__tenkz_kernel_leg_planned_bool { \exp_args:NnV \__tenkz_kernel_r_glyph_anchor_xy:nnNN {#1} \l__tenkz_kernel_r_physical_anchor_tl \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \bool_if:NF \l__tenkz_kernel_hull_measure_valid_bool { \bool_set_false:N \l__tenkz_kernel_leg_planned_bool \__tenkz_kernel_r_xy:nNN {#1} \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp } } { \int_compare:nNnTF { \l__tenkz_kernel_policy_span_tl } > {1} { \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_leg_row_tl } { \l__tenkz_kernel_leg_col_tl } \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp } { \__tenkz_kernel_r_xy:nNN {#1} \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp } } \fp_set:Nn \l__tenkz_kernel_r_reach_fp { \__tenkz_metric_ratio:n {physleg} } % An in-plane physical leg passes its enclosing contour by one % clearance. A plane transverse leg instead leaves the sheet itself; % the sheet's perimeter does not determine its reach. \bool_if:NF \l__tenkz_kernel_r_basis_plane_bool { \__tenkz_kernel_r_physical_enclosure:nn {#1} {#2} } % A leg crossed by a route is as long as the outermost route crossing % it, plus one clearance, so a crossing the author claimed by naming % the side always exists and the crossing police can no longer fall % silent where a leg stopped short of the string. \prop_get:NVN \l__tenkz_kernel_ro_legs_prop \l__tenkz_kernel_leg_name_tl \l__tenkz_kernel_leg_reach_tl \quark_if_no_value:NF \l__tenkz_kernel_leg_reach_tl { \clist_map_inline:Vn \l__tenkz_kernel_leg_reach_tl { \tl_set:Nn \l__tenkz_kernel_ro_row_tl {##1} \exp_last_unbraced:NV \__tenkz_kernel_r_leg_lane:nnn \l__tenkz_kernel_ro_row_tl } } % a declared crossing lengthens the leg past the crossing string \prop_get:NVN \l__tenkz_kernel_r_legref_prop \l__tenkz_kernel_leg_name_tl \l__tenkz_kernel_r_b_tl \quark_if_no_value:NF \l__tenkz_kernel_r_b_tl { % Topology and ink use the same declared-reference reach. \exp_args:NV \clist_map_inline:nn \l__tenkz_kernel_r_b_tl { \__tenkz_kernel_r_leg_reach:n {##1} } } } } \cs_new_protected:Npn \__tenkz_kernel_r_leg_slot:nnn #1#2#3 { \__tenkz_kernel_r_leg_geometry:nnn {#1} {#2} {#3} \bool_if:NT \l__tenkz_kernel_leg_geom_bool { \bool_if:NTF \l__tenkz_kernel_leg_plan_collect_bool { \bool_if:NT \l__tenkz_kernel_leg_planned_bool { \__tenkz_kernel_r_leg_plan_enrol:nn {#1}{#2} } } { \__tenkz_kernel_r_leg_consume:nn {#1}{#2} } } } % Enrol one plane-carried physical leg in a discrete topology corridor. The % independent transverse line belongs to one exact basis member and cell; it % is parallel to, but not identified with, the transverse line at any other % PEPS site. No page coordinate is rounded or clustered to invent identity. \cs_new_protected:Npn \__tenkz_kernel_r_leg_plan_enrol:nn #1#2 { \__tenkz_model_get:nnN {#1} {member} \l__tenkz_kernel_leg_member_tl \quark_if_no_value:NT \l__tenkz_kernel_leg_member_tl { \tl_set:Nn \l__tenkz_kernel_leg_member_tl {1} } \tl_set:Ne \l__tenkz_kernel_leg_plan_cid_tl { member-\tl_use:N \l__tenkz_kernel_leg_member_tl / transverse-#2 / row-\tl_use:N \l__tenkz_kernel_leg_row_tl / col-\tl_use:N \l__tenkz_kernel_leg_col_tl } % Reach computation may have used hull services with the same scratch % registers, so reload the record basis immediately before declaration. \__tenkz_kernel_r_carrier_basis:n {#1} \__tenkz_kernel_leg_plan_corridor:nnnnn { \l__tenkz_kernel_leg_plan_cid_tl } { cosd( \l__tenkz_kernel_leg_dir_tl ) } { sind( \l__tenkz_kernel_leg_dir_tl ) } { \l__tenkz_kernel_r_basis_ex_tl } { \l__tenkz_kernel_r_basis_ey_tl } \__tenkz_kernel_leg_plan_enrol:nnnnn { \l__tenkz_kernel_leg_name_tl } { \l__tenkz_kernel_leg_plan_cid_tl } { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } { \l__tenkz_kernel_r_reach_fp } } \cs_new_protected:Npn \__tenkz_kernel_r_leg_plan_unpack:nnnnnnnn #1#2#3#4#5#6#7#8 { \fp_set:Nn \l__tenkz_kernel_r_reach_fp {#2} \fp_set:Nn \l__tenkz_kernel_r_x_fp {#3} \fp_set:Nn \l__tenkz_kernel_r_y_fp {#4} \fp_set:Nn \l__tenkz_kernel_leg_bendx_fp {#5} \fp_set:Nn \l__tenkz_kernel_leg_bendy_fp {#6} \fp_set:Nn \l__tenkz_kernel_r_tipx_fp {#7} \fp_set:Nn \l__tenkz_kernel_r_tipy_fp {#8} } % Replace a planned leg's bare geometry by the corridor the lane planner % settled for it. Taken after the plan exists, so the collecting pass is not % a caller: the ink pass and the annotation layering both read the resolved % leg through this one production. \cs_new_protected:Npn \__tenkz_kernel_r_leg_plan_apply: { \bool_if:NT \l__tenkz_kernel_leg_planned_bool { \__tenkz_kernel_leg_plan_get:nN { \l__tenkz_kernel_leg_name_tl } \l__tenkz_kernel_leg_plan_result_tl \quark_if_no_value:NTF \l__tenkz_kernel_leg_plan_result_tl { \bool_set_false:N \l__tenkz_kernel_leg_planned_bool } { \exp_last_unbraced:NV \__tenkz_kernel_r_leg_plan_unpack:nnnnnnnn \l__tenkz_kernel_leg_plan_result_tl } } } \cs_new_protected:Npn \__tenkz_kernel_r_leg_consume:nn #1#2 { \__tenkz_kernel_r_leg_plan_apply: \bool_if:NTF \l__tenkz_kernel_topology_bool { \__tenkz_kernel_r_leg_ink:nnn {#1} {#2} { \l__tenkz_kernel_leg_name_tl } } { \quark_if_no_value:NTF \l__tenkz_kernel_r_b_tl { \__tenkz_kernel_r_leg_ink:nnn {#1} {#2} { } } { \__tenkz_kernel_r_leg_ink:nnn {#1} {#2} { \l__tenkz_kernel_leg_name_tl } } } } % Circle and mixed-carrier contours retain their established orthogonal % support reach; they do not claim one common affine chart. \cs_new_protected:Npn \__tenkz_kernel_r_leg_enclosure_orthogonal: { \__tenkz_kernel_hull_reach:NnnN \l__tenkz_kernel_leg_obst_seq { \l__tenkz_kernel_leg_dir_tl } { ( \l__tenkz_kernel_leg_pad_tl + \l__tenkz_kernel_leg_depth_tl ) * \__tenkz_metric_ratio:n {daylight} * \l__tenkz_kernel_leg_tl } \l__tenkz_kernel_leg_reach_tl \fp_set:Nn \l__tenkz_kernel_r_reach_fp { max( \l__tenkz_kernel_r_reach_fp , \l__tenkz_kernel_leg_reach_tl - \l__tenkz_kernel_r_x_fp * cosd( \l__tenkz_kernel_leg_dir_tl ) - \l__tenkz_kernel_r_y_fp * sind( \l__tenkz_kernel_leg_dir_tl ) ) } } % How far along its own page direction a leg must run to meet a route lane. % #1 is the lane coordinate and (#2,#3) is the dual-basis covector which reads % that coordinate. This line/covector intersection is valid for rotation, % shear, and unequal scale alike. \cs_new_protected:Npn \__tenkz_kernel_r_leg_lane:nnn #1#2#3 { \fp_compare:nNnF { (#2) * cosd( \l__tenkz_kernel_leg_dir_tl ) + (#3) * sind( \l__tenkz_kernel_leg_dir_tl ) } = {0} { \fp_set:Nn \l__tenkz_kernel_r_reach_fp { max( \l__tenkz_kernel_r_reach_fp , abs ( ( (#1) - (#2) * \l__tenkz_kernel_r_x_fp - (#3) * \l__tenkz_kernel_r_y_fp ) / ( (#2) * cosd( \l__tenkz_kernel_leg_dir_tl ) + (#3) * sind( \l__tenkz_kernel_leg_dir_tl ) ) ) + \__tenkz_metric_ratio:n {legcrossclear} ) } } } \tl_new:N \l__tenkz_kernel_leg_ref_kind_tl \tl_new:N \l__tenkz_kernel_leg_ref_end_tl \fp_new:N \l__tenkz_kernel_leg_ref_x_fp \fp_new:N \l__tenkz_kernel_leg_ref_y_fp % reach to the referencing wire's own resolved ends: #1 the wire record id \cs_new_protected:Npn \__tenkz_kernel_r_leg_reach:n #1 { % Only an authored wire's ends are address nodes; a skin pairing's % record spells its ends in port grammar and contributes no reach, as % it contributed none when this read the waypoint field. \__tenkz_model_get:nnN {#1} {kind} \l__tenkz_kernel_leg_ref_kind_tl \bool_lazy_and:nnT { ! \quark_if_no_value_p:N \l__tenkz_kernel_leg_ref_kind_tl } { \str_if_eq_p:Vn \l__tenkz_kernel_leg_ref_kind_tl {string} || \str_if_eq_p:Vn \l__tenkz_kernel_leg_ref_kind_tl {index} } { \__tenkz_kernel_r_leg_reach_ends:n {#1} } } \cs_new_protected:Npn \__tenkz_kernel_r_leg_reach_ends:n #1 { \clist_map_inline:nn { from , to } { \__tenkz_model_get:nnN {#1} {##1} \l__tenkz_kernel_leg_ref_end_tl % An end that stands on another string -- an on-wire fraction, a % crossing, a leg -- resolves only after routes are saved, and an % open end stands at the frame boundary, past every crossing its % wire makes on the way; neither bounds the crossing, so neither % contributes reach, as neither did when this read the waypoint % field. Every other frame-anchored end resolves now. \bool_lazy_all:nT { { ! \quark_if_no_value_p:N \l__tenkz_kernel_leg_ref_end_tl } { \str_if_eq_p:ee { \str_range:Nnn \l__tenkz_kernel_leg_ref_end_tl {1} {5} } {addr-} } { ! \str_if_eq_p:ee { \__tenkz_kernel_r_item:nn { \tl_use:N \l__tenkz_kernel_leg_ref_end_tl } {kind} } {crossing} } { ! \str_if_eq_p:ee { \__tenkz_kernel_r_item:nn { \tl_use:N \l__tenkz_kernel_leg_ref_end_tl } {kind} } {onwire} } { ! \str_if_eq_p:ee { \__tenkz_kernel_r_item:nn { \tl_use:N \l__tenkz_kernel_leg_ref_end_tl } {kind} } {leg} } { ! \str_if_eq_p:ee { \__tenkz_kernel_r_item:nn { \tl_use:N \l__tenkz_kernel_leg_ref_end_tl } {kind} } {outside} } } { \__tenkz_kernel_r_node:V \l__tenkz_kernel_leg_ref_end_tl \__tenkz_kernel_r_xy:nNN { \tl_use:N \l__tenkz_kernel_leg_ref_end_tl } \l__tenkz_kernel_leg_ref_x_fp \l__tenkz_kernel_leg_ref_y_fp % how far the wire stands ALONG THE LEG: the wire's own ends % are resolved page points, so each one's distance is the % projection onto the direction the leg leaves in. Down the % page it is the old vertical delta, an end behind the leg % projects negative rather than lengthening it backwards, and % the farther of the two ends is where the declared crossing % can stand at its highest. \fp_set:Nn \l__tenkz_kernel_r_reach_fp { max( \l__tenkz_kernel_r_reach_fp , ( \l__tenkz_kernel_leg_ref_x_fp - \l__tenkz_kernel_r_x_fp ) * cosd( \l__tenkz_kernel_leg_dir_tl ) + ( \l__tenkz_kernel_leg_ref_y_fp - \l__tenkz_kernel_r_y_fp ) * sind( \l__tenkz_kernel_leg_dir_tl ) + \__tenkz_metric_ratio:n {legcrossclear} ) } } } } % #3 empty: plain ink now; #3 a path id: save as an engine string instead % A flat or circular physical leg leaves along the atom's local north/south; % this makes circle-frame legs radial without an authored turn. A plane % physical leg instead follows the frame-owned transverse page axis resolved % before this ink pass. \fp_new:N \l__tenkz_kernel_r_tipx_fp \fp_new:N \l__tenkz_kernel_r_tipy_fp % A skin pairing keeps its geometric checks beside every renderer-owned % route, because it guards a glyph's own decoration. A leg of the glyph the % pairing decorates leaves through a port that pairing may also touch, and % that meeting is attachment rather than a crossing -- the same relation an % index wire leaving the same port already declares. \tl_new:N \l__tenkz_kernel_leg_skin_host_tl \tl_new:N \l__tenkz_kernel_leg_skin_name_tl \cs_new_protected:Npn \__tenkz_kernel_r_leg_skin_touch:n #1 { \seq_map_inline:Nn \l__tenkz_kernel_r_skin_routes_seq { \__tenkz_model_get:nnN {##1} {host} \l__tenkz_kernel_leg_skin_host_tl \str_if_eq:eeT { \tl_use:N \l__tenkz_kernel_leg_skin_host_tl } {#1} { \__tenkz_model_get:nnN {##1} {name} \l__tenkz_kernel_leg_skin_name_tl \exp_args:NVV \__tenkz_string_touch:nn \l__tenkz_kernel_leg_name_tl \l__tenkz_kernel_leg_skin_name_tl } } } \tl_new:N \l__tenkz_kernel_r_leg_turn_tl \tl_new:N \l__tenkz_kernel_r_leg_path_tl \cs_new_protected:Npn \__tenkz_kernel_r_leg_ink:nnn #1#2#3 { \bool_if:NF \l__tenkz_kernel_leg_planned_bool { \fp_set:Nn \l__tenkz_kernel_r_yc_fp { \l__tenkz_kernel_r_reach_fp } \fp_set:Nn \l__tenkz_kernel_r_tipx_fp { \l__tenkz_kernel_r_x_fp + \l__tenkz_kernel_r_yc_fp * cosd( \l__tenkz_kernel_leg_dir_tl ) } \fp_set:Nn \l__tenkz_kernel_r_tipy_fp { \l__tenkz_kernel_r_y_fp + \l__tenkz_kernel_r_yc_fp * sind( \l__tenkz_kernel_leg_dir_tl ) } } \tl_set:Ne \l__tenkz_kernel_r_leg_path_tl { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } } \bool_if:NT \l__tenkz_kernel_leg_planned_bool { \tl_put_right:Ne \l__tenkz_kernel_r_leg_path_tl { -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_leg_bendx_fp } { \l__tenkz_kernel_leg_bendy_fp } } } \tl_put_right:Ne \l__tenkz_kernel_r_leg_path_tl { -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_r_tipx_fp } { \l__tenkz_kernel_r_tipy_fp } } \tl_if_blank:nTF {#3} { % A leg that no declared crossing defers keeps its own ink pass, and % saves the route it inks under its canonical name exactly as an % ordinary index wire does. That is what lets a place on the leg be % read along the leg the reader sees. It joins the ordinary index % class of the crossing police, which is where a leg the picture % never named as a crossing operand has always stood. \__tenkz_string_save_route:VV \l__tenkz_kernel_leg_name_tl \l__tenkz_kernel_r_leg_path_tl \exp_args:NV \__tenkz_string_touch_all:nn \l__tenkz_kernel_leg_name_tl {leg} \__tenkz_kernel_r_leg_skin_touch:n {#1} % The capture key rides the same option list the real path strokes % with, as its last token, so the resolved width is read once, as % part of the one real stroke (#6330 review; see the key's own % comment above). \exp_args:NnV \__tenkz_render_stroke:nn { bond , tenkz~ink~capture~width } \l__tenkz_kernel_r_leg_path_tl \tl_set_eq:NN \l__tenkz_kernel_ink_stroke_tl \g__tenkz_kernel_ink_width_tl \exp_args:NV \__tenkz_kernel_r_wire_ink_event:nn \l__tenkz_kernel_leg_name_tl { leg } } { \tl_set:Ne \l__tenkz_kernel_r_c_tl { \__tenkz_kernel_r_ppt:nn { \l__tenkz_kernel_r_x_fp } { \l__tenkz_kernel_r_y_fp } } \bool_if:NT \l__tenkz_kernel_leg_planned_bool { \tl_put_right:Ne \l__tenkz_kernel_r_c_tl { \__tenkz_kernel_r_ppt:nn { \l__tenkz_kernel_leg_bendx_fp } { \l__tenkz_kernel_leg_bendy_fp } } } \tl_put_right:Ne \l__tenkz_kernel_r_c_tl { \__tenkz_kernel_r_ppt:nn { \l__tenkz_kernel_r_tipx_fp } { \l__tenkz_kernel_r_tipy_fp } } \use:e { \exp_not:N \__tenkz_string_declare_open:nn {#3} { \exp_not:V \l__tenkz_kernel_r_c_tl } } \prop_put:Nen \l__tenkz_kernel_r_legdrawn_prop {#3} { } } } % ---------- strings ------------------------------------------------------------------------------ % Pre-scan: crossing declarations that reference legs, so the leg pass can % register those legs as engine paths before any string is declared. \cs_new_protected:Npn \__tenkz_kernel_r_legref_add:nn #1#2 { \prop_get:NnN \l__tenkz_kernel_r_legref_prop {#1} \l__tenkz_kernel_r_tl \quark_if_no_value:NTF \l__tenkz_kernel_r_tl { \prop_put:Nnn \l__tenkz_kernel_r_legref_prop {#1} {#2} } { \clist_if_in:NnF \l__tenkz_kernel_r_tl {#2} { \tl_put_right:Nn \l__tenkz_kernel_r_tl {,#2} \prop_put:NnV \l__tenkz_kernel_r_legref_prop {#1} \l__tenkz_kernel_r_tl } } } \cs_generate_variant:Nn \__tenkz_kernel_r_legref_add:nn { VV } \cs_new_protected:Npn \__tenkz_kernel_r_cross_legref:nn #1#2 { \regex_extract_once:nnNT { \A \s* (over|under) \s+ at \s+ crossing \s+ of \s+ (.+) \s+ and \s+ (.+) \s* \Z } {#2} \l__tenkz_kernel_match_seq { \tl_set:Ne \l__tenkz_kernel_ro_a_tl { \seq_item:Nn \l__tenkz_kernel_match_seq {3} } \tl_set:Ne \l__tenkz_kernel_ro_b_tl { \seq_item:Nn \l__tenkz_kernel_match_seq {4} } \exp_args:NV \__tenkz_kernel_r_crossid:nN \l__tenkz_kernel_ro_a_tl \l__tenkz_kernel_r_b_tl \exp_args:NV \__tenkz_kernel_r_crossid:nN \l__tenkz_kernel_ro_b_tl \l__tenkz_kernel_r_c_tl \__tenkz_kernel_r_sid:nN {#1} \l__tenkz_kernel_r_sid_tl \tl_clear:N \l__tenkz_kernel_ro_a_tl \str_if_eq:VVTF \l__tenkz_kernel_r_b_tl \l__tenkz_kernel_r_sid_tl { \tl_set_eq:NN \l__tenkz_kernel_ro_a_tl \l__tenkz_kernel_r_c_tl } { \str_if_eq:VVT \l__tenkz_kernel_r_c_tl \l__tenkz_kernel_r_sid_tl { \tl_set_eq:NN \l__tenkz_kernel_ro_a_tl \l__tenkz_kernel_r_b_tl } } \exp_args:NnV \regex_match:nnT { \A (?:leg-[nesw]-\d+-\d+|port-open-[1-9]\d*) \Z } \l__tenkz_kernel_ro_a_tl { \tl_set:Nn \l__tenkz_kernel_ro_b_tl {#1} \exp_args:NVV \__tenkz_kernel_r_legref_add:nn \l__tenkz_kernel_ro_a_tl \l__tenkz_kernel_ro_b_tl } } } \cs_new_protected:Npn \__tenkz_kernel_r_prescan: { \prop_clear:N \l__tenkz_kernel_r_legref_prop \__tenkz_model_map_ids:nn {wire} { \__tenkz_model_get:nnN {##1} {cross} \l__tenkz_kernel_r_tl \quark_if_no_value:NF \l__tenkz_kernel_r_tl { \exp_args:NnV \regex_extract_all:nnN { leg \s+ ([nesw]) \s+ of \s+ \{? \s* \( \s* (\d+) \s* , \s* (\d+) \s* \) \s* \}? } \l__tenkz_kernel_r_tl \l__tenkz_kernel_r_scan_seq \int_step_inline:nnnn {2} {4} { \seq_count:N \l__tenkz_kernel_r_scan_seq } { \tl_set:Ne \l__tenkz_kernel_ro_a_tl { leg - \seq_item:Nn \l__tenkz_kernel_r_scan_seq {####1} - \seq_item:Nn \l__tenkz_kernel_r_scan_seq { ####1 + 1 } - \seq_item:Nn \l__tenkz_kernel_r_scan_seq { ####1 + 2 } } \tl_set:Nn \l__tenkz_kernel_ro_b_tl {##1} \exp_args:NVV \__tenkz_kernel_r_legref_add:nn \l__tenkz_kernel_ro_a_tl \l__tenkz_kernel_ro_b_tl } \exp_args:NV \clist_map_inline:nn \l__tenkz_kernel_r_tl { \__tenkz_kernel_r_cross_legref:nn {##1} {####1} } } } \__tenkz_kernel_r_route_measure_prepare: % A route's own crossing set joins the same ledger. Its legs become % engine paths whether or not the habit resolved their order, because a % crossing the picture does not resolve must still be one the crossing % police can see and refuse. \__tenkz_model_map_ids:nn {wire} { \__tenkz_kernel_route_legs:nN {##1} \l__tenkz_kernel_ro_leg_seq \prop_get:NnN \l__tenkz_kernel_ro_lane_prop {##1} \l__tenkz_kernel_ro_lane_tl \quark_if_no_value:NF \l__tenkz_kernel_ro_lane_tl { % The drawn route needs one lane coordinate, but its crossing % legs need the coordinate of the face each leg leaves. Restore % the whole measured box here so an all-side route does not make % a south leg chase its north edge. \prop_get:NnN \l__tenkz_kernel_ro_box_prop {##1} \l__tenkz_kernel_ro_b_tl \exp_last_unbraced:NV \__tenkz_kernel_r_route_box:nnnnnnnn \l__tenkz_kernel_ro_b_tl \seq_map_inline:Nn \l__tenkz_kernel_ro_leg_seq { \__tenkz_kernel_r_route_leg:nn {####1} {##1} } } } } % Route lanes and measured boxes are also needed by the topology prepass, % before address-bearing all-side routes can cache their endpoint turns. \cs_new_protected:Npn \__tenkz_kernel_r_route_measure_prepare: { \prop_clear:N \l__tenkz_kernel_ro_lane_prop \prop_clear:N \l__tenkz_kernel_ro_box_prop \prop_clear:N \l__tenkz_kernel_ro_legs_prop \prop_clear:N \l__tenkz_kernel_ro_taken_prop \prop_clear:N \l__tenkz_kernel_ro_family_prop \__tenkz_model_map_ids:nn {wire} { \__tenkz_kernel_r_route_measure:n {##1} } } % one leg of a route's crossing set: it is an engine path, and it reaches at % at least as far as every lane that crosses it \cs_new_protected:Npn \__tenkz_kernel_r_route_leg:nn #1#2 { \tl_set:Ne \l__tenkz_kernel_ro_b_tl { \tl_item:nn {#1} {1} } \prop_put:NVn \l__tenkz_kernel_r_legref_prop \l__tenkz_kernel_ro_b_tl {#2} % Every lane travels with the axes it is a coordinate in. For an % all-side route, choose the edge of the face this leg actually leaves: % north and south are distinct coordinates whenever the hull is not % symmetric. Bare lane scalars from differently turned selections cannot % be ordered, so retain all pairs and let the leg project each one into % its own direction. \tl_set:Ne \l__tenkz_kernel_ro_side_tl { \tl_item:nn {#1} {4} } \str_case:Vn \l__tenkz_kernel_ro_side_tl { {n} { \tl_set:Ne \l__tenkz_kernel_ro_lane_tl { \fp_eval:n { \l__tenkz_kernel_ro_yb_fp } } } {s} { \tl_set:Ne \l__tenkz_kernel_ro_lane_tl { \fp_eval:n { \l__tenkz_kernel_ro_y_fp } } } {e} { \tl_set:Ne \l__tenkz_kernel_ro_lane_tl { \fp_eval:n { \l__tenkz_kernel_ro_xb_fp } } } {w} { \tl_set:Ne \l__tenkz_kernel_ro_lane_tl { \fp_eval:n { \l__tenkz_kernel_ro_x_fp } } } } \str_case:VnTF \l__tenkz_kernel_ro_side_tl { {n}{} {s}{} } { \tl_set_eq:NN \l__tenkz_kernel_ro_gx_tl \l__tenkz_kernel_ro_vx_tl \tl_set_eq:NN \l__tenkz_kernel_ro_gy_tl \l__tenkz_kernel_ro_vy_tl } { \tl_set_eq:NN \l__tenkz_kernel_ro_gx_tl \l__tenkz_kernel_ro_ux_tl \tl_set_eq:NN \l__tenkz_kernel_ro_gy_tl \l__tenkz_kernel_ro_uy_tl } \tl_set:Ne \l__tenkz_kernel_ro_row_tl { { { \tl_use:N \l__tenkz_kernel_ro_lane_tl } { \tl_use:N \l__tenkz_kernel_ro_gx_tl } { \tl_use:N \l__tenkz_kernel_ro_gy_tl } } } \prop_get:NVN \l__tenkz_kernel_ro_legs_prop \l__tenkz_kernel_ro_b_tl \l__tenkz_kernel_ro_reach_tl \quark_if_no_value:NTF \l__tenkz_kernel_ro_reach_tl { \prop_put:NVV \l__tenkz_kernel_ro_legs_prop \l__tenkz_kernel_ro_b_tl \l__tenkz_kernel_ro_row_tl } { \tl_put_right:Ne \l__tenkz_kernel_ro_reach_tl { , \tl_use:N \l__tenkz_kernel_ro_row_tl } \prop_put:NVV \l__tenkz_kernel_ro_legs_prop \l__tenkz_kernel_ro_b_tl \l__tenkz_kernel_ro_reach_tl } } % the engine id of string record #1: its name, else the record id \cs_new_protected:Npn \__tenkz_kernel_r_sid:nN #1#2 { \__tenkz_model_get:nnN {#1} {name} #2 \quark_if_no_value:NT #2 { \tl_set:Nn #2 {#1} } } % Cache one undeclared non-prelude species in the picture-local house cycle. \cs_new_protected:Npn \__tenkz_kernel_r_cycle_hue:nN #1#2 { \prop_get:NnNF \l__tenkz_kernel_r_species_prop {#1} #2 { \tl_set:Ne #2 { \clist_item:Nn \c__tenkz_speccycle_clist { \int_mod:nn { \l__tenkz_kernel_r_species_cycle_int } { \clist_count:N \c__tenkz_speccycle_clist } + 1 } } \prop_put:NnV \l__tenkz_kernel_r_species_prop {#1} #2 \int_incr:N \l__tenkz_kernel_r_species_cycle_int } } % Species -> hue. An explicit hue is authoritative. Hue-less non-prelude % declarations reserve document-scope cycle slots, and other non-prelude % names take the next picture-local slots in model-record order. Prelude % names retain their fixed semantic hues unless explicitly overridden. \cs_new_protected:Npn \__tenkz_kernel_r_hue:nN #1#2 { \__tenkz_model_get:nnN {#1} {species} \l__tenkz_kernel_r_species_tl \quark_if_no_value:NTF \l__tenkz_kernel_r_species_tl { \__tenkz_kernel_r_host_hue:nN {#1} #2 } { \exp_args:NV \__tenkz_kernel_r_species_hue:nN \l__tenkz_kernel_r_species_tl #2 } } % A wire the policy stage generated declares no species of its own, and it is % not house ink: an open leg is its host atom's index leaving that atom, so it % carries the atom's colour. The record already names the host, which is the % only thing this needs to read. A record with no host, and an atom whose own % species is unset, keep the house ink they had. \cs_new_protected:Npn \__tenkz_kernel_r_host_hue:nN #1#2 { \__tenkz_model_get:nnN {#1} {host} \l__tenkz_kernel_r_host_tl \quark_if_no_value:NTF \l__tenkz_kernel_r_host_tl { \tl_set:Nn #2 { tenkzInk } } { \exp_args:NV \__tenkz_model_get:nnN \l__tenkz_kernel_r_host_tl {species} \l__tenkz_kernel_r_host_species_tl \quark_if_no_value:NTF \l__tenkz_kernel_r_host_species_tl { \tl_set:Nn #2 { tenkzInk } } { \exp_args:NV \__tenkz_kernel_r_species_hue:nN \l__tenkz_kernel_r_host_species_tl #2 } } } % Resolve a species name for every ink consumer. Declared hues win, % non-prelude names share the house cycle, and prelude names keep their fixed % semantic colors unless explicitly overridden; wires and skin pairings % therefore cannot color one species through different lookup paths. \cs_new_protected:Npn \__tenkz_kernel_r_species_hue:nN #1#2 { \prop_get:NnNTF \g__tenkz_kernel_species_prop {#1} \l__tenkz_kernel_r_species_descriptor_tl { \exp_args:NV \__tenkz_kernel_species_descriptor_hue:nN \l__tenkz_kernel_r_species_descriptor_tl #2 \tl_if_empty:NT #2 { \prop_get:NnNTF \g__tenkz_kernel_species_hue_prop {#1} #2 { } { \__tenkz_kernel_r_cycle_hue:nN {#1} #2 } } } { % The prelude words -- the four semantic roles and the five region % words the retired slot= key left to species= -- keep their fixed % hues from the one authority the declaration door also reads; any % other undeclared name rides the cycle. \__tenkz_kernel_prelude_hue:nN {#1} #2 \tl_if_empty:NT #2 { \__tenkz_kernel_r_cycle_hue:nN {#1} #2 } } } % ---------- the declared stroke of a wire --------------------------------------------------------- % A wire is solid unless it says otherwise. The two other spellings are the % ones the sources draw: a dashed rail for a wire that is present but not % contracted, and a dotted one for a lattice that lies under the sheet being % drawn. The pattern is a named metric, so a client never spells a dash % length of its own. \cs_new_protected:Npn \__tenkz_kernel_r_stroke_ink:nN #1#2 { \__tenkz_model_get:nnN {#1} {stroke} \l__tenkz_kernel_r_c_tl \quark_if_no_value:NF \l__tenkz_kernel_r_c_tl { \str_case:Vn \l__tenkz_kernel_r_c_tl { {dashed} { \tl_put_right:Nn #2 { , tenkz~wire~dashed } } {dotted} { \tl_put_right:Nn #2 { , tenkz~wire~dotted } } {solid} { } } } } % ---------- the station of a direction mark ------------------------------------------------------ % A leg springs from the centre of the glyph it leaves and the glyph's ink is % laid over it afterwards, so the named station -- a fraction of the whole % leg -- can fall inside the silhouette. A silhouette is wider than it is % tall, and an open leg is short, which is why the same mark that cleared a % south bearing vanished under an east one. The station is therefore % measured along the leg's DAYLIGHT: the stretch between the silhouette and % the free tip. It is the mark's BODY that rides the station, so the barb's % own length is set aside first and the barb never re-enters the silhouette % on any bearing. A leg whose near end already stands on the silhouette has % reach zero and keeps the plain station. \fp_new:N \l__tenkz_kernel_r_dir_reach_fp \fp_new:N \l__tenkz_kernel_r_dir_span_fp \fp_new:N \l__tenkz_kernel_r_dir_station_fp \fp_new:N \l__tenkz_kernel_r_dir_x_fp \fp_new:N \l__tenkz_kernel_r_dir_y_fp \fp_new:N \l__tenkz_kernel_r_dir_hx_fp \fp_new:N \l__tenkz_kernel_r_dir_hy_fp \tl_new:N \l__tenkz_kernel_r_dir_station_tl \tl_new:N \l__tenkz_kernel_r_dir_a_tl \tl_new:N \l__tenkz_kernel_r_dir_b_tl \tl_new:N \l__tenkz_kernel_r_dir_host_tl \cs_new_protected:Npn \__tenkz_kernel_r_dir_station:n #1 { \tl_clear:N \l__tenkz_kernel_r_dir_station_tl \__tenkz_model_get:nnN {#1} {kind} \l__tenkz_kernel_r_dir_a_tl \bool_lazy_and:nnT { \str_if_eq_p:Vn \l__tenkz_kernel_r_dir_a_tl {index} } { ! \str_if_eq_p:ee { \__tenkz_kernel_r_frame_word: } {plane} } { \__tenkz_kernel_r_dir_station_leg:n {#1} } } % An open leg is the one wire whose span is the named stub reach: one end is % a port on a glyph, the other is a free tip. Which end is open decides % whether the daylight is counted forward from the silhouette or backward % from the free tip. \cs_new_protected:Npn \__tenkz_kernel_r_dir_station_leg:n #1 { \__tenkz_model_get:nnN {#1} {from} \l__tenkz_kernel_r_dir_a_tl \__tenkz_model_get:nnN {#1} {to} \l__tenkz_kernel_r_dir_b_tl \quark_if_no_value:NTF \l__tenkz_kernel_r_dir_a_tl { \quark_if_no_value:NF \l__tenkz_kernel_r_dir_b_tl { \__tenkz_model_get:nnN {#1} {from-open} \l__tenkz_kernel_r_dir_a_tl \quark_if_no_value:NF \l__tenkz_kernel_r_dir_a_tl { \exp_args:NV \__tenkz_kernel_r_dir_reach:n \l__tenkz_kernel_r_dir_b_tl \__tenkz_kernel_r_dir_station_set:n {start} } } } { \quark_if_no_value:NT \l__tenkz_kernel_r_dir_b_tl { \__tenkz_model_get:nnN {#1} {to-open} \l__tenkz_kernel_r_dir_b_tl \quark_if_no_value:NF \l__tenkz_kernel_r_dir_b_tl { \exp_args:NV \__tenkz_kernel_r_dir_reach:n \l__tenkz_kernel_r_dir_a_tl \__tenkz_kernel_r_dir_station_set:n {end} } } } } % How far the glyph's silhouette reaches along the leg: the gap between the % point the leg is drawn from and the point at which it leaves the glyph. \cs_new_protected:Npn \__tenkz_kernel_r_dir_reach:n #1 { \fp_zero:N \l__tenkz_kernel_r_dir_reach_fp \str_if_eq:eeT { \__tenkz_kernel_node_item:nn {#1} {kind} } {port} { \__tenkz_kernel_r_port_record:nN {#1} \l__tenkz_kernel_r_dir_host_tl \quark_if_no_value:NF \l__tenkz_kernel_r_dir_host_tl { \__tenkz_kernel_r_wire_end_xy:nNN {#1} \l__tenkz_kernel_r_dir_x_fp \l__tenkz_kernel_r_dir_y_fp \__tenkz_kernel_r_hull_port_xy:nVNN {#1} \l__tenkz_kernel_r_dir_host_tl \l__tenkz_kernel_r_dir_hx_fp \l__tenkz_kernel_r_dir_hy_fp \fp_set:Nn \l__tenkz_kernel_r_dir_reach_fp { sqrt( ( \l__tenkz_kernel_r_dir_hx_fp - \l__tenkz_kernel_r_dir_x_fp ) ^ 2 + ( \l__tenkz_kernel_r_dir_hy_fp - \l__tenkz_kernel_r_dir_y_fp ) ^ 2 ) } } } } \cs_new_protected:Npn \__tenkz_kernel_r_dir_station_set:n #1 { \fp_compare:nNnT { \l__tenkz_kernel_r_dir_reach_fp } > { 0 } { \fp_set:Nn \l__tenkz_kernel_r_dir_span_fp { \dim_to_fp:n { \__tenkz_dim:n {barblen} } / \dim_to_fp:n { \use:c {tenkz@pitch} } + \__tenkz_metric_ratio:n {dirmarkstation} * max( \__tenkz_metric_ratio:n {stub} - \l__tenkz_kernel_r_dir_reach_fp - \dim_to_fp:n { \__tenkz_dim:n {barblen} } / \dim_to_fp:n { \use:c {tenkz@pitch} } , 0 ) } \str_if_eq:nnT {#1} {end} { \fp_add:Nn \l__tenkz_kernel_r_dir_span_fp { \l__tenkz_kernel_r_dir_reach_fp } } \fp_set:Nn \l__tenkz_kernel_r_dir_station_fp { min( \l__tenkz_kernel_r_dir_span_fp / \__tenkz_metric_ratio:n {stub} , 1 ) } \tl_set:Ne \l__tenkz_kernel_r_dir_station_tl { = { \fp_eval:n { \l__tenkz_kernel_r_dir_station_fp } } } } } % Ink semantics shared by index wires and strings. \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink:nN #1#2 { \__tenkz_kernel_r_hue:nN {#1} \l__tenkz_kernel_r_hue_tl \tl_set:Ne #2 { draw = \tl_use:N \l__tenkz_kernel_r_hue_tl } \__tenkz_kernel_r_stroke_ink:nN {#1} #2 \__tenkz_model_get:nnN {#1} {dir} \l__tenkz_kernel_r_c_tl \quark_if_no_value:NF \l__tenkz_kernel_r_c_tl { \str_case:Vn \l__tenkz_kernel_r_c_tl { {to} { \__tenkz_kernel_r_dir_station:n {#1} \tl_put_right:Ne #2 { , dir~marks \tl_use:N \l__tenkz_kernel_r_dir_station_tl } \__tenkz_kernel_r_wire_ink_dir_stash:n {#1} } {from} { \__tenkz_kernel_r_dir_station:n {#1} \tl_put_right:Ne #2 { , dir~marks~reversed \tl_use:N \l__tenkz_kernel_r_dir_station_tl } \__tenkz_kernel_r_wire_ink_dir_stash:n {#1} } {none} { } } } } % The station fraction just computed for the `dir marks` style word is the % SAME fraction the barb postaction places its mark at; stash it under the % wire's own id so the ink pass can find where to cover the barb without % re-deriving it from the resolved style text and without re-running any % live style key (#6330 review). Empty `l__tenkz_kernel_r_dir_station_tl` % means the style keeps its bare `.default`, the registry's own station % ratio; a non-empty one was just set, together with its own fp register, % by `\__tenkz_kernel_r_dir_station_set:n` above. \cs_new_protected:Npn \__tenkz_kernel_r_wire_ink_dir_stash:n #1 { \tl_if_empty:NTF \l__tenkz_kernel_r_dir_station_tl { \prop_put:Nne \l__tenkz_kernel_r_dir_mark_prop {#1} { \__tenkz_metric_ratio:n {dirmarkstation} } } { \prop_put:Nne \l__tenkz_kernel_r_dir_mark_prop {#1} { \fp_to_decimal:N \l__tenkz_kernel_r_dir_station_fp } } } % append the resolved (x, y) of address text #1 to the point list #2 \cs_new_protected:Npn \__tenkz_kernel_r_pts_add:nN #1#2 { \__tenkz_kernel_addr:nN {#1} \l__tenkz_kernel_r_node_tl \__tenkz_kernel_r_node:V \l__tenkz_kernel_r_node_tl \__tenkz_kernel_r_xy:nNN { \tl_use:N \l__tenkz_kernel_r_node_tl } \l__tenkz_kernel_r_xc_fp \l__tenkz_kernel_r_yc_fp \tl_put_right:Ne #2 { \__tenkz_kernel_r_ppt:nn { \l__tenkz_kernel_r_xc_fp } { \l__tenkz_kernel_r_yc_fp } } } % An affine open end first returns its routed neighbour to logical % coordinates, fixes the named row/column margin there, and applies the whole % frame again. This preserves the transverse logical coordinate under a % shear; mixing the neighbour's page x with a separately projected margin y % would silently turn every projected frame back into an axis-aligned one. \cs_new_protected:Npn \__tenkz_kernel_r_open_tip:nN #1#2 { \__tenkz_geom_frame_if_affine:nTF {kpic} { \__tenkz_kernel_r_open_tip_affine:nN {#1} #2 } { \__tenkz_kernel_r_open_tip_circle:nN {#1} #2 } } \cs_new_protected:Npn \__tenkz_kernel_r_open_tip_affine:nN #1#2 { \__tenkz_kernel_r_open_tip_affine_xy:nNN {#1} \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \tl_set:Ne #2 { \__tenkz_kernel_r_ppt:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yb_fp } } } \cs_new_protected:Npn \__tenkz_kernel_r_open_tip_affine_xy:nNN #1#2#3 { % A transverse word is not a logical ray: the tip stands one physical-leg % reach from its neighbour along the frame's signed page-space transverse % vector, exactly where the plane physical policy would end its own leg. \str_case:nnTF {#1} { {up} { \tl_set:Nn \l__tenkz_kernel_r_b_tl {n} } {down} { \tl_set:Nn \l__tenkz_kernel_r_b_tl {s} } } { \exp_args:NnV \__tenkz_geom_frame_transverse:nnNN {kpic} \l__tenkz_kernel_r_b_tl \l__tenkz_kernel_r_physical_x_tl \l__tenkz_kernel_r_physical_y_tl \fp_set:Nn #2 { \l__tenkz_kernel_r_xc_fp + \__tenkz_metric_ratio:n {physleg} * \l__tenkz_kernel_r_physical_x_tl } \fp_set:Nn #3 { \l__tenkz_kernel_r_yc_fp + \__tenkz_metric_ratio:n {physleg} * \l__tenkz_kernel_r_physical_y_tl } } { \__tenkz_kernel_r_open_tip_affine_planar_xy:nNN {#1} #2 #3 } } \cs_new_protected:Npn \__tenkz_kernel_r_open_tip_affine_planar_xy:nNN #1#2#3 { \__tenkz_geom_unapply:nnnNN {kpic} { \l__tenkz_kernel_r_xc_fp } { \l__tenkz_kernel_r_yc_fp } \l__tenkz_kernel_r_row_tl \l__tenkz_kernel_r_col_tl % A compass word is a logical ray, not a request for a picture corner. % Intersect that ray with the first expanded row/column margin, then % carry the resulting logical point through the complete affine frame. \str_case:nn {#1} { {n} { \tl_set:Nn \l__tenkz_kernel_r_b_tl {-90} } {s} { \tl_set:Nn \l__tenkz_kernel_r_b_tl { 90} } {w} { \tl_set:Nn \l__tenkz_kernel_r_b_tl {180} } {e} { \tl_set:Nn \l__tenkz_kernel_r_b_tl { 0} } {nw} { \tl_set:Nn \l__tenkz_kernel_r_b_tl {-135} } {ne} { \tl_set:Nn \l__tenkz_kernel_r_b_tl { -45} } {sw} { \tl_set:Nn \l__tenkz_kernel_r_b_tl { 135} } {se} { \tl_set:Nn \l__tenkz_kernel_r_b_tl { 45} } } \__tenkz_geom_rect_ray_intersect:nnnnnnnNN { \l__tenkz_kernel_r_col_tl } { \l__tenkz_kernel_r_row_tl } { \l__tenkz_kernel_r_b_tl } { 1 - \__tenkz_metric_ratio:n {stub} } { \l__tenkz_kernel_r_cols_int + \__tenkz_metric_ratio:n {stub} } { 1 - \__tenkz_metric_ratio:n {stub} } { \l__tenkz_kernel_r_rows_int + \__tenkz_metric_ratio:n {stub} } \l__tenkz_kernel_r_x_tl \l__tenkz_kernel_r_y_tl \tl_if_empty:NTF \l__tenkz_kernel_r_x_tl { % A point already outside the picture can face farther outward, so % its forward ray need not meet the rectangle. Preserve the % established named-margin fallback in that case; this matters for % off-cell relative waypoints in flat pictures. \fp_compare:nNnT { cosd(\l__tenkz_kernel_r_b_tl) } < {0} { \tl_set:Ne \l__tenkz_kernel_r_col_tl { \fp_eval:n { 1 - \__tenkz_metric_ratio:n {stub} } } } \fp_compare:nNnT { cosd(\l__tenkz_kernel_r_b_tl) } > {0} { \tl_set:Ne \l__tenkz_kernel_r_col_tl { \fp_eval:n { \l__tenkz_kernel_r_cols_int + \__tenkz_metric_ratio:n {stub} } } } \fp_compare:nNnT { sind(\l__tenkz_kernel_r_b_tl) } < {0} { \tl_set:Ne \l__tenkz_kernel_r_row_tl { \fp_eval:n { 1 - \__tenkz_metric_ratio:n {stub} } } } \fp_compare:nNnT { sind(\l__tenkz_kernel_r_b_tl) } > {0} { \tl_set:Ne \l__tenkz_kernel_r_row_tl { \fp_eval:n { \l__tenkz_kernel_r_rows_int + \__tenkz_metric_ratio:n {stub} } } } } { \tl_set_eq:NN \l__tenkz_kernel_r_col_tl \l__tenkz_kernel_r_x_tl \tl_set_eq:NN \l__tenkz_kernel_r_row_tl \l__tenkz_kernel_r_y_tl } \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_row_tl } { \l__tenkz_kernel_r_col_tl } #2 #3 } % A circle has no global affine inverse. Its established margin projection % remains station-based; affine pictures take the exact branch above. \cs_new_protected:Npn \__tenkz_kernel_r_open_tip_circle:nN #1#2 { \str_case:nn {#1} { {n} { \__tenkz_kernel_r_frame_xy:nnNN { 1 - \__tenkz_metric_ratio:n {stub} } {1} \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \tl_set:Ne #2 { \__tenkz_kernel_r_ppt:nn { \l__tenkz_kernel_r_xc_fp } { \l__tenkz_kernel_r_yb_fp } } } {s} { \__tenkz_kernel_r_frame_xy:nnNN { \l__tenkz_kernel_r_rows_int + \__tenkz_metric_ratio:n {stub} } {1} \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \tl_set:Ne #2 { \__tenkz_kernel_r_ppt:nn { \l__tenkz_kernel_r_xc_fp } { \l__tenkz_kernel_r_yb_fp } } } {w} { \__tenkz_kernel_r_frame_xy:nnNN {1} { 1 - \__tenkz_metric_ratio:n {stub} } \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \tl_set:Ne #2 { \__tenkz_kernel_r_ppt:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yc_fp } } } {e} { \__tenkz_kernel_r_frame_xy:nnNN {1} { \l__tenkz_kernel_r_cols_int + \__tenkz_metric_ratio:n {stub} } \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_yb_fp \tl_set:Ne #2 { \__tenkz_kernel_r_ppt:nn { \l__tenkz_kernel_r_xb_fp } { \l__tenkz_kernel_r_yc_fp } } } } } \cs_new_protected:Npn \__tenkz_kernel_r_string_declare:n #1 { % Mark this route as author-declared before it is saved, so the string % tier's crossing police can still catch it beside a renderer-owned % touch-all route (typically a lattice bond) that would otherwise % silence the pair -- issue #5825. \__tenkz_kernel_r_sid:nN {#1} \l__tenkz_kernel_r_sid_tl \exp_args:NV \__tenkz_string_author:n \l__tenkz_kernel_r_sid_tl \prop_if_in:NnTF \l__tenkz_kernel_ro_lane_prop {#1} { \__tenkz_kernel_r_route_string:n {#1} } { \__tenkz_kernel_r_string_free:n {#1} } } % The arc of the hull on the named side, at the lane the route stands in. % A compass word names the arc; `all' leaves it unnamed, and the two ends % pick the run of turns that joins them, so a wire routed around everything % travels the way round its own ends ask for. An end that named an address % starts or finishes there; an end that named a direction runs on to the % picture margin, as an end with a direction always has; an end that named % neither is the arc's own end and asks for nothing. \cs_new_protected:Npn \__tenkz_kernel_r_route_string:n #1 { \__tenkz_kernel_r_sid:nN {#1} \l__tenkz_kernel_r_sid_tl \__tenkz_kernel_route_of:nNN {#1} \l__tenkz_kernel_ro_side_tl \l__tenkz_kernel_ro_sel_tl \prop_get:NnN \l__tenkz_kernel_ro_lane_prop {#1} \l__tenkz_kernel_ro_lane_tl \prop_get:NnN \l__tenkz_kernel_ro_box_prop {#1} \l__tenkz_kernel_ro_b_tl \exp_last_unbraced:NV \__tenkz_kernel_r_route_box:nnnnnnnn \l__tenkz_kernel_ro_b_tl \fp_set:Nn \l__tenkz_kernel_ro_cx_fp { ( \l__tenkz_kernel_ro_x_fp + \l__tenkz_kernel_ro_xb_fp ) / 2 } \fp_set:Nn \l__tenkz_kernel_ro_cy_fp { ( \l__tenkz_kernel_ro_y_fp + \l__tenkz_kernel_ro_yb_fp ) / 2 } \str_if_eq:VnT \l__tenkz_kernel_ro_side_tl {all} { \__tenkz_kernel_select:VN \l__tenkz_kernel_ro_sel_tl \l__tenkz_kernel_ro_mem_seq \__tenkz_kernel_hull_obstacles:NN \l__tenkz_kernel_ro_mem_seq \l__tenkz_kernel_ro_obst_seq \__tenkz_kernel_hull_reach_linear:NnnnN \l__tenkz_kernel_ro_obst_seq { \l__tenkz_kernel_ro_ux_tl } { \l__tenkz_kernel_ro_uy_tl } {0} \l__tenkz_kernel_ro_xmax_fp \__tenkz_kernel_hull_reach_linear:NnnnN \l__tenkz_kernel_ro_obst_seq { -\l__tenkz_kernel_ro_ux_tl } { -\l__tenkz_kernel_ro_uy_tl } {0} \l__tenkz_kernel_ro_xmin_fp \fp_set:Nn \l__tenkz_kernel_ro_xmin_fp { -\l__tenkz_kernel_ro_xmin_fp } \__tenkz_kernel_hull_reach_linear:NnnnN \l__tenkz_kernel_ro_obst_seq { \l__tenkz_kernel_ro_vx_tl } { \l__tenkz_kernel_ro_vy_tl } {0} \l__tenkz_kernel_ro_ymax_fp \__tenkz_kernel_hull_reach_linear:NnnnN \l__tenkz_kernel_ro_obst_seq { -\l__tenkz_kernel_ro_vx_tl } { -\l__tenkz_kernel_ro_vy_tl } {0} \l__tenkz_kernel_ro_ymin_fp \fp_set:Nn \l__tenkz_kernel_ro_ymin_fp { -\l__tenkz_kernel_ro_ymin_fp } } \tl_clear:N \l__tenkz_kernel_r_from_tl \tl_clear:N \l__tenkz_kernel_r_to_tl \clist_map_inline:nn {from, to} { \__tenkz_kernel_r_route_end_at:nn {#1} {##1} } \str_case:Vn \l__tenkz_kernel_ro_side_tl { {n} { \__tenkz_kernel_r_route_across:nn {x} {lane} } {s} { \__tenkz_kernel_r_route_across:nn {x} {lane} } {e} { \__tenkz_kernel_r_route_across:nn {lane} {y} } {w} { \__tenkz_kernel_r_route_across:nn {lane} {y} } {all} { \__tenkz_kernel_r_route_around:n {#1} } } \clist_map_inline:nn {from, to} { \__tenkz_kernel_r_route_tip:nn {#1} {##1} } \tl_set:Ne \l__tenkz_kernel_r_pts_tl { \tl_use:N \l__tenkz_kernel_r_from_tl \tl_use:N \l__tenkz_kernel_r_pts_tl \tl_use:N \l__tenkz_kernel_r_to_tl } \prop_if_in:NeTF \l__tenkz_model_record_prop { #1 / closed } { \exp_args:NVV \__tenkz_string_declare_closed:nn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_pts_tl } { \str_if_eq:VnTF \l__tenkz_kernel_ro_side_tl {all} { \exp_args:NVV \__tenkz_string_declare_polyline:nnn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_pts_tl { \__tenkz_dim:n {corner} } } { \exp_args:NVV \__tenkz_string_declare_open:nn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_pts_tl } } } % the measured hull box, and the axes it was measured in, back into the route % registers \cs_new_protected:Npn \__tenkz_kernel_r_route_box:nnnnnnnn #1#2#3#4#5#6#7#8 { \fp_set:Nn \l__tenkz_kernel_ro_x_fp {#1} \fp_set:Nn \l__tenkz_kernel_ro_xb_fp {#2} \fp_set:Nn \l__tenkz_kernel_ro_y_fp {#3} \fp_set:Nn \l__tenkz_kernel_ro_yb_fp {#4} \tl_set:Nn \l__tenkz_kernel_ro_ex_tl {#5} \tl_set:Nn \l__tenkz_kernel_ro_ey_tl {#6} \tl_set:Nn \l__tenkz_kernel_ro_nx_tl {#7} \tl_set:Nn \l__tenkz_kernel_ro_ny_tl {#8} \__tenkz_geom_basis_dual:nnnnNNNN {#5}{#6}{#7}{#8} \l__tenkz_kernel_ro_ux_tl \l__tenkz_kernel_ro_uy_tl \l__tenkz_kernel_ro_vx_tl \l__tenkz_kernel_ro_vy_tl } % one point of the arc, named in the route's axes and carried to the page \cs_new_protected:Npn \__tenkz_kernel_r_route_pt:nn #1#2 { \fp_set:Nn \l__tenkz_kernel_ro_u_fp {#1} \fp_set:Nn \l__tenkz_kernel_ro_v_fp {#2} \__tenkz_kernel_ro_basis_apply:NN \l__tenkz_kernel_ro_u_fp \l__tenkz_kernel_ro_v_fp \tl_put_right:Ne \l__tenkz_kernel_r_pts_tl { \__tenkz_kernel_r_ppt:nn { \l__tenkz_kernel_ro_u_fp } { \l__tenkz_kernel_ro_v_fp } } } % a straight arc from one end of the side to the other: #1 and #2 name which % coordinate runs and which stands \cs_new_protected:Npn \__tenkz_kernel_r_route_across:nn #1#2 { \tl_clear:N \l__tenkz_kernel_r_pts_tl \__tenkz_kernel_r_route_pt:nn { \str_if_eq:nnTF {#1} {lane} { \l__tenkz_kernel_ro_lane_tl } { \l__tenkz_kernel_ro_x_fp } } { \str_if_eq:nnTF {#2} {lane} { \l__tenkz_kernel_ro_lane_tl } { \l__tenkz_kernel_ro_yb_fp } } \__tenkz_kernel_r_route_pt:nn { \str_if_eq:nnTF {#1} {lane} { \l__tenkz_kernel_ro_lane_tl } { \l__tenkz_kernel_ro_xb_fp } } { \str_if_eq:nnTF {#2} {lane} { \l__tenkz_kernel_ro_lane_tl } { \l__tenkz_kernel_ro_y_fp } } } % The whole hull. Its turns are numbered anticlockwise from the northeast, % and the route takes the run from the turn nearest where it starts to the % turn nearest where it stops. A closed wire takes every turn, which is the % ring; an open wire with no address at either end takes them all too, and % then its ends are the run's ends. \cs_new_protected:Npn \__tenkz_kernel_r_route_around:n #1 { \__tenkz_kernel_r_route_turn:nnNN {#1} {from} \l__tenkz_kernel_r_from_tl \l__tenkz_kernel_ro_row_tl \__tenkz_kernel_r_route_turn:nnNN {#1} {to} \l__tenkz_kernel_r_to_tl \l__tenkz_kernel_ro_col_tl \__tenkz_kernel_route_generated_lane:nT {#1} { \tl_set:Nn \l__tenkz_kernel_ro_row_tl {0} \tl_set:Nn \l__tenkz_kernel_ro_col_tl {0} } \int_compare:nNnT { \l__tenkz_kernel_ro_row_tl } = {0} { \tl_set:Nn \l__tenkz_kernel_ro_row_tl {1} } \int_compare:nNnT { \l__tenkz_kernel_ro_col_tl } = {0} { \tl_set:Nn \l__tenkz_kernel_ro_col_tl {4} } \tl_clear:N \l__tenkz_kernel_r_pts_tl \int_set:Nn \l__tenkz_kernel_ro_int { \int_mod:nn { \l__tenkz_kernel_ro_col_tl - \l__tenkz_kernel_ro_row_tl + 4 } {4} + 1 } \int_step_inline:nn { \l__tenkz_kernel_ro_int } { \__tenkz_kernel_r_route_turn:n { \int_mod:nn { \l__tenkz_kernel_ro_row_tl + ##1 - 2 } {4} + 1 } } } \cs_new_protected:Npn \__tenkz_kernel_r_route_turn:nnNN #1#2#3#4 { \prop_get:NnN \l__tenkz_kernel_ro_turn_prop { #1 / #2 } #4 \bool_lazy_or:nnT { \quark_if_no_value_p:N #4 } { \str_if_eq_p:Vn #4 {deferred} } { \__tenkz_kernel_r_route_turn_at:NN #3#4 } } \cs_new_protected:Npn \__tenkz_kernel_r_route_turn_xy:nnN #1#2#3 { \fp_set:Nn \l__tenkz_kernel_ro_xmin_fp { \dim_to_fp:n { \__tenkz_kernel_r_pt:n {#1} } / \dim_to_fp:n { \use:c {tenkz@pitch} } } \fp_set:Nn \l__tenkz_kernel_ro_ymin_fp { \dim_to_fp:n { \__tenkz_kernel_r_pt:n {#2} } / \dim_to_fp:n { \use:c {tenkz@pitch} } } \__tenkz_kernel_ro_basis_unapply:NN \l__tenkz_kernel_ro_xmin_fp \l__tenkz_kernel_ro_ymin_fp \tl_set:Ne #3 { \fp_eval:n { \l__tenkz_kernel_ro_ymin_fp >= \l__tenkz_kernel_ro_cy_fp ? ( \l__tenkz_kernel_ro_xmin_fp >= \l__tenkz_kernel_ro_cx_fp ? 1 : 2 ) : ( \l__tenkz_kernel_ro_xmin_fp >= \l__tenkz_kernel_ro_cx_fp ? 4 : 3 ) } } } % turn #1 of the hull, counted anticlockwise from the northeast -- of the % hull's own northeast, which is the corner of its axes and not of the page \cs_new_protected:Npn \__tenkz_kernel_r_route_turn:n #1 { \__tenkz_kernel_r_route_pt:nn { \int_compare:nNnTF {#1} < {2} { \l__tenkz_kernel_ro_xb_fp } { \int_compare:nNnTF {#1} < {4} { \l__tenkz_kernel_ro_x_fp } { \l__tenkz_kernel_ro_xb_fp } } } { \int_compare:nNnTF {#1} < {3} { \l__tenkz_kernel_ro_yb_fp } { \l__tenkz_kernel_ro_y_fp } } } % Which turn a point stands nearest, or 0 when there is no such point. The % point arrives on the page and the box it is weighed against stands in the % route's axes, so it is read in those axes before the two are compared. \cs_new_protected:Npn \__tenkz_kernel_r_route_turn_at:NN #1#2 { \tl_if_empty:NTF #1 { \tl_set:Nn #2 {0} } { \exp_args:Ne \__tenkz_kernel_r_point_fp:n { \tl_item:Nn #1 {1} } \__tenkz_kernel_ro_basis_unapply:NN \l__tenkz_kernel_r_xc_fp \l__tenkz_kernel_r_yc_fp \tl_set:Ne #2 { \fp_eval:n { \l__tenkz_kernel_r_yc_fp >= \l__tenkz_kernel_ro_cy_fp ? ( \l__tenkz_kernel_r_xc_fp >= \l__tenkz_kernel_ro_cx_fp ? 1 : 2 ) : ( \l__tenkz_kernel_r_xc_fp >= \l__tenkz_kernel_ro_cx_fp ? 4 : 3 ) } } } } % an end that named an address: the route starts or finishes there \cs_new_protected:Npn \__tenkz_kernel_r_route_end_at:nn #1#2 { \__tenkz_model_get:nnN {#1} {#2} \l__tenkz_kernel_r_end_tl \quark_if_no_value:NF \l__tenkz_kernel_r_end_tl { \__tenkz_kernel_r_node:V \l__tenkz_kernel_r_end_tl \__tenkz_kernel_r_xy:nNN { \tl_use:N \l__tenkz_kernel_r_end_tl } \l__tenkz_kernel_r_xc_fp \l__tenkz_kernel_r_yc_fp \str_if_eq:VnT \l__tenkz_kernel_ro_side_tl {all} { \__tenkz_kernel_r_route_end_inside_validate:nnV {#1} {#2} \l__tenkz_kernel_r_end_tl } \tl_set:Ne \l__tenkz_kernel_ro_tl { \__tenkz_kernel_r_ppt:nn { \l__tenkz_kernel_r_xc_fp } { \l__tenkz_kernel_r_yc_fp } } \__tenkz_kernel_r_route_end_put:nV {#2} \l__tenkz_kernel_ro_tl \str_if_eq:VnT \l__tenkz_kernel_ro_side_tl {all} { \str_if_eq:nnTF {#2} {from} { \__tenkz_kernel_r_route_turn_xy:nnN { \l__tenkz_kernel_r_xc_fp } { \l__tenkz_kernel_r_yc_fp } \l__tenkz_kernel_ro_row_tl \prop_put:NnV \l__tenkz_kernel_ro_turn_prop { #1 / from } \l__tenkz_kernel_ro_row_tl } { \__tenkz_kernel_r_route_turn_xy:nnN { \l__tenkz_kernel_r_xc_fp } { \l__tenkz_kernel_r_yc_fp } \l__tenkz_kernel_ro_col_tl \prop_put:NnV \l__tenkz_kernel_ro_turn_prop { #1 / to } \l__tenkz_kernel_ro_col_tl } } } } \cs_new_protected:Npn \__tenkz_kernel_r_route_end_inside_validate:nnn #1#2#3 { \fp_set_eq:NN \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_xc_fp \fp_set_eq:NN \l__tenkz_kernel_r_y_fp \l__tenkz_kernel_r_yc_fp \__tenkz_kernel_ro_basis_unapply:NN \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_y_fp \bool_set_false:N \l_tmpa_bool \bool_lazy_and:nnT { \fp_compare_p:n { \l__tenkz_kernel_r_x_fp > \l__tenkz_kernel_ro_xmin_fp && \l__tenkz_kernel_r_x_fp < \l__tenkz_kernel_ro_xmax_fp } } { \fp_compare_p:n { \l__tenkz_kernel_r_y_fp > \l__tenkz_kernel_ro_ymin_fp && \l__tenkz_kernel_r_y_fp < \l__tenkz_kernel_ro_ymax_fp } } { \bool_set_true:N \l_tmpa_bool } \bool_if:NT \l_tmpa_bool { \str_if_eq:eeT { \__tenkz_kernel_r_item:nn {#3} {kind} } {port} { \__tenkz_kernel_r_port_record:nN {#3} \l__tenkz_kernel_ro_a_tl \quark_if_no_value:NF \l__tenkz_kernel_ro_a_tl { \seq_if_in:NVTF \l__tenkz_kernel_ro_mem_seq \l__tenkz_kernel_ro_a_tl { \bool_set_false:N \l_tmpa_bool } { } } } } \bool_if:NT \l_tmpa_bool { \msg_error:nnnee {tenkz}{kernel-route-end-inside} {#1} {#2} { \__tenkz_kernel_r_item:nn {#3} {text} } } } \cs_generate_variant:Nn \__tenkz_kernel_r_route_end_inside_validate:nnn { nnV } % an end that named a direction: it runs on from the arc to the margin \cs_new_protected:Npn \__tenkz_kernel_r_route_tip:nn #1#2 { \__tenkz_model_get:nnN {#1} {#2} \l__tenkz_kernel_r_end_tl \quark_if_no_value:NT \l__tenkz_kernel_r_end_tl { \__tenkz_model_get:nnN {#1} {#2-open} \l__tenkz_kernel_r_end_tl \bool_lazy_and:nnT { ! \quark_if_no_value_p:N \l__tenkz_kernel_r_end_tl } { ! \str_if_eq_p:Vn \l__tenkz_kernel_r_end_tl {route} } { % the margin projection reads the arc end it leaves from \exp_args:Ne \__tenkz_kernel_r_point_fp:n { \str_if_eq:nnTF {#2} {from} { \tl_item:Nn \l__tenkz_kernel_r_pts_tl {1} } { \tl_item:Nn \l__tenkz_kernel_r_pts_tl {-1} } } \exp_args:NV \__tenkz_kernel_r_open_tip:nN \l__tenkz_kernel_r_end_tl \l__tenkz_kernel_ro_tl \__tenkz_kernel_r_route_end_put:nV {#2} \l__tenkz_kernel_ro_tl } } } \cs_new_protected:Npn \__tenkz_kernel_r_route_end_put:nn #1#2 { \str_if_eq:nnTF {#1} {from} { \tl_set:Nn \l__tenkz_kernel_r_from_tl {#2} } { \tl_set:Nn \l__tenkz_kernel_r_to_tl {#2} } } \cs_generate_variant:Nn \__tenkz_kernel_r_route_end_put:nn { nV } \cs_new:Npn \__tenkz_kernel_r_cm:n #1 { \fp_eval:n { round( (#1) * \dim_to_fp:n { \use:c {tenkz@pitch} } / \dim_to_fp:n { 1cm }, 5 ) } } \cs_new_protected:Npn \__tenkz_kernel_r_declare_wind:n #1 { \__tenkz_kernel_r_frame_xy:nnNN { ( 1 + \l__tenkz_kernel_r_rows_int ) / 2 } { ( 1 + \l__tenkz_kernel_r_cols_int ) / 2 } \l__tenkz_kernel_r_xc_fp \l__tenkz_kernel_r_yc_fp \__tenkz_string_declare_wind:nnnnnnn {#1} { \__tenkz_kernel_r_cm:n { \l__tenkz_kernel_r_xc_fp } } { \__tenkz_kernel_r_cm:n { \l__tenkz_kernel_r_yc_fp } } { \__tenkz_kernel_r_cm:n { ( max( \l__tenkz_kernel_r_cols_int, \l__tenkz_kernel_r_rows_int ) - 1 ) / 2 + \__tenkz_metric_ratio:n {outsidegap} } } { \seq_item:Nn \l__tenkz_kernel_match_seq {2} } { \seq_item:Nn \l__tenkz_kernel_match_seq {3} } { \__tenkz_kernel_r_cm:n { \__tenkz_metric_ratio:n {outsidegap} / 2 } } } \cs_new_protected:Npn \__tenkz_kernel_r_string_free:n #1 { \__tenkz_kernel_r_sid:nN {#1} \l__tenkz_kernel_r_sid_tl \tl_clear:N \l__tenkz_kernel_r_pts_tl % interior waypoints first: an open end needs its neighbour's transverse % coordinate before the tip can project to the margin \__tenkz_model_get:nnN {#1} {via} \l__tenkz_kernel_r_c_tl \tl_clear:N \l__tenkz_kernel_r_b_tl \quark_if_no_value:NF \l__tenkz_kernel_r_c_tl { \exp_args:NV \clist_map_inline:nn \l__tenkz_kernel_r_c_tl { \__tenkz_kernel_r_pts_add:nN {##1} \l__tenkz_kernel_r_pts_tl } } \prop_if_in:NeTF \l__tenkz_model_record_prop { #1 / closed } { % A closed string is one smooth cycle through its waypoints. A % wind={p,q} record instead delegates to the string engine's torus % projection, so the declared class determines the rendered curve. \__tenkz_model_get:nnN {#1} {wind} \l__tenkz_kernel_r_c_tl \quark_if_no_value:NTF \l__tenkz_kernel_r_c_tl { % route=orth squares the cycle's turns, as it squares an open % route's; every other route is the smooth Hobby cycle \__tenkz_model_get:nnN {#1} {route} \l__tenkz_kernel_r_tl \str_if_eq:VnTF \l__tenkz_kernel_r_tl {orth} { \exp_args:NV \__tenkz_kernel_r_orth_save_closed:nN \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_pts_tl } { \exp_args:NVV \__tenkz_string_declare_closed:nn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_pts_tl } } { \regex_extract_once:nVNTF { \A \s* ([-+]?\d+) \s* , \s* ([-+]?\d+) \s* \Z } \l__tenkz_kernel_r_c_tl \l__tenkz_kernel_match_seq { \bool_lazy_and:nnTF { \int_compare_p:nNn { \seq_item:Nn \l__tenkz_kernel_match_seq {2} } = {0} } { \int_compare_p:nNn { \seq_item:Nn \l__tenkz_kernel_match_seq {3} } = {0} } { \msg_error:nnn {tenkz}{kernel-wind-zero} {#1} } { \tl_if_empty:NTF \l__tenkz_kernel_r_pts_tl { \exp_args:NV \__tenkz_kernel_r_declare_wind:n \l__tenkz_kernel_r_sid_tl } { \msg_error:nnn {tenkz}{kernel-wind-via} {#1} } } } { \msg_error:nnxx {tenkz}{kernel-wind-shape} { \tl_use:N \l__tenkz_kernel_r_c_tl } {#1} } } } { % endpoints join the waypoint chain; each may be `open ` % Resolving one endpoint uses shared temporary values; it must not % overwrite whether the other endpoint is open. \tl_clear:N \l__tenkz_kernel_r_from_tl \tl_clear:N \l__tenkz_kernel_r_to_tl \__tenkz_model_get:nnN {#1} {from} \l__tenkz_kernel_r_end_tl \quark_if_no_value:NF \l__tenkz_kernel_r_end_tl { \__tenkz_kernel_r_wire_end_xy:VNN \l__tenkz_kernel_r_end_tl \l__tenkz_kernel_r_xc_fp \l__tenkz_kernel_r_yc_fp \tl_set:Ne \l__tenkz_kernel_r_from_tl { \__tenkz_kernel_r_ppt:nn { \l__tenkz_kernel_r_xc_fp } { \l__tenkz_kernel_r_yc_fp } } } \__tenkz_model_get:nnN {#1} {to} \l__tenkz_kernel_r_end_tl \quark_if_no_value:NF \l__tenkz_kernel_r_end_tl { \__tenkz_kernel_r_wire_end_xy:VNN \l__tenkz_kernel_r_end_tl \l__tenkz_kernel_r_xc_fp \l__tenkz_kernel_r_yc_fp \tl_set:Ne \l__tenkz_kernel_r_to_tl { \__tenkz_kernel_r_ppt:nn { \l__tenkz_kernel_r_xc_fp } { \l__tenkz_kernel_r_yc_fp } } } % open tips project from the neighbouring routed point, so they are % computed after every placed point is known \tl_if_empty:NT \l__tenkz_kernel_r_from_tl { \__tenkz_model_get:nnN {#1} {from-open} \l__tenkz_kernel_r_end_tl \quark_if_no_value:NF \l__tenkz_kernel_r_end_tl { \__tenkz_kernel_r_first_point: \exp_args:NV \__tenkz_kernel_r_open_tip:nN \l__tenkz_kernel_r_end_tl \l__tenkz_kernel_r_from_tl } } \tl_if_empty:NT \l__tenkz_kernel_r_to_tl { \__tenkz_model_get:nnN {#1} {to-open} \l__tenkz_kernel_r_end_tl \quark_if_no_value:NF \l__tenkz_kernel_r_end_tl { \__tenkz_kernel_r_last_point: \exp_args:NV \__tenkz_kernel_r_open_tip:nN \l__tenkz_kernel_r_end_tl \l__tenkz_kernel_r_to_tl } } \tl_set:Ne \l__tenkz_kernel_r_pts_tl { \tl_use:N \l__tenkz_kernel_r_from_tl \tl_use:N \l__tenkz_kernel_r_pts_tl \tl_use:N \l__tenkz_kernel_r_to_tl } % route=orth saves a right-angled polyline; route=arc bows a % waypointless string along its ends' faces; every other string -- % and an arc that routes through waypoints, whose points already % state its curve -- is a Hobby route through its points \__tenkz_model_get:nnN {#1} {route} \l__tenkz_kernel_r_tl \str_if_eq:VnTF \l__tenkz_kernel_r_tl {orth} { \exp_args:NV \__tenkz_kernel_r_orth_save:nN \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_pts_tl } { \bool_lazy_and:nnTF { \str_if_eq_p:Vn \l__tenkz_kernel_r_tl {arc} } { \int_compare_p:nNn { \tl_count:N \l__tenkz_kernel_r_pts_tl } = {2} } { \exp_args:Ne \__tenkz_kernel_r_point_fp:n { \tl_item:Nn \l__tenkz_kernel_r_pts_tl {1} } \fp_set_eq:NN \l__tenkz_kernel_r_x_fp \l__tenkz_kernel_r_xc_fp \fp_set_eq:NN \l__tenkz_kernel_r_y_fp \l__tenkz_kernel_r_yc_fp \exp_args:Ne \__tenkz_kernel_r_point_fp:n { \tl_item:Nn \l__tenkz_kernel_r_pts_tl {2} } \fp_set_eq:NN \l__tenkz_kernel_r_xb_fp \l__tenkz_kernel_r_xc_fp \fp_set_eq:NN \l__tenkz_kernel_r_yb_fp \l__tenkz_kernel_r_yc_fp \__tenkz_kernel_r_arc_controls:n {#1} \exp_args:NVV \__tenkz_string_declare_curve:nn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_arc_path_tl } { \exp_args:NVV \__tenkz_string_declare_open:nn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_pts_tl } } } } % load the from-tip's routed neighbour (first waypoint, else the other % end) into the xc/yc registers; likewise the to-tip's from the other side \cs_new_protected:Npn \__tenkz_kernel_r_first_point: { \tl_set:Ne \l__tenkz_kernel_r_tl { \tl_use:N \l__tenkz_kernel_r_pts_tl \tl_use:N \l__tenkz_kernel_r_to_tl } \tl_if_empty:NF \l__tenkz_kernel_r_tl { \exp_args:Ne \__tenkz_kernel_r_point_fp:n { \tl_item:Nn \l__tenkz_kernel_r_tl { 1 } } } } \cs_new_protected:Npn \__tenkz_kernel_r_last_point: { \tl_set:Ne \l__tenkz_kernel_r_tl { \tl_use:N \l__tenkz_kernel_r_from_tl \tl_use:N \l__tenkz_kernel_r_pts_tl } \tl_if_empty:NF \l__tenkz_kernel_r_tl { \exp_args:Ne \__tenkz_kernel_r_point_fp:n { \tl_item:Nn \l__tenkz_kernel_r_tl { -1 } } } } % one braced engine pair {Xpt,Ypt} -> the xc/yc registers, back in pitch units \cs_new_protected:Npn \__tenkz_kernel_r_point_fp:n #1 { \__tenkz_kernel_r_point_split:w #1 \q_stop } \cs_new_protected:Npn \__tenkz_kernel_r_point_split:w #1 , #2 \q_stop { \fp_set:Nn \l__tenkz_kernel_r_xc_fp { \dim_to_fp:n {#1} / \dim_to_fp:n { \use:c {tenkz@pitch} } } \fp_set:Nn \l__tenkz_kernel_r_yc_fp { \dim_to_fp:n {#2} / \dim_to_fp:n { \use:c {tenkz@pitch} } } } % a right-angled polyline saved for the same surgery and ink as any string. % The string engine owns the path, so the route is registered as generated % and states its `string' record like every other declared curve; the corner % radius is zero because `orth' squares its turns. \cs_new_protected:Npn \__tenkz_kernel_r_orth_save:nN #1#2 { \__tenkz_string_declare_polyline:nVn {#1} #2 { 0pt } } % the same route closed into a cycle: what `route=orth' means for a ring \cs_new_protected:Npn \__tenkz_kernel_r_orth_save_closed:nN #1#2 { \__tenkz_string_declare_closed_polyline:nVn {#1} #2 { 0pt } } % cross={over|under at crossing of A and B}: self over means the other % operand is the under path. A leg operand names the leg's saved path. The % field is a list, because a string that crosses several wires resolves % several crossings, whether the author wrote them or the route derived them. \cs_new_protected:Npn \__tenkz_kernel_r_crossings:n #1 { \__tenkz_model_get:nnN {#1} {cross} \l__tenkz_kernel_r_tl \quark_if_no_value:NF \l__tenkz_kernel_r_tl { \__tenkz_kernel_r_sid:nN {#1} \l__tenkz_kernel_r_sid_tl \exp_args:NV \clist_map_inline:nn \l__tenkz_kernel_r_tl { \__tenkz_kernel_r_crossing_one:n {##1} } } } \cs_new_protected:Npn \__tenkz_kernel_r_crossing_one:n #1 { \regex_extract_once:nnN { \A \s* (over|under) \s+ at \s+ crossing \s+ of \s+ (.+) \s+ and \s+ (.+) \Z } {#1} \l__tenkz_kernel_match_seq % The declared order is read out of the match before the operands are, % because resolving an operand runs its own match and leaves the shared % capture list holding a leg's face where the order word stood. Read % late, `over` came back as the second capture of the wrong match and % every declared crossing drew the way it was not declared. \tl_set:Ne \l__tenkz_kernel_r_order_tl { \seq_item:Nn \l__tenkz_kernel_match_seq {2} } \exp_args:Nee \__tenkz_kernel_r_cross_pair:nnn { \seq_item:Nn \l__tenkz_kernel_match_seq {3} } { \seq_item:Nn \l__tenkz_kernel_match_seq {4} } { \tl_use:N \l__tenkz_kernel_r_order_tl } } \tl_new:N \l__tenkz_kernel_r_order_tl \cs_new_protected:Npn \__tenkz_kernel_r_cross_pair:nnn #1#2#3 { \__tenkz_kernel_r_crossid:nN {#1} \l__tenkz_kernel_r_b_tl \__tenkz_kernel_r_crossid:nN {#2} \l__tenkz_kernel_r_c_tl % the operand that is not the declaring string is the other path \str_if_eq:VVTF \l__tenkz_kernel_r_b_tl \l__tenkz_kernel_r_sid_tl { \tl_set_eq:NN \l__tenkz_kernel_r_b_tl \l__tenkz_kernel_r_c_tl } { } % The order word arrives as a register to read, not as a word already % read, so it is compared expanded. Compared unexpanded it never equals % `over', and every crossing an author declared over was drawn under. \str_if_eq:eeTF {#3} {over} { \exp_args:NVV \__tenkz_string_under:nn \l__tenkz_kernel_r_b_tl \l__tenkz_kernel_r_sid_tl \exp_args:NVV \__tenkz_kernel_r_pairing_over_wire:nn \l__tenkz_kernel_r_b_tl \l__tenkz_kernel_r_sid_tl } { \exp_args:NVV \__tenkz_string_under:nn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_b_tl \exp_args:NVV \__tenkz_kernel_r_pairing_over_wire:nn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_b_tl } } \cs_new_protected:Npn \__tenkz_kernel_r_pairing_over_wire:nn #1#2 { % Crossing surgery is symmetric in its declaration owner: once the % resolved under path is a generated pairing and the over path is an % ordinary wire, the opaque host must redraw that wire locally. \prop_get:NnN \l__tenkz_kernel_r_sid_record_prop {#1} \l__tenkz_kernel_r_c_tl \quark_if_no_value:NF \l__tenkz_kernel_r_c_tl { \__tenkz_model_get:nnN { \l__tenkz_kernel_r_c_tl } {kind} \l__tenkz_kernel_scratch_tl \str_if_eq:VnT \l__tenkz_kernel_scratch_tl {pairing} { \tl_set_eq:NN \l__tenkz_kernel_r_b_tl \l__tenkz_kernel_r_c_tl \prop_get:NnN \l__tenkz_kernel_r_sid_record_prop {#2} \l__tenkz_kernel_r_c_tl \quark_if_no_value:NF \l__tenkz_kernel_r_c_tl { \__tenkz_model_get:nnN { \l__tenkz_kernel_r_c_tl } {kind} \l__tenkz_kernel_scratch_tl \str_if_eq:VnF \l__tenkz_kernel_scratch_tl {pairing} { \__tenkz_model_get:nnN { \l__tenkz_kernel_r_b_tl } {host} \l__tenkz_kernel_scratch_tl \prop_get:NVN \l__tenkz_kernel_r_skin_over_wire_prop \l__tenkz_kernel_scratch_tl \l__tenkz_kernel_r_c_tl \quark_if_no_value:NTF \l__tenkz_kernel_r_c_tl { \prop_put:NVn \l__tenkz_kernel_r_skin_over_wire_prop \l__tenkz_kernel_scratch_tl {#2} } { \clist_set:NV \l__tenkz_kernel_r_skin_over_wire_clist \l__tenkz_kernel_r_c_tl \clist_if_in:NnF \l__tenkz_kernel_r_skin_over_wire_clist {#2} { \clist_put_right:Nn \l__tenkz_kernel_r_skin_over_wire_clist {#2} \prop_put:NVx \l__tenkz_kernel_r_skin_over_wire_prop \l__tenkz_kernel_scratch_tl { \exp_not:V \l__tenkz_kernel_r_skin_over_wire_clist } } } } } } } } \cs_new_protected:Npn \__tenkz_kernel_r_crossid:nN #1#2 { \str_if_eq:eeTF {#1} {self} { \tl_set_eq:NN #2 \l__tenkz_kernel_r_sid_tl } { \regex_extract_once:nnNTF { \A pairing \s+ ([1-9]\d*) \s+ of \s+ ([A-Za-z][A-Za-z0-9\-]*) \Z } {#1} \l__tenkz_kernel_match_seq { \prop_get:NeN \l__tenkz_kernel_named_prop { \seq_item:Nn \l__tenkz_kernel_match_seq {3} } #2 \tl_set:Ne #2 { skin-\tl_use:N #2- \seq_item:Nn \l__tenkz_kernel_match_seq {2} } } { \regex_extract_once:nnNTF { \A leg \s+ ([nesw]) \s+ of \s+ \{? \s* \( \s* (\d+) \s* , \s* (\d+) \s* \) \s* \}? \Z } {#1} \l__tenkz_kernel_match_seq { \tl_set:Ne #2 { leg - \seq_item:Nn \l__tenkz_kernel_match_seq {2} - \seq_item:Nn \l__tenkz_kernel_match_seq {3} - \seq_item:Nn \l__tenkz_kernel_match_seq {4} } } { \tl_set:Nn #2 {#1} \tl_trim_spaces:N #2 } } } } \cs_new_protected:Npn \__tenkz_kernel_r_strings: { \prop_clear:N \l__tenkz_kernel_r_skin_over_wire_prop % The graph fixes the order in which curves are routed: one whose end is a % tensor waits for that tensor, and one whose end is a tensor standing on % another curve waits for that curve first. \seq_map_inline:Nn \l__tenkz_kernel_r_strings_seq { \__tenkz_kernel_settle:n {##1} } \seq_map_inline:Nn \l__tenkz_kernel_r_strings_seq { \__tenkz_kernel_r_sid:nN {##1} \l__tenkz_kernel_r_sid_tl \prop_put:NVn \l__tenkz_kernel_r_sid_record_prop \l__tenkz_kernel_r_sid_tl {##1} } \__tenkz_kernel_r_index_joins: \seq_map_inline:Nn \l__tenkz_kernel_r_strings_seq { \__tenkz_kernel_r_crossings:n {##1} } \seq_map_inline:Nn \l__tenkz_kernel_r_index_routes_seq { \__tenkz_kernel_r_crossings:n {##1} } \seq_map_inline:Nn \l__tenkz_kernel_r_skin_routes_seq { \__tenkz_kernel_r_crossings:n {##1} } \bool_lazy_or:nnT { ! \seq_if_empty_p:N \l__tenkz_string_ids_seq } { ! \prop_if_empty_p:N \l__tenkz_kernel_r_legdrawn_prop } { \__tenkz_string_resolve: } % Ordinary index wires retain their original first ink pass, now using % the crossing-policed saved path. Gapped legs and strings follow. A % physical closure's `trace` route is the one saved route that carries % its own paper halo rather than a crossing-derived gap % (`tenkz-core.code.tex`, the `trace` style), so it cannot settle for % the ordinary first-pass slot: sieve it out here and hold it for a % second pass after the deferred legs, so the halo remains the top ink % at any deferred-leg crossing instead of being buried under the leg % drawn over it. \seq_clear:N \l__tenkz_kernel_r_deferred_trace_routes_seq \seq_map_inline:Nn \l__tenkz_kernel_r_index_routes_seq { \prop_get:NnN \l__tenkz_kernel_r_index_style_prop {##1} \l__tenkz_kernel_r_wire_style_tl \regex_match:nVTF { \A trace \s* , } \l__tenkz_kernel_r_wire_style_tl { \seq_put_right:Nn \l__tenkz_kernel_r_deferred_trace_routes_seq {##1} } { \__tenkz_kernel_r_index_route:n {##1} } } \prop_map_inline:Nn \l__tenkz_kernel_r_legdrawn_prop { % A crossing-deferred leg is renderer-owned ink like any other leg, % so it writes its wire-ink record where it is stroked, from the % crossing-policed engine path, at the fixed width the string % renderer strokes it with. \tl_set:Ne \l__tenkz_kernel_ink_stroke_tl { \dim_to_decimal_in_sp:n { \__tenkz_dim:n {wirewidth} / 2 } } \__tenkz_kernel_r_wire_ink_event:nn {##1} { leg } \__tenkz_render_string:nn {##1} { draw = tenkzInk } } \seq_map_inline:Nn \l__tenkz_kernel_r_deferred_trace_routes_seq { \__tenkz_kernel_r_index_route:n {##1} } \seq_map_inline:Nn \l__tenkz_kernel_r_strings_seq { \__tenkz_kernel_r_sid:nN {##1} \l__tenkz_kernel_r_sid_tl \__tenkz_kernel_r_wire_ink:nN {##1} \l__tenkz_kernel_r_wire_ink_tl \exp_args:NVV \__tenkz_render_string:nn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_wire_ink_tl } } \cs_new_protected:Npn \__tenkz_kernel_r_index_joins: { \prop_map_inline:Nn \l__tenkz_kernel_r_index_sid_prop { \tl_set:Nn \l__tenkz_kernel_r_wire_record_tl {##2} \__tenkz_model_get:nnN {##2} {origin} \l__tenkz_kernel_scratch_tl \str_if_eq:VnF \l__tenkz_kernel_scratch_tl {port-open} { \__tenkz_string_touch_all:nn {##1} {bond} } % Deferred physical legs have saved paths but no model-wire owner. % Preserve their explicit topology relation with every index route; % unlike the common index class, they still cross-check user strings. \prop_map_inline:Nn \l__tenkz_kernel_r_legdrawn_prop { \__tenkz_string_touch:nn {##1} {####1} } \seq_map_inline:Nn \l__tenkz_kernel_r_skin_routes_seq { \__tenkz_model_get:nnN {####1} {name} \l__tenkz_kernel_r_b_tl \exp_args:NnV \__tenkz_kernel_r_index_join_oriented:nn {##1} \l__tenkz_kernel_r_b_tl } } } \cs_new_protected:Npn \__tenkz_kernel_r_index_join_oriented:nn #1#2 { \tl_set:Nn \l__tenkz_kernel_r_sid_tl {#1} \tl_set:Nn \l__tenkz_kernel_r_b_tl {#2} \prop_get:NnN \l__tenkz_kernel_r_sid_record_prop {#2} \l__tenkz_kernel_r_c_tl \quark_if_no_value:NTF \l__tenkz_kernel_r_c_tl { \exp_args:NVV \__tenkz_string_touch:nn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_b_tl } { \__tenkz_model_get:nnN { \l__tenkz_kernel_r_c_tl } {kind} \l__tenkz_kernel_scratch_tl \str_if_eq:VnTF \l__tenkz_kernel_scratch_tl {pairing} { \exp_args:NVV \__tenkz_kernel_r_wires_share_port:nnTF \l__tenkz_kernel_r_wire_record_tl \l__tenkz_kernel_r_c_tl { \exp_args:NVV \__tenkz_string_touch:nn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_b_tl } { \exp_args:NVV \__tenkz_string_endpoint_meeting:nnTF \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_b_tl { \exp_args:NVV \__tenkz_string_join:nn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_b_tl } { } } } { \__tenkz_model_get:nnN { \l__tenkz_kernel_r_wire_record_tl } {origin} \l__tenkz_kernel_scratch_tl \str_if_eq:VnF \l__tenkz_kernel_scratch_tl {port-open} { \exp_args:NVV \__tenkz_string_touch:nn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_r_b_tl } } } } \prg_new_protected_conditional:Npnn \__tenkz_kernel_r_wires_share_port:nn #1#2 {T,F,TF} { \bool_set_false:N \l_tmpa_bool % An ordinary index ending on the pairing's carrier is attached to that % carrier, even when grid sugar represented the end by its occupied cell % rather than by an explicit port node. The carrier's cell is asked for % by the one question both placements answer: an "at=" carrier keeps its % address as a node, a chained carrier as address text, and reading the % node alone leaves a chained carrier with no cell at all (issue 5528). \__tenkz_model_get:nnN {#2} {host} \l__tenkz_kernel_r_touch_c_tl \quark_if_no_value:NF \l__tenkz_kernel_r_touch_c_tl { \exp_args:NV \__tenkz_kernel_atom_rc:nNNN \l__tenkz_kernel_r_touch_c_tl \l__tenkz_kernel_r_touch_row_tl \l__tenkz_kernel_r_touch_col_tl \l__tenkz_kernel_r_touch_cell_bool \clist_map_inline:nn {from,to} { \__tenkz_model_get:nnN {#1} {##1} \l__tenkz_kernel_r_touch_a_tl \quark_if_no_value:NF \l__tenkz_kernel_r_touch_a_tl { \str_case:en { \__tenkz_kernel_node_item:Nn \l__tenkz_kernel_r_touch_a_tl {kind} } { {port} { \exp_args:NV \__tenkz_kernel_r_port_record:nN \l__tenkz_kernel_r_touch_a_tl \l__tenkz_kernel_r_touch_b_tl \str_if_eq:VVT \l__tenkz_kernel_r_touch_b_tl \l__tenkz_kernel_r_touch_c_tl { \bool_set_true:N \l_tmpa_bool } } {cell} { \bool_lazy_all:nT { { \l__tenkz_kernel_r_touch_cell_bool } { \str_if_eq_p:ee { \__tenkz_kernel_r_item:nn { \l__tenkz_kernel_r_touch_a_tl } {row} } { \l__tenkz_kernel_r_touch_row_tl } } { \str_if_eq_p:ee { \__tenkz_kernel_r_item:nn { \l__tenkz_kernel_r_touch_a_tl } {col} } { \l__tenkz_kernel_r_touch_col_tl } } } { \bool_set_true:N \l_tmpa_bool } } } } } } \clist_map_inline:nn {from,to} { \__tenkz_model_get:nnN {#1} {##1} \l__tenkz_kernel_r_touch_a_tl \quark_if_no_value:NF \l__tenkz_kernel_r_touch_a_tl { \clist_map_inline:nn {from,to} { \__tenkz_model_get:nnN {#2} {####1} \l__tenkz_kernel_r_touch_b_tl \quark_if_no_value:NF \l__tenkz_kernel_r_touch_b_tl { \str_if_eq:eeT { \__tenkz_kernel_node_item:Nn \l__tenkz_kernel_r_touch_a_tl {kind} } {port} { \str_if_eq:eeT { \__tenkz_kernel_node_item:Nn \l__tenkz_kernel_r_touch_b_tl {kind} } {port} { \exp_args:NV \__tenkz_kernel_r_port_record:nN \l__tenkz_kernel_r_touch_a_tl \l__tenkz_kernel_r_touch_c_tl \exp_args:NV \__tenkz_kernel_r_port_record:nN \l__tenkz_kernel_r_touch_b_tl \l__tenkz_kernel_r_touch_d_tl \bool_lazy_and:nnT { \str_if_eq_p:VV \l__tenkz_kernel_r_touch_c_tl \l__tenkz_kernel_r_touch_d_tl } { \str_if_eq_p:ee { \__tenkz_kernel_r_item:nn { \l__tenkz_kernel_r_touch_a_tl } {face} } { \__tenkz_kernel_r_item:nn { \l__tenkz_kernel_r_touch_b_tl } {face} } } { \str_if_eq:eeT { \__tenkz_kernel_r_item:nn { \l__tenkz_kernel_r_touch_a_tl } {slot} } { \__tenkz_kernel_r_item:nn { \l__tenkz_kernel_r_touch_b_tl } {slot} } { \bool_set_true:N \l_tmpa_bool } } } } } } } } \bool_if:NTF \l_tmpa_bool { \prg_return_true: } { \prg_return_false: } } \cs_new_protected:Npn \__tenkz_kernel_r_index_route:n #1 { \__tenkz_kernel_r_sid:nN {#1} \l__tenkz_kernel_r_sid_tl \prop_get:NnN \l__tenkz_kernel_r_index_style_prop {#1} \l__tenkz_kernel_r_wire_style_tl \prop_get:NVN \l__tenkz_kernel_ink_origin_prop \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_ink_origin_tl \quark_if_no_value:NT \l__tenkz_kernel_ink_origin_tl { \tl_set:Nn \l__tenkz_kernel_ink_origin_tl { bond } } % The capture key rides the SAME option list the real path strokes % with, as the last token, so the resolved width is read once, as part % of the one real stroke, instead of replaying the resolved style a % second time in a throwaway group (#6330 review). The wire-ink % record is then written after that stroke: the saved path carries % whatever gaps crossing surgery cut into it, so the auditor reads % exactly the ink the reader sees, at the width that stroke actually % painted with. \tl_set:Ne \l__tenkz_kernel_r_wire_style_tl { spath/use = { \tl_use:N \l__tenkz_kernel_r_sid_tl } , \tl_use:N \l__tenkz_kernel_r_wire_style_tl , tenkz~ink~capture~width } \exp_args:NV \__tenkz_render_stroke:nn \l__tenkz_kernel_r_wire_style_tl { } \tl_set_eq:NN \l__tenkz_kernel_ink_stroke_tl \g__tenkz_kernel_ink_width_tl % A queued trace paints the same paper halo as the after-atom path, % crossgap/2 beyond the captured foreground band; the record takes % the wider of the two, so a label in the halo's annulus is read % (#6359). \str_if_eq:VnT \l__tenkz_kernel_ink_origin_tl {trace} { \tl_set:Ne \l__tenkz_kernel_ink_stroke_tl { \fp_eval:n { max ( \l__tenkz_kernel_ink_stroke_tl , \__tenkz_kernel_r_trace_halo_sp: ) } } } \exp_args:NVV \__tenkz_kernel_r_wire_ink_event:nn \l__tenkz_kernel_r_sid_tl \l__tenkz_kernel_ink_origin_tl \tl_clear:N \l__tenkz_kernel_ink_origin_tl % A directed route's Straight Barb postaction painted ink in that same % stroke that the centreline walk above never sees; cover it (#6330 % review). \__tenkz_kernel_r_wire_ink_mark:n {#1} } % ---------- atom ink ----------------------------------------------------------------------------- \cs_new_protected:Npn \__tenkz_kernel_r_atoms: { % The automatic label station asks which faces carry ink. Read that off % the frozen records once, before the first dot asks. \__tenkz_kernel_r_label_occupancy: \__tenkz_model_map_ids:nn {atom} { \__tenkz_kernel_r_atom_ink:n {##1} } } % A plane physical closure reads the two semantic transverse endpoints stored % on its wire record. The glyph supplies their exact support points, while % the named physical-leg and trace-reach metrics determine only how far the % closure clears that ink. No in-plane numeric port participates. \tl_new:N \l__tenkz_kernel_phtrace_from_axis_tl \tl_new:N \l__tenkz_kernel_phtrace_to_axis_tl \tl_new:N \l__tenkz_kernel_phtrace_from_dir_tl \tl_new:N \l__tenkz_kernel_phtrace_to_dir_tl \tl_new:N \l__tenkz_kernel_phtrace_from_anchor_tl \tl_new:N \l__tenkz_kernel_phtrace_to_anchor_tl \fp_new:N \l__tenkz_kernel_phtrace_from_x_fp \fp_new:N \l__tenkz_kernel_phtrace_from_y_fp \fp_new:N \l__tenkz_kernel_phtrace_to_x_fp \fp_new:N \l__tenkz_kernel_phtrace_to_y_fp \fp_new:N \l__tenkz_kernel_phtrace_from_tip_x_fp \fp_new:N \l__tenkz_kernel_phtrace_from_tip_y_fp \fp_new:N \l__tenkz_kernel_phtrace_to_tip_x_fp \fp_new:N \l__tenkz_kernel_phtrace_to_tip_y_fp \fp_new:N \l__tenkz_kernel_phtrace_from_east_x_fp \fp_new:N \l__tenkz_kernel_phtrace_from_east_y_fp \fp_new:N \l__tenkz_kernel_phtrace_to_east_x_fp \fp_new:N \l__tenkz_kernel_phtrace_to_east_y_fp \fp_new:N \l__tenkz_kernel_phtrace_outer_x_fp \fp_new:N \l__tenkz_kernel_phtrace_reach_fp \cs_new_protected:Npn \__tenkz_kernel_r_physical_trace_plane:n #1 { \__tenkz_model_get:nnN {#1} {from-host} \l__tenkz_kernel_physical_axis_host_tl \__tenkz_model_get:nnN {#1} {to-host} \l__tenkz_kernel_physical_axis_other_host_tl \__tenkz_model_get:nnN {#1} {from-axis} \l__tenkz_kernel_phtrace_from_axis_tl \__tenkz_model_get:nnN {#1} {to-axis} \l__tenkz_kernel_phtrace_to_axis_tl \exp_args:NVV \__tenkz_kernel_r_physical_axis:nnNN \l__tenkz_kernel_physical_axis_host_tl \l__tenkz_kernel_phtrace_from_axis_tl \l__tenkz_kernel_phtrace_from_dir_tl \l__tenkz_kernel_phtrace_from_anchor_tl \exp_args:NVV \__tenkz_kernel_r_physical_axis:nnNN \l__tenkz_kernel_physical_axis_other_host_tl \l__tenkz_kernel_phtrace_to_axis_tl \l__tenkz_kernel_phtrace_to_dir_tl \l__tenkz_kernel_phtrace_to_anchor_tl \exp_args:NVV \__tenkz_kernel_r_glyph_anchor_or_site_xy:nnNN \l__tenkz_kernel_physical_axis_host_tl \l__tenkz_kernel_phtrace_from_anchor_tl \l__tenkz_kernel_phtrace_from_x_fp \l__tenkz_kernel_phtrace_from_y_fp \exp_args:NVV \__tenkz_kernel_r_glyph_anchor_or_site_xy:nnNN \l__tenkz_kernel_physical_axis_other_host_tl \l__tenkz_kernel_phtrace_to_anchor_tl \l__tenkz_kernel_phtrace_to_x_fp \l__tenkz_kernel_phtrace_to_y_fp \exp_args:NV \__tenkz_kernel_r_glyph_anchor_or_site_xy:nnNN \l__tenkz_kernel_physical_axis_host_tl {east} \l__tenkz_kernel_phtrace_from_east_x_fp \l__tenkz_kernel_phtrace_from_east_y_fp \exp_args:NV \__tenkz_kernel_r_glyph_anchor_or_site_xy:nnNN \l__tenkz_kernel_physical_axis_other_host_tl {east} \l__tenkz_kernel_phtrace_to_east_x_fp \l__tenkz_kernel_phtrace_to_east_y_fp \str_if_eq:VVTF \l__tenkz_kernel_physical_axis_host_tl \l__tenkz_kernel_physical_axis_other_host_tl { \fp_set:Nn \l__tenkz_kernel_phtrace_reach_fp { \__tenkz_metric_ratio:n {phtracereach} } } { \fp_set:Nn \l__tenkz_kernel_phtrace_reach_fp { \__tenkz_metric_ratio:n {pairtracereach} } } \fp_set:Nn \l__tenkz_kernel_phtrace_from_tip_x_fp { \l__tenkz_kernel_phtrace_from_x_fp + \__tenkz_metric_ratio:n {physleg} * cosd( \l__tenkz_kernel_phtrace_from_dir_tl ) } \fp_set:Nn \l__tenkz_kernel_phtrace_from_tip_y_fp { \l__tenkz_kernel_phtrace_from_y_fp + \__tenkz_metric_ratio:n {physleg} * sind( \l__tenkz_kernel_phtrace_from_dir_tl ) } \fp_set:Nn \l__tenkz_kernel_phtrace_to_tip_x_fp { \l__tenkz_kernel_phtrace_to_x_fp + \__tenkz_metric_ratio:n {physleg} * cosd( \l__tenkz_kernel_phtrace_to_dir_tl ) } \fp_set:Nn \l__tenkz_kernel_phtrace_to_tip_y_fp { \l__tenkz_kernel_phtrace_to_y_fp + \__tenkz_metric_ratio:n {physleg} * sind( \l__tenkz_kernel_phtrace_to_dir_tl ) } \fp_set:Nn \l__tenkz_kernel_phtrace_outer_x_fp { max( \l__tenkz_kernel_phtrace_from_east_x_fp, \l__tenkz_kernel_phtrace_to_east_x_fp, \l__tenkz_kernel_phtrace_from_tip_x_fp, \l__tenkz_kernel_phtrace_to_tip_x_fp ) + \l__tenkz_kernel_phtrace_reach_fp } \__tenkz_kernel_r_trace_stroke:nn {#1} { \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_phtrace_from_x_fp } { \l__tenkz_kernel_phtrace_from_y_fp } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_phtrace_from_tip_x_fp } { \l__tenkz_kernel_phtrace_from_tip_y_fp } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_phtrace_outer_x_fp } { \l__tenkz_kernel_phtrace_from_tip_y_fp } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_phtrace_outer_x_fp } { \l__tenkz_kernel_phtrace_to_tip_y_fp } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_phtrace_to_tip_x_fp } { \l__tenkz_kernel_phtrace_to_tip_y_fp } -- \__tenkz_kernel_r_pair:nn { \l__tenkz_kernel_phtrace_to_x_fp } { \l__tenkz_kernel_phtrace_to_y_fp } } } \cs_new_protected:Npn \__tenkz_kernel_r_physical_trace:n #1 { \__tenkz_model_get:nnN {#1} {physical-axis} \l__tenkz_kernel_r_b_tl \str_if_eq:VnTF \l__tenkz_kernel_r_b_tl {transverse} { \__tenkz_kernel_r_physical_trace_plane:n {#1} } { \__tenkz_model_get:nnN {#1} {col} \l__tenkz_kernel_r_col_tl \prop_get:NeN \l__tenkz_kernel_cell_prop { 1-\tl_use:N \l__tenkz_kernel_r_col_tl } \l__tenkz_kernel_r_tl \quark_if_no_value:NT \l__tenkz_kernel_r_tl { \__tenkz_model_map_ids:nn {atom} { \__tenkz_kernel_atom_rc:nNNN {##1} \l__tenkz_kernel_r_row_tl \l__tenkz_kernel_r_b_tl \l_tmpa_bool \bool_lazy_and:nnT { \bool_lazy_and_p:nn { \bool_if_p:N \l_tmpa_bool } { \int_compare_p:nNn { \l__tenkz_kernel_r_row_tl } = {1} } } { \int_compare_p:nNn { \l__tenkz_kernel_r_b_tl } = { \l__tenkz_kernel_r_col_tl } } { \tl_set:Nn \l__tenkz_kernel_r_tl {##1} } } } \bool_set_false:N \l_tmpa_bool \quark_if_no_value:NF \l__tenkz_kernel_r_tl { \cs_if_exist:cT { pgf@sh@ns@\tl_use:N \l__tenkz_kernel_r_tl } { \bool_set_true:N \l_tmpa_bool } } \bool_if:NTF \l_tmpa_bool { \pgfextractx \l__tenkz_kernel_r_north_x_dim { \pgfpointanchor{\tl_use:N \l__tenkz_kernel_r_tl}{north} } \pgfextracty \l__tenkz_kernel_r_north_y_dim { \pgfpointanchor{\tl_use:N \l__tenkz_kernel_r_tl}{north} } \pgfextracty \l__tenkz_kernel_r_south_y_dim { \pgfpointanchor{\tl_use:N \l__tenkz_kernel_r_tl}{south} } \pgfextractx \l__tenkz_kernel_r_east_x_dim { \pgfpointanchor{\tl_use:N \l__tenkz_kernel_r_tl}{east} } \dim_add:Nn \l__tenkz_kernel_r_east_x_dim { \__tenkz_dim:n {phtracereach} } \__tenkz_kernel_r_trace_stroke:nn {#1} { % Cap radius fits both the loop width and its clearance. [ rounded~corners = \dim_min:nn { \__tenkz_dim:n {phtracereach} } { ( \l__tenkz_kernel_r_east_x_dim - \l__tenkz_kernel_r_north_x_dim ) / 2 } ] ( \l__tenkz_kernel_r_north_x_dim , \l__tenkz_kernel_r_north_y_dim ) -- ++( 0 , \__tenkz_dim:n {phtracereach} ) -| ( \l__tenkz_kernel_r_east_x_dim , \l__tenkz_kernel_r_south_y_dim - \__tenkz_dim:n {phtracereach} ) -| ( \l__tenkz_kernel_r_north_x_dim , \l__tenkz_kernel_r_south_y_dim ) } } { \msg_error:nnee {tenkz}{kernel-render-phtrace} {#1} { \tl_use:N \l__tenkz_kernel_r_col_tl } } } } \ExplSyntaxOff \endinput