RED = 1
GREEN = 2 
BLUE = 3

maskedImage = rgb2gray(image)			% set to grayscale
maskedImage = repmat(maskedImage, 1, 1, 3)	% make 'psuedo-rgb'

% I need help with this:
maskedImage(:, :, RED) =  maskedImage + mask*255	
maskedImage(:, :, BLUE) = maskedImage + mask*-255	
maskedImage(:, :, GREEN) = maskedImage + mask*-255
maskedImage(maskedImage <= 0) = 0
maskedImage(maskedImage >= 255) = 255
% keep in uint8 space. this might not be necessary
% but i don't understand numpy's typing very well yet

% and this:
outputImage = [image, separator, maskedImage]	
%bmat('image', 'separator', 'maskedImage') seems like the right command,	
%except it seems to only work specifically on matrices, not n-dimensional numpy arrays.

Eela6 fucked around with this message at 20:38 on May 10, 2016

import numpy as np
from skimage import io
RED = 0
# i want an image where the top left corner is RED
# and the rest is black; just as a toy case.

redMask = np.zeros((128, 128, 3), 'uint8')
redMask[0:63][0:63][:, RED] = 255
redMask = np.uint8(redMask)
io.imshow(redMask)
# but this does not do what I want it to do.
# ... :(

import numpy as np
from skimage import color
def create_mask(blocks, img, init):
    # create mask: this is a 2d boolean matrix of the same dimensions as the 
    # original image, set to True in blocks that are connected to other blocks
    # (i.e, considered possibly copy-paste forged) and false elsewhere
    size = np.shape(img)
    rows = size[0]
    cols = size[1]
    mask = np.zeros(rows, cols)
    for block in blocks:
        row = block.row
        col = block.col
        rowEnd = row +init.blockSize-1
        colEnd = col + init.blockSize-1
        mask[row:rowEnd][:, col:colEnd] = True        
    return mask
    
def write_mask(mask, img, init):
    # we create an image image_out which is the original image on the left, a
    # 8-row BLUE (0, 0, 255) barrier, and then a MASKED image on the right.
    # The MASKED image is a grayscale version of the original image, except that
    # and set to RED (255, 0, 0) where the MASK is True 
    # (i.e, blocks considered modified)
    cols = np.shape[1]
    # we want a 'color' grayscale version of the original image:
    imgGray = color.gray2rgb(color.rgb2gray(img))


    """
create separator, maskedImage
we want to add maskedImage*255 to the red channel of imgGray
maskedImage*(-255) to the green channel
maskedImage*(-255) to the blue channel
then cast back to a uint8
    """
# this should work?
    imgOut =  np.hstack((image, separator, maskedImage))
    return imgOut

function [imgMasked, imgOut] = write_mask(mask, imgIn)
% use a mask (matrix of same size comprised of natural numbers)
% to 'write over' image: 

%imgMasked is the image in naive grayscale except
% RED   (255, 0, 0) where mask >= 1

%imgOut is the original m x n image (on LEFT)
% a m x 8 separation of BLUE (0, 255, 0)
% and then imageMasked on RIGHT

% create RED mask
mask = repmat(mask, 1, 1, 3);
to_red = (mask > 0);
mask(:, :, 1) = to_red*512;
mask(:, :, 2) = to_red*(-1024);
mask(:, :, 3) = to_red*(-1024);

% every element with a 1 will be > 256        
imgGray = rgb2gray(imgIn);
imgMasked = zeros([size(mask), 3]);
imgMasked(:, :, 1) = imgGray;
imgMasked(:, :, 2) = imgGray;
imgMasked(:, :, 3) = imgGray;
imgMasked = imgMasked + mask;
% every element in imgMasked will have
% blue and green channel < 0
separation = zeros([size(mask, 1), 8, 3]);
separation(:, :, 3) = 255;

imgOut = uint8([imgIn, separation, imgMasked]);
% every element in imgMasked will be grayscale except where mask has nonzeros
end

Eela6 fucked around with this message at 03:54 on May 11, 2016

import numpy as np
from skimage import io
RED = 0
GREEN = 1
BLUE = 2
ADD_CHANNEL = 8
REMOVE_CHANNEL = 16
testImg = io.imread('test.png')
mask = np.zeros((256, 256, 3), 'uint8')

""" set mask """
mask[0:64, 0:64, RED] = ADD_CHANNEL
mask[0:64, 0:64, GREEN] = REMOVE_CHANNEL
mask[0:64, 0:64, BLUE] = REMOVE_CHANNEL

mask[0:64, 64:128, RED] = REMOVE_CHANNEL
mask[0:64, 64:128, BLUE] = ADD_CHANNEL
mask[0:64, 64:128, GREEN] = REMOVE_CHANNEL

mask[64:128, 0:64, RED] = REMOVE_CHANNEL
mask[64:128, 0:64, BLUE] = REMOVE_CHANNEL
mask[64:128, 0:64, GREEN] = ADD_CHANNEL

mask[64:128, 64:128, RED] = ADD_CHANNEL
mask[64:128, 64:128, BLUE]= ADD_CHANNEL
mask[64:128, 64:128, GREEN] = REMOVE_CHANNEL

mask[32:96, 32:96, RED] = ADD_CHANNEL
mask[32:96, 32:96, GREEN] = ADD_CHANNEL
mask[32:96, 32:96, BLUE] = ADD_CHANNEL

mask[48:80, 48:80, RED] = REMOVE_CHANNEL
mask[48:80, 48:80, BLUE] = REMOVE_CHANNEL
mask[48:80, 48:80, GREEN] = REMOVE_CHANNEL

""" mask over image """
testImg[mask==ADD_CHANNEL] = 255
testImg[mask==REMOVE_CHANNEL]= -255
io.imshow(testImg)

Eela6 fucked around with this message at 20:34 on May 12, 2016

database = ['111111', '111111_222222', '141561', '123123']
def assign_parent_child(database):
    """assign tuples to database of index, unique id, and parent or child"""
    KEYLEN = 6
    # create dictionary of children
    childDict = {}  
    for data in database:
        if len(data) > KEYLEN:
            parent = (data[0:KEYLEN])
            childDict[parent] = data[KEYLEN+1:]
    
    # go through index and reassign in-place
    for index, data in enumerate(database):
        if len(data) > KEYLEN:
            parentChild = 'child'
        else:
            try:
                childDict[data]
                parentChild = 'parent'
            except KeyError:
                parentChild = None
            
        database[index] = (index, data, parentChild)
    return database

dataOut = assign_parent_child(database)
print(dataOut)

Eela6 fucked around with this message at 05:41 on Jul 2, 2016

Eela6 fucked around with this message at 17:37 on Sep 23, 2016

def raise_unnamed_exception():
    def internal_unnamed_raise():
        try:
            raise ValueError("basic exception")
        except Exception as err:
            raise
            
    internal_unnamed_raise()

raise_unnamed_exception()

runfile('C:/eela6_online_example/raise_unnamed_exception.py', wdir='C:/eela6_online_example')
Traceback (most recent call last):

  File "<ipython-input-15-83da24a50a8d>", line 1, in <module>
    runfile('C:/eela6_online_example/raise_unnamed_exception.py', wdir='C:/eela6_online_example')

  File "D:\Anaconda3\lib\site-packages\spyderlib\widgets\externalshell\sitecustomize.py", line 714, in runfile
    execfile(filename, namespace)

  File "D:\Anaconda3\lib\site-packages\spyderlib\widgets\externalshell\sitecustomize.py", line 89, in execfile
    exec(compile(f.read(), filename, 'exec'), namespace)

  File "C:/eela6_online_example/raise_unnamed_exception.py", line 17, in <module>
    raise_unnamed_exception()

  File "C:/eela6_online_example/raise_unnamed_exception.py", line 15, in raise_unnamed_exception
    internal_unnamed_raise()

  File "C:/eela6_online_example/raise_unnamed_exception.py", line 11, in internal_unnamed_raise
    raise ValueError("basic exception")

ValueError: basic exception

def raise_named_exception():
    def internal_named_raise():
        try:
            raise ValueError("basic exception")
        except Exception as err:
            raise err
            
    internal_named_raise()

raise_named_exception()

runfile('C:/eela6_online_example/raise_named_exception.py', wdir='C:/eela6_online_example')
Traceback (most recent call last):

  File "<ipython-input-16-280b30bc959d>", line 1, in <module>
    runfile('C:/eela6_online_example/raise_named_exception.py', wdir='C:/eela6_online_example')

  File "D:\Anaconda3\lib\site-packages\spyderlib\widgets\externalshell\sitecustomize.py", line 714, in runfile
    execfile(filename, namespace)

  File "D:\Anaconda3\lib\site-packages\spyderlib\widgets\externalshell\sitecustomize.py", line 89, in execfile
    exec(compile(f.read(), filename, 'exec'), namespace)

  File "C:/eela6_online_example/raise_named_exception.py", line 17, in <module>
    raise_named_exception()

  File "C:/eela6_online_example/raise_named_exception.py", line 15, in raise_named_exception
    internal_named_raise()

  File "C:/eela6_online_example/raise_named_exception.py", line 13, in internal_named_raise
    raise err

  File "C:/eela6_online_example/raise_named_exception.py", line 11, in internal_named_raise
    raise ValueError("basic exception")

ValueError: basic exception

Eela6 fucked around with this message at 22:07 on Sep 23, 2016

import sys
reload(sys)
sys.setdefaultencoding('utf8')

Eela6 fucked around with this message at 18:28 on Sep 27, 2016

from collections import namedtuple
database = object() # mock for whatever you have
Transfer = namedtuple('Transfer', ['name', 'isFrom', 'to', 'time'])
FrequentFlier = namedtuple('FrequentFlier', ['name', 'departed', 'returned'])
# i.e,  james = Transfer('James', 'ICU', '2E', <datetime obj>)
def within_24_hours():
    pass # I can't remember datetime syntax, but this part shouldn't be too bad.
transfers = (Transfer(x) for x in database)
transfers = sorted(database, key = lambda x: x.time)

def generate_frequent_fliers():
    seen = {}
    for transfer in transfers:
        patient = transfer.name
        if transfer.isFrom == 'ICU':
            seen[patient] = transfer 
            # because of our sort, this is always the most recent transfer out time
        elif patient in seen and transfer.to == 'ICU':
            if within_24_hours():
                departed = seen[patient].isFrom
                returned = transfer.to
                yield FrequentFlier(patient, departed, returned)

frequentFliers = generate_frequent_fliers()
for frequentFlier in frequentFliers:
   print('patient {0} left at {1} but came back at {2}'.format(
         frequentFlier.name, frequentFlier.departed, frequentFlier.returned))

Eela6 fucked around with this message at 04:50 on Oct 6, 2016

from collections import namedtuple
import csv
import datetime

""" 
helper functions start here
"""

def import_transfers(filename):
    """ import transfers from CSV, convert to namedtuple, then read into memory """
    Transfer = namedtuple('Transfer', ['name', 'isFrom', 'to', 'time'])
    asDateTime = datetime.strptime
    with open(filename) as file:
        database = csv.reader(file)
        transfers = [Transfer(*line[:3], asDateTime(line[3])) 
            for line in database]
        return transfers

def generate_frequent_fliers(transfers):
    """ generator function that yields patients who have transferred
    out of ICU, and then return within 24 hours"""
    FrequentFlier = namedtuple('FrequentFlier', ['name', 'left', 'returned'])
    TWENTY_FOUR_HOURS = datetime.timedelta(seconds = 60) * 60 * 24
    seen = {}
    for transfer in transfers:
        patient = transfer.name
        if transfer.isFrom == 'ICU':
            seen[patient] = transfer
            # because of our sort, this is always the most recent transfer out time
        elif patient in seen and transfer.to == 'ICU':
            departed = seen[patient].isFrom
            returned = transfer.to
            if returned.time - departed.time < TWENTY_FOUR_HOURS:
                yield FrequentFlier(patient, departed.time, returned.time)

def export_frequent_fliers(OUTPUT_FILEPATH, frequentFliers):
    """ writes list of frequent_fliers as CSV to output file in the following form:
    NAME, TIME IN, TIME OUT """
    with open(OUTPUT_FILEPATH, 'w') as file:
        writer = csv.writer(file)
        for frequentFlier in frequentFliers:
            writer.writerow(frequentFlier)

"""
helper functions end here
"""

#this is what actually runs
INPUT_FILEPATH = 'testin.csv'
OUTPUT_FILEPATH = 'testout.csv'
transfers = import_transfers(INPUT_FILEPATH)
transfers = sorted(transfers, key = lambda x: x.time)
frequentFliers = generate_frequent_fliers(transfers)
export_frequent_fliers(OUTPUT_FILEPATH, frequentFliers)

Eela6 fucked around with this message at 22:51 on Oct 6, 2016

class Unit:
     def __init__(self):
          pass
     

class Footman(Unit):
     def __init__(self, currentHp = 5, power = 5, maxHp = 5):
          self.currentHp = currentHp
          self.maxHp = maxHp
          self.power = power
          self.attackRange = 1
          self.armor = 2

     def __repr__(self):
          return 'Footman(currentHp = {0}, power = {1}, maxHp = {2})'.format(
                          self.currentHp, self.power, self.maxHp)

     def takeDamage(self, damage):
          self.currentHp -= max(damage-self.armor, 0)

def makeUnit(unitType, *args, **kwargs):
     return unitType(*args, **kwargs)

steve = makeUnit(Footman)
superSteve = makeUnit(Footman, 50, 100, maxHp = 250)
print(repr(steve))
steve.takeDamage(4)
print(repr(steve))
print(repr(superSteve))

Footman(currentHp = 5, power = 5, maxHp = 5)
Footman(currentHp = 3, power = 5, maxHp = 5)
Footman(currentHp = 50, power = 100, maxHp = 250)

Eela6 fucked around with this message at 20:55 on Oct 7, 2016

def count_machine_intervals(machines):
    START = 'START'
    END = 'END'
    Event = namedtuple('Event', ['time', 'type'])
    Interval = namedtuple('Interval', ['start', 'end'])
    def _generate_events():
        for machine in machines:
            for startTime in machine[0]:
                yield Event(startTime, START)
            for endTime in machine[1]:
                yield Event(endTime, END)

    events = sorted(_generate_events(), key = lambda x: x.time)
    count = 0
    previousTime = 0
    machineCountIntervals = defaultdict(list)
    def _update_machine_count_intervals():

        if interval.start == interval.end:
            return
        if machineCountIntervals[count]:
            # try merging intervals if appropriate
            lastSeen = machineCountIntervals[count][-1]
            if lastSeen.end == interval.start:
                machineCountIntervals[count][-1] = Interval(lastSeen.start, interval.end)
                return
        machineCountIntervals[count].append(interval)
        
    for event in events:
        interval = Interval(previousTime, event.time)
        _update_machine_count_intervals()

        if event.type == START:
            count += 1
        else:
            count -= 1
        previousTime = interval.end
    return machineCountIntervals

def test():
    machine_00 = [2, 7], [6, 11]
    machine_01 = [1, 5, 11], [3, 10, 13]
    machine_02 = [2, 6], [5, 8]
    machines = (machine_00, machine_01, machine_02)
    count = count_machine_intervals(machines)
    for key in count:
        print(key, count[key])

test()

0 [Interval(start=0, end=1)]
1 [Interval(start=1, end=2), Interval(start=10, end=13)]
2 [Interval(start=3, end=7), Interval(start=8, end=10)]
3 [Interval(start=2, end=3), Interval(start=7, end=8)]

Eela6 fucked around with this message at 20:46 on Oct 22, 2016

# good - makes it clear why we chose these elements
uniformColors= {'black', 'blue', 'white')
icecreamFlavors = {'chocolate', 'vanilla', 'strawberry'}

# debatable - probably useful. saves a little bit of brain space when reading over the code.
powersOfFive = {5**n for n in range(10)}

# silly
yesOrNo = {'yes', 'no'}
abcde = set('abcde')

# equivalent:
membership = {'a', 'b', 'c'}
membership = set(('a', 'b', 'c')) 

Eela6 fucked around with this message at 03:25 on Nov 10, 2016

A = np.array([2, 5, 8, 12, 20])
print(A)
between_twenty_and_three = np.logical_and(A>3, A<20)

print(between_twenty_and_three)
A[between_twenty_and_three] = 500

print(A)

[ 2  5  8 12 20]
[False  True  True  True False]
[  2 500 500 500  20]

def update_dataframe(df: pd.DataFrame) -> pd.DataFrame:
    df.Current = df.New
    df.Current[pd.isnull(df.New)] = df.Old[pd.isnull(df.New)]
    return df
    
def test_update_dataframe():
    df = pd.DataFrame([[1, 2,np.nan],
                   [3, 2,np.nan],
                   [7, np.nan,np.nan], 
                   [np.nan, 8,np.nan]],
                  columns=['Old', 'New', 'Current'])
    print('old')
    print(df)
    df = update_dataframe(df)
    print('new')
    print(df)    
    
test_update_dataframe()

old
   Old  New  Current
0  1.0  2.0      NaN
1  3.0  2.0      NaN
2  7.0  NaN      NaN
3  NaN  8.0      NaN
new
   Old  New  Current
0  1.0  2.0      2.0
1  3.0  2.0      2.0
2  7.0  NaN      7.0
3  NaN  8.0      8.0

Eela6 fucked around with this message at 23:11 on Nov 18, 2016

Eela6 fucked around with this message at 00:45 on Nov 22, 2016

someValue = database['table', 'column', 'value']
someColumn = database['table', 'column']
someTable = database['table'] 

everyValueInAColumn = database['table', 'column', :]

Eela6 fucked around with this message at 17:25 on Nov 22, 2016

Eela6 fucked around with this message at 23:30 on Dec 15, 2016

Eela6 fucked around with this message at 06:44 on Dec 18, 2016

A[A < 20] = 0

Eela6 fucked around with this message at 22:32 on Dec 18, 2016