Centrar

Rotar cierto ángulo

Reflejar en la otra dirección

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 mosaico

Dibujo libre

Rastro

Color manual

centrar = false
yT = -0.18000000000000113
xT = 7.46 (slider from 1.72 to 20, step 0.1)
TT0: (xT, yT)
A0 = (-1.52, 2.159999999999999)
e = Ray(A0, Rotate[A0 + (1, 0), 45°, A0])
M = Point(e)
L = Point(e)
f = Segment(L, M)
F = Point(f)
B0: (x(F), y(A0))
J: F + A0 - B0
CRot: J
A = (7.46, -1.5800000000000012)
CRot': CRot + A - A0
k = 3 (slider from 0 to 20, step 1)
B: A + B0 - A0
u = Vector(A, B)
C: A + J - A0
v = Vector(A, C)
yR = 1.279999999999999
xR = 8.24 (slider from 2.3 to 20, step 0.1)
R0: (xR, yR)
C1: B + F - B0
J4: A0 + A0 - B0
J2: F + F - B0
J3: (x(J4), y(J2))
F'': (x(A0), y(J2))
E = (-2.58, -2.3000000000000003)
fi = 1.618033988749895
d = Circle(E, 1 / fi)
G = Point(d)
R: R0 - (0.78, 1.47)
β0 = Angle(E + (0.5, 0), E, G)
rota = false
β = If(rota, round(β0), 0°)
yF = 4.04 (slider from 3.337 to 4.04, step 0.01)
xF = -0.06 (slider from -0.06 to 0.92, step 0.01)
yQ = 0.9199999999999989
xQ = 8.98 (slider from 2.26 to 20, step 0.01)
Q: Corner[pincel, 1] + (0.05, 0)
C2: A + J2 - A0
H = (0.2, -4.88)
A1 = 1
A2 = 2
xGoma = -0.9 (slider from -1.4 to -0.9, step 0.01)
yGoma = -1.8000000000000012 (slider from -2 to -1.7, step 0.01)
azulM = 22 (slider from 0 to 100, step 1)
rojoM = 70 (slider from 0 to 100, step 1)
verdeM = 54 (slider from 0 to 100, step 1)
reflejoD = 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
α = Angle(B0, A0, J)
rAB = Line(A, B)
rAC = Line(A, C)
a = Line(A, C)
b = Line(A, B)
qx = Line(Q, a)
qy = Line(Q, b)
Qy = Intersect(a, qy)
Qx = Intersect(b, qx)
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
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
A21: (2 * A20) - A19
A22: (2 * A21) - A20
A23: (2 * A22) - A21
A24: (2 * A23) - A22
A25: (2 * A24) - A23
A26: (2 * A25) - A24
A27: (2 * A26) - A25
A28: (2 * A27) - A26
A29: (2 * A28) - A27
A30: (2 * A29) - A28
A31: (2 * A30) - A29
A32: (2 * A31) - A30
A33: (2 * A32) - A31
A34: (2 * A33) - A32
A35: (2 * A34) - A33
A36: (2 * A35) - A34
A37: (2 * A36) - A35
A38: (2 * A37) - A36
A39: (2 * A38) - A37
A40: (2 * A39) - A38
A41: (2 * A40) - A39
A42: (2 * A41) - A40
A43: (2 * A42) - A41
A44: (2 * A43) - A42
A45: (2 * A44) - A43
A46: (2 * A45) - A44
A47: (2 * A46) - A45
A48: (2 * A47) - A46
c: {Distance[Q, rAC] / Distance[B, rAC], Distance[Q, rAB] / Distance[C, rAB], Distance[Q, B] / Distance[C, B]}
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, Qx] ≥ 0) ∧ (AffineRatio[A, B, Qx] ≤ 1) ∧ (AffineRatio[A, C, Qy] ≥ 0) ∧ (AffineRatio[A, C, Qy] ≤ 1) ∧ libre ∧ rastro
celda, celdaa, celdab, celdac, celdae = Polygon(A0, B0, F, J)
texto2: "Ángulo rotado = " + β
F': (x(J4), y(F))
celda', g, h, i, j = Polygon(F, J2, F'', J)
cisne2 = Rotate(cisne1, 90°, CRot')
D: (A + B + C1 + CRot') / 4
P' = If(β > 0, Rotate[CRot', β, R], R)
QR = Mirror(Q, CRot')
T1: (xQ, yQ)
celda'', a0, crot, f', i_1 = Polygon(A0, CRot, F', J4)
C3: A + J3 - A0
C4: A + J4 - A0
cisne4 = Rotate(cisne1, 270°, CRot')
F2 = Mirror(A0, CRot)
hayAxiales = false
listaCRot2 = Sequence(Sequence[Translate[CRot', Vector[((s * 2) * u) + ((t * 2) * v)]], s, (-k), k], t, (-k), k)
listaCRotUni = Join(listaCRot2)
listaP1 = Sequence(Q + Element[listaCRotUni, k] - CRot', k, 1, Length[listaCRotUni])
B1 = Element(listaP1, A1)
B2 = Element(listaP1, A2)
B3 = Element(listaP1, A3)
B4 = Element(listaP1, A4)
B5 = Element(listaP1, A5)
B6 = Element(listaP1, A6)
B7 = Element(listaP1, A7)
B8 = Element(listaP1, A8)
B9 = Element(listaP1, A9)
B10 = Element(listaP1, A10)
B11 = Element(listaP1, A11)
B12 = Element(listaP1, A12)
B13 = Element(listaP1, A13)
B14 = Element(listaP1, A14)
B15 = Element(listaP1, A15)
B16 = Element(listaP1, A16)
B17 = Element(listaP1, A17)
B18 = Element(listaP1, A18)
B19 = Element(listaP1, A19)
B20 = Element(listaP1, A20)
B21 = Element(listaP1, A21)
B22 = Element(listaP1, A22)
B23 = Element(listaP1, A23)
B24 = Element(listaP1, A24)
B25 = Element(listaP1, A25)
B26 = Element(listaP1, A26)
B27 = Element(listaP1, A27)
B28 = Element(listaP1, A28)
B29 = Element(listaP1, A29)
B30 = Element(listaP1, A30)
B31 = Element(listaP1, A31)
B32 = Element(listaP1, A32)
B33 = Element(listaP1, A33)
B34 = Element(listaP1, A34)
B35 = Element(listaP1, A35)
B36 = Element(listaP1, A36)
B37 = Element(listaP1, A37)
B38 = Element(listaP1, A38)
B39 = Element(listaP1, A39)
B40 = Element(listaP1, A40)
B41 = Element(listaP1, A41)
B42 = Element(listaP1, A42)
B43 = Element(listaP1, A43)
B44 = Element(listaP1, A44)
B45 = Element(listaP1, A45)
B46 = Element(listaP1, A46)
B47 = Element(listaP1, A47)
B48 = Element(listaP1, A48)
listaP2 = Sequence(Rotate[Q, 90°, CRot'] + Element[listaCRotUni, k] - CRot', k, 1, Length[listaCRotUni])
D1 = Element(listaP2, A1)
D2 = Element(listaP2, A2)
D3 = Element(listaP2, A3)
D4 = Element(listaP2, A4)
D5 = Element(listaP2, A5)
D6 = Element(listaP2, A6)
D7 = Element(listaP2, A7)
D8 = Element(listaP2, A8)
D9 = Element(listaP2, A9)
D10 = Element(listaP2, A10)
D11 = Element(listaP2, A11)
D12 = Element(listaP2, A12)
D13 = Element(listaP2, A13)
D14 = Element(listaP2, A14)
D15 = Element(listaP2, A15)
D16 = Element(listaP2, A16)
D17 = Element(listaP2, A17)
D18 = Element(listaP2, A18)
D19 = Element(listaP2, A19)
D20 = Element(listaP2, A20)
D21 = Element(listaP2, A21)
D22 = Element(listaP2, A22)
D23 = Element(listaP2, A23)
D24 = Element(listaP2, A24)
D25 = Element(listaP2, A25)
D26 = Element(listaP2, A26)
D27 = Element(listaP2, A27)
D28 = Element(listaP2, A28)
D29 = Element(listaP2, A29)
D30 = Element(listaP2, A30)
D31 = Element(listaP2, A31)
D32 = Element(listaP2, A32)
D33 = Element(listaP2, A33)
D34 = Element(listaP2, A34)
D35 = Element(listaP2, A35)
D36 = Element(listaP2, A36)
D37 = Element(listaP2, A37)
D38 = Element(listaP2, A38)
D39 = Element(listaP2, A39)
D40 = Element(listaP2, A40)
D41 = Element(listaP2, A41)
D42 = Element(listaP2, A42)
D43 = Element(listaP2, A43)
D44 = Element(listaP2, A44)
D45 = Element(listaP2, A45)
D46 = Element(listaP2, A46)
D47 = Element(listaP2, A47)
D48 = Element(listaP2, A48)
A49: (2 * A48) - A47
B49 = Element(listaP1, A49)
D49 = Element(listaP2, A49)
listaP3 = Sequence(Rotate[Q, 180°, CRot'] + Element[listaCRotUni, k] - CRot', k, 1, Length[listaCRotUni])
E1 = Element(listaP3, A1)
E2 = Element(listaP3, A2)
E3 = Element(listaP3, A3)
E4 = Element(listaP3, A4)
E5 = Element(listaP3, A5)
E6 = Element(listaP3, A6)
E7 = Element(listaP3, A7)
E8 = Element(listaP3, A8)
E9 = Element(listaP3, A9)
E10 = Element(listaP3, A10)
E11 = Element(listaP3, A11)
E12 = Element(listaP3, A12)
E13 = Element(listaP3, A13)
E14 = Element(listaP3, A14)
E15 = Element(listaP3, A15)
E16 = Element(listaP3, A16)
E17 = Element(listaP3, A17)
E18 = Element(listaP3, A18)
E19 = Element(listaP3, A19)
E20 = Element(listaP3, A20)
E21 = Element(listaP3, A21)
E22 = Element(listaP3, A22)
E23 = Element(listaP3, A23)
E24 = Element(listaP3, A24)
E25 = Element(listaP3, A25)
E26 = Element(listaP3, A26)
E27 = Element(listaP3, A27)
E28 = Element(listaP3, A28)
E29 = Element(listaP3, A29)
E30 = Element(listaP3, A30)
E31 = Element(listaP3, A31)
E32 = Element(listaP3, A32)
E33 = Element(listaP3, A33)
E34 = Element(listaP3, A34)
E35 = Element(listaP3, A35)
E36 = Element(listaP3, A36)
E37 = Element(listaP3, A37)
E38 = Element(listaP3, A38)
E39 = Element(listaP3, A39)
E40 = Element(listaP3, A40)
E41 = Element(listaP3, A41)
E42 = Element(listaP3, A42)
E43 = Element(listaP3, A43)
E44 = Element(listaP3, A44)
E45 = Element(listaP3, A45)
E46 = Element(listaP3, A46)
E47 = Element(listaP3, A47)
E48 = Element(listaP3, A48)
E49 = Element(listaP3, A49)
polígono1, j_1, f'_1, j3, f'' = Polygon(J, F', J3, F'')
patron: {Polygon[B, C2, C3, C4]}
lista1 = Sequence(Line[B + (s * (B - C4)), C2 + (s * (B - C4))], s, (-k), k)
lista2 = Sequence(Line[B + (s * (B - C2)), C4 + (s * (B - C2))], s, (-k), k)
vectoresP: {Vector[Q - (J2 - B0) / 2, Q + (J2 - B0) / 2], Vector[Q + (J2 - B0) / 2, Q - (J2 - B0) / 2], Vector[Q - (J4 - B0) / 2, Q + (J4 - B0) / 2], Vector[Q + (J4 - B0) / 2, Q - (J4 - B0) / 2]}
listaCisne1 = Sequence(Sequence[Translate[cisne1, Vector[(s * (B - C4)) - (t * (C2 - B))]], s, (-k), k], t, (-k), k)
cisne3 = Rotate(cisne1, 180°, CRot')
listaCisne2 = Sequence(Sequence[Translate[cisne2, Vector[(s * (B - C4)) - (t * (C2 - B))]], s, (-k), k], t, (-k), k)
listaCisne3 = Sequence(Sequence[Translate[cisne3, Vector[(s * (B - C4)) - (t * (C2 - B))]], s, (-k), k], t, (-k), k)
listaCisne4 = Sequence(Sequence[Translate[cisne4, Vector[(s * (B - C4)) - (t * (C2 - B))]], s, (-k), k], t, (-k), k)
listaP4 = Sequence(Rotate[Q, 270°, CRot'] + Element[listaCRotUni, k] - CRot', k, 1, Length[listaCRotUni])
G1 = Element(listaP4, A1)
G2 = Element(listaP4, A2)
G3 = Element(listaP4, A3)
G4 = Element(listaP4, A4)
G5 = Element(listaP4, A5)
G6 = Element(listaP4, A6)
G7 = Element(listaP4, A7)
G8 = Element(listaP4, A8)
G9 = Element(listaP4, A9)
G10 = Element(listaP4, A10)
G11 = Element(listaP4, A11)
G12 = Element(listaP4, A12)
G13 = Element(listaP4, A13)
G14 = Element(listaP4, A14)
G15 = Element(listaP4, A15)
G16 = Element(listaP4, A16)
G17 = Element(listaP4, A17)
G18 = Element(listaP4, A18)
G19 = Element(listaP4, A19)
G20 = Element(listaP4, A20)
G21 = Element(listaP4, A21)
G22 = Element(listaP4, A22)
G23 = Element(listaP4, A23)
G24 = Element(listaP4, A24)
G25 = Element(listaP4, A25)
G26 = Element(listaP4, A26)
G27 = Element(listaP4, A27)
G28 = Element(listaP4, A28)
G29 = Element(listaP4, A29)
G30 = Element(listaP4, A30)
G31 = Element(listaP4, A31)
G32 = Element(listaP4, A32)
G33 = Element(listaP4, A33)
G34 = Element(listaP4, A34)
G35 = Element(listaP4, A35)
G36 = Element(listaP4, A36)
G37 = Element(listaP4, A37)
G38 = Element(listaP4, A38)
G39 = Element(listaP4, A39)
G40 = Element(listaP4, A40)
G41 = Element(listaP4, A41)
G42 = Element(listaP4, A42)
G43 = Element(listaP4, A43)
G44 = Element(listaP4, A44)
G45 = Element(listaP4, A45)
G46 = Element(listaP4, A46)
G47 = Element(listaP4, A47)
G48 = Element(listaP4, A48)
G49 = Element(listaP4, A49)
T = If(centrar, CRot', TT0)
w = Vector(CRot', T)
baseCopia: {Polygon[Rotate[B + w - (4 * u) - (2 * v), β, R], Rotate[B + w + (2 * u) - (2 * v), β, R], Rotate[B + w + (4 * v) + (2 * u), β, R], Rotate[B + w - (4 * u) + (4 * v), β, R]]}
listaCisne1C = Sequence(Sequence[Rotate[Translate[cisne1, Vector[w + Vector[(s * (B - C4)) - (t * (C2 - B))]]], β, R], s, -1, 1], t, -1, 1)
listaCisne2C = Sequence(Sequence[Rotate[Translate[cisne2, Vector[w + Vector[(s * (B - C4)) - (t * (C2 - B))]]], β, R], s, -1, 1], t, -1, 1)
listaCisne3C = Sequence(Sequence[Rotate[Translate[cisne3, Vector[w + Vector[(s * (B - C4)) - (t * (C2 - B))]]], β, R], s, -1, 1], t, -1, 1)
listaCisne4C = Sequence(Sequence[Rotate[Translate[cisne4, Vector[w + Vector[(s * (B - C4)) - (t * (C2 - B))]]], β, R], s, -1, 1], t, -1, 1)
a1 = Segment(T - (3 * u), T + (3 * u))
listaCisne1CH = Sequence(Sequence[Mirror[Translate[cisne1, Vector[w + Vector[(s * (B - C4)) - (t * (C2 - B))]]], Line[T, T + (1, 0)]], s, -1, 1], t, -1, 1)
listaCisne2CH = Sequence(Sequence[Mirror[Translate[cisne2, Vector[w + Vector[(s * (B - C4)) - (t * (C2 - B))]]], Line[T, T + (1, 0)]], s, -1, 1], t, -1, 1)
listaCisne3CH = Sequence(Sequence[Mirror[Translate[cisne3, Vector[w + Vector[(s * (B - C4)) - (t * (C2 - B))]]], Line[T, T + (1, 0)]], s, -1, 1], t, -1, 1)
listaCisne4CH = Sequence(Sequence[Mirror[Translate[cisne4, Vector[w + Vector[(s * (B - C4)) - (t * (C2 - B))]]], Line[T, T + (1, 0)]], s, -1, 1], t, -1, 1)
listaCRot2B = Sequence(Sequence[Translate[CRot', Vector[(s * (u + v)) + (t * (u - v))]], s, (-k), k], t, (-k), k)
listaCRot: {CRot' - v}
cisne0 = Translate(cisne1, Vector[A, A0])
cisne02 = Translate(cisne2, Vector[A, A0])
cisne03 = Translate(cisne3, Vector[A, A0])
cisne04 = Translate(cisne4, Vector[A, A0])
listaCRotB: {CRot' + (0, 0), CRot' + u - v}
listaCRotBT: {Rotate[T, β, R], Rotate[T + u - v, β, R]}
listaCRotBTH: {Mirror[T, a1], Mirror[T + u - v, a1]}
listaCRotT: {Rotate[T - v, β, R]}
listaCRotTH: {Mirror[T - v, a1]}
PPP: (xQ, yQ)