diff options
| -rw-r--r-- | de-de/opencv-de.html.markdown | 152 | ||||
| -rw-r--r-- | de-de/shutit-de.html.markdown | 330 |
2 files changed, 482 insertions, 0 deletions
diff --git a/de-de/opencv-de.html.markdown b/de-de/opencv-de.html.markdown new file mode 100644 index 00000000..31d0d05f --- /dev/null +++ b/de-de/opencv-de.html.markdown @@ -0,0 +1,152 @@ +--- +category: tool +tool: OpenCV +filename: learnopencv.py +contributors: + - ["Yogesh Ojha", "http://github.com/yogeshojha"] +translators: + - ["Dennis Keller", "https://github.com/denniskeller"] +lang: de-de +--- +### Opencv + +OpenCV (Open Source Computer Vision) ist eine Bibliothek von Programmierfunktionen, +die hauptsächlich auf maschinelles Sehen in Echtzeit ausgerichtet ist. +Ursprünglich wurde OpenCV von Intel entwickelt. Später wurde es von von +Willow Garage und dann Itseez (das später von Intel übernommen wurde) unterstützt. +OpenCV unterstützt derzeit eine Vielzahl von Sprachen, wie C++, Python, Java uvm. + +#### Installation + +Bitte lese diese Artikel für die Installation von OpenCV auf deinen Computer. + +* Windows Installationsanleitung: [https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_setup/py_setup_in_windows/py_setup_in_windows.html#install-opencv-python-in-windows]() +* Mac Installationsanleitung (High Sierra): [https://medium.com/@nuwanprabhath/installing-opencv-in-macos-high-sierra-for-python-3-89c79f0a246a]() +* Linux Installationsanleitung (Ubuntu 18.04): [https://www.pyimagesearch.com/2018/05/28/ubuntu-18-04-how-to-install-opencv]() + +### Hier werden wir uns auf die Pythonimplementierung von OpenCV konzentrieren. + +```python +# Bild in OpenCV lesen +import cv2 +img = cv2.imread('Katze.jpg') + +# Bild darstellen +# Die imshow() Funktion wird verwendet um das Display darzustellen. +cv2.imshow('Image',img) +# Das erste Argument ist der Titel des Fensters und der zweite Parameter ist das Bild +# Wenn du den Fehler Object Type None bekommst ist eventuell dein Bildpfad falsch. +# Bitte überprüfe dann den Pfad des Bildes erneut. +cv2.waitKey(0) +# waitKey() ist eine Tastaturbindungsfunktion, sie nimmt Argumente in +# Millisekunden an. Für GUI Ereignisse MUSST du die waitKey() Funktion verwenden. + +# Ein Bild schreiben +cv2.imwrite('graueKatze.png',img) +# Das erste Arkument ist der Dateiname und das Zweite ist das Bild + +# Konveriere das Bild zu Graustufen +gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) + +# Videoaufnahme von der Webcam +cap = cv2.VideoCapture(0) +# 0 ist deine Kamera, wenn du mehrere Kameras hast musst du deren Id eingeben +while(True): + # Erfassen von Einzelbildern + _, frame = cap.read() + cv2.imshow('Frame',frame) + # Wenn der Benutzer q drückt -> beenden + if cv2.waitKey(1) & 0xFF == ord('q'): + break +# Die Kamera muss wieder freigegeben werden +cap.release() + +# Wiedergabe von Videos aus einer Datei +cap = cv2.VideoCapture('film.mp4') +while(cap.isOpened()): + _, frame = cap.read() + # Das Video in Graustufen abspielen + gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) + cv2.imshow('frame',gray) + if cv2.waitKey(1) & 0xFF == ord('q'): + break +cap.release() + +# Zeichne eine Linie in OpenCV +# cv2.line(img,(x,y),(x1,y1),(color->r,g,b->0 to 255),thickness) +cv2.line(img,(0,0),(511,511),(255,0,0),5) + +# Zeichne ein Rechteck +# cv2.rectangle(img,(x,y),(x1,y1),(color->r,g,b->0 to 255),thickness) +# thickness = -1 wird zum Füllen des Rechtecks verwendet +cv2.rectangle(img,(384,0),(510,128),(0,255,0),3) + +# Zeichne ein Kreis +cv2.circle(img,(xCenter,yCenter), radius, (color->r,g,b->0 to 255), thickness) +cv2.circle(img,(200,90), 100, (0,0,255), -1) + +# Zeichne eine Ellipse +cv2.ellipse(img,(256,256),(100,50),0,0,180,255,-1) + +# Text auf Bildern hinzufügen +cv2.putText(img,"Hello World!!!", (x,y), cv2.FONT_HERSHEY_SIMPLEX, 2, 255) + +# Bilder zusammenfüggen +img1 = cv2.imread('Katze.png') +img2 = cv2.imread('openCV.jpg') +dst = cv2.addWeighted(img1,0.5,img2,0.5,0) + +# Schwellwertbild +# Binäre Schwellenwerte +_,thresImg = cv2.threshold(img,127,255,cv2.THRESH_BINARY) +# Anpassbare Schwellenwerte +adapThres = cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY,11,2) + +# Weichzeichnung von einem Bild +# Gausßscher Weichzeichner +blur = cv2.GaussianBlur(img,(5,5),0) +# Rangordnungsfilter +medianBlur = cv2.medianBlur(img,5) + +# Canny-Algorithmus +img = cv2.imread('Katze.jpg',0) +edges = cv2.Canny(img,100,200) + +# Gesichtserkennung mit Haarkaskaden +# Lade die Haarkaskaden von https://github.com/opencv/opencv/blob/master/data/haarcascades/ herunter +import cv2 +import numpy as np +face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') +eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml') + +img = cv2.imread('Mensch.jpg') +gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) + +aces = face_cascade.detectMultiScale(gray, 1.3, 5) +for (x,y,w,h) in faces: + cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2) + roi_gray = gray[y:y+h, x:x+w] + roi_color = img[y:y+h, x:x+w] + eyes = eye_cascade.detectMultiScale(roi_gray) + for (ex,ey,ew,eh) in eyes: + cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2) + +cv2.imshow('img',img) +cv2.waitKey(0) + +cv2.destroyAllWindows() +# destroyAllWindows() zerstört alle Fenster +# Wenn du ein bestimmtes Fenter zerstören möchtest musst du den genauen Namen des +# von dir erstellten Fensters übergeben. +``` + +### Weiterführende Literatur: +* Lade Kaskade hier herunter [https://github.com/opencv/opencv/blob/master/data/haarcascades]() +* OpenCV Zeichenfunktionen [https://docs.opencv.org/2.4/modules/core/doc/drawing_functions.html]() +* Eine aktuelle Sprachenreferenz kann hier gefunden werden [https://opencv.org]() +* Zusätzliche Ressourcen können hier gefunden werden [https://en.wikipedia.org/wiki/OpenCV]() +* Gute OpenCv Tutorials + * [https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_tutorials.html]() + * [https://realpython.com/python-opencv-color-spaces]() + * [https://pyimagesearch.com]() + * [https://www.learnopencv.com]() diff --git a/de-de/shutit-de.html.markdown b/de-de/shutit-de.html.markdown new file mode 100644 index 00000000..f66ed906 --- /dev/null +++ b/de-de/shutit-de.html.markdown @@ -0,0 +1,330 @@ +--- +category: tool +filename: learnshutit.html +tool: ShutIt +contributors: + - ["Ian Miell", "http://ian.meirionconsulting.tk"] +translators: + - ["Dennis Keller", "https://github.com/denniskeller"] +lang: de-de +--- + +## ShutIt + +ShuIt ist eine Shellautomationsframework, welches für eine einfache +Handhabung entwickelt wurde. + +Er ist ein Wrapper, der auf einem Python expect Klon (pexpect) basiert. + +Es ist damit ein 'expect ohne Schmerzen'. + +Es ist verfügbar als pip install. + +## Hello World + +Starten wir mit dem einfachsten Beispiel. Erstelle eine Datei names example.py + +```python + +import shutit +session = shutit.create_session('bash') +session.send('echo Hello World', echo=True) +``` + +Führe es hiermit aus: + +```bash +python example.py +``` + +gibt aus: + +```bash +$ python example.py +echo "Hello World" +echo "Hello World" +Hello World +Ians-MacBook-Air.local:ORIGIN_ENV:RhuebR2T# +``` + +Das erste Argument zu 'send' ist der Befehl, den du ausführen möchtest. +Das 'echo' Argument gibt die Terminalinteraktion aus. ShuIt ist standardmäßig leise. + +'Send' kümmert sich um die nervige Arbeiten mit den Prompts und macht +alles was du von 'expect' erwarten würdest. + + +## Logge dich auf einen Server ein + +Sagen wir du möchtest dich auf einen Server einloggen und einen Befehl ausführen. +Ändere dafür example.py folgendermaßen: + +```python +import shutit +session = shutit.create_session('bash') +session.login('ssh you@example.com', user='du', password='meinpassword') +session.send('hostname', echo=True) +session.logout() +``` + +Dies erlaubt dir dich auf deinen Server einzuloggen +(ersetze die Details mit deinen Eigenen) und das Programm gibt dir deinen Hostnamen aus. + +``` +$ python example.py +hostname +hostname +example.com +example.com:cgoIsdVv:heDa77HB# +``` + + +Es ist klar das das nicht sicher ist. Stattdessen kann man Folgendes machen: + +```python +import shutit +session = shutit.create_session('bash') +password = session.get_input('', ispass=True) +session.login('ssh you@example.com', user='du', password=password) +session.send('hostname', echo=True) +session.logout() +``` + +Dies zwingt dich dein Passwort einzugeben: + +``` +$ python example.py +Input Secret: +hostname +hostname +example.com +example.com:cgoIsdVv:heDa77HB# +``` + + +Die 'login' Methode übernimmt wieder das veränderte Prompt für den Login. +Du übergibst ShutIt den User und das Passwort, falls es benötigt wird, +mit den du dich einloggen möchtest. ShutIt übernimmt den Rest. + +'logout' behandelt das Ende von 'login' und übernimmt alle Veränderungen des +Prompts für dich. + +## Einloggen auf mehrere Server + +Sagen wir, dass du eine Serverfarm mit zwei Servern hast und du dich in +beide Server einloggen möchtest. Dafür musst du nur zwei Session und +Logins erstellen und kannst dann Befehle schicken: + +```python +import shutit +session1 = shutit.create_session('bash') +session2 = shutit.create_session('bash') +password1 = session1.get_input('Password für server1', ispass=True) +password2 = session2.get_input('Password für server2', ispass=True) +session1.login('ssh you@one.example.com', user='du', password=password1) +session2.login('ssh you@two.example.com', user='du', password=password2) +session1.send('hostname', echo=True) +session2.send('hostname', echo=True) +session1.logout() +session2.logout() +``` + +Gibt aus: + +```bash +$ python example.py +Password for server1 +Input Secret: + +Password for server2 +Input Secret: +hostname +hostname +one.example.com +one.example.com:Fnh2pyFj:qkrsmUNs# hostname +hostname +two.example.com +two.example.com:Gl2lldEo:D3FavQjA# +``` + +## Beispiel: Überwachen mehrerer Server + +Wir können das obige Programm in ein einfaches Überwachungstool bringen indem +wir Logik hinzufügen um die Ausgabe von einem Befehl zu betrachten. + +```python +import shutit +capacity_command="""df / | awk '{print $5}' | tail -1 | sed s/[^0-9]//""" +session1 = shutit.create_session('bash') +session2 = shutit.create_session('bash') +password1 = session.get_input('Passwort für Server1', ispass=True) +password2 = session.get_input('Passwort für Server2', ispass=True) +session1.login('ssh you@one.example.com', user='du', password=password1) +session2.login('ssh you@two.example.com', user='du', password=password2) +capacity = session1.send_and_get_output(capacity_command) +if int(capacity) < 10: + print(kein Platz mehr auf Server1!') +capacity = session2.send_and_get_output(capacity_command) +if int(capacity) < 10: + print(kein Platz mehr auf Server2!') +session1.logout() +session2.logout() +``` + +Hier kannst du die 'send\_and\_get\_output' Methode verwenden um die Ausgabe von dem +Kapazitätsbefehl (df) zu erhalten. + +Es gibt elegantere Wege als oben (z.B. kannst du ein Dictionary verwenden um über +die Server zu iterieren), aber es hängt and dir wie clever das Python sein muss. + + +## kompliziertere IO - Expecting + +Sagen wir du hast eine Interaktion mit einer interaktiven Kommandozeilenprogramm, +die du automatisieren möchtest. Hier werden wir Telnet als triviales Beispiel verwenden: + +```python +import shutit +session = shutit.create_session('bash') +session.send('telnet', expect='elnet>', echo=True) +session.send('open google.com 80', expect='scape character', echo=True) +session.send('GET /', echo=True, check_exit=False) +session.logout() +``` + +Beachte das 'expect' Argument. Du brauchst nur ein Subset von Telnets +Eingabeaufforderung um es abzugleichen und fortzufahren. + +Beachte auch das neue Argument 'check\_exit'. Wir werden nachher nochmal +darauf zurückkommen. Die Ausgabe von oben ist: + +```bash +$ python example.py +telnet +telnet> open google.com 80 +Trying 216.58.214.14... +Connected to google.com. +Escape character is '^]'. +GET / +HTTP/1.0 302 Found +Cache-Control: private +Content-Type: text/html; charset=UTF-8 +Referrer-Policy: no-referrer +Location: http://www.google.co.uk/?gfe_rd=cr&ei=huczWcj3GfTW8gfq0paQDA +Content-Length: 261 +Date: Sun, 04 Jun 2017 10:57:10 GMT + +<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8"> +<TITLE>302 Moved</TITLE></HEAD><BODY> +<H1>302 Moved</H1> +The document has moved +<A HREF="http://www.google.co.uk/?gfe_rd=cr&ei=huczWcj3GfTW8gfq0paQDA"> +here +</A>. +</BODY></HTML> +Connection closed by foreign host. +``` + +Nun zurück zu 'check\_exit=False'. Da das Telnet Programm einen Fehler mit +Fehlercode (1) zurückgibt und wir nicht möchten das das Skript fehlschlägt +kannst du 'check\_exit=False' setzen und damit ShuIt wissen lassen, dass +der Ausgabecode dich nicht interessiert. + +Wenn du das Argument nicht mitgegeben hättest, dann hätte dir ShutIt +ein interaktives Terminal zurückgegeben, falls es ein Terminal zum +kommunizieren gibt. Dies nennt sich ein 'Pause point'. + + +## Pause Points + +Du kannst jederzeit 'pause point' auslösen, wenn du Folgendes in deinem Skript aufrufst: + +```python +[...] +session.pause_point('Das ist ein pause point') +[...] +``` + +Danach kannst du das Skript fortführen, wenn du CTRL und ']' zur selben Zeit drückst. +Dies ist gut für Debugging: Füge ein Pause Point hinzu und schaue dich um. +Danach kannst du das Programm weiter ausführen. Probiere folgendes aus: + +```python +import shutit +session = shutit.create_session('bash') +session.pause_point('Schaue dich um!') +session.send('echo "Hat dir der Pause point gefallen?"', echo=True) +``` + +Dies würde folgendes ausgeben: + +```bash +$ python example.py +Schaue dich um! + +Ians-Air.home:ORIGIN_ENV:I00LA1Mq# bash +imiell@Ians-Air:/space/git/shutit ⑂ master + +CTRL-] caught, continuing with run... +2017-06-05 15:12:33,577 INFO: Sending: exit +2017-06-05 15:12:33,633 INFO: Output (squashed): exitexitIans-Air.home:ORIGIN_ENV:I00LA1Mq# [...] +echo "Hat dir der Pause point gefallen?" +echo "Hat dir der Pause point gefallen?" +Hat dir der Pause point gefallen? +Ians-Air.home:ORIGIN_ENV:I00LA1Mq# +``` + + +## noch kompliziertere IO - Hintergrund + +Kehren wir zu unseren Beispiel mit dem Überwachen von mehreren Servern zurück. +Stellen wir uns vor, dass wir eine langlaufende Aufgabe auf jedem Server durchführen möchten. +Standardmäßig arbeitet ShutIt seriell, was sehr lange dauern würde. +Wir können jedoch die Aufgaben im Hintergrund laufen lassen um sie zu beschleunigen. + +Hier ist ein Beispiel, welches du ausprobieren kannst. +Es verwendet den trivialen Befehl: 'sleep'. + + +```python +import shutit +import time +long_command="""sleep 60""" +session1 = shutit.create_session('bash') +session2 = shutit.create_session('bash') +password1 = session1.get_input('Password for server1', ispass=True) +password2 = session2.get_input('Password for server2', ispass=True) +session1.login('ssh you@one.example.com', user='du', password=password1) +session2.login('ssh you@two.example.com', user='du', password=password2) +start = time.time() +session1.send(long_command, background=True) +session2.send(long_command, background=True) +print('Es hat: ' + str(time.time() - start) + ' Sekunden zum Starten gebraucht') +session1.wait() +session2.wait() +print('Es hat:' + str(time.time() - start) + ' Sekunden zum Vollenden gebraucht') +``` + +Mein Computer meint, dass er 0.5 Sekunden gebraucht hat um die Befehle zu starten +und dann nur etwas über eine Minute gebraucht um sie zu beenden +(mit Verwendung der 'wait' Methode). + + +Das alles ist trivial, aber stelle dir vor das du hunderte an Servern so managen +kannst und man kann nun das Potential sehen, die in ein paar Zeilen Code und ein Python +import liegen können. + + +## Lerne mehr + +Es gibt noch viel mehr, was mit ShutIt erreicht werden kann. + +Um mehr zu erfahren, siehe: + +[ShutIt](https://ianmiell.github.io/shutit/) +[GitHub](https://github.com/ianmiell/shutit/blob/master/README.md) + +Es handelt sich um ein breiteres Automatiesierungsframework, und das oben +genannte ist der sogennante 'standalone Modus'. + +Feedback, feature requests, 'Wie mache ich es' sind herzlich willkommen! Erreiche mit unter +[@ianmiell](https://twitter.com/ianmiell) |