| 
  • If you are citizen of an European Union member nation, you may not use this service unless you are at least 16 years old.

  • Stop wasting time looking for files and revisions. Connect your Gmail, DriveDropbox, and Slack accounts and in less than 2 minutes, Dokkio will automatically organize all your file attachments. Learn more and claim your free account.

View
 

Knot-Tying Notation

Page history last edited by dave@layhands.com 10 years, 5 months ago

Knot-Tying Notation

 

The intention is for this notation to be readable as if the tying instructions were written out in English, but eliminating as much wordiness as possible.

 

The Nodeology terms (which all begin with a dot) are defined on the Knots Terms page.

 

This notation is somewhat free-form with a few conventions for clarity and consistency.  The lack of rigid rules and a rigid grammar should make the notation easy to extend as needed.

 

 

 

Useful Conventions

 

  • Directions are given from the perspective of the viewer:

 

  -- "up" or "above" or "higher" indicates that an object is pointing toward the sky or is closer to the sky than another object is.

 

  -- "down" or "below" or "lower" indicates that an object is pointing toward the ground or is closer to the ground than another object is.

 

  -- "left" refers to the viewer's left.

 

  -- "right" refers to the viewer's right.

 

  -- "front" refers to the side of the .Knot which currently is closest to the viewer.  If an object (i.e. a part of the .Cord) is "pointing front" then it's pointing at the viewer.  If an object is "front of" a second object then it's closer to the viewer than the second object is.

 

  -- "behind" refers to the side of the .Knot which currently is farthest from the viewer (and which the viewer can't directly see).  If an object is "pointing behind" then it's pointing away from the viewer.  If an object is "behind" a second object then it's farther from the viewer than the second object is.

 

  -- Diagonal directions are specified by hyphenating the above terms, such as behind-right or down-front.

  

  • Each step in the tying instructions should be numbered.  This becomes useful when discussing a set of tying instructions.

 

  • Step 1 should describe the initial state of the .Cord being manipulated.

 

  • Commas are used for separating the different components within a step.

 

  • The result of a step, or any part of a .Cord, can be assigned a name for future reference.  For example, a .Wrap can be named as "wrap1" using this notation:  name = #wrap1#.  The # symbols are used for the purpose of making the name stand out.  It's helpful if the name assignment is the last component within a step, because this makes it easy to find all of the name assignments.

 

  • Typically, steps will consist of the object which needs to move (usually the .Tail_End), followed by the action to be performed, followed by a comma and the object's final state (optional), followed by a comma and a name assignment (optional).  Describing an object's final state helps the knot-tyer verify that he or she has properly completed the step, and it can help identify any unusual circumstances.  For example, a partial .Wrap can be specified by using the .Wrap term and then indicating the direction in which the .Tail_End points after the .Wrap is completed.

 

  • Sometimes an object (e.g. the .Tail_End) needs to be pushed between two different objects, such as pushing the .Tail_End between a .Wrap and a tree when tying a .Knot around a tree.  The two objects can be combined in the notation (for the purpose of pushing an object between them) in this way:  #wrap1# + tree.

 

  • In the case of a Zeppelin Bend, for example, we would make two .Wraps and then overlay them on top of each other and treat them as a single unit.  This can be written in the following way:  #wrap1# overlay front of #wrap2#, treat as one, name = #wrap3#.

 

  • It can be helpful to use shortcuts such as:  "repeat step 3" or "first tie a Bowline."

 

  • Sometimes it's useful to add comments, such as describing how the .Knot should look at a certain stage.  Putting the comments in square brackets helps to separate them from the tying actions.  Here's an example:  [the .Tail_End should be between #wrap1# and #wrap2#]

 

 

 

List of Knots

 

Note:  It generally works out best if you start with a fairly long .Tail_End.

 

 

.Base .Knot or .Base(around nothing, curve down, finish front)

Traditionally referred to as an Overhand Knot or Thumb Knot

Parameters:

    "around nothing" -- The .Knot is being tied in the air.

    "curve down" -- The .Tail_End begins by curving downwards.

    "finish front" -- In the final crossing when the .Knot is finished, the .Tail_End will end up in FRONT of a section of .Cord.  This is accomplished by making the .Tail_End cross in FRONT on the very first crossing (see step 2).

1) .Cord horizontal, .Tail_End points right

2) .Tail_End .Wrap(around nothing, curve down, finish front, hand size), .Tail_End points right, name = #wrap#

3) .Tail_End .Push(thru #wrap#, from behind), .Tail_End points right

 

 

.Base .Knot or .Base(around tree, curve behind, finish above)

Traditionally referred to as an Overhand Knot or Thumb Knot

Parameters:

    "around tree" -- The .Knot is being tied around a tree.

    "curve behind" -- The .Tail_End begins by curving behind (away from the viewer).

    "finish above" -- In the final crossing when the .Knot is finished, the .Tail_End will end up ABOVE a section of .Cord.  This is accomplished by making the .Tail_End cross ABOVE on the very first crossing (see step 2).

1) .Cord horizontal, .Tail_End points right, tree vertical behind .Cord

2) .Tail_End .Wrap(around tree, curve behind, finish above), .Tail_End points down [in front of .Wrap_Leg1], name = #wrap#

3) .Tail_End .Push(thru #wrap#_Leg1 + tree, from below), .Tail_End points right

4) .Dress and .Set

 

 

Bowline on the Bight

1) .Doubled_Cord, .Doubled_End points down

2) .Doubled_End .Wrap(around nothing, curve right, finish front, two-finger size), .Doubled_End points down, name = #wrap#

3) .Doubled_End .Push(thru #wrap#, from behind), .Doubled_End points up

4) [at this point, two .Rings have been created below #wrap#, so resize as needed]

5) two .Rings, treat as one, name = #rings#

6) .Doubled_End points forward, then points down

7) #rings# .Push(thru .Doubled_End, from behind)

8) .Knot .FlipSides(left becomes right, behind becomes front)

9) bring .Doubled_Cord_Curve up until Doubled_Cord is straight from Doubled_Cord_Curve down to #rings#

10) .Dress and .Set

 

 

Clove Hitch around a tree

1) .Cord horizontal, .Tail_End points right, tree vertical behind .Cord

2) .Tail_End .Wrap(around tree, curve behind, finish above), .Tail_End points right, name = #wrap1#

3) .Tail_End .Cross(over #wrap1#_Leg1, from front), .Tail_End points down-right

4) .Tail_End .Wrap(around tree, curve behind, finish below), .Tail_End points right, name = #wrap2#

5) [#wrap2# should be below #wrap1#]

6) .Tail_End .Push(thru #wrap2#_Leg1 + tree, from below), .Tail_End points right

7) [.Tail_End should be between #wrap1# and #wrap2#]

8) .Dress and .Set

 

 

Double-Knotted Bowline

1) .Cord vertical, .Tail_End points down

2) .Tail_End .Wrap(around nothing, curve right, finish front, two-finger size), .Tail_End points down, name = #wrap1#

3) repeat step 2 below #wrap1# [ignoring the name], .Tail_End points down, name = #wrap2#

4) #wrap2# overlay front of #wrap1#, treat as one, .Tail_End points down, name = #wrap3#

5) .Tail_End .Push(thru #wrap3#, from behind), .Tail_End points up

6) [at this point, a .Ring has been created below #wrap3#, so resize as needed]

7) .Tail_End bends left, then .Collar(around .Body, leg1 behind, curve down), .Tail_End points right

8) .Tail_End .Push(thru #wrap3#, from front), .Tail_End points down

9) .Dress and .Set.

 

 

Fisherman's Knot

1) .Cord1 horizontal, .Tail_End1 points right

2) .Tail_End1 ties a .Base(around nothing, curve down, finish front), .Tail_End1 points right, name = #base1#

3) .Cord2 horizontal, .Tail_End2 points left

4) .Tail_End2 .Push(thru #base1#, from front), .Tail_End2 points left

5) [.Cord2 should be straight and horizontal]

6) .Tail_End2 bends up, then .Cross(over .Body1, from behind), .Tail_End2 points up

7) .Tail_End2 ties a .Base(around .Body1, curve right, finish front), .Tail_End2 points down

8) .Dress and .Set both .Base .Knots.

9) .Load .Body1 and .Body2 in opposite directions until both .Base .Knots are snug against each other.

 

 

Perfection Loop

1) .Cord horizontal, .Tail_End points right

2) .Tail_End .Wrap(around nothing, curve up, finish behind, three-finger size), .Tail_End points down, .Wrap_Curve name = #wrap_curve#

3) .Tail_End .Becomes .Collar(around .Body, leg1 behind, curve left), [.Collar_Curve will become a .Ring, so resize as needed], .Tail_End points up, .Collar_Curve name = #ring#

4) .Tail_End extends higher than #wrap_curve#, then bends right and extends beyond #wrap_curve#

5) .Tail_End .Collar(around #wrap_curve#, leg1 behind, curve right), .Tail_End points up, .Collar_Leg2 name = #tail_end#

6) #ring# [pointing down on the left side of the .Knot] points forward, then points up

7) #ring# .Cross(over #tail_end#, from front), then .Push(thru #tail_end# + #wrap_curve#, from front), #ring# points right

8) .Dress and .Set

 

 

Round Turn and Two Half Hitches around a tree

1) .Cord horizontal, .Tail_End points right, tree vertical behind .Cord

2) .Tail_End .Wrap(around tree, curve behind, finish above, 1.5 times), .Tail_End points left

3) .Tail_End bends forward, then .Cross(over .Body, from above), .Tail_End points forward

4) .Tail_End .Grip_Wrap(around .Body, curve down, finish right), .Tail_End points forward

5) .Tail_End bends left, then bends behind, then .Cross(over .Body, from below), .Tail_End points behind

6) .Tail_End .Grip_Wrap(around .Body, curve up, finish right), .Tail_End points behind

7) .Dress and .Set

 

 

Zeppelin Bend

1) .Cord1 horizontal, .Tail_End1 points right

2) .Tail_End1 .Wrap(around nothing, curve down, finish behind, two-finger size), .Tail_End1 points up, name = #wrap1#

3) .Cord2 horizontal, .Tail_End2 points left

4) .Tail_End2 .Wrap(around nothing, curve up, finish front, two-finger size), .Tail_End2 points down, name = #wrap2#

5) #wrap2# overlay front of #wrap1#, treat as one, [both .Tail_Ends should remain as they were], name = #wrap3#

6) .Tail_End2 [which is pointing down] .Push(thru #wrap3#, from behind), .Tail_End2 points front

7) .Tail_End1 [which is pointing up] .Push(thru #wrap3#, from front), .Tail_End1 points behind

8) .Dress and .Set

 

 

Comments (0)

You don't have permission to comment on this page.