Selecionar camada no blender

Incluir a seguinte função:

def selectLayer(layer): 

    layers = [False] * 20 

    layers[layer - 1] = True 

    bpy.context.scene.layers = layers 

E no código:

selectLayer(20)

 Referência.

Posição do mouse via python, no Ubuntu

Utilizei a biblioteca Xlib para pegar as coordenadas x e y do mouse:

from Xlib import X, display
import time

d = display.Display().screen().root.query_pointer()._data

print ("x="+str(d["root_x"]))
print ("y="+str(d["root_y"]))

Lembrando de instalar via apt-get:

sudo apt-get install python-xlib

Referência.

Verificador de emails não lidos

No site de aprendizado da Sparkfun está disponível um tutorial de como fazer um verificador de emails não lidos utilizando a placa Galileo.

No tutorial, é utilizado um display de 7 segmentos para apresentar o número de emails não lidos e pode-se também escolher fazer a conexão na rede via wi-fi ou via cabo.

Alterei algumas partes do código original para que eu pudesse utilizar um display lcd ao invés de um display de 7 segmentos para, quem sabe, futuramente incrementar as funcionalidades deste código.

Os componentes necessários para este tutorial são:

• 1x Placa Intel® Galileo
• 1x Display LCD 16x2
• 1x potenciômetro
• 1x Cabo de rede
• 1x Cartão µSD

O diagrama da montagem com o LCD está apresentado na imagem a seguir:

Sugestão de ligação do display LCD

A montagem acima é da seguinte forma:

• Conectores DB4-DB7 do display ligados nos pinos A2-A5 da Galileo
• Conector RS do display ligado no pino A0 da Galileo
• Conector E (Enable) do display ligado no pino A1 da Galileo
• Conector V0 do display ligado no conector central do potenciômetro
• Conector VSS e conector R/W do display ligados em um conector não-central do potenciômetro curto-circuitado com Gnd da Galileo
• Conector VDD ligado ao conector restante do potenciômetro curto-circuitado com o pino de 5V da Galileo

Com esta ligação será possível apresentar no display a contagem de emails não lidos e qualquer mensagem que queiramos apresentar. O potenciômetro tem a função de controlar o 'alfa' do display.

Para realizar o tutorial é necessário que a Galileo esteja com o firmware atualizado e com o sistema linux instalado no cartão µSD, de acordo com os passos 3 e 4 destas recomendações.

Inclua o seguinte código em um arquivo python na raiz do cartão µSD que tem o linux instalado com o nome de pyMailCheck.py:

# pyMailCheck.py - Loga no seu gmail e imprime o numero de emails nao lidos.
# Coloque este arquivo na raiz do cartao SD da Galileo.
 
import imaplib  # Usado para conectar em um servidor IMAP4.
obj = imaplib.IMAP4_SSL('imap.gmail.com', '993')  # Conecta em um servidor IMAP4 com SSL, porta 993
obj.login('my_email_address@gmail.com','myPassword')  # Identifica o usuário e senha do cliente
obj.select()  # Seleciona o 'INBOX'  (parametro default)
# Procura na caixa de email o charset no (None), criterio:"UnSeen" (nao visto). Retornara uma tupla, pega a segunda parte,
# divide cada string em uma lista e retorna o tamanho desta lista:
print len(obj.search(None,'UnSeen')[1][0].split())

Altere o código acima colocando suas informações de e-mail e insira o cartão SD no slot da Galileo, ligue-a na fonte de energia e em seguida ao computador para fazer upload do código a seguir:

/* Galileo Email Checker
   by: Jim Lindblom
       SparkFun Electronics
   date: January 7, 2013
   license: Beerware. Please use, reuse, and modify this code.
   If you find it useful, you can buy me a beer when we meet.
   
   This code connects a Galileo to Ethernet. Then runs a Python script
   - https://gist.github.com/jimblom/8292444#file-pymailcheck-py -
   that lives on the Galileo's SD card to check how many unread
   emails you have. That number is displayed on an OpenSegment
   Shield - https://www.sparkfun.com/products/11846 - which is
   controlled over SPI.
   
   Editado para funcionar com uma shield LCD por Rodrigo Monteiro
*/
/////////////////////////////
// Inclusao de bibliotecas //
////////////////////////////

//Biblioteca do LCD
#include <LiquidCrystal.h>

#include <SD.h> // Biblioteca SD para ler o arquivo temporario
                // onde o script em python armazena o contador de emails nao lidos.
#include <Ethernet.h> // Biblioteca Ethernet 



// Inicializa a biblioteca com o numero dos pinos de interface
LiquidCrystal lcd(A0, A1, A2,A3, A4, A5);

////////////////////////////
// Definicoes de Ethernet //
///////////////////////////
byte mac[] = {0x6A, 0x11, 0x1l, 0x30, 0x12, 0x34};

///////////////////////////
// Definicoes de pinagem //
//////////////////////////
const int STAT_LED = 13; // The Galileo's status LED on pin 13

/////////////////////////////////////////////
// Variaveis globais de checagem de emails //
/////////////////////////////////////////////
const int emailUpdateRate = 10000; // Taxa de update em ms (10 s)
long emailLastMillis = 0; // Armazena o ultimo instante de checagem de email
int emailCount = 0; // Armazena a ultima contagem de email

// setup() inicializa o lcd, o SD card, e o Ethernet
// Se bem sucedido, o led de status se ligara.
void setup() 
{
  pinMode(STAT_LED, OUTPUT);
  digitalWrite(STAT_LED, LOW);

  Serial.begin(9600); // Monitor Serial para debug
 
  
  // Declara o numero de linhas e colunas do LCD: 
  lcd.begin(16, 2);
  lcd.print("Emails nao lidos");
  lcd.setCursor(1, 1);

  
  initSDCard();  // Inicializa a classe SD
  
  if (initEthernet() == 1) // Se a Ethernet conectar, acende o LED de status
    digitalWrite(STAT_LED, HIGH);
  else
  { // Se a conexao Ethernet falhar, imprima erro, loop infinito
    //SPIWriteString("----", 4);
    
    lcd.print("Erro de rede");
    lcd.setCursor(1, 1);
    
    while (1)
      ;
  }
}

// loop() checa pelo contador de emails nao lidos a cada emailUpdateRate
// mili segundos. Se o contador mudou, atualiza o display.
void loop() 
{
  // Apenas cheque o email se passou emailUpdateRate ms 
  if (millis() > emailLastMillis + emailUpdateRate)
  {
    emailLastMillis = millis(); // atualiza emailLastMillis
    
    // Obtem o contador de emails nao lidos e armazena em uma variavel temporaria
    int tempCount = getEmailCount(); 
    Serial.print("Voce tem ");
    Serial.print(tempCount);
    Serial.println(" emails nao lidos.");
    if (tempCount != emailCount) // Se e um valor diferente, atualize
    { // Faca isso para evitar piscar o mesmo numero
      emailCount = tempCount; // atualize a variavel emailCount
      lcd.print(emailCount); // imprima o contador de nao lidos
      lcd.setCursor(1, 14);
    }
  }
  
  // Bit de protecao no caso de overrun de millis:
  if (millis() < emailLastMillis)
    emailLastMillis = 0;
}


// getEmailCount executa o script pyMail.py , e le a saida.
// Ira retornar o valor impresso pelo script python.
int getEmailCount()
{
  int digits = 0;
  int temp[10];
  int emailCnt = 0;

  // Envia uma chamada de sistema para executar o script python e rotear a 
  // saida desse script para um arquivo.
  system("python /media/realroot/pyMailCheck.py > /media/realroot/emails");

  File emailsFile = SD.open("emails"); // Abre email para leitura

  // le dos emails ate que se atinja o final ou uma nova linha
  while ((emailsFile.peek() != '\n') && (emailsFile.available()))
    temp[digits++] = emailsFile.read() - 48; // Converte de ASCII para um numero
    
  emailsFile.close(); // fecha o arquivo de email
  system("rm /media/realroot/emails"); // remove o arquivo de emails
  

  // Transforma um numero individual em um inteiro de digito simples
  for (int i=0; i<digits; i++)
    emailCnt += temp[i] * pow(10, digits - 1 - i);
  
  return emailCnt;
}


// initSDCard() inicia a classe SD
void initSDCard()
{
  SD.begin();
}

uint8_t initEthernet()
{
  if (Ethernet.begin(mac) == 0)
    return 0;
  else
    return 1;
}

Ligue o cabo de rede na porta ethernet da placa Galileo e em um roteador com internet e após alguns segundos pode-se verificar a contagem de emails não lidos:

Verificador funcionando

Configurações 3D utilizando Blender

    O objetivo do post é expôr a minha solução para sobrepor duas cenas diferentes em uma aplicação 3D no Blender. Neste caso a camada inferior é um vídeo já em 3d (lado a lado) e a camada superior é um game que deveria ser adaptado em 3D, para que houvesse um casamento entre os efeitos.

Imagem 1: Vídeo 3D lado a lado e game sobreposto

    Após alguns testes com a aplicação direta do plugin do desenvolvedor noeol, sendo este código sendo usado juntamente com o controle add overlay scene do blender obtive um certo sucesso com a cena do game ficando 3d juntamente com o video. No entando, neste game o cursor colorido atira o projétil para "dentro" da tela, e este efeito estava completamente errado na aplicação que fiz.

Imagem 2: Controles para sobrepor a cena 'game' na cena principal

    A solução do problema foi alcançada com a aplicação de viewports, que dividem a cena verticalmente (ou horizontalmente) de modo que cada câmera que filma o game seja exibida em exatamente metade da tela.

Imagem 3: Blocos lógicos para o viewport

    Para o vídeo usado o viewport foi aplicado com uma divisão vertical, e deste modo, o efeito 3D do game foi alcaçado pois cada visão do game foi colocada em cima da metade do vídeo, de modo que quando uma tv compatível fizer a composição das imagens o game também ficará em 3D.

Imagem 4: Cursores duplicados, compatíveis com o vídeo

 
    O código utilizado para configurar os viewports foi obtido aqui, referente a este vídeo.

Movimentação de Objetos por script

Tutorial muito bom para aprender a programar scripts em python para Blender:
http://www.cgmasters.net/free-tutorials/python-scripting/