public void BombitaPlantaUnaMolotovSeMueveFueraDeSuAlcanceAgarraArticuloYLuegoDeQueLaBombaExplotaVuelveYPlantaUnaToleTole()
{
Punto PosicionDePlantado = new Punto(8, 2);
Bombita bombita = new Bombita(PosicionDePlantado);
Casilla unaCasilla = this.unJuego.Ambiente.ObtenerCasilla(PosicionDePlantado);
Casilla casillaBloqueConArticulo = this.unJuego.Ambiente.ObtenerCasilla(new Punto(7, 2));
unaCasilla.Transitar(bombita);
bombita.LanzarExplosivo();
bombita.Movimiento.CambiarADerecha();
bombita.Mover();
bombita.Mover();
bombita.Movimiento.CambiarAArriba();
bombita.Mover();
System.Threading.Thread.Sleep(3000);
this.unJuego.AvanzarElTiempo();
this.unJuego.AvanzarElTiempo();
this.unJuego.AvanzarElTiempo();
bombita.Movimiento.CambiarAAbajo();
bombita.Mover();
bombita.Movimiento.CambiarAIzquierda();
bombita.Mover();
bombita.Mover();
bombita.Mover(); //come articulo BombaToleToe
bombita.LanzarExplosivo();
Assert.IsInstanceOf(typeof(BombaToleTole), this.unJuego.Ambiente.ObtenerCasilla(new Punto(7, 2)).Explosivo);
Assert.IsFalse(bombita.Destruido());
}
public LosLopezReggaeAlado(Punto unPunto)
: base(unPunto)
{
this.Lanzador = new LanzadorMolotov();
this.UnidadesDeResistencia = VIDALOSLOPEZREGGAEALADO;
this.Nombre = Nombres.lopezReggaeAlado;
}
public void AgregarCasillaDejaLaCasillaEnLaPosicionCorrecta()
{
Punto unaPos = new Punto(2, 2);
Casilla unaCasilla = FabricaDeCasillas.FabricarPasillo(unaPos);
otroMapa.AgregarCasilla(unaCasilla);
Assert.AreSame(otroMapa.ObtenerCasilla(unaPos), unaCasilla);
}
public void BombitaAgarraUnArticuloBombaToleToleYAniquilaACecilio()
{
Punto posInicio = new Punto(3, 0);
Punto posInicioCecilio = new Punto(6, 2);
Personaje unBombita = new Bombita(posInicio);
Personaje unEnemigo = new Cecilio(posInicioCecilio);
//Agrego articulo
Punto posicionCasillaArt = new Punto(4, 0);
Casilla CasillaConArticulo = unJuego.Ambiente.ObtenerCasilla(posicionCasillaArt);
Articulo unArticulo = new ArticuloBombaToleTole();
CasillaConArticulo.ArticuloContenido = unArticulo; //Pongo un articulo en el pasillo para agarrarlo con bombita.
unJuego.Ambiente.AgregarPersonaje(unBombita);
unJuego.Ambiente.AgregarPersonaje(unEnemigo);
unJuego.AgregarEnemigo(unEnemigo);
unBombita.Movimiento.CambiarADerecha();
unBombita.Mover(); // 4,0, como articulo.
unBombita.Movimiento.CambiarAArriba();
unBombita.Mover(); // 4,1
unBombita.Mover(); // 4,2
unBombita.LanzarExplosivo();
unBombita.Movimiento.CambiarAIzquierda();
unBombita.Mover(); // 3,2
unBombita.Mover(); // 2,2
unEnemigo.Movimiento.CambiarAAbajo();
unBombita.Mover(); // 2,1 bombita se oculta
System.Threading.Thread.Sleep(5000);//Pasan 5 segundos
unJuego.AvanzarElTiempo();
Assert.IsTrue(unEnemigo.Destruido());
}
public Casilla(Punto pos)
{
this.posicion = pos;
articuloContenido = null;
transitandoEnCasilla = new List<IMovible>();
explosivo = null;
}
public void AgarroUnArticuloBombaToleToleConBombitaYDestruyoUnBloqueDeAcero()
{
Punto posInicio = new Punto(0, 0);
Personaje unBombita = new Bombita(posInicio);
//Agrego articulo
Punto posicionCasillaArt = new Punto(1, 0);
Casilla CasillaConArticulo = this.unJuego.Ambiente.ObtenerCasilla(posicionCasillaArt);
Articulo unArticulo = new ArticuloBombaToleTole();
CasillaConArticulo.ArticuloContenido = unArticulo; //Pongo un articulo en el pasillo para agarrarlo con bombita.
unJuego.Ambiente.AgregarPersonaje(unBombita);
unBombita.Movimiento.CambiarADerecha();
unBombita.Mover(); // 1,0, como articulo.
unBombita.LanzarExplosivo(); // lanzo tole tole
unBombita.Movimiento.CambiarAIzquierda();
unBombita.Mover(); // 0,0
unBombita.Movimiento.CambiarAArriba();
unBombita.Mover(); // 0,1.
System.Threading.Thread.Sleep(5000);//Pasan 5 segundos
unJuego.AvanzarElTiempo(); //explota tole tole
unBombita.Movimiento.CambiarADerecha();
unBombita.Mover(); // 1,1
Punto puntoFinal = new Punto(1, 1);
Assert.AreEqual(puntoFinal.X, unBombita.Posicion.X);
Assert.AreEqual(puntoFinal.Y, unBombita.Posicion.Y);
}
public void PosicionDerechaDevuelveUnaNuevaPosicionConCoordenadaXAumentadaEn1()
{
Punto p = new Punto(3, 4);
Punto posicionDerecha = p.PosicionDerecha();
Assert.IsTrue(posicionDerecha.Equals(new Punto(4, 4)));
}
public void CuandoEnOtroMapaAgrego2PersonajesEliminoAlUnicoEnemigoYSeActivaLaSalida()
{
// agrego articulo
Tablero otroMapa = Juego.Instancia().Ambiente;
Punto pUnaSalida = new Punto(3, 3);
Punto pUnCecilio = new Punto(2, 1);
Punto pUnaBombaMolotov = new Punto(2, 0);
Punto pBombita = new Punto(4, 4);
Casilla unaCasillaDeSalida = Juego.Instancia().Ambiente.ObtenerCasilla(pUnaSalida);
unaCasillaDeSalida.agregarSalida(Juego.Instancia().Salida);
Cecilio unCecil = new Cecilio(pUnCecilio);
Bombita unBombita = new Bombita(pBombita);
BombaMolotov unaBomba = new BombaMolotov(pUnaBombaMolotov, 0);
otroMapa.AgregarPersonaje(unBombita);
otroMapa.AgregarPersonaje(unCecil);
Juego.Instancia().EnemigosVivos.Add(unCecil);
Casilla casillaBomba = otroMapa.ObtenerCasilla(pUnaBombaMolotov);
Juego.Instancia().AlojarExplosivo(unaBomba);
System.Threading.Thread.Sleep(3000);
Juego.Instancia().AvanzarElTiempo();
Juego.Instancia().AvanzarElTiempo();
Juego.Instancia().AvanzarElTiempo();
Assert.AreEqual(0, Juego.Instancia().CantidadEnemigosVivos());
Assert.IsTrue(Juego.Instancia().Ambiente.ObtenerCasilla(pUnaSalida).ArticuloContenido.EstaActivo );
}
/// <summary>
/// Inicializa una nueva instancia de la clase <c>G02_CirculoH</c>
/// </summary>
public G02_CirculoH()
{
this.inicio = new Punto(0, 0, 0);
this.centro = new Punto(0, 0, 0);
//this.radio = 0;
this._moveCode = MovesCodes.circuloHorario;
}
public BombaMolotov(Punto posicion, int porcentajeRetardo)
: base(posicion)
{
this.tiempoExplosion = (TIEMPOEXPLOSION * (100 - porcentajeRetardo) / 100F);
this.PoderDeDestruccion = PODERDEDESTRUCCIONMOLOTOV;
this.OndaExpansiva = ONDAEXPANSIVAMOLOTOV;
nombre = Nombres.molotov;
}
public Cecilio(Punto unPunto)
: base(unPunto)
{
this.Lanzador = new LanzadorMolotov();
this.UnidadesDeResistencia = VIDACECILIO;
this.Movimiento.Velocidad = 1;
this.Nombre = Nombres.cecilio;
}
public MainWindow()
{
InitializeComponent();
pintar = false;
puntoCuadrado = new Punto();
colorPintura = Color.Black;
Text = "DuartePaint";
}
public static Casilla FabricarPasillo(Punto pos)
{
Casilla unaCasilla = new Casilla(pos);
unaCasilla.Estado = new Pasillo();
if (unaCasilla.Estado == null)
throw new EstadoNuloException();
return unaCasilla;
}
public BombaToleTole(Punto posicion, int porcentajeRetardo)
: base(posicion)
{
this.tiempoExplosion = TIEMPOEXPLOSION * ((100 - porcentajeRetardo) / 100F);
this.PoderDeDestruccion = INFINITO;
this.OndaExpansiva = ONDAEXPANSIVATOLETOLE;
nombre = Nombres.toleTole;
}
/// <summary>
/// Inicializa una nueva instancia de la clase <c>G01_Cubo</c>
/// </summary>
public G01_Cubo()
{
this.inicio = new Punto(0, 0, 0);
this.ancho = 0;
this.alto = 0;
this.largo = 0;
this._moveCode = MovesCodes.lineal;
}
/// <summary>
/// Inicializa una nueva instancia de la clase <c>G02_Arco</c>
/// </summary>
public G03_ArcoA()
{
this.inicio = new Punto(0, 0, 0);
this.fin = new Punto(0, 0, 0);
this.centro = new Punto(0, 0, 0);
this.radio = 0;
this._moveCode = MovesCodes.circuloAntihorario;
}
public static Casilla FabricarCasillaConBloqueLadrillos(Punto pos)
{
Casilla unaCasilla = new Casilla(pos);
unaCasilla.Estado = BloqueComun.CrearBloqueLadrillos();
if (unaCasilla.Estado == null)
throw new EstadoNuloException();
return unaCasilla;
}
public Bombita(Punto unPunto)
: base(unPunto)
{
this.lanzador = new LanzadorMolotov();
this.unidadesDeResistencia = VIDABOMBITA;
this.ciudadLiberada = false;
this.Nombre = Nombres.bombita;
}
public LosLopezReggae(Punto unPunto)
: base(unPunto)
{
this.movimiento.MultiplicarVelocidadPor(MULTIPLICADORVELOCIDADLOSLOPEZREGGAE);
this.Lanzador = new LanzadorProyectil();
this.UnidadesDeResistencia = VIDALOSLOPEZREGGAE;
this.Nombre = Nombres.lopezReggae;
}
public void TestSetup()
{
this.unJuego = Juego.Instancia();
this.unJuego.ComenzarDesdeElPrincipio();
this.unJuego.SeleccionarMapa();
this.unJuego.CargarMapa();
posicion = new Punto(3, 4);
}
public void DaniarBloqueDeCementoConBombaMolotovDisminuyeUnidadesDeResistenciaEn5Unidades()
{
Punto unPto = new Punto(3, 4);
Bomba bomba = new BombaMolotov(unPto, 0);
Obstaculo obstaculo = BloqueComun.CrearBloqueCemento();
bomba.Daniar(obstaculo);
Assert.AreEqual(obstaculo.UnidadesDeResistencia, 5);
}
public void BombitaChocaConObstaculoMoverNoCambiaSuPosicion()
{
IMovible otroMovil = Juego.Instancia().Protagonista;
otroMovil.Movimiento.CambiarADerecha();
otroMovil.Mover();
otroMovil.Mover();
Punto posObstaculo = new Punto(2, 0);
Assert.IsFalse(otroMovil.Posicion.Equals(posObstaculo));
}
public void TestSetup()
{
this.unaFabricaDeCasillas = new FabricaDeCasillas();
this.posicionOrigen = new Punto(2, 3);
this.origen = FabricaDeCasillas.FabricarPasillo(posicionOrigen);
this.posicionDestino = new Punto(3, 3);
this.destino = FabricaDeCasillas.FabricarPasillo(posicionDestino);
this.unPersonaje = new Bombita(posicionOrigen);
}
public void AgregarArticuloBombaToleToleNoMeDejaAgregarEnPasillo()
{
Punto unPunto = new Punto(1, 1);
Casilla unaCasilla = FabricaDeCasillas.FabricarPasillo(unPunto);
Articulo unArticulo = new ArticuloBombaToleTole();
unaCasilla.agregarArticulo(unArticulo);
Assert.IsNull(unaCasilla.ArticuloContenido);
}
public void AgregarArticuloBombaToleToleMeDejaAgregarEnBloqueLadrillos()
{
Punto unPunto = new Punto(1, 1);
Casilla unaCasilla = FabricaDeCasillas.FabricarCasillaConBloqueLadrillos(unPunto);
Articulo unArticulo = new ArticuloBombaToleTole();
unaCasilla.agregarArticulo(unArticulo);
Assert.AreEqual(unArticulo, unaCasilla.ArticuloContenido);
}
public void BombitaConVelocidadNormalCambiaDePosicionEnUnaUnidadDentroDelMapaAlMoversePorPasillo()
{
this.movil = new Bombita(new Punto(0, 0));
Punto posOriginal = this.movil.Posicion.Clonar();
this.unMapa.AgregarPersonaje(this.movil);
this.movil.Movimiento.CambiarADerecha();
this.movil.Mover();
Punto pos = new Punto(1, 0);
Assert.IsTrue(pos.Equals(this.movil.Posicion));
}
public FrmDibujoParams(ref Punto p)
{
InitializeComponent();
//p = new Punto();
propiedades.SelectedObject = p;
this.Text = "Punto de Referencia";
this.lblMensaje.Text = "Ingrese el punto de referencia desde donde" + Environment.NewLine + "iniciar la operación:";
}
public void BombaToleToleExplotaAlcanzandoAUnBloqueDeCementoDevuelveTrueSiElBloqueQuedaDestruido()
{
Punto pToleTole = new Punto(1, 2);
BombaToleTole unaBomba = new BombaToleTole(pToleTole, 0);
Casilla casillaBomba = unMapa.ObtenerCasilla(pToleTole);
casillaBomba.PlantarExplosivo(unaBomba);
unMapa.ManejarExplosion(unaBomba);
Casilla unaCasillaNueva = unMapa.ObtenerCasilla(new Punto(1, 1));
Assert.IsInstanceOf(typeof(Pasillo), unaCasillaNueva.Estado);
}
public void EstaExplotadaAlPasarUnTiempoDevuelveTrue()
{
Punto unPto = new Punto(2, 2);
Bomba bomba = new BombaMolotov(unPto, 0);
Juego.Instancia().Ambiente.ObtenerCasilla(unPto).PlantarExplosivo(bomba);
System.Threading.Thread.Sleep(1000);//Dejo Pasar un segundo y explota
bomba.CuandoPasaElTiempo();
System.Threading.Thread.Sleep(1000);
bomba.CuandoPasaElTiempo();
System.Threading.Thread.Sleep(1000);
bomba.CuandoPasaElTiempo();
Assert.IsTrue(bomba.EstaExplotado());
}
public void ExplotaUnaBombaMolotovYTieneUnCasilleroArribaConBloqueLadrilloLoDestruyeYLuegoLaCasillaEsUnPasillo()
{
Punto posicion = new Punto(0, 1);
Punto puntoCasillaDaniada = new Punto(0, 2);
Bomba unaBomba = new BombaMolotov(posicion, 0);
Casilla unaCasillaBomba = unMapa.ObtenerCasilla(posicion);
unaCasillaBomba.PlantarExplosivo(unaBomba);
unMapa.ManejarExplosion(unaBomba);
Casilla unaCasillaDaniada = unMapa.ObtenerCasilla(puntoCasillaDaniada);
Assert.IsInstanceOf(typeof(Pasillo), unaCasillaDaniada.Estado);
}
public void CrearPista(Vector3 a)
{
var r = new System.Random();
int m = 500;
Punto[] puntos = new Punto[m];
Punto Centro = new Punto(a.x, a.z);
for (int i = 0; i < m; i++)
{
//COORDENADAS POLARES argumentos en radianes
puntos[i] = new Punto(125 * UnityEngine.Random.value, UnityEngine.Random.value * 2 * Mathf.PI, 1);
puntos[i].x += Centro.x;
puntos[i].y += Centro.y;
}
List <Punto> l = new List <Punto>();
for (int i = 0; i < puntos.Length; i++)
{
l.Add(puntos[i]);
}
l.Add(puntos[0]);
puntos = l.ToArray();
ConvexHull ch = new ConvexHull();
List <float> ll = new List <float>();
for (int i = 0; i < puntos.Length; i++)
{
ll.Add(puntos[i].x);
ll.Add(puntos[i].y);
}
FloatArray fa = new FloatArray(ll.ToArray());
FloatArray contorno = ch.computePolygon(fa, false);
float[] xx;
float[] yy;
float[] xs, ys;
desglosarFloatArrayEnVectoresNormales(contorno, out xx, out yy);
Punto[] convexo = Punto.CrearArregloDesdeArreglos(xx, yy);
////////////////////////////////////// AGREGAR DIFICULTAD
float ancho = UnityEngine.Random.Range(5f, 9f);
ancho = (isSeguidorDeLinea) ? ancho / 3 : ancho;
Punto[] convexo2 = new Punto[convexo.Length * 2];
if (isDeforme)
{
deformar(ref convexo);
}
separarPuntos(ref convexo);
xx = Punto.getAbscisas(convexo);
yy = Punto.getOrdenadas(convexo);
CubicSpline.FitParametric(xx, yy, n, out xs, out ys, 1, -1, 1, -1);
/////////////////////////////////////////////////////////////////////////
/*
* en xs y en ys estan las posiciones x,y de cada punto de la pista
*/
LS.Add(Instantiate(this.suelo, new Vector3(0, -1, 0), Quaternion.Euler(Vector3.zero), this.transform));
float[] angulosEnGrados = new float[n];
for (int i = 0; i < xs.Length - 1; i++)
{
angulosEnGrados[i] = 180 * Mathf.Atan2(ys[i + 1] - ys[i], -xs[i + 1] + xs[i]) / Mathf.PI;
}
IList <Punto> listaRoja = new List <Punto>();
IList <Punto> listaBuena = new List <Punto>();
Punto[] puntosInteriores;
Punto[] puntosLinea;
int offset = r.Next();
Vector3 pos, pos2 = new Vector3();
Quaternion rot;
float offsetPos;
float offsetBuenas;// = UnityEngine.Random.Range(0.5f, ancho - 0.5f);
for (int i = 0; i < xs.Length - 1; i++)
{
pos = new Vector3(xs[i], 0, ys[i]);
rot = Quaternion.Euler(0, angulosEnGrados[i], 0);
pared.transform.position = pos;
pared.transform.rotation = rot;
LPA.Add(Instantiate(pared, pos, rot, this.transform));
if (isSeguidorDeLinea)
{
offsetBuenas = ancho / 4 * Mathf.Sin(i / n) - ancho / 4;
pared.transform.Translate((ancho / 2 - offsetBuenas) * -Vector3.back, Space.Self);
listaBuena.Add(new Punto(pared.transform.position));
pared.transform.Translate((ancho - offsetBuenas) * -Vector3.back, Space.Self);
}
if (i % 10 == 0)
{
offsetPos = UnityEngine.Random.Range(0, ancho / 2);
pared.transform.Translate(offsetPos * -Vector3.back, Space.Self);
pos2 = pared.transform.position;
pared.transform.Translate((ancho - offsetPos) * -Vector3.back, Space.Self);
listaRoja.Add(new Punto(pared.transform.position));
}
else
{
pared.transform.Translate((ancho) * -Vector3.back, Space.Self);
listaRoja.Add(new Punto(pared.transform.position));
}
if (i % 5 == 0)
{
pared.transform.Translate(ancho / 2 * Vector3.back, Space.Self);
checkpoint.transform.rotation = Quaternion.Euler(0, angulosEnGrados[i], 0);
checkpoint.transform.position = pared.transform.position;
checkpoint.transform.localScale = new Vector3(0.1f, checkpoint.transform.localScale.y, ancho);
LCH.Add(Instantiate(checkpoint, pared.transform.position, Quaternion.Euler(0, angulosEnGrados[i], 0), this.transform));
}
if ((UnityEngine.Random.value > 0.65f) && !isSeguidorDeLinea)
{
powerUp.transform.position = pos;
powerUp.transform.rotation = rot;
powerUp.transform.Translate(UnityEngine.Random.Range(1, ancho - 1) * Vector3.forward, Space.Self);
LPU.Add(Instantiate(powerUp, this.transform));
}
if (isObstaculos)
{
if (UnityEngine.Random.value > 0.988f)
{
obstaculo.transform.position = pos;
obstaculo.transform.rotation = rot;
obstaculo.transform.Translate(UnityEngine.Random.Range(1, ancho - 1) * Vector3.forward, Space.Self);
LO.Add(Instantiate(obstaculo, this.transform));
}
}
posIni[i / (EvolutionManager.CarCount / 10)] = pos2;
EvolutionManager.ini = posIni[i / (EvolutionManager.CarCount / 10)];
}
puntosLinea = listaBuena.ToArray();
if (listaBuena.Count > 0)
{
puntosLinea[puntosLinea.Length - 1] = puntosLinea[0];
arreglarAngulos(ref puntosLinea);
}
puntosInteriores = listaRoja.ToArray();
puntosInteriores[puntosInteriores.Length - 1] = puntosInteriores[0];
arreglarAngulos(ref puntosInteriores);
float[] xx2, xx3;
float[] yy2, yy3;
float[] xs2, ys2, xs3, ys3;
float[] angulosEnGrados2 = new float[n2];
float[] angulosEnGrados3 = new float[n2];
xx2 = Punto.getAbscisas(puntosInteriores);
yy2 = Punto.getOrdenadas(puntosInteriores);
if (isSeguidorDeLinea)
{
xx3 = Punto.getAbscisas(puntosLinea);
yy3 = Punto.getOrdenadas(puntosLinea);
CubicSpline.FitParametric(xx3, yy3, n2, out xs3, out ys3, 1, -1, 1, -1);
for (int i = 0; i < xx3.Length; i++)
{
angulosEnGrados3[i] = 180 * Mathf.Atan2(ys3[i + 1] - ys3[i], -xs3[i + 1] + xs3[i]) / Mathf.PI;
Linea.transform.rotation = Quaternion.Euler(0, angulosEnGrados3[i], 0);
Linea.transform.position = new Vector3(xs3[i], 0, ys3[i]);
LB.Add(Instantiate(Linea, new Vector3(xs3[i], 0, ys3[i]), Quaternion.Euler(0, angulosEnGrados3[i], 0), this.transform));
}
}
CubicSpline.FitParametric(xx2, yy2, n2, out xs2, out ys2, 1, -1, 1, -1);
for (int i = 0; i < xs2.Length - 1; i++)
{
angulosEnGrados2[i] = 180 * Mathf.Atan2(ys2[i + 1] - ys2[i], -xs2[i + 1] + xs2[i]) / Mathf.PI;
}
for (int i = 0; i < xs2.Length - 1; i++)
{
paredRoja.transform.rotation = Quaternion.Euler(0, angulosEnGrados2[i], 0);
paredRoja.transform.position = new Vector3(xs2[i], 0, ys2[i]);
LPR.Add(Instantiate(paredRoja, new Vector3(xs2[i], 0, ys2[i]), Quaternion.Euler(0, angulosEnGrados2[i], 0), this.transform));
}
}
public Segmento(Punto Inicio, Punto Final)
{
this.Inicio = Inicio;
this.Final = Final;
_Longitud = double.NaN;
}
/// <summary>
///
/// DIBUJA LOS PLANOS
///
/// </summary>
///
private void IniciarResolucion()
{
btDefecto.Hide();
if (defecto)
{
this.Focus();
btContinuar.Visible = true;
this.AcceptButton = this.btContinuar;
paso++;
//Punto de paso 1
tbPunto1X.Text = "0";
tbPunto1Y.Text = "10";
tbPunto1Z.Text = "10";
//Vector perpendicular 1
tbPunto2X.Text = "0";
tbPunto2Y.Text = "10";
tbPunto2Z.Text = "0";
//Punto de paso 2
tbPunto3X.Text = "0";
tbPunto3Y.Text = "0";
tbPunto3Z.Text = "20";
//Vector perpendicular 2
tbPunto4X.Text = "0";
tbPunto4Y.Text = "0";
tbPunto4Z.Text = "10";
}
// Mostrar los controles
lbTituloAnguloX.Visible = true; btIsometrica.Visible = true;
lbAnguloX.Visible = true; btAlzado.Visible = true;
sbAngulox.Visible = true; btPerfil.Visible = true;
lbTituloAnguloY.Visible = true; btPlanta.Visible = true;
lbAnguloY.Visible = true;
sbAnguloY.Visible = true;
lbTituloAnguloZ.Visible = true;
lbAnguloZ.Visible = true;
sbAnguloZ.Visible = true;
btZoomMas.Visible = true;
btZoomMenos.Visible = true;
lbZoomtitulo.Visible = true;
lbAjustar.Visible = true;
btAjustar.Visible = true;
pnZoom.Visible = true;
btAbajo.Visible = true;
btArriba.Visible = true;
btDerecha.Visible = true;
btIzquierda.Visible = true;
btCentrar.Visible = true;
btContinuar.Visible = true;
btDefecto.Hide();
punto1 = new Punto(tbPunto1X.Text + " " + tbPunto1Y.Text + " " + tbPunto1Z.Text);
punto2 = new Punto(tbPunto3X.Text + " " + tbPunto3Y.Text + " " + tbPunto3Z.Text);
vector1 = new Vector(tbPunto2X.Text + " " + tbPunto2Y.Text + " " + tbPunto2Z.Text);
vector2 = new Vector(tbPunto4X.Text + " " + tbPunto4Y.Text + " " + tbPunto4Z.Text);
lbExplicacion.Text = " Todo punto de la línea de intersección entre los dos planos, pertenecerá a ambos. Por lo tanto,todo punto de la recta de intersección cumplirá las ecuaciones de los dos planos.";
if (directa)
{
lbExplicacion.Hide();
}
// Construir los planos
plano1 = new Plano(vector1, punto1);
plano2 = new Plano(vector2, punto2);
// Mostrar las ecuaciones de los planos
label1.Show();
label1.Location = new Point(btContinuar.Location.X + btContinuar.Width + 5, btContinuar.Location.Y);
label1.Font = new Font(label1.Font.FontFamily, 10);
label1.BackColor = Color.Transparent;
label1.Text = "Ecuación del plano1: \n" + plano1.EcuacionDelPlano().ToString() + " \n\n Ecuación del plano2: \n" + plano2.EcuacionDelPlano().ToString();
// Dibujar los planos
Vector escalado1 = new Vector(vector1);
escalado1.MultiplicarPorEscalar(10);
ventanagrafica.PintarPlano(escalado1, punto1, 50, Color.DarkOrange);
ventanagrafica.PintarPlano(vector2, punto2, 50, Color.SlateBlue);
// Punto oculto para que se ajuste la escala al tamaño de los planos
Vector posicion1 = new Vector(plano1.PuntoDePaso.Coordenadas); // Vector de posicion del punto de paso del 1er plano
Vector posicion2 = new Vector(plano2.PuntoDePaso.Coordenadas); // Vector de posicion del punto de paso del 2º plano
if (posicion1.ModuloDecimal() > posicion2.ModuloDecimal())
{
Vector ampliado = new Vector(posicion1);
ampliado.MultiplicarPorEscalar(10);
oculto = new Punto(ampliado.Componentes);
}
else
{
Vector ampliado = new Vector(posicion1);
ampliado.MultiplicarPorEscalar(2);
oculto = new Punto(ampliado.Componentes);
}
ventanagrafica.PintarPunto(oculto, 1, false, Color.Black);
btIsometrica.PerformClick();
btAjustar.PerformClick();
if (directa)
{
ContinuarResolucion();
}
paso = 1;
}
void Pitagoras(double n, Punto A, Punto B, Punto C, Punto D)
{
Punto PE = new Punto(), PF = new Punto(), PG = new Punto(), PH = new Punto(), PI = new Punto();
// if (n == 0)
GL.Begin(PrimitiveType.Quads);
GL.Color3(Color.Red);
GL.Vertex2(A.x, A.y);
GL.Vertex2(B.x, B.y);
GL.Vertex2(C.x, C.y);
GL.Vertex2(D.x, D.y);
GL.End();
//}
if (n != 0)
{
PE = E(B, A);
PF = F(B, PE);
PG = G(B, PE);
PH = H(A, PE);
PI = I(A, PE);
Pitagoras(n - 1, PG, PF, B, PE);
Pitagoras(n - 1, PH, PI, PE, A);
}
}
/// <summary>
///
/// DIBUJA EL PUNTO DE PASO, EL VECTOR PERPENDICULAR, EL PLANO E INICIA LA EXPLICACION
///
/// </summary>
///
private void IniciarResolucion()
{
// Mostrar los controles
lbTituloAnguloX.Visible = true; btIsometrica.Visible = true;
lbAnguloX.Visible = true; btAlzado.Visible = true;
sbAngulox.Visible = true; btPerfil.Visible = true;
lbTituloAnguloY.Visible = true; btPlanta.Visible = true;
lbAnguloY.Visible = true;
sbAnguloY.Visible = true;
lbTituloAnguloZ.Visible = true;
lbAnguloZ.Visible = true;
sbAnguloZ.Visible = true;
btZoomMas.Visible = true;
btZoomMenos.Visible = true;
lbZoomtitulo.Visible = true;
lbAjustar.Visible = true;
btAjustar.Visible = true;
pnZoom.Visible = true;
btAbajo.Visible = true;
btArriba.Visible = true;
btDerecha.Visible = true;
btIzquierda.Visible = true;
btCentrar.Visible = true;
btContinuar.Visible = true;
// Establecer los valores por defecto
if (defecto)
{
tbPunto1X.Text = "15"; tbPunto1Y.Text = "25"; tbPunto1Z.Text = "6";
tbPunto2X.Text = "13"; tbPunto2Y.Text = "8"; tbPunto2Z.Text = "30";
}
punto1 = new Punto(tbPunto1X.Text + " " + tbPunto1Y.Text + " " + tbPunto1Z.Text);
vector = new Vector(tbPunto2X.Text + " " + tbPunto2Y.Text + " " + tbPunto2Z.Text);
plano = new Plano(vector, punto1);
lbExplicacion.Text = " Un plano en el espacio, se define por un punto de paso del plano, y un vector perpendicular al mismo.\n En la imagen puede verse el punto introducido en color naranja, el vector perpendicular en color azul y una porción del plano en color verde.";
if (directa)
{
lbExplicacion.Hide();
}
// Dibujar el vector perpendicular al plano
ventanagrafica.PintarVector(new Punto("0 0 0"), new Punto(vector.Componentes), Color.SlateBlue, 5, true);
//Dibujar el punto de paso del plano
ventanagrafica.PintarPunto(punto1, 10, true, Color.DarkOrange);
// Dibujar la porcion de plano
ventanagrafica.PintarPlano(vector, punto1, 50, Color.Chartreuse);
if (directa)
{
ContinuarResolucion();
}
btIsometrica.PerformClick();
btAjustar.PerformClick();
if (defecto)
{
btArriba.PerformClick();
btArriba.PerformClick();
}
paso = 1;
}
public DatiDispositivo(string mac, int timestamp, double x, double y)
{
this.MAC = mac;
this.timestamp = timestamp;
this.posizione = new Punto(x, y);
}
/// <summary>
/// <para>Obtener el area a rango</para>
/// </summary>
/// <param name="grid">Grid</param>
/// <returns></returns>
public override List <Area> GetAreasARango(Grid grid) // Obtener el area a rango
{
Punto posInicial = Unidad.Area.pos;
Punto posFinal;
List <Area> retValue = new List <Area>();
switch (Unidad.dir)
{
case Direcciones.Norte:
posFinal = new Punto(posInicial.x, grid.Max.y);
break;
case Direcciones.Este:
posFinal = new Punto(grid.Max.x, posInicial.y);
break;
case Direcciones.Sur:
posFinal = new Punto(posInicial.x, grid.Min.y);
break;
default: // West
posFinal = new Punto(grid.Min.x, posInicial.y);
break;
}
int dist = 0;
while (posInicial != posFinal)
{
if (posInicial.x < posFinal.x)
{
posInicial.x++;
}
else if (posInicial.x > posFinal.x)
{
posInicial.x--;
}
if (posInicial.y < posFinal.y)
{
posInicial.y++;
}
else if (posInicial.y > posFinal.y)
{
posInicial.y--;
}
Area a = grid.GetArea(posInicial);
if (a != null && Mathf.Abs(a.altura - Unidad.Area.altura) <= vertical)
{
retValue.Add(a);
}
dist++;
if (dist >= horizontal)
{
break;
}
}
return(retValue);
}
public void RemovePunto(Punto item) => _sqlCon.Delete(item);
/// <summary>
/// <para>Carga y actualiza la area.</para>
/// </summary>
/// <param name="p">Posicion</param>
/// <param name="h">Altura</param>
public void Load(Punto p, int h) // Carga y actualiza la area
{
pos = p;
altura = h;
ActualizarPosEsc();
}
public static Point ConvertToPoint(Punto punto)
{
return(new Point(punto.X, punto.Y));
}
public static float getDerivada(Punto p1, Punto p2)
{
return((p2.y - p1.y) / (p2.x - p2.x));
}
public void AsegurarVisibilidadPuntoPagina(int pagina, Punto punto)
{
}
public DatiDispositivo(string mac, int timestamp, Punto posizione)
{
this.MAC = mac;
this.timestamp = timestamp;
this.posizione = posizione;
}
public void DibujarLinea(Lapiz lapiz, Punto inicio, Punto fin)
{
Pen l = _lapices.Obtener(lapiz);
g.DrawLine(l, Traducir(inicio), Traducir(fin));
}
/// <summary>
///
/// DIBUJA LA RECTA, EL PUNTO , EL PLANO PERPENDICULAR A LA RECTA QUE PASA POR EL PUNTO E INICIA
/// LA EXPLICACION
///
/// </summary>
///
private void IniciarResolucion()
{
btDefecto.Hide();
if (defecto)
{
this.Focus();
btContinuar.Visible = true;
this.AcceptButton = this.btContinuar;
paso++;
tbPunto1X.Text = "2";
tbPunto1Y.Text = "6";
tbPunto1Z.Text = "7";
tbPunto2X.Text = "10";
tbPunto2Y.Text = "-5";
tbPunto2Z.Text = "15";
tbPunto3X.Text = "10";
tbPunto3Y.Text = "3";
tbPunto3Z.Text = "2";
}
// Mostrar los controles
lbTituloAnguloX.Visible = true; btIsometrica.Visible = true;
lbAnguloX.Visible = true; btAlzado.Visible = true;
sbAngulox.Visible = true; btPerfil.Visible = true;
lbTituloAnguloY.Visible = true; btPlanta.Visible = true;
lbAnguloY.Visible = true;
sbAnguloY.Visible = true;
lbTituloAnguloZ.Visible = true;
lbAnguloZ.Visible = true;
sbAnguloZ.Visible = true;
btZoomMas.Visible = true;
btZoomMenos.Visible = true;
lbZoomtitulo.Visible = true;
lbAjustar.Visible = true;
btAjustar.Visible = true;
pnZoom.Visible = true;
btAbajo.Visible = true;
btArriba.Visible = true;
btDerecha.Visible = true;
btIzquierda.Visible = true;
btCentrar.Visible = true;
btContinuar.Visible = true;
punto1 = new Punto(tbPunto1X.Text + " " + tbPunto1Y.Text + " " + tbPunto1Z.Text);
punto2 = new Punto(tbPunto2X.Text + " " + tbPunto2Y.Text + " " + tbPunto2Z.Text);
punto3 = new Punto(tbPunto3X.Text + " " + tbPunto3Y.Text + " " + tbPunto3Z.Text);
if (directa)
{
lbExplicacion.Hide();
}
lbExplicacion.Text = " La distancia entre el punto y la recta, es el módulo del vector perpendicular a la recta que vá desde el punto a la recta.\n El punto inicial de ese vector, es el punto del que se quiere encontrar la distancia a la recta. El punto final de ese vector, será el punto de intersección de la recta con el plano perpendicular a la misma, y que pasa por el punto del que se quiere encontrar la distancia a la recta.";
// Crear la recta
linea1 = new Recta(punto1, punto2);
// Pintar la linea
ventanagrafica.PintarLinea(punto1, punto2, Color.DarkOrange, 5);
// Pintar los puntos inicial y final del segmento de recta
ventanagrafica.PintarPunto(punto1, 5, true, Color.DarkOrange);
ventanagrafica.PintarPunto(punto2, 5, true, Color.DarkOrange);
// Pintar el punto
ventanagrafica.PintarPunto(punto3, 10, false, Color.Yellow);
btIsometrica.PerformClick();
btAjustar.PerformClick();
if (directa)
{
ContinuarResolucion();
}
paso = 1;
}
private void btnGatto_Click(object sender, EventArgs e)
{
int i = 0;
Graphics dc = this.CreateGraphics();
Pen BluePen = new Pen(Color.Blue, 1);
Pen BlackPen = new Pen(Color.Black, 1);
//disegna il bordo del foglio 20 x 30 cm
dc.DrawRectangle(BluePen, MARGINE_SINISTRO + 0, MARGINE_SUPERIORE + 0, LATO_X, LATO_Y);
Punto[] p = new Punto[30];
//Punti per creazione gatto
p[0] = new Punto(40, 110);
p[1] = new Punto(40, 130);
p[2] = new Punto(50, 140);
p[3] = new Punto(50, 150);
p[4] = new Punto(40, 160);
p[5] = new Punto(50, 160);
p[6] = new Punto(60, 160);
p[7] = new Punto(70, 150);
p[8] = new Punto(90, 150);
p[9] = new Punto(100, 160);
p[10] = new Punto(100, 150);
p[11] = new Punto(110, 160);
p[12] = new Punto(110, 150);
p[13] = new Punto(100, 140);
p[14] = new Punto(100, 130);
p[15] = new Punto(110, 130);
p[16] = new Punto(120, 140);
p[17] = new Punto(120, 130);
p[18] = new Punto(110, 120);
p[19] = new Punto(100, 120);
p[20] = new Punto(90, 130);
p[21] = new Punto(70, 130);
p[22] = new Punto(70, 110);
p[23] = new Punto(60, 120);
p[24] = new Punto(50, 120);
//Punti x Dettagli
p[25] = new Punto(60, 140); //per mento
p[26] = new Punto(60, 150); //per zampe
//per sedere collego 13 con 20
//per Mento
dc.DrawLine(BlackPen, X(p[2].X), Y(p[2].Y), X(p[25].X), Y(p[25].Y));
dc.DrawLine(BlackPen, X(p[25].X), Y(p[25].Y), X(p[21].X), Y(p[21].Y));
dc.DrawLine(BlackPen, X(p[5].X), Y(p[5].Y), X(p[26].X), Y(p[26].Y)); //per Zampe
dc.DrawLine(BlackPen, X(p[13].X), Y(p[13].Y), X(p[20].X), Y(p[20].Y)); //per Sedere
//creazione TESTA
//for (i = 0; i < 8; i++)
//{
// int j = i + 1;
// if (j == 8) j = 0;
// dc.DrawLine(BlackPen, X(p[i].X), Y(p[i].Y), X(p[j].X), Y(p[j].Y));
//}
////creazione CORPO
//for (i = 9; i < 25; i++)
//{
// int j = i + 1;
// if (j == 25) j = 0;
// dc.DrawLine(BlackPen, X(p[i].X), Y(p[i].Y), X(p[j].X), Y(p[j].Y));
//}
//STAMPA GATTO
for (i = 0; i < 25; i++)
{
int j = i + 1;
if (j == 25)
{
j = 0;
}
dc.DrawLine(BlackPen, X(p[i].X), Y(p[i].Y), X(p[j].X), Y(p[j].Y));
//in questo modo collega l'ultimo punto al primo
if (i == 24)
{
dc.DrawLine(BlackPen, X(p[i].X), Y(p[i].Y), X(p[0].X), Y(p[0].Y));
}
//in questo modo stampo la riga della zampa posteriore
if (i == 8)
{
dc.DrawLine(BlackPen, X(p[i].X), Y(p[i].Y), X(p[10].X), Y(p[10].Y));
}
}
// linea diagonale per vedere lo spazio attorno al foglio
//dc.DrawLine(BluePen, X(0), Y(0), X(LATO_X), Y(LATO_Y));
//dc.DrawLine(BluePen, X(0), Y(LATO_Y), X(LATO_X), Y(0));
}
private static void procesarSegmento(Punto inicial, Punto final, Dictionary <int, ArrayList> segmentos)
{
int dy = final.GetYEntero() - inicial.GetYEntero();
int dx = final.GetXEntero() - inicial.GetXEntero();
int stepX = 1;
int stepY = 1;
if (dx < 0)
{
//el x final es menor al inicial, entonces doy vuelta el punto.
//esto lo logro invirtiendo el orden de recorrida de los puntos
//y por lo tanto doy vuelta el dx
stepX = -1;
dx = -dx;
}
if (dy < 0)
{
//el y final es menor al inicial, entonces doy vuelta el punto.
//esto lo logro invirtiendo el orden de recorrida de los puntos
//y por lo tanto doy vuelta el dy
stepY = -1;
dy = -dy;
}
int x = inicial.GetXEntero();
int y = inicial.GetYEntero();
if (Math.Abs(dy) < Math.Abs(dx))
{
int error = 2 * dy - dx;
int errorE = 2 * dy;
int errorD = 2 * (dy - dx);
bool sentidoCreciente = (dx == 1);
int minX = x;
int maxX = x;
while (x != (final.GetXEntero() + stepX))
{
minX = x;
maxX = x;
if (x < minX)
{
minX = x;
}
if (x > maxX)
{
maxX = x;
}
x += stepX;
if (error < 0)
{
error += errorE;
}
else
{
if (sentidoCreciente)
{
agregarPunto(segmentos, maxX, y);
}
else
{
agregarPunto(segmentos, minX, y);
}
error += errorD;
y += stepY;
}
}
if (segmentos.ContainsKey(inicial.GetYEntero()) && segmentos[inicial.GetYEntero()].Contains(inicial.GetXEntero()))
{
segmentos[inicial.GetYEntero()].RemoveAt(segmentos[inicial.GetYEntero()].LastIndexOf(inicial.GetXEntero()));
}
if (segmentos.ContainsKey(final.GetYEntero()) && segmentos[final.GetYEntero()].Contains(final.GetXEntero()))
{
segmentos[final.GetYEntero()].RemoveAt(segmentos[final.GetYEntero()].LastIndexOf(final.GetXEntero()));
}
}
else
{
int error = 2 * dx - dy;
int errorE = 2 * dx;
int errorD = 2 * (dx - dy);
while (y != (final.GetYEntero() + stepY))
{
agregarPunto(segmentos, x, y);
y += stepY;
if (error < 0)
{
error += errorE;
}
else
{
error += errorD;
x += stepX;
}
}
segmentos[inicial.GetYEntero()].RemoveAt(segmentos[inicial.GetYEntero()].LastIndexOf(inicial.GetXEntero()));
segmentos[final.GetYEntero()].RemoveAt(segmentos[final.GetYEntero()].LastIndexOf(final.GetXEntero()));
}
}
/// <summary>
///
/// VISUALIZA PARAMETRO PARA CADA RECTA, EL PUNTO DE INTERSECCION , EXTIENDE LAS RECTAS HASTA
/// EL MISMO Y FINALIZA LA RESOLUCION
///
///
/// </summary>
///
private void FinalizarResolucion()
{
btContinuar.Hide();
lbExplicacion.Text = " Resolviendo el sistema, se obtienen los parametros t y s que se han de aplicar a las ecuaciones parametricas de cada recta para obtener el punto de intersección.";
Punto interseccion = linea1.Interseccion(linea2);
if (linea1.EsParalela(linea2))
{
if (directa)
{
lbResultado.Show();
lbResultado.Text = "Rectas paralelas.";
}
lbExplicacion.Text += "\nComo las lineas introducidas son paralelas, el punto de intersección entre ambas no existe2.";
}
else if (interseccion == null)
{
if (directa)
{
label10.Show();
label10.Text = "Las lineas se cruzan sin cortarse.";
label10.BackColor = Color.Chartreuse;
label10.Location = btContinuar.Location;
}
lbExplicacion.Text += "\n Podemos observar que aplicando el parámetro correspondiente a las ecuaciones de cada recta, el resultado es distinto. Esto indica que las rectas no se cortan, sino que se cruzan sin llegar a coincidir en ningún punto.";
// Alargar las dos rectas 100 unidades por los dos extremos
Punto extension1 = linea1.SituacionPunto(100);
// ventanagrafica.PintarPunto(extension1, 10, false, Color.Pink);
Punto extension2 = linea1.SituacionPunto(-100);
Punto extension3 = linea2.SituacionPunto(100);
Punto extension4 = linea2.SituacionPunto(-100);
ventanagrafica.PintarLinea(extension1, extension2, Color.DarkOrange, 1);
ventanagrafica.PintarLinea(extension3, extension4, Color.SlateBlue, 1);
}
else
{
lbExplicacion.Text += "\n Podemos observar, que aplicando el parámetro correspondiente a las ecuaciones de cada recta, el resultado es el mismo. Si el resultado fuese distinto, las rectas no se cortarian, pero en este caso se cortan en el punto indicado como se vé en el grafico.";
// Puntos de paso de cada recta
Punto a = linea1.PuntoDePaso;
Punto c = linea2.PuntoDePaso;
// Reducir la precision del punto de interseccion a tres decimales
double intx = Math.Round(interseccion.X.ToDouble(), 3);
double inty = Math.Round(interseccion.Y.ToDouble(), 3);
double intz = Math.Round(interseccion.Z.ToDouble(), 3);
Punto intersecc = new Punto(new Racional[] { intx, inty, intz });
// Calcular parametro que será la distancia entre el punto de paso de cada recta y el punto de interseccion
Vector vector1 = new Vector(a, intersecc);
double parametro1 = Math.Round(vector1.Modulo().ARacional().ToDouble(), 4);
Vector vector2 = new Vector(c, intersecc);
double parametro2 = Math.Round(vector2.Modulo().ARacional().ToDouble(), 4);
// Mostrar los parametros en el control flotante
if (!directa)
{
flotante.lbTituloParametro.Text += "\n\nt = " + parametro1 + " s = " + parametro2;
}
lbResultado.Show();
label10.Show();
label10.Location = btContinuar.Location;
label10.BackColor = Color.Chartreuse;
label10.Text = "Punto de intersección de las rectas:\n ( x:" + Math.Round(interseccion.X.ToDouble(), 4).ToString() + " y: " + Math.Round(interseccion.Y.ToDouble(), 4).ToString() + " z: " + Math.Round(interseccion.Z.ToDouble(), 4).ToString();
ventanagrafica.PintarPunto(interseccion, 20, true, Color.Chartreuse);
ventanagrafica.PintarLinea(punto2, interseccion, Color.DarkOrange, 1);
ventanagrafica.PintarLinea(punto4, interseccion, Color.SlateBlue, 1);
}
btCentrar.PerformClick();
if (directa)
{
btIsometrica.PerformClick();
btAjustar.PerformClick();
}
}
public PointF Traducir(Punto punto)
{
return(new PointF(
(float)punto.X.ConvertirA(unidaddispositivox).Valor,
(float)punto.Y.ConvertirA(unidaddispositivoy).Valor));
}
private void DibujarCopa()
{
Gl.glPushMatrix();
Gl.glRotated(90.0f, 1, 0, 0);
if (texturaCopa == null)
{
texturaCopa = new Textura(@"../../Imagenes/Texturas/Arbol/copa.bmp", false);
}
Gl.glEnable(Gl.GL_TEXTURE_2D);
texturaCopa.Activate();
float[] colorGray = new float[4] {
.5f, .5f, .5f, .15f
};
float[] colorNone = new float[4] {
0.0f, 0.0f, 0.0f, 0.0f
};
Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_AMBIENT_AND_DIFFUSE, colorGray);
Gl.glMaterialfv(Gl.GL_FRONT, Gl.GL_SPECULAR, new float[] { 0f, 0f, 0f, 1.0f });
Punto[] posicionesTextura = new Punto[]
{
new Punto(0, 0, 0),
new Punto(1, 0, 0),
new Punto(0, 1, 0),
new Punto(1, 1, 0)
};
for (int i = 0; i < matrizPuntosCopa.Length - 2; i++) // por columnas duplicadas
{
int cicloPosicionTextura = 0;
Punto posicionTextura = null;
Gl.glBegin(Gl.GL_TRIANGLE_STRIP);
for (int j = 0; j < matrizPuntosCopa[i].Length; j++)
{
double ancho = (matrizPuntosCopa[i + 1][j] - matrizPuntosCopa[i][j]).Modulo();
double alto = 1.0f;
if (j < matrizPuntosCopa[i].Length - 1)
{
alto = (matrizPuntosCopa[i][j + 1] - matrizPuntosCopa[i][j]).Modulo();
}
double anchoSobreAlto = ancho / alto;
posicionTextura = posicionesTextura[cicloPosicionTextura];
cicloPosicionTextura = (cicloPosicionTextura + 1) % posicionesTextura.Length;
Gl.glNormal3d(matrizPuntosCopa[i][j].NormalX, matrizPuntosCopa[i][j].NormalY, matrizPuntosCopa[i][j].NormalZ);
Gl.glVertex3d(matrizPuntosCopa[i][j].X, matrizPuntosCopa[i][j].Y, matrizPuntosCopa[i][j].Z);
Gl.glTexCoord2d(posicionTextura.X, posicionTextura.Y);
posicionTextura = posicionesTextura[cicloPosicionTextura];
cicloPosicionTextura = (cicloPosicionTextura + 1) % posicionesTextura.Length;
Gl.glNormal3d(matrizPuntosCopa[i + 1][j].NormalX, matrizPuntosCopa[i + 1][j].NormalY, matrizPuntosCopa[i + 1][j].NormalZ);
Gl.glVertex3d(matrizPuntosCopa[i + 1][j].X, matrizPuntosCopa[i + 1][j].Y, matrizPuntosCopa[i + 1][j].Z);
Gl.glTexCoord2d(posicionTextura.X, posicionTextura.Y);
}
Gl.glEnd();
}
Gl.glDisable(Gl.GL_TEXTURE_2D);
if (DIBUJAR_NORMALES)
{
Gl.glDisable(Gl.GL_LIGHTING);
for (int i = 0; i < matrizPuntosCopa.Length - 2; i++) // por columnas duplicadas
{
for (int j = 0; j < matrizPuntosCopa[i].Length; j++)
{
Gl.glBegin(Gl.GL_LINES);
Gl.glColor3d(1, 0, 0);
Gl.glVertex3d(matrizPuntosCopa[i][j].X, matrizPuntosCopa[i][j].Y, matrizPuntosCopa[i][j].Z);
Gl.glColor3d(.2, 0, 0);
Gl.glVertex3d(matrizPuntosCopa[i][j].NormalX, matrizPuntosCopa[i][j].NormalY, matrizPuntosCopa[i][j].NormalZ);
Gl.glEnd();
}
}
Gl.glEnable(Gl.GL_LIGHTING);
}
Gl.glPopMatrix();
}
public IActionResult VerificarFirmaElectronica(VerificarFirmaElectronicaViewModel viewModel)
{
if (viewModel.Archivo.Length > 0)
{
try
{
using (var fileStream = viewModel.Archivo.OpenReadStream())
using (var ms = new MemoryStream())
using (var firmaStream = viewModel.ArchivoFirmaElectronica.OpenReadStream())
using (var msFirma = new MemoryStream())
{
fileStream.CopyTo(ms);
var fileBytes = ms.ToArray();
firmaStream.CopyTo(msFirma);
var firmaBytes = msFirma.ToArray();
//string s = Convert.ToBase64String(fileBytes);
Dictionary <string, byte[]> archivos = CompressionHelper.UnCompressZip(firmaBytes);
var certificate = new X509Certificate2(archivos["certificado.crt"]);
var publicKey = certificate.GetPublicKey().Reverse <byte>().ToArray();
Punto publicKeyPoint = new Punto(publicKey);
var hex = publicKeyPoint.GetUncompressedByteArray().ToHexString();
var result = LibreriaCriptografica.FirmaElectronica.VerificarFirmaElectronica(publicKeyPoint, fileBytes, archivos["firma.bin"].Reverse <byte>().ToArray());
var commonName = certificate.GetNameInfo(X509NameType.SimpleName, false);
//var organizationArea = certificate.GetNameInfo(X509NameType., false);
var subjectViewModel = new CertificateSubjectViewModel();
var subjects = certificate.Subject.Split(',');
foreach (var subject in subjects)
{
var elements = subject.Split('=');
switch (elements[0].TrimStart(' ').TrimEnd(' '))
{
case "CN": subjectViewModel.CN = elements[1].TrimStart(' ').TrimEnd(' '); break;
case "OU": subjectViewModel.OU = elements[1].TrimStart(' ').TrimEnd(' '); break;
case "O": subjectViewModel.O = elements[1].TrimStart(' ').TrimEnd(' '); break;
case "S": subjectViewModel.S = elements[1].TrimStart(' ').TrimEnd(' '); break;
case "C": subjectViewModel.C = elements[1].TrimStart(' ').TrimEnd(' '); break;
}
}
return(Ok(new VerificarFirmaElectronicaResultViewModel()
{
Result = result,
Subject = subjectViewModel,
FileName = viewModel.Archivo.FileName,
FileSize = viewModel.Archivo.Length,
FileHash = LibreriaCriptografica.FirmaElectronica.ObtenerHash(fileBytes).ToHexString()
}));
//return File(firmaByteArray, "application/x-msdownload", fileName);
}
}
catch (System.IO.InvalidDataException e)
{
return(Ok(new Response(false, "Hubo un error")));
}
catch (Exception e) {
}
}
return(null);
}
private Punto[][] generarMatrizVertices(Punto[] curva, double gradosRevolucion, int cantidadCaras)
{
double anguloRotacionRadianes = MathUtils.DegreeToRadian(gradosRevolucion / cantidadCaras);
CurvaBzierSegmentosCubicos curvaBS = new CurvaBzierSegmentosCubicos(curva);
IList <Punto> curvaDiscretizada1 = curvaBS.GetPuntosDiscretos(PASO_BEZIER);
curvaDiscretizada1.RemoveAt(curvaDiscretizada1.Count - 2);
Punto[] curvaDiscretizada = curvaDiscretizada1.ToArray <Punto>();
Punto[] normales = this.ObtenerNormalesCurva2D(curvaDiscretizada);
Punto[][] matriz = new Punto[cantidadCaras + 2][];
for (int iteradorRotacion = 0; iteradorRotacion < cantidadCaras; ++iteradorRotacion)
{
matriz[iteradorRotacion] = new Punto[curvaDiscretizada.Length];
for (int iteradorBezier = 0; iteradorBezier < curvaDiscretizada.Length; ++iteradorBezier)
{
Punto puntoCurva = curvaDiscretizada[iteradorBezier];
matriz[iteradorRotacion][iteradorBezier] = puntoCurva.Clone();
// roto, al mismo tiempo, los puntos de la curva alrededor del eje Y
Punto puntoCurvaBack = puntoCurva.Clone();
puntoCurva.X = puntoCurvaBack.X * Math.Cos(anguloRotacionRadianes) + puntoCurvaBack.Z * Math.Sin(anguloRotacionRadianes);
puntoCurva.Z = puntoCurvaBack.Z * Math.Cos(anguloRotacionRadianes) - puntoCurvaBack.X * Math.Sin(anguloRotacionRadianes);
curvaDiscretizada[iteradorBezier] = puntoCurva;
// roto, al mismo tiempo, los puntos de la normal alrededor del eje Y
Punto puntoNormal = normales[iteradorBezier];
matriz[iteradorRotacion][iteradorBezier].NormalX = puntoNormal.X;
matriz[iteradorRotacion][iteradorBezier].NormalY = puntoNormal.Y;
matriz[iteradorRotacion][iteradorBezier].NormalZ = puntoNormal.Z;
Punto puntoNormalBack = puntoNormal.Clone();
puntoNormal.X = puntoNormalBack.X * Math.Cos(anguloRotacionRadianes) + puntoNormalBack.Z * Math.Sin(anguloRotacionRadianes);
puntoNormal.Z = puntoNormalBack.Z * Math.Cos(anguloRotacionRadianes) - puntoNormalBack.X * Math.Sin(anguloRotacionRadianes);
normales[iteradorBezier] = puntoNormal;
}
}
matriz[cantidadCaras] = matriz[0];
matriz[cantidadCaras + 1] = matriz[1]; // OJO solo si los grados son 360
/*
* // calculo las normales en toda la matriz
* Boolean invertirNormal = true;
* Punto puntoNorte = null;
* Punto puntoSur = null;
* Punto puntoEste = null;
* Punto puntoOeste = null;
* Punto puntoCentro = null;
* int cantidadPixelesAlto = curvaDiscretizada.Length;
* int cantidadPixelesAncho = matriz.Length;
*
* for (int indiceFila = 0; indiceFila < cantidadPixelesAncho; ++indiceFila)
* {
* for (int indiceColumna = 0; indiceColumna < cantidadPixelesAlto; ++indiceColumna)
* {
* puntoCentro = matriz[indiceFila][indiceColumna];
*
* if (indiceFila + 1 < cantidadPixelesAncho - 1) // Hay punto norte
* puntoNorte = matriz[indiceFila + 1][indiceColumna];
* else puntoNorte = null;
*
* if (indiceFila - 1 >= 0) // Hay punto sur
* puntoSur = matriz[indiceFila - 1][indiceColumna];
* else puntoSur = null;
*
* if (indiceColumna - 1 >= 0) // Hay punto este
* puntoOeste = matriz[indiceFila][indiceColumna - 1];
* else puntoOeste = null;
*
* if (indiceColumna + 1 < cantidadPixelesAlto - 1) // Hay punto oeste
* puntoEste = matriz[indiceFila][indiceColumna + 1];
* else puntoEste = null;
*
* Punto normal = Punto.CalcularNormal(puntoCentro, puntoNorte, puntoEste, puntoSur, puntoOeste, invertirNormal);
* matriz[indiceFila][indiceColumna].NormalX = normal.X;
* matriz[indiceFila][indiceColumna].NormalY = normal.Y;
* matriz[indiceFila][indiceColumna].NormalZ = normal.Z;
* }
* }
*/
return(matriz);
}
public Rectangulo(Punto punto, int ancho, int largo)
{
Punto = punto;
Ancho = ancho;
Largo = largo;
}
public bool EnRango(Punto esquinaSuperior, TamBloque tamaño, Punto puntoTest)
{
return(puntoTest.X >= esquinaSuperior.X && (puntoTest.X < esquinaSuperior.X + tamaño.Ancho) &&
puntoTest.Y >= esquinaSuperior.Y && (puntoTest.Y < esquinaSuperior.Y + tamaño.Alto));
}
private async void plano_Click(object sender, EventArgs e)
{
MouseEventArgs click = (MouseEventArgs)e;
int tipo;
if (a != null && a.getCompletado()) /// nota: deberia ir a.getEntrenado(), pero causa errores cuando no se alcanza el error minimo
{
if (!p.getEntrenado())
{
labelAlerta.Text = "La clasificación puede ser incorrecta ya que no se alcanzó el error mínimo";
}
float[] coordenadasAdaptadas = coordenadaRealToAdaptada(click.X, click.Y);
float[,] xTemp = new float[3, 1];
xTemp[0, 0] = -1;
xTemp[1, 0] = coordenadasAdaptadas[0];
xTemp[2, 0] = coordenadasAdaptadas[1];
double sigmoide = a.funcion_sigmoide(xTemp);
if (sigmoide > .5)
{
tipo = 1;
}
else
{
tipo = 0;
}
}
else if (p != null && p.getEntrenado())
{
float[] coordenadasAdaptadas = coordenadaRealToAdaptada(click.X, click.Y);
float[,] xTemp = new float[3, 1];
xTemp[0, 0] = -1;
xTemp[1, 0] = coordenadasAdaptadas[0];
xTemp[2, 0] = coordenadasAdaptadas[1];
tipo = p.funcionEscalon(xTemp);
}
else
{
if (click.Button.ToString() == "Right")
{
tipo = 1;
}
else
{
tipo = 0;
}
}
Punto punto_generado = new Punto(click.X, click.Y, tipo);
lista_puntos.Add(punto_generado);
await Task.Factory.StartNew(() =>
this.Invoke((MethodInvoker)(() => labelCoordenadaXClick.Text = punto_generado.getPosicionAdaptadaX().ToString()))
);
await Task.Factory.StartNew(() =>
this.Invoke((MethodInvoker)(() => labelCoordenadaYClick.Text = punto_generado.getPosicionAdaptadaY().ToString()))
);
dibujar_punto(punto_generado);
if (lista_puntos.Count > 2)
{
buttonInicializacion.Enabled = true;
}
}
public Punto ObtenerPuntoEscritorio(int pagina, Punto punto)
{
return(Punto.Origen);
}
private void _Inicializa()
{
_Inicio = new Punto();
_Final = new Punto();
}
public Punto ObtenerPuntoPagina(Punto posicionEscritorio)
{
return(Punto.Origen);
}
private IList <StrokeSLT> _GenerateFill(Poligonos Pols, double AnchoBoquilla, double Porcentaje, double AnguloTrama)
{
IList <StrokeSLT> Res = new List <StrokeSLT>();
if (Porcentaje > 1.0)
{
Porcentaje = 1.0;
}
if (Porcentaje < 0.0)
{
Porcentaje = 0.0;
}
double PasoTrama = Porcentaje * AnchoBoquilla; // /1
if (PasoTrama > 0.0) //omite PasoTrama inferior o igual a 0
{
//con el AnguloTrama y el PasoTrama intersectar con los poligonos
//recorre el bounding box de los polígonos
Punto Centro = Pols.Bownding.Centro;
double SemiDiagonal = Pols.Bownding.Diagonal * 1.1 / 2.0;//con un 10% de margen
double DeltaX = Convert.ToSingle(Math.Sin(Convert.ToDouble(AnguloTrama))) * SemiDiagonal;
double DeltaY = Convert.ToSingle(Math.Sin((Math.PI / 2) - Convert.ToDouble(AnguloTrama))) * SemiDiagonal;
//oriento el rayo
Segmento Rayo = new Segmento(new Punto(Centro.X - DeltaX, Centro.Y - DeltaY, Centro.Z),
new Punto(Centro.X + DeltaX, Centro.Y + DeltaY, Centro.Z));
//desplazo al inicio
Rayo = Rayo.Equidista(-SemiDiagonal);
IList <Segmento> ResSegmentos = new List <Segmento>();
bool InvierteTrazo = false;
int Pasos = Convert.ToInt32(SemiDiagonal * 2.0 / PasoTrama);
while (Pasos > 0)
{
IList <Segmento> TempSegmentos = Pols.SegmentosInteriores(Rayo);
if (InvierteTrazo)
{
for (int i = TempSegmentos.Count - 1; i >= 0; i--)
{
StrokeSLT TT = new StrokeSLT();
//trazo de traslación
TT.Mode = Modes.ModeTraslation;
TT.Pendiente = true;
TT.Destino = new VertexSLT(TempSegmentos[i].Final.X, TempSegmentos[i].Final.Y, TempSegmentos[i].Final.Z);
Res.Add(TT);
//trazo de relleno
TT.Mode = Modes.ModoFill;
TT.Pendiente = true;
TT.Destino = new VertexSLT(TempSegmentos[i].Inicio.X, TempSegmentos[i].Inicio.Y, TempSegmentos[i].Inicio.Z);
//trazo de traslación
Res.Add(TT);
}
}
else
{
for (int i = 0; i < TempSegmentos.Count; i++)
{
StrokeSLT TT = new StrokeSLT();
//trazo de traslación
TT.Mode = Modes.ModeTraslation;
TT.Pendiente = true;
TT.Destino = new VertexSLT(TempSegmentos[i].Inicio.X, TempSegmentos[i].Inicio.Y, TempSegmentos[i].Inicio.Z);
Res.Add(TT);
//trazo de relleno
TT.Mode = Modes.ModoFill;
TT.Pendiente = true;
TT.Destino = new VertexSLT(TempSegmentos[i].Final.X, TempSegmentos[i].Final.Y, TempSegmentos[i].Final.Z);
//trazo de traslación
Res.Add(TT);
}
}
//a la próxima la dirección es la contraria
InvierteTrazo = !InvierteTrazo;
//desplaza PasoTrama el rayo y lo recalcula
Rayo = Rayo.Equidista(PasoTrama);
//evalua si se ha salido del bounding box
Pasos--;
}
}
return(Res);
}
public static float anguloEnGrados(Punto p1, Punto p2)
{
return(180 * Mathf.Atan2(p2.y - p1.y, -p2.x + p1.x) / Mathf.PI);
}
