bambriz.me

import pandas as pd
import numpy as np
import os
import PIL
import sys
import matplotlib
import webcolors
from IPython.display import display, Image 
from matplotlib import pyplot as plt
from io import BytesIO
from collections import Counter
from PIL import Image as PILimage
PIL.Image.MAX_IMAGE_PIXELS = 933120000
%matplotlib inline
''' Color-comparison of 3 styles of art. Cubist, Impressionist, and Baroque.
    10 Images per style, each taken from public domain. 
'''
def load_styles():
    #These are the paths to the files in the local directory
    path_baroque = './Baroque'
    path_cubist = './Cubist'
    path_impressionism = './Impressionism'
    #This is a dataframe that will hold the image objects, extensions, and names/style
    styles = pd.DataFrame()
    series_objects = []
    number_colors = 256
    
    #Gets each individuals pixel data in RGB
    #As well as adds a column to convert RGB into human readable colors
    #later , (ex. Black, brickRed)
    for baroquefile in os.listdir(path_baroque):
        if baroquefile != '.DS_Store':
            imageadded = PILimage.open(path_baroque + '/' + baroquefile)
            pallet_mode = imageadded.getdata()
            array_like = list(pallet_mode)
            imageadded.close()
            fn, fext = os.path.splitext(baroquefile)
            toAdd = pd.Series(name = fn, data = {'web_colors':np.nan,'color_array': array_like, 'color_sequence': pallet_mode, 'color_length': len(array_like),'extension': fext, 'style': 'Baroque'})
            series_objects.append(toAdd)
    for cubistfile in os.listdir(path_cubist):
        if cubistfile != '.DS_Store':
            imageadded = PILimage.open(path_cubist + '/' + cubistfile)
            pallet_mode = imageadded.getdata()
            array_like = list(pallet_mode)
            imageadded.close()
            fn, fext = os.path.splitext(cubistfile)
            toAdd = pd.Series(name = fn, data={'web_colors':np.nan,'color_array': array_like, 'color_sequence': pallet_mode, 'color_length': len(array_like), 'extension': fext, 'style': 'Cubist'})
            series_objects.append(toAdd)
    for impressionistfile in os.listdir(path_impressionism):
        if impressionistfile != '.DS_Store':
            imageadded = PILimage.open(path_impressionism + '/' + impressionistfile)
            pallet_mode = imageadded.getdata()
            array_like = list(pallet_mode)
            imageadded.close()
            fn, fext = os.path.splitext(impressionistfile)
            toAdd = pd.Series(name = fn, data={'web_colors': np.nan, 'color_array': array_like,'color_sequence': pallet_mode, 'color_length': len(array_like),'extension': fext, 'style': 'Impressionist'})
            series_objects.append(toAdd)
            
    return styles.append(series_objects)

styles = load_styles()

def convertAdd_rgbColumn():
    #Converts RGB to Color 
    def closest_colour(requested_colour):
        min_colours = {}
        for key, name in webcolors.css3_hex_to_names.items():
            r_c, g_c, b_c = webcolors.hex_to_rgb(key)
            rd = (r_c - requested_colour[0]) ** 2
            gd = (g_c - requested_colour[1]) ** 2
            bd = (b_c - requested_colour[2]) ** 2
            min_colours[(rd + gd + bd)] = name
        return min_colours[min(min_colours.keys())]

    def get_colour_name(requested_colour):
        try:
            closest_name = actual_name = webcolors.rgb_to_name(requested_colour)
        except ValueError:
            closest_name = closest_colour(requested_colour)
            actual_name = None
        return closest_name
    
    paintingColorMatches = pd.Series(index=styles.index)
    for painting in styles.index:
        color_array = map(get_colour_name, styles.loc[painting].loc['color_array'])
        paintingColorMatches.loc[painting] = color_array
    styles['web_colors'] = paintingColorMatches

convertAdd_rgbColumn()

'''
creating a dictionary of the set of complete web_colors, iterating over each paintings
web_color map, and getting the counts as compared to the ratio of the complete image.
'''
import multiprocessing
def ratios():
    count_array = []
    for painting in styles.index:
        counts = {}
        print(painting)
        for value in styles.loc[painting].loc['web_colors']:
            if value not in counts.keys():
                counts[value] = 1
            else:
                counts[value] += 1
        count_array.append(counts)
        print(counts)
#Ran the following script & saved the output.
#Having it run takes around ~30 minutes for 30 files.
'''if __name__ == '__main__':
    jobs = []
    for i in range(5):
        p = multiprocessing.Process(target=ratios)
        jobs.append(p)
        p.start()
'''

''' 
    Finally, let's display our matplots.
    // I decided to shorten the amount
       of colors displayed on the x-axis by limiting the 
    // percent of measurable significance on the ratio of colors. 
    
    // For example, if the ratio of pixels for the color 'blanchedalmond' 
        on any particular image is less than 5%, then that means that it is insignificant
        for our purposes.
'''
def grab_ratios(cut_off):
    pixel_dictionary = {}
    pixel_ratios_array = []
    for painting in styles.index:
        for color in styles.loc[painting].loc['color_count']:
            count = styles.loc[painting].loc['color_count'][color]
            if ((count / styles.loc[painting].loc['color_length']) > cut_off):
                pixel_ratios_array.append((color, (count / styles.loc[painting].loc['color_length'])))
        pixel_ratios_array.sort(key=lambda x: x[1], reverse=True)
        pixel_dictionary[painting] = pixel_ratios_array
        pixel_ratios_array = []
    graphs = {'baroque':[],'impressionism':[], 'cubism':[]}
    sep = 0
    for key in pixel_dictionary:
        sep += 1
        temp_index = []
        temp_vals = []
        for tuples in pixel_dictionary[key]:
            temp_index.append(tuples[0])
            temp_vals.append(tuples[1])
        temp_sers = pd.Series(index = temp_index, data = temp_vals)
        if sep <= 30:
            if sep >= 20:
                graphs['cubism'].append( (key, temp_sers) )

            elif sep >= 10:
                graphs['impressionism'].append( (key, temp_sers)) 

            else:
                graphs['baroque'].append((key, temp_sers))

        temp_index = []
        temp_vals = []
    return graphs
graphs = grab_ratios(0.02)



'''
This function prints the colores used in the graph from most used to least, based on percentage
of pixels of that particular color. 
'''
def colored_graphs(style):
    if style not in ['baroque', 'cubism', 'impressionism']:
        raise ValueError('style not acceptable, try baroque, cubism, or impressionism.')
    for painting in graphs[style]:
        figure, axes = plt.subplots()
        plt.title(painting[0])
        axes.bar(np.arange(len(painting[1])), painting[1].values, width=0.25, tick_label = list(painting[1].index), color = list(painting[1].index), linewidth=0.5, edgecolor='white')
        axes.set_xlabel('Color')
        axes.set_ylabel('Percent Used')
        plt.xticks(rotation='45')
        plt.show(figure)
        plt.savefig("" + painting[0] + ".pdf")
        plt.close()
        figure.clear()
baroque = colored_graphs('baroque')

def average_by_style(style):
    plt.close()
    if style not in ['baroque', 'cubism', 'impressionism']:
        raise ValueError('style not acceptable, try baroque, cubism, or impressionism.')
    cut_off = 0.05
    graphs = grab_ratios(cut_off)
    color_dict = {}
    painting_sums = {}
    for painting in graphs[style]:
        sum_percent = 0
        for color in painting[1].index:
            sum_percent += painting[1][color]
        painting_sums[painting[0]] = sum_percent
        color = 0
    for painting in graphs[style]:
        for color in painting[1].index:
            painting[1].loc[color] = (painting[1].loc[color] / painting_sums[painting[0]])
            if color not in color_dict.keys():
                color_dict[color] = painting[1].loc[color]
            else:
                color_dict[color] += painting[1].loc[color]
    sum_all = sum(color_dict.values())
    tuple_set = []
    show_greater_than = 0.02
    iter_over = list(color_dict.keys())
    for key in iter_over:
        if (color_dict[key] / sum_all) < show_greater_than:
            del color_dict[key]
    new_sum = sum(color_dict.values())
    
    for key in color_dict.keys():
        color_dict[key] = (color_dict[key] / new_sum)
        tuple_set.append((key, color_dict[key]))
    tuple_set.sort(key= lambda x: x[1], reverse=True)
    avg_Series = pd.Series(index=[x[0] for x in tuple_set], data=[x[1] for x in tuple_set])
    figure = plt.figure(4, figsize=(10,10))
    axes = figure.add_subplot(211)
    new_ax = figure.add_subplot(212)
    
    axes.set_title('Average of ' + style)
    legend_labels = avg_Series.index
    def explode_sense(frequencies):
        explode = []
        for val in frequencies:
            if val > 0.02:
                explode.append(0)
            else:
                explode.append(0.2)
        return explode
    axes.axis('equal')
    new_ax.axis('off')
    explode = explode_sense(avg_Series.values)
    pie = axes.pie(x= avg_Series.values, labels=['%s, %1.1f%%' % (l, (float(s)) * 100) for l, s in zip(avg_Series.index, avg_Series.values)], colors = avg_Series.index, explode=explode, startangle=0)
    for text in pie[1]:
        text.set_color('white')
    
    new_ax.legend(pie[0], ['%s, %1.1f%%' % (l, (float(s)) * 100) for l, s in zip(avg_Series.index, avg_Series.values)], loc='center left')
    plt.show(figure)
    figure.clear()
        
        
average_by_style('cubism')