Prostokąt powiększony względem środka

Witam,

Mam do napisania takie zadanie:
Napisać metodę powiększającą prostokąt o zadaną dodatnią wielokrotność względem jego środka. Jeśli parametr powiększenia jest niedodatni, prostokąt ma nie ulec zmianie.

Teraz dostałem taką wskazówkę, jak to rozwiązać:
"Wektorowo. Znajdź środek O przekątnej i weź odpowiednią wielokrotność wektora OA (A - wierzchołek)."

Zacząłem rozwiązywać tak:

• Mam przekątną AD o takich współrzędnych:
  A(2, -8)
  D(7, -11)

• Współrzędna O (środek prostokąta) obliczyłem:
  O = [(2 + 7) / 2, (-8 + (-11)) / 2]
  O = [4,5, -9,5]

• Wektor OA
  wektor OA = [2 - 4,5, -8 -(-9,5)]
  wektor OA = [-2,5, 1,5]

Czy teraz wystarczy pomnożyć wektor OA przez liczbę?
Czyli wektor OA = [-2,5 * parametr, 1,5 * parametr]

Kod jaki udało mi się napisać:

 
class Prostokat
{
private:
    double przekatnaAx; 
    double przekatnaAy;
    double przekatnaDx;
    double przekatnaDy;
public:
    void PowiekszenieProstkata(double paramPowiekszeniaProstokata)
    {
        // wspolrzedna x srodka prosotkata
        double srodekOx = (przekatnaDx + przekatnaAx) / 2; 
        // wspolrzedna y srodka prostokata
        double srodekOy = (przekatnaAy + przekatnaDy) / 2;
        cout << srodekOx << endl;
        cout << srodekOy << endl;
        // wektor OA
        double wektorOAx = (przekatnaAx - srodekOx);
        double wektorOAy = (przekatnaAy - srodekOy);
        cout << wektorOAx << endl;
        cout << wektorOAy << endl;
        double przesunietyX = (wektorOAx * paramPowiekszeniaProstokata);
        double przesunietyY = (wektorOAy * paramPowiekszeniaProstokata);
        cout << przesunietyX << endl;
        cout << przesunietyY << endl;
    }
};

Twój kod nie zmienił prostokąta, składowe przekatnaAx, przekatnaAy,... muszą się zmienić.
Kod winien wyglądać tak:

class Prostokat
{
private:
    double przekatnaAx; 
    double przekatnaAy;
    double przekatnaDx;
    double przekatnaDy;
public:
    void PowiekszenieProstkata(double paramPowiekszeniaProstokata)
    {
        if(paramPowiekszeniaProstokata<0.0)
            return;
        // wspolrzedna x srodka prosotkata
        double srodekOx = (przekatnaDx + przekatnaAx) / 2;
        // wspolrzedna y srodka prostokata
        double srodekOy = (przekatnaAy + przekatnaDy) / 2;
        przekatnaAx=srodekOx+paramPowiekszeniaProstokata*(przekatnaAx-srodekOx);
        ...
    }
};

Czyli nie wystarczy pomnożyć parametru
(paramPowiekszeniaProstokata * wektor OAx)
(paramPowiekszeniaProstokata * wektor OAy)

gdzie:
wektor OAx = przekatnaAx - srodekOx
wektor OAy = przekatnaAy - srodekOy
?

Zastanawia mnie ta dodana srodekOx itd.

Zmodyfikowałem kod o klasę Punkt

 
#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;
        przekatnaA.x=srodekOx+paramPowiekszeniaProstokata*(przekatnaA.x-srodekOx);
        przekatnaA.y=srodekOy+paramPowiekszeniaProstokata*(przekatnaA.y-srodekOy);
        
        cout << przekatnaA.x << endl;
        cout << przekatnaA.y << endl;
    }
// ...
};

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