# Umfang berechnen für Polygone



## Brexoi (19. Mai 2015)

Hallo liebe Community,

ich hab eine Klasse namens Polygone:


```
import java.util.Arrays;

public class Polygon {
   private String bezeichnung;
   private Punkt[] eckpunkte;

   public Polygon() {
     eckpunkte = new Punkt[0];
     this.bezeichnung = "Testpoly ";
   }
 
   public Polygon(Punkt[] eckpunkte, String bezeichnung) {
     this.eckpunkte = eckpunkte;
     this.bezeichnung = bezeichnung;
   }

   public Polygon(Punkt[] eckpunkte) {
     this.eckpunkte = eckpunkte;
     this.bezeichnung = "";
   }
 
   public Punkt[] getEckpunkte() {
     return eckpunkte;
   }
 
   public int getAnzahlEcken() {
     return eckpunkte.length;
   }
 
   public void setEckpunkte(Punkt[] eckpunkte) {
     this.eckpunkte = eckpunkte;
   }
 
   public double[] berechneSeitenlaengen() {
     return new double[eckpunkte.length]; 
   }
 
   public double berechneUmfang() {
    return 0;
   }
 
   @Override
   public String toString() {
       return bezeichnung + 
               "mit N= " + getAnzahlEcken() + 
               ", U= " + berechneUmfang() +
               " und den Koordinaten P=" +Arrays.toString(eckpunkte);
   }
}
```

wie kann ich nun die Seitenlänge und den Umfang berechnen? Wüsste nicht wie ich das in den return abschnitt schreiben soll,..

Danke


----------



## Flown (19. Mai 2015)

Die Formel findest du hier: WIKI.

Du iterierst über deine Punkte und bildest die Kantenlängen, die du dann in dein Array speicherst und zurücklieferst.

Bei der Umfangberechnung holst du dir das Array mit den Kantenlängen und summierst sie auf.


----------



## Brexoi (19. Mai 2015)

Ich kann leider den Anhang den du bereitgestellt hast nicht sehen,..


----------



## Flown (19. Mai 2015)

Ah ok ich seh schon Bilder mag er gerade nicht Uploaden:


----------



## Brexoi (19. Mai 2015)

Danke dir, die formel unter Wicki kenn ich bereits, mein Problem ist eher, das ich bemerkt habe, das mir eine Methode für den Abstand noch fehlt um den Abstand 2er Punkte zu berechnen, ausserdem weiss ich gerade nicht was ich in die Formel "reinpacken" muss um das ergebnis zu bekommen,..
Es ist vielleicht etwas viel verlangt, aber könntest du mir vielleicht anhand meines Codes eine passende Methode für den Abstand sowie die berechnung der Seitenlänge und Umfang zeigen?

Ich meine (vermute) das ich weiss wie das geht, aber nicht niederschreiben kann.
Ich bräuchte zur berechnung der Seitenlänge zwei Koordinaten sprich A und B die Seitenlänge währe ja dann
 AB = Wurzel (B1 - A1)² + (B2 - A2)²

Wenn ich das habe kann ich deine Formel dann auch benutzen (glaub ich)
Mein Problem liegt eher darin, das ich nicht gerade genau weiss, wie ich das ganze niederschreibe und einfüge, 
da kommt noch hinzu das meine Koordinaten/Punkte ("Seitenlänge") in einer anderen Klasse sind und ich nicht weiss (vielleicht mit Super, hab ich gelesen,..) wie ich diese in die andere Klasse bekomme,.. falls mein gedankengang soweit überhaupt richtig ist,..


----------



## Flown (19. Mai 2015)

Du kannst einen Pseudocode von mir haben. Ein wenig Eigeninitiative ist schon gefragt:

```
def berechneSeitenlaengen() : double[] = {
  var result = new double[eckpunkte.length];
  for(i from 0 to result.length) {
    var dx = eckpunkte[(i + 1) % eckpunkte.length].x - eckpunkte[i].x;
    var dy = eckpunkte[(i + 1) % eckpunkte.length].y - eckpunkte[i].y;
    result[i] = Math.sqrt(dx * dx + dy * dy);
  }
  return result;
}
```

Und zur Umfangsberechnung:

```
def berechneUmfang() : double = {
  var sum = 0d;
  for(d in berechneSeitenlaengen()) {
    sum += d;
  }
  return sum;
}
```


----------



## Brexoi (19. Mai 2015)

Na dann probier ich es mal, habe die berechnung für den Umfang soweit fertig:

```
public double berechneUmfang() {
    double umfang = 0;
    for (int i=0; i<eckpunkte.length-1; i++)
    {
    umfang += eckpunkte[i].abstand(eckpunkte[i+1]);
    }
    return umfang;
}
```

Mein Problem liegt immer noch bei der Seitenlänge

```
public double[] berechneSeitenlaengen(){
     double[] result = new double[eckpunkte.length]; 
       int i;
     for (i from 0 to result.lenght) {
     double deltax = eckpunkte[(i + 1) % eckpunkte.lenght].x - eckpunkte[i].x;
     double deltay = eckpunkte[(i + 1) % eckpunkte.lenght].y - eckpunkte[i].y;
     result[i] = Math.sqrt(deltax * deltax + deltay *deltay);
   }
     return result;
   }
```

Ich verstehe nur nicht warum er mir .lenght aufeinmal als fehler anzeigt,..


----------



## Flown (19. Mai 2015)

for-Schleifen haben den Aufbau:

```
for(int i = 0; i < arr.length; i++) {
  ...
}
```

Deine Umfangsberechnung ist nicht richtig!


----------



## Brexoi (19. Mai 2015)

Flown hat gesagt.:


> for-Schleifen haben den Aufbau:
> 
> ```
> for(int i = 0; i < arr.length; i++) {
> ...



es lag alles an dem len*ght* ...
Warum falsch? Ich hab mich schon gefreut das alles inordnung scheint,.. und ich nur noch die methode abstand bearbeiten muss,..


----------



## Flown (19. Mai 2015)

Es ist falsch weil wie in der Formel oben, der letzte Punkt nicht mit dem ersten dazugerechnet wird (ist ja keine Linie, sondern ein Polygon). Darum hab ich in meinem Code ja das Modulo drinnen, der mir den Letzten auch noch dazunimmt.


----------



## Brexoi (19. Mai 2015)

Flown hat gesagt.:


> Es ist falsch weil wie in der Formel oben, der letzte Punkt nicht mit dem ersten dazugerechnet wird (ist ja keine Linie, sondern ein Polygon). Darum hab ich in meinem Code ja das Modulo drinnen, der mir den Letzten auch noch dazunimmt.



Was ist den ein Modulo  ?

Ps: vielleicht sollte ich erwähnen das ich recht frisch in der Java Welt bin und das mein 2tes übungsprogram ist, bin auch noch dabei das Buch "Java ist auch eine Insel" zu lesen,..


----------



## Flown (19. Mai 2015)

Wenn du das Inselbuch lest, dann kannst du es auch Nachschlagen: HIER unter Der Restwert-Operator %.

Aber das muss man ja nicht mit Modulo machen sondern du kannst 1:1 die Formel, die ich oben von Wikipedia übernommen habe, verwenden.

Aber wie gesagt, dir fehlt die letzte Strecke vom letzten Punkt zum Anfangspunkt.


----------



## Brexoi (19. Mai 2015)

Wenn ich deine Formel 1:1 übernehme wird alles bei mir rot angezeigt, und genau diese letzte strecke bekomme ich einfach nicht hin, genauso wenig wie ich die Formel die ich für die abstand methode habe nicht niederschreiben kann weil ich nicht weiss welche punkte/koordinaten nutzen soll ...


----------



## Flown (19. Mai 2015)

Wie sieht deine Punktklasse aus?


----------



## Brexoi (19. Mai 2015)

```
public class Punkt {
    
   private final static int maxpos = 1023;
   private int xpos;
   private int ypos;
    double x,y;

   public Punkt(int xpos, int ypos) {
     this.xpos = xpos;
     this.ypos = ypos;
     
    if(xpos<0) {
    this.xpos = 0;
  } else if(xpos>maxpos) {
    this.xpos=maxpos;
  } else {
    this.xpos=xpos;
  }
   if(ypos<0) {
    this.ypos = 0;
  } else if(xpos>maxpos) {
    this.ypos=maxpos;
  } else {
    this.ypos=ypos;
  }
   }

   public Punkt() {
     this.xpos = 511;
     this.ypos = 511;
      }

   public int getXpos() {
     return this.xpos;
   }

   public void setXYpos(int xpos, int ypos) {
     this.xpos = xpos;
     this.ypos = ypos;
   }

   public int getYpos() {
     return this.ypos;
   }

   public Punkt verschiebeUm(int deltax, int deltay) {
     return new Punkt(xpos + deltax, ypos + deltay);
   }

   public Punkt verschiebeUm(Punkt deltaxy) {
     return new Punkt(xpos + deltaxy.xpos, ypos + deltaxy.ypos);
   }

   public String toString() {
     return "(" + xpos + "," + ypos + ")";
   }
 
   public double abstand(Punkt B) {
        return new Punkt Math.sqrt(this.x-this.x) * (this.x-this.x) + (this.y-this.y) * (this.y-this.y); //<<-- daran arbeite ich gerade bzw probiere rum
        
    }
   
}
```


----------



## Flown (19. Mai 2015)

```
public double berechneAbstand(Punkt other) {
  double dx = other.xpos - xpos;
  double dy = other.ypos - ypos;
  return Math.sqrt(dx*dx + dy*dy);
}
```

Der Code steht doch schon da für die Abstände!


----------



## Brexoi (19. Mai 2015)

Danke dir vielmals, jetzt bekomme ich zwar ein ergebnis in der Ausgabe für den Umfang aber der letzte Punkt fehlt halt noch,..
Siehst du anhand des Codes warum ich deine formel nicht 1:1 übernehmen kann?


----------



## Flown (19. Mai 2015)

Es steht doch alles schon da was du brauchst!


```
public double berechneUmfang() {
  double umfang = 0d;
  for (int i=0; i<eckpunkte.length; i++) {
    umfang += eckpunkte[i].abstand(eckpunkte[(i+1) % eckpunkte.length]);
  }
  return umfang;
}
```


----------



## Brexoi (19. Mai 2015)

Tut mir leid ich weiss nicht was ich stehen oder falsch hatte, hatte eigentlich gedacht ich hab es genau wie du so stehen gehabt, hab aber eine andere Ausgabe gehabt als eigentlich sein sollte, deswegen war ich etwas irrittiert, ich hab es nun so 1:1 übernommen und es klappt  Danke!


----------

