stepfg 2.0.0__tar.gz

stepfg-2.0.0/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Eremey Valetov and Martin Berz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

stepfg-2.0.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: stepfg
+Version: 2.0.0
+Summary: Convert 2D polygon cross-sections into 3D STEP files via extrusion
+Author: Martin Berz
+Author-email: Eremey Valetov <evv@msu.edu>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/evvaletov/stepfg
+Keywords: STEP,CAD,polygon,extrusion,3D,ISO-10303
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Dynamic: license-file
+
+# stepfg: STEP File Generator
+
+**Python 3.8+** | **Zero dependencies** | [MIT License](LICENSE.md)
+
+Authors: E. Valetov and M. Berz
+Organization: Michigan State University
+Creation date: 03-Feb-2017
+
+## Introduction
+
+stepfg converts lists of 2D polygons (specified by vertices in the x-y plane)
+into 3D STEP files (ISO 10303-242) by extruding the polygon interiors along
+the z-axis. Pure Python, no external dependencies.
+
+## Installation
+
+```
+pip install stepfg
+```
+
+Or from source:
+
+```
+git clone https://github.com/evvaletov/stepfg.git
+cd stepfg
+pip install -e .
+```
+
+## Library usage
+
+```python
+from stepfg import StepBuilder, generate_step
+
+# Quick one-liner
+content = generate_step(
+    polygons=[[[0, 0], [1, 0], [1, 1], [0, 1]]],
+    z_range=[0, 10],
+    scale=1,
+)
+
+# Or use StepBuilder for more control
+builder = StepBuilder('output.stp')
+builder.generate_assembly(
+    list_vert_list=[[[0, 0], [1, 0], [1, 1], [0, 1]]],
+    geom_depth_list=[0, 10],
+    p_coeff=1,
+)
+builder.to_file('output.stp')
+```
+
+## Command-line usage
+
+```
+stepfg [input_file [output_file]]
+python -m stepfg [input_file [output_file]]
+```
+
+Run with the included sample geometry (a Muon g-2 quadrupole):
+
+```
+stepfg part_geometry.txt quadrupole.stp
+```
+
+## Input file format
+
+The input file is a Python literal containing three elements:
+
+```python
+[polygons, z_range, scale]
+```
+
+- **polygons**: `[[vertex, ...], ...]` — each vertex is `[x, y]` or `[x, y, 0]`
+- **z_range**: `[z1, z2]` — extrusion interval
+- **scale**: proportionality coefficient (output is in mm; use 10 for cm input)
+
+A sample input file `part_geometry.txt` containing a Muon g-2 Collaboration
+quadrupole cross-section is included.
+
+## Copyright Notice
+
+© 2017 Eremey Valetov and Martin Berz

stepfg-2.0.0/README.md

@@ -0,0 +1,81 @@
+# stepfg: STEP File Generator
+
+**Python 3.8+** | **Zero dependencies** | [MIT License](LICENSE.md)
+
+Authors: E. Valetov and M. Berz
+Organization: Michigan State University
+Creation date: 03-Feb-2017
+
+## Introduction
+
+stepfg converts lists of 2D polygons (specified by vertices in the x-y plane)
+into 3D STEP files (ISO 10303-242) by extruding the polygon interiors along
+the z-axis. Pure Python, no external dependencies.
+
+## Installation
+
+```
+pip install stepfg
+```
+
+Or from source:
+
+```
+git clone https://github.com/evvaletov/stepfg.git
+cd stepfg
+pip install -e .
+```
+
+## Library usage
+
+```python
+from stepfg import StepBuilder, generate_step
+
+# Quick one-liner
+content = generate_step(
+    polygons=[[[0, 0], [1, 0], [1, 1], [0, 1]]],
+    z_range=[0, 10],
+    scale=1,
+)
+
+# Or use StepBuilder for more control
+builder = StepBuilder('output.stp')
+builder.generate_assembly(
+    list_vert_list=[[[0, 0], [1, 0], [1, 1], [0, 1]]],
+    geom_depth_list=[0, 10],
+    p_coeff=1,
+)
+builder.to_file('output.stp')
+```
+
+## Command-line usage
+
+```
+stepfg [input_file [output_file]]
+python -m stepfg [input_file [output_file]]
+```
+
+Run with the included sample geometry (a Muon g-2 quadrupole):
+
+```
+stepfg part_geometry.txt quadrupole.stp
+```
+
+## Input file format
+
+The input file is a Python literal containing three elements:
+
+```python
+[polygons, z_range, scale]
+```
+
+- **polygons**: `[[vertex, ...], ...]` — each vertex is `[x, y]` or `[x, y, 0]`
+- **z_range**: `[z1, z2]` — extrusion interval
+- **scale**: proportionality coefficient (output is in mm; use 10 for cm input)
+
+A sample input file `part_geometry.txt` containing a Muon g-2 Collaboration
+quadrupole cross-section is included.
+
+## Copyright Notice
+
+© 2017 Eremey Valetov and Martin Berz

stepfg-2.0.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "stepfg"
+version = "2.0.0"
+description = "Convert 2D polygon cross-sections into 3D STEP files via extrusion"
+authors = [
+    { name = "Eremey Valetov", email = "evv@msu.edu" },
+    { name = "Martin Berz" },
+]
+license = "MIT"
+requires-python = ">=3.8"
+readme = "README.md"
+keywords = ["STEP", "CAD", "polygon", "extrusion", "3D", "ISO-10303"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering",
+]
+
+[project.scripts]
+stepfg = "stepfg.__main__:main"
+
+[project.urls]
+Repository = "https://github.com/evvaletov/stepfg"
+
+[tool.setuptools.packages.find]
+include = ["stepfg*"]

stepfg-2.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

stepfg-2.0.0/stepfg/__init__.py

@@ -0,0 +1,23 @@
+"""stepfg — convert 2D polygon cross-sections to 3D STEP files via extrusion."""
+
+__version__ = "2.0.0"
+
+from ._builder import StepBuilder
+from ._geometry import normalize, cross_product, convert_3d, convert_to_clockwise
+
+
+def generate_step(polygons, z_range, scale=1, filename='part_out.stp'):
+    """Generate STEP content from polygon cross-sections.
+
+    Args:
+        polygons: List of polygons, each a list of [x,y] or [x,y,z] vertices.
+        z_range: [z1, z2] extrusion interval.
+        scale: Proportionality coefficient (default 1). Use 10 for cm→mm.
+        filename: Filename embedded in the STEP header.
+
+    Returns:
+        STEP file content as a string.
+    """
+    builder = StepBuilder(filename)
+    builder.generate_assembly(polygons, z_range, scale)
+    return builder.to_string()

stepfg-2.0.0/stepfg/__main__.py

@@ -0,0 +1,66 @@
+"""CLI entry point: python -m stepfg"""
+
+import argparse
+import ast
+import sys
+from pathlib import Path
+
+from . import __version__, generate_step
+
+
+BANNER = """\
+----------------------------------------------------
+                STEP File Generator
+              E. Valetov and M. Berz
+             Michigan State University
+                Created 03-Feb-2017
+              Email: valetove@msu.edu
+----------------------------------------------------"""
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog='stepfg',
+        description='Convert 2D polygon geometry into 3D STEP files via extrusion.',
+    )
+    parser.add_argument('input', nargs='?', default='part_geometry.txt',
+                        help='Input file containing 2D geometry data (default: part_geometry.txt)')
+    parser.add_argument('output', nargs='?', default='part_out.stp',
+                        help='Output STEP file (default: part_out.stp)')
+    parser.add_argument('-V', '--version', action='version', version=f'stepfg {__version__}')
+
+    args = parser.parse_args(argv)
+
+    print(BANNER)
+
+    input_path = Path(args.input)
+    if not input_path.is_file():
+        print(f"Error: input file '{args.input}' not found.", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Reading 2D geometry file {args.input}... ", end="")
+    data = ast.literal_eval(input_path.read_text())
+    if not isinstance(data, list) or len(data) != 3:
+        print("[FAILED]")
+        print("Error: input must be a list of [polygons, z_range, scale].", file=sys.stderr)
+        sys.exit(1)
+    print("[DONE]")
+
+    polygons, z_range, scale = data
+
+    print("Generating assembly... ", end="")
+    try:
+        content = generate_step(polygons, z_range, scale, args.output)
+    except ValueError as e:
+        print("[FAILED]")
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    print("[DONE]")
+
+    print(f"Writing STEP file {args.output}... ", end="")
+    Path(args.output).write_text(content)
+    print("[DONE]")
+
+
+if __name__ == '__main__':
+    main()

stepfg-2.0.0/stepfg/_builder.py

@@ -0,0 +1,261 @@
+import operator
+import re
+from numbers import Number
+
+from ._geometry import normalize, cross_product, rotate, convert_3d, convert_to_clockwise
+from ._template import step_header
+
+
+def _line_index(line):
+    m = re.search(r'#(.+?)=', line)
+    return 0 if m is None else int(m.group(1))
+
+
+def _to_coord(clist):
+    if len(clist) != 3:
+        raise ValueError("to_coord: coordinates must be 3D")
+    return str(clist[0]) + ',' + str(clist[1]) + ',' + str(clist[2])
+
+
+def _to_step_list(slist):
+    if not isinstance(slist, list):
+        return '#' + str(slist)
+    return ','.join('#' + str(s) for s in slist)
+
+
+def _fort_bool(bool_in):
+    return '.T.' if (bool_in is True) or (bool_in == '.T.') else '.F.'
+
+
+class StepBuilder:
+    def __init__(self, filename='part_out.stp'):
+        self._filename = filename
+        self._file_array, self._index1, highest = step_header(filename)
+        self._current_index = highest + 1
+        self._work_array = []
+        self._part_body_index = 1
+
+    def _item_exists(self, string_in):
+        if not self._work_array:
+            return False
+        return any(item.endswith(string_in) for item in self._work_array)
+
+    def _existing_item_ln(self, string_in):
+        if not self._work_array or not self._item_exists(string_in):
+            return False
+        match = next(item for item in self._work_array if item.endswith(string_in))
+        return _line_index(match)
+
+    def new_item(self, string_in):
+        if self._item_exists(string_in):
+            return self._existing_item_ln(string_in)
+        self._work_array.append('#' + str(self._current_index) + '=' + string_in)
+        idx = self._current_index
+        self._current_index += 1
+        return idx
+
+    def point(self, coord_in):
+        return self.new_item(
+            "CARTESIAN_POINT('',(" + _to_coord(coord_in) + ")) ;\n")
+
+    def line(self, origin, direction):
+        coord_ln = self.new_item(
+            "CARTESIAN_POINT('Origin Line',(" + _to_coord(origin) + ")) ;\n")
+        dir_ln = self.new_item(
+            "DIRECTION('Vector Direction',("
+            + _to_coord(normalize(direction)) + ")) ;\n")
+        vec_ln = self.new_item(
+            "VECTOR('Line Direction',#" + str(dir_ln) + ",1.) ;\n")
+        return self.new_item(
+            "LINE('Line',#" + str(coord_ln) + ",#" + str(vec_ln) + ") ;\n")
+
+    def vertex(self, coord_in):
+        coord_ln = self.new_item(
+            "CARTESIAN_POINT('Vertex',(" + _to_coord(coord_in) + ")) ;\n")
+        return self.new_item("VERTEX_POINT('',#" + str(coord_ln) + ") ;\n")
+
+    def edge_curve(self, vertex1_ln, vertex2_ln, line_coord_ln, same_sense=True):
+        return self.new_item(
+            "EDGE_CURVE('',#" + str(vertex1_ln) + ",#" + str(vertex2_ln)
+            + ",#" + str(line_coord_ln) + "," + _fort_bool(same_sense) + ") ;\n")
+
+    def _edge_curve_0(self, v1, v2, same_sense=True):
+        return self.edge_curve(
+            self.vertex(v1), self.vertex(v2),
+            self.line(
+                [x / 2 for x in list(map(operator.add, v1, v2))],
+                list(map(operator.sub, v2, v1))),
+            _fort_bool(same_sense))
+
+    def oriented_edge(self, edge_curve_ln, same_sense=True):
+        return self.new_item(
+            "ORIENTED_EDGE('',*,*,#" + str(edge_curve_ln) + ","
+            + _fort_bool(same_sense) + ") ;\n")
+
+    def edge_loop(self, lines):
+        return self.new_item(
+            "EDGE_LOOP('',(" + _to_step_list(lines) + ")) ;\n")
+
+    def _edge_loop_0(self, vertices):
+        return self.edge_loop([
+            self.oriented_edge(self._edge_curve_0(x1, x2))
+            for x1, x2 in zip(vertices, rotate(vertices, -1))
+        ])
+
+    def face_outer_bound(self, edge_loop_ln, same_sense=True):
+        return self.new_item(
+            "FACE_OUTER_BOUND('',#" + str(edge_loop_ln) + ","
+            + _fort_bool(same_sense) + ") ;\n")
+
+    def _edge_loop_1(self, vertices, same_sense=True):
+        return self.face_outer_bound(self._edge_loop_0(vertices), same_sense)
+
+    def _axis2_placement_3d(self, origin_coord, direction1, direction2):
+        origin_ln = self.new_item(
+            "CARTESIAN_POINT('Axis2P3D Location',("
+            + _to_coord(origin_coord) + ")) ;\n")
+        d1_ln = self.new_item(
+            "DIRECTION('Axis2P3D ZDirection',("
+            + _to_coord(direction1) + ")) ;\n")
+        d2_ln = self.new_item(
+            "DIRECTION('Axis2P3D XDirection',("
+            + _to_coord(direction2) + ")) ;\n")
+        return self.new_item(
+            "AXIS2_PLACEMENT_3D('Plane Axis2P3D',#" + str(origin_ln)
+            + ",#" + str(d1_ln) + ",#" + str(d2_ln) + ") ;\n")
+
+    def plane(self, axis2_placement_3d_ln):
+        return self.new_item(
+            "PLANE('',#" + str(axis2_placement_3d_ln) + ") ;\n")
+
+    def advanced_face(self, face_outer_bound_ln, plane_ln, same_sense_plane=True):
+        return self.new_item(
+            "ADVANCED_FACE('PartBody',(" + _to_step_list(face_outer_bound_ln)
+            + "),#" + str(plane_ln) + "," + _fort_bool(same_sense_plane) + ") ;\n")
+
+    def _advanced_face_0(self, vertices, zaxis, same_sense_1=True, same_sense_2=True):
+        cp = cross_product(
+            list(map(operator.sub, vertices[2], vertices[1])),
+            list(map(operator.sub, vertices[2], vertices[0])))
+        if list(map(operator.add, normalize(zaxis), normalize(cp))) == [0, 0, 0]:
+            return self.advanced_face(
+                self._edge_loop_1(vertices, same_sense_1),
+                self.plane(self._axis2_placement_3d(
+                    vertices[0], normalize(zaxis),
+                    normalize(list(map(operator.sub, vertices[1], vertices[0]))))),
+                same_sense_2)
+        else:
+            rev = list(reversed(vertices))
+            return self.advanced_face(
+                self._edge_loop_1(rev, same_sense_1),
+                self.plane(self._axis2_placement_3d(
+                    vertices[0], normalize(zaxis),
+                    normalize(list(map(operator.sub, rev[1], rev[0]))))),
+                same_sense_2)
+
+    def closed_shell(self, advanced_face_ln_list):
+        return self.new_item(
+            "CLOSED_SHELL('Closed Shell',("
+            + _to_step_list(advanced_face_ln_list) + ")) ;\n")
+
+    def manifold_solid_brep(self, closed_shell_ln):
+        msb = self.new_item(
+            "MANIFOLD_SOLID_BREP('PartBody." + str(self._part_body_index)
+            + "',#" + str(closed_shell_ln) + ") ;\n")
+        self._part_body_index += 1
+        return msb
+
+    def _advanced_brep_shape_representation(self, msb_list, init_ln=45):
+        return self.new_item(
+            "ADVANCED_BREP_SHAPE_REPRESENTATION('NONE',("
+            + _to_step_list(msb_list) + "),#" + str(init_ln) + ") ;\n")
+
+    def _shape_representation_relationship(self, absr_ln, sr_ln=48):
+        return self.new_item(
+            "SHAPE_REPRESENTATION_RELATIONSHIP(' ',' ',#" + str(sr_ln)
+            + ",#" + str(absr_ln) + ") ;\n")
+
+    def zface(self, vertex1, vertex2, geom_depth_list):
+        z_neg, z_pos = geom_depth_list
+        return self._advanced_face_0(
+            [list(map(operator.add, vertex1, [0, 0, z_neg])),
+             list(map(operator.add, vertex2, [0, 0, z_neg])),
+             list(map(operator.add, vertex2, [0, 0, z_pos])),
+             list(map(operator.add, vertex1, [0, 0, z_pos]))],
+            normalize(cross_product(
+                list(map(operator.sub, vertex2, vertex1)),
+                [0, 0, -(z_pos - z_neg)])))
+
+    def xyface(self, vertex_list, depth, zdir):
+        return self._advanced_face_0(
+            [list(map(operator.add, x, [0, 0, depth])) for x in vertex_list],
+            zdir)
+
+    def af2d3d(self, vertex_list, geom_depth_list):
+        z_neg, z_pos = geom_depth_list
+        faces = [
+            self.xyface(vertex_list, z_pos, [0, 0, 1]),
+            self.xyface(vertex_list, z_neg, [0, 0, -1]),
+        ]
+        faces += [
+            self.zface(x1, x2, geom_depth_list)
+            for x1, x2 in zip(vertex_list, rotate(vertex_list, -1))
+        ]
+        return faces
+
+    def generate_part(self, vert_list, geom_depth):
+        return self.manifold_solid_brep(
+            self.closed_shell(self.af2d3d(vert_list, geom_depth)))
+
+    def generate_assembly(self, list_vert_list, geom_depth_list, p_coeff=1):
+        if not isinstance(p_coeff, Number):
+            raise ValueError("NaN supplied for proportionality coefficient")
+        if p_coeff == 0:
+            raise ValueError("Zero supplied as the proportionality coefficient")
+        if not isinstance(geom_depth_list, list) or len(geom_depth_list) != 2:
+            raise ValueError("z-coordinate interval [z1, z2] expected")
+        for d in geom_depth_list:
+            if not isinstance(d, Number):
+                raise ValueError("NaN found in the z-coordinate interval")
+        if geom_depth_list[0] == geom_depth_list[1]:
+            raise ValueError("z2 must be different from z1")
+        if geom_depth_list[0] > geom_depth_list[1]:
+            geom_depth_list = [geom_depth_list[1], geom_depth_list[0]]
+        if not isinstance(list_vert_list, list) or not list_vert_list:
+            raise ValueError("Non-empty list of vertex lists expected")
+        for part in list_vert_list:
+            if not isinstance(part, list) or not part:
+                raise ValueError("Non-empty list of vertices expected")
+            for v in part:
+                if not isinstance(v, list) or not v:
+                    raise ValueError("Non-empty vertex coordinate list expected")
+                if len(v) < 2 or len(v) > 3:
+                    raise ValueError(
+                        f"Vertex must have 2 or 3 coordinates, got {len(v)}")
+                for c in v:
+                    if not isinstance(c, Number):
+                        raise ValueError("NaN supplied for a vertex coordinate")
+
+        list_vert_list = [
+            [convert_3d(v) for v in part] for part in list_vert_list
+        ]
+        list_vert_list = [convert_to_clockwise(x) for x in list_vert_list]
+        list_vert_list = [
+            [[p_coeff * 1.0 * c for c in v] for v in part]
+            for part in list_vert_list
+        ]
+        geom_depth_list = [p_coeff * 1.0 * i for i in geom_depth_list]
+
+        part_list = [self.generate_part(x, geom_depth_list) for x in list_vert_list]
+        self._shape_representation_relationship(
+            self._advanced_brep_shape_representation(part_list))
+
+    def to_string(self):
+        result = (self._file_array[:self._index1]
+                  + self._work_array
+                  + self._file_array[self._index1 + 1:])
+        return ''.join(result)
+
+    def to_file(self, path):
+        with open(path, 'w') as f:
+            f.write(self.to_string())

stepfg-2.0.0/stepfg/_geometry.py

@@ -0,0 +1,43 @@
+import math
+import operator
+from numbers import Number
+
+
+def rotate(list_in, x):
+    return list_in[-x:] + list_in[:-x]
+
+
+def normalize(vector_in):
+    if len(vector_in) != 3:
+        raise ValueError("normalize: coordinates must be 3D")
+    magnitude = math.sqrt(sum(i ** 2 for i in vector_in))
+    return [x / magnitude for x in vector_in]
+
+
+def cross_product(x, y):
+    return [
+        -x[2] * y[1] + x[1] * y[2],
+        x[2] * y[0] - x[0] * y[2],
+        -x[1] * y[0] + x[0] * y[1],
+    ]
+
+
+def convert_3d(element_in):
+    if (isinstance(element_in, list) and len(element_in) == 2
+            and isinstance(element_in[0], Number)
+            and isinstance(element_in[1], Number)):
+        return [element_in[0], element_in[1], 0]
+    return element_in
+
+
+def convert_to_clockwise(part_list):
+    pol_sum = sum(
+        (x2[0] - x1[0]) * (x2[1] + x1[1])
+        for x1, x2 in zip(part_list, rotate(part_list, 1))
+    )
+    if pol_sum == 0:
+        raise ValueError("Polygon is neither clockwise nor counter-clockwise")
+    elif pol_sum > 0:
+        return list(reversed(part_list))
+    else:
+        return list(part_list)

stepfg-2.0.0/stepfg/_template.py

@@ -0,0 +1,102 @@
+import datetime
+import re
+
+
+def _line_index(line):
+    m = re.search(r'#(.+?)=', line)
+    return 0 if m is None else int(m.group(1))
+
+
+def step_header(filename='part_out.stp'):
+    d = datetime.datetime.now()
+    lines = [
+        "ISO-10303-21;",
+        "HEADER;",
+        "FILE_DESCRIPTION(('none'),'2;1');",
+        "",
+        "FILE_NAME('" + filename + "','none',('none'),('none'),"
+        "'none','none','none');",
+        "",
+        "FILE_SCHEMA(('CONFIG_CONTROL_DESIGN'));",
+        "",
+        "ENDSEC;",
+        "DATA;",
+        "#1=APPLICATION_CONTEXT('configuration controlled 3D design of"
+        " mechanical parts and assemblies') ;",
+        "#2=MECHANICAL_CONTEXT(' ',#1,'mechanical') ;",
+        "#3=DESIGN_CONTEXT(' ',#1,'design') ;",
+        "#4=APPLICATION_PROTOCOL_DEFINITION('international standard',"
+        "'config_control_design',1994,#1) ;",
+        "#5=PRODUCT('Part1','','',(#2)) ;",
+        "#6=PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE('',' '"
+        ",#5,.NOT_KNOWN.) ;",
+        "#7=PRODUCT_CATEGORY('part',$) ;",
+        "#8=PRODUCT_RELATED_PRODUCT_CATEGORY('detail',$,(#5)) ;",
+        "#9=PRODUCT_CATEGORY_RELATIONSHIP(' ',' ',#7,#8) ;",
+        "#10=COORDINATED_UNIVERSAL_TIME_OFFSET(0,0,.AHEAD.) ;",
+        "#11=CALENDAR_DATE(" + str(d.year) + "," + str(d.month) + ","
+        + str(d.day) + ") ;",
+        "#12=LOCAL_TIME(" + str(d.hour) + "," + str(d.minute) + ","
+        + str(d.second) + ".,#10) ;",
+        "#13=DATE_AND_TIME(#11,#12) ;",
+        "#14=PRODUCT_DEFINITION('',' ',#6,#3) ;",
+        "#15=SECURITY_CLASSIFICATION_LEVEL('unclassified') ;",
+        "#16=SECURITY_CLASSIFICATION(' ',' ',#15) ;",
+        "#17=DATE_TIME_ROLE('classification_date') ;",
+        "#18=CC_DESIGN_DATE_AND_TIME_ASSIGNMENT(#13,#17,(#16)) ;",
+        "#19=APPROVAL_ROLE('APPROVER') ;",
+        "#20=APPROVAL_STATUS('not_yet_approved') ;",
+        "#21=APPROVAL(#20,' ') ;",
+        "#22=PERSON(' ',' ',' ',$,$,$) ;",
+        "#23=ORGANIZATION(' ',' ',' ') ;",
+        "#24=PERSONAL_ADDRESS(' ',' ',' ',' ',' ',' ',' ',' ',' ',"
+        "' ',' ',' ',(#22),' ') ;",
+        "#25=PERSON_AND_ORGANIZATION(#22,#23) ;",
+        "#26=PERSON_AND_ORGANIZATION_ROLE('classification_officer') ;",
+        "#27=CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT(#25,#26,"
+        "(#16)) ;",
+        "#28=DATE_TIME_ROLE('creation_date') ;",
+        "#29=CC_DESIGN_DATE_AND_TIME_ASSIGNMENT(#13,#28,(#14)) ;",
+        "#30=CC_DESIGN_APPROVAL(#21,(#16,#6,#14)) ;",
+        "#31=APPROVAL_PERSON_ORGANIZATION(#25,#21,#19) ;",
+        "#32=APPROVAL_DATE_TIME(#13,#21) ;",
+        "#33=CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT(#25,#34,"
+        "(#6)) ;",
+        "#34=PERSON_AND_ORGANIZATION_ROLE('design_supplier') ;",
+        "#35=CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT(#25,#36,"
+        "(#6,#14)) ;",
+        "#36=PERSON_AND_ORGANIZATION_ROLE('creator') ;",
+        "#37=CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT(#25,#38,"
+        "(#5)) ;",
+        "#38=PERSON_AND_ORGANIZATION_ROLE('design_owner') ;",
+        "#39=CC_DESIGN_SECURITY_CLASSIFICATION(#16,(#6)) ;",
+        "",
+        "#40=PRODUCT_DEFINITION_SHAPE(' ',' ',#14) ;",
+        "#41=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.)) ;",
+        "#42=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.)) ;",
+        "#43=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT()) ;",
+        "#44=UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(0.005),#41,"
+        "'distance_accuracy_value','CONFUSED CURVE"
+        " UNCERTAINTY') ;",
+        "#45=(GEOMETRIC_REPRESENTATION_CONTEXT(3)"
+        "GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#44))"
+        "GLOBAL_UNIT_ASSIGNED_CONTEXT((#41,#42,#43))"
+        "REPRESENTATION_CONTEXT(' ',' ')) ;",
+        "",
+        "#46=CARTESIAN_POINT(' ',(0.,0.,0.)) ;",
+        "#47=AXIS2_PLACEMENT_3D(' ',#46,$,$) ;",
+        "#48=SHAPE_REPRESENTATION(' ',(#47),#45) ;",
+        "#49=SHAPE_DEFINITION_REPRESENTATION(#40,#48) ;",
+        "",
+        "/* Part Specification */",
+        "",
+        "ENDSEC;",
+        "END-ISO-10303-21;",
+    ]
+    file_array = [i + "\n" for i in lines]
+    index1 = file_array.index("/* Part Specification */\n")
+    initial_work_array = [k for k in file_array if k.startswith('#')]
+    highest_index = _line_index(
+        sorted(initial_work_array, key=_line_index)[-1]
+    )
+    return file_array, index1, highest_index

stepfg-2.0.0/stepfg.egg-info/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: stepfg
+Version: 2.0.0
+Summary: Convert 2D polygon cross-sections into 3D STEP files via extrusion
+Author: Martin Berz
+Author-email: Eremey Valetov <evv@msu.edu>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/evvaletov/stepfg
+Keywords: STEP,CAD,polygon,extrusion,3D,ISO-10303
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Dynamic: license-file
+
+# stepfg: STEP File Generator
+
+**Python 3.8+** | **Zero dependencies** | [MIT License](LICENSE.md)
+
+Authors: E. Valetov and M. Berz
+Organization: Michigan State University
+Creation date: 03-Feb-2017
+
+## Introduction
+
+stepfg converts lists of 2D polygons (specified by vertices in the x-y plane)
+into 3D STEP files (ISO 10303-242) by extruding the polygon interiors along
+the z-axis. Pure Python, no external dependencies.
+
+## Installation
+
+```
+pip install stepfg
+```
+
+Or from source:
+
+```
+git clone https://github.com/evvaletov/stepfg.git
+cd stepfg
+pip install -e .
+```
+
+## Library usage
+
+```python
+from stepfg import StepBuilder, generate_step
+
+# Quick one-liner
+content = generate_step(
+    polygons=[[[0, 0], [1, 0], [1, 1], [0, 1]]],
+    z_range=[0, 10],
+    scale=1,
+)
+
+# Or use StepBuilder for more control
+builder = StepBuilder('output.stp')
+builder.generate_assembly(
+    list_vert_list=[[[0, 0], [1, 0], [1, 1], [0, 1]]],
+    geom_depth_list=[0, 10],
+    p_coeff=1,
+)
+builder.to_file('output.stp')
+```
+
+## Command-line usage
+
+```
+stepfg [input_file [output_file]]
+python -m stepfg [input_file [output_file]]
+```
+
+Run with the included sample geometry (a Muon g-2 quadrupole):
+
+```
+stepfg part_geometry.txt quadrupole.stp
+```
+
+## Input file format
+
+The input file is a Python literal containing three elements:
+
+```python
+[polygons, z_range, scale]
+```
+
+- **polygons**: `[[vertex, ...], ...]` — each vertex is `[x, y]` or `[x, y, 0]`
+- **z_range**: `[z1, z2]` — extrusion interval
+- **scale**: proportionality coefficient (output is in mm; use 10 for cm input)
+
+A sample input file `part_geometry.txt` containing a Muon g-2 Collaboration
+quadrupole cross-section is included.
+
+## Copyright Notice
+
+© 2017 Eremey Valetov and Martin Berz

stepfg-2.0.0/stepfg.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE.md
+README.md
+pyproject.toml
+stepfg/__init__.py
+stepfg/__main__.py
+stepfg/_builder.py
+stepfg/_geometry.py
+stepfg/_template.py
+stepfg.egg-info/PKG-INFO
+stepfg.egg-info/SOURCES.txt
+stepfg.egg-info/dependency_links.txt
+stepfg.egg-info/entry_points.txt
+stepfg.egg-info/top_level.txt
+tests/test_builder.py
+tests/test_cli.py
+tests/test_geometry.py

stepfg-2.0.0/stepfg.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

stepfg-2.0.0/stepfg.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+stepfg = stepfg.__main__:main

stepfg-2.0.0/stepfg.egg-info/top_level.txt

@@ -0,0 +1 @@
+stepfg

stepfg-2.0.0/tests/test_builder.py

@@ -0,0 +1,71 @@
+import pytest
+from stepfg import StepBuilder
+
+
+class TestStepBuilder:
+    def test_square_extrusion(self):
+        b = StepBuilder()
+        square = [[[0, 0], [1, 0], [1, 1], [0, 1]]]
+        b.generate_assembly(square, [0, 1])
+        content = b.to_string()
+
+        assert content.startswith("ISO-10303-21;\n")
+        assert content.endswith("END-ISO-10303-21;\n")
+        assert "CLOSED_SHELL" in content
+        assert "MANIFOLD_SOLID_BREP" in content
+        assert "ADVANCED_FACE" in content
+
+    def test_entity_count(self):
+        b = StepBuilder()
+        square = [[[0, 0], [1, 0], [1, 1], [0, 1]]]
+        b.generate_assembly(square, [0, 1])
+        content = b.to_string()
+        # Count ADVANCED_FACE entities: 4 sides + 2 caps = 6
+        assert content.count("ADVANCED_FACE") == 6
+
+    def test_scale_factor(self):
+        b = StepBuilder()
+        square = [[[0, 0], [1, 0], [1, 1], [0, 1]]]
+        b.generate_assembly(square, [0, 5], p_coeff=10)
+        content = b.to_string()
+        # Vertices should be scaled: 10.0 instead of 1.0
+        assert "10.0" in content
+
+    def test_multi_polygon(self):
+        b = StepBuilder()
+        polys = [
+            [[0, 0], [1, 0], [1, 1], [0, 1]],
+            [[2, 0], [3, 0], [3, 1], [2, 1]],
+        ]
+        b.generate_assembly(polys, [0, 1])
+        content = b.to_string()
+        # Two closed shells → two manifold solid breps
+        assert content.count("MANIFOLD_SOLID_BREP") == 2
+
+    def test_to_file(self, tmp_path):
+        b = StepBuilder()
+        square = [[[0, 0], [1, 0], [1, 1], [0, 1]]]
+        b.generate_assembly(square, [0, 1])
+        out = tmp_path / "test.stp"
+        b.to_file(str(out))
+        assert out.exists()
+        assert out.stat().st_size > 0
+        assert out.read_text() == b.to_string()
+
+
+class TestValidation:
+    def test_zero_coeff(self):
+        with pytest.raises(ValueError, match="Zero"):
+            StepBuilder().generate_assembly([[[0, 0], [1, 0], [1, 1]]], [0, 1], 0)
+
+    def test_nan_coeff(self):
+        with pytest.raises(ValueError, match="NaN"):
+            StepBuilder().generate_assembly([[[0, 0], [1, 0], [1, 1]]], [0, 1], "x")
+
+    def test_equal_z(self):
+        with pytest.raises(ValueError, match="different"):
+            StepBuilder().generate_assembly([[[0, 0], [1, 0], [1, 1]]], [5, 5])
+
+    def test_empty_polygons(self):
+        with pytest.raises(ValueError):
+            StepBuilder().generate_assembly([], [0, 1])

stepfg-2.0.0/tests/test_cli.py

@@ -0,0 +1,40 @@
+import subprocess
+import sys
+from pathlib import Path
+
+
+STEPFG_DIR = Path(__file__).resolve().parent.parent
+
+
+def test_cli_with_sample_input(tmp_path):
+    out_file = tmp_path / "test_output.stp"
+    result = subprocess.run(
+        [sys.executable, "-m", "stepfg",
+         str(STEPFG_DIR / "part_geometry.txt"),
+         str(out_file)],
+        capture_output=True, text=True,
+        cwd=str(STEPFG_DIR),
+    )
+    assert result.returncode == 0
+    assert "[DONE]" in result.stdout
+    assert out_file.exists()
+    content = out_file.read_text()
+    assert content.startswith("ISO-10303-21;")
+    assert "CLOSED_SHELL" in content
+
+
+def test_cli_missing_file(tmp_path):
+    result = subprocess.run(
+        [sys.executable, "-m", "stepfg", "nonexistent.txt"],
+        capture_output=True, text=True,
+    )
+    assert result.returncode != 0
+
+
+def test_cli_version():
+    result = subprocess.run(
+        [sys.executable, "-m", "stepfg", "--version"],
+        capture_output=True, text=True,
+    )
+    assert result.returncode == 0
+    assert "2.0.0" in result.stdout

stepfg-2.0.0/tests/test_geometry.py

@@ -0,0 +1,61 @@
+import math
+import pytest
+from stepfg._geometry import normalize, cross_product, convert_3d, convert_to_clockwise
+
+
+class TestNormalize:
+    def test_unit_vector(self):
+        assert normalize([1, 0, 0]) == [1, 0, 0]
+
+    def test_scales_to_unit(self):
+        result = normalize([3, 4, 0])
+        assert math.isclose(result[0], 0.6)
+        assert math.isclose(result[1], 0.8)
+        assert math.isclose(result[2], 0.0)
+
+    def test_magnitude_one(self):
+        result = normalize([1, 2, 3])
+        mag = math.sqrt(sum(x ** 2 for x in result))
+        assert math.isclose(mag, 1.0)
+
+    def test_rejects_non_3d(self):
+        with pytest.raises(ValueError):
+            normalize([1, 2])
+
+
+class TestCrossProduct:
+    def test_x_cross_y(self):
+        assert cross_product([1, 0, 0], [0, 1, 0]) == [0, 0, 1]
+
+    def test_y_cross_x(self):
+        assert cross_product([0, 1, 0], [1, 0, 0]) == [0, 0, -1]
+
+    def test_parallel_is_zero(self):
+        assert cross_product([1, 0, 0], [2, 0, 0]) == [0, 0, 0]
+
+
+class TestConvert3d:
+    def test_2d_to_3d(self):
+        assert convert_3d([1, 2]) == [1, 2, 0]
+
+    def test_3d_unchanged(self):
+        assert convert_3d([1, 2, 3]) == [1, 2, 3]
+
+    def test_non_numeric_unchanged(self):
+        assert convert_3d([[1, 2], [3, 4]]) == [[1, 2], [3, 4]]
+
+
+class TestConvertToClockwise:
+    def test_ccw_square_reversed(self):
+        ccw = [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]]
+        result = convert_to_clockwise(ccw)
+        assert result == list(reversed(ccw))
+
+    def test_cw_square_unchanged(self):
+        cw = [[0, 1, 0], [1, 1, 0], [1, 0, 0], [0, 0, 0]]
+        result = convert_to_clockwise(cw)
+        assert result == cw
+
+    def test_degenerate_raises(self):
+        with pytest.raises(ValueError):
+            convert_to_clockwise([[0, 0, 0], [0, 0, 0], [0, 0, 0]])