Transformar imagens coloridas em P&B com Python


Olá,

Neste post será abordado como converter imagens PNG em JPEG, e também transformar as imagens coloridas em escala de cinza, ou seja, em preto-e-branco.

Com uma ou poucas imagens, abrir programas gráficos como o GIMP ou Adobe Photoshop, não seria tão trabalhoso abrir uma a uma, alterar o esquema de cores e alterar o formato dos arquivos conforme necessidade. Mas quando são centenas e até milhares de imagens, este processo manual, além de demorado, se torna cansativo.

Para contornar o problema acima descrito, desenvolvi um pequeno script em Python que converte as imagens PNG para JPEG, e também converte as imagens para P&B.

Sem mais delongas, segue o pequeno script:

Download

Código

__author__ = "elexsandro"
__date__ = "$31/12/2014 12:59:21$"

from PIL import Image
import glob, os

def convertToGrayScale(path, grayfilename):
    try:
        # abre a imagem na escala de cinza
        im = Image.open(path).convert("L")
        # salva a imagem
        print 'Salvando a imagem:', grayfilename
        im.save(grayfilename)
    except:
        print 'Erro ao converter a imagem'

# Modulo principal
if __name__ == "__main__":
    # Armazena o caminho informado na variavel d
    d = raw_input('Informe o diretorio de imagens:')
    
    if not os.path.exists(d):
        raise Exception('O diretorio informado nao existe')
        
    # 'Navega' ao diretorio informado
    os.chdir(d)
    # os.path.abspath(os.curdir) tambem retorna o diretorio corrente
    print 'Diretorio corrente:', os.getcwd()

    print 'Convertendo as imagens PNG para JPEG'
    for fn in glob.glob('*.png'):
            print 'Convertendo %s para PNG', fn
            # obtem o nome do arquivo sem a extensao
            f = glob.os.path.splittext(fn)[0]
            # Abre a imagem
            imagem = Image.open(fn)

            # obtem o nome do arquivo sem a extensao
            f = glob.os.path.splittext(fn)[0]
            imagem.save(f + '.png', 'PNG')
            print f +'.png salvo com sucesso.'

    # Cria o diretorio para armazenar as imagens P&B
    os.mkdir('GrayImages')
    
    # Convertendo todas as imagens JPEG para escalas de cinza
    for fn in glob.glob('*.jpg'):
            print 'Processando:', fn

            # obtem o nome do arquivo sem a extensao
            f = glob.os.path.splitext(fn)[0]

            # Converte a imagem escala de cinza e salva no diretorio GrayImages
            convertToGrayScale(fn, 'GrayImages/' + f + '_gray.jpg')

    print 'Concluido'

Até a próxima.

Anúncios

Introdução ao ActionScript 3.0


Vantagens do ActionScript 3.0
O ActionScript 3.0 vai além dos recursos de script de suas versões anteriores. Ele foi criado para facilitar a criação de
aplicativos altamente complexos com grandes conjuntos de dados e bases de código reutilizáveis orientadas a objetos.
Embora o ActionScript 3.0 não seja necessário para o conteúdo executado no Adobe Flash Player, ele permite
melhorias de desempenho que só estão disponíveis com a AVM2, a nova máquina virtual. O código do ActionScript
3.0 pode ser executado até 10 vezes mais rápido do que o código do ActionScript existente.
A versão antiga da AVM1 (ActionScript Virtual Machine) executa os códigos ActionScript 1.0 e ActionScript 2.0. As
versões 9 e 10 do Flash Player oferecem suporte a AVM1 para compatibilidade com conteúdo existente e herdado de
versões anteriores. Continue lendo “Introdução ao ActionScript 3.0”

Linguagem e sintaxe do ActionScript – Parte 1


O ActionScript 3.0 consiste na linguagem central do ActionScript e na API (Application Programming Interface) do Adobe Flash Player. A linguagem principal é a parte do ActionScript que define a sintaxe da linguagem, assim como os tipos de dados de nível superior. O ActionScript 3.0 oferece acesso programático ao Flash Player.
Este post apresenta uma breve instrução à linguagem e sintaxe centrais do ActionScript. Depois de lê-lo, você terá uma noção básica de como trabalhar com tipos de dados e variáveis, como usar a sintaxe apropriada e como controlar o fluxo de dados no seu programa. Continue lendo “Linguagem e sintaxe do ActionScript – Parte 1”

Introdução do ActionScript


Olá galera, hoje darei continuação ao tutorial de actionscript, começandocom um pouco de fundamento da programação;

Fundamentos de programação

Como o ActionScript é uma linguagem de programação, para conhecê-lo, primeiro é necessário compreender alguns conceitos gerais de programação de computador. Continue lendo “Introdução do ActionScript”

Introdução do ActionScript 3.0


Olá galera, hoje vou começar com alguns posts de actionscript 3.0, espero que lhes sejam úteis.

O ActionScript é a linguagem de programação dos ambientes de tempo de execução Adobe® Flash® Player e Adobe® AIR™.
Ele permite interatividade, manipulação de dados e muito mais no conteúdo e nos aplicativos do Flash, Flex e AIR.
O ActionScript é executado com a AVM (ActionScript Virtual Machine), que faz parte do Flash Player e do AIR. O
código do ActionScript em geral é compilado no formato de código de bytes (um tipo de linguagem de programação
escrita e entendida por computadores) por um compilador, como o criado no Adobe® Flash® CS4 Professional ou no
Adobe® Flex™ Builder™ ou como o disponível no Adobe® Flex™ SDK. O código de bytes é incorporado aos arquivos
SWF, que são executados pelo Flash Player e pelo AIR. Continue lendo “Introdução do ActionScript 3.0”

Obendo informações sobre os adaptadores de rede


Utilizando os recursos da plataforma .NET podemos entre muitas outras coisas obter as informações sobre os adaptadores de rede que estão concectados à nossa máquina.
Para obter informações sobre as interfaces de rede que estão conectadas à máquina local o namespace System.Net.NetworkInformation fornece acesso fácil as informações sobre a rede, configurações e estatísticas,
O método estático NetworkInterface.GetAllNetworkInterfaces, retorna uma matriz de objetos NetworkInterface. Cada objeto representa uma única interface de rede na máquina local, onde você então pode obter informações de rede e estatísticas da interface em questão.
Exemplo:
 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.NetworkInformation;
using System.Text;
using System.Threading.Tasks;

namespace CSharpNetwork
{
class Program
{
static void Main(string[] args)
{
// Verifica se existe alguma interface disponível
if (NetworkInterface.GetIsNetworkAvailable())
{
// Obtém todas as interfaces da máquina local
NetworkInterface[] interfaces = NetworkInterface.GetAllNetworkInterfaces();

foreach (NetworkInterface ni in interfaces)
{
// Informações básicas

// Nome da interface
Console.WriteLine("Nome da Interface: {0}", ni.Name);

// Obtém a descrição geral da interface
Console.WriteLine("Descrição: {0}", ni.Description);
// Identificador da interface
Console.WriteLine("Id: {0}", ni.Id);

// Obtém o valor do enumerador System.Net.NetworkInformation.NetworkInterfaceType
// que identifica o tipo da interface (Ethernet, FastEthernetT, LoopBack
Console.WriteLine("Tipo: {0}", ni.NetworkInterfaceType);

// Velocidade (bits por segundo)
Console.WriteLine("Velocidade: {0}", ni.Speed);

// Indica se a interface está ativa
Console.WriteLine("Status: {0}", ni.OperationalStatus);

// Indica se a interface somente recebe dados ou envia
// e recebe dados.
Console.WriteLine("Somente Recebe Dados: {0}", ni.IsReceiveOnly);


// Informações de endereçamento
Console.WriteLine("Endereço Físico (MAC): {0}", ni.GetPhysicalAddress().ToString());


Console.WriteLine("Endereços IP:");
foreach (var addr in ni.GetIPProperties().UnicastAddresses)
{
Console.WriteLine("             -IP: {0}, Máscara: {1}, Expira em: {2}",
addr.Address, addr.IPv4Mask, DateTime.Now + new TimeSpan(0, 0, (int)addr.DhcpLeaseLifetime));
}
// Estatísticas da interface
Console.WriteLine("Bytes enviados: {0}", ni.GetIPv4Statistics().BytesSent);
Console.WriteLine("Bytes recebidos: {0}", ni.GetIPv4Statistics().BytesReceived);
}

Console.ReadKey();
}
else
{
// Nâo existem nenhuma interface de rede disponível....
}
}
}
}

Até a próxima.

Monitorando arquivos via programação


Neste post mostrarei como monitorar arquivos e diretórios utilizando os recursos que a plataforma .NET oferece.

Para iniciar, vamos criar um novo projeto Console Application no Visual Studio.

Dê um nome para este projeto, no meu caso eu chamei de VigiaArquivos.

A nível didático iremos monitorar a criação, alteração e deleção de arquivos de texto que estão dentro de uma determinada pasta do usuário.

Importe o namespace System.IO com a seguinte instrução:

using System.IO;

Isto permitirá utilizar as classes que trabalham com arquivos e diretórios, onde é possível criar novos, alterar, remover e assim por diante, mas neste post vamos trabalhar com a classe FileSystemWatcher  ajustando a propriedade Path para informar o caminho do diretório  e a propriedade Filter que irá definir quais extensões de arquivos será monitorado. Continue lendo “Monitorando arquivos via programação”