Legosortiermaschine Bildverarbeitung

Aus HSHL Mechatronik
Zur Navigation springen Zur Suche springen

Dies ist ein Unterarikel von der Legoteil Zählmaschine, welcher die aktuellen Änderungen an dem Teilgebiet der Bildverarbeitung der Lego Sortiermaschine beschreibt.

Autor: Torben Müller

Einleitung

Diese Unterseite des Artikels beschäftigt sich hauptsächlich mit der Bildverarbeitung zur Erkennung der Legoteile. Dies geschieht in der Bildverarbeitungsbox der Anlage (vgl. Abbildung der Startseite Punkt 4). Zusätzlich dazu werden auch alle anderen Arbeiten an der Software des Matlab Programmes hier behandelt und dokumentiert.

Generell lässt sich das Programmes in drei Funktionalitäten aufteilen:

  • Sortierung
  • Anlernen
  • Baukasten bearbeiten

Die Funktion Sortierung stellt die Hauptfunktion dar. Sie beschreibt den laufenden Zustand der Anlage beim sortieren von Teilen. Hier spielt ein Großteil der Bildverarbeitung rein. Die Funktion Anlernen ist eine Nebenfunktion, die genutzt werden kann wenn die Anlage nicht sortiert. Hier können Legoteile angelernt werden, sodass die Anlage fähig ist diese Teile in einer späteren Sortierung zu erkennen. Die Funktion Baukasten bearbeiten dient als Wartungsfunktion um Informationen über Legobaukästen zu bearbeiten, denen jeweils die zu sortierenden Teile zugehören.

Anforderungen

Basiered auf einer Liste offener Punkte aus dem Vorsemester wurden für das Sommersemester 18 und das Wintersemester 18/19 folgende Anforderungen festgelegt:

Spezifikations-ID Anforderungs-ID Anforderungstitel Beschreibung der Spezifikation Link
0060 REQ10.2050 Bauteile Unterstützung sämtlicher Legoteile. Fokus auf NXT und EV3. Dokument
0060.1 REQ10.2050 Bauteile Visuelle Anleitung erstellen Wiki
0061 REQ10.2050 Bauteile Basissatz wird unterstützt und alle entsprechenden Teile werden erkannt Dokument
0062 REQ10.2050 Bauteile Erweiterungssatz wird unterstützt und alle entsprechenden Teile werden erkannt Dokument
0063 REQ10.2050 Bauteile Vorsortierung via GUI Wiki
0120 REQ10.2250 Bildverarbeitung Echtzeit mit Matlab/Simulink Dokument
0120.1 REQ10.2250 Bildverarbeitung Echtzeit mit Matlab/Simulink. Teile werden erkannt und mit Seriennummer klassifiziert Dokument
0122 REQ10.2220 Bildverarbeitung Geschwindingkeit erhöhen: Software analysieren und den Code beschleunigen z.B. Schleifen sparen, Variablen global speichern Dokument
0123 REQ10.2220 Bildverarbeitung Prozentsatz der erkannten Teile errechnen Dokument
0124 REQ10.2220 Bildverarbeitung Nicht erkannte Teile in der Position des nicht erkannten Teils anlernen Dokument
0125 REQ10.2220 Bildverarbeitung HSV Farbraum testen, um Farberkennung zu verbessern Dokument
0126 REQ10.2220 Bildverarbeitung In Bilderkennungsbox zusätzliche LEDs hinzufügen für besseres Auflichtbild Dokument
0127 REQ10.2220 Bildverarbeitung Offline-Modus einfügen um basierend auf einem Video die Bildverarbeitung zu testen Wiki
0140 REQ10.2300 Teileliste Inventurliste im xls-Format zeigt, wie viele Teile erkannt wurden und wie viele im Neuzustand des Kastens sind dadurch Differenz erkennbar. Fehlteilliste muss in geeignetem Format für Neubeschaffung ausgegeben werden Dokument
0141 REQ10.2300 Teileliste Geeignetes Format für eine Fehlteilliste planen, also welche Informationen enthalten sein müssen um eine Neubeschaffung zu ermöglichen zb Seriennummer oder Onlinelink Dokument
0142 REQ10.2300 Teileliste Fehlteiliste implementieren und ausgeben lassen Dokument
0143 REQ10.2300 Teileliste GUI erweitern um Fehlteilliste auszugeben Dokument
0180 REQ10.2330 Teach-In Über GUI neue Teile anlernbar. Ein benutzerfreundliches Interface soll das Anlernen der Bauteile ermöglichen. Dokument
0181 REQ10.2330 Teach-In Sicherstellung der vorhanden GUI- und Datenbankfunktionen Wiki
0182 REQ10.2330 Teach-In Fehlende Funktionen hinzufügen Dokument

Tabelle 1: Anforderungen

GUI

Die Benutzeroberfläche für dieses Projekt wurde bereits von Vorsemestern erstellt und kann verwendet werden, um das Projekt zu steuern. Zuerst galt es, die vorhandenen Funktionen der GUI zu prüfen, um weitere Arbeitsschritte zu ermitteln.

Sicherstellung vorhandener Funktionen

Für die Sicherstellung der vorhandenen GUI Funktionen wurde ein Test jedes Buttons innerhalb der Software durchgeführt und dokumentiert.

Abbildung 1: Hauptseite Abbildung 2: Hilfetexte
Der Startbildschirm (1) führt zu den Bereichen Sortierung (2), Teach-In (3) und Baukasten bearbeiten (4). Die Hilfeknöpfe blenden einen Hilfetext für den jeweiligen Programmteil ein und beenden öffnet ein Bestätigungsfenster, welches das Programm beendet oder das Fenster wieder schließt.
Abbildung 3: Sortierung starten Abbildung 4: Kontrollbildschirm bei laufender Sortierung Abbildung 5: Teach In
In dem Teilbereich der Sortierung lässt sich eine Kasten-ID auswählen, wodurch eine Tabelle mit allen in diesem Kasten enthaltenen Teilen angezeigt wird. Dort lässt sich eine manuelle Vorsortierung der Teile eintragen, wie in dem Abschnitt zur Vorsortierung beschrieben. Zurück führt zu dem Startbildschirm (1) und Beenden öffnet das Bestätigungsfenster zum Beenden oder abbrechen. Mit betätigen des Speichern Knopfes kommt man nach einem Fortschrittsbalken der Kamerakalibrierung zu einem Kontrollbildschirm, wo Echtzeitinformationen der Maschine angezeigt werden und die Maschine wird gestartet. Oben links wird das Kamerabild der Bildverarbeitung angezeigt und oben rechts ein Binärbild, welches bei der Bildverarbeitung aufgenommen wird. Unten links sieht man das Kamerabild der Seperierung und unten rechts das Binärbild aus der Seperierung. Mit Drücken der Escape-Taste wird die Maschine beendet und eine Inventurliste generiert, wo die Anzahlen der erkannten Teile angezeigt werden. In dem Bereich Teach-In kann in dem ersten Fenster eine Bauteile-ID eingegeben werden. Zurück kehrt zu dem Startbildschirm (1) zurück und Beenden führt zu dem Bestätigungsfenster. Mit Speichern & Weiter wird die Kamera der Bildverarbeitung angezeigt. Mit Enter wird ein Foto aufgenommen und mit Space wird dieses Foto in ein Binärbild umgewandelt und neu angezeigt. Erneutes Space speichert das Teil mit der eingegebenen Nummer in der Datenbank
Abbildung 6: Baukasten bearbeiten Abbildung 7: Einzelnes Teil im Baukasten bearbeiten
Bei Baukasten bearbeiten lässt sich oben im Fenster mit dem Knopf Speichern & Weiter ein neuer Baukasten erzeugen. Danach kann mit Eingaben ändern die Kasten-ID und die Anzahl der Teile nachträglich angepasst werden. In der Tabelle darunter können Teile in diesen Kasten eintragen. Änderungen speichern speichert diese Änderungen an dem Kasten in der Datenbank. Unten links kann dann Wahlweise ein Bauteil aus dem Kasten, ein Teil komplett oder ein ganzer Kasten gelöscht werden. Auswahl anwenden führt dabei die jeweils gewählte Aktion aus. Unten rechts lassen sich einzelne Bauteile in dem Kasten hinsichtlich ihrer Anzahl und Fachnummer in dem Kasten bearbeiten. Diese Änderungen werden jedoch mit dem Betätigen des Knopfes Änderungen speichern nicht in die Datenbank übernommen. Diese Funktion wird in dem Abschnitt Kastenänderungen abspeichern hinzugefügt.

Text der Oberfläche überarbeiten

Bei der Sicherstellung der Funktionalität ist aufgefallen, dass einige Knöpfe und Hinweise in der GUI nicht aussagekräftig. Zudem hatten einige Fenster noch keinen angemessenen Titel. Diese Anzeigetexte wurden angepasst, sodass die GUI einfacher zu verstehen und für ungeübte User einfacher zu benutzen ist. Die neuen Beschriftungen im Zusammenhang der Schritt für Schritt Anleitung hier zu sehen.

Sortierung

Die Sortierung ist die Hauptfunktion der Anlage. Zusammen mit dem Programm der Seperierung steuern beide die gesamte Anlage in ihrem sortierenden Zustand. Ein grober Ablauf der Sortierung kann der Abbildung NUMMER entnommen werden.

Dieser Algorithmus deckt die Teilbereiche Erkennung und Ansteuerung der Sortierung ab. Nach diesem Ablauf wird von der Hauptschleife des Programmes in der Datei StartSortiermaschine ein Durchlauf der Separierung gestartet. Dieser steuert alle zur Seperierung gehörenden Komponenten. Danach wird der Ablauf wiederholt. So werden alle nötigen Funktionen zum Sortieren von Legoteilen abgedeckt.

Funktionalität

Hier werden Themen behandelt, die direkt mit der Funktionalität und/oder der Effizienz der Sortierung zu tun haben. Diese Änderungen werden nicht direkt wahrgenommen und dienen dem steigern der Güte der Teileerkennung.

Bewegungserkennung

Es wurde eine Bewegungserkennung als erster Mechanismus in dem Algorithmus zum erkennen von Teilen eingefügt. Dieser Alorithmus funktioniert, indem zwei Bilder in einem kurzen Abstand voneinander aufgenommen werden. Diese Bilder werden in den Graubereich konvertiert von einander subtrahiert. In dem entstehenden Differenzbild wird das Maximum ermittelt und dieses dann mit einem Threshold verglichen.

Dieser Vorgang wird solange wiederholt, bis das Maximum des Differenzbildes kleiner ist als eine definierte Grenze, was bedeutet, dass das Teil ruht oder nur noch sehr langsam rutscht. Durch diesen Mechanismus können viele Aufnahmen verhindert werden, in denen das Bauteil noch nicht in Ruhe war und so ein verzerrtes Bild aufgenommen wurde, welches nicht korrekt analysiert werden kann.

Farberkennung

Ansatz 1:

Die Farberkennung in ihrem Ausgangszustand lieferte keine zuverlässigen Ergebnisse. Vor allem die die Farben rot, gelb, grün, blau und schwarz wurden oft in Grautönen erkannt. Um dieses Problem zu beheben, war der erste Ansatz eine Neukalibrierung der existierenden Farbwerte. Die Farbbeurteilung geschah in der Datei Farberkennung. Dort waren in dem Array Farbwerte für jede der möglichen 10 Farben Werte hinterlegt, mit denen ein aktuelles Bild verglichen wurde. Hier folgend die dort verwendeten Werte:

Farbwerte=[   0.5133 0.4578 0.4033; %'weiss'          
              0.4857 0.4154 0.3289; %'beige'         
              0.4522 0.1456 0.1868; %'rot'           
              0.1400 0.2129 0.3308; %'blau'          
              0.5817 0.4393 0.2213; %'gelb'          
              0.1637 0.1761 0.1961; %'schwarz'       
              0.1703 0.2396 0.2240; %'gruen'         
              0.3318 0.2959 0.2705; %'hellbraun'          
              0.3221 0.3228 0.3230; %'hell-grau'        
              0.2256 0.2302 0.2370; %'dunkel-grau'     
              ];

Um nun neue Farbkalibrierungswerte für jede Farbe zu erhalten und die vorhandenen damit zu überschreiben, wurden mehrere Teile jeder Farbe von der Bildverarbeitung analysiert und die berechneten Farbwerte wurden im Programm ausgelesen. Diese Farbwerte wurden dann in eine Tabelle eingetragen und über drei verschiedene Teile gemittelt. So konnte ein möglichst passender Wert für die jeweilige Legoteilfarbe ermittelt werden (vgl. Tabelle 3). Dieser Durchschnittswert wurde für alle Farben ermittelt und dann in die Farberkennung als neue Referenzwerte eingetragen.

weiß R G B
0,5153 0,4650 0,4136
0,5092 0,4570 0,4020
0,5155 0,4512 0,3944
0,5133 0,4578 0,4033

Tabelle 3: Beispielwerte für weiß


Ansatz 2:

Nach der Neukalibrierung bestanden jedoch weiterhin Erkennnungsprobleme mit einigen Farben. Vor allem schwarz konnte selten als selbiges erkannt werden. Darum folgt ein zweiter Ansatz zum verbessern der Farberkennung: Die Verwendung von Farbmasken

Mit der Matlab-App Color Thresholder lassen sich Farbmasken für spezielle Farben erstellen. Angewendet auf ein Farbbild erzeugen diese Masken ein Binärbild, wo nur Bereiche in der jeweiligen eingestellten Farbe markiert werden. Die Idee besteht somit darin, für jede Farbe, die ein Legoteil haben kann, eine Farbmaske zu erstellen. Alle diese Masken werden dann auf ein Farbbild angewendet, welches ein Teil einer Farbe enthält. Um die Erkennung noch zu verbessern, wird das Farbbild vorher mit dem Binärbild multipliziert. Dadurch bleibt ein Bild über, wo nur an der Stelle des Teiles die originalen Bildinformationen bestehen blieben. So wird sichergestellt, dass die Masken nur die Farbe des Teiles auswerten.

Die Maske, welche auf die aktuelle Farbe eingestellt ist, wird die meiste Fläche markieren (im Idealfall die komplette Fläche des Teiles). So erzeugt also diese Maske ein Binärbild, wo die meisten Pixel aktiviert sind. Eine einfache Summierung aller Pixel in dem Bild zeigt, welche der Masken am meisten von dem eingegebenen Farbbild aktiviert wurde. Das bedeutet das die Maske mit der größten Pixelsumme auf die Farbe des aktuellen Teiles eingestellt ist und somit die Farbe bekannt ist.

% Beurteilen, welche Maske am stärksten anschlägt, also am meisten Pixel auf eins setzt
maskenPixelSummen(1) = sum(sum(binaerBeige));
maskenPixelSummen(2) = sum(sum(binaerSchwarz));
maskenPixelSummen(3) = sum(sum(binaerBlau));
maskenPixelSummen(4) = sum(sum(binaerGrau));
maskenPixelSummen(5) = sum(sum(binaerGruen));
maskenPixelSummen(6) = sum(sum(binaerHellbraun));
maskenPixelSummen(7) = sum(sum(binaerHellgrau));
maskenPixelSummen(8) = sum(sum(binaerRot));
maskenPixelSummen(9) = sum(sum(binaerWeis));
maskenPixelSummen(10) = sum(sum(binaerGelb));

[~, index] = max(maskenPixelSummen);

%Entsprechende Farbe speichern
switch index
    case 1 
        Farbe='beige';
    case 2
        Farbe='schwarz';
    case 3
        Farbe='blau';
    case 4
        Farbe='dunkel-grau';
    case 5
        Farbe='gruen';
    case 6
        Farbe='hell-braun';
    case 7
        Farbe='hell-grau';
    case 8
        Farbe='rot';
    case 9
        Farbe='weiss';
    case 10
        Farbe='gelb';
    otherwise
        disp('ERROR with color detektion')
end

Merkmal-Erkennung

Die Merkmale eines Legoteiles werden aus dem Durchlichtbild extrahiert. Dazu wird das Bild zuerst in ein Binärbild konvertiert, um dann die einzelnen Merkmale kalkulieren zu können. Die Erstellung dieses Binärbildes hat sich im Ausgangszustand als Fehleranfällig erwiesen. Zudem war deutlich zu erkennen, dass das Teil nicht besonders genau abgebildet wurde, sodass Parameter wie Umfang und Fläche nicht sonderlich aussagekräftig waren.

Zur Besserung wurde hier ein neues Verfahren zur Erstellung des Binärbildes eingeführt. Eine Matlab-Funktion imbinarize ermöglicht die Berechnung eines Binärbildes durch einen vorher ermittelten Grenzwert aus einem Farbbild. Die Idee besteht darin, das Durchlichtbild an die Funktion imbinarize zu übergeben und dadurch ein Binärbild des Teiles zu erhalten. Anschließend müssen von der resultierenden Matrix die überflüssigen Tiefenkanäle abgeschnitten werden und das Bild von Salz- und Pfefferrauschen bereinigt werden.

    hintergrundLevel = graythresh(durchlichtbild);
    binaerbild = imbinarize(differenzFarbbild,hintergrundLevel);
    binaerbild = binaerbild(:,:,1);
    binaerbild = ~binaerbild;
    %Bereinigung des Binärbildes
    %Salz (weiße Pixel) auf Hintergrund entfernen
    binaerbild = bwareaopen(binaerbild,SalzPfeffer);
    %Pfeffer (schwarze Pixel) in Legoteilen entfernen
    binaerbild = ~bwareaopen(~binaerbild,SalzPfeffer);


Das Resultat ist ein einwandfreies Binärbild des Teiles (vgl. Abbildung NUMMER).

Echtzeit

Zum Testen der Echtzeit der Bildverarbeitung bezogen auf die Anforderung REQ10.2250 wurde ein Versuch entworfen. Dabei werden Teile wie im folgenden Bild direkt vor der Bildverarbeitungsbox auf das Förderband gelegt und zeitgleich eine Zeitmessung gestartet. Sobald ein Teil in die Bildverarbeitunngsbox gefallen ist, wird an die gleiche Stelle ein neues Teil gelegt, sodass fast permanent ein Teil in der Box liegt und die Pause zwischen den Teilen minimal ist.


Abbildung 8: Einlegestelle der Teile


Um die Ausgangssituation zu bewerten, wurde dieser Test mit verschiedenen Teilearten und -mengen ausgeführt. (Test vom 31.05.18)

Test Anzahl Teile Anzahl erkannt Gesamtzeit [s] Zeit pro Teil [s] Erkennungsrate [%] Teileart
1 15 10 43 2,86 66,6 gemischt
2 30 16 86 2,86 53,3 gemischt
3 20 15 60 3 75 klein
4 15 9 42 2,8 60 groß

Tabelle 2: Tests und Ergebnisse zur Echtzeit


Hier kann man erkennen, dass die Zeit pro Teil nur leichte Änderungen aufweist zwischen den unterschiedlichen Teilegruppen und dadurch festgestellt werden kann, dass die Echtzeit nicht stark von der Teileart beeinflusst wird.


In einem zweiten Testdurchgang wurde dann eine zufällige Teilegruppe verwendet und keine externe Zeitmessung mehr durchgeführt, sondern nur das Ergebnis des Matlab Profilers analysiert um verschiedene Methoden zur Erhöhung der Geschwindigkeit zu testen. Dieses Tool verfolgt zur Laufzeit des Programmes die Anzahl von Funktionsaufrufen und deren Ausführungsdauer. So wird für jede ausgeführte Programmzeile die Gesamtzeit gemessen, die diese Zeile beansprucht. Außerdem wird eine Übersicht erstellt mit den zeitaufwändigsten Zeilen und wie viel Zeit diese prozentual von der Gesamtzeit beansprucht haben.

Funktionsaufrufe: 267 Funktionsaufrufe: 404
Ausgangszustand:




0,13s pro Call


Erste Iteration:
  • imshow verschoben -> wird nur auseführt wenn Teil auch ausgewertet wird
  • Pause bei seriellen Befehlen entfernt
  • Lightdelay um die Hälfte reduziert


0,082s pro Call


Funktionsaufrufe: 287 Funktionsaufrufe: 297
Zweite Iteration:
  • 0,2s Pause für Bewegungserkennung innerhalb der Bildverarbeitungsbox hinzugefügt
  • Funktion figure(HauptFigure) entfernt


0,12s pro Call

Dritte Iteration:
  • Pause der Bewegungserkennung auf 0,1 reduziert



0,117s pro Call

Erkennung der Teile

Um die Erkennung der Teile aus beiden Baukästen (Basisset 45544 und Erweiterungsset 45560) sicherzustellen, wurde eine Excel Tabelle angelegt und jedes Teil einzeln geprüft, ob es von der Anlagt erkannt wird.

Das entsprechende Ergebnis wurde in der richtigen Spalte der Tabelle festgehalten. Hier sieht man den Aufbau der Tabelle:

Teile ID Kasten ID In Datenbank vorhanden Wird erkannt Muss manuell gezählt werden Bemerkungen

Wurde ein Teil nicht oder schwer erkannt, so wurde dies in der Spalte Bemerkung vermerkt, sodass später die kritischen Teile erneut angelernt werden konnten. Zusätzlich ließen sich hier Fehler in der Erkennung verdeutlichen, zum Beispiel das schwarze Teile zu beginn generell schwer erkannt werden konnten.

Mit dem Ende der Projektzeit sind alle Teile bearbeitet und so vermerkt, dass sie entweder von der Anlage erkannt werden können oder auf Grund von Größe oder Beschaffenheit manuell vorsortiert werden müssen.

Interaktion

Manuelle Vorsortierung

In Abbildung 3 wird die GUI zum Starten der Sortierung angezeigt. Dort wird in der Mitte eine Tabelle dargestellt, die nach Auswählen der Kasten ID alle Teile in diesem Kasten anzeigt. Die erste Spalte beinhaltet die ID des Teils, die zweite die vorgesehene Anzahl dieses Teiles in dem Kasten und in der dritten Spalte sollte dann die Möglichkeit bestehen die Anzahl der Teile einzutragen, die bereits mit der Hand vorsortiert worden sind. Dazu muss zuerst der Data Array der Tabelle, welcher die Inhalte speichert um eine dritte Nullspalte erweitert werden. Dazu wird die Funktion horzcat verwendet, die zwei Arrays horizontal miteinander verbindet:

% Datei SortierStart.m
Nullreihe = cell(size(curs.Data,1),1);
Nullreihe(:,1) = {0};
handles.uitable1.Data = horzcat(curs.Data, Nullreihe);

global GUI_vorsortierteTeile
GUI_vorsortierteTeile = handles.uitable1.Data;


Der Inhalt der Tabelle wird zuletzt in eine globale Variable gespeichert, um bei der Erstellung der Inventurliste auf die Anzahl der vorgezählten Teile zugreifen zu können. Dabei wird auf die Anzahl der automatisch gezählten Teile, gespeichert in der vierten Spalte von InventurListeContent, die Anzahl der manuell gezählten Teile, gespeichert in der dritten Spalte von GUI_vorsortierteTeile, addiert und später ausgegeben:

% Datei InventurlistenTemplateMultiKaesten.m
InventurListeContent(2:end,4) = num2cell(cell2mat(InventurListeContent(2:end,4)) + cell2mat(GUI_vorsortierteTeile(:,3)));
...
xlswrite(InventurlisteName,InventurListeContent);


Für diese hinzugefügte Funktion wurde in der Anleitung für die Gesamtanlage der entsprechende Abschnitt bearbeitet: Wiki-Artikel


Prozentsatz nicht erkannter Teile

In der Inventurliste soll zusammen mit den Anzahlen der einzelnen Teile auch eine Prozentzahl ausgegeben werden die angibt, wie viel Prozent der analysierten Teile nicht erkannt wurden. Der Array LegoTeile enthält die Anzahlen von allen Teilen zuzüglich der Anzahl der nicht erkannten Teile. Im nächsten Schritt müssen die einzelnen Mengen addiert werden um dann die Anzahl der nicht erkannten Teile in ein Verhältnis zu der Gesamtanzahl an analysierten Teilen setzen zu können. In der letzten Zeile wird die errechnete Zahl dann in die zweite Zeile unter der Inventurliste von Teilen in dem Kasten zusammen mit etwas Text ausgegeben ausgegeben

gesamtZahlTeile = sum(LegoTeile(:,2));
prozentsatzNichtErkannterTeile = LegoTeile(1,2)/gesamtZahlTeile;

InventurListeContent(end+2,3) = {['Nicht erkannte Teile: ' num2str(prozentsatzNichtErkannterTeile*100) '%']};

Layout einer Fehlteilliste

Um nach dem erfolgreichen Sortieren eines Kastens die Nachbestellung der fehlenden Teile zu vereinfachen, sollte ein Layout erstellt werden in dem die Fehlteile ausgegeben werden. Dieses Layout sollte die Teile übersichtlich mit allen wichtigen Informationen darstellen und eine Nachbestellung dieses Teils vereinfachen. Das folgende Layout orientiert sich an den üblichen Materiallisten der Hochschule, ist aber ergänzt um die Spalte Kastenbezeichnung, wo manuell die Nummer des Kastens eingetragen werden kann, die von der Hochschule auf den Kasten geklebt wurde. Die ersten drei Spalten sollen dann von der Software selbst ausgefüllt werden, sodass die generierte Liste dann verwendet werden kann, um den Nachbestellungsprozess zu dokumentieren und zu verwalten.


Abbildung 9: Layout der Fehlteiliste


Sortireungshauptfenster optimiert

Anlernen

Prinzip

Funktionalität überarbeitet

Interface ausgeweitet

Baukasten bearbeiten

Prinzip

Bearbeitung eines Kastens abspeichern

Datenbank export/import

Zusammenfassung

  • Offene Punkte

Dies ist ein Unterartikel von der Legoteil Zählmaschine, welcher den genauen Aufbau der Bildbearbeitung beschreibt.