So you want to start converting DaVinci Resolve markers to YouTube chapters – fully automated?

Here you will find 2 free tools to do so 😉!

Just paste the content of the „.edl“-file into the left textbox and the magic will happen.

Alternatively, you can simply drag and drop the file into the field and save yourself opening the file.

Background to DaVinci Resolve markers & YouTube chapters

Ultimately, you can export so-called „editing decision lists“ from your DaVinci Resolve timeline.

These arise or can be created by setting „markers„, i.e. small bookmarks, in DaVinci Resolve.

It is best to imagine it like a book in which you attach small bookmarks to certain pages so that you can remember this point later.

Each of these bookmarks – called „markers“ in DaVinci Resolve slang – you can also add text, i.e. a kind of title.

It wasn’t that long ago – 2 days lol to be precise – when I faced the problem myself for the first time.

So I went there more or less usual, made my videos and set the markers in DaVinci Resolve.

As mentioned, I did this so that I could quickly find the important points while I was working on it.

Later I realized that I could just as easily use these passages for my YouTube chapters.

Of course I didn’t feel like copying everything out by hand, so I looked for a tool.

Unfortunately I couldn’t find a tool quickly, but luckily you are a programmer and can build one yourself 😎.

Extension 1 – Converting multi color markers to YouTube chapters

Supporting multiple colors

Of course, a few small ideas came to mind with this tool after it was finished.

Currently the converter can process only one marker color, which may not be sufficient for some (a few?) applications.

It doesn’t matter which colors are present in the code, as the tool always takes the color from the first „dataset“ as the main color.

In theory, it wouldn’t be really difficult to add multiple colors since I was looking for extensibility in the code as always.

However, I still have to think about how to implement this as a surface, as I want to keep it intuitive.

Extension 2 – Windows Tool for eleminating manual work

Converting EDL files on creation

Programmers are known to be lazy, creative / innovative, so I thought about something.

Especially people who upload videos every day have this recurring task in front of them.

Filming, cutting, setting DaVinci Resolve markers, exporting, etc. every day – sigh.

Then going to my * wink * homepage and use the YouTube chapter converter, so:

• Open download folder
• Visit my page/open the tab
• Drop file into webbrowser
• copy chapters
• Open the Youtube video
• Paste chapters..

Anyone who knows me knows that I’m not a big fan of recurring „monkey work“, so the following idea came up:

How about a small Windows tool, which can recognize the creation of an „.edl“ file within a folder?

You could of course make this folder configurable and thus adapt it to your needs.

One should also be able to switch off the tool without closing it, of course.

Then the tool could go there and, if it detects the creation of a file, take this file and process it directly.

After the successful processing, the YouTube chapters could be placed on the clipboard immediately – automatically!

No sooner said than done – I implemented the tool quickly and this is what it looks like (I did without an overly beautiful design, sorry ..):

Downloads

Related posts

• Hacking a NET Application
• Filtering a VB NET DataGridView
• Removing items from a ListBox

Der Beitrag Converting DaVinci Resolve markers to YouTube chapters erschien zuerst auf Robert Skibbe.

Du möchtest DaVinci Resolve Marker in YouTube-Kapitel umwandeln und hast keine Lust selbst Hand anzulegen!?

Dann findest Du hier zwei Tools – in Form eines Webinterfaces und einer kleinen App – um dies automatisiert erledigen zu lassen 😉!

Füge einfach den Inhalt der „.edl„-Datei in das linke Textfeld ein und schon passiert die Magie.

Alternativ kannst Du die Datei auch einfach via „Drag & Drop“ in das Feld ziehen und sparst Dir so das Öffnen der Datei.

Hintergrund zu DaVinci Resolve Markern & YouTube-Kapiteln

Letztendlich kannst Du sogenannte Editierentscheidungslisten aus Deiner DaVinci Resolve Timeline exportieren.

Diese entstehen, bzw. können dadurch erstellt werden, dass Du in DaVinci Resolve „Marker„, also kleine Lesezeichen setzt.

Stell‚ es Dir am besten wie ein Buch vor, in dem Du auf gewissen Seiten kleine Lesezeichen einhängst, um Dich später an diese Stelle zu erinnern.

Jedes dieser Lesezeichen – im DaVinci Resolve Slang „Marker“ genannt – kannst Du zusätzlich mit Text, also einer Art Titel versehen.

Es ist gar nicht allzu lang her – um genau zu sein 2 Tage lol – wo ich das erste Mal selbst vor dem Problem stand.

Ich ging also wie mehr oder weniger gewohnt hin, machte meine Videos und setzte die Marker in DaVinci Resolve.

Das habe ich wie erwähnt deshalb gemacht, damit ich eben während meiner Bearbeitung schnell zu den wichtigen Stellen finde.

Nachträglich habe ich dann gemerkt, dass ich diese Stellen auch ebenso gut für meine YouTube-Kapitel nutzen könnte.

Natürlich hatte ich wenig Lust alles händisch herauszukopieren, also suchte ich nach einem Hilfsmittel.

Leider habe ich kein Tool auf die Schnelle gefunden, aber zum Glück ist man ja Programmierer und kann sich selbst eins bauen 😎.

Erweiterung 1 – Mehrfarbige Marker in YouTube-Kapitel umwandeln

Unterstützung mehrerer Farben

Natürlich kamen mir auch bei diesem Tool nach der Fertigstellung noch einige kleine Ideen in den Kopf.

Aktuell kann der Konverter z. B. nur eine Marker-Farbe verarbeiten, was für einige (wenige?) Einsatzfälle vielleicht nicht ausreicht.

Aktuell ist es egal, welche Farben im Code vorhanden sind, da das Tool immer die Farbe aus dem ersten „Datensatz“ als Haupt-Farbe nimmt.

Theoretisch wäre es nicht wirklich schwer, mehrere Farben hinzuzufügen, da ich im Code wie immer auf Erweiterbarkeit geachtet habe.

Ich muss mir allerdings noch überlegen, wie ich das als Oberfläche realisiere, da ich es weiterhin intuitiv halten möchte.

Erweiterung 2 – Windows Tool zur Eliminierung manueller Arbeit

EDL-Dateien bereits beim Erstellen umwandeln

Programmierer sind ja bekanntlich faul kreativ/innovativ, also habe ich mir noch was überlegt.

Besonders Menschen die täglich Videos hochladen, haben diese immer wiederkehrende Aufgabe vor sich.

Jeden Tag Material filmen, schneiden, DaVinci Resolve Marker setzen, exportieren, etc. – seufz.

Danach auf meine *zwinker* Homepage gehen und den YouTube-Kapitel Konverter nutzen, also:

• Download-Ordner öffnen
• Meine Seite öffnen / Tab öffnen
• Datei in den Webbrowser droppen
• Kapitel kopieren
• YouTube-Video öffnen
• Kapitel einfügen..

Wer mich kennt weiß, dass ich kein großer Fan von wiederkehrender „Monkey-Work“ ist, also kam folgende Idee:

Wie wäre es mit einem kleinen Windows-Tool, Welches die Erstellung einer „.edl“-Datei innerhalb eines Ordners erkennen kann?

Diesen Ordner könnte man natürlich konfigurierbar machen und somit an seine Bedürfnisse anpassen.

Ebenso sollte man die Möglichkeit haben, dass Tool ohne schließen abzuschalten, klar..

Danach könnte das Tool hingehen und sich bei erkannter Erstellung einer Datei, diese Datei nehmen und direkt verarbeiten.

Nach der erfolgreichen Verarbeitung könnten die YouTube-Kapitel also sofort in die Zwischenablage gelegt werden – automatisch!

Gesagt, getan – habe das Tool fix umgesetzt und so sieht es aus (ich habe auf übermäßig schönes Design verzichtet, sorry..):

Downloads

Weiterführende Links

• Erstelle dein eigenes VB NET Plugin-System
• Ein alternatives Webbrowser Steuerelement
• VB NET Formulare automatisch ausfüllen

Der Beitrag DaVinci Resolve Marker in YouTube-Kapitel umwandeln erschien zuerst auf Robert Skibbe.

VB.NET Formulare automatisch ausfüllen!

Ein VB NET Formular automatisch ausfüllen zu lassen wäre vermutlich für jeden „Windows Forms“ geprägten Entwickler eine Erleichterung. Man designt die Form seiner Wahl und möchte natürlich bei Aufruf die notwendigen Daten anzeigen. Besonders beim Flow aus diversen Suchmasken heraus ist es normal, dass man eine Detail-Ansicht mit entsprechenden Daten aufruft.

Wie es meistens ist..

Am besten wäre es natürlich, wenn man dem Formular direkt sagen könnte: „Hey, die Daten findest Du dort“. Mit modernen Mitteln wie in der WPF (Windows Presentation Foundation) ist dies durch Datenbindung eine gängige und vor allem einfache Praxis.

Dort findet man durch die saubere Trennung zwischen GUI und Daten eine simple und direkt in XAML implementierte Möglichkeit. In den guten alten Winforms findet man jedoch seltenst (jedenfalls aus meiner Erfahrung gesprochen) datengebundene Steuerelemente.

Monkey Work – ney, Automatisierung – yay!

Dort sieht es dann entgegengesetzt jeglicher Automatisierung eher so aus:

TextBox1.Text = "..."
TextBox2.Text = "..."
TextBox3.Text = "..."
TextBox4.Text = "..."
' ....

Eventuell entwickelt man wenigstens einigermaßen sauber und wählt passende Namen für die Textboxen:

tbFirstName.Text = "..."
tbLastName.Text = "..."
tbZip.Text = "..."
tbCity.Text = "..."
' ....

Schon besser, aber natürlich kann man sich schon vorstellen, dass dies nicht unbedingt das Gelbe vom Ei ist. Man wird auf diverse Probleme, bzw. Monkey-Work stoßen, Welche für Wartung und Co. nicht gerade vorteilhaft sind. Tonnenweise „duplicated Code“ und schon glatt eine Qual, wenn es bei einem Objekt mit 30 Properties heißt: „Hey, zeige die Daten mal an…“.

Nun ist man an einem Punkt, wo die bekannte Faulheit doch zum Vorteil sein und zu mehr Effizienz beitragen kann. Wie so häufig, haben wir als Entwickler die Möglichkeit uns gewisse (und vor allem wiederkehrende Aufgaben) zu vereinfachen. Not macht erfinderisch, richtig?

An die Zukunft denken

Je nachdem wie viel Planung und anschließenden Zeitaufwand man bereit ist zu investieren (nicht opfern!), wird die bevorstehende Arbeit beeinflussen. Man sollte meiner Meinung nach jedoch immer eins im Hinterkopf behalten: „Think twice, code once“! Leider arbeiten viele Entwickler auch gerne nach dem „Copy & Paste“-Prinzip, zur Not auch projektübergreifend.

Statt hier zukunftsorientiert zu denken, werden Aufgaben häufig nur akut und schnell gelöst. Auch wenn die Erledigung einiger Aufgaben ggf. am Anfang nervig und zeitaufwendig sind, können Sie einem später unfassbar viel Zeit ersparen. Dies gilt natürlich nicht nur für das aktuelle Projekt, sondern vermutlich auch noch für später anstehende Projekte und Problemstellungen.

Herangehensweise – VB NET Formular automatisch ausfüllen

Im nächsten Schritt machen wir uns einmal ein paar Gedanken bezüglich der Herangehensweise, die (Windows Forms)-Formulare automatisiert(er) auszufüllen. Auch wenn wir hier vermutlich noch keine volle Suite an Mini-Tools generieren werden, wird das meinerseits dargestellte Beispiel als Startschuss dienen können.

Jeder Entwickler im NET Bereich wird wohl immer wieder mal mit den guten alten Textboxen zu tun haben. Ich denke, dass dieses Steuerelement daher auch die erste zu bearbeitende Anlaufstelle sein sollte. Wenn man hingegen an Checkboxen, Listboxen und an die anderen Steuerelemente denkt, könnte es schon ein wenig komplexer werden.

Vielleicht werde ich dafür dann noch einmal einen getrennten Beitrag in Zukunft erstellen. Schauen wir einmal, wo mich die Beitrags-Reise, bzw. meine Schreib-Lust heute hinführt 😉.

Konkreter Ablauf

Wenn man sauber vorgeht, sollte man die Daten natürlich in irgendeiner sinnvollen Form vorliegen haben. Nach Möglichkeit gibt es hier also nicht z. B. 15 verschiedene Variablen, Welche dann im schlimmsten Fall noch „string1, string2, usw.“ heißen. Wir wollen ja im besten Fall mit relativ fest definierten Mustern arbeiten, um unsere Arbeit so einfach wie möglich zu gestalten.

Ich stelle mir einerseits eine bereits definierte Klasse als Daten-Container vor, andererseits könnte es sich auch um analog zugreifbare Daten wie bei einer DataRow handeln. Den konkreten Ablauf würde man kurz und knapp vielleicht so beschreiben: „Nimm dieses Ding hier und packe dessen Eigenschafts-Werte in die passenden Steuerelemente“.

Dabei könnte man entweder ausgehend vom Objekt, oder von der jeweiligen Form arbeiten, also Pseudocode mäßig so:

Für jede Eigenschaft im Objekt, finde die passende Textbox, trage den passenden Wert ein..

oder..

Für jede/s Textbox/Steuerelement auf dem Formular, finde im Ziel-Objekt die passende Eigenschaft und befülle Diese.

Eventuell könnte man hier auch noch für die Performance mit irgendeiner Art Cache arbeiten, oder je nach Situation die „Strategie“ (Anspielung Strategy-Pattern…) ändern. Ich werde es hier allerdings nicht weiter als nötig verkomplizieren, da dieses Beispiel nur als Inspiration dienen soll.

Code – VB NET Formular automatisch ausfüllen

Nachdem wir die Herangehensweise ein wenig durch Pseudocode dargestellt haben, starten wir auch direkt in den Code. Ich werde auf jeden Fall ein Modul verwenden, damit man den Code auch einfach für andere Projekte wiederverwenden kann. Alternativ könnte man natürlich auch eine getrennte Klassenbibliothek, ein NuGet-Paket, o. Ä. erstellen.

Mit gewissen neuen aus C# bekannten Features könnte man auch vielleicht in Visual Basic eine „Trait“ ähnelnde Verwendungsweise realisieren. Wie bekannt ist, ist Komposition ja zumeist besser, als Vererbung (Stichwort: „composition over inheritance“). „Traits“ kennt man zum Beispiel allzu gut aus der Web-Programmiersprache namens PHP, aber dazu vielleicht in einem anderen Beitrag mehr.

Das Modul

Erstelle nun im ersten Schritt ein neues Modul namens (z. B.) „modExtensions“ – auch hier verwende ich gerne eine kleine Konvention. Ich halte mich immer an ähnliche Bezeichnungen / Präfixe, wie z. B. „tb“ für eine Textbox, „cbb“ für eine Combobox, etc. Welchen Sinn das dann eventuell haben kann / wird, sehen wir unter anderem (und besonders) im heutigen Beitrag!

Da wir schon analog zum Modul geplant haben, eine Erweiterungsmethode zu verwenden, importieren wir direkt den „System.Runtime.CompilerServices“-Namespace.

Eine Fill-Methode – VB NET Formular automatisch ausfüllen

Durch den Import des zuvor genannten Namespaces, können wir dann das „Extension“-Attribut verwenden und unsere Methode namens z. B. „Fill“ damit bestücken.

Als nächstes definieren wir die beiden benötigten Parameter:

• Die Form, bzw. dessen Steuerelemente, Welche befüllt werden sollen
• Das Objekt, also eine jeweilige Instanz eines x-beliebigen Typs, Welches die Daten beinhaltet

Imports System.Runtime.CompilerServices

Module modExtensions

    <Extension()>
    Public Sub Fill(frm As Form, obj As Object)
        ' ...
    End Sub

End Module

Danach erfassen wir die Textboxen aus der „Controls“-Auflistung des Formulars, damit wir Diese anschließend verwenden können. Praktisch im gleichen Schritt, ziehen wir uns einfach auch direkt die Eigenschaften (Definitionen) des Daten-Objekts.

Das geht relativ einfach, also wie folgt:

Dim textBoxes = frm.Controls.OfType(Of TextBox)
Dim properties = obj.GetType().GetProperties()

Danach können wir die eben abgerufenen Textboxen einfach in einer „For Each“-Schleife durchlaufen und dann mit dem Befüllen der Eigenschaften beginnen. Im ersten Teil der Schleife prüfen wir, ob die jeweilige Textbox mit dem korrekten Prefix „tb“ betitelt wurde. Wir halten uns also an eine kleine, von uns festgelegte Konvention. Vielleicht sollte man dies auch durch ein eigenes Attribut konfigurierbar machen, jedoch verzichten wir der Einfachheit halber aktuell darauf. Falls die Textbox nicht mit „tb“ beginnt, ignorieren wir Sie aktuell einfach, sprich die Schleife springt in den nächsten Durchlauf.

Dim wrongPrefix = Not tb.Name.StartsWith("tb")
If wrongPrefix Then
    Continue For
End If

Der darauf folgende Teil prüft, ob wir eine Eigenschaft mit passendem Namen zur Textbox finden können. Ebenso checken wir, ob der Typ zur Textbox passt, es sich dabei also um einen String handelt.

Dim nameWithoutPrefix = tb.Name.Substring(2)
Dim matchingProperty = properties.SingleOrDefault(Function(x) x.Name = nameWithoutPrefix)
If matchingProperty Is Nothing OrElse matchingProperty.PropertyType IsNot GetType(String) Then
    Continue For
End If

Der letzte und wichtigste Part – also nach dem Motto „das Beste kommt zum Schluss“ – ist, die Text-Eigenschaft der Textbox zu setzen:

tb.Text = matchingProperty.GetValue(obj).ToString()

Dazu verwenden wir die „GetValue“-Funktion der „PropertyInfo“-Klasse, um an den hinterlegten Wert der Eigenschaft zu kommen.

Kompletter Code

Wie immer fasse ich hier am Ende des Beitrages den kompletten Code zusammen.

Imports System.Runtime.CompilerServices

Module modExtensions

    <Extension()>
    Public Sub Fill(frm As Form, obj As Object)
        Dim textBoxes = frm.Controls.OfType(Of TextBox)
        Dim properties = obj.GetType().GetProperties()

        For Each tb In textBoxes

            Dim wrongPrefix = Not tb.Name.StartsWith("tb")
            If wrongPrefix Then
                Continue For
            End If

            Dim nameWithoutPrefix = tb.Name.Substring(2)
            Dim matchingProperty = properties.SingleOrDefault(Function(x) x.Name = nameWithoutPrefix)
            If matchingProperty Is Nothing OrElse matchingProperty.PropertyType IsNot GetType(String) Then
                Continue For
            End If

            tb.Text = matchingProperty.GetValue(obj).ToString()
        Next
    End Sub

End Module

using System;
using System.Windows.Forms;

namespace AutoFillFormCS
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnAutoFill_Click(object sender, EventArgs e)
        {
            var customer = new Customer()
            {
                Company = "Nice ltd.",
                FirstName = "Max",
                LastName = "Random",
                Street = "The street",
                HouseNo = "11a"
            };
            this.Fill(customer);
        }
    }
}

Weiterführende Links

• MVVM – Model View ViewModel (Wissen auch für VB geeignet)
• Mahapps Metro Projekt aufsetzen
• Asynchrone Programmierung

Downloads

Der Beitrag VB NET Formular automatisch ausfüllen (Winforms) erschien zuerst auf Robert Skibbe.

VB NET MouseMove – Mausposition durch Code setzen

Du möchtest einen „VB NET MouseMove„-Befehl realisieren, aber weißt nicht ganz wie Du das anstellen sollst?

Lerne im diesmaligen Beitrag, wie Du in VB NET eine Mausbewegung via Code ausführen kannst.

Zugehörig zu den anderen AutoIt3-Beiträgen, fahre ich mit der kleinen Serie hier nun fort.

Du brauchst Dir auch keine besonderen Sorgen über die Speichergröße der hier verwendeten Hilfsmittel machen.

Darauf gehe ich aber zu einem späteren Zeitpunkt noch einmal kurz ein.

Auch wenn Du damit vermutlich keinen „OSU!„-Bot bauen kannst denke ich, dass es hier und da sehr hilfreich sein kann!

Auf YouTube ansehen – VB NET MouseMove simulieren

Wenn Du lieber ein Video sehen möchtest, statt Dich durch den Beitrag zu lesen, kannst Du das hier auch tun.

Gerne schweife ich in meinen Beiträgen auch mal ab und bringe hier und da Nebeninformationen rein.

Leider fehlt mir dazu oft in den Videos die Zeit, da ich denke, dass man einen Beitrag einfacher durchscrollen kann.

Sicherlich ist man vom Fernseher und von Videos gewohnt, hier und da mal durch zu zappen.

Ich finde allerdings, dass das Scrollen zu bestimmten Überschriften einfacher und leichter von der Hand geht.

Glücklicherweise hat YouTube seit längerer Zeit eine Art Kapitelübersicht hinzugefügt.

Wie ich auf den Beitrag kam

Auch wenn wir damit wie oben schon erwähnt vermutlich keinen „OSU!“-Bot bauen können, geht dennoch einiges.

In Kombination mit den anderen unten verlinkten Funktionalitäten kann man so manches realisieren.

Ich selbst kam nicht selten in die Versuchung gewisse Tools zur Erleichterung meiner Arbeit und auch des Gamings zu umzusetzen.

Daher beschäftigen wir uns in diesem Beitrag damit, wie man gewisse Mausbewegungen via Code steuern kann.

Im nächsten Teil des Beitrags schauen wir dazu allerdings erstmal die notwendigen Tools an.

Danach beschäftigen wir uns mit dem Aufsetzen des Visual Studio Projektes und der Installation der notwendigen Bibliotheken.

Nicht ohne Hilfe – wir nutzen AutoIt

Für unser Vorhaben, Welches auch roh in VB NET möglich wäre, verwenden wir hier allerdings bewusst die Bibliothek von AutoIt3.

Ich habe im „ImageSearch“-Beitrag schon einmal angesprochen dass viele Entwickler kritisch mit der Speichergröße der Projekte umgehen.

In erster Linie ist das natürlich völlig nachvollziehbar, da ich selbst ein Freund des KISS (Keep It Smart and Simple) bin.

Ich denke allerdings, dass es Situationen gibt, wo man es auch übertreiben kann.

In Festplatten–Generation „Terrabyte zum Preis von damaligen 80GB“ nörgle ich nicht für 1MB rum.

Das was letztendlich zählen sollte, ist die Relation zwischen Aufwand und Erfolg, bzw. das Erreichen des Ziels.

In intelligent entwickelten, bzw. strukturierten Programmen ist der spätere Austausch kein Problem.

Daher immer schön sauber mit Interfaces und deren Implementierungen arbeiten *zwinker*.

Ein neues Projekt anlegen und in Visual Studio vorbereiten

Nun wären wir an der Stelle, die notwendigen Libraries herunterzuladen.

Erledige das gern direkt hier, oder suche Dir anderweitige Quellen im Netz dafür.

Erstelle danach einfach ein neues Windows Forms-, oder ein WPF-Projekt.

Füge die „AutoItX3.Assembly.dll„-Datei nun als Verweis hinzu, damit wir Diese im Code nutzen können.

Relativ simpel geht das in Visual Studio zum Beispiel außen rechts über den Projektmappen-Explorer.

Führe dazu einfach einen rechten Mausklick auf „Verweise/Abhängigkeiten“ aus und wähle die Datei aus.

Neben dem genannten Weg, gibt es auch noch andere Möglichkeiten, zum Beispiel über das obige „Hauptmenü“.

Kopiere anschließend alle anderen Dateien (außer die ImageSearchDLL.dll) in den Debug-Ordner deines Projekts.

Die oben erwähnte Datei dürfte sich aufgrund des Imports schon im Ordner befinden.

Der Code – VB NET MouseMove

Nun kommen wir endlich an den Punkt, wo wir uns an den Code heranwagen.

Nachdem Du alle Vorbereitungen abgeschlossen hast, kann Du nun den Namespace importieren.

Dadurch kannst Du dann auf die benötigte Klasse zugreifen:

Imports AutoIt

Durch die nun verfügbare Klasse „AutoItX„, können wir jetzt die Mausbewegungen an sich realisieren.

Klicke Dir nun vielleicht noch vorher eine GUI wie Diese hier, mit 2 Labels, 2 Textboxen und einen Button zurecht:

Die beiden Labels sollen Dich auch noch in einem halben Jahr dran erinnern, welche Inputs wohin müssen.

Bei den Textboxen verzichten wir bei der Eingabe der Koordinaten in diesem Beispiel auf eine Prüfung.

Wir prüfen also nicht explizit, ob es sich dabei wirklich um Zahlen handelt, etc.

Anschließend holen wir uns die Koordinaten aus den Textboxen und wandeln Diese um.

Dafür verwenden wir natürlich den korrekten Datentyp namens Integer:

Dim x = Integer.Parse(tbX.Text)
Dim y = Integer.Parse(tbY.Text)

Nun kommen wir zum goldenen Teil des Beitrages, also der Durchführung der Mausbewegung selbst.

Dazu benutzen wir die importierte Klasse „AutoItX“ in Kombination mit den gerade festgelegten Koordinaten.

Optional könntest Du auch noch eine Art Geschwindigkeit der Bewegung, bzw. der „Animation“ festlegen .

Dim movementSpeed = 50
AutoItX.MouseMove(x, y, movementSpeed)

Als nächstes möchte ich die Parameter noch der Vollständigkeit halber erläutern, oder eher auflisten.

Detailliertere Informationen findest Du auf der offiziellen Seite, bzw. der offiziellen Dokumentation:

MouseMove-Parameter

x As Integer

Gibt den Koordinaten-Punkt des Klicks auf der horizontalen (X) Achse an.

y As Integer

Setzt die Koordinate des auszuführenden Klicks auf der vertikalen (Y) Achse.

speed As Integer

Gibt die Geschwindigkeit der Bewegung an.

Der komplette Code – TL;DR

Obwohl der Code hier vermutlich nicht durch seine Quantität glänzt, hier nochmal alles in einem Stück.

Imports AutoIt

Public Class Form1

    Private Sub btnMoveMouse_Click(sender As Object, e As EventArgs) Handles btnMoveMouse.Click
        Dim x = Integer.Parse(tbX.Text)
        Dim y = Integer.Parse(tbY.Text)
        Dim moveSpeed = 50
        AutoItX.MouseMove(x, y, moveSpeed)
    End Sub

End Class

Weiterführende Links

• Visual Basic NET MouseClick simulieren
• VB NET ImageSearch in Spielen, auf dem Desktop, etc.
• Visual Basic .NET Texterkennung auf Bildern via Google Cloud Vision API [OCR]

Downloads

Der Beitrag VB NET MouseMove – Mausbewegungen mit AutoIt3 simulieren erschien zuerst auf Robert Skibbe.

VB NET MouseClick simulieren

Einen VB NET MouseClick simulieren zu können wollte vermutlich jeder Entwickler schon einmal.

Ich würde sogar sagen, jeder Gamer sowieso, denn wer hat schon Lust auf die typische „Monkey-Work“.

Zig tausend mal die gleichen Dialoge in exakter Reihenfolge zu bestätigen und sich mühselig manuell durchzuklicken.

Also echt mal, da hat doch keiner Bock drauf, seufz, jedenfalls aller spätestens beim 2, 3, .. Mal.

Natürlich treffen wir ähnliche Bedürfnisse und Probleme auch im Büroalltag an, Excel, usw. lassen lieb grüßen.

Ein Glück, dass man (angehender) Entwickler ist, gell 😉!

Auf YouTube ansehen – VB NET MouseClick simulieren

Falls Du eher für eine visuelle Darstellung des Beitrages zu haben bist, kannst Du Dir natürlich auch das Video (vielleicht auch ergänzend zum Beitrag) anschauen.

Bei meinen Beiträgen bringe ich gerne auch immer diverse Detail-Infos, oder andere Dinge hinein.

Leider fehlt mir dazu oft in den Videos die Zeit, da ich denke, dass man einen Beitrag einfacher durchscrollen kann.

Vor allem den Beitrag sinnvoll zu gliedern ist denke ich einfacher, als durch ein Video zu zappen.

Immerhin hat YouTube seit geraumer Zeit eine Art Kapitelübersicht hinzugefügt, Welche ich auch gern verwende.

Die Idee zum Beitrag – VB NET MouseClick

Man möchte sich im Optimalfall natürlich selbst helfen können und besonders auch zukunftsorientiert.

Gerne hätte man eine Art Hilfe in Form einer Person, der man dann einfach sagen könnte „Mach das mal..“.

Als Programmierer können wir uns kreativen Köpfen selbstverständlich selbst unter die Arme greifen, man weiß nur nicht immer wie.

Daher lass‚ mich Dir mit diesem kleinen Beitrag helfen und zeigen, wie Du einen VB NET MouseClick mit der Hilfe von AutoIt3 durchführen kannst.

Dadurch kannst Du dann verschiedene Tools wie diverse Klicker–Bots realisieren und Dir Deinen Alltag erleichtern.

Nicht ohne mein AutoIt

Naja etwas witzig angelehnt die Headline hier, aber tatsächlich werden wir dieses kleine Geplänkel nicht ohne AutoIt3 realisieren.

Klar gibt es auch die Möglichkeit in VB NET einfach ich nenne es mal „manuell“ einen Mausklick zu simulieren, aber ich find’s hier mit AutoIt3 definitiv angenehmer.

Wie auch im „ImageSearch“-Beitrag schon angesprochen gehen viele Entwickler kritisch mit der Speichergröße der Projekte um.

Das kann ich natürlich nachvollziehen, da ich selbst ein Freund des Minimalismus bin, jedoch kann man die Kirche auch im Dorf lassen.

Ich würde mit Sicherheit in Festplatten–Generation „Terrabyte zum Preis von damaligen 80GB“ nicht anfangen für 1MB rumzunörgeln.

Letztendlich muss man ja immer den möglichen Mehrwert in Relation zur Eigenarbeit sehen.

Später kannst Du bei einem intelligent strukturierten Programm natürlich bedürftige Komponenten isoliert austauschen.

Projekt in Visual Studio vorbereiten

Lade Dir jetzt die benötigten Bibliotheken direkt hier herunter, oder suche alternativ nach anderen Quellen im Netz.

Danach kannst Du wie üblich ein neues Windows Forms-, oder auch ein WPF-Projekt anlegen.

Lege die „AutoItX3.Assembly.dll„-Datei nun als Verweis an, damit dein Projekt damit arbeiten kann.

Ganz einfach geht das zum Beispiel rechts über den Projektmappen-Explorer in Visual Studio.

Führe dazu einfach einen rechten Mausklick auf „Verweise/Abhängigkeiten“ aus und wähle die Datei aus.

Neben dem Weg über den Projektmappen–Explorer gibt es auch noch andere Möglichkeiten.

Kopiere anschließend alle anderen Dateien (außer die ImageSearchDLL.dll) in den Debug-Ordner deines Projekts.

Die oben erwähnte Datei dürfte sich aufgrund des Imports schon im Ordner befinden.

Nun zum Code – VB NET MouseClick

Sehen wir uns im nächsten Schritt den benötigten Code im Detail an.

Wenn Du alle vorherigen Schritte abgeschlossen hast, kannst Du nun den korrekten Import durchführen:

Imports AutoIt

Damit wird im aktuellen Scope die „AutoItX“-Klasse verfügbar, womit wir im nächsten Part den Klick realisieren können.

Zuvor kannst Du Dir allerdings noch eine solche (oder ähnliche) GUI zurechtklicken – relativ simpel.

Füge einfach nur 2 Labels, 2 Textboxen und einen Button hinzu:

Die 2 Labels sollen einfach nur ein wenig fürs Auge klar machen, welche Inputs, wo hinein müssen.

Bei den Textboxen handelt es sich um Eingabefelder für die Koordinaten, allerdings verzichten wir hier im Code auf Prüfungen.

Wir werden also der Einfachheit halber nicht weiter überprüfen, ob es sich bei den Eingaben um Zahlen handelt, bzw. ob etwas eingegeben wurde.

Nun ziehen wir die Koordinaten aus den Textboxen und wandeln Diese dann in Ganzzahlen vom Typ Integer um:

Dim x = Integer.Parse(tbX.Text)
Dim y = Integer.Parse(tbY.Text)

Danach können wir dann die wichtige und essentielle AutoIt3-Funktion namens „MouseClick“ verwenden:

AutoItX.MouseClick("LEFT", x, y, 1, 50)

MouseClick-Parameter

Die möglichen Parameter möchte ich hier einmal näher erläutern:

Weitere Informationen findest Du in der offiziellen Dokumentation von AutoIt.

button As String

Hier können wir den gewünschten Button als String übergeben, mögliche Werte sind: „“ (leer), „LEFT“, „MIDDLE“, „RIGHT“, „PRIMARY“, „MAIN“, „SECONDARY“, „MENU“. Wenn ein leerer String übergeben wird, wird automatisch die linke Maustaste verwendet.

x As Integer

Gibt den Koordinaten-Punkt des Klicks auf der horizontalen (X) Achse an.

y As Integer

Setzt die Koordinate des auszuführenden Klicks auf der vertikalen (Y) Achse.

numClicks As Integer

Legt die Anzahl der durchzuführenden Klicks an den Koordinaten fest.

speed As Integer

Gibt die Geschwindigkeit der durchzuführenden Klicks an.

Der komplette Code – TL;DR

Es ist zwar nicht viel, oder gar komplexer Code, aber hier siehst Du Ihn in einem Stück – vielleicht für die „TL;DR“-guys haha.

Imports AutoIt

Public Class Form1

    Private Sub btnExecuteClick_Click(sender As Object, e As EventArgs) Handles btnExecuteClick.Click
        Dim x = Integer.Parse(tbX.Text)
        Dim y = Integer.Parse(tbY.Text)
        AutoItX.MouseClick("LEFT", x, y, 1, 50)
    End Sub

End Class

Weiterführende Links

• VB NET ImageSearch – Bilder in Spielen, Desktop und Co. suchen
• VB NET Web API – Währungskurs Service Konsum von Grund auf erklärt
• VB.NET Texterkennung auf Bildern via Google Cloud Vision API [OCR]

Downloads

Der Beitrag VB NET MouseClick simulieren – mit AutoIt3 erschien zuerst auf Robert Skibbe.

VB.NET ImageSearch – Bilder in Spielen, Desktop und Co. suchen

Eine VB NET ImageSearch, also eine Bildersuche wollte vermutlich jeder Entwickler im NET Umfeld einmal realisieren.

Ach Gott wie präsent mir diese Momente noch im Gedächtnis sind, kleines Beispiel gefällig? Kein Problem!

Egal ob beim Ingame-Angeln, wo man praktisch immer wieder die exakt gleichen Aktionen durchführt, oder beim „craften“ von Gegenständen..

Auch wenn diese Beispiele eher mit dem Gaming-Sektor zu tun haben, gibt es mit Sicherheit genug Einsatzmöglichkeiten im Büro.

So oder so hat man sicherlich nicht immer Lust und vor allem die Zeit, diese Art von „Monkey-Work“, also praktisch die Arbeit für „Blöde“ zu erledigen.

Auf YouTube ansehen – VB NET ImageSearch

Falls Du die visuelle Darstellung, bzw. Erklärung des Beitrages bevorzugst, kannst Du natürlich auch das dementsprechende Video anschauen.

Ich habe allerdings in diesem Beitrag einige Neben-Themen eingebracht und kann mir auch hier die Zeit nehmen, ein wenig drum rum zu erklären.

Dieser Beitrag hier ist daher etwas länger und ausführlicher als das Video – just sayin‘.

Ursprung und Idee zum Beitrag – VB NET ImageSearch

In solchen häufig wiederkehrenden Momenten hat man sicherlich das Bedürfnis nach Hilfe.

Man möchte seinem Hausroboter einfach sagen können: „Hey, mach Du das bitte mal, ich habe keine Lust“.

Schnell wird man allerdings feststellen, dass das zu oft einfach nicht geht, bis auf in bestimmten Fällen.

Als Entwickler haben wir natürlich glücklicherweise die Möglichkeit uns verschiedene Hilfsmittel zu bauen.

Ob privat, beruflich, oder für’s Spielen diverser Spiele, können wir uns viele Hilfsmittel programmieren.

Vom einfachen Angel-Bot, Welcher eine bestimmte Abfolge immer wieder abarbeitet, bis hin zu komplexeren Bereichen.

Darunter könnte ich mir z. B. einen „Crafter-Bot“ vorstellen, Welcher nach gewissen Commands wie „Strg+Alt+<XY>“ komplexe Gegenstände erstellen kann.

Hilfsmittel zur Hand

Wir arbeiten in diesem Beitrag nicht ohne weitere Hilfsmittel, warum sollte man auch darauf verzichten.

Viele nützliche Funktionalitäten wurden bereits erfunden und erfolgreich über lange Zeit getestet.

Für viele Entwickler spielt natürlich die Größe der jeweiligen Hilfsmittel eine Rolle, man möchte natürlich keine 2GB großen Tools installieren.

Viele sehen allerdings schon rot, wenn die einzelnen Helfer bereits an eine Größe von 1-2 Megabyte rangehen.

In einer Zeit wo man X Terrabyte große Festplatten schon zum Preis von den damaligen 80GB-Kloppern bekommt, sehe ich es allerdings halb so schlimm.

Ich denke man muss letztendlich immer den Mehrwert gegenüber der Eigenarbeit in Relation sehen und der Mehrwert lohnt sich hier definitiv.

Wenn man sein Programm intelligent entwickelt, hält einen nachher auch nichts davon ab, gewisse Parts isoliert auszutauschen.

Letztendlich verwenden wir dieses Mal einige Funktionalitäten der AutoIt3 Scriptsprache zu Nutze.

Vorbereitungen des Visual Studio Projekts

Lade Dir nun am besten die von mir bereitgestellten Bibliotheken herunter, oder suche Diese alternativ im Netz.

Erstelle im nächsten Schritt nun wie gewohnt ein neues Windows Forms-, oder z. B. ein neues WPF-Projekt.

Füge die heruntergeladene „AutoItX3.Assembly.dll“-Datei nun als Verweis in dein Projekt ein – die anderen Dateien werden nicht funktionieren.

Einen Verweis kannst Du über den Projektmappen–Explorer rechts außen im Visual Studio hinzufügen.

Klicke dazu einfach mit der rechten Maustaste auf „Verweise“ und suche nach der Datei, wähle alternativ einen anderen Weg.

Du musst danach auch sämtliche anderen Dateien in das Debug–Verzeichnis deines Projekts legen.

Die oben Genannte ist bereits durch den vorhin geschehenen Import vorhanden.

Ran an den Code – VB NET ImageSearch

Die Funktion um die sich hier so gut wie alles drehen wird ist die „ImageSearch“-Funktion aus der „ImageSearchDLL.dll“.

Man beachte hier die komische Schreibweise, Welche trotz „doppelt-gemoppelt“ tatsächlich richtig ist..

Diese Funktion muss erst einmal wie folgt aus der passenden Library importiert werden:

    <DllImport("ImageSearchDLL.dll")>
    Private Shared Function ImageSearch(
                                 x As Integer,
                                 y As Integer,
                                 right As Integer,
                                 bottom As Integer,
                                 imagePath As String) As IntPtr
    End Function

Vergiss hier auch nicht den Import des „DllImport“-Attributs:

Imports System.Runtime.InteropServices

Ich denke, dass die Parameter der Funktion zwar relativ einleuchtend sind, gehe aber dennoch gerne darauf ein.

Dabei wird Dir denke ich das folgende Bild noch ein wenig unter die Arme greifen:

Je kleiner der durchsuchte Bereich ist und je weniger Bildfläche somit durchsucht werden muss, desto schneller ist die Bildsuche natürlich.

Parameter

x As Integer

Der X-Parameter gibt an, auf welcher Position der X-Achse die Funktion anfangen soll zu suchen.

y As Integer

Als nächstes wird der Y-Parameter übergeben, um zu definieren, ab welcher Position auf der vertikalen Achse des Bildschirms gesucht werden soll. Achtung: Von oben nach unten gesehen = je größer der Wert, desto weiter unten auf dem Bildschirm.

right As Integer

Gibt an, bis zu welchem Punkt auf der X-Achse gesucht werden soll.

bottom As Integer

Legt fest, bis zu welchem vertikalen Punkt auf der Y-Achse gesucht wird.

imagePath As String

Hier kannst Du den Pfad zum Bild angeben (z. B. „my_button.png“). Achtung: Wenn Du eine gewisse Toleranz für die Suche angeben möchtest, kannst Du dies mit einem voranstehenden Leerzeichen und dem einem Wert von 0-255 machen. Das sieht dann wie folgt aus: „50 my_button.png“. Wenn Du meine Wrapper-Klasse verwendest, macht Diese das für Dich.

Ein einfacher Aufruf – VB NET ImageSearch

Schaue Dir hier einen einfachen, beispielhaften Aufruf der rohen „ImageSearch“-Funktion an:

' dont forget the import..
' Imports AutoIt

Dim x = 0
Dim y = 0
Dim right = 1920 ' full screen width, adjust..
Dim bottom = 1080 ' full screen height, adjust..
Dim tolerance = 50 ' a tolerance value between 0 and 255
Dim imagePath = "my_button.png"
Dim finalImagePath = $"{tolerance} {imagePath}"

Dim result = ImageSearch(x, y, right, bottom, finalImagePath)
Dim res = Marshal.PtrToStringAnsi(result)

Dim imageFound = res(0) = "1"
If Not imageFound Then
    MessageBox.Show("Image not found")
    Return
End If

Dim data = res.Split("|")

x = Integer.Parse(data(1))
y = Integer.Parse(data(2))

' optional, getting image dimensions
' Dim width = Integer.Parse(data(3))
' Dim height = Integer.Parse(data(4))

' do something with the coordinates, like moving to it
AutoItX.MouseMove(x, y)

Meine kleinen Hilfsklassen

Hier zeige ich Dir beiden (wirklich) kleinen Hilfsklassen, Welche die Arbeit mit der „ImageSearch“-Funktion ein wenig vereinfachen soll.

ImageSearchResult-Klasse

Die einfachere Klasse von beiden kommt dabei zuerst, einfach nur ein Zwischenspeicher für die Werte (alternativ könnte man eine Structure verwenden).

Public Class ImageSearchResult

    Public Property Found As Boolean

    Public Property X As Integer

    Public Property Y As Integer

    Public Property Width As Integer

    Public Property Height As Integer

    Sub New(found As Boolean)
        Me.Found = found
    End Sub

End Class

ImageSearch-Klasse

Hier wäre die Klasse, Welche Dir die Aufrufe der „ImageSearch“-Funktion ein wenig vereinfachen könnte:

Imports System.Runtime.InteropServices

Public NotInheritable Class ImageSearch

    <DllImport("ImageSearchDLL.dll")>
    Private Shared Function ImageSearch(
                                 x As Integer,
                                 y As Integer,
                                 right As Integer,
                                 bottom As Integer,
                                 imagePath As String) As IntPtr
    End Function

    Public Shared Function Execute(imagePath As String, Optional tolerance As Integer = 0) As ImageSearchResult
        Dim workingArea = Screen.PrimaryScreen.WorkingArea
        Dim result = DoSearch(0, 0, workingArea.Width, workingArea.Height, imagePath, tolerance)
        Return result
    End Function

    Public Shared Function Execute(x As Integer, y As Integer, right As Integer, bottom As Integer, imagePath As String, Optional tolerance As Integer = 0) As ImageSearchResult
        Dim result = DoSearch(x, y, right, bottom, tolerance, imagePath)
        Return result
    End Function

    Public Shared Function Execute(location As Point, rightBottom As Point, imagePath As String, Optional tolerance As Integer = 0) As ImageSearchResult
        Dim result = DoSearch(location.X, location.Y, rightBottom.X, rightBottom.Y, tolerance, imagePath)
        Return result
    End Function

    Private Shared Function DoSearch(x As Integer, y As Integer, right As Integer, bottom As Integer, imagePath As String, Optional tolerance As Integer = 0) As ImageSearchResult
        imagePath = $"*{tolerance} {imagePath}"

        Dim result = ImageSearch(x, y, right, bottom, imagePath)
        Dim res = Marshal.PtrToStringAnsi(result)

        Dim imageSearchResult = New ImageSearchResult(res(0) <> "0")
        If Not imageSearchResult.Found Then
            Return imageSearchResult
        End If

        Dim data = res.Split("|")

        imageSearchResult.X = Integer.Parse(data(1))
        imageSearchResult.Y = Integer.Parse(data(2))

        imageSearchResult.Width = Integer.Parse(data(3))
        imageSearchResult.Height = Integer.Parse(data(4))

        Return imageSearchResult
    End Function

End Class

Ein Beispiel mit den Hilfsklassen

Hier folgt nun das Beispiel mit Hilfe der Hilfsklassen:

Dim result = ImageSearch.Execute("stop_button.png")
' providing a tolerance
' ImageSearch.Execute("stop_button.png", 50)
' and more overloads..
If Not result.Found Then
    MessageBox.Show("Image not found")
    ' if inside a sub, etc..
    Return
End If
' move to the found coordinates
AutoItX.MouseMove(result.X, result.Y)

Besonders interessant dabei sind die verschiedenen Überladungen, Welche Dir den Aufruf vermutlich verkürzen werden.

Weiterführende Links

• VB NET MouseClick simulieren – mit AutoIt3
• VB NET Web API – Währungskurs Service Konsum von Grund auf erklärt

Downloads

Der Beitrag VB NET ImageSearch – Bilder in Spielen, Desktop und Co. suchen erschien zuerst auf Robert Skibbe.