WeldingSpotPerformance/src/uml/creator.py

from src.uml.request_generator import Request


class UMLCreator:
    def __init__(self, request_generator: Request):
        self._request_generator = request_generator


    def _build_data(self):

        closure = self.timings_dict["closure"]
        compression = self.timings_dict["compression"]
        welding = self.timings_dict["welding"]
        opening = self.timings_dict["opening"]
        real_data = [
            [closure[0]*self.scaler, 'closure #green'],
            [closure[1]*self.scaler, '{-}'],
            [compression[0]*self.scaler+0.0001, 'compression #green'],
            [compression[1]*self.scaler, '{-}'],
            [welding[0]*self.scaler+0.0001, 'welding #green'],
            [welding[1]*self.scaler, '{-}'],
            [opening[0]*self.scaler+0.0001, 'opening  #green'],
            [opening[1]*self.scaler, '{-}'],
        ]

        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, '{-}'],
            [(self._ideal_time[0] + self._ideal_time[1]+ 0.0001) * self.scaler, 'welding #yellow'],
            [(self._ideal_time[0] + self._ideal_time[1] + self.WeldTime)*self.scaler, '{-}'],
            [(self._ideal_time[0] + self._ideal_time[1] + 0.0001 + self.WeldTime) * self.scaler, 'opening #yellow'],
            [(self._ideal_time[0] + self._ideal_time[1] + self._ideal_time[2] + self.WeldTime) * 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)
                times = []
                for f in changes:
                    times.append([str(float(f[0])*self.scaler), f[1]])
                self._request_generator.addBinary(name, str(signal), 'biba')
                self._request_generator.setTimestamps(name, times)

            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, 
                 operator_config: dict,
                 system_config : dict,
                 ideal_time: list[float],
                 bool_dict: dict,
                 float_dict: dict,
                 timings_dict: dict,
                 mode: bool):
        
        self._ideal_time = ideal_time
        self.bool_dict = bool_dict
        self.float_dict = float_dict
        self.timings_dict = timings_dict
        self.theor_mode = mode
        self.scaler = int(system_config['UML_time_scaler'])
        self.WeldTime = operator_config['time_wielding']
        
        
        real, client, ideal, bool_ = self._build_data()
        self._generate_svg(real, client, ideal, bool_)