#!/usr/bin/env python
import sys
import cv2
from numpy import r_, concatenate




def main():
    imgs  = []
    for fname in sys.argv[1:]:
        imgs.append(cv2.imread(fname))

    montage = concatenate(imgs, 0)
    cv2.imwrite('montage_vertical.png', montage)


    montage = concatenate(imgs, 1)
    cv2.imwrite('montage_horizontal.png', montage)

if __name__ == '__main__':
    main()

#!/usr/bin/env python
import sys
import cv2
from numpy import r_, concatenate

def main():
    img = cv2.imread(sys.argv[1])

    b = img.copy()
    b[:,:,1] = 0
    b[:,:,2] = 0


    g = img.copy()
    g[:,:,0] = 0
    g[:,:,2] = 0

    r = img.copy()
    r[:,:,0] = 0
    r[:,:,1] = 0

    montage = concatenate((b,g,r), 1)
    cv2.imwrite('montage_channels.png', montage)

if __name__ == '__main__':
    main()

#!/usr/bin/env python
import nltk
import numpy
import codecs
import sys

def main():
    raw = codecs.open(sys.argv[1]).read()
    tokens = nltk.word_tokenize(raw)
    text = nltk.Text(tokens)
    estimator = lambda fdist, bins: nltk.probability.LidstoneProbDist(fdist, 0.2)
    model = nltk.NgramModel(3, text, estimator=estimator)
    first_words =  model.generate(42)[-2:]
    print ' '.join(model.generate(50, first_words))


if __name__ == '__main__':
    if len(sys.argv) < 2:
        print "USO: %s arquivo_texto" % sys.argv[0]
    else:
        main()

#!/usr/bin/env python
from BeautifulSoup import BeautifulSoup
import urllib2,sys
import codecs

ADDRESS = 'http://www2.planalto.gov.br/imprensa/discursos?b_start:int=0'

def prox_pagina(soup):
    '''
    Itera pelas paginas do site do planalto usando o link no paginador.
    '''
    try:
        span_next = soup.find('span', {'class':'next'})
        href = span_next.first()['href']
        print href
        html = urllib2.urlopen(href).read()
        return BeautifulSoup(html)
    except Exception:
        return None



def parse_discurso_texto(href):
    '''
    Procura pelo texto do discurso. Separa os paragrafos por um new line.
    '''
    print href
    html = urllib2.urlopen(href).read()
    soup =  BeautifulSoup(html)
    #os paragrafos ficam dentro de um div com id parent-fieldname-text
    text = [p.text for p in soup.find(id='parent-fieldname-text').findAll('p')]
    text = '\n'.join(text)
    return text + '\n'



def main():
    #abre a pagina da internet
    html = urllib2.urlopen(ADDRESS).read()
    #inicializa o parser do html lido
    soup = BeautifulSoup(html)
    #abre arquivo onde salvar os discursos
    f = codecs.open('discursos.txt', 'w', "utf-8")
    while(soup):
        #os links dos discursos ficam nas tags a com classe summary url
        discursos = soup.findAll('a', {'class':'summary url'})
        discursos = [d['href'] for d in discursos]
        for d in discursos:
            t = parse_discurso_texto(d)
            f.write(t)
        soup = prox_pagina(soup)
    f.close()


if __name__ == '__main__':
    main()

#!/usr/bin/env python
import cv2
import numpy
import sys

if __name__ == '__main__':
    if len(sys.argv) > 1:
        img  = cv2.imread(sys.argv[1])
    else:
        cam = cv2.VideoCapture(0)
        status, img = cam.read()

    img = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
    #mean of each channel
    m = numpy.asarray([img[:,:,0].mean(), img[:,:,1].mean(), img[:,:,2].mean()])
    img = cv2.medianBlur(img, 9)
    dist = (img - m)**2
    print("mean color is %s"% m)
    salmap = numpy.zeros((dist.shape[0], dist.shape[1]))
    for l in range(dist.shape[0]):
        for c in range(dist.shape[1]):
            salmap[l][c] = numpy.sqrt(dist[l][c].sum())
    #minmax normalization
    salmap = (salmap -salmap.min())
    salmap = salmap/salmap.max()
    salmap = 255*salmap
    salmap = salmap.astype(numpy.uint8)
    cv2.imwrite('saliency.png', salmap)
    cv2.waitKey()

/*
Compares the HSV histograms of two images, a and b.
Return the norm  between 
*/
double compare_histograms(Mat a, Mat  b) {
    MatND  hista, histb;
    Mat a_hsv, b_hsv;

    //args to calculate the histogram
    int channels[] = {0, 1};
    //180 bins for hue and 256 bins to saturation
    int histsize[] = {180, 256};
    //distribution uniform by the bins
    float hrange[] = {0, 180};
    float srange[] = {0, 256};
    const float * ranges[] = {hrange,srange};

    //Convert images to HSV from BGR
    cvtColor(a, a_hsv, CV_BGR2HSV);
    cvtColor(b, b_hsv, CV_BGR2HSV);

    //Calculates the histogram of the two images
    calcHist(&a, 1, channels, Mat(), hista, 2, histsize, ranges);
    calcHist(&b, 1, channels, Mat(), histb, 2, histsize, ranges);

    //Return the norm
    return norm(hista, histb);
}

#!/usr/bin/env python
import cv2
import numpy
import sys

if __name__ == '__main__':
    if len(sys.argv) > 1:
        img  = cv2.imread(sys.argv[1])
    else:
        cam = cv2.VideoCapture(0)
        status, img = cam.read()

    m_protan = numpy.asarray( [[0.259411, 0.923008,  -0.182420],
                               [0.110296, 0.804340,  0.085364 ],
                               [-0.006276, -0.034346,  1.040622 ]])

    img = cv2.cvtColor(img, cv2.cv.CV_BGR2RGB)
    protan = cv2.transform(img, m_protan)
    protan = cv2.cvtColor(protan, cv2.cv.CV_RGB2BGR)
    cv2.imshow('protan', protan)
    cv2.imwrite('protan.png', protan)
    cv2.waitKey()

#!/usr/bin/env python
import cv2
import numpy
import sys

if __name__ == '__main__':
    if len(sys.argv) > 1:
        img  = cv2.imread(sys.argv[1])
    else:
        cam = cv2.VideoCapture(0)
        status, img = cam.read()

    m_sepia = numpy.asarray([[0.393, 0.769, 0.189],
                             [0.349, 0.686, 0.168],
                             [0.272, 0.534, 0.131]])
    sepia = cv2.transform(img, m_sepia)
    sepia = cv2.cvtColor(sepia, cv2.cv.CV_RGB2BGR)
    cv2.imshow('sepia', sepia)
    cv2.imwrite('sepia.png', sepia)
    cv2.waitKey()