src/cocktails/utilities/analysis_utilities.py

import numpy as np
import matplotlib.pyplot as plt

from src.cocktails.utilities.ingredients_utilities import ingredient_list, extract_ingredients, ingredients_per_type

color_codes = dict(ancestral='#000000',
                   spirit_forward='#2320D2',
                   duo='#6E20D2',
                   champagne_cocktail='#25FFCA',
                   complex_highball='#068F25',
                   simple_highball='#25FF57',
                   collins='#77FF96',
                   julep='#25B8FF',
                   simple_sour='#FBD756',
                   complex_sour='#DCAD07',
                   simple_sour_with_juice='#FF5033',
                   complex_sour_with_juice='#D42306',
                   # simple_sour_with_egg='#FF9C54',
                   # complex_sour_with_egg='#CF5700',
                   # almost_simple_sor='#FF5033',
                   # almost_sor='#D42306',
                   # almost_sor_with_egg='#D42306',
                   other='#9B9B9B'
                   )

def get_subcategories(data):
    subcategories = np.array(data['subcategory'])
    sub_categories_list = sorted(set(subcategories))
    subcat_count = dict(zip(sub_categories_list, [0] * len(sub_categories_list)))
    for sc in data['subcategory']:
        subcat_count[sc] += 1
    return subcategories, sub_categories_list, subcat_count

def get_ingredient_count(data):
    ingredient_counts = dict(zip(ingredient_list, [0] * len(ingredient_list)))
    for ing_str in data['ingredients_str']:
        ingredients, _ = extract_ingredients(ing_str)
        for ing in ingredients:
            ingredient_counts[ing] += 1
    return ingredient_counts

def compute_eucl_dist(a, b):
    return np.sqrt(np.sum((a - b)**2))

def recipe_contains(ingredients, stuff):
    if stuff in ingredient_list:
        return stuff in ingredients
    elif stuff == 'juice':
        return any(['juice' in ing and 'lemon' not in ing and 'lime' not in ing for ing in ingredients])
    elif stuff == 'bubbles':
        return any([ing in ['soda', 'tonic', 'cola', 'sparkling wine', 'ginger beer'] for ing in ingredients])
    elif stuff == 'acid':
        return any([ing in ['lemon juice', 'lime juice'] for ing in ingredients])
    elif stuff == 'vermouth':
        return any([ing in ingredients_per_type['vermouth'] for ing in ingredients])
    elif stuff == 'plain sweet':
        plain_sweet = ingredients_per_type['sweeteners']
        return any([ing in plain_sweet for ing in ingredients])
    elif stuff == 'sweet':
        sweet = ingredients_per_type['sweeteners'] + ingredients_per_type['liqueur'] + ['sweet vermouth', 'lillet blanc']
        return any([ing in sweet for ing in ingredients])
    elif stuff == 'spirit':
        return any([ing in ingredients_per_type['liquor'] for ing in ingredients])
    else:
        raise ValueError



def radar_factory(num_vars, frame='circle'):
    # from stackoverflow's post? Or matplotlib's blog
    """
    Create a radar chart with `num_vars` axes.

    This function creates a RadarAxes projection and registers it.

    Parameters
    ----------
    num_vars : int
        Number of variables for radar chart.
    frame : {'circle', 'polygon'}
        Shape of frame surrounding axes.

    """
    import numpy as np

    from matplotlib.patches import Circle, RegularPolygon
    from matplotlib.path import Path
    from matplotlib.projections.polar import PolarAxes
    from matplotlib.projections import register_projection
    from matplotlib.spines import Spine
    from matplotlib.transforms import Affine2D
    # calculate evenly-spaced axis angles
    theta = np.linspace(0, 2*np.pi, num_vars, endpoint=False)

    class RadarAxes(PolarAxes):

        name = 'radar'
        # use 1 line segment to connect specified points
        RESOLUTION = 1

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)
            # rotate plot such that the first axis is at the top
            self.set_theta_zero_location('N')

        def fill(self, *args, closed=True, **kwargs):
            """Override fill so that line is closed by default"""
            return super().fill(closed=closed, *args, **kwargs)

        def plot(self, *args, **kwargs):
            """Override plot so that line is closed by default"""
            lines = super().plot(*args, **kwargs)
            for line in lines:
                self._close_line(line)

        def _close_line(self, line):
            x, y = line.get_data()
            # FIXME: markers at x[0], y[0] get doubled-up
            if x[0] != x[-1]:
                x = np.append(x, x[0])
                y = np.append(y, y[0])
                line.set_data(x, y)

        def set_varlabels(self, labels):
            self.set_thetagrids(np.degrees(theta), labels)

        def _gen_axes_patch(self):
            # The Axes patch must be centered at (0.5, 0.5) and of radius 0.5
            # in axes coordinates.
            if frame == 'circle':
                return Circle((0.5, 0.5), 0.5)
            elif frame == 'polygon':
                return RegularPolygon((0.5, 0.5), num_vars,
                                      radius=.5, edgecolor="k")
            else:
                raise ValueError("Unknown value for 'frame': %s" % frame)

        def _gen_axes_spines(self):
            if frame == 'circle':
                return super()._gen_axes_spines()
            elif frame == 'polygon':
                # spine_type must be 'left'/'right'/'top'/'bottom'/'circle'.
                spine = Spine(axes=self,
                              spine_type='circle',
                              path=Path.unit_regular_polygon(num_vars))
                # unit_regular_polygon gives a polygon of radius 1 centered at
                # (0, 0) but we want a polygon of radius 0.5 centered at (0.5,
                # 0.5) in axes coordinates.
                spine.set_transform(Affine2D().scale(.5).translate(.5, .5)
                                    + self.transAxes)
                return {'polar': spine}
            else:
                raise ValueError("Unknown value for 'frame': %s" % frame)

    register_projection(RadarAxes)
    return theta

def plot_radar_cocktail(representation, labels_dim, labels_cocktails, save_path=None, to_show=False, to_save=False):
    assert to_show or to_save, 'either show or save'
    assert representation.ndim == 2
    n_data, dim_rep = representation.shape
    assert len(labels_cocktails) == n_data
    assert len(labels_dim) == dim_rep
    assert n_data <= 5, 'max 5 representation_analysis please'

    theta = radar_factory(dim_rep, frame='circle')


    fig, ax = plt.subplots(figsize=(9, 9), subplot_kw=dict(projection='radar'))
    fig.subplots_adjust(wspace=0.25, hspace=0.20, top=0.85, bottom=0.05)

    colors = ['b', 'r', 'g', 'm', 'y']
    # Plot the four cases from the example data on separate axes
    ax.set_rgrids([0.2, 0.4, 0.6, 0.8])
    for d, color in zip(representation, colors):
        ax.plot(theta, d, color=color)
    for d, color in zip(representation, colors):
        ax.fill(theta, d, facecolor=color, alpha=0.25)
    ax.set_varlabels(labels_dim)

    # add legend relative to top-left plot
    legend = ax.legend(labels_cocktails, loc=(0.9, .95),
                       labelspacing=0.1, fontsize='small')

    if to_save:
        plt.savefig(save_path, bbox_artists=(legend,), dpi=200)
    else:
        plt.show()