2D Viereck Flächeninhalt berechnen aus Punkten mit X und Y

huwul

Hallo zusammen,

hier erstmal die Aufgabe:

http://www.fotos-hochladen.net/view/bildschirmfotoydn80jol43.png

Nun ist es so, dass ich mir die ganzen Klassen und Header schon zusammengeschrieben habe ( vorab ja wir sollen die ganzen Klassen so erstellen, bitte nicht meckern, das hilft mir nämlich auch nichts, da dies eine Vorgabe ist ) und es hakt eigentlich nur noch an der Flächenberechnung...

Die Idee ist logischerweise immer die Differenz von 2 Punkten zusammen zunehmen ( Länge ) und dann mit der Differenz der anderen beiden Punkte zu multiplizieren, allerdings habe ich noch nicht so den Einblick wie dies mit den Punkten funktioniert. Hinzuzufügen noch, natürlich mit dem Betrag der jeweiligen Länge, da ein Flächeninhalt positiv sein sollte.

Ich hänge mal die ganzen Quellcodes hintendran:

main.cpp

#include<iostream>
#include "Tetragon.h"

int main()
{

  Tetragon viereck(Point2D(0,0), Point2D(1,1), Point2D(1,0), Point2D(0,1));
  std::cout << viereck.getArea() << std::endl;

  return 0;
}

Ngon.h

#ifndef __NGON_H__
#define __NGON_H__

#include<iostream>
#include<vector>
#include"Point2D.h"

class Ngon {

 protected: 
  std::vector<Point2D> points; /**< Vector of 2D points representing the n-gon */

 public:

  /** add a 2D point given as point or by ascissa and ordinate to an existing n-gon */

  void addPoint(Point2D p) { points.push_back(p); }
  void addPoint(double x, double y) { addPoint(Point2D(x,y)); }

  /** output all registered points of the n-gon */
  void print_points() {
    for (unsigned int i=0; i < points.size(); i++) {
      std::cout << points[i]<< std::endl;
    } 
  }
};

#endif /* __NGON_H__ */

Point2D.h

#ifndef __POINT2D_H__
#define __POINT2D_H__

class Point2D {

  double x, y; /**< x and y coordinate of point */

public:

  /** Standard Constructor will instantiate the coordinate origin */

  Point2D() { x=0.0; y=0.0; }

  /** Construct a point from x and y coordinates  */

  Point2D(double xx, double yy) : x(xx), y(yy) {};

  /** Getter for the abscissa and the ordinate */

  double getX() { return x; }
  double getY() { return y; }

  /** define output operator */

 friend std::ostream& operator<<(std::ostream& stream, Point2D p) {    
    stream <<  "(" << p.getX() << ", " << p.getY() << ")";
    return stream;
  }

  /** 2D vector addition */
  Point2D operator+(const Point2D& p2)
  {
    Point2D p1;
    p1.x = p2.x + x;
    p1.y = p2.y + y;
    return p1;
  }

  /** 2D vector subtraction */
  Point2D operator-(const Point2D& p2)
  {
    Point2D p1;
    p1.x = p2.x - x;
    p1.y = p2.y - y;
    return p1;
  }

};
#endif /*__POINT2D_H__ */

Tetragon.cpp

#include"Triangle.h"
#include<cstdlib>
#include<cmath>
#include "Tetragon.h"

double Tetragon::getArea() {

  Point2D u(points[a] - points[b]);
  Point2D v(points[d] - points[c]);
  return  0;  
}

Tetragon.h

#include<iostream>
#include<vector>
#include"Ngon.h"

class Tetragon : public Ngon {

 public:

  /** constructs a 4-gon by adding 4 points  to the n-gon*/

  Tetragon(Point2D a, Point2D b, Point2D c, Point2D d) {
    addPoint(a);
    addPoint(b);
    addPoint(c);
    addPoint(d);
  }

  /** computes the area of the tetragon */

  double getArea();
};

DocShoe

Und was genau ist die Frage?

Erster Hinweis:
Du hast die Aufgabe nicht genau verstanden. In der Aufgabe steht sogar, dass das Viereck kein Rechteck sein muss, sondern ein beliebiges Viereck sein kann (z.B. ein Trapez). Damit ist die Flächenberechnung Länge x Breite nicht immer korrekt.

huwul

Die genaue Frage ist, wie ich mit diesen vorgegebenen Punkten rechnen kann?

wir hatten mal eine Dreiecksfunktion in der stand:

Point2D u(points[1] - points[0]);
  Point2D v(points[2] - points[0]);
  return 0.5 * fabs ( u.getX() * v.getY() - u.getY() * v.getX() );

und darin verstehe ich das points[1] etc. schon nicht...

kleiner Zusatz edit:

Flächeninhalt wäre ja dann:

A=(1/2)|[(x3-x1)(y4-y2) +(x4-x2)(y1-y3)]|

huwul schrieb:

Die genaue Frage ist, wie ich mit diesen vorgegebenen Punkten rechnen kann?

wir hatten mal eine Dreiecksfunktion in der stand:
Point2D u(points[1] - points[0]);
  Point2D v(points[2] - points[0]);
  return 0.5 * fabs ( u.getX() * v.getY() - u.getY() * v.getX() );
und darin verstehe ich das points[1] etc. schon nicht...

points[i] ist der (i + 1)-te Point2D, der mit der Methode addPoint() (siehe Konstruktor von Tetragon ) hinzugefügt wurde. Bei points[1] ist das zweite, also für dein Viereck, dass du in main() erzeugt hast der Point2D(1,1) .

points[1] - points[0] ist Vektorarithmetik. Der Vektor von Punkt 1 wird hier von dem von Punkt 2 subtrahiert. Für die Punkte deines Vierecks entspricht der Ausdruck Point2D u(points[1] - points[0]); also mathematisch ausgedrückt $u := \begin{pmatrix}1\\1\end{pmatrix} - \begin{pmatrix}0\\0\end{pmatrix}$

Was die Berechnung der Fläche angeht, hilft dir vielleicht der Tip, dass man ein Viereck aus zwei Dreiecken zusammensetzen kann, bzw. ein gegebenes Viereck auch wieder ein zwei Dreiecke zerlegen kann

Gruss,
Finnegan

Werner Salomon

huwul schrieb:

Die genaue Frage ist, wie ich mit diesen vorgegebenen Punkten rechnen kann?

wir hatten mal eine Dreiecksfunktion in der stand:
Point2D u(points[1] - points[0]);
  Point2D v(points[2] - points[0]);
  return 0.5 * fabs ( u.getX() * v.getY() - u.getY() * v.getX() );

.. riecht doch nach Gaußscher Dreiecksformel siehe auch bei den Polygonflächen.

huwul

Danke für die points[] erklärung das hat mir schonmal sehr weitergeholfen:

#include"Triangle.h"
#include<cstdlib>
#include<cmath>
#include "Tetragon.h"

double Tetragon::getArea() {

  Point2D u(points[0] );
  Point2D v(points[1] );
  Point2D s(points[2] );
  Point2D t(points[3] );
  return  0.5 * fabs ((s.getX() - u.getX())*(t.getY() - v.getY())+(t.getX() - v.getX())*(u.getY() - s.getY()));  
}

So berechnet er richtigerweise den Flächeninhalt (da karthesisches Koord.sys.)

Mir stellt sich nur noch die Frage der Aufgabenstellung wie folgendes gemeint ist:

"Stellen Sie sicher dass ein Viereck nur konstruiert werden kann, wenn 4 Punkte angegeben werden."

Diese werden doch allerdings sowieso in der main.cpp in der Instanz erst eingefügt, sollten es nur 3 sein meckert der Compiler sowieso und sollten es 5 sein, ebenfalls, da in der Header-Datei nur 4 Punkte erstellt werden und in der zugehörigen .cpp wird mit mindestens 4 gerechnet...

Hab ich da jetzt irgendetwas falsch verstanden, oder ist damit gemeint, dass ich per cin, eine Eingabe der Punkte machen soll und dort nur 4 Punkte erstellt werden dürfen?

BTK

Hallo lieber Kommilitone

Nein, mit cin brauchst du (meines Verständnisses nach) nichts zu tun. Selbst wenn wüsste ich nicht wie man Ärger durch den Compiler umgehen kann. Das ist ja das tolle an Klassen da der Konstruktor klar definiert ist, ist Missbrauch ausgeschlossen.

P.S: berechnet deine getArea() Funktion denn auch den Flächeninhalt von überlappenden Vierecken? Also die die aussehen wie eine Fliege/Schleife (Kleidungsstück)? Das ist nämlich aktuell mein Problem, und ich gehe davon aus das wir auch diese Art von Vierecken berechnen können sollen.

Grüße aus Aachen nach Aachen