Cálculo de la distancia entre dos puntos

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 Punkt { 

    public double x; 
    public double y; 

    Punkt(double xkoord, double ykoord){ 
     this.x = xkoord; 
     this.y = ykoord; 
    } 

    public double getX() { 
     return x; 
    } 

    public double getY() { 
     return y; 
    }  
} 

La segunda clase.

package org.totalbeginner.tutorial; 
public class Strecke{ 

    double x; 
    double y; 

    Punkt p1 = new Punkt(2.0,2.0); 
    Punkt p2 = new Punkt(4.0,4.0); 
    Punkt mp = new Punkt(x,y); 

    public void mittelpunkt(){ 
     x = (p1.getX() + p2.getX())/2; 
     y = (p1.getY() + p2.getY())/2; 
    } 
} 

No estoy seguro de cómo conseguir un objeto de punto (el punto medio) entre los dos puntos definidos.

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

Answer 1

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

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

Pero, si lo que quieres es el punto medio (mittelpunkt) de sus dos puntos, debe cambiar su función de punto medio a:

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

Esto devolverá un nuevo objeto puntual con los puntos establecidos en el medio de los dos puntos dados (sin tener que preocuparse por ninguna otra matemática). Y, como su segunda clase es una línea, solo necesita los dos puntos finales para describirla, así que haría algunos cambios menores.

Primera Punkt.java (Punto):

class Punkt { 
    double x, y; 
    Punkt (double xkoord, double ykoord) { 
     this.x = xkoord; 
     this.y = ykoord; 
    } 
    public double getX() { 
     return x; 
    } 
    public double getY() { 
     return y; 
    } 
} 

Entonces Strecke.java (Línea):

public class Strecke { 
    Punkt p1, p2; 
    Strecke (Punkt punkt1, Punkt punkt2) { 
     this.p1 = punkt1; 
     this.p2 = punkt2; 
    } 
    public Punkt mittelPunkt() { 
     return new Punkt ((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[]) { 
     Strecke s = new Strecke (new Punkt(2.0, 2.0), new Punkt(5.0, 6.0)); 
     Punkt mp = s.mittelPunkt(); 
     System.out.println ("Midpoint = (" + mp.getX() + "," + mp.getY() + ")"); 
     double as = s.abstand(); 
     System.out.println ("Length = " + as); 
    } 
} 

Estos dos archivos, una vez recopilados y correr con los criterios de valoración 2,2 y 5,6 (la hipotenusa de un clásico Triángulo rectángulo 3/4/5), genere el correcto:

Midpoint = (3.5,4.0) 
Length = 5.0 

Answer 2

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 3

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

Imagine X y Y son sus puntos sobre una superficie plana. Entonces a es X.y - Y.y y b es Y.x - X.x. 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); 

Desde que se ve que están en armonía con a y b, el signo de ellos no es relevante - que se reducirá a la misma. Entonces, este método siempre funciona, dondequiera que estén los puntos.

de búsqueda de la Pythagorean theorem

Answer 4

que enseñan el teorema de Pitágoras en la escuela secundaria temprano aquí. Existe una buena posibilidad de que todo lo que aprendió en matemáticas sea útil en informática en algún momento.

Answer 5

Puede usar el Teorema de Pitágoras, como se dijo.Aquí hay una demostración visual del Wolfram Demostration Project.

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

Answer 6

lo que realmente necesita la distancia, o está tratando de obtener sólo el punto medio? Debido a su fragmento de código, parece que solo quiere crear un nuevo punto que se encuentra 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, 'Strecke') para lograr eso. Ya que lo que está tratando de encontrar es también un punto, tiene sentido añadir un constructor para la clase de punto existente, como así ..

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

.. entonces, en otro lugar digamos que ya tiene un par de puntos desea utilizar este encendido, utilice el constructor de este modo:

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

y si realmente desea medir la distancia entre dos puntos, que en realidad no es un atributo de cualquiera de los puntos, por lo que tiene sentido utilizar un método estático para que, como

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

y de regreso en el código de llamada, puede utilizar de esta manera:

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

Answer 7

en su segunda clase, parece que usted está tratando de establecer los valores de x y y que se utilizan para construir su mp variable. Todas las fórmulas son correctas, pero debe tener en cuenta para que se ejecute todo. En el código tal como está, está creando las variables x y y, que comienzan como 0, luego las diversas Punkt s. x y y son todavía 0, por lo que mp se establece en Punkt(0, 0).

Lo que es probable que desee hacer es cambiar el tipo de retorno de mittelpunkt a Punkt, de manera que cuando se llama a esa función, se obtiene una vuelta Punkt. A continuación, puede crear un nuevo objeto Punkt con los valores que calcule. Debe tener un aspecto de la misma familia:

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

Answer 8

Una solución programador perezoso utilizando el java2D point API

Answer 9

Se puede utilizar una función de Matemáticas para esto:

public Punkt mittelpunkt() { 
    //Calculate the difference betwen 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 Punkt(newX, newZ); 
} 

Math.pow:
mangos los problemas con valores negativos, etc. para ti.
usando Math.pow te da un método seguro porque tiene una gran cantidad de cheques construidos dentro de