Well Here's a short video showing the first mouseTrap mouth Click.

I hope you like it.

Acá les dejo un pequeño vídeo con el primer click ejecutado con mouseTrap.

Espero que les guste.

URL: http://www.youtube.com/watch?v=jfNRS1oSb34

Hi!!

I've been programming the httpServer and the dbusServer for mouseTrap and I wanted to share how simple is communicate with our applications using dbus and its python bindings.

The piece of code we are interested in is this:

import dbus
import gobject
import dbus.service
from dbus.mainloop.glib import DBusGMainLoop

main_loop = DBusGMainLoop()
bus = dbus.SessionBus(mainloop=main_loop)

DBUS_NAME = "org.myApp"
DBUS_PATH = "/org/myApp"

class myAppdBus(dbus.service.Object):
    """
    Our dbus Class
    """

    def __init__( self ):
        """
        Starting the dbus service.
        """
        global bus
        bus_name = dbus.service.BusName(DBUS_NAME, bus=bus)
        dbus.service.Object.__init__(self, bus_name, DBUS_PATH)

    @dbus.service.method(DBUS_NAME)
    def do( self ):
        """
        Function to execute using dbus service
        """
        print "do function has been called using dbus service"


class myApp:

    def __init__(self):
        self.loop = gobject.MainLoop()
        d = myAppdBus()

    def start(self):
        self.loop.run()


if __name__ == '__main__':
    app = myApp()
    app.start()

It is a simple script with 2 classes. The main class called myApp will call the dbus class (myAppdBus) and will start the applications main loop. The second class (myAppdBus) is the dbus class, it starts the service and register the methods that can be called using dbus.

The script can be executed like this (in my case the name of the script is dbus_script.py):


$ python dbus_script.py


After running the script it is possible to execute the do function like this:


$ dbus-send --reply-timeout=30000 --print-reply --dest=org.myApp /org/myApp org.myApp.do


This last command will show us the information related to the call we just executed. The output is something like:

flaper87@r4-p17:~$ dbus-send --reply-timeout=30000 --print-reply --dest=org.myApp
/org/myApp org.myApp.do
method return sender=:1.6 -> dest=:1.7 reply_serial=2

Ass you can the classes are really simple and show an easy way to communicate with our applications using dbus. There are a lot of options a tweaks that can be implemented so it's all in you hands now.

Good Luck.

P.S: Quick post, isn't it? :P

OpenCv (Open Source Computer Vision Library) es una librería de funciones principalmente orientadas al procesamiento de imágenes en tiempo real.

En este post colocare un ejemplo de como utilizar OpenCV para realizar una simple captura y mostrarla en un frame.

import sys
from opencv import cv,highgui

if __name__ == '__main__':
    #Iniciamos la captura del device 0. Ej: /dev/video
    capture = highgui.cvCreateCameraCapture (0)

    # Revisamos que este Capturando.
    if not capture:
        print "Error Abriendo el device /dev/video0"
        sys.exit (1)

    # Creamos las ventanas necesarias.
    highgui.cvNamedWindow ("Ejemplo OpenCV", highgui.CV_WINDOW_AUTOSIZE)

    while 1:
        # Loop Infinito.

        # 1. Capturamos la imagen actual
        frame = highgui.cvQueryFrame (capture)

        # 1.1 Si no hay captura salimos.
        if frame is None:
            break

        # 2. Mostramos la imagen
        highgui.cvShowImage ("Ejemplo OpenCV", frame)

        # 3. Manejar Eventos. Esta función debe ser llamada periódicamente,
        # por eso esta dentro del loop
        c = highgui.cvWaitKey (10)

        #Revisamos si alguna tecla de nuestro interés fue presionada
        if c == '\x1b':
            # Esc fue presionado, Salimos.
            break

    cvDestroyWindow( "Ejemplo OpenCV" );

Como pueden apreciar los pasos son muy simples:

1. Nos conectamos al device
2. Comenzamos a capturar
3. Mostramos la captura
4. Capturamos teclas.
5. Procesamos las capturas

Espero que les sirva como una pequeña introducción a opencv + python, seguire publicando otras formulas secretas :P para explicar pocas de las infinidades de cosas que se pueden hacer con esta combinacion :D

Feliz Día a todos!!

mouseTrap: This is the name of my new application. It is being developed using python and its main and most important function is allow users to control their mouse using a Web Cam and their faces by tracking specific points of the face previously detected. It is also capable to perform clicks and all the mouse options (at least it will). At this moment it is completely capable to perform mouse movements using at-spi's python bindings (pyatspi).

1) History:

mouseTrap started as a simple widgetsTrap (read bellow), while the development advanced new ideas were coming and one of them was the idea of creating an application to move the mouse with the head using a simple and low cost web cam. After doing some research I found OpenCV ( base library of mouseTrap ). After downloading and testing OpenCV I found out that it is capable to do amazing things including face detection. After this I just performed some other tests and apply everything into mouseTrap and so the Web Cam feature became the main function of it.

2) Project Main Goal:

The main goal of the project is to become a completely accessible application for people with movement impairments and so take care of that important part of accessibility that wasn't covered until now. With this, It's possible to expand even more the Assistive Technology and Computer Accessibility and so make the technology accessible for more people.

3) What does mouseTrap use to model the head movement into mouse movement?

It calculates the 2D coordinates variation of the face movement on the Web Cam image and after that it executes the required movements with the pointer. It is a really simple calculation that gives an absolute and flexible control. The required movement is completely customizable by the user through the gtk based GUI.

4) Other Important Features:

• WidgetsTrap: The widgetsTrap is a time-out focus executer feature that catches all the selectable and focusable widgets of the current window ( Desktop or any other application ) and if the mouse hasn't been moved in the setted time-out the nearest selectable or focusable widget will be focused. A demonstration video can be found here
• HttpServer: It is a basic httpServer to communicate with mouseTrap using command line ( wget ) or a simple web browser.
• KeyBindings: Yes Keybindings! The keybindings let the user perform some extra mouseTrap actions like, re-detect points, enable/disable features and so on...
• Mousebindings: There are also mousebindings for the main or most important actions ( like re-detect points ) so the can be executed using the Web Cam too requiring less movement.
• Internationalisation: multi language support.

5) Future Features:

• Eyetraking: This is the most important feature to implement, hopefully in a short future. This will allow the user to move the mouse just with the eyes, just watching the point in the screen where the mouse should be moved.
• Plugins Interface: a simple interface for plugins implementations.
• More Features to add soon...

I've recorded a Demo Video where is possible to appreciate how mouseTrap works. [video here]

There is a lot more to write, but i wanted to give a resume.

I hope you like the Video and even better the project.

Best Regards to all.

P.S: SPONSORS, Ideas, Suggestions, Opinions, Helps, DESIGNERS are welcomed so don't think twice and feel free to submit a comment or mail me to: flaper87 at flaper87 dot com    :P

Video on youtube:

Latest videos:

First MouseTrap Click: http://www.youtube.com/watch?v=jfNRS1oSb34

MouseTrap + MouseTweaks: http://www.youtube.com/watch?v=kqaT0YhPpjU

MouseTrap + MouseTweaks using screen mode: http://www.youtube.com/watch?v=O5jPzbCIlOE

Llevo ya varios días viendo distintos ataques a blogs de muchas personas que conozco y pues no puedo evitar preguntarme, tener un blog debería ser algo ¿Divertido? o ¿Peligroso?.

Cuando decidí abrir este blog fue con la simple razón de tener un espacio en la WWW donde pudiese escribir cosas que me parecen interesantes y que de alguna manera me gustaría compartir con otros, pero por lo visto para muchas personas se ha vuelto mas divertido buscar la forma de dañarle el blog a otra persona por odio, rencor, diversión o quien sabe que otra razón se le pueda dar.

El punto es que una vez más me doy cuenta que para el ser humano (y me permito generalizar) a veces es mas fácil recurrir a la violencia para saciar su inestabilidad interior (nuevamente llamese odio, maldad, rencor o X) que a las palabras mismas. y pues que lamentablemente la violencia no tiene y no tendrá limites (al menos en este momento no los veo).

Con esto no me la quiero dar de predicador ni nada por el estilo, si no que simplemente siendo no solo parte de este planeta sino también propietario de un blog, me preocupa el ver como nuestro mundo se nos viene abajo.

python -c "import freedom; print everything"

FlaPer87

Encontre esto en la web hecho en perl:

perl -e "print pack('c5',(41*2),sqrt(7056),(unpack('c',H)-2),oct(115),10);"

que decia ser la solución a todos los problemas, cuando lo corri no hice mas que reirme y como me da escalofrios usar perl entonces me dedique a importarlo a python manteniendo la misma estructura de la original (hay muchas mas formas de hacerlo asi que los invito a variar la original :-) ).

python -c "from struct import pack; print pack('5b', (41*len('99')),pow(8,2)+20, 4900** 0.5, range(78)[-1], 10)"

Ejecutenlo en la linea de comandos y vean el output. :-D

Ciao

EL otro día, me encontraba realmente fastidiado, y con la necesidad de crearme una contraseña nueva para mi usuario, así que como tenia la imaginación realmente apagada, me dedique a hacer un generador de contraseñas con este maravilloso lenguaje.

Primero que nada hay que entender algo, las contraseñas para que sean buenas y difíciles de descifrar, deben contener números, letras (mayúsculas y minúsculas) y signos de puntuación (también conocidos como signos especiales) mezclados dentro de ella. También se recomienda que sean bastante largas y que no tengan relación con nuestro entorno.

OJO: No voy a explicar todo lo que hace el script PyGenPass, solamente explicare como toma aleatoriamente la cantidad de digitos que queramos. El codigo puede descargarse desde AQUI

AL GRANO!!!

Primero importamos las 2 librerías que necesitamos:

>>>import string
>>>from random import choice

Luego lo que hice fue lo siguiente, sin necesidad de librerías extras que instalar, tome la lista de letras, números y signos especiales ofrecida por la librería string de python y las almacene en tres variables distintas para poder escoger desde ellas aleatoriamente lo que necesitara, de la siguiente manera:

>>>letras = string.letters
>>>numeros = string.digits
>>>signos = string.punctuation

Después de tener esas variables definidas podemos generar la contraseña iterando a través de las variables mientras seleccionamos un valor de los que contenga, así:

>>> print ''.join(choice([choice(letras),choice(numeros),
... choice(especiales)]) for x in range(10))

Donde esta N colocamos la longitud que queremos que tenga nuestra contraseña, si la queremos de 4 caracteres le colocamos 4.

Esta es una forma comprimida y corta para generar una contraseña con python, pero si quieren ser mas estrictos e indicarle el numero de letras, dígitos o signos especiales que quieren que tenga, les recomiendo que le den un ojo al código.

El código lo pueden descargar desde aqui, pueden leerlo, usarlo, modificarlo y distribuirlo a su gusto, es un poco mas largo debido a las opciones que quise agregarle y a que no quise hacer el código tan comprimido como en el ejemplo mostrado. A su vez si desean, pueden instalarlo de la siguiente forma (solo los que usen GNU/Linux ya que lo instala en /usr/bin), primero descompriman el .zip y luego desde la carpeta en donde se encuentre el código hagan como superusuarios:

# python PyGenPass.py -i
ó
# python PyGenPass.py --install

Luego de instalado, pueden darle uso simplemente escribiendo en la terminal pygenpass (esto si lo pueden hacer como usuario normales) y para poder usar las opciones vean la ayuda pygenpass -h.

Espero que les halla servido, cualquier cosa no duden en comentar.

Saludos

En la última versión de python (la 2.5), han habido muchas variaciones en cosas que ya existían como la forma de usar generadores, la validación de funciones, nuevas modalidades para las estructuras de decisión, como a su ves han habido nuevas funciones que han sido agregadas a este lenguaje. Una de ellas es la clausula "with", la cual tiene una forma simple y cómoda de funcionar.Supongamos que en alguna ocasión, necesitamos utilizar alguna información que tenemos en un fichero, lo que normalmente haríamos seria abrir el fichero, operarlo y luego cerrarlo, con la sentencia "with" simplemente lo tomamos, lo usamos y lo liberamos. Este tipo de casos los encontramos no solo en la manipulación de ficheros, también en conexiones con bases de datos, manipulacion de clases, librerias, entre otros. Vamos a la practica.

La forma para importar esta Clausula es la siguiente:

>>> from __future__ import with_statement

Esta clausula se encuentra en el modulo future, ya que algunas de las novedades de python2.5 están aun en prueba y no se han liberado.

Ahora si, un ejemplo de uso de esta clausula:

>>> from __future__ import with_statement
>>> with open('hola','r') as file:
...     contenido = (file.read()).split()
...
>>> print contenido
['hola']
>>>


Este ejemplo anterior se adapta muy bien para aquellos que suelen abrir los archivos, volcar su contenido dentro de una lista y manipularlos desde ahí, como en mi caso :).

Ahora bien, pasemos a un ejemplo un poco mas complejo, sabemos que con el "with" podemos capturar *algo* (termino que uso para generalizar) que necesitemos y tomar de el sus funciones, contenidos, clases etc, entonces hagamos una prueba con una clase.

Tenemos una clase llamada prueba, en la cual tenemos definidas 4 funciones, observen:

>>> from __future__ import with_statement
>>> valor = 3
>>> class prueba(object):
...     def __init__(self,valor):
...             self.valor = valor
...     def __enter__ (self):
...             self.valor += self.valor
...             self.mostrar = "El valor es: " + str(self.valor)
...             return self
...     def __exit__(self,type,value,traceback):
...             if traceback is not None:
...                     print "Hubo Problemas"
...     def imprimir(self):
...             print self.mostrar
...
>>> with prueba(valor) as imp:
...     imp.imprimir()
...
El valor es: 6
>>>

En nuestra clase prueba tenemos definida primero que nada una función __init__ que es la que va a recoger los valores o atributos que se le indiquen a la clase prueba. Seguida a esta función tenemos el metodo __enter__ que en nuestro caso nos retorna los valores recogidos por el __init__ y que fueron procesados en __enter__, es decir, retorna tanto el self.valor como el self.mostrar dentro de un *campo global* (por asi llamarlo) self. Luego de esto tenemos el metodo __exit__ que seria la salida de la clausula with, en nuestro caso, simplemente comprueba si el traceback tiene una salida distinta a None para que nos diga si algo ha salido mal.

Por último tenemos la función imprimir la cual va a mostrarnos el valor calculado en el metodo __enter__

Realmente, el ejemplo que muestro puede ser realizado de una manera mas simple y sin usar el with, pero la idea del mismo es mostrar el funcionamiento de esta clausula y que si vemos mas profundamente en ella, podremos ver que trae facilidades para procesos comunes como conexiones a bases de datos, o funciones y clases mas complicadas que pueden ser encontradas o necesitadas en algun momento.

Espero haberme explicado bien, y que hayan entendido esta clausula.

Saludos!!

Saludos para todos!!!

Me encontraba realizando un programa el cual tenia que lanzar una serie de alertas o avisos en un momento especifico, y se me ocurrio la idea de hacer que esos avisos fuesen estilo "Toaster" popup (este estilo de aviso, es una ventanita que usualmente aparece en la esquina inferior derecha del monitor, como las del MSN), para elo un amigo me recomendo una libreria llamada ToasterBox la cual fue escrita utilizando wxwidgets y te permite crear ese estilo de avisos, bien sea de manera simple o compleja. En la forma simple, se muestra el aviso con el texto seleccionado( "El hecho de que sea simple no significa que no sea configurable"). En la forma compleja, se podran incluir widgets, como botones, Tickers, Checkboxes entre otros.

En este post les explico la forma de asignar la posicion en la que tiene que aparecer este aviso, ya que fue donde me complique un poco y porque si explico todo el post sera bastante largo :). En mi caso yo creia que apareciera justo donde aparecen los del MSN, pero para ello, no podia asignarle los valores directamente, explico:

Si yo le asignaba los valores directamente hubiese sido algo asi:

tb = TB.ToasterBox(self, tbstyle, windowstyle, closingstyle)
posx = int(1070)
posy= int(648)
tb.SetPossition((posx,posy))

De esa manera hubiesen aparecido donde yo queria pero solo en mi monitor, ya que los valores se los habia asignado de acuerdo a la resolucion de mi monitor. Entonces para poder que en cualquier monitor este aviso apareciera en la esquina inferior derecha, nesecitaba obtener las medidas del area de trabajo del monitor en el que la aplicacion estaba corriendo. El Area de trabajo, es todo el espacio del escritorio, excluyedo la barra del menu inicio(Taskbar), y cualquier otra barra de herramientas que pueda tener el usuario. Para obtener las medidas de esta hice uso de las propiedades de wxpython:

tb = TB.ToasterBox(self, tbstyle, windowstyle, closingstyle)
sizex = Ancho del aviso
sizey = Altura del aviso
posx = wx.GetClientDisplayRect().GetWidth()-sizex
posy = wx.GetClientDisplayRect().GetHeight()-sizey
tb.SetPopupPosition((posx,posy))

Lo que hice fue tomar las medidas del area de trabajo individualmente con la propiedad GetClientDisplayRect() de wxpython y restarles las medidas del aviso, para que este pudiese aparecer en la posicion deseada.;)

Recuerden que esta libreria es altamente configurable, por lo tanto depende de ustedes como estara configurada. Les dejo el link[1] para que puedan descargar esta libreria si es de su interes(Viene con un Demo de ejemplo).

[1]ToasterBox

Durante varios meses me encontre trabajando con C# en Visual Studio 2005, un lenguaje no complicado pero si complejo en su forma de escribir el codigo. Luego de estos meses encuentro un lenguaje de programacion dinamicamente tipado llamado Python, el cual es simple y muy completo, con innumerables librerias y gran versatilidad; decidido a darle una oportunidad, me inscribo en un curso basico para ver de que se trata.

En estos momentos, luego de haber hecho este curso puedo decir que he encontrado uno de los lenguajes mas completo y amplio que he aprendido. Al decir amplio me refiero a la cantidad de cosas que se pueden desarrollar con este lenguaje como simples programas administrativos, juegos, Inteligencia Artificial entre otros. Su gran amplitud permite que distintos conocimientos de distintas areas interactuen entre si y permitan una integracion e interaccion a traves de este lenguaje interpretado, pudiendo lograr asi todo lo que el ser se disponga.

No digo que este lenguaje sea perfecto, pero no le he encontrado ninguna falla, y OJO TAMPOCO SE LA ESTOY BUSCANDO : ).

Los invito a probarlo, y darle una oportunidad a este lenguaje multiplataforma, les aseguro que no les fallara. Ahora les dejo publicado el Zen de Python, que muestra la filosofia de este lenguaje, y que deberiamos aplicar en nuestro día a día.

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one– and preferably only one –obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea — let’s do more of those!