TOTAL_BLOCKS = 150

from functools import cache

@cache
def lucas(a: int, b: int, n: int) -> int:
    """Compute a Lucas sequence from L_0 to L_{n-1}"""
    if n < 0:
        raise ValueError("n should be a positive integer.")
    if n == 0:
        return a
    if n == 1:
        return b
    return lucas(a, b, n-1) + lucas(a, b, n-2)

class LucasSequence(list[int]):
    def __init__(self, a: int, b: int, n: int, start=0):
        """
        Generate a Lucas sequence from L^{a, b}_0 up to but not including L^{a, b}_{n}.
        """
        super().__init__([lucas(a, b, i) for i in range(start, n)])
        self.a = a
        self.b = b
        self.n = n
        self.start = start

    def sum(self) -> int:
        """Efficient computation of sum of L^{a,b}_0 up to L^{a,b}_n."""
        return (lucas(self.a, self.b, self.n + 1) - self.b
                - (lucas(self.a, self.b, self.start + 1) - self.b))

    def __repr__(self) -> str:
        return f"{self.__class__.__name__}(a={self.a}, b={self.b}, n={self.n})"
    
sequence = LucasSequence(1, 1, 10)
print(sequence)
print(list(sequence))
print(sequence.sum())

LucasSequence(a=1, b=1, n=10)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
143

from collections.abc import Iterable, Iterator, Sequence, Sized
import matplotlib.pyplot as plt
import matplotlib.colors as mpl_colors
import numpy as np
import os

FIGURE_NUMBER = 0

# Creating a custom color map, to fit this project, ranging
# from white to Delft Blue.
DelftBlueColormap = mpl_colors.ListedColormap(["white", "#1F305E"])

# Threadings and treadlings are a series of shaft or treadle 
# numbers. We're fairly flexible with what we want to do with 
# them, but most of the time, we will only use operators
# reverse and + on them.  In the rare case
DraftSequence = Iterable[int]

def generate_draft(threading: DraftSequence,
                   treadling: DraftSequence = None, 
                   tie_up: dict[int, list[int]] = None,
                   num_shafts: int = None,
                   title: str = None):
    """
    Generate a weaving draft from the threading and treadling.

    A rising shed loom (for example, a table loom) is assumed.
    
    Each element in threading corresponds to a warp thread.  The value of the 
    element is the shaft its heddle is connected to.  Each element in treadling
    corresponds to a weft pick, and its value is the number of the pressed 
    treadle.

    If no treadling is provided, writ as tromp is assumed.

    If tie_up is not provided, a direct tie-up is assumed.  Otherwise, you can
    provide a dictionary that maps treadle numbers to a list of connected
    shafts.

    You can provide a value for num_shafts if for some reason the number of
    shafts in your design should be a higher number than occurs in either 
    threading or connected shafts in tie_up.
    """
    global FIGURE_NUMBER

    if treadling is None:
        treadling = threading[:]

    if not isinstance(threading, Sized):
        threading = list(threading)
    if not isinstance(treadling, Sized):
        treadling = list(treadling)
    num_warp = len(threading)
    num_picks = len(treadling)

    if num_shafts is None:
        if tie_up is None:
            num_shafts = max(threading)
        else:
            num_shafts = max(threading, 
                            max(max(shafts) for shafts in tie_up.values()))
    
    if tie_up is None:
        # If none provided, generate a straight draw tie-up
        tie_up = {i + 1: [i + 1] for i in range(max(num_shafts,
                                                    max(treadling)))}

    draft = np.zeros((num_picks, num_warp))

    for pick_nr, treadle in enumerate(treadling):
        if treadle in tie_up:
            lifted_shafts = tie_up[treadle]
            for warp_thread, shaft in enumerate(threading):
                if shaft in lifted_shafts:
                    draft[pick_nr, warp_thread] = 1
    
    plt.imshow(draft, cmap=DelftBlueColormap)
    plt.axis("on")
    if title:
        title = f"Fig. {FIGURE_NUMBER}: {title}"
        plt.title(title)

    if not os.path.isdir("./figs"):
        os.mkdir("./figs")
    plt.savefig(f"./figs/fig-{FIGURE_NUMBER}.png", bbox_inches="tight")
    plt.show()
    FIGURE_NUMBER += 1


generate_draft([1, 2, 1, 2, 1, 2], [1, 1, 2, 2, 1, 1],
               title="Een simpele profieltekening.")

def find_seq_by_sum(a: int, b: int, target: int) -> tuple[LucasSequence, LucasSequence]:
    """
    Find 2 Lucas sequences L1 = L^{a, b}_{0..n}, L2 = L^{a, b}_{0..n+1} 
    such that sum(L1) < target <= sum(L2).
    """
    for n in range(target):
        if LucasSequence(a, b, n).sum() >= target:
            return (LucasSequence(a, b, n - 1), LucasSequence(a, b, n))
    raise ValueError("sum(L^{a,b}_i for i in range(target+2)) is not large "
                     "enough.  Are you sure this even exists?")

def generate_block_profile(seq: list[int],
                           scheme: list[int] = [1, 2]) -> list[int]:
    """
    Generate a profile draft from a list of block repeats.
    
    Each element of seq represents the width of a block.
    
    A mapping from widths to block numbers can be provided as scheme.
    If none is provided, we assume alternating between blocks A and B.
    """
    threading = []
    for i, n in enumerate(seq):
        shaft = scheme[i % len(scheme)]
        threading += n * [shaft]
    return threading

A = 5
B = 2
approx_wanted_seqs = find_seq_by_sum(A, B, TOTAL_BLOCKS)
for seq in approx_wanted_seqs:
    threading = generate_block_profile(seq)
    generate_draft(threading, title=f"$L^{{{seq.a},{seq.b}}}_{{0:{seq.n}}}$, "
                                    f"blokken om en om"
                                    f"\n{len(threading)}×{len(threading)} blokken")

def mirrored(seq: DraftSequence,
             left_to_right=True,
             repeat_middle=True) -> list[int]:
    """
    Join a sequence of numbers to a reversed version of itself.

    By default, the reversed list is appended to the right side. If you want
    to append it to the left side, set left_to_right=False.

    When you don't want to repeat the block that will be in the middle of the
    new sequence, set repeat_middle=False.
    """
    if left_to_right:
        original: list[int] = list(seq)
    else:
        original: list[int] = list(reversed(list(seq)))
    
    offset = 0
    if not repeat_middle:
        offset = 1

    reflection = []
    for i in reversed(range(len(original) - offset)):
        reflection.append(original[i])
    return original + reflection

# We herhalen een variant van deze reeks, en daarom delen we TOTAL_BLOCKS 
# door het aantal herhalingen.
approx_wanted_seqs = find_seq_by_sum(A, B, TOTAL_BLOCKS//2)

for seq in approx_wanted_seqs:
    threading = generate_block_profile(mirrored(seq))
    generate_draft(threading, title=f"$L^{{{seq.a},{seq.b}}}_{{0:{seq.n}}}$, "
                                    f"gespiegeld"
                                    f"\n{len(threading)}×{len(threading)} blokken")

    threading = generate_block_profile(mirrored(seq, left_to_right=False))
    generate_draft(threading, title=f"$L^{{{seq.a},{seq.b}}}_{{0:{seq.n}}}$, "
                                    f"binnenstebuiten gespiegeld"
                                    f"\n{len(threading)}×{len(threading)} blokken")

def interweave(seq_a: DraftSequence, seq_b: DraftSequence) -> list[int]:
    """
    Alternatingly, join elements from seq_a and seq_b in a single list.
    """
    result = []
    for item_a, item_b in zip(seq_a, seq_b):
        result += [item_a, item_b]
    return result

approx_wanted_seqs = find_seq_by_sum(A, B, TOTAL_BLOCKS//2)

for seq in approx_wanted_seqs:
    threading = generate_block_profile(interweave(seq, reversed(seq)))
    generate_draft(threading, title=f"$L^{{{seq.a},{seq.b}}}_{{0:{seq.n}}}$, "
                                    f"blokken in tegengestelde richting, "
                                    f"eerst blok A"
                                    f"\n{len(threading)}×{len(threading)} blokken")

    threading = generate_block_profile(interweave(reversed(seq), seq))
    generate_draft(threading, title=f"$L^{{{seq.a},{seq.b}}}_{{0:{seq.n}}}$, "
                                    f"blokken in tegengestelde richting, "
                                    f"eerst blok B"
                                    f"\n{len(threading)}×{len(threading)} blokken")

approx_wanted_seqs = find_seq_by_sum(A, B, TOTAL_BLOCKS//4)

for seq in approx_wanted_seqs:
    threading = generate_block_profile(mirrored(interweave(seq, reversed(seq))))
    generate_draft(threading, title=f"$L^{{{seq.a},{seq.b}}}_{{0:{seq.n}}}$, "
                                    f"blokken in tegengestelde richting, "
                                    f"gespiegeld, "
                                    f"eerst blok A"
                                    f"\n{len(threading)}×{len(threading)} blokken")

    threading = generate_block_profile(mirrored(interweave(reversed(seq), seq)))
    generate_draft(threading, title=f"$L^{{{seq.a},{seq.b}}}_{{0:{seq.n}}}$, "
                                    f"blokken in tegengestelde richting, "
                                    f"gespiegeld, "
                                    f"eerst blok B"
                                    f"\n{len(threading)}×{len(threading)} blokken")

approx_wanted_seqs = find_seq_by_sum(A, B, TOTAL_BLOCKS//4)

for seq in approx_wanted_seqs:
    s = mirrored(interweave(seq, reversed(seq)) + [lucas(seq.a, seq.b, seq.n)],
                 repeat_middle=False)
    threading = generate_block_profile(s)
    generate_draft(threading, title=f"$L^{{{seq.a},{seq.b}}}_{{0:{seq.n}}}$, "
                                    f"blokken in tegengestelde richting, "
                                    f"ongelijke aantallen, "
                                    f"eerst blok A"
                                    f"\n{len(threading)}×{len(threading)} blokken")

    s = mirrored(reversed(interweave(seq, reversed(seq)) + [lucas(seq.a, seq.b, seq.n)]),
                 repeat_middle=False)
    threading = generate_block_profile(s)
    generate_draft(threading, title=f"$L^{{{seq.a},{seq.b}}}_{{0:{seq.n}}}$, "
                                    f"blokken in tegengestelde richting, "
                                    f"ongelijke aantallen, "
                                    f"eerst blok B"
                                    f"\n{len(threading)}×{len(threading)} blokken")

A_2 = 1
B_2 = 4

approx_wanted_threading = find_seq_by_sum(A, B, TOTAL_BLOCKS)
approx_wanted_treadling = find_seq_by_sum(A_2, B_2, TOTAL_BLOCKS)
for seq1 in approx_wanted_threading:
    threading = generate_block_profile(seq1)
    for seq2 in approx_wanted_treadling:
        treadling = generate_block_profile(seq2)
        generate_draft(threading, treadling, title=f"$L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                   f"en $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                   f"blokken om en om"
                                                   f"\n1 : {len(treadling)/len(threading):.2f}"
                                                   f"\n{len(threading)}×{len(treadling)} blokken")

approx_wanted_threading = find_seq_by_sum(A, B, TOTAL_BLOCKS//2)
approx_wanted_treadling = find_seq_by_sum(A_2, B_2, TOTAL_BLOCKS//2)

for seq1 in approx_wanted_threading:
    threading = generate_block_profile(mirrored(seq1))
    for seq2 in approx_wanted_treadling:
        treadling = generate_block_profile(mirrored(seq2, left_to_right=False))
        generate_draft(threading, treadling, title=f"$L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                   f"en $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                   f"gespiegeld"
                                                   f"\n1 : {len(treadling)/len(threading):.2f}"
                                                   f"\n{len(threading)}×{len(treadling)} blokken")

approx_wanted_threading = find_seq_by_sum(A, B, TOTAL_BLOCKS//2)
approx_wanted_treadling = find_seq_by_sum(A_2, B_2, TOTAL_BLOCKS//2)

for seq1 in approx_wanted_threading:
    threading1 = generate_block_profile(interweave(seq1, reversed(seq1)))
    threading2 = generate_block_profile(interweave(reversed(seq1), seq1))
    for seq2 in approx_wanted_treadling:
        treadling = generate_block_profile(interweave(seq2, reversed(seq2)))
        generate_draft(threading1, treadling, title=f"$L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                    f"en $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                    f"blokken in tegengestelde richting, "
                                                    f"eerst blok A"
                                                    f"\n1 : {len(treadling)/len(threading1):.2f}"
                                                    f"\n{len(threading1)}×{len(treadling)} blokken")
        generate_draft(threading2, treadling, title=f"rev. $L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                    f"en $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                    f"blokken in tegengestelde richting, "
                                                    f"eerst blok B"
                                                    f"\n1 : {len(treadling)/len(threading2):.2f}"
                                                    f"\n{len(threading2)}×{len(treadling)} blokken")

        treadling = generate_block_profile(interweave(reversed(seq2), seq2))
        generate_draft(threading1, treadling, title=f"$L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                    f"en rev. $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                    f"blokken in tegengestelde richting, "
                                                    f"eerst blok A"
                                                    f"\n1 : {len(treadling)/len(threading1):.2f}"
                                                    f"\n{len(threading1)}×{len(treadling)} blokken")
        generate_draft(threading2, treadling, title=f"rev. $L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                    f"en rev. $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                    f"blokken in tegengestelde richting, "
                                                    f"eerst blok B"
                                                    f"\n1 : {len(treadling)/len(threading2):.2f}"
                                                    f"\n{len(threading2)}×{len(treadling)} blokken")

approx_wanted_threading = find_seq_by_sum(A, B, TOTAL_BLOCKS//4)
approx_wanted_treadling = find_seq_by_sum(A_2, B_2, TOTAL_BLOCKS//4)

for seq1 in approx_wanted_threading:
    threading1 = generate_block_profile(mirrored(interweave(seq1, reversed(seq1))))
    threading2 = generate_block_profile(mirrored(interweave(reversed(seq1), seq1)))
    for seq2 in approx_wanted_treadling:
        treadling = generate_block_profile(mirrored(interweave(seq2, reversed(seq2))))
        generate_draft(threading1, treadling, title=f"$L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                    f"en $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                    f"blokken in tegengestelde richting, "
                                                    f"gespiegeld, "
                                                    f"eerst blok A"
                                                    f"\n1 : {len(treadling)/len(threading1):.2f}"
                                                    f"\n{len(threading1)}×{len(treadling)} blokken")
        generate_draft(threading2, treadling, title=f"rev. $L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                    f"en $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                    f"blokken in tegengestelde richting, "
                                                    f"gespiegeld, "
                                                    f"eerst blok B"
                                                    f"\n1 : {len(treadling)/len(threading2):.2f}"
                                                    f"\n{len(threading2)}×{len(treadling)} blokken")

        treadling = generate_block_profile(mirrored(interweave(reversed(seq2), seq2)))
        generate_draft(threading1, treadling, title=f"$L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                    f"en rev. $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                    f"blokken in tegengestelde richting, "
                                                    f"gespiegeld, "
                                                    f"eerst blok A"
                                                    f"\n1 : {len(treadling)/len(threading1):.2f}"
                                                    f"\n{len(threading1)}×{len(treadling)} blokken")
        generate_draft(threading2, treadling, title=f"rev. $L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                    f"en rev. $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                    f"blokken in tegengestelde richting, "
                                                    f"gespiegeld, "
                                                    f"eerst blok B"
                                                    f"\n1 : {len(treadling)/len(threading2):.2f}"
                                                    f"\n{len(threading2)}×{len(treadling)} blokken")

approx_wanted_threading = find_seq_by_sum(A, B, TOTAL_BLOCKS//4)
approx_wanted_treadling = find_seq_by_sum(A_2, B_2, TOTAL_BLOCKS//4)

for seq1 in approx_wanted_threading:
    s = mirrored(interweave(seq1, reversed(seq1)) + [lucas(seq1.a, seq1.b, seq1.n)], repeat_middle=False)
    threading1 = generate_block_profile(s)
    s = mirrored(reversed(interweave(seq1, reversed(seq1)) + [lucas(seq1.a, seq1.b, seq1.n)]), repeat_middle=False)
    threading2 = generate_block_profile(s)
    for seq2 in approx_wanted_treadling:
        s = mirrored(interweave(seq2, reversed(seq2)) + [lucas(seq2.a, seq2.b, seq2.n)], repeat_middle=False)
        treadling = generate_block_profile(s)
        generate_draft(threading1, treadling, title=f"$L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                    f"en $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                    f"blokken in tegengestelde richting, "
                                                    f"ongelijke aantallen, "
                                                    f"eerst blok A"
                                                    f"\n1 : {len(treadling)/len(threading1):.2f}"
                                                    f"\n{len(threading1)}×{len(treadling)} blokken")
        generate_draft(threading2, treadling, title=f"rev. $L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                    f"en $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                    f"blokken in tegengestelde richting, "
                                                    f"ongelijke aantallen, "
                                                    f"eerst blok B"
                                                    f"\n1 : {len(treadling)/len(threading2):.2f}"
                                                    f"\n{len(threading2)}×{len(treadling)} blokken")

        s = mirrored(reversed(interweave(seq2, reversed(seq2)) + [lucas(seq2.a, seq2.b, seq2.n)]), repeat_middle=False)
        treadling = generate_block_profile(s)
        generate_draft(threading1, treadling, title=f"$L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                    f"en rev. $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                    f"blokken in tegengestelde richting, "
                                                    f"ongelijke aantallen, "
                                                    f"eerst blok A"
                                                    f"\n1 : {len(treadling)/len(threading1):.2f}"
                                                    f"\n{len(threading1)}×{len(treadling)} blokken")
        generate_draft(threading2, treadling, title=f"rev. $L^{{{seq1.a},{seq1.b}}}_{{0:{seq1.n}}}$ "
                                                    f"en rev. $L^{{{seq2.a}, {seq2.b}}}_{{0:{seq2.n}}}$, "
                                                    f"blokken in tegengestelde richting, "
                                                    f"ongelijke aantallen, "
                                                    f"eerst blok B"
                                                    f"\n1 : {len(treadling)/len(threading2):.2f}"
                                                    f"\n{len(threading2)}×{len(treadling)} blokken")

seq = LucasSequence(5, 2, 5)
threading = generate_block_profile(mirrored(interweave(reversed(seq), seq)))
treadling = threading[:]
threading[108:110] = [2, 2]
threading[124:126] = [1, 1]
print(f"{len(threading)} dr")
generate_draft(threading, title=f"$L^{{{seq.a},{seq.b}}}_{{0:{seq.n}}}$, "
                                f"blokken in tegengestelde richting, "
                                f"gespiegeld, "
                                f"eerst blok B, met handmatig gebroddel"
                                f"\n{len(threading)}×{len(threading)} blokken")

156 dr

blocks_left = TOTAL_BLOCKS

border_seq = find_seq_by_sum(5, 2, blocks_left//5)[0]
border = mirrored(border_seq,
                  repeat_middle=False)
blocks_left -= 2*sum(border)

center_seq = find_seq_by_sum(1, 4, blocks_left//2)[1]
center = mirrored(center_seq,
                  repeat_middle=False)
blocks_left -= sum(center)

print(f"{border = }")
print(f"{center = }")
print(f"{blocks_left = }")

threading = generate_block_profile(border + center + border)
generate_draft(threading, title=f"$L^{{{border_seq.a},{border_seq.b}}}_{{0:{border_seq.n}}}$ "
                                f"gespiegeld voor randen, "
                                f"$L^{{{center_seq.a},{center_seq.b}}}_{{0:{center_seq.n}}}$ voor midden"
                                f"\n{len(threading)}×{len(threading)} blokken")

border = [5, 2, 7, 9, 7, 2, 5]
center = [1, 4, 5, 9, 14, 23, 14, 9, 5, 4, 1]
blocks_left = -13

blocks_left = 150

border_seq = find_seq_by_sum(5, 2, blocks_left//8)[0]
border = mirrored(border_seq,
                  repeat_middle=False)
blocks_left -= 2*sum(border)

center_seq = find_seq_by_sum(1, 4, blocks_left//2)[1]
center = mirrored(reversed(center_seq),
                  repeat_middle=False)
blocks_left -= sum(center)

print(f"{border = }")
print(f"{center = }")
print(f"{blocks_left = }")

threading = generate_block_profile(border + center + border)
generate_draft(threading, title=f"$L^{{{border_seq.a},{border_seq.b}}}_{{0:{border_seq.n}}}$ "
                                f"gespiegeld voor randen, "
                                f"rev. $L^{{{center_seq.a},{center_seq.b}}}_{{0:{center_seq.n}}}$ voor midden"
                                f"\n{len(threading)}×{len(threading)} blokken")

border = [5, 2, 7, 2, 5]
center = [23, 14, 9, 5, 4, 1, 4, 5, 9, 14, 23]
blocks_left = -3

blocks_left = 150

border_seq = find_seq_by_sum(5, 2, blocks_left//8)[1]
border = mirrored(border_seq,
                  repeat_middle=False)
blocks_left -= 2*sum(border)

center_seq = find_seq_by_sum(1, 4, blocks_left//2)[1]
center = mirrored(reversed(center_seq),
                  repeat_middle=False)
blocks_left -= sum(center)

print(f"{border = }")
print(f"{center = }")
print(f"{blocks_left = }")

threading = generate_block_profile(border + center + border)
generate_draft(threading, title=f"$L^{{{border_seq.a},{border_seq.b}}}_{{0:{border_seq.n}}}$ "
                                f"gespiegeld voor randen, "
                                f"rev. $L^{{{center_seq.a},{center_seq.b}}}_{{0:{center_seq.n}}}$ voor midden"
                                f"\n{len(threading)}×{len(threading)} blokken")

border = [5, 2, 7, 9, 7, 2, 5]
center = [23, 14, 9, 5, 4, 1, 4, 5, 9, 14, 23]
blocks_left = -35

blocks_left = 150

border_seq = find_seq_by_sum(5, 2, blocks_left//8)[1]
border = mirrored(border_seq,
                  repeat_middle=False)
blocks_left -= 2*sum(border)

center_seq = find_seq_by_sum(1, 4, blocks_left//2)[0]
center = mirrored(reversed(center_seq),
                  repeat_middle=False)
blocks_left -= sum(center)

print(f"{border = }")
print(f"{center = }")
print(f"{blocks_left = }")

threading = generate_block_profile(border + center + border)
generate_draft(threading, title=f"$L^{{{border_seq.a},{border_seq.b}}}_{{0:{border_seq.n}}}$ "
                                f"gespiegeld voor randen, "
                                f"rev. $L^{{{center_seq.a},{center_seq.b}}}_{{0:{center_seq.n}}}$ voor midden"
                                f"\n{len(threading)}×{len(threading)} blokken")

border = [5, 2, 7, 9, 7, 2, 5]
center = [14, 9, 5, 4, 1, 4, 5, 9, 14]
blocks_left = 11

blocks_left = 150

border_seq = find_seq_by_sum(5, 2, blocks_left//8)[1]
border = mirrored(border_seq,
                  repeat_middle=False)
blocks_left -= sum(border)

center_seq = find_seq_by_sum(1, 4, blocks_left//2)[1]
center = mirrored(reversed(center_seq),
                  repeat_middle=False)
blocks_left -= sum(center)

print(f"{border = }")
print(f"{center = }")
print(f"{blocks_left = }")

threading = generate_block_profile(border + center)
generate_draft(threading, title=f"$L^{{{border_seq.a},{border_seq.b}}}_{{0:{border_seq.n}}}$ "
                                f"gespiegeld voor één rand, "
                                f"rev. $L^{{{center_seq.a},{center_seq.b}}}_{{0:{center_seq.n}}}$ voor de rest"
                                f"\n{len(threading)}×{len(threading)} blokken")

border = [5, 2, 7, 9, 7, 2, 5]
center = [23, 14, 9, 5, 4, 1, 4, 5, 9, 14, 23]
blocks_left = 2

blocks_left = 150

border_seq = find_seq_by_sum(1, 4, blocks_left//8)[0]
border = mirrored(reversed(border_seq),
                  repeat_middle=False)
blocks_left -= 2*sum(border)

center_seq = find_seq_by_sum(5, 2, blocks_left//2)[1]
center = mirrored(reversed(center_seq),
                  repeat_middle=False)
blocks_left -= sum(center)

print(f"{border = }")
print(f"{center = }")
print(f"{blocks_left = }")


threading = generate_block_profile(border + center + border)
generate_draft(threading, title=f"rev. $L^{{{border_seq.a},{border_seq.b}}}_{{0:{border_seq.n}}}$ "
                                f"gespiegeld voor randen, "
                                f"rev. $L^{{{center_seq.a},{center_seq.b}}}_{{0:{center_seq.n}}}$ voor midden"
                                f"\n{len(threading)}×{len(threading)} blokken")

border = [5, 4, 1, 4, 5]
center = [25, 16, 9, 7, 2, 5, 2, 7, 9, 16, 25]
blocks_left = -11

blocks_left = 120

border_seq = find_seq_by_sum(1, 4, blocks_left//8)[0]
border = mirrored(reversed(border_seq),
                  repeat_middle=False)
blocks_left -= 2*sum(border)

center_seq = find_seq_by_sum(5, 2, blocks_left//2)[0]
center = mirrored(reversed(center_seq),
                  repeat_middle=False)
blocks_left -= sum(center)

print(f"{border = }")
print(f"{center = }")
print(f"{blocks_left = }")

threading = generate_block_profile(border + center + border)
generate_draft(threading, title=f"rev. $L^{{{border_seq.a},{border_seq.b}}}_{{0:{border_seq.n}}}$ "
                                f"gespiegeld voor randen, "
                                f"rev. $L^{{{center_seq.a},{center_seq.b}}}_{{0:{center_seq.n}}}$ voor midden"
                                f"\n{len(threading)}×{len(threading)} blokken")

border = [5, 4, 1, 4, 5]
center = [16, 9, 7, 2, 5, 2, 7, 9, 16]
blocks_left = 9

blocks_left = 150

border_seq = find_seq_by_sum(1, 4, blocks_left//8)[0]
border = mirrored(reversed(border_seq),
                  repeat_middle=False)
blocks_left -= 2*sum(border)

center_seq = find_seq_by_sum(5, 2, blocks_left//2)[1]
center = mirrored(reversed(center_seq),
                  repeat_middle=False)
blocks_left -= sum(center)

print(f"{border = }")
print(f"{center = }")
print(f"{blocks_left = }")

threading = generate_block_profile(border + center + border)
treadling = generate_block_profile(border + center + border + center + border)
generate_draft(threading, treadling,
               title=f"rev. $L^{{{border_seq.a},{border_seq.b}}}_{{0:{border_seq.n}}}$ "
                     f"gespiegeld voor randen, "
                     f"rev. $L^{{{center_seq.a},{center_seq.b}}}_{{0:{center_seq.n}}}$ voor midden,"
                     f"\nverlengd in inslag met nogmaals $L^{{{center_seq.a},{center_seq.b}}}_{{0:{center_seq.n}}}$"
                     f" + $L^{{{border_seq.a},{border_seq.b}}}_{{0:{border_seq.n}}}$"
                     f"\n{len(threading)}×{len(treadling)} blokken")

border = [5, 4, 1, 4, 5]
center = [25, 16, 9, 7, 2, 5, 2, 7, 9, 16, 25]
blocks_left = -11

Textiel ontwerpen, voor wevende nerds¶

Specificaties¶

Bindingstechniek¶

Materiaal en kleur¶

Experimenten: binding, materiaal en kleur¶

Ontwerpen van een tweebloks patroon¶

Profieltekeningen genereren¶

Lucas-rijen van ongeveer gewenste lengte¶

Compositie van één Lucas-rij¶

Simpele rij¶

Spiegeling¶

Tegengestelde richting¶

Gespiegelde tegengestelde richting¶

Ongelijke aantallen¶

Inslag ≠ inrijg¶

Simpel, twee rijen¶

Spiegeling, twee rijen¶

Tegengestelde richting, twee rijen¶

Gespiegelde tegengestelde richting, twee rijen¶

Ongelijke aantallen, twee rijen¶

Handmatige aanpassingen¶

Niet geheel wiskundige ontwerpen¶

Geselecteerde compositie¶

Detaillering¶

Realisatie¶

Conclusie en evaluatie¶