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 = 4.42 (slider from 3.5 to 5.88, step 0.01)
A = (3.3000000000000003, -3.7600000000000002)
A0 = (-4.1, 2.34)
xF = -0.56 (slider from -2 to 2, step 0.01)
F: (xF, yF)
CRot: (F + A0) / 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 = 6 (slider from 0 to 20, step 1)
B0: (xF, y(A0))
J: F + A0 - B0
B: A + B0 - A0
C: A + J - A0
xP = 5.9
yP = -0.66 (slider from -30 to 1.5, step 0.01)
P: 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.18 (slider from -2 to 1, step 0.01)
xR = 6.46
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.14 (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)
patron: {Polygon[B, A, C, C + B - A]}
b = Line(A, B)
py = Line(P, b)
Py = Intersect(a, py)
px = Line(P, 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[P, rAC] / Distance[B, rAC]
verdeA: Distance[P, rAB] / Distance[C, rAB]
azulA: Distance[P, 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)
v = Vector(A, C)
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]}
eH = Segment(T - (3 * (B0 - A0) / 2), T + (3 * (B0 - A0) / 2))
cisne0 = Translate(cisne, Vector[A, A0])
PPP: (xP, yP)
baseCopia: {Polygon[Rotate[A - u + w, β, R], Rotate[B + u + w, β, R], Rotate[C + (2 * u) + w, β, R], Rotate[C - u + w, β, R]]}
baseCopiaD: {Polygon[Rotate[A - u / 2 + w, β, R], Rotate[B + (1.5 * u) + w, β, R], Rotate[C + (2.5 * u) + w, β, R], Rotate[C - u / 2 + w, β, R]]}
rectas2 = Sequence(Line[A - (s * (C - A)), A + B - A - (s * (C - A))], s, -1, 0)
rectas1 = Sequence(Segment[A + (s * (B - A)), A + (s * (B - A)) + C - A], s, (-k), k)
vectoresT1: {Vector[T1 - (B0 - A0) / 2, T1 + (B0 - A0) / 2], Vector[T1 + (B0 - A0) / 2, T1 - (B0 - A0) / 2]}
reflejoD = false
listaP = Sequence(P + (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)
listaCisne = Sequence(Translate[cisne, Vector[(s * (B - A))]], s, (-k), k)
listaCisneC = Sequence(Rotate[Translate[cisne, Vector[w + Vector[(s * (B - A))]]], β, R], s, -1, 1)
listaCisneCH = Sequence(Mirror[Translate[cisne, Vector[w + Vector[(s * (B - A))]]], Line[T, T + (1, 0)]], s, -1, 1)
listaCisneCV = Sequence(Mirror[Translate[cisne, Vector[w + Vector[(s * (B - A))]]], Line[T, T + (0, 1)]], s, -1, 1)
eV = Segment(T - v / 2, T + v / 2)
bordes: {Polygon[A + v - (30, (-0.025)), A + v + (50, 0.025), A + v + (50, 2), A + v - (30, (-2))], Polygon[A - (30, 0.025), A + (50, (-0.025)), A + (50, (-2)), A - (30, 2)]}
listaCisneCD = Sequence(Translate[Mirror[Translate[cisne, Vector[w + Vector[(s * (B - A))]]], Line[T, T + (1, 0)]], Vector[(B - A) / 2]], s, -1, 1)
eD = Segment(T - u, T + (2 * u))