Fullscreen

#!/usr/bin/env python
from __future__ import division
from cv import *
from sys import argv, exit
import os


def capture_frame():
    """Capture frame from webcam, convert to grayscale, flip, and smooth."""
    global wc
    global fm
    global inputframe

    CvtColor(QueryFrame(wc), inputframe, CV_RGB2GRAY)
    Flip(inputframe, flipMode=fm)
    Smooth(inputframe, inputframe, CV_MEDIAN)

    return inputframe


def hybrid_process(hybframe):
    """Process frame using a gradient-Laplacian hybrid."""
    global summation

    hybgrad = gradient_process(hybframe)
    hyblap = laplacian_process(hybframe)

    Add(hybgrad, hyblap, summation)

    return summation


def gradient_process(gradframe):
    """Process frame using only a gradient."""
    global gradscaled

    Resize(gradframe, gradscaled)

    return GetMat(gradscaled)


def laplacian_process(lapframe):
    """Process frame using only a Laplacian."""
    global th
    global clr
    global edges
    global ldeg
    global lapscaled
 
    Threshold(lapframe, lapframe, th, clr, CV_THRESH_BINARY)
    Laplace(lapframe, edges, ldeg)
    Convert(edges, lapframe)
    Resize(lapframe, lapscaled)

    return GetMat(lapscaled)


def print_output(printmat):
    """Print the image as a string of ASCII characters"""
    printed = ''
    for y in range(printmat.height):
        printed = printed + ' ' * int((terminalwidth - dw) / 2)
        for x in range(printmat.width):
            printed = printed + asciiGroup[int(-1 + len(
                asciiGroup) - ((printmat[y, x] * len(asciiGroup)) // 256))]
        printed = printed + '\n' * (y != (printmat.height - 1))

    os.system('clear')
    print(printed)


def run(mode, tw, fw, invert):
    """Capture and process feed from webcam"""
    initialize(tw, fw, invert)

    while True:
        rawframe = capture_frame()

        if mode == '-c':
            printed = hybrid_process(rawframe)
        elif mode == '-g':
            printed = gradient_process(rawframe)
        elif mode == '-l':
            printed = laplacian_process(rawframe)

        print_output(printed)
        WaitKey(1)


def initialize(tw, fw, invert):
    """Initialize settings and images"""
    global wc
    global asciiGroup
    global fm
    global th
    global clr
    global ldeg
    global quadwidth
    global dqw
    global terminalwidth
    global dw
    global scaledsize
    global inputframe
    global gradscaled
    global edges
    global lapscaled
    global gradscaled
    global summation

    # Settings for frame capture
    wc = CaptureFromCAM(0)
    # Old ASCII Group
    # asciiGroup = "####**oahbpqwmzcunxrt-+~<>:,^`...     "
    asciiGroup = "#########**********oahkbdpqwmzcvunxrjft|?-+~<>!:,^`'....      "
    if invert:
        asciiGroup = asciiGroup[::-1]
    windowsize = GetSize(QueryFrame(wc))
    hght = windowsize[1]
    wdth = windowsize[0]
    flipMode = 1
    fm = flipMode

    # Settings for Threshold()
    threshold = 100
    th = threshold
    color = 255
    clr = color

    # Setting for Laplace()
    laplaceDegree = 7
    ldeg = laplaceDegree

    # Settings for sizing (for fullscreened terminal on 1600x900 screen)
    terminalwidth = tw
    desiredwidth = fw
    dw = desiredwidth
    scaledsize = (dw, int(dw / 2 * hght // wdth))

    # Initialize OpenCV images
    inputframe = CreateImage(windowsize, 8, 1)
    edges = CreateImage(windowsize, IPL_DEPTH_16S, 1)
    hybscaled = CreateImage(scaledsize, 8, 1)
    gradscaled = CreateImage(scaledsize, 8, 1)
    lapscaled = CreateImage(scaledsize, 8, 1)
    summation = CreateMat(scaledsize[1], scaledsize[0], CV_8UC1)


def help():
    """Print help"""
    print('-g            :    Gradient mode')
    print('-l            :    Laplacian mode')
    print('-c            :    Combined mode')
    print('-t            :    Trifecta')
    print('-tw <int>     :    Set width of terminal')
    print('-fw <int>     :    Set width of frame')
    print('-i            :    Invert the output color')
    exit(0)


def arg_processing():
    mode = False
    tw = False
    fw = False
    invert = False

    for i in range(1, len(argv)):
        try:
            inp = argv[i]
        except IndexError:
            inp = False
            
        if inp == '-g' or inp == '-l' or inp == '-c' or inp == '-t' and not mode:
            mode = inp
        elif inp == '-h' or inp == '--help':
            help()
        elif inp == '-tw':
            try:
                tw = int(argv[i+1])
            except IndexError:
                pass
            except ValueError:
                pass
        elif inp == '-fw':
            try:
                fw = int(argv[i+1])
            except IndexError:
                pass
            except ValueError:
                pass
        elif inp == '-i':
            invert = True

    if not mode:
        mode = '-c'
    if not tw:
        tw = 304
    if not fw:
        fw = 222
    if mode == '-t':
        os.system('./Trifecta -tw ' + str(tw) +' -fw ' + str(fw) + (' -i'*invert))
        exit(0)
    return [mode, tw, fw, invert]


if __name__ == '__main__':
    [mode, tw, fw, invert] = arg_processing()
    run(mode, tw, fw, invert)