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(0)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(0)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(0)Desprezível(0)

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)

Amostragem e Quantização

Para realizar este trabalho, foram utilizados os pacotes NumPy e OpenCV. O código está todo comentado e na sequência é possível ver as imagens resultantes.

Código

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

# Função: 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)

## Amostragem ##
# Reduzindo a imagem #
# Seleciona uma em cada 2 colunas, e de cada coluna uma a cada duas linhas
n = 2
img_red = img[::n,::n]

# Aumentando a imagem #
# Os pixels da imagem atual serão duplucados no eixo x e y. Assim, a imagem volta a ter o tamanho original, mas a partir da imagem reduzida
# Função: np.repeat(matriz, vezes, eixo). O eixo 0 é a altura e 1 a largura.
m = 2
img_aum = np.repeat(img_red, m, axis=0)
img_aum = np.repeat(img_aum, m, axis=1)

## Quantização ##
# 255 / 31 = 8,22...
# Assim, teremos uma imagem com 8 tons de cinza. A conta é feita desta forma para descartar a parte decimal dos números e alterar o vetor para que possua apenas 8 valores possíveis.
r = 31
img = np.uint8(img / r) * r

# Salvar imagem no disco #
#cv2.imwrite('C:/Diretório', img_aum)

# Mostra uma imagem
# Função: cv.imshow(nome da janela, matriz)
cv2.imshow('original',img)
cv2.imshow('reduzida',img_red)
cv2.imshow('aumentada',img_aum)

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

Imagens Resultantes

# Original

DCIM100GOPROGOPR0157.

# Reduzida

reduzida

# Aumentada

aumentada

# Quantizada

quantizada

Útil(0)Desprezível(0)

Configurar controle do XBOX no Windows 10

Até ontem eu usava o controle do XBOX pra jogar no PC com Windows 7, até que veio a atualização para o Windows 10 e o controle ficou listado como um dispositivo desconhecido e não funcionava.

Achei uma resposta simples Internet afora,  dizendo apenas para atualizar o driver atual para um outro determinado que já existe no PC. Faça o seguinte:

  1. Clique com o botão direito no atalho “Este Computador” (antigo Meu computador) na área de trabalho e vá em Gerenciar;
  2. Vá na opção Gerenciamento de dispositivos;
  3. Encontre o controle do XBOX, clique com o botão direito e vá em Atualizar driver;
  4. Escolha a opção: Procurar software de driver no computador;
  5. Agora clique em Permitir que eu escolha em uma lista de drivers de dispositivo no computador;
  6. Selecione: Xbox 360 Wireless Receiver for Windows Version: 2.1.0.1349 [8/13/2009];
  7. Clique em aceitar ou OK nas outras telas até fechar tudo;
  8. Pronto, seu controle será reconhecido.

Funcionou pra mim.

Fonte: Answers.microsoft.com/

Útil(11)Desprezível(9)

Atalhos para mover/redimensionar uma janela no Windows

Trabalhar com mais de um monitor é muito bom quando se utiliza muitas janelas/programas ao mesmo tempo. Em alguns casos a janela fica “ligada” ao monitor que ela estava posicionada e se você resolve abrir o mesmo programa usando um só monitor, ela tende a ir lá para o canto.

O jeito mais fácil de restaurar/mover uma janela que não está na sua tela atual é usando o atalho no teclado para posicionar, maximizar e minimizar. Use a combinação das teclas Windows + setas:

teclado-atalho-minimizar-maximizar

  • Cima: maximizar para tela cheia;
  • Baixo: minimizar para barra de tarefas;
  • Esquerda: maximizar a janela até o meio do monitor;
  • Direita: maximizar a janela até o meio do monitor;
Útil(0)Desprezível(0)

Restaurar fotos excluídas do celular

Formatei um cartão micro SD do meu celular (Android), sem querer querendo, e todas as fotos e vídeos da câmera que estavam salvas nele, se foram desta pra melhor :'(. Tentei recuperar pelo computador usando alguns softwares (Recuva, EaseUS Data Recovery,  Wondershare Data Recovery) que até conseguiram trazer de volta poucas fotos, mas algumas estavam deformadas.

Foi aí que pensei em usar algum aplicativo no próprio celular e depois de um bom tempo procurando e testando, encontrei o aplicativo que resolveu meu problema. Ele é o Photo Recovery. Feio, porém eficiente!

Usei o método 2 do Photo Recovery e depois de algum tempo as fotos estavam em uma pasta na raiz da memória do celular. Muitas outras imagens (como do what’s app) também foram recuperadas.

A partir daqui, usei o ES File Explorer (há muitos outros também) para acessar as imagens e jogá-las novamente no cartão de memória. Coloquei no computador, organizei por tamanho e excluí aquelas que não eram da câmera.

Dica de backup automático:

  • Fotos: o Google está fazendo um backup das fotos pelo aplicativo Fotos, e o espaço utilizado não é descontado do Google Drive.
  • OneDrive: O app da Microsoft faz o upload automático das fotos e quando você ativa esta opção, ganha mais 15 GB.
Útil(0)Desprezível(1)

Alterar servidor DNS no Linux (Ubuntu, Mint, etc)

Há vários tópicos na Internet sobre como fazer isso, mas tive que testar muitos para encontrar um que funcionava. Na maior parte deles, ao reiniciar o PC o arquivo /etc/resolv.conf voltava ao normal, e as tentativas de travar sua edição não eram válidas.

Encontrei em um tópico do Stackexchange explicando sobre a criação do arquivo /etc/resolv.conf e quais arquivos são utilizados para isso. Então, altere um destes arquivos e toda vez que você ligar o computador, as configurações estarão lá.

sudo nano /etc/resolvconf/resolv.conf.d/tail

Este arquivo serve para adicionar conteúdo dinâmico ao /etc/resolv.conf.

Agora adicione o conteúdo:

nameserver 8.8.8.8
nameserver 8.8.4.4

Salve o arquivo:

Ctrl + o

Feche:

Ctrl + x

Agora mande o sistema gerar novamente o arquivo:

sudo resolvconf -u

Por fim, reinicie o PC.

Fonte: How do I set my DNS on Ubuntu 14.04?

 

Útil(2)Desprezível(0)