Zitat von -mOsTwAnTeD-:

Hi ihr Cracks


hab da mal eine kleine frage

ich möchte mit der GDI ein Diagramm zeichnen. Das ist soweit kein problem. Doch anstatt Linien
werden an den Koordinaten Rechtecke gemalt. Immernoch kein Problem. Jetzt sollen aber die
Rechtecke unterschiedliche Farben erhalten.

So d.h ich habe mir eine Methode GetColour(int Wert, int Array, int* R, int* G, int* B)

geschrieben.

Der Wert ist der aktuelle Wert für den eine farbe ermitelt werden soll. In dem Array stehen alle
Werte (vorsicht das Array ist mehrdimensional)

die es insgesamt gibt. R,G und B sind zeiger die den RGB wert darstellen sollen.
So nun ist das Problem das ich nicht weiß wie ich die RGB Werte berechnen soll, denn es gibt
immer Unterschiedliche Werte die von 0 bis schätzungsweise 200
gehen, allerdings auch mal erst bei 50 anfangen und nur bis 100 gehen, oder nur von 0 bis 10. Da
man nicht für jeden Wert eine extra farbe nimmt, da es sonst zu unübersichtlich wird muss man
auch berücksichtigen, d.h wenn es unter 10 verschiedene Werte sind soll für jeden wert eine extra
farbe gewählt werden, wenn es mehr sind sollten alle 8-10 schritte eine neue farbe gewählt werden.
Außerdem sollte wenn man die Drafik ausdruckt (Schwarz-Weiß) auch noch zu erkennen sein
an welchen Stellen höhere und wo niederigere Werte liegen. -> Die 0 ist nicht zu berücksichtigen,
da die methode dann erst gar nicht aufgerufen wird. Die kleinste Zahl soll möglichst hell dargestellt
werden
und die höchste möglichst dunkel. Nur leider kann man nicht einfach den RGB Wert erhöen da sich
dann ja die gesamte Farbe ändert.(R++, G++, B++)
Außerdem sollte die Methode möglichst wenig resourcen benötigen damit das programm möglichst
nicht gebremst wird.



Ich habe jetzt nur eine idee und zwar das ganze mit zig if abfragen und switch case anweisungen
zu machen. Hat jemand eine idee wie es am leichtesten zu realisieren ist?


Greetz und schon mal danke im vorraus
most

Zitat von uwebaier:

Also wenn ich das jetz so halbwegs verstanden hab willst du Werte als Farben zeigen.
Der niedrigste Wert soll eine helle Farbe sein (also weiß) und der höchste eine dunkle Farbe (also Schwarz)

Um das ganze zu machen würd ich kein Mehrdimensionales Array nehmen sondern die Fraben und Werte in nem struct Speichern, also so:

struct farbwert {
int Wert;
unsigned char R;
unsigned char G;
unsigned char B;
};

Da du ja wies aussieht eh in Schwarz-weiß ausdrucken willst empfehl ich dir das ganze mit Grautönen zu machen.
Wenn du Grautöne benutzt kannst ja zu R G und B schrittweise das gleiche addieren...

Die Funktion sähe dann bei mir ungefähr so aus:

void erstelleFarbenArray
(farbwert * Buffer, //Ein Zeiger in den das Eregbnisarray geschrieben wird
int * Values,//Die Werte die die Funktion in das array schreiben soll
int Valuecount)
{
Buffer=new farbwert[Valuecount]; //Das neue Array erstellen
for (int i=0; i<Valuecount; i++) {
Buffer[i].Wert=Values[i];
Buffer[i].R=255/Valuecount*i;
Buffer[i].G=255/Valuecount*i;
Buffer[i].B=255/Valuecount*i; }
}

Das ominöse 255/valuecount*i bedeutet lediglich dass im ersten Schritt(255/Valuecount) die Farbschrittweite zum nächsten Wert bestimmt wird und im
zweiten Schritt (also *i) der Farbwert mit der Farbschrittweite mal der Nummer des Arrayindex versehen wird (bisschen Mathe am Mittag xD)

Ich glaub zwar nich dass ich dir ganz geholfen hab, aber du bist hoffentlich ein Stück näher gekommen und kannst was damit anfangen.
Wenn dir was fehlt oder ich was falsch verstanden hab, nur schreiben...

MFG WaynnnE

EDIT: Wenn de brauchst musst halt davor die Zahlen sortieren, google kann dir mit Quicksort oder ähnlichem helfen =)

Zitat von McPommes:

Es gibt doch auch ne Funktion um Linien zu zeichnen.

Zitat von McPommes:

Das mit den Farben hab ich vielleicht nicht wirklich kapiert. Was uwebaier schreibt, hab ich mir auch gedacht. Ich denk mal du will unterschiedliche Farben haben und dir ausrechnen, wann du welche Farbe nimmst.

Zitat:

Dazu würd ich ein paar Farben vorgeben und die in ein Array stecken.
Dann rechnest du aus wie viele unterschiedliche Werte es gibt und kannst daran entscheiden, wie viele Schritte du zu einer einzigen Farbe zusammenfasst. Daraus ergibt sich dann die Anzahl der Farben. Wenn du ein paar unterscheidbare Farben in deinem Array hasst, würd ich dann einfach die ersten x Farben nehmen, je nach dem wie viele du brauchst.
Triffts das ungefähr?

Zitat von uwebaier:

Also gut, ich glaub ich weiß jetz eher was du meinst...

Und das Problem mit den Werten (wenn ich das richtig verstanden hab)
ist dass du die Farben nich gleichmäßig sondern entsprechend ihrem Abstand zu höchstem/niedrigstem Wert liegen, also
5 (niedrigster Wert) 10 50 (höchster Wert)
Du willst jetz dass die Farben nicht gleichmäßig zunehmen sondern dass wie im Beispiel der Wert 10 heller dargestellt wird weil er näher bei 5 liegt als bei 50?

PS: Ist das mit den Grautönen von dir akzeptiert oder willst was anderes?

Zitat:

struct color {
unsigned char R;
unsigned char G;
unsigned char B; };

void fillColorArray(color * Array, int *Values, int Valuecount)
{
const int Maxcolorcount=10;
int Minvalue=Values[0];
int Maxvalue=Values[0];
for (int i=1; i<Valuecount; i++) {
if (Maxvalue<Values[i]) {
Maxvalue=Values[i]; }
else if (Minvalue>Values[i]) {
Minvalue=Values[i]; }
}
int Colorcount=(Valuecount>Maxcolorcount)?Maxcolorcount:Valuecount;
Maxvalue-=Minvalue;
for (int i=0;i<Valuecount; i++) {
Array[i].R=(float(Values[i]-Minvalue)/float(Maxvalue))*255; //Farbenwert
Array[i].R-=Array[i].R%Colorcount;
Array[i].G=Array[i].R;
Array[i].B=Array[i].B; }
}

Zitat von uwebaier:

Öhm das is eigenlich ganz einfach mit 2 Farben...

Das du Mathe kannst hab icj ja gesehen, also könnte dir das vielleicht den Finalen Tip geben (Ich weiß aber nich wies aussieht xD)

Rechne den Betrag von einer Frabe minus der anderen...
Nun teilst du dein Eregbnis in RGB auf und teilst dann einzeln R G und B durch die Anzahl der verschiedenen Farbwerte (Die Anzahl der Farben die du maximal anzeigen willst)

Damit hast Schrittweiten für R G und B, und bei der finalen for-schleife tust dann einfach zu der entsprechenden Farbe ihre Distanz dazurechnen also so:
RDistance=(großFarbe-kleinFarbe)/Maxanzahlfarben;

R=Wert/Maxwert*(großFarbe-kleinFarbe);
R-=R%RDistance;
R+=kleinFarbe;
/* Musst halt für jeden Farbton extra machen als R G und B... */

Probiers mal aus, ich kanns bei mir nich testen weil ich Probs mit CBuilder hab ^^