Vielleicht ließe sich was machen mit np.minimum() oder np.maximum().
>>> import numpy as np
>>> a=np.array([110], dtype=np.uint8)
>>> b=np.array([100], dtype=np.uint8)
>>> np.absolute(a-b)
array([10], dtype=uint8)
>>> np.absolute(b-a)
array([246], dtype=uint8)
>>>
>>> np.absolute(np.int8(a)-np.int8(b))
array([10], dtype=int8)
>>> np.absolute(np.int8(b)-np.int8(a))
array([10], dtype=int8)
Funktioniert also auch nicht. Einmal liefert der np.minimum() das gewünschte / richtige Ergebnis, bei anderen Werten aber der np.maximum().
>>> np.minimum(a-b, b-a)
array([10], dtype=uint8)
>>> np.maximum(a-b, b-a)
array([246], dtype=uint8)
>>>
>>> a=np.array([250], dtype=np.uint8)
>>> b=np.array([1], dtype=np.uint8)
>>> np.minimum(a-b, b-a)
array([7], dtype=uint8)
>>> np.maximum(a-b, b-a)
array([249], dtype=uint8)
Pixel Bild_1 |
Pixel Bild_2 |
Bild_1 - Bild_2 |
nach uint8 |
als uint8 |
Status |
110 |
100 |
10 |
10 & 0xff | 10 |
richtig |
100 |
110 |
-10 |
-10 & 0xff | 246 |
falsch |
250 |
1 |
249 |
249 & 0xff | 249 |
richtig |
1 |
250 |
-249 |
-249 & 0xff | 7 |
falsch |
diff=np.empty([480,
640], np.uint8) for y in range(480): for x in range(640): if img1[y, x]<img2[y, x]: diff[y, x]=img2[y, x]-img1[y, x] else: diff[y, x]=img1[y, x]-img2[y, x] |
Pixel Bild_1 |
als int8 |
Pixel Bild_2 |
als int8 |
Bild_1 - Bild_2 |
als Pixel |
status1 |
np.absolute() |
status2 |
110 |
110 |
100 |
100 |
110 - 100 = 10 |
10 |
richtig |
10 => 10 | richtig |
100 |
100 |
110 |
110 |
100 - 110 = -10 |
246 |
falsch |
-10 => 10 | richtig |
250 |
-6 |
1 |
1 |
-6 - 1 = -7 |
249 |
richtig |
-7 => 7 |
falsch |
1 |
1 |
250 |
-6 |
1 - -6 = 7 |
7 |
falsch |
7 => 7 |
falsch |
Ja. Deutlich! Passt nicht.
>>> 140-120 # erst der Gut-Fall
20
>>> np.uint8(np.absolute(np.int8(140)-np.int8(120)))
20
>>> np.uint8(np.absolute(np.int8(120)-np.int8(140)))
20
>>>
>>> 139-10 # und jetzt knapp drüber
129
>>> np.uint8(np.absolute(np.int8(139)-np.int8(10)))
127
>>> np.uint8(np.absolute(np.int8(10)-np.int8(139)))
127
>>>
>>> 200-10 # oder deutlich drüber
190
>>> np.uint8(np.absolute(np.int8(200)-np.int8(10)))
66
>>> np.uint8(np.absolute(np.int8(10)-np.int8(200)))
66
if
__name__=="__main__": cam=IP_Cam() img1=cam.getImageGrayscale() # liefert jetzt np.int8 time.sleep(0.1) img2=cam.getImageGrayscale() img1_u=np.uint8(img1) # eine np.uint8-Version daraus bauen img2_u=np.uint8(img2) diff=np.absolute(img1-img2) diff2=np.empty([480, 640], np.uint8) for y in range(480): for x in range(640): if img1_u[y, x]<img2_u[y, x]: diff2[y, x]=img2_u[y, x]-img1_u[y, x] else: diff2[y, x]=img1_u[y, x]-img2_u[y, x] cam.saveImage(np.uint8(diff), "diff1") cam.saveImage(diff2, "diff2") cam.saveImage(img1_u, "img1") cam.saveImage(img2_u, "img2") |
Größe |
Name |
17269 | diff1.jpg |
17269 | diff2.jpg |
39174 | img1.jpg |
39025 | img2.jpg |
Größe | Name |
20705 | diff1.jpg |
20790 | diff2.jpg |
39271 | img1.jpg |
38620 | img2.jpg |
def
differenceImageV1(img1, img2): # img1 und img2
sind vom Typ np.uint8 diff=np.empty_like(img1) h, w=img1.shape for y in range(h): for x in range(w): if img1[y, x]<img2[y, x]: diff[y, x]=img2[y, x]-img1[y, x] else: diff[y, x]=img1[y, x]-img2[y, x] return(diff) def differenceImageV2(img1, img2): return(np.uint8(np.absolute(np.int16(img1)-np.int16(img2)))) def differenceImageV3(img1, img2): # nur als Referenz - liefert falsches Ergebnis return(img1-img2) |
Die V1 ist in dieser Hinsicht eindeutig unbrauchbar.
10x: 1893.99 ms
1000x: 435.62 ms
1000x: 26.56 ms
def
differenceImageV6(img1, img2): a=img1-img2 b=np.uint8(img1<img2)*254+1 return(a*b) |
Damit könnte jetzt die Differenz von zwei uint8-Bildern schnell und korrekt gebildet werden.
1000x: 401.61 ms np.sum=26108157
1000x: 179.71 ms np.sum=26108157
Operation |
Funktion / Syntax |
Summe bilden |
np.sum() |
Mittelwert bilden |
np.mean() |
Differenz bilden |
arr1-arr2 |
Kopie erstellen |
arr2=1*arr1 oder arr2=np.array(arr1, dtype=xxx, copy=True) |
Bereich ausschneiden |
arr[y1:y2, x1:x2] |
Wertebereich ändern | arr[arr<x]=y |
Datentyp ändern |
np.uint8(), np.int16(), ... |
Operation |
Test int16 |
Test uint8 |
Zeit int16 |
Zeit uint8 |
Summe bilden |
tmp1=np.sum(img1_s16) tmp2=np.sum(img2_s16) |
tmp1=np.sum(img1_u8) tmp2=np.sum(img2_u8) |
830.78 ms |
980.18 ms |
Mittelwert bilden |
tmp1=np.mean(img1_s16) tmp2=np.mean(img2_s16) |
tmp1=np.mean(img1_u8) tmp2=np.mean(img2_u8) |
877.64 ms |
1127.37 ms |
Differenz bilden | tmp1=np.absolute(img1_s16-img2_s16) |
tmp1=differenceImageV6(img1_u8, img1_u8) |
599.29 ms |
328.10 ms |
Kopie erstellen V1 |
tmp1=1*img1_s16 tmp2=1*img2_s16 |
tmp1=1*img1_u8 tmp2=1*img2_u8 |
158.14 ms |
157.75 ms |
Kopie erstellen V2 | tmp1=np.array(img1_s16, copy=True) tmp2=np.array(img2_s16, copy=True) |
tmp1=np.array(img1_u8, copy=True) tmp2=np.array(img2_u8, copy=True) |
153.03 ms |
70.92 ms |
Bereich ausschneiden | tmp1=img1_s16[10:100, 10:100] tmp2=img2_s16[10:100, 10:100] |
tmp1=img1_u8[10:100, 10:100] tmp2=img2_u8[10:100, 10:100] |
1.11 ms |
1.10 ms |
Wertebereich ändern | tmp1=1*img1_s16 tmp2=1*img2_s16 tmp1[tmp1<128]=0 tmp2[tmp2<128]=0 |
tmp1=1*img1_u8 tmp2=1*img2_u8 tmp1[tmp1<128]=0 tmp2[tmp2<128]=0 |
6545.11 ms |
6779.61 ms |
Datentyp ändern | img1_s16=np.int16(img1_u8) img2_s16=np.int16(img2_u8) |
tmp1=np.uint8(img1_s16) tmp2=np.uint8(img2_s16) |
202.66 ms |
135.99 ms |
Operation |
RaspberryPi int16 |
RaspberryPi uint8 | BananaPi int16 |
BananaPi uint8 |
Summe bilden | 21092.51 ms |
17896.24 ms |
6576.92 ms |
6092.12 ms |
Mittelwert bilden | 44651.76 ms |
40972.37 ms |
10746.21 ms |
10717.93 ms |
Differenz bilden | 23580.92 ms |
37739.59 ms |
12088.47 ms |
18823.55 ms |
Kopie erstellen V1 | 19371.14 ms |
12048.09 ms |
9640.56 ms |
5632.14 ms |
Kopie erstellen V2 | 7161.44 ms |
2049.26 ms |
6034.22 ms |
1240.02 ms |
Bereich ausschneiden | 133.63 ms |
133.59 ms |
28.06 ms |
27.03 ms |
Wertebereich ändern | 71613.67 ms |
70013.32 ms |
33331.61 ms |
32231.65 ms |
Datentyp ändern | 13658.56 ms |
14429.18 ms |
6008.72 ms |
3367.94 ms |