def test_polygon_1arg_success(
vsk: vsketch.Vsketch, data: Iterable[Sequence[float]], expected: Sequence[complex]
) -> None:
# polygon() with a single arg, polygon should accept an iterable of 2-size iterable
vsk.polygon(data)
assert line_count_equal(vsk, 1)
assert line_exists(vsk, np.array(expected, dtype=complex))
def draw(self, vsk: vsketch.Vsketch) -> None:
vsk.size("a6", landscape=False)
doc = execute(
"msrandom -ms -q 0.01mm -n 5 10 module_sets/ms_neon_v1 linemerge -t 0.5mm "
"layout -m 2cm a6 ")
for line in doc.layers[1]:
line = vp.interpolate(line, step=0.1)
if not self.liquify:
vsk.polygon(line)
continue
perlin_x = vsk.noise(self.freq * line.real,
self.freq * line.imag,
grid_mode=False)
perlin_y = vsk.noise(
self.freq * line.real,
self.freq * line.imag,
1000 * np.ones_like(line.real),
grid_mode=False,
)
line += self.ampl * 2.0 * ((perlin_x - 0.5) +
(perlin_y - 0.5) * 1j)
vsk.polygon(line)
vsk.vpype("linesimplify -t 0.005mm")
def draw(self, vsk: vsketch.Vsketch) -> None:
vsk.size("a4", landscape=True)
vsk.scale("2cm")
# build a star
angles = np.linspace(0, 2 * np.pi, 5, endpoint=False)
idx = [0, 2, 4, 1, 3, 0]
x = np.cos(angles[idx] - np.pi / 2)
y = np.sin(angles[idx] - np.pi / 2)
with vsk.pushMatrix():
for i in range(5):
with vsk.pushMatrix():
vsk.scale(0.8**i)
vsk.polygon(x, y)
vsk.translate(2, 0)
vsk.translate(0, 4)
for i in range(5):
with vsk.pushMatrix():
vsk.rotate(i * 4, degrees=True)
vsk.polygon(x, y)
vsk.translate(2, 0)
def test_polygon_2args_fail(vsk: vsketch.Vsketch) -> None:
# wrong array dimensions
with pytest.raises(ValueError):
vsk.polygon(np.random.rand(5, 2), np.random.rand(5, 2))
# wrong array content
with pytest.raises(ValueError):
vsk.polygon(["red", "blue"], [1, 2]) # type: ignore
def draw(self, vsk: vsketch.Vsketch) -> None:
vsk.size("a4", landscape=True)
vsk.scale("cm")
x_coords = np.linspace(0, 25, 1000)
perlin = vsk.noise(
x_coords * self.x_freq,
np.arange(self.num_line) / self.num_line * self.y_freq)
for i in range(self.num_line):
y_coords = perlin[:, i] + self.y_offset / self.num_line * i
vsk.polygon(x_coords, y_coords)
def draw(self, vsk: vsketch.Vsketch) -> None:
vsk.size("a4", landscape=False, center=False)
vsk.scale(2)
y_coords = np.linspace(0.0, 250.0, self.num_lines)
x_coords = np.linspace(0.0, 250.0, 500)
perlin = vsk.noise(x_coords * 0.1, y_coords * 0.2)
x_factor = 0.5 * (1.0 - np.cos(x_coords / 250.0 * 2 * np.pi))
y_factor = 0.5 * (1.0 - np.cos(y_coords / 250.0 * 2 * np.pi))
for j, y in enumerate(y_coords):
vsk.polygon(x_coords,
y + perlin[:, j] * 12 * y_factor[j] * x_factor)
vsk.vpype("layout -h center -v top a4 translate 0 3.8cm")
def draw(self, vsk: vsketch.Vsketch) -> None:
vsk.size("a5", landscape=False)
# Create some drawings in a sub-sketch
sub = vsketch.Vsketch()
sub.scale("cm")
sub.rect(1, 1, 3, 4)
sub.circle(6, 6, 2)
sub.bezier(2.5, 3, 5, 2, 1, 7, 6, 6)
# Iterate over the sub-sketch lines
for line in sub.document.layers[1]:
line = vp.interpolate(line, self.quantization)
for i in range(math.floor(len(line) / self.dash_steps)):
if i % 2 == 1:
continue
vsk.polygon(line[i * self.dash_steps:(i + 1) *
self.dash_steps])
def draw(self, vsk: vsketch.Vsketch) -> None:
vsk.size(self.page_size, landscape=False)
vsk.scale("cm")
vsk.scale(self.scale_factor)
prob = {
# modifiers
"+": self.prob_plus,
"-": self.prob_minus,
"O": self.prob_bigger,
"o": self.prob_smaller,
"^": self.prob_raise,
"v": self.prob_lower,
" ": self.prob_segsep,
"\n": self.prob_ringsep,
# primitives
"d": self.prob_dot,
"D": self.prob_dotbar,
"c": self.prob_circle,
"b": self.prob_bar,
"p": self.prob_cross,
"s": self.prob_spring,
"r": self.prob_box,
"S": self.prob_sine,
"C": self.prob_carbon,
"l": self.prob_line,
"L": self.prob_multiline,
}
for j in range(self.ny):
for i in range(self.nx):
# noinspection SpellCheckingInspection
drawing = "".join(
random.choices(list(prob.keys()),
list(prob.values()),
k=self.letter_count))
lc = make_drawing(drawing)
vsk.stroke((i + j * self.nx) % self.nlayer + 1)
with vsk.pushMatrix():
vsk.translate(i * self.dx, j * self.dy)
for line in lc:
vsk.polygon(line)
def draw(self, vsk: vsketch.Vsketch) -> None:
vsk.size("a4", landscape=True)
vsk.scale("cm")
vsk.rotate(-90, degrees=True)
noise_coord = np.linspace(0, 1, self.point_per_line)
dirs = np.linspace(0, 2 * math.pi, self.num_line)
perlin = vsk.noise(noise_coord, dirs, [0, 100])
for i, direction in enumerate(dirs):
rdir = vsk.map(perlin[:, i, 0], 0, 1, direction - self.rdir_range,
direction + self.rdir_range)
roffset = vsk.map(perlin[:, i, 1], 0, 1, 0.05, 0.12)
xoffset = roffset * np.cos(rdir)
yoffset = roffset * np.sin(rdir)
vsk.polygon(np.cumsum(xoffset), np.cumsum(yoffset))
def draw(self, vsk: vsketch.Vsketch) -> None:
vsk.size("a6", landscape=False)
vsk.scale(self.scale_factor)
vsk.rotate(self.rotation, degrees=True)
N = 20
angles = np.array(random.sample(range(N), self.segment_count),
dtype=float)
angles *= 2 * math.pi / N
x = np.cos(angles)
y = np.sin(angles)
speeds = np.random.uniform(-1, 1, (self.segment_count, 2))
speeds *= self.delta / np.hypot(speeds[:, 0], speeds[:, 1]).reshape(
-1, 1)
for _ in range(self.line_count):
vsk.polygon(x, y)
x += speeds[:, 0]
y += speeds[:, 1]
def test_polygon_close(vsk: vsketch.Vsketch) -> None:
vsk.polygon([(0, 0), (1, 0), (3, 3)], close=True)
assert line_count_equal(vsk, 1)
assert line_exists(vsk, np.array([0, 1, 3 + 3j, 0]))
def test_polygon_2args_success(
vsk: vsketch.Vsketch, x: Iterable[float], y: Iterable[float], expected: Sequence[complex]
) -> None:
vsk.polygon(x, y)
assert line_count_equal(vsk, 1)
assert line_exists(vsk, np.array(expected, dtype=complex))
def test_polygon_1arg_fail(vsk: vsketch.Vsketch) -> None:
# 1D arrays are not
with pytest.raises(ValueError):
vsk.polygon([1, 3, 2])
