java - promedio - Cálculo de la distancia entre dos puntos.

distancia promedio entre 3 puntos java

Question

Necesito crear una clase que calcule la distancia entre dos puntos. Estoy atascado y soy un principiante total. Aquí están mis clases:

package org.totalbeginner.tutorial;
public class Point {
public double x;
public double y;
Point(double xcoord, double ycoord){
this.x = xcoord;
this.y = ycoord;
}
public double getX() {
return x;
}
public double getY() {
return y;
}
}

La segunda clase.

package org.totalbeginner.tutorial;
public class Line {
double x;
double y;
Point p1 = new Point(2.0,2.0);
Point p2 = new Point(4.0,4.0);
Point mp = new Point(x,y);
public void midpoint() {
x = (p1.getX() + p2.getX()) / 2;
y = (p1.getY() + p2.getY()) / 2;
}
}

No estoy seguro de cómo obtener un objeto de punto (el punto medio) entre ambos puntos definidos.

Puedo crear objetos puntuales, pero no estoy seguro de cómo devolver un objeto puntual a través de mi método midpoint() que se encuentra entre esos dos objetos puntuales.

Answer 1

¿Realmente necesitas la distancia, o estás tratando de obtener el punto medio? Porque desde su fragmento de código, parece que solo quiere crear un nuevo punto que está a medio camino entre dos puntos existentes.

Si realmente está justo después del punto medio, realmente no necesita una segunda clase completa (es decir, ''Línea'') para lograrlo. Ya que lo que está tratando de encontrar es también un punto, tiene sentido agregar un constructor a su clase de Punto existente, como así ...

Point(Point a, Point b)
{
x = (a.x + b.x) / 2;
y = (a.y + b.y) / 2;
}

.. luego, en otro lugar, digamos que ya tiene un par de puntos en los que quiere usar esto, use el constructor de esta manera:

Point p1 = new Point(2,2);
Point p2 = new Point(4,4);
Point midpoint = new Point(p1, p2);

y si realmente quieres una distancia entre dos puntos, ese no es realmente un atributo de ninguno de los puntos, por lo que tiene sentido usar un método estático para eso, así

public static double distance(Point a, Point b)
{
double dx = a.x - b.x;
double dy = a.y - b.y;
return Math.sqrt(dx * dx + dy * dy);
}

y de vuelta en el código de llamada, puedes usarlo de esta manera:

Point p1 = new Point(2,2);
Point p2 = new Point(4,4);
System.out.println("Distance between them is " + Point.distance(p1, p2));

Answer 2

En tu segunda clase, parece que estás tratando de establecer los valores de x e y que se usan para construir tu variable mp . Todas sus fórmulas son correctas, pero debe considerar el orden en que se ejecuta todo. En el código tal como está, está creando las variables x e y , que comienzan como 0, luego los diversos Point s. x e y siguen siendo 0, por lo que mp se establece en Point(0, 0) .

Lo que probablemente desee hacer es cambiar el tipo de retorno del midpoint a Point , de modo que cuando llame a esa función, recupere un Point . Luego, puede crear un nuevo objeto Point con los valores que calcula. Debería verse más como esto:

public Point midpoint() {
// calculate the middle x and y
double x = (p1.getX() + p2.getX()) / 2;
double y = (p1.getY() + p2.getY()) / 2;
// now make a new Point with those values, and return it
return new Point(x, y);
}

Answer 3

La distancia entre dos puntos (x1, y1) y (x2, y2) en una superficie plana es:

 ____________________
/ 2 2
// (y2-y1) + (x2-x1)

Pero, si todo lo que desea es el punto medio de sus dos puntos, debe cambiar su función de punto medio para:

public Point midpoint (Point p1, Point p2) {
return new Point ((p1.getX() + p2.getX()) / 2, (p1.getY() + p2.getY()) / 2);
}

Esto devolverá un nuevo objeto de punto con los puntos establecidos en el medio de los dos puntos dados (sin tener que preocuparse por ningún otro cálculo). Y, dado que su segunda clase es una línea, solo necesita los dos puntos finales para describirla, así que haría algunos cambios menores.

Primer Point.java :

class Point {
double x, y;
Point (double xcoord, double ycoord) {
this.x = xcoord;
this.y = ycoord;
}
public double getX() { return x; }
public double getY() { return y; }
}

Entonces Line.java :

public class Line {
Point p1, p2;
Line (Point point1, Point point2) {
this.p1 = point1;
this.p2 = point2;
}
public Point midpoint() {
return new Point ((p1.getX()+p2.getX())/2, (p1.getY()+p2.getY())/2);
}
public double abstand() {
return Math.sqrt(
(p1.getX() - p2.getX()) * (p1.getX() - p2.getX()) +
(p1.getY() - p2.getY()) * (p1.getY() - p2.getY())
);
}
static public void main (String args[]) {
Line s = new Line (new Point(2.0, 2.0), new Point(5.0, 6.0));
Point mp = s.midpoint();
System.out.println ("Midpoint = (" + mp.getX() + "," + mp.getY() + ")");
double as = s.abstand();
System.out.println ("Length = " + as);
}
}

Estos dos archivos, cuando se compilan y ejecutan con los puntos finales 2,2 y 5,6 (la hipotenusa de un triángulo clásico en ángulo recto de 3/4/5) generan el correcto:

Midpoint = (3.5,4.0)
Length = 5.0

Answer 4

Puedes usar una función matemática para esto:

public Point midpoint() {
//Calculate the difference between the old and new x/y
double dx = p1.getX() - p2.getX();
double dy = p1.getY() - p2.getY();
double newX = Math.pow(dx, 2D);
double newY = Math.pow(dz, 2D);
return new Point(newX, newZ);
}

Math.pow maneja los problemas con valores negativos, etc. Para usted, usar Math.pow le brinda un método seguro porque tiene muchos controles integrados.

Answer 5

Pythag simple ... raíz (dx ^ 2 + dy ^ 2)

Math.sqrt(Math.pow((p2.getX() - p1.getX()), 2) + Math.pow((p2.getY() - p1.getY()), 2))

Answer 6

Puedes usar el Teorema de Pitágoras , como se ha dicho. Aquí hay una demostración visual del proyecto de demostración de Wolfram .

alt text http://demonstrations.wolfram.com/DistanceBetweenTwoPoints/HTMLImages/index.en/popup_5.jpg

Answer 7

 X
+
|/
| /
a| /c
| /
| /
+-----+
b Y

Imagina que X e Y son tus puntos en una superficie plana. Entonces a es Xy - Yy y b es Yx - Xx . La longitud de c es su distancia, y es la longitud de la hipotenusa de ese triángulo. Se calcula utilizando

sqrt(a^2 + b^2);

Como ves que estamos cuadrando a y b , el signo de ellos no es relevante, se reducirá a lo mismo. Así que este método siempre funciona, donde quiera que estén los puntos.

Buscar el Pythagorean theorem