flexibles kleinteile-modul für das...
Post on 09-Aug-2019
215 Views
Preview:
TRANSCRIPT
Universität Bremen
Fachbereich 3 – Mathematik / Informatik
Flexibles Kleinteile-Modul für das COAT-System
Diplomarbeit
von
Ilia Smirnov
Bremen, Juli 2008
Gutachter: Prof. Dr. Karl-Heinz Rödiger
Prof. Dr. Friedrich-Wilhelm Bruns
2
Inhaltsverzeichnis
Inhaltsverzeichnis .......................................................................................................2
Abbildungsverzeichnis ...............................................................................................4
1. Einleitung ............................................................................................................6
1.1. Motivation ....................................................................................................6
1.2. Aufbau der Arbeit.........................................................................................7
1.3. Terminologie ................................................................................................7
2. Problembeschreibung.........................................................................................9
2.1. Schnittmusterkonstruktion............................................................................9
2.1.1. Erstellen des Grundschnittes ..............................................................10
2.1.2. Kleinteile in der Schnittkonstruktion..................................................12
2.1.3. Kleinteile und Modellschnittentwicklung ..........................................12
2.1.4. Gradieren der Schnittmuster...............................................................14
2.2. Stand der Technik.......................................................................................15
2.2.1. Das COAT-System.............................................................................15
2.2.2. Weitere CAD-Systeme .......................................................................17
2.3. Definition der Bausteine nach Anja Dewes................................................17
3. Anforderungen an die Kleinteile-Bibliothek..................................................19
4. Lösungsansätze .................................................................................................22
4.1. Begriffsklärung...........................................................................................22
4.1.1. Über Maßzugaben und Modellvariablen ............................................22
4.2. Parametrisierung der Kleinteile ..................................................................23
4.2.1. Parametrisierung über Körpermaße und Maßzugaben .......................23
4.2.2. Parametrisierung über Bezugselemente..............................................25
4.3. Inkonsistenz der Bezugselemente...............................................................27
4.4. Mehrfache Verwendung .............................................................................28
4.5. Vorschau der Kleinteile ..............................................................................29
4.6. Speichern der Kleinteile .............................................................................30
4.7. Ergänzen der Variablen ..............................................................................32
5. Lösung für die Kleinteile-Bibliothek ..............................................................34
5.1. Implementierungstechnik ...........................................................................34
5.2. Benutzungsinterface ...................................................................................35
5.3. Konstruktion eines Kleinteils .....................................................................35
3
5.4. Auswahl der Kleinteile ...............................................................................41
5.5. Einfügen eines Kleinteils............................................................................42
5.6. Weitere Aspekte der Lösung ......................................................................45
5.6.1. Erweiterung der Skript-Sprache .........................................................45
5.6.2. Kleinteile löschen ...............................................................................45
5.6.3. Import und Export ..............................................................................45
5.6.4. Copyright ............................................................................................46
5.6.5. Einschränkungen ................................................................................46
6. Beschreibung des Systems ...............................................................................48
6.1. Kleinteile konstruieren ...............................................................................48
6.2. Kleinteile einfügen .....................................................................................50
6.2.1. Dialog Kleinteile-Bibliothek ..............................................................50
6.2.2. Dialog Bezugselemente angeben........................................................51
7. Resümee.............................................................................................................53
8. Literatur ............................................................................................................55
9. Internetquellen..................................................................................................56
10. Anhang...........................................................................................................57
10.1. Beispiel für die Konstruktion einer Tasche ............................................57
10.2. Klassendiagramme .................................................................................62
4
Abbildungsverzeichnis
Abb. 1: Grundschnitt für einen Mantel.......................................................................11
Abb. 2: Vielfalt der Taschenformen ([McKelvey 1996: 169])...................................13
Abb. 3: Blusen-Grundschnitt mit Kleinteilen in COAT.............................................16
Abb. 4: Blusenmanschette ..........................................................................................24
Abb. 5: Rocktasche.....................................................................................................26
Abb. 6: Peter Pan-Kragen ([Aldrich 1997: 125]) ......................................................27
Abb. 7: Unterschiedliche Konstruktionsarten der Taillenlinie...................................28
Abb. 8: Dialog Kleinteile-Bibliothek .........................................................................41
Abb. 9: Button für Kleinteile-Modus .........................................................................48
Abb. 10: Dialog Kleinteil erstellen.............................................................................49
Abb. 11: Dialog Kleinteile-Bibliothek ........................................................................50
Abb. 12: Dialog Bezugselemente ...............................................................................51
Abb. 13: Vorderteil des Blusengrundschnittes ...........................................................57
Abb. 14: Schnittteil einfügen......................................................................................57
Abb. 15: Zugabe für die Taschenbreite ......................................................................58
Abb. 16: Konstruktion der Tasche..............................................................................58
Abb. 17: Vorderteil und Tasche zusammenlegen.......................................................58
Abb. 18: Fertige Tasche .............................................................................................59
Abb. 19: Kleinteil erstellen.........................................................................................59
Abb. 20: Kleinteile-Bibliothek ...................................................................................60
Abb. 21: Dialog Bezugselemente angeben .................................................................60
Abb. 22: Eingefügte Tasche im Modellschnitt Bluse 1 ..............................................61
5
Eidesstattliche Erklärung
Ich versichere, dass ich diese Arbeit ohne fremde Hilfe und ohne Benutzung anderer
als der angegebenen Quellen angefertigt habe und dass sie in gleicher oder ähnlicher
Form noch keiner anderen Prüfungsbehörde vorgelegen hat und von dieser als Teil
einer Prüfungsleistung angenommen wurde. Alle Ausführungen, die wörtlich oder
sinngemäß übernommen wurden, sind als solche gekennzeichnet.
Bremen, den 24. Juli 2008
Ilia Smirnov
6
1. Einleitung
Diese Arbeit bewegt sich im Untersuchungsfeld der Schnittkonstruktion in der Be-
kleidungsbranche. Im Rahmen der Arbeit wird ein Modul für das CAD-System
COAT entwickelt, mit dessen Hilfe Kleinteile in einer Bibliothek erfasst werden
können. Die vorgeschlagene Lösung ermöglicht die Wiederverwendung von Klein-
teilen in neuen Schnittmustern. Wie das COAT-System selbst, ist die Kleinteile-
Bibliothek vor allem an den Bedürfnissen von kleineren Ateliers und Werkstätten
ausgerichtet. Die hier entwickelte Lösung könnte jedoch auch für Arbeitsschritte der
Maßkonfektion interessant sein. Daneben soll der Arbeitsaufwand von Schneiderin-
nen durch Einsparung von repetitiven Arbeiten bei den Modellentwicklungen opti-
miert werden. Zentrale Fragestellungen bezieht diese Arbeit aus einem 1992 von
Anja Dewes [Dewes 1996] entwickelten und später von Udo Szczepanek [Szczepa-
nek 2003] in den technischen Details ausgeführten Konzepts zur Behandlung von
Kleinteilen als Bausteine. Das von Dewes und Szczepanek generierte Konzept wird
hier überarbeitet und eine Lösung des Baustein-Konzepts für das COAT-System
entwickelt.
1.1. Motivation
Seit einigen Jahren arbeite ich an der Weiterentwicklung eines Komplettsystems für
die Aufgaben der Bekleidungsbranche, das COAT-System. Zu meinen Aufgaben ge-
hört es, neue Ideen in diesem System umzusetzen und in Kooperation mit den
Schneiderbetrieben zu optimieren. In diesem Zusammenhang ist in den letzten Jahren
eine Entwicklung zur Umgestaltung und Rationalisierung der Arbeitsabläufe durch
computergestützte Systeme vor allem in kleineren handwerklichen Betrieben der Be-
kleidungsbranche wahrnehmbar. Diese Entwicklung reagiert auf Prozesse der globa-
lisierten Produktion und Vermarktung von Bekleidung. Während die
Rationalisierung der Schnittentwicklung im industriellen Bereich seit Jahrzehnten
wissenschaftlich unterstützt wird, sind kleinere Betriebe durch ihre traditionellen,
zeitraubenden Methoden der steigenden Konkurrenz durch die Industrie oft nicht
gewachsen. Durch die Möglichkeit, Modellschnitte im COAT-System schneller und
effizienter zu erstellen, könnte ihre Konkurrenzfähigkeit gesteigert werden.
Aus diesem durch globale Prozesse bedingten Wandel in der Bekleidungsbranche
ergibt sich eine weitere Motivation für diese Arbeit. Der Trend zur individuell ange-
7
passten Kleidung, die traditionell eher in kleineren Betrieben hergestellt wurde, wird
seit einiger Zeit auch von Großunternehmen bedient. Für die industrielle Fertigung
von komplett individuell nach Maß gefertigten oder individuell angepassten Klei-
dungsstücken steht der Begriff der Maßkonfektion [Seidel et al. 2001]. Dabei haben
sich Produktionsketten und Verfahren der Bestellvorgänge geändert. Neu ist die Art
der Kopplung von Händlern, welche die Körpermaße und Modellwünsche von Kun-
den ermitteln, und Produzenten, die diese Daten in der Produktion umsetzen. Auch
im Rahmen dieser veränderten Prozesse, die unter anderem neue Anforderungen an
eine Rationalisierung der Erstellung von Schnittmustern stellen, sehe ich eine Mög-
lichkeit, kleinere Betriebe zu unterstützen.
1.2. Aufbau der Arbeit
Im ersten Teil dieser Arbeit wird in Kürze der Prozess der Schnittmusterkonstruktion
dargestellt. Dabei werden die für die Arbeit relevanten Prozesse fokussiert. Daran
anschließend wird das Schnittkonstruktionssystem COAT vorgestellt, auf das die
hier entwickelte Lösung aufgesetzt wird. Im Kapitel Lösungsansätze wird die Lösung
im Detail überprüft und Entscheidungen für die Implementierung getroffen. Das dar-
auf folgende Kapitel beschreibt die technischen Einzelheiten der Implementierung
für die Kleinteile-Bibliothek. An einem ausgewählten Beispiel für die Konstruktion
eines Kleinteils wird im Anschluss das entstandene Modul evaluiert. Das Klassen-
Diagramm für die Implementierung befindet sich im Anhang.
1.3. Terminologie
Das Schneiderhandwerk ist heute ein typischer Frauenberuf. Durch die konsequente
Verwendung der weiblichen grammatischen Form für die Schneiderinnen von Be-
kleidung soll dieser Gender-Spezifik entsprochen werden.
Darüber hinaus werden in dieser Arbeit die Bezeichnungen Schneiderin / Konstruk-
teurin synonym verwendet. Nach Definition der Bundesagentur für Arbeit ist eine
Schnitt-, Entwurfs- und Fertigungsdirektrice bzw. Modelleurin eine Person, die Mo-
delle und Kollektionen für Bekleidung plant, entwirft und gestaltet [Berufenet 2008].
Im Rahmen dieser Arbeit wird darunter allgemein eine Person verstanden, die in ei-
nem handwerklichen, meist kleinen Betrieb hauptsächlich für die Entwicklung und /
oder die Anpassung von Schnittmustern, aber auch für die konkrete Anfertigung von
8
Bekleidung verantwortlich ist. In Vorbereitung dieser Arbeit fiel auf, dass die Begrif-
fe im Forschungsfeld der Schnittkonstruktion von Autor zu Autor stark variieren. Die
hier vorgeschlagene Lösung basiert auf dem COAT-System und übernimmt daher
auch die Terminologie dieses Systems (vgl. Kap. 2.1).
9
2. Problembeschreibung
In diesem Kapitel erfolgt eine Beschreibung des Problems, für das im Kapitel Lösung
für die Kleinteile-Bibliothek ein Lösungsweg entwickelt wird. Zunächst werden eini-
ge zentrale Begriffe der Schneiderarbeit erklärt, mit denen diese Arbeit operiert. Um
zu verdeutlichen, an welcher Stelle sich die Arbeit von Schneiderinnen optimieren
lässt, werden zunächst die Arbeitsabläufe der Schnittkonstruktion skizziert. Der
Schwerpunkt liegt dabei auf der Handhabung der Kleinteile. Es folgt eine kurze Dar-
stellung der Spezifik der Schnittkonstruktion mit Unterstützung von CAD-Systemen,
insbesondere des COAT-Systems. Anschließend werden die Vorarbeiten von Anja
Dewes und Udo Szczepanek dargestellt und darauf aufbauend neue Anforderungen
an die Kleinteile-Bibliothek formuliert.
2.1. Schnittmusterkonstruktion
Ein Kleidungsstück besteht aus einzelnen, zusammengenähten Schnittteilen. Die
Form dieser Schnittteile zu ermitteln ist Aufgabe der Schnittkonstruktion. Damit ein
gefertigtes Kleidungsstück passgenau der Form eines Körpers entspricht und gleich-
zeitig den Kundenvorstellungen von Ästhetik und Bewegungsfreiheit entspricht,
werden die Schnittmuster nach einem Schnittsystem entwickelt.
Exkurs Schnittsystem
Ein Schnittsystem beinhaltet
Körpermaßtabelle mit Vorschriften für die Abnahme der Körpermaße
Konstruktionsvariablen und Maßzugaben
Konstruktionsregeln
Die nach Konstruktionsvorschriften entstehenden geometrischen Objekte
wie Linien oder Kurven werden durch Variablen parametrisiert. Diese
Variablen werden durch Schnittsystem-spezifische Formeln berechnet.
Die Formeln benutzen Körpermaße, Maßzugaben, Konstruktionsvariablen
sowie erst bei der Konstruktion entstehende Variablen, wie z.B. die Länge
einer Strecke.
10
Körpermaße bzw. Maße sind auf bestimmte Messstrecken bezogene Messwerte. Sie bilden die Grund-lage für die Schnittkonstruktion.
Beispiel: Taillenumfang
Der Satz aus fertigen, produktionsreifen Schnittteilen eines Kleidungsstückes bildet
einen Produktionsschnitt. Der Weg zu einem Produktionsschnitt teilt sich in folgende
Etappen:
Idee
1. Konzeptionierung / Skizze
2. Erstellen / Auswahl eines Grundschnittes
3. Erstellen / Auswahl der Kleinteile
4. Modellschnittentwicklung
5. Erstellen eines Lagenbildes
Produktionsschnitt
Für diese Arbeit sind die Schritte 2 bis 4 relevant, die im Folgenden näher beschrie-
ben werden sollen. Da die Schritte vom Modellschnitt zum Produktionsschnitt hier
nicht betrachtet werden, wird für die Bezeichnung des Ergebnisses der Schnittkon-
struktion der Begriff Modellschnitt verwendet. Dies berücksichtigt auch die Termi-
nologie des COAT-Systems.
2.1.1. Erstellen des Grundschnittes
Die Konstruktion eines Modells beginnt mit der
Aufstellung eines Grundschnittes [Pekholz/Läer 1995:
68]: „Unter dem Grundschnitt ist der Abschnitt im
Konstruktionsablauf zu verstehen, der ausgehend von
den Körperkenngrößen [d.h. den Körpermaßen, I.S.],
die Haupteinzelteile eines bestimmten Kleidungsstückes in ihrer Grundform und
Grundabmessungen vollständig beschreibt“ [Mosinski / Pohl o.J.: 9, zit. n. Dewes
11
Maßzugaben bzw. Zugaben sind Beträge, die zu Körpermaßen ad-diert werden. Sie gewährleisten Bewegungsfreiheit und den locke-ren Sitz von Kleidungsstücken.
Beispiel: Bundzugabe
1996: 6]. Grundschnitte enthalten damit die wichtigsten geometrischen Abhängigkei-
ten einer bestimmten Art von Bekleidungsstück. Die Schneiderin erkennt im Grund-
schnitt den Verlauf der entscheidenden Linien und Nähte wie Taillenlinie,
Schulternaht oder Säume. Der Grundschnitt ist die
Ausgangsbasis für die weiteren Modellentwicklungen
innerhalb des ausgewählten Schnittsystems. Er enthält
in der Regel keine Nahtzugaben oder modische Details
wie die Kleinteile. Die zum Grundschnitt gehörenden
Schnittteile bilden die Gruppe der Basisteile [Dewes
1996: 6].
Zu den Basisteilen eines Mantels (Abb. 1) gehören
Vorderteil
Rückenteil
Ärmel
Abb. 1: Grundschnitt für einen Mantel
Neben den Basisteilen bilden Kleinteile und Spezialteile weitere Arten von Schnitt-
teilen. Unter Spezialteilen werden hier Schnittteile verstanden, die durch Modifizie-
ren der Basisteile bei der Modellentwicklung entstehen und nur begrenzt typisierbar
sind.
12
2.1.2. Kleinteile in der Schnittkonstruktion
Dagegen sind Kleinteile standardisierte Schnittteile, die selbst keinen Einfluss auf die
Basisteile des Grundschnittes haben. Form oder Position der Kleinteile sind jedoch
oft von den Basisteilen abhängig. Sie sind in der Regel tatsächlich klein in Bezug auf
die Basisteile und bilden mit diesen zusammen Ausstattungsvarianten eines Klei-
dungsstückes. Die geläufigsten Schnittteile-Arten in der Schnittkonstruktion sind
Taschen
Manschetten
Kragen
Gürtel
Bündchen
Kapuzen
Die Zuordnung von Schnittteilarten zu bestimmten Schnittteilgruppen ist nicht im-
mer eindeutig. So wird der Kragen von einigen Autoren den Basisteilen zugeordnet
[Müller 1993: 30-31], von anderen den Kleinteilen [Schipilowa 2003: 207]. In dieser
Arbeit wird der Kragen als ein Kleinteil betrachtet und insgesamt die Definition von
Kleinteilen (vgl. Kap. 2.3) möglichst offen gehalten, da eine Lösung angestrebt wird,
durch die sich möglichst viele Schnittteilarten als Kleinteile behandeln lassen.
2.1.3. Kleinteile und Modellschnittentwicklung
Ein Modellschnitt entsteht durch Modifikationen des Grundschnittes. Dabei können
die notwendigen Kleinteile auf verschiedene Weise entstehen.
1. Übernahme der passenden Kleinteile aus anderen, fertigen Modellschnitten
2. Neukonstruktion
Bei der handwerklichen Arbeit ohne Computerunterstützung werden die Kleinteile in
der Regel aus anderen Schnitten als fertige Schablonen übernommen bzw. nach Au-
genmaß angepasst. Anders ist es bei der Verwendung von CAD-Systemen. Ob sich
Kleinteile aus fertigen Konstruktionen einfügen lassen, ist dann bedingt durch das
konkrete System. Bevor die Probleme der Übernahme von Kleinteilen aus anderen
13
Modellschnitten in CAD-Systemen diskutiert werden, müssen einige Erläuterungen
zur konzeptionellen Behandlung von Kleinteilen vorgenommen werden. So können
bei der Modellentwicklung Abhängigkeiten zwischen Basis- und Kleinteilen entste-
hen. Dabei treten mitunter Fälle auf, in denen sowohl die Kleinteile als auch die Ba-
sisteile geometrisch angepasst werden müssen, etwa wenn
ein Vorderteil je nach ausgewählter Taschenart einen Einschnitt oder
eine Anlegelinie für die Tasche bekommt; oder wenn
ein Kragen an die Halslochlinie angepasst werden muss, die sich auf
den Basisteilen befindet.
Gerade im Bereich der Maßanfertigung ergeben sich weitere Modifikationen für die
Kleinteile aus individuellen Vorstellungen von Ästhetik und Design. Daher ist es er-
forderlich, dass übernommene Kleinteile variiert und modifiziert werden können.
Abb. 2: Vielfalt der Taschenformen ([McKelvey 1996: 169])
14
Konfektionsgrößen, auch Standardgrößen genannt, sindGrößen, die nach standardisier-ten Maßsätzen konstruiert wer-
den.
Diese Modifikationen können Köpermaß- und Modellvariablen-abhängig sein. Ab-
bildung 2 zeigt als Beispiel einen kleinen Ausschnitt aus der Vielfalt von Taschen-
formen. Die Technik des Gradierens von Schnittmustern in Abhängigkeit von
Körpermaßen und Maßzugaben wird im folgenden Kapitel beschrieben.
2.1.4. Gradieren der Schnittmuster
Unter dem Gradieren von Schnittmustern wird sowohl die Umsetzung eines Model-
schnittmusters in die Konfektionsgrößen als auch das Erstellen eines nach Körper-
maß angepassten Schnittmusters anhand von vorhandenen Modellen verstanden.
Grob lassen sich die bekannten Gradierverfahren in zwei Techniken einteilen:
Gradieren durch Sprungwerte
Gradieren durch parametrisierte Konstruktion
Beim Sprungwertgradierverfahren sind die Konturen der
Schnittteile mindestens in einer Größe als Grundlage für
die Abwicklung der weiteren Größen vorhanden. Für die
Ermittlung der Konturen anderer Größen werden die
Eckpunkte eines Schnittteils um bestimmte Beträge
(Sprungwerte) verschoben. Sprungwertgradieren ist eine
Standardmethode in der industriellen Fertigung und kann nur begrenzt für die Maß-
anfertigung genutzt werden, weil Sprungwerte für Standardgrößen definiert sind und
für jeden individuellen Schnitt neu erstellt werden müssten. Die Verfahren zur Ablei-
tung der Sprungwerte aus individuellen Körpermaßen sind ungenau.
In dieser Arbeit wird ausschließlich die zweite Art des Gradierens behandelt, näm-
lich das Gradieren durch parametrisierte Konstruktion, mit dem auch das COAT-
System arbeitet. Voraussetzung für das konstruktive Gradieren ist ein Computersys-
tem, das alle Konstruktionsschritte, sowohl die des Grundschnittes als auch die der
Modellentwicklung, ausführen kann. Dabei können in der Konstruktion nicht die
konstanten Werte, sondern müssen Variablen für Körpermaße und Maßzugaben ver-
wendet werden. Das System führt abgespeicherte Arbeitsschritte mit individuellen
Datensätzen von Körpermaßen und Maßzugaben aus und berechnet im Ergebnis die
15
angepassten Konturen der Schnittteile. Dadurch, dass ein Computersystem in Sekun-
denschnelle gradieren kann, können auch Grundschnitte direkt gradiert werden; da-
nach werden Modellentwicklungen vorgenommen.
2.2. Stand der Technik
2.2.1. Das COAT-System
Das COAT-System ist eine Komplettlösung für alle Aufgaben, die in einem kleinen
bis mittelständischen Betrieb der Bekleidungsbranche anfallen [Szczepanek 2003].
Die Abkürzung COAT steht für CAD and Office Application in Tailors Trade. Das
System besteht aus zwei Modulen: einem Büro- und einem Werkstatt-Teil. Der Bü-
ro-Teil unterstützt das Ausführen von administrativen Aufgaben wie die Verwaltung
von Kundendaten, das Erstellen von Aufträgen, die Pflege eines Modellkatalogs. Der
Werkstatt-Teil ist eine CAD-Anwendung zur Konstruktion von produktionsreifen
Schnittmustern. Die vorliegende Arbeit befasst sich mit der Weiterentwicklung des
Werkstatt-Teils. Im Folgenden wird unter COAT nur der Werkstatt-Teil des Systems
verstanden.
Aus den Interaktionen der Schneiderin mit dem COAT-System entsteht ein Kon-
struktionsskript, in dem die Befehle für die Erzeugung von geometrischen Elementen
enthalten sind. Außerdem beinhaltet das Konstruktionsskript Anweisungen zum An-
legen neuer Schnittteile, Beschreibungen zu den Arbeitsschritten und Referenzen auf
Grundschnitte. Die geometrischen Elemente werden in der Regel parametrisiert er-
zeugt, das heißt, sie beziehen sich auf eine Maßtabelle, eine Zugabentabelle oder auf
vorher entstandene Elemente. Die derzeitige Version der Skriptsprache erlaubt es, zu
Beginn einer Konstruktion ein bestehendes, anderes Skript zu laden. Durch diesen
Mechanismus gewährleistet das COAT-System bereits die Wiederverwendung von
Grundschnitten. Ein einmal konstruierter Grundschnitt kann als Basis für die Kon-
struktion einer beliebigen Anzahl von Modellschnitten benutzt werden.
Dagegen ist im COAT-System kein Mechanismus zum Einfügen von Kleinteilen
enthalten. In der Datenbank des Systems sind derzeit nur wenige Kleinteile in den
Grundschnitten fest integriert (Abb. 3). Wenn die Schneiderin ihre Konstruktion mit
16
anderen Kleinteilen ausstatten möchte, hat sie die Wahl, die Kleinteile aus dem
Grundschnitt zu löschen und stattdessen eigene zu konstruieren oder die Kleinteile
einzeln als Schnittmuster anzulegen und getrennt abzuspeichern. Im ersten Fall tritt
das Problem auf, dass sie für jeden Modellschnitt die gleichen Schritte zur Konstruk-
tion von Kleinteilen mehrfach wiederholen muss. Im zweiten Fall besteht keine
Möglichkeit, die Kleinteile abhängig von den Basisteilen zu konstruieren bzw. die
Basisteile mit Elementen zu gestalten, an denen Kleinteile automatisch positioniert
werden können. Daher ist eine Erweiterung des Systems sinnvoll, die es der Schnei-
derin erlaubt, diese Aufgabe durch Zugriff auf eine Kleinteile-Bibliothek zu lösen.
Die technische Schwierigkeit liegt dabei darin, dass die derzeitige Version der
Skriptsprache von COAT kein Einfügen von Skripten während des Konstruktions-
prozesses erlaubt.
Es gibt einige Arten von Kleinteilen, die keinen direkten Bezug zu anderen Teilen
der Konstruktion haben und nur über eigene Variablen parametrisiert werden. Aller-
dings wird nach einer möglich flexiblen Lösung gesucht, durch welche die Schneide-
rin bei der Arbeit mit Kleinteilen weniger eingeschränkt ist. Wenn sich die Planung
der Kleinteile-Bibliothek nur auf die über Körpermaße und Maßzugaben parametri-
sierbaren Kleinteile begrenzen würde, böte sie nur wenige Vorteile, da dies durch die
Möglichkeit externen Speicherns faktisch bereits gegeben ist.
Abb. 3: Blusen-Grundschnitt mit Kleinteilen in COAT
17
2.2.2. Weitere CAD-Systeme
Da die Industrie immer noch überwiegend Konfektionsgrößen produziert, arbeiten
die meisten industriellen CAD-Systeme mit Sprungwertgradieren. Ein Schnittteile-
Baukasten in einem System zu realisieren, das Sprungwertgradieren verwendet, ist
technisch relativ einfach umzusetzen, da der Input des Systems kein parametrisiertes
Skript ist, sondern die endgültige geometrische Form eines Schnittmusters. Die An-
zahl der abzuleitenden Standardgrößen ist beim konstruktiven Gradieren begrenzt,
was das Problem der Positionierung der Kleinteile an den Bezugselementen erleich-
tert. Ein Schnittteil, unabhängig davon, ob es sich dabei um ein Basisteil oder Klein-
teil handelt, kann in solchen Systemen einfach zu dem bestehenden Schnittmuster
nachgeladen werden.
Die meisten Schnittkonstruktionssysteme haben einen ausgeprägt kommerziellen
Charakter; die Software-Produzenten bieten sehr selten eine Demo- oder Trial-
Version zum Kennenlernen ihrer Produkte an. Dies erschwert einen Vergleich der
Behandlung von Kleinteilen in anderen Systemen.
2.3. Definition der Bausteine nach Anja Dewes
Eine der ersten Untersuchungen zur computergestützten Schnittmusterkonstruktion
durch Bausteine wurde 1996 von Anja Dewes entwickelt [Dewes 1996]. Zentrale
konzeptionelle Hypothesen zur Bausteinfunktionalität, mit der die vorliegende Dip-
lomarbeit operiert, bauen auf der Pionierarbeit von Dewes auf. Die vor zwölf Jahren
an der Universität Hamburg in Kooperation mit der Universität Bremen entstandene
Arbeit untersucht die Eignung von Schnittkonstruktionssystemen für den handwerk-
lichen Bereich. Dewes geht von den Arbeitsabläufen im Schneiderhandwerk aus und
erkennt wesentliche Probleme bei der Anwendung der relevanten CAD-Systeme, die
in der damaligen Zeit hauptsächlich für die industrielle Anfertigung von Bekleidung
konzipiert waren. Im Ergebnis kommt sie zu dem Schluss, dass keines der von ihr
aufgelisteten CAD-Systeme den Anforderungen handwerklicher Betriebe gerecht
wird. Sie hat daher die konzeptionellen Grundlagen für ein auf dem Baustein-Prinzip
basierendes System entwickelt. Ihr Konzept war am Projekt CAD im Schneider-
handwerk ausgerichtet und wurde technisch mit Einschränkungen realisiert. Im
COAT-System wurde eine Funktion Baustein einfügen implementiert. Außer durch
18
Maß- und Zugabentabellen konnten die Bausteine nicht zu den anderen Schnittteilen
in Beziehung gesetzt werden.
Dewes definiert einen Schnittteile-Baukasten basierend auf dem Baustein-Prinzip.
Die Bausteine müssen Einheiten von Konstruktionsschritten zusammenfassen, wel-
che repetitive Arbeitsvorgänge automatisieren. Ein Vorteil durch Bausteine ergibt
sich erst bei der Anwendung der CAD-Systeme in der Schneiderarbeit. Durch Auto-
matisierung der Arbeitsschritte werden sonst zeitaufwändige manuelle Operationen
in Sekundenschnelle ausgeführt. Da die fertigen Teile in der Regel durch Gradierung
individuell angepasst werden müssen, müssen die Bausteine parametrisiert, kon-
struiert und ausgeführt werden. Daher ist es angebracht, nur allgemein formulierbare
Schnittteile als Bausteine auszuwählen [Dewes 1996: 32]. So sieht Dewes als sinn-
volle Kandidaten für Bausteine Grundschnitte und Kleinteile.
In folgenden Schritten entwirft sie einen Arbeitsplan zur Konstruktion eines Modell-
schnittes durch Bausteine:
1. Auswahl und Parametrisierung des Bausteins für einen Grundschnitt
2. Auswahl und Parametrisierung der Bausteine für Kleinteile
3. Modellentwicklung durch Modifikation der zusammengestellten Basis- und
Kleinteile
Die Grundschnitte werden in COAT als Bausteine bereits benutzt. Daher kann diese
Arbeit auf die bereits bestehende Behandlung der Schnittteile nach dem Baustein-
Prinzip zurückgreifen, die um die Kleinteile erweitert wird. Da es sich bei Kleintei-
len nur um eine Art von Schnittteilen handelt, wird der Begriff des Bausteins in die-
ser Arbeit durch den Begriff Kleinteil ersetzt. In den Quellcodes des Programms wird
jedoch für die Methoden und Klassen der Begriff Baustein verwendet, der hier syn-
onym für Kleinteil gelesen werden kann. Ein Grund dafür ist, dass das hier geplante
Konzept für das Kleinteile-Modul ausbaufähig ist. Auf der Basis von Bausteinen
können später Makros implementiert werden (vgl. Kap. 7).
19
3. Anforderungen an die Kleinteile-Bibliothek
Für die Erweiterung des COAT-Systems gelten die gleichen allgemeinen Anforde-
rungen an computergestützte Schnittkonstruktionssysteme wie für das COAT-System
selbst. Die wichtigsten Anforderungen sind durch die Spezifik der Zielgruppen be-
stimmt. Das grundlegende Kriterium für die Kleinteile-Bibliothek muss eine Gestal-
tung der Handhabung von Kleinteilen in dem Sinne sein, dass der Gesamtaufwand
des Einfügens und Anpassens gegenüber dem alten Vorgehen der Kleinteilekonstruk-
tion Zeitersparnis erbringt. Daneben ist zu beachten, dass die typische Benutzerin
nicht über die Kenntnisse eines Ingenieurs verfügt [Szczepanek 2003: 40]. Das
COAT-System wurde unter Beachtung dieser Anforderungen konzipiert und entwi-
ckelt [Szczepanek 2003: 109]. Wichtig ist, dass die Handhabung der Erweiterung auf
die Kleinteile diesen Anforderungen auch entspricht. Der Umgang mit der Kleinteile-
Bibltiothek soll in etwa die gleichen Computer- und Fachkenntnisse voraussetzen
wie die bisherige Arbeit mit COAT.
Unter den potenziellen Benutzern der Kleinteile-Bibliothek sind zwei Gruppen zu
unterscheiden: Konstrukteurinnen und Anwenderinnen. Je nach Aufgaben dieser
Gruppen werden die Anforderungen folgendermaßen formuliert:
Eine Konstrukteurin beschäftigt sich mit der Konstruktion der Kleinteile primär für
die Weitergabe derselben an die Anwender. Sie besitzt gute Kenntnisse der Schnitt-
konstruktion und hat schon mit dem COAT-System gearbeitet. Für die Konstrukteu-
rin ist wichtig, dass der Prozess der Konstruktion von Kleinteilen möglichst dem der
Konstruktion der Basisteile ähnelt. Die Grundsätze der regulären Schnittkonstruktion
sollen bei der Entwicklung der Kleinteile bestehen bleiben und die technischen Ein-
schränkungen des Konstruktionsprozesses minimal sein. Dadurch kann die Konstruk-
teurin vorhandene Erfahrungen mit dem System optimal nutzen.
Eine Anwenderin konstruiert Kleinteile nicht selbst, benutzt jedoch die Kleinteile
der Bibliothek für eigene Modelle. Von Bedeutung ist für sie primär die Einfachheit
und Klarheit beim Einfügen der Bausteine.
20
Als Dewes 1996 ihre Anforderungen an einen Schnittteile-Baukasten formulierte
[Dewes 1996: 37], befand sich das COAT-System in einer frühen Entwicklungspha-
se. Einige ihrer Anforderungen an die Handhabbarkeit des Systems sind bereits um-
gesetzt worden. Doch finden sich in ihrer Arbeit Anforderungen, die für die
vorliegende Arbeit übernommen werden müssen. So erwähnt sie die Notwendigkeit,
die für einen Baustein (hier: Kleinteil) erforderlichen Schnittteile zu visualisieren,
damit die Auswirkungen einer Änderung der Parameter des Bausteins in der Kon-
struktion sichtbar werden.
Darüber hinaus schlägt sie vor, für die Bausteine Parameterbereiche zu definieren,
um dem Anwender beim Einfügen eines Bausteins zu signalisieren, ob die eingege-
benen Parameter im gültigen Wertebereich liegen und dann gegebenenfalls einen
Fehler zu melden. Diese Anforderung wird nicht direkt übernommen, da sie sich im
Rahmen des hier geplanten Konzepts erübrigt, nach dem die Kontrolle der Gültigkeit
der Parameter über die schrittweise Zuweisung der Parameter des Kleinteils erfolgen
soll.
Aus den Charakterisierungen der beiden Zielgruppen und aus den bereits von Dewes
formulierten Anforderungen resultieren folgende, aktualisierte Anforderungen an die
Kleinteile-Bibliothek:
1. Das System soll eine Bibliothek mit einer Liste aller Kleinteile enthalten;
zu jedem Kleinteil soll zügig eine Vorschau aufgerufen werden können.
2. Die Techniken zur Konstruktion der Kleinteile sollen dieselben wie bei
der regulären Schnittkonstruktion sein.
3. Kleinteile sollen parametrisierbar sein:
a. durch Körpermaßtabellen und Zugabentabellen.
b. durch Abhängigkeiten zu Basisteilen.
4. Kleinteile sollen innerhalb eines Schnittmusters konstruiert werden.
5. Der Aufwand der Wiederverwendung von Kleinteilen aus der Bibliothek
soll minimal sein und der Prozess des Einfügens möglichst klar und ver-
ständlich.
21
6. Das Einfügen der Kleinteile in die Schnittmuster hinsichtlich der Para-
metrisierung über Maße / Zugaben oder Elemente soll möglichst flexibel
sein.
7. Kleinteile sollen zwischen Installationen des COAT-Systems durch einen
Export- / Import-Mechanismus im Büro-Teil von COAT austauschbar
sein.
8. Ein Kleinteil soll mehrfach in dieselbe Konstruktion eingefügt werden
können.
22
4. Lösungsansätze
4.1. Begriffsklärung
Im Folgenden werden einige für diese Arbeit zentrale technische Begriffe erklärt, die
im Verlauf der Konzeptionierung der Kleinteile-Bibliothek entwickelt wurden.
Hauptkonstruktion
Basisteile eines Grund- oder Modellschnittes.
Ursprungsschnitt
Schnittmuster bzw. sein Skript, in dem ein Kleinteil konstruiert wurde.
Zielschnitt
Schnittmuster, in das ein Kleinteil eingefügt wird.
Bezugselement
Ein geometrisches Element, wie Punkt, Linie, Kurve, das innerhalb eines Ba-
sisteils erzeugt wurde, jedoch sowohl vom Basisteil als auch von einem
Kleinteil benutzt wird.
Ursprungselement
Ein Bezugselement im Ursprungsschnitt.
Zielelement
Ein Bezugselement im Zielschnitt.
4.1.1. Über Maßzugaben und Modellvariablen
COAT verwendet Zugabentabellen, um zwei Arten von Variablen zu speichern:
Maßzugaben und Modellvariablen. Der Begriff Maßzugabe / Zugabe findet sich in
Kapitel 2.1.1. erläutert. Die Modellvariablen definieren unterschiedliche Gestal-
tungsmerkmale oder Streckenangaben, wie zum Beispiel die Anzahl der Knöpfe oder
23
die Breite einer Tasche. Da die beiden Arten der Variablen in COAT nicht getrennt
behandelt werden, wird hier für beide der Begriff Zugaben verwendet.
4.2. Parametrisierung der Kleinteile
Wie in der Anforderungsliste angesprochen, sollen die Kleinteile parametrisiert kon-
struiert werden. Im Folgenden wird die Problematik der Parametrisierung der Klein-
teile in einzelne Aspekte zerlegt. Erreicht werden soll, dass bei Wiederverwendung
eines Kleinteils die Abhängigkeiten im Zielschnitt so definiert werden, dass die fol-
genden Bedingungen erfüllt sind:
Das Kleinteil lässt sich mit verschiedenen Parametrisierungsarten
konstruieren.
Das Kleinteil kann mit möglichst minimalem Aufwand an den Ziel-
schnitt korrekt angepasst werden.
4.2.1. Parametrisierung über Körpermaße und Maßzugaben
Für Kleinteile sollen Körpermaße aus der Maßtabelle verwendbar sein. Werden diese
Körpermaße bei der Konstruktion benutzt, müssen diese auch beim Einfügen des
Kleinteils verfügbar sein. Die Bezeichnungen der Maße sind für alle Schnitte eines
Schnittsystems in COAT gültig. Wenn neue Maße erzeugt werden, sind die Werte
dieser Maße nur für den Kunden / die Größe definiert, in denen sie erzeugt wurden,
weil diese Maße bei anderen Kunden / Größen meistens andere Werte bekommen.
Wird der Schnitt mit der Körpermaßtabelle eines anderen Kunden oder einer anderen
Größe geladen, müssen die Werte dieser neuen Maße beim Öffnen manuell eingetra-
gen werden. Dieses Vorgehen kann beim Einfügen der Kleinteile übernommen wer-
den. Sind die Maße eines Kleinteils im Zielschnitt nicht definiert oder vorhanden,
müssen die fehlenden Werte beim Einfügen nachgetragen werden. Die eingegebenen
Werte werden für die ausgewählte Kombination Schnitt / Kunde / Größe in die Da-
tenbank eingetragen. Die Maßtabelle soll bei der Kleinteilekonstruktion verfügbar
sein, damit neue Maße angelegt werden können. Ebenso können vorhandene Werte
geändert werden.
24
Abb. 4: Blusenmanschette
Ein Beispiel für die Verwendung der Körpermaße und Maßzugaben in Kleinteilen ist
eine gerade Blusenmanschette (Abb. 4). Die Länge der Manschette ergibt sich aus
dem Körpermaß Armumfang (Strecke AB), zu dem eine Zugabe addiert wird (Stre-
cke BC), damit die Manschette locker sitzt.
Benutzt ein Kleinteil Maße, wird es Schnittsystem-abhängig [Szczepanek 2003:
111]. Dies bedeutet, dass ein Kleinteil aus der Bibliothek nur in Schnitten des glei-
chen Schnittsystems benutzt werden kann. Eine Schnittsystem-übergreifende Lösung
ist technisch realisierbar, sie setzt aber voraus, dass die Maße eines Schnittsystems in
ein anderes überführt werden können. In diesem Falle kann es dazu kommen, dass
ein Maß aus unterschiedlichen Schnittsystemen mit unterschiedlichen Bezeichnun-
gen in der Maßtabelle erscheint. Ein solches Vorgehen widerspricht auch den übli-
chen Regeln der Schnittkonstruktion.
Wie in dem Beispiel der Blusenmanschette zu sehen ist, müssen auch die Zugaben
(hier die Strecke BC) als Parameter festgelegt werden können. COAT benutzt Zuga-
bentabellen in der Datenbank, um Zugaben zu speichern. In der Zugabentabelle wer-
den auch Modellvariablen abgespeichert. Aus technischer Sicht gibt es keinen
Unterschied zwischen Maßzugaben und Modellvariablen in COAT. Gerade bei der
Kleinteilekonstruktion ist es wichtig, die Modellvariablen als Parameter der Kleintei-
le zu definieren. Daraus ergibt sich die manuelle Anpassung eines Kleinteils an den
Zielschnitt. Wenn eine Tasche ohne Wiederverwendungsabsicht konstruiert wird,
25
kann die Designerin die Breite der Tasche als Konstante festlegen. Unter den neuen
Anforderungen an die Konstruktion mit Wiederverwendung bekommt die Tasche für
die Breite eine Modellvariable. Beim Einfügen der Tasche in eine andere Konstruk-
tion ermöglicht der Schneiderin, den Parameter Breite nach ihrem Wunsch festzule-
gen.
Die Zugabentabellen in COAT beziehen sich auf einen bestimmten Schnitt. Daher
müssen die Zugaben beim Einfügen des Kleinteils in den jeweiligen Schnitt übertra-
gen werden. Dabei muss die Designerin in der Lage sein, diese Zugaben zu ändern.
Während die Bezeichnungen der erforderlichen Zugaben automatisch mit dem Ziel-
schnitt verknüpft werden können, müssen die ursprünglichen Werte für Zugaben ma-
nuell bestätigt und bei Bedarf geändert werden können.
4.2.2. Parametrisierung über Bezugselemente
Im Rahmen dieser Arbeit ist diese Art der Parametrisierung entscheidend. Wie in
Kapitel 2.3 erwähnt, existierte eine Version des Schnittteile-Baukastens mit der Pa-
rametrisierung ausschließlich über Maß- und Zugabentabellen. Die Kleinteile-
Bibliothek soll nicht in der alten Form reimplementiert werden, sondern durch die
Parametrisierung über Bezugselemente erweitert und flexibler gemacht werden. Hät-
te die Schneiderin nicht die Möglichkeit, in der Kleinteilekonstruktion Elemente aus
den Basisteilen zu benutzen, wäre der Bestand der Kleinteile-Bibliothek potenziell
eingeschränkt. Die Schneiderin hätte außerdem einen Zusatzaufwand für die nach-
trägliche Anpassung der Kleinteile; so müsste sie zum Beispiel eine eingefügte Ta-
sche manuell auf einem Basisteil positionieren. Die folgenden Szenarien für die
Verwendung von Bezugselementen exemplifizieren das Problem:
Positionierung des Kleinteils an einem Bezugselement
Nach den Anleitungen zur Konstruktion von Hosen- und Rocktaschen bei Ja-
que [Jaque 1991: 39] kann eine Tasche parallel oder schräg zur Taillenlinie
aufgesetzt werden (Abb. 5).
26
Abb. 5: Rocktasche
Damit bezieht sich die Position der Tasche auf die Taillenlinie. Für die ge-
naue Positionierung der Tasche kann eine Hilfslinie parallel zur Taillenlinie
gezeichnet werden. Die Tasche kann danach als Kleinteil konstruiert und an-
schließend mittels der Funktion Schnittteile zusammenlegen an die Hilfslinie
angelegt werden. Wenn das Kleinteil abgeschlossen wird, sollte die Schneide-
rin zum Bezugselement Taschenposition einen Kommentar erstellen können,
aus dem hervorgeht, welche Bedeutung dieses Element für die Konstruktion
besitzt. Dieser Kommentar soll in der Datenbank mit dem dazu gehörigen
Datensatz des Kleinteils gespeichert werden und bei der Navigation in der
Kleinteile-Bibliothek und beim Einfügen sichtbar sein. Anhand des Kommen-
tars wird die Schneiderin bzw. eine andere Schneiderin die ursprüngliche
Konstruktionsidee erkennen. Wenn eine Hilfslinie für die Taschenposition in
der Zielkonstruktion nicht vorhanden ist, kann diese nachkonstruiert werden.
Übernahme einer Kurvenform aus der Hauptkonstruktion
Ein Beispiel für ein Kleinteil, das die Form von Kurven aus der Basiskon-
struktion übernimmt, ist der so genannte Peter Pan-Kragen (Abb. 6). Vorder-
und Rückenteil einer Damenbluse werden am Anfangspunkt der Schulterlinie
zusammengelegt. Die Kurven für das Halsloch der beiden Teile bilden die
Nahtlinie des Kragens. Der Peter Pan-Kragen soll als Kleinteil auf der Basis
der beiden Kurven des Halsloches konstruiert werden. Beim Einfügen müs-
sen die entsprechenden Kurven aus der Zielkonstruktion als Bezugselemente
angegeben werden.
27
Abb. 6: Peter Pan-Kragen ([Aldrich 1997: 125])
4.3. Inkonsistenz der Bezugselemente
Gleiche Konturen eines Schnittteils lassen sich auf mehrere Weisen mit unterschied-
lichen geometrischen Objekten definieren. Eine Strecke kann je nach Konstrukti-
onsweise der Schneiderin in einem Fall aus einer Linie und in einem anderen aus
mehreren Linien bestehen. Zwar enthalten die Schnittsysteme eindeutige Anweisun-
gen für die Konstruktion, jedoch haben die Schneiderinnen, wie sich in der Zusam-
menarbeit an den technischen Problemen mit dem COAT-System immer wieder
gezeigt hat, bei der Erstellung von Modellschnitten oft ihre eigene Vorgehensweise.
So können sich die bei der Konstruktion eines Kleinteils benutzten Bezugselemente
von den Objekten im Zielschnitt unterscheiden. Mehrere Zielelemente für ein Ur-
sprungselement einzugeben bzw. Elemente unterschiedlicher geometrischer Typen
zuzuweisen, erfordert einen hohen Implementierungsaufwand. Außerdem verlangt
eine solche Lösung komplexere Eingaben der Bezugselemente durch den Benutzer,
weil die Anzahl der Variationen ansteigt.
Statt eines solchen Verfahrens wird der Benutzerin angeboten, unmittelbar beim Ein-
fügen eines Kleinteils ihre Konstruktion so zu ändern, dass sie den Anforderungen
des Kleinteils entspricht.
28
Beispiel:
Abbildung 7 zeigt, wie die Taillenlinie auf dem Hinterteil eines Rocks konstruiert
werden kann. Im linken Beispiel ist sie als eine Kurve eingefügt worden. Rechts be-
steht die Taillenlinie aus zwei Linien und einer Kurve.
Abb. 7: Unterschiedliche Konstruktionsarten der Taillenlinie
4.4. Mehrfache Verwendung
Ein Kleinteil kann unter Umständen mehrfach in eine Konstruktion eingefügt wer-
den. Wenn die Behandlung von Kleinteile-Skripten wie bisher im COAT-System er-
folgt – die Skriptzeilen erzeugen die geometrischen Objekte – kann daraus das
Problem einer Inkonsistenz der Objektnamen entstehen. Dies kann gelöst werden,
wenn die Namen der Kopien eines Kleinteils verändert werden. Allerdings ist ein
solcher Mechanismus im COAT-System nicht zu finden und stellt keine elegante Lö-
sung dar.
Eine Lösung, die dem hierarchischen Aufbau eines Schnittes in COAT eher ent-
spricht, besteht darin, neue Schnittteile für die Kleinteile zu erstellen. Die Elemente
des Kleinteils müssen in das neue Schnittteil verschoben werden. Die neuen Schnitt-
teile bekommen unterschiedlich generierte Namen. Die Elemente des Kleinteils ha-
ben als Präfix den Schnittteilnamen und sind damit innerhalb eines Skriptes
erkennbar. So können die Elemente des Kleinteils nachbearbeitet werden, ohne dass
ein Namenskonflikt entsteht.
29
4.5. Vorschau der Kleinteile
Eine Anzeige für die in der Bibliothek bereits existierenden Kleinteile kann unter
zwei Aspekten nützlich sein:
Schnelle Vorschau der Kleinteile im Haupt-Dialog der Bibliothek
Übersicht der ursprünglichen Konstruktion beim Einfügen eines
Kleinteils
Eine technisch leicht realisierbare Lösung bietet sich durch die Abspeicherung einer
Bildschirmkopie beim Erstellen des Kleinteils. Eine Bildschirmkopie gibt einen gro-
ben Überblick über die Geometrie des Kleinteils. Allerdings gehen die Informationen
über die einzelnen Elemente dabei verloren. Diese Informationen könnten beim Ein-
fügen der Kleinteile benötigt werden, weil die Elemente zur Parametrisierung des
Kleinteils beitragen. Bisher entstehen die Objekte in COAT beim Parsen des Skrip-
tes. Die Kleinteile sollen einerseits getrennt vom Hauptskript gehalten werden, ande-
rerseits vollständig parsbar sein, damit beim Parsen geometrische Elemente für die
Vorschau erzeugt werden können. Ein Problem bilden dabei die Bezugselemente,
weil sie vom Kleinteil-Skript nur referenziert werden und beim Parsen des Kleinteil-
Skripts ohne ergänzende Informationen nicht erzeugt werden können. Daher müssen
nur die geometrischen Informationen zu den ursprünglichen Bezugselementen abge-
speichert werden. Diese Elemente sollen ohne weitere Zugriffe auf die Skripte er-
zeugt werden können. In der Datenbank werden die folgenden Daten abgespeichert:
Typ des Bezugselements
Absolute Koordinaten der Stützpunkte
Status: Regulär- oder Hilfsobjekt
Benutzer-Kommentar
Um eine Vorschau des Bausteins zu erstellen, werden die Vorgabewerte für die Be-
zugselemente aus der Datenbank benötigt. In jeder Skriptzeile des Kleinteils wird vor
dem Parsen temporär der Ausdruck für jedes Bezugselement mit dem Vorgabewert
ersetzt; die daraus resultierenden Objekte werden an die Dialoge übergeben, in denen
die Vorschau des Kleinteils erscheint.
30
Ohne die in der Maßtabelle fehlenden Maße, die für die Bausteinkonstruktion nötig
sind, kann eine Vorschau nicht erzeugt werden. Die fehlenden Maße werden von der
Schneiderin in Dialogen mit Kleinteile-Vorschau erstellt. Wenn die Liste der fehlen-
den Maße vollständig ergänzt ist, erscheint eine Voransicht des Kleinteils.
4.6. Speichern der Kleinteile
Für das Speichern der Kleinteile ist an erster Stelle zu entscheiden, wie die Skripte in
der Datenbank des Systems abgelegt und von dort aufgerufen werden. Ein Kleinteil-
Skript kann als Referenz im Hauptskript abgelegt werden. Im Hauptskript werden in
diesem Fall ein Verweis auf die ID des Kleinteil-Skripts und zusätzlich die Anpas-
sungsbefehle erzeugt. Eine Variante besteht darin, dass die Kleinteil-Skripte aus der
Datenbank kopiert und in einer angepassten Form in das Zielskript eingefügt werden.
In diesem Fall dient das Kleinteil-Skript als Vorlage für die Erweiterung der Haupt-
skripte.
Unter Umständen können die Skripte aus mehreren tausend Zeilen bestehen. Die
Schnittmuster-Datenbank einer Schneiderin kann Hunderte Megabyte groß sein. Un-
ter diesem Aspekt ist es wichtig, bei der Weiterentwicklung des Systems auf die
kompakte Speicherung der Schnittmuster zu achten. Dies spricht für das Ablegen der
Kleinteil-Skripte als Referenzen. Ein anderes Argument für die Referenzierung ist,
dass ein Kleinteil-Skript nach einer abgeschlossenen Konstruktion geändert werden
kann, so dass die Änderungen in allen Schnittmustern wirksam werden. Obwohl die
einmal erstellten Kleinteile abgeschlossen sind und ihre Skripte nicht verändert wer-
den dürfen, fallen manchmal Arbeiten an der Datenbank durch das Fachpersonal von
COAT an, bei denen Skripte direkt in der Datenbank geändert werden müssen.
31
Die bisherige Struktur des COAT-Skriptes sieht leicht vereinfacht folgendermaßen
aus:
Schnittteil1 = Schnittteil();
Schnittteil1.Punkt1 = Punkt (X1, Y1)
Schnittteil1.Punkt1 = Punkt (X2, Y2)
Schnittteil1.Linie1 = LinieAbtragen(Punkt1, Punkt2)
Schnittteil1.Kurve1 = Kurve(Punkt2, Punkt3, …)
...
Kleinteil1 = Schnittteil()
Kleinteil1.Linie =
Linie(Schnittteil1.Linie1, Schnittteil1.Punkt1)
...
Bisherige Struktur des COAT_Skriptes
Im rot markierten Abschnitt entstehen Elemente eines Kleinteils. Diese Skriptzeilen
sollen in der Datenbank isoliert abgelegt werden, um später als Kleinteil-Skripte ab-
rufbar zu sein.
Die neue Struktur des Skriptes soll die Kleinteil-Skripte referenzieren. Im angeführ-
ten Beispiel soll mit der Anweisung Baustein(integer ID) das Skript des
Kleinteils nachgeladen werden. Der Zeilenblock zum Laden des Kleinteil-Skriptes ist
in dem unteren Beispiel rot markiert.
32
Schnittteil1 = Schnittteil();
Schnittteil1.Punkt1 = Punkt (X1, Y1)
Schnittteil1.Punkt1 = Punkt (X2, Y2)
Schnittteil1.Linie1 = LinieAbtragen(Punkt1, Punkt2)
Schnittteil1.Kurve1 = Kurve(Punkt2, Punkt3, …)
...
Kleinteil1 = Schnittteil()
Baustein(1)
Kleinteil1.Linie1 = Schnittteil1.Linie1
Tasche = Schnittteil()
Kleinteil1 => Tasche
Kleinteil1.Loeschen()
...
Neue Struktur des COAT_Skriptes
Neben der Anweisung zum Laden des Kleinteil-Skriptes muss die gleiche Anzahl der
Schnittteile erzeugt werden, die in dem Kleinteil-Skript enthalten sind. Die Elemente
des Kleinteil-Skripts werden in diese Schnittteile verschoben. Sollen die Kleinteile
nach dem Einfügen modifiziert werden, werden die neu erzeugten Schnittteile modi-
fiziert. Dadurch wird gewährleistet, dass die Kleinteile in jedem Zielskript verändert
werden können, ohne dass die Modifikationen eine Auswirkung auf die abgespei-
cherte Kleinteil-Skripte haben. Das Schema zur Instanziierung der Kleinteile wird
etwas genauer im Kapitel 5.5 beschrieben.
4.7. Ergänzen der Variablen
Die neu erzeugten Variablen müssen beim Einfügen des Kleinteils im Zielskript ent-
weder bereits existieren oder nachgetragen werden. Die Variablen im Zielskript kön-
nen durch Zufall einen passenden Namen tragen, jedoch für andere Zwecke angelegt
worden sein, wie zum Beispiel die Variable Länge. Daher sollte sich die Benutzerin
alle Variablen, die das Kleinteil verwendet, vor dem Einfügen ansehen, durch die
Vorschau kontrollieren und gegebenenfalls anpassen.
33
Wenn ein Maß mit dem gleichen Namen in der Maßtabelle des Zielschnittes schon
vorhanden ist, aber eine andere Bedeutung hat, wird die Schneiderin aufgefordert,
den Namen des Maßes im Zielschnitt zu ändern. Würde man anbieten, die Bezeich-
nung des Maßes innerhalb des Kleinteils zu ändern, könnten namensbedingte Kon-
flikte entstehen, wenn das Kleinteil in anderen Schnittmustern schon verwendet
wurde.
34
5. Lösung für die Kleinteile-Bibliothek
5.1. Implementierungstechnik
Das COAT-System ist mit der Programmiersprache C++ hauptsächlich Objekt-
orientiert unter der Programmierumgebung Visual Studio der Firma Microsoft imp-
lementiert. Das System ist minimal modularisiert – in einer dynamisch gelinkten
Bibliothek befindet sich nur ein Modul zum Exportieren von Schnittmustern im
DXF-Format. Der Kern des Systems schließt ca. 420 Klassen ein, die in 106.125 Zei-
len des Programmcodes implementiert sind. Das System besitzt keine externe
Schnittstelle (API), über die die einzelnen geometrischen Objekte angesprochen
werden können. Die Entwicklung einer solchen Schnittstelle ist auch nicht geplant.
Eine Erweiterung des Systems auf die Kleinteile-Funktionalität außerhalb des Kerns
des Systems, in einem Modul, wäre daher mit sehr hohem Aufwand verbunden. Die
Implementierungstechnik bleibt somit wie im gesamten COAT-System: die Pro-
grammiersprache C++ mit einer Bibliothek für die Benutzungsoberfläche MFC. Ein
Teil der Kleinteile-Erweiterung wird im Büro-Teil von COAT in der Programmier-
sprache Visual Basic implementiert: das Import- / Export-Modul.
35
5.2. Benutzungsinterface
Im COAT-System werden drei neue Dialoge für die Kleinteile-Behandlung realisiert.
Dialog Funktion
Kleinteile-Bibliothek Anzeige der im System vorhandenen Kleinteile
mit dazugehörigen Informationen;
Auswahl der Kleinteile.
Kleinteil einfügen Eingabe erforderlicher Zielelemente und Vari-
ablen. Einfügen des Kleinteils in die Zielkon-
struktion.
Kleinteil erstellen Abschluss eines konstruierten Kleinteils. Erstel-
lung der Informationen zu dem Kleinteil und
Kontrolle der Bezugselemente.
Die Dialoge Kleinteile-Bibliothek und Kleinteil erstellen sind modal. Der Dialog
Kleinteil einfügen ist nicht modal, damit der Zielschnitt während des Einfügens
nachbearbeitet werden kann. Neben den neuen Dialogen werden die bereits vorhan-
denen zum Export / Import der Schnittteile im Büro modifiziert.
5.3. Konstruktion eines Kleinteils
Die Konstruktion eines Kleinteils wird in zwei Etappen durchgeführt. Die erste
Etappe schließt die Vorbereitungsroutinen unmittelbar nach Aktivierung des Klein-
teile-Modus ein. Die zweite Etappe zum Erstellen des Kleinteils folgt, nachdem die
Konstruktionsschritte für das Kleinteil durchgeführt worden sind, und fügt ein ferti-
ges Kleinteil in die Bibliothek ein.
36
Vorbereitungsroutinen
Erstellen einer Kopie des Variablenbaums
Nachdem der Kleinteile-Modus aktiviert ist, müssen Informationen über den
aktuellen Zustand des Schnittmusters abgespeichert werden. Der Variablen-
baum für die aktuelle Größe wird in eine neue Variablengruppe kopiert. Die
Variablenbäume für die regulären Schnittmuster enthalten das Präfix An-
fang, zum Beispiel:
Anfang.Schnittteil1.Linie1
Damit der Variablenbaum des aktuellen Zustands des Schnittmusters später
erkennbar ist, muss dieser ein anderes Präfix bekommen. Er erhält das Präfix
“Baustein.“. Bei der Erstellung des Kleinteils dient die Variablenkopie
dem Erkennen der aus der Hauptkonstruktion benutzten Objekte, die als Be-
zugselemente bezeichnet werden.
Kleinteile-Modus im Skript aktivieren
Damit eine nicht abgeschlossene Kleinteilkonstruktion zwischengespeichert
werden kann, muss im Skript vermerkt werden, an welcher Stelle die Klein-
teilkonstruktion begonnen wurde. Dafür wird in das Skript die folgende An-
weisung eingefügt.
BausteinModus()
Wenn das Schnittmuster geschlossen und später aufgerufen wird, werden die
Vorbereitungsroutinen beim Parsen des Skripts wieder ausgeführt. Dieser
Mechanismus dient zum Zwischenspeichern der Kleinteile. Deswegen muss
die Skript-Anweisung BausteinModus() nach Abschluss des Kleinteils
aus dem Skript entfernt werden.
37
Konstruktionsphase
Eine Grundlinie wird gesetzt und dann die übliche Konstruktion des Klein-
teils durchgeführt. Einschränkungen bei der Konstruktion sind im Kapitel
5.6.5 aufgezählt. Die zuvor entstandene Zeichnung sowie die Maßtabelle und
Zugabentabelle sind hier verfügbar. Der Benutzer erkennt den aktivierten
Kleinteile-Modus durch ein Anzeigeelement (??? in Kap. 6.1.). Bei der Klein-
teile-Konstruktion werden die Skriptzeilen genauso generiert wie bei der ge-
wöhnlichen Konstruktion.
Kleinteil abschließen
Die Konstruktion wird durch Ausschalten des Kleinteile-Modus abgeschlos-
sen. In dieser Phase wird das Skript des Kleinteils verändert und abgespei-
chert.
Bezugselemente erkennen
Nach dem Ausschalten des Kleinteile-Modus wird das Skript untersucht. Die
Bezugselemente des Kleinteils werden erkannt und in einer Liste erfasst. Um
die Suche zu beschleunigen, müssen einige Transformationen der vorliegen-
den Daten vorgenommen werden. Der Grund dafür ist, dass die in einem Va-
riablenbaum abgespeicherten Elemente der Basiskonstruktion mit dem
Variablenbaum des letzten Zustands der Konstruktion verglichen werden sol-
len. Der Aufwand eines solchen Vergleichs ist quadratisch in Bezug auf die
Größe der Variablenbäume.
1. Alle Elemente des aktuellen Variablenbaums werden in einer Hash-
Tabelle1 gesammelt. Um einen Objekt-Pointer nach dem Namen des
zugehörigen Elementes zu suchen, ist in der Hash-Tabelle keine voll-
ständige Iteration erforderlich. Der Aufwand der Suche ist konstant.
2. Für die Objekte aus der Variablenkopie werden ihre Parser-Namen in
einem Array als Strings gespeichert. Dabei werden nur die Gruppen
ausgefiltert und nur die geometrischen Objekte abgespeichert.
1 Eine Hash-Tabelle ist die Datenstruktur für das Hash-Verfahren zum Suchen und Speichern von Da-ten. Sie ermöglicht das schnelle Auffinden von Daten nach einem Schlüssel. Im gegebenen Fall wird der Elementname als Schlüssel benutzt.
38
3. Das Array mit Objekten wird iteriert und jeder Name in der Hash-
Tabelle gesucht. Ist das Objekt gefunden, wird der Pointer des Ob-
jekts in die Gruppe der Bezugselemente eingefügt. Danach werden al-
le in der Kleinteilkonstruktion entstandenen Skriptzeilen ausgelesen
und alle Objekte des Kleinteils in einer Gruppe abgespeichert. An-
schließend wird der Name des ersten Schnittteils aus dem Kleinteil als
Vorgabename für den Kleinteilnamen vermerkt. Die erstellten Daten-
strukturen werden an den Dialog Kleinteil erstellen übergeben.
Dialog Kleinteil erstellen
Im nächsten Schritt wird der Dialog Kleinteil erstellen angezeigt. Die Namen
der Bezugselemente werden in einer Liste angezeigt. Für die Bezugselemente
werden Datenstrukturen angelegt, welche Zusatzinformationen wie die Be-
schreibung enthalten. Die Beschreibungen zu den Bezugselementen und zum
Kleinteil gibt der Benutzer in die entsprechenden Dialogfelder ein. Eine War-
nung wird angezeigt, wenn nicht alle Bezugselemente mit einer Beschreibung
versehen wurden.
Bezugselemente in die Vorgaben umwandeln
Die Bezugselemente werden als Vorgaben in der Datenbank abgespeichert.
Daraus werden beim Einfügen temporäre, geometrische Elemente für die
Vorschau des Kleinteils erstellt. Die Vorgabentabelle enthält folgende Infor-
mationen über
BausteinID
ID des Kleinteil-Skriptes
Name
Name des Bezugselementes
Typ
Der Typ des Bezugselementes als Integer-Wert
Wert
Koordinaten der Stützpunkte des Elementes
39
BausteinID Name Typ Wert
1 Linie1 2 12.56, 35.64; 39.23,
27.87;
1 Punkt1 1 10.00, 25.50;
2 Kurve1 3 15.78, 89.00; 18.23,
95.05; 22.10, 101.00 …
Tab. 1: Vorgabentabelle
Der Name des Bezugselementes wird automatisch aus dem Skript übertragen.
Dieser Name kann nur im Konstruktionsprozess geändert werden. Nicht alle
Typen der Elemente in COAT sind als Bezugselemente erlaubt. Verfügbar
sind Linien, Punkte und Kurven. Im Datenbank-Feld Wert werden die Koor-
dinaten der Stützpunkte von Bezugselementen als String abgelegt. Die Form
der Kodierung der
Punkte: X, Y
dabei sind X und Y die Koordinaten des Punktes als Float-Werte
Linien: X1, Y1; X2, X2
dabei sind X1, Y1 die Koordinaten des Startpunktes und X2, Y2 Koor-
dinaten des Endpunktes der Linie als Float-Werte
Kurven: X1, Y1; …; XN, YN,
wo XN, YN die Koordinaten der Stützpunkte der Kurve als Float-
Werte.
Kleinteil-Skript entfernen
Nachdem die Informationen über Vorgaben abgespeichert wurden, werden die
Skriptzeilen des Kleinteils in der Datenbank gespeichert. Dafür werden die Zeilen ab
der Anweisung BausteinModus() extrahiert und unter einer neuen ID in der Ta-
belle Skript gespeichert. Die Anweisung BausteinModus() wird entfernt.
Kleinteil-Skript automatisch einfügen
Das Kleinteil wird wieder in die Konstruktion eingefügt, in der es entstanden ist. So
wird das Kleinteil sowohl im Ursprungsschnitt als auch in allen Zielschnitten auf die
gleiche Weise eingebettet. Da die Informationen über die Bezugselemente, Maße und
40
Zugaben in diesem Fall schon vorhanden sind, wird der Benutzerin kein Dialog zur
Zuweisung der Bezugselemente angezeigt. Die Informationen über Parametrisierung
werden an die Klasse CBausteinSkript übergeben, so dass keine zusätzlichen Einga-
ben erforderlich sind. Kapitel 5.5 geht detailliert auf den Mechanismus des Einfügens
ein.
41
5.4. Auswahl der Kleinteile
Der Dialog Kleinteile-Bibliothek (Abb. 8) kann aus dem Menü von COAT über den
Eintrag Kleinteile-Bibliothek erreicht werden. Der Menü-Eintrag ist nur bei nicht ab-
geschlossenen Skripten aktiviert.
Abb. 8: Dialog Kleinteile-Bibliothek
Im Dialog Kleinteile-Bibliothek wird eine Übersicht über alle im System verfügbaren
Kleinteile gegeben. Bei der Konzeptionierung des Dialogs wurde insbesondere auf
eine kompakte und benutzungsfreundliche Darstellung der umfangreichen Datensät-
ze zu den Kleinteilen geachtet. In diesem Dialog werden folgende Daten angezeigt:
Liste der Kleinteile gruppiert nach Kategorien
Auswahl der Art der Sortierung nach Kategorie oder alphabetisch
Bezugselemente des ausgewählten Kleinteils
Beschreibung des Kleinteils
Beschreibung zum ausgewählten Bezugselement
Vorschau des ausgewählten Kleinteils
Beim Aufruf des Dialogs Kleinteile-Bibliothek werden die Daten zu einem Kleinteil
aus der Datenbank ausgelesen. Die Liste der Kleinteile wird aus der Datenbank-
42
Tabelle Kleinteile gelesen. Über die ID des Kleinteils werden die Zusatzinformatio-
nen, wie etwa die Kategorie oder die Liste der Bezugsobjekte, aus den Tabellen Vor-
gaben und Skript bezogen. Bei der Auswahl eines Kleinteils aus der Liste wird die
Vorschau angezeigt. Dazu muss das Skript des jeweiligen Kleinteils geparst werden,
wofür zunächst die Bezugsobjekte als Variablen erzeugt werden müssen. Das Objekt
für die Vorschau wird nicht gelöscht, weil die Vorschau zu dem ausgewählten Klein-
teil im darauf folgenden Dialog Kleinteil einfügen benutzt wird. Die jeweiligen Ob-
jekte zu dem ausgewählten Kleinteil bleiben erhalten und werden als Pointer an den
Dialog Kleinteil einfügen übergeben.
Auf ein Textfeld zur Beschreibung des ausgewählten Bezugselementes wird verzich-
tet. Die Benutzerin erhält Auskunft über Bezugselemente, indem sie einen Listenein-
trag doppelt anklickt oder sie hält den Mauszeiger über den jeweiligen Eintrag,
woraufhin die Beschreibung in einem Pop-Up-Textfeld erscheint. Für das bereits
ausgewählte Kleinteil sind die Informationen zu den Bezugselementen im Kontext
des Dialogs Kleinteil einfügen von höherer Relevanz. Sie werden dort in einem Dia-
logfeld ausgegeben.
5.5. Einfügen eines Kleinteils
Das in der Kleinteile-Bibliothek ausgewählte Kleinteil soll vor dem Einfügen in dem
Dialog Kleinteil einfügen durch die für die Parametrisierung relevanten Informatio-
nen ergänzt werden. In diesem Dialog werden die Bezugselemente eingegeben, die
Einbettung des Kleinteils über die Vorschau kontrolliert und anschließend das Klein-
teil eingefügt.
Bezugselemente vorbereiten
Die Bezugselemente werden in einer Liste des Dialogs angezeigt. Die Liste
hat drei Spalten für:
Ursprungselemente
Zielelemente
Status der Zuweisung der Elemente
43
Die Ursprungselemente werden in der Liste angezeigt. Die Zielelemente er-
scheinen in den entsprechenden Zeilen, nachdem sie eingegeben wurden. Der
Status der Zuweisung signalisiert, ob das eingegebene Zielelement mit dem
Ursprungselement konsistent ist. Erst nachdem alle Zuweisungen einen posi-
tiven Status haben, ist der Button zum Einfügen des Kleinteils aktiviert.
Schnittteile erzeugen
Zunächst wird die Anzahl der Schnittteile im Kleinteil-Skript ermittelt. Im
Zielschnitt werden sie als neue Schnittteile angelegt. Ihre Namen müssen in
einer Liste erfasst werden, weil in diese Schnittteile die entsprechenden Ele-
mente des Kleinteils verschoben werden. Skriptzeilen für Schnittteile-
Konstruktoren werden angelegt.
Kleinteil1 = Schnittteil()
Referenz auf das Kleinteil-Skript erzeugen
In dem Skript wird eine Referenz auf das Kleinteil-Skript erzeugt. Die An-
weisung Baustein bekommt als Parameter die ID des Kleinteil-Skriptes.
Baustein(integer ID)
Zuweisungen der Elemente im Skript erzeugen
Jedem Ursprungselement muss das entsprechende Zielelement im Skript zu-
gewiesen werden. Die Daten werden aus der Liste der Bezugselemente ent-
nommen.
Kleinteil1.Linie1 = Schnittteil1.Linie1
Laden des Kleinteil-Skripts
Das Skript des aktuellen Kleinteils wird geparst. Beim Parsen des Skriptes
werden die Elemente in einem eigenen Variablenbaum angelegt; sie werden
an den aktuellen Variablenbaum des Zielschnitts angehängt. Dabei hat der
Parser eine Zugriffsmöglichkeit auf die Maß- und Zugabentabellen des aktu-
ellen Schnitts.
44
Elemente verschieben
Die Elemente des Kleinteils werden in die angelegten Schnittteile verscho-
ben. Der Operator => verschiebt die Elemente, indem sie kopiert und danach
gelöscht werden.
Kleinteil positionieren
Bezieht sich das Kleinteil auf kein Element aus der Basiskonstruktion, muss
es auf der Arbeitsfläche positioniert werden. Dies geschieht ähnlich wie beim
Einfügen der Grundlinie eines Schnittteils. Die Konturen des Kleinteils wer-
den beim Verschieben des Cursors hell-grau angezeigt.
45
5.6. Weitere Aspekte der Lösung
5.6.1. Erweiterung der Skript-Sprache
Um neue, für die Kleinteile-Bibliothek implementierte Konstrukte einzulesen, muss
die Skript-Sprache von COAT erweitert werden. Das COAT-System benutzt ein ex-
ternes Modul „CoCo“ zur Generierung des Parsers. Die Skriptsprache wird über die
EBNF-Grammatik definiert [Szczepanek 2003: 111]. Der COAT-Parser ist um fol-
gende grammatische Strukturen erweitert worden:
Funktion BausteinModus()
Die Funktion schaltet den Kleinteile-Modus ein.
Operator =>
Verschiebt alle Objekte eines Kleinteils oder eines Schnittteils in ein
anderes Schnittteil.
Funktion Baustein(integer ID)
Parst ein Kleinteil aus dem Skript mit der Identifikation ID.
5.6.2. Kleinteile löschen
Beim Löschen eines Kleinteils muss geprüft werden, ob das Kleinteil in Schnittmus-
tern benutzt wird. Ist dies der Fall, kann es erst dann gelöscht werden, wenn auch die
Schnittmuster selbst entfernt werden. Die Referenz auf ein Kleinteil könnte theore-
tisch aus einem Schnittmuster entfernt werden, wenn nach dem Einfügen des Klein-
teils keine weiteren Konstruktionsschritte durchgeführt wurden. Damit wäre ein
automatischer Löschvorgang von bereits verwendeten Kleinteilen komplex und auf-
wändig. Aus diesem Grund verzichtet die Lösung für die Kleinteile-Bibliothek auf
das Löschen von solchen Kleinteilen. Nur die nicht verwendeten Kleinteile können
aus der Bibliothek entfernt werden.
5.6.3. Import und Export
Für die Bausteine ist ein Import- / Export-Mechanismus vorgesehen. Der Aufruf zum
Import / Export erfolgt aus dem Büro-Teil von COAT. Der vorhandene Mechanis-
46
mus zum Import / Export der Schnittmuster wird für die Kleinteile so angepasst, dass
die Kleinteile-Liste in einer eigenen Kategorie im Büro-Teil angezeigt wird. Dort
können die Kleinteile ausgewählt und dann importiert und exportiert werden.
5.6.4. Copyright
Beim Export eines Kleinteils aus einem fremden System wird der Text zum Urheber-
recht im Büro-Teil angezeigt, wobei das Durchlesen dieses Textes explizit durch die
Importeurin bestätigt werden muss. Ähnlich wie beim Import von Schnittmustern
legt beim Import der Kleinteile die Exporteurin in einer Option fest, ob der urheber-
rechtliche Text angezeigt wird und bestätigt werden muss.
5.6.5. Einschränkungen
Das Konzept der Kleinteile-Bibliothek sieht vor, dass die Benutzerin bei der Kon-
struktion im Kleinteile-Modus möglichst wenig eingeschränkt ist. Jedoch können
einige Arbeitsschritte aus technischen Gründen nicht durchgeführt werden. Ein-
schränkungen kommen auch bei Arbeitsschritten hinzu, die aus Sicht der Schnittkon-
struktion nicht sinnvoll erscheinen.
Folgende Funktionen des Systems sind im Kleinteile-Modus blockiert:
Lagenbild erstellen
Nahtzugaben erstellen
Kleinteil einfügen
Schnittteile zusammenlegen
Nahtzugaben und ein Lagenbild werden nach der Modellentwicklung erstellt. Daher
sollten diese Funktionen im Kleinteile-Modus blockiert werden. Ein rekursiver Me-
chanismus zum Einfügen der untergeordneten Kleinteile ist innerhalb der vorliegen-
den Arbeit nicht geplant; der Menü-Eintrag Kleinteil einfügen wird daher im
Kleinteile-Modus blockiert.
Weitere Einschränkungen ergeben sich aus der Besonderheit des Abspeicherns der
Kleinteile. Da der Skript-Text eines Kleinteils lediglich die Kleinteilelemente erzeu-
gen und die Elemente der Basiskonstruktion nur für den Bedarf des Kleinteils benut-
47
zen soll, müssen Arbeitsschritte blockiert werden, die nur Basisteile ohne Bezug auf
Kleinteile verändern. Zu diesen gehören:
Schnittteile zusammenlegen
Schnittteile beschriften
Schnittteile verschieben
Diese Funktionen sind nur für die Basiskonstruktion nicht verfügbar.
48
6. Beschreibung des Systems
In diesem Kapitel wird die Kleinteile-Bibliothek aus der Perspektive der Benutzerin-
nen beschrieben. Alle neuen Funktionen werden charakterisiert und erläutert. Die
Beschreibung gliedert sich in zwei Bereiche: Kleinteile konstruieren und Kleinteile
einfügen.
6.1. Kleinteile konstruieren
Wie bei den Anforderungen bereits erwähnt, soll die Schneiderin die Kleinteile-
Bibliothek um eigene Kleinteile erweitern können.
Anfang der Konstruktion
Die Konstruktion jedes neuen Kleinteils für die Bibliothek beginnt, indem der Klein-
teile-Modus aktiviert wird. Dies geschieht durch Anklicken des Buttons Kleinteile-
Modus (Abb. 9).
Abb. 9: Button für Kleinteile-Modus
Das Kleinteil wird konstruiert. Um die Konstruktion des Kleinteils zu beenden, muss
der Kleinteile-Modus durch Anklicken des Buttons Kleinteile-Modus deaktiviert
werden.
49
Abb. 10: Dialog Kleinteil erstellen
Danach erscheint der Dialog Kleinteil erstellen (Abb. 10), in dem die folgenden Ein-
gaben gemacht werden:
1. Name
Im Eingabefeld Name wird das Kleinteil mit einer Bezeichnung versehen.
Die Voreinstellung in diesem Feld ist der Name des ersten im Kleinteil-
Modus erzeugten Schnittteils.
2. Beschreibung
Hier wird eine allgemeine Beschreibung des Kleinteils eingegeben.
3. Bezugselemente
Die Liste enthält alle in dem Kleinteil aus der Hauptkonstruktion verwen-
deten Elemente.
4. Beschreibung zum Bezugselement:
In diesem Feld wird das ausgewählte Bezugselement mit einer Beschrei-
bung versehen. Die Beschreibung soll verdeutlichen, welche Funktion das
ausgewählte Bezugselement in der Hauptkonstruktion hat.
5. Vorschau
Im Vorschau-Fenster wird das fertige Kleinteil angezeigt. Das Vorschau-
50
Fenster hat die gleichen Funktionen wie Verschiebung oder Zoom in an-
deren Dialogen des COAT-Systems.
6.2. Kleinteile einfügen
6.2.1. Dialog Kleinteile-Bibliothek
Eine Übersicht über alle im System vorhandenen Kleinteile bietet der Dialog Klein-
teile-Bibliothek (Abb. 11). Um ein Kleinteil in die Konstruktion einzufügen, ruft die
Benutzerin zuerst die Kleinteile-Bibliothek über den Menüeintrag Kleinteil einfügen
auf. Der erscheinende Dialog ist folgendermaßen aufgebaut:
Abb. 11: Dialog Kleinteile-Bibliothek
Links befindet sich das Dialogfeld Kleinteile. Hier sind alle Kleinteile in einer
baumartigen Ansicht aufgelistet. Im Auswahlfeld Sortieren nach kann bestimmt
werden, ob die Kleinteile in einer alphabetisch sortierten Liste oder gruppiert nach
Arten der Kleinteile dargestellt werden sollen.
In der Liste Erforderliche Bezugselemente befinden sich Angaben zu den Bezugs-
elementen, die das links ausgewählte Kleinteil benötigt. Im Textfeld Beschreibung
befindet sich die Beschreibung des ausgewählten Kleinteils. Um eine Beschreibung
51
der einzelnen Bezugselemente des ausgewählten Kleinteils zu erhalten, muss der je-
weilige Eintrag in der Liste der Bezugselemente doppelt angeklickt werden. Im rech-
ten Dialogfenster findet sich eine Vorschau des ausgewählten Kleinteils.
Die Kleinteile-Bibliothek kann durch Anklicken des Buttons Schließen geschlossen
werden. Um das ausgewählte Kleinteil in die Konstruktion einzufügen, wird der But-
ton Weiter… angeklickt.
6.2.2. Dialog Bezugselemente angeben
Der Dialog Bezugselemente angeben (Abb. 12) erscheint nach dem Anklicken des
Buttons Weiter… in der Kleinteile-Bibliothek, falls ein Kleinteil dort ausgewählt
wurde. In diesem Dialog werden den Bezugselementen des jeweiligen Kleinteils die
Elemente aus dem Zielschnitt zugewiesen und durch weitere erforderliche Angaben
zum Kleinteil ergänzt.
Abb. 12: Dialog Bezugselemente
Die Liste der Bezugselemente enthält Informationen über die erforderlichen Ur-
sprungselemente und die definierten Zielelemente der Konstruktion. In der Liste
links stehen die nötigen Bezugselemente bereit. Rechts befinden sich zunächst keine
Elemente, die erst in diesem Dialog eingegeben werden müssen. Bei der Auswahl
eines Elements aus der Liste werden zu diesem im Textfeld Beschreibung nähere
52
Angaben angezeigt. Das ausgewählte Element wird im Preview-Fenster rot markiert.
Anhand seiner Beschreibung und seiner geometrischen Form entscheidet die Benut-
zerin, welches Element aus der Konstruktion dem Bezugselement zugewiesen wer-
den soll.
Im Eingabefeld Vervollständigen Sie das Element wird mittels Drag-and-Drop ein
Element aus der Konstruktion eingegeben. Nur ein Objekt vom gleichen Typ wie das
erforderliche Bezugselement kann in das Feld gezogen werden. Direkt nach der Ein-
gabe eines Bezugselementes wird das Preview-Fenster angepasst: die Konsequenzen
der Zuweisung des Bezugselements werden sichtbar. Entspricht das eingegebene Ob-
jekt nicht den Konstruktionsideen des Kleinteils, wird dies im Vorschau-Fenster für
die Schneiderin durch Verzerrung oder Zerstörung der Konturen sichtbar.
Sind alle Elemente definiert, wird der Button Einfügen aktiviert und das Kleinteil
kann eingefügt werden. Der Dialog wird geschlossen und das Kleinteil kann auf der
Arbeitsfläche mit der Maus positioniert werden. Nach dem Klicken auf der Arbeits-
fläche wird das Kleinteil an der angegebenen Stelle eingefügt. Die Konturen des
Kleinteils können nun durch weitere Arbeitsschritte nach Bedarf bearbeitet werden.
53
7. Resümee
Ziel dieser Arbeit war es, ein Konzept für eine bessere Handhabung und Speicherung
von Kleinteilen in COAT zu erarbeiten und zu implementieren. Die hier vorgestellte
Lösung zeigt, dass mit dem Kleinteile-Modul ein flexibles und erweiterbares Werk-
zeug realisiert worden ist. Aus dieser Lösung ergeben sich verschiedene Vorteile für
die Schneiderinnen. Zum einen können repetitive Arbeiten zur Konstruktion der
Kleinteile durch die Verwendung von bereits vorgefertigten und abgespeicherten
Kleinteilen eingespart werden. Zum anderen kann den Benutzerinnen des COAT-
Systems eine neue Datenbank mit von Fachkräften erstellten Kleinteilen angeboten
werden. Die selbsterstellten Kleinteile können zwischen den COAT-Installationen
isoliert, ohne Grund- oder Modellschnitte, ausgetauscht werden. Der Prozess der
Konstruktion von Kleinteilen unterscheidet sich prinzipiell nicht vom üblichen Kon-
struktionsprozess.
In der Diskussion mit Anwenderinnen sind die repetitiven Arbeiten bei der Schnitt-
konstruktion als zeitraubend beschrieben worden. Eine Erweiterung des COAT-
Systems um die Kleinteile-Bibliothek wurde als wünschenswert und notwendig ein-
geschätzt. So besteht bei der Firma braviange in Hamburg, die maßgeschneiderte
Damenwäsche anfertigt, bereits Interesse, BH-Träger als Kleinteile zu konstruieren,
da diese derzeit bei den Basisteilen mehrfach mitkonstruiert werden müssen.
Zu prüfen ist noch, inwieweit das Kleinteile-Modul für die Konstruktion spezieller
Bekleidungsarten geeignet ist. Ein Beispiel für solche Bekleidungsarten sind maßge-
schneiderte Tauchanzüge, für die das COAT-System schon eingesetzt wurde. Ein
Tauchanzug bietet viele Gestaltungsmöglichkeiten, die sich hauptsächlich durch die
Kombination mehrerer Kleinteile ergeben. Hier ist die korrekte Positionierung der
Kleinteile auf den Basisteilen besonders wichtig.
Neben der Konstruktion der Kleinteile treten repetitive Arbeiten auch in anderen
Konstruktionsvorgängen auf. Bei der Schnittkonstruktion treten oft sehr ähnliche
Kombinationen von Arbeitsschritten auf, ohne dass dabei neue Schnittteile erzeugt
werden. Ein Beispiel dafür ist die Neukonstruktion oder Übertragung bzw. das Zu-
drehen eines Abnähers. Hier wäre ein Einsatz des Bausteine-Prinzips denkbar, auf
54
dessen Basis das Kleinteile-Modul entwickelt worden ist. Parametrisiert abgespei-
cherte Konstruktionsanweisungen, die zum Beispiel einen Abnäher zudrehen, könn-
ten als Makro (bzw. Baustein) abgespeichert werden. Dieses Makro kann in einem
beliebigen Schnitt auf einen Abnäher angewendet werden und ihn zudrehen. Eine
weitere Analyse der Anforderungen für eine Makro-Aufzeichnung würde den Rah-
men dieser Arbeit sprengen und bleibt daher Folgearbeiten überlassen.
55
8. Literatur
[Aldrich 1997] Aldrich, W.: Metric Pattern Cutting, 3rd ed., Oxford et al.
1997.
[Belschner et al. 1994]
Belschner, I., E. Kirchdörfer, K. Reusch, W. Bruder und J.
Niemann: Anforderungsdefinitionen an Schnitteiledatenban-
ken (= Bekleidungstechnische Schriftenreihe, Bd. 102), Köln
1994.
[Bray 1996] Bray, N.: Dress Pattern Designing. The Basic Principles of Cut
and Fit, 5th ed., Oxford et al. 1996.
[Brinkmann-Stieler 2001]
Brinkmann-Stieler, A.: DOB-Gradierung. Schnitt-Know-how
für Industrie und Handwerk, München 2001.
[Cooklin 1997] Cooklin, G.: Garment Technology for Fashion Designers, Ox-
ford et al. 1997.
[Dewes 1996] Dewes, A.: Schnitteile-Baukasten. Ein Beitrag zur rechnerge-
stützten Schnittkonstruktion im Schneiderhandwerk, Diplom-
arbeit, Bremen 1996.
[Jaque 1991] Jaque, L.: Tekhnika Kroja. Techniques de la Coupe, Udmurtia
1991.
[McKelvey 1996] McKelvey, K.: Fashion Source Book, Oxford et al. 1996.
[Müller 1993] Müller, R.: Konstruieren und Planen mit Baugruppen (= Be-
kleidungstechnische Schriftenreihe, Bd. 41), 3. Aufl., Köln
1993.
56
[Pekholz/Läer 1995] Peckholz, U. und D. Läer: Von der Idee zur Serie, Hamburg
1995.
[Plath 2004] Plath, J.: Computergestützte Konstruktion von Maßschuhen,
Aachen 2004.
[Schierbaum 1982] Schierbaum, W.: Bekleidungslexikon, 2. erw. Aufl., Berlin
1982.
[Schierbaum 1997] Schierbaum, W. (Hg.): Jahrbuch für die Bekleidungs-Industrie
1997, Berlin 1997.
[Schipilowa 2003] Schipilowa, E.A.: Azbuka kroja dlja natschinajuschtschikh
portnikh [A bis Z des Schneiderns für Anfänger], Rostov a.D.
2003.
[Seidl et al. 2001] Seidl, A., S. Mecheels, G. Wauer, und W. Bruder (Hrsg.): Zu-
kunft Maßkonfektion. Technik, Markt und Management,
Frankfurt a.M. 2001.
[Szczepanek 2003] Szczepanek, U.: Konzeption und Entwicklung eines prozeßo-
rientierten CAD-Systems für die Bekleidungskonstruktion,
Aachen 2003.
9. Internetquellen
[COAT] Webseite des COAT-Systems, www.coat.de [Stand: 20.07.2008].
[Berufenet 2008] Bundesagentur für Arbeit, Berufenet,
http://berufenet.arbeitsagentur.de/berufe/ [Stand: 16.07.2008]
57
10. Anhang
10.1. Beispiel für die Konstruktion einer Tasche
Das folgende Beispiel soll die Konstruktion und die Wiederverwendung einer Tasche
zeigen. Es wird eine einfache aufgesetzte Tasche konstruiert und eingefügt. Der Ur-
sprungsschnitt ist der Grundschnitt für die Bluse (Abb. 13). Die Tasche wird nach
der Konstruktion an einer Hilfslinie des Vorderteils angelegt.
Abb. 13: Vorderteil des Blusengrundschnittes
Der Kleinteile-Modus wird aktiviert; ein neues Schnittteil für die Tasche wird in die
Konstruktion eingefügt (Abb. 14).
Abb. 14: Schnittteil einfügen
Danach werden zwei Variablen in der Zugabentabelle erzeugt: Taschenbreite (Abb.
15) und Taschenlänge.
58
Abb. 15: Zugabe für die Taschenbreite
Die Tasche wird konstruiert (Abb. 16) und anschließend über die Funktion Schnitt-
teile zusammenlegen an die Hilfslinie des Vorderteils angelegt (Abb. 17). Dies ist
eine einfache Taschenart; sie hat eine rechteckige Form, deren Seiten durch die Vari-
ablen Taschenbreite und Taschenlänge bestimmt sind.
Abb. 16: Konstruktion der Tasche
Abb. 17: Vorderteil und Tasche zusammenlegen
59
Abb. 18: Fertige Tasche
Wenn die Konstruktion der Tasche beendet ist (Abb. 18), wird der Kleinteile-Modus
deaktiviert. Es erscheint der Dialog Kleinteil erstellen. Die Hilfslinie zum Anlegen
der Tasche wird zu einem Bezugselement für sie und soll mit einem Kommentar ver-
sehen werden (Abb. 19).
Abb. 19: Kleinteil erstellen
60
Jetzt kann ein anderer Schnitt geöffnet werden, in den die Tasche eingefügt werden
soll. Dafür wird der Modellschnitt Bluse 1 gewählt. Um die Tasche einzufügen, wird
die Kleinteile-Bibliothek (Abb. 20) aufgerufen.
Abb. 20: Kleinteile-Bibliothek
Die abgespeicherte Tasche befindet sich in der Kategorie Taschen. Sie wird ausge-
wählt; nach dem Klicken auf Weiter erscheint der Dialog Bezugselemente angeben
(Abb. 21).
Abb. 21: Dialog Bezugselemente angeben
Mit der entsprechenden Hilfslinie aus dem Modell Bluse 1 wird das Bezugselement
Linie5 ergänzt. Der Dialog wird durch das Klicken auf Einfügen geschlossen. Die
Tasche wird in den Zielschnitt eingefügt (Abb. 22).
61
Abb. 22: Eingefügte Tasche im Modellschnitt Bluse 1
62
10.2. Klassendiagramme
Auf den folgenden Seiten findet sich das Klassendiagramm für die Implementierung
der Kleinteile-Bibliothek. In dieses Diagramm wurden nur die neuen und die für die
Kleinteile-Implementierung modifizierten Klassen eingetragen. Auf den Klassen sind
nur neue Methoden und Variablen angegeben.
top related