WIP: Crackle operation

[yaxu]

Proof-of-concept implementation of crackle weave, where a motif is repeated along a path, with 'incidental' warps added where needed to connect motifs.

It seems to work well, but marked as WIP as it needs some polishing. It would be good if e.g.:

• the standard crackle weave motif was used if that inlet isn't connected
• someone more familiar with AdaCAD and weaving paradigms looked over it ! For example probably it would be more weaverly if the motif was placed relative to its bottom rather than top?
• the 'add incidentals' argument wasn't ignored
• I had a proper look at the rules for adding incidentals or removing ends, perhaps adding configuration options for changing them

Plus it needs documenting!

Ref:

• Ralph Griswold - Pattern book, and guide part 1, part 2, part 3
• He references Harriet Tidball 's explanation which tied it together for me
• He also references Berta Fray's "Designing and Drafting for Handweavers" for crackle rules, which I couldn't find online but have ordered a hard copy !

[Devendork]

Hi Hi, I'm playing with this today and seeing if I can understand and implement some of the pieces you suggest. I'm also not the expert on crackle weave but it seems like a profile drafting technique that follows specific rules. I'm writing how I understand it here so it's clear how I implemented and also, just to make it recorded somewhere!

1. A crackle motif follows a basic form and a set of "blocks" is produced by shifting the starting motif up one shaft (or up one weft in AdaCAD speak). So, if the starting motif is 0,1,2,1, we'd call that A, and the next block B would be 1,2,3,2 and so on. The number of blocks corresponds to the number of shafts/wefts represented in the path. So, if the path is shaped over 8 shafts, a total of 8 blocks are used. The path becomes an index into the blocks. So, if the draft shows a path of 1 2 3 4, that essentially means that our threading is the same as putting blocks A, B, C, D next to eachother.

2. Incidentals
   This enforces rules on what happens between the blocks, making sure there is a successive sequence of shafts and also no repeated shafts in the resulting pattern. It seems like we can do a sweep over the initial path created and check for conditions:

[       ] 
[       ] 
[ x x ]
[       ]

if shaft @ j == shaft @ j+1 => 
delete shaft @ j  OR insert (shaft @ j) -1 after j


[          ]
[       x ] 
[          ]
[  x      ]
else if (shaft @ j + 1 - shaft @ j) > 1 
// this is a case where we "skipped" shafts from from a low to high value. 
let difference = (shaft @ j + 1 - shaft @ j)
for(x = 1; x < difference; x++){
insert (shaft @ j) + x after j
}

[          ]
[ x       ] 
[          ]
[       x ]
else if (shaft @ j + 1 - shaft @ j) < -1 
// this is a case where we "skipped" shafts from from a high to a low. 
let difference = abs(shaft @ j + 1 - shaft @ j)
for(x = 1; x < difference; x++){
insert (shaft @ j) - x after j
}

While this makes sense as one interpretation of the rules, it also doesn't seem to replicate the outcomes in the paper because it arbitrarily chooses a direction (+1 or -1 shaft) when you could really transition either way (or, you could go down then back up, etc). This makes me think I'm missing something in the description....but I might implement it just to have something.

Side thought - seems like could generalize this to a "block substitution" operation where you explicitly define blocks A, B, C , D, E and swap them into a path.

[Devendork]

Welp, I also see now that you already implemented this! I guess it's just my way of understanding what is going on :)