TexGen - User contributions [en]

MediaWiki:Sidebar

2011-10-12T15:29:47Z

WikiSysop:

MediaWiki:Sidebar

2011-10-12T15:28:22Z

WikiSysop:

MediaWiki:Sidebar

2011-10-12T15:27:55Z

WikiSysop:

MediaWiki:Sidebar

2011-10-12T15:24:24Z

WikiSysop:

Download TexGen

2011-10-12T14:16:38Z

WikiSysop: Created page with " Download Texgen"

Download Texgen

MediaWiki:Sidebar

2011-10-12T14:15:05Z

WikiSysop:

TexGen Applications

2011-10-03T09:14:36Z

WikiSysop: Protected "TexGen Applications": Excessive spamming ([edit=sysop] (indefinite) [move=sysop] (indefinite)) [cascading]

Originally developed at the University of Nottingham to describe textile composite reinforcements, TexGen has various applications in modelling dry fabric mechanics, fluid flow through fabrics and mechanics of textile composites. This page contains information on published and current research activity related to TexGen. Further information is available on the [http://www.textiles.nottingham.ac.uk/ textile composite research pages] at the University of Nottingham.

* [[Textile mechanics]]

* [[Textile permeability]]

* [[Textile composite mechanics]]

* [[Textile composite heat transfer]]

* [[Textile composite viscous forming]]

* [[Other applications]]

Documentation

2011-10-03T09:14:07Z

WikiSysop: Protected "Documentation" ([edit=sysop] (indefinite) [move=sysop] (indefinite)) [cascading]

The following documentation is available:

* [[User Guide]] - Guide to using the TexGen graphical user interface
* [[Scripting Guide]] - Guide to writing Python scripts for generating TexGen models
* [http://texgen.sourceforge.net/api/ API Reference Guide] - Reference guide for Python scripting
* [[TG3 File Format]] - TexGen save file format description
* [[TexGen Applications]] - Published applications of TexGen
* [http://etheses.nottingham.ac.uk/archive/00000303/01/thesis-final.pdf Modelling Theory] - Much of the theory behind TexGen can be found in this thesis (Chapters 2 and 3)
* [http://texgen.sourceforge.net/documents/TexGen_17_10_07.pdf Presentation Slides] - Some slides from a presentation made on TexGen on the 17/10/07

Windows Installation

2011-10-03T09:13:46Z

WikiSysop: Protected "Windows Installation": Excessive spamming ([edit=sysop] (indefinite) [move=sysop] (indefinite)) [cascading]

__NOTOC__
==Download==
TexGen is hosted on sourceforge and the latest version can be [http://sourceforge.net/project/showfiles.php?group_id=181000 downloaded here]. As of version 3.2.0 you have a choice between two version: ''texgen-3.x.x.exe'' and ''texgen-bundle-3.x.x.exe''. TexGen requires the Python interpreter to be installed in order to run. The standard installation package named ''texgen-3.x.x.exe'' does not include Python and must be installed manually. The bundle installation package comes with the Python interpreter which means that it does not need to be installed manually.

If you don't know what Python is or you won't be using it for anything other than TexGen then the bundle package is recommended. For experienced users, the standard installation package is preferable since it will integrate itself with an existing python installation giving existing Python scripts access to TexGen.

==Installation==
===Prerequisites===
If you didn't download the bundle installer than you will need to have Python 2.5 installed, otherwise you can skip this step. "Python 2.5.x Windows installer" can be [http://www.python.org/download/ found here]. Note that even users with a 64 bit system should NOT install the AMD64 or Itanium version of Python (see FAQ for more information).

===Install===
Run the installer and follow the on screen instructions. Again if you didn't download the bundle installer there are a few extra steps to complete during the installation. You will be asked to specify where Python has been installed. The installer should detect this automatically if all goes well, if not you must specify the directory manually. This is necessary because TexGen will install an extension module in the Python directory. This is so that Python scripts can be executed from anywhere on the system. Since the TexGen graphical user interface also relies on the Python interface to function, it will not work unless this step is completed correctly.

===Running===
If TexGen has successfully been installed you should be able to run it from the start menu:

'''Start → Programs → TexGen → TexGen'''

Visit the [[User Guide]] section for information on using TexGen.

==FAQ==
===python25.dll not found, how do i fix it?===

Normally python25.dll should be placed in windows\system32 directory on installation of Python. In some cases this may not happen, python25.dll may be placed in your Python installation directory instead. If this happens TexGen will not know where to look for it, to solve the issue copy python25.dll from the Python directory to the TexGen directory.

If you have a 64 bit processor (AMD64 or Itanium) and have installed the "Python Windows AMD64 installer" or "Python Windows Itanium installer" TexGen will not function correctly. This is because TexGen is compiled as a 32 bit application and as such cannot link against a 64 bit library<ref>http://en.wikipedia.org/wiki/Windows_XP_Pro_x64#Compatibility_with_32-bit_applications</ref>. You must un-install Python and install the "Python Windows installer" instead which has been compiled as 32 bit. You may also need locate and copy the python25.dll manually into the TexGen folder, look for it in the windows\SysWoW64 directory. In the future a 64 bit version of TexGen may be provided in binary form but until then you must use the 32 bit version of Python or compile TexGen from source.

==References==

<references/>

Main Page

2011-10-03T09:12:33Z

WikiSysop: Changed protection level for "Main Page": Excessive spamming ([edit=sysop] (indefinite) [move=sysop] (indefinite)) [cascading]

__NOTOC__
[[Image:3Tex Vf 0.55.png|thumb|3d orthogonal woven fabric]]
[[Image:2DWeave.png|thumb|2d woven fabric]]
[[Image:Ncf.png|thumb|Non-crimp fabric]]
[[Image:Triaxialbraid.png|thumb|Triaxial braid fabric]]
[[Image:Weftknit.png|thumb|Weft knit fabric]]

TexGen is open source software licensed under the General Public License developed at the University of Nottingham for modelling the geometry of textile structures. TexGen has been used by the Nottingham team as the basis of models for a variety of properties, including textile mechanics, permeability and composite mechanical behaviour.

A summary of our work involving TexGen can be found on the [[TexGen Applications]] page. Please also visit the [http://www.textiles.nottingham.ac.uk/ University of Nottingham Textile Composites Research] website for more details about our research group.

On this website you will find all the information necessary to get started with TexGen by using the sidebar for navigation.

Please leave a message on the [http://texgen.sourceforge.net/phpBB3/index.php TexGen forum] if you find TexGen to be a useful tool. We are very interested to hear about research conducted with TexGen. The [http://texgen.sourceforge.net/phpBB3/index.php forum] is also the place to ask questions, make comments and generally discuss about TexGen with other users.

Specific bug reports, feature requests and patches are always welcome and should be directed to the [http://sourceforge.net/tracker/?group_id=181000 sourceforge trackers].

== News ==
===TexGen 3.4.1 Released! ===
Version 3.4.1 has been released. This contains minor changes to ABAQUS voxel mesh output and some bug fixes.
A list of changes can be found [https://sourceforge.net/projects/texgen/files//texgen/3.4.1/README/view here].

15:09, 22 June 2011 (GMT)

===TexGen 3.4.0 Released! ===
Version 3.4.0 has been released. It contains the addition of periodic boundary conditions to the Abaqus voxel mesh output. The dry fibre volume mesh intersection correction has been improved and an additional option added to regenerate the textile model using the adapted mesh following correction. There are also some bug fixes.
A list of changes can be found [https://sourceforge.net/projects/texgen/files//texgen/3.4.0/ReleaseNotes3.4.0.txt/view here].

14:49, 16 March 2011 (GMT)

=== TexGen 3.3.3 Released! ===
Version 3.3.3 has been released. It contains new features to save fibre and/or matrix as a voxel mesh in Abaqus format, to assign fibre properties to individual yarns and to adjust for small intersections in dry fibre volume mesh when outputting to Abaqus format. There are also some bug fixes.
A list of changes can be found [https://sourceforge.net/projects/texgen/files//texgen/3.3.3/ReleaseNotes3.3.3.txt/view here].

4 November 2010

=== TexGen 3.3.2 Released! ===
Version 3.3.2 has been released. It contains new features to save fibre models to Abaqus output, render fibre volume mesh and render interference depth. There are also some bug fixes, in particular a couple to get the GUI working in the Linux version.
A list of changes can be found [https://sourceforge.net/projects/texgen/files/texgen/3.3.2/Release%20notes3-3-2.txt/view here].

15 June 2010

===TexGen 3.3.1 Released! ===

Version 3.3.1 has been released (currently only Windows versions). It contains a couple of bug fixes and an option to switch output of messages on and off. A list of changes can be found [https://sourceforge.net/projects/texgen/files/texgen/3.3.1/Release%20notes3-3-1.txt/view here].

17 March 2010

=== TexGen 3.3.0 Released! ===

Version 3.3.0 has been released, it has various bug fixes most notably to the volume mesher and a few new algorithms dealing with geometry prediction based on mechanical behaviour of yarns. A list of changes can be found [https://sourceforge.net/project/shownotes.php?group_id=181000&release_id=591019 here].

16:52, 9 April 2008 (GMT)

=== TexGen 3.2.1 Released! ===

Version 3.2.1 has been released, this is mainly a bug fix release however there are a few new features. A list of changes can be found [http://sourceforge.net/project/shownotes.php?release_id=553663&group_id=181000 here].

04:12, 13 November 2007 (PST)

Documentation

2011-09-27T11:48:48Z

WikiSysop:

MediaWiki:Sidebar

2011-03-18T13:36:16Z

WikiSysop:

Scripting Examples

2008-05-15T09:02:12Z

WikiSysop:

This page contains a number of example scripts which show off some of the more advanced classes used to achieve specific tasks within TexGen. This functionality is not ''yet'' accessible from the graphical user interface.

=== Geometry Solver ===

The theory behind the geometry solver is described in a paper submitted to "The First World Conference on 3D Fabrics and Their Applications" held in Manchester on the 10-11th of April 2008 titled "Prediction of textile geometry using strain energy minimisation". A longer more detailed version of this will shortly be submitted as a journal paper.

<pre>
from TexGen.Core import *

# Read in a textile
ReadFromXML('800s4.tg3')
Textile = GetTextile()

# Create an instance of the geometry solver
Solver = CGeometrySolver()

# Set some parameters
Solver.SetContactStiffness(1e6)
Solver.SetDisabledStiffness(1e-6)
Solver.SetSeed(1.0)
# Create the system of equations to be solved
Solver.CreateSystem(Textile)
# Solve the system
Solver.SolveSystem()
# Save the result to a VTK file for viewing purposes
Solver.SaveToVTK("GeomSolve")
# Deform the textile
Solver.DeformTextile()
# Save the result back to a TG3 file
SaveToXML('Def-800s4.tg3')
</pre>

=== ABAQUS Dry Fabric Simulation ===

This code consists of running ABAQUS dry fabric simulations from TexGen geometrical models and using the results to modify that model. The basic procedure is outlined below:

* TexGen meshes the yarns using a combination of Hexahedral and Wedge elements.
* TexGen generates an ABAQUS input file which contains the mesh, element orientations, element volume fractions, material definitions, contact surfaces and definitions, compression plates, periodic boundary conditions and loading steps. Some of this information cannot be determined automatically by TexGen, in these cases they must be specified by the user. These are material definitions, loading steps and initial gap between compression plates if they are to be included.
* TexGen launches ABAQUS feeding it the input file generated and waits for the process to terminate before continuing. In the case where the simulation failed for an unknown reason an error message is printed and it is up to the user to determine what went wrong.
* If the simulation succeeded TexGen parses the ABAQUS .dat file to obtain the nodal displacements and .inp file to obtain element connectivity. Using this information, the yarn path and cross-sections of the TexGen model are deformed by the predicted displacement field.

The theory behind this will be described in more depth in a journal paper. Until then the following short example script shows how to use this:

<pre>
from TexGen.Abaqus import *

# Define a linear transformation
tension = CLinearTransformation()
# Add a scale in the X direction
tension.Scale(1.1)

# Create an instance of the TextileDeformerAbaqus class
deformer = TextileDeformerAbaqus()
# Add the tensile deformation step
deformer.AddDeformationStep(tension)

# Read in a TexGen model
ReadFromXML('pweave.tg3')
textile = GetTextile()

# This is where all the work is done, note this may take a long time to run
deformer.DeformTextile(textile)

# Save the result back to a new TexGen model
SaveToXML('pweave-tensioned.tg3')
</pre>

Scripting Guide

2008-05-15T09:00:37Z

WikiSysop:

Scripting Examples

2008-05-15T08:59:55Z

WikiSysop:

This page contains a number of example scripts which show off some of the more advanced classes used to achieve specific tasks within TexGen.

=== Geometry Solver ===

The theory behind the geometry solver is described in a paper submitted to "The First World Conference on 3D Fabrics and Their Applications" held in Manchester on the 10-11th of April 2008 titled "Prediction of textile geometry using strain energy minimisation". A longer more detailed version of this will shortly be submitted as a journal paper.

<pre>
from TexGen.Core import *

# Read in a textile
ReadFromXML('800s4.tg3')
Textile = GetTextile()

# Create an instance of the geometry solver
Solver = CGeometrySolver()

# Set some parameters
Solver.SetContactStiffness(1e6)
Solver.SetDisabledStiffness(1e-6)
Solver.SetSeed(1.0)
# Create the system of equations to be solved
Solver.CreateSystem(Textile)
# Solve the system
Solver.SolveSystem()
# Save the result to a VTK file for viewing purposes
Solver.SaveToVTK("GeomSolve")
# Deform the textile
Solver.DeformTextile()
# Save the result back to a TG3 file
SaveToXML('Def-800s4.tg3')
</pre>

=== ABAQUS Dry Fabric Simulation ===

This code consists of running ABAQUS dry fabric simulations from TexGen geometrical models and using the results to modify that model. The basic procedure is outlined below:

* TexGen meshes the yarns using a combination of Hexahedral and Wedge elements.
* TexGen generates an ABAQUS input file which contains the mesh, element orientations, element volume fractions, material definitions, contact surfaces and definitions, compression plates, periodic boundary conditions and loading steps. Some of this information cannot be determined automatically by TexGen, in these cases they must be specified by the user. These are material definitions, loading steps and initial gap between compression plates if they are to be included.
* TexGen launches ABAQUS feeding it the input file generated and waits for the process to terminate before continuing. In the case where the simulation failed for an unknown reason an error message is printed and it is up to the user to determine what went wrong.
* If the simulation succeeded TexGen parses the ABAQUS .dat file to obtain the nodal displacements and .inp file to obtain element connectivity. Using this information, the yarn path and cross-sections of the TexGen model are deformed by the predicted displacement field.

The theory behind this will be described in more depth in a journal paper. Until then the following short example script shows how to use this:

<pre>
from TexGen.Abaqus import *

# Define a linear transformation
tension = CLinearTransformation()
# Add a scale in the X direction
tension.Scale(1.1)

# Create an instance of the TextileDeformerAbaqus class
deformer = TextileDeformerAbaqus()
# Add the tensile deformation step
deformer.AddDeformationStep(tension)

# Read in a TexGen model
ReadFromXML('pweave.tg3')
textile = GetTextile()

# This is where all the work is done, note this may take a long time to run
deformer.DeformTextile(textile)

# Save the result back to a new TexGen model
SaveToXML('pweave-tensioned.tg3')
</pre>

Scripting Examples

2008-05-15T08:48:36Z

WikiSysop: /* Geometry Solver */

Scripting Examples

2008-05-14T15:53:03Z

WikiSysop:

Scripting Export Mesh

2008-05-14T11:36:23Z

WikiSysop: /* Getting started */

==Export a mesh==
In the [[Scripting Create Models]] section you learnt how to create TexGen models from Python scripts. In this tutorial I will explain how to get a volume mesh of the textile and save it to an arbitrary file format. This is a fairly common task but unfortunately one that must often be repeated due to the fact that there is very little standardisation on the file format for meshes. Each software package uses its own mesh file format and so we must learn to read and write to these different formats. Fortunately the Python language is ideal for performing these tasks with relative ease.

==Standalone scripts==
I am going to diverge a bit from this tutorial to talk about standalone scripts. In the previous guide it was assumed that the scripts you were writing would be run from within TexGen. However in some situations you may find it useful to simply run the scripts on their own from the command line without loading up the graphical user interface. In order to do this you must have installed [http://www.python.org/ Python] and installed the non-bundle version of TexGen (see [[Windows Installation]] for more details). To run your script you can then type the following from the command line:

python myscript.py

However before your scripts will work on their own, you must import the TexGen modules at the start of your script. In order to do that simply add the following line to the top of your script:

from TexGen.Core import *

Note that by adding this line does not prevent you from running your scripts through the GUI as well.

==Getting started==

I'm going to assume you already have a textile model you want to get a mesh of and have saved it to a .tg3 file named "textile.tg3". So the first step is to load this model so that we can go about extracting a mesh from it:
<pre>
from TexGen.Core import *
# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()
</pre>
The variable <code>textile</code> now contains an instance of the [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_textile.html CTextile] class representing the textile model. Let's now extract a mesh for this textile, fortunately TexGen has some built-in functionality to do this:

<pre>
# Create a mesh instance
mesh = CMesh()
# Add the volume of the textile to the mesh and trim the mesh to the domain
textile.AddVolumeToMesh(mesh, True)
</pre>

We declare <code>mesh</code> to be an instance of [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] and then use it to store a volume mesh of the textile. So with just a few lines of code we now have a volume mesh of the textile stored in memory. Note that this is just a mesh of the yarns, the volume between the yarns (i.e. the matrix volume) is not meshed. If you wanted to get a mesh of the yarns and matrix together you need to use the <code>CMesher</code> class instead, like this:

<pre>
# Create an instance of the mesher class
mesher = CMesher()
# Create the mesh
mesher.CreateMesh(textile)
# Get the mesh
mesh = mesher.GetMesh()
</pre>

This was a bit of a divergence from the tutorial, don't put this in your script unless you specifically wanted a mesh of the matrix as well. If you do use this, please be aware that it will generate a tetrahedral mesh and the code below will need to be extended to accommodate these elements.

The problem we are now faced with is how do we transfer this mesh from memory to the hard disk in the file format that we want so that it can be understood by our software of choice? Read on to find out.

==Defining the file format==

In this example I will be showing you how to save to the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format]. I have chosen this file format because it is simple and well documented. Unfortunately, in a lot of cases, file formats are poorly documented (if at all) and are complex due to poor design.

Note that TexGen already has a function to export to the VTK XML file format along with a number of other common file formats, and can be called in a single line of code like so: <code>mesh.SaveToVTK("mesh.vtu")</code>. But in this tutorial I want to explain how to actually write the data out line by line so that you can hopefully translate that to any other file format of your choice.

==Writing the data to file==

Now that we have decided what format the data will be written in, let's get down to actually writing it. First we will open a file for writing:
file = open("mesh.vtk", "w")
See the [http://docs.python.org/tut/node9.html#SECTION009200000000000000000 Python tutorial section 7.2] for more details on writing to files in Python. Next we need to write the header:
<pre>
# Write the header
file.write("# vtk DataFile Version 2.0\n")
file.write("Textile mesh data\n")
file.write("ASCII\n")
file.write("DATASET UNSTRUCTURED_GRID\n")
</pre>
As defined in the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format documentation]. A mesh consists of a number of nodes (or points) and a number of elements (or cells). Each corner of an element is defined as an index into the list of points. An index of 0 refers to the first point, index 1 refers to the second and so on. So first of all we shall write the list of points to the file in the correct format:
<pre>
# Write the points
file.write("POINTS %d float\n" % mesh.GetNumNodes())
for node in mesh.GetNodes():
file.write("%g %g %g\n" % (node.x, node.y, node.z))
</pre>
The % operator is known as the string formatting or interpolation operator. It is important to understand how this works when writing data to files in ASCII format. Read the [http://docs.python.org/tut/node9.html#SECTION009100000000000000000 Python tutorial section 7.1] and [http://docs.python.org/lib/typesseq-strings.html Python library reference 3.6.2] for more information on this.

At this point, if you run the script it should create a valid VTK file that you can load into the free [http://www.paraview.org/ ParaView] visualisation software. You may want to try this now to check that what you have done so far works correctly. Initially you will not see anything when loaded into ParaView because we have just defined points and nothing else. In order to visualise these points you must apply the Glyph filter. Assuming this works, let's continue and write the elements.

Defining the elements is a little more tricky because there are different types of elements. When meshing the yarns TexGen will use a mix of wedge and hexahedral elements, so we only need to deal with these element types. The [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] class stores a long list of indices for each element type. For example, a mesh containing 2 wedge elements and 3 hex elements would contain a list of 12 indices for the wedges and a list of 24 for the hex elements. The first thing to do is to define some variables to contain this data:
<pre>
wedgeIndices = list(mesh.GetIndices(CMesh.WEDGE))
hexIndices = list(mesh.GetIndices(CMesh.HEX))
numWedges = len(wedgeIndices)/6
numHexes = len(hexIndices)/8
</pre>
Next we actually write the data to the file similarly to the way the points were written:
<pre>
file.write("CELLS %d %d\n" % (numWedges+numHexes, numWedges*7+numHexes*9))
for i in range(numWedges):
file.write("6 %d %d %d %d %d %d\n" % tuple(wedgeIndices[i*6:(i+1)*6]))
for i in range(numHexes):
file.write("8 %d %d %d %d %d %d %d %d\n" % tuple(hexIndices[i*8:(i+1)*8]))
</pre>
Here I have made use of slicing (wedgeIndices'''['''i*6''':'''(i+1)*6''']''') to reduce the amount of code necessary to output the data. See the [http://docs.python.org/tut/node5.html#SECTION005140000000000000000 Python tutorial section 3.1.4] for information about how slicing works.

And finally we need to output the type of each of these elements:
<pre>
file.write("CELL_TYPES %d\n" % (numWedges+numHexes))
for i in range(numWedges):
file.write("13\n")
for i in range(numHexes):
file.write("12\n")
</pre>
The VTK file format defines wedges to be of element type 13 and hexes to be of element type 12.

That's it, you should now have a script which reads a TexGen tg3 file, extracts a mesh from it and writes the contents to a file in the VTK legacy file format. Your Python script should look like this:

<pre>
from TexGen.Core import *

# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()

# Create a mesh instance
mesh = CMesh()
# Add the volume of the textile to the mesh
textile.AddVolumeToMesh(mesh, True)

file = open("mesh.vtk", "w")

# Write the header
file.write("# vtk DataFile Version 2.0\n")
file.write("Textile mesh data\n")
file.write("ASCII\n")
file.write("DATASET UNSTRUCTURED_GRID\n")

# Write the points
file.write("POINTS %d float\n" % mesh.GetNumNodes())
for node in mesh.GetNodes():
file.write("%g %g %g\n" % (node.x, node.y, node.z))

# Get element information from the mesh
wedgeIndices = list(mesh.GetIndices(CMesh.WEDGE))
hexIndices = list(mesh.GetIndices(CMesh.HEX))
numWedges = len(wedgeIndices)/6
numHexes = len(hexIndices)/8

# Write the element information
file.write("CELLS %d %d\n" % (numWedges+numHexes, numWedges*7+numHexes*9))
for i in range(numWedges):
file.write("6 %d %d %d %d %d %d\n" % tuple(wedgeIndices[i*6:(i+1)*6]))
for i in range(numHexes):
file.write("8 %d %d %d %d %d %d %d %d\n" % tuple(hexIndices[i*8:(i+1)*8]))

file.write("CELL_TYPES %d\n" % (numWedges+numHexes))
for i in range(numWedges):
file.write("13\n")
for i in range(numHexes):
file.write("12\n")
</pre>

==Verification==

The first thing to do now is to run the script from the command line like so:

python myscript.py

replacing <code>myscript.py</code> with the name of the script your created and ensuring you have a textile model named <code>textile.tg3</code> in the some folder as the script. If it ran successfully you should see a file named <code>mesh.vtk</code> being created. Load this up into [http://www.paraview.org/ ParaView] and you should see a mesh of your textile.

When writing your own scripts it is unlikely that they will work straight away (even for professional programmers), so it is a good idea to check the output of your script at each step with a text editor to ensure that it is writing exactly what you want. This will enable you to isolate bugs early on and one at a time rather than having to fix a long script containing numerous bugs. The [http://docs.python.org/tut/node5.html#SECTION005200000000000000000 print statement] is your friend when it comes to debugging, it can be used to print out values and verify that they are what you expect.

Scripting Export Mesh

2008-05-14T11:26:14Z

WikiSysop: /* Getting started */

==Export a mesh==
In the [[Scripting Create Models]] section you learnt how to create TexGen models from Python scripts. In this tutorial I will explain how to get a volume mesh of the textile and save it to an arbitrary file format. This is a fairly common task but unfortunately one that must often be repeated due to the fact that there is very little standardisation on the file format for meshes. Each software package uses its own mesh file format and so we must learn to read and write to these different formats. Fortunately the Python language is ideal for performing these tasks with relative ease.

==Standalone scripts==
I am going to diverge a bit from this tutorial to talk about standalone scripts. In the previous guide it was assumed that the scripts you were writing would be run from within TexGen. However in some situations you may find it useful to simply run the scripts on their own from the command line without loading up the graphical user interface. In order to do this you must have installed [http://www.python.org/ Python] and installed the non-bundle version of TexGen (see [[Windows Installation]] for more details). To run your script you can then type the following from the command line:

python myscript.py

However before your scripts will work on their own, you must import the TexGen modules at the start of your script. In order to do that simply add the following line to the top of your script:

from TexGen.Core import *

Note that by adding this line does not prevent you from running your scripts through the GUI as well.

==Getting started==

I'm going to assume you already have a textile model you want to get a mesh of and have saved it to a .tg3 file named "textile.tg3". So the first step is to load this model so that we can go about extracting a mesh from it:
<pre>
from TexGen.Core import *
# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()
</pre>
The variable <code>textile</code> now contains an instance of the [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_textile.html CTextile] class representing the textile model. Let's now extract a mesh for this textile, fortunately TexGen has some built-in functionality to do this:

<pre>
# Create a mesh instance
mesh = CMesh()
# Add the volume of the textile to the mesh and trim the mesh to the domain
textile.AddVolumeToMesh(mesh, True)
</pre>

We declare <code>mesh</code> to be an instance of [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] and then use it to store a volume mesh of the textile. So with just a few lines of code we now have a volume mesh of the textile stored in memory. Note that this is just a mesh of the yarns, the volume between the yarns (i.e. the matrix volume) is not meshed. If you wanted to get a mesh of the yarns and matrix together you need to use the <code>CMesher</code> class instead, like this:

<pre>
# Create an instance of the mesher class
mesher = CMesher()
# Create the mesh
mesher.CreateMesh(textile)
# Get the mesh
mesh = mesher.GetMesh()
</pre>

This was a bit of a divergence from the tutorial, don't put this in your script unless you specifically wanted a mesh of the matrix as well. Please be aware that if you use this code, it will generate a tetrahedral mesh and so the code below will need to be extended to accommodate that.

The problem we are now faced with is how do we transfer this mesh from memory to the hard disk in the file format that we want so that it can be understood by our software of choice? Read on to find out.

==Defining the file format==

In this example I will be showing you how to save to the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format]. I have chosen this file format because it is simple and well documented. Unfortunately, in a lot of cases, file formats are poorly documented (if at all) and are complex due to poor design.

Note that TexGen already has a function to export to the VTK XML file format along with a number of other common file formats, and can be called in a single line of code like so: <code>mesh.SaveToVTK("mesh.vtu")</code>. But in this tutorial I want to explain how to actually write the data out line by line so that you can hopefully translate that to any other file format of your choice.

==Writing the data to file==

Now that we have decided what format the data will be written in, let's get down to actually writing it. First we will open a file for writing:
file = open("mesh.vtk", "w")
See the [http://docs.python.org/tut/node9.html#SECTION009200000000000000000 Python tutorial section 7.2] for more details on writing to files in Python. Next we need to write the header:
<pre>
# Write the header
file.write("# vtk DataFile Version 2.0\n")
file.write("Textile mesh data\n")
file.write("ASCII\n")
file.write("DATASET UNSTRUCTURED_GRID\n")
</pre>
As defined in the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format documentation]. A mesh consists of a number of nodes (or points) and a number of elements (or cells). Each corner of an element is defined as an index into the list of points. An index of 0 refers to the first point, index 1 refers to the second and so on. So first of all we shall write the list of points to the file in the correct format:
<pre>
# Write the points
file.write("POINTS %d float\n" % mesh.GetNumNodes())
for node in mesh.GetNodes():
file.write("%g %g %g\n" % (node.x, node.y, node.z))
</pre>
The % operator is known as the string formatting or interpolation operator. It is important to understand how this works when writing data to files in ASCII format. Read the [http://docs.python.org/tut/node9.html#SECTION009100000000000000000 Python tutorial section 7.1] and [http://docs.python.org/lib/typesseq-strings.html Python library reference 3.6.2] for more information on this.

At this point, if you run the script it should create a valid VTK file that you can load into the free [http://www.paraview.org/ ParaView] visualisation software. You may want to try this now to check that what you have done so far works correctly. Initially you will not see anything when loaded into ParaView because we have just defined points and nothing else. In order to visualise these points you must apply the Glyph filter. Assuming this works, let's continue and write the elements.

Defining the elements is a little more tricky because there are different types of elements. When meshing the yarns TexGen will use a mix of wedge and hexahedral elements, so we only need to deal with these element types. The [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] class stores a long list of indices for each element type. For example, a mesh containing 2 wedge elements and 3 hex elements would contain a list of 12 indices for the wedges and a list of 24 for the hex elements. The first thing to do is to define some variables to contain this data:
<pre>
wedgeIndices = list(mesh.GetIndices(CMesh.WEDGE))
hexIndices = list(mesh.GetIndices(CMesh.HEX))
numWedges = len(wedgeIndices)/6
numHexes = len(hexIndices)/8
</pre>
Next we actually write the data to the file similarly to the way the points were written:
<pre>
file.write("CELLS %d %d\n" % (numWedges+numHexes, numWedges*7+numHexes*9))
for i in range(numWedges):
file.write("6 %d %d %d %d %d %d\n" % tuple(wedgeIndices[i*6:(i+1)*6]))
for i in range(numHexes):
file.write("8 %d %d %d %d %d %d %d %d\n" % tuple(hexIndices[i*8:(i+1)*8]))
</pre>
Here I have made use of slicing (wedgeIndices'''['''i*6''':'''(i+1)*6''']''') to reduce the amount of code necessary to output the data. See the [http://docs.python.org/tut/node5.html#SECTION005140000000000000000 Python tutorial section 3.1.4] for information about how slicing works.

And finally we need to output the type of each of these elements:
<pre>
file.write("CELL_TYPES %d\n" % (numWedges+numHexes))
for i in range(numWedges):
file.write("13\n")
for i in range(numHexes):
file.write("12\n")
</pre>
The VTK file format defines wedges to be of element type 13 and hexes to be of element type 12.

That's it, you should now have a script which reads a TexGen tg3 file, extracts a mesh from it and writes the contents to a file in the VTK legacy file format. Your Python script should look like this:

<pre>
from TexGen.Core import *

# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()

# Create a mesh instance
mesh = CMesh()
# Add the volume of the textile to the mesh
textile.AddVolumeToMesh(mesh, True)

file = open("mesh.vtk", "w")

# Write the header
file.write("# vtk DataFile Version 2.0\n")
file.write("Textile mesh data\n")
file.write("ASCII\n")
file.write("DATASET UNSTRUCTURED_GRID\n")

# Write the points
file.write("POINTS %d float\n" % mesh.GetNumNodes())
for node in mesh.GetNodes():
file.write("%g %g %g\n" % (node.x, node.y, node.z))

# Get element information from the mesh
wedgeIndices = list(mesh.GetIndices(CMesh.WEDGE))
hexIndices = list(mesh.GetIndices(CMesh.HEX))
numWedges = len(wedgeIndices)/6
numHexes = len(hexIndices)/8

# Write the element information
file.write("CELLS %d %d\n" % (numWedges+numHexes, numWedges*7+numHexes*9))
for i in range(numWedges):
file.write("6 %d %d %d %d %d %d\n" % tuple(wedgeIndices[i*6:(i+1)*6]))
for i in range(numHexes):
file.write("8 %d %d %d %d %d %d %d %d\n" % tuple(hexIndices[i*8:(i+1)*8]))

file.write("CELL_TYPES %d\n" % (numWedges+numHexes))
for i in range(numWedges):
file.write("13\n")
for i in range(numHexes):
file.write("12\n")
</pre>

==Verification==

The first thing to do now is to run the script from the command line like so:

python myscript.py

replacing <code>myscript.py</code> with the name of the script your created and ensuring you have a textile model named <code>textile.tg3</code> in the some folder as the script. If it ran successfully you should see a file named <code>mesh.vtk</code> being created. Load this up into [http://www.paraview.org/ ParaView] and you should see a mesh of your textile.

When writing your own scripts it is unlikely that they will work straight away (even for professional programmers), so it is a good idea to check the output of your script at each step with a text editor to ensure that it is writing exactly what you want. This will enable you to isolate bugs early on and one at a time rather than having to fix a long script containing numerous bugs. The [http://docs.python.org/tut/node5.html#SECTION005200000000000000000 print statement] is your friend when it comes to debugging, it can be used to print out values and verify that they are what you expect.

Compiling from Source

2008-05-14T10:46:25Z

WikiSysop: /* Checkout TexGen source code from subversion server */

In order to compile TexGen and '''all''' of its modules, the following software is required:

The following programs are needed to build TexGen:
* [http://www.cmake.org/ CMake]
* [http://www.swig.org/ SWIG]

The following libraries are needed to link to TexGen:
* [http://www.vtk.org/ VTK]
* [http://www.wxwidgets.org/ wxWidgets]
* [http://www.opencascade.org/ OpenCascade]
* [http://www.python.org/ Python]

However to perform a minimum build of TexGen with none of the additional modules you only require CMake and a C++ compiler. It is recommended to begin with a minimum build, once that is working try adding modules one at a time. A list of modules along with dependencies is shown below:

* Python interface: Python, SWIG
* Renderer: VTK
* Export: OpenCascade
* GUI: wxWidgets, Renderer, Python interface
* Unit tests: CPPUnit

A graphical representation of the modules and their dependencies can also be found in the [http://texgen.sourceforge.net/api/ TexGen API].

If you want to get the source code from the Subversion repository you will need to install [http://subversion.tigris.org/ Subversion] by following the instructions below. Note that this is the very latest development source and so may it contain some bugs and unfinished features. However it is very easy to keep up to date with the latest version of TexGen using this method and will allow you to keep any modifications you have made to the source when updating. If you find a bug or implement new features that may be usefull to the rest of the community they can also be submited as patch and incorporated into TexGen following review.

Alternatively the stable source code can be downloaded as a [http://sourceforge.net/project/showfiles.php?group_id=181000 tarball]. Download the latest file release named ''texgen-3.x.x.tar.gz''.

== Windows (Microsoft Visual Studio C++, recommended method) ==
=== Prerequisites ===
It is assumed that Microsoft Visual Studio is already installed. If it isn't and you plan to use it, then install it. It may be possible to use the free [http://www.microsoft.com/express/ Visual Studio Express]; if anyone tries this and finds out one way or the other, please post the information either here or in the [http://texgen.sourceforge.net/phpBB2/index.php forum]. Brief instructions on how to install the various 3rd party libraries under windows are given below. Note that you do not need to install all of these in order to perform the minimal build. Only CMake is absolutely required.

==== CMake ====

[http://www.cmake.org/HTML/Download.html Download CMake] and install, selecting 'Add CMake to the system PATH for all users' (select current user if this is not permissible on your system).

==== TortoiseSVN ====

[http://tortoisesvn.net/downloads Download TortoiseSVN] and install it.

==== SWIG ====

[http://www.swig.org/ Download] the latest release of the windows .zip files and extract to a suitable location (e.g. c:\Program Files\swigwin-1.3.31).

==== Python ====

[http://www.python.org/ Download Python] and install.

==== OpenCascade ====

[http://www.opencascade.org/getocc/download/ Download OpenCascade] and install; this extracts the files to a directory. If the installation doesn't start automatically, run the 'install.bat' file located the directory where the files where extracted (read 'readme.htm' file in the same directory for more information). Choose 'complete installation' and tick the box to set the environment variables.

==== VTK ====

[http://www.vtk.org/get-software.php Download] the latest source files and extract them. Follow the instructions in 'README.html' found in the extracted directory to compile VTK using CMake. The following CMake settings should be set:

BUILD_EXAMPLES OFF
BUILD_SHARED_LIBS OFF
VTK_USE_MPEG2_ENCODER OFF
VTK_USE_PARALLEL OFF
VTK_USE_RENDERING ON
VTK_WRAP_JAVA OFF
VTK_WRAP_PYTHON OFF
VTK_WRAP_TCL OFF

You may be able to get things working with different settings, however these are the settings I use and are known to work.

==== wxWidgets ====

[http://www.wxwidgets.org/downloads/ Download] and install the windows version of wxWidgets (wxMSW). It is then necessary to compile wxWidgets from source, detailed instructions on how to do this can be found in 'install.txt' located in the 'docs\msw' subfolder. The main steps are to open 'wx.dsw' with MSVC located in the 'build\msw' subfolder and compile both Release and Debug configurations (The configuration can be selected from the drop down box on the main toolbar in Visual Studio. Universal, Unicode and DLL versions need not be compiled).

=== Checkout TexGen source code from subversion server ===
Create a directory where you would like to store the TexGen source code in Windows Explorer. Right click on this folder and select "SVN Checkout..." from the context menu that appears. In the dialog box which follows, enter "https://texgen.svn.sourceforge.net/svnroot/texgen/TexGen/trunk/" in the URL field. The Checkout directory field should have been filled in automatically. Click on OK to start downloading the TexGen source code. In future the latest version of the source code can be obtained simply by right clicking on the folder and selecting "SVN Update" from the context menu.

=== Configuring the build system with CMake ===
Run CMake from its shortcut on the Start menu. There are some general instructions on using CMake on the [http://www.cmake.org/HTML/RunningCMake.html CMake website] which are worth reading. You will need to fill in the source code location, this should point to where you checkout out the latest TexGen SVN code or where you extracted the source code from the zip file. Also set where to place the binary files once they are compiled, this can be the same as the source directory, a subdirectory within the source directory or any other location.

Once that is entered click 'Configure' and choose the Visual Studio version which you have installed and click ok. You will initially get a number of error messages such as:

CMake Error: Swig was not found on the system. Please specify the location of Swig. (click OK)
CMake Error: Error in configuration process, project files may be invalid. (click OK)

This is normal, in order to get rid of the errors you will need to tell CMake where the various libraries you have installed can be found. This is done in the Cache Values sections.

It is recommended to begin with a minimal build, this is achieved by setting the cache values as follows:

BUILD_CASCADE_EXPORT OFF
BUILD_DOCUMENTATION OFF
BUILD_EXAMPLES OFF
BUILD_GUI OFF
BUILD_PYTHON_INTERFACE OFF
BUILD_RENDERER OFF
BUILD_SHARED ON
BUILD_UNIT_TESTS OFF

Once these are set press configure again and you shouldn't have any more errors/warnings. Press 'OK' to generate the MSVC solution and project files. Configuring the various optional modules is explained in [[#Configuring optional modules]].

=== Configuring optional modules ===

Once the minimal build is working you may want to switch on the optional modules. To do this open up CMake again and switch the modules you want to ON in the Cache Values then click Configure. You will most likely see some errors telling you it is unable to automatically find certain directories. You will need to specify these manually. An explanation of the different locations is listed below:

'''PYTHON_SITEPACKAGES_DIR''' - This should be the folder where the TexGen python modules will be placed. Usually located in 'C:\Python25\Lib\site-packages', but this will depend on the version of Python installed and where you decided to install it.

'''SWIG_DIR''' - This is the location where you extracted the SWIG executable. e.g. 'C:\Program Files\swigwin-1.3.35'.

'''SWIG_EXECUTABLE''' - Same as root directory followed by 'swig.exe'

'''wxWidgets_ROOT_DIR''' - Location where you install wxWidgets. e.g. 'C:/wxWidgets-2.8.7'.

'''wxWidgets_LIB_DIR''' - Location where the wxWidgets libraries were compiled to, should be the same as the root directory followed by 'lib\vc_lib'.

'''OPENCASCADE_INCLUDE_DIR''' - Location where the OpenCascade header files are located. e.g. 'C:/OpenCASCADE6.1.0/ros/inc'.

'''OPENCASCADE_LIBRARY_DIR''' - Location where the OpenCascade libraries are located. e.g. 'C:/OpenCASCADE6.1.0/ros/win32/lib'.

'''OPENCASCADE_DEBUG_LIBRARY_DIR''' - Location where the OpenCascade debug libraries are located. e.g. 'C:/OpenCASCADE6.1.0/ros/win32/libd'.

'''VTK_DIR''' - Location of the VTK binary directory (note: not the source directory).

After setting the directories manually, click on configure again. You may need to go through several iterations of changing parameters then pressing configure. Once you have finished changing parameters and have successfully pressed configure without error messages you can press the OK button to generate the build. Note: you can always come back to this at a later time to make changes.

=== Compiling ===

Find 'TexGen.sln' which should be located in the directory where you told CMake to output the binary files to and open it with Microsoft Visual Studio.

Set the configuration to 'Release' and build the solution. Hopefully the project will have been compiled without errors.

If you want to compile and execute the Graphical User Interface you will need to install it, you will not be able to execute it directly from the build directory. This is done by right click on the 'INSTALL' project in the Solution Explorer and selecting Build. This will copy the Python modules into the Python site-packages directory so that they can be imported into scripts, and it will copy the executable along with other necessary files into 'C:\Program Files\TexGen\' by default (this can be changed with the CMAKE_INSTALL_PREFIX cache value in CMake). TexGenGUI.exe should then be run from the installed location, if you attempt to run it directly from where it was compiled you will get some errors on launch.

=== Building the documentation ===

To build the documentation, [http://www.stack.nl/~dimitri/doxygen/download.html Doxygen] is required. Open a command prompt in the 'Docs' subdirectory of the source code and run 'doxygen'. If the doxygen directory is not in your path, you must add it, or give the full path on the command line.

=== Integrating TexGen with ABAQUS ===

If you are using ABAQUS and wish to use TexGen Python scripting from within the ABAQUS/CAE environment, there are a few extra steps to perform. This is because ABAQUS comes packaged with its own version of Python, so any modules added to your standalone python installation will not be accessible by ABAQUS. You must compile the TexGen Python modules with the same version of Python as ABAQUS uses. The following table shows which version of Python is used in specific ABAQUS versions:

{| class="wikitable" style="text-align:center" border="1"
! ABAQUS Version !! Python Version
|-
| 6.6-1 || 2.3.3
|-
| 6.7-1 || 2.4.3
|}

If your version of ABAQUS is not listed in the table above you can type 'abaqus python -V' to check what version of Python is used (then please edit this page to update the table). You can obtain specific versions of Python from http://www.python.org/download/releases/x.y.z/ where x.y.z represents the version number.

Additionally you will need to place the TexGen python modules inside ABAQUS' version of python. There are a few ways to accomplish this, the easiest is perhaps to set the CMake cache variable 'PYTHON_SITEPACKAGES_DIR' point to the ABAQUS' python directory, e.g.:

PYTHON_SITEPACKAGES_DIR C:\Abaqus\6.7-1\Python\Lib\

Then when you build the INSTALL project in MSVC++ it will automatically copy the TexGen python modules to the ABAQUS' Python. Alternatively you can simply copy the files manually or modify Python's search path to include the TexGen python modules, e.g. In python:

import sys
sys.path.append('C:/Python24/Lib/site-packages/')

=== Troubleshooting ===

'''Q:''' I get the following error when compiling:
fatal error LNK1104: cannot open file 'python25_d.lib'

'''A:''' The windows installation of Python doesn't come with the debug library ('python25_d.lib', the _d part means debug). You should be able to compile in release mode however. If you really want to compile in debug mode you will need to compile Python from source and link to that. Or you can try to link to the release library 'python25.lib' instead, easiest way to do that is to copy 'python25.lib' to 'python25_d.lib' but this may cause problems during linking or execution.

'''Q:''' I get the following error when compiling:
fatal error C1083: Cannot open include file: 'wx/wxprec.h': No such file or directory

'''A:''' Make sure that you have compiled wxWidgets and that the wxWidgets_XXX cache variables are set correctly in CMake.

'''Q:''' I do not have a 'libd' folder in 'ros/win32' for OpenCASCADE.

'''A:''' If you do not compile OpenCASCADE yourself then this folder does not exist. However it can be ignored if you are only interested in building the release version of TexGen. If you really want to compile the debug version please refer to the OpenCASCADE documentation.

'''Q:''' Why do I get the error message: "The parameter is incorrect." when launching TexGenGUI.exe?

'''A:''' This appears to only happen when compiling TexGen with MSVC 2005 or later. I have still not been able to track down the cause of the error as it is particularly cryptic and it will not even allow me to debug the program. For now you must compile with MSVC 2003 or avoid using the GUI until this issue can be resolved.

== Windows (Cygwin and gcc, alternate method) ==
A limited build (without graphics) can be made under cygwin, this is a UNIX emulation environment available at [http://www.cygwin.com www.cygwin.com].
This can exist peacefully next to the native windows version.
Cygwin creates a unix-style file system within your windows installation. If you choose c:/cygwin as your install directory, your HOME will be at c:/cygwin/home/<username>/.

=== Download cygwin and install packages ===
Install gcc, g++, wget, make and cmake using the setup.exe program from the cygwin website.
For the mesh generator and python interface to work we currently need VTK and swig.

This downloads and installs swig from source (when starting the cygwin shell you can paste this into the command line, otherwise write it to a file and run it with sh).
mkdir progs
cd progs
SWIG=swig-1.3.31
wget -nc http://kent.dl.sourceforge.net/sourceforge/swig/$SWIG.tar.gz
tar xzvf $SWIG.tar.gz
cd $SWIG
./configure
make
make install

This downloads and installs VTK from source, in the ccmake stage, use the cmake graphical commands to get a working install.
VTK=vtk-5.0.3
wget -nc http://www.vtk.org/files/release/5.0/$VTK.tar.gz
tar xzvf $VTK.tar.gz
mkdir vtkbin
cd vtkbin
ccmake ../VTK
make
make install

=== Install TexGen from source ===
Now we can proceed to install texgen, as an example we'll work in ~/temp/texgen
cd ~; mkdir temp; cd temp; mkdir texgen; cd texgen
svn checkout https://texgen.svn.sourceforge.net/svnroot/texgen/TexGen/trunk/ TexGen
cd .. ; mkdir tbin; cd tbin
ccmake ../texgen
make
make install

This should result in a working texgen install in ~/temp/texgen/tbin.

== Unix ==
=== Notes ===
If you are installing to a system where you don't have root access (i.e. this computer does not belong to you) you won't be able to install the software using the default configure script. This is because by default software is installed to the /usr/local directory. If you are not a systems administrator then you will quite rightly not have write access to this folder. All is not lost! You can still install software into your home directory. In order to do this you should always call the configure script with the following parameter: --prefix=$HOME. This goes for all the software to be installed below. All executables will then be placed in ~/bin, libraries in ~/lib, includes in ~/include, etc...

In the guide below the parameter is included in italic. If you do in fact have root access then it is recommended to omit this parameter and install to the default directory so that other users will also have access to the software.

=== Get TexGen from Subversion repository ===

==== Install Subversion ====
[http://subversion.tigris.org/servlets/ProjectDocumentList?collapseFolder=260&folderID=260 Download Subversion] and unpack.
Open a shell in extracted folder and type:
./configure --with-ssl ''--prefix=$HOME''
make
make install

Notes:
* You will need to install Subversion with SSL support since TexGen is hosted on sourceforge which uses SSL. If you don't configure with the --with-ssl flag you will get an error when trying to checkout TexGen in the next step.
* If you have trouble installing the latest version of Subversion, try installing version 1.3 as it does not require a seperate dependencies package.

==== Checkout ====
Open a shell in folder you wish to place TexGen (e.g. ~/):
svn checkout https://texgen.svn.sourceforge.net/svnroot/texgen/TexGen/trunk/ TexGen

Notes:
* The first parameter tells SVN to get the files for the first time
* The second parameter is the location of the TexGen svn repository
* The final parameter is the subfolder to put the files in

==== Update ====
The checkout command only needs to performed once. SVN keeps track of where the code was originally obtained and can update to the latest version without having to re-specify the location. In order to do that open a shell in the folder where TexGen was originally checkout (e.g. ~/TexGen) and type:
svn update
or if you are in a hurry you can type the shorter version:
svn up

=== Compile source ===

==== Install CMake ====

[http://www.cmake.org/HTML/Download.html Download CMake] and unpack.
Open a shell in extracted folder and type:
./configure ''--prefix=$HOME''
make
make install

==== Compile TexGen core ====
Open a shell in the folder with the TexGen source code (e.g. ~/TexGen):
mkdir bin
cd bin
ccmake ../
Press 'c' to configure. When a warning pops up telling you it can't find such and such a file press 'e' to close it. You will now need to specify which components of TexGen to build and where their dependencies can be found. Use the up and down arrows to move the caret and press enter to modify options. Do this to set BUILD_GUI, BUILD_PYTHON_INTERFACE and BUILD_RENDERER to OFF. You are basically telling CMake not to attempt to build these components, which means that you won't need to have installed their dependencies.

Similarly to the --prefix=$HOME parameter to the configure script, you can tell CMake to install TexGen to your home directory by changing CMAKE_INSTALL_PREFIX to ~/. Note that it won't actually install anything until you get type make install.

Now press 'c' again to update the changes.

Hopefully now that all the additional modules have been switched off no errors will be shown. Press 'g' to generate the makefiles and exit. At the shell type:
make
make install

Note that at this point you have only built and installed the TexGen Core library which doesn't actually do anything on its own. If you plan to incorporate TexGen into your own C++ program then this is enough, however if you would like to interface with TexGen from a Python script or Graphical User Interface then follow the steps below.

=== Compiling optional modules ===
==== Python interface ====
[http://www.python.org/download/ Download Python] and unpack.
Open a shell in the extracted folder and type:
./configure ''--prefix=$HOME''
make
make install

[http://www.swig.org/download.html Download SWIG] and unpack.
Open a shell in the extracted folder and type:
./configure ''--prefix=$HOME''
make
make install

Open a shell in the folder where you called ccmake from for the first time (e.g. ~/TexGen/bin):
ccmake ../

Use the up and down arrows to reach BUILD_PYTHON_INTERFACE and press Enter to set it to ON. Then press 'c' to configure. You will probably get a warning saying you need to specify the location of SWIG and/or Python, press 'e' to close it.

Set the PYTHON_INCLUDE_PATH, PYTHON_LIBRARY, PYTHON_SITEPACKAGES_DIR, SWIG_DIR and SWIG_EXECUTABLE parameters correctly where necessary. If you have installed packages to your home directory then they should look something like this:

PYTHON_INCLUDE_PATH: ~/include/python2.5
PYTHON_LIBRARY: ~/lib/python2.5/config/libpython2.5.a
PYTHON_SITEPACKAGES_DIR: ~/lib/python2.5/site-packages
SWIG_DIR: ~/bin
SWIG_EXECUTABLE: ~/bin/swig

Once that is done press 'c' again. You may need perform this process over several iterations. When everything is set correctly press 'g' to generate the makefiles.

At the shell type:
make
make install

Assuming the build completed without errors you should now be able to access TexGen functions from within Python. In order to check everything worked as planned open Python in interactive mode by typing:
python

Then from within Python type:
from TexGen.Core import *
CTexGen.GetInstance().GetVersion()

This should display the version of TexGen installed.

=== Troubleshooting ===

'''Q:''' I get the following error when linking _Core.so:
libpython2.5.a(abstract.o): relocation R_X86_64_32 against `a local symbol'
can not be used when making a shared object; recompile with -fPIC

'''A:''' Try removing libpython2.5.a from the libraries to link to by setting PYTHON_LIBRARY to a bogus path, e.g.:

PYTHON_LIBRARY: ~/

By doing so you may receive a warning similar to this:
Warning: Ignoring path found in link libraries for target: _Core, path is:
/home/username. Expected a library name or a full path to a library name.
This warning may be ignored.

Compiling from Source

2008-05-13T16:30:29Z

WikiSysop: /* Troubleshooting */

In order to compile TexGen and '''all''' of its modules, the following software is required:

The following programs are needed to build TexGen:
* [http://www.cmake.org/ CMake]
* [http://www.swig.org/ SWIG]

The following libraries are needed to link to TexGen:
* [http://www.vtk.org/ VTK]
* [http://www.wxwidgets.org/ wxWidgets]
* [http://www.opencascade.org/ OpenCascade]
* [http://www.python.org/ Python]

However to perform a minimum build of TexGen with none of the additional modules you only require CMake and a C++ compiler. It is recommended to begin with a minimum build, once that is working try adding modules one at a time. A list of modules along with dependencies is shown below:

* Python interface: Python, SWIG
* Renderer: VTK
* Export: OpenCascade
* GUI: wxWidgets, Renderer, Python interface
* Unit tests: CPPUnit

A graphical representation of the modules and their dependencies can also be found in the [http://texgen.sourceforge.net/api/ TexGen API].

If you want to get the source code from the Subversion repository you will need to install [http://subversion.tigris.org/ Subversion] by following the instructions below. Note that this is the very latest development source and so may it contain some bugs and unfinished features. However it is very easy to keep up to date with the latest version of TexGen using this method and will allow you to keep any modifications you have made to the source when updating. If you find a bug or implement new features that may be usefull to the rest of the community they can also be submited as patch and incorporated into TexGen following review.

Alternatively the stable source code can be downloaded as a [http://sourceforge.net/project/showfiles.php?group_id=181000 tarball]. Download the latest file release named ''texgen-3.x.x.tar.gz''.

== Windows (Microsoft Visual Studio C++, recommended method) ==
=== Prerequisites ===
It is assumed that Microsoft Visual Studio is already installed. If it isn't and you plan to use it, then install it. It may be possible to use the free [http://www.microsoft.com/express/ Visual Studio Express]; if anyone tries this and finds out one way or the other, please post the information either here or in the [http://texgen.sourceforge.net/phpBB2/index.php forum]. Brief instructions on how to install the various 3rd party libraries under windows are given below. Note that you do not need to install all of these in order to perform the minimal build. Only CMake is absolutely required.

==== CMake ====

[http://www.cmake.org/HTML/Download.html Download CMake] and install, selecting 'Add CMake to the system PATH for all users' (select current user if this is not permissible on your system).

==== TortoiseSVN ====

[http://tortoisesvn.net/downloads Download TortoiseSVN] and install it.

==== SWIG ====

[http://www.swig.org/ Download] the latest release of the windows .zip files and extract to a suitable location (e.g. c:\Program Files\swigwin-1.3.31).

==== Python ====

[http://www.python.org/ Download Python] and install.

==== OpenCascade ====

[http://www.opencascade.org/getocc/download/ Download OpenCascade] and install; this extracts the files to a directory. If the installation doesn't start automatically, run the 'install.bat' file located the directory where the files where extracted (read 'readme.htm' file in the same directory for more information). Choose 'complete installation' and tick the box to set the environment variables.

==== VTK ====

[http://www.vtk.org/get-software.php Download] the latest source files and extract them. Follow the instructions in 'README.html' found in the extracted directory to compile VTK using CMake. The following CMake settings should be set:

BUILD_EXAMPLES OFF
BUILD_SHARED_LIBS OFF
VTK_USE_MPEG2_ENCODER OFF
VTK_USE_PARALLEL OFF
VTK_USE_RENDERING ON
VTK_WRAP_JAVA OFF
VTK_WRAP_PYTHON OFF
VTK_WRAP_TCL OFF

You may be able to get things working with different settings, however these are the settings I use and are known to work.

==== wxWidgets ====

[http://www.wxwidgets.org/downloads/ Download] and install the windows version of wxWidgets (wxMSW). It is then necessary to compile wxWidgets from source, detailed instructions on how to do this can be found in 'install.txt' located in the 'docs\msw' subfolder. The main steps are to open 'wx.dsw' with MSVC located in the 'build\msw' subfolder and compile both Release and Debug configurations (The configuration can be selected from the drop down box on the main toolbar in Visual Studio. Universal, Unicode and DLL versions need not be compiled).

=== Checkout TexGen source code from subversion server ===
Create a directory where you would like to store the TexGen source code in Windows Explorer. Right click on this folder and select 'SVN Checkout...' from the context menu that appears. In the dialog box which follows, enter 'https://texgen.svn.sourceforge.net/svnroot/texgen/TexGen/trunk/' in the URL field. The Checkout directory field should have been filled in automatically. Click on OK to start downloading the TexGen source code. In future the latest version of the source code can be obtained simply by right clicking on the folder and selecting 'SVN Update' from the context menu.

=== Configuring the build system with CMake ===
Run CMake from its shortcut on the Start menu. There are some general instructions on using CMake on the [http://www.cmake.org/HTML/RunningCMake.html CMake website] which are worth reading. You will need to fill in the source code location, this should point to where you checkout out the latest TexGen SVN code or where you extracted the source code from the zip file. Also set where to place the binary files once they are compiled, this can be the same as the source directory, a subdirectory within the source directory or any other location.

Once that is entered click 'Configure' and choose the Visual Studio version which you have installed and click ok. You will initially get a number of error messages such as:

CMake Error: Swig was not found on the system. Please specify the location of Swig. (click OK)
CMake Error: Error in configuration process, project files may be invalid. (click OK)

This is normal, in order to get rid of the errors you will need to tell CMake where the various libraries you have installed can be found. This is done in the Cache Values sections.

It is recommended to begin with a minimal build, this is achieved by setting the cache values as follows:

BUILD_CASCADE_EXPORT OFF
BUILD_DOCUMENTATION OFF
BUILD_EXAMPLES OFF
BUILD_GUI OFF
BUILD_PYTHON_INTERFACE OFF
BUILD_RENDERER OFF
BUILD_SHARED ON
BUILD_UNIT_TESTS OFF

Once these are set press configure again and you shouldn't have any more errors/warnings. Press 'OK' to generate the MSVC solution and project files. Configuring the various optional modules is explained in [[#Configuring optional modules]].

=== Configuring optional modules ===

Once the minimal build is working you may want to switch on the optional modules. To do this open up CMake again and switch the modules you want to ON in the Cache Values then click Configure. You will most likely see some errors telling you it is unable to automatically find certain directories. You will need to specify these manually. An explanation of the different locations is listed below:

'''PYTHON_SITEPACKAGES_DIR''' - This should be the folder where the TexGen python modules will be placed. Usually located in 'C:\Python25\Lib\site-packages', but this will depend on the version of Python installed and where you decided to install it.

'''SWIG_DIR''' - This is the location where you extracted the SWIG executable. e.g. 'C:\Program Files\swigwin-1.3.35'.

'''SWIG_EXECUTABLE''' - Same as root directory followed by 'swig.exe'

'''wxWidgets_ROOT_DIR''' - Location where you install wxWidgets. e.g. 'C:/wxWidgets-2.8.7'.

'''wxWidgets_LIB_DIR''' - Location where the wxWidgets libraries were compiled to, should be the same as the root directory followed by 'lib\vc_lib'.

'''OPENCASCADE_INCLUDE_DIR''' - Location where the OpenCascade header files are located. e.g. 'C:/OpenCASCADE6.1.0/ros/inc'.

'''OPENCASCADE_LIBRARY_DIR''' - Location where the OpenCascade libraries are located. e.g. 'C:/OpenCASCADE6.1.0/ros/win32/lib'.

'''OPENCASCADE_DEBUG_LIBRARY_DIR''' - Location where the OpenCascade debug libraries are located. e.g. 'C:/OpenCASCADE6.1.0/ros/win32/libd'.

'''VTK_DIR''' - Location of the VTK binary directory (note: not the source directory).

After setting the directories manually, click on configure again. You may need to go through several iterations of changing parameters then pressing configure. Once you have finished changing parameters and have successfully pressed configure without error messages you can press the OK button to generate the build. Note: you can always come back to this at a later time to make changes.

=== Compiling ===

Find 'TexGen.sln' which should be located in the directory where you told CMake to output the binary files to and open it with Microsoft Visual Studio.

Set the configuration to 'Release' and build the solution. Hopefully the project will have been compiled without errors.

If you want to compile and execute the Graphical User Interface you will need to install it, you will not be able to execute it directly from the build directory. This is done by right click on the 'INSTALL' project in the Solution Explorer and selecting Build. This will copy the Python modules into the Python site-packages directory so that they can be imported into scripts, and it will copy the executable along with other necessary files into 'C:\Program Files\TexGen\' by default (this can be changed with the CMAKE_INSTALL_PREFIX cache value in CMake). TexGenGUI.exe should then be run from the installed location, if you attempt to run it directly from where it was compiled you will get some errors on launch.

=== Building the documentation ===

To build the documentation, [http://www.stack.nl/~dimitri/doxygen/download.html Doxygen] is required. Open a command prompt in the 'Docs' subdirectory of the source code and run 'doxygen'. If the doxygen directory is not in your path, you must add it, or give the full path on the command line.

=== Integrating TexGen with ABAQUS ===

If you are using ABAQUS and wish to use TexGen Python scripting from within the ABAQUS/CAE environment, there are a few extra steps to perform. This is because ABAQUS comes packaged with its own version of Python, so any modules added to your standalone python installation will not be accessible by ABAQUS. You must compile the TexGen Python modules with the same version of Python as ABAQUS uses. The following table shows which version of Python is used in specific ABAQUS versions:

{| class="wikitable" style="text-align:center" border="1"
! ABAQUS Version !! Python Version
|-
| 6.6-1 || 2.3.3
|-
| 6.7-1 || 2.4.3
|}

If your version of ABAQUS is not listed in the table above you can type 'abaqus python -V' to check what version of Python is used (then please edit this page to update the table). You can obtain specific versions of Python from http://www.python.org/download/releases/x.y.z/ where x.y.z represents the version number.

Additionally you will need to place the TexGen python modules inside ABAQUS' version of python. There are a few ways to accomplish this, the easiest is perhaps to set the CMake cache variable 'PYTHON_SITEPACKAGES_DIR' point to the ABAQUS' python directory, e.g.:

PYTHON_SITEPACKAGES_DIR C:\Abaqus\6.7-1\Python\Lib\

Then when you build the INSTALL project in MSVC++ it will automatically copy the TexGen python modules to the ABAQUS' Python. Alternatively you can simply copy the files manually or modify Python's search path to include the TexGen python modules, e.g. In python:

import sys
sys.path.append('C:/Python24/Lib/site-packages/')

=== Troubleshooting ===

'''Q:''' I get the following error when compiling:
fatal error LNK1104: cannot open file 'python25_d.lib'

'''A:''' The windows installation of Python doesn't come with the debug library ('python25_d.lib', the _d part means debug). You should be able to compile in release mode however. If you really want to compile in debug mode you will need to compile Python from source and link to that. Or you can try to link to the release library 'python25.lib' instead, easiest way to do that is to copy 'python25.lib' to 'python25_d.lib' but this may cause problems during linking or execution.

'''Q:''' I get the following error when compiling:
fatal error C1083: Cannot open include file: 'wx/wxprec.h': No such file or directory

'''A:''' Make sure that you have compiled wxWidgets and that the wxWidgets_XXX cache variables are set correctly in CMake.

'''Q:''' I do not have a 'libd' folder in 'ros/win32' for OpenCASCADE.

'''A:''' If you do not compile OpenCASCADE yourself then this folder does not exist. However it can be ignored if you are only interested in building the release version of TexGen. If you really want to compile the debug version please refer to the OpenCASCADE documentation.

'''Q:''' Why do I get the error message: "The parameter is incorrect." when launching TexGenGUI.exe?

'''A:''' This appears to only happen when compiling TexGen with MSVC 2005 or later. I have still not been able to track down the cause of the error as it is particularly cryptic and it will not even allow me to debug the program. For now you must compile with MSVC 2003 or avoid using the GUI until this issue can be resolved.

== Windows (Cygwin and gcc, alternate method) ==
A limited build (without graphics) can be made under cygwin, this is a UNIX emulation environment available at [http://www.cygwin.com www.cygwin.com].
This can exist peacefully next to the native windows version.
Cygwin creates a unix-style file system within your windows installation. If you choose c:/cygwin as your install directory, your HOME will be at c:/cygwin/home/<username>/.

=== Download cygwin and install packages ===
Install gcc, g++, wget, make and cmake using the setup.exe program from the cygwin website.
For the mesh generator and python interface to work we currently need VTK and swig.

This downloads and installs swig from source (when starting the cygwin shell you can paste this into the command line, otherwise write it to a file and run it with sh).
mkdir progs
cd progs
SWIG=swig-1.3.31
wget -nc http://kent.dl.sourceforge.net/sourceforge/swig/$SWIG.tar.gz
tar xzvf $SWIG.tar.gz
cd $SWIG
./configure
make
make install

This downloads and installs VTK from source, in the ccmake stage, use the cmake graphical commands to get a working install.
VTK=vtk-5.0.3
wget -nc http://www.vtk.org/files/release/5.0/$VTK.tar.gz
tar xzvf $VTK.tar.gz
mkdir vtkbin
cd vtkbin
ccmake ../VTK
make
make install

=== Install TexGen from source ===
Now we can proceed to install texgen, as an example we'll work in ~/temp/texgen
cd ~; mkdir temp; cd temp; mkdir texgen; cd texgen
svn checkout https://texgen.svn.sourceforge.net/svnroot/texgen/TexGen/trunk/ TexGen
cd .. ; mkdir tbin; cd tbin
ccmake ../texgen
make
make install

This should result in a working texgen install in ~/temp/texgen/tbin.

== Unix ==
=== Notes ===
If you are installing to a system where you don't have root access (i.e. this computer does not belong to you) you won't be able to install the software using the default configure script. This is because by default software is installed to the /usr/local directory. If you are not a systems administrator then you will quite rightly not have write access to this folder. All is not lost! You can still install software into your home directory. In order to do this you should always call the configure script with the following parameter: --prefix=$HOME. This goes for all the software to be installed below. All executables will then be placed in ~/bin, libraries in ~/lib, includes in ~/include, etc...

In the guide below the parameter is included in italic. If you do in fact have root access then it is recommended to omit this parameter and install to the default directory so that other users will also have access to the software.

=== Get TexGen from Subversion repository ===

==== Install Subversion ====
[http://subversion.tigris.org/servlets/ProjectDocumentList?collapseFolder=260&folderID=260 Download Subversion] and unpack.
Open a shell in extracted folder and type:
./configure --with-ssl ''--prefix=$HOME''
make
make install

Notes:
* You will need to install Subversion with SSL support since TexGen is hosted on sourceforge which uses SSL. If you don't configure with the --with-ssl flag you will get an error when trying to checkout TexGen in the next step.
* If you have trouble installing the latest version of Subversion, try installing version 1.3 as it does not require a seperate dependencies package.

==== Checkout ====
Open a shell in folder you wish to place TexGen (e.g. ~/):
svn checkout https://texgen.svn.sourceforge.net/svnroot/texgen/TexGen/trunk/ TexGen

Notes:
* The first parameter tells SVN to get the files for the first time
* The second parameter is the location of the TexGen svn repository
* The final parameter is the subfolder to put the files in

==== Update ====
The checkout command only needs to performed once. SVN keeps track of where the code was originally obtained and can update to the latest version without having to re-specify the location. In order to do that open a shell in the folder where TexGen was originally checkout (e.g. ~/TexGen) and type:
svn update
or if you are in a hurry you can type the shorter version:
svn up

=== Compile source ===

==== Install CMake ====

[http://www.cmake.org/HTML/Download.html Download CMake] and unpack.
Open a shell in extracted folder and type:
./configure ''--prefix=$HOME''
make
make install

==== Compile TexGen core ====
Open a shell in the folder with the TexGen source code (e.g. ~/TexGen):
mkdir bin
cd bin
ccmake ../
Press 'c' to configure. When a warning pops up telling you it can't find such and such a file press 'e' to close it. You will now need to specify which components of TexGen to build and where their dependencies can be found. Use the up and down arrows to move the caret and press enter to modify options. Do this to set BUILD_GUI, BUILD_PYTHON_INTERFACE and BUILD_RENDERER to OFF. You are basically telling CMake not to attempt to build these components, which means that you won't need to have installed their dependencies.

Similarly to the --prefix=$HOME parameter to the configure script, you can tell CMake to install TexGen to your home directory by changing CMAKE_INSTALL_PREFIX to ~/. Note that it won't actually install anything until you get type make install.

Now press 'c' again to update the changes.

Hopefully now that all the additional modules have been switched off no errors will be shown. Press 'g' to generate the makefiles and exit. At the shell type:
make
make install

Note that at this point you have only built and installed the TexGen Core library which doesn't actually do anything on its own. If you plan to incorporate TexGen into your own C++ program then this is enough, however if you would like to interface with TexGen from a Python script or Graphical User Interface then follow the steps below.

=== Compiling optional modules ===
==== Python interface ====
[http://www.python.org/download/ Download Python] and unpack.
Open a shell in the extracted folder and type:
./configure ''--prefix=$HOME''
make
make install

[http://www.swig.org/download.html Download SWIG] and unpack.
Open a shell in the extracted folder and type:
./configure ''--prefix=$HOME''
make
make install

Open a shell in the folder where you called ccmake from for the first time (e.g. ~/TexGen/bin):
ccmake ../

Use the up and down arrows to reach BUILD_PYTHON_INTERFACE and press Enter to set it to ON. Then press 'c' to configure. You will probably get a warning saying you need to specify the location of SWIG and/or Python, press 'e' to close it.

Set the PYTHON_INCLUDE_PATH, PYTHON_LIBRARY, PYTHON_SITEPACKAGES_DIR, SWIG_DIR and SWIG_EXECUTABLE parameters correctly where necessary. If you have installed packages to your home directory then they should look something like this:

PYTHON_INCLUDE_PATH: ~/include/python2.5
PYTHON_LIBRARY: ~/lib/python2.5/config/libpython2.5.a
PYTHON_SITEPACKAGES_DIR: ~/lib/python2.5/site-packages
SWIG_DIR: ~/bin
SWIG_EXECUTABLE: ~/bin/swig

Once that is done press 'c' again. You may need perform this process over several iterations. When everything is set correctly press 'g' to generate the makefiles.

At the shell type:
make
make install

Assuming the build completed without errors you should now be able to access TexGen functions from within Python. In order to check everything worked as planned open Python in interactive mode by typing:
python

Then from within Python type:
from TexGen.Core import *
CTexGen.GetInstance().GetVersion()

This should display the version of TexGen installed.

=== Troubleshooting ===

'''Q:''' I get the following error when linking _Core.so:
libpython2.5.a(abstract.o): relocation R_X86_64_32 against `a local symbol'
can not be used when making a shared object; recompile with -fPIC

'''A:''' Try removing libpython2.5.a from the libraries to link to by setting PYTHON_LIBRARY to a bogus path, e.g.:

PYTHON_LIBRARY: ~/

By doing so you may receive a warning similar to this:
Warning: Ignoring path found in link libraries for target: _Core, path is:
/home/username. Expected a library name or a full path to a library name.
This warning may be ignored.

Scripting Create Models

2008-05-09T11:55:31Z

WikiSysop: /* Example 4: A sheared plain weave */

===Example 1: A plain weave===
First of all, a Python script is just a plain ASCII text file with a .py extension. To create one simply open up your favorite text editor. Notepad will do if you have nothing else but I suggest a more powerful freeware text editor like [http://www.pspad.com/ PSPad] or [http://notepad-plus.sourceforge.net/ Notepad++]. Code that goes into the python script will be displayed like so:

# All Python code will be shown in a box like this one.
# Lines begining with a '#' character are comments

In this example, we will create a simple 2x2 plain weave model with a Python script. Its time to dive in and see some actual Python code. At this point if you are completely lost please refer back to the resources on Python programming. The first step is to create an instance of the <code>CTextileWeave2D</code> class and give it a name, <code>weave</code>:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

The <code>CTextileWeave2D</code> class takes 5 parameters in the order shown below:
* Number of weft yarns in the unit cell
* Number of warp yarns in the unit cell
* Spacing between the yarns
* Thickness of the fabrics
* Refine model (True/False)

The only parameter that really needs an explanation here is the Refine model option, this controls whether or not the interference correction algorithm will be applied to keep the yarn volumes from intersecting which is a common problem. The interference correction algorithm generally does a good job but is not instantaneous so sometimes it can be beneficial to switch it off.

This is the bare minimum information necessary to create a 2D woven fabric. In the following steps we will add more information to create the model the way we want it.

Let's set the weave pattern, this determines whether a warp or weft yarn will appear on top at a particular cross over. Cross overs are arranged in 2d grid where the size of the grid depends on the number of warp and weft yarns created. To swap the positions of the weft and warp yarns, we call the function <code>SwapPosition</code> with the grid coordinates of the cross over. In order to create a plain weave we need to do this on two diagonally opposite cross overs like so:

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

Now let's add our <code>weave</code> model to the database of models so that TexGen can render it:

# Add the textile
AddTextile(weave)

Thats it! This is a very simple script but it will generate a plain weave model. To recap your Python script should look like this:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

# Add the textile
AddTextile(weave)

Save it to disk as ''PlainWeave.py'' or give it whatever name you want as long as it has a ''.py'' extension.

In order to test the Script we need to load it into TexGen. So start up the TexGen GUI and from the ''Python menu'' select ''Run Script''. Select the file you have just saved and click ok. With a bit of luck you should see a 2d plain weave on screen:

[[Image:Example1.png]]

Congratulations you have created your first TexGen Python script!

===Example 2: Another plain weave (the hard way)===
In the first example we made use of the <code>CTextileWeave2D</code> which is the reason the script is so compact. This was great for creating a 2D Weave, but what if we want to create something other than a 2D Weave? Well, let's stick to the 2D weave for now but in this example we will create geometric model in a generic way without the use of the <code>CTextileWeave2D</code> class. This takes a little bit longer to do, but gives more control over the final geometry.

First we will define a general textile and call it <code>Textile</code>:

# Create a textile
Textile = CTextile()

The <code>CTextile</code> class doesn't take any parameters, instead yarns will be created and added to it. Next we will create 4 yarns to go inside our textile, it is convenient to make use of the Python lists to do this. Create a list called <code>Yarns</code> with 4 elements, each one an instance of the class <code>CYarn</code>:

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

<code>Yarns</code> now contains 4 empty yarns. Note that the yarns are not currently associated with the Textile, first we must fill in the details then make them a part of the textile. The first thing to do is define their paths with nodes. This is done like so:

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

We have added 3 nodes to each yarn creating a woven pattern. The number in the square brackets after <code>Yarns</code> refers to a particular yarn in the list. The function <code>AddNode</code> is then called for the yarn. The function takes an instance of the class <code>CNode</code> which in turn is constructed with an instance of the class <code>XYZ</code> representing the position of the node. The class <code>XYZ</code> is constructed with 3 numbers representing the X, Y and Z coordinates of the point.

We still need to define a few more things to obtain a model. For the sake of simplicity, we will give all the yarns the same cross sectional shape, width, height, etc... The easiest way to do this is to loop over the yarns and assign the same properties to each yarn one by one. The syntax for looping over <code>Yarns</code> is shown here:

# Loop over all the yarns in the list
for Yarn in Yarns:

Inside the loop, the variable <code>Yarn</code> refers to the current yarn in the list. So within the loop we just assign properties to <code>Yarn</code> and they will be applied to all the yarns in the list. In python the begining and end of a loop are defined by indentation, hence the following lines are indented to represent the contents of the loop.

Let us define periodic cubic spline interpolation between the nodes:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

This is done with the function <code>AssignInterpolation</code> which takes an instance of a class derived from <code>CInterpolation</code>. In this case we used <code>CInterpolationCubic</code> to specify periodic cubic spline interpolation.

Next we need to define a cross section for the yarn, to keep things simple a constant cross section all along the length of the yarn will be defined:

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

The function <code>AssignSection</code> takes an instance of a class derived from <code>CYarnSection</code>. In this case we used <code>CYarnSectionConstant</code> which in turns take an instance of a class derived from <code>CSection</code> as a constructor. <code>CSectionEllipse</code> defines an elliptical cross section with given width and height defined by the first and second parameters respectively.

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

This line sets the resolution of the surface mesh created. The first parameter to the function <code>SetResolution</code> represents the number of points around a cross section. The number of points along the length of the yarns is automatically calculated such that the distance between points is similar to around the cross section.

Next we must add repeat vectors to define how the yarns are repeated.

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

The function <code>AddRepeat</code> takes an instance of the class <code>XYZ</code>. As we saw earlier the class <code>XYZ</code> is constructed with 3 numbers defining the X, Y and Z components.

Finally the yarn is fully defined, it can now be added to <code>Textile</code>:

# Add the yarn to our textile
Textile.AddYarn(Yarn)

This is the end of the loop, hence the following lines return to the original indentation. Now let's define a Domain within which the textile will be placed:

Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

The function <code>AssignDomain</code> takes an instance of a class derived from <code>CDomain</code>. In this case we will create a box shaped domain, this can be accomplished by using the class <code>CDomainPlanes</code>. A box can be created by passing in opposite corners of the box (the minimum and maximum coordinates). This is done again with the class <code>XYZ</code>.

And finally <code>Textile</code> must be added to so that it can be rendered. Each Textile added must be assigned a name to identify it, this is the name that will appear at the top in the TexGen GUI. This name can either be generated automatically or we can specify it explicitly like so:

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

That's it! You now have the knowledge to create any type of fabric imaginable. Well, almost. The model created here is pretty simple, there is plenty of oppertunity to create more complex shapes. For example non-constant cross sections can be defined, complex domain shapes defined by arbritrary planes, different interpolation functions.

Here is the completed script:

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

# Loop over all the yarns in the list
for Yarn in Yarns:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a domain and assign it to the textile
Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

And the result:

[[Image:Example2.png]]

===Example 3: A 3d weave===
This example is similar to the [[Scripting Create Models#Example 2: Another plain weave (the hard way)|Example 2]] in that the yarns will be defined by nodes. This time we will create a 3d woven fabric that looks like this:

[[Image:Example3.png]]

We start by defining a new CTextile instance:

# Create a textile
Textile = CTextile()

Before starting to define the geometry using TexGen it is helpful to define a list of parameters which may need to be changed later. These typically include spacing between yarns and yarn dimensions:

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

It is a good idea to define these up front rather than hard coding them in the rest of the script because if you want to tweak any parameters they can easily be located and will only need to be changed once. Lets start by defining the warp stuffer yarns, these are fairly easy to define since they all straight and parallel to each other:

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

Next we define the weft stuffer yarns, again these are easy to define:

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

And finally we need to insert the binder yarns. Making clever use of the repeat vectors it is only necessary to define a single instance of the binder yarn.

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Now that the geometry is defined we shall define a domain and add the textile so that TexGen knows about it.

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

The completed scripts is shown below:

# Create a textile
Textile = CTextile()

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

===Example 4: A sheared plain weave===
This example builds on [[Scripting Create Models#Example 2: Another plain weave (the hard way)|Example 2]], except this time we will be modeling a sheared unit cell. The final script can be found at the bottom, I will not step through each section of case as I have done for the previous cases since you should now be familiar with the basic procedure.

You will notice at the top of the script the line <code>from math import *</code>, this is a Python command to import the contents of the math module. We need this here because we will be making use of the value <code>pi</code> and functions <code>cos</code> and <code>sin</code>.

In this script I have also defined some constants up front (spacing, height, shear angle, twist angle and shear offset) as they will get used frequently within the script. It is best to define them as variables so that they can easily be modified later.

The position of the nodes are arranged as plain weave but displaced slightly by the shear offset. Note that if the shear angle is 0, the shear offset is also 0 and the position of the nodes is equivalent to [[Scripting Create Models#Example 2: Another plain weave (the hard way)|Example 2]].

The next difference is how the cross-section is defined. When a plain woven fabric is sheared the yarn is likely to twist, so we can no longer use a constant cross-section all along the length of the yarn. Instead here I have defined a yarn which twists in one direction at 1/4 of its way along the length of the yarn and twists in the other direction at 3/4 of the way along the length of the yarn. This is to avoid intersections between the yarns. The cross-section is interpolated at other positions along the yarn.

The repeat vectors are defined to take into account the shear and is fairly straight forwards.

The next complication is defining a domain which is sheared. This is done by specifying 6 planes which define the bounds of the domain. The normals of the planes must point inwards, in the case of an unsheared fabric the normals are all in line with the global axes. But in order to create a lozenge shaped unit cell these normals must be rotated.

<pre>
from math import *

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Define some constants that will be used in further calculations
spacing = 0.22
height = 0.05

shearAngle = pi/16
twistAngle = shearAngle

shearOffset = spacing*sin(shearAngle)

# Add nodes to the yarns to describe their paths, these are the sheared node positions
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(spacing, shearOffset, height)))
Yarns[0].AddNode(CNode(XYZ(2*spacing, 2*shearOffset, 0)))

Yarns[1].AddNode(CNode(XYZ(0+shearOffset, spacing, height)))
Yarns[1].AddNode(CNode(XYZ(spacing+shearOffset, spacing+shearOffset, 0)))
Yarns[1].AddNode(CNode(XYZ(2*spacing+shearOffset, spacing+2*shearOffset, height)))

Yarns[2].AddNode(CNode(XYZ(0, 0, height)))
Yarns[2].AddNode(CNode(XYZ(shearOffset, spacing, 0)))
Yarns[2].AddNode(CNode(XYZ(2*shearOffset, 2*spacing, height)))

Yarns[3].AddNode(CNode(XYZ(spacing, 0+shearOffset, 0)))
Yarns[3].AddNode(CNode(XYZ(spacing+shearOffset, spacing+shearOffset, height)))
Yarns[3].AddNode(CNode(XYZ(spacing+2*shearOffset, 2*spacing+shearOffset, 0)))

# Create a cross-section which twists along the length of the yarn to accommodate the sheared fabric architecture
ellipse = CSectionEllipse(0.18, 0.04)
sectionTwist1 = CYarnSectionInterpPosition()
sectionTwist1.AddSection(0.25, CSectionRotated(ellipse, -twistAngle))
sectionTwist1.AddSection(0.75, CSectionRotated(ellipse, twistAngle))
sectionTwist2 = CYarnSectionInterpPosition()
sectionTwist2.AddSection(0.25, CSectionRotated(ellipse, twistAngle))
sectionTwist2.AddSection(0.75, CSectionRotated(ellipse, -twistAngle))

for Yarn in (Yarns[1], Yarns[3]):
Yarn.AssignSection(sectionTwist1)
for Yarn in (Yarns[0], Yarns[2]):
Yarn.AssignSection(sectionTwist2)

# Loop over all the yarns in the list
for Yarn in Yarns:
# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(2*spacing, 2*shearOffset, 0))
Yarn.AddRepeat(XYZ(2*shearOffset, 2*spacing, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a sheared domain with 6 planes
domain = CDomainPlanes()
d = (2*spacing-2*shearOffset*sin(shearAngle))/sqrt(1+sin(shearAngle)**2)
domain.AddPlane(PLANE(XYZ(1, -sin(shearAngle), 0), 0))
domain.AddPlane(PLANE(XYZ(-1, sin(shearAngle), 0), -d))
domain.AddPlane(PLANE(XYZ(-sin(shearAngle), 1, 0), 0))
domain.AddPlane(PLANE(XYZ(sin(shearAngle), -1, 0), -d))
domain.AddPlane(PLANE(XYZ(0, 0, 1), -height))
domain.AddPlane(PLANE(XYZ(0, 0, -1), -2*height))
Textile.AssignDomain(domain)

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)
</pre>

Once you run the script your model should look like this:

[[Image:Example4.png]]

===Saving to TG3 file format===
TexGen has it's own file format for storing textile geometry with the extension .tg3. For more details on this file format please read the [[TG3 File Format]] page. Any textile models saved to this file format can be reloaded at a later time however it is also a good idea to keep the python script used to generate the geometry in case modifications need to be made. To save such a file it is simply a matter of adding an additional like at the end of your script like so:

SaveToXML("MyTextile.tg3")

The first parameter is the name of the file to save, note that if the .tg3 extension is omitted then it will automatically be appended for you. The second parameter is optional and if used should be the name of the textile to save, this is useful if you have several textiles loaded at once (i.e. you called AddTextile more than once) and you only want to save one of them. Note that if you don't specify the second parameter and you do have several textiles loaded then it will save all of them to a single .tg3 file. The third parameter determines how much information is saved in the .tg3 file, see the [[TG3 File Format]] for more details.

Scripting Create Models

2008-05-09T11:53:35Z

WikiSysop:

===Example 1: A plain weave===
First of all, a Python script is just a plain ASCII text file with a .py extension. To create one simply open up your favorite text editor. Notepad will do if you have nothing else but I suggest a more powerful freeware text editor like [http://www.pspad.com/ PSPad] or [http://notepad-plus.sourceforge.net/ Notepad++]. Code that goes into the python script will be displayed like so:

# All Python code will be shown in a box like this one.
# Lines begining with a '#' character are comments

In this example, we will create a simple 2x2 plain weave model with a Python script. Its time to dive in and see some actual Python code. At this point if you are completely lost please refer back to the resources on Python programming. The first step is to create an instance of the <code>CTextileWeave2D</code> class and give it a name, <code>weave</code>:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

The <code>CTextileWeave2D</code> class takes 5 parameters in the order shown below:
* Number of weft yarns in the unit cell
* Number of warp yarns in the unit cell
* Spacing between the yarns
* Thickness of the fabrics
* Refine model (True/False)

The only parameter that really needs an explanation here is the Refine model option, this controls whether or not the interference correction algorithm will be applied to keep the yarn volumes from intersecting which is a common problem. The interference correction algorithm generally does a good job but is not instantaneous so sometimes it can be beneficial to switch it off.

This is the bare minimum information necessary to create a 2D woven fabric. In the following steps we will add more information to create the model the way we want it.

Let's set the weave pattern, this determines whether a warp or weft yarn will appear on top at a particular cross over. Cross overs are arranged in 2d grid where the size of the grid depends on the number of warp and weft yarns created. To swap the positions of the weft and warp yarns, we call the function <code>SwapPosition</code> with the grid coordinates of the cross over. In order to create a plain weave we need to do this on two diagonally opposite cross overs like so:

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

Now let's add our <code>weave</code> model to the database of models so that TexGen can render it:

# Add the textile
AddTextile(weave)

Thats it! This is a very simple script but it will generate a plain weave model. To recap your Python script should look like this:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

# Add the textile
AddTextile(weave)

Save it to disk as ''PlainWeave.py'' or give it whatever name you want as long as it has a ''.py'' extension.

In order to test the Script we need to load it into TexGen. So start up the TexGen GUI and from the ''Python menu'' select ''Run Script''. Select the file you have just saved and click ok. With a bit of luck you should see a 2d plain weave on screen:

[[Image:Example1.png]]

Congratulations you have created your first TexGen Python script!

===Example 2: Another plain weave (the hard way)===
In the first example we made use of the <code>CTextileWeave2D</code> which is the reason the script is so compact. This was great for creating a 2D Weave, but what if we want to create something other than a 2D Weave? Well, let's stick to the 2D weave for now but in this example we will create geometric model in a generic way without the use of the <code>CTextileWeave2D</code> class. This takes a little bit longer to do, but gives more control over the final geometry.

First we will define a general textile and call it <code>Textile</code>:

# Create a textile
Textile = CTextile()

The <code>CTextile</code> class doesn't take any parameters, instead yarns will be created and added to it. Next we will create 4 yarns to go inside our textile, it is convenient to make use of the Python lists to do this. Create a list called <code>Yarns</code> with 4 elements, each one an instance of the class <code>CYarn</code>:

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

<code>Yarns</code> now contains 4 empty yarns. Note that the yarns are not currently associated with the Textile, first we must fill in the details then make them a part of the textile. The first thing to do is define their paths with nodes. This is done like so:

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

We have added 3 nodes to each yarn creating a woven pattern. The number in the square brackets after <code>Yarns</code> refers to a particular yarn in the list. The function <code>AddNode</code> is then called for the yarn. The function takes an instance of the class <code>CNode</code> which in turn is constructed with an instance of the class <code>XYZ</code> representing the position of the node. The class <code>XYZ</code> is constructed with 3 numbers representing the X, Y and Z coordinates of the point.

We still need to define a few more things to obtain a model. For the sake of simplicity, we will give all the yarns the same cross sectional shape, width, height, etc... The easiest way to do this is to loop over the yarns and assign the same properties to each yarn one by one. The syntax for looping over <code>Yarns</code> is shown here:

# Loop over all the yarns in the list
for Yarn in Yarns:

Inside the loop, the variable <code>Yarn</code> refers to the current yarn in the list. So within the loop we just assign properties to <code>Yarn</code> and they will be applied to all the yarns in the list. In python the begining and end of a loop are defined by indentation, hence the following lines are indented to represent the contents of the loop.

Let us define periodic cubic spline interpolation between the nodes:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

This is done with the function <code>AssignInterpolation</code> which takes an instance of a class derived from <code>CInterpolation</code>. In this case we used <code>CInterpolationCubic</code> to specify periodic cubic spline interpolation.

Next we need to define a cross section for the yarn, to keep things simple a constant cross section all along the length of the yarn will be defined:

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

The function <code>AssignSection</code> takes an instance of a class derived from <code>CYarnSection</code>. In this case we used <code>CYarnSectionConstant</code> which in turns take an instance of a class derived from <code>CSection</code> as a constructor. <code>CSectionEllipse</code> defines an elliptical cross section with given width and height defined by the first and second parameters respectively.

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

This line sets the resolution of the surface mesh created. The first parameter to the function <code>SetResolution</code> represents the number of points around a cross section. The number of points along the length of the yarns is automatically calculated such that the distance between points is similar to around the cross section.

Next we must add repeat vectors to define how the yarns are repeated.

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

The function <code>AddRepeat</code> takes an instance of the class <code>XYZ</code>. As we saw earlier the class <code>XYZ</code> is constructed with 3 numbers defining the X, Y and Z components.

Finally the yarn is fully defined, it can now be added to <code>Textile</code>:

# Add the yarn to our textile
Textile.AddYarn(Yarn)

This is the end of the loop, hence the following lines return to the original indentation. Now let's define a Domain within which the textile will be placed:

Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

The function <code>AssignDomain</code> takes an instance of a class derived from <code>CDomain</code>. In this case we will create a box shaped domain, this can be accomplished by using the class <code>CDomainPlanes</code>. A box can be created by passing in opposite corners of the box (the minimum and maximum coordinates). This is done again with the class <code>XYZ</code>.

And finally <code>Textile</code> must be added to so that it can be rendered. Each Textile added must be assigned a name to identify it, this is the name that will appear at the top in the TexGen GUI. This name can either be generated automatically or we can specify it explicitly like so:

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

That's it! You now have the knowledge to create any type of fabric imaginable. Well, almost. The model created here is pretty simple, there is plenty of oppertunity to create more complex shapes. For example non-constant cross sections can be defined, complex domain shapes defined by arbritrary planes, different interpolation functions.

Here is the completed script:

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

# Loop over all the yarns in the list
for Yarn in Yarns:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a domain and assign it to the textile
Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

And the result:

[[Image:Example2.png]]

===Example 3: A 3d weave===
This example is similar to the [[Scripting Create Models#Example 2: Another plain weave (the hard way)|Example 2]] in that the yarns will be defined by nodes. This time we will create a 3d woven fabric that looks like this:

[[Image:Example3.png]]

We start by defining a new CTextile instance:

# Create a textile
Textile = CTextile()

Before starting to define the geometry using TexGen it is helpful to define a list of parameters which may need to be changed later. These typically include spacing between yarns and yarn dimensions:

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

It is a good idea to define these up front rather than hard coding them in the rest of the script because if you want to tweak any parameters they can easily be located and will only need to be changed once. Lets start by defining the warp stuffer yarns, these are fairly easy to define since they all straight and parallel to each other:

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

Next we define the weft stuffer yarns, again these are easy to define:

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

And finally we need to insert the binder yarns. Making clever use of the repeat vectors it is only necessary to define a single instance of the binder yarn.

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Now that the geometry is defined we shall define a domain and add the textile so that TexGen knows about it.

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

The completed scripts is shown below:

# Create a textile
Textile = CTextile()

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

===Example 4: A sheared plain weave===
This example builds on [[Scripting Create Models#Example 2: Another plain weave (the hard way)|Example 2]], except this time we will be modeling a sheared unit cell. The final script can be found at the bottom, I will not step through each section of case as I have done for the previous cases since you should now be familiar with the basic procedure.

You will notice at the top of the script the line <code>from math import *</code>, this is a Python command to import the contents of the math module. We need this here because we will be making use of the value <code>pi</code> and functions <code>cos</code> and <code>sin</code>.

In this script I have also defined some constants up front (spacing, height, shear angle, twist angle and shear offset) as they will get used frequently within the script. It is best to define them as variables so that they can easily be modified later.

The position of the nodes are arranged as plain weave but displaced slightly by the shear offset. Note that if the shear angle is 0, the shear offset is also 0 and the position of the nodes is equivalent to [[Scripting Create Models#Example 2: Another plain weave (the hard way)|Example 2]].

The next difference is how the cross-section is defined. When a plain woven fabric is sheared the yarn is likely to twist, so we can no longer use a constant cross-section all along the length of the yarn. Instead here I have defined a yarn which twists in one direction at 1/4 of its way along the length of the yarn and twists in the other direction at 3/4 of the way along the length of the yarn. This is to avoid intersections between the yarns. The cross-section is interpolated at other positions along the yarn.

The repeat vectors are defined to take into account the shear and is fairly straight forwards.

The next complication is defining a domain which is shared. This is done by specifying 6 planes which define the bounds of the domain. The normals of the planes must point inwards, in the case of an unsheared fabric the normals are all in line with the global axes. But in order to create a lozenge shaped unit cell these normals must be rotated.

<pre>
from math import *

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Define some constants that will be used in further calculations
spacing = 0.22
height = 0.05

shearAngle = pi/16
twistAngle = shearAngle

shearOffset = spacing*sin(shearAngle)

# Add nodes to the yarns to describe their paths, these are the sheared node positions
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(spacing, shearOffset, height)))
Yarns[0].AddNode(CNode(XYZ(2*spacing, 2*shearOffset, 0)))

Yarns[1].AddNode(CNode(XYZ(0+shearOffset, spacing, height)))
Yarns[1].AddNode(CNode(XYZ(spacing+shearOffset, spacing+shearOffset, 0)))
Yarns[1].AddNode(CNode(XYZ(2*spacing+shearOffset, spacing+2*shearOffset, height)))

Yarns[2].AddNode(CNode(XYZ(0, 0, height)))
Yarns[2].AddNode(CNode(XYZ(shearOffset, spacing, 0)))
Yarns[2].AddNode(CNode(XYZ(2*shearOffset, 2*spacing, height)))

Yarns[3].AddNode(CNode(XYZ(spacing, 0+shearOffset, 0)))
Yarns[3].AddNode(CNode(XYZ(spacing+shearOffset, spacing+shearOffset, height)))
Yarns[3].AddNode(CNode(XYZ(spacing+2*shearOffset, 2*spacing+shearOffset, 0)))

# Create a cross-section which twists along the length of the yarn to accommodate the sheared fabric architecture
ellipse = CSectionEllipse(0.18, 0.04)
sectionTwist1 = CYarnSectionInterpPosition()
sectionTwist1.AddSection(0.25, CSectionRotated(ellipse, -twistAngle))
sectionTwist1.AddSection(0.75, CSectionRotated(ellipse, twistAngle))
sectionTwist2 = CYarnSectionInterpPosition()
sectionTwist2.AddSection(0.25, CSectionRotated(ellipse, twistAngle))
sectionTwist2.AddSection(0.75, CSectionRotated(ellipse, -twistAngle))

for Yarn in (Yarns[1], Yarns[3]):
Yarn.AssignSection(sectionTwist1)
for Yarn in (Yarns[0], Yarns[2]):
Yarn.AssignSection(sectionTwist2)

# Loop over all the yarns in the list
for Yarn in Yarns:
# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(2*spacing, 2*shearOffset, 0))
Yarn.AddRepeat(XYZ(2*shearOffset, 2*spacing, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a sheared domain with 6 planes
domain = CDomainPlanes()
d = (2*spacing-2*shearOffset*sin(shearAngle))/sqrt(1+sin(shearAngle)**2)
domain.AddPlane(PLANE(XYZ(1, -sin(shearAngle), 0), 0))
domain.AddPlane(PLANE(XYZ(-1, sin(shearAngle), 0), -d))
domain.AddPlane(PLANE(XYZ(-sin(shearAngle), 1, 0), 0))
domain.AddPlane(PLANE(XYZ(sin(shearAngle), -1, 0), -d))
domain.AddPlane(PLANE(XYZ(0, 0, 1), -height))
domain.AddPlane(PLANE(XYZ(0, 0, -1), -2*height))
Textile.AssignDomain(domain)

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)
</pre>

Once you run the script your model should look like this:

[[Image:Example4.png]]

===Saving to TG3 file format===
TexGen has it's own file format for storing textile geometry with the extension .tg3. For more details on this file format please read the [[TG3 File Format]] page. Any textile models saved to this file format can be reloaded at a later time however it is also a good idea to keep the python script used to generate the geometry in case modifications need to be made. To save such a file it is simply a matter of adding an additional like at the end of your script like so:

SaveToXML("MyTextile.tg3")

The first parameter is the name of the file to save, note that if the .tg3 extension is omitted then it will automatically be appended for you. The second parameter is optional and if used should be the name of the textile to save, this is useful if you have several textiles loaded at once (i.e. you called AddTextile more than once) and you only want to save one of them. Note that if you don't specify the second parameter and you do have several textiles loaded then it will save all of them to a single .tg3 file. The third parameter determines how much information is saved in the .tg3 file, see the [[TG3 File Format]] for more details.

File:Example4.png

2008-05-09T11:52:50Z

WikiSysop:

Scripting Create Models

2008-05-09T11:49:14Z

WikiSysop: /* Example 4: A sheared plain weave */

===Example 1: A plain weave===
First of all, a Python script is just a plain ASCII text file with a .py extension. To create one simply open up your favorite text editor. Notepad will do if you have nothing else but I suggest a more powerful freeware text editor like [http://www.pspad.com/ PSPad] or [http://notepad-plus.sourceforge.net/ Notepad++]. Code that goes into the python script will be displayed like so:

# All Python code will be shown in a box like this one.
# Lines begining with a '#' character are comments

In this example, we will create a simple 2x2 plain weave model with a Python script. Its time to dive in and see some actual Python code. At this point if you are completely lost please refer back to the resources on Python programming. The first step is to create an instance of the <code>CTextileWeave2D</code> class and give it a name, <code>weave</code>:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

The <code>CTextileWeave2D</code> class takes 5 parameters in the order shown below:
* Number of weft yarns in the unit cell
* Number of warp yarns in the unit cell
* Spacing between the yarns
* Thickness of the fabrics
* Refine model (True/False)

The only parameter that really needs an explanation here is the Refine model option, this controls whether or not the interference correction algorithm will be applied to keep the yarn volumes from intersecting which is a common problem. The interference correction algorithm generally does a good job but is not instantaneous so sometimes it can be beneficial to switch it off.

This is the bare minimum information necessary to create a 2D woven fabric. In the following steps we will add more information to create the model the way we want it.

Let's set the weave pattern, this determines whether a warp or weft yarn will appear on top at a particular cross over. Cross overs are arranged in 2d grid where the size of the grid depends on the number of warp and weft yarns created. To swap the positions of the weft and warp yarns, we call the function <code>SwapPosition</code> with the grid coordinates of the cross over. In order to create a plain weave we need to do this on two diagonally opposite cross overs like so:

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

Now let's add our <code>weave</code> model to the database of models so that TexGen can render it:

# Add the textile
AddTextile(weave)

Thats it! This is a very simple script but it will generate a plain weave model. To recap your Python script should look like this:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

# Add the textile
AddTextile(weave)

Save it to disk as ''PlainWeave.py'' or give it whatever name you want as long as it has a ''.py'' extension.

In order to test the Script we need to load it into TexGen. So start up the TexGen GUI and from the ''Python menu'' select ''Run Script''. Select the file you have just saved and click ok. With a bit of luck you should see a 2d plain weave on screen:

[[Image:Example1.png]]

Congratulations you have created your first TexGen Python script!

===Example 2: Another plain weave (the hard way)===
In the first example we made use of the <code>CTextileWeave2D</code> which is the reason the script is so compact. This was great for creating a 2D Weave, but what if we want to create something other than a 2D Weave? Well, let's stick to the 2D weave for now but in this example we will create geometric model in a generic way without the use of the <code>CTextileWeave2D</code> class. This takes a little bit longer to do, but gives more control over the final geometry.

First we will define a general textile and call it <code>Textile</code>:

# Create a textile
Textile = CTextile()

The <code>CTextile</code> class doesn't take any parameters, instead yarns will be created and added to it. Next we will create 4 yarns to go inside our textile, it is convenient to make use of the Python lists to do this. Create a list called <code>Yarns</code> with 4 elements, each one an instance of the class <code>CYarn</code>:

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

<code>Yarns</code> now contains 4 empty yarns. Note that the yarns are not currently associated with the Textile, first we must fill in the details then make them a part of the textile. The first thing to do is define their paths with nodes. This is done like so:

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

We have added 3 nodes to each yarn creating a woven pattern. The number in the square brackets after <code>Yarns</code> refers to a particular yarn in the list. The function <code>AddNode</code> is then called for the yarn. The function takes an instance of the class <code>CNode</code> which in turn is constructed with an instance of the class <code>XYZ</code> representing the position of the node. The class <code>XYZ</code> is constructed with 3 numbers representing the X, Y and Z coordinates of the point.

We still need to define a few more things to obtain a model. For the sake of simplicity, we will give all the yarns the same cross sectional shape, width, height, etc... The easiest way to do this is to loop over the yarns and assign the same properties to each yarn one by one. The syntax for looping over <code>Yarns</code> is shown here:

# Loop over all the yarns in the list
for Yarn in Yarns:

Inside the loop, the variable <code>Yarn</code> refers to the current yarn in the list. So within the loop we just assign properties to <code>Yarn</code> and they will be applied to all the yarns in the list. In python the begining and end of a loop are defined by indentation, hence the following lines are indented to represent the contents of the loop.

Let us define periodic cubic spline interpolation between the nodes:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

This is done with the function <code>AssignInterpolation</code> which takes an instance of a class derived from <code>CInterpolation</code>. In this case we used <code>CInterpolationCubic</code> to specify periodic cubic spline interpolation.

Next we need to define a cross section for the yarn, to keep things simple a constant cross section all along the length of the yarn will be defined:

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

The function <code>AssignSection</code> takes an instance of a class derived from <code>CYarnSection</code>. In this case we used <code>CYarnSectionConstant</code> which in turns take an instance of a class derived from <code>CSection</code> as a constructor. <code>CSectionEllipse</code> defines an elliptical cross section with given width and height defined by the first and second parameters respectively.

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

This line sets the resolution of the surface mesh created. The first parameter to the function <code>SetResolution</code> represents the number of points around a cross section. The number of points along the length of the yarns is automatically calculated such that the distance between points is similar to around the cross section.

Next we must add repeat vectors to define how the yarns are repeated.

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

The function <code>AddRepeat</code> takes an instance of the class <code>XYZ</code>. As we saw earlier the class <code>XYZ</code> is constructed with 3 numbers defining the X, Y and Z components.

Finally the yarn is fully defined, it can now be added to <code>Textile</code>:

# Add the yarn to our textile
Textile.AddYarn(Yarn)

This is the end of the loop, hence the following lines return to the original indentation. Now let's define a Domain within which the textile will be placed:

Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

The function <code>AssignDomain</code> takes an instance of a class derived from <code>CDomain</code>. In this case we will create a box shaped domain, this can be accomplished by using the class <code>CDomainPlanes</code>. A box can be created by passing in opposite corners of the box (the minimum and maximum coordinates). This is done again with the class <code>XYZ</code>.

And finally <code>Textile</code> must be added to so that it can be rendered. Each Textile added must be assigned a name to identify it, this is the name that will appear at the top in the TexGen GUI. This name can either be generated automatically or we can specify it explicitly like so:

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

That's it! You now have the knowledge to create any type of fabric imaginable. Well, almost. The model created here is pretty simple, there is plenty of oppertunity to create more complex shapes. For example non-constant cross sections can be defined, complex domain shapes defined by arbritrary planes, different interpolation functions.

Here is the completed script:

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

# Loop over all the yarns in the list
for Yarn in Yarns:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a domain and assign it to the textile
Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

And the result:

[[Image:Example2.png]]

===Example 3: A 3d weave===
This example is similar to the [[Scripting Create Models#Example 2: Another plain weave (the hard way)|Example 2]] in that the yarns will be defined by nodes. This time we will create a 3d woven fabric that looks like this:

[[Image:Example3.png]]

We start by defining a new CTextile instance:

# Create a textile
Textile = CTextile()

Before starting to define the geometry using TexGen it is helpful to define a list of parameters which may need to be changed later. These typically include spacing between yarns and yarn dimensions:

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

It is a good idea to define these up front rather than hard coding them in the rest of the script because if you want to tweak any parameters they can easily be located and will only need to be changed once. Lets start by defining the warp stuffer yarns, these are fairly easy to define since they all straight and parallel to each other:

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

Next we define the weft stuffer yarns, again these are easy to define:

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

And finally we need to insert the binder yarns. Making clever use of the repeat vectors it is only necessary to define a single instance of the binder yarn.

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Now that the geometry is defined we shall define a domain and add the textile so that TexGen knows about it.

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

The completed scripts is shown below:

# Create a textile
Textile = CTextile()

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

===Example 4: A sheared plain weave===
This example builds on [[Scripting Create Models#Example 2: Another plain weave (the hard way)|Example 2]], except this time we will be modeling a sheared unit cell. The final script can be found at the bottom, I will not step through each section of case as I have done for the previous cases since you should now be familiar with the basic procedure.

You will notice at the top of the script the line <code>from math import *</code>, this is a Python command to import the contents of the math module. We need this here because we will be making use of the value <code>pi</code> and functions <code>cos</code> and <code>sin</code>.

In this script I have also defined some constants up front (spacing, height, shear angle, twist angle and shear offset) as they will get used frequently within the script. It is best to define them as variables so that they can easily be modified later.

The position of the nodes are arranged as plain weave but displaced slightly by the shear offset. Note that if the shear angle is 0, the shear offset is also 0 and the position of the nodes is equivalent to [[Scripting Create Models#Example 2: Another plain weave (the hard way)|Example 2]].

The next difference is how the cross-section is defined. When a plain woven fabric is sheared the yarn is likely to twist, so we can no longer use a constant cross-section all along the length of the yarn. Instead here I have defined a yarn which twists in one direction at 1/4 of its way along the length of the yarn and twists in the other direction at 3/4 of the way along the length of the yarn. This is to avoid intersections between the yarns. The cross-section is interpolated at other positions along the yarn.

The repeat vectors are defined to take into account the shear and is fairly straight forwards.

The next complication is defining a domain which is shared. This is done by specifying 6 planes which define the bounds of the domain. The normals of the planes must point inwards, in the case of an unsheared fabric the normals are all in line with the global axes. But in order to create a lozenge shaped unit cell these normals must be rotated.

<pre>
from math import *

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Define some constants that will be used in further calculations
spacing = 0.22
height = 0.05

shearAngle = pi/16
twistAngle = shearAngle

shearOffset = spacing*sin(shearAngle)

# Add nodes to the yarns to describe their paths, these are the sheared node positions
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(spacing, shearOffset, height)))
Yarns[0].AddNode(CNode(XYZ(2*spacing, 2*shearOffset, 0)))

Yarns[1].AddNode(CNode(XYZ(0+shearOffset, spacing, height)))
Yarns[1].AddNode(CNode(XYZ(spacing+shearOffset, spacing+shearOffset, 0)))
Yarns[1].AddNode(CNode(XYZ(2*spacing+shearOffset, spacing+2*shearOffset, height)))

Yarns[2].AddNode(CNode(XYZ(0, 0, height)))
Yarns[2].AddNode(CNode(XYZ(shearOffset, spacing, 0)))
Yarns[2].AddNode(CNode(XYZ(2*shearOffset, 2*spacing, height)))

Yarns[3].AddNode(CNode(XYZ(spacing, 0+shearOffset, 0)))
Yarns[3].AddNode(CNode(XYZ(spacing+shearOffset, spacing+shearOffset, height)))
Yarns[3].AddNode(CNode(XYZ(spacing+2*shearOffset, 2*spacing+shearOffset, 0)))

# Create a cross-section which twists along the length of the yarn to accommodate the sheared fabric architecture
ellipse = CSectionEllipse(0.18, 0.04)
sectionTwist1 = CYarnSectionInterpPosition()
sectionTwist1.AddSection(0.25, CSectionRotated(ellipse, -twistAngle))
sectionTwist1.AddSection(0.75, CSectionRotated(ellipse, twistAngle))
sectionTwist2 = CYarnSectionInterpPosition()
sectionTwist2.AddSection(0.25, CSectionRotated(ellipse, twistAngle))
sectionTwist2.AddSection(0.75, CSectionRotated(ellipse, -twistAngle))

for Yarn in (Yarns[1], Yarns[3]):
Yarn.AssignSection(sectionTwist1)
for Yarn in (Yarns[0], Yarns[2]):
Yarn.AssignSection(sectionTwist2)

# Loop over all the yarns in the list
for Yarn in Yarns:
# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(2*spacing, 2*shearOffset, 0))
Yarn.AddRepeat(XYZ(2*shearOffset, 2*spacing, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a sheared domain with 6 planes
domain = CDomainPlanes()
d = (2*spacing-2*shearOffset*sin(shearAngle))/sqrt(1+sin(shearAngle)**2)
domain.AddPlane(PLANE(XYZ(1, -sin(shearAngle), 0), 0))
domain.AddPlane(PLANE(XYZ(-1, sin(shearAngle), 0), -d))
domain.AddPlane(PLANE(XYZ(-sin(shearAngle), 1, 0), 0))
domain.AddPlane(PLANE(XYZ(sin(shearAngle), -1, 0), -d))
domain.AddPlane(PLANE(XYZ(0, 0, 1), -height))
domain.AddPlane(PLANE(XYZ(0, 0, -1), -2*height))
Textile.AssignDomain(domain)

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)
</pre>

===Saving to TG3 file format===
TexGen has it's own file format for storing textile geometry with the extension .tg3. For more details on this file format please read the [[TG3 File Format]] page. Any textile models saved to this file format can be reloaded at a later time however it is also a good idea to keep the python script used to generate the geometry in case modifications need to be made. To save such a file it is simply a matter of adding an additional like at the end of your script like so:

SaveToXML("MyTextile.tg3")

The first parameter is the name of the file to save, note that if the .tg3 extension is omitted then it will automatically be appended for you. The second parameter is optional and if used should be the name of the textile to save, this is useful if you have several textiles loaded at once (i.e. you called AddTextile more than once) and you only want to save one of them. Note that if you don't specify the second parameter and you do have several textiles loaded then it will save all of them to a single .tg3 file. The third parameter determines how much information is saved in the .tg3 file, see the [[TG3 File Format]] for more details.

Scripting Create Models

2008-05-09T11:27:41Z

WikiSysop: /* Example 3: A 3d weave */

===Example 1: A plain weave===
First of all, a Python script is just a plain ASCII text file with a .py extension. To create one simply open up your favorite text editor. Notepad will do if you have nothing else but I suggest a more powerful freeware text editor like [http://www.pspad.com/ PSPad] or [http://notepad-plus.sourceforge.net/ Notepad++]. Code that goes into the python script will be displayed like so:

# All Python code will be shown in a box like this one.
# Lines begining with a '#' character are comments

In this example, we will create a simple 2x2 plain weave model with a Python script. Its time to dive in and see some actual Python code. At this point if you are completely lost please refer back to the resources on Python programming. The first step is to create an instance of the <code>CTextileWeave2D</code> class and give it a name, <code>weave</code>:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

The <code>CTextileWeave2D</code> class takes 5 parameters in the order shown below:
* Number of weft yarns in the unit cell
* Number of warp yarns in the unit cell
* Spacing between the yarns
* Thickness of the fabrics
* Refine model (True/False)

The only parameter that really needs an explanation here is the Refine model option, this controls whether or not the interference correction algorithm will be applied to keep the yarn volumes from intersecting which is a common problem. The interference correction algorithm generally does a good job but is not instantaneous so sometimes it can be beneficial to switch it off.

This is the bare minimum information necessary to create a 2D woven fabric. In the following steps we will add more information to create the model the way we want it.

Let's set the weave pattern, this determines whether a warp or weft yarn will appear on top at a particular cross over. Cross overs are arranged in 2d grid where the size of the grid depends on the number of warp and weft yarns created. To swap the positions of the weft and warp yarns, we call the function <code>SwapPosition</code> with the grid coordinates of the cross over. In order to create a plain weave we need to do this on two diagonally opposite cross overs like so:

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

Now let's add our <code>weave</code> model to the database of models so that TexGen can render it:

# Add the textile
AddTextile(weave)

Thats it! This is a very simple script but it will generate a plain weave model. To recap your Python script should look like this:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

# Add the textile
AddTextile(weave)

Save it to disk as ''PlainWeave.py'' or give it whatever name you want as long as it has a ''.py'' extension.

In order to test the Script we need to load it into TexGen. So start up the TexGen GUI and from the ''Python menu'' select ''Run Script''. Select the file you have just saved and click ok. With a bit of luck you should see a 2d plain weave on screen:

[[Image:Example1.png]]

Congratulations you have created your first TexGen Python script!

===Example 2: Another plain weave (the hard way)===
In the first example we made use of the <code>CTextileWeave2D</code> which is the reason the script is so compact. This was great for creating a 2D Weave, but what if we want to create something other than a 2D Weave? Well, let's stick to the 2D weave for now but in this example we will create geometric model in a generic way without the use of the <code>CTextileWeave2D</code> class. This takes a little bit longer to do, but gives more control over the final geometry.

First we will define a general textile and call it <code>Textile</code>:

# Create a textile
Textile = CTextile()

The <code>CTextile</code> class doesn't take any parameters, instead yarns will be created and added to it. Next we will create 4 yarns to go inside our textile, it is convenient to make use of the Python lists to do this. Create a list called <code>Yarns</code> with 4 elements, each one an instance of the class <code>CYarn</code>:

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

<code>Yarns</code> now contains 4 empty yarns. Note that the yarns are not currently associated with the Textile, first we must fill in the details then make them a part of the textile. The first thing to do is define their paths with nodes. This is done like so:

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

We have added 3 nodes to each yarn creating a woven pattern. The number in the square brackets after <code>Yarns</code> refers to a particular yarn in the list. The function <code>AddNode</code> is then called for the yarn. The function takes an instance of the class <code>CNode</code> which in turn is constructed with an instance of the class <code>XYZ</code> representing the position of the node. The class <code>XYZ</code> is constructed with 3 numbers representing the X, Y and Z coordinates of the point.

We still need to define a few more things to obtain a model. For the sake of simplicity, we will give all the yarns the same cross sectional shape, width, height, etc... The easiest way to do this is to loop over the yarns and assign the same properties to each yarn one by one. The syntax for looping over <code>Yarns</code> is shown here:

# Loop over all the yarns in the list
for Yarn in Yarns:

Inside the loop, the variable <code>Yarn</code> refers to the current yarn in the list. So within the loop we just assign properties to <code>Yarn</code> and they will be applied to all the yarns in the list. In python the begining and end of a loop are defined by indentation, hence the following lines are indented to represent the contents of the loop.

Let us define periodic cubic spline interpolation between the nodes:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

This is done with the function <code>AssignInterpolation</code> which takes an instance of a class derived from <code>CInterpolation</code>. In this case we used <code>CInterpolationCubic</code> to specify periodic cubic spline interpolation.

Next we need to define a cross section for the yarn, to keep things simple a constant cross section all along the length of the yarn will be defined:

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

The function <code>AssignSection</code> takes an instance of a class derived from <code>CYarnSection</code>. In this case we used <code>CYarnSectionConstant</code> which in turns take an instance of a class derived from <code>CSection</code> as a constructor. <code>CSectionEllipse</code> defines an elliptical cross section with given width and height defined by the first and second parameters respectively.

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

This line sets the resolution of the surface mesh created. The first parameter to the function <code>SetResolution</code> represents the number of points around a cross section. The number of points along the length of the yarns is automatically calculated such that the distance between points is similar to around the cross section.

Next we must add repeat vectors to define how the yarns are repeated.

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

The function <code>AddRepeat</code> takes an instance of the class <code>XYZ</code>. As we saw earlier the class <code>XYZ</code> is constructed with 3 numbers defining the X, Y and Z components.

Finally the yarn is fully defined, it can now be added to <code>Textile</code>:

# Add the yarn to our textile
Textile.AddYarn(Yarn)

This is the end of the loop, hence the following lines return to the original indentation. Now let's define a Domain within which the textile will be placed:

Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

The function <code>AssignDomain</code> takes an instance of a class derived from <code>CDomain</code>. In this case we will create a box shaped domain, this can be accomplished by using the class <code>CDomainPlanes</code>. A box can be created by passing in opposite corners of the box (the minimum and maximum coordinates). This is done again with the class <code>XYZ</code>.

And finally <code>Textile</code> must be added to so that it can be rendered. Each Textile added must be assigned a name to identify it, this is the name that will appear at the top in the TexGen GUI. This name can either be generated automatically or we can specify it explicitly like so:

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

That's it! You now have the knowledge to create any type of fabric imaginable. Well, almost. The model created here is pretty simple, there is plenty of oppertunity to create more complex shapes. For example non-constant cross sections can be defined, complex domain shapes defined by arbritrary planes, different interpolation functions.

Here is the completed script:

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

# Loop over all the yarns in the list
for Yarn in Yarns:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a domain and assign it to the textile
Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

And the result:

[[Image:Example2.png]]

===Example 3: A 3d weave===
This example is similar to the [[Scripting Create Models#Example 2: Another plain weave (the hard way)|Example 2]] in that the yarns will be defined by nodes. This time we will create a 3d woven fabric that looks like this:

[[Image:Example3.png]]

We start by defining a new CTextile instance:

# Create a textile
Textile = CTextile()

Before starting to define the geometry using TexGen it is helpful to define a list of parameters which may need to be changed later. These typically include spacing between yarns and yarn dimensions:

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

It is a good idea to define these up front rather than hard coding them in the rest of the script because if you want to tweak any parameters they can easily be located and will only need to be changed once. Lets start by defining the warp stuffer yarns, these are fairly easy to define since they all straight and parallel to each other:

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

Next we define the weft stuffer yarns, again these are easy to define:

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

And finally we need to insert the binder yarns. Making clever use of the repeat vectors it is only necessary to define a single instance of the binder yarn.

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Now that the geometry is defined we shall define a domain and add the textile so that TexGen knows about it.

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

The completed scripts is shown below:

# Create a textile
Textile = CTextile()

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

===Example 4: A sheared plain weave===
This example builds on [[Scripting Guide#Example 2: Another plain weave (the hard way)|Example 2]], except this time we will be modelling a sheared unit cell.

<pre>
from TexGen.Core import *
from math import *

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Define some constants that will be used in further calculations
spacing = 0.22
height = 0.05

shearAngle = pi/32
twistAngle = shearAngle

shearOffset = spacing*sin(shearAngle)

# Add nodes to the yarns to describe their paths, these are the sheared node positions
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(spacing, shearOffset, height)))
Yarns[0].AddNode(CNode(XYZ(2*spacing, 2*shearOffset, 0)))

Yarns[1].AddNode(CNode(XYZ(0+shearOffset, spacing, height)))
Yarns[1].AddNode(CNode(XYZ(spacing+shearOffset, spacing+shearOffset, 0)))
Yarns[1].AddNode(CNode(XYZ(2*spacing+shearOffset, spacing+2*shearOffset, height)))

Yarns[2].AddNode(CNode(XYZ(0, 0, height)))
Yarns[2].AddNode(CNode(XYZ(shearOffset, spacing, 0)))
Yarns[2].AddNode(CNode(XYZ(2*shearOffset, 2*spacing, height)))

Yarns[3].AddNode(CNode(XYZ(spacing, 0+shearOffset, 0)))
Yarns[3].AddNode(CNode(XYZ(spacing+shearOffset, spacing+shearOffset, height)))
Yarns[3].AddNode(CNode(XYZ(spacing+2*shearOffset, 2*spacing+shearOffset, 0)))

# Create a cross-section which twists along the length of the yarn to accommodate the sheared fabric architecture
ellipse = CSectionEllipse(0.18, 0.04)
sectionTwist1 = CYarnSectionInterpPosition()
sectionTwist1.AddSection(0.25, CSectionRotated(ellipse, -twistAngle))
sectionTwist1.AddSection(0.75, CSectionRotated(ellipse, twistAngle))
sectionTwist2 = CYarnSectionInterpPosition()
sectionTwist2.AddSection(0.25, CSectionRotated(ellipse, twistAngle))
sectionTwist2.AddSection(0.75, CSectionRotated(ellipse, -twistAngle))

for Yarn in (Yarns[1], Yarns[3]):
Yarn.AssignSection(sectionTwist1)
for Yarn in (Yarns[0], Yarns[2]):
Yarn.AssignSection(sectionTwist2)

# Loop over all the yarns in the list
for Yarn in Yarns:
# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(2*spacing, 2*shearOffset, 0))
Yarn.AddRepeat(XYZ(2*shearOffset, 2*spacing, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a sheared domain with 6 planes
domain = CDomainPlanes()
d = (2*spacing-2*shearOffset*sin(shearAngle))/sqrt(1+sin(shearAngle)**2)
domain.AddPlane(PLANE(XYZ(1, -sin(shearAngle), 0), 0))
domain.AddPlane(PLANE(XYZ(-1, sin(shearAngle), 0), -d))
domain.AddPlane(PLANE(XYZ(-sin(shearAngle), 1, 0), 0))
domain.AddPlane(PLANE(XYZ(sin(shearAngle), -1, 0), -d))
domain.AddPlane(PLANE(XYZ(0, 0, 1), -height))
domain.AddPlane(PLANE(XYZ(0, 0, -1), -2*height))
Textile.AssignDomain(domain)

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)
</pre>

===Saving to TG3 file format===
TexGen has it's own file format for storing textile geometry with the extension .tg3. For more details on this file format please read the [[TG3 File Format]] page. Any textile models saved to this file format can be reloaded at a later time however it is also a good idea to keep the python script used to generate the geometry in case modifications need to be made. To save such a file it is simply a matter of adding an additional like at the end of your script like so:

SaveToXML("MyTextile.tg3")

The first parameter is the name of the file to save, note that if the .tg3 extension is omitted then it will automatically be appended for you. The second parameter is optional and if used should be the name of the textile to save, this is useful if you have several textiles loaded at once (i.e. you called AddTextile more than once) and you only want to save one of them. Note that if you don't specify the second parameter and you do have several textiles loaded then it will save all of them to a single .tg3 file. The third parameter determines how much information is saved in the .tg3 file, see the [[TG3 File Format]] for more details.

Scripting Create Models

2008-05-09T11:26:45Z

WikiSysop:

===Example 1: A plain weave===
First of all, a Python script is just a plain ASCII text file with a .py extension. To create one simply open up your favorite text editor. Notepad will do if you have nothing else but I suggest a more powerful freeware text editor like [http://www.pspad.com/ PSPad] or [http://notepad-plus.sourceforge.net/ Notepad++]. Code that goes into the python script will be displayed like so:

# All Python code will be shown in a box like this one.
# Lines begining with a '#' character are comments

In this example, we will create a simple 2x2 plain weave model with a Python script. Its time to dive in and see some actual Python code. At this point if you are completely lost please refer back to the resources on Python programming. The first step is to create an instance of the <code>CTextileWeave2D</code> class and give it a name, <code>weave</code>:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

The <code>CTextileWeave2D</code> class takes 5 parameters in the order shown below:
* Number of weft yarns in the unit cell
* Number of warp yarns in the unit cell
* Spacing between the yarns
* Thickness of the fabrics
* Refine model (True/False)

The only parameter that really needs an explanation here is the Refine model option, this controls whether or not the interference correction algorithm will be applied to keep the yarn volumes from intersecting which is a common problem. The interference correction algorithm generally does a good job but is not instantaneous so sometimes it can be beneficial to switch it off.

This is the bare minimum information necessary to create a 2D woven fabric. In the following steps we will add more information to create the model the way we want it.

Let's set the weave pattern, this determines whether a warp or weft yarn will appear on top at a particular cross over. Cross overs are arranged in 2d grid where the size of the grid depends on the number of warp and weft yarns created. To swap the positions of the weft and warp yarns, we call the function <code>SwapPosition</code> with the grid coordinates of the cross over. In order to create a plain weave we need to do this on two diagonally opposite cross overs like so:

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

Now let's add our <code>weave</code> model to the database of models so that TexGen can render it:

# Add the textile
AddTextile(weave)

Thats it! This is a very simple script but it will generate a plain weave model. To recap your Python script should look like this:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

# Add the textile
AddTextile(weave)

Save it to disk as ''PlainWeave.py'' or give it whatever name you want as long as it has a ''.py'' extension.

In order to test the Script we need to load it into TexGen. So start up the TexGen GUI and from the ''Python menu'' select ''Run Script''. Select the file you have just saved and click ok. With a bit of luck you should see a 2d plain weave on screen:

[[Image:Example1.png]]

Congratulations you have created your first TexGen Python script!

===Example 2: Another plain weave (the hard way)===
In the first example we made use of the <code>CTextileWeave2D</code> which is the reason the script is so compact. This was great for creating a 2D Weave, but what if we want to create something other than a 2D Weave? Well, let's stick to the 2D weave for now but in this example we will create geometric model in a generic way without the use of the <code>CTextileWeave2D</code> class. This takes a little bit longer to do, but gives more control over the final geometry.

First we will define a general textile and call it <code>Textile</code>:

# Create a textile
Textile = CTextile()

The <code>CTextile</code> class doesn't take any parameters, instead yarns will be created and added to it. Next we will create 4 yarns to go inside our textile, it is convenient to make use of the Python lists to do this. Create a list called <code>Yarns</code> with 4 elements, each one an instance of the class <code>CYarn</code>:

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

<code>Yarns</code> now contains 4 empty yarns. Note that the yarns are not currently associated with the Textile, first we must fill in the details then make them a part of the textile. The first thing to do is define their paths with nodes. This is done like so:

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

We have added 3 nodes to each yarn creating a woven pattern. The number in the square brackets after <code>Yarns</code> refers to a particular yarn in the list. The function <code>AddNode</code> is then called for the yarn. The function takes an instance of the class <code>CNode</code> which in turn is constructed with an instance of the class <code>XYZ</code> representing the position of the node. The class <code>XYZ</code> is constructed with 3 numbers representing the X, Y and Z coordinates of the point.

We still need to define a few more things to obtain a model. For the sake of simplicity, we will give all the yarns the same cross sectional shape, width, height, etc... The easiest way to do this is to loop over the yarns and assign the same properties to each yarn one by one. The syntax for looping over <code>Yarns</code> is shown here:

# Loop over all the yarns in the list
for Yarn in Yarns:

Inside the loop, the variable <code>Yarn</code> refers to the current yarn in the list. So within the loop we just assign properties to <code>Yarn</code> and they will be applied to all the yarns in the list. In python the begining and end of a loop are defined by indentation, hence the following lines are indented to represent the contents of the loop.

Let us define periodic cubic spline interpolation between the nodes:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

This is done with the function <code>AssignInterpolation</code> which takes an instance of a class derived from <code>CInterpolation</code>. In this case we used <code>CInterpolationCubic</code> to specify periodic cubic spline interpolation.

Next we need to define a cross section for the yarn, to keep things simple a constant cross section all along the length of the yarn will be defined:

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

The function <code>AssignSection</code> takes an instance of a class derived from <code>CYarnSection</code>. In this case we used <code>CYarnSectionConstant</code> which in turns take an instance of a class derived from <code>CSection</code> as a constructor. <code>CSectionEllipse</code> defines an elliptical cross section with given width and height defined by the first and second parameters respectively.

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

This line sets the resolution of the surface mesh created. The first parameter to the function <code>SetResolution</code> represents the number of points around a cross section. The number of points along the length of the yarns is automatically calculated such that the distance between points is similar to around the cross section.

Next we must add repeat vectors to define how the yarns are repeated.

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

The function <code>AddRepeat</code> takes an instance of the class <code>XYZ</code>. As we saw earlier the class <code>XYZ</code> is constructed with 3 numbers defining the X, Y and Z components.

Finally the yarn is fully defined, it can now be added to <code>Textile</code>:

# Add the yarn to our textile
Textile.AddYarn(Yarn)

This is the end of the loop, hence the following lines return to the original indentation. Now let's define a Domain within which the textile will be placed:

Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

The function <code>AssignDomain</code> takes an instance of a class derived from <code>CDomain</code>. In this case we will create a box shaped domain, this can be accomplished by using the class <code>CDomainPlanes</code>. A box can be created by passing in opposite corners of the box (the minimum and maximum coordinates). This is done again with the class <code>XYZ</code>.

And finally <code>Textile</code> must be added to so that it can be rendered. Each Textile added must be assigned a name to identify it, this is the name that will appear at the top in the TexGen GUI. This name can either be generated automatically or we can specify it explicitly like so:

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

That's it! You now have the knowledge to create any type of fabric imaginable. Well, almost. The model created here is pretty simple, there is plenty of oppertunity to create more complex shapes. For example non-constant cross sections can be defined, complex domain shapes defined by arbritrary planes, different interpolation functions.

Here is the completed script:

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

# Loop over all the yarns in the list
for Yarn in Yarns:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a domain and assign it to the textile
Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

And the result:

[[Image:Example2.png]]

===Example 3: A 3d weave===
This example is similar to the [[Scripting Guide#Example 2: Another plain weave (the hard way)|Example 2]] in that the yarns will be defined by nodes. This time we will create a 3d woven fabric that looks like this:

[[Image:Example3.png]]

We start by defining a new CTextile instance:

# Create a textile
Textile = CTextile()

Before starting to define the geometry using TexGen it is helpful to define a list of parameters which may need to be changed later. These typically include spacing between yarns and yarn dimensions:

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

It is a good idea to define these up front rather than hard coding them in the rest of the script because if you want to tweak any parameters they can easily be located and will only need to be changed once. Lets start by defining the warp stuffer yarns, these are fairly easy to define since they all straight and parallel to each other:

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

Next we define the weft stuffer yarns, again these are easy to define:

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

And finally we need to insert the binder yarns. Making clever use of the repeat vectors it is only necessary to define a single instance of the binder yarn.

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Now that the geometry is defined we shall define a domain and add the textile so that TexGen knows about it.

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

The completed scripts is shown below:

# Create a textile
Textile = CTextile()

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

===Example 4: A sheared plain weave===
This example builds on [[Scripting Guide#Example 2: Another plain weave (the hard way)|Example 2]], except this time we will be modelling a sheared unit cell.

<pre>
from TexGen.Core import *
from math import *

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Define some constants that will be used in further calculations
spacing = 0.22
height = 0.05

shearAngle = pi/32
twistAngle = shearAngle

shearOffset = spacing*sin(shearAngle)

# Add nodes to the yarns to describe their paths, these are the sheared node positions
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(spacing, shearOffset, height)))
Yarns[0].AddNode(CNode(XYZ(2*spacing, 2*shearOffset, 0)))

Yarns[1].AddNode(CNode(XYZ(0+shearOffset, spacing, height)))
Yarns[1].AddNode(CNode(XYZ(spacing+shearOffset, spacing+shearOffset, 0)))
Yarns[1].AddNode(CNode(XYZ(2*spacing+shearOffset, spacing+2*shearOffset, height)))

Yarns[2].AddNode(CNode(XYZ(0, 0, height)))
Yarns[2].AddNode(CNode(XYZ(shearOffset, spacing, 0)))
Yarns[2].AddNode(CNode(XYZ(2*shearOffset, 2*spacing, height)))

Yarns[3].AddNode(CNode(XYZ(spacing, 0+shearOffset, 0)))
Yarns[3].AddNode(CNode(XYZ(spacing+shearOffset, spacing+shearOffset, height)))
Yarns[3].AddNode(CNode(XYZ(spacing+2*shearOffset, 2*spacing+shearOffset, 0)))

# Create a cross-section which twists along the length of the yarn to accommodate the sheared fabric architecture
ellipse = CSectionEllipse(0.18, 0.04)
sectionTwist1 = CYarnSectionInterpPosition()
sectionTwist1.AddSection(0.25, CSectionRotated(ellipse, -twistAngle))
sectionTwist1.AddSection(0.75, CSectionRotated(ellipse, twistAngle))
sectionTwist2 = CYarnSectionInterpPosition()
sectionTwist2.AddSection(0.25, CSectionRotated(ellipse, twistAngle))
sectionTwist2.AddSection(0.75, CSectionRotated(ellipse, -twistAngle))

for Yarn in (Yarns[1], Yarns[3]):
Yarn.AssignSection(sectionTwist1)
for Yarn in (Yarns[0], Yarns[2]):
Yarn.AssignSection(sectionTwist2)

# Loop over all the yarns in the list
for Yarn in Yarns:
# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(2*spacing, 2*shearOffset, 0))
Yarn.AddRepeat(XYZ(2*shearOffset, 2*spacing, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a sheared domain with 6 planes
domain = CDomainPlanes()
d = (2*spacing-2*shearOffset*sin(shearAngle))/sqrt(1+sin(shearAngle)**2)
domain.AddPlane(PLANE(XYZ(1, -sin(shearAngle), 0), 0))
domain.AddPlane(PLANE(XYZ(-1, sin(shearAngle), 0), -d))
domain.AddPlane(PLANE(XYZ(-sin(shearAngle), 1, 0), 0))
domain.AddPlane(PLANE(XYZ(sin(shearAngle), -1, 0), -d))
domain.AddPlane(PLANE(XYZ(0, 0, 1), -height))
domain.AddPlane(PLANE(XYZ(0, 0, -1), -2*height))
Textile.AssignDomain(domain)

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)
</pre>

===Saving to TG3 file format===
TexGen has it's own file format for storing textile geometry with the extension .tg3. For more details on this file format please read the [[TG3 File Format]] page. Any textile models saved to this file format can be reloaded at a later time however it is also a good idea to keep the python script used to generate the geometry in case modifications need to be made. To save such a file it is simply a matter of adding an additional like at the end of your script like so:

SaveToXML("MyTextile.tg3")

The first parameter is the name of the file to save, note that if the .tg3 extension is omitted then it will automatically be appended for you. The second parameter is optional and if used should be the name of the textile to save, this is useful if you have several textiles loaded at once (i.e. you called AddTextile more than once) and you only want to save one of them. Note that if you don't specify the second parameter and you do have several textiles loaded then it will save all of them to a single .tg3 file. The third parameter determines how much information is saved in the .tg3 file, see the [[TG3 File Format]] for more details.

Compiling from Source

2008-05-02T15:07:10Z

WikiSysop: /* Configuring optional modules */

In order to compile TexGen and '''all''' of its modules, the following software is required:

The following programs are needed to build TexGen:
* [http://www.cmake.org/ CMake]
* [http://www.swig.org/ SWIG]

The following libraries are needed to link to TexGen:
* [http://www.vtk.org/ VTK]
* [http://www.wxwidgets.org/ wxWidgets]
* [http://www.opencascade.org/ OpenCascade]
* [http://www.python.org/ Python]

However to perform a minimum build of TexGen with none of the additional modules you only require CMake and a C++ compiler. It is recommended to begin with a minimum build, once that is working try adding modules one at a time. A list of modules along with dependencies is shown below:

* Python interface: Python, SWIG
* Renderer: VTK
* Export: OpenCascade
* GUI: wxWidgets, Renderer, Python interface
* Unit tests: CPPUnit

A graphical representation of the modules and their dependencies can also be found in the [http://texgen.sourceforge.net/api/ TexGen API].

If you want to get the source code from the Subversion repository you will need to install [http://subversion.tigris.org/ Subversion] by following the instructions below. Note that this is the very latest development source and so may it contain some bugs and unfinished features. However it is very easy to keep up to date with the latest version of TexGen using this method and will allow you to keep any modifications you have made to the source when updating. If you find a bug or implement new features that may be usefull to the rest of the community they can also be submited as patch and incorporated into TexGen following review.

Alternatively the stable source code can be downloaded as a [http://sourceforge.net/project/showfiles.php?group_id=181000 tarball]. Download the latest file release named ''texgen-3.x.x.tar.gz''.

== Windows (Microsoft Visual Studio C++, recommended method) ==
=== Prerequisites ===
It is assumed that Microsoft Visual Studio is already installed. If it isn't and you plan to use it, then install it. It may be possible to use the free [http://www.microsoft.com/express/ Visual Studio Express]; if anyone tries this and finds out one way or the other, please post the information either here or in the [http://texgen.sourceforge.net/phpBB2/index.php forum]. Brief instructions on how to install the various 3rd party libraries under windows are given below. Note that you do not need to install all of these in order to perform the minimal build. Only CMake is absolutely required.

==== CMake ====

[http://www.cmake.org/HTML/Download.html Download CMake] and install, selecting 'Add CMake to the system PATH for all users' (select current user if this is not permissible on your system).

==== TortoiseSVN ====

[http://tortoisesvn.net/downloads Download TortoiseSVN] and install it.

==== SWIG ====

[http://www.swig.org/ Download] the latest release of the windows .zip files and extract to a suitable location (e.g. c:\Program Files\swigwin-1.3.31).

==== Python ====

[http://www.python.org/ Download Python] and install.

==== OpenCascade ====

[http://www.opencascade.org/getocc/download/ Download OpenCascade] and install; this extracts the files to a directory. If the installation doesn't start automatically, run the 'install.bat' file located the directory where the files where extracted (read 'readme.htm' file in the same directory for more information). Choose 'complete installation' and tick the box to set the environment variables.

==== VTK ====

[http://www.vtk.org/get-software.php Download] the latest source files and extract them. Follow the instructions in 'README.html' found in the extracted directory to compile VTK using CMake. The following CMake settings should be set:

BUILD_EXAMPLES OFF
BUILD_SHARED_LIBS OFF
VTK_USE_MPEG2_ENCODER OFF
VTK_USE_PARALLEL OFF
VTK_USE_RENDERING ON
VTK_WRAP_JAVA OFF
VTK_WRAP_PYTHON OFF
VTK_WRAP_TCL OFF

You may be able to get things working with different settings, however these are the settings I use and are known to work.

==== wxWidgets ====

[http://www.wxwidgets.org/downloads/ Download] and install the windows version of wxWidgets (wxMSW). It is then necessary to compile wxWidgets from source, detailed instructions on how to do this can be found in 'install.txt' located in the 'docs\msw' subfolder. The main steps are to open 'wx.dsw' with MSVC located in the 'build\msw' subfolder and compile both Release and Debug configurations (The configuration can be selected from the drop down box on the main toolbar in Visual Studio. Universal, Unicode and DLL versions need not be compiled).

=== Checkout TexGen source code from subversion server ===
Create a directory where you would like to store the TexGen source code in Windows Explorer. Right click on this folder and select 'SVN Checkout...' from the context menu that appears. In the dialog box which follows, enter 'https://texgen.svn.sourceforge.net/svnroot/texgen/TexGen/trunk/' in the URL field. The Checkout directory field should have been filled in automatically. Click on OK to start downloading the TexGen source code. In future the latest version of the source code can be obtained simply by right clicking on the folder and selecting 'SVN Update' from the context menu.

=== Configuring the build system with CMake ===
Run CMake from its shortcut on the Start menu. There are some general instructions on using CMake on the [http://www.cmake.org/HTML/RunningCMake.html CMake website] which are worth reading. You will need to fill in the source code location, this should point to where you checkout out the latest TexGen SVN code or where you extracted the source code from the zip file. Also set where to place the binary files once they are compiled, this can be the same as the source directory, a subdirectory within the source directory or any other location.

Once that is entered click 'Configure' and choose the Visual Studio version which you have installed and click ok. You will initially get a number of error messages such as:

CMake Error: Swig was not found on the system. Please specify the location of Swig. (click OK)
CMake Error: Error in configuration process, project files may be invalid. (click OK)

This is normal, in order to get rid of the errors you will need to tell CMake where the various libraries you have installed can be found. This is done in the Cache Values sections.

It is recommended to begin with a minimal build, this is achieved by setting the cache values as follows:

BUILD_CASCADE_EXPORT OFF
BUILD_DOCUMENTATION OFF
BUILD_EXAMPLES OFF
BUILD_GUI OFF
BUILD_PYTHON_INTERFACE OFF
BUILD_RENDERER OFF
BUILD_SHARED ON
BUILD_UNIT_TESTS OFF

Once these are set press configure again and you shouldn't have any more errors/warnings. Press 'OK' to generate the MSVC solution and project files. Configuring the various optional modules is explained in [[#Configuring optional modules]].

=== Configuring optional modules ===

Once the minimal build is working you may want to switch on the optional modules. To do this open up CMake again and switch the modules you want to ON in the Cache Values then click Configure. You will most likely see some errors telling you it is unable to automatically find certain directories. You will need to specify these manually. An explanation of the different locations is listed below:

'''PYTHON_SITEPACKAGES_DIR''' - This should be the folder where the TexGen python modules will be placed. Usually located in 'C:\Python25\Lib\site-packages', but this will depend on the version of Python installed and where you decided to install it.

'''SWIG_DIR''' - This is the location where you extracted the SWIG executable. e.g. 'C:\Program Files\swigwin-1.3.35'.

'''SWIG_EXECUTABLE''' - Same as root directory followed by 'swig.exe'

'''wxWidgets_ROOT_DIR''' - Location where you install wxWidgets. e.g. 'C:/wxWidgets-2.8.7'.

'''wxWidgets_LIB_DIR''' - Location where the wxWidgets libraries were compiled to, should be the same as the root directory followed by 'lib\vc_lib'.

'''OPENCASCADE_INCLUDE_DIR''' - Location where the OpenCascade header files are located. e.g. 'C:/OpenCASCADE6.1.0/ros/inc'.

'''OPENCASCADE_LIBRARY_DIR''' - Location where the OpenCascade libraries are located. e.g. 'C:/OpenCASCADE6.1.0/ros/win32/lib'.

'''OPENCASCADE_DEBUG_LIBRARY_DIR''' - Location where the OpenCascade debug libraries are located. e.g. 'C:/OpenCASCADE6.1.0/ros/win32/libd'.

'''VTK_DIR''' - Location of the VTK binary directory (note: not the source directory).

After setting the directories manually, click on configure again. You may need to go through several iterations of changing parameters then pressing configure. Once you have finished changing parameters and have successfully pressed configure without error messages you can press the OK button to generate the build. Note: you can always come back to this at a later time to make changes.

=== Compiling ===

Find 'TexGen.sln' which should be located in the directory where you told CMake to output the binary files to and open it with Microsoft Visual Studio.

Set the configuration to 'Release' and build the solution. Hopefully the project will have been compiled without errors.

If you want to compile and execute the Graphical User Interface you will need to install it, you will not be able to execute it directly from the build directory. This is done by right click on the 'INSTALL' project in the Solution Explorer and selecting Build. This will copy the Python modules into the Python site-packages directory so that they can be imported into scripts, and it will copy the executable along with other necessary files into 'C:\Program Files\TexGen\' by default (this can be changed with the CMAKE_INSTALL_PREFIX cache value in CMake). TexGenGUI.exe should then be run from the installed location, if you attempt to run it directly from where it was compiled you will get some errors on launch.

=== Building the documentation ===

To build the documentation, [http://www.stack.nl/~dimitri/doxygen/download.html Doxygen] is required. Open a command prompt in the 'Docs' subdirectory of the source code and run 'doxygen'. If the doxygen directory is not in your path, you must add it, or give the full path on the command line.

=== Integrating TexGen with ABAQUS ===

If you are using ABAQUS and wish to use TexGen Python scripting from within the ABAQUS/CAE environment, there are a few extra steps to perform. This is because ABAQUS comes packaged with its own version of Python, so any modules added to your standalone python installation will not be accessible by ABAQUS. You must compile the TexGen Python modules with the same version of Python as ABAQUS uses. The following table shows which version of Python is used in specific ABAQUS versions:

{| class="wikitable" style="text-align:center" border="1"
! ABAQUS Version !! Python Version
|-
| 6.6-1 || 2.3.3
|-
| 6.7-1 || 2.4.3
|}

If your version of ABAQUS is not listed in the table above you can type 'abaqus python -V' to check what version of Python is used (then please edit this page to update the table). You can obtain specific versions of Python from http://www.python.org/download/releases/x.y.z/ where x.y.z represents the version number.

Additionally you will need to place the TexGen python modules inside ABAQUS' version of python. There are a few ways to accomplish this, the easiest is perhaps to set the CMake cache variable 'PYTHON_SITEPACKAGES_DIR' point to the ABAQUS' python directory, e.g.:

PYTHON_SITEPACKAGES_DIR C:\Abaqus\6.7-1\Python\Lib\

Then when you build the INSTALL project in MSVC++ it will automatically copy the TexGen python modules to the ABAQUS' Python. Alternatively you can simply copy the files manually or modify Python's search path to include the TexGen python modules, e.g. In python:

import sys
sys.path.append('C:/Python24/Lib/site-packages/')

=== Troubleshooting ===

'''Q:''' I get the following error when compiling:
fatal error LNK1104: cannot open file 'python25_d.lib'

'''A:''' The windows installation of Python doesn't come with the debug library ('python25_d.lib', the _d part means debug). You should be able to compile in release mode however. If you really want to compile in debug mode you will need to compile Python from source and link to that. Or you can try to link to the release library 'python25.lib' instead, easiest way to do that is to copy 'python25.lib' to 'python25_d.lib' but this may cause problems during linking or execution.

'''Q:''' I get the following error when compiling:
fatal error C1083: Cannot open include file: 'wx/wxprec.h': No such file or directory

'''A:''' Make sure that you have compiled wxWidgets and that the wxWidgets_XXX cache variables are set correctly in CMake.

'''Q:''' I do not have a 'libd' folder in 'ros/win32' for OpenCASCADE.

'''A:''' If you do not compile OpenCASCADE yourself then this folder does not exist. However it can be ignored if you are only interested in building the release version of TexGen. If you really want to compile the debug version please refer to the OpenCASCADE documentation.

== Windows (Cygwin and gcc, alternate method) ==
A limited build (without graphics) can be made under cygwin, this is a UNIX emulation environment available at [http://www.cygwin.com www.cygwin.com].
This can exist peacefully next to the native windows version.
Cygwin creates a unix-style file system within your windows installation. If you choose c:/cygwin as your install directory, your HOME will be at c:/cygwin/home/<username>/.

=== Download cygwin and install packages ===
Install gcc, g++, wget, make and cmake using the setup.exe program from the cygwin website.
For the mesh generator and python interface to work we currently need VTK and swig.

This downloads and installs swig from source (when starting the cygwin shell you can paste this into the command line, otherwise write it to a file and run it with sh).
mkdir progs
cd progs
SWIG=swig-1.3.31
wget -nc http://kent.dl.sourceforge.net/sourceforge/swig/$SWIG.tar.gz
tar xzvf $SWIG.tar.gz
cd $SWIG
./configure
make
make install

This downloads and installs VTK from source, in the ccmake stage, use the cmake graphical commands to get a working install.
VTK=vtk-5.0.3
wget -nc http://www.vtk.org/files/release/5.0/$VTK.tar.gz
tar xzvf $VTK.tar.gz
mkdir vtkbin
cd vtkbin
ccmake ../VTK
make
make install

=== Install TexGen from source ===
Now we can proceed to install texgen, as an example we'll work in ~/temp/texgen
cd ~; mkdir temp; cd temp; mkdir texgen; cd texgen
svn checkout https://texgen.svn.sourceforge.net/svnroot/texgen/TexGen/trunk/ TexGen
cd .. ; mkdir tbin; cd tbin
ccmake ../texgen
make
make install

This should result in a working texgen install in ~/temp/texgen/tbin.

== Unix ==
=== Notes ===
If you are installing to a system where you don't have root access (i.e. this computer does not belong to you) you won't be able to install the software using the default configure script. This is because by default software is installed to the /usr/local directory. If you are not a systems administrator then you will quite rightly not have write access to this folder. All is not lost! You can still install software into your home directory. In order to do this you should always call the configure script with the following parameter: --prefix=$HOME. This goes for all the software to be installed below. All executables will then be placed in ~/bin, libraries in ~/lib, includes in ~/include, etc...

In the guide below the parameter is included in italic. If you do in fact have root access then it is recommended to omit this parameter and install to the default directory so that other users will also have access to the software.

=== Get TexGen from Subversion repository ===

==== Install Subversion ====
[http://subversion.tigris.org/servlets/ProjectDocumentList?collapseFolder=260&folderID=260 Download Subversion] and unpack.
Open a shell in extracted folder and type:
./configure --with-ssl ''--prefix=$HOME''
make
make install

Notes:
* You will need to install Subversion with SSL support since TexGen is hosted on sourceforge which uses SSL. If you don't configure with the --with-ssl flag you will get an error when trying to checkout TexGen in the next step.
* If you have trouble installing the latest version of Subversion, try installing version 1.3 as it does not require a seperate dependencies package.

==== Checkout ====
Open a shell in folder you wish to place TexGen (e.g. ~/):
svn checkout https://texgen.svn.sourceforge.net/svnroot/texgen/TexGen/trunk/ TexGen

Notes:
* The first parameter tells SVN to get the files for the first time
* The second parameter is the location of the TexGen svn repository
* The final parameter is the subfolder to put the files in

==== Update ====
The checkout command only needs to performed once. SVN keeps track of where the code was originally obtained and can update to the latest version without having to re-specify the location. In order to do that open a shell in the folder where TexGen was originally checkout (e.g. ~/TexGen) and type:
svn update
or if you are in a hurry you can type the shorter version:
svn up

=== Compile source ===

==== Install CMake ====

[http://www.cmake.org/HTML/Download.html Download CMake] and unpack.
Open a shell in extracted folder and type:
./configure ''--prefix=$HOME''
make
make install

==== Compile TexGen core ====
Open a shell in the folder with the TexGen source code (e.g. ~/TexGen):
mkdir bin
cd bin
ccmake ../
Press 'c' to configure. When a warning pops up telling you it can't find such and such a file press 'e' to close it. You will now need to specify which components of TexGen to build and where their dependencies can be found. Use the up and down arrows to move the caret and press enter to modify options. Do this to set BUILD_GUI, BUILD_PYTHON_INTERFACE and BUILD_RENDERER to OFF. You are basically telling CMake not to attempt to build these components, which means that you won't need to have installed their dependencies.

Similarly to the --prefix=$HOME parameter to the configure script, you can tell CMake to install TexGen to your home directory by changing CMAKE_INSTALL_PREFIX to ~/. Note that it won't actually install anything until you get type make install.

Now press 'c' again to update the changes.

Hopefully now that all the additional modules have been switched off no errors will be shown. Press 'g' to generate the makefiles and exit. At the shell type:
make
make install

Note that at this point you have only built and installed the TexGen Core library which doesn't actually do anything on its own. If you plan to incorporate TexGen into your own C++ program then this is enough, however if you would like to interface with TexGen from a Python script or Graphical User Interface then follow the steps below.

=== Compiling optional modules ===
==== Python interface ====
[http://www.python.org/download/ Download Python] and unpack.
Open a shell in the extracted folder and type:
./configure ''--prefix=$HOME''
make
make install

[http://www.swig.org/download.html Download SWIG] and unpack.
Open a shell in the extracted folder and type:
./configure ''--prefix=$HOME''
make
make install

Open a shell in the folder where you called ccmake from for the first time (e.g. ~/TexGen/bin):
ccmake ../

Use the up and down arrows to reach BUILD_PYTHON_INTERFACE and press Enter to set it to ON. Then press 'c' to configure. You will probably get a warning saying you need to specify the location of SWIG and/or Python, press 'e' to close it.

Set the PYTHON_INCLUDE_PATH, PYTHON_LIBRARY, PYTHON_SITEPACKAGES_DIR, SWIG_DIR and SWIG_EXECUTABLE parameters correctly where necessary. If you have installed packages to your home directory then they should look something like this:

PYTHON_INCLUDE_PATH: ~/include/python2.5
PYTHON_LIBRARY: ~/lib/python2.5/config/libpython2.5.a
PYTHON_SITEPACKAGES_DIR: ~/lib/python2.5/site-packages
SWIG_DIR: ~/bin
SWIG_EXECUTABLE: ~/bin/swig

Once that is done press 'c' again. You may need perform this process over several iterations. When everything is set correctly press 'g' to generate the makefiles.

At the shell type:
make
make install

Assuming the build completed without errors you should now be able to access TexGen functions from within Python. In order to check everything worked as planned open Python in interactive mode by typing:
python

Then from within Python type:
from TexGen.Core import *
CTexGen.GetInstance().GetVersion()

This should display the version of TexGen installed.

=== Troubleshooting ===

'''Q:''' I get the following error when linking _Core.so:
libpython2.5.a(abstract.o): relocation R_X86_64_32 against `a local symbol'
can not be used when making a shared object; recompile with -fPIC

'''A:''' Try removing libpython2.5.a from the libraries to link to by setting PYTHON_LIBRARY to a bogus path, e.g.:

PYTHON_LIBRARY: ~/

By doing so you may receive a warning similar to this:
Warning: Ignoring path found in link libraries for target: _Core, path is:
/home/username. Expected a library name or a full path to a library name.
This warning may be ignored.

Compiling from Source

2008-05-02T15:05:50Z

WikiSysop: /* Prerequisites */

In order to compile TexGen and '''all''' of its modules, the following software is required:

The following programs are needed to build TexGen:
* [http://www.cmake.org/ CMake]
* [http://www.swig.org/ SWIG]

The following libraries are needed to link to TexGen:
* [http://www.vtk.org/ VTK]
* [http://www.wxwidgets.org/ wxWidgets]
* [http://www.opencascade.org/ OpenCascade]
* [http://www.python.org/ Python]

However to perform a minimum build of TexGen with none of the additional modules you only require CMake and a C++ compiler. It is recommended to begin with a minimum build, once that is working try adding modules one at a time. A list of modules along with dependencies is shown below:

* Python interface: Python, SWIG
* Renderer: VTK
* Export: OpenCascade
* GUI: wxWidgets, Renderer, Python interface
* Unit tests: CPPUnit

A graphical representation of the modules and their dependencies can also be found in the [http://texgen.sourceforge.net/api/ TexGen API].

If you want to get the source code from the Subversion repository you will need to install [http://subversion.tigris.org/ Subversion] by following the instructions below. Note that this is the very latest development source and so may it contain some bugs and unfinished features. However it is very easy to keep up to date with the latest version of TexGen using this method and will allow you to keep any modifications you have made to the source when updating. If you find a bug or implement new features that may be usefull to the rest of the community they can also be submited as patch and incorporated into TexGen following review.

Alternatively the stable source code can be downloaded as a [http://sourceforge.net/project/showfiles.php?group_id=181000 tarball]. Download the latest file release named ''texgen-3.x.x.tar.gz''.

== Windows (Microsoft Visual Studio C++, recommended method) ==
=== Prerequisites ===
It is assumed that Microsoft Visual Studio is already installed. If it isn't and you plan to use it, then install it. It may be possible to use the free [http://www.microsoft.com/express/ Visual Studio Express]; if anyone tries this and finds out one way or the other, please post the information either here or in the [http://texgen.sourceforge.net/phpBB2/index.php forum]. Brief instructions on how to install the various 3rd party libraries under windows are given below. Note that you do not need to install all of these in order to perform the minimal build. Only CMake is absolutely required.

==== CMake ====

[http://www.cmake.org/HTML/Download.html Download CMake] and install, selecting 'Add CMake to the system PATH for all users' (select current user if this is not permissible on your system).

==== TortoiseSVN ====

[http://tortoisesvn.net/downloads Download TortoiseSVN] and install it.

==== SWIG ====

[http://www.swig.org/ Download] the latest release of the windows .zip files and extract to a suitable location (e.g. c:\Program Files\swigwin-1.3.31).

==== Python ====

[http://www.python.org/ Download Python] and install.

==== OpenCascade ====

[http://www.opencascade.org/getocc/download/ Download OpenCascade] and install; this extracts the files to a directory. If the installation doesn't start automatically, run the 'install.bat' file located the directory where the files where extracted (read 'readme.htm' file in the same directory for more information). Choose 'complete installation' and tick the box to set the environment variables.

==== VTK ====

[http://www.vtk.org/get-software.php Download] the latest source files and extract them. Follow the instructions in 'README.html' found in the extracted directory to compile VTK using CMake. The following CMake settings should be set:

BUILD_EXAMPLES OFF
BUILD_SHARED_LIBS OFF
VTK_USE_MPEG2_ENCODER OFF
VTK_USE_PARALLEL OFF
VTK_USE_RENDERING ON
VTK_WRAP_JAVA OFF
VTK_WRAP_PYTHON OFF
VTK_WRAP_TCL OFF

You may be able to get things working with different settings, however these are the settings I use and are known to work.

==== wxWidgets ====

[http://www.wxwidgets.org/downloads/ Download] and install the windows version of wxWidgets (wxMSW). It is then necessary to compile wxWidgets from source, detailed instructions on how to do this can be found in 'install.txt' located in the 'docs\msw' subfolder. The main steps are to open 'wx.dsw' with MSVC located in the 'build\msw' subfolder and compile both Release and Debug configurations (The configuration can be selected from the drop down box on the main toolbar in Visual Studio. Universal, Unicode and DLL versions need not be compiled).

=== Checkout TexGen source code from subversion server ===
Create a directory where you would like to store the TexGen source code in Windows Explorer. Right click on this folder and select 'SVN Checkout...' from the context menu that appears. In the dialog box which follows, enter 'https://texgen.svn.sourceforge.net/svnroot/texgen/TexGen/trunk/' in the URL field. The Checkout directory field should have been filled in automatically. Click on OK to start downloading the TexGen source code. In future the latest version of the source code can be obtained simply by right clicking on the folder and selecting 'SVN Update' from the context menu.

=== Configuring the build system with CMake ===
Run CMake from its shortcut on the Start menu. There are some general instructions on using CMake on the [http://www.cmake.org/HTML/RunningCMake.html CMake website] which are worth reading. You will need to fill in the source code location, this should point to where you checkout out the latest TexGen SVN code or where you extracted the source code from the zip file. Also set where to place the binary files once they are compiled, this can be the same as the source directory, a subdirectory within the source directory or any other location.

Once that is entered click 'Configure' and choose the Visual Studio version which you have installed and click ok. You will initially get a number of error messages such as:

CMake Error: Swig was not found on the system. Please specify the location of Swig. (click OK)
CMake Error: Error in configuration process, project files may be invalid. (click OK)

This is normal, in order to get rid of the errors you will need to tell CMake where the various libraries you have installed can be found. This is done in the Cache Values sections.

It is recommended to begin with a minimal build, this is achieved by setting the cache values as follows:

BUILD_CASCADE_EXPORT OFF
BUILD_DOCUMENTATION OFF
BUILD_EXAMPLES OFF
BUILD_GUI OFF
BUILD_PYTHON_INTERFACE OFF
BUILD_RENDERER OFF
BUILD_SHARED ON
BUILD_UNIT_TESTS OFF

Once these are set press configure again and you shouldn't have any more errors/warnings. Press 'OK' to generate the MSVC solution and project files. Configuring the various optional modules is explained in [[#Configuring optional modules]].

=== Configuring optional modules ===

Once the minimal build is working you may want to switch on the optional modules. To do this open up CMake again and switch the modules you want to ON in the Cache Values then click Configure. You will most likely see some errors telling you it is unable to automatically find certain directories. You will need to specify these manually. An explanation of the different locations is listed below:

'''PYTHON_SITEPACKAGES_DIR''' - This should be the folder where the TexGen python modules will be placed. Usually located in 'C:\Python25\Lib\site-packages', but this will depend on the version of Python installed and where you decided to install it.

'''SWIG_DIR''' - This is the location where you extracted the SWIG executable. e.g. 'C:\Program Files\swigwin-1.3.31'.

'''SWIG_EXECUTABLE''' - Same as root directory followed by 'swig.exe'

'''wxWidgets_ROOT_DIR''' - Location where you install wxWidgets. e.g. 'C:/wxWidgets-2.8.3'.

'''wxWidgets_LIB_DIR''' - Location where the wxWidgets libraries were compiled to, should be the same as the root directory followed by 'lib\vc_lib'.

'''OPENCASCADE_INCLUDE_DIR''' - Location where the OpenCascade header files are located. e.g. 'C:/OpenCASCADE6.1.0/ros/inc'.

'''OPENCASCADE_LIBRARY_DIR''' - Location where the OpenCascade libraries are located. e.g. 'C:/OpenCASCADE6.1.0/ros/win32/lib'.

'''OPENCASCADE_DEBUG_LIBRARY_DIR''' - Location where the OpenCascade debug libraries are located. e.g. 'C:/OpenCASCADE6.1.0/ros/win32/libd'.

'''VTK_DIR''' - Location of the VTK binary directory (note: not the source directory).

After setting the directories manually, click on configure again. You may need to go through several iterations of changing parameters then pressing configure. Once you have finished changing parameters and have successfully pressed configure without error messages you can press the OK button to generate the build. Note: you can always come back to this at a later time to make changes.

=== Compiling ===

Find 'TexGen.sln' which should be located in the directory where you told CMake to output the binary files to and open it with Microsoft Visual Studio.

Set the configuration to 'Release' and build the solution. Hopefully the project will have been compiled without errors.

If you want to compile and execute the Graphical User Interface you will need to install it, you will not be able to execute it directly from the build directory. This is done by right click on the 'INSTALL' project in the Solution Explorer and selecting Build. This will copy the Python modules into the Python site-packages directory so that they can be imported into scripts, and it will copy the executable along with other necessary files into 'C:\Program Files\TexGen\' by default (this can be changed with the CMAKE_INSTALL_PREFIX cache value in CMake). TexGenGUI.exe should then be run from the installed location, if you attempt to run it directly from where it was compiled you will get some errors on launch.

=== Building the documentation ===

To build the documentation, [http://www.stack.nl/~dimitri/doxygen/download.html Doxygen] is required. Open a command prompt in the 'Docs' subdirectory of the source code and run 'doxygen'. If the doxygen directory is not in your path, you must add it, or give the full path on the command line.

=== Integrating TexGen with ABAQUS ===

If you are using ABAQUS and wish to use TexGen Python scripting from within the ABAQUS/CAE environment, there are a few extra steps to perform. This is because ABAQUS comes packaged with its own version of Python, so any modules added to your standalone python installation will not be accessible by ABAQUS. You must compile the TexGen Python modules with the same version of Python as ABAQUS uses. The following table shows which version of Python is used in specific ABAQUS versions:

{| class="wikitable" style="text-align:center" border="1"
! ABAQUS Version !! Python Version
|-
| 6.6-1 || 2.3.3
|-
| 6.7-1 || 2.4.3
|}

If your version of ABAQUS is not listed in the table above you can type 'abaqus python -V' to check what version of Python is used (then please edit this page to update the table). You can obtain specific versions of Python from http://www.python.org/download/releases/x.y.z/ where x.y.z represents the version number.

Additionally you will need to place the TexGen python modules inside ABAQUS' version of python. There are a few ways to accomplish this, the easiest is perhaps to set the CMake cache variable 'PYTHON_SITEPACKAGES_DIR' point to the ABAQUS' python directory, e.g.:

PYTHON_SITEPACKAGES_DIR C:\Abaqus\6.7-1\Python\Lib\

Then when you build the INSTALL project in MSVC++ it will automatically copy the TexGen python modules to the ABAQUS' Python. Alternatively you can simply copy the files manually or modify Python's search path to include the TexGen python modules, e.g. In python:

import sys
sys.path.append('C:/Python24/Lib/site-packages/')

=== Troubleshooting ===

'''Q:''' I get the following error when compiling:
fatal error LNK1104: cannot open file 'python25_d.lib'

'''A:''' The windows installation of Python doesn't come with the debug library ('python25_d.lib', the _d part means debug). You should be able to compile in release mode however. If you really want to compile in debug mode you will need to compile Python from source and link to that. Or you can try to link to the release library 'python25.lib' instead, easiest way to do that is to copy 'python25.lib' to 'python25_d.lib' but this may cause problems during linking or execution.

'''Q:''' I get the following error when compiling:
fatal error C1083: Cannot open include file: 'wx/wxprec.h': No such file or directory

'''A:''' Make sure that you have compiled wxWidgets and that the wxWidgets_XXX cache variables are set correctly in CMake.

'''Q:''' I do not have a 'libd' folder in 'ros/win32' for OpenCASCADE.

'''A:''' If you do not compile OpenCASCADE yourself then this folder does not exist. However it can be ignored if you are only interested in building the release version of TexGen. If you really want to compile the debug version please refer to the OpenCASCADE documentation.

== Windows (Cygwin and gcc, alternate method) ==
A limited build (without graphics) can be made under cygwin, this is a UNIX emulation environment available at [http://www.cygwin.com www.cygwin.com].
This can exist peacefully next to the native windows version.
Cygwin creates a unix-style file system within your windows installation. If you choose c:/cygwin as your install directory, your HOME will be at c:/cygwin/home/<username>/.

=== Download cygwin and install packages ===
Install gcc, g++, wget, make and cmake using the setup.exe program from the cygwin website.
For the mesh generator and python interface to work we currently need VTK and swig.

This downloads and installs swig from source (when starting the cygwin shell you can paste this into the command line, otherwise write it to a file and run it with sh).
mkdir progs
cd progs
SWIG=swig-1.3.31
wget -nc http://kent.dl.sourceforge.net/sourceforge/swig/$SWIG.tar.gz
tar xzvf $SWIG.tar.gz
cd $SWIG
./configure
make
make install

This downloads and installs VTK from source, in the ccmake stage, use the cmake graphical commands to get a working install.
VTK=vtk-5.0.3
wget -nc http://www.vtk.org/files/release/5.0/$VTK.tar.gz
tar xzvf $VTK.tar.gz
mkdir vtkbin
cd vtkbin
ccmake ../VTK
make
make install

=== Install TexGen from source ===
Now we can proceed to install texgen, as an example we'll work in ~/temp/texgen
cd ~; mkdir temp; cd temp; mkdir texgen; cd texgen
svn checkout https://texgen.svn.sourceforge.net/svnroot/texgen/TexGen/trunk/ TexGen
cd .. ; mkdir tbin; cd tbin
ccmake ../texgen
make
make install

This should result in a working texgen install in ~/temp/texgen/tbin.

== Unix ==
=== Notes ===
If you are installing to a system where you don't have root access (i.e. this computer does not belong to you) you won't be able to install the software using the default configure script. This is because by default software is installed to the /usr/local directory. If you are not a systems administrator then you will quite rightly not have write access to this folder. All is not lost! You can still install software into your home directory. In order to do this you should always call the configure script with the following parameter: --prefix=$HOME. This goes for all the software to be installed below. All executables will then be placed in ~/bin, libraries in ~/lib, includes in ~/include, etc...

In the guide below the parameter is included in italic. If you do in fact have root access then it is recommended to omit this parameter and install to the default directory so that other users will also have access to the software.

=== Get TexGen from Subversion repository ===

==== Install Subversion ====
[http://subversion.tigris.org/servlets/ProjectDocumentList?collapseFolder=260&folderID=260 Download Subversion] and unpack.
Open a shell in extracted folder and type:
./configure --with-ssl ''--prefix=$HOME''
make
make install

Notes:
* You will need to install Subversion with SSL support since TexGen is hosted on sourceforge which uses SSL. If you don't configure with the --with-ssl flag you will get an error when trying to checkout TexGen in the next step.
* If you have trouble installing the latest version of Subversion, try installing version 1.3 as it does not require a seperate dependencies package.

==== Checkout ====
Open a shell in folder you wish to place TexGen (e.g. ~/):
svn checkout https://texgen.svn.sourceforge.net/svnroot/texgen/TexGen/trunk/ TexGen

Notes:
* The first parameter tells SVN to get the files for the first time
* The second parameter is the location of the TexGen svn repository
* The final parameter is the subfolder to put the files in

==== Update ====
The checkout command only needs to performed once. SVN keeps track of where the code was originally obtained and can update to the latest version without having to re-specify the location. In order to do that open a shell in the folder where TexGen was originally checkout (e.g. ~/TexGen) and type:
svn update
or if you are in a hurry you can type the shorter version:
svn up

=== Compile source ===

==== Install CMake ====

[http://www.cmake.org/HTML/Download.html Download CMake] and unpack.
Open a shell in extracted folder and type:
./configure ''--prefix=$HOME''
make
make install

==== Compile TexGen core ====
Open a shell in the folder with the TexGen source code (e.g. ~/TexGen):
mkdir bin
cd bin
ccmake ../
Press 'c' to configure. When a warning pops up telling you it can't find such and such a file press 'e' to close it. You will now need to specify which components of TexGen to build and where their dependencies can be found. Use the up and down arrows to move the caret and press enter to modify options. Do this to set BUILD_GUI, BUILD_PYTHON_INTERFACE and BUILD_RENDERER to OFF. You are basically telling CMake not to attempt to build these components, which means that you won't need to have installed their dependencies.

Similarly to the --prefix=$HOME parameter to the configure script, you can tell CMake to install TexGen to your home directory by changing CMAKE_INSTALL_PREFIX to ~/. Note that it won't actually install anything until you get type make install.

Now press 'c' again to update the changes.

Hopefully now that all the additional modules have been switched off no errors will be shown. Press 'g' to generate the makefiles and exit. At the shell type:
make
make install

Note that at this point you have only built and installed the TexGen Core library which doesn't actually do anything on its own. If you plan to incorporate TexGen into your own C++ program then this is enough, however if you would like to interface with TexGen from a Python script or Graphical User Interface then follow the steps below.

=== Compiling optional modules ===
==== Python interface ====
[http://www.python.org/download/ Download Python] and unpack.
Open a shell in the extracted folder and type:
./configure ''--prefix=$HOME''
make
make install

[http://www.swig.org/download.html Download SWIG] and unpack.
Open a shell in the extracted folder and type:
./configure ''--prefix=$HOME''
make
make install

Open a shell in the folder where you called ccmake from for the first time (e.g. ~/TexGen/bin):
ccmake ../

Use the up and down arrows to reach BUILD_PYTHON_INTERFACE and press Enter to set it to ON. Then press 'c' to configure. You will probably get a warning saying you need to specify the location of SWIG and/or Python, press 'e' to close it.

Set the PYTHON_INCLUDE_PATH, PYTHON_LIBRARY, PYTHON_SITEPACKAGES_DIR, SWIG_DIR and SWIG_EXECUTABLE parameters correctly where necessary. If you have installed packages to your home directory then they should look something like this:

PYTHON_INCLUDE_PATH: ~/include/python2.5
PYTHON_LIBRARY: ~/lib/python2.5/config/libpython2.5.a
PYTHON_SITEPACKAGES_DIR: ~/lib/python2.5/site-packages
SWIG_DIR: ~/bin
SWIG_EXECUTABLE: ~/bin/swig

Once that is done press 'c' again. You may need perform this process over several iterations. When everything is set correctly press 'g' to generate the makefiles.

At the shell type:
make
make install

Assuming the build completed without errors you should now be able to access TexGen functions from within Python. In order to check everything worked as planned open Python in interactive mode by typing:
python

Then from within Python type:
from TexGen.Core import *
CTexGen.GetInstance().GetVersion()

This should display the version of TexGen installed.

=== Troubleshooting ===

'''Q:''' I get the following error when linking _Core.so:
libpython2.5.a(abstract.o): relocation R_X86_64_32 against `a local symbol'
can not be used when making a shared object; recompile with -fPIC

'''A:''' Try removing libpython2.5.a from the libraries to link to by setting PYTHON_LIBRARY to a bogus path, e.g.:

PYTHON_LIBRARY: ~/

By doing so you may receive a warning similar to this:
Warning: Ignoring path found in link libraries for target: _Core, path is:
/home/username. Expected a library name or a full path to a library name.
This warning may be ignored.

Roadmap

2008-04-23T13:45:32Z

WikiSysop: /* Todo */

== ChangeLog ==

== Todo ==
http://sourceforge.net/tracker/?group_id=181000
* Add ability to set textile name in the 2d weave wizard
* Memory management, may want to think about how the textile and yarn classes are stored. Currently the yarn has no knowledge of its parent. This can be troublesome for some functions. It is often useful for the yarn to have access to information about the textile it belongs to. Consider adding a parameter to yarn which points back to its parent. This removes the ability for the yarn to be copied, however this is not such a big deal anyway. There are few cases when this is necessary or useful.

* '''Modeller'''
** Popup menu in the outliner when right clicking on a yarn to assign sections and whatnot (could also enable the pop-up in the main render window) - then remove the buttons on the modeller page to clean things up a bit
** Have option to see repeat vectors graphically along with some repeated yarns
** Do sorting based on camera position for transparency
** Box selection (paraview have made a plugin for this)
** Layers so that picking of nodes belonging to specific yarns made easier
** Add undo ability
** Make sure python code is generated for all important operations (e.g. python code should be generated when mouse is released from a move operation)

* '''Bugs'''
** GetYarnLength doesn't seem to be working in python scripts
** Picking in the modeller seems screwed up sometimes (need to click a bit above desired position)
** White lines appear in the 3d modelling wizard

Scripting Export Mesh

2008-04-15T11:35:16Z

WikiSysop: /* Export a mesh */

==Export a mesh==
In the [[Scripting Create Models]] section you learnt how to create TexGen models from Python scripts. In this tutorial I will explain how to get a volume mesh of the textile and save it to an arbitrary file format. This is a fairly common task but unfortunately one that must often be repeated due to the fact that there is very little standardisation on the file format for meshes. Each software package uses its own mesh file format and so we must learn to read and write to these different formats. Fortunately the Python language is ideal for performing these tasks with relative ease.

==Standalone scripts==
I am going to diverge a bit from this tutorial to talk about standalone scripts. In the previous guide it was assumed that the scripts you were writing would be run from within TexGen. However in some situations you may find it useful to simply run the scripts on their own from the command line without loading up the graphical user interface. In order to do this you must have installed [http://www.python.org/ Python] and installed the non-bundle version of TexGen (see [[Windows Installation]] for more details). To run your script you can then type the following from the command line:

python myscript.py

However before your scripts will work on their own, you must import the TexGen modules at the start of your script. In order to do that simply add the following line to the top of your script:

from TexGen.Core import *

Note that by adding this line does not prevent you from running your scripts through the GUI as well.

==Getting started==

I'm going to assume you already have a textile model you want to get a mesh of and have saved it to a .tg3 file named "textile.tg3". So the first step is to load this model so that we can go about extracting a mesh from it:
<pre>
from TexGen.Core import *
# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()
</pre>
The variable <code>textile</code> now contains an instance of the [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_textile.html CTextile] class representing the textile model. Let's now extract a mesh for this textile, fortunately TexGen has some built-in functionality to do this:

<pre>
# Create a mesh instance
mesh = CMesh()
# Add the volume of the textile to the mesh and trim the mesh to the domain
textile.AddVolumeToMesh(mesh, True)
</pre>

We declare <code>mesh</code> to be an instance of [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] and then use it to store a volume mesh of the textile. So with just a few lines of code we now have a volume mesh of the textile stored in memory. The problem we are now faced with is how do we transfer this mesh from memory to the hard disk in the file format that we want so that it can be understood by our software of choice? Read on to find out.

==Defining the file format==

In this example I will be showing you how to save to the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format]. I have chosen this file format because it is simple and well documented. Unfortunately, in a lot of cases, file formats are poorly documented (if at all) and are complex due to poor design.

Note that TexGen already has a function to export to the VTK XML file format along with a number of other common file formats, and can be called in a single line of code like so: <code>mesh.SaveToVTK("mesh.vtu")</code>. But in this tutorial I want to explain how to actually write the data out line by line so that you can hopefully translate that to any other file format of your choice.

==Writing the data to file==

Now that we have decided what format the data will be written in, let's get down to actually writing it. First we will open a file for writing:
file = open("mesh.vtk", "w")
See the [http://docs.python.org/tut/node9.html#SECTION009200000000000000000 Python tutorial section 7.2] for more details on writing to files in Python. Next we need to write the header:
<pre>
# Write the header
file.write("# vtk DataFile Version 2.0\n")
file.write("Textile mesh data\n")
file.write("ASCII\n")
file.write("DATASET UNSTRUCTURED_GRID\n")
</pre>
As defined in the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format documentation]. A mesh consists of a number of nodes (or points) and a number of elements (or cells). Each corner of an element is defined as an index into the list of points. An index of 0 refers to the first point, index 1 refers to the second and so on. So first of all we shall write the list of points to the file in the correct format:
<pre>
# Write the points
file.write("POINTS %d float\n" % mesh.GetNumNodes())
for node in mesh.GetNodes():
file.write("%g %g %g\n" % (node.x, node.y, node.z))
</pre>
The % operator is known as the string formatting or interpolation operator. It is important to understand how this works when writing data to files in ASCII format. Read the [http://docs.python.org/tut/node9.html#SECTION009100000000000000000 Python tutorial section 7.1] and [http://docs.python.org/lib/typesseq-strings.html Python library reference 3.6.2] for more information on this.

At this point, if you run the script it should create a valid VTK file that you can load into the free [http://www.paraview.org/ ParaView] visualisation software. You may want to try this now to check that what you have done so far works correctly. Initially you will not see anything when loaded into ParaView because we have just defined points and nothing else. In order to visualise these points you must apply the Glyph filter. Assuming this works, let's continue and write the elements.

Defining the elements is a little more tricky because there are different types of elements. When meshing the yarns TexGen will use a mix of wedge and hexahedral elements, so we only need to deal with these element types. The [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] class stores a long list of indices for each element type. For example, a mesh containing 2 wedge elements and 3 hex elements would contain a list of 12 indices for the wedges and a list of 24 for the hex elements. The first thing to do is to define some variables to contain this data:
<pre>
wedgeIndices = list(mesh.GetIndices(CMesh.WEDGE))
hexIndices = list(mesh.GetIndices(CMesh.HEX))
numWedges = len(wedgeIndices)/6
numHexes = len(hexIndices)/8
</pre>
Next we actually write the data to the file similarly to the way the points were written:
<pre>
file.write("CELLS %d %d\n" % (numWedges+numHexes, numWedges*7+numHexes*9))
for i in range(numWedges):
file.write("6 %d %d %d %d %d %d\n" % tuple(wedgeIndices[i*6:(i+1)*6]))
for i in range(numHexes):
file.write("8 %d %d %d %d %d %d %d %d\n" % tuple(hexIndices[i*8:(i+1)*8]))
</pre>
Here I have made use of slicing (wedgeIndices'''['''i*6''':'''(i+1)*6''']''') to reduce the amount of code necessary to output the data. See the [http://docs.python.org/tut/node5.html#SECTION005140000000000000000 Python tutorial section 3.1.4] for information about how slicing works.

And finally we need to output the type of each of these elements:
<pre>
file.write("CELL_TYPES %d\n" % (numWedges+numHexes))
for i in range(numWedges):
file.write("13\n")
for i in range(numHexes):
file.write("12\n")
</pre>
The VTK file format defines wedges to be of element type 13 and hexes to be of element type 12.

That's it, you should now have a script which reads a TexGen tg3 file, extracts a mesh from it and writes the contents to a file in the VTK legacy file format. Your Python script should look like this:

<pre>
from TexGen.Core import *

# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()

# Create a mesh instance
mesh = CMesh()
# Add the volume of the textile to the mesh
textile.AddVolumeToMesh(mesh, True)

file = open("mesh.vtk", "w")

# Write the header
file.write("# vtk DataFile Version 2.0\n")
file.write("Textile mesh data\n")
file.write("ASCII\n")
file.write("DATASET UNSTRUCTURED_GRID\n")

# Write the points
file.write("POINTS %d float\n" % mesh.GetNumNodes())
for node in mesh.GetNodes():
file.write("%g %g %g\n" % (node.x, node.y, node.z))

# Get element information from the mesh
wedgeIndices = list(mesh.GetIndices(CMesh.WEDGE))
hexIndices = list(mesh.GetIndices(CMesh.HEX))
numWedges = len(wedgeIndices)/6
numHexes = len(hexIndices)/8

# Write the element information
file.write("CELLS %d %d\n" % (numWedges+numHexes, numWedges*7+numHexes*9))
for i in range(numWedges):
file.write("6 %d %d %d %d %d %d\n" % tuple(wedgeIndices[i*6:(i+1)*6]))
for i in range(numHexes):
file.write("8 %d %d %d %d %d %d %d %d\n" % tuple(hexIndices[i*8:(i+1)*8]))

file.write("CELL_TYPES %d\n" % (numWedges+numHexes))
for i in range(numWedges):
file.write("13\n")
for i in range(numHexes):
file.write("12\n")
</pre>

==Verification==

The first thing to do now is to run the script from the command line like so:

python myscript.py

replacing <code>myscript.py</code> with the name of the script your created and ensuring you have a textile model named <code>textile.tg3</code> in the some folder as the script. If it ran successfully you should see a file named <code>mesh.vtk</code> being created. Load this up into [http://www.paraview.org/ ParaView] and you should see a mesh of your textile.

When writing your own scripts it is unlikely that they will work straight away (even for professional programmers), so it is a good idea to check the output of your script at each step with a text editor to ensure that it is writing exactly what you want. This will enable you to isolate bugs early on and one at a time rather than having to fix a long script containing numerous bugs. The [http://docs.python.org/tut/node5.html#SECTION005200000000000000000 print statement] is your friend when it comes to debugging, it can be used to print out values and verify that they are what you expect.

Scripting Guide

2008-04-15T11:34:17Z

WikiSysop:

Scripting Create Models

2008-04-15T11:31:15Z

WikiSysop:

===Example 1: A plain weave===
First of all, a Python script is just a plain ASCII text file with a .py extension. To create one simply open up your favorite text editor. Notepad will do if you have nothing else but I suggest a more powerful freeware text editor like [http://www.pspad.com/ PSPad] or [http://notepad-plus.sourceforge.net/ Notepad++]. Code that goes into the python script will be displayed like so:

# All Python code will be shown in a box like this one.
# Lines begining with a '#' character are comments

In this example, we will create a simple 2x2 plain weave model with a Python script. Its time to dive in and see some actual Python code. At this point if you are completely lost please refer back to the resources on Python programming. The first step is to create an instance of the <code>CTextileWeave2D</code> class and give it a name, <code>weave</code>:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

The <code>CTextileWeave2D</code> class takes 5 parameters in the order shown below:
* Number of weft yarns in the unit cell
* Number of warp yarns in the unit cell
* Spacing between the yarns
* Thickness of the fabrics
* Refine model (True/False)

The only parameter that really needs an explanation here is the Refine model option, this controls whether or not the interference correction algorithm will be applied to keep the yarn volumes from intersecting which is a common problem. The interference correction algorithm generally does a good job but is not instantaneous so sometimes it can be beneficial to switch it off.

This is the bare minimum information necessary to create a 2D woven fabric. In the following steps we will add more information to create the model the way we want it.

Let's set the weave pattern, this determines whether a warp or weft yarn will appear on top at a particular cross over. Cross overs are arranged in 2d grid where the size of the grid depends on the number of warp and weft yarns created. To swap the positions of the weft and warp yarns, we call the function <code>SwapPosition</code> with the grid coordinates of the cross over. In order to create a plain weave we need to do this on two diagonally opposite cross overs like so:

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

Now let's add our <code>weave</code> model to the database of models so that TexGen can render it:

# Add the textile
AddTextile(weave)

Thats it! This is a very simple script but it will generate a plain weave model. To recap your Python script should look like this:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

# Add the textile
AddTextile(weave)

Save it to disk as ''PlainWeave.py'' or give it whatever name you want as long as it has a ''.py'' extension.

In order to test the Script we need to load it into TexGen. So start up the TexGen GUI and from the ''Python menu'' select ''Run Script''. Select the file you have just saved and click ok. With a bit of luck you should see a 2d plain weave on screen:

[[Image:Example1.png]]

Congratulations you have created your first TexGen Python script!

===Example 2: Another plain weave (the hard way)===
In the first example we made use of the <code>CTextileWeave2D</code> which is the reason the script is so compact. This was great for creating a 2D Weave, but what if we want to create something other than a 2D Weave? Well, let's stick to the 2D weave for now but in this example we will create geometric model in a generic way without the use of the <code>CTextileWeave2D</code> class. This takes a little bit longer to do, but gives more control over the final geometry.

First we will define a general textile and call it <code>Textile</code>:

# Create a textile
Textile = CTextile()

The <code>CTextile</code> class doesn't take any parameters, instead yarns will be created and added to it. Next we will create 4 yarns to go inside our textile, it is convenient to make use of the Python lists to do this. Create a list called <code>Yarns</code> with 4 elements, each one an instance of the class <code>CYarn</code>:

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

<code>Yarns</code> now contains 4 empty yarns. Note that the yarns are not currently associated with the Textile, first we must fill in the details then make them a part of the textile. The first thing to do is define their paths with nodes. This is done like so:

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

We have added 3 nodes to each yarn creating a woven pattern. The number in the square brackets after <code>Yarns</code> refers to a particular yarn in the list. The function <code>AddNode</code> is then called for the yarn. The function takes an instance of the class <code>CNode</code> which in turn is constructed with an instance of the class <code>XYZ</code> representing the position of the node. The class <code>XYZ</code> is constructed with 3 numbers representing the X, Y and Z coordinates of the point.

We still need to define a few more things to obtain a model. For the sake of simplicity, we will give all the yarns the same cross sectional shape, width, height, etc... The easiest way to do this is to loop over the yarns and assign the same properties to each yarn one by one. The syntax for looping over <code>Yarns</code> is shown here:

# Loop over all the yarns in the list
for Yarn in Yarns:

Inside the loop, the variable <code>Yarn</code> refers to the current yarn in the list. So within the loop we just assign properties to <code>Yarn</code> and they will be applied to all the yarns in the list. In python the begining and end of a loop are defined by indentation, hence the following lines are indented to represent the contents of the loop.

Let us define periodic cubic spline interpolation between the nodes:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

This is done with the function <code>AssignInterpolation</code> which takes an instance of a class derived from <code>CInterpolation</code>. In this case we used <code>CInterpolationCubic</code> to specify periodic cubic spline interpolation.

Next we need to define a cross section for the yarn, to keep things simple a constant cross section all along the length of the yarn will be defined:

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

The function <code>AssignSection</code> takes an instance of a class derived from <code>CYarnSection</code>. In this case we used <code>CYarnSectionConstant</code> which in turns take an instance of a class derived from <code>CSection</code> as a constructor. <code>CSectionEllipse</code> defines an elliptical cross section with given width and height defined by the first and second parameters respectively.

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

This line sets the resolution of the surface mesh created. The first parameter to the function <code>SetResolution</code> represents the number of points around a cross section. The number of points along the length of the yarns is automatically calculated such that the distance between points is similar to around the cross section.

Next we must add repeat vectors to define how the yarns are repeated.

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

The function <code>AddRepeat</code> takes an instance of the class <code>XYZ</code>. As we saw earlier the class <code>XYZ</code> is constructed with 3 numbers defining the X, Y and Z components.

Finally the yarn is fully defined, it can now be added to <code>Textile</code>:

# Add the yarn to our textile
Textile.AddYarn(Yarn)

This is the end of the loop, hence the following lines return to the original indentation. Now let's define a Domain within which the textile will be placed:

Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

The function <code>AssignDomain</code> takes an instance of a class derived from <code>CDomain</code>. In this case we will create a box shaped domain, this can be accomplished by using the class <code>CDomainPlanes</code>. A box can be created by passing in opposite corners of the box (the minimum and maximum coordinates). This is done again with the class <code>XYZ</code>.

And finally <code>Textile</code> must be added to so that it can be rendered. Each Textile added must be assigned a name to identify it, this is the name that will appear at the top in the TexGen GUI. This name can either be generated automatically or we can specify it explicitly like so:

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

That's it! You now have the knowledge to create any type of fabric imaginable. Well, almost. The model created here is pretty simple, there is plenty of oppertunity to create more complex shapes. For example non-constant cross sections can be defined, complex domain shapes defined by arbritrary planes, different interpolation functions.

Here is the completed script:

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

# Loop over all the yarns in the list
for Yarn in Yarns:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a domain and assign it to the textile
Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

And the result:

[[Image:Example2.png]]

===Example 3: A 3d weave===
This example is similar to the [[Scripting Guide#Example 2: Another plain weave (the hard way)|Example 2]] in that the yarns will be defined by nodes. This time we will create a 3d woven fabric that looks like this:

[[Image:Example3.png]]

We start by defining a new CTextile instance:

# Create a textile
Textile = CTextile()

Before starting to define the geometry using TexGen it is helpful to define a list of parameters which may need to be changed later. These typically include spacing between yarns and yarn dimensions:

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

It is a good idea to define these up front rather than hard coding them in the rest of the script because if you want to tweak any parameters they can easily be located and will only need to be changed once. Lets start by defining the warp stuffer yarns, these are fairly easy to define since they all straight and parallel to each other:

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

Next we define the weft stuffer yarns, again these are easy to define:

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

And finally we need to insert the binder yarns. Making clever use of the repeat vectors it is only necessary to define a single instance of the binder yarn.

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Now that the geometry is defined we shall define a domain and add the textile so that TexGen knows about it.

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

The completed scripts is shown below:

# Create a textile
Textile = CTextile()

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

===Saving to TG3 file format===
TexGen has it's own file format for storing textile geometry with the extension .tg3. For more details on this file format please read the [[TG3 File Format]] page. Any textile models saved to this file format can be reloaded at a later time however it is also a good idea to keep the python script used to generate the geometry in case modifications need to be made. To save such a file it is simply a matter of adding an additional like at the end of your script like so:

SaveToXML("MyTextile.tg3")

The first parameter is the name of the file to save, note that if the .tg3 extension is omitted then it will automatically be appended for you. The second parameter is optional and if used should be the name of the textile to save, this is useful if you have several textiles loaded at once (i.e. you called AddTextile more than once) and you only want to save one of them. Note that if you don't specify the second parameter and you do have several textiles loaded then it will save all of them to a single .tg3 file. The third parameter determines how much information is saved in the .tg3 file, see the [[TG3 File Format]] for more details.

Scripting Export Mesh

2008-04-15T11:28:34Z

WikiSysop: /* Verification */

==Export a mesh==
In the [[Scripting Guide]] section you learnt how to create TexGen models from Python scripts. In this tutorial I will explain how to get a volume mesh of the textile and save it to an arbitrary file format. This is a fairly common task but unfortunately one that must often be repeated due to the fact that there is very little standardisation on the file format for meshes. Each software package uses its own mesh file format and so we must learn to read and write to these different formats. Fortunately the Python language is ideal for performing these tasks with relative ease.

==Standalone scripts==
I am going to diverge a bit from this tutorial to talk about standalone scripts. In the previous guide it was assumed that the scripts you were writing would be run from within TexGen. However in some situations you may find it useful to simply run the scripts on their own from the command line without loading up the graphical user interface. In order to do this you must have installed [http://www.python.org/ Python] and installed the non-bundle version of TexGen (see [[Windows Installation]] for more details). To run your script you can then type the following from the command line:

python myscript.py

However before your scripts will work on their own, you must import the TexGen modules at the start of your script. In order to do that simply add the following line to the top of your script:

from TexGen.Core import *

Note that by adding this line does not prevent you from running your scripts through the GUI as well.

==Getting started==

I'm going to assume you already have a textile model you want to get a mesh of and have saved it to a .tg3 file named "textile.tg3". So the first step is to load this model so that we can go about extracting a mesh from it:
<pre>
from TexGen.Core import *
# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()
</pre>
The variable <code>textile</code> now contains an instance of the [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_textile.html CTextile] class representing the textile model. Let's now extract a mesh for this textile, fortunately TexGen has some built-in functionality to do this:

<pre>
# Create a mesh instance
mesh = CMesh()
# Add the volume of the textile to the mesh and trim the mesh to the domain
textile.AddVolumeToMesh(mesh, True)
</pre>

We declare <code>mesh</code> to be an instance of [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] and then use it to store a volume mesh of the textile. So with just a few lines of code we now have a volume mesh of the textile stored in memory. The problem we are now faced with is how do we transfer this mesh from memory to the hard disk in the file format that we want so that it can be understood by our software of choice? Read on to find out.

==Defining the file format==

In this example I will be showing you how to save to the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format]. I have chosen this file format because it is simple and well documented. Unfortunately, in a lot of cases, file formats are poorly documented (if at all) and are complex due to poor design.

Note that TexGen already has a function to export to the VTK XML file format along with a number of other common file formats, and can be called in a single line of code like so: <code>mesh.SaveToVTK("mesh.vtu")</code>. But in this tutorial I want to explain how to actually write the data out line by line so that you can hopefully translate that to any other file format of your choice.

==Writing the data to file==

Now that we have decided what format the data will be written in, let's get down to actually writing it. First we will open a file for writing:
file = open("mesh.vtk", "w")
See the [http://docs.python.org/tut/node9.html#SECTION009200000000000000000 Python tutorial section 7.2] for more details on writing to files in Python. Next we need to write the header:
<pre>
# Write the header
file.write("# vtk DataFile Version 2.0\n")
file.write("Textile mesh data\n")
file.write("ASCII\n")
file.write("DATASET UNSTRUCTURED_GRID\n")
</pre>
As defined in the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format documentation]. A mesh consists of a number of nodes (or points) and a number of elements (or cells). Each corner of an element is defined as an index into the list of points. An index of 0 refers to the first point, index 1 refers to the second and so on. So first of all we shall write the list of points to the file in the correct format:
<pre>
# Write the points
file.write("POINTS %d float\n" % mesh.GetNumNodes())
for node in mesh.GetNodes():
file.write("%g %g %g\n" % (node.x, node.y, node.z))
</pre>
The % operator is known as the string formatting or interpolation operator. It is important to understand how this works when writing data to files in ASCII format. Read the [http://docs.python.org/tut/node9.html#SECTION009100000000000000000 Python tutorial section 7.1] and [http://docs.python.org/lib/typesseq-strings.html Python library reference 3.6.2] for more information on this.

At this point, if you run the script it should create a valid VTK file that you can load into the free [http://www.paraview.org/ ParaView] visualisation software. You may want to try this now to check that what you have done so far works correctly. Initially you will not see anything when loaded into ParaView because we have just defined points and nothing else. In order to visualise these points you must apply the Glyph filter. Assuming this works, let's continue and write the elements.

Defining the elements is a little more tricky because there are different types of elements. When meshing the yarns TexGen will use a mix of wedge and hexahedral elements, so we only need to deal with these element types. The [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] class stores a long list of indices for each element type. For example, a mesh containing 2 wedge elements and 3 hex elements would contain a list of 12 indices for the wedges and a list of 24 for the hex elements. The first thing to do is to define some variables to contain this data:
<pre>
wedgeIndices = list(mesh.GetIndices(CMesh.WEDGE))
hexIndices = list(mesh.GetIndices(CMesh.HEX))
numWedges = len(wedgeIndices)/6
numHexes = len(hexIndices)/8
</pre>
Next we actually write the data to the file similarly to the way the points were written:
<pre>
file.write("CELLS %d %d\n" % (numWedges+numHexes, numWedges*7+numHexes*9))
for i in range(numWedges):
file.write("6 %d %d %d %d %d %d\n" % tuple(wedgeIndices[i*6:(i+1)*6]))
for i in range(numHexes):
file.write("8 %d %d %d %d %d %d %d %d\n" % tuple(hexIndices[i*8:(i+1)*8]))
</pre>
Here I have made use of slicing (wedgeIndices'''['''i*6''':'''(i+1)*6''']''') to reduce the amount of code necessary to output the data. See the [http://docs.python.org/tut/node5.html#SECTION005140000000000000000 Python tutorial section 3.1.4] for information about how slicing works.

And finally we need to output the type of each of these elements:
<pre>
file.write("CELL_TYPES %d\n" % (numWedges+numHexes))
for i in range(numWedges):
file.write("13\n")
for i in range(numHexes):
file.write("12\n")
</pre>
The VTK file format defines wedges to be of element type 13 and hexes to be of element type 12.

That's it, you should now have a script which reads a TexGen tg3 file, extracts a mesh from it and writes the contents to a file in the VTK legacy file format. Your Python script should look like this:

<pre>
from TexGen.Core import *

# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()

# Create a mesh instance
mesh = CMesh()
# Add the volume of the textile to the mesh
textile.AddVolumeToMesh(mesh, True)

file = open("mesh.vtk", "w")

# Write the header
file.write("# vtk DataFile Version 2.0\n")
file.write("Textile mesh data\n")
file.write("ASCII\n")
file.write("DATASET UNSTRUCTURED_GRID\n")

# Write the points
file.write("POINTS %d float\n" % mesh.GetNumNodes())
for node in mesh.GetNodes():
file.write("%g %g %g\n" % (node.x, node.y, node.z))

# Get element information from the mesh
wedgeIndices = list(mesh.GetIndices(CMesh.WEDGE))
hexIndices = list(mesh.GetIndices(CMesh.HEX))
numWedges = len(wedgeIndices)/6
numHexes = len(hexIndices)/8

# Write the element information
file.write("CELLS %d %d\n" % (numWedges+numHexes, numWedges*7+numHexes*9))
for i in range(numWedges):
file.write("6 %d %d %d %d %d %d\n" % tuple(wedgeIndices[i*6:(i+1)*6]))
for i in range(numHexes):
file.write("8 %d %d %d %d %d %d %d %d\n" % tuple(hexIndices[i*8:(i+1)*8]))

file.write("CELL_TYPES %d\n" % (numWedges+numHexes))
for i in range(numWedges):
file.write("13\n")
for i in range(numHexes):
file.write("12\n")
</pre>

==Verification==

The first thing to do now is to run the script from the command line like so:

python myscript.py

replacing <code>myscript.py</code> with the name of the script your created and ensuring you have a textile model named <code>textile.tg3</code> in the some folder as the script. If it ran successfully you should see a file named <code>mesh.vtk</code> being created. Load this up into [http://www.paraview.org/ ParaView] and you should see a mesh of your textile.

When writing your own scripts it is unlikely that they will work straight away (even for professional programmers), so it is a good idea to check the output of your script at each step with a text editor to ensure that it is writing exactly what you want. This will enable you to isolate bugs early on and one at a time rather than having to fix a long script containing numerous bugs. The [http://docs.python.org/tut/node5.html#SECTION005200000000000000000 print statement] is your friend when it comes to debugging, it can be used to print out values and verify that they are what you expect.

Scripting Export Mesh

2008-04-15T11:25:20Z

WikiSysop:

==Export a mesh==
In the [[Scripting Guide]] section you learnt how to create TexGen models from Python scripts. In this tutorial I will explain how to get a volume mesh of the textile and save it to an arbitrary file format. This is a fairly common task but unfortunately one that must often be repeated due to the fact that there is very little standardisation on the file format for meshes. Each software package uses its own mesh file format and so we must learn to read and write to these different formats. Fortunately the Python language is ideal for performing these tasks with relative ease.

==Standalone scripts==
I am going to diverge a bit from this tutorial to talk about standalone scripts. In the previous guide it was assumed that the scripts you were writing would be run from within TexGen. However in some situations you may find it useful to simply run the scripts on their own from the command line without loading up the graphical user interface. In order to do this you must have installed [http://www.python.org/ Python] and installed the non-bundle version of TexGen (see [[Windows Installation]] for more details). To run your script you can then type the following from the command line:

python myscript.py

However before your scripts will work on their own, you must import the TexGen modules at the start of your script. In order to do that simply add the following line to the top of your script:

from TexGen.Core import *

Note that by adding this line does not prevent you from running your scripts through the GUI as well.

==Getting started==

I'm going to assume you already have a textile model you want to get a mesh of and have saved it to a .tg3 file named "textile.tg3". So the first step is to load this model so that we can go about extracting a mesh from it:
<pre>
from TexGen.Core import *
# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()
</pre>
The variable <code>textile</code> now contains an instance of the [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_textile.html CTextile] class representing the textile model. Let's now extract a mesh for this textile, fortunately TexGen has some built-in functionality to do this:

<pre>
# Create a mesh instance
mesh = CMesh()
# Add the volume of the textile to the mesh and trim the mesh to the domain
textile.AddVolumeToMesh(mesh, True)
</pre>

We declare <code>mesh</code> to be an instance of [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] and then use it to store a volume mesh of the textile. So with just a few lines of code we now have a volume mesh of the textile stored in memory. The problem we are now faced with is how do we transfer this mesh from memory to the hard disk in the file format that we want so that it can be understood by our software of choice? Read on to find out.

==Defining the file format==

In this example I will be showing you how to save to the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format]. I have chosen this file format because it is simple and well documented. Unfortunately, in a lot of cases, file formats are poorly documented (if at all) and are complex due to poor design.

Note that TexGen already has a function to export to the VTK XML file format along with a number of other common file formats, and can be called in a single line of code like so: <code>mesh.SaveToVTK("mesh.vtu")</code>. But in this tutorial I want to explain how to actually write the data out line by line so that you can hopefully translate that to any other file format of your choice.

==Writing the data to file==

Now that we have decided what format the data will be written in, let's get down to actually writing it. First we will open a file for writing:
file = open("mesh.vtk", "w")
See the [http://docs.python.org/tut/node9.html#SECTION009200000000000000000 Python tutorial section 7.2] for more details on writing to files in Python. Next we need to write the header:
<pre>
# Write the header
file.write("# vtk DataFile Version 2.0\n")
file.write("Textile mesh data\n")
file.write("ASCII\n")
file.write("DATASET UNSTRUCTURED_GRID\n")
</pre>
As defined in the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format documentation]. A mesh consists of a number of nodes (or points) and a number of elements (or cells). Each corner of an element is defined as an index into the list of points. An index of 0 refers to the first point, index 1 refers to the second and so on. So first of all we shall write the list of points to the file in the correct format:
<pre>
# Write the points
file.write("POINTS %d float\n" % mesh.GetNumNodes())
for node in mesh.GetNodes():
file.write("%g %g %g\n" % (node.x, node.y, node.z))
</pre>
The % operator is known as the string formatting or interpolation operator. It is important to understand how this works when writing data to files in ASCII format. Read the [http://docs.python.org/tut/node9.html#SECTION009100000000000000000 Python tutorial section 7.1] and [http://docs.python.org/lib/typesseq-strings.html Python library reference 3.6.2] for more information on this.

At this point, if you run the script it should create a valid VTK file that you can load into the free [http://www.paraview.org/ ParaView] visualisation software. You may want to try this now to check that what you have done so far works correctly. Initially you will not see anything when loaded into ParaView because we have just defined points and nothing else. In order to visualise these points you must apply the Glyph filter. Assuming this works, let's continue and write the elements.

Defining the elements is a little more tricky because there are different types of elements. When meshing the yarns TexGen will use a mix of wedge and hexahedral elements, so we only need to deal with these element types. The [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] class stores a long list of indices for each element type. For example, a mesh containing 2 wedge elements and 3 hex elements would contain a list of 12 indices for the wedges and a list of 24 for the hex elements. The first thing to do is to define some variables to contain this data:
<pre>
wedgeIndices = list(mesh.GetIndices(CMesh.WEDGE))
hexIndices = list(mesh.GetIndices(CMesh.HEX))
numWedges = len(wedgeIndices)/6
numHexes = len(hexIndices)/8
</pre>
Next we actually write the data to the file similarly to the way the points were written:
<pre>
file.write("CELLS %d %d\n" % (numWedges+numHexes, numWedges*7+numHexes*9))
for i in range(numWedges):
file.write("6 %d %d %d %d %d %d\n" % tuple(wedgeIndices[i*6:(i+1)*6]))
for i in range(numHexes):
file.write("8 %d %d %d %d %d %d %d %d\n" % tuple(hexIndices[i*8:(i+1)*8]))
</pre>
Here I have made use of slicing (wedgeIndices'''['''i*6''':'''(i+1)*6''']''') to reduce the amount of code necessary to output the data. See the [http://docs.python.org/tut/node5.html#SECTION005140000000000000000 Python tutorial section 3.1.4] for information about how slicing works.

And finally we need to output the type of each of these elements:
<pre>
file.write("CELL_TYPES %d\n" % (numWedges+numHexes))
for i in range(numWedges):
file.write("13\n")
for i in range(numHexes):
file.write("12\n")
</pre>
The VTK file format defines wedges to be of element type 13 and hexes to be of element type 12.

That's it, you should now have a script which reads a TexGen tg3 file, extracts a mesh from it and writes the contents to a file in the VTK legacy file format. Your Python script should look like this:

<pre>
from TexGen.Core import *

# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()

# Create a mesh instance
mesh = CMesh()
# Add the volume of the textile to the mesh
textile.AddVolumeToMesh(mesh, True)

file = open("mesh.vtk", "w")

# Write the header
file.write("# vtk DataFile Version 2.0\n")
file.write("Textile mesh data\n")
file.write("ASCII\n")
file.write("DATASET UNSTRUCTURED_GRID\n")

# Write the points
file.write("POINTS %d float\n" % mesh.GetNumNodes())
for node in mesh.GetNodes():
file.write("%g %g %g\n" % (node.x, node.y, node.z))

# Get element information from the mesh
wedgeIndices = list(mesh.GetIndices(CMesh.WEDGE))
hexIndices = list(mesh.GetIndices(CMesh.HEX))
numWedges = len(wedgeIndices)/6
numHexes = len(hexIndices)/8

# Write the element information
file.write("CELLS %d %d\n" % (numWedges+numHexes, numWedges*7+numHexes*9))
for i in range(numWedges):
file.write("6 %d %d %d %d %d %d\n" % tuple(wedgeIndices[i*6:(i+1)*6]))
for i in range(numHexes):
file.write("8 %d %d %d %d %d %d %d %d\n" % tuple(hexIndices[i*8:(i+1)*8]))

file.write("CELL_TYPES %d\n" % (numWedges+numHexes))
for i in range(numWedges):
file.write("13\n")
for i in range(numHexes):
file.write("12\n")
</pre>

==Verification==

The first thing to do now is to run the script from the command line like so:

python myscript.py

replacing <code>myscript.py</code> with the name of the script your created and ensuring you have a textile model named <code>textile.tg3</code> in the some folder as the script. If it ran successfully you should see a file named <code>mesh.vtk</code> being created. Load this up into [http://www.paraview.org/ ParaView] and you should a mesh of your textile.

When writing your own scripts it is likely that it will not work straight away, so it is a good idea to check the output of your script at each step with a text editor to ensure that it is writing exactly what you want. This will enable you to isolate bugs early on and one at a time rather than having to fix a long script contain numerous bugs. The [http://docs.python.org/tut/node5.html#SECTION005200000000000000000 print statement] is your friend when it comes to debugging, it can be used to print out values and verify that they are what you expect.

Scripting Export Mesh

2008-04-15T11:14:58Z

WikiSysop:

Scripting Export Mesh

2008-04-15T11:13:20Z

WikiSysop: /* Writing the data to file */

Scripting Export Mesh

2008-04-15T11:09:12Z

WikiSysop: /* Standalone scripts */

==Export a mesh==
In the [[Scripting Guide]] section you learnt how to create TexGen models from Python scripts. In this tutorial I will explain how to get a volume mesh of the textile and save it to an arbitrary file format. This is a fairly common task but unfortunately one that must often be repeated due to the fact that there is very little standardisation on the file format for meshes. Each software package uses its own mesh file format and so we must learn to read and write to these different formats. Fortunately the Python language is ideal for performing these tasks with relative ease.

==Standalone scripts==
I am going to diverge a bit from this tutorial to talk about standalone scripts. In the previous guide it was assumed that the scripts you were writing would be run from within TexGen. However in some situations you may find it useful to simply run the scripts on their own from the command line without loading up the graphical user interface. In order to do this you must have installed [http://www.python.org/ Python] and installed the non-bundle version of TexGen (see [[Windows Installation]] for more details). To run your script you can then type the following from the command line:

python myscript.py

However before your scripts will work on their own, you must import the TexGen modules at the start of your script. In order to do that simply add the following line to the top of your script:

from TexGen.Core import *

Note that by adding this line does not prevent you from running your scripts through the GUI as well.

==Getting started==

I'm going to assume you already have a textile model you want to get a mesh of and have saved it to a .tg3 file named "textile.tg3". So the first step is to load this model so that we can go about extracting a mesh from it:
<pre>
from TexGen.Core import *
# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()
</pre>
The variable <code>textile</code> now contains an instance of the [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_textile.html CTextile] class representing the textile model. Let's now extract a mesh for this textile, fortunately TexGen has some built-in functionality to do this:

<pre>
# Create a mesh instance
mesh = CMesh()
# Add the volume of the textile to the mesh and trim the mesh to the domain
textile.AddVolumeToMesh(mesh, True)
</pre>

We declare <code>mesh</code> to be an instance of [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] and then use it to store a volume mesh of the textile. So with just a few lines of code we now have a volume mesh of the textile stored in memory. The problem we are now faced with is how do we transfer this mesh from memory to the hard disk in the file format that we want so that it can be understood by our software of choice? Read on to find out.

==Defining the file format==

In this example I will be showing you how to save to the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format]. I have chosen this file format because it is simple and well documented. Unfortunately, in a lot of cases, file formats are poorly documented (if at all) and are complex due to poor design.

Note that TexGen already has a function to export to the VTK XML file format along with a number of other common file formats, and can be called in a single line of code like so: <code>mesh.SaveToVTK("mesh.vtu")</code>. But in this tutorial I want to explain how to actually write the data out line by line so that you can hopefully translate that to any other file format of your choice.

==Writing the data to file==

Now that we have decide what format the data will be written in, let's get down to actually writing it. First we will open a file for writing:
file = open("mesh.vtk", "w")
See the [http://docs.python.org/tut/node9.html#SECTION009200000000000000000 Python tutorial section 7.2] for more details on writing to files in Python. Next we need to write the header:
<pre>
# Write the header
file.write("# vtk DataFile Version 2.0\n")
file.write("Textile mesh data\n")
file.write("ASCII\n")
file.write("DATASET UNSTRUCTURED_GRID\n")
</pre>
As defined in the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format documentation]. A mesh consists of a number of nodes (or points) and a number of elements (or cells). Each corner of an element is defined as an index into the list of points. An index of 0 refers to the first point, index 1 refers to the second and so on. So first of all we shall write the list of points to the file in the correct format:
<pre>
# Write the points
file.write("POINTS %d float\n" % mesh.GetNumNodes())
for node in mesh.GetNodes():
file.write("%g %g %g\n" % (node.x, node.y, node.z))
</pre>
The % operator is known as the string formatting or interpolation operator. It is important to understand how this works when writing data to files in ASCII format. Read the [http://docs.python.org/tut/node9.html#SECTION009100000000000000000 Python tutorial section 7.1] and [http://docs.python.org/lib/typesseq-strings.html Python library reference 3.6.2] for more information on this.

It this point, if you run the script it should create a valid VTK file that you can load into the free [http://www.paraview.org/ ParaView] visualisation software. You may want to try this now to check that what you have done so far works correctly. Initially you will not see anything when loaded into ParaView because we have just defined points and nothing else. In order to visualise these points you must apply the Glyph filter. Assuming this works, let's continue and write the elements.

Defining the elements is a little more tricky because there are different types of elements. When meshing the yarns TexGen will use a mix of wedge and hexahedral elements, so we only need to deal with these element types. The [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] class stores a long list of indices for each element type. For example, a mesh containing 2 wedge elements and 3 hex elements would contain a list of 12 indices for the wedges and a list of 24 for the hex elements. The first thing to do is to define some variables to contain this data:
<pre>
wedgeIndices = list(mesh.GetIndices(CMesh.WEDGE))
hexIndices = list(mesh.GetIndices(CMesh.HEX))
numWedges = len(wedgeIndices)/6
numHexes = len(hexIndices)/8
</pre>
Next we actually write the data to the file similarly to the way the points where written:
<pre>
file.write("CELLS %d %d\n" % (numWedges+numHexes, numWedges*7+numHexes*9))
for i in range(numWedges):
file.write("6 %d %d %d %d %d %d\n" % tuple(wedgeIndices[i*6:(i+1)*6]))
for i in range(numHexes):
file.write("8 %d %d %d %d %d %d %d %d\n" % tuple(hexIndices[i*8:(i+1)*8]))
</pre>
Here I have made use of slicing (wedgeIndices'''['''i*6''':'''(i+1)*6''']''') to reduce the amount of code necessary to output the data. See the [http://docs.python.org/tut/node5.html#SECTION005140000000000000000 Python tutorial section 3.1.4] for information about how slicing works.

And finally we need to output the type of each of these elements:
<pre>
file.write("CELL_TYPES %d\n" % (numWedges+numHexes))
for i in range(numWedges):
file.write("13\n")
for i in range(numHexes):
file.write("12\n")
</pre>
The VTK file format defines wedges to be of element type 13 and hexes to be of element type 12.

Scripting Export Mesh

2008-04-15T11:07:23Z

WikiSysop: /* Writing the data to file */

==Export a mesh==
In the [[Scripting Guide]] section you learnt how to create TexGen models from Python scripts. In this tutorial I will explain how to get a volume mesh of the textile and save it to an arbitrary file format. This is a fairly common task but unfortunately one that must often be repeated due to the fact that there is very little standardisation on the file format for meshes. Each software package uses its own mesh file format and so we must learn to read and write to these different formats. Fortunately the Python language is ideal for performing these tasks with relative ease.

==Standalone scripts==
I am going to diverge a bit from this tutorial to talk about standalone scripts. In the previous guide it was assumed that the scripts you were writing would be run from within TexGen. However in some situations you may find it useful to simply run the scripts on their own from the command line without loading up the graphical user interface. In order to do this you must have installed [http://www.python.org/ Python] and installed the non-bundle version of TexGen (see [[Windows Installation]] for more details). To run your script you can then type the following from the command line:

python myscript.py

However before your scripts will work on their own, you must import the TexGen modules at the start of your script. In order to do that simply add the following line to the top of your script:

from TexGen.Core import *

You don't need to do this if you go through the GUI because this step is done automatically for you. Note that by adding this line does not prevent you from running your scripts through the GUI.

==Getting started==

I'm going to assume you already have a textile model you want to get a mesh of and have saved it to a .tg3 file named "textile.tg3". So the first step is to load this model so that we can go about extracting a mesh from it:
<pre>
from TexGen.Core import *
# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()
</pre>
The variable <code>textile</code> now contains an instance of the [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_textile.html CTextile] class representing the textile model. Let's now extract a mesh for this textile, fortunately TexGen has some built-in functionality to do this:

<pre>
# Create a mesh instance
mesh = CMesh()
# Add the volume of the textile to the mesh and trim the mesh to the domain
textile.AddVolumeToMesh(mesh, True)
</pre>

We declare <code>mesh</code> to be an instance of [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] and then use it to store a volume mesh of the textile. So with just a few lines of code we now have a volume mesh of the textile stored in memory. The problem we are now faced with is how do we transfer this mesh from memory to the hard disk in the file format that we want so that it can be understood by our software of choice? Read on to find out.

==Defining the file format==

In this example I will be showing you how to save to the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format]. I have chosen this file format because it is simple and well documented. Unfortunately, in a lot of cases, file formats are poorly documented (if at all) and are complex due to poor design.

Note that TexGen already has a function to export to the VTK XML file format along with a number of other common file formats, and can be called in a single line of code like so: <code>mesh.SaveToVTK("mesh.vtu")</code>. But in this tutorial I want to explain how to actually write the data out line by line so that you can hopefully translate that to any other file format of your choice.

==Writing the data to file==

Now that we have decide what format the data will be written in, let's get down to actually writing it. First we will open a file for writing:
file = open("mesh.vtk", "w")
See the [http://docs.python.org/tut/node9.html#SECTION009200000000000000000 Python tutorial section 7.2] for more details on writing to files in Python. Next we need to write the header:
<pre>
# Write the header
file.write("# vtk DataFile Version 2.0\n")
file.write("Textile mesh data\n")
file.write("ASCII\n")
file.write("DATASET UNSTRUCTURED_GRID\n")
</pre>
As defined in the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format documentation]. A mesh consists of a number of nodes (or points) and a number of elements (or cells). Each corner of an element is defined as an index into the list of points. An index of 0 refers to the first point, index 1 refers to the second and so on. So first of all we shall write the list of points to the file in the correct format:
<pre>
# Write the points
file.write("POINTS %d float\n" % mesh.GetNumNodes())
for node in mesh.GetNodes():
file.write("%g %g %g\n" % (node.x, node.y, node.z))
</pre>
The % operator is known as the string formatting or interpolation operator. It is important to understand how this works when writing data to files in ASCII format. Read the [http://docs.python.org/tut/node9.html#SECTION009100000000000000000 Python tutorial section 7.1] and [http://docs.python.org/lib/typesseq-strings.html Python library reference 3.6.2] for more information on this.

It this point, if you run the script it should create a valid VTK file that you can load into the free [http://www.paraview.org/ ParaView] visualisation software. You may want to try this now to check that what you have done so far works correctly. Initially you will not see anything when loaded into ParaView because we have just defined points and nothing else. In order to visualise these points you must apply the Glyph filter. Assuming this works, let's continue and write the elements.

Defining the elements is a little more tricky because there are different types of elements. When meshing the yarns TexGen will use a mix of wedge and hexahedral elements, so we only need to deal with these element types. The [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] class stores a long list of indices for each element type. For example, a mesh containing 2 wedge elements and 3 hex elements would contain a list of 12 indices for the wedges and a list of 24 for the hex elements. The first thing to do is to define some variables to contain this data:
<pre>
wedgeIndices = list(mesh.GetIndices(CMesh.WEDGE))
hexIndices = list(mesh.GetIndices(CMesh.HEX))
numWedges = len(wedgeIndices)/6
numHexes = len(hexIndices)/8
</pre>
Next we actually write the data to the file similarly to the way the points where written:
<pre>
file.write("CELLS %d %d\n" % (numWedges+numHexes, numWedges*7+numHexes*9))
for i in range(numWedges):
file.write("6 %d %d %d %d %d %d\n" % tuple(wedgeIndices[i*6:(i+1)*6]))
for i in range(numHexes):
file.write("8 %d %d %d %d %d %d %d %d\n" % tuple(hexIndices[i*8:(i+1)*8]))
</pre>
Here I have made use of slicing (wedgeIndices'''['''i*6''':'''(i+1)*6''']''') to reduce the amount of code necessary to output the data. See the [http://docs.python.org/tut/node5.html#SECTION005140000000000000000 Python tutorial section 3.1.4] for information about how slicing works.

And finally we need to output the type of each of these elements:
<pre>
file.write("CELL_TYPES %d\n" % (numWedges+numHexes))
for i in range(numWedges):
file.write("13\n")
for i in range(numHexes):
file.write("12\n")
</pre>
The VTK file format defines wedges to be of element type 13 and hexes to be of element type 12.

Scripting Export Mesh

2008-04-15T11:05:46Z

WikiSysop: /* Writing the data to file */

==Export a mesh==
In the [[Scripting Guide]] section you learnt how to create TexGen models from Python scripts. In this tutorial I will explain how to get a volume mesh of the textile and save it to an arbitrary file format. This is a fairly common task but unfortunately one that must often be repeated due to the fact that there is very little standardisation on the file format for meshes. Each software package uses its own mesh file format and so we must learn to read and write to these different formats. Fortunately the Python language is ideal for performing these tasks with relative ease.

==Standalone scripts==
I am going to diverge a bit from this tutorial to talk about standalone scripts. In the previous guide it was assumed that the scripts you were writing would be run from within TexGen. However in some situations you may find it useful to simply run the scripts on their own from the command line without loading up the graphical user interface. In order to do this you must have installed [http://www.python.org/ Python] and installed the non-bundle version of TexGen (see [[Windows Installation]] for more details). To run your script you can then type the following from the command line:

python myscript.py

However before your scripts will work on their own, you must import the TexGen modules at the start of your script. In order to do that simply add the following line to the top of your script:

from TexGen.Core import *

You don't need to do this if you go through the GUI because this step is done automatically for you. Note that by adding this line does not prevent you from running your scripts through the GUI.

==Getting started==

I'm going to assume you already have a textile model you want to get a mesh of and have saved it to a .tg3 file named "textile.tg3". So the first step is to load this model so that we can go about extracting a mesh from it:
<pre>
from TexGen.Core import *
# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()
</pre>
The variable <code>textile</code> now contains an instance of the [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_textile.html CTextile] class representing the textile model. Let's now extract a mesh for this textile, fortunately TexGen has some built-in functionality to do this:

<pre>
# Create a mesh instance
mesh = CMesh()
# Add the volume of the textile to the mesh and trim the mesh to the domain
textile.AddVolumeToMesh(mesh, True)
</pre>

We declare <code>mesh</code> to be an instance of [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] and then use it to store a volume mesh of the textile. So with just a few lines of code we now have a volume mesh of the textile stored in memory. The problem we are now faced with is how do we transfer this mesh from memory to the hard disk in the file format that we want so that it can be understood by our software of choice? Read on to find out.

==Defining the file format==

In this example I will be showing you how to save to the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format]. I have chosen this file format because it is simple and well documented. Unfortunately, in a lot of cases, file formats are poorly documented (if at all) and are complex due to poor design.

Note that TexGen already has a function to export to the VTK XML file format along with a number of other common file formats, and can be called in a single line of code like so: <code>mesh.SaveToVTK("mesh.vtu")</code>. But in this tutorial I want to explain how to actually write the data out line by line so that you can hopefully translate that to any other file format of your choice.

==Writing the data to file==

Now that we have decide what format the data will be written in, let's get down to actually writing it. First we will open a file for writing:
file = open("mesh.vtk", "w")
See the [http://docs.python.org/tut/node9.html#SECTION009200000000000000000 Python tutorial] for more details on writing to files in Python. Next we need to write the header:
<pre>
# Write the header
file.write("# vtk DataFile Version 2.0\n")
file.write("Textile mesh data\n")
file.write("ASCII\n")
file.write("DATASET UNSTRUCTURED_GRID\n")
</pre>
As defined in the [http://www.vtk.org/pdf/file-formats.pdf VTK legacy file format documentation]. A mesh consists of a number of nodes (or points) and a number of elements (or cells). Each corner of an element is defined as an index into the list of points. An index of 0 refers to the first point, index 1 refers to the second and so on. So first of all we shall write the list of points to the file in the correct format:
<pre>
# Write the points
file.write("POINTS %d float\n" % mesh.GetNumNodes())
for node in mesh.GetNodes():
file.write("%g %g %g\n" % (node.x, node.y, node.z))
</pre>
The % operator is known as the string formatting or interpolation operator. It is important to understand how this works when writing data to files in ASCII format. Read the [http://docs.python.org/tut/node9.html#SECTION009100000000000000000 Python tutorial] and [http://docs.python.org/lib/typesseq-strings.html Python library reference] for more information on this.

It this point, if you run the script it should create a valid VTK file that you can load into the free [http://www.paraview.org/ ParaView] visualisation software. You may want to try this now to check that what you have done so far works correctly. Initially you will not see anything when loaded into ParaView because we have just defined points and nothing else. In order to visualise these points you must apply the Glyph filter. Assuming this works, let's continue and write the elements.

Defining the elements is a little more tricky because there are different types of elements. When meshing the yarns TexGen will use a mix of wedge and hexahedral elements, so we only need to deal with these element types. The [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_mesh.html CMesh] class stores a long list of indices for each element type. For example, a mesh containing 2 wedge elements and 3 hex elements would contain a list of 12 indices for the wedges and a list of 24 for the hex elements. The first thing to do is to define some variables to contain this data:
<pre>
wedgeIndices = list(mesh.GetIndices(CMesh.WEDGE))
hexIndices = list(mesh.GetIndices(CMesh.HEX))
numWedges = len(wedgeIndices)/6
numHexes = len(hexIndices)/8
</pre>
Next we actually write the data to the file similarly to the way the points where written:
<pre>
file.write("CELLS %d %d\n" % (numWedges+numHexes, numWedges*7+numHexes*9))
for i in range(numWedges):
file.write("6 %d %d %d %d %d %d\n" % tuple(wedgeIndices[i*6:(i+1)*6]))
for i in range(numHexes):
file.write("8 %d %d %d %d %d %d %d %d\n" % tuple(hexIndices[i*8:(i+1)*8]))
</pre>
Here I have made use of slicing (wedgeIndices'''['''i*6''':'''(i+1)*6''']''') to reduce the amount of code necessary to output the data. See the [http://docs.python.org/tut/node5.html#SECTION005140000000000000000 Python tutorial section 3.1.4] for information about how slicing works.

And finally we need to output the type of each of these elements:
<pre>
file.write("CELL_TYPES %d\n" % (numWedges+numHexes))
for i in range(numWedges):
file.write("13\n")
for i in range(numHexes):
file.write("12\n")
</pre>
The VTK file format defines wedges to be of element type 13 and hexes to be of element type 12.

Scripting Export Mesh

2008-04-15T10:58:25Z

WikiSysop: /* Writing the data to file */

Scripting Export Mesh

2008-04-15T10:33:44Z

WikiSysop: /* Getting started */

Scripting Export Mesh

2008-04-15T09:52:51Z

WikiSysop: /* Writing the data to file */

Scripting Export Mesh

2008-04-15T09:51:39Z

WikiSysop: /* Getting started */

Scripting Export Mesh

2008-04-15T09:21:35Z

WikiSysop: /* Export a mesh */

Scripting Export Mesh

2008-04-15T09:20:31Z

WikiSysop: /* Export a mesh */

==Export a mesh==
In the [[Scripting Guide]] section you learnt how to create TexGen models from Python scripts. In this tutorial I will explain how to get a mesh of the textile and save it to an arbitrary file format. This is a fairly common task but unfortunately one that must often be repeated due to the fact that there is very little standardisation on the file format for meshes. Each software package uses its own mesh file format and so we must learn to read and write to these different formats. Fortunately the Python language is ideal for performing these tasks with relative ease.

==Standalone scripts==
I am going to diverge a bit from this tutorial to talk about standalone scripts. In the previous guide it was assumed that the scripts you were writing would be run from within TexGen. However in some situations you may find it useful to simply run the scripts on their own from the command line without loading up the graphical user interface. In order to do this you must have installed [http://www.python.org/ Python] and installed the non-bundle version of TexGen (see [[Windows Installation]] for more details). To run your script you can then type the following from the command line:

python myscript.py

However before your scripts will work on their own, you must import the TexGen modules at the start of your script. In order to do that simply add the following line to the top of your script:

from TexGen.Core import *

You don't need to do this if you go through the GUI because this step is done automatically for you. Note that by adding this line does not prevent you from running your scripts through the GUI.

==Getting started==

I'm going to assume you already have a textile model you want to get a mesh of and have saved it to a .tg3 file named "textile.tg3". So the first step is to load this model so that we can go about extracting a mesh from it:
<pre>
from TexGen.Core import *
# Read in the textile
ReadFromXML('textile.tg3')

# Get a hold of the textile we just loaded in
textile = GetTextile()
</pre>
The variable <code>textile</code> now contains an instance of the [http://texgen.sourceforge.net/api/class_tex_gen_1_1_c_textile.html CTextile] class representing the textile model.

Scripting Guide

2008-04-15T08:48:50Z

WikiSysop: /* Saving to TG3 file format */

==Python Interface==
[http://www.python.org/ Python] is a high level interpreted programming language. In this case it is used as a scripting language to allow easy access to TexGen functionality. Python has been embedded in the TexGen GUI which allows the GUI to run python scripts. The goal of this tutorial is not to teach Python programming, there are plenty of resources online for that. A few of them are listed below:

* [http://www.poromenos.org/tutorials/python Learn Python in 10 minutes] - Quick introduction to Python for competent programmers.
* [http://docs.python.org/tut/tut.html Python Tutorial] - Official Python tutorial (requires some programming knowledge).
* [http://www.greenteapress.com/thinkpython/ How to Think Like a Computer Scientist: Learning with Python] - Book on Python programming for beginners. [http://www.greenteapress.com/thinkpython/html/ HTML Version]
* [http://diveintopython.org/ Dive Into Python] - In depth book covering advanced subjects in a comprehensive manner. [http://diveintopython.org/toc/index.html HTML Version]

An advanced knowledge of Python is not needed in order to write simple TexGen scripts. However, bear in mind that Python is a very powerful language with many libraries included for performing common tasks. I suggest you try to follow through the examples below and if you get stuck refer to one of the documents above.

===Example 1: A plain weave===
First of all, a Python script is just a plain ASCII text file with a .py extension. To create one simply open up your favorite text editor. Notepad will do if you have nothing else but I suggest a more powerful freeware text editor like [http://www.pspad.com/ PSPad] or [http://notepad-plus.sourceforge.net/ Notepad++]. Code that goes into the python script will be displayed like so:

# All Python code will be shown in a box like this one.
# Lines begining with a '#' character are comments

In this example, we will create a simple 2x2 plain weave model with a Python script. Its time to dive in and see some actual Python code. At this point if you are completely lost please refer back to the resources on Python programming. The first step is to create an instance of the <code>CTextileWeave2D</code> class and give it a name, <code>weave</code>:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

The <code>CTextileWeave2D</code> class takes 5 parameters in the order shown below:
* Number of weft yarns in the unit cell
* Number of warp yarns in the unit cell
* Spacing between the yarns
* Thickness of the fabrics
* Refine model (True/False)

The only parameter that really needs an explanation here is the Refine model option, this controls whether or not the interference correction algorithm will be applied to keep the yarn volumes from intersecting which is a common problem. The interference correction algorithm generally does a good job but is not instantaneous so sometimes it can be beneficial to switch it off.

This is the bare minimum information necessary to create a 2D woven fabric. In the following steps we will add more information to create the model the way we want it.

Let's set the weave pattern, this determines whether a warp or weft yarn will appear on top at a particular cross over. Cross overs are arranged in 2d grid where the size of the grid depends on the number of warp and weft yarns created. To swap the positions of the weft and warp yarns, we call the function <code>SwapPosition</code> with the grid coordinates of the cross over. In order to create a plain weave we need to do this on two diagonally opposite cross overs like so:

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

Now let's add our <code>weave</code> model to the database of models so that TexGen can render it:

# Add the textile
AddTextile(weave)

Thats it! This is a very simple script but it will generate a plain weave model. To recap your Python script should look like this:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

# Add the textile
AddTextile(weave)

Save it to disk as ''PlainWeave.py'' or give it whatever name you want as long as it has a ''.py'' extension.

In order to test the Script we need to load it into TexGen. So start up the TexGen GUI and from the ''Python menu'' select ''Run Script''. Select the file you have just saved and click ok. With a bit of luck you should see a 2d plain weave on screen:

[[Image:Example1.png]]

Congratulations you have created your first TexGen Python script!

===Example 2: Another plain weave (the hard way)===
In the first example we made use of the <code>CTextileWeave2D</code> which is the reason the script is so compact. This was great for creating a 2D Weave, but what if we want to create something other than a 2D Weave? Well, let's stick to the 2D weave for now but in this example we will create geometric model in a generic way without the use of the <code>CTextileWeave2D</code> class. This takes a little bit longer to do, but gives more control over the final geometry.

First we will define a general textile and call it <code>Textile</code>:

# Create a textile
Textile = CTextile()

The <code>CTextile</code> class doesn't take any parameters, instead yarns will be created and added to it. Next we will create 4 yarns to go inside our textile, it is convenient to make use of the Python lists to do this. Create a list called <code>Yarns</code> with 4 elements, each one an instance of the class <code>CYarn</code>:

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

<code>Yarns</code> now contains 4 empty yarns. Note that the yarns are not currently associated with the Textile, first we must fill in the details then make them a part of the textile. The first thing to do is define their paths with nodes. This is done like so:

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

We have added 3 nodes to each yarn creating a woven pattern. The number in the square brackets after <code>Yarns</code> refers to a particular yarn in the list. The function <code>AddNode</code> is then called for the yarn. The function takes an instance of the class <code>CNode</code> which in turn is constructed with an instance of the class <code>XYZ</code> representing the position of the node. The class <code>XYZ</code> is constructed with 3 numbers representing the X, Y and Z coordinates of the point.

We still need to define a few more things to obtain a model. For the sake of simplicity, we will give all the yarns the same cross sectional shape, width, height, etc... The easiest way to do this is to loop over the yarns and assign the same properties to each yarn one by one. The syntax for looping over <code>Yarns</code> is shown here:

# Loop over all the yarns in the list
for Yarn in Yarns:

Inside the loop, the variable <code>Yarn</code> refers to the current yarn in the list. So within the loop we just assign properties to <code>Yarn</code> and they will be applied to all the yarns in the list. In python the begining and end of a loop are defined by indentation, hence the following lines are indented to represent the contents of the loop.

Let us define periodic cubic spline interpolation between the nodes:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

This is done with the function <code>AssignInterpolation</code> which takes an instance of a class derived from <code>CInterpolation</code>. In this case we used <code>CInterpolationCubic</code> to specify periodic cubic spline interpolation.

Next we need to define a cross section for the yarn, to keep things simple a constant cross section all along the length of the yarn will be defined:

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

The function <code>AssignSection</code> takes an instance of a class derived from <code>CYarnSection</code>. In this case we used <code>CYarnSectionConstant</code> which in turns take an instance of a class derived from <code>CSection</code> as a constructor. <code>CSectionEllipse</code> defines an elliptical cross section with given width and height defined by the first and second parameters respectively.

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

This line sets the resolution of the surface mesh created. The first parameter to the function <code>SetResolution</code> represents the number of points around a cross section. The number of points along the length of the yarns is automatically calculated such that the distance between points is similar to around the cross section.

Next we must add repeat vectors to define how the yarns are repeated.

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

The function <code>AddRepeat</code> takes an instance of the class <code>XYZ</code>. As we saw earlier the class <code>XYZ</code> is constructed with 3 numbers defining the X, Y and Z components.

Finally the yarn is fully defined, it can now be added to <code>Textile</code>:

# Add the yarn to our textile
Textile.AddYarn(Yarn)

This is the end of the loop, hence the following lines return to the original indentation. Now let's define a Domain within which the textile will be placed:

Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

The function <code>AssignDomain</code> takes an instance of a class derived from <code>CDomain</code>. In this case we will create a box shaped domain, this can be accomplished by using the class <code>CDomainPlanes</code>. A box can be created by passing in opposite corners of the box (the minimum and maximum coordinates). This is done again with the class <code>XYZ</code>.

And finally <code>Textile</code> must be added to so that it can be rendered. Each Textile added must be assigned a name to identify it, this is the name that will appear at the top in the TexGen GUI. This name can either be generated automatically or we can specify it explicitly like so:

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

That's it! You now have the knowledge to create any type of fabric imaginable. Well, almost. The model created here is pretty simple, there is plenty of oppertunity to create more complex shapes. For example non-constant cross sections can be defined, complex domain shapes defined by arbritrary planes, different interpolation functions.

Here is the completed script:

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

# Loop over all the yarns in the list
for Yarn in Yarns:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a domain and assign it to the textile
Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

And the result:

[[Image:Example2.png]]

===Example 3: A 3d weave===
This example is similar to the [[Scripting Guide#Example 2: Another plain weave (the hard way)|Example 2]] in that the yarns will be defined by nodes. This time we will create a 3d woven fabric that looks like this:

[[Image:Example3.png]]

We start by defining a new CTextile instance:

# Create a textile
Textile = CTextile()

Before starting to define the geometry using TexGen it is helpful to define a list of parameters which may need to be changed later. These typically include spacing between yarns and yarn dimensions:

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

It is a good idea to define these up front rather than hard coding them in the rest of the script because if you want to tweak any parameters they can easily be located and will only need to be changed once. Lets start by defining the warp stuffer yarns, these are fairly easy to define since they all straight and parallel to each other:

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

Next we define the weft stuffer yarns, again these are easy to define:

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

And finally we need to insert the binder yarns. Making clever use of the repeat vectors it is only necessary to define a single instance of the binder yarn.

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Now that the geometry is defined we shall define a domain and add the textile so that TexGen knows about it.

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

The completed scripts is shown below:

# Create a textile
Textile = CTextile()

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

===Saving to TG3 file format===
TexGen has it's own file format for storing textile geometry with the extension .tg3. For more details on this file format please read the [[TG3 File Format]] page. Any textile models saved to this file format can be reloaded at a later time however it is also a good idea to keep the python script used to generate the geometry in case modifications need to be made. To save such a file it is simply a matter of adding an additional like at the end of your script like so:

SaveToXML("MyTextile.tg3")

The first parameter is the name of the file to save, note that if the .tg3 extension is omitted then it will automatically be appended for you. The second parameter is optional and if used should be the name of the textile to save, this is useful if you have several textiles loaded at once (i.e. you called AddTextile more than once) and you only want to save one of them. Note that if you don't specify the second parameter and you do have several textiles loaded then it will save all of them to a single .tg3 file. The third parameter determines how much information is saved in the .tg3 file, see the [[TG3 File Format]] for more details.

Scripting Guide

2008-04-15T08:45:42Z

WikiSysop: /* Saving to TG3 file format */

==Python Interface==
[http://www.python.org/ Python] is a high level interpreted programming language. In this case it is used as a scripting language to allow easy access to TexGen functionality. Python has been embedded in the TexGen GUI which allows the GUI to run python scripts. The goal of this tutorial is not to teach Python programming, there are plenty of resources online for that. A few of them are listed below:

* [http://www.poromenos.org/tutorials/python Learn Python in 10 minutes] - Quick introduction to Python for competent programmers.
* [http://docs.python.org/tut/tut.html Python Tutorial] - Official Python tutorial (requires some programming knowledge).
* [http://www.greenteapress.com/thinkpython/ How to Think Like a Computer Scientist: Learning with Python] - Book on Python programming for beginners. [http://www.greenteapress.com/thinkpython/html/ HTML Version]
* [http://diveintopython.org/ Dive Into Python] - In depth book covering advanced subjects in a comprehensive manner. [http://diveintopython.org/toc/index.html HTML Version]

An advanced knowledge of Python is not needed in order to write simple TexGen scripts. However, bear in mind that Python is a very powerful language with many libraries included for performing common tasks. I suggest you try to follow through the examples below and if you get stuck refer to one of the documents above.

===Example 1: A plain weave===
First of all, a Python script is just a plain ASCII text file with a .py extension. To create one simply open up your favorite text editor. Notepad will do if you have nothing else but I suggest a more powerful freeware text editor like [http://www.pspad.com/ PSPad] or [http://notepad-plus.sourceforge.net/ Notepad++]. Code that goes into the python script will be displayed like so:

# All Python code will be shown in a box like this one.
# Lines begining with a '#' character are comments

In this example, we will create a simple 2x2 plain weave model with a Python script. Its time to dive in and see some actual Python code. At this point if you are completely lost please refer back to the resources on Python programming. The first step is to create an instance of the <code>CTextileWeave2D</code> class and give it a name, <code>weave</code>:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

The <code>CTextileWeave2D</code> class takes 5 parameters in the order shown below:
* Number of weft yarns in the unit cell
* Number of warp yarns in the unit cell
* Spacing between the yarns
* Thickness of the fabrics
* Refine model (True/False)

The only parameter that really needs an explanation here is the Refine model option, this controls whether or not the interference correction algorithm will be applied to keep the yarn volumes from intersecting which is a common problem. The interference correction algorithm generally does a good job but is not instantaneous so sometimes it can be beneficial to switch it off.

This is the bare minimum information necessary to create a 2D woven fabric. In the following steps we will add more information to create the model the way we want it.

Let's set the weave pattern, this determines whether a warp or weft yarn will appear on top at a particular cross over. Cross overs are arranged in 2d grid where the size of the grid depends on the number of warp and weft yarns created. To swap the positions of the weft and warp yarns, we call the function <code>SwapPosition</code> with the grid coordinates of the cross over. In order to create a plain weave we need to do this on two diagonally opposite cross overs like so:

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

Now let's add our <code>weave</code> model to the database of models so that TexGen can render it:

# Add the textile
AddTextile(weave)

Thats it! This is a very simple script but it will generate a plain weave model. To recap your Python script should look like this:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

# Add the textile
AddTextile(weave)

Save it to disk as ''PlainWeave.py'' or give it whatever name you want as long as it has a ''.py'' extension.

In order to test the Script we need to load it into TexGen. So start up the TexGen GUI and from the ''Python menu'' select ''Run Script''. Select the file you have just saved and click ok. With a bit of luck you should see a 2d plain weave on screen:

[[Image:Example1.png]]

Congratulations you have created your first TexGen Python script!

===Example 2: Another plain weave (the hard way)===
In the first example we made use of the <code>CTextileWeave2D</code> which is the reason the script is so compact. This was great for creating a 2D Weave, but what if we want to create something other than a 2D Weave? Well, let's stick to the 2D weave for now but in this example we will create geometric model in a generic way without the use of the <code>CTextileWeave2D</code> class. This takes a little bit longer to do, but gives more control over the final geometry.

First we will define a general textile and call it <code>Textile</code>:

# Create a textile
Textile = CTextile()

The <code>CTextile</code> class doesn't take any parameters, instead yarns will be created and added to it. Next we will create 4 yarns to go inside our textile, it is convenient to make use of the Python lists to do this. Create a list called <code>Yarns</code> with 4 elements, each one an instance of the class <code>CYarn</code>:

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

<code>Yarns</code> now contains 4 empty yarns. Note that the yarns are not currently associated with the Textile, first we must fill in the details then make them a part of the textile. The first thing to do is define their paths with nodes. This is done like so:

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

We have added 3 nodes to each yarn creating a woven pattern. The number in the square brackets after <code>Yarns</code> refers to a particular yarn in the list. The function <code>AddNode</code> is then called for the yarn. The function takes an instance of the class <code>CNode</code> which in turn is constructed with an instance of the class <code>XYZ</code> representing the position of the node. The class <code>XYZ</code> is constructed with 3 numbers representing the X, Y and Z coordinates of the point.

We still need to define a few more things to obtain a model. For the sake of simplicity, we will give all the yarns the same cross sectional shape, width, height, etc... The easiest way to do this is to loop over the yarns and assign the same properties to each yarn one by one. The syntax for looping over <code>Yarns</code> is shown here:

# Loop over all the yarns in the list
for Yarn in Yarns:

Inside the loop, the variable <code>Yarn</code> refers to the current yarn in the list. So within the loop we just assign properties to <code>Yarn</code> and they will be applied to all the yarns in the list. In python the begining and end of a loop are defined by indentation, hence the following lines are indented to represent the contents of the loop.

Let us define periodic cubic spline interpolation between the nodes:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

This is done with the function <code>AssignInterpolation</code> which takes an instance of a class derived from <code>CInterpolation</code>. In this case we used <code>CInterpolationCubic</code> to specify periodic cubic spline interpolation.

Next we need to define a cross section for the yarn, to keep things simple a constant cross section all along the length of the yarn will be defined:

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

The function <code>AssignSection</code> takes an instance of a class derived from <code>CYarnSection</code>. In this case we used <code>CYarnSectionConstant</code> which in turns take an instance of a class derived from <code>CSection</code> as a constructor. <code>CSectionEllipse</code> defines an elliptical cross section with given width and height defined by the first and second parameters respectively.

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

This line sets the resolution of the surface mesh created. The first parameter to the function <code>SetResolution</code> represents the number of points around a cross section. The number of points along the length of the yarns is automatically calculated such that the distance between points is similar to around the cross section.

Next we must add repeat vectors to define how the yarns are repeated.

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

The function <code>AddRepeat</code> takes an instance of the class <code>XYZ</code>. As we saw earlier the class <code>XYZ</code> is constructed with 3 numbers defining the X, Y and Z components.

Finally the yarn is fully defined, it can now be added to <code>Textile</code>:

# Add the yarn to our textile
Textile.AddYarn(Yarn)

This is the end of the loop, hence the following lines return to the original indentation. Now let's define a Domain within which the textile will be placed:

Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

The function <code>AssignDomain</code> takes an instance of a class derived from <code>CDomain</code>. In this case we will create a box shaped domain, this can be accomplished by using the class <code>CDomainPlanes</code>. A box can be created by passing in opposite corners of the box (the minimum and maximum coordinates). This is done again with the class <code>XYZ</code>.

And finally <code>Textile</code> must be added to so that it can be rendered. Each Textile added must be assigned a name to identify it, this is the name that will appear at the top in the TexGen GUI. This name can either be generated automatically or we can specify it explicitly like so:

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

That's it! You now have the knowledge to create any type of fabric imaginable. Well, almost. The model created here is pretty simple, there is plenty of oppertunity to create more complex shapes. For example non-constant cross sections can be defined, complex domain shapes defined by arbritrary planes, different interpolation functions.

Here is the completed script:

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

# Loop over all the yarns in the list
for Yarn in Yarns:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a domain and assign it to the textile
Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

And the result:

[[Image:Example2.png]]

===Example 3: A 3d weave===
This example is similar to the [[Scripting Guide#Example 2: Another plain weave (the hard way)|Example 2]] in that the yarns will be defined by nodes. This time we will create a 3d woven fabric that looks like this:

[[Image:Example3.png]]

We start by defining a new CTextile instance:

# Create a textile
Textile = CTextile()

Before starting to define the geometry using TexGen it is helpful to define a list of parameters which may need to be changed later. These typically include spacing between yarns and yarn dimensions:

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

It is a good idea to define these up front rather than hard coding them in the rest of the script because if you want to tweak any parameters they can easily be located and will only need to be changed once. Lets start by defining the warp stuffer yarns, these are fairly easy to define since they all straight and parallel to each other:

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

Next we define the weft stuffer yarns, again these are easy to define:

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

And finally we need to insert the binder yarns. Making clever use of the repeat vectors it is only necessary to define a single instance of the binder yarn.

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Now that the geometry is defined we shall define a domain and add the textile so that TexGen knows about it.

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

The completed scripts is shown below:

# Create a textile
Textile = CTextile()

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

===Saving to TG3 file format===
TexGen has it's own file format for storing textile geometry with the extension .TG3. For more details on this file format please read the [[TG3 File Format]] page. Any textile models saved to this file format can be reloaded at a later time however it is also a good idea to keep the python script used to generate the geometry in case modifications need to be made. To save such a file it is simply a matter of adding an additional like at the end of your script like so:

SaveToXML("MyTextile.tg3")

The first parameter is the name of the file to save, note that if the .tg3 extension is omitted then it will automatically be appended for you. The second parameter is optional and if used should be the name of the textile to save, this is useful if you have several textiles loaded at once (i.e. you called AddTextile more than once) and you only want to save one of them. Note that if you don't specify the second parameter and you do have several textiles loaded then it will save all of them. The third parameter determines how much information is saved in the .tg3 file, see the [[TG3 File Format]] for more details.

Scripting Guide

2008-04-15T08:44:48Z

WikiSysop:

==Python Interface==
[http://www.python.org/ Python] is a high level interpreted programming language. In this case it is used as a scripting language to allow easy access to TexGen functionality. Python has been embedded in the TexGen GUI which allows the GUI to run python scripts. The goal of this tutorial is not to teach Python programming, there are plenty of resources online for that. A few of them are listed below:

* [http://www.poromenos.org/tutorials/python Learn Python in 10 minutes] - Quick introduction to Python for competent programmers.
* [http://docs.python.org/tut/tut.html Python Tutorial] - Official Python tutorial (requires some programming knowledge).
* [http://www.greenteapress.com/thinkpython/ How to Think Like a Computer Scientist: Learning with Python] - Book on Python programming for beginners. [http://www.greenteapress.com/thinkpython/html/ HTML Version]
* [http://diveintopython.org/ Dive Into Python] - In depth book covering advanced subjects in a comprehensive manner. [http://diveintopython.org/toc/index.html HTML Version]

An advanced knowledge of Python is not needed in order to write simple TexGen scripts. However, bear in mind that Python is a very powerful language with many libraries included for performing common tasks. I suggest you try to follow through the examples below and if you get stuck refer to one of the documents above.

===Example 1: A plain weave===
First of all, a Python script is just a plain ASCII text file with a .py extension. To create one simply open up your favorite text editor. Notepad will do if you have nothing else but I suggest a more powerful freeware text editor like [http://www.pspad.com/ PSPad] or [http://notepad-plus.sourceforge.net/ Notepad++]. Code that goes into the python script will be displayed like so:

# All Python code will be shown in a box like this one.
# Lines begining with a '#' character are comments

In this example, we will create a simple 2x2 plain weave model with a Python script. Its time to dive in and see some actual Python code. At this point if you are completely lost please refer back to the resources on Python programming. The first step is to create an instance of the <code>CTextileWeave2D</code> class and give it a name, <code>weave</code>:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

The <code>CTextileWeave2D</code> class takes 5 parameters in the order shown below:
* Number of weft yarns in the unit cell
* Number of warp yarns in the unit cell
* Spacing between the yarns
* Thickness of the fabrics
* Refine model (True/False)

The only parameter that really needs an explanation here is the Refine model option, this controls whether or not the interference correction algorithm will be applied to keep the yarn volumes from intersecting which is a common problem. The interference correction algorithm generally does a good job but is not instantaneous so sometimes it can be beneficial to switch it off.

This is the bare minimum information necessary to create a 2D woven fabric. In the following steps we will add more information to create the model the way we want it.

Let's set the weave pattern, this determines whether a warp or weft yarn will appear on top at a particular cross over. Cross overs are arranged in 2d grid where the size of the grid depends on the number of warp and weft yarns created. To swap the positions of the weft and warp yarns, we call the function <code>SwapPosition</code> with the grid coordinates of the cross over. In order to create a plain weave we need to do this on two diagonally opposite cross overs like so:

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

Now let's add our <code>weave</code> model to the database of models so that TexGen can render it:

# Add the textile
AddTextile(weave)

Thats it! This is a very simple script but it will generate a plain weave model. To recap your Python script should look like this:

# Create a 2D weave textile
weave = CTextileWeave2D(2, 2, 1, 0.2, True)

# Set the weave pattern
weave.SwapPosition(0, 0)
weave.SwapPosition(1, 1)

# Add the textile
AddTextile(weave)

Save it to disk as ''PlainWeave.py'' or give it whatever name you want as long as it has a ''.py'' extension.

In order to test the Script we need to load it into TexGen. So start up the TexGen GUI and from the ''Python menu'' select ''Run Script''. Select the file you have just saved and click ok. With a bit of luck you should see a 2d plain weave on screen:

[[Image:Example1.png]]

Congratulations you have created your first TexGen Python script!

===Example 2: Another plain weave (the hard way)===
In the first example we made use of the <code>CTextileWeave2D</code> which is the reason the script is so compact. This was great for creating a 2D Weave, but what if we want to create something other than a 2D Weave? Well, let's stick to the 2D weave for now but in this example we will create geometric model in a generic way without the use of the <code>CTextileWeave2D</code> class. This takes a little bit longer to do, but gives more control over the final geometry.

First we will define a general textile and call it <code>Textile</code>:

# Create a textile
Textile = CTextile()

The <code>CTextile</code> class doesn't take any parameters, instead yarns will be created and added to it. Next we will create 4 yarns to go inside our textile, it is convenient to make use of the Python lists to do this. Create a list called <code>Yarns</code> with 4 elements, each one an instance of the class <code>CYarn</code>:

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

<code>Yarns</code> now contains 4 empty yarns. Note that the yarns are not currently associated with the Textile, first we must fill in the details then make them a part of the textile. The first thing to do is define their paths with nodes. This is done like so:

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

We have added 3 nodes to each yarn creating a woven pattern. The number in the square brackets after <code>Yarns</code> refers to a particular yarn in the list. The function <code>AddNode</code> is then called for the yarn. The function takes an instance of the class <code>CNode</code> which in turn is constructed with an instance of the class <code>XYZ</code> representing the position of the node. The class <code>XYZ</code> is constructed with 3 numbers representing the X, Y and Z coordinates of the point.

We still need to define a few more things to obtain a model. For the sake of simplicity, we will give all the yarns the same cross sectional shape, width, height, etc... The easiest way to do this is to loop over the yarns and assign the same properties to each yarn one by one. The syntax for looping over <code>Yarns</code> is shown here:

# Loop over all the yarns in the list
for Yarn in Yarns:

Inside the loop, the variable <code>Yarn</code> refers to the current yarn in the list. So within the loop we just assign properties to <code>Yarn</code> and they will be applied to all the yarns in the list. In python the begining and end of a loop are defined by indentation, hence the following lines are indented to represent the contents of the loop.

Let us define periodic cubic spline interpolation between the nodes:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

This is done with the function <code>AssignInterpolation</code> which takes an instance of a class derived from <code>CInterpolation</code>. In this case we used <code>CInterpolationCubic</code> to specify periodic cubic spline interpolation.

Next we need to define a cross section for the yarn, to keep things simple a constant cross section all along the length of the yarn will be defined:

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

The function <code>AssignSection</code> takes an instance of a class derived from <code>CYarnSection</code>. In this case we used <code>CYarnSectionConstant</code> which in turns take an instance of a class derived from <code>CSection</code> as a constructor. <code>CSectionEllipse</code> defines an elliptical cross section with given width and height defined by the first and second parameters respectively.

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

This line sets the resolution of the surface mesh created. The first parameter to the function <code>SetResolution</code> represents the number of points around a cross section. The number of points along the length of the yarns is automatically calculated such that the distance between points is similar to around the cross section.

Next we must add repeat vectors to define how the yarns are repeated.

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

The function <code>AddRepeat</code> takes an instance of the class <code>XYZ</code>. As we saw earlier the class <code>XYZ</code> is constructed with 3 numbers defining the X, Y and Z components.

Finally the yarn is fully defined, it can now be added to <code>Textile</code>:

# Add the yarn to our textile
Textile.AddYarn(Yarn)

This is the end of the loop, hence the following lines return to the original indentation. Now let's define a Domain within which the textile will be placed:

Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

The function <code>AssignDomain</code> takes an instance of a class derived from <code>CDomain</code>. In this case we will create a box shaped domain, this can be accomplished by using the class <code>CDomainPlanes</code>. A box can be created by passing in opposite corners of the box (the minimum and maximum coordinates). This is done again with the class <code>XYZ</code>.

And finally <code>Textile</code> must be added to so that it can be rendered. Each Textile added must be assigned a name to identify it, this is the name that will appear at the top in the TexGen GUI. This name can either be generated automatically or we can specify it explicitly like so:

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

That's it! You now have the knowledge to create any type of fabric imaginable. Well, almost. The model created here is pretty simple, there is plenty of oppertunity to create more complex shapes. For example non-constant cross sections can be defined, complex domain shapes defined by arbritrary planes, different interpolation functions.

Here is the completed script:

# Create a textile
Textile = CTextile()

# Create a python list containing 4 yarns
Yarns = [CYarn(), CYarn(), CYarn(), CYarn()]

# Add nodes to the yarns to describe their paths
Yarns[0].AddNode(CNode(XYZ(0, 0, 0)))
Yarns[0].AddNode(CNode(XYZ(0.22, 0, 0.05)))
Yarns[0].AddNode(CNode(XYZ(0.44, 0, 0)))

Yarns[1].AddNode(CNode(XYZ(0, 0.22, 0.05)))
Yarns[1].AddNode(CNode(XYZ(0.22, 0.22, 0)))
Yarns[1].AddNode(CNode(XYZ(0.44, 0.22, 0.05)))

Yarns[2].AddNode(CNode(XYZ(0, 0, 0.05)))
Yarns[2].AddNode(CNode(XYZ(0, 0.22, 0)))
Yarns[2].AddNode(CNode(XYZ(0, 0.44, 0.05)))

Yarns[3].AddNode(CNode(XYZ(0.22, 0, 0)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.22, 0.05)))
Yarns[3].AddNode(CNode(XYZ(0.22, 0.44, 0)))

# Loop over all the yarns in the list
for Yarn in Yarns:

# Set the interpolation function
Yarn.AssignInterpolation(CInterpolationCubic())

# Assign a constant cross-section all along the yarn of elliptical shape
Yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(0.18, 0.04)))

# Set the resolution of the surface mesh created
Yarn.SetResolution(20)

# Add repeat vectors to the yarn
Yarn.AddRepeat(XYZ(0.44, 0, 0))
Yarn.AddRepeat(XYZ(0, 0.44, 0))

# Add the yarn to our textile
Textile.AddYarn(Yarn)

# Create a domain and assign it to the textile
Textile.AssignDomain(CDomainPlanes(XYZ(0, 0, -0.02), XYZ(0.44, 0.44, 0.07)))

# Add the textile with the name "polyester"
AddTextile("polyester", Textile)

And the result:

[[Image:Example2.png]]

===Example 3: A 3d weave===
This example is similar to the [[Scripting Guide#Example 2: Another plain weave (the hard way)|Example 2]] in that the yarns will be defined by nodes. This time we will create a 3d woven fabric that looks like this:

[[Image:Example3.png]]

We start by defining a new CTextile instance:

# Create a textile
Textile = CTextile()

Before starting to define the geometry using TexGen it is helpful to define a list of parameters which may need to be changed later. These typically include spacing between yarns and yarn dimensions:

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

It is a good idea to define these up front rather than hard coding them in the rest of the script because if you want to tweak any parameters they can easily be located and will only need to be changed once. Lets start by defining the warp stuffer yarns, these are fairly easy to define since they all straight and parallel to each other:

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

Next we define the weft stuffer yarns, again these are easy to define:

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

And finally we need to insert the binder yarns. Making clever use of the repeat vectors it is only necessary to define a single instance of the binder yarn.

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Now that the geometry is defined we shall define a domain and add the textile so that TexGen knows about it.

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

The completed scripts is shown below:

# Create a textile
Textile = CTextile()

# Define some parameters
# Spacing between weft yarns
sx = 2
# Spacing between warp yarns
sy = 0.8
# Vertical distance between yarns at cross overs
sz = 0.16

# Width of the weft yarns is less than the weft spacing
weftyarnwidth = 1.2
# Width of the warp yarns set equal to the warp spacing
warpyarnwidth = sy
# Yarn height equal to the vertical distance between yarns at cross overs
yarnheight = sz

# Create warp stuffer yarns
for i in range(3):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, 2*i*sz)))
yarn.AddNode(CNode(XYZ(2*sx, 0, 2*i*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create weft stuffer yarns
for i in range(4):
yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, 0, (2*i-1)*sz)))
yarn.AddNode(CNode(XYZ(0, 2*sy, (2*i-1)*sz)))

yarn.AssignInterpolation(CInterpolationCubic())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(weftyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(sx, 0, 0))
yarn.AddRepeat(XYZ(0, 2*sy, 0))

Textile.AddYarn(yarn)

# Create warp binder yarns
top = 6*sz
bottom = -2*sz

oh = 0.5*weftyarnwidth+0.12
ov = 0.8*sz

yarn = CYarn()
yarn.AddNode(CNode(XYZ(0, sy, top)))
yarn.AddNode(CNode(XYZ(oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(sx-oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(sx, sy, bottom)))
yarn.AddNode(CNode(XYZ(sx+oh, sy, bottom+ov)))
yarn.AddNode(CNode(XYZ(2*sx-oh, sy, top-ov)))
yarn.AddNode(CNode(XYZ(2*sx, sy, top)))

yarn.AssignInterpolation(CInterpolationBezier())
yarn.AssignSection(CYarnSectionConstant(CSectionEllipse(warpyarnwidth, yarnheight)))
yarn.SetResolution(20)
yarn.AddRepeat(XYZ(2*sx, 0, 0))
yarn.AddRepeat(XYZ(sx, 2*sy, 0))

Textile.AddYarn(yarn)

Textile.AssignDomain(CDomainPlanes(XYZ(-0.5*sx,-0.5*sy,bottom-sz), XYZ(1.5*sx,3.5*sy,top+sz)))

# Add the textile to our TexGen singleton
AddTextile(Textile)

===Saving to TG3 file format===
TexGen has it's own file format for storing textile geometry with the extension .TG3. For more details on this file format please read the [[TG3 File Format]] page. Any textile models saved to this file format can be reloaded at a later time however it is also a good idea to keep the python script used to generate the geometry in case modifications need to be made. To save such a file it is simply a matter of adding an additional like at the end of your script like so:

SaveToXML("MyTextile.tg3")

The first parameter is the name of the file to save, note that if the .tg3 extension is omitted then it will automatically be appended for you. The second parameter is optional and if used should be the name of the textile to save, this is useful if you have several textiles loaded at once and you only want to save one of them. Note that if you don't specify the second parameter and you do have several textiles loaded then it will save all of them. The third parameter determines how much information is saved in the .tg3 file, see the [[TG3 File Format]] for more details.

Scripting Export Mesh

2008-04-14T15:39:30Z

WikiSysop: