aeroraven / momo-asr-bot Goto Github PK

# graphics_utils.py
class ZwGraphicsContainer(QGLWidget):
    def __init__(self, parent, format_s, frame_rate=60, app=None, s_width=None, s_height=None):
        super().__init__(format_s, parent)
        self.wparent = parent
        self.gl_assist = ZwOpenGLHelper()
        self.attrib = ZwInteractivePageAttrib()
        self.application = app
        self.updater = QTimer(self)
        self.updater.timeout.connect(self.frame_advance)
        self.interval = 1000 / frame_rate
        self.setMouseTracking(True)
        self.s_width = s_width
        self.s_height = s_height

    def mouseMoveEvent(self, event):
        try:
            x = event.x()
            y = event.y()
            dy = self.attrib.page_width_scale * self.s_height / self.s_width * (y / self.s_height)
            dy = dy * 2 - self.attrib.page_width_scale * self.s_height / self.s_width
            dx = self.attrib.page_width_scale * (x / self.s_width)
            dx = dx * 2 - self.attrib.page_width_scale
            self.application.qt_mouse_move_event(dx, dy)
            event.accept()
        except AttributeError:
            pass

    def mousePressEvent(self, event):
        try:
            x = event.x()
            y = event.y()
            dy = self.attrib.page_width_scale * self.s_height / self.s_width * (y / self.s_height)
            dy = - dy * 2 + self.attrib.page_width_scale * self.s_height / self.s_width
            dx = self.attrib.page_width_scale * (x / self.s_width)
            dx = dx * 2 - self.attrib.page_width_scale
            self.application.qt_mouse_down_event(dx, dy)
            ZwLogger().log(ZwLogger.ROLE_GUIQT, ZwLogger.LV_INFO,
                           "Mouse press event. ax=" + str(dx) + ", ay=" + str(dy))
            event.accept()
        except AttributeError:
            pass

    def frame_advance(self):
        self.application.frame_update()
        self.application.play()
        self.update()

    def paintGL(self) -> None:
        self.makeCurrent()
        self.application.gl_clear_func()
        ogl.glLoadIdentity()
        ogl.glTranslated(0, 0, -10)
        ogl.glClear(ogl.GL_COLOR_BUFFER_BIT | ogl.GL_DEPTH_BUFFER_BIT)
        self.application.render()

    def initializeGL(self) -> None:
        self.updater.start(int(self.interval))
        self.makeCurrent()
        ZwLogger().log(ZwLogger.ROLE_GUI, ZwLogger.LV_INFO, "Initializing OpenGL in Qt5 Framework")
        ogl.glShadeModel(ogl.GL_SMOOTH)
        ogl.glEnable(ogl.GL_DEPTH_TEST)
        # ogl.glEnable(ogl.GL_CULL_FACE)
        ogl.glEnable(ogl.GL_POINT_SMOOTH)
        ogl.glEnable(ogl.GL_LINE_SMOOTH)
        ogl.glEnable(ogl.GL_MULTISAMPLE)
        ogl.glEnable(ogl.GL_POLYGON_SMOOTH)
        ogl.glHint(ogl.GL_POLYGON_SMOOTH_HINT, ogl.GL_NICEST)
        ogl.glHint(ogl.GL_LINE_SMOOTH_HINT, ogl.GL_NICEST)
        ogl.glHint(ogl.GL_POINT_SMOOTH_HINT, ogl.GL_NICEST)
        ZwLogger().log(ZwLogger.ROLE_GUI, ZwLogger.LV_INFO, "Initializing OpenGL Utility Tools in Qt5 Framework")
        self.glut_initialization()
        ZwLogger().log(ZwLogger.ROLE_GUI, ZwLogger.LV_INFO, "Graphic initialization completed.")

    def glut_initialization(self):
        glut.glutInit()
        glut.glutMouseFunc(self.glut_mouse_event)
        glut.glutMotionFunc(self.glut_motion_event)

    def glut_mouse_event(self, button, state, x, y):
        print(button, state, x, y)

    def glut_motion_event(self, x, y):
        print("Motion", x, y)

    def resizeGL(self, w: int, h: int) -> None:
        self.makeCurrent()
        side = min(w, h)
        if side < 0:
            return
        ogl.glViewport(0, 0, w, h)
        ogl.glMatrixMode(ogl.GL_PROJECTION)
        ogl.glLoadIdentity()
        ogl.glOrtho(-self.attrib.page_width_scale, self.attrib.page_width_scale,
                    -self.attrib.page_width_scale * h / w, self.attrib.page_width_scale * h / w,
                    self.attrib.z_near, self.attrib.z_far)
        ogl.glMatrixMode(ogl.GL_MODELVIEW)

class InteractionUI(QWidget):
    arg_msaa = 16
    max_fps = 60

    def __init__(self, width=590 * 1.5, height=950):
        super().__init__()
        ZwLogger().log(ZwLogger.ROLE_GUIQT, ZwLogger.LV_INFO, "Initializing Window Widget")
        # MSAA Anti-aliasing
        self.msaa = QGLFormat()
        self.msaa.setSamples(InteractionUI.arg_msaa)

        # Init ASR
        SpeechRecognitionUtil().env_noise_record('./noise.wav')

        # QT Configuration
        self.custom_width = int(width)
        self.custom_height = int(height)
        self.ogl_widget = ZwGraphicsContainer(self,
                                              format_s=self.msaa,
                                              frame_rate=InteractionUI.max_fps,
                                              app=ZwUIHCILab01(),
                                              s_width=int(width),
                                              s_height=int(height))
        self.setFixedSize(width, height)
        self.init_ui()

    def init_ui(self):
        ZwLogger().log(ZwLogger.ROLE_GUIQT, ZwLogger.LV_INFO, "Initializing UI")
        self.resize(self.custom_width, self.custom_height)
        self.move(400, 200)
        self.setWindowTitle("Hello")

        # OGL Widget
        self.ogl_widget.move(0, 0)
        self.ogl_widget.resize(self.custom_width, self.custom_height)
        self.show()

# zwui_shapes.py
class ZwUIAbstractShape:
    def __init__(self, **kwargs):
        # Primitive Attributes
        self.fill_type = gl.GL_POLYGON
        self.text_mode = False
        self.shape_list = []
        self.color_list = []
        # Text Attributes
        self.caption = ""
        self.location_x = 0
        self.location_y = 0
        self.scale = 5
        self.line_width = 2
        self.font_color = ZwUIHelper.get_opengl_rgba_vector(0, 0, 0)
        self.space_modifier = -10000
        self.letter_modifier = 1900

    def render(self,**kwargs):
        offset_z = 0
        if 'z_index' in kwargs:
            offset_z = kwargs['z_index']

        if not self.text_mode:
            gl.glBegin(self.fill_type)
            for i in range(len(self.shape_list)):
                gl.glColor4f(self.color_list[i][0], self.color_list[i][1], self.color_list[i][2], self.color_list[i][3])
                gl.glVertex3f(self.shape_list[i][0], self.shape_list[i][1], self.shape_list[i][2]+offset_z)
            gl.glEnd()
        else:
            gl.glPushMatrix()
            gl.glTranslatef(self.location_x, self.location_y, offset_z)
            gl.glScalef(self.scale, self.scale, 0)
            gl.glLineWidth(self.line_width)
            for i in range(len(self.caption)):
                gl.glColor4f(self.font_color[0], self.font_color[1], self.font_color[2], self.font_color[3])
                glut.glutStrokeCharacter(ctypes.c_void_p(0), ctypes.c_int(ord(self.caption[i])))
                if self.caption[i] == ' ':
                    gl.glTranslatef(self.space_modifier * self.scale, 0, 0)
                else:
                    gl.glTranslatef(self.letter_modifier * self.scale, 0, 0)
            gl.glLineWidth(1)
            gl.glPopMatrix()

    def reset(self):
        self.shape_list = []
        self.color_list = []

    def insert(self, shape, color):
        if not isinstance(shape, list) or not isinstance(color, list):
            raise Exception("Arguments must be lists")
        if len(shape) != 3 or len(color) != 4:
            raise Exception("Vector dimensions mismatch")
        self.shape_list.append(shape)
        self.color_list.append(color)

    def initialize(self, **kwargs):
        # Custom shapes should re-implement this method
        pass

# zwui_shapes.py
class ZwUIRoundedRectangle(ZwUIAbstractShape):
    def __init__(self, left, bottom, width, height, radius, color):
        super(ZwUIRoundedRectangle, self).__init__()
        self.left = left
        self.bottom = bottom
        self.width = width
        self.height = height
        self.color = color
        self.radius = radius
        self.initialize()

    def initialize(self, **kwargs):
        step = 90
        # Left bottom end
        self.insert(ZwUIHelper.get_opengl_pos3d_vector(self.left + self.radius, self.bottom), self.color)
        # Right bottom start
        self.insert(ZwUIHelper.get_opengl_pos3d_vector(self.left + self.width - self.radius, self.bottom), self.color)
        # Right bottom arc
        for i in range(1, step + 1):
            tx = self.left + self.width - self.radius
            ty = self.bottom + self.radius
            tx += self.radius * math.cos(i / step * PI / 2 - PI / 2)
            ty += self.radius * math.sin(i / step * PI / 2 - PI / 2)
            self.insert(ZwUIHelper.get_opengl_pos3d_vector(tx, ty), self.color)
        # Right Top start:
        self.insert(ZwUIHelper.get_opengl_pos3d_vector(self.left + self.width, self.bottom + self.height - self.radius),
                    self.color)
        # Right top arc
        for i in range(1, step + 1):
            tx = self.left + self.width - self.radius
            ty = self.bottom + self.height - self.radius
            tx += self.radius * math.cos(i / step * PI / 2)
            ty += self.radius * math.sin(i / step * PI / 2)
            self.insert(ZwUIHelper.get_opengl_pos3d_vector(tx, ty), self.color)
        # Left top start:
        self.insert(ZwUIHelper.get_opengl_pos3d_vector(self.left + self.radius, self.bottom + self.height), self.color)
        # Left top arc:
        for i in range(1, step + 1):
            tx = self.left + self.radius
            ty = self.bottom + self.height - self.radius
            tx += self.radius * math.cos(i / step * PI / 2 + PI / 2)
            ty += self.radius * math.sin(i / step * PI / 2 + PI / 2)
            self.insert(ZwUIHelper.get_opengl_pos3d_vector(tx, ty), self.color)
        # Left bottom start
        self.insert(ZwUIHelper.get_opengl_pos3d_vector(self.left, self.bottom + self.radius), self.color)
        # Left bottom arc
        for i in range(1, step + 1):
            tx = self.left + self.radius
            ty = self.bottom + self.radius
            tx += self.radius * math.cos(i / step * PI / 2 + PI)
            ty += self.radius * math.sin(i / step * PI / 2 + PI)
            self.insert(ZwUIHelper.get_opengl_pos3d_vector(tx, ty), self.color)

class ZwUIAbstractControl:
    def __init__(self, **kwargs):
        self.ani_clips = {"default": ZwUIClips()}
        self.current_clips = "default"
        self.z_index = 0
        self.paused = False
        self.play_ended = False
        self.handlers = {}
        self.name = ""
        self.hidden = False
        self.recorded_dict = kwargs

    def reload(self, **kwargs):
        for key in kwargs.keys():
            self.recorded_dict[key] = kwargs[key]
        self.ani_clips = {"default": ZwUIClips()}
        self.initialize(**self.recorded_dict)

    def add_handler(self, event: str, handler: callable):
        self.handlers[event] = handler

    def switch_to_animation_list(self, name):
        self.current_clips = name
        if name not in self.ani_clips:
            self.ani_clips[name] = ZwUIClips()

    def switch_to_keyframe(self, idx):
        self.ani_clips[self.current_clips].selected_clips = idx

    def play_animation(self, **kwargs):
        if self.paused:
            return
        self.ani_clips[self.current_clips].selected_clips += 1
        if self.ani_clips[self.current_clips].selected_clips >= len(self.ani_clips[self.current_clips].clips):
            self.ani_clips[self.current_clips].selected_clips = len(self.ani_clips[self.current_clips].clips) - 1
            if not self.play_ended:
                if ZwUIConstant.EV_PLAY_ENDED in self.handlers:
                    self.handlers[ZwUIConstant.EV_PLAY_ENDED](
                        initiator=ZwUIConstant.ROLE,
                        control_name=self.name,
                        event=ZwUIConstant.EV_PLAY_ENDED
                    )
            self.play_ended = True
        else:
            self.play_ended = False

    def append_keyframe(self, keyframe):
        self.ani_clips[self.current_clips].add_frame(keyframe)

    def pop_keyframe(self):
        self.ani_clips[self.current_clips].pop_frame()

    def render(self):
        if not self.hidden:
            self.ani_clips[self.current_clips].render(z_index=self.z_index)

    def on_mouse_down(self, x, y):
        pass

    def initialize(self, **kwargs):
        ZwLogger().log(ZwLogger.ROLE_GUILA, ZwLogger.LV_WARN, "Abstract initialization function is called")
        keyframe = ZwUIKeyFrame()
        self.append_keyframe(keyframe)

    def frame_update(self, **kwargs):
        pass

# zwui_animation.py
def standard_cubic_bezier(x1, y1, x2, y2):
    return lambda t: 3 * np.array([x1, y1]) * t * (1 - t) * (1 - t) + 3 * np.array([x2, y2]) * t * t * (
        1 - t) + np.array([1, 1]) * t * t * t

# zwui_animation.py
def standard_cubic_bezier_time(x1, y1, x2, y2):
    def cubic_root(x):
        if x >= 0:
            return x ** (1. / 3.)
        else:
            return -(-x) ** (1. / 3.)

        def solver(x):
            a = (1 + 3 * x1 - 3 * x2)
            a2 = a * a
            b = (3 * x2 - 6 * x1)
            b2 = b * b
            c = 3 * x1
            p = (3. * a * c - b2) / (9. * a2)
            q = (-9. * a * b * c - 27. * a2 * x + 2. * b * b2) / (54. * a * a2)
            w = math.sqrt(q * q + p * p * p)
            v = -0.5 + math.sqrt(3) * 0.5j
            v2 = v * v
            f = b / 3. / a
            s = cubic_root(-q + w)
            t = cubic_root(-q - w)
            ex = 1000
            ret = [s + t - f,
                   v * s + v2 * t * 1j - f,
                   v2 * s + v * t * 1j - f]
            for i in ret:
                if (isinstance(i, float) or isinstance(i, int)) and (0.0 <= i <= 1.0):
                    return round(i * ex) / ex
                if isinstance(i, complex):
                    if math.fabs(i.imag) < 1e-5 and (0.0 <= i.real <= 1.0):
                        return round(i.real * ex) / ex
                    raise Exception("No solution", " X=" + str(x), "t=" + str(t), "SimCoef" + str([1, p, q]),
                                    "Coef=" + str([a, b, c, -x]), ret, )

                    def solver_x(x):
                        t = solver(x)
                        eq = ZwUITransition.standard_cubic_bezier(x1, y1, x2, y2)
                        return eq(t)

                    return lambda x: solver_x(x)

# app.py
# Transition Schemes
t_bezier = ZwUITransition.standard_cubic_bezier_time(.76, .36, .24, .56)
t_bezier_beta = ZwUITransition.standard_cubic_bezier_time(.78, .17, .22, .85)
t_bezier_alpha = ZwUITransition.standard_cubic_bezier_time(.88, .28, .26, .91)
t_linear = lambda x: (x, x)

# app.py
class ZwUIHCILab01EventThread(threading.Thread):
    def __init__(self, parent: object = None, event_callback_handler: callable = None):
        super(ZwUIHCILab01EventThread, self).__init__()
        self.callback = event_callback_handler
        self.parent = parent

    def run(self):
        ZwLogger().log(ZwLogger.ROLE_APP, ZwLogger.LV_INFO, "Speech recognition thread starts")
        responder = Responder()
        responder.waiting_and_respond(self.callback, True, self.parent)

class Responder:
    def __init__(self):
        self.text_analyst = TextUtil()
        self.application_map = { ... }

    def waiting_and_respond(self,
                            callback_function: callable = None,
                            is_member_function: bool = False,
                            parent_node: object = None):
        async def callback_wrapper(**kwargs):
            ZwLogger().log(ZwLogger.ROLE_ALRSP, ZwLogger.LV_INFO, "Initiating the callback procedure"
                                                                  " to the event handler")
            await asyncio.sleep(1)
            if callback_function is not None:
                callback_function(**kwargs)

        sr = SpeechRecognitionUtil()
        tx = TextUtil()
        while True:
            rec = sr.interpret_from_microphone(None)
            action = None
            for key in self.application_map.keys():
                if tx.similarity(key, rec) > 0.8:
                    action = self.application_map[key]
                    break
            asyncio.run(callback_wrapper(initiator="responder", action=action, result=rec))

    # algorithm_utils.py
    def record_audio(self, wave_out_path, callback_function=None):
        async def callback_wrapper(**kwargs):
            await asyncio.sleep(1)
            if callback_function is not None:
                callback_function(**kwargs)

        chunk = 1024
        audio_format = pyaudio.paInt16
        channels = 1
        rate = 16000
        p = pyaudio.PyAudio()
        stream = p.open(format=audio_format,
                        channels=channels,
                        rate=rate,
                        input=True,
                        frames_per_buffer=chunk)
        wf = wave.open(wave_out_path, 'wb')
        wf.setnchannels(channels)
        wf.setsampwidth(p.get_sample_size(audio_format))
        wf.setframerate(rate)
        occupied = False
        stopflag = 0
        stopflag2 = 0
        threshold = 7000
        ZwLogger().log(ZwLogger.ROLE_ALRC, ZwLogger.LV_INFO, "Start to listening the Recorder")
        while True:
            data = stream.read(chunk)
            rt_data = np.frombuffer(data, np.dtype('<i2'))
            fft_temp_data = fftpack.fft(rt_data, rt_data.size, overwrite_x=True)
            fft_data = np.abs(fft_temp_data)[0:fft_temp_data.size // 2 + 1]
            SpeechRecognitionUtil.wave_ratio = sum(fft_data) // len(fft_data)
            if sum(fft_data) // len(fft_data) > threshold:
                stopflag += 1
                if not occupied:
                    ZwLogger().log(ZwLogger.ROLE_ALRC, ZwLogger.LV_INFO, "Start recording. Power gained via FFT:" +
                                   str(sum(fft_data) // len(fft_data)))
                    occupied = True
                    stopflag = 0
                    stopflag2 = 0
            else:
                stopflag2 += 1
                if not occupied:
                    continue
            ons = rate / chunk * 2
            if stopflag2 + stopflag > ons:
                if stopflag2 > ons * 0.8:
                    ZwLogger().log(ZwLogger.ROLE_ALRC, ZwLogger.LV_INFO, "Record completed")
                    break
                else:
                    stopflag2 = 0
                    stopflag = 0

            wf.writeframes(data)
            # ZwLogger().log(ZwLogger.ROLE_ALRC, ZwLogger.LV_INFO, data)
        stream.stop_stream()
        stream.close()
        p.terminate()
        wf.close()
        rate, data = wavfile.read(wave_out_path)
        _, noise_data = wavfile.read("./noise.wav")
        reduced_noise = nr.reduce_noise(y=data, y_noise=noise_data, sr=rate)
        wavfile.write(wave_out_path, rate, reduced_noise)

# algorithm_utils.py
def interpret_from_file(self, path):
    if SpeechRecognitionUtil.engine == "ds":
        fin = wave.open(path, 'rb')
        audio = np.frombuffer(fin.readframes(fin.getnframes()), np.int16)
        return SpeechRecognitionUtil.model.stt(audio)
    else:
        file = sr.AudioFile(path)
        with file as f:
            audio = self.recognizer.record(f)
        return self.recognizer.recognize_sphinx(audio)

class ZwUIStripedWaveControl(ZwUIAbstractControl):
    def __init__(self, x, center_y, strips, strip_width, strip_gap, color):
        super(ZwUIStripedWaveControl, self).__init__()
        self.x = x
        self.y = center_y
        self.st = strips
        self.wid = strip_width
        self.gap = strip_gap
        self.color = color
        self.initialize()
        self.floating = 0
        self.floating_lim = 45
        self.hv = 0.05
        self.emp_list = [0.05 for _ in range(100)]

    def initialize(self, **kwargs):
        kf = ZwUIKeyFrame()
        for i in range(self.st):
            t = ZwUIRectangle(self.x + (self.wid + self.gap) * i, -0.1 + self.y, self.wid, 0.2, self.color)
            kf.add_shape(t)
        self.append_keyframe(kf)

    def set_height(self, height=0.1):
        self.hv = height

    def frame_update(self, **kwargs):
        self.floating = self.floating + 1

        kf = ZwUIKeyFrame()
        for i in range(self.st - 1):
            t = ZwUIRectangle(self.x + (self.wid + self.gap) * i +
                              (self.floating / self.floating_lim) * (self.wid + self.gap),
                              -self.emp_list[i + 1] + self.y, self.wid, self.emp_list[i + 1] * 2, self.color)
            kf.add_shape(t)
        dr = self.floating / self.floating_lim
        dl = self.gap / (self.wid + self.gap)
        if dr >= dl:
            t = ZwUIRectangle(self.x, self.y - self.emp_list[0],
                              self.wid * (dr - dl) / (1 - dl), self.emp_list[0] * 2, self.color)
            kf.add_shape(t)
        else:
            t = ZwUIRectangle(self.x + (self.wid + self.gap) * (self.st - 1) +
                              (self.floating / self.floating_lim) * (self.wid + self.gap),
                              -self.emp_list[self.st] + self.y, self.wid * (1 - dr / dl),
                              self.emp_list[self.st] * 2, self.color)
            kf.add_shape(t)
        if self.floating == self.floating_lim:
            self.emp_list.pop()
            self.emp_list.insert(0, self.hv)
            self.floating = 0
        self.pop_keyframe()
        self.append_keyframe(kf)

# app.py 
def on_frame_update(self, **kwargs):
    hw = (min(0.05 * max(math.log(SpeechRecognitionUtil.wave_ratio + 1) - 0.2, 0), 0.5) + 0.05)
    self.get_scene("main_scene") \
    .get_control("wave") \
    .set_height(hw)

    self.get_scene("welcome_scene") \
    .get_control("start_guide_mcb") \
    .set_height(hw)

# algorithm_utils.py
class ShellUtil:
    @staticmethod
    def execute(path: str):
        ZwLogger().log(ZwLogger.ROLE_ALWIN, ZwLogger.LV_INFO, "Executing "+str(path))
        win32api.ShellExecute(0, 'open', path, '', '', 1)

# app.py
elif action[0] == "shell":
    self.get_scene("response_scene").get_control("tip_2").reload(
        overridden_text="I've found the application!")
    self.get_scene("response_scene").get_control("rec_2a").reload(
        overridden_text=action[1])
    self.get_scene("response_scene").get_control("rec_2b").reload(
        overridden_text="Execute " + self.action_list["applications"][action[1]])
    ShellUtil.execute(self.action_list["applications"][action[1]])

# app.py
if action[0] == "web_browse" and action[1] == "movie":
    self.get_scene("response_scene").get_control("tip_2").reload(
        overridden_text="I'll open a movie website!")

    key_chosen = random.choice(list(self.action_list["movie"].keys()))
    webbrowser.open(self.action_list["movie"][key_chosen], new=0, autoraise=True)
    self.get_scene("response_scene").get_control("rec_2a").reload(
        overridden_text=key_chosen)
    self.get_scene("response_scene").get_control("rec_2b").reload(
        overridden_text=self.action_list["movie"][key_chosen])

elif action[0] == "event":
    if action[1] == "dice":
        self.get_scene("response_scene").get_control("tip_2").reload(
            overridden_text="Is that you want?")
        self.get_scene("response_scene").get_control("rec_2a").reload(
            overridden_text="Dice Rolling")
        self.get_scene("response_scene").get_control("rec_2b").reload(
            overridden_text="Result is " + str(random.randint(1, 6)))

# main.py
def __init__(self, width=590 * 1.5, height=950):
    super().__init__()
    ZwLogger().log(ZwLogger.ROLE_GUIQT, ZwLogger.LV_INFO, "Initializing Window Widget")
    # MSAA Anti-aliasing
    self.msaa = QGLFormat()
    self.msaa.setSamples(InteractionUI.arg_msaa)
     self.ogl_widget = ZwGraphicsContainer(self,
                                              format_s=self.msaa,...)
    
# graphics_utils.py
class ZwGraphicsContainer(QGLWidget):
    def __init__(self, parent, format_s, frame_rate=60, app=None, s_width=None, s_height=None):
        super().__init__(format_s, parent)

# graphics_utils.py
ogl.glEnable(ogl.GL_POINT_SMOOTH)
ogl.glEnable(ogl.GL_LINE_SMOOTH)
ogl.glEnable(ogl.GL_MULTISAMPLE)
ogl.glEnable(ogl.GL_POLYGON_SMOOTH)
ogl.glHint(ogl.GL_POLYGON_SMOOTH_HINT, ogl.GL_NICEST)
ogl.glHint(ogl.GL_LINE_SMOOTH_HINT, ogl.GL_NICEST)
ogl.glHint(ogl.GL_POINT_SMOOTH_HINT, ogl.GL_NICEST)

def interpret_from_file(self, path):
    # DeepSpeech
    if SpeechRecognitionUtil.engine == "ds":
        fin = wave.open(path, 'rb')
        audio = np.frombuffer(fin.readframes(fin.getnframes()), np.int16)
        return SpeechRecognitionUtil.model.stt(audio)
    # Sphinx
    else:
        file = sr.AudioFile(path)
        with file as f:
            audio = self.recognizer.record(f)
            return self.recognizer.recognize_sphinx(audio)

self.application_map = {
    "open notepad": ["shell", "Notepad"],
    "notepad": ["shell", "Notepad"],
    "write notes": ["shell", "Notepad"],
    "write something": ["shell", "Notepad"],
    "take notes": ["shell", "Notepad"],
    "play music": ["shell", "Music Player"],
    "music": ["shell", "Music Player"],
    "play songs": ["shell", "Music Player"],
    "listen to music": ["shell", "Music Player"],
    "open calculator": ["shell", "Calculator"],
    "watch a movie": ["web_browse", "movie"],
    "movie": ["web_browse", "movie"],
    "watch movies": ["web_browse", "movie"],
    "a movie": ["web_browse", "movie"],
    "roll a dice": ["event", "dice"],
    "play dice": ["event", "dice"],
    "roll the dice": ["event", "dice"],
    "throw the dice": ["event", "dice"],
    "roll dice": ["event", "dice"]
}

class ZwUIAniMomoBotIconControl(ZwUIAbstractControl):
    def __init__(self, x, y, radius=2, fore=ZwUIHelper.get_opengl_rgba_vector(1, 1, 1),
                 back=ZwUIHelper.get_opengl_rgba_vector(0, 0, 0), **kwargs):
        super(ZwUIAniMomoBotIconControl, self).__init__()
        self.x = x
        self.y = y
        self.r = radius
        self.fore = fore
        self.back = back
        self.paused = True
        self.initialize(**kwargs)

    def initialize(self, **kwargs):
        # Primary Params
        x = self.x
        y = self.y
        r = self.r
        r2 = self.r * 0.718
        # Face Params
        fr = 0.5
        fr2 = 0.3
        dh = r / 1.618
        fs = r / 3
        delta = 0.01
        # Antenna Params
        anw = r / 5
        anh = r / 3
        anhd = 0.1
        anhr = r / 5
        # Eye Params
        eyecl = r / 2.8
        eyelh = r / 3.8
        eyenr = r / 8
        eyesp = r / 9

        eyecl2 = r / 3
        eyelh2 = r / 3.5
        eyenr2 = r / 5

        eyecl2i = r / 2
        eyelh2i = r / 4.5
        eyenr2i = r / 9

        # Ear Params
        earw = r / 5
        earh = r / 2
        earb = r / 3
        ear_adjust = 0.1

        assert 'animation_duration' in kwargs, "Animation duration must be configured"
        tra = lambda x: x
        if 'animation_transition' in kwargs:
            tra = lambda x: kwargs['animation_transition'](x)[1]
        for i in range(-1, int(kwargs['animation_duration'])):
            fgc = self.fore
            bgc = ZwUITransition.color_trans(tra, self.fore, self.back, (i + 1) / int(kwargs['animation_duration']))
            face1 = ZwUICircle(x + r, y + dh, r, bgc, 0, PI + 1.0 / 360 * PI * 2)
            face2 = ZwUIRoundedRectangle(x, y, 2 * r, dh, fr, bgc)
            face3 = ZwUIRectangle(x, y + fr, 2 * r, dh - fr + delta, bgc)
            face_in1 = ZwUICircle(x + r, y + dh, r2, fgc, 0, PI + 1.0 / 360 * PI * 2)
            face_in2 = ZwUIRoundedRectangle(x + (r - r2), y + dh - fs + fr2, r2 * 2, fs, fr2, fgc)
            antenna1 = ZwUIRectangle(x + r - anw / 2, y + dh + r - anhd, anw, anh, bgc)
            antenna2 = ZwUICircle(x + r, y + dh + r - anhd + anh, anhr, bgc)
            eye_normal1 = ZwUICircle(x + r - eyecl, y + dh - fs + fr2 + eyelh, eyenr, bgc)
            eye_normal2 = ZwUICircle(x + r + eyecl, y + dh - fs + fr2 + eyelh, eyenr, bgc)
            eye_exciting1 = ZwUITriangle(
                ZwUIHelper.get_opengl_pos3d_vector(x + r - eyecl2 + eyenr2, y + dh - fs + fr2 + eyelh2),
                ZwUIHelper.get_opengl_pos3d_vector(x + r - eyecl2 - eyenr2, y + dh - fs + fr2 + eyelh2 + eyenr2),
                ZwUIHelper.get_opengl_pos3d_vector(x + r - eyecl2 - eyenr2, y + dh - fs + fr2 + eyelh2 - eyenr2),
                bgc
            )
            eye_exciting2 = ZwUITriangle(
                ZwUIHelper.get_opengl_pos3d_vector(x + r + eyecl2 - eyenr2, y + dh - fs + fr2 + eyelh2),
                ZwUIHelper.get_opengl_pos3d_vector(x + r + eyecl2 + eyenr2, y + dh - fs + fr2 + eyelh2 + eyenr2),
                ZwUIHelper.get_opengl_pos3d_vector(x + r + eyecl2 + eyenr2, y + dh - fs + fr2 + eyelh2 - eyenr2),
                bgc
            )
            eye_exciting_in1 = ZwUITriangle(
                ZwUIHelper.get_opengl_pos3d_vector(x + r - eyecl2i + eyenr2i, y + dh - fs + fr2 + eyelh2),
                ZwUIHelper.get_opengl_pos3d_vector(x + r - eyecl2i - eyenr2i, y + dh - fs + fr2 + eyelh2 + eyenr2i),
                ZwUIHelper.get_opengl_pos3d_vector(x + r - eyecl2i - eyenr2i, y + dh - fs + fr2 + eyelh2 - eyenr2i),
                fgc
            )
            eye_exciting_in2 = ZwUITriangle(
                ZwUIHelper.get_opengl_pos3d_vector(x + r + eyecl2i - eyenr2i, y + dh - fs + fr2 + eyelh2),
                ZwUIHelper.get_opengl_pos3d_vector(x + r + eyecl2i + eyenr2i, y + dh - fs + fr2 + eyelh2 + eyenr2i),
                ZwUIHelper.get_opengl_pos3d_vector(x + r + eyecl2i + eyenr2i, y + dh - fs + fr2 + eyelh2 - eyenr2i),
                fgc
            )
            ear1 = ZwUIRectangle(x - earw + ear_adjust, y + earb, earw, earh, bgc)
            ear2 = ZwUIRectangle(x + 2 * r - ear_adjust, y + earb, earw, earh, bgc)

            keyframe1 = ZwUIKeyFrame()
            keyframe1.add_shape(eye_exciting_in1)
            keyframe1.add_shape(eye_exciting_in2)
            keyframe1.add_shape(eye_exciting1)
            keyframe1.add_shape(eye_exciting2)
            keyframe1.add_shape(face_in1)
            keyframe1.add_shape(face_in2)
            keyframe1.add_shape(face1)
            keyframe1.add_shape(face2)
            keyframe1.add_shape(face3)
            keyframe1.add_shape(antenna1)
            keyframe1.add_shape(antenna2)
            keyframe1.add_shape(ear1)
            keyframe1.add_shape(ear2)

            keyframe2 = ZwUIKeyFrame()
            keyframe2.add_shape(eye_normal1)
            keyframe2.add_shape(eye_normal2)
            keyframe2.add_shape(face_in1)
            keyframe2.add_shape(face_in2)
            keyframe2.add_shape(face1)
            keyframe2.add_shape(face2)
            keyframe2.add_shape(face3)
            keyframe2.add_shape(antenna1)
            keyframe2.add_shape(antenna2)
            keyframe2.add_shape(ear1)
            keyframe2.add_shape(ear2)

            self.append_keyframe(keyframe1)
            self.ani_clips["normal"] = ZwUIClips()
            self.ani_clips["normal"].add_frame(keyframe2)