path: root/face.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

import math

import gi
from gi.repository import Gtk
from gi.repository import Gdk

class Face(Gtk.EventBox):
    """La cara."""
    
    def __init__(self):
        
        Gtk.EventBox.__init__(self)
        
        self.eyes_box = None
        self.mouth = None
        
        self.type_eyes = 'Round'
        self.type_mouth = 'Simple'
        
        self.eyes_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
        mouthbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
        
        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        box.pack_start(self.eyes_box, True, True, 0)
        box.pack_start(mouthbox, True, True, 0)
        
        self.mouth = Mouth()
        mouthbox.pack_start(self.mouth, True, True, 0)
        
        self.add(box)
        
        self.set_number_eyes(2)
        
        self.show_all()

    def set_type_mouth(self, tipo):
        """Actualizar el tipo de boca.
        tipo puede ser 'Simple' o 'Waveform' o 'Frequency'"""
        
        self.type_mouth = tipo
        self.mouth.tipo = self.type_mouth
            
    def set_type_eyes(self, tipo):
        """Actualizar el tipo de ojos.
        tipo puede ser 'Round' o 'Glasses'"""
        
        self.type_eyes = tipo
        for child in self.eyes_box.get_children():
            child.set_type(self.type_eyes)
        
    def set_number_eyes(self, number):
        """Actualizar la cantidad de ojos."""
        
        while len(self.eyes_box.get_children()) < number:
            self.add_eye()
        
        while len(self.eyes_box.get_children()) > number:
            self.del_eye()
        
        self.set_type_eyes(self.type_eyes)
        
    def add_eye(self):
        """Agrega un ojo."""
        
        self.eyes_box.pack_start(Eye(), True, True, 0)
    
    def del_eye(self):
        """Quita un ojo."""
        
        childs = self.eyes_box.get_children()
        if childs:
            eye = childs[-1]
            self.eyes_box.remove(eye)
            eye.destroy()
            
    def look_at(self, pos):
        """Mirar hacia pos"""
        
        x, y = pos
        map(lambda e, x=x, y=y: e.look_at(x, y), self.eyes_box.get_children())
        

class Eye(Gtk.DrawingArea):
    """El ojo.
    self.tipo puede ser 'Round' o 'Glasses'."""
    
    def __init__(self):
        
        Gtk.DrawingArea.__init__(self)
        
        self.x, self.y = 0, 0
        self.fill_color = (49000, 52000, 18000)
        self.tipo = 'Round'
        
        self.show_all()
    
    def set_type(self, tipo):
        """Cambia el tipo de ojo.
        tipo puede ser 'Round' o 'Glasses'"""
        
        self.tipo = tipo
        self.queue_draw()
        
    def look_at(self, x, y):
        """ Look. . ."""
        
        self.x = x
        self.y = y
        self.queue_draw()
        
    def computePupil(self):
        """La Pupila."""
        
        rect = self.get_allocation()

        if self.x is None or self.y is None:
            if rect.x + rect.width / 2 < rect.width / 2:
                cx = rect.width * 0.6
            else:
                cx = rect.width * 0.4
            return cx, rect.height * 0.6

        EYE_X, EYE_Y = self.translate_coordinates(
                self.get_toplevel(), rect.width / 2, rect.height / 2)
        EYE_HWIDTH = rect.width
        EYE_HHEIGHT = rect.height
        BALL_DIST = EYE_HWIDTH / 4

        dx = self.x - EYE_X
        dy = self.y - EYE_Y

        if dx or dy:
            angle = math.atan2(dy, dx)
            cosa = math.cos(angle)
            sina = math.sin(angle)
            h = math.hypot(EYE_HHEIGHT * cosa, EYE_HWIDTH * sina)
            x = (EYE_HWIDTH * EYE_HHEIGHT) * cosa / h
            y = (EYE_HWIDTH * EYE_HHEIGHT) * sina / h
            dist = BALL_DIST * math.hypot(x, y)

            if dist < math.hypot(dx, dy):
                dx = dist * cosa
                dy = dist * sina

        return rect.width / 2 + dx, rect.height / 2 + dy

    def do_draw(self, context):
        rect = self.get_allocation()
        eyeSize = min(rect.width, rect.height)
        
        outlineWidth = eyeSize / 20.0
        pupilSize = eyeSize / 10.0
        pupilX, pupilY = self.computePupil()
        dX = pupilX - rect.width / 2.
        dY = pupilY - rect.height / 2.
        distance = math.sqrt(dX * dX + dY * dY)
        limit = eyeSize / 2 - outlineWidth * 2 - pupilSize
        if distance > limit:
            pupilX = rect.width / 2 + dX * limit / distance
            pupilY = rect.height / 2 + dY * limit / distance
            
        r,g,b = self.fill_color
        context.set_source_rgba(r,g,b,1)
        context.rectangle(0, 0, rect.width, rect.height)
        context.fill()
            
        if self.tipo == 'Round':
            # eye ball
            context.set_source_rgb(1, 1, 1)
            context.arc(rect.width / 2,
                rect.height / 2,
                eyeSize / 2 - outlineWidth / 2,
                0, 360)
            context.fill()
            
            # outline
            context.set_source_rgb(0, 0, 0)
            context.set_line_width(outlineWidth)
            context.arc(rect.width / 2,
                rect.height / 2,
                eyeSize / 2 - outlineWidth / 2,
                0, 360)
            context.stroke()
            
        elif self.tipo == 'Glasses':
            def roundrect(x1, y1, x2, y2):
                context.move_to(x1, (y1 + y2) / 2.)
                context.curve_to(x1, y1, x1, y1, (x1 + x2) / 2., y1)
                context.curve_to(x2, y1, x2, y1, x2, (y1 + y2) / 2.)
                context.curve_to(x2, y2, x2, y2, (x1 + x2) / 2., y2)
                context.curve_to(x1, y2, x1, y2, x1, (y1 + y2) / 2.)
                
            # eye ball
            context.set_source_rgb(1, 1, 1)
            roundrect(outlineWidth,
                      outlineWidth,
                      rect.width - outlineWidth,
                      rect.height - outlineWidth)
            context.fill()
            
            # outline
            context.set_source_rgb(0, 0, 0)
            context.set_line_width(outlineWidth)
            roundrect(outlineWidth,
                      outlineWidth,
                      rect.width - outlineWidth,
                      rect.height - outlineWidth)
            context.stroke()
            
        # pupil
        context.arc(pupilX, pupilY, pupilSize, 0, 360)
        context.set_source_rgb(0, 0, 0)
        context.fill()
            
        return True
    
class Mouth(Gtk.DrawingArea):
    """La boca."""
    
    def __init__(self):
        
        Gtk.DrawingArea.__init__(self)
        
        self.fill_color = (49000, 52000, 18000)
        self.volume = 0
        self.tipo = "Simple"
        
        self.show_all()

    def do_draw(self, context):
        
        rect = self.get_allocation()
        
        #self.processBuffer()
        
        # background
        r,g,b = self.fill_color
        context.set_source_rgba(r,g,b,1)
        context.paint()

        # Draw the mouth
        volume = self.volume / 30000.
        mouthH = volume * rect.height
        mouthW = volume ** 2 * (rect.width / 2.) + rect.width / 2.
        #        T
        #  L          R
        #        B
        Lx, Ly = rect.width / 2 - mouthW / 2, rect.height / 2
        Tx, Ty = rect.width / 2, rect.height / 2 - mouthH / 2
        Rx, Ry = rect.width / 2 + mouthW / 2, rect.height / 2
        Bx, By = rect.width / 2, rect.height / 2 + mouthH / 2
        context.set_line_width(min(rect.height / 10.0, 10))
        context.move_to(Lx, Ly)
        context.curve_to(Tx, Ty, Tx, Ty, Rx, Ry)
        context.curve_to(Bx, By, Bx, By, Lx, Ly)
        context.set_source_rgb(0, 0, 0)
        context.close_path()
        context.stroke()
        
        return True
    
    '''
    def _new_buffer(self, obj, buf):
        if len(buf) < 28:
            self.newest_buffer = []
        else:
            self.newest_buffer = list(unpack(str(int(len(buf)) / 2) + 'h',
                                      buf))
            self.main_buffers += self.newest_buffer
            if(len(self.main_buffers) > self.buffer_size):
                del self.main_buffers[0:(len(self.main_buffers) - \
                        self.buffer_size)]

        self.queue_draw()
        return True

    def processBuffer(self):
        if len(self.main_buffers) == 0 or len(self.newest_buffer) == 0:
            self.volume = 0
        else:
            self.volume = numpy.core.max(self.main_buffers)  # -\
            # numpy.core.min(self.main_buffers)




class WaveformMouth(Mouth):
    def __init__(self, audioSource, fill_color):

        Mouth.__init__(self, audioSource, fill_color)

        self.buffer_size = 100
        self.peaks = []

        self.stop = False

        self.y_mag_bias_multiplier = 1
        self.y_mag = 0.7
        
        self.show_all()

    def draw_wave(self, context):
        rect = self.get_allocation()
        self.param1 = rect.height / 65536.0
        self.param2 = rect.height / 2.0
        
        # background
        context.set_source_rgba(*self.fill_color.get_rgba())
        context.paint()
        
        # Draw the waveform
        context.set_line_width(min(rect.height / 10.0, 10))
        count = 0
        buflen = float(len(self.main_buffers))
        for value in self.main_buffers:
            peak = float(self.param1 * value * self.y_mag) +\
                   self.y_mag_bias_multiplier * self.param2
                
            if peak >= rect.height:
                peak = rect.height
            if peak <= 0:
                peak = 0
                
            x = count / buflen * rect.width
            context.line_to(x, rect.height - peak)
            
            count += 1
        context.set_source_rgb(0, 0, 0)
        context.stroke()
        
        return True


class FFTMouth(Mouth):
    def __init__(self, audioSource, fill_color):

        Mouth.__init__(self, audioSource, fill_color)

        self.peaks = []

        self.y_mag = 1.7
        self.freq_range = 70
        self.draw_interval = 1
        self.num_of_points = 105

        self.stop = False

        #constant to multiply with self.param2 while scaling values
        self.y_mag_bias_multiplier = 1

        self.fftx = []

        self.scaleX = "10"
        self.scaleY = "10"
        
        self.show_all()
        self.connect('draw', self.draw_fftmouth)

    def newprocessBuffer(self, rect):
        self.param1 = rect.height / 65536.0
        self.param2 = rect.height / 2.0

        if(self.stop == False):

            Fs = 48000
            nfft = 65536
            self.newest_buffer = self.newest_buffer[0:256]
            self.fftx = fft(self.newest_buffer, 256, -1)

            self.fftx = self.fftx[0:self.freq_range * 2]
            self.draw_interval = rect.width / (self.freq_range * 2.)

            NumUniquePts = ceil((nfft + 1) / 2)
            self.buffers = abs(self.fftx) * 0.02
            self.y_mag_bias_multiplier = 0.1
            self.scaleX = "hz"
            self.scaleY = ""

        if(len(self.buffers) == 0):
            return False

        # Scaling the values
        val = []
        for i in self.buffers:
            temp_val_float = float(self.param1 * i * self.y_mag) +\
                             self.y_mag_bias_multiplier * self.param2

            if(temp_val_float >= rect.height):
                temp_val_float = rect.height - 25
            if(temp_val_float <= 0):
                temp_val_float = 25
            val.append(temp_val_float)

        self.peaks = val

    def draw_fftmouth(self, widget, context):
        rect = widget.get_allocation()
        
        self.newprocessBuffer(rect)
        
        # background
        context.set_source_rgba(*self.fill_color.get_rgba())
        context.paint()
        
        # Draw the waveform
        context.set_line_width(min(rect.height / 10.0, 10))
        context.set_source_rgb(0, 0, 0)
        count = 0
        for peak in self.peaks:
            context.line_to(rect.width / 2 + count,
                                 rect.height / 2 - peak)
            count += self.draw_interval
        context.stroke()
        count = 0
        for peak in self.peaks:
            context.line_to(rect.width / 2 - count,
                rect.height / 2 - peak)
            count += self.draw_interval
        context.stroke()
        
        return True'''