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

xF = -0.52 (slider from -3 to 0.08, step 0.01)
A0 = (-4.1, 2.34)
B0: (xF, y(A0))
A = (3.3000000000000003, -3.7600000000000002)
yF = 3.7800000000000002 (slider from 3 to 4.25, step 0.01)
F: (xF, yF)
J: F + A0 - B0
C: A + J - A0
v = Vector(A, C)
CRot: (F + A0) / 2 + v / 2
CRot': CRot + A - A0
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)
B: A + B0 - A0
xP = 6.04
yP = -0.1 (slider from -30 to 1.5, step 0.01)
Q: Corner[pincel, 1] + (0.05, 0)
yT1 = -0.8200000000000001
xT1 = 5.4 (slider from 1.72 to 20, step 0.1)
T1: (xT1, yT1)
a = Line(A, C)
yR = -0.86 (slider from -2 to 1, step 0.01)
xR = 5.88
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.0200000000000005 (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)
u = Vector(A, B)
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)
vectoresT1: {Vector[T1 - (B0 - A0) / 2, T1 + (B0 - A0) / 2], Vector[T1 + (B0 - A0) / 2, T1 - (B0 - A0) / 2]}
reflejoD = false
listaP = Sequence(Q + (s * (B - A)), 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])
baseCopia: {Polygon[Rotate[A - (1.5 * u) + w, β, R], Rotate[B + (1.5 * u) + w, β, R], Rotate[C + (2.5 * u) + w + v, β, R], Rotate[C - (1.5 * u) + w + v, β, R]]}
baseCopiaD: {Polygon[Rotate[A - u + w, β, R], Rotate[B + (2 * u) + w, β, R], Rotate[C + (3 * u) + w + v, β, R], Rotate[C - u + w + v, β, R]]}
C': C + B - A
rCC' = Line(C, C')
I: A0 + v + u / 2
z = Vector(A0 + v, I)
cisne2 = Translate(Mirror[cisne1, ejeH], z)
rectas2 = Sequence(Line[A - ((s * 2) * v), A + u - ((s * 2) * v)], s, -1, 0)
rectas1 = Sequence(Segment[A + (s * u), A + (s * u) + (2 * v)], s, (-k), k)
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)
patron: {Polygon[B, A, C + v, C + v + u]}
polígono2, i_1, h, j, l = Polygon(I, I + u, I + u + v, I + v)
cisne02 = Translate(cisne2, Vector[A, A0])
d = Segment(I, I + u)
eH = Segment(T - (2 * u), T + (2 * u))
eV = Segment(T - v, T + v)
listaCisne = Sequence(Translate[cisne1, Vector[(s * (B - A))]], s, (-k), k)
listaCisne2 = Sequence(Translate[cisne2, Vector[(s * u)]], s, (-k), k)
listaCisneC = Sequence(Rotate[Translate[cisne1, Vector[w + Vector[(s * (B - A))]]], β, R], s, -1, 1)
listaCisne2C = Sequence(Rotate[Translate[cisne2, Vector[w + (s * u)]], β, R], s, -2, 1)
listaCisneCH = Sequence(Mirror[Translate[cisne1, Vector[w + Vector[(s * (B - A))]]], Line[T, T + (1, 0)]], s, -1, 1)
listaCisne2CH = Sequence(Mirror[Translate[cisne2, Vector[w + Vector[(s * (B - A))]]], Line[T, T + (1, 0)]], s, -2, 1)
listaCisneCV = Sequence(Mirror[Translate[cisne1, Vector[w + Vector[(s * (B - A))]]], Line[T, T + (0, 1)]], s, -1, 1)
listaCisne2CV = Sequence(Mirror[Translate[cisne2, Vector[w + Vector[(s * (B - A))]]], Line[T, T + (0, 1)]], s, -2, 1)
listaCisneCD = Sequence(Translate[Mirror[Translate[cisne1, Vector[w + Vector[(s * (B - A))]]], Line[T, T + (1, 0)]], Vector[(B - A) / 2]], s, -1, 1)
listaCisne2CD = Sequence(Translate[Mirror[Translate[cisne2, Vector[w + Vector[(s * (B - A))]]], Line[T, T + (1, 0)]], Vector[(B - A) / 2]], s, -2, 1)
eD = Segment(T - (1.5 * u), T + (2.5 * u))
QR = Translate(Mirror[Q, ejeH], z)
listaP2 = Sequence(QR + (s * u), s, (-k), k)
C1 = Element(listaP2, A1)
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)
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)]}