Dodawanie dwóch prostokątów

0

Witam,

Mam do napisania takie zadanie:
"Napisać metodę dodawania dwóch prostokątów. Nowy prostokąt powinien być najmniejszym obejmującym swoim polem dwa dodawane prostokąty".

Napisałem taki kod - metoda DodawanieDwochProstokatow().
Prostokąt pierwszy ma pole 15, drugi 60. Metoda zwraca wynik 75.


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

using namespace std;

class Punkt
{
public:
    double x;
    double y;
};

class Prostokat
{
private:
    Punkt przekatnaA; 
    Punkt przekatnaD;
public:
    // ustaw przekątną A i D
    void Ustaw1(double aPrzekatnaA, double aPrzekatnaAy, 
                double aPrzekatnaDx, double aPrzekatnaDy)
    {
        przekatnaA.x = aPrzekatnaA;
        przekatnaA.y = aPrzekatnaAy;
        przekatnaD.x = aPrzekatnaDx;
        przekatnaD.y = aPrzekatnaDy;
    }

    void PowiekszenieProstkata(double paramPowiekszeniaProstokata)
    {
        if (paramPowiekszeniaProstokata < 0.0)
            return;
        // wspolrzedna x srodka prosotkata
        double srodekOx = (przekatnaD.x + przekatnaA.x) / 2; 
        // wspolrzedna y srodka prostokata
        double srodekOy = (przekatnaA.y + przekatnaD.y) / 2;
        // wspolrzedna A` powiekszonego prostokata
        przekatnaA.x=srodekOx+paramPowiekszeniaProstokata*(przekatnaA.x-srodekOx);
        przekatnaA.y=srodekOy+paramPowiekszeniaProstokata*(przekatnaA.y-srodekOy);
        // wspolrzedna D` powiekszonego prostokata
        przekatnaD.x = srodekOx + paramPowiekszeniaProstokata * (przekatnaD.x - srodekOx);
        przekatnaD.y = srodekOy + paramPowiekszeniaProstokata * (przekatnaD.y - srodekOy);
    }

    double DodawanieDwochProstokatow()
    {   
        return abs((przekatnaD.y-przekatnaA.y) * (przekatnaD.x-przekatnaA.x)) + 
        (abs((przekatnaD.y-przekatnaA.y) * (przekatnaD.x-przekatnaA.x))) / 4;                
    }

   int _tmain(int argc, _TCHAR* argv[])
   {
       Prostokat prostokat;
       prostokat.Ustaw1(2, -8, 7, -11);
       prostokat.PowiekszenieProstkata(2);
       cout << prostokat.DodawanieDwochProstokatow();
       system("pause");
       return 0;
   }

Edit: Jednak kod nie jest poprawny. Mam obecnie współrzędne większego prostokąta, a potrzebuje
współrzędne mniejszego prostokąta, co by obliczyć jego pole, potem zsumować.

0

Ty się naucz czytać ze zrozumieniem, metoda DodajDwaProsokaty() ma zwrócić prostokąt, a nie liczbę będącą polem tego prostokąta.

0

Zmyliło mnie to "napisać metodę dodawania dwóch prostokątów".

1

Bah. Zakładając że chodzi o prostokąty równoległe do osi układu współrzędnych:
Skoro masz dwa prostokąty to masz osiem punktów. Lub cztery bo do opisania prostokątu wystarczą dwa przeciwległe punkty.
Z danego zestawu punktów wyciągasz extrema:
Max_X, Max_Y, Min_X, MinY
Tworzysz z tego punkt Max(Max_X,Max,Y) i Min(Min_X, Min Y)
Poszukiwany prostokąt jest opisany na tych dwóch punktach.
Do dzieła.

0
O_o napisał(a)

Bah. Zakładając że chodzi o prostokąty równoległe do osi układu współrzędnych:
Skoro masz dwa prostokąty to masz osiem punktów. Lub cztery bo do opisania prostokątu wystarczą dwa przeciwległe punkty.
Z danego zestawu punktów wyciągasz extrema:
Max_X, Max_Y, Min_X, MinY
Tworzysz z tego punkt Max(Max_X,Max,Y) i Min(Min_X, Min Y)
Poszukiwany prostokąt jest opisany na tych dwóch punktach.
Do dzieła.

Mając punkty:

A`(-0,5, -6,5) // wierzchołek przekątnej większego prostokąta
A(2, -8) // wierzchołek przekątnej mniejszego prostokąta

D(7, -11) // wierzchołek przekątnej mniejszego prostokąta
D`(9,5, -12,5) // wierzchołek przekątnej większego prostokąta

To max będzie A(2, -6,5) min będzie D(7, -12,5)
?

0

Blargh, weź no popraw swój post bo od czytania tego to mi się jeszcze drugie oko skurczy o_O
Łap sampel implementacji:

Rect Foo(Rect A,B)
{
    return new Rect(
      new Point( min(A.left, B.left), min(A.top, B.top)
      ,
      new Point( max( A.right, B.right), min(A.bottom, B.bottom)
    )
}
0

Kod jest skomplikowany, ale spróbuje go zastosować do mojej klasy Prostokąt.

0

Eh, pokaż no ten swój prostokąt.

0
O_o napisał(a)

Eh, pokaż no ten swój prostokąt.

Ok wstawiam kompletny kod źródłowy klasy Prostokąt i klasy Punkt


#include "stdafx.h"
#include <iostream>
#include <algorithm>

using namespace std;

class Punkt
{
public:
    double x;
    double y;
};

class Prostokat
{
private:
    Punkt przekatnaA; 
    Punkt przekatnaD;
public:
    // ustaw przekątną A i D
    void Ustaw1(double aPrzekatnaA, double aPrzekatnaAy, 
                double aPrzekatnaDx, double aPrzekatnaDy)
    {
        przekatnaA.x = aPrzekatnaA;
        przekatnaA.y = aPrzekatnaAy;
        przekatnaD.x = aPrzekatnaDx;
        przekatnaD.y = aPrzekatnaDy;
    }

    // ustaw wierzchołki B i C
    void Ustaw2(double aWierzcholekBx, double aWierzcholekAy, 
                double aWierzcholekCx, double aWierzcholekCy)
    { 
        // wierzchołek B            
        przekatnaD.x = aWierzcholekBx;
        przekatnaA.y = aWierzcholekAy;
        // wierzchołek C
        przekatnaD.y = aWierzcholekCx;
        przekatnaA.x = aWierzcholekCy;
    }

    // wierzchołek A i długośc boków a i b
    void Ustaw3(double aPrzekatnaAx, double aPrzekatnaAy, 
                double aDlugoscBokuA, double aDlugoscBokuB)
    {   
        // wierzchołek A
        przekatnaA.x = aPrzekatnaAx;
        przekatnaA.y = aPrzekatnaAy;
        przekatnaD.x = przekatnaA.x + aDlugoscBokuA;
        przekatnaD.y = przekatnaA.y + aDlugoscBokuB;
    }

    // ustaw współrzędne wierchołka A oraz dł. boków a i przekątnej c
   void Ustaw4(double aPrzekatnaAx, double aPrzekatnaAy,
                double aDlugoscBokuA, double aPrzekatnaC)
    {
        // wierzchołek A
        przekatnaA.x = aPrzekatnaAx;
        przekatnaA.y = aPrzekatnaAy;
        przekatnaD.x = przekatnaA.x+aDlugoscBokuA;
        //poniższy wzór korzysta z tw. Pitagorasa
        przekatnaD.y = przekatnaA.y+sqrt(aPrzekatnaC*aPrzekatnaC-aDlugoscBokuA*aDlugoscBokuA);
    }

    // metoda ma przesunąć prostokąt o zadany wektor
    void PrzesunOwektor(double przekatnaAxBis, double aPrzekatnaAx, double przekatnaAyBis,
                        double przekatnaDxBis, double aPrzekatnaDx, double przekatnaDyBis,
                        double aPrzekatnaDyBis, double wektorA,double wektorB)
    {
        // punkt przesunięty A`
        przekatnaA.x = przekatnaA.x + wektorA;
        przekatnaA.y = przekatnaA.y + wektorB;
        // punkt przesunięty B`
        przekatnaD.x = przekatnaD.x + wektorA;
        przekatnaAyBis = przekatnaA.y + wektorB;
        // punk przesunięty C`
        przekatnaD.y = przekatnaD.y + wektorA;
        przekatnaAxBis = aPrzekatnaAx + wektorB; 
        // punkt przesunięty D`
        przekatnaDxBis = aPrzekatnaDx + wektorA;
        przekatnaDyBis = aPrzekatnaDyBis + wektorB;
    }

    // metoda oblicza pole prostokata

    double PoleProstokata() 
    {
        return abs((przekatnaD.y-przekatnaA.y) * (przekatnaD.x-przekatnaA.x)); 
    }

    /*
    void CzyProstokatRownolegly()
    {
        if ((przekatnaAx == przekatnaAx) && (przekatnaAy == przekatnaAy)) // to przecież nie ma sensu
            cout << "Jest równoległy";
        else
            cout << "Nie jest równoległy" << endl;
    }
    */

    // metoda obliczajaca obwod prostokata
    double ObwodProstokata()
    {
        return 2 * abs(przekatnaD.x-przekatnaA.x) + 2 * abs(przekatnaD.y-przekatnaA.y);
    }

    void PowiekszenieProstkata(double paramPowiekszeniaProstokata)
    {
        if (paramPowiekszeniaProstokata < 0.0)
            return;
        // wspolrzedna x srodka prosotkata
        double srodekOx = (przekatnaD.x + przekatnaA.x) / 2; 
        // wspolrzedna y srodka prostokata
        double srodekOy = (przekatnaA.y + przekatnaD.y) / 2;
        // wspolrzedna A` powiekszonego prostokata
        przekatnaA.x = srodekOx + paramPowiekszeniaProstokata * (przekatnaA.x-srodekOx);
        przekatnaA.y = srodekOy + paramPowiekszeniaProstokata * (przekatnaA.y-srodekOy);
        // wspolrzedna D` powiekszonego prostokata
        przekatnaD.x = srodekOx + paramPowiekszeniaProstokata * (przekatnaD.x - srodekOx);
        przekatnaD.y = srodekOy + paramPowiekszeniaProstokata * (przekatnaD.y - srodekOy);
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    Prostokat prostokat;
    prostokat.Ustaw1(2, -8, 7, -11);
    prostokat.PowiekszenieProstkata(2);
    system("pause");
    return 0;
}
0

Ło boizu ale paszkudztwo :D
Piszę z palca więc mogą być drobne errory. Zrób potem dziedziczenie z tego na ten twój monstrualny prostokąt i tam dodaj te dziwadła.

// nie chce mi się myśleć ale chyba dobre ten max i min będą
public static max(double a, double b, double c, double d)
{
  double ret = a>b?a:b; ret=a>c?a:c; ret = a>d:a?d;
  return ret;
}
public static min(double a, double b, double c, double d)
{
  double ret = a<b?a:b; ret=a<c?a:c; ret = a<d:a?d;
  return ret;
}
class Punkt
{  // bloki public: są w pewien sposób "blee"
  public double x;
  public double y;
  public Punkt(double x,double y) { this.x=x; this.y=y; }
};
class Rect
{
  Punkt A,B,C,D;
  // możesz sobie dodać inne konstruktory ale ten wystarczy jako bazowy.
  public Rect(Punkt A, Punkt D)
  {
    this.A=A; this.D=D;
    B=new Punkt(A.x,D.y);
    C=new Punkt(D.y,D.x);
  }
  // można by też przeładować arytmetykę ale mi się niechce ;p
  public static Rect Add(Rect R, Rect S)
  {
    return new Rect(
      new Point(min(R.A.x,R.B.x,R.C.x,R.D.x), min(R.A.y,R.B.y,R.C.y,R.D.y))
      ,
      new Point(max(R.A.x,R.B.x,R.C.x,R.D.x), max(R.A.y,R.B.y,R.C.y,R.D.y))
    );
  }
}

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0