Wand TypeError

[__blackjack__]

Und diese Klasse ist immer noch unsinnig und überflüssig.

[__deets__]

Na die scheint in ein Framework oä zu gehören. Aber gerade dann ist das manipulieren des current directory erst recht riskant. Wenn andere das auch tun....

[Felix92]

Ok das mit dem enumerate verstehe ich noch allerdings hatte ich damit Probleme beim sortieren der Bilder und bei chdir weiß ich nicht wie ich sonst in den neu angelegten Ordner schreiben soll !? Die Klasse wird so benötigt, da sie im model des Projekts liegt und da liegt noch ne GUI drüber etc.

[sparrow]

bei chdir weiß ich nicht wie ich sonst in den neu angelegten Ordner schreiben soll !?

Indem du den kompleten Pfad der zur Datei und nicht nur den Dateinamen angibst.

[DeaD_EyE]

Edit: Dein Programm kann überall dort hinschreiben, zu dem es auch die entsprechenden Berechtigungen hat.
Das aktuelle Verzeichnis zu wechseln ist überhaupt nicht notwendig. Das muss man nur machen, wenn man irgendwelche schlechten Bibliotheken nutzt, die einem keine andere Wahl lassen.

Code: Alles auswählen

from pdf2image import convert_from_path
from pathlib import Path


def convert(path, filename, folder_path, folder_name):
    """a function that creates a new project folder split the pdf to pictures and save them in the new folder"""
    folder = Path(folder_path, folder_name)
    folder.mkdir(exist_ok=True) 
    input_file = Path(path, filename)
    pages = convert_from_path(str(input_file), 300)
    for page_number, page in enumerate(pages, start=1):
        target = folder / f"{page_number:03d}.jpg"
        page.save(str(target),  'JPEG')

Ich bin ein pathlib-faschist.
Code ist nicht getestet. Wenn man noch alte Bibliotheken verwendet, müssen die Path Objekte zuvor in einen String umgewandelt werden.
Das aktuelle Verzeichnis zur Laufzeit des Programms zu wechseln, ist eine ganz schlechte Idee. Eine Klasse mit zwei Methoden ist keine Klasse.
Das ignorieren von Vorschlägen führt dazu, dass du vieles per Hand machst (enumerate z.B.).

Überlege dir andere Namen für die Variablen. path, filename, folder_path, folder_name kann alles mögliche sein.
Nutze nicht die ungarische Notation.

[Tholo]

@Dead_Eye
Was ist die ungarische Notation?
Edit: WTF das scheint wirklich ein Begriff in der Programmierung zu sein. Schau grad auf Wiki nach.
Gibt es auch die Thüringer Notation?

[Felix92]

@Dead_Eye
vielen Dank ich habe das mal umgesetzt Code läuft.
Notation ist vom Softwarearchitekten leider so vorgegeben.
MfG Felix

[Sirius3]

@Felix92: von welcher Notation redest Du?

[Felix92]

@Sirius3 hat sich erledigt habe gerade gegoogelt ^^ Diese ungarische Notation ist doch nichts anderes als camelCase wenn ich das gerade richtig gesehen habe !??

So zurück zum Thema da hätte ich nämlich gleich noch eine Frage
In der Methode check_color wird nun der Bereich des Bildes durchlaufen wo das Video dann platziert werden soll.
Das klappt auch ganz gut allerdings frage ich mich ob es nicht möglich wäre mit

Code: Alles auswählen

 box = (left_pixel, upper_pixel, right_pixel, lower_pixel)

einfach den kompletten Bereich zu überprüfen und sich somit die while zu sparen!??
Des weiteren würde ich gerne noch einfügen das der Hintergrund nicht 100% weiß sein muss sondern auch kleine Abweichungen erlaubt sind dazu ist mir allerdings leider noch keine "gute" Idee gekommen
kurz noch zur Erklärung: left_pixel und upper_pixel bilden im Koordinatensystem die (x,y)-Werte der obere linke Ecke des Videobereichs right_pixel und lower_pixel die untere rechte Ecke.

Code: Alles auswählen

def convert(self, file_path, filename, new_project_path, new_project_name):
        folder = Path(new_project_path, new_project_name)
        folder.mkdir(exist_ok=True) 
        input_file = Path(file_path, filename)
        pages = convert_from_path(str(input_file), 250)
        files = []
        for page_number, page in enumerate(pages, start=1):
            target = folder / f"{page_number:03d}.jpg"
            page.save(str(target),  'JPEG')
            
        for file in os.listdir(folder):
            files.append(file)

        files.sort()

    def check_color(self, file_path, filename, left_pixel, upper_pixel, right_pixel, lower_pixel):
        input_file = Path(file_path, filename)
        img = Image.open(input_file)
        width, height = img.size  #1260x945
        #box = (left_pixel, upper_pixel, right_pixel, lower_pixel)
        imgload = img.load()
        x = left_pixel
        y = upper_pixel
        window_width = right_pixel - left_pixel   
        
        while True:
            point = imgload[x, y]
            if point == (255, 255, 255):
                x += 1
                if x == width:
                    x -= window_width
                    y += 1
                elif x == right_pixel and y == lower_pixel:  
                        return True
            else:
                return False

[__deets__]

Du wirst nicht darum herumkommen, dir die Pixel anzuschauen. Aber natuerlich kannst du das mit anderen Methoden wie eben zb der OpenCV machen. Da gibt es dann Operationen, die auf dem gesamten Bildausschnitt arbeiten, und dir zB ein Histogramm der Grauwerte liefern, das du auswerten kannst. Oder Kontouren ermittelt, die du zaehlen kannst. Und mit oder ohne adaptive Thresholding vorher. Etc. Das ist dann halt computer vision. Wenn du da Fortschritte erzielen willst, ist es hilfreich dir eine Sammlung von positiv und negativ Beispielen zu erstellen, und deine Bewertungsfunktion einfach darauf anzuwenden, um zu sehen, ob sie die Beispiele richtig klassifiziert.

[__blackjack__]

@Felix92: Ungarische Notation hat nichts mit CamelCase zu tun, das geht auch nur mit Kleinbuchstaben und Unterstrichen.

Eine ``while``-Schleife falsch, auch wenn man sich die Pixel tatsächlich in Python-Code einzeln anschaut. Das ist ein Fall für ``for``-Schleifen.

Man könnte sich das Bild in ein Numpy-Array umwandeln, dann kann man sich Schleifen in Python sparen. Vorher vielleicht in ein Graustufenbild umwandeln, und hinterher 255 von dem Array abziehen und schauen ob absolute Werte über einer bestimmten Grenze übrig bleiben.

Und die ”Methoden” sind auch wieder/immer noch keine Methoden sondern einfach nur Funktionen die nichts in einer Klasse verloren haben. In der Klasse sollte man da mindestens mal `staticmethod()` verwenden, damit das klarer ist, das die überhaupt nicht vom Objekt abhängen.

Warum ist das denn in einer Klasse definiert? Du erwähntest ja einen Softwarearchitekten – nicht das der das alles in eine ”Klasse” gesteckt hat, weil der *alles* in Klassen steckt, weil er von Sprachen kommt oder Werkzeuge/Notationen verwendet, bei denen es keine Funktionen gibt und man gezwungen ist alles in eine Klasse zu stecken.

[DeaD_EyE]

Die ungarische Notation ergibt nur bei statisch typisierten Sprachen Sinn.
Mit der Notation gibt man am Anfang der Variable an, um welchen Datentyp es sich handelt.

Python ist eine dynamische Sprache und da kann ein Name auf alle möglichen Objekte verweisen und sich zur Laufzeit ändern.
Würde man auch in Python diese Art der Notation verwenden, verleitet das den Programmierer zu falschen Annahmen.

@ontopic
Wenn du irgendeinen Container oder Sequenz hast (list, tuple, dict...) und wiederholt irgendwas mit den Daten machen musst, ist eine for-schleife die richtige Wahl.
Wenn du selbst alles zu Fuß machst, kannst auch gleich auf C umsteigen. Dort muss man alles zu Fuß machen. Nutze lieber die Konzepte, die über 20 Jahre lang gereift sind.
Iteration ist eins der wichtigsten Konzepte in Python.

Numpy wäre hier auf jeden Fall die bessere Wahl, weil diese Bibliothek auch die Slice-Notation für mehrdimensionale Arrays ermöglicht (und noch viel mehr).

[__blackjack__]

@DeaD_EyE: Das stimmt nicht so ganz, denn ungarische Notation ist eigentlich das man den ”duck type” als Präfix in den Namen schreibt. Das Microsoft und ein paar andere das einfach auf die konkreten Typen und ohne nachzudenken auf alle Namen angewendet haben, war so ja gar nicht gedacht. Und das macht gerade bei statisch typisierten Sprachen am wenigsten Sinn und kommt auch eher aus der Ecke der nicht strikt, dynamisch typsierten Sprachen. Also da wo der Benutzer selbst dafür verantwortlich ist immer den Typ zu kennen, weil der nirgends sonst kodiert ist. Also weder statisch einem Namen zugeordnet ist, noch dynamisch einem Wert.

[Felix92]

Vielen Dank erstmal an alle ich werde mir das die Tage mal anschauen
@__blackjack__ hier mal die Anforderungen für die Folienverarbeitung und die Erkennung des Sprechers:
ich habe es gerade selbst gesehen das es ein Modul und keine Klasse sein soll werde ich morgen noch anpassen ^^
Die Ausgabe wurde nach Absprache geändert also das mit dem Projektordner ist korrekt.





MfG Felix

[Felix92]

Da bin ich wieder
Und zwar wollte ich mal nachfragen, wie ich aus dieser regionOfInterest (roi) nun quasi prüfen kann ob jeder Pixel weiß ist oder noch besser die einzelnen Pixel einen ähnlichen Farbwert besitzen, falls es leichte Abweichungen geben sollte .
Und wäre es möglich wie hier white eine Variable mit einem Farbwert zu initialisieren ?
Weil ich habe so die leichte Vermutung dass das Blödsinn ist

Code: Alles auswählen

def test(file, y1, y2, x1, x2):

    img = cv2.imread(file, cv2.IMREAD_GRAYSCALE)
    white = (255, 255)  
    print(img.shape) 
    roi = img[y1:y2, x1:x2]
  
    print(np.all(video_place is white))
    cv2.imshow('image', roi)
    cv2.waitKey()
    cv2.destroyAllWindows

MfG Felix

[__deets__]

Hast du mal in die aeusserst umfangreiche OpenCV-Dokumentation geschaut? Was da so an Beispielen zu den von mir genannten Stichworten zB steht?

[Felix92]

Naja ich hatte mir in der docu die Tutorials angesehen dann noch probiert über google etwas zu finden ohne großen Erfolg und die docu an sich allerdings bin ich da nicht so schlau draus geworden, da diese wie du schon sagtest ziemlich umfangreich ist.

[__deets__]

Ich habe dir ja eine Reihe von konkreten Ansaetzen genannt, zB Histogramme. Letztlich musst du entscheiden, welche Kriterien fuer "hier ist nichts was wichtig ist" du hast. Das kann hier keiner fuer dich tun, denn es ist dein Projekt, deine Slides, deine Kriterien.

Und wenn du *ein* Kriterium hast (zb einfach alles komplett weiss), das fuer einen gegebenen Ausschnitt funktioniert, dann kannst du das ja in Zukunft erweitern. Oder deinen Prof fragen, wie das Kriterium genauer aussehen soll.

[Felix92]

Huhu und zwar wollte ich mal nachfragen, wie ich es hinbekomme dass in einem Bild ein Video als Overlay liegt, welches relativ zum Video abspielt.
Kurz zum Problem: ich habe eine PDF in Bilder gesplittet diese Bilder werden dann geprüft ob auf ihnen unten rechts (250x200) alles weiß ist um dort ein Bild einzufügen (soweit läuft alles) nun soll es aber auch möglich sein in diesem unteren Bereich anstatt einem Bild ein Video einzublenden.
Also kurz im unteren Beispiel sollte jetzt nur die Folie zu sehen sein und das aktuelle Video auf der Folie unten rechts wenn Platz ist ansonsten wenn kein Platz ist wird nur die Folie angezeigt.
Ich hoffe es ist einigermaßen verständlich




Das steht bisher (hat bisher mehr zum testen und probieren gedient):
check_color liefert True wenn Platz auf der Folie ist.

Code: Alles auswählen

def video_in_slide(file_path, filename, video_path, videoname, y1, y2, x1, x2):
    presentation_file = Path(file_path, filename)
    video_file = Path(video_path, videoname)
    if check_color(file_path, filename, y1, y2, x1, x2) == True:
        cap = cv2.VideoCapture(str(video_file))
        if(cap.isOpened() == False):
            print("Error opening video stream or file")
        while(cap.isOpened()):
            ret, frame = cap.read()
            if ret == True:
                cv2.imshow('Frame', frame)
                if cv2.waitKey(25) & 0xFF == ord('q'):
                    break
            else:
                break
        cap.release()
        cv2.destroyAllWindows()
    else:
        img = cv2.imread(str(presentation_file), cv2.IMREAD_COLOR)
        return img

MfG Felix

[__deets__]

Brauchst du keinen Ton dafuer? Woher weisst du denn, wann welche Slide dran ist?

Ansonsten ist das ganz einfach: den Frame kannst du mit imresize auf das gewuenschte Mass stutzen, und in das Image des PDFs das du ja schon als numpy-Array vorliegen hast reinpacken.

slide[y:y+hoehe,x:x+breite] = frame