Converting Data Into Weaving Drafts

A weaving draft has four core structures:

• Threading: which shaft each warp thread passes through (1 row per warp end)
• Tieup: which shafts each treadle controls (matrix of shafts x treadles)
• Treadling: the sequence of treadles pressed (1 row per weft pick)
• Drawdown: the derived over/under fabric pattern (computed from the three above)

Minimal text-to-draft encoding (name-drafting style):

Python
def text_to_threading(text, num_shafts=8):
    # Map each letter to a shaft number (A=1, B=2, ... wrap at num_shafts)
    return [(ord(c.upper()) - ord('A')) % num_shafts + 1
            for c in text if c.isalpha()]

def compute_drawdown(threading, tieup, treadling):
    import numpy as np
    drawdown = np.zeros((len(treadling), len(threading)), dtype=int)
    for pick_idx, treadle in enumerate(treadling):
        active_shafts = {s for s, pressed in enumerate(tieup[treadle], 1) if pressed}
        for end_idx, shaft in enumerate(threading):
            drawdown[pick_idx, end_idx] = 1 if shaft in active_shafts else 0
    return drawdown

Progress:

• Choose source data type (text/name, image, log/data stream, or manual design)
• Select encoding scheme (letter-to-shaft, pixel-to-block, event-to-pick)
• Generate threading sequence from encoded data
• Generate or select a tieup matching target weave structure (plain, twill, summer-and-winter, damask, etc.)
• Generate treadling sequence (often mirrors threading for symmetric structures, or encodes a second data stream)
• Compute drawdown and validate it's weavable (no floats longer than loom tolerance, correct shaft count)
• Export to WIF or JSON
• (Optional) Render drawdown as image/3D visualization

Step details:

1. Pick the encoding. Text/names → letter-to-shaft mapping (classic "name draft" algorithm, often reusing threading pattern for treadling so the name reads twice). Images → sample pixel blocks and map intensity/color to block-weave units (summer-and-winter, taqueté, double cloth). Logs/time-series → map each discrete event (e.g., one log line = one pick) to a treadling row, encoding event type as shaft/treadle choice.

2. Respect shaft/treadle limits. Real looms range from 4 to 40 shafts; decide the shaft count up front and reduce/modulo your data to fit (value % num_shafts + 1).

3. Pick a structural tieup. Don't invent tieups ad hoc unless intentional — reuse known weave structures (plain weave, straight/point twill, summer-and-winter) so the physical cloth is weavable and holds together. Validate no unsupported "floats" (a warp or weft thread skipping too many opposite threads unsupported).

4. Compute and sanity-check the drawdown before export — verify dimensions match (picks x ends), and spot-check a known pattern region.

5. Export WIF (a plaintext INI-style format with [WEFT], [WARP], [TIEUP], [THREADING], [TREADLING] sections) or JSON for web tools. WIF is the interchange standard most desktop/loom software reads.

Example 1: Name into threading/treadling Input: "ADA", 8 shafts Output: threading = [1, 4, 1] (A=1, D=4, A=1); treadling reuses [1, 4, 1] so the drawdown shows the name pattern both in warp and weft direction, common in historical "name draft" coverlets.

Example 2: Log entries into picks Input: 24 hourly log entries, categorized as ERROR/WARN/INFO Output: Each hour becomes one treadling row; event category maps to one of 3 treadles tied to overlapping shaft groups on an 8-shaft tieup, so error-heavy periods appear as a visually distinct block in the woven cloth.

Example 3: Image to block draft Input: 10x10 grayscale image, threshold at 50% gray Output: Each pixel → one block unit; dark pixels = summer block (shafts 1-2 tieup), light pixels = winter block (shafts 3-4 tieup), producing a double-faced reversible cloth pattern.