ich habe von einem Kunden folgende Aufgabe bekommen:

-Finden Sie auf diesem Bild die weißen Pixel, speichern Sie die Positionen (ist erledigt mit Maps)
-Nun teilen berechnen Sie die Strecke der weißen Pixel zu anderen weißen Pixel, fals Wert unter 30 ist, dann wird er nicht gespeichert
-Berechnen Sie den Winkel zwischen den Pixel die den Wert über 30 haben

Die erste Aufgabe hab ich erledigt mit CIMG. Die folgenden würd ich vom Mathematischen her auch lösen können, aber nicht vom C++-mäßigem her. Ich weiß einfach nicht wie ich den Wert der Strecke bei den Pixeln speichern soll, damit ich dann noch was anfangen kann.

Vielleicht kann mir einer von euch helfen.
Danke schon mal!

Wenn Du die Pixel schon gespeichert hast, könntest Du denen IDs oder so geben. Dann kannst Du ne struct bilden, die halt so aussieht:

struct PathInformation
{
std::size_t idPixel1;
std::size_t idPixel2;
unsigned int distance;
unsigned int angle;
};

oder so. Die einzelnen Pixel hättest Du ja vorher in einem vector via:

struct Pixel
{
unsigned int x;
unsigned int y;
};

typedef std::vector<Pixel> PixelVector;

speichern können. Und als IDs oben kannst Du dann z.B. die Indizes nehmen.

-Finden Sie auf diesem Bild die weißen Pixel, speichern Sie die Positionen (ist erledigt mit Maps)
-Nun teilen berechnen Sie die Strecke der weißen Pixel zu anderen weißen Pixel, fals Wert unter 30 ist, dann wird er nicht gespeichert
-Berechnen Sie den Winkel zwischen den Pixel die den Wert über 30 haben

also für mich ist grade die zweite aufgabe kein korrekter deutscher satz
und da versthe ich die aufgabe nicht...

man soll die entfernung aller weissen pixel zueinander berechnen?
(das wären doch sowas bei n! strecken dann?!)

und dann soll man diese ab einer gewissen länge auch speichern?

#include <vector>
#include <iostream>
#include <cmath>

namespace math 
{
    const double PI(3.14159265);

    const double toDegree(const double radian) 
    { return radian * 180.0 / PI; }

    const double toRadian(const double degree) 
    { return degree * PI / 180.0; }
}; // math

class Pixel
{
public:
	Pixel(){}
	Pixel(int x, int y): x(x), y(y) {}

	friend std::ostream& operator<<(std::ostream& ostr, const Pixel& p)
	{
		ostr << p.x << " " << p.y << "\n";
		return ostr;
	}

	int GetX(){return x;}
	int GetY(){return y;}

private:
	int x;
	int y;
};

class PixelCombo
{
public:
	PixelCombo(const Pixel& p1, const Pixel& p2)
	{
		a = p1;
		b = p2;

		distanz = sqrt((double)((a.GetX() - b.GetX())*(a.GetX() - b.GetX())) + ((a.GetY() - b.GetY())*(a.GetY() - b.GetY())));

		if(distanz > 30)
		{
			winkel = math::toDegree( std::atan((double)(a.GetY() - b.GetY()) / (a.GetX() - b.GetX())));
		}
		else
		{
			winkel = 0.0;
		}
	}

	friend std::ostream& operator<<(std::ostream& ostr, const PixelCombo& p)
	{
		ostr << "Punkt 1: " << p.a << "Punkt 2: " << p.b << "Distanz: " << p.distanz << "\nWinkel: " << p.winkel << "\n\n";

		return ostr;
	}

private:
	Pixel a;
	Pixel b;
	double distanz;
	double winkel;
};

typedef std::vector<Pixel> PixelVector;
typedef std::vector<PixelCombo> ComboVector;

int main()		
{ 
	PixelVector pvec;
	ComboVector cvec;

	pvec.push_back(Pixel(5, 10));
	pvec.push_back(Pixel(7, 10));
	pvec.push_back(Pixel(8, 3));
	pvec.push_back(Pixel(8, 40));

	for(PixelVector::iterator i = pvec.begin(); i != pvec.end() - 1; ++i)
		for(PixelVector::iterator y = i + 1; y != pvec.end(); ++y)
			cvec.push_back(PixelCombo(*i, *y));

	for(ComboVector::iterator i = cvec.begin(); i != cvec.end(); ++i)
		std::cout << *i;
}

Eine Frage noch: Was ist am Codebeispiel von "AlsGrobeIdee" so schlecht?

for(int x = 0; x < 100; ++x)
	for(int y = 0; y < 100; ++y)
		pvec.push_back(Pixel(x, y));

Mal abgesehen davon dass man Zeile 39 - 42 abkürzen kann und Zeile 19 entfernen sollte. Zeile 48 ist alles andere als sicher (Teilen durch 0).

Mal ganz beiseite gelassen, dass die Punkte permanent kopiert werden...

Es war auch nur als kurz niedergeschriebenes Beispiel gedacht.

Naja, 100 * 100 weiße Pixel sprengen jedenfalls meinen Ram.

Was sind schon 100 x 100 Punkte? Es können doch auch viel mehr sein. 'Mach das' sagt der Kunde und man steht schnell auf dem Schlauch! Im Ram macht man das sinnvollerweise nicht. Mit einer zu sortierenden Datei ist das aber jederzeit machbar.

Naja, 100 * 100 weiße Pixel sprengen jedenfalls meinen Ram.

for(int x = 0; x < 100; ++x)
	for(int y = 0; y < 100; ++y)
		pvec.push_back(Pixel(x, y));

Mal abgesehen davon dass man Zeile 39 - 42 abkürzen kann und Zeile 19 entfernen sollte. Zeile 48 ist alles andere als sicher (Teilen durch 0).

Mal ganz beiseite gelassen, dass die Punkte permanent kopiert werden...

Es war auch nur als kurz niedergeschriebenes Beispiel gedacht.

Hä? 10000 ist doch nix, was hast du für nen PC?

Hä? 10000 ist doch nix, was hast du für nen PC?

Bevor du sowas schreibst hättest du den Programmabsturz gut und gerne in deinem Taskmanager mitverfolgen können.

Edit: Was eine dämliche Rechnung meinerseits...

Ok nochmal:
Summierung 10000 bis 1 entspricht ((10000 + 10000^2) / 2)
Dadurch ergibt sich eine Speicheranforderung von ((10000 + 10000^2) / 2) * 32 Byte = 1,49 GB

Nicht gerade unbedeutend bei nur 10000 Pixel...