Hola Indetectables, despus de un tiempo inactivo vengo con un problema que no consigo solucionar. El tema es que intento calcular el punto donde dos lineas se cruzan, lienas que genero yo para crear un grafico.
Aqui una imagen:
Imagen


El problema es que no tengo lineas verticales y horizontales sino que una de ellas es perpendicular.
¿Como podria calcular el punto donde estas dos lienas se cruzan?

El codigo que utilizo es el siguiente :

Main.java
import java.awt.Color;

import javax.swing.JFrame;

class Main{
	
	public static void main(String[] args){
		
		Listas_Hor objListasHor = new Listas_Hor();
		objListasHor.GenerarLineasHor();
		
		Listas_Ver objListasVer = new Listas_Ver();
		objListasVer.GenerarLineasVer();
		
		Panel objPanel = new Panel(objListasHor.getObjLineasHor(), objListasVer.getObjLineasVer());
		JFrame objFrame = new JFrame();
		
		objFrame.getContentPane().add(objPanel);
		objFrame.setTitle("LIRAP");
		objFrame.setBackground(Color.BLACK);
		objFrame.setSize(545, 518);
		objFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		objFrame.setLocationRelativeTo(null);
		objFrame.setVisible(true);
		
	}
	
}
Panel.java
import java.awt.Color;
import java.awt.Graphics;

import javax.swing.ImageIcon;
import javax.swing.JPanel;

public class Panel extends JPanel {

	private static final long serialVersionUID = 1L;
	
	Lineas_Horizontales[] objLineasHor = new Lineas_Horizontales[3];
	Lineas_Verticales[] objLineasVer = new Lineas_Verticales[1];
	
	public Panel(Lineas_Horizontales[] objLineasHor, Lineas_Verticales[] objLineasVer) {
		this.objLineasHor = objLineasHor;
		this.objLineasVer = objLineasVer;
	}

	public void paintComponent(Graphics objGraphics){
		
		//ImageIcon Img = new ImageIcon(getClass().getResource("/Img/Graf.png")); 
		//objGraphics.drawImage(Img.getImage(), 0, 0, Img.getIconWidth(), Img.getIconHeight(), null);
		
		//Lineas Horizontales
		objGraphics.setColor(Color.red);
		for(int i=0;i<objLineasHor.length;i++){
			objGraphics.drawLine(objLineasHor[i].getiX1(), objLineasHor[i].getiY1(), objLineasHor[i].getiX2(), objLineasHor[i].getiY2());
		}
		
		//Lineas Verticales
		objGraphics.setColor(Color.blue);
		for(int i=0;i<objLineasVer.length;i++){
			objGraphics.drawLine(objLineasVer[i].getiX1(), objLineasVer[i].getiY1(), objLineasVer[i].getiX2(), objLineasVer[i].getiY2());
		}
		
	}
	
}
Lineas_Horinzotales.java
public class Lineas_Horizontales {

	private int iX1;
	private int iY1;
	private int iX2;
	private int iY2;
	private double iValor;
	
	public Lineas_Horizontales(int iX1, int iY1, int iX2, int iY2, double iValor) {
		this.iX1 = iX1;
		this.iY1 = iY1;
		this.iX2 = iX2;
		this.iY2 = iY2;
		this.iValor = iValor;
	}
	public int getiX2() {
		return iX2;
	}
	public int getiY2() {
		return iY2;
	}
	public int getiX1() {
		return iX1;
	}
	public int getiY1() {
		return iY1;
	}
	public double getiValor() {
		return iValor;
	}

}
Listas_Hor.java
public class Listas_Hor {

	private Lineas_Horizontales[] objLineasHor = new Lineas_Horizontales[3];
	
	public void GenerarLineasHor(){

		objLineasHor[0] = new Lineas_Horizontales(71, 438, 458, 443, 4000);
		objLineasHor[1] = new Lineas_Horizontales(72, 384, 463, 390, 4500);
		objLineasHor[2] = new Lineas_Horizontales(73, 330, 463, 335, 5000);
		//objLineasHor[3] = new Lineas_Horizontales(73, 280, 463, 290, 5500);
		
	}

	public Lineas_Horizontales[] getObjLineasHor() {
		return objLineasHor;
	}
	
}
Lineas_Verticales.java
public class Lineas_Verticales {

	private int iX1;
	private int iY1;
	private int iX2;
	private int iY2;
	private double iValor;
	
	public Lineas_Verticales(int iX1, int iY1, int iX2, int iY2, double iValor) {
		this.iX1 = iX1;
		this.iY1 = iY1;
		this.iX2 = iX2;
		this.iY2 = iY2;
		this.iValor = iValor;
	}
	public int getiX2() {
		return iX2;
	}
	public int getiY2() {
		return iY2;
	}
	public int getiX1() {
		return iX1;
	}
	public int getiY1() {
		return iY1;
	}
	public double getiValor() {
		return iValor;
	}
	
}
Listas_Ver.java
public class Listas_Ver {

	private Lineas_Verticales[] objLineasVer = new Lineas_Verticales[1];
	
	public void GenerarLineasVer(){

		objLineasVer[0] = new Lineas_Verticales(71, 285, 458, 393, 3600);
		
	}

	public Lineas_Verticales[] getObjLineasVer() {
		return objLineasVer;
	}
	
}
El valor de las lineas estan dados en el atributo "Valor" de las clases Lineas_Verticales y Lineas_Horizontales, en este ejemplo solo genero 3 lienas horizontales (4500, 5000, 5500) y una perpendicular (3600). Querria calcular el valor de X y Y del cruze entre el eje 5500 y 3600.

Gracias de antemano.
Saludos
Skype: naker.noventa
Prueba lo siguiente:

Una recta queda completamente determinada por dos puntos de la misma, y por tanto suponemos que podremos obtenerlos. Trabajaremos con ecuaciones de rectas de la forma:
y=mx+b

Para calcular m a partir de los puntos (x1, y1) y (x2, y2):
m=(y2-y1)/(x2-x1)

Para calcular b:
b=y1-mx1

Si igualamos las ecuaciones
y=m1x+b1,
y=m2x+b2

y despejamos x:
x=(b1-b2)/(m2-m1)

De esta forma, si las rectas se cruzan en un punto (i.e. no son paralelas), el valor en el eje de abcisas coincidirá con este último. Puesto que el punto de intersección pertenece a ambas rectas, podemos obtener el valor del eje de coordenadas sustituyendo x en cualquiera de las dos ecuaciones iniciales.

Un saludo!
github.com/Slek-Z
Gracias por tu respuesta Slek ahora se por donde van los tiros, he estado probando pero al aplicar las formulas no me han dado buen resultado. Supongo que el problema esta en los puntos de las lineas ya que se refieren a los pixeles de la ventana. De todas formas intentare solucionarlo de otra manera y si lo consigo lo dejare por aqui por si a alguien le sirve.
Saludos
Skype: naker.noventa
Naker, aquí te dejo un ejemplo de cómo calcular y dibujar la intersección con las clases que has usado:

(en el método paintComponent de Panel.java)
Lineas_Horizontales l1 = objLineasHor[2];
Lineas_Verticales l2 = objLineasVer[0];

float m1 = (l1.getiY2()-l1.getiY1())/(float) (l1.getiX2()-l1.getiX1());
float b1 = l1.getiY1()-m1*l1.getiX1();

float m2 = (l2.getiY2()-l2.getiY1())/(float) (l2.getiX2()-l2.getiX1());
float b2 = l2.getiY1()-m2*l2.getiX1();

int x = Math.round((b1-b2)/(m2-m1));
int y = Math.round(m1*x + b1);

objGraphics.setColor(Color.white);
objGraphics.drawLine(x-5, y, x+5, y);
objGraphics.drawLine(x, y-5, x, y+5);
Imagen


Es solo un ejemplo. Se podría optimizar y además habría que comprobar que las dos rectas no tienen la misma pendiente (m1 != m2).

Saludos!
github.com/Slek-Z
Olvídate de las notaciones/sufijos estilo AutoIt y similares, en estos lenguajes(los haces ambiguos) y tiempos de intellisense.

Imagen



Saludos
Imagen
Responder

Volver a “Java”