Wie schnell ändern Sie die Bildhelligkeit mit python + OpenCV?

Ich habe eine Sequenz von Bildern. Ich brauche, um die Durchschnittliche Helligkeit dieser Bilder.

Ersten Beispiel (sehr langsam):

img = cv2.imread('test.jpg') #load rgb image
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) #convert it to hsv

for x in range(0, len(hsv)):
    for y in range(0, len(hsv[0])):
        hsv[x, y][2] += value

img = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite("image_processed.jpg", img)

Zweiten Beispiel (schnell)

hsv += value

Diesem Beispiel sehr schnell, aber es ändert alle Werte, die der HSV (ich brauche eine änderung nur V (Helligkeit))

InformationsquelleAutor Pavel | 2015-09-16

16

Slice wählen Sie nur den Dritten Kanal, und ändern Sie dann die Elemente -
```
hsv[:,:,2] += value
```
- Funktioniert nicht. Gibt einige seltsame Bild als Ausgabe, nach der Erhöhung der Helligkeit.
- Sie könnten immer überlaufen. Wenn dem so ist, müssen Sie möglicherweise verwenden clipping : numpy.clip. Auch, nur eine Erinnerung, dass diese arbeiten auf der HSV-Seite. Also, Sie tun müssen, würde diese RGB zu HSV und zurück Konvertierungen.
- Ja, ich habe alles. BGR zum HSV, Dann der hsv[:,:,2] += 50, Dann np.clip schließlich HSV BGR. Immer noch kein Glück.
- href="http://stackoverflow.com/questions/37822375/python-opencv-increasing-image-brightness-without-overflowing-uint8-array">This sollte helfen. Zum einstellen des Grenzwertes, möchten Sie vielleicht zu Lesen, auf HSV Wiki.
- Hi, ich habe einfach angewendet opencv-Methode bgr Bild - cv2.add(inputImage, np.array([50.0])) erhöht die Helligkeit von 50.0
- Überlegen, eine neue Frage, wenn Ihre Fragen nicht geklärt sind, setzen gemeinsam alle details und die Verknüpfung zu den relevanten F&So.
- wie kann ich reduzieren die Helligkeit?
- Wert?
- verursachen Unterlauf negative Zahl im Falle der V channel Werte sind weniger die value. Schon versucht
- Folgen Sie diesem - stackoverflow.com/questions/37822375/...
- versuchen Sie, nicht in der Lage, immer die Logik gerade
- Post eine neue Frage.
InformationsquelleAutor Divakar

Ich weiß, diese Frage ist ein bisschen alt, aber ich dachte, ich könnte die post die komplette Lösung, die für mich gearbeitet (kümmert sich um den überlauf situation, indem Sie die Sättigung auf 255):

def increase_brightness(img, value=30):
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    h, s, v = cv2.split(hsv)

    lim = 255 - value
    v[v > lim] = 255
    v[v <= lim] += value

    final_hsv = cv2.merge((h, s, v))
    img = cv2.cvtColor(final_hsv, cv2.COLOR_HSV2BGR)
    return img

Diese können wie folgt verwendet werden:

frame = increase_brightness(frame, value=20)

Klar, leicht zu Lesen und effektiv. Dies sollte die akzeptierte Antwort

InformationsquelleAutor Bill Grates

7

Iterieren über das gesamte Bild, um änderungen vorzunehmen ist nicht sehr skalierbar option in opencv, Opencv bietet viele Methoden und Funktionen zur Durchführung der arithmetischen Operationen auf dem gegebenen Bild.

Können Sie einfach teilen Sie die konvertierte HSV-Bild in die einzelnen Kanäle und dann den V-Kanal entsprechend als:
```
img = cv2.imread('test.jpg') #load rgb image
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) #convert it to hsv

h, s, v = cv2.split(hsv)
v += 255
final_hsv = cv2.merge((h, s, v))

img = cv2.cvtColor(final_hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite("image_processed.jpg", img)
```
InformationsquelleAutor ZdaR
3

Den anderen Antworten schlagen Sie die " Sättigung "von hand" mit allen Arten von numpy Magie, aber Sie können auch verwenden, cv2.add() und lassen Sie OpenCV-handle, das für Sie:
```
import cv2
import numpy as np

image = cv2.read('image.png')
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
value = 42 #whatever value you want to add
cv2.add(hsv[:,:,2], value, hsv[:,:,2])
image = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite('out.png', image)
```
- Weit und Weg die beste Antwort. Ich war das Lesen der anderen Antworten, die sich Fragen, warum niemand etwas Tat, was Sie vorgeschlagen. Leider ist diese Antwort war an der Unterseite. Die akzeptierte Antwort ist vorbehaltlich der 8-bit-overflow und den hilfreichen Kommentar über cv2.fügen Sie nicht gleichmäßig aufhellen eines Bildes je nach Farben. Diese Antwort macht es richtig.
InformationsquelleAutor Gui Meira

import cv2
import numpy as np

image = cv2.imread('image.jpg')
image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

v = image[:, :, 2]
v = np.where(v <= 255 - increase, v + increase, 255)
image[:, :, 2] = v

image = cv2.cvtColor(image, cv2.COLOR_HSV2BGR)

cv2.imshow('Brightness', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

Beste Antwort, ohne überlauf, danke 🙂

InformationsquelleAutor Rendicahya

Hoffe, dies ist nützlich für jemanden, der

@Divakar Antwort Python, OpenCV: Erhöhung der Bildhelligkeit ohne überzulaufen UINT8-array

mImage = cv2.imread('image1.jpg')

hsvImg = cv2.cvtColor(mImage,cv2.COLOR_BGR2HSV)

value = 0

vValue = hsvImg[...,2]
hsvImg[...,2] = np.where((255-vValue)<value,255,vValue+value)

plt.subplot(111), plt.imshow(cv2.cvtColor(hsvImg,cv2.COLOR_HSV2RGB))
plt.title('brightened image'), plt.xticks([]), plt.yticks([])
plt.show()

Um die Helligkeit zu verringern

mImage = cv2.imread('image1.jpg')

hsvImg = cv2.cvtColor(mImage,cv2.COLOR_BGR2HSV)

# decreasing the V channel by a factor from the original
hsvImg[...,2] = hsvImg[...,2]*0.6

plt.subplot(111), plt.imshow(cv2.cvtColor(hsvImg,cv2.COLOR_HSV2RGB))
plt.title('brightened image'), plt.xticks([]), plt.yticks([])
plt.show()

InformationsquelleAutor Santhosh Dhaipule Chandrakanth

1
```
def change_brightness(img, alpha, beta):
   return cv2.addWeighted(img, alpha, np.zeros(img.shape, img.dtype),0, beta)
```
Hier alpha & beta sind Eingabeparameter. Jedes pixel des eingangsbildes wird sich ändern nach dieser Formel.
```
 alpha(pixel_value) + beta.
```
Niedrigeren Wert von alpha wie 2 oder 3 ist gut

InformationsquelleAutor Vikas
0

Vielleicht zu alt, aber ich benutze cv.covertTo, die für mich funktioniert
```
Mat resultBrightImage;    
origImage.convertTo(resultBrightImage, -1, 1, percent); // Where percent = (int)(percent_val/100)*255, e.g., percent = 50 to increase brightness by 50%
```
convertTo verwendet saturate_cast am Ende zu vermeiden, irgendwelche overflows. Ich glaube nicht, verwenden Python und die oben ist in C++, aber ich hoffe, es ist leicht umwandelbar in Python und hoffe es hilft

InformationsquelleAutor Bilal

Können Sie mit dieser Funktion ändern Sie Ihren gewünschten Helligkeit oder Kontrast mithilfe von C++ genau wie die gleiche Weise tun Sie es auf photoshop oder andere ähnliche Foto-Bearbeitungs-software.

def apply_brightness_contrast(input_img, brightness = 255, contrast = 127):
    brightness = map(brightness, 0, 510, -255, 255)
    contrast = map(contrast, 0, 254, -127, 127)

    if brightness != 0:
        if brightness > 0:
            shadow = brightness
            highlight = 255
        else:
            shadow = 0
            highlight = 255 + brightness
        alpha_b = (highlight - shadow)/255
        gamma_b = shadow

        buf = cv2.addWeighted(input_img, alpha_b, input_img, 0, gamma_b)
    else:
        buf = input_img.copy()

    if contrast != 0:
        f = float(131 * (contrast + 127)) / (127 * (131 - contrast))
        alpha_c = f
        gamma_c = 127*(1-f)

        buf = cv2.addWeighted(buf, alpha_c, buf, 0, gamma_c)

    cv2.putText(buf,'B:{},C:{}'.format(brightness,contrast),(10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
    return buf

def map(x, in_min, in_max, out_min, out_max):
    return int((x-in_min) * (out_max-out_min) / (in_max-in_min) + out_min)

Danach müssen Sie zum aufrufen der Funktionen durch die Schaffung trackbar mit cv2.createTrackbar() und rufen Sie die oben genannten Funktionen mit den richtigen Parametern als gut. Um die Zuordnung der Helligkeitswerte, die reicht von -255 bis +255 und Kontrast-Werte -127 bis +127, die Sie verwenden können, dass map() Funktion. Sie können überprüfen Sie die gesamte details über python-Implementierung hier.

InformationsquelleAutor Md. Hanif Ali Sohag

Ich weiß, das sollte nicht so schwer sein und es zum anpassen der Helligkeit eines Bildes. Auch gibt es bereits viele gute Antworten. Ich möchte zu verbessern die Antwort von @BillGrates, so dass es funktioniert auf Graustufenbilder und mit Abnehmender Helligkeit: value = -255 erzeugt ein Schwarzes Bild in der Erwägung, dass value = 255 eine weiße.

def adjust_brightness(img, value):
    num_channels = 1 if len(img.shape) < 3 else 1 if img.shape[-1] == 1 else 3
    img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) if num_channels == 1 else img
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    h, s, v = cv2.split(hsv)

    if value >= 0:
        lim = 255 - value
        v[v > lim] = 255
        v[v <= lim] += value
    else:
        value = int(-value)
        lim = 0 + value
        v[v < lim] = 0
        v[v >= lim] -= value

    final_hsv = cv2.merge((h, s, v))

    img = cv2.cvtColor(final_hsv, cv2.COLOR_HSV2BGR)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) if num_channels == 1 else img
    return img

InformationsquelleAutor oezguensi

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.