HYTOS

        Presentation.to_xml(node, layer='125', color='0', line_type='1', line_weight=1, r=0, g=0, b=0)

        Presentation.to_xml(node, layer='20', color='0', line_type='1', line_weight=1.5, r=0, g=0, b=0)

    def binomial(i, n):

        """Binomial coefficient"""

        import math

        return math.factorial(n) / float(math.factorial(i) * math.factorial(n - i))

    @staticmethod

    def bernstein(t, i, n):

        """Bernstein polynom"""

        return BsplineCurve.binomial(i, n) * (t ** i) * ((1 - t) ** (n - i))

    @staticmethod

    def bezier(t, points):

        """Calculate coordinate of a point in the bezier curve"""

        n = len(points) - 1

        x = y = 0

        for i, pos in enumerate(points):

            bern = BsplineCurve.bernstein(t, i, n)

            x += pos.real * bern

            y += pos.imag * bern

        return x, y

    @staticmethod

    def bezier_curve_range(n, points) -> list:

        """Range of points in a curve bezier"""

        pts = []

        for i in range(n):

            t = i / float(n - 1)

            pts.append(BsplineCurve.bezier(t, points))

        return pts

    @staticmethod

        steps = 16

        points = BsplineCurve.bezier_curve_range(steps, controls)

        node = Element('PolyLine')

        node.attrib['NumPoints'] = f"{len(points)}"

        Presentation.to_xml(node, layer="125", color="-32363", line_type="1", r=0, g=0, b=0)

        min_x = min([control.real for control in controls])

        max_x = max([control.real for control in controls])

        min_y = min([control.imag for control in controls])

        max_y = max([control.imag for control in controls])

        _extent_node = SubElement(node, 'Extent')

        _min_node = SubElement(_extent_node, 'Min')

        _min_node.attrib['X'] = str(min_x)

        _min_node.attrib['Y'] = str(min_y)

        _min_node.attrib['Z'] = '0'

        _max_node = SubElement(_extent_node, 'Max')

        _max_node.attrib['X'] = str(max_x)

        _max_node.attrib['Y'] = str(max_y)

        _max_node.attrib['Z'] = '0'

        for point in points:

            node.append(Point.to_xml('Coordinate', x=point[0], y=point[1], z=0))

        """

        Presentation.to_xml(node, layer="125", color="-32363", line_type="1", r=0.67, g=0.38, b=0)

            knots_multi_node = SubElement(node, 'KnotMultiplicities')

            for knot in knots:

                knot_multi_node = SubElement(knots_multi_node, 'Multiplicity')

                knot_multi_node.text = '1'

            weight_node.text = '1'

        """

import sys

        try:

            catalogue = set()

            items = [item for item in scene.items() if issubclass(type(item), SymbolSvgItem)]

            for item in items:

                type_str = f"{item.type}/{item.name}"

                if type_str not in catalogue:

                    shape_node = SubElement(node, 'Nozzle' if item.type == 'Nozzles' else 'Equipment')

                    shape_node.attrib['ID'] = f"XMC_{ShapeCatalogue.ITEMS}"

                    shape_node.attrib['ComponentClass'] = type_str

                    shape_node.attrib['ComponentName'] = item.name

                    shape_node.attrib['Status'] = 'Current'

                    Presentation.to_xml(shape_node, layer='0', color='0', line_type='0', line_weight=0.1, r=0, g=0, b=0)

                    position_node = SubElement(shape_node, 'Position')

                    position_node.append(Point.to_xml('Location', x=item.symbolOrigin[0], y=item.symbolOrigin[1], z=0))

                    position_node.append(Point.to_xml('Axis', x=0, y=0, z=1))

                    position_node.append(Point.to_xml('Reference', x=1, y=0, z=0))

                    generic_attributes = GenericAttributes(item)

                    _attr_node = generic_attributes.to_xml()

                    if _attr_node:

                        shape_node.append(_attr_node)

                    extent = None

                    scale_trans = QTransform()

                    scale_trans.scale(1, -1)

                    svg = item.to_svg(parent=None)

                    paths = svg[0].findall('path')

                    for path in paths:

                        trans = Transform.to_transform(path.attrib['transform']) * scale_trans

                        path_ele = parse_path(path.attrib['d'])

                        for idx, ele in enumerate(path_ele):

                            if type(ele) is Move:

                                continue

                            elif type(ele) is Line:

                                line = DEXPI_Line(Transform.apply_transform(trans, ele.start),

                                                  Transform.apply_transform(trans, ele.end))

                                extent = ShapeCatalogue.merge_extent(extent, line.extent())

                                shape_node.append(line.to_xml('Line', None))

                            elif type(ele) is Arc:

                                continue

                            elif type(ele) is CubicBezier:

                                """

                                line = DEXPI_Line(Transform.apply_transform(trans, ele.start),

                                                  Transform.apply_transform(trans, ele.control1))

                                extent = ShapeCatalogue.merge_extent(extent, line.extent())

                                shape_node.append(line.to_xml('Line', None))

                                line = DEXPI_Line(Transform.apply_transform(trans, ele.control1),

                                                  Transform.apply_transform(trans, ele.control2))

                                extent = ShapeCatalogue.merge_extent(extent, line.extent())

                                shape_node.append(line.to_xml('Line', None))

                                line = DEXPI_Line(Transform.apply_transform(trans, ele.control2),

                                                  Transform.apply_transform(trans, ele.end))

                                extent = ShapeCatalogue.merge_extent(extent, line.extent())

                                shape_node.append(line.to_xml('Line', None))

                                """

                                controls = [Transform.apply_transform(trans, ele.start),

                                            Transform.apply_transform(trans, ele.control1),

                                            Transform.apply_transform(trans, ele.control2),

                                            Transform.apply_transform(trans, ele.end)]

                                min_x = min([control.real for control in controls])

                                max_x = max([control.real for control in controls])

                                min_y = min([control.imag for control in controls])

                                max_y = max([control.imag for control in controls])

                                extent = ShapeCatalogue.merge_extent(extent, (min_x, min_y, max_x, max_y))

                                bspline_curve_node = BsplineCurve.to_xml(controls=controls,

                                                                         _type='BsplineCurve',

                                                                         knots=[0, 0, 0, 0, 1, 1, 1, 1])

                                shape_node.append(bspline_curve_node)

                            elif type(ele) is QuadraticBezier:

                                continue

                            else:

                                continue

                    extent_node = SubElement(shape_node, 'Extent')

                    extent_node.append(Point.to_xml('Min', x=extent[0], y=extent[1], z=0))

                    extent_node.append(Point.to_xml('Max', x=extent[2], y=extent[2], z=0))

                    ShapeCatalogue.ITEMS += 1

                    _conn_node = ConnectionPoints.to_xml(item.symbolOrigin, item.connectors)

                    if _conn_node:

                        shape_node.append(_conn_node)

                    catalogue.add(type_str)

        except Exception as ex:

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

            print(message)