ka111
Anmeldungsdatum: 22. Juni 2014
Beiträge: Zähle...
|
Weiss jemand ob man mit ImageMagick nach Pixeln mit einer bestimmten Farbe, oder einer Farbe die zwischen zwei rgb Werten liegt suchen kann und alle gefundenen Pixeln in eine Text Datei konvertieren kann, so dass nur die Koordinaten und rgb Werte jedes gesuchten Pixels darin stehen? Also zB. suche ich alle Pixel die Rot zwischen 50 - 100 haben, Grün zwischen 100 - 200, und Blau zwischen 200 und 255. Und am besten wäre es wenn in der Text Datei nicht solche Zeilen stehen:
133,463: (44718,42405,42405) #AEA5A5 srgb(174,165,165)
134,463: (46517,46517,46517) #B5B5B5 grey71
sondern solche:
133,463:174,165,165
134,463:71,71,71 Ist das möglich nur mit ImageMagick?
|
seahawk1986
Anmeldungsdatum: 27. Oktober 2006
Beiträge: 11179
Wohnort: München
|
Warum muss das unbedingt mit Imagemagick passieren? Man könnte da z.B. opencv nutzen (Pakete python3-opencv und python3-numpy):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30 | #!/usr/bin/env python3
import sys
import cv2
import numpy as np
r_min = 50
r_max = 100
g_min = 100
g_max = 200
b_min = 200
b_max = 255
# opencv uses a BGR instead of a RGB color space by default!
lower_bound = np.array([b_min, g_min, r_min])
upper_bound = np.array([b_max, g_max, r_max])
for image in sys.argv[1:]:
try:
img = cv2.imread(image)
except OSError as e:
print(e, file=sys.stderr)
else:
with open(image + ".matching_pixels.txt", "w") as f:
mask = cv2.inRange(img, lower_bound, upper_bound)
for x, (row, mask_row) in enumerate(zip(img, mask)):
for y, (pixel, pixel_mask) in enumerate(zip(row, mask_row)):
if pixel_mask:
print(f"{x},{y}:{','.join(str(v) for v in reversed(pixel))}",
file=f)
|
Dem Skript kann man eines oder mehrere Bilder als Argument übergeben und es erstellt dann pro Bild eine Textdatei mit den gefundenen Pixeln, die in dem Farbraum liegen (die Werte für die Farben könnte man z.B. auch aus einer Datei lesen oder dem Skript als Optionen übergeben, aber dazu wäre es sinnvoll ein bisschen mehr darüber zu wissen, wie du das verwenden willst).
|
ka111
(Themenstarter)
Anmeldungsdatum: 22. Juni 2014
Beiträge: 141
|
Wo müsste ich den Pfad zum Bild angeben in diesem Python Script? Mit Python habe ich keine Erfahrung, hatte nur mal einen online Kurs gemacht und ein bisschen wieder die gleichen Sachen herausgefunden die ich mit Shell/Bash mache, aber die Darstellung und alle Sonderzeichen konnte ich nicht so gut auswendig, und habe es jetzt wieder vergessen. Und wenn ich zuerst von png zu txt konvertiere und danach mit grep nach der Pixelfarbe suche dauert das konvertieren ein paar Sekunden und grep ein paar bis viele Minuten. Und Imagemagick kann viel, und wenn man im convert Befehl von Imagemagick gleich auch nach den rgb Farben suchen könnte wäre das vielleicht schneller. Ich habe immer Imagemagick für Pixelfarben und Bilder benützt.
|
rklm
Projektleitung
Anmeldungsdatum: 16. Oktober 2011
Beiträge: 12822
|
ka111 schrieb: Wo müsste ich den Pfad zum Bild angeben in diesem Python Script?
Auf der Kommandozeile beim Aufruf. Das sieht man in Zeile 18.
Und wenn ich zuerst von png zu txt konvertiere und danach mit grep nach der Pixelfarbe suche dauert das konvertieren ein paar Sekunden und grep ein paar bis viele Minuten. Und Imagemagick kann viel, und wenn man im convert Befehl von Imagemagick gleich auch nach den rgb Farben suchen könnte wäre das vielleicht schneller. Ich habe immer Imagemagick für Pixelfarben und Bilder benützt.
Btw. GraphicsMagic ist eine Alternative zu ImageMagick, die oft schneller ist.
|
ka111
(Themenstarter)
Anmeldungsdatum: 22. Juni 2014
Beiträge: 141
|
Wo müsste ich den Pfad zum Bild angeben in diesem Python Script? Auf der Kommandozeile beim Aufruf. Das sieht man in Zeile 18.
Und wie kann ich den Pfad direkt im Script angeben?
Btw. GraphicsMagic ist eine Alternative zu ImageMagick, die oft schneller ist.
Sind das die gleichen Befehle wie mit ImageMagick nur mit gm davor? Ich schaue es mir mal an, danke.
|
seahawk1986
Anmeldungsdatum: 27. Oktober 2006
Beiträge: 11179
Wohnort: München
|
ka111 schrieb: Und wie kann ich den Pfad direkt im Script angeben?
Zum Beispiel so (Pfad zum Bild in Zeile 13):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32 | #!/usr/bin/env python3
import sys
import cv2
import numpy as np
r_min = 50
r_max = 100
g_min = 100
g_max = 200
b_min = 200
b_max = 255
image = "test.png"
# opencv uses a BGR instead of a RGB color space by default!
lower_bound = np.array([b_min, g_min, r_min])
upper_bound = np.array([b_max, g_max, r_max])
try:
img = cv2.imread(image)
except OSError as e:
print(e, file=sys.stderr)
else:
with open(image + ".matching_pixels.txt", "w") as f:
mask = cv2.inRange(img, lower_bound, upper_bound)
for x, (row, mask_row) in enumerate(zip(img, mask)):
for y, (pixel, pixel_mask) in enumerate(zip(row, mask_row)):
if pixel_mask:
print(f"{x},{y}:{','.join(str(v) for v in reversed(pixel))}",
file=f)
|
Wenn man mehr als ein Bild hat ist es aber effizienter das Skript nur einmal zu starten und dann über alle Bilder zu iterieren als es für jedes Bild neu aufzurufen.
|
ka111
(Themenstarter)
Anmeldungsdatum: 22. Juni 2014
Beiträge: 141
|
Das funktioniert, und ist sogar schneller als nur convert. Weisst du auch wie ich die Farb-Variablen ?_min und ?_max aus Dateien beziehe die gleich heissen wie die Variable? Also r_min aus einer Datei die r_min heisst und 50 beinhaltet? Edit: Und GraphicsMagick convertiert ja extrem schnell im gegensatz zu ImageMagick.
|
seahawk1986
Anmeldungsdatum: 27. Oktober 2006
Beiträge: 11179
Wohnort: München
|
ka111 schrieb: Das funktioniert, und ist sogar schneller als nur convert. Weisst du auch wie ich die Farb-Variablen ?_min und ?_max aus Dateien beziehe die gleich heissen wie die Variable? Also r_min aus einer Datei die r_min heisst und 50 beinhaltet?
Ja, das ginge z.B. so:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36 | #!/usr/bin/env python3
import sys
import cv2
import numpy as np
rgb_value_files = [
'r_min',
'r_max',
'g_min',
'g_max',
'b_min',
'b_max',
]
for value_file in rgb_value_files:
with open(value_file) as f:
value = f.readline().strip()
globals()[value_file] = int(value)
# opencv uses a BGR instead of a RGB color space!
lower_bound = np.array([b_min, g_min, r_min])
upper_bound = np.array([b_max, g_max, r_max])
for image in sys.argv[1:]:
try:
img = cv2.imread(image)
except OSError as e:
print(e, file=sys.stderr)
else:
with open(image + ".matching_pixels.txt", "w") as f:
mask = cv2.inRange(img, lower_bound, upper_bound)
for x, (row, mask_row) in enumerate(zip(img, mask)):
for y, (pixel, pixel_mask) in enumerate(zip(row, mask_row)):
if pixel_mask:
print(f"{x},{y}:{','.join(str(v) for v in reversed(pixel))}",
file=f)
|
|
ka111
(Themenstarter)
Anmeldungsdatum: 22. Juni 2014
Beiträge: 141
|
Das scheint zu funktionieren, danke vielmals 😀 (So mit Pfad zum Bild:)
#!/usr/bin/env python3
import sys
import cv2
import numpy as np
image = "bild.png"
rgb_value_files = [
'r_min',
'r_max',
'g_min',
'g_max',
'b_min',
'b_max',
]
for value_file in rgb_value_files:
with open(value_file) as f:
value = f.readline().strip()
globals()[value_file] = int(value)
# opencv uses a BGR instead of a RGB color space!
lower_bound = np.array([b_min, g_min, r_min])
upper_bound = np.array([b_max, g_max, r_max])
try:
img = cv2.imread(image)
except OSError as e:
print(e, file=sys.stderr)
else:
with open(image + ".matching_pixels.txt", "w") as f:
mask = cv2.inRange(img, lower_bound, upper_bound)
for x, (row, mask_row) in enumerate(zip(img, mask)):
for y, (pixel, pixel_mask) in enumerate(zip(row, mask_row)):
if pixel_mask:
print(f"{x},{y}:{','.join(str(v) for v in reversed(pixel))}",
file=f)
Würde mich jetzt aber trotzdem noch interessieren wie schnell ImageMagick und GraphicsMagick wären wenn man es direkt mit einem convert Befehl machen könnte, ich habe im Internet gesehen das man einen Pixel Bereich umfärben kann, aber wie man es herausschneidet so dass das Bild dann auch kleiner wird habe ich nirgends gesehen, vielleicht weis das ja noch irgend jemand. Danke jedenfalls allen für die Hilfe
|
seahawk1986
Anmeldungsdatum: 27. Oktober 2006
Beiträge: 11179
Wohnort: München
|
Wenn du das Bild anhand der gefundenen Punkte beschneiden willst (anstatt die Koordinaten der gefundenen Punkte rauszuschreiben), geht das so:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 | #!/usr/bin/env python3
import sys
import cv2
import numpy as np
image = "test.png"
cropped_image = "cropped_test.png"
rgb_value_files = [
'r_min',
'r_max',
'g_min',
'g_max',
'b_min',
'b_max',
]
for value_file in rgb_value_files:
with open(value_file) as f:
value = f.readline().strip()
globals()[value_file] = int(value)
# opencv uses a BGR instead of a RGB color space!
lower_bound = np.array([b_min, g_min, r_min])
upper_bound = np.array([b_max, g_max, r_max])
img = cv2.imread(image)
if img is None:
sys.exit("could not read image", image, file=sys.stderr)
mask = cv2.inRange(img, lower_bound, upper_bound)
x, y, w, h = cv2.boundingRect(mask)
crop_slice = img[y:y+h, x:x+w]
cv2.imwrite(cropped_image, crop_slice)
|
Edit: überflüssige Zeile entfernt. Edit2: Tippfehler (ein y durch ein x ersetzt) Edit3: Das Öffnen der Text Datei kann auch noch raus.
|
ka111
(Themenstarter)
Anmeldungsdatum: 22. Juni 2014
Beiträge: 141
|
Ich wollte das Bild zwar nicht beschneiden anhand der gesuchten Pixel, aber ich habe sonst manchmal zuerst einen kleinen Teil vom Bild herausgeschnitten und dort drin nach Pixelfarben gesucht wenn es sehr schnell gehen muss. Und das scheint auch zu funktionieren, sogar mit der Bildgrösse als Variablen aus Dateien geholt. Ist das so richtig? :
#!/usr/bin/env python3
import sys
import cv2
import numpy as np
image = "bild.png"
cropped_image = "geschnitten.png"
rgb_value_files = [
'rmin',
'rmax',
'gmin',
'gmax',
'bmin',
'bmax',
'xvon',
'xbis',
'yvon',
'ybis',
]
for value_file in rgb_value_files:
with open(value_file) as f:
value = f.readline().strip()
globals()[value_file] = int(value)
# opencv uses a BGR instead of a RGB color space!
lower_bound = np.array([bmin, gmin, rmin])
upper_bound = np.array([bmax, gmax, rmax])
try:
img = cv2.imread(image)
crop_slice = img[xvon:xbis, yvon:ybis]
cv2.imwrite(cropped_image, crop_slice)
img = cv2.imread(cropped_image)
except OSError as e:
print(e, file=sys.stderr)
else:
with open(cropped_image + ".ergebnis.txt", "w") as f:
mask = cv2.inRange(img, lower_bound, upper_bound)
for x, (row, mask_row) in enumerate(zip(img, mask)):
for y, (pixel, pixel_mask) in enumerate(zip(row, mask_row)):
if pixel_mask:
print(f"{x},{y}:{','.join(str(v) for v in reversed(pixel))}",
file=f)
|
seahawk1986
Anmeldungsdatum: 27. Oktober 2006
Beiträge: 11179
Wohnort: München
|
Ich glaube da stimmt das Beschneiden des Bildes nicht, ich habe noch mal in die Dokumenation zu opencv geschaut, die Matrix will zuerst die y-Koordinate und dann die X-Koordinaten haben. Bei der Ausgabe waren x und y fälschlicherweise ebenefalls vertauscht. Als Optimierung könntest du den Slice des Bildes crop_slice einfach weiter benutzen als es auf die Platte zu schreiben und dann wieder zu laden. Je nach Bildgröße könnte es (weil das durchsuchen von mehrdimensionalen Numpy-Arrays mit den von OpenCV bereitgestellten Methoden viel schneller ist als da mit Python-Konstrukten darüber zu iterieren) sinnvoll sein, sich erst die Bounding-Box zu suchen, einen weiteren Slice dafür zu erstellen und dann erst mit einem Offset darüber zu laufen:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49 | #!/usr/bin/env python3
import sys
import cv2
import numpy as np
image = "bild.png"
cropped_image = "geschnitten.png"
rgb_value_files = [
'rmin',
'rmax',
'gmin',
'gmax',
'bmin',
'bmax',
'xvon',
'xbis',
'yvon',
'ybis',
]
for value_file in rgb_value_files:
with open(value_file) as f:
value = f.readline().strip()
globals()[value_file] = int(value)
# opencv uses a BGR instead of a RGB color space!
lower_bound = np.array([bmin, gmin, rmin])
upper_bound = np.array([bmax, gmax, rmax])
try:
img = cv2.imread(image)
crop_slice = img[yvon:ybis, xvon:xbis]
cv2.imwrite(cropped_image, crop_slice)
mask = cv2.inRange(crop_slice, lower_bound, upper_bound)
x, y, w, h = cv2.boundingRect(mask)
box_slice = crop_slice[y:y+h, x:x+w]
mask_slice = mask[y:y+h, x:x+w]
print(box_slice.shape)
except OSError as e:
print(e, file=sys.stderr)
else:
with open(cropped_image + ".ergebnis.txt", "w") as f:
for y_pix, (row, mask_row) in enumerate(zip(box_slice, mask_slice), start=y):
for x_pix, (pixel, pixel_mask) in enumerate(zip(row, mask_row), start=x):
if pixel_mask:
print(f"{x_pix},{y_pix}:{','.join(str(v) for v in reversed(pixel))}",
file=f)
|
Um noch mehr Geschwindigkeit herauszuholen könnte man sich ggf. noch überlegen die for-Schleife durch eine in Cython geschriebene Funktion zu ersetzen: https://www.pyimagesearch.com/2017/08/28/fast-optimized-for-pixel-loops-with-opencv-and-python/
|
ka111
(Themenstarter)
Anmeldungsdatum: 22. Juni 2014
Beiträge: 141
|
Ou, da komme ich langsam nicht mehr mit. Hast du in dem Script jetzt crop_slice weiter benutzt und eine Bounding-Box gesucht und einen weiteren Slice dafür erstellt und bist dann mit einem Offset darüber gelaufen? Diese beiden Scripte sind bei mir mit einem Bild das 3000x3000 Pixel hat beide 29s schnell, wenn man nach allen Farben sucht (0-255 für r g b). Und es gibt immer eine Zeile aus beim letzten Script: (2999, 1569, 3), ich habe auf 2999x2999 Pixel beschnitten.
Und es stimmt das die Pixel verkehrt waren, hatte ich gar nicht gemerkt weil ich immer mit einem Quadrat getestet habe das x und y gleich hatte. Also wäre es dann mit dem ersten schneid-Script und ohne schneiden so:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46 | #!/usr/bin/env python3
import sys
import cv2
import numpy as np
image = "bild.png"
cropped_image = "geschnitten.png"
rgb_value_files = [
'rmin',
'rmax',
'gmin',
'gmax',
'bmin',
'bmax',
'xvon',
'xbis',
'yvon',
'ybis',
]
for value_file in rgb_value_files:
with open(value_file) as f:
value = f.readline().strip()
globals()[value_file] = int(value)
# opencv uses a BGR instead of a RGB color space!
lower_bound = np.array([bmin, gmin, rmin])
upper_bound = np.array([bmax, gmax, rmax])
try:
img = cv2.imread(image)
crop_slice = img[yvon:ybis, xvon:xbis]
cv2.imwrite(cropped_image, crop_slice)
img = cv2.imread(cropped_image)
except OSError as e:
print(e, file=sys.stderr)
else:
with open(cropped_image + ".ergebnis.txt", "w") as f:
mask = cv2.inRange(img, lower_bound, upper_bound)
for y, (row, mask_row) in enumerate(zip(img, mask)):
for x, (pixel, pixel_mask) in enumerate(zip(row, mask_row)):
if pixel_mask:
print(f"{x},{y}:{','.join(str(v) for v in reversed(pixel))}",
file=f)
|
und 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37 | #!/usr/bin/env python3
import sys
import cv2
import numpy as np
image = "bild.png"
rgb_value_files = [
'rmin',
'rmax',
'gmin',
'gmax',
'bmin',
'bmax',
]
for value_file in rgb_value_files:
with open(value_file) as f:
value = f.readline().strip()
globals()[value_file] = int(value)
# opencv uses a BGR instead of a RGB color space!
lower_bound = np.array([bmin, gmin, rmin])
upper_bound = np.array([bmax, gmax, rmax])
try:
img = cv2.imread(image)
except OSError as e:
print(e, file=sys.stderr)
else:
with open(image + ".ergebnis.txt", "w") as f:
mask = cv2.inRange(img, lower_bound, upper_bound)
for y, (row, mask_row) in enumerate(zip(img, mask)):
for x, (pixel, pixel_mask) in enumerate(zip(row, mask_row)):
if pixel_mask:
print(f"{x},{y}:{','.join(str(v) for v in reversed(pixel))}",
file=f)
|
Das ist richtig oder? Du hast die zweitletzte Zeile etwas anders im letzten Script geschrieben, aber es funktioniert so.
Eigentlich reichen diese auch im Moment, Cython sieht interessant aus wenn es irgendwann mal wirklich schnell gehen muss. Edit: Ah nein, das Bild hat nur 1569x3000 Pixel, egal es gibt die Zeile trotzdem aus, auch wenn ich nur nach x 1500 und y 2999 schneide.
|
seahawk1986
Anmeldungsdatum: 27. Oktober 2006
Beiträge: 11179
Wohnort: München
|
ka111 schrieb: Ou, da komme ich langsam nicht mehr mit. Hast du in dem Script jetzt crop_slice weiter benutzt und eine Bounding-Box gesucht und einen weiteren Slice dafür erstellt und bist dann mit einem Offset darüber gelaufen? Diese beiden Scripte sind bei mir mit einem Bild das 3000x3000 Pixel hat beide 29s schnell, wenn man nach allen Farben sucht (0-255 für r g b).
Ja, da hilft nur ausprobieren - es sollte einen Unterschied machen, wenn das zugeschnittene Bild deutlich größer ist als der Bereich mit den Pixeln, die in dem gesuchten Farbraum liegen. Wenn man nach allen Farben sucht, ist sind das beschnittene Bild und die Bounding-Box ja zwangsläufig gleich groß. Und es gibt immer eine Zeile aus beim letzten Script: (2999, 1569, 3)
Das print-Statement in Zeile 39 kann noch raus, das gibt die Größe des von der Bounding-Box eingeschlossenen mehrdimensionalen Arrays aus. Und es stimmt das die Pixel verkehrt waren, hatte ich gar nicht gemerkt weil ich immer mit einem Quadrat getestet habe das x und y gleich hatte. Also wäre es dann mit dem ersten schneid-Script und ohne schneiden so:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46 | #!/usr/bin/env python3
import sys
import cv2
import numpy as np
image = "bild.png"
cropped_image = "geschnitten.png"
rgb_value_files = [
'rmin',
'rmax',
'gmin',
'gmax',
'bmin',
'bmax',
'xvon',
'xbis',
'yvon',
'ybis',
]
for value_file in rgb_value_files:
with open(value_file) as f:
value = f.readline().strip()
globals()[value_file] = int(value)
# opencv uses a BGR instead of a RGB color space!
lower_bound = np.array([bmin, gmin, rmin])
upper_bound = np.array([bmax, gmax, rmax])
try:
img = cv2.imread(image)
crop_slice = img[yvon:ybis, xvon:xbis]
cv2.imwrite(cropped_image, crop_slice)
img = cv2.imread(cropped_image)
except OSError as e:
print(e, file=sys.stderr)
else:
with open(cropped_image + ".ergebnis.txt", "w") as f:
mask = cv2.inRange(img, lower_bound, upper_bound)
for y, (row, mask_row) in enumerate(zip(img, mask)):
for x, (pixel, pixel_mask) in enumerate(zip(row, mask_row)):
if pixel_mask:
print(f"{x},{y}:{','.join(str(v) for v in reversed(pixel))}",
file=f)
|
Ja, wobei es wie schon weiter oben erwähnt nicht nötig ist das Bild in Zeile 35 neu einzulesen, weil man direkt mit dem Slice weiterarbeiten kann (das originale Bild bleibt dann einfach im Speicher und man schaut wie durch ein Fenster auf eine begrenzte Darstellung von selbigem, spart sich also das verlgeichsweise langsame erneute Einlesen). und 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37 | #!/usr/bin/env python3
import sys
import cv2
import numpy as np
image = "bild.png"
rgb_value_files = [
'rmin',
'rmax',
'gmin',
'gmax',
'bmin',
'bmax',
]
for value_file in rgb_value_files:
with open(value_file) as f:
value = f.readline().strip()
globals()[value_file] = int(value)
# opencv uses a BGR instead of a RGB color space!
lower_bound = np.array([bmin, gmin, rmin])
upper_bound = np.array([bmax, gmax, rmax])
try:
img = cv2.imread(image)
except OSError as e:
print(e, file=sys.stderr)
else:
with open(image + ".ergebnis.txt", "w") as f:
mask = cv2.inRange(img, lower_bound, upper_bound)
for y, (row, mask_row) in enumerate(zip(img, mask)):
for x, (pixel, pixel_mask) in enumerate(zip(row, mask_row)):
if pixel_mask:
print(f"{x},{y}:{','.join(str(v) for v in reversed(pixel))}",
file=f)
|
Das ist richtig oder?
Wenn es das tut, was du erwartest - ja. Du hast die zweitletzte Zeile etwas anders im letzten Script geschrieben, aber es funktioniert so.
Da ich das x und y von der Bounding-Box noch in der for-Schleife benutze, musste ich die Variablen für die Koordinaten nach x_pix und y_pix umbenennen.
|
ka111
(Themenstarter)
Anmeldungsdatum: 22. Juni 2014
Beiträge: 141
|
Das print-Statement in Zeile 39 kann noch raus, das gibt die Größe des von der Bounding-Box eingeschlossenen mehrdimensionalen Arrays aus.
Ah ja, jetzt gibt es keine Zeile mehr aus. Ja, wobei es wie schon weiter oben erwähnt nicht nötig ist das Bild in Zeile 35 neu einzulesen, weil man direkt mit dem Slice weiterarbeiten kann (das originale Bild bleibt dann einfach im Speicher und man schaut wie durch ein Fenster auf eine begrenzte Darstellung von selbigem, spart sich also das verlgeichsweise langsame erneute Einlesen).
Aber ohne diese Zeile findet es so viele Pixel wie wenn ich im ganzen Bild suche, es funktioniert irgendwie nicht ohne diese Zeile bei mir. Ich glaube die scheint nötig zu sein. - es sollte einen Unterschied machen, wenn das zugeschnittene Bild deutlich größer ist als der Bereich mit den Pixeln, die in dem gesuchten Farbraum liegen.
Ok, ich teste noch ein wenig.
|