Problema com libglew1.10 instalando o cliente do Runescape no Linux

Seguindo o passo a passo da instalação do Runescape no Linux, tive o seguinte problema:

......
Os pacotes a seguir têm dependências desencontradas:
runescape-launcher : Depende: libglew1.10 (>= 1.10.0-3) mas não é instalável
E: Impossível corrigir problemas, você manteve (hold) pacotes quebrados.

A solução foi remover a versão instalada do libglew1.X e instalar ele manualmente na versão 1.10. Para isso:

  1. Remova o pacote que tem no seu PC: sudo apt-get remove libglew1.*
  2. Baixe e instale (dando dois cliques no arquivo mesmo) a versão 1.10 de um dos repositórios a seguir: https://packages.ubuntu.com/trusty/amd64/libglew1.10/download
  3. Instale novamente o launcher: sudo apt-get install -y runescape-launcher 
Útil(0)Desprezível(0)

Instalação e utilização de ambientes virtuais no Windows

Este tópico tem como objetivo guiar a instalação e criação de ambientes virtuais (virtualenv) no Windows.

Considerando que você já tem o Python instalado, bem como as variáveis de ambiente e o “pip”, siga o procedimento a seguir.

– Instalar pacote para criação de ambientes virtuais
pip install virtualenv

– Instalar pacote para gerenciamento dos ambientes virtuais
pip install virtualenvwrapper-win

– Crie um ambiente virtual
mkvirtualenv nome_do_ambiente

– Ative o ambiente virtual recém criado
workon nome_do_ambiente

Pronto. Agora é só instalar os pacotes que deseja ter nesse ambiente virtual que você acabou de criar e ativar. Você pode ter quantos ambientes desejar e eles, por padrão, ficam dentro no diretório Envs dentro da pasta do usuário. Por exemplo: C:\Users\rafael\Envs

O procedimento a seguir serve para instalação do Django e de mais três coisas úteis para ele: o bootstrap, o braces para controle de acesso e o crispy-forms para geração de formulários conforme os padrões do bootstrap. Não esqueça de ativar o ambiente virtual que você deseja instalar os pacotes: workon nome_do_ambiente.

– Instalação dos pacotes no ambiente virtual desejado.
pip install django
pip install django-bootstrap4
pip install django-braces
pip install django-crispy-forms

Útil(0)Desprezível(0)

Concatenar/juntar data e texto no LibreOffice Calc

Você tem algumas células do Calc com datas e quer concatená-las com texto, mas quando faz isso aparece um número no lugar da data.

É simples, basta converter a célula da data em texto e especificar o formato. Por exemplo:

=CONCAT( A1; " - "; TEXTO(B1, "DD/MM/YYYY") )

Considerando que A1 é o texto e B1 a data que você quer juntar.

Útil(5)Desprezível(2)

Resolvendo o problema do Windows 10 com disco 100% de uso desativando o processo Microsoft Office Click to Run

Meu computador com o Microsoft Windows 10 estava com 100% da utilização do disco sempre que ligava. Procurei vários tutoriais na Internet, mas o problema ainda insistia.

Já tentei várias coisas, como: aquele comando RestoreHealth, desativar paginação, limpar a inicialização de arquivos, excluir arquivos temporários, pontos de restauração e por aí vai. Porém, o problema do disco 100% ainda insistia.

Então notei um processo do Microsoft Office chamado Click To Run e resolvi desativá-lo. Pronto, problema do disco 100% resolvido!

Para desativar o Microsoft Office Click To Run procure no menu iniciar por “cmd“, clique com o botão direito e vá em “Executar como administrador“. Digite os três próximos comandos para parar, desativar e excluir o serviço:

sc stop "ClickToRunSvc"

sc config "ClickToRunSvc" start=disabled

sc delete "ClickToRunSvc"

Não precisei reiniciar e máquina e cerca de um minuto depois disso o disco voltou ao normal:

Útil(24)Desprezível(2)

Erro 0x80041023 ao ativar o Windows 10

Recentemente tentei ativar o Windows 10 de uma máquina nova com a chave de um PC antigo que tinha atualizado do Windows 8 para o 10 gratuitamente.

A mensagem de erro era: “A chave do produto (Product Key) inserida não funcionou. Verifique-a e tente novamente, ou use outra. (0x40041023)”.

Entrei em contato com o suporte da Microsoft e a resposta foi que a chave do Windows 10 fica restrita àquele computador que recebeu o update.

Útil(6)Desprezível(16)

Tutorial para Atualizar Django na Kinghost

Aleluia!

Começo este post com esta palavra porque deu muito trabalho conseguir (está certo que sou iniciante). Vou colocar aqui alguns passos pra você que deseja atualizar a versão no Django na sua hospedagem Kinghost.

No final do tópico deixei algumas referências que usei para construir este tutorial. O que fiz foi pegar a ideia de vários lugares, juntar tudo e fazer funcionar.

No momento, estou usando o Django versão 1.9.4. Vamos lá:

Primeiro crie o diretório .site-packages dentro de /home/usuário/app_wsgi/

cd apps_wsgi/ (se ela não existe, crie com o mkdir)
mkdir .site-packages
easy_install --install-dir=$PYTHONPATH virtualenv

Agora vamos criar um diretório para armazenar seu ambiente virtual. Crie a pasta .virtualenvs/ na raiz da sua hospedagem (/home/usuário/) e depois o ambiente. O ambiente virtual serve para você instalar versões de pacotes diferentes das atuais. Você pode ter vários ambientes virtuais instalados, cada um isolado do outro com suas versões de pacotes e aplicativos.

mkdir .virtualenvs
python apps_wsgi/.site-packages/virtualenv .virtualenvs/NOME_DO_AMBIENTE_VIRTUAL

Ative o ambiente para começar a instalar seus pacotes.

source .virtualenvs/NOME_DO_AMBIENTE_VIRTUAL/bin/activate

Até aqui, todo o conteúdo é original do https://gist.github.com/douglasmiranda/1232693.

Agora o nome do seu ambiente virtual vai aparecer entre parênteses no começo da linha. Isso quer dizer que você está usando seu ambiente virtual.

(SEU_AMBIENTE_VIRTUAL)14:51 ~ $ which pip
~/.virtualenvs/djpy/bin/pip

Agora sabemos que o pip usado é do ambiente virtual. Instale o Django na versão que preferir:

pip install django==1.9.4

Para verificar se foi instalado corretamente (meu ambiente virtual chama-se djpy) e qual a versão está instalada:

(djpy)-bash-4.1$ which django-admim.py
/usr/local/bin/django-admin.py
(djpy)-bash-4.1$ which django-admin
~/.virtualenvs/djpy/bin/django-admin

(djpy)-bash-4.1$ django-admin.py --version
1.8.3
(djpy)-bash-4.1$ django-admin --version
1.9.4

Repare que se eu colocar o .py no final do comando faz total diferença sobre o que você pretende fazer.

Crie seu projeto pelo painel administrativo da KingHost. Ele deve aparecer na pasta /home/usuário/app_wsgi/SEU_PROJETO. Agora você tem a pasta e um arquivo chamado /home/usuário/app_wsgi/SEU_PROJETO.wsgi.

Agora exclua seu projeto vazio e depois crie ele novamente com o mesmo nome na versão correta (cuidado com o .py):

(djpy)-bash-4.1$ rm -R SEU_PROJETO/
(djpy)-bash-4.1$ django-admin startproject SEU_PROJETO

Altere o conteúdo do arquivo SEU_PROJETO.wsgi para (lembrando que só coloquei maiúsculas para facilitar a visualização):

import os, sys

apache_configuration = os.path.realpath(os.path.dirname(__file__))
project = os.path.join(apache_configuration, 'SEU_PROJETO')

sys.path.append(apache_configuration)
sys.path.append(project)
sys.path.insert(0, "/home/usuário/.virtualenvs/SEU_AMBIENTE_VIRTUAL/lib/python2.7/site-packages")

os.environ['PYTHON_EGG_CACHE'] = '/home/usuário/apps_wsgi/.python-eggs'
os.environ['DJANGO_SETTINGS_MODULE'] = 'SEU_PROJETO.settings'

from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()

Use o comando touch para “recarregar” seu projeto no seu servidor:

(djpy)-bash-4.1$ touch SEU_PROJETO.wsgi

A fim de que os arquivos JS e CSS da admin do Django sejam servidos corretamente, você deverá configurar o parâmetro STATIC_ROOT (settings.py):

STATIC_ROOT='/home/usuário/www/static'
STATIC_URL='/static/'

Execute os comandos a seguir para coletar o conteúdo e recarregar a aplicação:

(djpy)-bash-4.1$ python manage.py collectstatic
(djpy)-bash-4.1$ touch familia.wsgi

Agora envie seu projeto usando um cliente FTP para a pasta /apps_wsgi/SEU_PROJETO/

Depois, sempre execute os comandos a seguir para coletar arquivos estáticos necessários e para recarregar a aplicação (dentro do diretório /home/usuário/apps_wsgi):

(djpy)-bash-4.1$ python manage.py collectstatic
(djpy)-bash-4.1$ touch SEU_PROJETO.wsgi

Lembre-se de sempre ativar o ambiente virtual desejado (para executar os comandos citados acima):

$ cd /home/usuário/apps_wsgi/
$ source .virtualenvs/NOME_DO_AMBIENTE_VIRTUAL/bin/activate

Referências: Suporte da Kinghost
https://gist.github.com/douglasmiranda/1232693
https://help.pythonanywhere.com/pages/VirtualEnvForNewerDjango

Útil(1)Desprezível(0)

Transformada de Fourier

A ideia é criar uma bola no centro de uma imagem e considerá-la que está no domínio da frequência. Após isso, a Transformada Inversa de Fourier foi calculada para voltar ao domínio espacial e a imagem resultante pode ser vista no final deste post.

# -*- coding: utf-8 -*-
"""
@author: Rafael Zottesso
"""

import numpy as np
import cv2

# Cria uma imagem de 300 linhas com 300 colunas dentro de cada linha
t = 300
img = np.zeros((t,t,1), np.uint8)

# Posição do centro da imagem
x = y = int(t/2)
# Tamanho do raio do círculo
raio = 30

# Cria um array de índices com base no tamanho da imagem
I,J=np.meshgrid(np.arange(img.shape[0]),np.arange(img.shape[1]))

# Calcula a distância dos pontos com o centro (euclidiana)
dist=np.sqrt((I-x)**2+(J-y)**2)

# Coloca a intensidade 255 nos pontos onde a distância é menor que o raio
img[np.where(dist<raio)]=255

# Faz a transformada inversa de Fourier na imagem com o círculo no centro
img_fourier = np.fft.fftshift(img)

# Mostra a imagem original e a resultante
# Parâmetros: nome da janela, matriz
cv2.imshow('Resultado',img)
cv2.imwrite('./Imagens/bola.png', img)

cv2.imshow('Fourier',img_fourier)
cv2.imwrite('./Imagens/bola_Fourier.png', img_fourier)

# Funções mostrar as janelas com as imagens
cv2.waitKey(0)
cv2.destroyAllWindows()

Imagens Resultantes

# Imagem gerada com círculo no centro, no domínio da frequência

bola

# Imagem após a Transformada Inversa de Fourier

bola_Fourier

Útil(1)Desprezível(0)

Convolução e Correlação

Este código faz a Correlação em uma imagem com uma máscara simples de pesos 1 e tamanho 3×3. É possível ver que a imagem resultante da convolução teve um leve “borramento”.

O tempo de execução do algoritmo para aplicar a máscara simples foi de 2.331 segundos. Com a imagem “percorrendo” a máscara, o tempo foi de 0.00454 segundos. Desta última forma, há maneiras implícitas de executar um for para percorrer algumas linhas e colunas da imagem, o que ajuda a tornar o processo muito mais rápido.

# -*- coding: utf-8 -*-
"""
@author: Rafael Zottesso
"""

# Apenas para contagem de tempo
import timeit

# Outros imports necessários
import numpy as np
import cv2

# Cria uma função para fazer a correlação simples, movendo a máscara sobre a imagem
def correlacao_comum(img, img_corr, mascara):

 # Percorre cada pixel da imagem
 for x in range(img.shape[0]):
 for y in range(img.shape[1]):

 # Usa o try porque algumas coordenadas não existem, assim não apresenta o erro. As bordas não estão sendo consideradas.
 try:
 
 # Cálculo da máscara coluna a coluna: multuplica o peso que está na máscara pela intensidade do pixel

 ### Máscara simples, primeira coluna ##
 m = img[x-1][y+1] * mascara[0][0]
 m += img[x-1][y] * mascara[1][0]
 m += img[x-1][y-1] * mascara[2][0]

 # Segunda coluna
 m += img[x][y+1] * mascara[0][1]
 m += img[x][y] * mascara[1][1]
 m += img[x][y-1] * mascara[2][1]
 
 # Terceira coluna
 m += img[x+1][y+1] * mascara[0][2]
 m += img[x+1][y] * mascara[1][2]
 m += img[x+1][y-1] * mascara[2][2]

 # Faz a média dos valores e guarda como intensidade do pixel
 img_corr[x][y] = m/9

 # Quando a coordenada não existir, passe para o próximo pixel
 except:
 continue

 return img_corr

# Função com a imagem percorrendo a máscara (contrário da outra)
def correlacao_rapida(img, img_corr, mascara):

 # criando uma nova imagem = tamanho da imagem + bordas da mascara
 img_corr_rap = np.zeros(np.array(img.shape) + np.array(mascara.shape) - 1)

 # Percorre a máscara
 for x in range(mascara.shape[0]):
 for y in range(mascara.shape[1]):

 # Copia os valores para a imagem nova, que é maior para armazenar o cálculo
 img_corr_rap[x:x+img.shape[0], y:y+img.shape[1]] += img * mascara[x,y]

 return img_corr_rap.astype('uint8')

# imread ( nome da imagem, [1=cor, 0=grayscape, -1=alpha])
# Cada coluna da imagem é armazenada em um subvetor, onde cada coluna é uma posição
img = cv2.imread('./Imagens/original.jpg', 0)

# Abre a imagem novamente para comparar com a original
img_corr = cv2.imread('./Imagens/original.jpg', 0)

# Cria uma máscara simples com o mesmo peso
mascara = np.array([ [1,1,1], [1,1,1], [1,1,1] ])

################### Comum ################
# Verifica o horário inicial da convolução
time_start = timeit.default_timer()

# Executa a função de correlação
img_corr_comum = correlacao_comum(img, img_corr, mascara)

# Verifica o tempo final da convolução
time_end = timeit.default_timer()

# Apresenta a duração do processo de convolução
time = time_end - time_start
print 'Tempo de processamento Comum:', time, 'segundos'

################ Rápida #######################

# Verifica o horário inicial da convolução
time_start = timeit.default_timer()

# Executa a função de correlação
img_corr_rapida = correlacao_rapida(img, img_corr, mascara)

# Verifica o tempo final da convolução
time_end = timeit.default_timer()

# Apresenta a duração do processo de convolução
time = time_end - time_start
print 'Tempo de processamento Rápida:', time, 'segundos'


# Mostrar imagem
# nome da janela, matriz
cv2.imshow('Original',img)

cv2.imshow('Correlação Másc. Simples',img_corr_comum)
cv2.imwrite('./Imagens/original_corr.jpg', img_corr_comum)

# Funções para funcionamento correto ao mostrar a imagem numa janela
cv2.waitKey(0)
cv2.destroyAllWindows()

Imagens resultantes

# Imagem original

original

# Após a convolução com a máscara imples

original_conv

Útil(3)Desprezível(3)

Colorindo uma imagem com uma paleta de cores HSI

Dada uma imagem em tons de cinza, a ideia é definir uma cor (inicial) para representar o preto e outra (final) para representar o branco. Em seguida, criar uma paleta de cores HSI que varia da cor inicial até a final e aplicar estas cores na imagem original.

Para realizar este trabalho, foram utilizados os pacotes NumPy e OpenCV. O código está todo comentado e no final do post é possível ver as imagens resultantes.

# -*- coding: utf-8 -*-
"""
@author: Rafael Zottesso
"""

import numpy as np
import cv2

# Função para gerar a peleta de cores com um início e fim de cor
def gerar_paleta(inicio, fim, sv):

	# Função: np.linspace(A, B, X)
	# Descrição: gera um vetor com X valores entre A e B.
	h = np.linspace(inicio, fim, 256)
	s = np.linspace(sv, sv, 256)
	i = np.linspace(sv, sv, 256)
	    
	# Função: a.reshape(alt, largura)
	# Descrição: Da uma nova forma a uma lista. Neste caso, criamos uma altura de 256 e 1 de largura
	# Função: np.tile(array, X)
	# Descrição: Repete um array X vezes. Aqui, repetindo o mesmo valor no eixo da largura para ficar com 256 de largura    
	p1 = np.tile( h.reshape(256,1), 256 )
	p2 = np.tile( s.reshape(256,1), 256 )
	p3 = np.tile( i.reshape(256,1), 256 )
	   
	# Função: np.uint8(num)
	# Descrição: converter números para 8 bits
	p1 = np.uint8(p1)
	p2 = np.uint8(p2)
	p3 = np.uint8(p3)
	    
	# Função: np.dstack( (v1, v2) )
	# Descrição: Faz a concatenação dos dois vetores, por exemplo.
	paleta = np.dstack( (np.dstack( (p1,p2) ), p3) )
	        
	return paleta

# Gera a paleta de cores considerando que o HSI está sendo usado
paleta = gerar_paleta(120, 240, sv=200)

# imread ( nome da imagem, [1=cor, 0=grayscape, -1=alpha])
# Cada coluna da imagem é armazenada em um subvetor, onde cada coluna é uma posição
img = cv2.imread('./Imagens/original.jpg', 0)

# Cria uma matriz com o mesmo tamanho da imagem cinza, mas com 3 dimensões
img_colorida = np.zeros( (img.shape[0], img.shape[1], 3) )

# Como a peleta possui as mesmas cores RGB no eixo da largura, podemos sempre pegar a posição 0
# O for percorre a altura e a largura da nova matriz criada para representar a imagem colorida, e recebe a cor de acordo com a imagem original e o tom de cinza
for i in range(img.shape[0]):
    for j in range(img.shape[1]):
    	# na posição zero porque todas as camadas são iguais
        img_colorida[i][j] = paleta [ img[i][j] ][0]

# Converte a imagem colorida pra 8 bits
img_colorida = np.uint8(img_colorida)

# Transforma pra RGB
paleta = cv2.cvtColor(paleta, cv2.COLOR_HSV2BGR)
img_colorida = cv2.cvtColor(img_colorida, cv2.COLOR_HSV2BGR)
# Mostra a imagem e salva ela
# nome da janela, matriz
cv2.imshow('Original',img)

cv2.imshow('Paleta',paleta)
cv2.imwrite('./Imagens/paleta_hsi.jpg', paleta)

cv2.imshow('Colorida',img_colorida)
cv2.imwrite('./Imagens/original_hsi.jpg', img_colorida)


# Código para manter a jenala com a imagem
cv2.waitKey(0)
cv2.destroyAllWindows()

 

Imagens Resultantes

# Imagem original

original

# Paleta HSI

paleta_hsi

# Imagem colorida

original_hsi

Útil(0)Desprezível(0)

Definindo uma paleta de cores e aplicando em uma imagem

Dada uma imagem em tons de cinza, a ideia é definir uma cor (inicial) para representar o preto e outra (final) para representar o branco. Em seguida, criar uma paleta que varia da cor inicial até a final e aplicar estas cores na imagem original.

Para realizar este trabalho, foram utilizados os pacotes NumPy e OpenCV. O código está todo comentado e no final do post é possível ver as imagens resultantes.

Código

# -*- coding: utf-8 -*-
import numpy as np
import cv2

# Função para gerar a peleta de cores com um início e fim de cor definida pelo usuário
def gerar_paleta( b1, g1, r1, b2, g2, r2):
    
    # Função: np.linspace(A, B, X)
    # Descrição: gera um vetor com X valores entre A e B.
    b = np.linspace(b1, b2, 256)
    g = np.linspace(g1, g2, 256)
    r = np.linspace(r1, r2, 256)
        
    # Função: a.reshape(alt, largura)
    # Descrição: Da uma nova forma a uma lista. Neste caso, criamos uma altura de 256 e 1 de largura
    # Função: np.tile(array, X)
    # Descrição: Repete um array X vezes. Aqui, repetindo o mesmo valor no eixo da largura para ficar com 256 de largura    
    p1 = np.tile( b.reshape(256,1), 256 )
    p2 = np.tile( g.reshape(256,1), 256 )
    p3 = np.tile( r.reshape(256,1), 256 )
       
    # Função: np.uint8(num)
    # Descrição: converter números para 8 bits
    p1 = np.uint8(p1)
    p2 = np.uint8(p2)
    p3 = np.uint8(p3)
        
    # Função: np.dstack( (v1, v2) )
    # Descrição: Faz a concatenação dos dois vetores, por exemplo.
    paleta = np.dstack( (np.dstack( (p1,p2) ), p3) )
            
    return paleta
    # Fim da função

# Definindo uma cor inicial
b1 = 79
g1 = 79
r1 = 47
# Definindo uma cor final
b2 = 134
g2 = 230
r2 = 240

# Gerando uma paleta de cores da inicial até a final    
paleta = gerar_paleta(b1, g1, r1, b2, g2, r2)

# Abrir a imagem original em tons de cinza, por isso o parâmetro 0
img = cv2.imread('./Imagens/original.jpg', 0)

# Criar uma nova matriz com o mesmo tamanho que a imagem, porém com uma terceira dimensão para armazenar as cores BGR
# Função: np.zeros ( (x,y,z) , dtype=np.int8/16/32/... )
# img.shape[0] = altura, 1 = largura, 2 = profundidade, etc (conforme existir)
img_colorida = np.zeros( (img.shape[0], img.shape[1], 3) )

# Como a peleta possui as mesmas cores RGB no eixo da largura, podemos sempre pegar a posição 0
# O for percorre a altura e a largura da nova matriz criada para representar a imagem colorida, e recebe a cor de acordo com a imagem original e o tom de cinza
for i in range(img.shape[0]):
    for j in range(img.shape[1]):
        img_colorida[i][j] = paleta [ img[i][j] ][0]

# Converte os números da matriz para 8 bits
img_colorida = np.uint8(img_colorida)

# Mostrar uma imagem
cv2.imshow('Paleta de cores', paleta)
cv2.imshow('Imagem Original', img)
cv2.imshow('Imagem resultante', img_colorida)

# Funções para o funcionamento correto do python no Windows.
cv2.waitKey(0)
cv2.destroyAllWindows()

Imagens resultantes

# Paleta

paleta

# Original (tons de cinza)

original

# Colorida

colorida

Útil(0)Desprezível(0)