1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
|
class pto2D extends pto3D
{
pto2D ()
{
x = 0.0f;
y = 0.0f;
z = 0.0f;
}
pto2D (float xt, float yt)
{
x = xt;
y = yt;
z = 0.0f;
}
pto2D (double xt, double yt)
{
x = (float) xt;
y = (float) yt;
z = 0.0f;
}
boolean dentro3 (pto2D A, pto2D B, pto2D C) //Ha de ser un metodo estricto, aunque se ponen >=
{
pto3D bisA = B.menos (A).aversor ().mas (C.menos (A).aversor ()); //bisectrices
pto3D bisB = A.menos (B).aversor ().mas (C.menos (B).aversor ());
double angulo1 = C.menos (A).anguloconr (bisA); //angulos maximos
double angulo2 = C.menos (B).anguloconr (bisB);
double anguloP1 = menos (A).anguloconr (bisA); //Angulos del candidato
double anguloP2 = menos (B).anguloconr (bisB);
if ((anguloP1 <= angulo1) && (anguloP2 <= angulo2))
return true;
else
return false;
}
boolean dentro3l (pto2D A, pto2D B, pto2D C) //el metodo laxo
{
pto2D centro = A.mas (B).mas (C).escala (0.3333).a2D ();
//Vectores de conexion a cada uno de los cuatro
pto2D ca = A.menos (centro).a2D ();
pto2D cb = B.menos (centro).a2D ();
pto2D cc = C.menos (centro).a2D ();
//y nuevos puntos, expandidos
A = centro.mas (ca).mas (ca.aversor ().escala (0.05)).a2D ();
B = centro.mas (cb).mas (ca.aversor ().escala (0.05)).a2D ();
C = centro.mas (cc).mas (ca.aversor ().escala (0.05)).a2D ();
return dentro3 (A, B, C);
}
boolean dentrocasi3 (pto2D A, pto2D B, pto2D v1, pto2D v2)
//ptos comprendidos en el triangulo cuyo lado esta formado por AB
//los lados marcados por v1 (que emerge de A) y v2 (de B)
//Ha de ser un metodo estricto
{
pto3D vAB = B.menos (A);
pto3D vBA = A.menos (B);
pto3D bisA = vAB.aversor ().mas (v1.aversor ()); //bisectrices
pto3D bisB = vBA.aversor ().mas (v2.aversor ());
double angulo1 = v1.anguloconr (bisA); //angulos maximos
double angulo2 = v2.anguloconr (bisB);
double anguloP1 = menos (A).anguloconr (bisA); //Angulos del candidato
double anguloP2 = menos (B).anguloconr (bisB);
if ((anguloP1 <= angulo1) && (anguloP2 <= angulo2))
return true;
else
return false;
}
boolean dentro4cv (pto2D A, pto2D B, pto2D C, pto2D D, double p)
{
//SOLO VALIDO PARA TRAP CONVEXOS
// C---------------------D
// / \
// A-----------------------B
// TRAPEZOIDE MAGICO compuesto por A= 0, B quiral 1er tubo
//C origen segundo tubo D=final segundo tubo
//angulos subtendidos BAC y CDB
//Calculamos centroide,
pto2D centro = A.mas (B).mas (C).mas (D).escala (0.25).a2D ();
//Vectores de conexion a cada uno de los cuatro
pto2D ca = A.menos (centro).a2D ();
pto2D cb = B.menos (centro).a2D ();
pto2D cc = C.menos (centro).a2D ();
pto2D cd = D.menos (centro).a2D ();
//y nuevos puntos, expandidos
A = centro.mas (ca.escala (p)).a2D ();
B = centro.mas (cb.escala (p)).a2D ();
C = centro.mas (cc.escala (p)).a2D ();
D = centro.mas (cd.escala (p)).a2D ();
pto3D bisA = B.menos (A).aversor ().mas (C.menos (A).aversor ()); //bisectrices
pto3D bisD = B.menos (D).aversor ().mas (C.menos (D).aversor ());
double anguloA = C.menos (A).anguloconr (bisA); //angulos maximos
double anguloD = B.menos (D).anguloconr (bisD);
//
double anguloPbisA = menos (A).anguloconr (bisA); //Angulos del candidato
double anguloPbisD = menos (D).anguloconr (bisD);
if ((anguloPbisA < anguloA) && (anguloPbisD < anguloD))
return true;
else
return false;
}
boolean dentro4 (pto2D A, pto2D B, pto2D C, pto2D D, double p)
{
//esta vez los puntos a, b, c y d tienen que seguir el camino.
//Primero detectamos si es convexo, si tiene cero, una concavidad,
int nconcav = 0;
//el interior esta por debajo del primer trayecto. si tiene4 concavidades, es el complementario del cuadrado.
pto2D v1 = B.menos (A);
pto2D v2 = C.menos (B);
pto2D v3 = D.menos (C);
pto2D v4 = A.menos (D);
pto2D[]ap = new pto2D[4];
boolean[]ac = new boolean[4];
ap[0] = A;
ap[1] = B;
ap[2] = C;
ap[3] = D;
double a2 = v1.angulocwhasta (v2);
double a3 = v2.angulocwhasta (v3);
double a4 = v3.angulocwhasta (v4);
double a1 = v4.angulocwhasta (v1);
double margen = 0.001; //Ojo, es vital para evitar cosas raras!
if (a1 < margen || a1 > Math.PI - margen) {
nconcav++;
ac[0] = true;
} else
ac[0] = false;
if (a2 < margen || a2 > Math.PI - margen) {
nconcav++;
ac[1] = true;
} else
ac[1] = false;
if (a3 < margen || a3 > Math.PI - margen) {
nconcav++;
ac[2] = true;
} else
ac[2] = false;
if (a4 < margen || a4 > Math.PI - margen) {
nconcav++;
ac[3] = true;
} else
ac[3] = false;
//antes de nada, vemos si hay algun angulo de aprox 180
if (nconcav == 0) { //Convexo, usamos el anterior
return dentro4cv (A, B, D, C, p); //Hay que darle la vuelta
} else if (nconcav == 1) { //identificamos el concavo
int ocon1 = -1;
for (int i = 0; i < 4; i++) {
if (ac[i] == true)
ocon1 = i;
}
int ocona = ocon1 + 1;
if (ocona > 3)
ocona -= 4;
int ocon2 = ocon1 + 2;
if (ocon2 > 3)
ocon2 -= 4;
int oconb = ocon1 + 3;
if (oconb > 3)
oconb -= 4;
boolean dentroa = dentro3l (ap[ocon1], ap[ocona], ap[ocon2]); //EXPERIMENTAL!!
boolean dentrob = dentro3l (ap[ocon1], ap[oconb], ap[ocon2]);
if (dentroa || dentrob)
return true;
else
return false;
} else if (nconcav == 2) { //las concavidades han de estar seguidas,
//a la fuerza, y eso representa un cruce
//Nos abstenemos? return false;
//Prueba con los triangulos formados?
int conc1 = -1;
int conc2 = -1;
int conv1 = -1;
int conv2 = -1;
for (int i = 0; i < 4; i++) {
if (ac[i] == false)
conc1 = i;
}
//Ya tenemos el primero, buscamos el segundo con concavidad
//van por parejas, conc, conc, no conc, no conc, nunca alternados
//Buscamos el segundo
for (int i = 0; i < 4; i++) {
if ((i != conc1) && (ac[i] == false))
conc2 = i;
}
//Una vez que conocemos los dos concavos, buscamos los convexos
for (int i = 0; i < 4; i++) {
if (ac[i] == true)
conv1 = i;
}
for (int i = 0; i < 4; i++) {
if ((i != conv1) && (ac[i] == true))
conv2 = i;
}
//ahora, asociamos a cada puntillo el vecino con concavidad contraria
int cc1v1 = conc1 + 1;
if (cc1v1 > 3)
cc1v1 -= 4;
int cc1v2 = conc1 + 3;
if (cc1v2 > 3)
cc1v2 -= 4;
int cc2v1 = conc2 + 1;
if (cc2v1 > 3)
cc2v1 -= 4;
int cc2v2 = conc2 + 3;
if (cc2v2 > 3)
cc2v2 -= 4;
int cv1v1 = conv1 + 1;
if (cv1v1 > 3)
cv1v1 -= 4;
int cv1v2 = conv1 + 3;
if (cv1v2 > 3)
cv1v2 -= 4;
int cv2v1 = conv2 + 1;
if (cv2v1 > 3)
cv2v1 -= 4;
int cv2v2 = conv2 + 3;
if (cv2v2 > 3)
cv2v2 -= 4;
//Ya tenemos a cada uno con sus vecinos. Cual es el de concav opuesta?
int cc1op = -1;
if ((ac[cc1v1] != ac[conc1])
&& (ac[cc1v2] == ac[conc1]))
cc1op = cc1v1;
else if ((ac[cc1v2] != ac[conc1])
&& (ac[cc1v1] == ac[conc1]))
cc1op = cc1v2;
int cc2op = -1;
if ((ac[cc2v1] != ac[conc2])
&& (ac[cc2v2] == ac[conc2]))
cc2op = cc2v1;
else if ((ac[cc2v2] != ac[conc2])
&& (ac[cc2v1] == ac[conc2]))
cc2op = cc2v2;
int cv1op = -1;
if ((ac[cv1v1] != ac[conv1])
&& (ac[cv1v2] == ac[conv1]))
cv1op = cv1v1;
else if ((ac[cv1v2] != ac[conv1])
&& (ac[cv1v1] == ac[conv1]))
cv1op = cv1v2;
int cv2op = -1;
if ((ac[cv2v1] != ac[conv2])
&& (ac[cv2v2] == ac[conv2]))
cv2op = cv2v1;
else if ((ac[cv2v2] != ac[conv2])
&& (ac[cv2v1] == ac[conv2]))
cv2op = cv2v2;
boolean ta = dentrocasi3 (ap[conc1], ap[conc2],
ap[cc1op].menos (ap[conc1]),
ap[cc2op].menos (ap[conc2]));
boolean tb = dentrocasi3 (ap[conv1], ap[conv2],
ap[cv1op].menos (ap[conv1]),
ap[cv2op].menos (ap[conv2]));
if (ta || tb)
return true;
else
return false;
} else if (nconcav == 3) {
int ocon1 = -1;
for (int i = 0; i < 4; i++) {
if (ac[i] == false)
ocon1 = i;
}
int ocona = ocon1 + 1;
if (ocona > 3)
ocona -= 4;
int ocon2 = ocon1 + 2;
if (ocon2 > 3)
ocon2 -= 4;
int oconb = ocon1 + 3;
if (oconb > 3)
oconb -= 4;
boolean fueraa = !dentro3l (ap[ocon1], ap[ocona], ap[ocon2]);
boolean fuerab = !dentro3l (ap[ocon1], ap[oconb], ap[ocon2]);
//if (fueraa&&fuerab) return true;
//else return false;}
return true;
} else if (nconcav == 4) { //Complementario de convexo, complementario del anterior True si esta fuera
return !dentro4cv (A, B, D, C, p); //Hay que darle la vuelta
} else {
return false;
}
}
boolean dentro4 (pto2D A, pto2D B, pto2D C, pto2D D)
{
return dentro4 (A, B, C, D, 0.0);
}
double anguloccwhasta (pto2D phasta) //EN RADIANES
{
double an = 0;
double a = anguloconr (phasta);
pto3D pv = prodvect (phasta);
if (pv.z < 0)
an = (Math.PI * 2.0) - a;
else if (pv.z >= 0)
an = a;
return an;
}
double angulocwhasta (pto2D phasta) //EN RADIANES
{
double an = 0;
double a = anguloconr (phasta);
pto3D pv = prodvect (phasta);
if (pv.z > 0)
an = (Math.PI * 2.0) - a;
else if (pv.z <= 0)
an = a;
return an;
}
boolean dentro4e (pto2D A, pto2D B, pto2D C, pto2D D)
{
return dentro4 (A, B, C, D, 1.00);
} //estricto
boolean dentro4l (pto2D A, pto2D B, pto2D C, pto2D D)
{
return dentro4 (A, B, C, D, 1.01);
} //laxo
pto2D mas (pto2D p)
{
return new pto2D (this.x + p.x, this.y + p.y);
}
pto2D menos (pto2D p)
{
return new pto2D (this.x - p.x, this.y - p.y);
}
}
|
