1.0--Selenium.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%reload_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from fastai.text import *\n",
    "from PIL import Image, ImageDraw, ImageOps, ImageFont, ImageEnhance, ImageFilter, ImageChops\n",
    "import pdb\n",
    "import textwrap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "PATH = Path('data/fonts/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# img_path = PATH/'fonts_resize'\n",
    "# df = pd.read_csv(PATH/'edited_font.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "#1050 width\n",
    "fonts = {'Indie Flower':29, 'Dancing Script':35, 'Pacifico':31, 'Shadows Into Light':33, 'Satisfy':33, 'Courgette':28,\n",
    " 'Caveat':38, 'Butterfly Kids':43, 'Kaushan Script':32, 'Great Vibes':40, 'Cookie':40, 'Tangerine':49,\n",
    " 'Gloria Hallelujah':25, 'Sacramento':38, 'Marck Script':30, 'Gochi Hand':30, 'Bad Script':33, 'Yellowtail':36,\n",
    " 'Parisienne':34, 'Schoolbell':31, 'Homemade Apple':22, 'Allura':37, 'Damion':35, 'Alex Brush':36,\n",
    " 'Covered By Your Grace':35, 'Italianno':48, 'Mr Dafoe':37, 'Nothing You Could Do':26, 'Pinyon Script':32,\n",
    " 'Niconne':37, 'Nanum Pen Script':36, 'Yesteryear':39, 'Reenie Beanie':34, 'Leckerli One':27, 'Arizonia':33,\n",
    " 'Just Another Hand':61, 'Coming Soon':27, 'Rochester':39, 'Grand Hotel':42,\n",
    " 'Nanum Brush Script':39, 'Norican':37, 'Annie Use Your Telescope':37, 'Sue Ellen Francisco':47,\n",
    " 'Herr Von MuellerHoff':49, 'Mr De Haviland':51, 'Calligraffitti':34, 'Kristi':50, 'Sofia':28, 'Aladin':38,\n",
    " 'The Girl Next Door':26, 'Give You Glory':27, 'Cedarville Cursive':27, 'Monsieur La Doulaise':36, 'Montez':40,\n",
    " 'Qwigley':53, 'Rouge Script':41, 'La Belle Aurore':29, 'Bilbo Swash Caps':45, 'Crafty Girls':24,\n",
    " 'Waiting for the Sunrise':32, 'Meddon':20, 'Aguafina Script':44, 'Loved By The King':39, 'Vibur':35,\n",
    " 'Just Me Again Down Here':42, 'Princess Sofia':37, 'Dawning Of A New Day':34, 'Mrs Saint Delafield':46,\n",
    " 'Over The Rainbow':27, 'Swanky and Moo Moo':31, 'Engagement':51, 'Mr Bedfort':33,\n",
    " 'Lovers Quarrel':54, 'Condiment':37, 'Charmonman':31, 'League Script':29, 'Bilbo':47, 'Gaegu':29, 'Stalemate':58,\n",
    " 'Julee':32, 'Jim Nightshade':43, 'Miss Fajardose':54, 'Ruthie':44, 'Dokdo':31, 'Mrs Sheppards':37, 'Dr Sugiyama':39,\n",
    " 'Felipa':34, 'Devonshire':42, 'East Sea Dokdo':43, 'Gamja Flower':35, 'Hi Melody':34, 'Ruge Boogie':40,\n",
    " 'Sunshiney':37, 'Romanesco':53, 'Lakki Reddy':28}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Combinations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "PATH = Path('data/IAM_handwriting')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a = pd.read_csv(PATH/'combo_cat_pg_dl_sorted.csv')\n",
    "b = pd.read_csv(PATH/'imdb_wiki_combo.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "b = b[['filename', 'label', 'num_lines']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df = pd.concat([a,b], ignore_index=True)\n",
    "len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a = pd.read_csv(PATH/'knot.csv', usecols=['filename', 'label'])\n",
    "# b = pd.read_csv(PATH/'imdb_unsup_21k_debug.csv', usecols=['filename', 'label'])\n",
    "c = pd.read_csv(PATH/'adrift.csv', usecols=['filename', 'label'])\n",
    "d = pd.read_csv(PATH/'zane.csv', usecols=['filename', 'label'])\n",
    "e = pd.read_csv(PATH/'american.csv', usecols=['filename', 'label'])\n",
    "f = pd.read_csv(PATH/'age.csv', usecols=['filename', 'label'])\n",
    "g = pd.read_csv(PATH/'room.csv', usecols=['filename', 'label'])\n",
    "df = pd.concat([a,c,d,e,f,g], ignore_index=True)\n",
    "len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# add num_lines to df\n",
    "lines = df.label.apply(lambda x: len(x.split('\\n'))) \n",
    "df['num_lines'] = lines.astype('int32')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.sort_values('num_lines', inplace=True)\n",
    "df.reset_index(inplace=True, drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.to_csv(PATH/'combo_145k.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### Move Images to new folder based on criteria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "lines = new.label.apply(lambda x: len(x.split('\\n'))) \n",
    "new['num_lines'] = lines.astype('int32')\n",
    "new.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "lines = new.label.apply(lambda x: sum(1 for c in x if c.isupper())) \n",
    "new['num_caps'] = lines.astype('int32')\n",
    "new.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "ten_lines = new[new.num_caps > 9]\n",
    "len(ten_lines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def move_images(fnames, src, targ):\n",
    "    for fname in fnames:\n",
    "        try:\n",
    "            os.rename(src/fname, targ/fname)\n",
    "        except FileNotFoundError:\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "src_path = PATH/'combo'\n",
    "targ_path = PATH/'combo_test'\n",
    "os.makedirs(targ_path, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "move_images(ten_lines.filename.values, src_path, targ_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### Populate df with only files left in directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "fnames = os.listdir(img_path)\n",
    "len(fnames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df = df[df.filename.isin(fnames)]\n",
    "len(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### Remove files not in df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "files = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "for filename in progress_bar(os.listdir(PATH/'fonts'), total=81256):\n",
    "    if filename not in new.filename.values:\n",
    "        files.append(filename)\n",
    "        os.rename(str(PATH/'fonts'/filename), str(PATH/'overflow_fonts'/filename))  # move\n",
    "#         os.remove(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# files = []\n",
    "for fname in progress_bar(mins.filename.values):\n",
    "#     files.append(fname)\n",
    "    os.rename(str(PATH/'fonts'/fname), str(PATH/'fonts_removed'/fname))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "len(files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "row = mins[mins.filename == 'zane_1508_0.png']\n",
    "print(mins.loc[row.index[0]]['label'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IMDB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "pre = 'imdb_'\n",
    "img_path = PATH/'imdb_wiki_combo'\n",
    "csv_path = PATH/'imdb.csv'\n",
    "\n",
    "df = pd.read_csv(Path('data/fonts/texts/imdb.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wiki103"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "pre = 'wiki_'\n",
    "img_path = PATH/'imdb_wiki_combo'\n",
    "csv_path = PATH/'wiki.csv'\n",
    "\n",
    "df = pd.read_csv(Path('data/fonts/texts/wiki103.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### Remove non ASCII chars and resave txt file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "with open(text_path) as file:  \n",
    "    text = file.read()\n",
    "\n",
    "text = re.sub(r'[^\\x00-\\x7F]+','', text)\n",
    "\n",
    "with open(str(text_path), \"w\") as text_file:\n",
    "    print(text, file=text_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Arthur - Cast Adrift"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "img_path = PATH/'adrift'\n",
    "csv_path = PATH/'adrift.csv'\n",
    "text_path = Path('data/texts/cast_adrift.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# combine\n",
    "df = pd.read_csv(csv_path)\n",
    "len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.to_csv(csv_path, columns=['filename', 'label'], index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Grey - Betty Zane"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "img_path = PATH/'zane'\n",
    "csv_path = PATH/'zane.csv'\n",
    "text_path = Path('data/texts/betty_zane.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# combine\n",
    "df = pd.read_csv(csv_path)\n",
    "len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.to_csv(csv_path, columns=['filename', 'label'], index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## James - The American"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "img_path = PATH/'american'\n",
    "csv_path = PATH/'american.csv'\n",
    "text_path = Path('data/texts/the_american.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# combine\n",
    "# a = pd.read_csv(PATH/'american0.csv', usecols=['filename', 'label'])\n",
    "# b = pd.read_csv(PATH/'american.csv', usecols=['filename', 'label'])\n",
    "# df = pd.concat([a,b], ignore_index=True)\n",
    "\n",
    "df = pd.read_csv(csv_path)\n",
    "len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "!ls {img_path} | wc -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.to_csv(csv_path, columns=['filename', 'label'], index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Wharton - Age of Innocence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "img_path = PATH/'age'\n",
    "csv_path = PATH/'age.csv'\n",
    "text_path = Path('data/texts/age_of_innocence.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# combine\n",
    "# a = pd.read_csv(PATH/'age0.csv', usecols=['filename', 'label'])\n",
    "# b = pd.read_csv(PATH/'age.csv', usecols=['filename', 'label'])\n",
    "# df = pd.concat([a,b], ignore_index=True)\n",
    "\n",
    "df = pd.read_csv(csv_path)\n",
    "len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "!ls {img_path} | wc -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.to_csv(csv_path, columns=['filename', 'label'], index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Forster - Room with a View"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "img_path = PATH/'room'\n",
    "csv_path = PATH/'room.csv'\n",
    "text_path = Path('data/texts/room_with_a_view.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# combine\n",
    "# a = pd.read_csv(PATH/'room0.csv', usecols=['filename', 'label'])\n",
    "# c = pd.read_csv(PATH/'room1.csv', usecols=['filename', 'label'])\n",
    "# b = pd.read_csv(PATH/'room.csv', usecols=['filename', 'label'])\n",
    "# df = pd.concat([a,c,b], ignore_index=True)\n",
    "\n",
    "df = pd.read_csv(csv_path)\n",
    "len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "!ls {img_path} | wc -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.sort_values('filename', inplace=True)\n",
    "df.reset_index(inplace=True, drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.to_csv(csv_path, columns=['filename', 'label'], index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Shaw - Irrational Knot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "img_path = PATH/'knot'\n",
    "csv_path = PATH/'knot.csv'\n",
    "text_path = Path('data/texts/irrational_knot.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# combine\n",
    "# a = pd.read_csv(PATH/'shaw_knot.csv')\n",
    "# b = pd.read_csv(PATH/'shaw_knot1.csv')\n",
    "# df = pd.concat([a,b], ignore_index=True)\n",
    "\n",
    "df = pd.read_csv(csv_path)\n",
    "len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.sort_values('filename', inplace=True)\n",
    "df.reset_index(inplace=True, drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.to_csv(csv_path, columns=['filename', 'label'], index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true
   },
   "source": [
    "# Text Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "with open(text_path) as file:  \n",
    "    text = file.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "text = text.replace('\\n',' ')\n",
    "lines = text.split('  ')\n",
    "len(lines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df = pd.DataFrame({'text': lines})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# remove small lines\n",
    "df['char_len'] = df.text.map(len)\n",
    "df = df[df['char_len'] > 15]\n",
    "df.sort_values('char_len', inplace=True)\n",
    "df.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import textwrap\n",
    "\n",
    "# truncate text len to 1000 w/ textwrap\n",
    "df['text'] = df.text.map(lambda x: textwrap.wrap(x, width=700, replace_whitespace=False)[0])\n",
    "df['char_len'] = df.text.map(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.sort_index(inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "texts = df.text.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "len(texts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Background"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# random image from folder\n",
    "def rand_from_folder(f_path):\n",
    "    files = [f for f in os.listdir(f_path) if not f.startswith(\".\")]  # remove .DS_Store and other hidden files\n",
    "    fname = random.choice(files)\n",
    "    return Image.open(f_path/fname).convert('L')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def skew_pixels(im, brightness=0.5, sharpness=-0.5):\n",
    "    '''increase brightness to lighten darks\n",
    "       decrease sharpness to spread values out\n",
    "    '''\n",
    "    enhance = ImageEnhance.Brightness(im)\n",
    "    im = enhance.enhance(1.0 + brightness)  # increase brightness\n",
    "    enhance = ImageEnhance.Sharpness(im)\n",
    "    im = enhance.enhance(1.0 + sharpness)  # decrease sharpness\n",
    "    return im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def overlay_bg(im, bg_img=None):\n",
    "    if bg_img is None:\n",
    "        bg_img = rand_from_folder(Path('data/IAM_handwriting/paragraphs'))\n",
    "    blur = 70 #random.randint(70,150) \n",
    "    bg = bg_img.filter(ImageFilter.GaussianBlur(blur))\n",
    "    # random flips\n",
    "    choices = [Image.FLIP_LEFT_RIGHT, Image.FLIP_TOP_BOTTOM, Image.ROTATE_90, Image.ROTATE_180, Image.ROTATE_270]\n",
    "    bg.transpose(random.choice(choices))\n",
    "\n",
    "    return ImageChops.darker(im, bg.resize(im.size))\n",
    "#     diff = PIL.ImageChops.difference(im, bg.resize(im.size))\n",
    "#     return PIL.ImageChops.subtract(im, diff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def poisson_noise(image, mod=1.5):\n",
    "    image = np.array(image)\n",
    "    # Determine unique values in image & calculate the next power of two\n",
    "    vals = len(np.unique(image))\n",
    "    vals = mod ** np.ceil(np.log2(vals))\n",
    "\n",
    "    # Generating noise for each unique value in image.\n",
    "    out = np.random.poisson(image * vals) / float(vals)\n",
    "    return Image.fromarray(out.astype('uint8'), mode='L')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def crop_image(im):    \n",
    "    bg = Image.new(im.mode, im.size, im.getpixel((0,0)))\n",
    "    diff = ImageChops.difference(im, bg)\n",
    "    diff = ImageChops.add(diff, diff, 2.0, -100)\n",
    "    box = diff.getbbox()\n",
    "    return im.crop(box)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def pad_image(im, pad_range=(10,50)):\n",
    "    \"adjusted to minimize large ratio differences\"\n",
    "    row,col = im.size\n",
    "    bg_color = im.getpixel((0,0))\n",
    "    l = int(random.randint(*pad_range) * col/row)\n",
    "    u = int(random.randint(*pad_range) * row/col)\n",
    "    r = int(random.randint(*pad_range) * col/row)\n",
    "    b = int(random.randint(*pad_range) * row/col)\n",
    "    #print(l,u,r,b)\n",
    "    return ImageOps.expand(im, border=(l,u,r,b), fill=bg_color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def add_background(img, crop=True, pad=True, skew=True, bg=True, poisson=True):\n",
    "    if crop: img = crop_image(img)\n",
    "    if pad: img = pad_image(img)\n",
    "    if skew: img = skew_pixels(img)\n",
    "    if bg: img = overlay_bg(img)\n",
    "    if poisson: img = poisson_noise(img, 1.8)\n",
    "    return img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PIL generate images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "class FontGenerator:\n",
    "    def __init__(self, texts, fonts, font_path=None, size=(1050,1000), xy=(10,10)):\n",
    "        self.texts = texts\n",
    "        self.fonts = fonts\n",
    "        self.font_path = font_path or \"./data/fonts/font_files/\"\n",
    "        self.size = size\n",
    "        self.xy = xy\n",
    "        self.results = []\n",
    "        \n",
    "    def create_images(self, total, img_path, pre='', offset=0):\n",
    "        for idx in progress_bar(range(offset, total)):\n",
    "            font = self.font_type()\n",
    "            t,nl = self.random_text()\n",
    "            image = self.text_image(t, font)\n",
    "            image = add_background(image)\n",
    "            fname = pre+'{:05d}'.format(idx)+'.png'\n",
    "            image.save(str(img_path/fname))\n",
    "            o = {'filename':fname, 'label':t, 'font_name':font.getname()[0], 'font_size':font.size, 'num_lines': nl}\n",
    "            self.results.append(o)\n",
    "\n",
    "    def save_csv(self, csv_path):\n",
    "        pd.DataFrame(self.results).to_csv(csv_path, index=False)\n",
    "        \n",
    "    def font_type(self, name=None, size=None):\n",
    "        name = name or random.choice(list(self.fonts.keys()))\n",
    "        size = size or int(self.fonts[name]) - random.randint(0,5)\n",
    "        name = name.replace(' ','')+'-Regular.ttf'\n",
    "        return ImageFont.truetype(self.font_path+name, size)\n",
    "\n",
    "    def text_image(self, text, font):\n",
    "        bg = random.randrange(240,255)\n",
    "        image = Image.new(\"L\", self.size, color=bg)\n",
    "        spacing = random.randrange(10,40)\n",
    "        color = random.randrange(10,80)\n",
    "        draw = ImageDraw.Draw(image)\n",
    "        draw.text(self.xy, text, fill=color, font=font, spacing=spacing)\n",
    "        return image\n",
    "\n",
    "    def random_text(self):\n",
    "        t = np.random.choice(self.texts)\n",
    "        t = textwrap.fill(t, width=60-random.randint(0,10))\n",
    "        t = t.split('\\n')[:10]      # only keep maximum 10 lines    \n",
    "        nl = len(t)\n",
    "        return '\\n'.join(t), nl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "fg = FontGenerator(df.text.values, fonts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "img_path, csv_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# !rm -rf {img_path}\n",
    "# os.makedirs(img_path, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "fg.create_images(50000, img_path, pre)\n",
    "fg.save_csv(csv_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "csv = pd.read_csv(csv_path)\n",
    "csv.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Google Fonts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "img_path = PATH/'test'\n",
    "csv_path = PATH/'test.csv'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from selenium import webdriver\n",
    "from selenium.webdriver import ActionChains\n",
    "from selenium.webdriver.chrome.options import Options\n",
    "from selenium.webdriver.support.ui import WebDriverWait\n",
    "from selenium.webdriver.support import expected_conditions as EC\n",
    "from selenium.webdriver.common.keys import Keys\n",
    "from selenium.webdriver.common.by import By"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# def set_font_size(driver, actions, value):\n",
    "#     slider = driver.find_element_by_class_name('md-track-container') # whole container not just the slider\n",
    "#     width = slider.size['width']\n",
    "#     s_max,s_min = 300,8\n",
    "#     step = width / (s_max - s_min)\n",
    "#     val = int(step * (value - s_min + 1))\n",
    "#     actions.click_and_hold(slider).move_by_offset(-width//2,0).move_by_offset(val,0).release().perform()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "class SeleniumFontGenerator:\n",
    "    def __init__(self, opts, fonts):\n",
    "        self.options = opts\n",
    "        self.fonts = fonts\n",
    "        self.results = []\n",
    "        self.driver, self.actions, self.wait = None, None, None\n",
    "        \n",
    "    def new_driver(self):\n",
    "        self.driver, self.actions, self.wait = self.driver_setup()\n",
    "    \n",
    "    def page_setup(self, font_name=None, font_size=None, pad_top=10):\n",
    "        self.font_name = font_name or random.choice(list(self.fonts.keys()))\n",
    "        self.font_size = font_size or int(self.fonts[name]) - random.randint(1,5)\n",
    "#         self.letter_spacing = random.randrange(-0.0, , step=0.01)\n",
    "        self.pad_top = pad_top\n",
    "        self.font_input = self.set_font()\n",
    "        self.text_form = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'font-preview-text')))\n",
    "        #self.set_text_settings()  need to set text settings after inputting text...\n",
    "                \n",
    "    def save_image(self, t, img_path, fname):\n",
    "        if '\\n' not in t:\n",
    "            t = textwrap.fill(t, width=60-random.randint(0,10))\n",
    "            # this is here for individual verification purposes...\n",
    "        t = t.split('\\n')[:10]      # only keep maximum 10 lines    \n",
    "        nl = len(t)\n",
    "        t = '\\n'.join(t)\n",
    "\n",
    "        self.input_text(t)\n",
    "        self.set_text_settings()\n",
    "        \n",
    "        # fix unintentional line breaks text\n",
    "        while not self.compare_heights(nl):\n",
    "            self.font_size -= 5\n",
    "            self.set_text_settings()\n",
    "\n",
    "        # fix overflow text\n",
    "        while not self.hide_cursor():                  \n",
    "            t = t.split('\\n')[:-2]  # remove last 2 lines at a time\n",
    "            nl = len(t)\n",
    "            t = '\\n'.join(t)\n",
    "            self.input_text(t)\n",
    "            self.set_text_settings()\n",
    "\n",
    "        self.text_form.screenshot(str(img_path/fname))\n",
    "        out = {'filename':fname, 'label':t, 'font_name':self.font_name, 'font_size':self.font_size,\n",
    "               'num_lines': nl, 'line_height':self.line_height(), 'height':self.actual_height()}\n",
    "        self.results.append(out)\n",
    "        \n",
    "    def set_font(self):\n",
    "        font_input = self.wait.until(EC.element_to_be_clickable((By.ID, 'input_4')))\n",
    "        font_input.clear()\n",
    "        font_input.send_keys(self.font_name)\n",
    "        return font_input\n",
    "    \n",
    "    def input_text(self, text):\n",
    "        self.text_form.clear()\n",
    "        self.text_form.send_keys(text)\n",
    "        \n",
    "    def compare_heights(self, nl):\n",
    "        exp = max(132, nl*self.font_size*self.line_height()+self.pad_top)\n",
    "        act = self.actual_height()\n",
    "        return (exp>=act and act<=940)  \n",
    "    \n",
    "    def hide_cursor(self):\n",
    "        try:\n",
    "            self.font_input.send_keys(\"\")\n",
    "            return True\n",
    "        except:\n",
    "            return False\n",
    "    \n",
    "    def set_text_settings(self):\n",
    "        tf = self.text_form\n",
    "        self.driver.execute_script(f\"arguments[0].style.fontSize = '{self.font_size}px';\", tf)\n",
    "        self.driver.execute_script(f\"arguments[0].style.lineHeight = {self.line_height()};\", tf)\n",
    "        self.driver.execute_script(f\"arguments[0].style.paddingTop = '{self.pad_top}px';\", tf)\n",
    "        self.driver.execute_script(f\"arguments[0].style.letterSpacing = '-.08em';\", tf)\n",
    "\n",
    "    def line_height(self): return -0.01*self.font_size+1.55 + 0.6\n",
    "    def actual_height(self): return self.text_form.size['height']\n",
    "    def close(self): self.driver.close()\n",
    "    \n",
    "    def driver_setup(self):\n",
    "        try:\n",
    "            self.close()\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "        driver = webdriver.Chrome(options=self.options)\n",
    "        driver.get('https://fonts.google.com/?category=Handwriting')\n",
    "        #view as list\n",
    "        driver.find_element_by_class_name('font-preview-layout-toggle-button').click()\n",
    "        # remove scroll-to-top button\n",
    "        scroll_btn = driver.find_element_by_class_name('scroll-top-button-fab')\n",
    "        driver.execute_script(\"arguments[0].parentNode.removeChild(arguments[0]);\", scroll_btn)\n",
    "        # remove footer\n",
    "        footer = driver.find_element_by_id('footer')\n",
    "        driver.execute_script(\"arguments[0].parentNode.removeChild(arguments[0]);\", footer)\n",
    "        return driver, ActionChains(driver), WebDriverWait(driver, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## bulk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "options = Options()\n",
    "options.add_argument(\"--headless\")  \n",
    "options.add_argument(\"--window-size=1050,1000\")   #(\"--window-size=%s\" % WINDOW_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def save_images(total, texts, num, img_path, csv_path, pre='', offset=0):\n",
    "    sfg = SeleniumFontGenerator(options, fonts)\n",
    "    try:\n",
    "        for idx in progress_bar(range(offset, total)):\n",
    "            if sfg.driver is None: sfg.new_driver()\n",
    "            # reset driver every now and then to keep from getting throttled\n",
    "            if idx%10 == 0: sfg.new_driver()\n",
    "            sfg.page_setup()\n",
    "            ts = np.random.choice(texts, num)\n",
    "            for i,t in enumerate(ts):\n",
    "                fname = pre+'{:04d}'.format(idx)+f\"_{i}.png\"\n",
    "                sfg.save_image(t, img_path, fname)\n",
    "    except:\n",
    "        print(sys.exc_info())\n",
    "        sfg.driver.save_screenshot(str(Path('data/fonts/fail.png')))\n",
    "    finally:\n",
    "        pd.DataFrame(sfg.results).to_csv(csv_path, index=False)\n",
    "        return sfg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "csv_path = PATH/'room1.csv'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "img_path, csv_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# !rm -rf {img_path}\n",
    "# os.makedirs(img_path, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sfg = save_images(10000, texts, 5, img_path, csv_path, pre='full_', offset=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "sfg.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Individual"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "options = Options()\n",
    "# options.add_argument(\"--headless\")\n",
    "options.add_argument(\"--window-size=1050,1000\")   #(\"--window-size=%s\" % WINDOW_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "t = \"Yes, go and bathe, George. Why do you dawdle talking? Bring\\nthem back to tea. Bring back some milk, cakes, honey. The\\nchange will do you good. George has been working very hard\\nat his office. I can't believe he's well.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "t = \"Now, this was abominably impertinent, and she ought to have been furious. But it is sometimes as difficult to lose one's temper as it is difficult at other times to keep it. Lucy could not get cross. Mr. Emerson was an old man, and surely a girl might humour him. On the other hand, his son was a young man, and she felt that a girl ought to be offended with him, or at all events be offended before him. It was at him that she gazed before replying. Now, this was abominably impertinent, and she ought to have been furious. But it is sometimes as difficult to lose one's temper as it is difficult at other times to keep it. Lucy could not get cross. Mr. Emerson was an old man, and surely a girl might humour him. On the other hand, his son was a young man, and she felt that a girl ought to be offended with him, or at all events be offended before him. It was at him that she gazed before replying.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "nl = 10\n",
    "t = \"Now, this was abominably impertinent, and she ought to\\nhave been furious. But it is sometimes as difficult to\\nlose one's temper as it is difficult at other times to\\nkeep it. Lucy could not get cross. Mr. Emerson was an old\\nman, and surely a girl might humour him. On the other\\nhand, his son was a young man, and she felt that a girl\\nought to be offended with him, or at all events be\\noffended before him. It was at him that she gazed before\\nreplying. Now, this was abominably impertinent, and she\\nought to have been furious. But it is sometimes as\"\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sfg = SeleniumFontGenerator(options, fonts)\n",
    "sfg.new_driver()\n",
    "sfg.page_setup('Romanesco', 58)\n",
    "test_path = Path('data/fonts')\n",
    "fname = 'test.png'\n",
    "sfg.save_image(t, test_path, fname)\n",
    "print(sfg.results[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "sfg.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Scripts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "t = \"Now, this was abominably impertinent, and she\\nought to have been furious. But it is sometimes as\\ndifficult to lose one's temper as it is difficult\\nat other times to keep it. Lucy could not get\\ncross. Mr. Emerson was an old man, and surely a\\ngirl might humour him. On the other hand, his son\\nwas a young man, and she felt that a girl ought to\\nbe offended with him, or at all events be offended\\nbefore him. It was at him that she gazed before\\nreplying.\\nNow, this was abominably impertinent, and she\\nought to have been furious. But it is sometimes as\\ndifficult to lose one's temper as it is difficult\\nat other times to keep it. Lucy could not get\\ncross. Mr. Emerson was an old man, and surely a\\ngirl might humour him. On the other hand, his son\\nwas a young man, and she felt that a girl ought to\\nbe offended with him, or at all events be offended\\nbefore him. It was at him that she gazed before\\nreplying.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## Comparing img heights w/ estimated heights by font/size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### Calculating Estimated Line Heights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def set_font(wait, fontName):\n",
    "    font_input = wait.until(EC.element_to_be_clickable((By.ID, 'input_4')))\n",
    "    font_input.clear()\n",
    "    font_input.send_keys(fontName)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def determine_max_line_heights(csv_path):\n",
    "    res = []\n",
    "    txt = \"ABC\\nDEF\\nGHI\\nJKL\\nMNO\\nPQR\\nSTU\\nVWX\"\n",
    "    driver = None\n",
    "    \n",
    "    try:\n",
    "        for name,size in progress_bar(fonts.items(), total=len(fonts)): \n",
    "            driver,actions,wait = new_driver(driver)\n",
    "            set_font(wait, name)\n",
    "\n",
    "            text_form = wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'font-preview-text')))\n",
    "            text_form.clear()\n",
    "            text_form.send_keys(txt)\n",
    "\n",
    "            for sz in range(size-5,size):\n",
    "                set_font_size(driver, actions, sz)\n",
    "                total = text_form.size['height']\n",
    "                res.append({'font': name, 'size': sz, 'line_height': total//8})\n",
    "    finally:\n",
    "        pd.DataFrame(res).to_csv(csv_path, index=False)\n",
    "        driver.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "lh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "determine_max_line_heights(PATH/'line_heights.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "1.8-.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### Calculating Actual/Expected Heights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "lh = pd.read_csv(PATH/'line_heights.csv')\n",
    "lh.set_index(['font', 'size'], inplace=True)  #multi-index\n",
    "# lh.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def img_height(row):\n",
    "    with Image.open(img_path/row['filename']) as img:\n",
    "        return img.size[1]\n",
    "    \n",
    "def expected_height(row):\n",
    "    try:\n",
    "        h = lh.loc[row['font'], row['size']].line_height\n",
    "    except TypeError:\n",
    "        h = lh.loc[row['font']].values.flatten()[0]  #size is missing: choose smallest size\n",
    "    nl = len(row['label'].split('\\n'))\n",
    "    return max(264, h * nl * 2)  # 264 is minimum height\n",
    "\n",
    "\n",
    "def set_heights(df):\n",
    "    heights = df.apply(lambda x: img_height(x), axis=1)  \n",
    "    df['height'] = heights.astype('int32')\n",
    "    \n",
    "#     hgt = df.apply(lambda x: expected_height(x), axis=1)  \n",
    "#     df['exp_height'] = hgt.astype('int32')\n",
    "    \n",
    "#     df['diff'] = df.apply(lambda row: (row['height'] - row['exp_height']), axis=1)\n",
    "    \n",
    "    \n",
    "def taller_than_expected(df): return df[df['diff'] > 0].sort_values('diff', ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# set_heights(df)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# calculate character lengths\n",
    "lgts = df.label.apply(len)  \n",
    "df['char_len'] = lgts.astype('int32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "more = taller_than_expected(df)\n",
    "len(more)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### Remove from df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.drop(more.index.values, inplace=True)\n",
    "len(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### Check images below minimum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "mins = df[(df['height'] < 265) & (df['char_len'] > 65)]\n",
    "len(mins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "im = PIL.Image.open(PATH/'fonts_removed'/'zane_1507_1.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "im.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "img_path = PATH/'fonts_removed'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def trim(im):\n",
    "    bg = PIL.Image.new(im.mode, im.size, im.getpixel((0,0)))\n",
    "    diff = PIL.ImageChops.difference(im, bg)\n",
    "    diff = PIL.ImageChops.add(diff, diff, 2.0, -100)\n",
    "    bbox = diff.getbbox()\n",
    "    if bbox:\n",
    "        return im.crop(bbox).size[1]\n",
    "    else:\n",
    "        return 264\n",
    "    \n",
    "def trimmed_height(row):\n",
    "    with PIL.Image.open(img_path/row['filename']) as img:\n",
    "        return trim(img)\n",
    "    \n",
    "def set_heights(df):\n",
    "    heights = df.apply(lambda x: trimmed_height(x), axis=1)\n",
    "    df['height'] = heights.astype('int32')\n",
    "    \n",
    "    nl = df.label.apply(lambda x: len(x.split('\\n')))  \n",
    "    df['num_lines'] = nl.astype('int32')\n",
    "    \n",
    "#     df['diff'] = df.apply(lambda row: (row['height'] - row['exp_height']), axis=1)\n",
    "    \n",
    "    \n",
    "def taller_than_expected(df): return df[df['diff'] > 0].sort_values('diff', ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "set_heights(mins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "mins[mins['height']<10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "more = taller_than_expected(df)\n",
    "len(more)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Replace overflowing images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def replace_images(df, img_path):\n",
    "    driver = None\n",
    "    try:\n",
    "        for idx,row in progress_bar(df.iterrows(), total=len(df)):\n",
    "            if idx%20 == 0: driver,actions,wait = new_driver(driver)\n",
    "\n",
    "            # set font name and size\n",
    "            name = random.choice(list(fonts.keys()))\n",
    "            #font_input = driver.find_element_by_id('input_4')\n",
    "            font_input = wait.until(EC.element_to_be_clickable((By.ID, 'input_4')))\n",
    "            font_input.clear()\n",
    "            font_input.send_keys(name)\n",
    "            size = fonts[name] - 10 #random.randint(1,5)\n",
    "            set_font_size(driver, actions, size)\n",
    "\n",
    "            text_form = wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'font-preview-text')))\n",
    "            text_form.clear()\n",
    "            text_form.send_keys(t)\n",
    "            # remove cursor\n",
    "            font_input.send_keys(\"\")\n",
    "                # save img\n",
    "                fname = pre+'{:04d}'.format(idx+offset)+f\"_{i}.png\"\n",
    "                text_form.screenshot(str(img_path/fname))\n",
    "                res.append({'filename':fname, 'label':t, 'font':name, 'size':size})\n",
    "    except:\n",
    "        print(sys.exc_info())\n",
    "        driver.save_screenshot(str(img_path/'fail.png'))\n",
    "    finally:\n",
    "        pd.DataFrame(res).to_csv(csv_path, index=False)\n",
    "        driver.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "img_path, csv_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# !rm -rf {img_path}\n",
    "os.makedirs(img_path, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "save_images(1155, texts, 5, img_path, csv_path, pre='imdb_unsup_', offset=2846)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Naive check for overflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def text_overflow(txt, text_form):\n",
    "    st = \"\\nABCDEFGHI\\nJKLMNOPQR\\nSTUVWXYZ\\n\"\n",
    "    st += txt\n",
    "    num_lines = len(st.split(\"\\n\"))\n",
    "    text_form.clear()\n",
    "    text_form.send_keys(st)\n",
    "    line_height = text_form.find_element_by_xpath(\"div[3]\").size['height']\n",
    "    total_height = text_form.size['height']\n",
    "    return total_height != line_height * num_lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def check_images_for_overflow(csv_path, img_path):\n",
    "    df = pd.read_csv(csv_path)\n",
    "    pageFont,pageSize = None,None\n",
    "    driver = None\n",
    "    redo = False\n",
    "    \n",
    "    for idx,row in progress_bar(df.iterrows(), total=len(df)):\n",
    "        if idx%20 == 0: driver,actions,wait = new_driver(driver)\n",
    "            \n",
    "        fname,txt,rowFont,rowSize = row['filename'],row['label'],row['font'],row['size']\n",
    "        if pageFont != rowFont: set_font(wait, rowFont)\n",
    "        if pageSize != rowSize: set_font_size(driver, actions, rowSize)\n",
    "        \n",
    "        text_form = wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'font-preview-text')))\n",
    "        while text_overflow(txt, text_form):\n",
    "            redo = True\n",
    "            set_font_size(driver, actions, rowSize-5)\n",
    "        \n",
    "        if redo:\n",
    "            text_form.clear()\n",
    "            text_form.send_keys(txt)\n",
    "        \n",
    "            # remove cursor\n",
    "            set_font(wait, rowFont)\n",
    "\n",
    "            new_path = str(img_path)+'_overflow/'+fname\n",
    "            text_form.screenshot(new_path)\n",
    "        redo = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "img_path, csv_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "os.makedirs(str(img_path)+'_overflow/', exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "check_images_for_overflow(PATH/'imdb_unsup_20k_debug.csv', img_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {}
   },
   "source": [
    "# Verify"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# df_v = pd.read_csv(csv_path)\n",
    "# len(df_v)\n",
    "\n",
    "# df_v.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "y = iter(range(len(csv)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "i = next(y) #random.randrange(0,5000) #\n",
    "row = csv.iloc[i]\n",
    "im = Image.open(img_path/row.filename)\n",
    "fig,ax = plt.subplots(figsize=(18,12))\n",
    "ax.imshow(im)\n",
    "print(row.filename)\n",
    "print(row.label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {},
    "heading_collapsed": true,
    "hidden": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}