<\/p>\n
Die Bilder einer Webcam kann man üblicherweise auf dem Rechner speichern, auf dem man diese erstellt hat. Gegebenenfalls geschieht das auch automatisch – so zum Beispiel mit der Kamera-App von Windows. Ein Leser fragte, ob sich das Aufnehmen von Bildern auch so steuern lässt, dass man die neuen Fotos direkt in einer Datenbank weiterverwenden kann – durch Speichern des Bildes oder des Speicherpfades in der Datenbank und das anschließende Anzeigen des Bildes direkt in einem Formular der Datenbank. Eine direkte Steuerung via VBA haben wir nicht realisiert, aber einen Workaround, der diese Aufgabe ebenso gut erfüllt.<\/b><\/p>\n
Die Aufgabe lautet also: Wir möchten von einem Access-Formular aus, das beispielsweise ein Produkt anzeigt, die Kamera-App von Windows öffnen, mit dieser ein Bild schießen und dieses dann in der Access-Anwendung so verfügbar machen, dass es direkt im aufrufenden Formular angezeigt werden kann.<\/p>\n
Die Idee dazu lautet: Wir öffnen per Mausklick die Kamera-App und starten zum gleichen Zeitpunkt einen Formular-Timer, der alle paar Sekunden prüft, ob in einem bestimmten Ordner eine neue Datei hinzugefügt wurde. Ist das der Fall, soll die neue Datei als Bilddatei zum aktuellen Datensatz hinzugefügt werden.<\/p>\n
Die Kamera-App speichert die Bilder nämlich in einem vorgegebenen Ordner (üblicherweise c:Users Diesen können wir ändern oder ihn einfach übernehmen. Nachdem wir während der Ausführung der Timer-Ereignisprozedur ein neues Bild im angegebenen Ordner entdeckt haben, verarbeiten wir dieses und beenden das Auslösen des Timers. Außerdem soll das Bild nun als neues Bild im Formular angezeigt werden.<\/p>\n Probleme mit der Kamera-App<\/b><\/p>\n Eines direkt vorneweg: Die Steuerung der Kamera-App ist ein wenig kompliziert und funktioniert mit der nachfolgend vorgestellten Methode nicht in allen Fällen perfekt. Zunächst einmal muss man wissen, dass die Kamera-App auch gestartet wird, wenn gar keine Kamera vorhanden ist – in diesem Fall erscheint zwar eine Anwendung, aber diese liefert lediglich die Meldung, dass keine Kamera gefunden werden konnte (siehe Bild 1). In diesem Fall wollen wir einfach abfangen, wenn der Benutzer die Meldung und somit die Kamera-App wieder schließt.<\/p>\n Bild 1: Meldung bei fehlender oder deaktivierter Kamera<\/span><\/b><\/p>\n Datenmodell der Anwendung<\/b><\/p>\n Für die Anwendung haben wir ein recht einfaches Datenmodell definiert. Wir wollen zu einem Datensatz der Tabelle tblProdukte <\/b>ein oder mehrere Fotos in der Tabelle tblBilder <\/b>speichern können und verknüpfen die Tabelle tblBilder<\/b> wie in Bild 2 über das Fremdschlüsselfeld Produkt-ID<\/b>.<\/p>\n Bild 2: Datenmodell der Beispieldatenbank<\/span><\/b><\/p>\n Das Feld Bild <\/b>der Tabelle tblBilder <\/b>legen wir als Anlage-Feld an. Damit können wir darin nicht nur Bilder speichern, sondern diese auch gleich über das Anlage-Steuerelement im Formular anzeigen.<\/p>\n Neben diesen beiden Tabellen verwenden wir noch eine Tabelle namens tblOptionen<\/b>, die nur ein Feld namens Fotopfad <\/b>enthält.<\/p>\n Formulare der Anwendung<\/b><\/p>\n Das erste Formular namens frmOptionen <\/b>verwendet die Tabelle tblOptionen <\/b>als Datensatzherkunft. Damit der Benutzer nur den vorhandenen Datensatz bearbeiten kann und weder neue Datensätze hinzufügen noch den bestehenden Datensatz löschen kann, stellen wir die Eigenschaften Anfügen zulassen <\/b>und Löschen zulassen <\/b>im Entwurf des Formulars auf Nein <\/b>ein (siehe Bild 3).<\/p>\n Bild 3: Entwurf des Formulars zum Auswählen des Fotopfades<\/span><\/b><\/p>\n Die Schaltfläche cmdFotopfad <\/b>ruft die Prozedur aus Listing 1 auf. Diese verwendet die im Modul mdlTools <\/b>definierte Funktion OpenPathName<\/b>, um einen Dialog zum Auswählen eines Verzeichnisses anzuzeigen. Dabei übergibt sie als ersten Parameter den bisher in der Tabelle tblOptionen <\/b>gespeicherten Ordner und als zweiten den anzuzeigenden Titel für den Dialog.<\/p>\n Listing 1: Prozedur zum Auswählen eines Verzeichnisses<\/span><\/b><\/p>\n In der Formularansicht sieht das Formular wie in Bild 4 aus.<\/p>\n Bild 4: Dialog zum Einstellen der Optionen der Anwendung<\/span><\/b><\/p>\n Formular zum Einlesen von Fotos<\/b><\/p>\n Das Formular zum Einlesen und Anzeigen der Fotos besteht aus einem Haupt- und einen Unterformular (siehe Bild 5).<\/p>\n Bild 5: Entwurf des Formulars frmProdukte<\/span><\/b><\/p>\n Das Unterformular heißt sfmProdukte <\/b>und verwendet die Tabelle tblBilder <\/b>als Datensatzquelle und zeigt lediglich den Inhalt des Feldes Bild <\/b>in einem Anlage<\/b>-Steuerelement an. Nachdem wir dieses Formular angelegt und gespeichert haben, erstellen wir das Hauptformular.<\/p>\n In dieses ziehen wir das Unterformular sfmProdukte<\/b>. Außerdem legen wir für das Formular frmProdukte <\/b>die Tabelle tblProdukte <\/b>als Datensatzquelle fest und fügen die beiden Felder ProduktID <\/b>und Produktbezeichnung <\/b>zum Detailbereich hinzu.<\/p>\n Über dem Unterformular platzieren wir die beiden Schaltflächen cmdFotoHinzufuegen <\/b>und cmdFotoPfadAnpassen<\/b>.<\/p>\n Letztere ruft die folgende Prozedur auf und öffnet so das Formular frmOptionen <\/b>als modalen Dialog:<\/p>\n Foto hinzufügen<\/b><\/p>\n Die Schaltfläche cmdFotoHinzufuegen <\/b>soll dafür sorgen, dass die Kamera-App gestartet wird und dass nach dem Fotografieren die im Fotoverzeichnis gespeicherte neue Datei in die Tabelle tblBilder <\/b>eingelesen und im Formular angezeigt wird.<\/p>\n Dazu benötigen wir eine modulweit deklarierte Variable, deren Funktion wir im Anschluss erläutern:<\/p>\n <\/p>\n Die Prozedur, die durch einen Mausklick auf die Schaltfläche Foto hinzufügen ausgelöst wird, finden Sie in Listing 2. Diese füllt die Variable datStart <\/b>mit dem Wert der Funktion Now<\/b>, welche das aktuelle Datum und die aktuelle Uhrzeit liefert. Damit haben wir den Zeitpunkt gespeichert, an dem der Benutzer ein Foto aufnehmen möchte.<\/p>\n Listing 2: Starten der Fotoaufnahme<\/span><\/b><\/p>\n Danach nutzen wir die Shell<\/b>-Anweisung, um die Kamera-App zu starten. Das Starten einer Windows-App ist nicht so trivial wie das Starten einer einfachen .exe<\/b>-Anwendung.<\/p>\n Wir benötigen dazu einen kleinen Trick, indem wir über die Shell<\/b>-Methode die Kommandozeile aufrufen, die wiederum mit der start<\/b>-Anweisung die Windows-Kamera startet:<\/p>\n Danach warten wir eine Sekunde, was wir durch den Aufruf der im Modul mdlTools <\/b>deklarierten Sleep<\/b>-Methode erreichen (der Wert 1000 <\/b>entspricht einer Sekunde).<\/p>\n Danach prüfen wir, ob die Kamera-App geöffnet ist. Dazu nutzen wir die Hilfsfunktion AnwendungGeoeffnet<\/b>, die Sie ebenfalls im Modul mdlTools <\/b>finden.<\/p>\n Sie nutzt die die API-Funktion FindWindow<\/b>, um das Vorhanden eines Fensters mit dem Titel Kamera <\/b>zu überprüfen.<\/p>\n Liefert diese Funktion den Wert True <\/b>zurück, stellen wir den Wert der Eigenschaft TimerInterval <\/b>des Formulars auf 1000 <\/b>ein. Das bedeutet, dass von nun an jeweils nach einer Sekunde einmal die Ereignisprozedur Form_Timer <\/b>aufgerufen wird.<\/p>\n Sekündliche Suche nach einem neuen Bild<\/b><\/p>\n Die Prozedur Form_Timer <\/b>sucht einmal pro Sekunde nach einer neuen Datei im Foto-Verzeichnis (siehe Listing 3).<\/p>\n Listing 3: Sekündliche Suche nach einer neuen Datei<\/span><\/b><\/p>\n Dabei verwenden wir Elemente des FileSystemObjects<\/b>, das wir zunächst noch per Verweis zum VBA-Projekt hinzufügen müssen. Dazu öffnen Sie den Verweise<\/b>-Dialog mit dem Menübefehl Extras|Verweise <\/b>im VBA-Editor und fügen dort den Eintrag aus Bild 6 hinzu.<\/p>\n Bild 6: Hinzufügen eines Verweises auf die Bibliothek Microsoft Scripting Runtime<\/span><\/b><\/p>\n Anschließend deklarieren wir die benötigten Objektvariablen, und zwar jeweils eine für das FileSystemObject <\/b>selbst, für die File<\/b>-Klasse für das aktuell untersuchte Objekt (objFile<\/b>) sowie das zuletzt erstellte Objekt (objNewestFile<\/b>) und für die Folder<\/b>-Klasse (objFolder<\/b>). Die Variable datAktuell <\/b>speichert das Erstellungsdatum der aktuell untersuchten Datei.<\/p>\n Außerdem benötigen wir noch Variablen für den Primärschlüsselwert des hinzuzufügenden Bilddatensatzes in der Tabelle tblFotos <\/b>und für das zu untersuchende Fotoverzeichnis.<\/p>\n Dieses liest die Prozedur als Erstes aus der Optionentabelle in die Variable strFotoverzeichnis <\/b>ein. Dann referenziert sie mit objFolder <\/b>das Folder<\/b>-Verzeichnis zu strFotoverzeichnis<\/b> und durchläuft in einer For Each<\/b>-Schleife alle File<\/b>-Objekte in objFolder.Files<\/b>. Dies dient dazu, die aktuellste Datei des Verzeichnisses zu ermitteln. Dabei prüft sie zunächst, ob das mit DateCreated <\/b>ermittelte Erstellungsdatum der aktuellen Datei größer als das in datAktuell <\/b>gespeicherte Datum ist. Beim ersten Durchlauf hat datAktuell <\/b>den Wert 0<\/b>, also ist datAktuell <\/b>auf jeden Fall größer und die erste If…Then<\/b>-Bedingung ist erfüllt.<\/p>\n Innerhalb der Schleife prüfen wir dann noch, ob die Dateiendung nicht auf .ini <\/b>lautet. Bei unseren Versuchen wurde nämlich gelegentlich eine solche Datei automatisch erstellt – und diese wollen wir natürlich nicht als neues Foto in die Datenbank importieren.<\/p>\n Handelt es sich also nicht um eine .ini<\/b>-Datei, stellen wir den Wert der Variablen datAktuell <\/b>auf das Erstellungsdatum der aktuell untersuchten Datei ein und referenzieren das File<\/b>-Objekt zu dieser Datei mit der Variablen objNewestFile <\/b>ein.<\/p>\n Auf diese Weise durchlaufen wir alle File<\/b>-Objekt der Files<\/b>-Auflistung des Verzeichnisses auf objFolder<\/b>. Am Ende referenziert objNewestFile <\/b>die zuletzt hinzugefügte Datei und wir verlassen die For Each<\/b>-Schleife.<\/p>\n Danach prüfen wir, ob der Wert von datAktuell<\/b>, also dem Erstellungsdatum der neuesten Datei, größer als der Wert aus datStart <\/b>ist, also der Uhrzeit, an der die Kamera-App gestartet wurde. Ist das der Fall, wurde offensichtlich nach dem Starten der Kamera-App eine neue Datei zum Foto-Ordner hinzugefügt und wir gehen davon aus, dass es sich dabei um ein neu erstelltes Foto handelt.<\/p>\n In diesem Fall stellen wir die Eigenschaft TimerInterval <\/b>auf 0<\/b>, damit die Prozedur Form_Timer <\/b>nicht erneut aufgerufen wird. Außerdem rufen wir die Funktion AttachmentImportieren <\/b>auf, der wir den Pfad zu dem zu importierenden Foto übergeben sowie den Primärschlüsselwert des Produkt-Datensatzes, dem das Foto hinzugefügt werden soll. Die Funktion, die wir gleich im Anschluss beschreiben, liefert den Primärschlüsselwert des neu erstellten Datensatzes in der Tabelle tblBilder <\/b>zurück. Diesen speichern wir in der Variablen lngBildID<\/b>.<\/p>\n Damit das neu erstellte Foto direkt angezeigt wird, aktualisieren wir den Inhalt des Unterformulars und stellen dieses auf den Datensatz mit dem Wert aus lngBildID <\/b>für das Feld BildID <\/b>ein.<\/p>\n Die letzte If…Then<\/b>-Bedingung deckt den Fall ab, dass die Kamera-App ohne Erstellen eines Fotos geschlossen wird – weil der Benutzer es sich entweder anders überlegt hat oder weil die Anwendung wie oben beschrieben zwar gestartet wurde, aber keine Kamera gefunden hat. Die If…Then<\/b>-Bedingung prüft, ob die Funktion AnwendungGeoeffnet <\/b>noch den Wert True <\/b>liefert. Falls nicht, stellt die Prozedur auch hier den Wert der Eigenschaft TimerInterval <\/b>auf den Wert 0 <\/b>ein.<\/p>\n Importieren des Fotos<\/b><\/p>\n Die Funktion AttachmentImportieren <\/b>aus Listing 4 soll das mit dem ersten Parameter angegebene Foto in einen neuen, leeren Datensatz der Tabelle tblBilder<\/b> importieren und gleichzeitig den Wert des Feldes ProduktID <\/b>auf den Wert des zweiten Parameters einstellen. Außerdem soll sie den Primärschlüsselwert des neuen Datensatzes zurückliefern.<\/p>\n Listing 4: Importieren des Fotos<\/span><\/b><\/p>\n Die Funktion deklariert neben einer Database<\/b>-Variablen zwei Variablen des Typs Recordset2<\/b>. Die erste soll die Tabelle tblBilder <\/b>referenzieren, die zweite die interne Tabelle des Anlagefeldes Bild<\/b>. Außerdem benötigen wir noch eine Variable des Typs Field2<\/b>.<\/p>\n Nachdem die Prozedur die Variable db <\/b>mit einem Verweis auf das aktuelle Database<\/b>-Objekt gefüllt hat, erstellt es das erste Recordset2<\/b>-Objekt auf Basis der Tabelle tblBilder<\/b>. Da wir nur einen neuen Datensatz anlegen wollen, aber nicht auf vorhandene Datensätze zugreifen, legen wir als Kriterium den Wert 1 = 2 <\/b>fest, was für keinen Datensatz zutrifft – und dementsprechend eine leere Datensatzgruppe zurückliefert.<\/p>\n Diesem Recordset fügt die Prozedur nun einen neuen Datensatz hinzu und stellt dessen Feld ProduktID <\/b>auf den Wert des zweiten Parameters lngProduktID <\/b>ein. Dann legt es das zweite Recordset2<\/b>-Objekt für das im Feld Bild <\/b>enthaltene Recordset an. Dazu muss es auf die Value<\/b>-Eigenschaft des Feldes zugreifen. Auch hier legt sie einen neuen Datensatz an und referenziert dann das Feld FileData <\/b>dieses Datensatzes mit der Field2<\/b>-Variablen fld<\/b>.<\/p>\n Dann nutzen wir die LoadFromFile<\/b>-Methode und übergeben den Pfad zu der zu importierenden Bilddatei aus strDatei <\/b>als Parameter. Danach speichern wir die Änderungen an dem neuen Anlage-Datensatz. Bevor wir auch die Änderungen am neuen Datensatz der Tabelle tblBilder <\/b>speichern, greifen wir noch den Primärschlüsselfeld des neuen Datensatzes ab und weisen diesen als Rückgabewert der Funktion AttachmentImportieren <\/b>zu. Erst dann führen wir die Update<\/b>-Methode auch für das Recordset mit dem neuen Datensatz der Tabelle tblBilder <\/b>aus und schließen diesen und leeren die Objektvariablen.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Dieser Beitrag stellt eine Lösung vor, mit der Sie die Kamera-App von Windows starten und damit geschossene Fotos direkt in die Datenbank speichern können. Da wir die Kamera-App nicht komplett fernsteuern können, kann es zu unvorhergesehenem Verhalten kommen – beispielsweise, wenn der Benutzer nicht den Ordner angegeben hat, in den die Kamera-App ihre Fotos speichert oder wenn die Kamera-App gar keine Kamera findet oder aktivieren kann.<\/p>\n Wir haben die Beispielanwendung mit einem Surface mit eingebauter Kamera getestet. Probieren Sie aus, ob es auch mit der Kamera Ihres Rechners funktioniert!<\/p>\n Enthaltene Beispieldateien:<\/p>\n WebcamBilderInDatenbank.accdb<\/p>\n![\"Meldung](\"..\/fileadmin\/_temp_\/2020_06\/pic_1275_001.png\")
<\/p>\n![\"Datenmodell](\"..\/fileadmin\/_temp_\/2020_06\/pic_1275_002.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2020_06\/pic_1275_003.png\")
<\/p>\nPrivate Sub <\/span>cmdVerzeichnisAuswaehlen_Click()\r\n Dim <\/span>strFotopfad As String<\/span>\r\n strFotopfad = OpenPathName(Nz(Me!txtFotopfad, CurrentProject.Path), \"Fotoverzeichnis auswählen\")\r\n If <\/span>Not<\/span> Len<\/span>(strFotopfad) = 0 Then<\/span>\r\n Me!txtFotopfad = strFotopfad\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Dialog](\"..\/fileadmin\/_temp_\/2020_06\/pic_1275_004.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2020_06\/pic_1275_005.png\")
<\/p>\nPrivate Sub <\/span>cmdFotopfadAnpassen_Click()\r\n DoCmd.OpenForm \"frmOptionen\", WindowMode:=acDialog\r\nEnd Sub<\/span><\/pre>\nDim <\/span>datStart As Date<\/span><\/pre>\nPrivate Sub <\/span>cmdFotoHinzufuegen_Click()\r\n datStart = Now\r\n Shell \"cmd.exe \/C \"\"start microsoft.windows.camera:\"\", vbMaximisedFocus\"\r\n Sleep 1000\r\n If <\/span>AnwendungGeoeffnet(\"Kamera\") Then<\/span>\r\n Me.TimerInterval = 1000\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nShell \"cmd.exe \/C \"\"start microsoft.windows.camera:\"\", vbMaximisedFocus\"<\/pre>\n
Private Sub <\/span>Form_Timer()\r\n Dim <\/span>objFS As <\/span>Scripting.FileSystemObject\r\n Dim <\/span>objFile As <\/span>Scripting.File\r\n Dim <\/span>objFolder As <\/span>Scripting.Folder\r\n Dim <\/span>datAktuell As Date<\/span>\r\n Dim <\/span>objNewestFile As <\/span>Scripting.File\r\n Dim <\/span>lngBildID As Long<\/span>\r\n Dim <\/span>strFotoverzeichnis As String<\/span>\r\n strFotoverzeichnis = Nz(DLookup(\"Fotopfad\", \"tblOptionen\"), Environ$(\"USERPROFILE\") & \"PicturesCamera Roll\")\r\n If <\/span>Not<\/span> Right<\/span>(strFotoverzeichnis, 1) = \"\" Then<\/span>\r\n strFotoverzeichnis = strFotoverzeichnis & \"\"\r\n End If<\/span>\r\n Set<\/span> objFS = New<\/span> FileSystemObject\r\n Set<\/span> objFolder = objFS.GetFolder(strFotoverzeichnis)\r\n datAktuell = datStart\r\n For Each objFile In objFolder.Files\r\n If <\/span>objFile.DateCreated > datAktuell Then<\/span>\r\n Select Case Mid<\/span>(objFile.Name, InStrRev<\/span>(objFile.Name, \".\") + 1)\r\n Case <\/span>\"ini\"\r\n Case Else<\/span>\r\n datAktuell = objFile.DateCreated\r\n Set<\/span> objNewestFile = objFile\r\n End Select<\/span>\r\n End If<\/span>\r\n Next<\/span> objFile\r\n If <\/span>datAktuell > datStart Then<\/span>\r\n Me.TimerInterval = 0\r\n lngBildID = AttachmentImportieren(strFotoverzeichnis & objNewestFile.Name, Me!ProduktID)\r\n Me!sfmProdukte.Form.Requery\r\n Me!sfmProdukte.Form.Recordset.FindFirst \"BildID = \" & lngBildID\r\n End If<\/span>\r\n If <\/span>Not<\/span> AnwendungGeoeffnet(\"Kamera\") Then<\/span>\r\n Me.TimerInterval = 0\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2020_06\/pic_1275_006.png\")
<\/p>\nPublic Function <\/span>AttachmentImportieren(strDatei As String<\/span>, lngProduktID As Long<\/span>) As Long<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>Recordset2\r\n Dim <\/span>rstAttachments As <\/span>Recordset2\r\n Dim <\/span>fld As <\/span>Field2\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblBilder WHERE 1 = 2\", dbOpenDynaset)\r\n rst.AddNew<\/span>\r\n rst!ProduktID = lngProduktID\r\n Set<\/span> rstAttachments = rst.Fields(\"Bild\").Value\r\n rstAttachments.AddNew<\/span>\r\n Set<\/span> fld = rstAttachments.Fields(\"FileData\")\r\n fld.LoadFromFile strDatei\r\n rstAttachments.Update\r\n AttachmentImportieren = rst!BildID\r\n rst.Update\r\n rst.Close\r\n Set<\/span> rst = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Function<\/span><\/pre>\nDownloads zu diesem Beitrag<\/h3>\n