Feeds:
Posts
Comments

Archive for the ‘Python’ Category

Python + Maya – Part 1


First, what’s Maya?

Maya is a high end 3D computer graphics and 3D modeling software package originally developed by Alias Systems Corporation, but now owned by Autodesk as part of the Media and Entertainment division. Autodesk acquired the software in October 2005 upon purchasing Alias. Maya is used in the film and TV industry, as well as for computer and video games.Wikipedia on Autodesk Maya

On its 8th version, Maya introduced Python scripting as an alternative for their native scripting language, MEL (Maya Embedded Language) which was being used for quite a long time.
After spending some months learning Python, today started to study maya bindings to Python and decided to make a series of posts showing some of the things I learn on the process.

The idea is that Python and MEL are alternatives for a programmer as they provided similar functionalities. So one must choose between one each and start their program.

Inputing code to Maya might be done in a series of different ways:

  • On start Maya always runs a script named “userSetup.py” which must be located at:
    • Windows: <drive>:\Documents and Settings\<user>\My Documents\maya\<version>\scripts
    • Mac OS X: ~/Library/Preferences/Autodesk/maya/<version>/scripts
    • Linux: ~/maya/<version>/scripts

    So you can write anything you’d like Maya to do on its first moments of life at this file;

  • Command Line It’s possible to input simple commands through Maya command line on the bottom of the window, like some select command of a hard to click object;
  • Script Editor The best way to test and debug your script. Since 8th edition, the script editor has two tabs on its lower part: MEL and Python. Clicking Python part won’t change anything but the interpreter the script editor will use to interpret your code. It provides simple ways to test it, but could be better if there was some syntax highlight;
  • Code outside Maya One can write the whole code outside Maya using any editor he’d like. It’s probably the best alternative for big plugins since most editors are a lot better than Maya Script Editor itself.

After learning that, and jumping on to the API to see what it was capable i was pleasantly surprised (since I’ve never spent much time studying MEL’s API) to find out it was capable of many amazing things and they were all documented.

It’s possible to access every attribute of any of the nodes on the scene, to create key frames and make complete animations through one script and to access many of the tools provided throughout the menus.

One quick example is how to create a bouncing ball animation.

import maya.cmds as cmds
cmds.polySphere( name = ‘bouncing’, radius = 2 )
g = -0.04
v0y = 0.8
v0x = 0.1
pos0y = 2
pos0x = 0
for itr in xrange(0,6):
for tx in xrange(0,42):
posy = pos0y + v0y*(tx-1) + g*(tx-1)*(tx-1)/2
posx = pos0x + v0x*((itr*42) + tx-1)
cmds.setKeyframe( ‘bouncing’, attribute=’translateY’, value=posy, t=(itr*42) + tx )
cmds.setKeyframe( ‘bouncing’, attribute=’translateX’, value=posx, t=(itr*42) + tx )

Line 1 imports all the Maya Comands to cmds and line 2 creates a polygonal sphere named “bouncing” with 2 units radius.
Lines 3 to 7 set a few physical constants like gravity (g), initial speeds (v0x and v0y) and initial positions (pos0x and pos0y).
Then comes the keyframe creation. The ball will jump 6 times, so we have a for from 0 to 6. Each bounce will take 42 frames what explains the second for from 0 to 42. Inside the second for and through some basic physical equations we set new positions for both x and y axis, and then create keyframes for both attributes.

I’m still trying to figure out a way to create less keyframes (through this method, I ended up creating 252 keyframes) even though I know this doesn’t represent a real problem for Maya standards.

So, thanks for reading, hope you enjoyed it and, if you try this at home, please feel free to comment your experience. And don’t forget to check our next episode: Python + Maya – Part 2!!

Powered by ScribeFire.

Read Full Post »

Lua/Python C API


Nos últimos dias precisei trabalhar com a interface entre códigos escritos em Lua e em C. Pesquisei um pouco sobre o assunto e pude perceber que apesar de um pouco complicada e de não ser tão bem documentada, a API de Lua para C funcionava muito bem. Resumidamente, a comunicação entre os programas se dá através de uma “pilha virtual”, acessada pelo programa em C. Cada elemento dessa pilha representa um valor de Lua, que pode ser utilizado em C através de funções de conversão como lua_tostring, ou lua_tonumber.

Até aí tudo bem. Alguns defeitos dessa interface começam a aparecer quando é preciso lidar com tipos de dados mais complexos, como tabelas em Lua, por exemplo. Abaixo está um trecho de czódigo em C para colocar uma tabela na pilha:

lua_newtable(L);
lua_pushstring(L,”indice1″);
lua_pushnumber(L,15);
lua_settable(L,2);
lua_pushstring(L,”indice2″);
lua_pushstring(L,”testedatabela”);
lua_settable(L,2);

Como é possível ver no código, é preciso dar um push no índice, outro push no valor e chamar a função lua_settable passando o índice da tabela na pilha como argumento para cada elemento. Para uma tabela com poucos elementos, não há complicações. O problema é quando esse procedimento precisa ser realizado para tabelas bem maiores.

Essa complicação toda me motivou a procurar como seria essa interface em outras linguagens. Acabei decidindo pesquisar uma solução em Python. Logo de cara já encontrei uma documentação muito mais clara e completa, e, no pouco tempo que passei estudando, tive a impressão de que a interface se dá de maneira bem mais simples. A função abaixo passa para o programa em Python um dicionário semelhante a tabela em Lua construída acima:

Py_BuildValue(“{siss}”,”indice1″,15,”indice2″,”testedatabela”);

A função Py_BuildValue é responsável pela comunicação com o código em Python. O funcionamento dela se dá através de strings de formatação, formadas por unidades de formatação que representam um objeto Python. Através dessas strings, é possível passar, sem maiores complicações, inteiros, strings, dicionários, listas e outros tipos de dados entre os programas em C e Python. Nesse exemplo, a string “{siss}” indica que o objeto Python gerado será um dicionário, e cada conjunto de dois valores em C consecutivos adiciona um item a esse dicionário.

Para mais detalhes, veja:
Lua/C API

Python/C API

Read Full Post »

Para quem usa Ubuntu já deve saber que a maioria das suas ferramentas administrativas são escritas em python.
Nessa distribuição quem desejar configurar mais de um monitor deve usar a ferramenta displayconfig-gtk, a qual foi adicionada na última versão da distribuição. Infelizmente quem usar esta ferramenta talvez não obtenha êxito na sua tarefa e não consiga configurar os dois monitores para funcionar da forma desejada. Uma pesquisa no google sobre dual head no linux aponta para uma página com uma solução relativamente simples. O conteúdo é para placa de video intel, mas deve funcionar para a maioria das placas de vídeo, uma vez que o material é bem genérico. O documento, o qual é mantido pela própria intel, pode ser encontrado aqui.

No entanto, a solução para dual head no ubuntu exige alteração no arquivo de configuração do servidor X, ou então manipulação através do software xrandr, via linha de comando. O XRandR (X Resize and Rotate extension) é uma extensão do servidor X que permite ao cliente alterá-lo dinamicamente. A opção adotando o xrandr é muito mais simples, rápida e não deixa bagunças como arquivos de configuração mal editados. Essa solução pode ser facilmente repetida e não exige direitos de administrador. O ideal para usuários novatos seria que a ferramenta displayconfig-gtk funcionasse como o esperado. A ferramenta é escrita em python e uma leve olhada no seu código mostra que na versão instalada no Ubuntu 7.10 não faz uso da biblioteca do xrandr. Pelo contrário, o displayconfig-gtk faz uso das bibliotecas do servidor X diretamente. O uso da biblioteca xrandr com certeza melhoraria o funcionamento do displayconfig-gtk já que ela funciona sem necessitar de arquivo de configuração ou restart do servidor X.

A página do projeto DisplayConfigGTK, no entanto, mostra que eles já estão fazendo a atualização da ferramenta para uso da biblioteca xrandr. Até o momento não existia nenhum bind do python para o xrandr e o pessoal da Canonical decidiu começar tal projeto também. O projeto chamado pyxrandr tem seu código disponível no launchpad, mantido pela Canonical, no seguinte link.

Um dos pontos interessantes no pyxrandr é que ele pode ser usado como ferramenta via linha de comando, como o xrandr, e também fornece a API do xrandr para desenvolvedores python. A “cola” da biblioteca python com a biblioteca xrandr foi feita diretamente com a biblioteca ctypes do python sem exigir uma camada intermediária em C com a Python/C API. O ctypes

será abordado em breve em outro post, para mostrar como é facil fazer a ligação Python-C sem ter que sair do alto nível da linguagem python.

Vamos então mostrar como podemos manipular o X através do python usando o pyxrandr.


from xrandr import xrandr

screen = xrandr.get_current_screen()
output = screen.get_output_by_name( 'default' )
modes = output.get_avaliable_modes()
newmode = [ (count,mode) for mode in enumerate(modes) if mode.name == "1024x768" ]
output.set_to_mode(newmode[0][0])
screen.apply_config()

Depois de importar o xrandr necessitamos pegar o screen atual para podermos manipular o X. O screen possui vários outputs, se você está utilizando um único monitor apenas um estará ativo, esse screen se chamará default. Na linha 1 e 2 do código acima estamos pegando o screen e o ouput default, respectivamente. O que pretendemos fazer nesse código é modificar a resolução do output default.

Cada output suporta vários modos de exibição. A resolução de 1024×768 pode ser exibida, por exemplo, em várias frequências diferentes. Para setar uma nova resolução deve-se usar o método set_to_mode do output em questão, no entanto, esse método recebe o índice do mode na lista de modes disponíveis. Essa parte é com certeza a parte mais complicada do código acima, mas para definir a resolução do output vários parâmetros são necessários como: atualização vertical, horizontal, frequência de atualização, resolução e etc. Acredito que a forma como o set_to_mode funciona adotada pela API do pyxrandr esteja certa. Através do método get_avaliable_modes uma lista de modes suportados pelo output são retornados, o que o programador deve fazer é pegar o índice do mode que ele quer usar. Para encontrarmos o novo objeto mode que desejamos, a linha 5 filtra os modes que possuem resolução de 1024×768 e pega o índice da primeira ocorrência para usar como parâmetro do set_to_mode. Essa linha contém uma list comprehension do python, mas ela também poderia ser feita com os famosos map e filter. As demais linhas setam de fato o novo modo de exibição e aplicam as configurações. É importante lembrar de aplicar as configurações, se não você não observará nenhuma modificação.

O pyxrandr fornece quase toda a API do xrandr, pelo que pude ver está completa, existem métodos para ativar mais de um output caso você tenha dois monitores ligados e também é possível configurar qual monitor esta acima, abaixo, à esquerda ou à direita do outro monitor. Não achei a documentação do projeto mas seu código é pequeno e conciso, a leitura do mesmo é bastante recomendada. Em breve, com certeza teremos o DisplayConfigGTK funcionando extremamente bem, sem precisar reiniciar o X ou fazer qualquer modificação em seus arquivos. Por enquanto, nós podemos brincar com o X e quem sabe até fazer softwares concorrentes ao DisplayConfigGTK. Se alguém topar ajudar no design e na parte gráfica da ferramenta começaremos outra.

Powered by ScribeFire.

Read Full Post »

Este blog é escrito por diversos autores que trabalham na mesma empresa. No momento da criação do blog surgiu a dúvida: “Ele será um planet e agregará os posts dos blogs de cada pessoa, ou todos nós postaremos no mesmo blog?”. A segunda opção foi a escolhida. Entretanto alguns de nós já possuiam blogs pessoais e queriam mantê-los assim, apenas importando alguns posts no Linil.

Como o blog é hospedado diretamente no wordpress não há a opção de instalar plugins e portanto não temos como usar um plugin de planet já feito. Diante dessa dificuldade surgiu a idéia de se criar uma ferramenta que fizesse o mecanismo de planet automaticamente, não exigindo o processo de exportar e importar posts manualmente.

O wordpress é uma excelente ferramenta e possui um servidor de xmlrpc que permite ao desenvolvedor acesso a uma API para manipulação remota do blog. Para ser mais exato o wordpress implementa um conjunto de APIs voltadas para a edição de blogs, são elas: WordPress API, Blogger API, MetaWeblog API e MovableType API. Essas APIs possuem vários métodos, alguns repetidos, mas se complementam de uma boa forma e tornam o wordpress melhor ainda. A MetaWeblog API possui métodos que também existem na Blogger API, no entanto, oferece dados mais detalhados. Um exemplo disso é que quando se puxa um post, através do método getPost de ambas, grande parte dos dados na Blogger API são retornados num único campo da resposta enquanto que no MetaWeblog API esses dados são enviados bem divididos em título, contéudo, autor e etc.

De posse de uma API de alto nível o trabalho ficou fácil e o algoritmo se resume basicamente a puxar os posts dos blogs e criar um novo no linil. Para tal vou mostrar de uma forma simples como é feito o acesso a API do wordpress. A linguagem de programação utilizada aqui é Python. O exemplo abaixo é apenas para ilustrar a facilidade de utilização da API e não tem por objetivo abranger toda a API suportada pelo wordpress. Uma excelente referência para os métodos das APIs suportadas pelo wordpress pode ser encontrado no endereço do sixapart.

Antes de começar é necessário importar o módulo do python que permite o uso do xmlrpc, e conectar-se ao servidor:


 import xmlrpclib
 server  =   xmlrpclib.ServerProxy( "http://seublog.wordpress.com/xmlrpc.php" )

Para ter acesso a algum post do blog é necessário apenas chamar o método getPost da seguinte forma:


 post = server.metaWeblog.getPost(iddopost , "seulogin", "suasenha" )

Pode-se perceber que foi usado o método getPost da MetaWeblog API. O primeiro parâmetro é o número do id do post, os demais são o login e senha exigidos para o acesso ao blog. Existem inúmeros métodos que permitem a total manipulação do blog, recomendo fortemente o estudo das APIs suportadas através do link acima do site sixapart, foi o melhor material que eu encontrei até o momento sobre o assunto. Durante o estudo dessa interface do wordpress decidi baixar o código do mesmo e ver de fato quais são as funções implementadas e como elas são implementadas, se você tiver tempo também recomendo a leitura, o código se encontra no arquivo xmlrpc.php.

O software que precisamos poderia ser facilmente implementado pegando posts de um blog através do getPost e inserindo em outro pelo método newPost. Entretanto, os blogs possuem mecanismos de feeds que são muito mais úteis para a extração do conteúdo dos posts e python contém uma boa biblioteca para leitura de feeds. A biblioteca feedparser é bastante simples mas também poderosa.

Segue um pequeno exemplo de como pegar os posts de um rss:


 import feedparser
 feed = feedparser.parse("https://linil.wordpress.com/feed/" )

O objeto feed possui diversos atributos, dentro eles o que nos interessa é o atributo entries, o qual é uma lista que possue todos os posts do feed. Nele os posts são dicionários python que contém todos os atributos de um post. Por exemplo, o título do primeiro post do blog pode ser lido em feed.entries[0].title.

Uma vez que todas as ferramentas necessárias já foram estudadas, é possível construir nosso próprio planet e de forma bastante simples. Basicamente o que resta fazer é monitorar o feed por atualizações e inserir-las no blog. Espero que o post tenha ajudado as pessoas que estão tentando implementar algo parecido e que também possa mostrar o quanto é simples escrever em python pequenas aplicações que se tornam necessárias no dia-a-dia.

Read Full Post »

« Newer Posts

Design a site like this with WordPress.com
Get started