pyedb 0.38.0__py3-none-any.whl → 0.39.1__py3-none-any.whl

pyedb/ipc2581/ecad/cad_data/layer_feature.py

@@ -29,8 +29,9 @@ from pyedb.ipc2581.ecad.cad_data.feature import Feature, FeatureType
 class LayerFeature(object):
     """Class describing IPC2581 layer feature."""
 
-    def __init__(self, ipc):
+    def __init__(self, ipc, pedb):
         self._ipc = ipc
+        self._pedb = pedb
         self.layer_name = ""
         self.color = ""
         self._features = []
@@ -48,12 +49,15 @@ class LayerFeature(object):
 
     def add_feature(self, obj_instance=None):  # pragma no cover
         if obj_instance:
-            feature = Feature(self._ipc)
-            feature.net = obj_instance.net_name
-            if obj_instance.type == "Polygon":
+            feature = Feature(self._ipc, self._pedb)
+            if obj_instance.net_name:
+                feature.net = obj_instance.net_name
+            else:
+                feature.net = ""
+            if obj_instance.type.lower() == "polygon":
                 feature.feature_type = FeatureType.Polygon
                 feature.polygon.add_poly_step(obj_instance)
-            elif obj_instance.type == "Path":
+            elif obj_instance.type.lower() == "path":
                 feature.feature_type = FeatureType.Path
                 feature.path.add_path_step(obj_instance)
             self.features.append(feature)
@@ -62,7 +66,7 @@ class LayerFeature(object):
 
     def add_via_instance_feature(self, padstack_inst=None, padstackdef=None, layer_name=None):  # pragma no cover
         if padstack_inst and padstackdef:
-            feature = Feature(self._ipc)
+            feature = Feature(self._ipc, self._pedb)
             def_name = padstackdef.name
             position = padstack_inst.position if padstack_inst.position else padstack_inst.position
             feature.padstack_instance.net = padstack_inst.net_name
@@ -71,11 +75,14 @@ class LayerFeature(object):
             feature.feature_type = FeatureType.PadstackInstance
             feature.padstack_instance.x = self._ipc.from_meter_to_units(position[0], self._ipc.units)
             feature.padstack_instance.y = self._ipc.from_meter_to_units(position[1], self._ipc.units)
-            if padstackdef._hole_params is None:
-                hole_props = [i.ToDouble() for i in padstackdef.hole_params[2]]
+            if not self._pedb.grpc:
+                if padstackdef._hole_params is None:
+                    hole_props = [i.ToDouble() for i in padstackdef.hole_params[2]]
+                else:
+                    hole_props = [i.ToDouble() for i in padstackdef._hole_params[2]]
+                feature.padstack_instance.diameter = float(hole_props[0]) if hole_props else 0
             else:
-                hole_props = [i.ToDouble() for i in padstackdef._hole_params[2]]
-            feature.padstack_instance.diameter = float(hole_props[0]) if hole_props else 0
+                feature.padstack_instance.diameter = padstackdef.hole_diameter
             feature.padstack_instance.hole_name = def_name
             feature.padstack_instance.name = padstack_inst.name
             try:
@@ -96,7 +103,7 @@ class LayerFeature(object):
                 pass
 
     def add_drill_feature(self, via, diameter=0.0):  # pragma no cover
-        feature = Feature(self._ipc)
+        feature = Feature(self._ipc, self._pedb)
         feature.feature_type = FeatureType.Drill
         feature.drill.net = via.net_name
         position = via._position if via._position else via.position
@@ -113,14 +120,19 @@ class LayerFeature(object):
                 is_via = False
                 if not pin.start_layer == pin.stop_layer:
                     is_via = True
-                pin_net = pin._edb_object.GetNet().GetName()
-                pos_rot = pin._edb_padstackinstance.GetPositionAndRotationValue()
-                pin_rotation = pos_rot[2].ToDouble()
-                if pin._edb_padstackinstance.IsLayoutPin():
-                    out2 = pin._edb_padstackinstance.GetComponent().GetTransform().TransformPoint(pos_rot[1])
-                    pin_position = [out2.X.ToDouble(), out2.Y.ToDouble()]
+                if not self._pedb.grpc:
+                    pin_net = pin._edb_object.GetNet().GetName()
+                    pos_rot = pin._edb_padstackinstance.GetPositionAndRotationValue()
+                    pin_rotation = pos_rot[2].ToDouble()
+                    if pin._edb_padstackinstance.IsLayoutPin():
+                        out2 = pin._edb_padstackinstance.GetComponent().GetTransform().TransformPoint(pos_rot[1])
+                        pin_position = [out2.X.ToDouble(), out2.Y.ToDouble()]
+                    else:
+                        pin_position = [pos_rot[1].X.ToDouble(), pos_rot[1].Y.ToDouble()]
                 else:
-                    pin_position = [pos_rot[1].X.ToDouble(), pos_rot[1].Y.ToDouble()]
+                    pin_net = pin.net_name
+                    pin_rotation = pin.rotation
+                    pin_position = pin.position
                 pin_x = self._ipc.from_meter_to_units(pin_position[0], self._ipc.units)
                 pin_y = self._ipc.from_meter_to_units(pin_position[1], self._ipc.units)
                 cmp_rot_deg = component.rotation * 180 / math.pi
@@ -131,11 +143,11 @@ class LayerFeature(object):
                 comp_placement_layer = component.placement_layer
                 if comp_placement_layer == top_bottom_layers[-1]:
                     mirror = True
-                feature = Feature(self._ipc)
+                feature = Feature(self._ipc, self._pedb)
                 feature.feature_type = FeatureType.PadstackInstance
                 feature.net = pin_net
                 feature.padstack_instance.net = pin_net
-                feature.padstack_instance.pin = pin.pin.GetName()
+                feature.padstack_instance.pin = pin.name
                 feature.padstack_instance.x = pin_x
                 feature.padstack_instance.y = pin_y
                 feature.padstack_instance.rotation = rotation

pyedb/ipc2581/ecad/cad_data/outline.py

@@ -27,9 +27,10 @@ from pyedb.ipc2581.ecad.cad_data.polygon import Polygon
 class Outline:
     """Class describing an IPC2581 outline."""
 
-    def __init__(self, ipc):
+    def __init__(self, ipc, pedb):
         self._ipc = ipc
-        self.polygon = Polygon(self._ipc)
+        self._pedb = pedb
+        self.polygon = Polygon(self._ipc, pedb)
         self.line_ref = ""
 
     def write_xml(self, package):  # pragma no cover

pyedb/ipc2581/ecad/cad_data/package.py

@@ -33,15 +33,16 @@ from pyedb.ipc2581.ecad.cad_data.polygon import PolyStep
 class Package(object):
     """Class describing an IPC2581 package definition."""
 
-    def __init__(self, ipc):
+    def __init__(self, ipc, pedb):
         self._ipc = ipc
+        self._pedb = pedb
         self.name = ""
         self.type = "OTHER"
         self.pin_one = "1"
         self.pin_orientation = "OTHER"
         self.height = 0.1
-        self.assembly_drawing = AssemblyDrawing(self._ipc)
-        self.outline = Outline(self._ipc)
+        self.assembly_drawing = AssemblyDrawing(self._ipc, pedb)
+        self.outline = Outline(self._ipc, pedb)
         self._pins = []
         self.pickup_point = [0.0, 0.0]
 

pyedb/ipc2581/ecad/cad_data/path.py

@@ -28,8 +28,9 @@ from pyedb.ipc2581.ecad.cad_data.polygon import PolyStep, PolyType
 class Path(object):
     """Class describing an IPC2581 trace."""
 
-    def __init__(self, ipc):
+    def __init__(self, ipc, pedb):
         self._ipc = ipc
+        self._pedb = pedb
         self.location_x = 0.0
         self.location_y = 0.0
         self.poly_steps = []
@@ -37,38 +38,22 @@ class Path(object):
         self.width_ref_id = ""
 
     def add_path_step(self, path_step=None):  # pragma no cover
-        arcs = path_step.primitive_object.GetCenterLine().GetArcData()
-        if not arcs:
-            return
-        self.line_width = self._ipc.from_meter_to_units(path_step.primitive_object.GetWidth(), self._ipc.units)
-        self.width_ref_id = "ROUND_{}".format(self.line_width)
-        if not self.width_ref_id in self._ipc.content.dict_line.dict_lines:
-            entry_line = EntryLine()
-            entry_line.line_width = self.line_width
-            self._ipc.content.dict_line.dict_lines[self.width_ref_id] = entry_line
-        # first point
-        arc = arcs[0]
-        new_segment_tep = PolyStep()
-        new_segment_tep.x = arc.Start.X.ToDouble()
-        new_segment_tep.y = arc.Start.Y.ToDouble()
-        self.poly_steps.append(new_segment_tep)
-        if arc.Height == 0:
+        if not self._pedb.grpc:
+            arcs = path_step.primitive_object.GetCenterLine().GetArcData()
+            if not arcs:
+                return
+            self.line_width = self._ipc.from_meter_to_units(path_step.primitive_object.GetWidth(), self._ipc.units)
+            self.width_ref_id = "ROUND_{}".format(self.line_width)
+            if not self.width_ref_id in self._ipc.content.dict_line.dict_lines:
+                entry_line = EntryLine()
+                entry_line.line_width = self.line_width
+                self._ipc.content.dict_line.dict_lines[self.width_ref_id] = entry_line
+            # first point
+            arc = arcs[0]
             new_segment_tep = PolyStep()
-            new_segment_tep.poly_type = PolyType.Segment
-            new_segment_tep.x = arc.End.X.ToDouble()
-            new_segment_tep.y = arc.End.Y.ToDouble()
+            new_segment_tep.x = arc.Start.X.ToDouble()
+            new_segment_tep.y = arc.Start.Y.ToDouble()
             self.poly_steps.append(new_segment_tep)
-        else:
-            arc_center = arc.GetCenter()
-            new_poly_step = PolyStep()
-            new_poly_step.poly_type = PolyType.Curve
-            new_poly_step.center_X = arc_center.X.ToDouble()
-            new_poly_step.center_y = arc_center.Y.ToDouble()
-            new_poly_step.x = arc.End.X.ToDouble()
-            new_poly_step.y = arc.End.Y.ToDouble()
-            new_poly_step.clock_wise = not arc.IsCCW()
-            self.poly_steps.append(new_poly_step)
-        for arc in list(arcs)[1:]:
             if arc.Height == 0:
                 new_segment_tep = PolyStep()
                 new_segment_tep.poly_type = PolyType.Segment
@@ -85,6 +70,72 @@ class Path(object):
                 new_poly_step.y = arc.End.Y.ToDouble()
                 new_poly_step.clock_wise = not arc.IsCCW()
                 self.poly_steps.append(new_poly_step)
+            for arc in list(arcs)[1:]:
+                if arc.Height == 0:
+                    new_segment_tep = PolyStep()
+                    new_segment_tep.poly_type = PolyType.Segment
+                    new_segment_tep.x = arc.End.X.ToDouble()
+                    new_segment_tep.y = arc.End.Y.ToDouble()
+                    self.poly_steps.append(new_segment_tep)
+                else:
+                    arc_center = arc.GetCenter()
+                    new_poly_step = PolyStep()
+                    new_poly_step.poly_type = PolyType.Curve
+                    new_poly_step.center_X = arc_center.X.ToDouble()
+                    new_poly_step.center_y = arc_center.Y.ToDouble()
+                    new_poly_step.x = arc.End.X.ToDouble()
+                    new_poly_step.y = arc.End.Y.ToDouble()
+                    new_poly_step.clock_wise = not arc.IsCCW()
+                    self.poly_steps.append(new_poly_step)
+        else:
+            arcs = path_step.cast().center_line.arc_data
+            if not arcs:
+                return
+            self.line_width = self._ipc.from_meter_to_units(path_step.cast().width.value, self._ipc.units)
+            self.width_ref_id = "ROUND_{}".format(self.line_width)
+            if not self.width_ref_id in self._ipc.content.dict_line.dict_lines:
+                entry_line = EntryLine()
+                entry_line.line_width = self.line_width
+                self._ipc.content.dict_line.dict_lines[self.width_ref_id] = entry_line
+            # first point
+            arc = arcs[0]
+            new_segment_tep = PolyStep()
+            new_segment_tep.x = arc.start.x.value
+            new_segment_tep.y = arc.start.y.value
+            self.poly_steps.append(new_segment_tep)
+            if arc.height == 0:
+                new_segment_tep = PolyStep()
+                new_segment_tep.poly_type = PolyType.Segment
+                new_segment_tep.x = arc.end.x.value
+                new_segment_tep.y = arc.end.y.value
+                self.poly_steps.append(new_segment_tep)
+            else:
+                arc_center = arc.center
+                new_poly_step = PolyStep()
+                new_poly_step.poly_type = PolyType.Curve
+                new_poly_step.center_X = arc_center.x.value
+                new_poly_step.center_y = arc_center.y.value
+                new_poly_step.x = arc.end.x.value
+                new_poly_step.y = arc.end.y.value
+                new_poly_step.clock_wise = not arc.is_ccw
+                self.poly_steps.append(new_poly_step)
+            for arc in list(arcs)[1:]:
+                if arc.height == 0:
+                    new_segment_tep = PolyStep()
+                    new_segment_tep.poly_type = PolyType.Segment
+                    new_segment_tep.x = arc.end.x.value
+                    new_segment_tep.y = arc.end.y.value
+                    self.poly_steps.append(new_segment_tep)
+                else:
+                    arc_center = arc.center
+                    new_poly_step = PolyStep()
+                    new_poly_step.poly_type = PolyType.Curve
+                    new_poly_step.center_X = arc_center.x.value
+                    new_poly_step.center_y = arc_center.y.value
+                    new_poly_step.x = arc.end.x.value
+                    new_poly_step.y = arc.end.y.value
+                    new_poly_step.clock_wise = not arc.is_ccw
+                    self.poly_steps.append(new_poly_step)
 
     def write_xml(self, net_root):  # pragma no cover
         if not self.poly_steps:

pyedb/ipc2581/ecad/cad_data/polygon.py

@@ -26,8 +26,9 @@ from pyedb.generic.general_methods import ET
 
 
 class Polygon(object):
-    def __init__(self, ipc):
+    def __init__(self, ipc, pedb):
         self._ipc = ipc
+        self._pedb = pedb
         self.is_void = False
         self.poly_steps = []
         self.solid_fill_id = ""
@@ -35,65 +36,126 @@ class Polygon(object):
 
     def add_poly_step(self, polygon=None):  # pragma no cover
         if polygon:
-            polygon_data = polygon._edb_object.GetPolygonData()
-            if polygon_data.IsClosed():
-                arcs = polygon_data.GetArcData()
-                if not arcs:
-                    return
-                # begin
-                new_segment_tep = PolyStep()
-                new_segment_tep.poly_type = PolyType.Segment
-                new_segment_tep.x = arcs[0].Start.X.ToDouble()
-                new_segment_tep.y = arcs[0].Start.Y.ToDouble()
-                self.poly_steps.append(new_segment_tep)
-                for arc in arcs:
-                    if arc.Height == 0:
-                        new_segment_tep = PolyStep()
-                        new_segment_tep.poly_type = PolyType.Segment
-                        new_segment_tep.x = arc.End.X.ToDouble()
-                        new_segment_tep.y = arc.End.Y.ToDouble()
-                        self.poly_steps.append(new_segment_tep)
-                    else:
-                        arc_center = arc.GetCenter()
-                        new_poly_step = PolyStep()
-                        new_poly_step.poly_type = PolyType.Curve
-                        new_poly_step.center_X = arc_center.X.ToDouble()
-                        new_poly_step.center_y = arc_center.Y.ToDouble()
-                        new_poly_step.x = arc.End.X.ToDouble()
-                        new_poly_step.y = arc.End.Y.ToDouble()
-                        new_poly_step.clock_wise = not arc.IsCCW()
-                        self.poly_steps.append(new_poly_step)
-                for void in polygon.voids:
-                    void_polygon_data = void._edb_object.GetPolygonData()
-                    if void_polygon_data.IsClosed():
-                        void_arcs = void_polygon_data.GetArcData()
-                        if not void_arcs:
-                            return
-                        void_polygon = Cutout(self._ipc)
-                        self.cutout.append(void_polygon)
-                        # begin
-                        new_segment_tep = PolyStep()
-                        new_segment_tep.poly_type = PolyType.Segment
-                        new_segment_tep.x = void_arcs[0].Start.X.ToDouble()
-                        new_segment_tep.y = void_arcs[0].Start.Y.ToDouble()
-                        void_polygon.poly_steps.append(new_segment_tep)
-                        for void_arc in void_arcs:
-                            if void_arc.Height == 0:
-                                new_segment_tep = PolyStep()
-                                new_segment_tep.poly_type = PolyType.Segment
-                                new_segment_tep.x = void_arc.End.X.ToDouble()
-                                new_segment_tep.y = void_arc.End.Y.ToDouble()
-                                void_polygon.poly_steps.append(new_segment_tep)
-                            else:
-                                arc_center = void_arc.GetCenter()
-                                new_poly_step = PolyStep()
-                                new_poly_step.poly_type = PolyType.Curve
-                                new_poly_step.center_X = arc_center.X.ToDouble()
-                                new_poly_step.center_y = arc_center.Y.ToDouble()
-                                new_poly_step.x = void_arc.End.X.ToDouble()
-                                new_poly_step.y = void_arc.End.Y.ToDouble()
-                                new_poly_step.clock_wise = not void_arc.IsCCW()
-                                void_polygon.poly_steps.append(new_poly_step)
+            if not self._pedb.grpc:
+                polygon_data = polygon._edb_object.GetPolygonData()
+                if polygon_data.IsClosed():
+                    arcs = polygon_data.GetArcData()
+                    if not arcs:
+                        return
+                    # begin
+                    new_segment_tep = PolyStep()
+                    new_segment_tep.poly_type = PolyType.Segment
+                    new_segment_tep.x = arcs[0].Start.X.ToDouble()
+                    new_segment_tep.y = arcs[0].Start.Y.ToDouble()
+                    self.poly_steps.append(new_segment_tep)
+                    for arc in arcs:
+                        if arc.Height == 0:
+                            new_segment_tep = PolyStep()
+                            new_segment_tep.poly_type = PolyType.Segment
+                            new_segment_tep.x = arc.End.X.ToDouble()
+                            new_segment_tep.y = arc.End.Y.ToDouble()
+                            self.poly_steps.append(new_segment_tep)
+                        else:
+                            arc_center = arc.GetCenter()
+                            new_poly_step = PolyStep()
+                            new_poly_step.poly_type = PolyType.Curve
+                            new_poly_step.center_X = arc_center.X.ToDouble()
+                            new_poly_step.center_y = arc_center.Y.ToDouble()
+                            new_poly_step.x = arc.End.X.ToDouble()
+                            new_poly_step.y = arc.End.Y.ToDouble()
+                            new_poly_step.clock_wise = not arc.IsCCW()
+                            self.poly_steps.append(new_poly_step)
+                    for void in polygon.voids:
+                        void_polygon_data = void._edb_object.GetPolygonData()
+                        if void_polygon_data.IsClosed():
+                            void_arcs = void_polygon_data.GetArcData()
+                            if not void_arcs:
+                                return
+                            void_polygon = Cutout(self._ipc)
+                            self.cutout.append(void_polygon)
+                            # begin
+                            new_segment_tep = PolyStep()
+                            new_segment_tep.poly_type = PolyType.Segment
+                            new_segment_tep.x = void_arcs[0].Start.X.ToDouble()
+                            new_segment_tep.y = void_arcs[0].Start.Y.ToDouble()
+                            void_polygon.poly_steps.append(new_segment_tep)
+                            for void_arc in void_arcs:
+                                if void_arc.Height == 0:
+                                    new_segment_tep = PolyStep()
+                                    new_segment_tep.poly_type = PolyType.Segment
+                                    new_segment_tep.x = void_arc.End.X.ToDouble()
+                                    new_segment_tep.y = void_arc.End.Y.ToDouble()
+                                    void_polygon.poly_steps.append(new_segment_tep)
+                                else:
+                                    arc_center = void_arc.GetCenter()
+                                    new_poly_step = PolyStep()
+                                    new_poly_step.poly_type = PolyType.Curve
+                                    new_poly_step.center_X = arc_center.X.ToDouble()
+                                    new_poly_step.center_y = arc_center.Y.ToDouble()
+                                    new_poly_step.x = void_arc.End.X.ToDouble()
+                                    new_poly_step.y = void_arc.End.Y.ToDouble()
+                                    new_poly_step.clock_wise = not void_arc.IsCCW()
+                                    void_polygon.poly_steps.append(new_poly_step)
+            else:
+                polygon_data = polygon.polygon_data
+                if polygon_data.is_closed:
+                    arcs = polygon_data.arc_data
+                    if not arcs:
+                        return
+                    # begin
+                    new_segment_tep = PolyStep()
+                    new_segment_tep.poly_type = PolyType.Segment
+                    new_segment_tep.x = arcs[0].start.x.value
+                    new_segment_tep.y = arcs[0].start.y.value
+                    self.poly_steps.append(new_segment_tep)
+                    for arc in arcs:
+                        if arc.height == 0:
+                            new_segment_tep = PolyStep()
+                            new_segment_tep.poly_type = PolyType.Segment
+                            new_segment_tep.x = arc.end.x.value
+                            new_segment_tep.y = arc.end.y.value
+                            self.poly_steps.append(new_segment_tep)
+                        else:
+                            arc_center = arc.center
+                            new_poly_step = PolyStep()
+                            new_poly_step.poly_type = PolyType.Curve
+                            new_poly_step.center_X = arc_center.x.value
+                            new_poly_step.center_y = arc_center.y.value
+                            new_poly_step.x = arc.end.x.value
+                            new_poly_step.y = arc.end.y.value
+                            new_poly_step.clock_wise = not arc.is_ccw
+                            self.poly_steps.append(new_poly_step)
+                    for void in polygon.voids:
+                        void_polygon_data = void.polygon_data
+                        if void_polygon_data.is_closed:
+                            void_arcs = void_polygon_data.arc_data
+                            if not void_arcs:
+                                return
+                            void_polygon = Cutout(self._ipc)
+                            self.cutout.append(void_polygon)
+                            # begin
+                            new_segment_tep = PolyStep()
+                            new_segment_tep.poly_type = PolyType.Segment
+                            new_segment_tep.x = void_arcs[0].start.x.value
+                            new_segment_tep.y = void_arcs[0].start.y.value
+                            void_polygon.poly_steps.append(new_segment_tep)
+                            for void_arc in void_arcs:
+                                if void_arc.height == 0:
+                                    new_segment_tep = PolyStep()
+                                    new_segment_tep.poly_type = PolyType.Segment
+                                    new_segment_tep.x = void_arc.end.x.value
+                                    new_segment_tep.y = void_arc.end.y.value
+                                    void_polygon.poly_steps.append(new_segment_tep)
+                                else:
+                                    arc_center = void_arc.center
+                                    new_poly_step = PolyStep()
+                                    new_poly_step.poly_type = PolyType.Curve
+                                    new_poly_step.center_X = arc_center.x.value
+                                    new_poly_step.center_y = arc_center.y.value
+                                    new_poly_step.x = void_arc.end.x.value
+                                    new_poly_step.y = void_arc.end.y.value
+                                    new_poly_step.clock_wise = not void_arc.is_ccw
+                                    void_polygon.poly_steps.append(new_poly_step)
 
     def add_cutout(self, cutout):  # pragma no cover
         if not isinstance(cutout, Cutout):

pyedb/ipc2581/ecad/cad_data/profile.py

@@ -48,15 +48,16 @@ class Profile(object):
         for poly in self.profile:
             for feature in poly.features:
                 if feature.feature_type == 0:
-                    polygon = ET.SubElement(profile, "Polygon")
-                    polygon_begin = ET.SubElement(polygon, "PolyBegin")
-                    polygon_begin.set(
-                        "x", str(self._ipc.from_meter_to_units(feature.polygon.poly_steps[0].x, self._ipc.units))
-                    )
-                    polygon_begin.set(
-                        "y", str(self._ipc.from_meter_to_units(feature.polygon.poly_steps[0].y, self._ipc.units))
-                    )
-                    for poly_step in feature.polygon.poly_steps[1:]:
-                        poly_step.write_xml(polygon, self._ipc)
-                    for cutout in feature.polygon.cutout:
-                        cutout.write_xml(profile, self._ipc)
+                    if feature.polygon.poly_steps:
+                        polygon = ET.SubElement(profile, "Polygon")
+                        polygon_begin = ET.SubElement(polygon, "PolyBegin")
+                        polygon_begin.set(
+                            "x", str(self._ipc.from_meter_to_units(feature.polygon.poly_steps[0].x, self._ipc.units))
+                        )
+                        polygon_begin.set(
+                            "y", str(self._ipc.from_meter_to_units(feature.polygon.poly_steps[0].y, self._ipc.units))
+                        )
+                        for poly_step in feature.polygon.poly_steps[1:]:
+                            poly_step.write_xml(polygon, self._ipc)
+                        for cutout in feature.polygon.cutout:
+                            cutout.write_xml(profile, self._ipc)