Centrar

Rotar 180º

Reflejar en la vertical

Reflejar en la horizontal

Celda primitiva

Aplicar simetrías

Azulejo

Vectores de traslación

Centros de rotación

Ejes de reflexión

Copiar parte del friso

Dibujo libre

Rastro

Color manual

Reflejar con desplazamiento

yF = 3.7800000000000002 (slider from 3 to 4.25, step 0.01)
A0 = (-1.05, 2.34)
xF = 1 (slider from 0.12 to 2, step 0.01)
F: (xF, yF)
B0: (xF, y(A0))
J: F + A0 - B0
A = (3.3000000000000003, -3.7600000000000002)
B: A + B0 - A0
u = Vector(A, B)
CRot: J
CRot': CRot + A - A0
ejeV = Line(CRot', CRot' + (0, 1))
C: A + J - A0
v = Vector(A, C)
I: A0 + v
z = Vector(A0 + v, I)
ejeH = Line(CRot', CRot' + (1, 0))
centrar = false
xT = 9.08 (slider from 1.72 to 20, step 0.1)
yT = 0.8
k = 10 (slider from 0 to 20, step 1)
xP = 4.94
yP = -2 (slider from -30 to 1.5, step 0.01)
Q: Corner[pincel, 1] + (0.05, 0)
yT1 = -1.2
xT1 = 3.3200000000000003 (slider from 1.72 to 20, step 0.1)
T1: (xT1, yT1)
a = Line(A, C)
yR = -0.38 (slider from -2 to 1, step 0.01)
xR = 5.28
TT0 = Point(ejeH)
T = If(centrar, CRot', TT0)
R0: (xR, yR)
R: R0 - (0.78, 1.47)
rota = false
fi = 1.618033988749895
β = If(rota, 180°, 0°)
reflejoV = false
reflejoH = false
motivo = true
isometrías = false
patrón = true
vectores = false
rotación = false
reflexión = false
copia = false
libre = false
rastro = false
manual = false
A1 = 1
A2 = 2
xGoma = 13.5 (slider from 13.5 to 14, step 0.01)
yGoma = 5 (slider from 5 to 5.5, step 0.01)
rojoM = 70 (slider from 0 to 100, step 1)
verdeM = 54 (slider from 0 to 100, step 1)
azulM = 22 (slider from 0 to 100, step 1)
H = (14.14, 2.38)
α = Angle(B0, A0, J)
rAB = Line(A, B)
rAC = Line(A, C)
b = Line(A, B)
py = Line(Q, b)
Py = Intersect(a, py)
px = Line(Q, a)
Px = Intersect(b, px)
PuntoGoma: (xGoma, yGoma)
A3: (2 * A2) - A1
A4: (2 * A3) - A2
A5: (2 * A4) - A3
A6: (2 * A5) - A4
A7: (2 * A6) - A5
A8: (2 * A7) - A6
A9: (2 * A8) - A7
A10: (2 * A9) - A8
A11: (2 * A10) - A9
A12: (2 * A11) - A10
A13: (2 * A12) - A11
rojoA: Distance[Q, rAC] / Distance[B, rAC]
verdeA: Distance[Q, rAB] / Distance[C, rAB]
azulA: Distance[Q, B] / Distance[C, B]
rojo = If(manual, rojoM / 100, rojoA)
verde = If(manual, verdeM / 100, verdeA)
azul = If(manual, azulM / 100, azulA)
muestraColor: {Polygon[H, H + (1, 0), H + (1, fi), H + (0, fi)]}
texto1: "% Rojo = " + rojoM + "

% Verde = " + verdeM + "

% Azul = " + azulM
test: (AffineRatio[A, B, Px] ≥ 0) ∧ (AffineRatio[A, B, Px] ≤ 1) ∧ (AffineRatio[A, C, Py] ≥ 0) ∧ (AffineRatio[A, C, Py] ≤ 1) ∧ libre ∧ rastro
celda, celdaa, celdab, celdac, celdad = Polygon(A0, B0, F, J)
D: (B + C) / 2
A'' = If(β > 0, Rotate[CRot', β, R], R)
w = Vector(CRot', T)
f = 7
c: {Distance[T1, rAC] / Distance[B, rAC], Distance[T1, rAB] / Distance[C, rAB], Distance[T1, B] / Distance[C, B]}
PPP: (xP, yP)
reflejoD = false
listaP = Sequence(Q + ((s * 2) * u), s, (-k), k)
B1 = Element(listaP, A1)
B2 = Element(listaP, A2)
B3 = Element(listaP, A3)
B4 = Element(listaP, A4)
B5 = Element(listaP, A5)
B6 = Element(listaP, A6)
B7 = Element(listaP, A7)
B8 = Element(listaP, A8)
B9 = Element(listaP, A9)
B10 = Element(listaP, A10)
B11 = Element(listaP, A11)
B12 = Element(listaP, A12)
B13 = Element(listaP, A13)
cisne0 = Translate(cisne1, Vector[A, A0])
C': C + B - A
cisne2 = Translate(Mirror[cisne1, ejeV], z)
rCC' = Line(C, C')
A14: (2 * A13) - A12
A15: (2 * A14) - A13
A16: (2 * A15) - A14
A17: (2 * A16) - A15
A18: (2 * A17) - A16
A19: (2 * A18) - A17
A20: (2 * A19) - A18
B14 = Element(listaP, A14)
B15 = Element(listaP, A15)
B16 = Element(listaP, A16)
B17 = Element(listaP, A17)
B18 = Element(listaP, A18)
B19 = Element(listaP, A19)
B20 = Element(listaP, A20)
A21: (2 * A20) - A19
B21 = Element(listaP, A21)
polígono2, e, g, h, i = Polygon(I, I - u, I - u - v, I - v)
cisne02 = Translate(cisne2, Vector[A, A0])
QR = Translate(Mirror[Q, ejeV], z)
listaP2 = Sequence(QR + ((s * 2) * u), s, (-k), k)
C2 = Element(listaP2, A2)
C3 = Element(listaP2, A3)
C4 = Element(listaP2, A4)
C5 = Element(listaP2, A5)
C6 = Element(listaP2, A6)
C7 = Element(listaP2, A7)
C8 = Element(listaP2, A8)
C9 = Element(listaP2, A9)
C10 = Element(listaP2, A10)
C11 = Element(listaP2, A11)
C12 = Element(listaP2, A12)
C13 = Element(listaP2, A13)
C14 = Element(listaP2, A14)
C15 = Element(listaP2, A15)
C16 = Element(listaP2, A16)
C17 = Element(listaP2, A17)
C18 = Element(listaP2, A18)
C19 = Element(listaP2, A19)
C20 = Element(listaP2, A20)
C21 = Element(listaP2, A21)
baseCopia: {Polygon[Rotate[A - (3 * u) + w, β, R], Rotate[B + (2 * u) + w, β, R], Rotate[C + (3 * u) + w + v, β, R], Rotate[C - (3 * u) + w + v, β, R]]}
baseCopiaD: {Polygon[Rotate[A - (2 * u) + w, β, R], Rotate[B + (3 * u) + w, β, R], Rotate[C + (4 * u) + w + v, β, R], Rotate[C - (2 * u) + w + v, β, R]]}
listaCisne = Sequence(Translate[cisne1, Vector[((s * 2) * u)]], s, (-k), k)
listaCisne2 = Sequence(Translate[cisne2, Vector[((s * 2) * u)]], s, (-k), k)
vectoresT1: {Vector[T1 - u, T1 + u], Vector[T1 + u, T1 - u]}
listaEjes = Sequence(Line[CRot' + (u * s), CRot' + (u * s) + (0, 1)], s, (-k), k)
listaCisne2C = Sequence(Rotate[Translate[cisne2, Vector[w + ((s * 2) * u)]], β, R], s, -1, 1)
listaCisneC = Sequence(Rotate[Translate[cisne1, Vector[w + ((s * 2) * u)]], β, R], s, -1, 1)
listaCisneCH = Sequence(Mirror[Translate[cisne1, Vector[w + ((s * 2) * u)]], Line[T, T + (1, 0)]], s, -1, 1)
listaCisne2CH = Sequence(Mirror[Translate[cisne2, Vector[w + ((s * 2) * u)]], Line[T, T + (1, 0)]], s, -1, 1)
listaCisneCV = Sequence(Mirror[Translate[cisne1, Vector[w + ((s * 2) * u)]], Line[T, T + (0, 1)]], s, -1, 1)
listaCisne2CV = Sequence(Mirror[Translate[cisne2, Vector[w + ((s * 2) * u)]], Line[T, T + (0, 1)]], s, -1, 1)
ejeHC = Segment(T - (3 * u), T + (3 * u))
listaCisne2CD = Sequence(Translate[Mirror[Translate[cisne2, Vector[w + ((s * 2) * u)]], Line[T, T + (1, 0)]], u], s, -1, 1)
listaCisneCD = Sequence(Translate[Mirror[Translate[cisne1, Vector[w + ((s * 2) * u)]], Line[T, T + (1, 0)]], u], s, -1, 1)
eD = Segment(T - (2 * u), T + (4 * u))
polígono1, f_1, j, l, m = Polygon(F, J, J + v, F + v)
CRot2: (F + A0) / 2 + v / 2
polígono3, j_1, n, p, q = Polygon(J, J + v, J + v - u, J - u)
d = Segment(I + v, I - v)
CRot2': CRot2 + A - A0
cisne3 = Rotate(cisne1, 180°, CRot2')
listaCisne3 = Sequence(Translate[cisne3, Vector[((s * 2) * u)]], s, (-k), k)
cisne03 = Translate(cisne3, Vector[A, A0])
cisne4 = Mirror(cisne3, ejeV)
cisne04 = Translate(cisne4, Vector[A, A0])
listaCisne4 = Sequence(Translate[cisne4, Vector[((s * 2) * u)]], s, (-k), k)
listaCRot2 = Sequence(Translate[CRot2', Vector[(s * u)]], s, (-k), k)
rectas2 = Sequence(Line[A - ((2 * s) * v), A + u - ((2 * s) * v)], s, -1, 0)
rectas1 = Sequence(Segment[A + u + ((s * 2) * u), A + u + ((s * 2) * u) + (2 * v)], s, (-k), k)
patron: {Polygon[B, A - u, C - u + v, C + u + v]}
eV = Segment(T - v, T + v)
listaCisne3C = Sequence(Rotate[Translate[cisne3, Vector[w + ((s * 2) * u)]], β, R], s, -1, 1)
listaCisne4C = Sequence(Rotate[Translate[cisne4, Vector[w + ((s * 2) * u)]], β, R], s, -1, 1)
listaCisne3CD = Sequence(Translate[Mirror[Translate[cisne3, Vector[w + ((s * 2) * u)]], Line[T, T + (1, 0)]], u], s, -1, 1)
listaCisne4CD = Sequence(Translate[Mirror[Translate[cisne4, Vector[w + ((s * 2) * u)]], Line[T, T + (1, 0)]], u], s, -1, 1)
listaCisne3CH = Sequence(Mirror[Translate[cisne3, Vector[w + ((s * 2) * u)]], Line[T, T + (1, 0)]], s, -1, 1)
listaCisne4CH = Sequence(Mirror[Translate[cisne4, Vector[w + ((s * 2) * u)]], Line[T, T + (1, 0)]], s, -1, 1)
listaCisne3CV = Sequence(Mirror[Translate[cisne3, Vector[w + ((s * 2) * u)]], Line[T, T + (0, 1)]], s, -1, 1)
listaCisne4CV = Sequence(Mirror[Translate[cisne4, Vector[w + ((s * 2) * u)]], Line[T, T + (0, 1)]], s, -1, 1)
QR2 = Rotate(Q, 180°, CRot2')
QR2R = Translate(Mirror[QR2, ejeV], z)
listaP3 = Sequence(QR2 + ((s * 2) * u), s, (-k), k)
listaP4 = Sequence(QR2R + ((s * 2) * u), s, (-k), k)
C1 = Element(listaP2, A1)
D1 = Element(listaP3, A1)
E1 = Element(listaP4, A1)
D2 = Element(listaP3, A2)
E2 = Element(listaP4, A2)
D3 = Element(listaP3, A3)
E3 = Element(listaP4, A3)
D4 = Element(listaP3, A4)
E4 = Element(listaP4, A4)
D5 = Element(listaP3, A5)
E5 = Element(listaP4, A5)
D6 = Element(listaP3, A6)
E6 = Element(listaP4, A6)
D7 = Element(listaP3, A7)
E7 = Element(listaP4, A7)
D8 = Element(listaP3, A8)
E8 = Element(listaP4, A8)
D9 = Element(listaP3, A9)
E9 = Element(listaP4, A9)
D10 = Element(listaP3, A10)
E10 = Element(listaP4, A10)
D11 = Element(listaP3, A11)
E11 = Element(listaP4, A11)
D12 = Element(listaP3, A12)
E12 = Element(listaP4, A12)
D13 = Element(listaP3, A13)
E13 = Element(listaP4, A13)
D14 = Element(listaP3, A14)
E14 = Element(listaP4, A14)
D15 = Element(listaP3, A15)
E15 = Element(listaP4, A15)
D16 = Element(listaP3, A16)
E16 = Element(listaP4, A16)
D17 = Element(listaP3, A17)
E17 = Element(listaP4, A17)
D18 = Element(listaP3, A18)
E18 = Element(listaP4, A18)
D19 = Element(listaP3, A19)
E19 = Element(listaP4, A19)
D20 = Element(listaP3, A20)
E20 = Element(listaP4, A20)
D21 = Element(listaP3, A21)
E21 = Element(listaP4, A21)
bordes: {Polygon[A + (2 * v) - (30, (-0.025)), A + (2 * v) + (50, 0.025), A + (2 * v) + (50, 2), A + (2 * v) - (30, (-2))], Polygon[A - (30, 0.025), A + (50, (-0.025)), A + (50, (-2)), A - (30, 2)]}