Flexibles Kleinteile-Modul für das...

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.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.Linie1 = LinieAbtragen(Punkt1, Punkt2)

Schnittteil1.Kurve1 = Kurve(Punkt2, Punkt3, …)

...


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.


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.

Flexibles Kleinteile-Modul für das...

Documents

Transcript of Flexibles Kleinteile-Modul für das...