WeldingSpotPerformance/src/uml/creator.py

from uml.request_generator import Request


class UMLCreator:
    def __init__(self, 
                 system_config : dict,
                 request_generator: Request,
                 ideal_time: list[float],
                 bool_dict: dict,
                 float_dict: dict):
        self._request_generator = request_generator
        self._ideal_time = ideal_time
        self.bool_dict = bool_dict
        self.float_dict = float_dict
        self.scaler = int(system_config['UML_time_scaler'])


    def _build_data(self):
        sig = [
            'Electrode Closing Algorithm Execute',  # Начало закрытия
            'Electrode Closing Algorithm Done',
            # 'STEP 3: ME Hold P2 AND Condition Start Force Control',  # Конец закрытия и Начало набора усилия
            'STEP 4: ME Force Control',
            'Position Control ME',  # Начало разъезда или 'Posision Control Activated FE'
            'Position Control FE',  # Начало разъезда
            'Position Control Completed  ME',  # Конец разъезда
            'Position Control Completed FE',  # Конец разъезда
            'STEP 4: ME Force Control Complete',  # Конец набора усилия
        ]
        closure = self._get_time([sig[0], sig[1]])
        compression = self._get_time([sig[2], sig[3]])
        # opening = self.__getTime([sig[4], sig[5], sig[6], sig[7]])

        real_data = [
            [closure[0], 'closure #green'],
            [closure[1], '{-}'],
            [compression[0], 'compression #green'],
            [compression[1], '{-}'],
            # [max(opening[0:2]), 'opening  #green'],
            # [max(opening[2:4]), '{-}'],
        ]

        client_data = [
            [0.0 * self.scaler, 'closure'],
            [0.165 * self.scaler, '{-}'],
            [0.166 * self.scaler, 'compression'],
            [0.176 * self.scaler, '{-}'],
            # [0.180*self.scaler, 'welding'],
            # [0.200*self.scaler, '{-}'],
            [0.210 * self.scaler, 'opening'],
            [0.300 * self.scaler, '{-}'],
        ]

        ideal_data = [
            [0.0 * self.scaler, 'closure #yellow'],
            [self._ideal_time[0] * self.scaler, '{-}'],
            [(self._ideal_time[0] + 0.0001) * self.scaler, 'compression #yellow'],
            [(self._ideal_time[0] + self._ideal_time[1]) * self.scaler, '{-}'],
            # [0.*self.scaler, 'welding #yellow'],
            # [0.*self.scaler, '{-}'],
            [(self._ideal_time[0] + self._ideal_time[1] + 0.0001) * self.scaler, 'opening #yellow'],
            [(self._ideal_time[0] + self._ideal_time[1] + self._ideal_time[2]) * self.scaler, '{-}'],
        ]
        return real_data, client_data, ideal_data, self.bool_dict

    def _get_time(self, signals = '', states = ''):
        res = []
        for i, sig in enumerate(signals):
            if states: state = states[i]
            else: state = 'high'
            index1 = next ((i for i, _ in enumerate(self.bool_dict[sig]) if _[1]==state), -1)
            time = self.bool_dict[sig][index1][0]
            res.append(time)
        return res

    def _generate_svg(self, real_data, client_data, ideal_data, bool_data) -> None:
        try:
            self._request_generator.clear()
            self._request_generator.addLineStyle('biba', 'red', 2)

            for i, [signal, changes] in enumerate(bool_data.items()):
                name = 'bool_' + str(i)
                self._request_generator.addBinary(name, str(signal), 'biba')
                self._request_generator.setTimestamps(name, changes)

            self._request_generator.addConcise('RD', 'Real data')
            self._request_generator.setTimestamps('RD', real_data)
            self._request_generator.addConcise('CD', 'Client data')
            self._request_generator.setTimestamps('CD', client_data)
            self._request_generator.addConcise('ID', 'Ideal data')
            self._request_generator.setTimestamps('ID', ideal_data)

            self._request_generator.generateSVG()

        except Exception as e:
            print(f"SVG generate error: {e}")

    def update_uml(self) -> None:
        real, client, ideal, bool_ = self._build_data()
        self._generate_svg(real, client, ideal, bool_)