ich hab ein problem und zwar... bekomme ich durch ein Tracking system bis zu 4 geometrische Punkte geliefert in einem vector x und vector y. Die punkte gehören immer zusammen also x[i] und y[i]. Wenn ich 4 Punkte bekomme ergeben diese ein viereck das sich aber um 360° rotieren kann also kann man nicht davon ausgehen das der Punkt oben links bei 0,0 liegt, bzw den kleinsten x und den kleinsten y Wert hat. Deswegen muss ich in abhängigkeit zu x und y sortieren so das Punkt 0 der punkt "oben links" ist punkt 1 der punkt "oben rechts" punkt 2 "unten links" ist und so weiter. Dabei tracke ich aber immer ein 4eck kann aber nie mit Garantie sagen das ich auch alle 4 Eckpunkte bekomme.

Das ganze hatte ich angefangen in dem ich die beiden vectoren versucht habe zu sortieren und dabei die kriterien beachtet habe, das artet aber wahrscheinlich in einem rießen code aus und ist von der Programmierung her auch sehr schlecht.

Nun meine Frage ist gibt es vllt einen vorgefertigten Container in C++ der das für mich machen könnte oder hat jemand eine Idee wie man das sinnvoller lösen kann?

Schon mal Vielen Dank im Voraus.

Mfg
Ambroxol

Edit:
Um das ganze vielleicht etwas klarer zu gestalten bekomme ich dann z.B diese 4 Punkte
0 = 499,111
1 = 179,386
2 = 173,105
3 = 502,379
Das "Gemälde" dazu würde dann ca so aussehen:
|---------->x
|*2 *0
|
|
|*1 *3
|
v
y

Und das will ich dann so sortieren und in einen container schieben das der Punkt oben links der derzeit punkt 2 ist dann punkt 0 ist und punkt 0 dann 1 und so weiter.

Wenn Du Dir zwei Diagonalen (unter 45°) durch Dein Koordinatensystem gezogen denkst, könnte man jeweils den Punkt herausfinden, der am weitesten von der jeweiligen Diagonalen entfernt in Richtung der gewünschten Ecke liegt. Berechnen lässt sich der Abstand leicht mit der Hesseschen Normalform und Raussuchen geht mit dem Algorithmus max_element aus dem C++-Standard.

Hier mein Vorschlag unter Zuhilfenahme des ersten Links auf den Vector (s.o.)

#include "Vektor.h"
#include <algorithm>    // copy, max_element
#include <cassert>
#include <iterator>     // ostream_iterator
#include <iostream>
#include <vector>
using namespace std;

struct Ebene    // Ebene in der Hesseschen Normalform
{
    explicit Ebene( const Vector& n, double d = 0.0 )
        : m_n( n ) 
        , m_d( d )
    {}
    // liefert 'true' wenn 'p1' mehr unterhalb der Ebene liegt als 'p2'
    bool operator()( const Vector& p1, const Vector& p2 ) const
    {
        return p1 * m_n < p2 * m_n;
    }
private:
    Vector m_n;
    double m_d; // Bem.: wird hier nicht benötigt!
};

std::vector< Vector > sortRechteck( std::vector< Vector > quadriga )
{                       // Bem.: Übergabe des Parameters per copy, da er intern verändert wird
    assert( quadriga.size() == 4 );
    // hier wird definiert was oben und unten im Sinne von x und y bedeutet
    const double LINKS = -1;        // x - Richtung
    const double RECHTS = +1;
    const double OBEN = -1;         // y - Rchtung; Bem.: y zeigt nach unten
    const double UNTEN = +1;

    vector< Vector > ecken(4);
    // hier wird die Reihenfolge der Punkte festgelegt
    ecken[0] = Vector( LINKS, OBEN );
    ecken[1] = Vector( RECHTS, OBEN );
    ecken[2] = Vector( RECHTS, UNTEN );
    ecken[3] = Vector( LINKS, UNTEN );

    vector< Vector > sortiertePunkte;   // Ergebnis
    for( vector< Vector >::iterator iEcke = ecken.begin(); iEcke != ecken.end(); ++iEcke )
    {
        // '*i' ist der Punkt, der am nächsten in Richtung der Ecke '*iEcke' liegt.
        vector< Vector >::iterator i = std::max_element( quadriga.begin(), quadriga.end(), 
            Ebene( *iEcke ) );
        sortiertePunkte.push_back( *i );
        quadriga.erase( i );    // Löschen, damit kein Punkt zweimal vorkommt!
    }
    return sortiertePunkte;
}

int main()
{
    // --   Satz Beispieldaten
    vector< Vector > punkte(4);
    punkte[0] = Vector( 499, 111 );
    punkte[1] = Vector( 179, 386 );
    punkte[2] = Vector( 173, 105 );
    punkte[3] = Vector( 502, 379 );

    // --   Sortierung nach Rechteck ausführen
    vector< Vector > sortiert = sortRechteck( punkte );

    // --   Ergebnis ausgeben
    copy( sortiert.begin(),  sortiert.end(),
        ostream_iterator< Vector >( cout << "Die sortierte Reihenfolge: \n", "\n" ) );

    return 0;
}

Die Ausgabe dieses Programms ist:

Die sortierte Reihenfolge:
173 105 0
499 111 0
502 379 0
179 386 0

ich nehme an, das ist das, was Du wolltest.

Gruß
Werner

Bin aber dann noch auf ne andere Idee gekommen die zum glück auch gut funtioniert und zwar kann ich die Punkte in den Ursprung transformieren, die dort rotieren und dann die Punkte anhand ihrer Quadranten zuordnen.