WolframAlpha.com
WolframCloud.com
All Sites & Public Resources...
Products & Services
Wolfram|One
Mathematica
Wolfram|Alpha Notebook Edition
Finance Platform
System Modeler
Wolfram Player
Wolfram Engine
WolframScript
Enterprise Private Cloud
Application Server
Enterprise Mathematica
Wolfram|Alpha Appliance
Enterprise Solutions
Corporate Consulting
Technical Consulting
Wolfram|Alpha Business Solutions
Resource System
Data Repository
Neural Net Repository
Function Repository
Wolfram|Alpha
Wolfram|Alpha Pro
Problem Generator
API
Data Drop
Products for Education
Mobile Apps
Wolfram Player
Wolfram Cloud App
Wolfram|Alpha for Mobile
Wolfram|Alpha-Powered Apps
Services
Paid Project Support
Wolfram U
Summer Programs
All Products & Services »
Technologies
Wolfram Language
Revolutionary knowledge-based programming language.
Wolfram Cloud
Central infrastructure for Wolfram's cloud products & services.
Wolfram Science
Technology-enabling science of the computational universe.
Wolfram Notebooks
The preeminent environment for any technical workflows.
Wolfram Engine
Software engine implementing the Wolfram Language.
Wolfram Natural Language Understanding System
Knowledge-based broadly deployed natural language.
Wolfram Data Framework
Semantic framework for real-world data.
Wolfram Universal Deployment System
Instant deployment across cloud, desktop, mobile, and more.
Wolfram Knowledgebase
Curated computable knowledge powering Wolfram|Alpha.
All Technologies »
Solutions
Engineering, R&D
Aerospace & Defense
Chemical Engineering
Control Systems
Electrical Engineering
Image Processing
Industrial Engineering
Mechanical Engineering
Operations Research
More...
Finance, Statistics & Business Analysis
Actuarial Sciences
Bioinformatics
Data Science
Econometrics
Financial Risk Management
Statistics
More...
Education
All Solutions for Education
Trends
Machine Learning
Multiparadigm Data Science
Internet of Things
High-Performance Computing
Hackathons
Software & Web
Software Development
Authoring & Publishing
Interface Development
Web Development
Sciences
Astronomy
Biology
Chemistry
More...
All Solutions »
Learning & Support
Learning
Wolfram Language Documentation
Fast Introduction for Programmers
Wolfram U
Videos & Screencasts
Wolfram Language Introductory Book
Webinars & Training
Summer Programs
Books
Need Help?
Support FAQ
Wolfram Community
Contact Support
Premium Support
Paid Project Support
Technical Consulting
All Learning & Support »
Company
About
Company Background
Wolfram Blog
Events
Contact Us
Work with Us
Careers at Wolfram
Internships
Other Wolfram Language Jobs
Initiatives
Wolfram Foundation
MathWorld
Computer-Based Math
A New Kind of Science
Wolfram Technology for Hackathons
Student Ambassador Program
Wolfram for Startups
Demonstrations Project
Wolfram Innovator Awards
Wolfram + Raspberry Pi
Summer Programs
More...
All Company »
Search
WOLFRAM COMMUNITY
Connect with users of Wolfram technologies to learn, solve problems and share ideas
Join
Sign In
Dashboard
Groups
People
Message Boards
Answer
(
Unmark
)
Mark as an Answer
GROUPS:
Staff Picks
Visual Arts
Geometry
Graphs and Networks
Wolfram Language
Modeling
Wolfram High School Summer Camp
6
Eli Morton
[WSC21] Computational crochet
Eli Morton
Posted
1 year ago
3329 Views
|
3 Replies
|
6 Total Likes
Follow this post
|
Computational crochet
by
Eli Morton
The objective of this project was to compute simple and complex surfaces through crochet. I began by establishing a formula for simple polygons, creating a system that could construct any trapezoid or triangle. Said trapezoids and triangles can be stacked on top of each other to make a pattern for any polygon. I then looked into creating patterns for curved structures, and made a function that can semi-successfully make a crochet pattern given an equation.
Basics of Crochet
C
r
o
c
h
e
t
i
s
a
f
i
b
e
r
a
r
t
t
h
a
t
u
s
e
s
y
a
r
n
a
n
d
a
h
o
o
k
t
o
c
r
e
a
t
e
t
e
x
t
i
l
e
s
.
T
h
e
“
a
t
o
m
”
o
f
c
r
o
c
h
e
t
i
s
a
c
h
a
i
n
,
m
a
d
e
b
y
p
u
l
l
i
n
g
l
o
o
p
s
o
f
y
a
r
n
t
h
r
o
u
g
h
a
h
o
l
e
i
n
t
h
e
p
r
e
v
i
o
u
s
r
o
w
:
I
n
c
r
e
a
s
e
s
a
n
d
d
e
c
r
e
a
s
e
s
i
n
t
h
e
n
u
m
b
e
r
o
f
c
h
a
i
n
s
p
e
r
r
o
w
a
r
e
m
a
d
e
b
y
c
r
e
a
t
i
n
g
t
w
o
c
h
a
i
n
s
i
n
o
n
e
c
h
a
i
n
i
n
t
h
e
p
r
e
v
i
o
u
s
r
o
w
o
r
s
k
i
p
p
i
n
g
o
n
e
c
h
a
i
n
i
n
t
h
e
p
r
e
v
i
o
u
s
r
o
w
,
r
e
s
p
e
c
t
i
v
e
l
y
.
E
a
c
h
c
h
a
i
n
i
s
d
i
r
e
c
t
l
y
c
o
n
n
e
c
t
e
d
t
o
a
s
p
e
c
i
f
i
c
c
h
a
i
n
i
n
t
h
e
r
o
w
b
e
l
o
w
i
t
,
a
s
w
e
l
l
a
s
i
t
’
s
a
d
j
a
c
e
n
t
n
e
i
g
h
b
o
r
s
.
F
o
r
W
o
l
f
r
a
m
S
u
m
m
e
r
C
a
m
p
m
y
p
r
o
j
e
c
t
l
e
v
e
r
a
g
e
d
o
n
h
o
w
c
r
o
c
h
e
t
p
a
t
t
e
r
n
s
c
a
n
b
e
r
e
p
r
e
s
e
n
t
e
d
a
s
a
g
r
i
d
-
l
i
k
e
g
r
a
p
h
:
Simple Polygons
T
o
d
e
f
i
n
e
t
r
a
p
e
z
o
i
d
s
,
I
w
i
l
l
b
e
u
s
i
n
g
h
e
i
g
h
t
,
l
e
f
t
b
a
s
e
,
r
i
g
h
t
b
a
s
e
,
l
e
f
t
r
o
o
f
,
a
n
d
r
i
g
h
t
r
o
o
f
,
a
s
s
e
e
n
b
e
l
o
w
:
For these purposes, triangles are effectively trapezoids with roofs of 1.
Row Lengths
The first step to making a crochet pattern is deciding how many chains in each row. I made a function "widths" to take the chain count of the height, left base, right base, left roof, and right roof, and find the width of the project at each row using simple algebra. Using vertices to represent chains and edges to represent connections, it outputs the columns in which each row has a chain:
I
n
[
]
:
=
w
i
d
t
h
s
[
h
e
i
g
h
t
_
I
n
t
e
g
e
r
,
l
e
f
t
b
a
s
e
_
,
r
i
g
h
t
b
a
s
e
_
,
l
e
f
t
r
o
o
f
_
,
r
i
g
h
t
r
o
o
f
_
]
:
=
D
e
l
e
t
e
C
a
s
e
s
[
T
a
b
l
e
[
F
l
a
t
t
e
n
[
S
o
r
t
[
T
a
b
l
e
[
l
e
f
t
b
a
s
e
-
a
+
1
,
{
a
,
R
o
u
n
d
[
(
l
e
f
t
b
a
s
e
-
l
e
f
t
r
o
o
f
)
*
(
1
-
x
/
h
e
i
g
h
t
)
]
+
l
e
f
t
r
o
o
f
}
]
]
,
T
a
b
l
e
[
a
+
l
e
f
t
b
a
s
e
,
{
a
,
R
o
u
n
d
[
(
r
i
g
h
t
b
a
s
e
-
r
i
g
h
t
r
o
o
f
)
*
(
1
-
x
/
h
e
i
g
h
t
)
]
+
r
i
g
h
t
r
o
o
f
}
]
,
1
]
,
{
x
,
1
,
h
e
i
g
h
t
,
1
}
]
,
{
}
]
I
n
[
]
:
=
w
i
d
t
h
s
[
6
,
1
,
3
,
3
,
1
]
O
u
t
[
]
=
{
{
1
,
2
,
3
,
4
}
,
{
1
,
2
,
3
,
4
}
,
{
0
,
1
,
2
,
3
}
,
{
2
,
3
,
4
,
5
}
,
{
-
1
,
0
,
1
,
2
}
,
{
3
,
4
,
5
,
6
}
}
Unfortunately, crochet works with a snake-like pattern, alternating the direction of the row. This output would not allow me to easily make directed edges that actually follow the correct order. Instead, I split the function into odd rows and even rows, with even rows' doing the exact opposite of the odds', and riffled the two together.
I
n
[
]
:
=
w
i
d
t
h
s
[
h
e
i
g
h
t
_
I
n
t
e
g
e
r
,
l
e
f
t
b
a
s
e
_
,
r
i
g
h
t
b
a
s
e
_
,
l
e
f
t
r
o
o
f
_
,
r
i
g
h
t
r
o
o
f
_
]
:
=
D
e
l
e
t
e
C
a
s
e
s
[
R
i
f
f
l
e
[
(
*
O
d
d
*
)
T
a
b
l
e
[
F
l
a
t
t
e
n
[
S
o
r
t
[
T
a
b
l
e
[
l
e
f
t
b
a
s
e
-
a
+
1
,
{
a
,
R
o
u
n
d
[
(
l
e
f
t
b
a
s
e
-
l
e
f
t
r
o
o
f
)
*
(
1
-
x
/
h
e
i
g
h
t
)
]
+
l
e
f
t
r
o
o
f
}
]
]
,
T
a
b
l
e
[
a
+
l
e
f
t
b
a
s
e
,
{
a
,
R
o
u
n
d
[
(
r
i
g
h
t
b
a
s
e
-
r
i
g
h
t
r
o
o
f
)
*
(
1
-
x
/
h
e
i
g
h
t
)
]
+
r
i
g
h
t
r
o
o
f
}
]
,
1
]
,
{
x
,
1
,
h
e
i
g
h
t
,
2
}
]
,
(
*
E
v
e
n
*
)
T
a
b
l
e
[
F
l
a
t
t
e
n
[
S
o
r
t
[
T
a
b
l
e
[
r
i
g
h
t
b
a
s
e
-
a
+
1
,
{
a
,
R
o
u
n
d
[
(
r
i
g
h
t
b
a
s
e
-
r
i
g
h
t
r
o
o
f
)
*
(
1
-
x
/
h
e
i
g
h
t
)
]
+
r
i
g
h
t
r
o
o
f
}
]
]
,
T
a
b
l
e
[
a
+
r
i
g
h
t
b
a
s
e
,
{
a
,
R
o
u
n
d
[
(
l
e
f
t
b
a
s
e
-
l
e
f
t
r
o
o
f
)
*
(
1
-
x
/
h
e
i
g
h
t
)
]
+
l
e
f
t
r
o
o
f
}
]
,
1
]
,
{
x
,
1
,
F
l
o
o
r
[
h
e
i
g
h
t
/
2
]
*
2
,
2
}
]
]
,
{
}
]
I
n
[
]
:
=
w
i
d
t
h
s
[
6
,
1
,
3
,
3
,
1
]
O
u
t
[
]
=
{
{
1
,
2
,
3
,
4
}
,
{
1
,
2
,
3
,
4
}
,
{
0
,
1
,
2
,
3
}
,
{
2
,
3
,
4
,
5
}
,
{
-
1
,
0
,
1
,
2
}
,
{
3
,
4
,
5
,
6
}
}
This output has the number of the columns switching every row, which makes it more difficult for a human to read, but it allows the computer to arrange it correctly later on.
Edges
Now that I had the row's components, I began to connect them. I started with the first row, which has unique instructions due to being the baseline. I connected each vertex—labeled by {row, column}—to the next with a directed edge, all the way up to the second-to-last vertex.
w
=
w
i
d
t
h
s
[
h
e
i
g
h
t
,
l
e
f
t
b
a
s
e
,
r
i
g
h
t
b
a
s
e
,
l
e
f
t
r
o
o
f
,
r
i
g
h
t
r
o
o
f
]
;
T
a
b
l
e
[
{
1
,
a
}
{
1
,
a
+
1
}
,
{
a
,
F
i
r
s
t
[
w
[
[
1
]
]
]
,
L
a
s
t
[
w
[
[
1
]
]
]
-
1
}
]
;
The last vertex in that row doesn't go to another adjacent vertex; it connects up to the first vertex of the second row. This ease is due the the riffling in the widths function: the last of each row lines up with the first of the next.
{
1
,
L
a
s
t
[
w
[
[
1
]
]
]
}
{
2
,
F
i
r
s
t
[
w
[
[
2
]
]
]
}
After this is a section of code for all but the first row. It is split into two pieces: one for all but the last column, and one for all columns. The one for all but the last column connects each vertex to its adjacent vertex, and connects it to the vertex in the previous row directly below it. If that vertex does not exist, it connects to the closest vertex in the previous row.
I
n
[
]
:
=
h
e
l
p
e
r
D
e
t
e
c
t
i
o
n
R
o
w
s
[
w
_
,
b
_
,
a
_
]
:
=
I
f
[
C
o
n
t
a
i
n
s
A
l
l
[
w
[
[
b
-
1
]
]
,
{
L
e
n
g
t
h
[
w
[
[
1
]
]
]
+
1
-
a
}
]
,
L
e
n
g
t
h
[
w
[
[
1
]
]
]
+
1
-
a
,
N
e
a
r
e
s
t
[
w
[
[
b
-
1
]
]
,
L
e
n
g
t
h
[
w
[
[
1
]
]
]
+
1
-
a
]
[
[
1
]
]
]
I
n
[
]
:
=
T
a
b
l
e
[
(
*
a
d
j
a
c
e
n
t
*
)
{
b
,
a
}
{
b
,
a
+
1
}
,
(
*
r
o
w
b
e
l
o
w
*
)
{
b
,
a
}
{
b
-
1
,
h
e
l
p
e
r
D
e
t
e
c
t
i
o
n
R
o
w
s
[
w
,
b
,
a
]
}
,
{
b
,
2
,
L
e
n
g
t
h
[
w
]
}
,
{
a
,
F
i
r
s
t
[
w
[
[
b
]
]
]
,
L
a
s
t
[
w
[
[
b
]
]
]
-
1
}
]
O
u
t
[
]
=
{
{
{
{
2
,
1
}
{
2
,
2
}
,
{
2
,
1
}
{
1
,
6
}
}
,
{
{
2
,
2
}
{
2
,
3
}
,
{
2
,
2
}
{
1
,
5
}
}
,
{
{
2
,
3
}
{
2
,
4
}
,
{
2
,
3
}
{
1
,
4
}
}
,
{
{
2
,
4
}
{
2
,
5
}
,
{
2
,
4
}
{
1
,
3
}
}
,
{
{
2
,
5
}
{
2
,
6
}
,
{
2
,
5
}
{
1
,
2
}
}
}
,
{
{
{
3
,
2
}
{
3
,
3
}
,
{
3
,
2
}
{
2
,
5
}
}
,
{
{
3
,
3
}
{
3
,
4
}
,
{
3
,
3
}
{
2
,
4
}
}
,
{
{
3
,
4
}
{
3
,
5
}
,
{
3
,
4
}
{
2
,
3
}
}
}
,
{
{
{
4
,
2
}
{
4
,
3
}
,
{
4
,
2
}
{
3
,
5
}
}
,
{
{
4
,
3
}
{
4
,
4
}
,
{
4
,
3
}
{
3
,
4
}
}
,
{
{
4
,
4
}
{
4
,
5
}
,
{
4
,
4
}
{
3
,
3
}
}
}
,
{
{
{
5
,
3
}
{
5
,
4
}
,
{
5
,
3
}
{
4
,
4
}
}
}
}
In the piece for all columns, I connected each final vertex to the corresponding vertex in the previous row, using the same rule in said vertex's absence.
I
n
[
]
:
=
h
e
l
p
e
r
D
e
t
e
c
t
i
o
n
C
o
l
u
m
n
s
[
w
_
,
b
_
]
:
=
I
f
[
C
o
n
t
a
i
n
s
A
l
l
[
w
[
[
b
-
1
]
]
,
{
L
e
n
g
t
h
[
w
[
[
1
]
]
]
+
1
-
L
a
s
t
[
w
[
[
b
]
]
]
}
]
,
L
e
n
g
t
h
[
w
[
[
1
]
]
]
+
1
-
L
a
s
t
[
w
[
[
b
]
]
]
,
N
e
a
r
e
s
t
[
w
[
[
b
-
1
]
]
,
L
e
n
g
t
h
[
w
[
[
1
]
]
]
+
1
-
L
a
s
t
[
w
[
[
b
]
]
]
]
[
[
1
]
]
]
I
n
[
]
:
=
T
a
b
l
e
[
{
b
,
L
a
s
t
[
w
[
[
b
]
]
]
}
{
b
-
1
,
h
e
l
p
e
r
D
e
t
e
c
t
i
o
n
C
o
l
u
m
n
s
[
w
,
b
]
}
,
{
b
,
2
,
L
e
n
g
t
h
[
w
]
}
]
O
u
t
[
]
=
{
{
{
2
,
6
}
{
1
,
1
}
}
,
{
{
3
,
5
}
{
2
,
2
}
}
,
{
{
4
,
5
}
{
3
,
2
}
}
,
{
{
5
,
4
}
{
4
,
3
}
}
}
Now, outside of this Table for all rows but first, I connected the final vertex of all the non-first-nor-last rows to the first vertex of the next row.
I
n
[
]
:
=
T
a
b
l
e
[
{
b
,
L
a
s
t
[
w
[
[
b
]
]
]
}
{
b
+
1
,
F
i
r
s
t
[
w
[
[
b
+
1
]
]
]
}
,
{
b
,
2
,
L
e
n
g
t
h
[
w
]
-
1
}
]
O
u
t
[
]
=
{
{
{
2
,
6
}
{
3
,
2
}
}
,
{
{
3
,
5
}
{
4
,
2
}
}
,
{
{
4
,
5
}
{
5
,
3
}
}
}
All together, we have the function:
I
n
[
]
:
=
e
d
g
e
s
[
h
e
i
g
h
t
_
I
n
t
e
g
e
r
,
l
e
f
t
b
a
s
e
_
,
r
i
g
h
t
b
a
s
e
_
,
l
e
f
t
r
o
o
f
_
,
r
i
g
h
t
r
o
o
f
_
]
:
=
w
=
w
i
d
t
h
s
[
h
e
i
g
h
t
,
l
e
f
t
b
a
s
e
,
r
i
g
h
t
b
a
s
e
,
l
e
f
t
r
o
o
f
,
r
i
g
h
t
r
o
o
f
]
;
,
F
l
a
t
t
e
n
[
(
*
f
i
r
s
t
r
o
w
(
b
a
s
e
)
*
)
T
a
b
l
e
[
{
1
,
a
}
{
1
,
a
+
1
}
,
{
a
,
F
i
r
s
t
[
w
[
[
1
]
]
]
,
L
a
s
t
[
w
[
[
1
]
]
]
-
1
}
]
,
(
*
c
o
n
n
e
c
t
l
a
s
t
1
s
t
t
o
f
i
r
s
t
2
n
d
*
)
{
1
,
l
e
f
t
b
a
s
e
+
r
i
g
h
t
b
a
s
e
}
{
2
,
F
i
r
s
t
[
w
[
[
2
]
]
]
}
,
(
*
l
a
t
e
r
r
o
w
s
*
)
T
a
b
l
e
[
T
a
b
l
e
[
(
*
a
d
j
a
c
e
n
t
*
)
{
b
,
a
}
{
b
,
a
+
1
}
,
(
*
r
o
w
b
e
l
o
w
*
)
{
b
,
a
}
{
b
-
1
,
h
e
l
p
e
r
D
e
t
e
c
t
i
o
n
R
o
w
s
[
w
,
b
,
a
]
}
,
{
a
,
F
i
r
s
t
[
w
[
[
b
]
]
]
,
L
a
s
t
[
w
[
[
b
]
]
]
-
1
}
]
,
(
*
l
a
s
t
v
e
r
t
e
x
i
n
r
o
w
*
)
(
*
b
e
l
o
w
*
)
{
b
,
L
a
s
t
[
w
[
[
b
]
]
]
}
{
b
-
1
,
h
e
l
p
e
r
D
e
t
e
c
t
i
o
n
C
o
l
u
m
n
s
[
w
,
b
]
}
,
{
b
,
2
,
L
e
n
g
t
h
[
w
]
}
]
,
(
*
A
l
l
b
u
t
f
i
r
s
t
a
n
d
l
a
s
t
r
o
w
-
c
o
n
n
e
c
t
t
o
n
e
x
t
r
o
w
*
)
T
a
b
l
e
[
{
b
,
L
a
s
t
[
w
[
[
b
]
]
]
}
{
b
+
1
,
F
i
r
s
t
[
w
[
[
b
+
1
]
]
]
}
,
{
b
,
2
,
L
e
n
g
t
h
[
w
]
-
1
}
]
]
[
[
2
]
]
Now, with our edges function, we can graph the final pattern:
I
n
[
]
:
=
G
r
a
p
h
[
e
d
g
e
s
[
6
,
1
,
3
,
3
,
1
]
,
V
e
r
t
e
x
L
a
b
e
l
s
A
u
t
o
m
a
t
i
c
]
O
u
t
[
]
=
Connecting Trapezoids
Now that we have a function that creates patterns for trapezoids, we can stack them on top of each other to create more complicated polygons. To do this, I added parameters to"widths" and "edges" that allow for an offset in both the x and y direction in order to make the first trapezoid's last row the same as the next trapezoid's first row.
I
n
[
]
:
=
w
i
d
t
h
s
[
h
e
i
g
h
t
_
I
n
t
e
g
e
r
,
l
e
f
t
b
a
s
e
_
,
r
i
g
h
t
b
a
s
e
_
,
l
e
f
t
r
o
o
f
_
,
r
i
g
h
t
r
o
o
f
_
,
x
o
f
f
s
e
t
_
]
:
=
D
e
l
e
t
e
C
a
s
e
s
[
R
i
f
f
l
e
[
(
*
O
d
d
*
)
T
a
b
l
e
[
F
l
a
t
t
e
n
[
S
o
r
t
[
T
a
b
l
e
[
l
e
f
t
b
a
s
e
-
a
+
1
+
x
o
f
f
s
e
t
,
{
a
,
R
o
u
n
d
[
(
l
e
f
t
b
a
s
e
-
l
e
f
t
r
o
o
f
)
*
(
1
-
x
/
h
e
i
g
h
t
)
]
+
l
e
f
t
r
o
o
f
}
]
]
,
T
a
b
l
e
[
a
+
l
e
f
t
b
a
s
e
+
x
o
f
f
s
e
t
,
{
a
,
R
o
u
n
d
[
(
r
i
g
h
t
b
a
s
e
-
r
i
g
h
t
r
o
o
f
)
*
(
1
-
x
/
h
e
i
g
h
t
)
]
+
r
i
g
h
t
r
o
o
f
}
]
,
1
]
,
{
x
,
1
,
h
e
i
g
h
t
,
2
}
]
,
(
*
E
v
e
n
*
)
T
a
b
l
e
[
F
l
a
t
t
e
n
[
S
o
r
t
[
T
a
b
l
e
[
r
i
g
h
t
b
a
s
e
-
a
+
1
-
x
o
f
f
s
e
t
,
{
a
,
R
o
u
n
d
[
(
r
i
g
h
t
b
a
s
e
-
r
i
g
h
t
r
o
o
f
)
*
(
1
-
x
/
h
e
i
g
h
t
)
]
+
r
i
g
h
t
r
o
o
f
}
]
]
,
T
a
b
l
e
[
a
+
r
i
g
h
t
b
a
s
e
-
x
o
f
f
s
e
t
,
{
a
,
R
o
u
n
d
[
(
l
e
f
t
b
a
s
e
-
l
e
f
t
r
o
o
f
)
*
(
1
-
x
/
h
e
i
g
h
t
)
]
+
l
e
f
t
r
o
o
f
}
]
,
1
]
,
{
x
,
1
,
F
l
o
o
r
[
h
e
i
g
h
t
/
2
]
*
2
,
2
}
]
]
,
{
}
]
;
e
d
g
e
s
[
h
e
i
g
h
t
_
I
n
t
e
g
e
r
,
l
e
f
t
b
a
s
e
_
,
r
i
g
h
t
b
a
s
e
_
,
l
e
f
t
r
o
o
f
_
,
r
i
g
h
t
r
o
o
f
_
,
x
o
f
f
s
e
t
_
:
0
,
y
o
f
f
s
e
t
_
:
0
]
:
=
w
=
w
i
d
t
h
s
[
h
e
i
g
h
t
,
l
e
f
t
b
a
s
e
,
r
i
g
h
t
b
a
s
e
,
l
e
f
t
r
o
o
f
,
r
i
g
h
t
r
o
o
f
,
x
o
f
f
s
e
t
]
;
,
F
l
a
t
t
e
n
[
(
*
f
i
r
s
t
r
o
w
(
b
a
s
e
)
*
)
T
a
b
l
e
[
{
1
+
y
o
f
f
s
e
t
,
a
}
{
1
+
y
o
f
f
s
e
t
,
a
+
1
}
,
{
a
,
F
i
r
s
t
[
w
[
[
1
]
]
]
,
L
a
s
t
[
w
[
[
1
]
]
]
-
1
}
]
,
(
*
c
o
n
n
e
c
t
l
a
s
t
1
s
t
t
o
f
i
r
s
t
2
n
d
*
)
{
1
+
y
o
f
f
s
e
t
,
l
e
f
t
b
a
s
e
+
r
i
g
h
t
b
a
s
e
+
x
o
f
f
s
e
t
}
{
2
+
y
o
f
f
s
e
t
,
F
i
r
s
t
[
w
[
[
2
]
]
]
}
,
(
*
l
a
t
e
r
r
o
w
s
*
)
T
a
b
l
e
[
T
a
b
l
e
[
(
*
a
d
j
a
c
e
n
t
*
)
{
b
+
y
o
f
f
s
e
t
,
a
}
{
b
+
y
o
f
f
s
e
t
,
a
+
1
}
,
(
*
r
o
w
b
e
l
o
w
*
)
{
b
+
y
o
f
f
s
e
t
,
a
}
{
b
+
y
o
f
f
s
e
t
-
1
,
h
e
l
p
e
r
D
e
t
e
c
t
i
o
n
R
o
w
s
[
w
,
b
,
a
]
}
,
{
a
,
F
i
r
s
t
[
w
[
[
b
]
]
]
,
L
a
s
t
[
w
[
[
b
]
]
]
-
1
}
]
,
(
*
l
a
s
t
v
e
r
t
e
x
i
n
r
o
w
*
)
(
*
b
e
l
o
w
*
)
{
b
+
y
o
f
f
s
e
t
,
L
a
s
t
[
w
[
[
b
]
]
]
}
{
b
+
y
o
f
f
s
e
t
-
1
,
h
e
l
p
e
r
D
e
t
e
c
t
i
o
n
C
o
l
u
m
n
s
[
w
,
b
]
}
,
{
b
,
2
,
L
e
n
g
t
h
[
w
]
}
]
,
(
*
A
l
l
b
u
t
f
i
r
s
t
a
n
d
l
a
s
t
r
o
w
-
c
o
n
n
e
c
t
t
o
n
e
x
t
r
o
w
*
)
T
a
b
l
e
[
{
{
b
+
y
o
f
f
s
e
t
,
L
a
s
t
[
w
[
[
b
]
]
]
}
{
b
+
y
o
f
f
s
e
t
+
1
,
F
i
r
s
t
[
w
[
[
b
+
1
]
]
]
}
}
,
{
b
,
2
,
L
e
n
g
t
h
[
w
]
-
1
}
]
]
[
[
2
]
]
Using this new functionality, we can combine two "edges" outputs to make one graph
I
n
[
]
:
=
G
r
a
p
h
[
U
n
i
o
n
[
e
d
g
e
s
[
6
,
1
,
3
,
3
,
1
]
,
e
d
g
e
s
[
7
,
3
,
1
,
4
,
5
,
2
,
5
]
]
,
V
e
r
t
e
x
L
a
b
e
l
s
A
u
t
o
m
a
t
i
c
]
O
u
t
[
]
=
I
f
o
l
l
o
w
e
d
t
h
i
s
p
a
t
t
e
r
n
e
x
a
c
t
l
y
t
o
c
r
o
c
h
e
t
t
h
i
s
:
I also created formulas for simple pentagons and hexagons, whose logic can be applied for more polygons:
I
n
[
]
:
=
p
e
n
t
a
g
o
n
[
l
e
f
t
1
_
,
r
i
g
h
t
1
_
,
h
e
i
g
h
t
1
_
,
l
e
f
t
2
_
,
r
i
g
h
t
2
_
,
h
e
i
g
h
t
2
_
]
:
=
G
r
a
p
h
[
U
n
i
o
n
[
e
d
g
e
s
[
h
e
i
g
h
t
1
,
l
e
f
t
1
,
r
i
g
h
t
1
,
l
e
f
t
2
,
r
i
g
h
t
2
]
,
e
d
g
e
s
[
h
e
i
g
h
t
2
,
l
e
f
t
2
,
r
i
g
h
t
2
,
1
,
1
,
l
e
f
t
1
-
l
e
f
t
2
,
h
e
i
g
h
t
1
-
1
]
]
,
V
e
r
t
e
x
L
a
b
e
l
s
A
u
t
o
m
a
t
i
c
]
h
e
x
a
g
o
n
[
l
e
f
t
1
_
,
r
i
g
h
t
1
_
,
h
e
i
g
h
t
1
_
,
l
e
f
t
2
_
,
r
i
g
h
t
2
_
,
h
e
i
g
h
t
2
_
,
l
e
f
t
3
_
,
r
i
g
h
t
3
_
]
:
=
G
r
a
p
h
[
U
n
i
o
n
[
e
d
g
e
s
[
h
e
i
g
h
t
1
,
l
e
f
t
1
,
r
i
g
h
t
1
,
l
e
f
t
2
,
r
i
g
h
t
2
]
,
e
d
g
e
s
[
h
e
i
g
h
t
2
,
l
e
f
t
2
,
r
i
g
h
t
2
,
l
e
f
t
3
,
r
i
g
h
t
3
,
l
e
f
t
1
-
l
e
f
t
2
,
h
e
i
g
h
t
1
-
1
]
]
,
V
e
r
t
e
x
L
a
b
e
l
s
A
u
t
o
m
a
t
i
c
]
Application
To apply my function to 3D structures, I decomposed a triangular prism into its faces: three rectangles and two triangles. I decided on equilateral triangles with side length 6 and rectangles of height 12.
I
n
[
]
:
=
R
o
w
[
F
l
a
t
t
e
n
[
G
r
a
p
h
[
#
[
[
1
]
]
,
V
e
r
t
e
x
L
a
b
e
l
s
-
>
A
u
t
o
m
a
t
i
c
]
,
#
[
[
2
]
]
&
/
@
{
{
e
d
g
e
s
[
6
,
6
,
6
,
6
,
6
]
,
"
3
R
e
c
t
a
n
g
l
e
s
"
}
,
{
e
d
g
e
s
[
R
o
u
n
d
[
3
*
S
q
r
t
[
3
]
]
,
3
,
3
,
1
,
1
]
,
"
2
T
r
i
a
n
g
l
e
s
"
}
}
]
]
O
u
t
[
]
=
3
R
e
c
t
a
n
g
l
e
s
2
T
r
i
a
n
g
l
e
s
Following these instructions and WL's net for a triangular prism, I created this:
It worked very accurately for such a small number of chains; chains only work in whole numbers, which doesn't allow for precise slopes.
Curved Surfaces
Because my previous method relied on an assumption of flat surfaces, I was unsure of how to approach curved surfaces. One problem is that crochet isn't an exact science: yarn can be squished and stretched enough that one can't rely on it to hold its shape; on the other hand, it doesn't follow the malleability rules of topology. Everything must be approximated.
Establishing a base set of vertices
I figured a good place to start would be establishing a list of vertices at every whole number {x,y} of a 3D function.
I
n
[
]
:
=
p
o
i
n
t
s
=
T
a
b
l
e
[
T
a
b
l
e
[
{
x
,
y
,
x
^
2
+
2
y
^
2
+
3
x
^
3
+
4
y
^
4
+
5
x
^
5
+
6
y
^
6
}
,
{
y
,
-
1
,
1
,
.
2
}
]
,
{
x
,
-
1
,
1
,
.
2
}
]
;
I then followed my old method for rows: adding directed edges along adjacent vertices. However, this time it was not as simple. Each connection has a length of 1 unit, and with a curved surface I couldn't simply assume that the distance from {x,y} to {x+1,y+1} would be 1 unit. Instead, for each vertex, I rounded the distance from it to the next vertex and added more vertices as necessary to have ~1 unit in between vertices. To keep track of which points were at which coordinates, I set up the table to be formatted {{{coordinates, {row,column}}, [directed edge to next point]}
I
n
[
]
:
=
T
a
b
l
e
[
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
+
a
*
(
p
o
i
n
t
s
[
[
y
]
]
[
[
x
+
1
]
]
-
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
)
,
(
*
c
o
o
r
d
i
n
a
t
e
s
*
)
{
y
,
x
+
a
}
,
(
*
r
o
w
a
n
d
c
o
l
u
m
n
*
)
{
y
,
x
+
a
}
{
y
,
x
+
a
+
1
/
C
e
i
l
i
n
g
[
E
u
c
l
i
d
e
a
n
D
i
s
t
a
n
c
e
[
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
,
p
o
i
n
t
s
[
[
y
]
]
[
[
x
+
1
]
]
]
*
.
1
]
}
(
*
c
o
n
n
e
c
t
i
o
n
*
)
,
{
a
,
0
,
1
-
1
/
C
e
i
l
i
n
g
[
E
u
c
l
i
d
e
a
n
D
i
s
t
a
n
c
e
[
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
,
p
o
i
n
t
s
[
[
y
]
]
[
[
x
+
1
]
]
]
*
.
1
]
,
1
/
C
e
i
l
i
n
g
[
E
u
c
l
i
d
e
a
n
D
i
s
t
a
n
c
e
[
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
,
p
o
i
n
t
s
[
[
y
]
]
[
[
x
+
1
]
]
]
*
.
1
]
}
]
Mapping that function across all rows gives us:
I
n
[
]
:
=
r
o
w
s
=
T
a
b
l
e
[
F
l
a
t
t
e
n
[
T
a
b
l
e
[
T
a
b
l
e
[
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
+
a
*
(
p
o
i
n
t
s
[
[
y
]
]
[
[
x
+
1
]
]
-
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
)
,
(
*
c
o
o
r
d
i
n
a
t
e
s
*
)
{
y
,
x
+
a
}
(
*
r
o
w
a
n
d
c
o
l
u
m
n
*
)
,
{
y
,
x
+
a
}
{
y
,
x
+
a
+
1
/
C
e
i
l
i
n
g
[
E
u
c
l
i
d
e
a
n
D
i
s
t
a
n
c
e
[
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
,
p
o
i
n
t
s
[
[
y
]
]
[
[
x
+
1
]
]
]
*
.
1
]
}
,
{
a
,
0
,
1
-
1
/
C
e
i
l
i
n
g
[
E
u
c
l
i
d
e
a
n
D
i
s
t
a
n
c
e
[
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
,
p
o
i
n
t
s
[
[
y
]
]
[
[
x
+
1
]
]
]
*
.
2
]
,
1
/
C
e
i
l
i
n
g
[
E
u
c
l
i
d
e
a
n
D
i
s
t
a
n
c
e
[
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
,
p
o
i
n
t
s
[
[
y
]
]
[
[
x
+
1
]
]
]
*
.
1
]
}
]
,
{
x
,
1
,
L
e
n
g
t
h
[
p
o
i
n
t
s
[
[
y
]
]
]
-
1
,
1
}
]
,
2
]
,
{
y
,
1
,
L
e
n
g
t
h
[
p
o
i
n
t
s
]
,
1
}
]
;
I then made lists with information extracted from "rows": the edges listed in rows ("edgesrows"), each coordinate along with its row and column ("associationlist"), a list of all coordinates used ("coordinatelist"), and a list of all points ("pointlist").
I
n
[
]
:
=
e
d
g
e
s
r
o
w
s
=
F
l
a
t
t
e
n
[
T
a
b
l
e
[
T
a
b
l
e
[
r
o
w
s
[
[
a
]
]
[
[
n
]
]
,
{
n
,
2
,
L
e
n
g
t
h
[
r
o
w
s
[
[
a
]
]
]
,
2
}
]
,
{
a
,
1
,
L
e
n
g
t
h
[
r
o
w
s
]
}
]
]
;
a
s
s
o
c
i
a
t
i
o
n
l
i
s
t
=
F
l
a
t
t
e
n
[
T
a
b
l
e
[
T
a
b
l
e
[
r
o
w
s
[
[
a
]
]
[
[
x
]
]
,
{
x
,
1
,
L
e
n
g
t
h
[
r
o
w
s
[
[
a
]
]
]
-
1
,
2
}
]
,
{
a
,
1
,
L
e
n
g
t
h
[
r
o
w
s
]
}
]
,
1
]
;
c
o
o
r
d
i
n
a
t
e
l
i
s
t
=
T
a
b
l
e
[
T
a
b
l
e
[
r
o
w
s
[
[
a
]
]
[
[
x
]
]
[
[
1
]
]
,
{
x
,
1
,
L
e
n
g
t
h
[
r
o
w
s
[
[
a
]
]
]
-
1
,
2
}
]
,
{
a
,
1
,
L
e
n
g
t
h
[
r
o
w
s
]
}
]
;
p
o
i
n
t
l
i
s
t
=
T
a
b
l
e
[
T
a
b
l
e
[
r
o
w
s
[
[
a
]
]
[
[
x
]
]
[
[
2
]
]
,
{
x
,
1
,
L
e
n
g
t
h
[
r
o
w
s
[
[
a
]
]
]
-
1
,
2
}
]
,
{
a
,
1
,
L
e
n
g
t
h
[
r
o
w
s
]
}
]
;
Next is an association between the coordinates and their row and column. Using that, I made a function that for each vertex in rows after 1, there is an undirected edge between it and the nearest (in coordinates) vertex in the row below.
I
n
[
]
:
=
v
e
r
t
a
s
s
o
c
=
A
s
s
o
c
i
a
t
i
o
n
[
#
[
[
1
]
]
#
[
[
2
]
]
&
/
@
a
s
s
o
c
i
a
t
i
o
n
l
i
s
t
]
;
v
e
r
t
e
d
g
e
s
=
F
l
a
t
t
e
n
[
T
a
b
l
e
[
T
a
b
l
e
[
v
e
r
t
a
s
s
o
c
[
c
o
o
r
d
i
n
a
t
e
l
i
s
t
[
[
a
]
]
[
[
x
]
]
]
v
e
r
t
a
s
s
o
c
[
N
e
a
r
e
s
t
[
c
o
o
r
d
i
n
a
t
e
l
i
s
t
[
[
a
-
1
]
]
,
c
o
o
r
d
i
n
a
t
e
l
i
s
t
[
[
a
]
]
[
[
x
]
]
]
[
[
1
]
]
]
,
{
x
,
1
,
L
e
n
g
t
h
[
c
o
o
r
d
i
n
a
t
e
l
i
s
t
[
[
a
]
]
]
}
]
,
{
a
,
2
,
L
e
n
g
t
h
[
c
o
o
r
d
i
n
a
t
e
l
i
s
t
]
}
]
]
;
The final set of edges connects each last edge in a row to the last in the row above
I
n
[
]
:
=
l
a
s
t
i
n
r
o
w
=
T
a
b
l
e
[
L
a
s
t
[
S
o
r
t
[
p
o
i
n
t
l
i
s
t
[
[
x
]
]
]
]
L
a
s
t
[
S
o
r
t
[
p
o
i
n
t
l
i
s
t
[
[
x
+
1
]
]
]
]
,
{
x
,
1
,
L
e
n
g
t
h
[
p
o
i
n
t
l
i
s
t
]
-
1
}
]
;
Now, we can plug all our edges into a Graph3D:
I
n
[
]
:
=
G
r
a
p
h
3
D
[
U
n
i
o
n
[
e
d
g
e
s
r
o
w
s
,
v
e
r
t
e
d
g
e
s
,
l
a
s
t
i
n
r
o
w
]
,
V
e
r
t
e
x
L
a
b
e
l
s
A
u
t
o
m
a
t
i
c
]
O
u
t
[
]
=
Putting these altogether, we have a function that takes an equation, x and y boundaries, and baseline vertex distance, and outputs a graph pattern.
I
n
[
]
:
=
c
u
r
v
e
d
g
r
a
p
h
[
e
q
u
a
t
i
o
n
_
,
x
b
o
u
n
d
s
_
,
y
b
o
u
n
d
s
_
,
i
n
i
t
s
p
a
c
i
n
g
_
]
:
=
L
a
s
t
[
p
o
i
n
t
s
=
T
a
b
l
e
[
T
a
b
l
e
[
e
q
u
a
t
i
o
n
,
{
y
,
y
b
o
u
n
d
s
[
[
1
]
]
,
y
b
o
u
n
d
s
[
[
2
]
]
,
i
n
i
t
s
p
a
c
i
n
g
}
]
,
{
x
,
x
b
o
u
n
d
s
[
[
1
]
]
,
x
b
o
u
n
d
s
[
[
2
]
]
,
i
n
i
t
s
p
a
c
i
n
g
}
]
;
r
o
w
s
=
T
a
b
l
e
[
F
l
a
t
t
e
n
[
T
a
b
l
e
[
T
a
b
l
e
[
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
+
a
*
(
p
o
i
n
t
s
[
[
y
]
]
[
[
x
+
1
]
]
-
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
)
,
(
*
c
o
o
r
d
i
n
a
t
e
s
*
)
{
y
,
x
+
a
}
(
*
r
o
w
a
n
d
c
o
l
u
m
n
*
)
,
{
y
,
x
+
a
}
{
y
,
x
+
a
+
1
/
C
e
i
l
i
n
g
[
E
u
c
l
i
d
e
a
n
D
i
s
t
a
n
c
e
[
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
,
p
o
i
n
t
s
[
[
y
]
]
[
[
x
+
1
]
]
]
*
.
1
]
}
(
*
c
o
n
n
e
c
t
i
o
n
*
)
,
{
a
,
0
,
1
-
1
/
C
e
i
l
i
n
g
[
E
u
c
l
i
d
e
a
n
D
i
s
t
a
n
c
e
[
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
,
p
o
i
n
t
s
[
[
y
]
]
[
[
x
+
1
]
]
]
*
.
2
]
,
1
/
C
e
i
l
i
n
g
[
E
u
c
l
i
d
e
a
n
D
i
s
t
a
n
c
e
[
p
o
i
n
t
s
[
[
y
]
]
[
[
x
]
]
,
p
o
i
n
t
s
[
[
y
]
]
[
[
x
+
1
]
]
]
*
.
1
]
}
]
,
{
x
,
1
,
L
e
n
g
t
h
[
p
o
i
n
t
s
[
[
y
]
]
]
-
1
,
1
}
]
,
2
]
,
{
y
,
1
,
L
e
n
g
t
h
[
p
o
i
n
t
s
]
,
1
}
]
;
e
d
g
e
s
r
o
w
s
=
F
l
a
t
t
e
n
[
T
a
b
l
e
[
T
a
b
l
e
[
r
o
w
s
[
[
a
]
]
[
[
n
]
]
,
{
n
,
2
,
L
e
n
g
t
h
[
r
o
w
s
[
[
a
]
]
]
,
2
}
]
,
{
a
,
1
,
L
e
n
g
t
h
[
r
o
w
s
]
}
]
]
;
a
s
s
o
c
i
a
t
i
o
n
l
i
s
t
=
F
l
a
t
t
e
n
[
T
a
b
l
e
[
T
a
b
l
e
[
r
o
w
s
[
[
a
]
]
[
[
x
]
]
,
{
x
,
1
,
L
e
n
g
t
h
[
r
o
w
s
[
[
a
]
]
]
-
1
,
2
}
]
,
{
a
,
1
,
L
e
n
g
t
h
[
r
o
w
s
]
}
]
,
1
]
;
v
e
r
t
a
s
s
o
c
=
A
s
s
o
c
i
a
t
i
o
n
[
#
[
[
1
]
]
#
[
[
2
]
]
&
/
@
a
s
s
o
c
i
a
t
i
o
n
l
i
s
t
]
;
c
o
o
r
d
i
n
a
t
e
l
i
s
t
=
T
a
b
l
e
[
T
a
b
l
e
[
r
o
w
s
[
[
a
]
]
[
[
x
]
]
[
[
1
]
]
,
{
x
,
1
,
L
e
n
g
t
h
[
r
o
w
s
[
[
a
]
]
]
-
1
,
2
}
]
,
{
a
,
1
,
L
e
n
g
t
h
[
r
o
w
s
]
}
]
;
p
o
i
n
t
l
i
s
t
=
T
a
b
l
e
[
T
a
b
l
e
[
r
o
w
s
[
[
a
]
]
[
[
x
]
]
[
[
2
]
]
,
{
x
,
1
,
L
e
n
g
t
h
[
r
o
w
s
[
[
a
]
]
]
-
1
,
2
}
]
,
{
a
,
1
,
L
e
n
g
t
h
[
r
o
w
s
]
}
]
;
v
e
r
t
e
d
g
e
s
=
F
l
a
t
t
e
n
[
T
a
b
l
e
[
T
a
b
l
e
[
v
e
r
t
a
s
s
o
c
[
c
o
o
r
d
i
n
a
t
e
l
i
s
t
[
[
a
]
]
[
[
x
]
]
]
v
e
r
t
a
s
s
o
c
[
N
e
a
r
e
s
t
[
c
o
o
r
d
i
n
a
t
e
l
i
s
t
[
[
a
-
1
]
]
,
c
o
o
r
d
i
n
a
t
e
l
i
s
t
[
[
a
]
]
[
[
x
]
]
]
[
[
1
]
]
]
,
{
x
,
1
,
L
e
n
g
t
h
[
c
o
o
r
d
i
n
a
t
e
l
i
s
t
[
[
a
]
]
]
}
]
,
{
a
,
2
,
L
e
n
g
t
h
[
c
o
o
r
d
i
n
a
t
e
l
i
s
t
]
}
]
]
;
l
a
s
t
i
n
r
o
w
=
T
a
b
l
e
[
L
a
s
t
[
S
o
r
t
[
p
o
i
n
t
l
i
s
t
[
[
x
]
]
]
]
L
a
s
t
[
S
o
r
t
[
p
o
i
n
t
l
i
s
t
[
[
x
+
1
]
]
]
]
,
{
x
,
1
,
L
e
n
g
t
h
[
p
o
i
n
t
l
i
s
t
]
-
1
}
]
;
G
r
a
p
h
3
D
[
U
n
i
o
n
[
e
d
g
e
s
r
o
w
s
,
v
e
r
t
e
d
g
e
s
,
l
a
s
t
i
n
r
o
w
]
,
V
e
r
t
e
x
L
a
b
e
l
s
A
u
t
o
m
a
t
i
c
]
]
I
n
[
]
:
=
c
u
r
v
e
d
g
r
a
p
h
[
{
x
,
y
,
x
^
2
+
2
y
^
2
+
3
x
^
3
+
4
y
^
4
+
5
x
^
5
+
6
y
^
6
}
,
{
-
1
,
1
}
,
{
-
1
,
1
}
,
.
2
]
O
u
t
[
]
=
H
e
r
e
i
s
a
c
r
o
c
h
e
t
v
e
r
s
i
o
n
o
f
t
h
i
s
e
x
a
c
t
p
a
t
t
e
r
n
.
I
t
'
s
n
o
t
c
u
r
r
e
n
t
l
y
i
n
c
r
e
d
i
b
l
y
a
c
c
u
r
a
t
e
,
b
u
t
i
t
d
o
e
s
m
i
m
i
c
t
h
e
s
h
a
p
e
o
f
t
h
e
f
u
n
c
t
i
o
n
t
o
a
n
e
x
t
e
n
t
.
Future steps
Simple Polyhedron
For my simple polygon function, I'd like to improve the user interface. I'd want to automate the process of stacking polygons for more than just pentagons and hexagons. I also would like to create a function with an input of a specific polyhedron and measurements, and an output of patterns for each face and instructions for how to connect them.
Curved surfaces
There's still a lot of work to do with curved surfaces. For example:
◼
working on the algorithm to more closely create a surface that can be made with crochet properties
◼
allowing for curved surfaces that don't exist just within a rectangular section of a function
◼
fixing the issue of unintentional vertices at the end of the row in the pattern
◼
making the pattern more readable without having to move the 3D Graph around
POSTED BY:
Eli Morton
Reply
|
Flag
3 Replies
Sort By:
Replies
Likes
Recent
0
Claire Chen
Claire Chen, Glastonbury High School
Posted
1 year ago
Nice work Eliza!!! The triangular prism is so cool and it was fun working with you!!
POSTED BY:
Claire Chen