Export limb geometry to an open CAD format

[stfnp]

In GitLab by spfeifer on Jan 8, 2018, 17:34

[stfnp]

In GitLab by ozra on Jan 9, 2018, 12:23

One format I know of is Step (stp), which handles solid geometry (not only tesselated/polygon data).
AutoCAD, FreeCAD, etc. handles it, afaik, as well as free standing viewers.

[stfnp]

In GitLab by spfeifer on Jan 17, 2018, 23:17

STEP seems like a good choice. Maybe use the STEPcode library. Another option would be IGES with libIGES for example.

[stfnp]

In GitLab by ozra on Jan 23, 2018, 00:37

Of the two, Step seems more capable, while Iges covers more legacy / wider repertoire of sw packages. A quick web scan indicates there's plenty of software for conversion, so feels like Step would be the better choice. Being able to also describe materials if wanted.

[stfnp]

In GitLab by spfeifer on Jan 23, 2018, 10:58

Material properties is a good point, that pretty much rules out IGES then.

[stfnp]

Have been thinking some more about this. Using a library might be overkill in this case, because STEP is just a text format and we only need to generate it, never load. Instead we could just create a "test limb" in a CAD program, export it as STEP and look at the result. Then try and write some code that generates similar files, but with exchangeable numbers.

[stfnp]

I made a Python script that creates a CAD model of a generic bow limb and export it as a STEP file using CadQuery.

This is what the result looks like in ANSYS SpaceClaim:

Python script: https://gist.github.com/stfnp/12f1705ca7576738ba2ac414976553fe
Output file: result.zip

The original limb geometry is approximated by splines, since not all geometry in VirtualBow has a 1:1 representation in STEP. (Even if that were the case, I wouldn't want to commit to only ever using geometry that is supported by our export formats.) Ideally the resolution of the spline approximation would be determined by some error tolerance that users can modify, like e.g. 1e-3 mm.

Now the remaining tasks, in my opinion, are

• Answer remaining questions below
• Analyze the resulting STEP files, maybe clean them up and rearrange sections
• Recreate them in C++ without using CadQuery. The basic syntax is described on Wikipedia.
• Add STEP export to VirtualBow

Question 1: Should the layers be exported as an assembly or as a single compound part?

Assembly:

result = (
    cq.Assembly(name="MyBow")
    .add(layer_1, name="Layer_1", color=cq.Color("gray"))
    .add(layer_2, name="Layer_2", color=cq.Color("red"))
)

Compound:

# https://github.com/CadQuery/cadquery/issues/212
def create_compound(parts):
    vals = []
    for part in parts:
        for o in part.all():
            vals.extend(o.vals())
        
    return cq.Compound.makeCompound(vals)

Question 2: Can STEP represent material properties/assignments, apart from color? How would that work in either of the two cases above?

https://forum.freecadweb.org/viewtopic.php?t=48641

Links

• Draft version of ISO 10303-21 with specification for the syntax: http://www.steptools.com/stds/step/IS_final_p21e3.html

• Best practices for implementation: https://www.oasis-open.org/committees/download.php/11728/recprac8.pdf

• Documentation of the various entities in a STEP file: https://www.steptools.com/stds/stp_aim/html/schema.html

Edit:

My current progress on reverse-engineering the format is this Python script that generates a STEP file for a cube without using any external libraries: https://gist.github.com/stfnp/55004e52ea60825efa7ceee92f4094d9

Material properties seem to be difficult and/or not well supported except for name, color and density. Maybe only set name and color for consistency (no physical properties).

[stfnp]

A first working Python prototype for CAD export: https://gist.github.com/stfnp/b3d32feb95f389a5a6664f6f7051630d

This script can create files in the STEP and STL formats. STL is another very common exchange format, but based on triangle meshes instead of solids. With these two export formats it should be possible to get the bow geometry imported into virtually any other CAD/Simulation/Graphics software out there, so I don't think that any more formats are necessary for now.

The following points of the STEP implementation still need some work:

• The files open correctly in ANSYS SpaceClaim, but do not show correctly in PTC Creo or FreeCAD

• The implementation creates some duplicate entities that could be shared between layers instead.

• The exported geometry is described with B-Spline curves and surfaces. For now the original limb points have been used as the control points. But B-Splines don't generally interpolate their control points, so this is visually close but not correct. The control points have to be determined from the source points such that the resulting spline interpolates the source points, see for example https://pages.mtu.edu/~shene/COURSES/cs3621/NOTES/INT-APP/CURVE-INT-global.html. In Python this could be done with scipy.interpolate.make_interp_spline.

• Support layers that have a height of zero over some part of their length (also relevant for STL)

  • Possibility 1: Ignore and export solids with a thickness of zero at some areas => Works technically, but the importing software might show the surfaces with graphical artifacts (testet with SpaceClaim) which makes it look as if something with the file was wrong...
  • Possibility 2: The layer height as of now can be zero at arbitrary points of the limb and as often as wanted. So if the exported solid for the layer shouldn't have a thickness of zero anywhere, multiple solids might be needed per layer. Maybe more sensible would be to restrict the layer definition and say that a layer can have a thickness of zero only at the first and/or the last control point. So it is still possible to define layers that fade in/out, but not multiple times. Each layer then corresponds to exactly one solid and can be exported as such => See new issue Restrictions for layer height distribution #244

Eventually the STEP export will also have to work with non-rectangular cross sections (#206). I'm afraid this is going to be quite tricky, with things like edge roundings that potentially cut through multiple layers and create additional surfaces. But that's out of scope for now.