häufigste Bildschirmfarbe auslesen

  • C++

  • RimShot
  • 1701 Aufrufe 4 Antworten

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • häufigste Bildschirmfarbe auslesen

    Hallo
    Ich möchte ein Programm schreiben, welches die Bildschirmfarben ausliest, und dann schaut, welche Farbe am häufigsten vorkommt.
    Es soll so was ähnliches wie Ambilight geben.
    Dazu muss natürlich nicht der ganze Bildschirm ausgelesen werden, sonder nur der Rand.

    folgende Ideen:
    • Farbwerte auslesen und zwischenspeichern
    • nur die Ränder betrachten; Koordinaten angeben
    • Farbwerte vergleichen, nach dem am häufigsten vorkommenden suchen


    Den folgenden Code habe ich bereits:

    C-Quellcode

    1. #include <windows.h>
    2. #include <iostream>
    3. using namespace std;
    5. int main(void){
    6. HDC dc = GetDC(0); //WinAPI Funktion, liest Farben
    7. for(int i=0;i<1024;i++){ // Koordinaten y
    8. for(int j=0;j<1280;j++){ // Koordinaten x
    9. COLORREF c = GetPixel(dc,j,i);
    10. cout << (int)GetRValue(c) << " " << (int)GetGValue(c) << " " << (int)GetBValue(c) << "n"; // ausgabe der Pixelwerte
    11. }
    12. }
    13. ReleaseDC(0,dc);
    14. return 0;
    15. }
    Alles anzeigen


    Das hat aber mehrere Probleme:

    • Nur vorgegebene Auflösung
    • ganzer Bildschirm ausgelesen
    • kein Vergleich der Farben


    Den Code habe ich nicht selbst geschrieben... denke aber man könnte darauf aufbauen.
    Ich erwarte jetzt nicht, dass mir jemand hier ein fertiges Programm schickt :P, aber ich würde mich freuen, wenn mir jemand die Befehle und deren Verwendung sagen könnte, mit denen ich den Rest erreiche :)
    Vielen Dank schon mal fürs lesen!

  • ich hätte mal eine idee wie du die häufigste farbe herausfinden kannst. du musst einfach alle rgb werte addieren und dann durch die anzabl pixel teilen und schon hast du die durchschnittsfarbe
    zu deiber anderen frage. du kannst z.b. 2 schlaufen schreiben, welhe halt nur die ränder auslesen und dann die rgb werte in ein array schreien. in dem kannst du dann die werte addieren und durch die anzahl elemente teilen
    Posted via Mobile Device

  • Hier ist mal ein Beispiel für ein "einfaches Ambi-Light":

    C-Quellcode

    1. #include <windows.h>
    2. #include <iostream.h>
    4. using namespace std;
    6. int main(void)
    7. {
    8. //Wieviel Pixel-Spalten sollen links/rechts berücksichtigt werden?
    9. const int BREITE = 150;
    12. //Durchschnittsfarbe Links
    13. int Farbe_Links_R = 0;
    14. int Farbe_Links_G = 0;
    15. int Farbe_Links_B = 0;
    16. //Durchschnittsfarbe Rechts
    17. int Farbe_Rechts_R = 0;
    18. int Farbe_Rechts_G = 0;
    19. int Farbe_Rechts_B = 0;
    21. HDC dc = GetDC(0);
    22. int scrBreite = GetSystemMetrics(SM_CXSCREEN);
    23. int scrHoehe = GetSystemMetrics(SM_CYSCREEN);
    25. //Linke Durchschnittsfarbe berechnen
    26. long tmp_r = 0;
    27. long tmp_g = 0;
    28. long tmp_b = 0;
    29. for(int x = 0; x < BREITE; x++)
    30. {
    31. for(int y = 0; y < scrHoehe; y++)
    32. {
    33. COLORREF Farbe = GetPixel(dc,x,y);
    34. tmp_r += GetRValue(Farbe);
    35. tmp_g += GetGValue(Farbe);
    36. tmp_b += GetBValue(Farbe);
    37. }
    38. }
    39. Farbe_Links_R = tmp_r / (BREITE * scrHoehe);
    40. Farbe_Links_G = tmp_g / (BREITE * scrHoehe);
    41. Farbe_Links_B = tmp_b / (BREITE * scrHoehe);
    43. //Rechte Durchschnittsfarbe berechnen
    44. tmp_r = 0;
    45. tmp_g = 0;
    46. tmp_b = 0;
    47. for(int x = scrBreite - BREITE; x < scrBreite; x++)
    48. {
    49. for(int y = 0; y < scrHoehe; y++)
    50. {
    51. COLORREF Farbe = GetPixel(dc,x,y);
    52. tmp_r += GetRValue(Farbe);
    53. tmp_g += GetGValue(Farbe);
    54. tmp_b += GetBValue(Farbe);
    55. }
    56. }
    57. Farbe_Rechts_R = tmp_r / (BREITE * scrHoehe);
    58. Farbe_Rechts_G = tmp_g / (BREITE * scrHoehe);
    59. Farbe_Rechts_B = tmp_b / (BREITE * scrHoehe);
    61. ReleaseDC(0,dc);
    62. cout << "Durchschnittsfarbe Links: (R,G,B) " << Farbe_Links_R << "," << Farbe_Links_G << "," << Farbe_Links_B << ")\r\n";
    63. cout << "Durchschnittsfarbe Rechts: (R,G,B) " << Farbe_Rechts_R << "," << Farbe_Rechts_G << "," << Farbe_Rechts_B << ")\r\n";
    64. getchar();
    65. return 0;
    66. }
    Alles anzeigen

    Durch die Konstante BREITE kann man noch den linken und rechten Bildschirmrand verändern.
    Es wird u.a. die Bildschirmhöhe und -breite ermittelt, und am Ende wird für jeden Farbkanal der Mittelwert berechnet.

    Am Ende erhält man dann einen Farbwert im RGB-Format. z.B. lautet die Ausgabe:
    Durchschnittsfarbe Links: (R,G,B) 0, 255, 255

    dann ist die Durchschnittsfarbe am linken Rand: CYAN
    Wo ist Iphigenie?

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von tarkus ()

  • Hi
    Vielen Dank
    Dein Code hatte noch ein paar Fehler. Jedenfalls ging es bei mir noch nicht.
    Jetzt habe ich ihn etwas umgeschrieben. Jetzt gibt er zwar etwas aus, aber die Farben stimmen irgendwie noch nicht.
    Er gibt z.T. seltsame Farbwerte aus.
    z.B. :
    L 203, 202, 201
    R 969, 967, 966

    Der Code sieht so aus:

    C-Quellcode

    1. #include <windows.h>
    2. #include <iostream>
    4. using namespace std;
    6. int main(void)
    7. {
    8. //Wieviel Pixel-Spalten sollen links/rechts berücksichtigt werden?
    9. const int BREITE = 150;
    12. //Durchschnittsfarbe Links
    13. int Farbe_Links_R = 0;
    14. int Farbe_Links_G = 0;
    15. int Farbe_Links_B = 0;
    16. //Durchschnittsfarbe Rechts
    17. int Farbe_Rechts_R = 0;
    18. int Farbe_Rechts_G = 0;
    19. int Farbe_Rechts_B = 0;
    21. HDC dc = GetDC(0);
    22. int scrBreite = GetSystemMetrics(SM_CXSCREEN);
    23. int scrHoehe = GetSystemMetrics(SM_CYSCREEN);
    25. //Linke Durchschnittsfarbe berechnen
    26. long tmp_r = 0;
    27. long tmp_g = 0;
    28. long tmp_b = 0;
    29. for(int x = 0; x < BREITE; x++)
    30. {
    31. for(int y = 0; y < scrHoehe; y++)
    32. {
    33. COLORREF Farbe = GetPixel(dc,x,y);
    34. tmp_r += GetRValue(Farbe);
    35. tmp_g += GetGValue(Farbe);
    36. tmp_b += GetBValue(Farbe);
    37. }
    38. }
    39. Farbe_Links_R = tmp_r / (BREITE * scrHoehe);
    40. Farbe_Links_G = tmp_g / (BREITE * scrHoehe);
    41. Farbe_Links_B = tmp_b / (BREITE * scrHoehe);
    43. //Rechte Durchschnittsfarbe berechnen
    44. tmp_r = 0;
    45. tmp_g = 0;
    46. tmp_b = 0;
    49. for( (scrBreite - BREITE); x < scrBreite; x++)
    50. {
    51. for(int y = 0; y < scrHoehe; y++)
    52. {
    53. COLORREF Farbe = GetPixel(dc,x,y);
    54. tmp_r += GetRValue(Farbe);
    55. tmp_g += GetGValue(Farbe);
    56. tmp_b += GetBValue(Farbe);
    57. }
    58. }
    59. Farbe_Rechts_R = tmp_r / (BREITE * scrHoehe);
    60. Farbe_Rechts_G = tmp_g / (BREITE * scrHoehe);
    61. Farbe_Rechts_B = tmp_b / (BREITE * scrHoehe);
    63. //Evtl. std::cout verwenden?! sollte aber eingebunden sein, s.o.
    65. ReleaseDC(0,dc);
    66. cout << "Durchschnittsfarbe Links: (R,G,B) " << Farbe_Links_R << "," << Farbe_Links_G << "," << Farbe_Links_B << "\r\n";
    67. cout << "Durchschnittsfarbe Rechts: (R,G,B) " << Farbe_Rechts_R << "," << Farbe_Rechts_G << "," << Farbe_Rechts_B << "\r\n";
    68. getchar();
    69. return 0;
    70. }
    Alles anzeigen


    Vielen Dank für deine Hilfe! Hat mich echt weiter gebracht!

  • ja, ein Fehler bei meinem Code:
    es heisst: #include <iostream.h> aber richtig ist:

    Quellcode

    1. #include <iostream>

    (also ohne ".h")

    und bei dir fehlt in der Schleife für den rechten Rand eigentlich nur das:

    Quellcode

    1. for ([B]int x =[/B] (scrBreite - BREITE); ...


    sonst hat alles bei mir funktioniert. Anscheinend stimmt deine Mittelwert-Berechnung nicht. Hast du vlt noch die Anzahl der Schleifendurchläufe geändert?
    Oder hast du vergessen die tmp-Variablen wieder auf Null zu setzen?

    jedenfalls funzt auch dein Quellcode bei mir (mit der "int x = " Ergänzung in der Schleife)
    Wo ist Iphigenie?