diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..0ed1831d569fe1f5e6e10107494d96f180520f97 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +PixHtLab-Src/Demo/PixhtLab/Examples/c82c09fc01e84282bc8870c263dcf81b_bg.jpg filter=lfs diff=lfs merge=lfs -text diff --git a/PixHtLab-Src/.gitignore b/PixHtLab-Src/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..7ddcc89b29662dddf170f1d849c05ea67fa9f0f5 --- /dev/null +++ b/PixHtLab-Src/.gitignore @@ -0,0 +1,5 @@ +.DS_Store +.idea +*.log +tmp/ +*__pycache__* diff --git a/PixHtLab-Src/Data/data_prepare.py b/PixHtLab-Src/Data/data_prepare.py new file mode 100644 index 0000000000000000000000000000000000000000..3fc09935b6560d28becd0487f17c9cd534fc1b18 --- /dev/null +++ b/PixHtLab-Src/Data/data_prepare.py @@ -0,0 +1,21 @@ +import objaverse +import multiprocessing +import random + +processes = 8 + +random.seed(0) +uids = objaverse.load_uids() +random_object_uids = random.sample(uids, 100) +objects = objaverse.load_objects( + uids=random_object_uids, + download_processes=processes +) + + +objects = objaverse.load_objects( + uids=random_object_uids, + download_processes=processes +) + +import pdb; pdb.set_trace() diff --git a/PixHtLab-Src/Demo/PixhtLab/Demo.ipynb b/PixHtLab-Src/Demo/PixhtLab/Demo.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..8e7e09f3a3f5dc2be67e81d3d4505b42dc8cd806 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Demo.ipynb @@ -0,0 +1,368 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "172c2554-0698-4666-ba18-769b1abbb9a7", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import os \n", + "from os.path import join \n", + "from glob import glob \n", + "from tqdm.auto import tqdm\n", + "from torchvision import utils\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from hshadow_render import hshadow_render\n", + "from hshadow_render import style_hardshadow as softshadow_render\n", + "\n", + "import sys\n", + "import inspect\n", + "\n", + "from camera import axis_camera\n", + "from reflect_render import *\n", + "from xyh_proj import xyz2xyh, xyh2xyz, compute_normal, get_ray_mat, normalize_vec3\n", + "\n", + "def show(img, title=''):\n", + " print(img.shape, img.min(), img.max())\n", + " plt.figure(figsize=(15,10))\n", + " plt.imshow(img)\n", + " plt.title(title)\n", + " plt.show()\n", + "\n", + "def show_tensor(tensor,title=''):\n", + " img = utils.make_grid(tensor).detach().cpu().numpy().transpose(1,2,0)\n", + " show(img, title=title)\n", + "\n", + "def parse_configs(config):\n", + " with open(config, 'r') as stream:\n", + " try:\n", + " configs=yaml.safe_load(stream)\n", + " return configs\n", + " except yaml.YAMLError as exc:\n", + " logging.error(exc)\n", + " return {}\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4ab6a6c2-0706-4976-8fc4-3aa5ea491532", + "metadata": {}, + "outputs": [], + "source": [ + "# shadow related functions \n", + "def proj_horizon_plane(p):\n", + " pp = p.copy()\n", + " pp[1] = pp[1] + pp[2] \n", + " pp[2] = pp[2] * 0.0\n", + " return pp\n", + "\n", + "def compute_light_pos(p0, p1, light_horizon):\n", + " \"\"\" Given a pair of xyh and light h, compute the light height\n", + " \"\"\" \n", + " if len(p0) != 3 or len(p1) !=3:\n", + " raise ValueError('Input size {},{} is wrong(should be 3).'.format(p0.shape, p1.shape))\n", + "\n", + " x0, y0, h0, x1, y1, h1 = p0[0], p0[1], p0[2], p1[0], p1[1], p1[2]\n", + " light_sign = ((y1+h1)-(y0+h0))/np.abs((y1+h1)-(y0+h0))\n", + " print('light sign: ', light_sign)\n", + "\n", + " # import pdb; pdb.set_trace()\n", + " pp0, pp1 = proj_horizon_plane(p0), proj_horizon_plane(p1) \n", + " t = (light_horizon - pp0[1])/(pp1[1]-pp0[1])\n", + " lightx, lighty, lighth = (1.0-t)*x0 + t*x1, (1.0-t)*y0+t*y1, (1.0-t)*h0 + t * h1\n", + " return np.array([lightx, lighty, lighth])\n", + "\n", + "\n", + "from __future__ import print_function\n", + "from ipywidgets import interact, interactive, fixed, interact_manual\n", + "import ipywidgets as widgets\n", + "\n", + "def composite(rgb, mask, shadow):\n", + " return rgb * mask + (1.0-mask) * shadow" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ff428e6c-7db3-4216-bfea-019c0340811d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def composite_reflection(rgb, mask, fg_pixht, bg_rgba, bg_pixht, rechmap, horizon, sample=10, glossness=0.05):\n", + " params = {\n", + " 'sample_n': sample,\n", + " 'horizon': horizon,\n", + " 'ref_idx': 0.3,\n", + " 'glossness': glossness,\n", + " 'dh': 1.0,\n", + " 'batch_size': 1,\n", + " 'reflect_alpha': 1.0,\n", + " 'camera_h': 10\n", + " }\n", + " \n", + " fg_rgba = np.concatenate([rgb, mask], axis=2)\n", + " fg_height = fg_pixht\n", + " bg_height = rechmap\n", + " bg_reflection_layer = bg_rgba[..., -1:]\n", + "\n", + " reflection_rgb = reflection_layer(fg_rgba, fg_height, bg_rgba, bg_height, bg_reflection_layer, params)\n", + " \n", + " comp = rgb * mask + (1.0-mask) * reflection_rgb\n", + " return comp\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5047268d-acf2-4d87-9659-83f4c6b38eb5", + "metadata": {}, + "outputs": [], + "source": [ + "def render_shadow(rgb, mask, fg_pixht, bg_pixht, rechmap, x, y, horizon, softness=0.9):\n", + " tmphmap = mask * fg_pixht\n", + " mask_top_pos = list(np.unravel_index(np.argmax(tmphmap), tmphmap.shape))\n", + " mask_top_pos = [mask_top_pos[1], mask_top_pos[0], tmphmap.max()]\n", + " \n", + " mouse_p = np.array([x, y, rechmap[y, x, 0]])\n", + " light_xyh = compute_light_pos(mouse_p, mask_top_pos, horizon)\n", + " \n", + " tmp_mask = mask.copy()\n", + " tmp_mask[tmp_mask>0.0] = 1.0\n", + " \n", + " fg_pixht = fg_pixht * mask\n", + " bg_pixht = bg_pixht * mask\n", + " \n", + " fg_min = fg_pixht[tmp_mask != 0].min()\n", + " fg_pixht -= fg_min\n", + " bg_pixht -= fg_min\n", + " \n", + " last_pos = [0, 0]\n", + " fg_shadow = hshadow_render(rgb, mask, fg_pixht, rechmap, light_xyh, last_pos)\n", + " bg_shadow = hshadow_render(rgb, mask, bg_pixht, rechmap, light_xyh, last_pos)\n", + " \n", + " return fg_shadow, bg_shadow\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "af2a9966-8167-4de5-940e-1138ddf37799", + "metadata": {}, + "outputs": [], + "source": [ + "root = 'Examples'\n", + "fg_rgba1 = plt.imread(join(root, '009_rgb.png'))\n", + "fg_rgba2 = plt.imread(join(root, '010_rgb.png'))\n", + "fg_rgba3 = plt.imread(join(root, '011_rgb.png'))\n", + "\n", + "fg_pixht1 = np.load(join(root, '009_pixht_new.npy'))\n", + "fg_pixht2 = np.load(join(root, '010_pixht_new.npy'))\n", + "fg_pixht3 = np.load(join(root, '011_pixht_new.npy'))\n", + "\n", + "mask1 = np.load(join(root, '009_depth_valid_mask.npy'))\n", + "mask2 = np.load(join(root, '010_depth_valid_mask.npy'))\n", + "mask3 = np.load(join(root, '011_depth_valid_mask.npy'))\n", + "\n", + "bg = plt.imread(join(root, 'c82c09fc01e84282bc8870c263dcf81b_bg.jpg')) / 255.0\n", + "\n", + "cur_rgb = fg_rgba1.copy()\n", + "cur_mask = mask1.copy()[..., None]\n", + "cur_fg_pixht = fg_pixht1.copy()[..., None]\n", + "cur_bg_pixht = fg_pixht1.copy()[..., None]\n", + "\n", + "h, w = bg.shape[:2]\n", + "\n", + "bg = cv2.resize(bg, (w//4, h//4))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a33be1ad-cddc-4045-9244-822bfcb6bb79", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def composite(rgb1, rgb2, mask1):\n", + " return rgb1 * mask1 + rgb2 * (1.0-mask1)\n", + "\n", + "\n", + "def safe_comp(rgb1, rgb2, mask1, topleft):\n", + " h1, w1 = rgb1.shape[:2]\n", + " h2, w2 = rgb2.shape[:2]\n", + " \n", + " h_ = topleft[0]\n", + " w_ = topleft[1]\n", + " \n", + " h__ = h_ + h1\n", + " w__ = w_ + w1\n", + " \n", + " h_1 = np.clip(h_, 0, h2)\n", + " w_1 = np.clip(w_, 0, w2)\n", + " \n", + " h__1 = np.clip(h__, 0, h2)\n", + " w__1 = np.clip(w__, 0, w2)\n", + " \n", + " delta_h = h__ - h__1\n", + " delta_w = w__ - w__1\n", + " \n", + " cur_rgb1 = rgb1[:h1-delta_h, :w1 - delta_w]\n", + " cur_mask1 = mask1[:h1-delta_h, :w1 - delta_w]\n", + " \n", + " rgb2[h_:h__1, w_:w__1] = composite(cur_rgb1, rgb2[h_:h__1, w_:w__1], cur_mask1)\n", + " return rgb2\n", + "\n", + "\n", + "top_left1 = [500, 360]\n", + "size1 = [512, 512]\n", + "\n", + "cur_slice_h = slice(top_left1[0], top_left1[0] + size1[0])\n", + "cur_slice_w = slice(top_left1[1], top_left1[1] + size1[1])\n", + "\n", + "cur_bg = bg.copy()\n", + "new_fg_rgb = np.zeros_like(cur_bg)\n", + "new_fg_mask = np.zeros_like(cur_bg)\n", + "new_fg_pixht = np.zeros_like(cur_bg)\n", + "\n", + "cur_bg = safe_comp(cur_rgb, cur_bg, cur_mask, top_left1)\n", + "new_fg_rgb = safe_comp(cur_rgb, new_fg_rgb, cur_mask, top_left1)\n", + "new_fg_mask = safe_comp(cur_mask, new_fg_mask, cur_mask, top_left1)\n", + "\n", + "new_fg_pixht = safe_comp(cur_fg_pixht, new_fg_pixht, cur_mask, top_left1)\n", + "new_bg_pixht = new_fg_pixht.copy() \n", + "\n", + "# show(new_fg_pixht)\n", + "# show(cur_bg)\n", + "# show(new_fg_rgb)\n", + "# show(new_fg_mask)\n", + "\n", + "h, w = cur_bg.shape[:2]\n", + "cur_bg_rgba = np.ones((h, w, 4))\n", + "cur_bg_rgba[..., :3] = cur_bg" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b951d4c0-cdc0-4f95-8fdd-caf9d686f502", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(893, 1300, 3)\n", + "(893, 1300, 1)\n", + "(893, 1300, 1)\n", + "(893, 1300, 1)\n", + "(893, 1300, 1)\n", + "light sign: -1.0\n", + "light sign: -1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ysheng/Documents/Research/EXP/PixHtLab-Src/Demo/PixhtLab/reflect_render.py:157: RuntimeWarning: invalid value encountered in divide\n", + " return vec3/np.linalg.norm(vec3, axis=-1, keepdims=True)\n", + "Render: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 2.77it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(893, 1300, 3) 0.0 1.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rechmap = np.zeros_like(new_fg_rgb)[..., 0:1]\n", + "\n", + "new_fg_mask = new_fg_mask[..., 0:1]\n", + "new_fg_pixht = new_fg_pixht[..., 0:1]\n", + "new_bg_pixht = new_bg_pixht[..., 0:1]\n", + "\n", + "x = 455\n", + "y = 776\n", + "horizon = 600\n", + "softness = 0.1\n", + "\n", + "print(new_fg_rgb.shape)\n", + "print(new_fg_mask.shape)\n", + "print(new_fg_pixht.shape)\n", + "print(new_bg_pixht.shape)\n", + "print(rechmap.shape)\n", + "\n", + "ao_shadow, bg_shadow = render_shadow(new_fg_rgb, new_fg_mask, new_fg_pixht, new_bg_pixht, rechmap, x, y, horizon)\n", + "fg_shadow, bg_shadow = render_shadow(new_fg_rgb, new_fg_mask, new_fg_pixht, new_bg_pixht, rechmap, 455, 776, horizon)\n", + "\n", + "ao_weight = 0.5\n", + "ao_softness = 0.2\n", + "glossness = 0.01\n", + "sample = 1\n", + "\n", + "ao_ss = softshadow_render(new_fg_mask[..., :1], ao_shadow[..., :1], ao_softness)[0]\n", + "dir_ss = softshadow_render(new_fg_mask[..., :1], fg_shadow[..., :1], softness)[0]\n", + "final_ss = 1.0 - ((1.0 - ao_ss) * ao_weight + (1.0 - dir_ss) * (1.0-ao_weight) )\n", + "shadow_bg = composite(new_fg_rgb, final_ss * cur_bg_rgba[..., :3], new_fg_mask)\n", + "cur_bg_rgba[..., :3] = shadow_bg\n", + "final = composite_reflection(new_fg_rgb, new_fg_mask, new_fg_pixht, cur_bg_rgba, new_bg_pixht, rechmap, horizon=horizon, glossness=glossness, sample=sample) \n", + "\n", + "show(final)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46babb38-5898-46ff-a8d4-46071b26ea9e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.8.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/PixHtLab-Src/Demo/PixhtLab/Examples/009_depth.npy b/PixHtLab-Src/Demo/PixhtLab/Examples/009_depth.npy new file mode 100644 index 0000000000000000000000000000000000000000..b6fc652a5e5a16791ff5dc87ee1007caec51cec6 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Examples/009_depth.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:17338c5be1e9aa07c8d68ed26076af44f433374a92a90130b3f803d66f8d2442 +size 1048704 diff --git a/PixHtLab-Src/Demo/PixhtLab/Examples/009_depth_valid_mask.npy b/PixHtLab-Src/Demo/PixhtLab/Examples/009_depth_valid_mask.npy new file mode 100644 index 0000000000000000000000000000000000000000..06a1132916762bfffc5e0458be3144c80fc81bba --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Examples/009_depth_valid_mask.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:85f888fa80c5da36acf97938cda8f55323758aefda263fc859ab83b2955c92c1 +size 262272 diff --git a/PixHtLab-Src/Demo/PixhtLab/Examples/009_pixht_new.npy b/PixHtLab-Src/Demo/PixhtLab/Examples/009_pixht_new.npy new file mode 100644 index 0000000000000000000000000000000000000000..3a366482863361ac471dd56753e8caeb3b5edd0e --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Examples/009_pixht_new.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:25dfedce61e31739fec2164898d9975ab9224c02aea1540029eb7b04d0505118 +size 2097280 diff --git a/PixHtLab-Src/Demo/PixhtLab/Examples/010_depth.npy b/PixHtLab-Src/Demo/PixhtLab/Examples/010_depth.npy new file mode 100644 index 0000000000000000000000000000000000000000..3244dfd9388becd1e0c2f60ec1b54d61bc5ba758 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Examples/010_depth.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:872277399788bc63b43a1fc63e817d8c12d18e6960b6d7e51a41d2ea2fae21f6 +size 1048704 diff --git a/PixHtLab-Src/Demo/PixhtLab/Examples/010_depth_valid_mask.npy b/PixHtLab-Src/Demo/PixhtLab/Examples/010_depth_valid_mask.npy new file mode 100644 index 0000000000000000000000000000000000000000..8075d1521236a245a5e1f342e1ab3f8b40414d7e --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Examples/010_depth_valid_mask.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2ceb9b34576604a240e557f2bb2fa87b7328e30a28a44357d799c6a3271c6bf6 +size 262272 diff --git a/PixHtLab-Src/Demo/PixhtLab/Examples/010_pixht_new.npy b/PixHtLab-Src/Demo/PixhtLab/Examples/010_pixht_new.npy new file mode 100644 index 0000000000000000000000000000000000000000..f020e7f24f7942093482ec19aae1bb7160f11e2a --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Examples/010_pixht_new.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bb2031249ece53825e983e62e1a695c53bdfcd5ae12d3a1350dff80e710f0aa3 +size 2097280 diff --git a/PixHtLab-Src/Demo/PixhtLab/Examples/011_depth.npy b/PixHtLab-Src/Demo/PixhtLab/Examples/011_depth.npy new file mode 100644 index 0000000000000000000000000000000000000000..7613dd1325609193e6e162db4cffaad4a8a0c86f --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Examples/011_depth.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bfdabce8a328c02e7e52d156a2f2f03e1302fb695e9e70f35355d1aced7de24f +size 1048704 diff --git a/PixHtLab-Src/Demo/PixhtLab/Examples/011_depth_valid_mask.npy b/PixHtLab-Src/Demo/PixhtLab/Examples/011_depth_valid_mask.npy new file mode 100644 index 0000000000000000000000000000000000000000..e2a0f1f2072f8c95f34be96c694fb733eb8619e9 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Examples/011_depth_valid_mask.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:12eaae90b70229aa83450d8ea63fd77c7e8fdc6240e473aafab77021c2891efe +size 262272 diff --git a/PixHtLab-Src/Demo/PixhtLab/Examples/011_pixht_new.npy b/PixHtLab-Src/Demo/PixhtLab/Examples/011_pixht_new.npy new file mode 100644 index 0000000000000000000000000000000000000000..1eef04d92821a576f7fbeb601ded94f2b1c07ecf --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Examples/011_pixht_new.npy @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9ef1a1f21f4ac53dc680fc6a965cce4f8043bd313a89e52ef733c5986be16595 +size 2097280 diff --git a/PixHtLab-Src/Demo/PixhtLab/Examples/c82c09fc01e84282bc8870c263dcf81b_bg.jpg b/PixHtLab-Src/Demo/PixhtLab/Examples/c82c09fc01e84282bc8870c263dcf81b_bg.jpg new file mode 100644 index 0000000000000000000000000000000000000000..91fa2dd17ffc2bf348383bc04bc13fd515b1274e --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Examples/c82c09fc01e84282bc8870c263dcf81b_bg.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d51aad0c7a87ff499f6bee8834e87c9013e3800b0db25aee2b497398d0687ab7 +size 1261240 diff --git a/PixHtLab-Src/Demo/PixhtLab/GSSN/__init__.py b/PixHtLab-Src/Demo/PixhtLab/GSSN/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/PixHtLab-Src/Demo/PixhtLab/GSSN/inference_shadow.py b/PixHtLab-Src/Demo/PixhtLab/GSSN/inference_shadow.py new file mode 100644 index 0000000000000000000000000000000000000000..39341fffc62b0f2eacdbc70a3f906326c5698a66 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/GSSN/inference_shadow.py @@ -0,0 +1,70 @@ +import os +import numpy as np +from PIL import Image +import matplotlib.pyplot as plt + +import torch +import torch.nn as nn +from torch.utils.data import Dataset, DataLoader +import torch.optim as optim +import torchvision +import torchvision.transforms as T +import argparse +import time +from tqdm import tqdm +import numpy as np +import os +from os.path import join + +import math + +import cv2 +import random + +import sys +# sys.path.insert(0, '../../Training/app/models') +sys.path.insert(0, '/home/ysheng/Documents/Research/GSSN/Training/app/models') + +from SSN_v1 import SSN_v1 +from SSN import SSN + + +class SSN_Infernece(): + def __init__(self, ckpt, device=torch.device('cuda:0')): + self.device = device + self.model = SSN(3, 1, mid_act='gelu', out_act='null', resnet=False) + + weight = torch.load(ckpt) + self.model.to(device) + self.model.load_state_dict(weight['model']) + + # inference related + BINs = 100 + MAX_RAD = 20 + self.size_interval = MAX_RAD / BINs + self.soft_distribution = [[np.exp(-0.2 * (i - j) ** 2) for i in np.arange(BINs)] for j in np.arange(BINs)] + + + def render_ss(self, input_np, softness): + """ input_np: + H x W x C + """ + input_tensor = torch.tensor(input_np.transpose((2, 0, 1)))[None, ...].float().to(self.device) + transform = T.Resize((256, 256)) + + c = input_tensor.shape[1] + # for i in range(c): + # print(input_tensor[:, i].min(), input_tensor[:, i].max()) + + # print('softness: ', softness) + l = torch.from_numpy(np.array(self.soft_distribution[int(softness/self.size_interval)]).astype(np.float32)).unsqueeze(dim=0).to(self.device) + + input_tensor = transform(input_tensor) + output_tensor = self.model(input_tensor, l) + output_np = output_tensor[0].detach().cpu().numpy().transpose((1,2,0)) + + return output_np + + +if __name__ == '__main__': + model = SSN_Infernece('weights/0000000700.pt') diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/__init__.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/__init__.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/inference_shadow.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/inference_shadow.py new file mode 100644 index 0000000000000000000000000000000000000000..2441ee52caa9377b09f9b71e83e90d258ddd2803 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/inference_shadow.py @@ -0,0 +1,70 @@ +import os +import numpy as np +from PIL import Image +import matplotlib.pyplot as plt + +import torch +import torch.nn as nn +from torch.utils.data import Dataset, DataLoader +import torch.optim as optim +import torchvision +import torchvision.transforms as transforms +import argparse +import time +from tqdm import tqdm +import numpy as np +import os +from os.path import join + +import math + +import cv2 +import random +from .ssn.ssn import Relight_SSN +device = torch.device('cuda:0') + +def net_render_np(model, mask_np, hard_shadow_np, size, orientation): + """ + input: + mask_np shape: b x c x h x w + ibl_np shape: 1 x 16 x 32 + output: + shadow_predict shape: b x c x h x w + """ + + size_interval = 0.5 / 100 + ori_interval = np.pi / 100 + + soft_distribution = [[np.exp(-0.2 * (i - j) ** 2) for i in np.arange(0.5 / size_interval)] + for j in np.arange(0.5 / size_interval)] + + # print('mask_np: {}, hard_shadow_np: {}'.format(mask_np.shape, hard_shadow_np.shape)) + s = time.time() + if mask_np.dtype == np.uint8: + mask_np = mask_np / 255.0 + + mask, h_shadow = torch.Tensor(mask_np), torch.Tensor(hard_shadow_np) + size_soft = torch.Tensor(np.array(soft_distribution[int(size / size_interval)])).unsqueeze(0) + ori_soft = torch.Tensor(np.array(soft_distribution[int(orientation / ori_interval)])).unsqueeze(0) + + with torch.no_grad(): + I_m, I_h, size_t, ori = mask.to(device), h_shadow.to(device), size_soft.to(device), ori_soft.to(device) + # print('I_m: {}, I_h: {}'.format(I_m.shape, I_h.shape)) + predicted_img = model(I_h, I_m, size_t, ori) + + # print('net predict finished, time: {}s'.format(time.time() - s)) + + return predicted_img.detach().cpu().numpy() + +def init_models(ckpt): + baseline_model = Relight_SSN(1, 1, is_training=False) + baseline_checkpoint = torch.load(ckpt) + baseline_model.to(device) + baseline_model.load_state_dict(baseline_checkpoint['model_state_dict']) + return baseline_model + +if __name__ == '__main__': + softness = [0.02, 0.2, 0.3, 0.4] + model = init_models('weights/human_baseline123.pt') + mask, hard_shadow, size, orientation = np.random.randn(1,1,256,256), np.random.randn(1,1,256,256), softness[0], 0 + shadow = net_render_np(model, mask, hard_shadow, size, orientation) diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/params.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/params.py new file mode 100644 index 0000000000000000000000000000000000000000..82626d12faffc499e65d5fb30da8e12b23f42ce1 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/params.py @@ -0,0 +1,92 @@ +import argparse + +class params(): + """ Singleton class for doing experiments """ + + class __params(): + def __init__(self): + self.norm = 'group_norm' + self.prelu = False + self.weight_decay = 5e-4 + self.small_ds = False + self.multi_gpu = False + self.log = False + self.input_channel = 1 + self.vis_port = 8002 + self.cpu = False + self.pred_touch = False + self.tbaseline = False + self.touch_loss = False + self.input_channel = 1 + + def set_params(self, options): + self.options = options + self.norm = options.norm + self.prelu = options.prelu + self.weight_decay = options.weight_decay + self.small_ds = options.small_ds + self.multi_gpu = options.multi_gpu + self.log = options.log + self.input_channel = options.input_channel + self.vis_port = options.vis_port + self.cpu = options.cpu + self.ds_folder = options.ds_folder + self.pred_touch = options.pred_touch + self.tbaseline = options.tbaseline + self.touch_loss = options.touch_loss + + def __str__(self): + return 'norm: {} prelu: {} weight decay: {} small ds: {}'.format(self.norm, self.prelu, self.weight_decay, self.small_ds) + + # private static variable + param_instance = None + + def __init__(self): + if not params.param_instance: + params.param_instance = params.__params() + + def get_params(self): + return params.param_instance + + def set_params(self, options): + params.param_instance.set_params(options) + +def parse_params(): + parser = argparse.ArgumentParser() + parser.add_argument('--workers', type=int, help='number of data loading workers', default=16) + parser.add_argument('--batch_size', type=int, default=28, help='input batch size during training') + parser.add_argument('--epochs', type=int, default=10000, help='number of epochs to train for') + parser.add_argument('--lr', type=float, default=0.003, help='learning rate, default=0.005') + parser.add_argument('--beta1', type=float, default=0.9, help='momentum for SGD, default=0.9') + parser.add_argument('--resume', action='store_true', help='resume training') + parser.add_argument('--relearn', action='store_true', help='forget previous best validation loss') + parser.add_argument('--weight_file',type=str, help='weight file') + parser.add_argument('--multi_gpu', action='store_true', help='use multiple GPU training') + parser.add_argument('--timers', type=int, default=1, help='number of epochs to train for') + parser.add_argument('--use_schedule', action='store_true',help='use automatic schedule') + parser.add_argument('--patience', type=int, default=2, help='use automatic schedule') + parser.add_argument('--exp_name', type=str, default='l1 loss',help='experiment name') + parser.add_argument('--norm', type=str, default='group_norm', help='use group norm') + parser.add_argument('--ds_folder', type=str, default='./dataset/general_dataset', help='Dataset folder') + parser.add_argument('--hd_dir', type=str, default='/mnt/yifan/data/Adobe/HD_styleshadow/', help='Dataset folder') + parser.add_argument('--prelu', action='store_true', help='use prelu') + parser.add_argument('--small_ds', action='store_true', help='small dataset') + parser.add_argument('--log', action='store_true', help='log information') + parser.add_argument('--vis_port', default=8002,type=int, help='visdom port') + parser.add_argument('--weight_decay', type=float, default=4e-5, help='weight decay for model weight') + parser.add_argument('--save', action='store_true', help='save batch results?') + parser.add_argument('--cpu', action='store_true', help='Force training on CPU') + parser.add_argument('--pred_touch', action='store_true', help='Use touching surface') + parser.add_argument('--input_channel', type=int, default=1, help='how many input channels') + + # based on baseline method, for fine tuning + parser.add_argument('--from_baseline', action='store_true', help='training from baseline') + parser.add_argument('--tbaseline', action='store_true', help='T-baseline, input two channels') + parser.add_argument('--touch_loss', action='store_true', help='Use touching loss') + + + arguments = parser.parse_args() + parameter = params() + parameter.set_params(arguments) + + return arguments diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/__init__.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/perturb_touch.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/perturb_touch.py new file mode 100644 index 0000000000000000000000000000000000000000..c1bc6c133d638e86510013bafb813a60224e8629 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/perturb_touch.py @@ -0,0 +1,24 @@ +import numpy as np +import cv2 +import random + +random.seed(19920208) + +def random_kernel(): + ksize = random.randint(1,3) + kernel = np.ones((ksize, ksize)) + return kernel + +def random_perturb(img): + return img +# perturbed = img.copy() +# if random.random() < 0.5: +# perturbed = cv2.erode(perturbed, random_kernel(), iterations = 1) + +# if random.random() < 0.5: +# perturbed = cv2.dilate(perturbed, random_kernel(), iterations = 1) + +# cv2.normalize(perturbed, perturbed, 0.0,1.0, cv2.NORM_MINMAX) +# if len(perturbed.shape) == 2: +# perturbed = perturbed[:,:,np.newaxis] +# return perturbed \ No newline at end of file diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/random_pattern.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/random_pattern.py new file mode 100644 index 0000000000000000000000000000000000000000..f60f82a3fb7b07baf61858f85b0c4c4d17ea77bc --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/random_pattern.py @@ -0,0 +1,92 @@ +import random +import time +import numbergen as ng +import imagen as ig +import numpy as np +import cv2 +from param.parameterized import get_logger +import logging + +get_logger().setLevel(logging.ERROR) + +class random_pattern(): + def __init__(self, maximum_blob=50): + # self.generator_list = [] + + # start = time.time() + # for i in range(maximum_blob): + # self.generator_list.append(ig.Gaussian(size=)) + # print('random pattern init time: {}s'.format(time.time()-start)) + + pass + + def y_transform(self, y): + # y = [] + pass + + def get_pattern(self, w, h, x_density=512, y_density=128, num=50, scale=3.0, size=0.1, energy=3500, + mitsuba=False, seed=None, dataset=False): + if seed is None: + seed = random.randint(0, 19920208) + else: + seed = seed + int(time.time()) + + if num == 0: + ibl = np.zeros((y_density, x_density)) + orientation = np.pi * ng.UniformRandom(seed=seed + 3)() + else: + y_fact = y_density / 256 + num = 1 + size = size * ng.UniformRandom(seed=seed + 4)() + orientation = np.pi * ng.UniformRandom(seed=seed + 3)() + gs = ig.Composite(operator=np.add, + generators=[ig.Gaussian( + size=size, + scale=1.0, + x=ng.UniformRandom(seed=seed + i + 1) - 0.5, + y=((1.0 - ng.UniformRandom(seed=seed + i + 2) * y_fact) - 0.5), + aspect_ratio=0.7, + orientation=orientation, + ) for i in range(num)], + position=(0, 0), + xdensity=512) + + # gs = ig.Composite(operator=np.add, + # generators=[ig.Gaussian( + # size=size * ng.UniformRandom(seed=seed + i + 4), + # scale=scale * (ng.UniformRandom(seed=seed + i + 5) + 1e-3), + # x=int(ind / h), + # y=ind % h, + # aspect_ratio=0.7, + # orientation=np.pi * ng.UniformRandom(seed=seed + i + 3), + # ) for i in range(num)], + # position=(0, 0), + # xdensity=512) + ibl = gs()[:y_density, :] + + # prepare to fix energy inconsistent + if dataset: + ibl = self.to_dataset(ibl, w, h) + + if mitsuba: + return ibl, size, orientation + else: + return ibl, size, orientation + + def to_mts_ibl(self, ibl): + """ Input: 256 x 512 pattern generated ibl + Output: the ibl in mitsuba ibl + """ + return np.repeat(ibl[:, :, np.newaxis], 3, axis=2) + + def normalize(self, ibl, energy=30.0): + total_energy = np.sum(ibl) + if total_energy < 1e-3: + print('small energy: ', total_energy) + h, w = ibl.shape + return np.zeros((h, w)) + + return ibl * energy / total_energy + + def to_dataset(self, ibl, w, h): + return self.normalize(cv2.flip(cv2.resize(ibl, (w, h)), 0), 30) diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/ssn.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/ssn.py new file mode 100644 index 0000000000000000000000000000000000000000..2f7ae407cd9be3a6bcf61e577f00d8d707c02e86 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/ssn.py @@ -0,0 +1,146 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .ssn_submodule import Conv, Up, Up_Stream, get_layer_info, add_coords +import copy + +class Relight_SSN(nn.Module): + """ Implementation of Relighting Net """ + + def __init__(self, n_channels=3, out_channels=3, is_training=True, activation_func = 'relu'): + super(Relight_SSN, self).__init__() + self.is_training = is_training + + norm_layer1, activation_func1 = get_layer_info(16, activation_func) + norm_layer2, activation_func2 = get_layer_info(16, activation_func) + if norm_layer1 is not None: + self.in_conv1 = nn.Sequential( + nn.Conv2d(n_channels, 16, kernel_size=7, padding=3, bias=True), + norm_layer1, + activation_func1 + ) + elif norm_layer1 is None: + self.in_conv1 = nn.Sequential( + nn.Conv2d(n_channels, 16, kernel_size=7, padding=3, bias=True), + activation_func1 + ) + + if norm_layer2 is not None: + self.in_conv2 = nn.Sequential( + nn.Conv2d(n_channels, 16, kernel_size=7, padding=3, bias=True), + norm_layer2, + activation_func2 + ) + elif norm_layer2 is None: + self.in_conv2 = nn.Sequential( + nn.Conv2d(n_channels, 16, kernel_size=7, padding=3, bias=True), + activation_func2 + ) + + self.down_256_128 = Conv(32, 64, conv_stride=2) + self.down_128_128 = Conv(64, 64, conv_stride=1) + self.down_128_64 = Conv(64, 128, conv_stride=2) + self.down_64_64 = Conv(128, 128, conv_stride=1) + self.down_64_32 = Conv(128, 256, conv_stride=2) + self.down_32_32 = Conv(256, 256, conv_stride=1) + self.down_32_16 = Conv(256, 512, conv_stride=2) + self.down_16_16_1 = Conv(512, 512, conv_stride=1) + self.down_16_16_2 = Conv(512, 512, conv_stride=1) + self.down_16_16_3 = Conv(512, 512, conv_stride=1) + self.to_bottleneck = Conv(512, 2, conv_stride=1) + + self.up_stream = Up_Stream(out_channels) + + """ + Input is (source image, target light, source light, ) + Output is: predicted new image, predicted source light, self-supervision image + """ + + def forward(self, I_h, I_m, size, angle): + if self.is_training: + bs, fake_bs, dim = size.shape + bs, fake_bs, ch, w, h = I_h.shape + size = size.reshape(bs * fake_bs, dim) + angle = angle.reshape(bs * fake_bs, dim) + I_h = I_h.reshape(bs * fake_bs, ch, w, h) + I_m = I_m.reshape(bs * fake_bs, ch, w, h) + else: + size = size + angle = angle + I_h = I_h + I_m = I_m + style = torch.cat((size, angle), dim=1) + x1 = self.in_conv1(I_m) # 29 x 256 x 256 + x2 = self.in_conv2(I_h) + + x1 = torch.cat((x1, x2), dim=1) # 32 x 256 x 256 + + x2 = self.down_256_128(x1, x1) # 64 x 128 x 128 + + x3 = self.down_128_128(x2, x1) # 64 x 128 x 128 + + x4 = self.down_128_64(x3, x1) # 128 x 64 x 64 + + x5 = self.down_64_64(x4, x1) # 128 x 64 x 64 + + x6 = self.down_64_32(x5, x1) # 256 x 32 x 32 + + x7 = self.down_32_32(x6, x1) # 256 x 32 x 32 + + x8 = self.down_32_16(x7, x1) # 512 x 16 x 16 + + x9 = self.down_16_16_1(x8, x1) # 512 x 16 x 16 + + x10 = self.down_16_16_2(x9, x1) # 512 x 16 x 16 + + x11 = self.down_16_16_3(x10, x1) # 512 x 16 x 16 + ty = self.up_stream(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, style) + + return ty + + +def baseline_2_tbaseline(model): + """ change input layer to be two channels + """ + input_channel = 2 + tbase_inlayer = nn.Sequential( + nn.Conv2d(input_channel, 32 - input_channel, kernel_size=7, padding=3, bias=True), + nn.GroupNorm(1, 32 - input_channel), + nn.ReLU() + ) + model.in_conv = tbase_inlayer + return model + + +def baseline_2_touchloss(model): + """ change output layer to be two channels + """ + touchless_outlayer = nn.Sequential( + nn.Conv2d(64, 2, stride=1, kernel_size=3, padding=1, bias=True), + nn.GroupNorm(1, 2), + nn.ReLU() + ) + model.up_stream.out_conv = touchless_outlayer + return model + + +if __name__ == '__main__': + mask_test, touch_test = torch.zeros((1, 1, 256, 256)), torch.zeros((1, 1, 256, 256)) + ibl = torch.zeros((1, 1, 16, 32)) + + I_s = mask_test + baseline = Relight_SSN(1, 1) + baseline_output, _ = baseline(I_s, ibl) + + tbaseline = baseline_2_tbaseline(copy.deepcopy(baseline)) + I_s = torch.cat((mask_test, touch_test), axis=1) + tbaseline_output, _ = tbaseline(I_s, ibl) + + t_loss_baseline = baseline_2_touchloss(copy.deepcopy(baseline)) + I_s = mask_test + tloss_output, _ = t_loss_baseline(I_s, ibl) + + print('baseline output: ', baseline_output.shape) + print('tbaseline output: ', tbaseline_output.shape) + print('tloss output: ', tloss_output.shape) diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/ssn_dataset.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/ssn_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..734e64ff0d4c2d7868090eb6143b606c03dcd26d --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/ssn_dataset.py @@ -0,0 +1,290 @@ +import sys + +sys.path.append("..") + +import os +from os.path import join +import torch +import numpy as np +import torch +from torch.utils.data import Dataset, DataLoader +from torchvision import transforms, utils +import time +import random +# import matplotlib.pyplot as plt +import cv2 +from params import params +from .random_pattern import random_pattern +from .perturb_touch import random_perturb + + +class ToTensor(object): + """Convert ndarrays in sample to Tensors.""" + + def __call__(self, img, is_transpose=True): + # swap color axis because + # numpy image: H x W x C + # torch image: C X H X W + if is_transpose: + img = img.transpose((0, 3, 1, 2)) + return torch.Tensor(img) + + +class SSN_Dataset(Dataset): + def __init__(self, ds_dir, hd_dir, is_training, fake_batch_size=8): + start = time.time() + self.fake_batch_size = fake_batch_size + # # of samples in each group + # magic number here + self.ibl_group_size = 16 + + parameter = params().get_params() + + # (shadow_path, mask_path) + self.meta_data = self.init_meta(ds_dir, hd_dir) + + self.is_training = is_training + self.to_tensor = ToTensor() + + end = time.time() + print("Dataset initialize spent: {} ms".format(end - start)) + + # fake random + np.random.seed(19950220) + np.random.shuffle(self.meta_data) + + self.valid_divide = 10 + if parameter.small_ds: + self.meta_data = self.meta_data[:len(self.meta_data) // self.valid_divide] + + self.training_num = len(self.meta_data) - len(self.meta_data) // self.valid_divide + print('training: {}, validation: {}'.format(self.training_num, len(self.meta_data) // self.valid_divide)) + + self.random_pattern_generator = random_pattern() + + self.thread_id = os.getpid() + self.seed = os.getpid() + self.perturb = not parameter.pred_touch and not parameter.touch_loss + self.size_interval = 0.5 / 100 + self.ori_interval = np.pi / 100 + + self.soft_distribution = [[np.exp(-0.4 * (i - j) ** 2) for i in np.arange(0.5 / self.size_interval)] + for j in np.arange(0.5 / self.size_interval)] + + def __len__(self): + if self.is_training: + return self.training_num + else: + # return len(self.meta_data) - self.training_num + return len(self.meta_data) // self.valid_divide + + def __getitem__(self, idx): + if self.is_training and idx > self.training_num: + print("error") + # offset to validation set + if not self.is_training: + idx = self.training_num + idx + + cur_seed = idx * 1234 + os.getpid() + time.time() + random.seed(cur_seed) + + # random ibls + shadow_path, mask_path, hard_path, touch_path = self.meta_data[idx] + hard_folder = hard_path.replace(hard_path.split('/')[-1], '') + if os.path.exists(hard_folder): + # hard_shadow = cv2.imread(hard_folder) + + mask_img = cv2.imread(mask_path) + mask_img = mask_img[:, :, 0] + if mask_img.dtype == np.uint8: + mask_img = mask_img / 255.0 + mask_img, shadow_bases = np.expand_dims(mask_img, axis=2), np.load(shadow_path) + + w, h, c, m = shadow_bases.shape + shadow_soft_list = [] + shadow_hard_list = [] + size_list = [] + orientation_list = [] + mask_img_list = [] + for i in range(int(self.fake_batch_size)): + shadow_img, light_img, size, orientation = self.render_new_shadow(shadow_bases) + + h, w = mask_img.shape[0], mask_img.shape[1] + hi, wi = np.where(light_img == light_img.max()) + + while len(hi) > 1: + shadow_img, light_img, size, orientation = self.render_new_shadow(shadow_bases) + hi, wi = np.where(light_img == light_img.max()) + size_soft = np.array(self.soft_distribution[int(size / self.size_interval)]) + ori_soft = np.array(self.soft_distribution[int(orientation / self.ori_interval)]) + prefix = '_ibli_' + str(int(wi * 8)) + '_iblj_' + str(int(hi * 8) + 128) + '_shadow.png' + shadow_hard_path = hard_path.replace('_shadow.png', prefix) + shadow_base = cv2.imread(shadow_hard_path, -1)[:, :, 0] / 255.0 + shadow_base = np.expand_dims(shadow_base, axis=2) + shadow_base = self.line_aug(shadow_base) + shadow_soft_list.append(shadow_img) + shadow_hard_list.append(shadow_base) + size_list.append(size_soft) + orientation_list.append(ori_soft) + mask_img_list.append(mask_img) + shadow_softs = np.array(shadow_soft_list) + shadow_hards = np.array(shadow_hard_list) + sizes = np.array(size_list) + orientations = np.array(orientation_list) + mask_imgs = np.array(mask_img_list) + + # touch_img = self.read_img(touch_path) + # touch_img = touch_img[:, :, 0:1] + + # if self.perturb: + # touch_img = random_perturb(touch_img) + + # input_img = np.concatenate((mask_img, touch_img), axis=2) + size = torch.Tensor(sizes) + ori = torch.Tensor(orientations) + hard_shadow, soft_shadow, mask_img = self.to_tensor(shadow_hards), self.to_tensor( + shadow_softs), self.to_tensor( + mask_imgs) + return {"hard_shadow": hard_shadow, "soft_shadow": soft_shadow, "mask_img": mask_img, "size": size, + "angle": ori} + else: + mask_img = cv2.imread(mask_path) + mask_img = mask_img[:, :, 0] + if mask_img.dtype == np.uint8: + mask_img = mask_img / 255.0 + mask_img, shadow_bases = np.expand_dims(mask_img, axis=2), 1.0 - np.load(shadow_path) + + w, h, c, m = shadow_bases.shape + shadow_soft_list = [] + shadow_hard_list = [] + size_list = [] + orientation_list = [] + mask_img_list = [] + for i in range(int(self.fake_batch_size)): + shadow_img, light_img, size, orientation = self.render_new_shadow(shadow_bases) + + h, w = mask_img.shape[0], mask_img.shape[1] + hi, wi = np.where(light_img == light_img.max()) + + while len(hi) > 1: + shadow_img, light_img, size, orientation = self.render_new_shadow(shadow_bases) + hi, wi, _ = np.where(light_img == light_img[:, :, :].max()) + size_soft = np.array(self.soft_distribution[int(size / self.size_interval)]) + ori_soft = np.array(self.soft_distribution[int(orientation / self.ori_interval)]) + + shadow_base = shadow_bases[:, :, wi, hi] + shadow_base[shadow_base > 0.3] = 1 + shadow_base[shadow_base < 0.4] = 0 + shadow_base = self.line_aug(shadow_base) + mask_img = np.expand_dims(cv2.resize(mask_img, (512, 512)), axis=2) + shadow_base = np.expand_dims(cv2.resize(shadow_base, (512, 512)), axis=2) + shadow_img = np.expand_dims(cv2.resize(shadow_img, (512, 512)), axis=2) + shadow_soft_list.append(shadow_img) + shadow_hard_list.append(shadow_base) + size_list.append(size_soft) + orientation_list.append(ori_soft) + mask_img_list.append(mask_img) + shadow_softs = np.array(shadow_soft_list) + shadow_hards = np.array(shadow_hard_list) + sizes = np.array(size_list) + orientations = np.array(orientation_list) + mask_imgs = np.array(mask_img_list) + + # touch_img = self.read_img(touch_path) + # touch_img = touch_img[:, :, 0:1] + + # if self.perturb: + # touch_img = random_perturb(touch_img) + + # input_img = np.concatenate((mask_img, touch_img), axis=2) + size = torch.Tensor(sizes) + ori = torch.Tensor(orientations) + + hard_shadow, soft_shadow, mask_img = self.to_tensor(shadow_hards), self.to_tensor( + shadow_softs), self.to_tensor( + mask_imgs) + + return {"hard_shadow": hard_shadow, "soft_shadow": soft_shadow, "mask_img": mask_img, "size": size, + "angle": ori} + + def init_meta(self, ds_dir, hd_dir): + metadata = [] + # base_folder = join(ds_dir, 'base') + # mask_folder = join(ds_dir, 'mask') + # hard_folder = join(ds_dir, 'hard') + # touch_folder = join(ds_dir, 'touch') + # model_list = [f for f in os.listdir(base_folder) if os.path.isdir(join(base_folder, f))] + # for m in model_list: + # shadow_folder, cur_mask_folder = join(base_folder, m), join(mask_folder, m) + # shadows = [f for f in os.listdir(shadow_folder) if f.find('_shadow.npy') != -1] + # for s in shadows: + # prefix = s[:s.find('_shadow')] + # metadata.append((join(shadow_folder, s), + # join(cur_mask_folder, prefix + '_mask.png'), + # join(join(hard_folder, m), prefix + '_shadow.png'), + # join(join(touch_folder, m), prefix + '_touch.png'))) + + base_folder = join(hd_dir, 'base') + mask_folder = join(hd_dir, 'mask') + hard_folder = join(hd_dir, 'hard') + touch_folder = join(hd_dir, 'touch') + model_list = [f for f in os.listdir(base_folder) if os.path.isdir(join(base_folder, f))] + for m in model_list: + shadow_folder, cur_mask_folder = join(base_folder, m), join(mask_folder, m) + shadows = [f for f in os.listdir(shadow_folder) if f.find('_shadow.npy') != -1] + for s in shadows: + prefix = s[:s.find('_shadow')] + metadata.append((join(shadow_folder, s), + join(cur_mask_folder, prefix + '_mask.png'), + join(join(hard_folder, m), prefix + '_shadow.png'), + join(join(touch_folder, m), prefix + '_touch.png'))) + + return metadata + + def line_aug(self, shadow): + p = np.random.random() + if p > 0.6: + k = np.tan(min((np.random.random() + 0.000000001), 0.999) * np.pi - np.pi / 2) + x, y, c = shadow.shape + b_max = y - x * k + line_num = np.random.randint(1, 20) + b_list = np.random.random(line_num) * b_max + x_coord = np.tile(np.arange(shadow.shape[1])[None, :], (shadow.shape[0], 1)) + y_coord = np.tile(np.arange(shadow.shape[0])[:, None], (1, shadow.shape[1])) + + for b in b_list: + mask_res = y_coord - k * x_coord - b + shadow[np.abs(mask_res) < 1] = 0 + return shadow + + def get_prefix(self, path): + folder = os.path.dirname(path) + basename = os.path.basename(path) + return os.path.join(folder, basename[:basename.find('_')]) + + def render_new_shadow(self, shadow_bases): + shadow_bases = shadow_bases[:, :, :, :] + h, w, iw, ih = shadow_bases.shape + + num = random.randint(0, 50) + pattern_img, size, orientation = self.random_pattern_generator.get_pattern(iw, ih, num=num, size=0.5, + mitsuba=False) + + # flip to mitsuba ibl + pattern_img = self.normalize_energy(cv2.flip(cv2.resize(pattern_img, (iw, ih)), 0)) + shadow = np.tensordot(shadow_bases, pattern_img, axes=([2, 3], [1, 0])) + # pattern_img = np.expand_dims(cv2.resize(pattern_img, (iw, 16)), 2) + + return np.expand_dims(shadow, 2), pattern_img, size, orientation + + def get_min_max(self, batch_data, name): + print('{} min: {}, max: {}'.format(name, np.min(batch_data), np.max(batch_data))) + + def log(self, log_info): + with open('log.txt', 'a+') as f: + f.write(log_info) + + def normalize_energy(self, ibl, energy=30.0): + if np.sum(ibl) < 1e-3: + return ibl + return ibl * energy / np.sum(ibl) diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/ssn_submodule.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/ssn_submodule.py new file mode 100644 index 0000000000000000000000000000000000000000..a2365a0f300c5bd1a831670868d5f9c63d03baef --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/ssn_submodule.py @@ -0,0 +1,282 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +def get_layer_info(out_channels, activation_func='relu'): + if out_channels >= 32: + group_num = 32 + else: + group_num = 1 + + norm_layer = nn.GroupNorm(group_num, out_channels) + + if activation_func == 'relu': + activation_func = nn.ReLU() + elif activation_func == 'prelu': + activation_func = nn.PReLU(out_channels) + + return norm_layer, activation_func + + +# add coord_conv +class add_coords(nn.Module): + def __init__(self, use_cuda=True): + super(add_coords, self).__init__() + self.use_cuda = use_cuda + + def forward(self, input_tensor): + b, c, dim_y, dim_x = input_tensor.shape + xx_ones = torch.ones([1, 1, 1, dim_x], dtype=torch.int32) + yy_ones = torch.ones([1, 1, 1, dim_y], dtype=torch.int32) + + xx_range = torch.arange(dim_y, dtype=torch.int32) + yy_range = torch.arange(dim_x, dtype=torch.int32) + xx_range = xx_range[None, None, :, None] + yy_range = yy_range[None, None, :, None] + + xx_channel = torch.matmul(xx_range, xx_ones) + yy_channel = torch.matmul(yy_range, yy_ones) + + # transpose y + yy_channel = yy_channel.permute(0, 1, 3, 2) + + xx_channel = xx_channel.float() / (dim_y - 1) + yy_channel = yy_channel.float() / (dim_x - 1) + + xx_channel = xx_channel * 2 - 1 + yy_channel = yy_channel * 2 - 1 + + xx_channel = xx_channel.repeat(b, 1, 1, 1) + yy_channel = yy_channel.repeat(b, 1, 1, 1) + + if torch.cuda.is_available and self.use_cuda: + input_tensor = input_tensor.cuda() + xx_channel = xx_channel.cuda() + yy_channel = yy_channel.cuda() + out = torch.cat([input_tensor, xx_channel, yy_channel], dim=1) + return out + + +class Conv(nn.Module): + """ (convolution => [BN] => ReLU) """ + + def __init__(self, in_channels, out_channels, kernel_size=3, conv_stride=1, padding=1, bias=True, + activation_func='relu', style=False): + super().__init__() + + self.style = style + norm_layer, activation_func = get_layer_info(out_channels, activation_func) + if style: + self.styleconv = Conv2DMod(in_channels, out_channels, kernel_size) + self.relu = nn.LeakyReLU(0.2, inplace=True) + else: + if norm_layer is not None: + self.conv = nn.Sequential( + nn.Conv2d(in_channels, out_channels, stride=conv_stride, kernel_size=kernel_size, padding=padding, + bias=bias), + norm_layer, + activation_func) + else: + self.conv = nn.Sequential( + nn.Conv2d(in_channels, out_channels, stride=conv_stride, kernel_size=kernel_size, padding=padding, + bias=bias), + activation_func) + + def forward(self, x, style_fea): + if self.style: + res = self.styleconv(x, style_fea) + res = self.relu(res) + return res + else: + return self.conv(x) + + +class Conv2DMod(nn.Module): + def __init__(self, in_chan, out_chan, kernel, demod=True, stride=1, dilation=1, eps=1e-8, **kwargs): + super().__init__() + self.filters = out_chan + self.demod = demod + self.kernel = kernel + self.stride = stride + self.dilation = dilation + self.weight = nn.Parameter(torch.randn((out_chan, in_chan, kernel, kernel))) + self.eps = eps + nn.init.kaiming_normal_(self.weight, a=0, mode='fan_in', nonlinearity='leaky_relu') + + def _get_same_padding(self, size, kernel, dilation, stride): + return ((size - 1) * (stride - 1) + dilation * (kernel - 1)) // 2 + + def forward(self, x, y): + b, c, h, w = x.shape + + w1 = y[:, None, :, None, None] + w2 = self.weight[None, :, :, :, :] + weights = w2 * (w1 + 1) + + if self.demod: + d = torch.rsqrt((weights ** 2).sum(dim=(2, 3, 4), keepdim=True) + self.eps) + weights = weights * d + + x = x.reshape(1, -1, h, w) + + _, _, *ws = weights.shape + weights = weights.reshape(b * self.filters, *ws) + + padding = self._get_same_padding(h, self.kernel, self.dilation, self.stride) + x = F.conv2d(x, weights, padding=padding, groups=b) + + x = x.reshape(-1, self.filters, h, w) + return x + +class Up(nn.Module): + """ Upscaling then conv """ + + def __init__(self, in_channels, out_channels, activation_func='relu', style=False): + super().__init__() + self.style = style + activation_func = 'relu' + norm_layer, activation_func = get_layer_info(out_channels, activation_func) + + self.up_layer = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True) + self.up = Conv(in_channels, in_channels // 4, activation_func=activation_func, style=style) + + def forward(self, x, style_fea): + if self.style: + x = self.up_layer(x) + return self.up(x, style_fea) + else: + x = self.up_layer(x) + return self.up(x, style_fea) + + +class PSPUpsample(nn.Module): + def __init__(self, in_channels, out_channels, scale_x, scale_y): + super().__init__() + self.conv = Conv(in_channels, out_channels) + self.scale_x = scale_x + self.scale_y = scale_y + + def forward(self, x): + h, w = self.scale_y * x.size(2), self.scale_x * x.size(3) + p = F.upsample(input=x, size=(h, w), mode='bilinear') + return self.conv(p) + + +class PSP(nn.Module): + def __init__(self, in_channels): + super().__init__() + # pooling + self.pool2 = nn.AdaptiveAvgPool2d((2, 2)) + self.pool4 = nn.AdaptiveAvgPool2d((4, 4)) + self.pool8 = nn.AdaptiveAvgPool2d((8, 8)) + + # conv -> compress channels + avg_channel = in_channels // 4 + self.conv2 = Conv(in_channels, avg_channel) + self.conv4 = Conv(in_channels, avg_channel) + self.conv8 = Conv(in_channels, avg_channel) + self.conv16 = Conv(in_channels, avg_channel) + + # up sapmle -> match dimension + self.up2 = PSPUpsample(avg_channel, avg_channel, 16 // 2, 16 // 2) + self.up4 = PSPUpsample(avg_channel, avg_channel, 16 // 4, 16 // 4) + self.up8 = PSPUpsample(avg_channel, avg_channel, 16 // 8, 16 // 8) + + def forward(self, x): + x2 = self.up2(self.conv2(self.pool2(x))) + x4 = self.up4(self.conv4(self.pool4(x))) + x8 = self.up8(self.conv8(self.pool8(x))) + x16 = self.conv16(x) + return torch.cat((x2, x4, x8, x16), dim=1) + + +class Up_Stream(nn.Module): + """ Up Stream Sequence """ + + def __init__(self, out_channels=3, activation_func = 'relu'): + super(Up_Stream, self).__init__() + + input_channel = 512 + fea_dim = 200 + norm_layer, activation_func = get_layer_info(input_channel, activation_func) + self.to_style1 = nn.Linear(in_features=fea_dim, out_features=input_channel) + self.up_16_16_1 = Conv(input_channel, 256, activation_func=activation_func, style=True) + self.up_16_16_2 = Conv(768, 512, activation_func=activation_func) + self.up_16_16_3 = Conv(1024, 512, activation_func=activation_func) + + self.up_16_32 = Up(1024, 256, activation_func=activation_func) + self.to_style2 = nn.Linear(in_features=fea_dim, out_features=512) + self.up_32_32_1 = Conv(512, 256, activation_func=activation_func, style=True) + + self.up_32_64 = Up(512, 128, activation_func=activation_func) + self.to_style3 = nn.Linear(in_features=fea_dim, out_features=256) + self.up_64_64_1 = Conv(256, 128, activation_func=activation_func, style=True) + + self.up_64_128 = Up(256, 64, activation_func=activation_func) + self.to_style4 = nn.Linear(in_features=fea_dim, out_features=128) + self.up_128_128_1 = Conv(128, 64, activation_func=activation_func, style=True) + + self.up_128_256 = Up(128, 32, activation_func=activation_func) + self.out_conv = Conv(64, out_channels, activation_func='relu') + + def forward(self, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, style): + batch_size, c, h, w = x1.size() + + # import pdb; pdb.set_trace() + # multiple channel ibl + # style = torch.zeros(batch_size, 500).to(x11.device) + + # y = l.view(-1, 512, 1, 1).repeat(1, 1, 16, 16) + style1 = self.to_style1(style) + y = self.up_16_16_1(x11, style1) # 256 x 16 x 16 + + y = torch.cat((x10, y), dim=1) # 768 x 16 x 16 + # print(y.size()) + + y = self.up_16_16_2(y, y) # 512 x 16 x 16 + # print(y.size()) + + y = torch.cat((x9, y), dim=1) # 1024 x 16 x 16 + # print(y.size()) + + # import pdb; pdb.set_trace() + y = self.up_16_16_3(y, y) # 512 x 16 x 16 + # print(y.size()) + + y = torch.cat((x8, y), dim=1) # 1024 x 16 x 16 + # print(y.size()) + + # import pdb; pdb.set_trace() + y = self.up_16_32(y, y) # 256 x 32 x 32 + # print(y.size()) + + y = torch.cat((x7, y), dim=1) + style2 = self.to_style2(style) + y = self.up_32_32_1(y, style2) # 256 x 32 x 32 + # print(y.size()) + + y = torch.cat((x6, y), dim=1) + y = self.up_32_64(y, y) + # print(y.size()) + y = torch.cat((x5, y), dim=1) + style3 = self.to_style3(style) + y = self.up_64_64_1(y, style3) # 128 x 64 x 64 + # print(y.size()) + + y = torch.cat((x4, y), dim=1) + y = self.up_64_128(y, y) + # print(y.size()) + y = torch.cat((x3, y), dim=1) + style4 = self.to_style4(style) + y = self.up_128_128_1(y, style4) # 64 x 128 x 128 + # print(y.size()) + + y = torch.cat((x2, y), dim=1) + y = self.up_128_256(y, y) # 32 x 256 x 256 + # print(y.size()) + + y = torch.cat((x1, y), dim=1) + + y = self.out_conv(y, y) # 3 x 256 x 256 + + return y diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/test.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/test.py new file mode 100644 index 0000000000000000000000000000000000000000..e8e295c52576252a5eb52cbc568c693f0b2b9125 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/test.py @@ -0,0 +1,24 @@ +import torch +import ssn_dataset +from torchvision import transforms, utils +import numpy as np + +csv_file = "~/Dataset/soft_shadow/train/metadata.csv" +# compose_transform = None +training_dataset = ssn_dataset.SSN_Dataset(csv_file, is_training = True) +testing_dataset = ssn_dataset.SSN_Dataset(csv_file, is_training = False) + +print('training set size: ', len(training_dataset)) +print('testing set size: ',len(testing_dataset)) + +print(len(training_dataset.meta_data)) +print(training_dataset.meta_data[0]) + +# for j in range(10): +# for i in range(len(training_dataset)): +# data = training_dataset[i] +# # print("{} \r".format(i), flush=True, end="") +# print("{} ".format(i)) + +# for i,data in enumerate(testing_dataset): +# print("{} \r".format(i), flush=True, end="") diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/test_dataset.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/test_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..262c0496a70e727f7e2754074c40eefe3867146d --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/ssn/test_dataset.py @@ -0,0 +1,21 @@ +import ssn_dataset +import time + +if __name__ == '__main__': + start = time.time() + csv_file = "~/Dataset/soft_shadow/single_human/metadata.csv" + training_dataset = ssn_dataset.SSN_Dataset(csv_file, is_training=True) + testing_dataset = ssn_dataset.SSN_Dataset(csv_file, is_training=False) + + print("Training dataset num: ", len(training_dataset)) + print("Testing dataset num: ",len(testing_dataset)) + + for i in range(len(training_dataset)): + data = training_dataset[i] + print('Training set: successfully iterate {} \r'.format(i), flush=True, end='') + + for i in range(len(testing_dataset)): + data = testing_dataset[i] + print('Validation set: successfully iterate {} \r'.format(i), flush=True, end='') + + end = time.time() diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/__init__.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/html.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/html.py new file mode 100644 index 0000000000000000000000000000000000000000..9b8722b556683df920d7a6fa446f86242086d5e1 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/html.py @@ -0,0 +1,61 @@ +import dominate +from dominate.tags import meta, h3, table, tr, td, p, a, img, br +import os + +class HTML: + def __init__(self, web_dir, title, reflesh=0): + self.title = title + self.web_dir = web_dir + if not os.path.exists(self.web_dir): + os.makedirs(self.web_dir) + + # print(self.img_dir) + + self.doc = dominate.document(title=title) + if reflesh > 0: + with self.doc.head: + meta(http_equiv="reflesh", content=str(reflesh)) + + def get_image_dir(self): + return self.img_dir + + def add_header(self, str): + with self.doc: + h3(str) + + def add_table(self, border=1): + self.t = table(border=border, style="table-layout: fixed;") + self.doc.add(self.t) + + def add_images(self, ims, txts, links, width=400, height=300): + self.add_table() + with self.t: + with tr(): + for im, txt, link in zip(ims, txts, links): + with td(style="word-wrap: break-word; height:{}px; width:{}px".format(height + 10,width + 10), halign="center", valign="top"): + with p(): + with a(href=os.path.join('/',link)): + img(style="width:{}px;height:{}".format(width, height), src=os.path.join('/',im)) + br() + p(txt) + + def save(self): + html_file = '%s/index.html' % self.web_dir + f = open(html_file, 'wt') + f.write(self.doc.render()) + f.close() + + +if __name__ == '__main__': + html = HTML('web/', 'test_html') + html.add_header('hello world') + + ims = [] + txts = [] + links = [] + for n in range(4): + ims.append('image_%d.png' % n) + txts.append('text_%d' % n) + links.append('image_%d.png' % n) + html.add_images(ims, txts, links) + html.save() diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/html_server.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/html_server.py new file mode 100644 index 0000000000000000000000000000000000000000..58c5f2029388e66f085090a582b540b2aa996078 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/html_server.py @@ -0,0 +1,9 @@ +import http.server +import socketserver + +PORT = 8081 +Handler = http.server.SimpleHTTPRequestHandler + +with socketserver.TCPServer(("", PORT), Handler) as httpd: + print("serving at port", PORT) + httpd.serve_forever() diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/imgs b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/imgs new file mode 100644 index 0000000000000000000000000000000000000000..14eb8bcb99683c095299e7a1b3aba6e5d611f5e9 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/imgs @@ -0,0 +1 @@ +/home/ysheng/Dataset/dropbox/Research/SSN_Training_Share/touch \ No newline at end of file diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/index.html b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/index.html new file mode 100644 index 0000000000000000000000000000000000000000..9bff4fa31ddd2ffc82a9401d78f79ec7ae063051 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/index.html @@ -0,0 +1,10809 @@ + + + + benchmark + + + + + + + +
+

+ + +
+

pitch_0_rot_0_fov_60_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_81_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_129_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_78_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_60_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_26_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_85_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_45_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_109_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_93_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_73_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_113_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_127_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_65_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_68_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_76_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_104_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_54_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_56_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_113_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_88_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_59_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_68_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_109_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_72_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_130_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_134_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_52_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_23_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_86_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_75_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_50_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_21_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_89_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_80_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_61_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_43_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_102_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_70_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_98_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_35_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_67_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_112_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_23_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_80_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_117_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_73_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_67_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_97_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_115_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_29_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_101_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_102_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_66_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_79_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_25_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_66_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_20_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_64_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_38_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_79_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_73_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_81_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_42_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_38_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_73_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_60_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_51_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_81_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_73_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_76_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_80_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_96_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_103_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_104_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_80_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_30_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_44_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_120_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_42_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_49_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_20_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_105_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_49_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_37_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_27_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_94_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_98_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_70_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_95_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_38_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_22_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_56_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_92_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_110_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_82_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_102_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_28_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_85_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_64_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_98_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_68_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_64_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_61_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_116_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_94_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_104_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_22_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_54_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_64_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_88_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_54_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_124_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_72_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_36_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_44_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_50_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_45_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_44_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_84_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_73_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_41_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_54_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_33_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_106_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_72_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_70_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_88_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_100_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_27_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_129_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_64_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_26_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_61_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_107_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_106_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_115_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_90_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_52_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_33_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_72_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_95_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_100_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_131_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_102_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_117_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_43_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_52_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_93_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_26_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_127_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_65_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_115_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_99_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_59_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_30_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_49_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_61_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_51_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_84_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_84_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_35_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_72_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_107_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_112_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_43_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_42_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_70_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_85_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_47_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_49_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_85_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_67_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_34_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_36_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_75_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_92_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_99_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_70_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_90_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_54_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_35_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_117_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_25_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_76_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_93_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_23_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_113_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_99_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_25_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_73_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_108_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_107_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_100_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_64_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_36_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_66_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_108_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_60_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_59_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_91_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_90_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_34_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_104_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_65_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_43_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_69_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_133_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_21_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_49_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_79_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_98_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_25_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_45_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_59_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_38_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_85_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_85_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_63_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_105_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_99_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_30_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_101_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_28_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_61_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_29_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_71_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_64_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_102_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_43_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_40_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_97_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_81_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_58_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_102_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_79_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_65_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_106_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_23_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_91_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_47_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_66_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_33_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_54_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_23_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_59_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_85_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_138_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_86_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_35_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_114_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_106_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_34_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_96_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_104_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_42_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_93_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_84_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_43_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_138_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_21_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_62_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_31_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_24_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_92_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_112_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_66_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_28_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_64_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_90_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_35_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_112_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_109_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_121_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_62_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_69_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_30_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_71_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_117_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_35_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_84_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_35_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_47_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_65_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_102_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_31_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_44_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_24_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_34_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_64_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_51_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_48_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_42_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_42_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_59_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_30_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_102_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_65_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_135_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_108_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_122_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_85_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_103_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_100_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_63_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_79_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_24_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_22_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_61_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_108_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_94_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_88_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_126_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_70_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_47_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_35_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_81_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_92_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_92_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_49_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_36_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_50_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_98_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_33_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_44_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_68_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_105_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_121_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_70_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_89_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_65_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_44_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_43_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_76_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_116_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_31_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_24_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_104_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_119_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_30_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_67_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_68_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_29_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_85_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_48_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_111_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_49_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_98_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_36_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_124_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_64_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_31_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_120_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_97_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_78_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_64_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_70_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_80_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_36_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_77_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_25_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_95_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_98_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_98_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_101_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_69_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_90_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_74_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_107_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_135_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_40_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_41_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_51_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_59_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_82_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_118_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_58_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_38_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_91_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_42_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_133_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_47_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_103_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_43_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_119_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_51_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_94_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_44_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_113_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_31_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_41_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_114_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_73_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_104_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_96_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_104_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_78_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_37_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_99_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_59_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_42_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_82_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_133_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_52_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_110_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_74_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_77_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_96_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_90_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_80_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_77_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_92_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_28_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_138_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_29_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_113_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_50_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_29_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_63_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_91_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_136_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_93_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_80_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_108_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_118_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_43_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_110_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_69_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_34_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_40_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_37_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_73_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_58_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_94_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_61_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_138_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_127_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_125_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_84_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_90_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_61_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_37_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_62_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_41_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_69_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_91_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_129_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_116_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_106_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_52_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_130_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_72_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_37_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_91_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_76_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_28_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_127_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_81_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_29_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_69_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_84_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_103_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_61_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_91_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_115_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_107_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_113_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_82_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_29_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_103_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_89_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_65_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_21_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_100_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_59_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_26_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_63_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_23_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_24_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_77_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_54_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_74_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_121_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_66_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_51_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_85_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_33_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_36_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_41_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_47_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_71_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_50_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_106_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_40_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_49_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_75_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_79_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_73_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_47_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_62_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_49_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_93_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_99_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_86_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_29_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_59_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_72_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_86_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_42_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_27_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_118_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_96_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_74_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_44_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_50_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_44_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_123_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_52_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_77_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_68_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_40_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_108_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_94_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_81_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_95_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_24_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_98_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_29_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_24_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_20_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_56_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_33_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_77_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_92_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_35_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_132_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_90_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_33_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_91_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_113_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_82_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_64_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_52_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_136_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_107_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_123_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_37_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_76_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_41_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_65_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_80_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_69_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_90_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_37_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_24_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_120_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_25_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_78_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_63_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_49_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_76_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_21_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_45_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_60_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_84_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_29_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_89_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_51_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_75_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_48_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_104_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_60_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_129_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_30_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_79_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_65_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_90_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_45_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_50_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_61_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_66_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_76_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_72_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_92_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_45_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_139_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_41_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_109_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_43_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_80_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_75_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_93_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_92_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_28_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_20_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_98_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_66_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_52_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_82_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_89_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_45_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_56_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_119_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_67_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_70_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_106_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_20_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_35_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_38_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_94_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_67_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_48_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_130_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_52_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_139_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_48_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_74_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_44_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_104_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_58_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_95_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_98_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_58_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_47_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_77_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_124_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_99_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_81_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_75_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_102_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_34_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_95_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_114_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_21_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_62_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_22_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_90_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_21_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_45_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_78_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_86_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_103_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_81_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_51_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_77_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_61_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_35_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_66_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_59_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_82_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_44_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_89_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_21_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_78_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_45_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_104_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_100_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_119_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_65_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_71_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_52_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_27_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_26_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_47_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_29_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_90_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_67_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_82_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_122_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_73_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_93_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_138_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_41_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_139_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_94_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_28_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_89_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_82_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_37_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_64_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_80_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_76_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_82_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_63_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_124_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_56_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_121_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_68_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_23_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_31_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_56_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_103_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_24_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_78_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_84_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_80_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_128_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_106_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_108_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_139_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_58_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_123_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_38_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_22_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_61_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_72_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_40_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_70_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_88_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_81_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_27_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_88_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_105_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_129_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_113_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_53_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_122_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_38_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_32_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_66_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_55_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_25_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_30_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_69_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_51_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_97_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_41_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_60_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_50_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_101_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_97_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_49_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_91_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_30_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_20_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_106_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_63_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_82_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_62_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_61_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_84_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_71_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_86_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_67_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_27_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_73_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_35_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_42_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_21_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_82_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_45_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_72_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_75_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_112_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_63_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_89_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_119_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_74_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_46_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_107_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_41_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_99_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_87_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_41_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-90_fov_57_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-45_fov_83_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_90_fov_47_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_-45_fov_122_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_45_fov_71_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_0_fov_43_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-90_fov_52_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_45_fov_74_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_90_fov_102_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_-90_fov_36_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_0_fov_50_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_0_rot_90_fov_39_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_45_fov_122_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_30_rot_0_fov_75_touch.png

+

+
+ + + + +
+

+ + +
+

pitch_15_rot_-45_fov_78_touch.png

+

+
+ + \ No newline at end of file diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/make_html.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/make_html.py new file mode 100644 index 0000000000000000000000000000000000000000..5875d362a5a5ccc74a641abc663aa767cfcd80b9 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/make_html.py @@ -0,0 +1,133 @@ +import numpy as np +import json +import pdb +import os +from os.path import join +import html +from tqdm import tqdm +import argparse +import pandas as pd +import matplotlib.pyplot as plt + +def get_files(folder): + return [join(folder, f) for f in os.listdir(folder) if os.path.isfile(join(folder, f))] + +def get_folders(folder): + return [join(folder, f) for f in os.listdir(folder) if os.path.isdir(join(folder, f))] + +vis_img_folder = 'imgs' +vis_eval_img_folder = 'eval_imgs' +def eval_gen(webpage, output_folder, is_pattern=True): + def get_file(files, key_world): + mitsuba_shadow = '' + for f in files: + if f.find(key_world) != -1: + mitsuba_shadow = f + break + return mitsuba_shadow + + def flip_shadow(img_file): + dirname, fname = os.path.dirname(img_file), os.path.splitext(os.path.basename(img_file))[0] + if img_file == '': + print('find one zero') + mts_shadow_np = np.zeros((256,256,3)) + else: + mts_shadow_np = plt.imread(img_file) + + save_path = join(dirname, fname + '_flip.png') + plt.imsave(save_path, 1.0-mts_shadow_np) + return save_path + + img_folders = join(output_folder, 'imgs') + folders = get_folders(img_folders) + print("There are {} folders".format(len(folders))) + + for model in tqdm(folders): + cur_model_relative = join(vis_img_folder, os.path.basename(model)) + evl_cur_model_relative = join(vis_eval_img_folder, os.path.basename(model)) + + if is_pattern: + ibl_relative = join(cur_model_relative, 'pattern') + else: + ibl_relative = join(cur_model_relative, 'real') + + # import pdb; pdb.set_trace() + ibl_folders = get_folders(ibl_relative) + ibl_folders.sort() + for ibl in ibl_folders: + cur_ibl_relative = join(ibl_relative,os.path.basename(ibl)) + gt_files = get_files(cur_ibl_relative) + mts_shadow = get_file(gt_files, '_shadow.png') + + ibl_name = os.path.basename(ibl) + ibl = join(cur_ibl_relative, ibl_name + '.png') + + mitsuba_shadow = flip_shadow(mts_shadow) + + cur_eval_folder = join(evl_cur_model_relative, join('pattern', ibl_name)) + net_predict = get_file(get_files(cur_eval_folder), 'predict.png') + + # mitsuba_final = join(cur_ibl_relative, 'composite.png') + # pred_final = join(cur_ibl_relative, 'composite_pred.png') + + # print(ibl_name) + ims, txts, links = [ibl,mitsuba_shadow, net_predict], ['ibl','mitsuba', 'predict'], [ibl,mitsuba_shadow, net_predict] + + webpage.add_images(ims, txts, links) + +vis_pattern_folder = '/home/ysheng/Documents/vis_pattern' +vis_real_folder = '/home/ysheng/Documents/vis_real' +def vis_files_in_folder(): + folder = '/home/ysheng/Documents/vis_models' + webpage = html.HTML(folder, 'models', reflesh=1) + img_folders = join(folder, 'imgs') + files = get_files(img_folders) + print("There are {} files".format(len(files))) + + prefix_set = set() + for cur_file in tqdm(files): + cur_name = os.path.splitext(os.path.basename(cur_file))[0] + prefix_set.add(cur_name[:-3]) + + print('there are {} prefixs'.format(len(prefix_set))) + prefix_set = list(prefix_set) + prefix_set.sort() + + # import pdb; pdb.set_trace() + relative_folder = './imgs' + for i, prefix in enumerate(prefix_set): + ims = [join(relative_folder, prefix + '{:03d}.png'.format(i)) for i in range(len(files) // len(prefix_set))] + txts = [prefix + '{:03d}'.format(i) for i in range(len(files) // len(prefix_set))] + links = ims + webpage.add_images(ims, txts, links) + + webpage.save() + print('finished') + +def vis_files(df_file): + """ input is a pandas dataframe + format: path, path,..., name,name, ... + """ + folder = '.' + webpage = html.HTML(folder, 'benchmark', reflesh=1) + + relative_folder = './imgs' +# for i, prefix in enumerate(prefix_set): +# ims = [join(relative_folder, prefix + '{:03d}.png'.format(i)) for i in range(len(files) // len(prefix_set))] +# txts = [prefix + '{:03d}'.format(i) for i in range(len(files) // len(prefix_set))] +# links = ims +# webpage.add_images(ims, txts, links) + + df = pd.read_csv(df_file) + for i,v in tqdm(df.iterrows(), total=len(df)): + img_range = len(v)//2+1 + imgs = [join(relative_folder,v[i]) for i in range(1,img_range)] + txts = [v[i] for i in range(img_range, len(v))] + links = imgs + webpage.add_images(imgs, txts, links) + + webpage.save() + print('finished') + +if __name__ == "__main__": + vis_files('/home/ysheng/Documents/paper_project/adobe/soft_shadow/benchmark_results/html.csv') diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/net_utils.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/net_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..6de30e871af85d67fb5bab06e79c8d90100d961b --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/net_utils.py @@ -0,0 +1,70 @@ +#import matplotlib.pyplot as plt +import os +from torchvision import transforms, utils +import torch +#import matplotlib.pyplot as plt +import numpy as np +from utils.utils_file import get_cur_time_stamp, create_folder + +def compute_differentiable_params(net): + return sum(p.numel() for p in net.parameters() if p.requires_grad) + +def convert_Relight_latent_light(latent_feature): + """ Convert n x 6 x 16 x 16 -> n x 3 x 16 x 32 """ + # torch image: C X H X W + batch_size, C, H, W = latent_feature.size() + latent_feature = torch.reshape(latent_feature, (batch_size, 3, 16, 32)) # make sure it is right + # print(latent_feature.size()) + return latent_feature + +def show_batch(sample_batch, out_file=None): + grid = utils.make_grid(sample_batch) + plt.figure(figsize=(30,20)) + plt.imshow(grid.detach().cpu().numpy().transpose((1,2,0))) + + if not out_file is None: + print('try save ', out_file) + plt.savefig(out_file) + + plt.show() + +def show_light_batch(light_batch): + light_batch = convert_Relight_latent_light(light_batch) + show_batch(light_batch) + +def save_loss(figure_fname, train_loss, valid_loss): + plt.plot(train_loss) + plt.plot(valid_loss) + plt.legend(['train_loss', 'valid_loss']) + plt.savefig(figure_fname) + +def save_model(output_folder, model, optimizer, epoch, best_loss, fname, hist_train_loss, hist_valid_loss, hist_lr, params): + """ Save current best model into some folder """ + create_folder(output_folder) + + # cur_time_stamp = get_cur_time_stamp() + # output_fname = os.path.join(output_folder, exp_name + '_' + cur_time_stamp + ".pt") + output_fname = os.path.join(output_folder, fname) + tmp_model = model + if params.multi_gpu and hasattr(tmp_model, 'module'): + tmp_model = model.module + + torch.save({ + 'epoch': epoch, + 'best_loss': best_loss, + 'model_state_dict': tmp_model.state_dict(), + 'optimizer_state_dict': optimizer.state_dict(), + 'hist_train_loss': hist_train_loss, + 'hist_valid_loss': hist_valid_loss, + 'hist_lr':hist_lr, + 'params':str(params) + }, output_fname) + return output_fname + +def get_lr(optimizer): + for param_group in optimizer.param_groups: + return param_group['lr'] + +def set_lr(optimizer, lr): + for param_group in optimizer.param_groups: + param_group['lr'] = lr diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/tensorboard_utils.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/tensorboard_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..f8ef863d30f9dd7db86b7c1ba2212d4c3943f5be --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/tensorboard_utils.py @@ -0,0 +1,29 @@ +import numpy as np +import torch +from torch.utils.tensorboard import SummaryWriter + +def tensorboard_plot_loss(win_name, loss, writer): + writer.add_scalar("Loss/{}".format(win_name), loss[-1], len(loss)) + writer.flush() + +def normalize_img(imgs): + b,c,h,w = imgs.shape + gt_batch = b//2 + for i in range(gt_batch): + factor = torch.max(imgs[i]) + imgs[i] = imgs[i]/factor + imgs[gt_batch + i] = imgs[gt_batch + i]/factor + + imgs = torch.clamp(imgs, 0.0,1.0) + return imgs + +def tensorboard_show_batch(imgs, writer, win_name=None, nrow=2, normalize=True, step=0): + if normalize: + imgs = normalize_img(imgs) + + writer.add_images('{}'.format(win_name), imgs, step) + writer.flush() + +def tensorboard_log(log_info, writer, win_name='logger', step=0): + writer.add_text(win_name, log_info, step) + writer.flush() diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/time_utils.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/time_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..3b5111cbe2f7cdbc049552ff752497875055481f --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/time_utils.py @@ -0,0 +1,6 @@ +import datetime + +def get_time_stamp(): + return '{:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now()) + + diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/utils_file.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/utils_file.py new file mode 100644 index 0000000000000000000000000000000000000000..6671ea65279856058346dd29c543ae2e532b4ba0 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/utils_file.py @@ -0,0 +1,59 @@ +from shutil import copyfile +from os import listdir +from os.path import isfile, join +import os +import datetime + +def get_all_folders(folder): + if check_file_exists(folder) == False: + print("Cannot find the folder ", folder) + return [] + subfolders = [f for f in os.listdir(folder) if not isfile(join(folder,f))] + return subfolders + +def get_all_files(folder): + if check_file_exists(folder) == False: + print("Cannot find the folder ", folder) + return [] + + ori_files = [f for f in listdir(folder) if isfile(join(folder, f))] + return ori_files + +def create_folder(folder): + if not os.path.exists(folder): + os.mkdir(folder) + +def create_folders(folder_list): + for f in folder_list: + create_folder(f) + +def replace_file_ext(fname, new_ext): + ext_pos = fname.find(".") + if ext_pos != -1: + return fname[0:ext_pos] + "."+ new_ext + else: + print("Please check " + fname) + +def check_file_exists(fname, verbose=True): + try: + if not os.path.exists(fname) or get_file_size(fname) == 0: + if verbose: + print("file {} does not exists! ".format(fname)) + return False + except: + print("File {} has some issue! ".format(fname)) + return False + return True + +def delete_file(fname): + if check_file_exists(fname): + os.remove(fname) + +def get_file_size(fname): + return os.path.getsize(fname) + +def get_folder_size(folder): + return sum(os.path.getsize(folder + f) for f in listdir(folder) if isfile(join(folder, f))) + +def get_cur_time_stamp(): + return datetime.datetime.now().strftime("%d-%B-%I-%M-%p") \ No newline at end of file diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/vis_test_results.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/vis_test_results.py new file mode 100644 index 0000000000000000000000000000000000000000..58a3876b648de554b1a1a9b3522ce86a37a63b01 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/vis_test_results.py @@ -0,0 +1,21 @@ +import numpy as np +import json +import pdb +import os +from os.path import join +import html +from tqdm import tqdm +import argparse +import pandas as pd +import cv2 as cv + +base_softness = "0.1" +base_exp_name = "fov_results_real_89" +root_dir = "/mnt/share/yifan/code/soft_shadow-master/vis_res/" +base_dir = root_dir + base_exp_name + '/' + base_softness + +exp_name = ["fov_results_real_hd", "fov_results_real_hd_0713"] + +softness = [0.1, 0.2] + +case_name = ["case1", "case2", "case7"] diff --git a/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/visdom_utils.py b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/visdom_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..97340c489a506670de6affa8ab49c43216af9bf6 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/ShadowStyle/inference/utils/visdom_utils.py @@ -0,0 +1,53 @@ +from visdom import Visdom +import numpy as np +import torch + +# viz = Visdom(port=8002) +# viz2 = Visdom(port=8003) + +def setup_visdom(port=8002): + return Visdom(port=port) + +def visdom_plot_loss(win_name, loss, cur_viz): + loss_np = np.array(loss) + x = np.arange(1, 1 + len(loss)) + cur_viz.line(win=win_name, + X=x, + Y=loss_np, + opts=dict(showlegend=True, legend=[win_name])) + +def guassian_light(light_tensor): + light_tensor = light_tensor.detach().cpu() + channel = light_tensor.size()[0] + tensor_ret = torch.zeros(light_tensor.size()) + for i in range(channel): + light_np = light_tensor[0].numpy() * 100.0 + light_np = gaussian_filter(light_np, sigma=2) + tensor_ret[i] = torch.from_numpy(light_np) + tensor_ret[i] = torch.clamp(tensor_ret[i], 0.0, 1.0) + + return tensor_ret + +def normalize_img(imgs): + b,c,h,w = imgs.shape + gt_batch = b//2 + for i in range(gt_batch): + factor = torch.max(imgs[i]) + imgs[i] = imgs[i]/factor + imgs[gt_batch + i] = imgs[gt_batch + i]/factor + # imgs[i] = imgs[i]/3.0 + + imgs = torch.clamp(imgs, 0.0,1.0) + return imgs + +def visdom_show_batch(imgs, cur_viz, win_name=None, nrow=2, normalize=True): + if normalize: + imgs = normalize_img(imgs) + + if win_name is None: + cur_viz.images(imgs, win="batch visualize",nrow=nrow) + else: + cur_viz.images(imgs, win=win_name, opts=dict(title=win_name),nrow=nrow) + +def visdom_log(log_info, viz, win_name='logger'): + viz.text(log_info, win=win_name) \ No newline at end of file diff --git a/PixHtLab-Src/Demo/PixhtLab/Torch_Render/hshadow_cuda.cpp b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/hshadow_cuda.cpp new file mode 100644 index 0000000000000000000000000000000000000000..357492883bf311f0d8e1d579952d0bde227c0375 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/hshadow_cuda.cpp @@ -0,0 +1,98 @@ +#include + +#include +#include + +// CUDA forward declarations +std::vector hshadow_render_cuda_forward(torch::Tensor rgb, torch::Tensor mask, torch::Tensor mask_bb, torch::Tensor hmap, torch::Tensor rechmap, torch::Tensor light_pos); +std::vector reflect_render_cuda_forward(torch::Tensor rgb, torch::Tensor mask, torch::Tensor hmap, torch::Tensor rechmap, torch::Tensor thresholds); +std::vector glossy_reflect_render_cuda_forward(torch::Tensor rgb, torch::Tensor mask, torch::Tensor hmap, torch::Tensor rechmap, const int sample_n, const float glossy); +torch::Tensor ray_intersect_cuda_forward(torch::Tensor rgb, torch::Tensor mask, torch::Tensor hmap, torch::Tensor rechmap, torch::Tensor rd_map); +torch::Tensor ray_scene_intersect_cuda_forward(torch::Tensor rgb, torch::Tensor mask, torch::Tensor hmap, torch::Tensor ro, torch::Tensor rd, float dh); + +// C++ interface +// NOTE: AT_ASSERT has become AT_CHECK on master after 0.4. +#define CHECK_CUDA(x) AT_ASSERTM(x.type().is_cuda(), #x " must be a CUDA tensor") +#define CHECK_CONTIGUOUS(x) AT_ASSERTM(x.is_contiguous(), #x " must be contiguous") +#define CHECK_INPUT(x) CHECK_CUDA(x); CHECK_CONTIGUOUS(x) + +/* Heightmap Shadow Rendering + rgb: B x 3 x H x W + mask: B x 1 x H x W + mask: B x 1 + hmap: B x 1 x H x W + rechmap: B x 1 x H x W + light_pos: B x 1 (x,y,h) +*/ +std::vector hshadow_render_forward(torch::Tensor rgb, torch::Tensor mask, torch::Tensor bb, torch::Tensor hmap, torch::Tensor rechmap, torch::Tensor light_pos) { + CHECK_INPUT(rgb); + CHECK_INPUT(mask); + CHECK_INPUT(bb); + CHECK_INPUT(hmap); + CHECK_INPUT(rechmap); + CHECK_INPUT(light_pos); + + return hshadow_render_cuda_forward(rgb, mask, bb, hmap, rechmap, light_pos); +} + +std::vector reflect_render_forward(torch::Tensor rgb, torch::Tensor mask, torch::Tensor hmap, torch::Tensor rechmap, torch::Tensor thresholds) { + CHECK_INPUT(rgb); + CHECK_INPUT(mask); + CHECK_INPUT(hmap); + CHECK_INPUT(rechmap); + CHECK_INPUT(thresholds); + + return reflect_render_cuda_forward(rgb, mask, hmap, rechmap, thresholds); +} + + +std::vector glossy_reflect_render_forward(torch::Tensor rgb, + torch::Tensor mask, + torch::Tensor hmap, + torch::Tensor rechmap, + int sample_n, + float glossy) { + CHECK_INPUT(rgb); + CHECK_INPUT(mask); + CHECK_INPUT(hmap); + CHECK_INPUT(rechmap); + + return glossy_reflect_render_cuda_forward(rgb, mask, hmap, rechmap, sample_n, glossy); +} + + +torch::Tensor ray_intersect_foward(torch::Tensor rgb, + torch::Tensor mask, + torch::Tensor hmap, + torch::Tensor rechmap, + torch::Tensor rd_map) { + CHECK_INPUT(rgb); + CHECK_INPUT(mask); + CHECK_INPUT(hmap); + CHECK_INPUT(rechmap); + + return ray_intersect_cuda_forward(rgb, mask, hmap, rechmap, rd_map); +} + +torch::Tensor ray_scene_intersect_foward(torch::Tensor rgb, + torch::Tensor mask, + torch::Tensor hmap, + torch::Tensor ro, + torch::Tensor rd, + float dh) { + CHECK_INPUT(rgb); + CHECK_INPUT(mask); + CHECK_INPUT(hmap); + CHECK_INPUT(ro); + CHECK_INPUT(rd); + + return ray_scene_intersect_cuda_forward(rgb, mask, hmap, ro, rd, dh); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("forward", &hshadow_render_forward, "Heightmap Shadow Rendering Forward (CUDA)"); + m.def("reflection", &reflect_render_forward, "Reflection Rendering Forward (CUDA)"); + m.def("glossy_reflection", &glossy_reflect_render_forward, "Glossy Reflection Rendering Forward (CUDA)"); + m.def("ray_intersect", &ray_intersect_foward, "Ray scene intersection"); + m.def("ray_scene_intersect", &ray_scene_intersect_foward, "Ray scene intersection"); +} diff --git a/PixHtLab-Src/Demo/PixhtLab/Torch_Render/hshadow_cuda_kernel.cu b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/hshadow_cuda_kernel.cu new file mode 100644 index 0000000000000000000000000000000000000000..a56530d3c04decc754a81b17a685f53be92f0b2b --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/hshadow_cuda_kernel.cu @@ -0,0 +1,682 @@ +#include + +#include +#include + +#include +#include + +namespace { + template + __device__ + scalar_t sign(scalar_t t) { + if (t > 0.0) { + return (scalar_t)1.0; + } else { + return -(scalar_t)1.0; + } + } + + template + struct vec2 { + scalar_t x, y; + + __device__ + vec2() { x=0.0, y=0.0;} + + __device__ + vec2(scalar_t x, scalar_t y):x(x), y(y) {} + }; + + + template + struct vec3 { + scalar_t x, y, z; + + __device__ + vec3() { x=0.0, y=0.0, z=0.0;} + + __device__ + vec3(scalar_t x, scalar_t y, scalar_t z):x(x), y(y), z(z) {} + }; + + + template + __device__ + scalar_t lerp(scalar_t a, scalar_t b, scalar_t t) { + return (1.0-t) * a + t * b; + } + + template + __device__ + void proj_ground( + scalar_t x0, scalar_t y0, scalar_t h0, + scalar_t x1, scalar_t y1, scalar_t h1, + scalar_t &x2, scalar_t &y2 + ) { + scalar_t t = (0-h0)/(h1-h0); + x2 = lerp(x0, x1, t); + y2 = lerp(y0, y1, t); + } + + + // line checking condition with thickness value dh, which is the height difference for double-height map + // we can also use dh as a tolerance value + template + __device__ + bool check_intersect( + scalar_t xa, scalar_t ya, scalar_t ha, + scalar_t xb, scalar_t yb, scalar_t hb, + scalar_t x, scalar_t y, scalar_t h, + scalar_t dh, int& flag) { + scalar_t t = xa == xb ? (y-ya)/(yb-ya):(x-xa)/(xb-xa); + scalar_t h_ = lerp(ha, hb, t); + flag = h_ <= h ? 1:-1; + return (h_ <= h) && (h_ >= h-dh); + } + + /* + * Ray trace in the current scene + * Given start point xyh, light point xyh, current receiver's height map, + * Return: + * 1. if intersect or not + * 2. the color for the intersection point + * */ + template + __device__ + bool ray_trace(vec3 s, + vec3 l, + const int bi, + const torch::PackedTensorAccessor64 d_mask, + const torch::PackedTensorAccessor64 d_hmap, + const torch::PackedTensorAccessor64 d_rechmap, + const torch::PackedTensorAccessor64 d_rgb, + vec3 &out) { + bool ret = false; + + const int batch_size = d_rgb.size(0), h = d_rgb.size(2), w = d_rgb.size(3); + scalar_t lx = l.x; + scalar_t ly = l.y; + scalar_t lh = l.z; + + scalar_t recx = s.x; + scalar_t recy = s.y; + scalar_t rech = s.z; + + scalar_t dirx = lx - recx, diry = ly - recy; + bool gox = abs(dirx) > abs(diry); + int searching_n = gox ? w : h; + int starti = 0, endi = searching_n; + if (lh > 0) { + if (gox) { + starti = recx < lx ? recx:lx; + + endi = recx < lx ? lx:recx; + } + else { + starti = recy < ly ? recy:ly; + endi = recy < ly ? ly:recy; + } + } + if (lh < 0) { + if (gox) { + starti = recx < lx ? 0:recx; + endi = recx < lx ? recx:endi; + } + else { + starti = recy < ly ? 0:recy; + endi = recy < ly ? recy:endi; + } + } + + scalar_t sx, sy; + int flag = 0, last_flag = 0; + for(int si = starti; si < endi; ++si) { + /* Searching Point xyh */ + if (gox) { + sx = si; + sy = recy + (sx-recx)/dirx * diry; + } else { + sy = si; + sx = recx + (sy-recy)/diry * dirx; + } + + if (sx < 0 || sx > w-1 || sy < 0 || sy > h-1 || d_mask[bi][0][sy][sx] < 0.989) { + last_flag = 0; + continue; + } + + + scalar_t sh0 = d_hmap[bi][0][sy][sx]; + scalar_t sh1, sh; + // do linear interpolation for sh; note that either sy or sx are floating number + if (gox) { + if ( sy+1 > h-1 || d_mask[bi][0][sy+1][sx] < 0.989) + sh = sh0; + else { + sh1 = d_hmap[bi][0][sy+1][sx]; + sh = lerp(sh0, sh1, sy - int(sy)); + } + } + else { + if ( sx+1 > w-1 || d_mask[bi][0][sy][sx+1] < 0.989) + sh = sh0; + else { + sh1 = d_hmap[bi][0][sy][sx+1]; + sh = lerp(sh0, sh1, sx - int(sx)); + } + } + + scalar_t dh = 1.0; // this controls the thickness; for double height map, dh = h_f - h_b + bool intersect = check_intersect(recx, recy, rech, lx, ly, lh, sx, sy, sh, dh, flag); + if (intersect) { + /* TODO, which sampling? linear interpolation? */ + out.x = d_rgb[bi][0][(int)sy][(int)sx]; + out.y = d_rgb[bi][1][(int)sy][(int)sx]; + out.z = d_rgb[bi][2][(int)sy][(int)sx]; + + ret = true; + break; + } + if (last_flag != 0){ + if (last_flag != flag) { + out.x = d_rgb[bi][0][(int)sy][(int)sx]; + out.y = d_rgb[bi][1][(int)sy][(int)sx]; + out.z = d_rgb[bi][2][(int)sy][(int)sx]; + + ret = true; + break; + } + } + last_flag = flag; + } + + return ret; + } + + /* + * Ray trace in the current scene + * Given start point xyh, light point xyh, current receiver's height map, + * Return: + * 1. if intersect or not + * 2. the color for the intersection point + * */ + template + __device__ + bool ray_scene_intersect(vec3 ro, + vec3 rd, + const scalar_t dh, + const int bi, + const torch::PackedTensorAccessor64 d_mask, + const torch::PackedTensorAccessor64 d_hmap, + const torch::PackedTensorAccessor64 d_rgb, + vec3 &out) { + bool ret = false; + int h = d_mask.size(2); + int w = d_mask.size(3); + scalar_t dirx = rd.x, diry = rd.y, dirh = rd.z; + + /* Special Case, there's no direction update in x or y, but in h */ + if (abs(dirx) < 1e-6f && abs(diry) < 1e-6f) { + out.x = d_rgb[bi][0][(int)ro.y][(int)ro.x]; + out.y = d_rgb[bi][1][(int)ro.y][(int)ro.x]; + out.z = d_rgb[bi][2][(int)ro.y][(int)ro.x]; + return true; + } + + bool gox = abs(dirx) > abs(diry); + int searching_n = gox ? w : h; + + scalar_t cur_h; + scalar_t sx, sy; + + int prev_sign, cur_sign; + + // for(int si = starti; si < endi; ++si) { + for(int si = 0; si < searching_n; ++si) { + /* Searching Point XYH */ + if (gox) { + sx = ro.x + si * sign(dirx); + sy = ro.y + (sx-ro.x)/dirx * diry; + } else { + sy = ro.y + si * sign(diry); + sx = ro.x + (sy-ro.y)/diry * dirx; + } + + if (sx < 0 || sx > w-1 || sy < 0 || sy > h-1 || d_mask[bi][0][sy][sx] < 0.989) { + continue; + } + + scalar_t sh0 = d_hmap[bi][0][sy][sx]; + scalar_t sh1, sh; + // do linear interpolation for sh; note that either sy or sx are floating number + if (gox) { + if (sy+1 > h-1 || d_mask[bi][0][sy+1][sx] < 0.989) + sh = sh0; + else { + sh1 = d_hmap[bi][0][sy+1][sx]; + sh = lerp(sh0, sh1, sy - int(sy)); // Always use 0.5 to do interpolation + } + + cur_h = ro.z + (sx - ro.x) / dirx * dirh; + } + else { + if ( sx + 1 > w-1 || d_mask[bi][0][sy][sx+1] < 0.989) + sh = sh0; + else { + sh1 = d_hmap[bi][0][sy][sx+1]; + sh = lerp(sh0, sh1, sx - int(sx)); + } + + cur_h = ro.z + (sy - ro.y) / diry * dirh; + } + + // collide with the rechmap? + if (si == 0) { /* First sign */ + cur_sign = cur_h - sh; + continue; + } else { + prev_sign = cur_sign; + } + + cur_sign = cur_h - sh; + // if (cur_sign * prev_sign < 0.0 || abs(cur_sign) < dh) { /* pass through some objects */ + if (abs(cur_sign) < dh) { /* pass through some objects */ + out.x = d_rgb[bi][0][(int)sy][(int)sx]; + out.y = d_rgb[bi][1][(int)sy][(int)sx]; + out.z = d_rgb[bi][2][(int)sy][(int)sx]; + ret = true; + break; + } + + } + + return ret; + } + + + template + __global__ void hshadow_render_cuda_forward( + const torch::PackedTensorAccessor64 d_rgb, + const torch::PackedTensorAccessor64 d_mask, + const torch::PackedTensorAccessor64 d_bb, + const torch::PackedTensorAccessor64 d_hmap, + const torch::PackedTensorAccessor64 d_rechmap, + const torch::PackedTensorAccessor64 d_lightpos, + torch::PackedTensorAccessor64 d_shadow) { + const int wstride = gridDim.x * blockDim.x, hstride = gridDim.y * blockDim.y, bstride = gridDim.z * blockDim.z; + const int batch_size = d_rgb.size(0), h = d_rgb.size(2), w = d_rgb.size(3); + + for (int bi = blockIdx.z; bi < batch_size; bi += bstride) { + /* light xyh */ + scalar_t lx = d_lightpos[bi][0], ly = d_lightpos[bi][1], lh = d_lightpos[bi][2]; + int minh = max((int)d_bb[bi][0], 0), maxh = min((int)d_bb[bi][1], h-1), minw = max((int)d_bb[bi][2], 0), maxw = min((int)d_bb[bi][3], w-1); + + vec3 light(lx, ly, lh); + for (int wi = blockIdx.x * blockDim.x + threadIdx.x; wi < w; wi += wstride) for(int hi = blockIdx.y * blockDim.y + threadIdx.y; hi < h; hi += hstride) { + scalar_t shadow(1.0), mask_alpha(0.0); + scalar_t recx = wi + 0.5, recy = hi+0.5, rech = d_rechmap[bi][0][hi][wi]; + + vec3 start(recx, recy, rech); + vec3 intersect_color; + + /* Searching Potentials */ + if (ray_trace(start, light, bi, d_mask, d_hmap, d_rechmap, d_rgb, intersect_color)) { + shadow = 0.0; + } + + d_shadow[bi][0][hi][wi] = shadow; + d_shadow[bi][1][hi][wi] = shadow; + d_shadow[bi][2][hi][wi] = shadow; + } + } + } + + + template + __global__ void ray_intersect_cuda_forward( + const torch::PackedTensorAccessor64 d_rgb, + const torch::PackedTensorAccessor64 d_mask, + const torch::PackedTensorAccessor64 d_hmap, + const torch::PackedTensorAccessor64 d_rechmap, + const torch::PackedTensorAccessor64 d_rd_map, + torch::PackedTensorAccessor64 d_intersect) { + + const int wstride = gridDim.x * blockDim.x, hstride = gridDim.y * blockDim.y, bstride = gridDim.z * blockDim.z; + const int batch_size = d_rgb.size(0), h = d_rgb.size(2), w = d_rgb.size(3); + const scalar_t default_value = 0.0; + + for (int bi = blockIdx.z; bi < batch_size; bi += bstride) { + for (int wi = blockIdx.x * blockDim.x + threadIdx.x; wi < w; wi += wstride) for(int hi = blockIdx.y * blockDim.y + threadIdx.y; hi < h; hi += hstride) { + scalar_t shadow(1.0), mask_alpha(0.0); + scalar_t recx = wi + 0.5, recy = hi+0.5, rech = d_rechmap[bi][0][hi][wi]; + + scalar_t lx = d_rd_map[bi][0][hi][wi]; + scalar_t ly = d_rd_map[bi][1][hi][wi]; + scalar_t lh = d_rd_map[bi][2][hi][wi]; + + vec3 start(recx, recy, rech); + vec3 rd(lx, ly, lh); + + vec3 intersect_color; + if (ray_trace(start, rd, bi, d_mask, d_hmap, d_rechmap, d_rgb, intersect_color)) { + d_intersect[bi][0][hi][wi] = intersect_color.x; + d_intersect[bi][1][hi][wi] = intersect_color.y; + d_intersect[bi][2][hi][wi] = intersect_color.z; + d_intersect[bi][3][hi][wi] = 1.0; + } else { + d_intersect[bi][0][hi][wi] = default_value; + d_intersect[bi][1][hi][wi] = default_value; + d_intersect[bi][2][hi][wi] = default_value; + d_intersect[bi][3][hi][wi] = 0.0; + } + } + } + } + + template + __global__ void ray_scene_intersect_cuda_forward( + const torch::PackedTensorAccessor64 d_rgb, + const torch::PackedTensorAccessor64 d_mask, + const torch::PackedTensorAccessor64 d_hmap, + const torch::PackedTensorAccessor64 d_ro, + const torch::PackedTensorAccessor64 d_rd, + const scalar_t dh, + torch::PackedTensorAccessor64 d_intersect) { + + const int wstride = gridDim.x * blockDim.x, hstride = gridDim.y * blockDim.y, bstride = gridDim.z * blockDim.z; + const int batch_size = d_rgb.size(0), h = d_rgb.size(2), w = d_rgb.size(3); + const scalar_t default_value = 0.0; + + for (int bi = blockIdx.z; bi < batch_size; bi += bstride) { + for (int wi = blockIdx.x * blockDim.x + threadIdx.x; wi < w; wi += wstride) { + for(int hi = blockIdx.y * blockDim.y + threadIdx.y; hi < h; hi += hstride) { + // scalar_t rox = wi + 0.5, roy = hi+0.5, roh = d_ro[bi][0][hi][wi]; + scalar_t rox = d_ro[bi][0][hi][wi]; + scalar_t roy = d_ro[bi][1][hi][wi]; + scalar_t roh = d_ro[bi][2][hi][wi]; + + scalar_t rdx = d_rd[bi][0][hi][wi]; + scalar_t rdy = d_rd[bi][1][hi][wi]; + scalar_t rdh = d_rd[bi][2][hi][wi]; + + vec3 ro(rox, roy, roh); + vec3 rd(rdx, rdy, rdh); + + vec3 intersect_color; + if (ray_scene_intersect(ro, rd, dh, bi, d_mask, d_hmap, d_rgb, intersect_color)) { + d_intersect[bi][0][hi][wi] = intersect_color.x; + d_intersect[bi][1][hi][wi] = intersect_color.y; + d_intersect[bi][2][hi][wi] = intersect_color.z; + d_intersect[bi][3][hi][wi] = 1.0; + } else { + d_intersect[bi][0][hi][wi] = default_value; + d_intersect[bi][1][hi][wi] = default_value; + d_intersect[bi][2][hi][wi] = default_value; + d_intersect[bi][3][hi][wi] = 0.0; + } + } + } + } + } + + template + __global__ void reflect_render_cuda_forward( + const torch::PackedTensorAccessor64 d_rgb, + const torch::PackedTensorAccessor64 d_mask, + const torch::PackedTensorAccessor64 d_hmap, + const torch::PackedTensorAccessor64 d_rechmap, + const torch::PackedTensorAccessor64 d_thresholds, + torch::PackedTensorAccessor64 d_reflect, + torch::PackedTensorAccessor64 d_reflect_height, + torch::PackedTensorAccessor64 d_reflect_mask) { + const int wstride = gridDim.x * blockDim.x, hstride = gridDim.y * blockDim.y, bstride = gridDim.z * blockDim.z; + const int batch_size = d_rgb.size(0), h = d_rgb.size(2), w = d_rgb.size(3); + + for (int bi = blockIdx.z; bi < batch_size; bi += bstride) { + for (int wi = blockIdx.x * blockDim.x + threadIdx.x; wi < w; wi += wstride) for(int hi = blockIdx.y * blockDim.y + threadIdx.y; hi < h; hi += hstride) { + /* Back tracing along the height + Find the closest point, filter the closest point + */ + scalar_t min_dis = FLT_MAX; + scalar_t min_r, min_g, min_b, min_height, min_mask; + for(int ti = hi-1; ti >= 0; --ti) { + if (d_mask[bi][0][ti][wi] < 0.45) + continue; + + scalar_t dis = abs(d_hmap[bi][0][ti][wi] * 2 + ti - hi); + if (dis < min_dis) { + min_dis = dis; + min_r = d_rgb[bi][0][ti][wi]; + min_g = d_rgb[bi][1][ti][wi]; + min_b = d_rgb[bi][2][ti][wi]; + + min_height = d_hmap[bi][0][ti][wi]; + min_mask = d_mask[bi][0][ti][wi]; + } + } + + /* Check Condition */ + scalar_t cur_thresholds = d_thresholds[bi][0]; + if (min_dis < cur_thresholds) { + /* Let Use Nearest Neighbor First */ + d_reflect[bi][0][hi][wi] = min_r; + d_reflect[bi][1][hi][wi] = min_g; + d_reflect[bi][2][hi][wi] = min_b; + d_reflect_height[bi][0][hi][wi] = min_height; + d_reflect_mask[bi][0][hi][wi] = 1.0; + } + + // } else { + // scalar_t fadding = 1.0-(min_dis-cur_thresholds); + // if (fadding < 0.0) fadding = 0.0; + // d_reflect[bi][0][hi][wi] = min_r * fadding + (1.0-fadding); + // d_reflect[bi][1][hi][wi] = min_g * fadding + (1.0-fadding); + // d_reflect[bi][2][hi][wi] = min_b * fadding + (1.0-fadding); + // d_reflect_height[bi][0][hi][wi] = 0.0; + // d_reflect_mask[bi][0][hi][wi] = fadding; + // } + } + } + } + + template + __global__ void glossy_reflect_render_cuda_forward( + const torch::PackedTensorAccessor64 d_rgb, + const torch::PackedTensorAccessor64 d_mask, + const torch::PackedTensorAccessor64 d_hmap, + const torch::PackedTensorAccessor64 d_rechmap, + const int sample_n, + const float glossy, + torch::PackedTensorAccessor64 d_reflect) { + + const int wstride = gridDim.x * blockDim.x, hstride = gridDim.y * blockDim.y, bstride = gridDim.z * blockDim.z; + const int batch_size = d_rgb.size(0), h = d_rgb.size(2), w = d_rgb.size(3); + + for (int bi = blockIdx.z; bi < batch_size; bi += bstride) { + for (int wi = blockIdx.x * blockDim.x + threadIdx.x; wi < w; wi += wstride) for(int hi = blockIdx.y * blockDim.y + threadIdx.y; hi < h; hi += hstride) { + /* Back tracing along the height + Find the closest point, filter the closest point + */ + scalar_t min_dis = FLT_MAX; + scalar_t min_r, min_g, min_b, min_height, min_mask; + for(int ti = hi-1; ti >= 0; --ti) { + if (d_mask[bi][0][ti][wi] < 0.45) + continue; + + scalar_t dis = abs(d_hmap[bi][0][ti][wi] * 2 + ti - hi); + if (dis < min_dis) { + min_dis = dis; + min_r = d_rgb[bi][0][ti][wi]; + min_g = d_rgb[bi][1][ti][wi]; + min_b = d_rgb[bi][2][ti][wi]; + + min_height = d_hmap[bi][0][ti][wi]; + min_mask = d_mask[bi][0][ti][wi]; + } + } + + /* Check Condition */ + float cur_thresholds = 1e-1; + if (min_dis < cur_thresholds) { + /* Let Use Nearest Neighbor First */ + d_reflect[bi][0][hi][wi] = min_r; + d_reflect[bi][1][hi][wi] = min_g; + d_reflect[bi][2][hi][wi] = min_b; + } + } + } + } + +} // namespace + +std::vector hshadow_render_cuda_forward( + torch::Tensor rgb, + torch::Tensor mask, + torch::Tensor bb, + torch::Tensor hmap, + torch::Tensor rechmap, + torch::Tensor light_pos) { + const auto batch_size = rgb.size(0); + const auto channel_size = rgb.size(1); + const auto h = rgb.size(2); + const auto w = rgb.size(3); + const dim3 threads(16, 16, 1); + const dim3 blocks((w + threads.x - 1) / threads.x, (h+threads.y-1)/threads.y, batch_size); + torch::Tensor shadow_tensor = torch::ones({batch_size, 3, h, w}).to(rgb); + + AT_DISPATCH_FLOATING_TYPES(rgb.type(), "hshadow_render_cuda_forward", ([&] { + hshadow_render_cuda_forward<<>>( + rgb.packed_accessor64(), + mask.packed_accessor64(), + bb.packed_accessor64(), + hmap.packed_accessor64(), + rechmap.packed_accessor64(), + light_pos.packed_accessor64(), + shadow_tensor.packed_accessor64()); + })); + + return {shadow_tensor}; +} + +std::vector reflect_render_cuda_forward( + torch::Tensor rgb, + torch::Tensor mask, + torch::Tensor hmap, + torch::Tensor rechmap, + torch::Tensor thresholds) { + const auto batch_size = rgb.size(0); + const auto channel_size = rgb.size(1); + const auto h = rgb.size(2); + const auto w = rgb.size(3); + const dim3 threads(16, 16, 1); + const dim3 blocks((w + threads.x - 1) / threads.x, (h+threads.y-1)/threads.y, batch_size); + torch::Tensor reflection_tensor = torch::ones({batch_size, 3, h, w}).to(rgb); + torch::Tensor reflection_mask_tensor = torch::zeros({batch_size, 1, h, w}).to(rgb); + torch::Tensor reflection_height_tensor = torch::zeros({batch_size, 1, h, w}).to(rgb); + + AT_DISPATCH_FLOATING_TYPES(rgb.type(), "reflect_render_cuda_forward", ([&] { + reflect_render_cuda_forward<<>>( + rgb.packed_accessor64(), + mask.packed_accessor64(), + hmap.packed_accessor64(), + rechmap.packed_accessor64(), + thresholds.packed_accessor64(), + reflection_tensor.packed_accessor64(), + reflection_height_tensor.packed_accessor64(), + reflection_mask_tensor.packed_accessor64()); + })); + + return {reflection_tensor, reflection_height_tensor,reflection_mask_tensor}; +} + + +std::vector glossy_reflect_render_cuda_forward(torch::Tensor rgb, + torch::Tensor mask, + torch::Tensor hmap, + torch::Tensor rechmap, + const int sample_n, + const float glossy) { + const auto batch_size = rgb.size(0); + const auto channel_size = rgb.size(1); + const auto h = rgb.size(2); + const auto w = rgb.size(3); + const dim3 threads(16, 16, 1); + const dim3 blocks((w + threads.x - 1) / threads.x, (h+threads.y-1)/threads.y, batch_size); + + torch::Tensor reflection_tensor = torch::ones({batch_size, 3, h, w}).to(rgb); + + AT_DISPATCH_FLOATING_TYPES(rgb.type(), "reflect_render_cuda_forward", ([&] { + glossy_reflect_render_cuda_forward<<>>( + rgb.packed_accessor64(), + mask.packed_accessor64(), + hmap.packed_accessor64(), + rechmap.packed_accessor64(), + sample_n, + glossy, + reflection_tensor.packed_accessor64()); + })); + + return {reflection_tensor}; + +} + + +torch::Tensor ray_intersect_cuda_forward(torch::Tensor rgb, + torch::Tensor mask, + torch::Tensor hmap, + torch::Tensor rechmap, + torch::Tensor rd_map){ + const auto batch_size = rgb.size(0); + const auto channel_size = rgb.size(1); + const auto h = rgb.size(2); + const auto w = rgb.size(3); + const dim3 threads(16, 16, 1); + const dim3 blocks((w + threads.x - 1) / threads.x, (h+threads.y-1)/threads.y, batch_size); + + torch::Tensor intersect_tensor = torch::ones({batch_size, 4, h, w}).to(rgb); + + AT_DISPATCH_FLOATING_TYPES(rgb.type(), "reflect_render_cuda_forward", ([&] { + ray_intersect_cuda_forward<<>>( + rgb.packed_accessor64(), + mask.packed_accessor64(), + hmap.packed_accessor64(), + rechmap.packed_accessor64(), + rd_map.packed_accessor64(), + intersect_tensor.packed_accessor64()); + })); + + return intersect_tensor; + +} + + +torch::Tensor ray_scene_intersect_cuda_forward(torch::Tensor rgb, + torch::Tensor mask, + torch::Tensor hmap, + torch::Tensor ro, + torch::Tensor rd, + float dh){ + const auto batch_size = rgb.size(0); + const auto channel_size = rgb.size(1); + const auto h = rgb.size(2); + const auto w = rgb.size(3); + const dim3 threads(16, 16, 1); + const dim3 blocks((w + threads.x - 1) / threads.x, (h+threads.y-1)/threads.y, batch_size); + + torch::Tensor intersect_tensor = torch::ones({batch_size, 4, h, w}).to(rgb); + + AT_DISPATCH_FLOATING_TYPES(rgb.type(), "reflect_render_cuda_forward", ([&] { + ray_scene_intersect_cuda_forward<<>>( + rgb.packed_accessor64(), + mask.packed_accessor64(), + hmap.packed_accessor64(), + ro.packed_accessor64(), + rd.packed_accessor64(), + dh, + intersect_tensor.packed_accessor64()); + })); + + return intersect_tensor; + +} diff --git a/PixHtLab-Src/Demo/PixhtLab/Torch_Render/plane_visualize.cpp b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/plane_visualize.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5ea15c6bac5dd6641949c322f29bbe31187f982c --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/plane_visualize.cpp @@ -0,0 +1,26 @@ + +#include + +#include +#include + +// CUDA forward declarations +std::vector plane_visualize_cuda(torch::Tensor planes, torch::Tensor camera, int h, int w); + +// C++ interface +// NOTE: AT_ASSERT has become AT_CHECK on master after 0.4. +#define CHECK_CUDA(x) AT_ASSERTM(x.type().is_cuda(), #x " must be a CUDA tensor") +#define CHECK_CONTIGUOUS(x) AT_ASSERTM(x.is_contiguous(), #x " must be contiguous") +#define CHECK_INPUT(x) CHECK_CUDA(x); CHECK_CONTIGUOUS(x) + +std::vector plane_visualize(torch::Tensor planes, torch::Tensor camera, int h, int w) { + CHECK_INPUT(planes); + CHECK_INPUT(camera); + + return plane_visualize_cuda(planes, camera, h, w); +} + + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("forward", &plane_visualize, "Plane Visualization (CUDA)"); +} \ No newline at end of file diff --git a/PixHtLab-Src/Demo/PixhtLab/Torch_Render/plane_visualize_cuda.cu b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/plane_visualize_cuda.cu new file mode 100644 index 0000000000000000000000000000000000000000..b30ec1d758dd16d933f541f5b70fc3b1d31ca4a0 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/plane_visualize_cuda.cu @@ -0,0 +1,237 @@ +#include + +#include +#include + +#include + +namespace { + template + struct vec3 { + scalar_t x, y, z; + + __device__ __host__ + vec3():x(0),y(0),z(0) {} + + __device__ __host__ + vec3(scalar_t a):x(a),y(a),z(a) {} + + __device__ __host__ + vec3(scalar_t xx, scalar_t yy, scalar_t zz):x(xx),y(yy),z(zz) {} + + __device__ __host__ + vec3 operator*(const scalar_t &rhs) const { + vec3 ret(x,y,z); + ret.x = x * rhs; + ret.y = y * rhs; + ret.z = z * rhs; + return ret; + } + + __device__ __host__ + vec3 operator/(const scalar_t &rhs) const { + vec3 ret(x,y,z); + ret.x = x / rhs; + ret.y = y / rhs; + ret.z = z / rhs; + return ret; + } + + __device__ __host__ + vec3 operator+(const vec3 &rhs) const { + vec3 ret(x,y,z); + ret.x = x + rhs.x; + ret.y = y + rhs.y; + ret.z = z + rhs.z; + return ret; + } + + __device__ __host__ + vec3 operator-(const vec3 &rhs) const { + vec3 ret(x,y,z); + ret.x = x - rhs.x; + ret.y = y - rhs.y; + ret.z = z - rhs.z; + return ret; + } + }; + + template + struct Ray { + vec3 ro, rd; + }; + + template + struct Scene { + vec3 pp, pn; + }; + + template + __device__ + float deg2rad(scalar_t d) { + return d/180.0 * 3.1415926f; + } + + template + __device__ + scalar_t dot(vec3 a, vec3 b) { + return a.x * b.x + a.y * b.y + a.z * b.z; + } + + template + __device__ + vec3 cross(vec3 a, vec3 b) { + vec3 ret(0.0f); + ret.x = a.y * b.z - a.z * b.y; + ret.y = a.z * b.x - a.x * b.z; + ret.z = a.x * b.y - a.y * b.x; + return ret; + } + + template + __device__ + scalar_t length(vec3 a) { + return sqrt(dot(a, a)); + } + + template + __device__ + vec3 normalize(vec3 a) { + return a/length(a); + } + + template + __device__ + scalar_t get_focal(int w, scalar_t fov) { + return 0.5 * w / tan(deg2rad(fov * 0.5)); + } + + template + __device__ + vec3 get_rd(vec3 right, vec3 front, vec3 up, int h, int w, scalar_t focal, scalar_t x, scalar_t y) { + /* x, y in [-1, 1] */ + right = normalize(right); + front = normalize(front); + up = normalize(up); + + return front * focal + right * x * (float)w * 0.5f + up * y * (float)h * 0.5f; + } + + template + __device__ + Ray get_ray(int h, int w, float hi, float wi, vec3 right, vec3front, vec3 up, vec3 cam_pos, float fov) { + /* Note, wi/hi is in [-1.0, 1.0] */ + Ray ray; + + float focal = 0.5f * w / tan(deg2rad(fov)); + ray.ro = cam_pos; + ray.rd = front * focal + right * 0.5f * w * wi + up * 0.5f * h * hi; + return ray; + } + + template + __device__ + bool plane_intersect(Ray ray, vec3 p, vec3 n, float &t) { + vec3 ro = ray.ro, rd = ray.rd; + t = dot(p-ro, n)/dot(rd, n); + return t >= 0.0; + } + + template + __device__ + vec3 horizon2front(scalar_t horizon, int h, int w, float fov) { + scalar_t yoffset = h / 2 - horizon; + scalar_t focal = 0.5f * w / tan(deg2rad(fov)); + vec3 front = vec3(0.0f,0.0f,-1.0f) * focal + vec3(0.0f, 1.0f, 0.0f) * yoffset; + return normalize(front); + } + + template + __device__ + vec3 plane_texture(vec3 p) { + float freq = 6.0f; + float u = sin(p.x * freq), v = sin(p.z * freq); + vec3 ret(0.0f); + float line_width = 0.05f; + if ((abs(u) < line_width || abs(v) < line_width)) { + ret = vec3(1.0f); + } + return ret; + } + + template + __device__ + bool ray_scene_trace(Ray ray, Scene scene, vec3 &color) { + color = vec3(0.0f); + float t; + if (plane_intersect(ray, scene.pp, scene.pn, t)) { + vec3 intersect_pos = ray.ro + ray.rd * t; + color = plane_texture(intersect_pos); + return true; + } + return false; + } + + template + __global__ void plane_visualize_foward( + const torch::PackedTensorAccessor64 d_plane, + const torch::PackedTensorAccessor64 d_camera, + torch::PackedTensorAccessor64 d_vis) { + const int wstride = gridDim.x * blockDim.x, hstride = gridDim.y * blockDim.y, bstride = gridDim.z * blockDim.z; + const int batch_size = d_vis.size(0), h = d_vis.size(2), w = d_vis.size(3); + const int samples = 10; + + vec3 cam_pos(0.0f, 1.0f, 1.0f), front(0.0f,0.0f,-1.0f), right(1.0f, 0.0f, 0.0f), up(0.0f, 1.0f, 0.0f); + for (int bi = blockIdx.z; bi < batch_size; bi += bstride) { + // scalar_t px = d_plane[bi][0], py = d_plane[bi][1], pz = d_plane[bi][2]; + vec3 plane_pos(d_plane[bi][0], d_plane[bi][1], d_plane[bi][2]); + vec3 plane_norm(d_plane[bi][3], d_plane[bi][4], d_plane[bi][5]); + Scene scene = {plane_pos, plane_norm}; + + scalar_t fov = d_camera[bi][0], horizon = d_camera[bi][1]; + front = normalize(horizon2front(horizon, h, w, fov)); + up = normalize(cross(right, front)); + for (int wi = blockIdx.x * blockDim.x + threadIdx.x; wi < w; wi += wstride) + for(int hi = blockIdx.y * blockDim.y + threadIdx.y; hi < h; hi += hstride) { + bool intersect = false; + vec3 color(0.0f); + for (int si = 0; si < samples * samples; ++si) { + float hoffset = (float)(si/samples)/max(samples-1, 1); + float woffset = (float)(si%samples)/max(samples-1, 1); + float x = (float)(wi + woffset)/w * 2.0 - 1.0; + float y = (float)(hi + hoffset)/h * 2.0 - 1.0; + Ray ray = get_ray(h, w, y, x, right, front, up, cam_pos,fov); + vec3 tmp_color(0.0f); + if(ray_scene_trace(ray, scene, tmp_color)) { + color = color + tmp_color; + intersect = intersect || true; + } + } + if (intersect) { + color = color / float(samples * samples); + d_vis[bi][0][hi][wi] = color.x; + d_vis[bi][1][hi][wi] = color.y; + d_vis[bi][2][hi][wi] = color.z; + } + } + } + } + +} // namespace + +std::vector plane_visualize_cuda(torch::Tensor planes, torch::Tensor camera, int h, int w){ + const auto batch_size = planes.size(0); + const int threads = 512; + const dim3 blocks((w + threads - 1) / threads, (h+threads-1)/threads, batch_size); + + torch::Tensor vis_tensor = torch::zeros({batch_size, 3, h, w}).to(planes); + AT_DISPATCH_FLOATING_TYPES(planes.type(), "plane_visualize_foward", ([&] { + plane_visualize_foward<<>>( + planes.packed_accessor64(), + camera.packed_accessor64(), + vis_tensor.packed_accessor64() + ); + })); + + return {vis_tensor}; +} diff --git a/PixHtLab-Src/Demo/PixhtLab/Torch_Render/setup.py b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..eca8f1240bbcfa79c8082a8c6e03c033415f383c --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/setup.py @@ -0,0 +1,29 @@ +from setuptools import setup +from torch.utils.cpp_extension import BuildExtension, CUDAExtension + + +setup( + name='hshadow', + ext_modules=[ + CUDAExtension('hshadow', [ + 'hshadow_cuda.cpp', + 'hshadow_cuda_kernel.cu', + ]) + ], + cmdclass={ + 'build_ext': BuildExtension + } +) + +# setup( +# name='plane_visualize', +# ext_modules=[ +# CUDAExtension('plane_visualize', [ +# 'plane_visualize.cpp', +# 'plane_visualize_cuda.cu', +# ]) +# ], +# cmdclass={ +# 'build_ext': BuildExtension +# } +# ) \ No newline at end of file diff --git a/PixHtLab-Src/Demo/PixhtLab/Torch_Render/test_ground.py b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/test_ground.py new file mode 100644 index 0000000000000000000000000000000000000000..cedb3eb19020ecd7c0d460b6b7c9cdad4a40e529 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/test_ground.py @@ -0,0 +1,33 @@ +import time +import torch +import plane_visualize +import matplotlib.pyplot as plt +from PIL import Image +from torchvision import transforms +import os +from os.path import join +import numpy as np + +test_output = 'imgs/output' +os.makedirs(test_output, exist_ok=True) +device = torch.device("cuda:0") + +def test_ground(): + fov, horizon = 120, 400 + camera = torch.tensor([[fov, horizon]]) + planes = torch.tensor([[0.0, 0.0, 0.0, 0.0, 1.0, 0.0]]) + + camera = camera.repeat(5,1).float().to(device) + planes = planes.repeat(5,1).float().to(device) + + ground_vis = plane_visualize.forward(planes, camera, int(512), int(512))[0] + return ground_vis + +t = time.time() +ground_vis = test_ground() +print('{} s'.format(time.time() - t)) +batch = ground_vis.shape[0] +for bi in range(batch): + img = ground_vis[bi].detach().cpu().numpy().transpose(1,2,0) + img = np.clip(img, 0.0, 1.0) + plt.imsave(join(test_output, 'ground_{}.png'.format(bi)),img) \ No newline at end of file diff --git a/PixHtLab-Src/Demo/PixhtLab/Torch_Render/test_hshadow.py b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/test_hshadow.py new file mode 100644 index 0000000000000000000000000000000000000000..f1340d2afab8b16af5c8b24d30c1ffc7e43ceae7 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/Torch_Render/test_hshadow.py @@ -0,0 +1,130 @@ +import time +import torch +import hshadow +import matplotlib.pyplot as plt +from PIL import Image +from torchvision import transforms +import os +from os.path import join +import numpy as np +from scipy.ndimage import uniform_filter + +test_output = 'imgs/output' +os.makedirs(test_output, exist_ok=True) +def test_shadow(rgb, mask, hmap, rechmap, light_pos): + h,w = rgb.shape[:2] + bb = torch.tensor([[0, h-1, 0, w-1]]).float().to(device) + start = time.time() + shadow = hshadow.forward(rgb, mask, bb, hmap, rechmap, light_pos)[0] + end = time.time() + + print('Shadow rendering: {}s'.format(end-start)) + res = (1.0-mask) * rgb * shadow + mask * rgb + return res, shadow + +def frenel_reflect(reflect_tensor, reflect_mask, fov, ref_ind): + # Use schilik approximation https://en.wikipedia.org/wiki/Schlick%27s_approximation + def deg2rad(deg): + return deg/180.0 * 3.1415926 + + def img2cos(reflect_img, fov, horizon): + # Note, this factor needs calibration if we have camera parameters + b, c, h, w = reflect_img.shape + focal = 0.5 * h / np.tan(deg2rad(0.5 * fov)) + fadding_map = torch.arange(0, h).unsqueeze(1).expand(h, w).unsqueeze(0).unsqueeze(0).repeat(b, c, 1, 1) + fadding_map = focal / torch.sqrt((fadding_map-horizon)**2 + focal **2) + return fadding_map.to(reflect_img) + + + ind = (1.0-ref_ind)/(1.0+ref_ind) + ind = ind ** 2 + h = reflect_tensor.shape[2] + horizon = h * 0.7 + cos_map = img2cos(reflect_tensor, fov, horizon) + # fadding = 1.0 - (ind + (1.0-ind) * torch.pow(1.0-cos_map, 4)) + b, c, h, w = reflect_tensor.shape + fadding = torch.linspace(3.0,0.0,h)[None, None, ..., None].repeat(b,c,1,w).to(reflect_tensor) ** 4 + fadding = torch.clip(fadding, 0.0, 1.0) + plt.imsave('test_fadding.png', fadding[0].detach().cpu().numpy().transpose(1,2,0)) + reflect_mask = reflect_mask.repeat(1,3,1,1) + return fadding * reflect_tensor * reflect_mask + (1.0-reflect_mask * fadding) * torch.ones_like(reflect_tensor) + +def refine_boundary(output, filter=3): + return output + h,w,c = output.shape + for i in range(c): + output[...,i] = uniform_filter(output[...,i], size=filter) + return output + +def height_fadding(reflect, reflect_height, reflect_mask, fadding_factor): + def np_sigmoid(a): + return 1.0/(1.0+np.exp(-a)) + + h,w,c = reflect.shape + reflect_h = reflect_height/h + reflect_h = reflect_h/reflect_h.max() + fadding = (1.0-(np_sigmoid(reflect_h * fadding_factor)-0.5)* 2.0) * reflect_mask + after_fadding = fadding * reflect + (1.0-fadding) * np.ones_like(reflect) + return after_fadding + +def to_numpy(tensor): + return tensor[0].detach().cpu().numpy().transpose(1,2,0) + +def test_reflect(rgb, mask, hmap, rechmap, thresholds=1.5, fadding_factor=10.0): + b, c, h, w = rgb.shape + # thresholds = torch.tensor([[1.0 + i/b] for i in range(b)]).float().to(device) + thresholds = torch.tensor([[thresholds]]).float().to(device) + start = time.time() + reflect, reflect_height, reflect_mask = hshadow.reflection(rgb, mask, hmap, rechmap, thresholds) + end = time.time() + print('Reflection rendering: {}s'.format(end-start)) + + reflect, reflect_height, reflect_mask = to_numpy(reflect), to_numpy(reflect_height), to_numpy(reflect_mask) + # reflect = frenel_reflect(reflect, reflect_height, reflect_mask, 175, 0.9) + refine_reflect, refine_reflect_height = refine_boundary(reflect), refine_boundary(reflect_height) + refine_reflect_mask = reflect_mask + reflect = height_fadding(refine_reflect, refine_reflect_height, refine_reflect_mask, fadding_factor) + rgb, mask = to_numpy(rgb), to_numpy(mask) + res = (1.0-mask) * rgb * reflect + mask * rgb + return res, reflect + + +def test_glossy_reflect(rgb, mask, hmap, rechmap, sample, glossy, fadding_factor=10.0): + b, c, h, w = rgb.shape + # thresholds = torch.tensor([[1.0 + i/b] for i in range(b)]).float().to(device) + start = time.time() + reflect = hshadow.glossy_reflection(rgb, mask, hmap, rechmap, sample, glossy)[0] + end = time.time() + print('Reflection rendering: {}s'.format(end-start)) + + reflect = to_numpy(reflect) + refine_reflect = refine_boundary(reflect) + rgb, mask = to_numpy(rgb), to_numpy(mask) + res = (1.0-mask) * rgb * reflect + mask * rgb + return res, reflect + + +device = torch.device("cuda:0") +to_tensor = transforms.ToTensor() +# for i in range(1,5): +i = 2 +if True: + prefix = 'canvas{}'.format(i) + rgb, mask, hmap = to_tensor(Image.open('imgs/{}_rgb.png'.format(prefix)).convert('RGB')).to(device), to_tensor(Image.open('imgs/{}_mask.png'.format(prefix)).convert('RGB'))[0:1].to(device), to_tensor(Image.open('imgs/{}_height.png'.format(prefix)).convert('RGB'))[0:1].to(device) + h, w = hmap.shape[1:] + hmap = hmap * h * 0.45 + + rechmap = torch.zeros_like(hmap) + rgb, mask, hmap, rechmap = rgb.unsqueeze(dim=0), mask.unsqueeze(dim=0), hmap.unsqueeze(dim=0), rechmap.unsqueeze(dim=0) + lightpos = torch.tensor([[300, -100, 200.0]]).to(device) + shadow_res, shadow = test_shadow(rgb, mask, hmap, rechmap, lightpos) + reflect_res, reflect = test_reflect(rgb, mask, hmap, rechmap, thresholds=2.5, fadding_factor=18.0) + + glossy_reflect_res, glossy_reflect = test_glossy_reflect(rgb, mask, hmap, rechmap, sample=10, glossy=0.5, fadding_factor=18.0) + + plt.imsave(join(test_output, prefix + "_shadow_final.png"), shadow_res[0].detach().cpu().numpy().transpose(1,2,0)) + plt.imsave(join(test_output, prefix + "_shadow.png"), shadow[0].detach().cpu().numpy().transpose(1,2,0)) + plt.imsave(join(test_output, prefix + "_reflect_final.png"), reflect_res) + plt.imsave(join(test_output, prefix + "_reflect.png"), reflect) + plt.imsave(join(test_output, prefix + "_glossy_reflect_final.png"), glossy_reflect_res) + plt.imsave(join(test_output, prefix + "_glossy_reflect.png"), glossy_reflect) diff --git a/PixHtLab-Src/Demo/PixhtLab/camera.py b/PixHtLab-Src/Demo/PixhtLab/camera.py new file mode 100644 index 0000000000000000000000000000000000000000..b05d89fd7a189ea80e006ddb9cdcd49969208a72 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/camera.py @@ -0,0 +1,246 @@ +import numpy as np +import math +from abc import ABC +import copy + +class camera(ABC): + def __init__(self, hfov, h, w, height=100.0): + self.fov = hfov + self.h = h + self.w = w + + self.ori_height = height + self.height = copy.deepcopy(self.ori_height) + self.O = np.array([0.0, self.height, 0.0]) # ray origianl + + + ###################################################################################### + """ Abstraction + """ + def align_horizon(self, cur_horizon): + raise NotImplementedError('Not implemented yet') + + def C(self): + raise NotImplementedError('Not implemented yet') + + def right(self): + raise NotImplementedError('Not implemented yet') + + def up(self): + raise NotImplementedError('Not implemented yet') + + ###################################################################################### + + def deg2rad(self, d): + return d / 180.0 * 3.1415925 + + + def rad2deg(self, d): + return d / 3.1415925 * 180.0 + + + def get_ray(self, xy): + """ Assume the center is on the top-left corner + """ + u, v = xy + mat = self.get_ABC_mat() + r = np.dot(mat, np.array([u, v, 1.0]).T) + + # r = r/np.sqrt(r @ r) + return r + + + def project(self, xyz): + relative = xyz - self.O + + mat = self.get_ABC_mat() + pp = np.dot(np.linalg.inv(mat), relative) + pixel = np.array([pp[0]/pp[2], pp[1]/pp[2]]) + + return pixel + + + def xyh2w(self, xyh): + u, v, h = xyh + + foot_xyh = np.copy(xyh) + foot_xyh[1] = foot_xyh[1] + foot_xyh[2] + foot_xyh[2] = 0.0 + fu, fv, fh = foot_xyh + + a = self.right() + b = -self.up() + c = self.C() + mat = self.get_ABC_mat() + + w = -self.height/(a[1] * fu + b[1] * fv + c[1]) + return w + + + def xyh2xyz(self, xyh): + u, v, h = xyh + + foot_xyh = np.copy(xyh) + foot_xyh[1] = foot_xyh[1] + foot_xyh[2] + foot_xyh[2] = 0.0 + fu, fv, fh = foot_xyh + + a = self.right() + b = -self.up() + c = self.C() + mat = self.get_ABC_mat() + + w = -self.height/(a[1] * fu + b[1] * fv + c[1]) + # print('w: {} a*u + b * v + c: {}, b/c: {}/{}, fv: {}'.format(w, a[1] * fu + b[1] * fv + c[1], b, c, fv)) + xyz = self.O + np.dot(mat, np.array([u, v, 1.0]).T) * w + + # print('w: {}, -{}/{}'.format(w, self.height, a[1] * fu + b[1] * fv + c[1])) + + return xyz + + + def xyz2xyh(self, xyz): + foot_xyz = np.copy(xyz) + foot_xyz[1] = 0.0 + + foot_xy = self.project(foot_xyz) + xy = self.project(xyz) + + ret = np.copy(xyz) + ret[:2] = xy + ret[2] = foot_xy[1] - xy[1] + + return ret + + + def get_ABC_mat(self): + a = self.right() + b = -self.up() + c = self.C() + + mat = np.concatenate([a[:, None], b[:,None], c[:, None]], axis=1) + return mat + + +class pitch_camera(camera): + """ Picth alignment camera + """ + def __init__(self, hfov, h, w, height=100.0): + """ + alignment algorithm: + 1. pitch alignment + 2. axis alignment + """ + super().__init__(hfov, h, w, height) + + self.ori_view = np.array([0.0, 0.0, -1.0]) + self.cur_view = np.copy(self.ori_view) + + + def align_horizon(self, cur_horizon): + """ Given horizon, compute the camera pitch + """ + ref_horizon = self.h / 2 + rel_distance = -(ref_horizon - cur_horizon) + + focal = self.focal() + pitch = math.atan2(rel_distance, focal) + + # construct a rotation matrix + c, s = np.cos(pitch), np.sin(pitch) + rot = np.array([[0, 0, 0], [0, c, -s], [0, s, c]]) + + # compute the new view vector + img_plane_view = self.ori_view * focal + img_plane_view = rot @ img_plane_view.T + + self.cur_view = img_plane_view / math.sqrt(np.dot(img_plane_view, img_plane_view)) + + def C(self): + return self.view() * self.focal() - 0.5 * self.w * self.right() + 0.5 * self.h * self.up() + + + def right(self): + return np.array([1.0, 0.0, 0.0]) + + + def up(self): + return np.cross(self.right(), self.view()) + + + def focal(self): + focal = self.w * 0.5 / math.tan(self.deg2rad(self.fov * 0.5)) + return focal + + + def view(self): + return self.cur_view + + + +class axis_camera(camera): + """ Axis alignment camera + """ + def __init__(self, hfov, h, w, height=100.0): + super().__init__(hfov, h, w, height) + + focal = self.w * 0.5 / math.tan(self.deg2rad(self.fov * 0.5)) + self.up_vec = np.array([0.0, 1.0, 0.0]) + self.right_vec = np.array([1.0, 0.0, 0.0]) + + self.ori_c = np.array([-0.5 * self.w, 0.5 * self.h, -focal]) + self.c_vec = np.copy(self.ori_c) + + + def align_horizon(self, cur_horizon): + """ Given horizon, we move the axis to update the horizon + i.e. we need to change C + """ + ref_horizon = self.h // 2 + delta_horizon = cur_horizon - ref_horizon + self.c_vec = self.ori_c + delta_horizon * self.up() + # self.height = self.ori_height + delta_horizon + # self.O = np.array([0.0, self.height, 0.0]) + + + + def C(self): + return self.c_vec + + + def right(self): + return self.right_vec + + + def up(self): + return self.up_vec + + +def test(ppc): + xyh = np.array([500, 500, 100.0]) + + proj_xyz = ppc.xyh2xyz(xyh) + proj_xyh = ppc.xyz2xyh(proj_xyz) + + print('xyh: {}, proj xyz: {}, proj xyh: {}'.format(xyh, proj_xyz, proj_xyh)) + + # import pdb; pdb.set_trace() + new_horizon_list = [0, 100, 250, 400, 500] + new_horizon_list = [100, 250, 400, 500] + + # import pdb; pdb.set_trace() + for cur_horizon in new_horizon_list: + ppc.align_horizon(cur_horizon) + test_xyh = np.array([500, cur_horizon, 0]) + test_xyz = ppc.xyh2xyz(test_xyh) + + # print('{} -> {} -> {}'.format(test_xyh, test_xyz, ppc.xyz2xyh(test_xyz))) + print('{} \t -> {} \t -> {}'.format(test_xyh, test_xyz, ppc.xyz2xyh(test_xyz))) + + +if __name__ == '__main__': + p_camera = pitch_camera(90.0, 500, 500) + a_camera = axis_camera(90.0, 500, 500) + + test(p_camera) + test(a_camera) diff --git a/PixHtLab-Src/Demo/PixhtLab/gssn_demo.py b/PixHtLab-Src/Demo/PixhtLab/gssn_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..6e6961c0c700941ac5f7f3ea4a86e0562ab3eb4b --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/gssn_demo.py @@ -0,0 +1,32 @@ +from pathlib import Path +import torch +import gradio as gr +from torch import nn +import numpy as np + + +def render_btn_fn(mask, background, buffers, pitch, roll, softness): + print('Pitch and roll: {}, {}'.format(pitch, roll)) + print('Mask, background, bufferss: {}, {}, {}'.format(mask.shape, background.shape, buffers.shape)) + pass + + +with gr.Blocks() as demo: + with gr.Row(): + mask_input = gr.Image(shape=(256, 256), image_mode="L", label="Mask") + bg_input = gr.Image(shape=(256, 256), image_mode="RGB", label="Background") + buff_input = gr.Image(shape=(256, 256), image_mode="RGB", label="Buffers") + + with gr.Row(): + with gr.Column(): + pitch_input = gr.Slider(minimum=0, maximum=1, step=0.01, default=0.5, label="Pitch") + roll_input = gr.Slider(minimum=0, maximum=1, step=0.01, default=0.5, label="Roll") + softness_input = gr.Slider(minimum=0, maximum=1, step=0.01, default=0.5, label="Softness") + + render_btn = gr.Button(label="Render") + output = gr.Image(shape=(256, 256), image_mode="RGB", label="Output") + + render_btn.click(render_btn_fn, inputs=[mask_input, bg_input, buff_input, pitch_input, roll_input, softness_input], outputs=output) + + +demo.launch() diff --git a/PixHtLab-Src/Demo/PixhtLab/hshadow_render.py b/PixHtLab-Src/Demo/PixhtLab/hshadow_render.py new file mode 100644 index 0000000000000000000000000000000000000000..09c5c7f0b347e20ce76736448fb961b3b99b14fe --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/hshadow_render.py @@ -0,0 +1,268 @@ +import time +import torch +import hshadow +# import plane_visualize +import numpy as np +from torchvision import transforms +from scipy.ndimage import uniform_filter +from ShadowStyle.inference import inference_shadow +import cv2 +import matplotlib.pyplot as plt +from utils import * +from GSSN.inference_shadow import SSN_Infernece + +device = torch.device("cuda:0") +to_tensor = transforms.ToTensor() +model = inference_shadow.init_models('/home/ysheng/Documents/Research/GSSN/HardShadow/qtGUI/weights/human_baseline_all_21-July-04-52-AM.pt') +# GSSN_model = SSN_Infernece('GSSN/weights/0000000700.pt') +GSSN_model = SSN_Infernece('/home/ysheng/Documents/Research/GSSN/HardShadow/qtGUI/GSSN/weights/only_shadow/0000000200.pt') + +def crop_mask(mask): + hnon, wnon = np.nonzero(mask) + aabb = (hnon.min(), hnon.max(), wnon.min(), wnon.max()) + return aabb + +def norm_output(np_img): + return np.clip(cv2.normalize(np_img, None, 0.0, 1.0, cv2.NORM_MINMAX),0.0,1.0) + +def padding(mask, shadow, mask_aabb, shadow_aabb, final_shape=(512, 512)): + mh, mhh, mw, mww = mask_aabb + sh, shh, sw, sww = shadow_aabb + cropped_mask, cropped_shadow = mask[mh:mhh, mw:mww], shadow[sh:shh, sw:sww] + global_h, global_w = mask.shape[:2] + h, w, c, sc = *cropped_mask.shape, shadow.shape[2] + fract = 0.4 + if h > w: + newh = int(final_shape[0]*fract) + neww = int(newh/h*w) + else: + neww = int(final_shape[1]*fract) + newh = int(neww/w*h) + + small_mask = cv2.resize(cropped_mask, (neww, newh), interpolation=cv2.INTER_AREA) + if len(small_mask.shape) == 2: + small_mask = small_mask[...,np.newaxis] + + mask_ret, shadow_ret = np.zeros((final_shape[0], final_shape[1], c)),np.ones((final_shape[0], final_shape[1], sc)) + paddingh, paddingw = 10, (final_shape[0]-neww)//2 + mask_lpos = (paddingh, paddingw) + mask_ret = overlap_replace(mask_ret, small_mask, mask_lpos) + + # padding shadow + hscale, wscale = newh/h, neww/w + newsh, newsw = int((shh-sh) * hscale), int((sww-sw) * wscale) + small_shadow = cv2.resize(cropped_shadow, (newsw, newsh), interpolation=cv2.INTER_AREA) + + if len(small_shadow.shape) == 2: + small_shadow = small_shadow[...,np.newaxis] + + + loffseth, loffsetw = int((sh-mh)*hscale), int((sw-mw)*wscale) + shadow_lpos = (paddingh + loffseth, paddingw + loffsetw) + shadow_ret = overlap_replace(shadow_ret, small_shadow, shadow_lpos) + + # return mask_ret, shadow_ret[...,0:1], [mask_aabb, mask_lpos, hscale, wscale, final_shape, mask.shape[0], mask.shape[1]] + return mask_ret, shadow_ret, [mask_aabb, mask_lpos, hscale, wscale, final_shape, mask.shape[0], mask.shape[1]] + + +def transform_input(mask, hardshadow): + """ Note, trans_info marks the AABBs, and scaling factors + """ + mask_aabb, shadow_aabb = crop_mask(mask[...,0]), crop_mask(hardshadow[...,0]) + # import pdb; pdb.set_trace() + cmask, cshadow, trans_info = padding(mask, hardshadow, mask_aabb, shadow_aabb) + return cmask.transpose(2,0,1)[np.newaxis,...], 1.0 - cshadow.transpose(2,0,1)[np.newaxis, ...], trans_info + + +def transform_output(softshadow, trans_info): + mask_aabb, mask_lpos, hscale, wscale, final_shape, h, w = trans_info + # import pdb; pdb.set_trace() + ret, gsh, gsw = np.zeros((h,w,1)), int(final_shape[0]/hscale), int(final_shape[1]/wscale) + global_shadow = cv2.resize(softshadow[0,0], (gsw, gsh)) + + # global start = global_mask_aabb - (local_mask_start)/scaling + mh, mw, mask_lh, mask_lw = mask_aabb[0], mask_aabb[2], mask_lpos[0], mask_lpos[1] + starth, startw = int(mh - mask_lh / hscale), int(mw - mask_lw / wscale) + ret = norm_output(overlap_replace(ret, global_shadow[...,np.newaxis], (starth, startw))) + if len(ret.shape) == 2: + ret = ret[..., np.newaxis] + + return 1.0-ret.repeat(3,axis=2) + +def style_hardshadow(mask, hardshadow, softness): + mask_net, hardshadow_net, trans_info = transform_input(mask, hardshadow) + netsoftshadow = inference_shadow.net_render_np(model, mask_net, hardshadow_net, softness, 0.0) + softshadow = transform_output(netsoftshadow, trans_info) + + return softshadow, (norm_output(mask_net[0,0]), norm_output(hardshadow_net[0,0]), norm_output(netsoftshadow[0,0])) + +def gssn_shadow(mask, pixel_height, shadow_channels, softness): + # mask_net, hardshadow_net, trans_info = transform_input(mask, shadow_channels) + + mask_aabb, shadow_aabb = crop_mask(mask[...,0]), crop_mask(shadow_channels[...,0]) + ph_channel, hardshadow_net, trans_info = padding(pixel_height, shadow_channels, mask_aabb, shadow_aabb) + + ph_channel = ph_channel/512.0 + hardshadow_net = 1.0-hardshadow_net + input_np = np.concatenate([ph_channel, hardshadow_net], axis=2) + + # import pdb; pdb.set_trace() + + netsoftshadow = np.clip(GSSN_model.render_ss(input_np, softness), 0.0, 1.0) + netsoftshadow = netsoftshadow.transpose((2,0,1))[None, ...] + softshadow = transform_output(netsoftshadow, trans_info) + + return softshadow + + +def proj_ground(p, light_pos): + tmpp = p.copy() + + t = (0-tmpp[2])/(light_pos[:, 2:3]-tmpp[2]+1e-6) + tmpp = (1.0-t) * tmpp[:2] + t * light_pos[:, :2] + return tmpp + +def proj_bb(mask, hmap, light_pos, mouse_pos): + tmp_lights = light_pos.copy() + if len(light_pos.shape) == 1: + tmp_lights = tmp_lights[..., np.newaxis] + + # bb -> four points + highest = hmap.max() + highest_h, highest_w = list(np.unravel_index(np.argmax(hmap), hmap.shape)) + hbb, wbb = np.nonzero(mask) + h, hh, w, ww = hbb.min(), hbb.max(), wbb.min(), wbb.max() + bb0, bb1, bb2, bb3 = np.array([w, h, hmap.max()]), np.array([ww, h, hmap.max()]), np.array([w, hh, 0]), np.array([ww, hh, 0]) + + # compute projection for the four points + tmp_lights = tmp_lights.transpose(1,0) + bb0, bb1, bb2, bb3 = proj_ground(bb0, tmp_lights), proj_ground(bb1, tmp_lights), proj_ground(bb2, tmp_lights), proj_ground(bb3, tmp_lights) + + batch = len(tmp_lights) + new_bb = np.zeros((batch, 4)) + for i in range(batch): + new_bb[i, 0] = min([bb0[i, 1], bb1[i,1], bb2[i, 1], bb3[i, 1], mouse_pos[1], h]) # h + new_bb[i, 1] = max([bb0[i, 1], bb1[i,1], bb2[i, 1], bb3[i, 1], mouse_pos[1], hh]) + new_bb[i, 2] = min([bb0[i, 0], bb1[i,0], bb2[i, 0], bb3[i, 0], mouse_pos[0], w]) # w + new_bb[i, 3] = max([bb0[i, 0], bb1[i,0], bb2[i, 0], bb3[i, 0], mouse_pos[0], ww]) + + return new_bb + +def to_torch_device(np_img): + if len(np_img.shape) == 3: + return to_tensor(np_img).float().unsqueeze(dim=0).contiguous().to(device) + else: + return torch.from_numpy(np_img).float().contiguous().to(device) + +def hshadow_render(rgb, mask, hmap, rechmap, light_pos, mouse_pos): + """ Heightmap Shadow Rendering + rgb: H x W x e + mask: H x W x 1 + hmap: H x W x 1 + rechmap: H x W x 1 + light_pos: (3,B) + return: + shadow masking + """ + + hbb, wbb = np.nonzero(mask[...,0]) + # speed optimization + bb = proj_bb(mask[...,0], hmap[...,0], light_pos, mouse_pos) + + # import pdb; pdb.set_trace() + if len(light_pos.shape) == 1: + light_pos_d = torch.from_numpy(light_pos).to(device).unsqueeze(dim=0).float() + rgb_d, mask_d, hmap_d, rechmap_d = to_torch_device(rgb), to_torch_device(mask), to_torch_device(hmap), to_torch_device(rechmap) + bb_d = torch.from_numpy(bb).float().to(device) + batch = 1 + else: + light_pos_d = torch.from_numpy(np.ascontiguousarray(light_pos.transpose(1,0))).float().to(device) + batch = len(light_pos_d) + h,w = rgb.shape[:2] + rgb_d = to_torch_device(np.repeat(rgb[np.newaxis,...].transpose(0,3,1,2), batch, axis=0)) + mask_d = to_torch_device(np.repeat(mask[np.newaxis,...].transpose(0,3,1,2), batch, axis=0)) + hmap_d = to_torch_device(np.repeat(hmap[np.newaxis,...].transpose(0,3,1,2), batch, axis=0)) + rechmap_d = to_torch_device(np.repeat(rechmap[np.newaxis,...].transpose(0,3,1,2), batch, axis=0)) + bb_d = torch.from_numpy(np.ascontiguousarray(bb)).float().to(device) + + shadow = hshadow.forward(rgb_d, mask_d, bb_d, hmap_d, rechmap_d, light_pos_d) + # mask_top_pos = list(np.unravel_index(np.argmax(hmap), hmap.shape)) + # x,y = mask_top_pos[1], mask_top_pos[0] + # mh = hmap[y,x,0] + # light_top_d = light_pos_d - torch.tensor([[x,y,mh]]).to(light_pos_d) + # weights = torch.abs(light_top_d[:,2]/torch.sqrt((light_top_d[:,0] **2 + light_top_d[:,1] **2))) + # print('weights: ', weights) + # weights = (weights)/weights.sum() + + # print(weights.shape, shadow[0].shape) + # flipped = (weights[...,None, None,None] * (1.0-shadow[0])).sum(dim=0, keepdim=True) + # shadow = shadow[0].sum(dim=0, keepdim=True)/len(shadow[0]) + # return (1.0-flipped)[0].detach().cpu().numpy().transpose(1,2,0) + + shadow = shadow[0].sum(dim=0, keepdim=True)/len(shadow[0]) + return shadow[0].detach().cpu().numpy().transpose(1,2,0) + +def refine_shadow(shadow, intensity=0.6, filter=5): + shadow[...,0] = uniform_filter(shadow[...,0], size=filter) + shadow[...,1] = uniform_filter(shadow[...,1], size=filter) + shadow[...,2] = uniform_filter(shadow[...,2], size=filter) + return 1.0 - (1.0-shadow) * intensity + +def render_ao(rgb, mask, hmap): + rechmap = np.zeros_like(hmap) + hbb, wbb = np.nonzero(mask[...,0]) + # light_pos = np.array([hbb.min(), (wbb.min() + wbb.max()) * 0.8, -100000]) + light_pos = np.array([-1300.10811363, -46999.86253089, 46486.73121776]) + mouse_pos = light_pos + + shadow = hshadow_render(rgb, mask, hmap, rechmap, light_pos, mouse_pos) + softshadow = style_hardshadow(mask, shadow[..., :1], 0.45)[0] + softshadow = refine_shadow(softshadow) + return softshadow + +def ao_composite(rgb, mask, hmap, rechmap, light_pos, mouse_pos): + # shadow = hshadow_render(rgb, mask, hmap, rechmap, light_pos, mouse_pos) + # softshadow = style_hardshadow(mask, shadow, 0.45)[0] + # softshadow = refine_shadow(softshadow) + + softshadow = render_ao(rgb, mask, hmap) + mask_ = np.repeat(mask, 3, axis=2) + return (1.0-mask_) * softshadow * rgb + mask_ * rgb, softshadow.copy() + + +def render_shadow(rgb, mask, hmap, rechmap, light_pos, mouse_pos, softness, shadow_intensity=0.6): + shadow = hshadow_render(rgb, mask, hmap, rechmap, light_pos, mouse_pos) + + if softness is not None: + shadow, dbgs = style_hardshadow(mask, shadow[..., :1], softness) + else: + dbgs = None + + shadow = refine_shadow(shadow, intensity=shadow_intensity) + return shadow, dbgs + + +def hshadow_composite(rgb, mask, hmap, rechmap, light_pos, mouse_pos, softness, shadow_intensity=0.6): + """ Shadow Rendering and Composition + rgb: H x W x 3 + mask: H x W x 1 + hmap: H x W x 1 + rechmap: H x W x 1 + light_pos: [x,y,h] + return: + Compositied image + """ + shadow, dbgs = render_shadow(rgb, mask, hmap, rechmap, light_pos, mouse_pos, softness, shadow_intensity) + mask_ = np.repeat(mask, 3, axis=2) + return (1.0-mask_) * shadow * rgb + mask_ * rgb, shadow.copy(), dbgs + +# def vis_horizon(fov, horizon, h, w): +# # fov, horizon = 120, 400 +# camera = torch.tensor([[fov, horizon]]) +# planes = torch.tensor([[0.0, 0.0, 0.0, 0.0, 1.0, 0.0]]) + +# camera = camera.float().to(device) +# planes = planes.float().to(device) + +# ground_vis = plane_visualize.forward(planes, camera, h, w)[0] +# return 1.0-ground_vis[0].detach().cpu().numpy().transpose(1,2,0) diff --git a/PixHtLab-Src/Demo/PixhtLab/reflect_render.py b/PixHtLab-Src/Demo/PixhtLab/reflect_render.py new file mode 100644 index 0000000000000000000000000000000000000000..e1587128b986143a95ca5d60998567997e8f0a0e --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/reflect_render.py @@ -0,0 +1,437 @@ +import cv2 +import os + +import sys +import inspect + +import h5py +import matplotlib.pyplot as plt +import numpy as np +from camera import pitch_camera, axis_camera +from tqdm import tqdm + +import torch +from torchvision import utils +import matplotlib.pyplot as plt +import scipy as sp +import numpy as np +from meshplot import plot, subplot, interact +import time +import hshadow + +def to_numpy(tensor): + return tensor[0].detach().cpu().numpy().transpose(1,2,0) +def test_intersect(rgb, mask, hmap, rechmap, light): + b, c, h, w = rgb.shape + + start = time.time() + intersection = hshadow.ray_intersect(rgb, mask, hmap, rechmap, light) + end = time.time() + # print('Reflection rendering: {}s'.format(end-start)) + return intersection + intersection = to_numpy(intersection) + return intersection + + + +def compute_normal(xyz): + zx = cv2.Sobel(xyz, cv2.CV_64F, 1, 0, ksize=3) + zy = cv2.Sobel(xyz, cv2.CV_64F, 0, 1, ksize=3) + norm = np.cross(zy, zx) + return norm + + +def deg2rad(deg): + return deg/180.0 * 3.14159265 + + +def direction(theta, phi): + t, p = deg2rad(theta), deg2rad(phi) + return np.array([np.sin(p)* np.cos(t), np.cos(p), np.sin(p) * np.sin(t)]) + + +def shading(normal, light_dir): + relighted = np.clip(np.dot(normal, light_dir), 0.0, 1.0) + return relighted + + +def get_camera_mat(cur_camera): + """ return 3 x 3 camera matrix + """ + cam_mat = cur_camera.get_ABC_mat() + return cam_mat + + +def get_ray_mat(cur_camera): + """ return H x W x 3 vector field + """ + h, w = cur_camera.h, cur_camera.w + u = np.arange(0, w, 1) + v = np.arange(0, h, 1) + uu, vv = np.meshgrid(u, v) + uniform_coord = np.concatenate([uu[..., None], vv[..., None], np.ones_like(uu)[..., None]], axis=2) + + cam_mat = get_camera_mat(cur_camera) + ray_mat = np.einsum('ct,hwt->hwc', cam_mat, uniform_coord) + + return ray_mat + + +def project(xyz, cur_camera): + """ xyz: B x 3 + return: B x 2 + """ + O = cur_camera.O + relative = xyz - O + + cam_mat = get_camera_mat(cur_camera) # 3 x 3 + inv_cam_mat = np.linalg.inv(cam_mat) # 3 x 3 + + # M x UV * w = P - O + B = len(xyz) + pp = np.einsum('ct,Bt->Bc', inv_cam_mat, relative) # B x 3 + pixel = pp/pp[..., -1:] # B x 3 + + return pixel[..., :2] + + +def xyz2xyh(xyz, cur_camera): + """ B x 3 -> B x 3 + """ + ori_shape = xyz.shape + + xyz = xyz.reshape(-1, 3) + foot_xyz = np.copy(xyz) + + foot_xyz[..., 1] = 0.0 # 0.0 is ground + foot_xy = project(foot_xyz, cur_camera) # B x 3 + xy = project(xyz, cur_camera) # B x 3 + + ret = np.copy(xyz) # B x 3 + ret[..., :2] = xy + ret[..., 2] = foot_xy[..., 1] - xy[..., 1] # B x 3 + + ret = ret.reshape(*ori_shape) + xyz = xyz.reshape(*ori_shape) + return ret + + +def xyh2xyz(xyh, cur_camera): + """ xyh: H x W x 1, pixel height channel + """ + h, w = xyh.shape[:2] + + u = np.arange(0, w, 1) + v = np.arange(0, h, 1) + uu, vv = np.meshgrid(u, v) # H x W + + h = xyh + coord = np.concatenate([uu[..., None], vv[..., None], h], axis=-1) + + coord[..., 1] = coord[..., 1] + coord[..., 2] # foot Y coord + coord[..., 2] = 0.0 # height 0 + + fu, fv, fh = coord[..., 0], coord[..., 1], coord[..., 2] # H x W + + a = cur_camera.right() # 3 + b = -cur_camera.up() # 3 + c = cur_camera.C() # 3 + + ww = -cur_camera.height/(a[1] * fu + b[1] * fv + c[1]) # H x W + + ww[np.isinf(ww)] = 0.0 + ww[np.isnan(ww)] = 0.0 + + cam_origin = cur_camera.O + cam_mat = get_camera_mat(cur_camera) # 3 x 3 + + uniform_coord = np.concatenate([uu[..., None], vv[..., None], np.ones_like(uu)[..., None]], axis=-1) # H x W x 3 + xyz = cam_origin + np.einsum('ct,hwt->hwc', cam_mat, uniform_coord) * ww[..., None] # H x W x 3 + + return xyz + + +def normalize_vec3(vec3): + """ vec3: ... x 3 + """ + return vec3/np.linalg.norm(vec3, axis=-1, keepdims=True) + + +def to_tensor(np_img): + device = torch.device("cuda:0") + return torch.tensor(np_img.transpose((2,0,1)))[None, ...].to(device).float() + + +def sphere_cartesian(theta, phi): + # t, p = deg2rad(theta), deg2rad(phi) + t, p = theta, phi + coord = np.array([np.sin(p)* np.cos(t), np.cos(p), np.sin(p) * np.sin(t)]) + return coord.T + + +def uniform_over_sphere(b, n): + theta = 2 * np.pi * np.random.uniform(0.0, 1.0, (b, n)) + phi = np.arccos(2*np.random.uniform(0.0, 1.0, (b, n))-1.0) + + coord = sphere_cartesian(theta, phi) + return coord.transpose((1,0,2)) + + +def solid_angle_sampling(cur_dir, ang, n): + h,w = cur_dir.shape[:2] + + sphere_samples = uniform_over_sphere(h * w, n) + + rad = deg2rad(ang) + dis = 1.0/np.tan(rad) + + sphere_samples = sphere_samples.reshape(n, h, w, 3) + + samples = sphere_samples + (cur_dir/np.linalg.norm(cur_dir, axis=2, keepdims=True) * dis) + samples = samples/np.linalg.norm(samples, axis=-1, keepdims=True) + return samples + + +def glossy_samples(reflected_dirs, glossy_ness, sample_n): + """ Inputs: + reflected_dirs: H x W x 3 + glossy_ness: [0, 1] + sample_n: [1, N] + Outputs: + [sample_n, H, W, 3] + """ + solid_ang = glossy_ness * 90.0 + samples = solid_angle_sampling(reflected_dirs, solid_ang, sample_n) + + return samples + + +def Fresnel(wi, ref_idx): + cosine = np.cos(wi) + r0 = (1.0 - ref_idx)/(1.0 + ref_idx) + r0 = r0 ** 2 + return r0 + (1.0-r0) * np.power((1.0-cosine), 5) + + +def BRDF(wi, wo, n, brdf_type, params=None): + if brdf_type == 'oren_nayar': + sigma = params['sigma'] + fr = oren_nayar_reflect(sigma, wi, wo) + elif brdf_type == 'diffuse': + fr = np.ones_like(wo) * 1.0 # 50 x H x W + fr = fr[:, None, ...] + elif brdf_type == 'empirical': + pass + else: + raise NotImplementedError('{} not implemented yet'.format(brdf_type)) + + + ref_idx = params['ref_idx'] + # fresnel = (1.0-Fresnel(wi, ref_idx)) + fresnel = Fresnel(wi, ref_idx) + return fr, fresnel + + +def ray_intersect(rgb, mask, hmap, ro, rd, dh): + b, c, h, w = rgb.shape + + start = time.time() + intersection = hshadow.ray_scene_intersect(rgb, mask, hmap, ro, rd, dh) + end = time.time() + # print('Ray-Scene intersect: {}s'.format(end-start)) + return intersection + + + +def render_reflection(fg_rgba, fg_height, bg_rgba, bg_height, params): + """ Note, samples_n in params should be n * 50 + """ + horizon = params['horizon'] + ref_idx = params['ref_idx'] + samples_n = params['sample_n'] + glossness = params['glossness'] + dh = params['dh'] + batch_size = params['batch_size'] + camera_h = params['camera_h'] + + n = batch_size + batch_size = max(samples_n // batch_size, 1) + + device = torch.device("cuda:0") + + fg_rgb, fg_mask = fg_rgba[..., :3], fg_rgba[..., -1:] + bg_rgb, bg_mask = bg_rgba[..., :3], bg_rgba[..., -1:] + + h, w = fg_rgba.shape[:2] + cur_camera = axis_camera(80.0, h, w, camera_h) + cur_camera.align_horizon(horizon) + + xyz = xyh2xyz(bg_height, cur_camera) + normal = normalize_vec3(compute_normal(xyz)) * bg_mask + normal[np.isnan(normal)] = 0.0 + + ray_mat = get_ray_mat(cur_camera) # H x W x 3 + ray_mat_normal = normalize_vec3(ray_mat) + rr = ray_mat_normal - 2.0 * (ray_mat_normal * normal).sum(axis=2, keepdims=True) * normal + wi = np.arccos(-(ray_mat_normal * np.array([0.0, 1.0, 0.0])[None, None, ...]).sum(axis=-1)) # for BRDF, 1 x H x W + + h,w = ray_mat_normal.shape[:2] + result = np.zeros((h, w, 3)) + alpha = np.zeros((h, w, 1)) + + cur_rgb = torch.tensor(fg_rgb.transpose((2,0,1)))[None, ...].repeat(n, 1, 1, 1).float().to(device) + cur_mask = torch.tensor(fg_mask.transpose((2,0,1)))[None, ...].repeat(n, 1, 1, 1).float().to(device) + cur_hmap = torch.tensor(fg_height.transpose((2,0,1)))[None, ...].repeat(n, 1, 1, 1).float().to(device) + cur_rechmap = torch.tensor(bg_height.transpose((2,0,1)))[None, ...].repeat(n, 1, 1, 1).float().to(device) + + cur_rgb_np = np.repeat(bg_rgba[..., :3].transpose((2,0,1))[None, ...], n, axis=0) + + ro_np = xyz2xyh(xyz, cur_camera) + ro = torch.tensor(ro_np.transpose((2,0,1)))[None, ...].repeat(n, 1, 1, 1).float().to(device) + + for i in tqdm(range(batch_size), desc='Render'): + rr_samples = glossy_samples(rr, glossness, n) # 5 x H x W x 3 + wo = np.arccos((rr_samples * np.array([[0.0, 1.0, 0.0]])).sum(axis=-1)) # n x H x W + + fr, frenel = BRDF(wi, wo, normal, brdf_type='diffuse', params={'ref_idx': ref_idx}) # n x H x W + + # # compute reflected xyh + scale = 1.0 + reflected_xyz = xyz[None, ...] + rr_samples * scale + reflected_xyh = xyz2xyh(reflected_xyz, cur_camera) + + rd = reflected_xyh - ro_np + rd = torch.tensor(rd.transpose((0, 3, 1, 2))).float().contiguous().to(device) + + intersect = ray_intersect(cur_rgb, cur_mask, cur_hmap, ro, rd, dh).detach().cpu().numpy() + rgb_channel = intersect[:, :3] # n x 3 x H x W + rgb_channel = rgb_channel * fr + alpha_channel = intersect[:, -1:] + + missing_pos = alpha_channel[0, 0] == 0 + rgb_channel[:, :, missing_pos] = cur_rgb_np[:, :, missing_pos] + alpha_channel = intersect[:, -1:] * fr * frenel + + result += rgb_channel.sum(axis=0).transpose((1,2,0)) + alpha += alpha_channel.sum(axis=0).transpose((1,2,0)) + + torch.cuda.empty_cache() + + rgb_channel = result / (n * batch_size) + alpha_channel = alpha/(n * batch_size) + return rgb_channel, alpha_channel + + + +def reflection_layer(fg_rgba, fg_height, bg_rgba, bg_height, bg_reflection_layer, params): + """ Example: + params = { + 'sample_n': 1, + 'horizon': h//2, + 'ref_idx': 0.8, + 'glossness': 0.01, + 'dh': 5.0, + 'batch_size': 1 + } + + bg_reflection_layer = np.copy(bg_height) + bg_reflection_layer[bg_reflection_layer>0.0] = 1.0 + bg_reflection_layer = 1.0 - bg_reflection_layer + + # fg_rgba, fg_height = glass_rgba, glass_height + fg_rgba, fg_height = flower_rgba, flower_height + reflection_rgb = reflection_layer(fg_rgba, fg_height, bg_rgba, bg_height, bg_reflection_layer, params) + show(reflection_rgb) + """ + reflect_alpha = params['reflect_alpha'] + + bg_rgba, bg_height = bg_rgba, bg_height + h, w = bg_rgba.shape[:2] + reflection_rgb, reflection_alpha = render_reflection(fg_rgba, fg_height, bg_rgba, bg_height, params) + reflection_alpha = reflect_alpha * reflection_alpha * bg_reflection_layer + reflection_rgb = reflection_rgb * reflection_alpha + bg_rgba[..., :3] * (1.0-reflection_alpha) + + return reflection_rgb + + + +def render_refraction(fg_rgba, fg_height, bg_rgba, bg_height, params): + etai_over_etat = params['etai_over_etat'] + horizon = params['horizon'] + dh = params['dh'] + + h, w = fg_rgba.shape[:2] + cur_camera = axis_camera(80.0, h, w) + cur_camera.align_horizon(horizon) + + fg_mask = fg_rgba[..., -1:] + fg_mask[fg_mask<0.999] = 0.0 + fg_mask[fg_mask>0.999] = 1.0 + + # ray intersection + xyz = xyh2xyz(fg_height, cur_camera) + normal = compute_normal(xyz) + normal = normalize_vec3(normal) + + # ray refraction + rays = get_ray_mat(cur_camera) + rays = normalize_vec3(rays) + + """ + auto cos_theta = fmin(dot(-uv, n), 1.0); + vec3 r_out_perp = etai_over_etat * (uv + cos_theta*n); + vec3 r_out_parallel = -sqrt(fabs(1.0 - r_out_perp.length_squared())) * n; + return r_out_perp + r_out_parallel; + """ + cos_theta = (-rays * normal).sum(axis=-1, keepdims=True) + cos_theta[cos_theta>=1.0] = 1.0 + + ray_out_perp = etai_over_etat * (rays + cos_theta * normal) + ray_out_parallel = -np.sqrt(np.abs(1.0-(ray_out_perp*ray_out_perp).sum(axis=-1, keepdims=True))) * normal + ray_out = ray_out_perp + ray_out_parallel + ray_out[np.isnan(ray_out)] = 0.0 + ray_out = normalize_vec3(ray_out) + ray_out = ray_out * fg_mask + + # everything needs to be transformed into xyh domain + ray_out_xyz = xyz + ray_out + ray_out_xyh = xyz2xyh(ray_out_xyz, cur_camera) + xyh = xyz2xyh(xyz, cur_camera) + ray_out_xyh = ray_out_xyh - xyh + ray_out_xyh[np.isnan(ray_out_xyh)] = 0.0 + + device = torch.device('cuda:0') + cur_rgb = torch.tensor(bg_rgba[..., :3].transpose((2,0,1)))[None, ...].float().contiguous().to(device) + cur_mask = torch.tensor(bg_rgba[..., -1:].transpose((2,0,1)))[None, ...].float().contiguous().to(device) + cur_hmap = torch.tensor(bg_height.transpose((2,0,1)))[None, ...].float().contiguous().to(device) + + ro = torch.tensor(xyh.transpose((2, 0, 1))).float()[None, ...].contiguous().to(device) + rd = torch.tensor(ray_out_xyh.transpose((2, 0, 1))).float()[None, ...].contiguous().to(device) + + intersect = ray_intersect(cur_rgb, cur_mask, cur_hmap, ro, rd, dh) + refracted = intersect[0, :3].detach().cpu().numpy().transpose((1,2,0)) + return refracted + + +def refraction_composite(fg_rgba, fg_height, bg_rgba, bg_height, refract_layer, params): + """ Example: + params = { + 'etai_over_etat': 1.0/1.5, + 'horizon': 395.0, + 'dh': 30.0 + } + refract_layer = fg_rgba[..., -1:] + final_comp = refraction_composite(fg_rgba, fg_height, bg_rgba, bg_height, refract_layer, params) + + show(final_comp) + """ + fg_mask = fg_rgba[..., -1:] + fg_rgb = fg_rgba[..., :3] + bg_rgb = bg_rgba[..., :3] + bg_mask = bg_rgba[..., -1:] + + refracted = render_refraction(fg_rgba, fg_height, bg_rgba, bg_height, params) + fg_mask = fg_mask * refract_layer + final_comp = fg_mask * refracted + (1.0-fg_mask) * bg_rgb + + return final_comp diff --git a/PixHtLab-Src/Demo/PixhtLab/utils.py b/PixHtLab-Src/Demo/PixhtLab/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..bea2c1ef393db011dc3a5c562c2e8e9ac695b991 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/utils.py @@ -0,0 +1,178 @@ +import os +import sys +from os.path import join + +from PyQt5 import QtWidgets, QtCore +from PyQt5.QtCore import Qt, pyqtSlot +from PyQt5.QtWidgets import QApplication, QMainWindow,QWidget, QAction, QFileDialog,QLabel, QPushButton, QSlider, QGridLayout, QGroupBox, QListWidget +from PyQt5.QtGui import QIcon, QPixmap, QImage + +import cv2 +import numpy as np +from PIL import Image, ImageDraw +import matplotlib.pyplot as plt +import time + +def lerp(a, b, t): + return (1.0-t) * a + t * b + +def resize(img, max_size): + old_shape = len(img.shape) + h,w = img.shape[:2] + if h > w: + newh, neww = max_size, int(max_size * w/h) + else: + newh, neww = int(max_size * h / w), max_size + ret = cv2.resize(img, (neww, newh), interpolation=cv2.INTER_AREA) + if old_shape != len(ret.shape): + return ret[..., np.newaxis] + return ret + +def set_qt_img(img, label): + pixmap = QPixmap(img) + label.setPixmap(pixmap) + label.adjustSize() + +def to_qt_img(np_img): + if np_img.dtype != np.uint8: + np_img = np.clip(np_img, 0.0, 1.0) + np_img = np_img * 255.0 + np_img = np_img.astype(np.uint8) + + if len(np_img.shape) == 2: + np_img = np_img[..., np.newaxis].repeat(3, axis=2) + + h, w, c = np_img.shape + # bytesPerLine = 3 * w + return QImage(np_img.data, w, h, 3 * w, QImage.Format_RGB888) + +def update_img_widget(widget, img): + set_qt_img(to_qt_img(img), widget) + +def overlap_replace(a, b, start_pos): + """ overlapping a and b + """ + ha, wa = a.shape[:2] + hb, wb = b.shape[:2] + a_ = a.copy() + + sh, shh, sw, sww = start_pos[0], start_pos[0] + hb, start_pos[1], start_pos[1] + wb + clipped_h, clipped_hh, clipped_w, clipped_ww = np.clip(sh,0,ha), np.clip(shh, 0, ha), np.clip(sw, 0, wa), np.clip(sww, 0, wa) + h,w = clipped_hh - clipped_h, clipped_ww - clipped_w + a_[clipped_h:clipped_hh, clipped_w:clipped_ww] = b[clipped_h-sh:clipped_h-sh+h, clipped_w-sw:clipped_w-sw+w] + return a_ + +def composite(a, b, bmask): + return (1.0-bmask) * a + bmask * b + +def overlap_comp(a, b, bmask, start_pos): + """ overlap and composite a and b with bmask + """ + acopy = a.copy() + ha, wa = a.shape[:2] + hb, wb = b.shape[:2] + + sh, shh, sw, sww = start_pos[0], start_pos[0] + hb, start_pos[1], start_pos[1] + wb + clipped_h, clipped_hh, clipped_w, clipped_ww = np.clip(sh,0,ha), np.clip(shh, 0, ha), np.clip(sw, 0, wa), np.clip(sww, 0, wa) + h,w = clipped_hh - clipped_h, clipped_ww - clipped_w + acopy[clipped_h:clipped_hh, clipped_w:clipped_ww] = composite(a[clipped_h:clipped_hh, clipped_w:clipped_ww], b[clipped_h-sh:clipped_h-sh+h, clipped_w-sw:clipped_w-sw+w], bmask[clipped_h-sh:clipped_h-sh+h, clipped_w-sw:clipped_w-sw+w]) + return acopy + +def line_height(a, b, x): + # line equation: + # f = a + (b-a) * t + # t = (f-a)/(b-a) + ax, ay, bx, by = a[0], a[1], b[0], b[1] + t = (x-ax)/(bx-ax) + y = ay + (by-ay) * t + return y + +def line_height_map(p0, p1, w, h): +# start, end = np.array([384, 491]), np.array([2176, 938]) + start, end = p0, p1 + img = np.zeros((h,w,3)) + line_vec = end - start + x,y = np.arange(0, w), np.arange(0,h) + xx, yy = np.meshgrid(x, y) + height = line_height(start, end, xx) + yy = height - yy + yy = yy / h + yy = np.clip(yy, 0.0, 1.0) + return yy + +def heightmap_resize(hmap, ori_mask, newsize): + """ Dilate original heightmap + """ + oh, ow = hmap.shape[:2] + black_size = max(ow, oh) + + # Filling the hmap by dilation + kernel = np.ones((black_size,black_size), np.uint8) + uintmask = (ori_mask*255.0).astype(np.uint8) + dilated_mask = cv2.dilate(uintmask, kernel, 1) + if len(dilated_mask.shape) != len(uintmask.shape): + dilated_mask = dilated_mask[..., np.newaxis] + inpainting_mask = dilated_mask - uintmask + + inpainted_hmap = cv2.inpaint((hmap * 255.0).astype(np.uint8), inpainting_mask[...,0], 3, cv2.INPAINT_TELEA) + resized_hmap = resize(inpainted_hmap, newsize)/255.0 + if len(resized_hmap.shape) == 2: + resized_hmap = resized_hmap[..., np.newaxis] + return resized_hmap + +def heightmap_resizehw(hmap, ori_mask, neww, newh): + """ Dilate original heightmap + """ + oh, ow = hmap.shape[:2] + black_size = max(ow, oh) + + # Filling the hmap by dilation + kernel = np.ones((black_size,black_size), np.uint8) + uintmask = (ori_mask*255.0).astype(np.uint8) + dilated_mask = cv2.dilate(uintmask, kernel, 1) + if len(dilated_mask.shape) != len(uintmask.shape): + dilated_mask = dilated_mask[..., np.newaxis] + inpainting_mask = dilated_mask - uintmask + inpainted_hmap = cv2.inpaint((hmap * 255.0).astype(np.uint8), inpainting_mask[...,0], 3, cv2.INPAINT_TELEA) + + resized_hmap = cv2.resize(inpainted_hmap, (neww, newh))/255.0 + if len(resized_hmap.shape) == 2: + resized_hmap = resized_hmap[..., np.newaxis] + return resized_hmap + + +def read_img(fname, fmt='RGB'): + return np.array(Image.open(fname).convert(fmt))/255.0 + +def save_img(fname, img): + plt.imsave(fname, np.clip(img, 0.0, 1.0)) + print('{} file saved'.format(fname)) + +def draw_line(img, p0, p1, color='red'): + pil_img = Image.fromarray((img*255.0).astype(np.uint8)) + img_draw = ImageDraw.Draw(pil_img) + img_draw.line((p0, p1), fill=color, width=2) + return np.array(pil_img)/255.0 + +def draw_point(img, p, size=5, color='red'): + pil_img = Image.fromarray((img*255.0).astype(np.uint8)) + img_draw = ImageDraw.Draw(pil_img) + img_draw.ellipse((p[0], p[1], p[0] + size, p[1] + size), fill=color) + return np.array(pil_img)/255.0 + + +def compute_wall_hmap(wall_line, rechmap): + h,w = rechmap.shape[:2] + newrechmap = line_height_map(wall_line[0], wall_line[1], w, h) + newrechmap = np.repeat(newrechmap[..., np.newaxis], 3, axis=2) + return newrechmap * h + +def visualize_hmap(rechmap): + h,w = rechmap.shape[:2] + rgb1, rgb2 = np.array([[2, 245, 229]])/255.0, np.array([[70, 212, 202]])/255.0 + + rechmap = rechmap/h + wall_mask = rechmap.copy() + wall_mask[wall_mask>0] = 1.0 + vis_layer = (1.0-wall_mask) * rgb1 + wall_mask * rgb2 + return vis_layer diff --git a/PixHtLab-Src/Demo/PixhtLab/xyh_proj.py b/PixHtLab-Src/Demo/PixhtLab/xyh_proj.py new file mode 100644 index 0000000000000000000000000000000000000000..3352295fa5ba4b514055c505d90874316e2a0022 --- /dev/null +++ b/PixHtLab-Src/Demo/PixhtLab/xyh_proj.py @@ -0,0 +1,166 @@ +import cv2 +import os + +import sys +import inspect + +import h5py +import matplotlib.pyplot as plt +import numpy as np +from camera import pitch_camera, axis_camera +from tqdm import tqdm + +from torchvision import utils +import matplotlib.pyplot as plt +import scipy as sp +import numpy as np +from meshplot import plot, subplot, interact +import time +import hshadow + +def to_numpy(tensor): + return tensor[0].detach().cpu().numpy().transpose(1,2,0) + + +def test_intersect(rgb, mask, hmap, rechmap, light): + b, c, h, w = rgb.shape + + start = time.time() + intersection = hshadow.ray_intersect(rgb, mask, hmap, rechmap, light) + end = time.time() + # print('Reflection rendering: {}s'.format(end-start)) + return intersection + intersection = to_numpy(intersection) + return intersection + + + +def compute_normal(xyz): + zx = cv2.Sobel(xyz, cv2.CV_64F, 1, 0, ksize=3) + zy = cv2.Sobel(xyz, cv2.CV_64F, 0, 1, ksize=3) + norm = np.cross(zy, zx) + return norm + + +def deg2rad(deg): + return deg/180.0 * 3.14159265 + + +def direction(theta, phi): + t, p = deg2rad(theta), deg2rad(phi) + return np.array([np.sin(p)* np.cos(t), np.cos(p), np.sin(p) * np.sin(t)]) + + +def shading(normal, light_dir): + relighted = np.clip(np.dot(normal, light_dir), 0.0, 1.0) + return relighted + + +def get_camera_mat(cur_camera): + """ return 3 x 3 camera matrix + """ + cam_mat = cur_camera.get_ABC_mat() + return cam_mat + + +def get_ray_mat(cur_camera): + """ return H x W x 3 vector field + """ + h, w = cur_camera.h, cur_camera.w + u = np.arange(0, w, 1) + v = np.arange(0, h, 1) + uu, vv = np.meshgrid(u, v) + uniform_coord = np.concatenate([uu[..., None], vv[..., None], np.ones_like(uu)[..., None]], axis=2) + + cam_mat = get_camera_mat(cur_camera) + ray_mat = np.einsum('ct,hwt->hwc', cam_mat, uniform_coord) + + return ray_mat + + +def project(xyz, cur_camera): + """ xyz: B x 3 + return: B x 2 + """ + O = cur_camera.O + relative = xyz - O + + cam_mat = get_camera_mat(cur_camera) # 3 x 3 + inv_cam_mat = np.linalg.inv(cam_mat) # 3 x 3 + + # M x UV * w = P - O + B = len(xyz) + pp = np.einsum('ct,Bt->Bc', inv_cam_mat, relative) # B x 3 + pixel = pp/pp[..., -1:] # B x 3 + + return pixel[..., :2] + + +def xyz2xyh(xyz, cur_camera): + """ B x 3 -> B x 3 + """ + ori_shape = xyz.shape + + xyz = xyz.reshape(-1, 3) + foot_xyz = np.copy(xyz) + + foot_xyz[..., 1] = 0.0 # 0.0 is ground + foot_xy = project(foot_xyz, cur_camera) # B x 3 + xy = project(xyz, cur_camera) # B x 3 + + ret = np.copy(xyz) # B x 3 + ret[..., :2] = xy + ret[..., 2] = foot_xy[..., 1] - xy[..., 1] # B x 3 + + ret = ret.reshape(*ori_shape) + xyz = xyz.reshape(*ori_shape) + return ret + + +def xyh2xyz(xyh, cur_camera): + """ xyh: H x W x 1, pixel height channel + """ + h, w = xyh.shape[:2] + + u = np.arange(0, w, 1) + v = np.arange(0, h, 1) + uu, vv = np.meshgrid(u, v) # H x W + + h = xyh + coord = np.concatenate([uu[..., None], vv[..., None], h], axis=-1) + + coord[..., 1] = coord[..., 1] + coord[..., 2] # foot Y coord + coord[..., 2] = 0.0 # height 0 + + fu, fv, fh = coord[..., 0], coord[..., 1], coord[..., 2] # H x W + + a = cur_camera.right() # 3 + b = -cur_camera.up() # 3 + c = cur_camera.C() # 3 + + ww = -cur_camera.height/(a[1] * fu + b[1] * fv + c[1]) # H x W + + ww[np.isinf(ww)] = 0.0 + ww[np.isnan(ww)] = 0.0 + + cam_origin = cur_camera.O + cam_mat = get_camera_mat(cur_camera) # 3 x 3 + + uniform_coord = np.concatenate([uu[..., None], vv[..., None], np.ones_like(uu)[..., None]], axis=-1) # H x W x 3 + xyz = cam_origin + np.einsum('ct,hwt->hwc', cam_mat, uniform_coord) * ww[..., None] # H x W x 3 + + return xyz, ww + + +def normalize_vec3(vec3): + """ vec3: ... x 3 + """ + return vec3/(np.linalg.norm(vec3, axis=-1, keepdims=True)+1e-8) + + +def to_tensor(np_img): + device = torch.device("cuda:0") + return torch.tensor(np_img.transpose((2,0,1)))[None, ...].to(device).float() + + + diff --git a/PixHtLab-Src/Demo/SSN/app.py b/PixHtLab-Src/Demo/SSN/app.py new file mode 100644 index 0000000000000000000000000000000000000000..f86477b49b1fa51c902e235b855675cf540b07c5 --- /dev/null +++ b/PixHtLab-Src/Demo/SSN/app.py @@ -0,0 +1,199 @@ +import torch +from torch import nn +import logging + +from pathlib import Path +import gradio as gr +import numpy as np +import cv2 + +import model_utils +from models.SSN import SSN + +config_file = 'configs/SSN.yaml' +weight = 'weights/0000001000.pt' +device = torch.device('cuda:0') +device = torch.device('cpu') +model = model_utils.load_model(config_file, weight, SSN, device) + +DEFAULT_INTENSITY = 0.9 +DEFAULT_GAMMA = 2.0 + +logging.info('Model loading succeed') + +cur_rgba = None +cur_shadow = None +cur_intensity = DEFAULT_INTENSITY +cur_gamma = DEFAULT_GAMMA + +def resize(img, size): + h, w = img.shape[:2] + + if h > w: + newh = size + neww = int(w / h * size) + else: + neww = size + newh = int(h / w * size) + + resized_img = cv2.resize(img, (neww, newh), interpolation=cv2.INTER_AREA) + + if len(img.shape) != len(resized_img.shape): + resized_img = resized_img[..., none] + + return resized_img + + +def ibl_normalize(ibl, energy=30.0): + total_energy = np.sum(ibl) + if total_energy < 1e-3: + # print('small energy: ', total_energy) + h,w = ibl.shape + return np.zeros((h,w)) + + return ibl * energy / total_energy + + +def padding_mask(rgba_input: np.array): + """ Padding the mask input so that it fits the training dataset view range + If the rgba does not have enough padding area, we need to pad the area + :param rgba_input: H x W x 4 inputs, the first 3 channels are RGB, the last channel is the alpha + :returns: H x W x 4 padded RGBAD + """ + padding = 40 + padding_size = 256 - padding * 2 + + h, w = rgba_input.shape[:2] + rgb = rgba_input[:, :, :3] + alpha = rgba_input[:, :, -1:] + + zeros = np.where(alpha==0) + hh, ww = zeros[0], zeros[1] + h_min, h_max = hh.min(), hh.max() + w_min, w_max = ww.min(), ww.max() + + + # if the area already has enough padding + if h_max - h_min < padding_size and w_max - w_min < padding_size: + return rgba_input + + padding_output = np.zeros((256, 256, 4)) + padding_output[..., :3] = 1.0 + + padded_rgba = resize(rgba_input, padding_size) + new_h, new_w = padded_rgba.shape[:2] + + padding_h = (256 - new_h) // 2 + padding_w = (256 - new_w) // 2 + + padding_output[padding_h:padding_h+new_h, padding_w:padding_w+new_w, :] = padded_rgba + padding_output = np.clip(padding_output, 0.0, 1.0) + + return padding_output + +def shadow_composite(rgba, shadow, intensity, gamma): + rgb = rgba[..., :3] + mask = rgba[..., 3:] + + if len(shadow.shape) == 2: + shadow = shadow[..., None] + + new_shadow = 1.0 - shadow ** gamma * intensity + ret = rgb * mask + (1.0 - mask) * new_shadow + return ret, new_shadow[..., 0] + + +def render_btn_fn(mask, ibl): + global cur_rgba, cur_shadow, cur_gamma, cur_intensity + + print("Button clicked!") + + mask = mask / 255.0 + ibl = ibl/ 255.0 + + mask = np.clip(mask, 0.0, 1.0) + + # smoothing ibl + ibl = cv2.GaussianBlur(ibl, (11, 11), 0) + + # padding mask + mask = padding_mask(mask) + + cur_rgba = np.copy(mask) + + + print('mask shape: {}/{}/{}/{}, ibl shape: {}/{}/{}/{}'.format(mask.shape, mask.dtype, mask.min(), mask.max(), + ibl.shape, ibl.dtype, ibl.min(), ibl.max())) + + # ret = np.random.randn(256, 256, 3) + # ret = (ret - ret.min()) / (ret.max() - ret.min() + 1e-8) + + rgb, mask = mask[..., :3], mask[..., 3] + + ibl = ibl_normalize(cv2.resize(ibl, (32, 16))) + + # ibl = 1.0 - ibl + + x = { + 'mask': mask, + 'ibl': ibl + } + shadow = model.inference(x) + cur_shadow = np.copy(shadow) + + ret, shadow = shadow_composite(cur_rgba, shadow, cur_intensity, cur_gamma) + + # print('IBL range: {}/{} Shadow range: {} {}'.format(ibl.min(), ibl.max(), shadow.min(), shadow.max())) + return ret, shadow + + +def intensity_change(x): + global cur_rgba, cur_shadow, cur_gamma, cur_intensity + + cur_intensity = x + ret, shadow = shadow_composite(cur_rgba, cur_shadow, cur_intensity, cur_gamma) + return ret, shadow + + +def gamma_change(x): + global cur_rgba, cur_shadow, cur_gamma, cur_intensity + + cur_gamma = x + ret, shadow = shadow_composite(cur_rgba, cur_shadow, cur_intensity, cur_gamma) + return ret, shadow + +def update_input(mask): + return mask + + +ibl_h = 128 +ibl_w = ibl_h * 2 + +with gr.Blocks() as demo: + with gr.Row(): + mask_input = gr.Image(shape=None, width=256, height=256,image_mode="RGBA", label="RGBA") + ibl_input = gr.Sketchpad(shape=(ibl_w, ibl_h), image_mode="L", label="IBL", tool='sketch', invert_colors=True) + output = gr.Image(shape=(256, 256), height=256, width=256, image_mode="RGB", label="Output") + shadow_output = gr.Image(shape=(256, 256), height=256, width=256, image_mode="L", label="Shadow Layer") + + with gr.Row(): + intensity_slider = gr.Slider(0.0, 1.0, value=DEFAULT_INTENSITY, step=0.1, label="Intensity", info="Choose between 0.0 and 1.0") + gamma_slider = gr.Slider(1.0, 4.0, value=DEFAULT_GAMMA, step=0.1, label="Gamma", info="Gamma correction for shadow") + render_btn = gr.Button(label="Render") + + with gr.Row(): + gr.Examples( + examples=[['imgs/woman.png'],['imgs/man.png'], ['imgs/plant1.png'], ['imgs/human2.png'], ['imgs/cloud.png']], + fn=update_input, + inputs=[mask_input], + outputs=mask_input + ) + + render_btn.click(render_btn_fn, inputs=[mask_input, ibl_input], outputs=[output, shadow_output]) + intensity_slider.release(intensity_change, inputs=[intensity_slider], outputs=[output, shadow_output]) + gamma_slider.release(gamma_change, inputs=[gamma_slider], outputs=[output, shadow_output]) + + logging.info('Finished') + + +demo.launch() diff --git a/PixHtLab-Src/Demo/SSN/configs/SSN.yaml b/PixHtLab-Src/Demo/SSN/configs/SSN.yaml new file mode 100644 index 0000000000000000000000000000000000000000..96eb02c0c7c48752fa4b3966d8e19ceea0fbb15d --- /dev/null +++ b/PixHtLab-Src/Demo/SSN/configs/SSN.yaml @@ -0,0 +1,51 @@ +exp_name: SSN + +# model related +model: + name: 'SSN' + in_channels: 1 + out_channels: 1 + resnet: False + + mid_act: "relu" + out_act: 'relu' + + optimizer: 'Adam' + weight_decay: 4e-5 + beta1: 0.9 + + +# dataset +dataset: + name: 'SSN_Dataset' + hdf5_file: 'Dataset/SSN/ssn_shadow/shadow_base/ssn_base.hdf5' + shadow_per_epoch: 10 + + +# test_dataset: +# name: 'SSN_Dataset' +# hdf5_file: 'Dataset/SSN/ssn_shadow/shadow_base/ssn_base.hdf5' + + +# training related +hyper_params: + lr: 1e-3 + epochs: 100000 + workers: 40 + batch_size: 10 + save_epoch: 10 + + eval_batch: 10 + eval_save: False + + # visualization + vis_iter: 100 # iteration for visualization + save_iter: 100 + n_cols: 5 + gpus: + - 0 + - 1 + + default_folder: 'weights' + resume: False + weight_file: 'latest' \ No newline at end of file diff --git a/PixHtLab-Src/Demo/SSN/imgs/imgs_convert_rgb_alpha.py b/PixHtLab-Src/Demo/SSN/imgs/imgs_convert_rgb_alpha.py new file mode 100644 index 0000000000000000000000000000000000000000..9ed560b95575b197e2a1af33727e366a751f454f --- /dev/null +++ b/PixHtLab-Src/Demo/SSN/imgs/imgs_convert_rgb_alpha.py @@ -0,0 +1,14 @@ +import matplotlib.pyplot as plt +import numpy as np + +rgb_file = 'fg-1-rgb.png' +alpha_file = 'fg-1-alpha.png' +output_file = 'fg-1-rgba.png' + +rgb = plt.imread(rgb_file) +alpha = plt.imread(alpha_file) + +print(rgb.shape, alpha.shape) + +rgba = np.concatenate([rgb[..., :3], alpha[..., 0:1]], axis=2) +plt.imsave(output_file, rgba) diff --git a/PixHtLab-Src/Demo/SSN/imgs/imgs_test.py b/PixHtLab-Src/Demo/SSN/imgs/imgs_test.py new file mode 100644 index 0000000000000000000000000000000000000000..0f0449ce5da7caac56f5aff33ea37928ac7cc5cf --- /dev/null +++ b/PixHtLab-Src/Demo/SSN/imgs/imgs_test.py @@ -0,0 +1,14 @@ +import matplotlib.pyplot as plt +import numpy as np + + +rgb = 'woman.png' +mask = 'woman_mask.png' +ofile = 'test1.png' + +rgb = plt.imread(rgb) +mask = plt.imread(mask) + +output = np.concatenate([rgb[..., :3], mask[..., :1]], axis=2) +plt.imsave(ofile, output) + diff --git a/PixHtLab-Src/Demo/SSN/imgs/man.png b/PixHtLab-Src/Demo/SSN/imgs/man.png new file mode 100644 index 0000000000000000000000000000000000000000..de23bf178b77dfa1f8b6359f7fb9fec65a237c3c Binary files /dev/null and b/PixHtLab-Src/Demo/SSN/imgs/man.png differ diff --git a/PixHtLab-Src/Demo/SSN/model_utils.py b/PixHtLab-Src/Demo/SSN/model_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..a6f8ab5adadee5ac6c1da91c52c8ff11f25105c1 --- /dev/null +++ b/PixHtLab-Src/Demo/SSN/model_utils.py @@ -0,0 +1,49 @@ +import os +import yaml +import logging + +import torch + + +def parse_configs(config: str): + """ Parse the config file and return a dictionary of configs + :param config: path to the config file + :returns: + """ + if not os.path.exists(config): + logging.error('Cannot find the config file: {}'.format(config)) + exit() + + with open(config, 'r') as stream: + try: + configs=yaml.safe_load(stream) + return configs + + except yaml.YAMLError as exc: + logging.error(exc) + return {} + + +def load_model(config: str, weight: str, model_def, device): + """ Load the model from the config file and the weight file + :param config: path to the config file + :param weight: path to the weight file + :param model_def: model class definition + :param device: pytorch device + :returns: + """ + assert os.path.exists(weight), 'Cannot find the weight file: {}'.format(weight) + assert os.path.exists(config), 'Cannot find the config file: {}'.format(config) + + + opt = parse_configs(config) + model = model_def(opt) + cp = torch.load(weight, map_location=device) + + models = model.get_models() + for k, m in models.items(): + m.load_state_dict(cp[k]) + m.to(device) + + model.set_models(models) + return model diff --git a/PixHtLab-Src/Demo/SSN/models/SSN.py b/PixHtLab-Src/Demo/SSN/models/SSN.py new file mode 100644 index 0000000000000000000000000000000000000000..8330cc0daa091290f2cb49fe3023893dbfc437ae --- /dev/null +++ b/PixHtLab-Src/Demo/SSN/models/SSN.py @@ -0,0 +1,139 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from torchvision import utils +from collections import OrderedDict +import numpy as np + +from .abs_model import abs_model +from .blocks import * +from .SSN_Model import SSN_Model + + +class SSN(abs_model): + def __init__(self, opt): + mid_act = opt['model']['mid_act'] + out_act = opt['model']['out_act'] + in_channels = opt['model']['in_channels'] + out_channels = opt['model']['out_channels'] + self.ncols = opt['hyper_params']['n_cols'] + + self.model = SSN_Model(in_channels=in_channels, out_channels=out_channels, mid_act=mid_act, out_act=out_act) + self.optimizer = get_optimizer(opt, self.model) + self.visualization = {} + + def setup_input(self, x): + return x + + + def forward(self, x): + keys = ['mask', 'ibl'] + + for k in keys: + assert k in x.keys(), '{} not in input'.format(k) + + mask = x['mask'] + ibl = x['ibl'] + + return self.model(mask, ibl) + + + def compute_loss(self, y, pred): + total_loss = self.norm_loss_.loss(y, pred) + return total_loss + + + def supervise(self, input_x, y, is_training:bool)->float: + optimizer = self.optimizer + model = self.model + + optimizer.zero_grad() + pred = self.forward(input_x) + loss = self.compute_loss(y, pred) + + # logging.info('Pred/Target: {}, {}/{}, {}'.format(pred.min().item(), pred.max().item(), y.min().item(), y.max().item())) + + if is_training: + loss.backward() + optimizer.step() + + self.visualization['mask'] = input_x['mask'].detach() + self.visualization['ibl'] = input_x['ibl'].detach() + self.visualization['y'] = y.detach() + self.visualization['pred'] = pred.detach() + + return loss.item() + + + def get_visualize(self) -> OrderedDict: + """ Convert to visualization numpy array + """ + nrows = self.ncols + visualizations = self.visualization + ret_vis = OrderedDict() + + for k, v in visualizations.items(): + batch = v.shape[0] + n = min(nrows, batch) + + plot_v = v[:n] + plot_v = (plot_v - plot_v.min())/(plot_v.max() - plot_v.min()) + ret_vis[k] = np.clip(utils.make_grid(plot_v.cpu(), nrow=nrows).numpy().transpose(1,2,0), 0.0, 1.0) + + return ret_vis + + + def get_logs(self): + pass + + + def inference(self, x): + keys = ['mask', 'ibl'] + for k in keys: + assert k in x.keys(), '{} not in input'.format(k) + assert len(x[k].shape) == 2, '{} should be 2D tensor'.format(k) + + + # device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + device = torch.device('cpu') + + mask = torch.tensor(x['mask'])[None, None, ...].float().to(device) + ibl = torch.tensor(x['ibl'])[None, None, ...].float().to(device) + + input_x = {'mask': mask, 'ibl': ibl} + pred = self.forward(input_x) + + pred = np.clip(pred[0, 0].detach().cpu().numpy() / 30.0, 0.0, 1.0) + return pred + + + + def batch_inference(self, x): + # TODO + pass + + + """ Getter & Setter + """ + def get_models(self) -> dict: + return {'model': self.model} + + + def get_optimizers(self) -> dict: + return {'optimizer': self.optimizer} + + + def set_models(self, models: dict) : + # input test + if 'model' not in models.keys(): + raise ValueError('{} not in self.model'.format('model')) + + self.model = models['model'] + + + def set_optimizers(self, optimizer: dict): + self.optimizer = optimizer['optimizer'] + + #################### + # Personal Methods # + #################### diff --git a/PixHtLab-Src/Demo/SSN/models/SSN_Model.py b/PixHtLab-Src/Demo/SSN/models/SSN_Model.py new file mode 100644 index 0000000000000000000000000000000000000000..be959f718689bff4d4d6396331651e0da8f0eb6f --- /dev/null +++ b/PixHtLab-Src/Demo/SSN/models/SSN_Model.py @@ -0,0 +1,333 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.optim as optim +import logging + +def weights_init(init_type='gaussian', std=0.02): + def init_fun(m): + classname = m.__class__.__name__ + if (classname.find('Conv') == 0 or classname.find( + 'Linear') == 0) and hasattr(m, 'weight'): + if init_type == 'gaussian': + nn.init.normal_(m.weight, 0.0, std) + elif init_type == 'xavier': + nn.init.xavier_normal_(m.weight, gain=math.sqrt(2)) + elif init_type == 'kaiming': + nn.init.kaiming_normal_(m.weight, a=0, mode='fan_in') + elif init_type == 'orthogonal': + nn.init.orthogonal_(m.weight, gain=math.sqrt(2)) + elif init_type == 'default': + pass + else: + assert 0, "Unsupported initialization: {}".format(init_type) + if hasattr(m, 'bias') and m.bias is not None: + nn.init.constant_(m.bias, 0.0) + + return init_fun + +def freeze(module): + for param in module.parameters(): + param.requires_grad = False + +def unfreeze(module): + for param in module.parameters(): + param.requires_grad = True + +def get_optimizer(opt, model): + lr = float(opt['hyper_params']['lr']) + beta1 = float(opt['model']['beta1']) + weight_decay = float(opt['model']['weight_decay']) + opt_name = opt['model']['optimizer'] + + optim_params = [] + # weight decay + for key, value in model.named_parameters(): + if not value.requires_grad: + continue # frozen weights + + if key[-4:] == 'bias': + optim_params += [{'params': value, 'weight_decay': 0.0}] + else: + optim_params += [{'params': value, + 'weight_decay': weight_decay}] + + if opt_name == 'Adam': + return optim.Adam(optim_params, + lr=lr, + betas=(beta1, 0.999), + eps=1e-5) + else: + err = '{} not implemented yet'.format(opt_name) + logging.error(err) + raise NotImplementedError(err) + + +def get_activation(activation): + if activation is None: + return nn.Identity() + + act_func = { + 'relu':nn.ReLU(), + 'sigmoid':nn.Sigmoid(), + 'tanh':nn.Tanh(), + 'prelu':nn.PReLU(), + 'leaky':nn.LeakyReLU(0.2), + 'gelu':nn.GELU(), + } + if activation not in act_func.keys(): + logging.error("activation {} is not implemented yet".format(activation)) + assert False + + return act_func[activation] + +def get_norm(out_channels, norm_type='Instance'): + norm_set = ['Instance', 'Batch', 'Group'] + if norm_type not in norm_set: + err = "Normalization {} has not been implemented yet" + logging.error(err) + raise ValueError(err) + + if norm_type == 'Instance': + return nn.InstanceNorm2d(out_channels, affine=True) + + if norm_type == 'Batch': + return nn.BatchNorm2d(out_channels) + + if norm_type == 'Group': + if out_channels >= 32: + groups = 32 + else: + groups = 1 + + return nn.GroupNorm(groups, out_channels) + + else: + raise NotImplementedError('{} has not implemented yet'.format(norm_type)) + + + +def get_layer_info(out_channels, activation_func='relu'): + activation = get_activation(activation_func) + norm_layer = get_norm(out_channels, 'Group') + return norm_layer, activation + + +class Conv(nn.Module): + """ (convolution => [BN] => ReLU) """ + def __init__(self, + in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1, + bias=True, + activation='leaky', + resnet=True): + super().__init__() + + norm_layer, act_func = get_layer_info(out_channels,activation) + + if resnet and in_channels == out_channels: + self.resnet = True + else: + self.resnet = False + + self.conv = nn.Sequential( + nn.Conv2d(in_channels, out_channels, stride=stride, kernel_size=kernel_size, padding=padding, bias=bias), + norm_layer, + act_func) + + def forward(self, x): + res = self.conv(x) + + if self.resnet: + res = res + x + + return res + + + +class Up(nn.Module): + """ Upscaling then conv """ + + def __init__(self, in_channels, out_channels, activation='relu', resnet=True): + super().__init__() + + self.up_layer = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True) + self.up = Conv(in_channels, out_channels, activation=activation, resnet=resnet) + + def forward(self, x): + x = self.up_layer(x) + return self.up(x) + + + +class DConv(nn.Module): + """ Double Conv Layer + """ + def __init__(self, in_channels, out_channels, activation='relu', resnet=True): + super().__init__() + + self.conv1 = Conv(in_channels, out_channels, activation=activation, resnet=resnet) + self.conv2 = Conv(out_channels, out_channels, activation=activation, resnet=resnet) + + def forward(self, x): + return self.conv2(self.conv1(x)) + + +class Encoder(nn.Module): + def __init__(self, in_channels=3, mid_act='leaky', resnet=True): + super(Encoder, self).__init__() + self.in_conv = Conv(in_channels, 32-in_channels, stride=1, activation=mid_act, resnet=resnet) + self.down_32_64 = Conv(32, 64, stride=2, activation=mid_act, resnet=resnet) + self.down_64_64_1 = Conv(64, 64, activation=mid_act, resnet=resnet) + self.down_64_128 = Conv(64, 128, stride=2, activation=mid_act, resnet=resnet) + self.down_128_128_1 = Conv(128, 128, activation=mid_act, resnet=resnet) + self.down_128_256 = Conv(128, 256, stride=2, activation=mid_act, resnet=resnet) + self.down_256_256_1 = Conv(256, 256, activation=mid_act, resnet=resnet) + self.down_256_512 = Conv(256, 512, stride=2, activation=mid_act, resnet=resnet) + self.down_512_512_1 = Conv(512, 512, activation=mid_act, resnet=resnet) + self.down_512_512_2 = Conv(512, 512, activation=mid_act, resnet=resnet) + self.down_512_512_3 = Conv(512, 512, activation=mid_act, resnet=resnet) + + + def forward(self, x): + x1 = self.in_conv(x) # 32 x 256 x 256 + x1 = torch.cat((x, x1), dim=1) + + x2 = self.down_32_64(x1) + x3 = self.down_64_64_1(x2) + + x4 = self.down_64_128(x3) + x5 = self.down_128_128_1(x4) + + x6 = self.down_128_256(x5) + x7 = self.down_256_256_1(x6) + + x8 = self.down_256_512(x7) + x9 = self.down_512_512_1(x8) + x10 = self.down_512_512_2(x9) + x11 = self.down_512_512_3(x10) + + return x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1 + + +class Decoder(nn.Module): + """ Up Stream Sequence """ + + def __init__(self, + out_channels=3, + mid_act='relu', + out_act='sigmoid', + resnet = True): + + super(Decoder, self).__init__() + + input_channel = 512 + fea_dim = 100 + + + self.up_16_16_1 = Conv(input_channel, 256, activation=mid_act, resnet=resnet) + self.up_16_16_2 = Conv(768, 512, activation=mid_act, resnet=resnet) + self.up_16_16_3 = Conv(1024, 512, activation=mid_act, resnet=resnet) + + self.up_16_32 = Up(1024, 256, activation=mid_act, resnet=resnet) + self.up_32_32_1 = Conv(512, 256, activation=mid_act, resnet=resnet) + + self.up_32_64 = Up(512, 128, activation=mid_act, resnet=resnet) + self.up_64_64_1 = Conv(256, 128, activation=mid_act, resnet=resnet) + + self.up_64_128 = Up(256, 64, activation=mid_act, resnet=resnet) + self.up_128_128_1 = Conv(128, 64, activation=mid_act, resnet=resnet) + + self.up_128_256 = Up(128, 32, activation=mid_act, resnet=resnet) + self.out_conv = Conv(64, out_channels, activation=out_act) + + + def forward(self, x, ibl): + x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1 = x + + h,w = x10.shape[2:] + y = ibl.view(-1, 512, 1, 1).repeat(1, 1, h, w) + + y = self.up_16_16_1(y) # 256 x 16 x 16 + + y = torch.cat((x10, y), dim=1) # 768 x 16 x 16 + y = self.up_16_16_2(y) # 512 x 16 x 16 + + + y = torch.cat((x9, y), dim=1) # 1024 x 16 x 16 + y = self.up_16_16_3(y) # 512 x 16 x 16 + + y = torch.cat((x8, y), dim=1) # 1024 x 16 x 16 + y = self.up_16_32(y) # 256 x 32 x 32 + + y = torch.cat((x7, y), dim=1) + y = self.up_32_32_1(y) # 256 x 32 x 32 + + y = torch.cat((x6, y), dim=1) + y = self.up_32_64(y) + + y = torch.cat((x5, y), dim=1) + y = self.up_64_64_1(y) # 128 x 64 x 64 + + y = torch.cat((x4, y), dim=1) + y = self.up_64_128(y) + + y = torch.cat((x3, y), dim=1) + y = self.up_128_128_1(y) # 64 x 128 x 128 + + y = torch.cat((x2, y), dim=1) + y = self.up_128_256(y) # 32 x 256 x 256 + + y = torch.cat((x1, y), dim=1) + y = self.out_conv(y) # 3 x 256 x 256 + + return y + + +class SSN_Model(nn.Module): + """ Implementation of Relighting Net """ + + def __init__(self, + in_channels=3, + out_channels=3, + mid_act='leaky', + out_act='sigmoid', + resnet=True): + super(SSN_Model, self).__init__() + + self.out_act = out_act + + self.encoder = Encoder(in_channels, mid_act=mid_act, resnet=resnet) + self.decoder = Decoder(out_channels, mid_act=mid_act, out_act=out_act, resnet=resnet) + + # init weights + init_func = weights_init('gaussian', std=1e-3) + self.encoder.apply(init_func) + self.decoder.apply(init_func) + + + def forward(self, x, ibl): + """ + Input is (source image, target light, source light, ) + Output is: predicted new image, predicted source light, self-supervision image + """ + latent = self.encoder(x) + pred = self.decoder(latent, ibl) + + if self.out_act == 'sigmoid': + pred = pred * 30.0 + + return pred + + +if __name__ == '__main__': + x = torch.randn(5,1,256,256) + ibl = torch.randn(5, 1, 32, 16) + model = SSN_Model(1,1) + + y = model(x, ibl) + + print('Output: ', y.shape) \ No newline at end of file diff --git a/PixHtLab-Src/Demo/SSN/models/__pycache__/SSN_Model.cpython-310.pyc b/PixHtLab-Src/Demo/SSN/models/__pycache__/SSN_Model.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d205df77c94bbd0d03def8ff379e6b1ea025f07c Binary files /dev/null and b/PixHtLab-Src/Demo/SSN/models/__pycache__/SSN_Model.cpython-310.pyc differ diff --git a/PixHtLab-Src/Demo/SSN/models/abs_model.py b/PixHtLab-Src/Demo/SSN/models/abs_model.py new file mode 100644 index 0000000000000000000000000000000000000000..b424a47beb265cb8aa32e44468a133bc1443a9a4 --- /dev/null +++ b/PixHtLab-Src/Demo/SSN/models/abs_model.py @@ -0,0 +1,73 @@ +from abc import ABC, abstractmethod +from collections import OrderedDict + +class abs_model(ABC): + """ Training Related Interface + """ + @abstractmethod + def setup_input(self, x): + pass + + + @abstractmethod + def forward(self, x): + pass + + + @abstractmethod + def supervise(self, input_x, y, is_training:bool)->float: + pass + + + @abstractmethod + def get_visualize(self) -> OrderedDict: + return {} + + + """ Inference Related Interface + """ + @abstractmethod + def inference(self, x): + pass + + + @abstractmethod + def batch_inference(self, x): + pass + + + """ Logging/Visualization Related Interface + """ + @abstractmethod + def get_logs(self): + pass + + + """ Getter & Setter + """ + @abstractmethod + def get_models(self) -> dict: + """ GAN may have two models + """ + pass + + + @abstractmethod + def get_optimizers(self) -> dict: + """ GAN may have two optimizer + """ + pass + + + @abstractmethod + def set_models(self, models) -> dict: + """ GAN may have two models + """ + pass + + + @abstractmethod + def set_optimizers(self, optimizers: dict): + """ GAN may have two optimizer + """ + pass diff --git a/PixHtLab-Src/Demo/SSN/models/blocks.py b/PixHtLab-Src/Demo/SSN/models/blocks.py new file mode 100644 index 0000000000000000000000000000000000000000..7fabe5f4de6c43a35f40d16ba3ad26222b5a0bf0 --- /dev/null +++ b/PixHtLab-Src/Demo/SSN/models/blocks.py @@ -0,0 +1,238 @@ +from enum import Enum +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.optim as optim +import logging + + +def get_model_size(model): + param_size = 0 + for param in model.parameters(): + param_size += param.nelement() * param.element_size() + + buffer_size = 0 + for buffer in model.buffers(): + buffer_size += buffer.nelement() * buffer.element_size() + + size_all_mb = (param_size + buffer_size) / 1024 ** 2 + print('model size: {:.3f}MB'.format(size_all_mb)) + # return param_size + buffer_size + return size_all_mb + + +def weights_init(init_type='gaussian'): + def init_fun(m): + classname = m.__class__.__name__ + if (classname.find('Conv') == 0 or classname.find( + 'Linear') == 0) and hasattr(m, 'weight'): + if init_type == 'gaussian': + nn.init.normal_(m.weight, 0.0, 0.02) + elif init_type == 'xavier': + nn.init.xavier_normal_(m.weight, gain=math.sqrt(2)) + elif init_type == 'kaiming': + nn.init.kaiming_normal_(m.weight, a=0, mode='fan_in') + elif init_type == 'orthogonal': + nn.init.orthogonal_(m.weight, gain=math.sqrt(2)) + elif init_type == 'default': + pass + else: + assert 0, "Unsupported initialization: {}".format(init_type) + if hasattr(m, 'bias') and m.bias is not None: + nn.init.constant_(m.bias, 0.0) + + return init_fun + + +def freeze(module): + for param in module.parameters(): + param.requires_grad = False + + +def unfreeze(module): + for param in module.parameters(): + param.requires_grad = True + + +def get_optimizer(opt, model): + lr = float(opt['hyper_params']['lr']) + beta1 = float(opt['model']['beta1']) + weight_decay = float(opt['model']['weight_decay']) + opt_name = opt['model']['optimizer'] + + optim_params = [] + # weight decay + for key, value in model.named_parameters(): + if not value.requires_grad: + continue # frozen weights + + if key[-4:] == 'bias': + optim_params += [{'params': value, 'weight_decay': 0.0}] + else: + optim_params += [{'params': value, + 'weight_decay': weight_decay}] + + if opt_name == 'Adam': + return optim.Adam(optim_params, + lr=lr, + betas=(beta1, 0.999), + eps=1e-5) + else: + err = '{} not implemented yet'.format(opt_name) + logging.error(err) + raise NotImplementedError(err) + + +def get_activation(activation): + act_func = { + 'relu':nn.ReLU(), + 'sigmoid':nn.Sigmoid(), + 'tanh':nn.Tanh(), + 'prelu':nn.PReLU(), + 'leaky_relu':nn.LeakyReLU(0.2), + 'gelu':nn.GELU(), + } + if activation not in act_func.keys(): + logging.error("activation {} is not implemented yet".format(activation)) + assert False + + return act_func[activation] + + +def get_norm(out_channels, norm_type='Group', groups=32): + norm_set = ['Instance', 'Batch', 'Group'] + if norm_type not in norm_set: + err = "Normalization {} has not been implemented yet" + logging.error(err) + raise ValueError(err) + + if norm_type == 'Instance': + return nn.InstanceNorm2d(out_channels, affine=True) + + if norm_type == 'Batch': + return nn.BatchNorm2d(out_channels) + + if norm_type == 'Group': + if out_channels >= 32: + groups = 32 + else: + groups = max(out_channels // 2, 1) + + return nn.GroupNorm(groups, out_channels) + else: + raise NotImplementedError + + +class Conv(nn.Module): + def __init__(self, in_channels, out_channels, stride=1, norm_type='Batch', activation='relu'): + super().__init__() + + act_func = get_activation(activation) + norm_layer = get_norm(out_channels, norm_type) + self.conv = nn.Sequential( + nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=True, padding_mode='reflect'), + norm_layer, + act_func) + + def forward(self, x): + return self.conv(x) + + +def zero_module(module): + """ + Zero out the parameters of a module and return it. + """ + for p in module.parameters(): + p.detach().zero_() + return module + + +class Up(nn.Module): + def __init__(self): + super().__init__() + pass + + def forward(self, x): + return F.interpolate(x, scale_factor=2, mode='bilinear') + + +class Down(nn.Module): + def __init__(self, channels, use_conv): + super().__init__() + self.use_conv = use_conv + + if self.use_conv: + self.op = nn.Conv2d(channels, channels, 3, stride=2, padding=1) + else: + self.op = nn.AvgPool2d(kernel_size=3, stride=2, padding=1) + + + def forward(self, x): + return self.op(x) + + +class Res_Type(Enum): + UP = 1 + DOWN = 2 + SAME = 3 + + +class ResBlock(nn.Module): + def __init__(self, in_channels: int, out_channels: int, dropout=0.0, updown=Res_Type.DOWN, mid_act='leaky'): + """ ResBlock to cover several cases: + 1. Up/Down/Same + 2. in_channels != out_channels + """ + super().__init__() + + self.updown = updown + + self.in_norm = get_norm(out_channels, 'Group') + self.in_act = get_activation(mid_act) + self.in_conv = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=True) + + # up down + if self.updown == Res_Type.DOWN: + self.h_updown = Down(in_channels, use_conv=True) + self.x_updown = Down(in_channels, use_conv=True) + elif self.updown == Res_Type.UP: + self.h_updown = Up() + self.x_updown = Up() + else: + self.h_updown = nn.Identity() + + self.out_layer = nn.Sequential( + get_norm(out_channels, 'Group'), + get_activation(mid_act), + nn.Dropout(p=dropout), + zero_module(nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1, bias=True)) + ) + + + def forward(self, x): + # in layer + h = self.in_act(self.in_norm(x)) + h = self.in_conv(self.h_updown(h)) + x = self.x_updown(x) + + # out layer + h = self.out_layer(h) + return x + h + + + +if __name__ == '__main__': + x = torch.randn(5, 3, 256, 256) + up = Up() + conv_down = Down(3, True) + pool_down = Down(3, False) + + print('Up: {}'.format(up(x).shape)) + print('Conv down: {}'.format(conv_down(x).shape)) + print('Pool down: {}'.format(pool_down(x).shape)) + + up_model = ResBlock(3, 6, updown=True) + down_model = ResBlock(3, 6, updown=False) + + print('model down: {}'.format(up_model(x).shape)) + print('model down: {}'.format(down_model(x).shape)) \ No newline at end of file diff --git a/PixHtLab-Src/Demo/SSN/weights/.placeholder b/PixHtLab-Src/Demo/SSN/weights/.placeholder new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/PixHtLab-Src/Docker/Dockerfile b/PixHtLab-Src/Docker/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..e9ef0e67240f6635b74a899840d2659bf9dcced6 --- /dev/null +++ b/PixHtLab-Src/Docker/Dockerfile @@ -0,0 +1,117 @@ +FROM nvidia/cuda:11.3.0-devel-ubuntu20.04 as base + +ENV NV_CUDA_LIB_VERSION "11.3.0" + +FROM base as base-amd6 + +LABEL maintainer "Yichen Sheng " + +ARG DEBIAN_FRONTEND=noninteractive + +ENV NVIDIA_DRIVER_CAPABILITIES=compute,utility + +# ARG CUDA_ARCHITECTURES=90;89;86;80;75;70;61;52;37 +ARG CUDA_ARCHITECTURES=90;89;86;80;75;70;61;52;37 + +# Install required apt packages and clear cache afterwards. +RUN apt-get update && \ + apt-get install -y --no-install-recommends \ + build-essential \ + cmake \ + curl \ + ffmpeg \ + git \ + htop \ + wget \ + colmap \ + tmux \ + xorg-dev \ + libatlas-base-dev \ + libboost-filesystem-dev \ + libboost-graph-dev \ + libboost-program-options-dev \ + libboost-system-dev \ + libboost-test-dev \ + libhdf5-dev \ + libcgal-dev \ + libeigen3-dev \ + libflann-dev \ + libfreeimage-dev \ + libgflags-dev \ + libglew-dev \ + libgoogle-glog-dev \ + libmetis-dev \ + libprotobuf-dev \ + libqt5opengl5-dev \ + libsqlite3-dev \ + libsuitesparse-dev \ + nano \ + protobuf-compiler \ + python3.8 \ + python3-pip \ + python3.8-distutils \ + python3.8-dev \ + python-is-python3 \ + qtbase5-dev \ + sudo \ + vim-tiny \ + wget && \ + rm -rf /var/lib/apt/lists/* + +# RUN apt-get update && \ +# apt-get install -y software-properties-common + +# RUN add-apt-repository ppa:ubuntu-toolchain-r/test -y && \ +# apt-get update && \ +# apt-get install libstdc++6 -y + + +RUN apt update +RUN apt install -y software-properties-common +RUN rm -rf /var/lib/apt/lists/* + +# colmap seems to have a bug in the docker image, a workaround is this: +# https://stackoverflow.com/questions/63627955/cant-load-shared-library-libqt5core-so-5 +RUN strip --remove-section=.note.ABI-tag /usr/lib/x86_64-linux-gnu/libQt5Core.so.5 +RUN ldconfig + +WORKDIR /home/root/ + +RUN apt update +RUN apt install -y software-properties-common +RUN add-apt-repository universe \ + && add-apt-repository multiverse +RUN apt update +RUN rm -rf /var/lib/apt/lists/* + +# Set up symlinks for python and pip +RUN /usr/bin/python --version +RUN ls /usr/bin/python* +RUN rm /usr/bin/python && \ + rm /usr/bin/pip && \ + ln -s /usr/bin/python3.8 /usr/bin/python && \ + ln -s /usr/bin/pip3 /usr/bin/pip + +RUN python3.8 -m pip install --upgrade pip pybind11 + +# install data generation code +COPY DBG_GUI /home/root/DBG_GUI +RUN /bin/bash -c "cd /home/root/DBG_GUI/data && python3.8 setup.py install" + +RUN python3.8 -m pip install torch==1.12.1+cu113 torchvision==0.13.1+cu113 torchaudio==0.12.1 --extra-index-url https://download.pytorch.org/whl/cu113 +RUN python3.8 -m pip install pandas matplotlib tqdm +RUN python3.8 -m pip install opencv-python + +RUN python3.8 -m pip install h5py pyyaml dominate +RUN python3.8 -m pip install parse + +RUN python3.8 -m pip uninstall Pillow -y && python3.8 -m pip install Pillow==9.5.0 +RUN python3.8 -m pip install tensorboard +RUN python3.8 -m pip install scipy + +# imagen +RUN git clone https://github.com/holoviz-topics/imagen.git /home/root/imagen +RUN python3.8 -m pip install imagen +RUN cd /home/root/imagen && python3.8 setup.py install --force + +ENTRYPOINT [ "/bin/bash" ] diff --git a/PixHtLab-Src/Docker/build_docker.sh b/PixHtLab-Src/Docker/build_docker.sh new file mode 100644 index 0000000000000000000000000000000000000000..fbe3763ff30b6a535e334eb5ec934dc4e188c4ec --- /dev/null +++ b/PixHtLab-Src/Docker/build_docker.sh @@ -0,0 +1 @@ +docker build -t yichensheng/pixht . \ No newline at end of file diff --git a/PixHtLab-Src/Docker/imagen/.gitignore b/PixHtLab-Src/Docker/imagen/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..f600c600c18e35d873cf8981e4454866602b2940 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/.gitignore @@ -0,0 +1,12 @@ +*.py[cod] +#*# +*~ +*.egg +*.egg-info +*.swp +*.DS_Store +*.so +*.o +*.out +*.lock +.ipynb_checkpoints \ No newline at end of file diff --git a/PixHtLab-Src/Docker/imagen/.gitmodules b/PixHtLab-Src/Docker/imagen/.gitmodules new file mode 100644 index 0000000000000000000000000000000000000000..e4cc273601785ca41b9f3b71e1944cf0ae1a2fbe --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/.gitmodules @@ -0,0 +1,6 @@ +[submodule "doc/nbpublisher"] + path = doc/nbpublisher + url = https://github.com/ioam/ioam-builder.git +[submodule "doc/builder"] + path = doc/builder + url = https://github.com/ioam/ioam-builder.git diff --git a/PixHtLab-Src/Docker/imagen/.travis.yml b/PixHtLab-Src/Docker/imagen/.travis.yml new file mode 100644 index 0000000000000000000000000000000000000000..df3bba5cabab3f90cb4bd5df4200149695bb2404 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/.travis.yml @@ -0,0 +1,25 @@ +dist: xenial +sudo: true +language: python +python: + - "2.7" + - "3.5" + - "3.6" + - "3.7" + +notifications: + email: + on_failure: change # [always|never|change] default: always + +install: + - pip install param + - pip install holoviews + - pip install jinja2 tornado pyzmq matplotlib pillow + - if [[ $TRAVIS_PYTHON_VERSION == 2* ]]; then pip install ipython==5 ipykernel; fi + - if [[ $TRAVIS_PYTHON_VERSION == 3* ]]; then pip install ipython ipykernel; fi + +before-script: + - "echo 'backend : Agg' > $HOME/.matplotlib/matplotlibrc" + +script: + - nosetests --with-doctest \ No newline at end of file diff --git a/PixHtLab-Src/Docker/imagen/LICENSE.txt b/PixHtLab-Src/Docker/imagen/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..de9fcd62e78b7ab9b210e7546dbcb6debc9823ff --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/LICENSE.txt @@ -0,0 +1,30 @@ +Copyright (c) 2005-2018, IOAM (ioam.github.com) +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the + distribution. + + * Neither the name of IOAM nor the names of its contributors + may be used to endorse or promote products derived from this + software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/PixHtLab-Src/Docker/imagen/MANIFEST.in b/PixHtLab-Src/Docker/imagen/MANIFEST.in new file mode 100644 index 0000000000000000000000000000000000000000..1c9f16b117d1b91d3efc667c860f41ba8803bfa3 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/MANIFEST.in @@ -0,0 +1,5 @@ +include README.txt +include LICENSE.txt +include setup.py +recursive-include imagen *.py + diff --git a/PixHtLab-Src/Docker/imagen/README.rst b/PixHtLab-Src/Docker/imagen/README.rst new file mode 100644 index 0000000000000000000000000000000000000000..d12efa94b48a04b216f248ebb9996ebe99d9fae9 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/README.rst @@ -0,0 +1,41 @@ +|BuildStatus|_ |Package|_ |License|_ |Downloads|_ + +ImaGen +====== + +ImaGen is a generic Python library for 0D, 1D, and 2D pattern +distributions. + +Please see `ImaGen's website `_ for +documentation and examples. + + +Installation +============ + +ImaGen requires `Holoviews `_, +`Param `_, and +`NumPy `_. + +If you want to use the image-loading features in imagen.image, you +will also need either `Pillow +`_ (recommended) or `PIL +`_. + +Official releases of ImaGen are available at `PyPI +`_, and can be installed along +with dependencies via ``pip install --user imagen``. More recent +changes can be obtained by cloning the git repository. + + +.. |Package| image:: https://img.shields.io/pypi/v/imagen.svg +.. _Package: https://pypi.python.org/pypi/imagen + +.. |License| image:: https://img.shields.io/pypi/l/imagen.svg +.. _License: https://github.com/pyviz-topics/imagen/blob/master/LICENSE.txt + +.. |BuildStatus| image:: https://travis-ci.org/pyviz-topics/imagen.svg?branch=master +.. _BuildStatus: https://travis-ci.org/pyviz-topics/imagen + +.. |Downloads| image:: https://img.shields.io/pypi/dm/imagen.svg +.. _Downloads: https://pypi.python.org/pypi/imagen diff --git a/PixHtLab-Src/Docker/imagen/build/lib/imagen/__init__.py b/PixHtLab-Src/Docker/imagen/build/lib/imagen/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5965ca118b1d5c2d9d1d7c8069ecef4bc005446e --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/build/lib/imagen/__init__.py @@ -0,0 +1,1552 @@ +""" +Objects capable of generating a two-dimensional array of values. + +Such patterns can be used as input to machine learning, neural +network, or compuatational neuroscience algorithms, or for any other +purpose where a two-dimensional pattern may be needed. Any new +PatternGenerator classes can be derived from these, and can then be +combined with the existing classes easily. +""" + +import sys, os, copy + +# Add param submodule to sys.path +cwd = os.path.abspath(os.path.split(__file__)[0]) +sys.path.insert(0, os.path.join(cwd, '..', 'param')) +sys.path.insert(0, os.path.join(cwd, '..', 'holoviews')) + +import param +from param.version import Version + +__version__ = Version(release=(2,1,0), fpath=__file__, + commit="$Format:%h$", reponame='imagen') + + +import numpy as np +from numpy import pi + +from param.parameterized import ParamOverrides +from param import ClassSelector + +# Imported here so that all PatternGenerators will be in the same package +from .patterngenerator import PatternGenerator, CompositeBase, Composite +from .patterngenerator import Constant, ChannelTransform, ChannelGenerator # pyflakes:ignore (API import) +from .patterngenerator import CorrelateChannels, ComposeChannels # pyflakes:ignore (API import) + + +from holoviews.element import Image # pyflakes:ignore (API import) + +from holoviews.core import SheetCoordinateSystem # pyflakes:ignore (API import) +from holoviews.core import boundingregion, sheetcoords # pyflakes:ignore (API import) + +from .patternfn import gaussian,exponential,gabor,line,disk,ring,\ + sigmoid,arc_by_radian,arc_by_center,smooth_rectangle,float_error_ignore, \ + log_gaussian + +import numbergen +from imagen.transferfn import DivisiveNormalizeL1 + +# Could add a Gradient class, where the brightness varies as a +# function of an equation for a plane. This could be useful as a +# background, or to see how sharp a gradient is needed to get a +# response. + + +class HalfPlane(PatternGenerator): + """ + Constant pattern on in half of the plane, and off in the rest, + with optional Gaussian smoothing. + """ + + smoothing = param.Number(default=0.02,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off.") + + def function(self,p): + if p.smoothing==0.0: + falloff=self.pattern_y*0.0 + else: + with float_error_ignore(): + falloff=np.exp(np.divide(-self.pattern_y*self.pattern_y, + 2*p.smoothing*p.smoothing)) + + return np.where(self.pattern_y>0.0,1.0,falloff) + + +class Gaussian(PatternGenerator): + """ + 2D Gaussian pattern generator. + + The sigmas of the Gaussian are calculated from the size and + aspect_ratio parameters: + + ysigma=size/2 + xsigma=ysigma*aspect_ratio + + The Gaussian is then computed for the given (x,y) values as:: + + exp(-x^2/(2*xsigma^2) - y^2/(2*ysigma^2) + """ + + aspect_ratio = param.Number(default=1/0.31,bounds=(0.0,None),softbounds=(0.0,6.0), + precedence=0.31,doc=""" + Ratio of the width to the height. + Specifically, xsigma=ysigma*aspect_ratio (see size).""") + + size = param.Number(default=0.155,doc=""" + Overall size of the Gaussian, defined by: + exp(-x^2/(2*xsigma^2) - y^2/(2*ysigma^2) + where ysigma=size/2 and xsigma=size/2*aspect_ratio.""") + + def function(self,p): + ysigma = p.size/2.0 + xsigma = p.aspect_ratio*ysigma + + return gaussian(self.pattern_x,self.pattern_y,xsigma,ysigma) + + +class ExponentialDecay(PatternGenerator): + """ + 2D Exponential pattern generator. + + Exponential decay based on distance from a central peak, + i.e. exp(-d), where d is the distance from the center (assuming + size=1.0 and aspect_ratio==1.0). More generally, the size and + aspect ratio determine the scaling of x and y dimensions: + + yscale=size/2 + xscale=yscale*aspect_ratio + + The exponential is then computed for the given (x,y) values as:: + + exp(-sqrt((x/xscale)^2 - (y/yscale)^2)) + """ + + aspect_ratio = param.Number(default=1/0.31,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc="""Ratio of the width to the height.""") + + size = param.Number(default=0.155,doc=""" + Overall scaling of the x and y dimensions.""") + + def function(self,p): + yscale = p.size/2.0 + xscale = p.aspect_ratio*yscale + + return exponential(self.pattern_x,self.pattern_y,xscale,yscale) + + +class SineGrating(PatternGenerator): + """2D sine grating pattern generator.""" + + frequency = param.Number(default=2.4,bounds=(0.0,None),softbounds=(0.0,10.0), + precedence=0.50, doc="Frequency of the sine grating.") + + phase = param.Number(default=0.0,bounds=(0.0,None),softbounds=(0.0,2*pi), + precedence=0.51,doc="Phase of the sine grating.") + + def function(self,p): + """Return a sine grating pattern (two-dimensional sine wave).""" + return 0.5 + 0.5*np.sin(p.frequency*2*pi*self.pattern_y + p.phase) + + + +class Gabor(PatternGenerator): + """2D Gabor pattern generator.""" + + frequency = param.Number(default=2.4,bounds=(0.0,None),softbounds=(0.0,10.0), + precedence=0.50,doc="Frequency of the sine grating component.") + + phase = param.Number(default=0.0,bounds=(0.0,None),softbounds=(0.0,2*pi), + precedence=0.51,doc="Phase of the sine grating component.") + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc= + """ + Ratio of pattern width to height. + The width of the Gaussian component is size*aspect_ratio (see Gaussian). + """) + + size = param.Number(default=0.25,doc=""" + Determines the height of the Gaussian component (see Gaussian).""") + + def function(self,p): + height = p.size/2.0 + width = p.aspect_ratio*height + + return gabor(self.pattern_x,self.pattern_y,width,height, + p.frequency,p.phase) + + +class Line(PatternGenerator): + """2D line pattern generator.""" + + # Hide unused parameters + size = param.Number(precedence=-1.0) + + thickness = param.Number(default=0.006,bounds=(0.0,None),softbounds=(0.0,1.0), + precedence=0.60,doc=""" + Thickness (width) of the solid central part of the line.""") + + enforce_minimal_thickness = param.Boolean(default=False,precedence=0.60, doc=""" + If True, ensure that the line is at least one pixel in width even for + small thicknesses where the line could otherwise fall in between pixel + centers and thus disappear at some orientations.""") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61, doc=""" + Width of the Gaussian fall-off.""") + + + def _pixelsize(self, p): + """Calculate line width necessary to cover at least one pixel on all axes.""" + xpixelsize = 1./float(p.xdensity) + ypixelsize = 1./float(p.ydensity) + return max([xpixelsize,ypixelsize]) + + def _effective_thickness(self, p): + """Enforce minimum thickness based on the minimum pixel size.""" + return max([p.thickness,self._pixelsize(p)]) + + def _count_pixels_on_line(self, y, p): + """Count the number of pixels rendered on this line.""" + h = line(y, self._effective_thickness(p), 0.0) + return h.sum() + + def _minimal_y(self, p): + """ + For the specified y and one offset by half a pixel, return the + one that results in the fewest pixels turned on, so that when + the thickness has been enforced to be at least one pixel, no + extra pixels are needlessly included (which would cause + double-width lines). + """ + y0 = self.pattern_y + y1 = y0 + self._pixelsize(p)/2. + return y0 if self._count_pixels_on_line(y0, p) < self._count_pixels_on_line(y1, p) else y1 + + def function(self,p): + return line( + self.pattern_y if not p.enforce_minimal_thickness else self._minimal_y(p), + p.thickness if not p.enforce_minimal_thickness else self._effective_thickness(p), + p.smoothing) + + + +class Disk(PatternGenerator): + """ + 2D disk pattern generator. + + An elliptical disk can be obtained by adjusting the aspect_ratio + of a circular disk; this transforms a circle into an ellipse by + stretching the circle in the y (vertical) direction. + + The Gaussian fall-off at a point P is an approximation for + non-circular disks, since the point on the ellipse closest to P is + taken to be the same point as the point on the circle before + stretching that was closest to P. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc= + "Ratio of width to height; size*aspect_ratio gives the width of the disk.") + + size = param.Number(default=0.5,doc="Top to bottom height of the disk") + + smoothing = param.Number(default=0.1,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off") + + def function(self,p): + height = p.size + + if p.aspect_ratio==0.0: + return self.pattern_x*0.0 + + return disk(self.pattern_x/p.aspect_ratio,self.pattern_y,height, + p.smoothing) + + +class Ring(PatternGenerator): + """ + 2D ring pattern generator. + + See the Disk class for a note about the Gaussian fall-off. + """ + + thickness = param.Number(default=0.015,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness (line width) of the ring.") + + smoothing = param.Number(default=0.1,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off inside and outside the ring.") + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc= + "Ratio of width to height; size*aspect_ratio gives the overall width.") + + size = param.Number(default=0.5) + + def function(self,p): + height = p.size + if p.aspect_ratio==0.0: + return self.pattern_x*0.0 + + return ring(self.pattern_x/p.aspect_ratio,self.pattern_y,height, + p.thickness,p.smoothing) + + +class OrientationContrast(SineGrating): + """ + Circular pattern for testing responses to differences in contrast. + + The pattern contains a sine grating ring surrounding a sine + grating disk, each with parameters (orientation, size, scale and + offset) that can be changed independently. + """ + + orientationcenter = param.Number(default=0.0,bounds=(0.0,2*pi), doc="Orientation of the center grating.") + orientationsurround = param.Number(default=0.0,bounds=(-pi*2,pi*2), doc="Orientation of the surround grating, either absolute or relative to the central grating.") + surround_orientation_relative = param.Boolean(default=False, doc="Determines whether the surround grating is relative to the central grating.") + sizecenter = param.Number(default=0.5,bounds=(0.0,None),softbounds=(0.0,10.0), doc="Size of the center grating.") + sizesurround = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,10.0), doc="Size of the surround grating.") + scalecenter = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,10.0), doc="Scale of the center grating.") + scalesurround = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,10.0), doc="Scale of the surround grating.") + offsetcenter = param.Number(default=0.0,bounds=(0.0,None),softbounds=(0.0,10.0), doc="Offset of the center grating.") + offsetsurround = param.Number(default=0.0,bounds=(0.0,None),softbounds=(0.0,10.0), doc="Offset of the surround grating.") + smoothing = param.Number(default=0.0,bounds=(0.0,None),softbounds=(0.0,0.5), doc="Width of the Gaussian fall-off inside and outside the ring.") + thickness = param.Number(default=0.3,bounds=(0.0,None),softbounds=(0.0,0.5), doc="Thickness (line width) of the ring.") + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), doc="Ratio of width to height; size*aspect_ratio gives the overall width.") + size = param.Number(default=0.5) + + def __call__(self,**params_to_override): + p = ParamOverrides(self,params_to_override) + input_1=SineGrating(mask_shape=Disk(smoothing=0,size=1.0),phase=p.phase, frequency=p.frequency, + orientation=p.orientationcenter, + scale=p.scalecenter, offset=p.offsetcenter, + x=p.x, y=p.y,size=p.sizecenter) + if p.surround_orientation_relative: + surround_or = p.orientationcenter + p.orientationsurround + else: + surround_or = p.orientationsurround + input_2=SineGrating(mask_shape=Ring(thickness=p.thickness,smoothing=0,size=1.0),phase=p.phase, frequency=p.frequency, + orientation=surround_or, scale=p.scalesurround, offset=p.offsetsurround, + x=p.x, y=p.y, size=p.sizesurround) + + patterns = [input_1(xdensity=p.xdensity,ydensity=p.ydensity,bounds=p.bounds), + input_2(xdensity=p.xdensity,ydensity=p.ydensity,bounds=p.bounds)] + + image_array = np.add.reduce(patterns) + return image_array + + + +class RawRectangle(PatternGenerator): + """ + 2D rectangle pattern generator with no smoothing, for use when + drawing patterns pixel by pixel. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc= + "Ratio of width to height; size*aspect_ratio gives the width of the rectangle.") + + size = param.Number(default=0.5,doc="Height of the rectangle.") + + def function(self,p): + height = p.size + width = p.aspect_ratio*height + return np.bitwise_and(np.abs(self.pattern_x)<=width/2.0, + np.abs(self.pattern_y)<=height/2.0) + + + +class Rectangle(PatternGenerator): + """ + 2D rectangle pattern, with Gaussian smoothing around the + edges. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,6.0), + precedence=0.31,doc= + "Ratio of width to height; size*aspect_ratio gives the width of the rectangle.") + + size = param.Number(default=0.5,doc="Height of the rectangle.") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off outside the rectangle.") + + def function(self,p): + height=p.size + width=p.aspect_ratio*height + + return smooth_rectangle(self.pattern_x, self.pattern_y, + width, height, p.smoothing, p.smoothing) + + + +class Arc(PatternGenerator): + """ + 2D arc pattern generator. + + Draws an arc (partial ring) of the specified size (radius*2), + starting at radian 0.0 and ending at arc_length. The orientation + can be changed to choose other start locations. The pattern is + centered at the center of the ring. + + See the Disk class for a note about the Gaussian fall-off. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,6.0), + precedence=0.31,doc=""" + Ratio of width to height; size*aspect_ratio gives the overall width.""") + + thickness = param.Number(default=0.015,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness (line width) of the ring.") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off inside and outside the ring.") + + arc_length = param.Number(default=pi,bounds=(0.0,None),softbounds=(0.0,2.0*pi), + inclusive_bounds=(True,False),precedence=0.62, doc=""" + Length of the arc, in radians, starting from orientation 0.0.""") + + size = param.Number(default=0.5) + + def function(self,p): + if p.aspect_ratio==0.0: + return self.pattern_x*0.0 + + return arc_by_radian(self.pattern_x/p.aspect_ratio, self.pattern_y, p.size, + (2*pi-p.arc_length, 0.0), p.thickness, p.smoothing) + + +class Curve(Arc): + """ + 2D curve pattern generator. + + Based on Arc, but centered on a tangent point midway through the + arc, rather than at the center of a ring, and with curvature + controlled directly rather than through the overall size of the + pattern. + + Depending on the size_type, the size parameter can control either + the width of the pattern, keeping this constant regardless of + curvature, or the length of the curve, keeping that constant + instead (as for a long thin object being bent). + + Specifically, for size_type=='constant_length', the curvature + parameter determines the ratio of height to width of the arc, with + positive curvature for concave shape and negative for convex. The + size parameter determines the width of the curve. + + For size_type=='constant_width', the curvature parameter + determines the portion of curve radian to 2pi, and the curve + radius is changed accordingly following the formula:: + + size=2pi*radius*curvature + + Thus, the size parameter determines the total length of the + curve. Positive curvature stands for concave shape, and negative + for convex. + + See the Disk class for a note about the Gaussian fall-off. + """ + + # Hide unused parameters + arc_length = param.Number(precedence=-1.0) + aspect_ratio = param.Number(default=1.0, precedence=-1.0) + + size_type = param.ObjectSelector(default='constant_length', + objects=['constant_length','constant_width'],precedence=0.61,doc=""" + For a given size, whether to draw a curve with that total length, + or with that width, keeping it constant as curvature is varied.""") + + curvature = param.Number(default=0.5, bounds=(-0.5, 0.5), precedence=0.62, doc=""" + Ratio of height to width of the arc, with positive value giving + a concave shape and negative value giving convex.""") + + def function(self,p): + return arc_by_center(self.pattern_x/p.aspect_ratio,self.pattern_y, + (p.size,p.size*p.curvature), + (p.size_type=='constant_length'), + p.thickness, p.smoothing) + + + +class SquareGrating(PatternGenerator): + """2D squarewave (symmetric or asymmetric) grating pattern generator.""" + + frequency = param.Number(default=2.4,bounds=(0.0,None),softbounds=(0.0,10.0), + precedence=0.50,doc="Frequency of the square grating.") + + phase = param.Number(default=0.0,bounds=(0.0,None),softbounds=(0.0,2*pi), + precedence=0.51,doc="Phase of the square grating.") + + duty_cycle = param.Number(default=0.5,bounds=(0.0,1.0), + precedence=0.51,doc=""" + The duty cycle is the ratio between the pulse duration (width of the bright bar) + and the period (1/frequency). + The pulse is defined as the time during which the square wave signal is 1 (high).""") + + # We will probably want to add anti-aliasing to this, + # and there might be an easier way to do it than by + # cropping a sine grating. + + def function(self,p): + """ + Return a square-wave grating (alternating black and white bars). + """ + return np.around( + 0.5 + + 0.5*np.sin(pi*(p.duty_cycle-0.5)) + + 0.5*np.sin(p.frequency*2*pi*self.pattern_y + p.phase)) + + +#JABALERT: replace with x%1.0 below +def wrap(lower, upper, x): + """ + Circularly alias the numeric value x into the range [lower,upper). + + Valid for cyclic quantities like orientations or hues. + """ + #I have no idea how I came up with this algorithm; it should be simplified. + # + # Note that Python's % operator works on floats and arrays; + # usually one can simply use that instead. E.g. to wrap array or + # scalar x into 0,2*pi, just use "x % (2*pi)". + range_=upper-lower + return lower + np.fmod(x-lower + 2*range_*(1-np.floor(x/(2*range_))), range_) + + + +class Selector(CompositeBase): + """ + PatternGenerator that selects from a list of other PatternGenerators. + """ + + # CB: needs to have time_fn=None + index = param.Number(default=numbergen.UniformRandom(lbound=0,ubound=1.0,seed=76), + bounds=(-1.0,1.0),precedence=0.20,doc=""" + Index into the list of pattern generators, on a scale from 0 + (start of the list) to 1.0 (end of the list). Typically a + random value or other number generator, to allow a different item + to be selected each time.""") + + + def function(self,p): + """Selects and returns one of the patterns in the list.""" + int_index=int(len(p.generators)*wrap(0,1.0,p.index)) + pg=p.generators[int_index] + + image_array = pg(xdensity=p.xdensity,ydensity=p.ydensity,bounds=p.bounds, + x=p.x+p.size*(pg.x*np.cos(p.orientation)-pg.y*np.sin(p.orientation)), + y=p.y+p.size*(pg.x*np.sin(p.orientation)+pg.y*np.cos(p.orientation)), + orientation=pg.orientation+p.orientation,size=pg.size*p.size, + scale=pg.scale*p.scale,offset=pg.offset+p.offset) + + return image_array + + def get_current_generator(self): + """Return the current generator (as specified by self.index).""" + int_index=int(len(self.generators)*wrap(0,1.0,self.inspect_value('index'))) + return self.generators[int_index] + + def channels(self, use_cached=False, **params_to_override): + """ + Get channel data from the current generator. use_cached is + not supported at the moment, though it must be forced to be + True in the current_generator in order to avoid generating the + same data twice (the first time by self() and the second with + current_generator.channels() ). + """ + default = self(**params_to_override) + current_generator = self.get_current_generator() + + res = current_generator.channels(use_cached=True) + res['default'] = default + + return res + + def num_channels(self): + """ + Get the number of channels in the input generators. + """ + if(self.inspect_value('index') is None): + if(len(self.generators)>0): + return self.generators[0].num_channels() + return 0 + + return self.get_current_generator().num_channels() + + +class OffsetTimeFn(param.Parameterized): + """ + A picklable version of the global time function with a custom offset + and reset period. + """ + + offset = param.Number(default=0, doc=""" + The time offset from which frames are generated given the + supplied pattern.""") + + reset_period = param.Number(default=4,bounds=(0,None),doc=""" + Period between generating each new translation episode.""") + + time_fn = param.Callable(default=param.Dynamic.time_fn,doc=""" + Function to generate the time used as a base for translation.""") + + def __call__(self): + time = self.time_fn() + return self.time_fn.time_type((time // self.reset_period) + self.offset) + + + +class Sweeper(ChannelGenerator): + """ + PatternGenerator that sweeps a supplied PatternGenerator in a + direction perpendicular to its orientation. Each time step, the + supplied PatternGenerator is sweeped further at a fixed speed, and + after reset_period time steps a new pattern is drawn. + """ + generator = param.ClassSelector(PatternGenerator,default=Gaussian(),precedence=0.97, + doc="Pattern to sweep.") + + time_offset = param.Number(default=0, doc=""" + The time offset from which frames are generated given the + supplied pattern.""") + + step_offset = param.Number(default=0, doc=""" + The number of steps to offset the sweeper by.""") + + reset_period = param.Number(default=4,bounds=(0,None),doc=""" + Period between generating each new translation episode.""") + + speed = param.Number(default=2.0/24.0,bounds=(0.0,None),doc=""" + The speed with which the pattern should move, + in sheet coordinates per time_fn unit.""") + + relative_motion_orientation = param.Number(default=pi/2.0,bounds=(0,2*pi),doc=""" + The direction in which the pattern should be moved, relative + to the orientation of the supplied generator""") + + time_fn = param.Callable(default=param.Dynamic.time_fn,doc=""" + Function to generate the time used as a base for translation.""") + + + def num_channels(self): + return self.generator.num_channels() + + + def function(self, p): + motion_time_fn = OffsetTimeFn(offset=p.time_offset, + reset_period=p.reset_period, + time_fn=p.time_fn) + pg = p.generator + pg.set_dynamic_time_fn(motion_time_fn) + motion_orientation = pg.orientation + p.relative_motion_orientation + + step = int(p.time_fn() % p.reset_period) + p.step_offset + + new_x = p.x + p.size * pg.x + new_y = p.y + p.size * pg.y + + try: + #TFALERT: Not sure whether this is needed + if(len(self._channel_data)!=len(pg._channel_data)): + self._channel_data=copy.deepcopy(pg._channel_data) + + # For multichannel pattern generators + for i in range(len(pg._channel_data)): + self._channel_data[i] = pg.channels( + x=new_x + p.speed * step * np.cos(motion_orientation), + y=new_y + p.speed * step * np.sin(motion_orientation), + xdensity=p.xdensity, ydensity=p.ydensity, + bounds=p.bounds, + orientation=pg.orientation + p.orientation, + scale=pg.scale * p.scale, offset=pg.offset + p.offset)[i] + except AttributeError: + pass + + image_array = pg(xdensity=p.xdensity, ydensity=p.ydensity, + bounds=p.bounds, + x=new_x + p.speed * step * np.cos(motion_orientation), + y=new_y + p.speed * step * np.sin(motion_orientation), + orientation=pg.orientation + p.orientation, + scale=pg.scale * p.scale, offset=pg.offset + p.offset) + + return image_array + + + +class Spiral(PatternGenerator): + """ + Archimedean spiral. + Successive turnings of the spiral have a constant separation distance. + + Spiral is defined by polar equation r=size*angle plotted in Gaussian plane. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Ratio of width to height.") + + thickness = param.Number(default=0.02,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness (line width) of the spiral.") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off inside and outside the spiral.") + + turning = param.Number(default=0.05,bounds=(0.01,None),softbounds=(0.01,2.0), + precedence=0.62,doc="Density of turnings; turning*angle gives the actual radius.") + + def function(self,p): + aspect_ratio = p.aspect_ratio + x = self.pattern_x/aspect_ratio + y = self.pattern_y + thickness = p.thickness + gaussian_width = p.smoothing + turning = p.turning + + spacing = turning*2*pi + + distance_from_origin = np.sqrt(x**2+y**2) + distance_from_spiral_middle = np.fmod(spacing + distance_from_origin - turning*np.arctan2(y,x),spacing) + + distance_from_spiral_middle = np.minimum(distance_from_spiral_middle,spacing - distance_from_spiral_middle) + distance_from_spiral = distance_from_spiral_middle - thickness/2.0 + + spiral = 1.0 - np.greater_equal(distance_from_spiral,0.0) + + sigmasq = gaussian_width*gaussian_width + + with float_error_ignore(): + falloff = np.exp(np.divide(-distance_from_spiral*distance_from_spiral, 2.0*sigmasq)) + + return np.maximum(falloff, spiral) + + + +class SpiralGrating(Composite): + """ + Grating pattern made from overlaid spirals. + """ + + parts = param.Integer(default=2,bounds=(1,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Number of parts in the grating.") + + thickness = param.Number(default=0.00,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness (line width) of the spiral.") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off inside and outside the spiral.") + + turning = param.Number(default=0.05,bounds=(0.01,None),softbounds=(0.01,2.0), + precedence=0.62,doc="Density of turnings; turning*angle gives the actual radius.") + + + def function(self, p): + gens = [Spiral(turning=p.turning,smoothing=p.smoothing,thickness=p.thickness, + orientation=i*2*np.pi/p.parts) for i in range(p.parts)] + + return Composite(generators=gens, bounds=p.bounds, orientation=p.orientation, + xdensity=p.xdensity, ydensity=p.ydensity)() + + + +class HyperbolicGrating(PatternGenerator): + """ + Concentric rectangular hyperbolas with Gaussian fall-off which share the same asymptotes. + abs(x^2/a^2 - y^2/a^2) = 1, where a mod size = 0 + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Ratio of width to height.") + + thickness = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness of the hyperbolas.") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off inside and outside the hyperbolas.") + + size = param.Number(default=0.5,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.62,doc="Size as distance of inner hyperbola vertices from the centre.") + + def function(self,p): + aspect_ratio = p.aspect_ratio + x = self.pattern_x/aspect_ratio + y = self.pattern_y + thickness = p.thickness + gaussian_width = p.smoothing + size = p.size + + distance_from_vertex_middle = np.fmod(np.sqrt(np.absolute(x**2 - y**2)),size) + distance_from_vertex_middle = np.minimum(distance_from_vertex_middle,size - distance_from_vertex_middle) + + distance_from_vertex = distance_from_vertex_middle - thickness/2.0 + + hyperbola = 1.0 - np.greater_equal(distance_from_vertex,0.0) + + sigmasq = gaussian_width*gaussian_width + + with float_error_ignore(): + falloff = np.exp(np.divide(-distance_from_vertex*distance_from_vertex, 2.0*sigmasq)) + + return np.maximum(falloff, hyperbola) + + + +class Wedge(PatternGenerator): + """ + A sector of a circle with Gaussian fall-off, with size determining the arc length. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Ratio of width to height.") + + size = param.Number(default=pi/4,bounds=(0.0,None),softbounds=(0.0,2.0*pi), + precedence=0.60,doc="Angular length of the sector, in radians.") + + smoothing = param.Number(default=0.4,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off outside the sector.") + + def function(self,p): + aspect_ratio = p.aspect_ratio + x = self.pattern_x/aspect_ratio + y = self.pattern_y + gaussian_width = p.smoothing + + angle = np.absolute(np.arctan2(y,x)) + half_length = p.size/2 + + radius = 1.0 - np.greater_equal(angle,half_length) + distance = angle - half_length + + sigmasq = gaussian_width*gaussian_width + + with float_error_ignore(): + falloff = np.exp(np.divide(-distance*distance, 2.0*sigmasq)) + + return np.maximum(radius, falloff) + + + +class RadialGrating(Composite): + """ + Grating pattern made from alternating smooth circular segments (pie-shapes). + """ + + parts = param.Integer(default=4,bounds=(1,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Number of parts in the grating.") + + smoothing = param.Number(default=0.8,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc=""" + Width of the Gaussian fall-off outside the sector, scaled by parts.""") + + def function(self, p): + gens = [Wedge(size=1.0/p.parts,smoothing=p.smoothing/p.parts, + orientation=i*2*np.pi/p.parts) for i in range(p.parts)] + + return Composite(generators=gens, bounds=p.bounds, orientation=p.orientation, + xdensity=p.xdensity, ydensity=p.ydensity)() + + +class Asterisk(Composite): + """ + Asterisk-like object composed of radial rectangular lines. + Also makes crosses and tripods. + """ + + parts = param.Integer(default=3,bounds=(1,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Number of parts in the asterisk.") + + thickness = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness of the rectangle.") + + smoothing = param.Number(default=0.015,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off around the rectangles.") + + size = param.Number(default=0.5,bounds=(0.01,None),softbounds=(0.1,2.0), + precedence=0.62,doc="Overall diameter of the pattern.") + + def function(self, p): + o=2*np.pi/p.parts + gens = [Rectangle(orientation=i*o,smoothing=p.smoothing, + aspect_ratio=2*p.thickness/p.size, + size=p.size/2, + x=-p.size/4*np.sin(i*o), + y= p.size/4*np.cos(i*o)) + for i in range(p.parts)] + + return Composite(generators=gens, bounds=p.bounds, orientation=p.orientation, + xdensity=p.xdensity, ydensity=p.ydensity)() + + + +class Angle(Composite): + """ + Angle composed of two line segments. + """ + + thickness = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness of the rectangle.") + + smoothing = param.Number(default=0.015,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off around the rectangles.") + + size = param.Number(default=0.5,bounds=(0.01,None),softbounds=(0.1,2.0), + precedence=0.62,doc="Overall diameter of the pattern, if angle=pi.") + + angle = param.Number(default=pi/4,bounds=(0.0,None),softbounds=(0,pi), + precedence=0.63,doc="Angle between the two line segments.") + + def function(self, p): + gens=[Rectangle(orientation=i*p.angle,smoothing=p.smoothing, + aspect_ratio=p.thickness/p.size,size=p.size, + x=-p.size/2*np.sin(i*p.angle)) + for i in [-1,1]] + + return Composite(generators=gens, bounds=p.bounds, orientation=p.orientation, + xdensity=p.xdensity, ydensity=p.ydensity)() + + + +class ConcentricRings(PatternGenerator): + """ + Concentric rings with linearly increasing radius. + Gaussian fall-off at the edges. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Ratio of width to height.") + + thickness = param.Number(default=0.04,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness (line width) of the ring.") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off inside and outside the rings.") + + size = param.Number(default=0.4,bounds=(0.01,None),softbounds=(0.1,2.0), + precedence=0.62,doc="Radius difference of neighbouring rings.") + + def function(self,p): + aspect_ratio = p.aspect_ratio + x = self.pattern_x/aspect_ratio + y = self.pattern_y + thickness = p.thickness + gaussian_width = p.smoothing + size = p.size + + distance_from_origin = np.sqrt(x**2+y**2) + + distance_from_ring_middle = np.fmod(distance_from_origin,size) + distance_from_ring_middle = np.minimum(distance_from_ring_middle,size - distance_from_ring_middle) + + distance_from_ring = distance_from_ring_middle - thickness/2.0 + + ring = 1.0 - np.greater_equal(distance_from_ring,0.0) + + sigmasq = gaussian_width*gaussian_width + + with float_error_ignore(): + falloff = np.exp(np.divide(-distance_from_ring*distance_from_ring, 2.0*sigmasq)) + + return np.maximum(falloff, ring) + + + +class ArcCentered(Arc): + """ + 2D arc pattern generator (centered at the middle of the arc). + + Draws an arc (partial ring) of the specified size (radius*2), + with middle at radian 0.0 and starting at arc_length/2 and ending + at -arc_length/2. The pattern is centered at the middle of the arc. + + See the Disk class for a note about the Gaussian fall-off. + """ + + def function(self,p): + if p.aspect_ratio==0.0: + return self.pattern_x*0.0 + self.pattern_x -= (1+np.cos(pi-p.arc_length/2))*p.size/4 + + return arc_by_radian((self.pattern_x+p.size/2)/p.aspect_ratio, self.pattern_y, p.size, + (2*pi-p.arc_length/2, p.arc_length/2), p.thickness, p.smoothing) + + +class DifferenceOfGaussians(PatternGenerator): + """ + Two-dimensional difference of Gaussians pattern. + """ + + positive_size = param.Number(default=0.1, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(1), + doc="""Size of the positive region of the pattern.""") + + positive_aspect_ratio = param.Number(default=1.5, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(2), + doc="""Ratio of width to height for the positive region of the pattern.""") + + positive_x = param.Number(default=0.0, bounds=(None,None), softbounds=(-2.0,2.0), precedence=(3), + doc="""X position for the central peak of the positive region.""") + + positive_y = param.Number(default=0.0, bounds=(None,None), softbounds=(-2.0,2.0), precedence=(4), + doc="""Y position for the central peak of the positive region.""") + + + negative_size = param.Number(default=0.3, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(5), + doc="""Size of the negative region of the pattern.""") + + negative_aspect_ratio = param.Number(default=1.5, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(6), + doc="""Ratio of width to height for the negative region of the pattern.""") + + negative_x = param.Number(default=0.0, bounds=(None,None), softbounds=(-2.0,2.0), precedence=(7), + doc="""X position for the central peak of the negative region.""") + + negative_y = param.Number(default=0.0, bounds=(None,None), softbounds=(-2.0,2.0), precedence=(8), + doc="""Y position for the central peak of the negative region.""") + + + def function(self, p): + positive = Gaussian(x=p.positive_x+p.x, y=p.positive_y+p.y, + size=p.positive_size*p.size, aspect_ratio=p.positive_aspect_ratio, + orientation=p.orientation, output_fns=[DivisiveNormalizeL1()]) + + negative = Gaussian(x=p.negative_x+p.x, y=p.negative_y+p.y, + size=p.negative_size*p.size, aspect_ratio=p.negative_aspect_ratio, + orientation=p.orientation, output_fns=[DivisiveNormalizeL1()]) + + return Composite(generators=[positive,negative], operator=np.subtract, + xdensity=p.xdensity, ydensity=p.ydensity, bounds=p.bounds)() + + + +class Sigmoid(PatternGenerator): + """ + Two-dimensional sigmoid pattern, dividing the plane into positive + and negative halves with a smoothly sloping transition between + them. + """ + + slope = param.Number(default=10.0, bounds=(None,None), softbounds=(-100.0,100.0), + doc="""Parameter controlling the smoothness of the transition + between the two regions; high values give a sharp transition.""") + + + def function(self, p): + return sigmoid(self.pattern_y, p.slope) + + + +class SigmoidedDoG(PatternGenerator): + """ + Sigmoid multiplicatively combined with a difference of Gaussians, + such that one part of the plane can be the mirror image of the other. + """ + + size = param.Number(default=0.5) + + positive_size = param.Number(default=0.15, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(1), + doc="""Size of the positive Gaussian pattern.""") + + positive_aspect_ratio = param.Number(default=2.0, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(2), + doc="""Ratio of width to height for the positive Gaussian pattern.""") + + negative_size = param.Number(default=0.25, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(3), + doc="""Size of the negative Gaussian pattern.""") + + negative_aspect_ratio = param.Number(default=1.0, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(4), + doc="""Ratio of width to height for the negative Gaussian pattern.""") + + sigmoid_slope = param.Number(default=10.0, bounds=(None,None), softbounds=(-100.0,100.0), precedence=(5), + doc="""Parameter controlling the smoothness of the transition between the two regions; + high values give a sharp transition.""") + + sigmoid_position = param.Number(default=0.0, bounds=(None,None), softbounds=(-1.0,1.0), precedence=(6), + doc="""X position of the transition between the two regions.""") + + + def function(self, p): + diff_of_gaussians = DifferenceOfGaussians(positive_x=p.x, positive_y=p.y, negative_x=p.x, negative_y=p.y, + positive_size=p.positive_size*p.size, positive_aspect_ratio=p.positive_aspect_ratio, + negative_size=p.negative_size*p.size, negative_aspect_ratio=p.negative_aspect_ratio) + + sigmoid = Sigmoid(slope=p.sigmoid_slope, orientation=p.orientation+pi/2, x=p.x+p.sigmoid_position) + + return Composite(generators=[diff_of_gaussians, sigmoid], bounds=p.bounds, + operator=np.multiply, xdensity=p.xdensity, ydensity=p.ydensity)() + + + +class LogGaussian(PatternGenerator): + """ + 2D Log Gaussian pattern generator allowing standard gaussian + patterns but with the added advantage of movable peaks. + + The spread governs decay rates from the peak of the Gaussian, + mathematically this is the sigma term. + + The center governs the peak position of the Gaussian, + mathematically this is the mean term. + """ + + aspect_ratio = param.Number(default=0.5, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,1.0), + doc="""Ratio of the pattern's width to height.""") + + x_shape = param.Number(default=0.8, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,5.0), + doc="""The length of the tail along the x axis.""") + + y_shape = param.Number(default=0.35, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,5.0), + doc="""The length of the tail along the y axis.""") + + + def __call__(self, **params_to_override): + """ + Call the subclass's 'function' method on a rotated and scaled + coordinate system. + + Creates and fills an array with the requested pattern. If + called without any params, uses the values for the Parameters + as currently set on the object. Otherwise, any params + specified override those currently set on the object. + """ + p = ParamOverrides(self, params_to_override) + + self._setup_xy(p) + fn_result = self.function(p) + self._apply_mask(p, fn_result) + + scale_factor = p.scale / np.max(fn_result) + result = scale_factor*fn_result + p.offset + + for of in p.output_fns: + of(result) + + return result + + + def _setup_xy(self, p): + """ + Produce pattern coordinate matrices from the bounds and + density (or rows and cols), and transforms them according to + x, y, and orientation. + """ + self.debug("bounds=%s, xdensity=%s, ydensity=%s, x=%s, y=%s, orientation=%s",p.bounds, p.xdensity, p.ydensity, p.x, p.y, p.orientation) + + x_points,y_points = SheetCoordinateSystem(p.bounds, p.xdensity, p.ydensity).sheetcoordinates_of_matrixidx() + + self.pattern_x, self.pattern_y = self._create_and_rotate_coordinate_arrays(x_points-p.x, y_points-p.y, p) + + + def _create_and_rotate_coordinate_arrays(self, x, y, p): + """ + Create pattern matrices from x and y vectors, and rotate + them to the specified orientation. + """ + + if p.aspect_ratio == 0 or p.size == 0: + x = x * 0.0 + y = y * 0.0 + else: + x = (x*10.0) / (p.size*p.aspect_ratio) + y = (y*10.0) / p.size + + offset = np.exp(p.size) + pattern_x = np.add.outer(np.sin(p.orientation)*y, np.cos(p.orientation)*x) + offset + pattern_y = np.subtract.outer(np.cos(p.orientation)*y, np.sin(p.orientation)*x) + offset + + np.clip(pattern_x, 0, np.Infinity, out=pattern_x) + np.clip(pattern_y, 0, np.Infinity, out=pattern_y) + + return pattern_x, pattern_y + + + def function(self, p): + return log_gaussian(self.pattern_x, self.pattern_y, p.x_shape, p.y_shape, p.size) + + + +class SigmoidedDoLG(PatternGenerator): + """ + Sigmoid multiplicatively combined with a difference of Log + Gaussians, such that one part of the plane can be the mirror image + of the other, and the peaks of the gaussians are movable. + """ + + size = param.Number(default=1.5) + + + positive_size = param.Number(default=0.5, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,10.0), + doc="""Size of the positive LogGaussian pattern.""") + + positive_aspect_ratio = param.Number(default=0.5, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,1.0), + doc="""Ratio of width to height for the positive LogGaussian pattern.""") + + positive_x_shape = param.Number(default=0.8, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,5.0), + doc="""The length of the tail along the x axis for the positive LogGaussian pattern.""") + + positive_y_shape = param.Number(default=0.35, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,5.0), + doc="""The length of the tail along the y axis for the positive LogGaussian pattern.""") + + positive_scale = param.Number(default=1.5, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,10.0), + doc="""Multiplicative scale for the positive LogGaussian pattern.""") + + + negative_size = param.Number(default=0.8, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,10.0), + doc="""Size of the negative LogGaussian pattern.""") + + negative_aspect_ratio = param.Number(default=0.3, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,1.0), + doc="""Ratio of width to height for the negative LogGaussian pattern.""") + + negative_x_shape = param.Number(default=0.8, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,5.0), + doc="""The length of the tail along the x axis for the negative LogGaussian pattern.""") + + negative_y_shape = param.Number(default=0.35, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,5.0), + doc="""The length of the tail along the y axis for the negative LogGaussian pattern.""") + + negative_scale = param.Number(default=1.0, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,10.0), + doc="""Multiplicative scale for the negative LogGaussian pattern.""") + + + sigmoid_slope = param.Number(default=50.0, bounds=(None,None), softbounds=(-100.0,100.0), + doc="""Parameter controlling the smoothness of the transition between the two regions; + high values give a sharp transition.""") + + sigmoid_position = param.Number(default=0.05, bounds=(None,None), softbounds=(-1.0,1.0), + doc="""X position of the transition between the two regions.""") + + + def function(self, p): + positive = LogGaussian(size=p.positive_size*p.size, aspect_ratio=p.positive_aspect_ratio, x_shape=p.positive_x_shape, + y_shape=p.positive_y_shape, scale=p.positive_scale*p.scale, orientation=p.orientation, x=p.x, y=p.y, + output_fns=[]) + + negative = LogGaussian(size=p.negative_size*p.size, aspect_ratio=p.negative_aspect_ratio, x_shape=p.negative_x_shape, + y_shape=p.negative_y_shape, scale=p.negative_scale*p.scale, orientation=p.orientation, x=p.x, y=p.y, + output_fns=[]) + + diff_of_log_gaussians = Composite(generators=[positive, negative], operator=np.subtract, + xdensity=p.xdensity, ydensity=p.ydensity, bounds=p.bounds) + + sigmoid = Sigmoid(x=p.x+p.sigmoid_position, slope=p.sigmoid_slope, orientation=p.orientation+pi/2.0) + + return Composite(generators=[diff_of_log_gaussians, sigmoid], bounds=p.bounds, + operator=np.multiply, xdensity=p.xdensity, ydensity=p.ydensity, output_fns=[DivisiveNormalizeL1()])() + + + +class TimeSeries(param.Parameterized): + """ + Generic class to return intervals of a discretized time series. + """ + + time_series = param.Array(default=np.repeat(np.array([0,1]),50), + doc="""An array of numbers that form a series.""") + + sample_rate = param.Integer(default=50, allow_None=True, bounds=(0,None), inclusive_bounds=(False,False), softbounds=(0,44100), + doc="""The number of samples taken per second to form the series.""") + + seconds_per_iteration = param.Number(default=0.1, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,1.0), + doc="""Number of seconds advanced along the time series on each iteration.""") + + interval_length = param.Number(default=0.1, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,1.0), + doc="""The length of time in seconds to be returned on each iteration.""") + + repeat = param.Boolean(default=True, + doc="""Whether the signal loops or terminates once it reaches its end.""") + + + def __init__(self, **params): + super(TimeSeries, self).__init__(**params) + self._next_interval_start = 0 + + if self.seconds_per_iteration > self.interval_length: + self.warning("Seconds per iteration > interval length, some signal will be skipped.") + + + def append_signal(self, new_signal): + self.time_series = np.hstack((self.time_series, new_signal)) + + + def extract_specific_interval(self, interval_start, interval_end): + """ + Overload if special behaviour is required when a series ends. + """ + + interval_start = int(interval_start) + interval_end = int(interval_end) + + if interval_start >= interval_end: + raise ValueError("Requested interval's start point is past the requested end point.") + + elif interval_start > self.time_series.size: + if self.repeat: + interval_end = interval_end - interval_start + interval_start = 0 + else: + raise ValueError("Requested interval's start point is past the end of the time series.") + + if interval_end < self.time_series.size: + interval = self.time_series[interval_start:interval_end] + + else: + requested_interval_size = interval_end - interval_start + remaining_signal = self.time_series[interval_start:self.time_series.size] + + if self.repeat: + if requested_interval_size < self.time_series.size: + self._next_interval_start = requested_interval_size-remaining_signal.size + interval = np.hstack((remaining_signal, self.time_series[0:self._next_interval_start])) + + else: + repeated_signal = np.repeat(self.time_series, np.floor(requested_interval_size/self.time_series.size)) + self._next_interval_start = requested_interval_size % self.time_series.size + + interval = (np.hstack((remaining_signal, repeated_signal)))[0:requested_interval_size] + + else: + self.warning("Returning last interval of the time series.") + self._next_interval_start = self.time_series.size + 1 + + samples_per_interval = self.interval_length*self.sample_rate + interval = np.hstack((remaining_signal, np.zeros(samples_per_interval-remaining_signal.size))) + + return interval + + + def __call__(self): + interval_start = self._next_interval_start + interval_end = int(np.floor(interval_start + self.interval_length*self.sample_rate)) + + self._next_interval_start += int(np.floor(self.seconds_per_iteration*self.sample_rate)) + return self.extract_specific_interval(interval_start, interval_end) + + + +def generate_sine_wave(duration, frequency, sample_rate): + time_axis = np.linspace(0.0, duration, int(duration*sample_rate)) + return np.sin(2.0*pi*frequency * time_axis) + + + +class TimeSeriesParam(ClassSelector): + """ + Parameter whose value is a TimeSeries object. + """ + + def __init__(self, **params): + super(TimeSeriesParam, self).__init__(TimeSeries, **params) + + + +class PowerSpectrum(PatternGenerator): + """ + Outputs the spectral density of a rolling interval of the input + signal each time it is called. Over time, the results could be + arranged into a spectrogram, e.g. for an audio signal. + """ + + x = param.Number(precedence=(-1)) + y = param.Number(precedence=(-1)) + size = param.Number(precedence=(-1)) + orientation = param.Number(precedence=(-1)) + + scale = param.Number(default=0.01, bounds=(0,None), inclusive_bounds=(False,False), softbounds=(0.001,1000), + doc="""The amount by which to scale amplitudes by. This is useful if we want to rescale to say a range [0:1]. + + Note: Constant scaling is preferable to dynamic scaling so as not to artificially ramp down loud sounds while ramping + up hiss and other background interference.""") + + signal = TimeSeriesParam(default=TimeSeries(time_series=generate_sine_wave(0.1,5000,20000), sample_rate=20000), + doc="""A TimeSeries object on which to perfom the Fourier Transform.""") + + min_frequency = param.Integer(default=0, bounds=(0,None), inclusive_bounds=(True,False), softbounds=(0,10000), + doc="""Smallest frequency for which to return an amplitude.""") + + max_frequency = param.Integer(default=9999, bounds=(0,None), inclusive_bounds=(False,False), softbounds=(0,10000), + doc="""Largest frequency for which to return an amplitude.""") + + windowing_function = param.Parameter(default=None, + doc="""This function is multiplied with the current interval, i.e. the most recent portion of the + waveform interval of a signal, before performing the Fourier transform. It thus shapes the interval, + which is otherwise always rectangular. + + The function chosen here dictates the tradeoff between resolving comparable signal strengths with similar + frequencies, and resolving disparate signal strengths with dissimilar frequencies. + + numpy provides a number of options, e.g. bartlett, blackman, hamming, hanning, kaiser; see + http://docs.scipy.org/doc/numpy/reference/routines.window.html + + You may also supply your own.""") + + + def __init__(self, **params): + super(PowerSpectrum, self).__init__(**params) + + self._previous_min_frequency = self.min_frequency + self._previous_max_frequency = self.max_frequency + + + def _create_frequency_indices(self): + if self.min_frequency >= self.max_frequency: + raise ValueError("PowerSpectrum: min frequency must be lower than max frequency.") + + # calculate the discrete frequencies possible for the given sample rate. + sample_rate = self.signal.sample_rate + available_frequency_range = np.fft.fftfreq(sample_rate, d=1.0/sample_rate)[0:sample_rate/2] + + if not available_frequency_range.min() <= self.min_frequency or not available_frequency_range.max() >= self.max_frequency: + raise ValueError("Specified frequency interval [%s:%s] is unavailable, available range is [%s:%s]. Adjust to these frequencies or modify the sample rate of the TimeSeries object." %(self.min_frequency, self.max_frequency, available_frequency_range.min(), available_frequency_range.max())) + + min_freq = np.nonzero(available_frequency_range >= self.min_frequency)[0][0] + max_freq = np.nonzero(available_frequency_range <= self.max_frequency)[0][-1] + + self._set_frequency_spacing(min_freq, max_freq) + + + def _set_frequency_spacing(self, min_freq, max_freq): + """ + Frequency spacing to use, i.e. how to map the available + frequency range to the discrete sheet rows. + + NOTE: We're calculating the spacing of a range between the + highest and lowest frequencies, the actual segmentation and + averaging of the frequencies to fit this spacing occurs in + _getAmplitudes(). + + This method is here solely to provide a minimal overload if + custom spacing is required. + """ + + self.frequency_spacing = np.linspace(min_freq, max_freq, num=self._sheet_dimensions[0]+1, endpoint=True) + + + def _get_row_amplitudes(self): + """ + Perform a real Discrete Fourier Transform (DFT; implemented + using a Fast Fourier Transform algorithm, FFT) of the current + sample from the signal multiplied by the smoothing window. + + See numpy.rfft for information about the Fourier transform. + """ + + signal_interval = self.signal() + sample_rate = self.signal.sample_rate + + # A signal window *must* span one sample rate + signal_window = np.tile(signal_interval, int(np.ceil(1.0/self.signal.interval_length))) + + if self.windowing_function: + smoothed_window = signal_window[0:sample_rate] * self.windowing_function(sample_rate) + else: + smoothed_window = signal_window[0:sample_rate] + + amplitudes = (np.abs(np.fft.rfft(smoothed_window))[0:sample_rate/2] + self.offset) * self.scale + + for index in range(0, self._sheet_dimensions[0]-2): + start_frequency = self.frequency_spacing[index] + end_frequency = self.frequency_spacing[index+1] + + normalisation_factor = end_frequency - start_frequency + if normalisation_factor == 0: + amplitudes[index] = amplitudes[start_frequency] + else: + amplitudes[index] = np.sum(amplitudes[int(start_frequency):int(end_frequency)]) / normalisation_factor + + return np.flipud(amplitudes[0:self._sheet_dimensions[0]].reshape(-1,1)) + + + def set_matrix_dimensions(self, bounds, xdensity, ydensity): + super(PowerSpectrum, self).set_matrix_dimensions(bounds, xdensity, ydensity) + + self._sheet_dimensions = SheetCoordinateSystem(bounds, xdensity, ydensity).shape + self._create_frequency_indices() + + + def _shape_response(self, row_amplitudes): + if self._sheet_dimensions[1] > 1: + row_amplitudes = np.repeat(row_amplitudes, self._sheet_dimensions[1], axis=1) + + return row_amplitudes + + + def __call__(self): + if self._previous_min_frequency != self.min_frequency or self._previous_max_frequency != self.max_frequency: + self._previous_min_frequency = self.min_frequency + self._previous_max_frequency = self.max_frequency + self._create_frequency_indices() + + return self._shape_response(self._get_row_amplitudes()) + + + +class Spectrogram(PowerSpectrum): + """ + Extends PowerSpectrum to provide a temporal buffer, yielding a 2D + representation of a fixed-width spectrogram. + """ + + min_latency = param.Integer(default=0, precedence=1, + bounds=(0,None), inclusive_bounds=(True,False), softbounds=(0,1000), + doc="""Smallest latency (in milliseconds) for which to return amplitudes.""") + + max_latency = param.Integer(default=500, precedence=2, + bounds=(0,None), inclusive_bounds=(False,False), softbounds=(0,1000), + doc="""Largest latency (in milliseconds) for which to return amplitudes.""") + + + def __init__(self, **params): + super(Spectrogram, self).__init__(**params) + + self._previous_min_latency = self.min_latency + self._previous_max_latency = self.max_latency + + + def _shape_response(self, new_column): + + millisecs_per_iteration = int(self.signal.seconds_per_iteration * 1000) + + if millisecs_per_iteration > self.max_latency: + self._spectrogram[0:,0:] = new_column + else: + # Slide old values along, add new data to left hand side. + self._spectrogram[0:, millisecs_per_iteration:] = self._spectrogram[0:, 0:self._spectrogram.shape[1]-millisecs_per_iteration] + self._spectrogram[0:, 0:millisecs_per_iteration] = new_column + + sheet_representation = np.zeros(self._sheet_dimensions) + + for column in range(0,self._sheet_dimensions[1]): + start_latency = int(self._latency_spacing[column]) + end_latency = int(self._latency_spacing[column+1]) + + normalisation_factor = end_latency - start_latency + if normalisation_factor > 1: + sheet_representation[0:, column] = np.sum(self._spectrogram[0:, start_latency:end_latency], axis=1) / normalisation_factor + else: + sheet_representation[0:, column] = self._spectrogram[0:, start_latency] + + return sheet_representation + + + def set_matrix_dimensions(self, bounds, xdensity, ydensity): + super(Spectrogram, self).set_matrix_dimensions(bounds, xdensity, ydensity) + self._create_latency_indices() + + + def _create_latency_indices(self): + if self.min_latency >= self.max_latency: + raise ValueError("Spectrogram: min latency must be lower than max latency.") + + self._latency_spacing = np.floor(np.linspace(self.min_latency, self.max_latency, num=self._sheet_dimensions[1]+1, endpoint=True)) + self._spectrogram = np.zeros([self._sheet_dimensions[0],self.max_latency]) + + + def __call__(self): + if self._previous_min_latency != self.min_latency or self._previous_max_latency != self.max_latency: + self._previous_min_latency = self.min_latency + self._previous_max_latency = self.max_latency + self._create_latency_indices() + + return super(Spectrogram, self).__call__() + + + + +_public = list(set([_k for _k,_v in locals().items() if isinstance(_v,type) and issubclass(_v,PatternGenerator)])) +__all__ = _public + ["image", "random", "patterncoordinator", "boundingregion", "sheetcoords"] +# Should avoid loading audio.py and other modules that rely on external +# libraries that might not be present on this system. diff --git a/PixHtLab-Src/Docker/imagen/build/lib/imagen/audio.py b/PixHtLab-Src/Docker/imagen/build/lib/imagen/audio.py new file mode 100644 index 0000000000000000000000000000000000000000..8031c97a36cccebb9e999be19da07c0935ea46e7 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/build/lib/imagen/audio.py @@ -0,0 +1,524 @@ +""" +Pattern generators for audio signals. +""" + + +import param +import os + +from . import TimeSeries, Spectrogram, PowerSpectrum + +from numpy import arange, array, ceil, complex64, cos, exp, fft, flipud, \ + float64, floor, hanning, hstack, log, log10, logspace, multiply, \ + nonzero, ones, pi, reshape, shape, size, sqrt, sum, tile, zeros + +try: + import scikits.audiolab as audiolab + +except ImportError: + param.Parameterized().warning("audio.py classes will not be usable because scikits.audiolab is not available.") + + + +class AudioFile(TimeSeries): + """ + Requires an audio file in any format accepted by audiolab (wav, aiff, flac). + """ + + time_series = param.Array(precedence=(-1)) + sample_rate = param.Number(precedence=(-1)) + + filename = param.Filename(default='sounds/complex/daisy.wav', doc=""" + File path (can be relative to Param's base path) to an audio file. + The audio can be in any format accepted by audiolab, e.g. WAV, AIFF, or FLAC.""") + + precision = param.Parameter(default=float64, doc=""" + The float precision to use for loaded audio files.""") + + + def __init__(self, **params): + super(AudioFile, self).__init__(**params) + self._load_audio_file() + + + def _load_audio_file(self): + source = audiolab.Sndfile(self.filename, 'r') + + # audiolab scales the range by the bit depth automatically so the dynamic range is now [-1.0, 1.0] + # we rescale it to the range [0.0, 1.0] + self.time_series = (source.read_frames(source.nframes, dtype=self.precision) + 1) / 2 + self.sample_rate = source.samplerate + + + +class AudioFolder(AudioFile): + """ + Returns a rolling spectrogram, i.e. the spectral density over time + of a rolling window of the input audio signal, for all files in the + specified folder. + """ + + filename = param.Filename(precedence=(-1)) + + folderpath = param.Foldername(default='sounds/sine_waves/normalized', + doc="""Folder path (can be relative to Param's base path) to a + folder containing audio files. The audio can be in any format accepted + by audiolab, i.e. WAV, AIFF, or FLAC.""") + + gap_between_sounds = param.Number(default=0.0, bounds=(0.0,None), + doc="""The gap in seconds to insert between consecutive soundfiles.""") + + + def __init__(self, **params): + super(AudioFolder, self).__init__(**params) + self._load_audio_folder() + + + def _load_audio_folder(self): + folder_contents = os.listdir(self.folderpath) + self.sound_files = [] + + for file in folder_contents: + if file[-4:]==".wav" or file[-3:]==".wv" or file[-5:]==".aiff" or file[-4:]==".aif" or file[-5:]==".flac": + self.sound_files.append(self.folderpath + "/" + file) + + self.filename=self.sound_files[0] + self._load_audio_file() + self.next_file = 1 + + + def extract_specific_interval(self, interval_start, interval_end): + """ + Overload if special behaviour is required when a series ends. + """ + + interval_start = int(interval_start) + interval_end = int(interval_end) + + if interval_start >= interval_end: + raise ValueError("Requested interval's start point is past the requested end point.") + + elif interval_start > self.time_series.size: + if self.repeat: + interval_end = interval_end - interval_start + interval_start = 0 + else: + raise ValueError("Requested interval's start point is past the end of the time series.") + + if interval_end < self.time_series.size: + interval = self.time_series[interval_start:interval_end] + + else: + requested_interval_size = interval_end - interval_start + remaining_signal = self.time_series[interval_start:self.time_series.size] + + if self.next_file == len(self.sound_files) and self.repeat: + self.next_file = 0 + + if self.next_file < len(self.sound_files): + next_source = audiolab.Sndfile(self.sound_files[self.next_file], 'r') + self.next_file += 1 + + if next_source.samplerate != self.sample_rate: + raise ValueError("All sound files must be of the same sample rate") + + if self.gap_between_sounds > 0: + remaining_signal = hstack((remaining_signal, zeros(int(self.gap_between_sounds*self.sample_rate), dtype=self.precision))) + + self.time_series = hstack((remaining_signal, next_source.read_frames(next_source.nframes, dtype=self.precision))) + + interval = self.time_series[0:requested_interval_size] + self._next_interval_start = requested_interval_size + + else: + self.warning("Returning last interval of the time series.") + self._next_interval_start = self.time_series.size + 1 + + samples_per_interval = self.interval_length*self.sample_rate + interval = hstack((remaining_signal, zeros(samples_per_interval-remaining_signal.size))) + + return interval + + + +class LogSpectrogram(Spectrogram): + """ + Extends Spectrogram to provide a response over an octave scale. + """ + + log_base = param.Integer(default=2, bounds=(0.0,None), + doc="""The base of the logarithm used to generate logarithmic frequency spacing.""") + + + def _get_row_amplitudes(self): + signal_interval = self.signal() + sample_rate = self.signal.sample_rate + + # A signal window *must* span one sample rate + signal_window = tile(signal_interval, ceil(1.0/self.signal.interval_length)) + + if self.windowing_function: + smoothed_window = signal_window[0:sample_rate] * self.windowing_function(sample_rate) + else: + smoothed_window = signal_window[0:sample_rate] + + amplitudes = (abs(fft.rfft(smoothed_window))[0:sample_rate/2] + self.offset) * self.scale + + for index in range(0, self._sheet_dimensions[0]-2): + start_frequency = self.frequency_spacing[index] + end_frequency = self.frequency_spacing[index+1] + + normalisation_factor = nonzero(amplitudes[start_frequency:end_frequency])[0].size + if normalisation_factor == 0: + amplitudes[index] = 0 + else: + amplitudes[index] = sum(amplitudes[start_frequency:end_frequency]) / normalisation_factor + + return flipud(amplitudes[0:self._sheet_dimensions[0]].reshape(-1,1)) + + + def _set_frequency_spacing(self, min_freq, max_freq): + min_frequency = log10(min_freq+1) / log10(self.log_base) + max_frequency = log10(max_freq) / log10(self.log_base) + + self.frequency_spacing = logspace(min_frequency, max_frequency, + num=self._sheet_dimensions[0]+1, endpoint=True, base=self.log_base) + + + +class ModulatedLogSpectrogram(LogSpectrogram): + """ + Extends OctaveSpectrogram with a simple model of outer ear + amplification. One can set both the range to amplify and the + amount. + """ + + lower_freq_bound = param.Number(default=1000.0, bounds=(0.0,None), + doc="""The lower bound of the frequency range to be modulated.""") + + upper_freq_bound = param.Number(default=7000.0, bounds=(0.0,None), + doc="""The upper bound of the frequency range to be modulated.""") + + modulation_function = param.Parameter(default=hanning, + doc="""The function by which to modulate the signal between the + specified frequency range. + + The default (hanning) multiplies a section of the signal by a + hanning window.""") + + + def __init__(self, **params): + super(ModulatedLogSpectrogram, self).__init__(**params) + + if self.lower_freq_bound > self.upper_freq_bound: + raise ValueError("Modulation frequency lower bound must be less than the upper bound.") + + + def set_matrix_dimensions(self, bounds, xdensity, ydensity): + super(ModulatedLogSpectrogram, self).set_matrix_dimensions(bounds, xdensity, ydensity) + + self._modulation_start_index = nonzero(self.frequency_spacing >= self.lower_freq_bound)[0][0] + self._modulation_end_index = nonzero(self.frequency_spacing >= self.upper_freq_bound)[0][0] + + self._modulation = self.modulation_function(self._modulation_end_index-self._modulation_start_index) + self._modulation = reshape(self._modulation, [-1,1]) + + + def _shape_response(self, new_column): + if self.amplify_by_percentage > 0: + if (self.lower_freq_bound < self.min_frequency) or (self.lower_freq_bound > self.max_frequency): + raise ValueError("Lower bound of frequency to amplify is outside the global frequency range.") + + elif (self.upper_freq_bound < self.min_frequency) or (self.upper_freq_bound > self.max_frequency): + raise ValueError("Upper bound of frequency to amplify is outside the global frequency range.") + + else: + new_column[self._modulation_start_index:self._modulation_end_index] *= self._modulation + + return super(ModulatedLogSpectrogram, self)._shape_response(new_column) + + + +class LyonsCochlearModel(PowerSpectrum): + """ + Outputs a cochlear decomposition as a set of frequency responses of linear + band-pass filters. Employs Lyons Cochlear Model to do so. + + R. F. Lyon, "A computational model of filtering, detection and compression + in the cochlea." in Proc. of the IEEE Int. Conf. Acoust., Speech, Signal + Processing, Paris, France, May 1982. + + Specific implementation details can be found in: + + Malcolm Slaney, "Lyon's Cochlear Model, in Advanced Technology Group, + Apple Technical Report #13", 1988. + """ + + signal = param.Parameter(default=None, doc=""" + A TimeSeries object to be fed to the model. + + This can be any kind of signal, be it from audio files or live + from a mic, as long as the values conform to a TimeSeries. + """) + + quality_factor = param.Number(default=8.0, doc=""" + Quality factor controls the bandwidth of each cochlear filter. + + The bandwidth of each cochlear filter is a function of its + center frequency. At high frequencies the bandwidth is + approximately equal to the center frequency divided by a + quality constant (quality_factor). At lower frequncies the + bandwidth approaches a constant given by: 1000/quality_factor. + """) + + stage_overlap_factor = param.Number(default=4.0, doc=""" + The degree of overlap between filters. + + Successive filter stages are overlapped by a fraction of their + bandwidth. The number is arbitrary but smaller numbers lead to + more computations. We currently overlap 4 stages within the + bandpass region of any one filter. + """) + + precision = param.Parameter(default=float64, doc=""" + The float precision to use when calculating ear stage filters.""") + + + def __init__(self, **params): + super(LyonsCochlearModel, self).__init__(**params) + + # Hardwired Parameters specific to model, which is to say changing + # them without knowledge of the mathematics of the model is a bad idea. + self.sample_rate = self.signal.sample_rate + self.half_sample_rate = float(self.sample_rate/2.0) + self.quart_sample_rate = float(self.half_sample_rate/2.0) + + self.ear_q = float(self.quality_factor) + self.ear_step_factor = float(1.0/self.stage_overlap_factor) + + self.ear_break_f = float(1000.0) + self.ear_break_squared = self.ear_break_f*self.ear_break_f + + self.ear_preemph_corner_f = float(300.0) + self.ear_zero_offset = float(1.5) + self.ear_sharpness = float(5.0) + + self._num_of_channels = self._num_of_channels() + self._generateCochlearFilters() + + + def _ear_bandwidth(self, cf): + return sqrt(cf*cf + self.ear_break_squared) / self.ear_q + + + def _max_frequency(self): + bandwidth_step_max_f = self._ear_bandwidth(self.half_sample_rate) * self.ear_step_factor + return self.half_sample_rate + bandwidth_step_max_f - bandwidth_step_max_f*self.ear_zero_offset + + + def _num_of_channels(self): + min_f = self.ear_break_f / sqrt(4.0*self.ear_q*self.ear_q - 1.0) + channels = log(self.max_f_calc) - log(min_f + sqrt(min_f*min_f + self.ear_break_squared)) + + return int(floor(self.ear_q*channels/self.ear_step_factor)) + + + def _calc_centre_frequencies_till(self, channel_index): + if (self.centre_frequencies[channel_index] > 0): + return self.centre_frequencies[channel_index] + else: + step = self._calc_centre_frequencies_till(channel_index-1) + channel_cf = step - self.ear_step_factor*self._ear_bandwidth(step) + self.centre_frequencies[channel_index] = channel_cf + + return channel_cf + + + def _evaluate_filters_for_frequencies(self, filters, frequencies): + Zs = exp(2j*pi*frequencies/self.sample_rate) + Z_squareds = Zs * Zs + + zeros = ones((shape(frequencies)[0], shape(filters[0])[0], 3), dtype=complex64) + zeros[:,:,2] = filters[0][:,2] * Z_squareds + zeros[:,:,1] = filters[0][:,1] * Zs + zeros[:,:,0] = filters[0][:,0] + zeros = sum(zeros, axis=2) + + poles = ones((shape(frequencies)[0], shape(filters[1])[0], 3), dtype=complex64) + poles[:,:,2] = filters[1][:,2] * Z_squareds + poles[:,:,1] = filters[1][:,1] * Zs + poles[:,:,0] = filters[1][:,0] + poles = sum(poles, axis=2) + + return zeros / poles + + + # a frequency and gain are specified so that the resulting filter can + # be normalized to have any desired gain at a specified frequency. + def _make_filters(self, zeros, poles, f, desired_gains): + desired_gains = reshape(desired_gains,[size(desired_gains),1]) + + unit_gains = self._evaluate_filters_for_frequencies([zeros,poles], f) + unit_gains = reshape(unit_gains,[size(unit_gains),1]) + + return [zeros*desired_gains, poles*unit_gains] + + + def _frequency_responses(self, evaluated_filters): + evaluated_filters[evaluated_filters==0] = 1.0 + return 20.0 * log10(abs(evaluated_filters)) + + + def _specific_filter(self, x2_coefficient, x_coefficient, constant): + return array([[x2_coefficient,x_coefficient,constant], ], dtype=self.precision) + + + def _first_order_filter_from_corner(self, corner_f): + polynomial = zeros((1,3), dtype=self.precision) + polynomial[:,0] = -exp(-2.0*pi*corner_f/self.sample_rate) + polynomial[:,1] = 1.0 + + return polynomial + + + def _second_order_filter_from_center_q(self, cf, quality): + cf_as_ratio = cf/self.sample_rate + + rho = exp(-pi*cf_as_ratio/quality) + rho_squared = rho*rho + + theta = 2.0*pi*cf_as_ratio * sqrt(1.0-1.0/(4.0*quality*quality)) + theta_calc = -2.0*rho*cos(theta) + + polynomial = ones((size(cf),3), dtype=self.precision) + polynomial[:,1] = theta_calc + polynomial[:,2] = rho_squared + + return polynomial + + + def _ear_filter_gains(self): + return self.centre_frequencies[:-1] / self.centre_frequencies[1:] + + + def _ear_first_stage(self): + outer_middle_ear_filter = self._make_filters(self._first_order_filter_from_corner(self.ear_preemph_corner_f), + self._specific_filter(1.0,0.0,0.0), array([0.0]), 1.0) + + high_freq_compensator = self._make_filters(self._specific_filter(1.0,0.0,-1.0), self._specific_filter(0.0,0.0,1.0), + array([self.quart_sample_rate]), 1.0) + + pole_pair = self._make_filters(self._specific_filter(0.0,0.0,1.0), + self._second_order_filter_from_center_q(self.cascade_pole_cfs[0],self.cascade_pole_qs[0]), + array([self.quart_sample_rate]), 1.0) + + outer_middle_ear_evaluations = self._evaluate_filters_for_frequencies(outer_middle_ear_filter, self.frequencies) + high_freq_compensator_evaluations = self._evaluate_filters_for_frequencies(high_freq_compensator, self.frequencies) + pole_pair_evaluations = self._evaluate_filters_for_frequencies(pole_pair, self.frequencies) + + return outer_middle_ear_evaluations * high_freq_compensator_evaluations * pole_pair_evaluations + + + def _ear_all_other_stages(self): + zeros = self._second_order_filter_from_center_q(self.cascade_zero_cfs[1:], self.cascade_zero_qs[1:]) + poles = self._second_order_filter_from_center_q(self.cascade_pole_cfs[1:], self.cascade_pole_qs[1:]) + + stage_filters = self._make_filters(zeros, poles, array([0.0]), self.ear_filter_gains) + return self._evaluate_filters_for_frequencies(stage_filters, self.frequencies) + + + def _generate_cascade_filters(self): + cascade_filters = self.ear_stages + + for channel in range(1,self._num_of_channels): + cascade_filters[channel,:] = cascade_filters[channel,:] * cascade_filters[channel-1,:] + + return self._frequency_responses(cascade_filters) + + + def _generateCochlearFilters(self): + max_f = self._max_frequency() + self.max_f_calc = max_f + sqrt(max_f*max_f + self.ear_break_squared) + + self.centre_frequencies = zeros(self._num_of_channels, dtype=self.precision) + self.centre_frequencies[0] = max_f + self._calc_centre_frequencies_till(self._num_of_channels-1) + + bandwidths = self._ear_bandwidth(self.centre_frequencies) + + self.cascade_zero_cfs = self.centre_frequencies + bandwidths*self.ear_step_factor*self.ear_zero_offset + self.cascade_zero_qs = self.ear_sharpness * self.cascade_zero_cfs / bandwidths + self.cascade_pole_cfs = self.centre_frequencies + self.cascade_pole_qs = self.centre_frequencies / bandwidths + + self.ear_filter_gains = self._ear_filter_gains() + + self.frequencies = arange(self.half_sample_rate).reshape(self.half_sample_rate, 1) + + self.ear_stages = hstack((self._ear_first_stage(), self._ear_all_other_stages())).transpose() + + self.cochlear_channels = self._generate_cascade_filters() + + + def _get_row_amplitudes(self): + """ + Perform a real Discrete Fourier Transform (DFT; implemented + using a Fast Fourier Transform algorithm, FFT) of the current + sample from the signal multiplied by the smoothing window. + + See numpy.rfft for information about the Fourier transform. + """ + + sample_rate = self.signal.sample_rate + + # A signal window *must* span one sample rate, irrespective of interval length. + signal_window = tile(self.signal(), ceil(1.0/self.signal.interval_length)) + + if self.windowing_function == None: + smoothed_window = signal_window[0:sample_rate] + else: + smoothed_window = signal_window[0:sample_rate] * self.windowing_function(sample_rate) + + row_amplitudes = abs(fft.rfft(smoothed_window))[0:sample_rate/2] + row_amplitudes = row_amplitudes.reshape(1,sample_rate/2.0) + + filter_responses = multiply(self.cochlear_channels, row_amplitudes) + sheet_responses = zeros(self._num_of_channels) + + for channel in range(0,self._num_of_channels): + time_responses = abs(fft.ifft(filter_responses[channel])) + sheet_responses[channel] = sum(time_responses) / (sample_rate/2.0) + + return sheet_responses.reshape(self._num_of_channels, 1) + + + def set_matrix_dimensions(self, bounds, xdensity, ydensity): + super(LyonsCochlearModel, self).set_matrix_dimensions(bounds, xdensity, ydensity) + + self._num_of_channels = self._num_of_channels() + if self._sheet_dimensions[0] == self._num_of_channels: + self._generateCochlearFilters() + else: + raise ValueError("The number of Sheet Rows must correspond to the number of Lyons Filters. Adjust the number sheet rows from [%s] to [%s]." %(self._sheet_dimensions[0], self._num_of_channels)) + + + +class LyonsCochleogram(LyonsCochlearModel): + """ + Employs Lyons Cochlear Model to return a Cochleoogram, + i.e. the response over time along the cochlea. + """ + + def _update_cochleogram(self, new_column): + self._cochleogram = hstack((new_column, self._cochleogram)) + self._cochleogram = self._cochleogram[0:, 0:self._sheet_dimensions[1]] + + + def set_matrix_dimensions(self, bounds, xdensity, ydensity): + super(LyonsCochleogram, self).set_matrix_dimensions(bounds, xdensity, ydensity) + self._cochleogram = zeros(self._sheet_dimensions) + + + def __call__(self, **params_to_override): + self._update_cochleogram(self._get_row_amplitudes()) + return self._cochleogram diff --git a/PixHtLab-Src/Docker/imagen/build/lib/imagen/colorspaces.py b/PixHtLab-Src/Docker/imagen/build/lib/imagen/colorspaces.py new file mode 100644 index 0000000000000000000000000000000000000000..17168f8645778eb7b5d57bdcd5376c8dfd365835 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/build/lib/imagen/colorspaces.py @@ -0,0 +1,517 @@ +""" +Utilities for converting images between various color spaces, such as: + + * RGB (for display on computer monitor red, green, and blue channels) + * HSV (allowing manipulation of the hue, saturation, and value), + * LMS (estimates of human long, medium, and short cone responses), + * LCH (CIE perceptually uniform luminance, chroma (saturation), and hue) + * LAB (CIE opponent black/white, red/green, blue/yellow axes) + * XYZ (CIE interchange format) + +See http://en.wikipedia.org/wiki/Color_space for more detailed descriptions. + +To use these utilities, users should instantiate one of these two classes: + +ColorSpace + Provides a convert(from, to, what) method to perform conversion + between colorspaces, e.g. ``convert("rgb", "hsv", X)``, where ``X`` + is assumed to be a numpy.dstack() object with three matching arrays. + +FeatureColorConverter + Declare a set of color spaces to allow external code to work the + same for any combination of color spaces. Specifically, declares: + + * image color space (the space in which a dataset of images has + been stored), + * working color space (to which the images will be converted), + e.g. to transform images to a different working dataset, and + * analysis color space (space in which analyses will be performed) + + These values can be set using:: + + color_conversion.image_space="XYZ" # e.g. RGB, XYZ, LMS + color_conversion.working_space="RGB" # e.g. RGB, LMS + color_conversion.analysis_space="HSV" # e.g. HSV, LCH + +The other code in this file is primarily implementation for these two +classes, and will rarely need to be used directly. + +""" + +from math import pi, fmod, floor + +import param +import copy +import colorsys +import numpy as np + + +def _threeDdot_simple(M,a): + "Return Ma, where M is a 3x3 transformation matrix, for each pixel" + + result = np.empty(a.shape,dtype=a.dtype) + + for i in range(a.shape[0]): + for j in range(a.shape[1]): + A = np.array([a[i,j,0],a[i,j,1],a[i,j,2]]).reshape((3,1)) + L = np.dot(M,A) + result[i,j,0] = L[0] + result[i,j,1] = L[1] + result[i,j,2] = L[2] + + return result + + +def _threeDdot_opt(M,a): + swapped = a.swapaxes(0,2) + shape = swapped.shape + result = np.dot(M,swapped.reshape((3,-1))) + result.shape = shape + b = result.swapaxes(2,0) + # need to do asarray to ensure dtype? + return np.asarray(b,dtype=a.dtype) + +# CB: probably could make a faster version if do aM instead, +# e.g. something like (untested): + +#def _threeDdot(M,a): +# shape = a.shape +# result = np.dot(a.reshape((-1,3)),M) +# result.shape = shape +# return result + +threeDdot = _threeDdot_opt + + +def _abc_to_def_array(ABC,fn): + shape = ABC[:,:,0].shape + dtype = ABC.dtype + + DEF = np.zeros(ABC.shape,dtype=dtype) + + for i in range(shape[0]): + for j in range(shape[1]): + DEF[i,j,0],DEF[i,j,1],DEF[i,j,2]=fn(ABC[i,j,0],ABC[i,j,1],ABC[i,j,2]) + + return DEF + + +def _rgb_to_hsv_array(RGB): + """Equivalent to colorsys.rgb_to_hsv, except expects array like :,:,3""" + return _abc_to_def_array(RGB,colorsys.rgb_to_hsv) + + +def _hsv_to_rgb_array(HSV): + """Equivalent to colorsys.hsv_to_rgb, except expects array like :,:,3""" + return _abc_to_def_array(HSV,colorsys.hsv_to_rgb) + + +# these aliases can be overriden after loading this file, if +# optimized versions are available +rgb_to_hsv = _rgb_to_hsv_array +hsv_to_rgb = _hsv_to_rgb_array + + +# Should document where these constants are from. +KAP = 24389/27.0 +EPS = 216/24389.0 + + +def xyz_to_lab(XYZ,wp): + + X,Y,Z = np.dsplit(XYZ,3) + xn,yn,zn = X/wp[0], Y/wp[1], Z/wp[2] + + def f(t): + t = t.copy() # probably unnecessary! + t_eps = t>EPS + t_not_eps = t<=EPS + t[t_eps] = np.power(t[t_eps], 1.0/3) + t[t_not_eps] = (KAP*t[t_not_eps]+16.0)/116. + return t + + fx,fy,fz = f(xn), f(yn), f(zn) + L = 116*fy - 16 + a = 500*(fx - fy) + b = 200*(fy - fz) + + return np.dstack((L,a,b)) + + +def lab_to_xyz(LAB,wp): + + L,a,b = np.dsplit(LAB,3) + fy = (L+16)/116.0 + fz = fy - b / 200.0 + fx = a/500.0 + fy + + def finv(y): + y =copy.copy(y) # CEBALERT: why copy? + eps3 = EPS**3 + return np.where(y > eps3, + np.power(y,3), + (116*y-16)/KAP) + + xr, yr, zr = finv(fx), finv(fy), finv(fz) + return np.dstack((xr*wp[0],yr*wp[1],zr*wp[2])) + + +def lch_to_lab(LCH): + L,C,H = np.dsplit(LCH,3) + return np.dstack( (L,C*np.cos(H),C*np.sin(H)) ) + + +def lab_to_lch(LAB): + L,A,B = np.dsplit(LAB,3) + range_ = 2*pi + x = np.arctan2(B,A) + return np.dstack( (L, np.hypot(A,B), fmod(x + 2*range_*(1-floor(x/(2*range_))), range_) ) ) + + +def xyz_to_lch(XYZ,whitepoint): + return lab_to_lch(xyz_to_lab(XYZ,whitepoint)) + + +def lch_to_xyz(LCH,whitepoint): + return lab_to_xyz(lch_to_lab(LCH),whitepoint) + + + + +# Preceding functions started from ceball's colorfns.py file +# the rest started from +# http://projects.scipy.org/scipy/browser/trunk/Lib/sandbox/image/color.py?rev=1698 + +whitepoints = {'CIE A': ['Normal incandescent', 0.4476, 0.4074], + 'CIE B': ['Direct sunlight', 0.3457, 0.3585], + 'CIE C': ['Average sunlight', 0.3101, 0.3162], + 'CIE E': ['Normalized reference', 1.0/3, 1.0/3], + 'D50': ['Bright tungsten', 0.3457, 0.3585], + 'D55': ['Cloudy daylight', 0.3324, 0.3474], + 'D65': ['Daylight', 0.312713, 0.329016], + 'D75': ['?', 0.299, 0.3149], + 'D93': ['low-quality old CRT', 0.2848, 0.2932] + } + + +def triwhite(chrwhite): + x,y = chrwhite + X = float(x) / y + Y = 1.0 + Z = (1-x-y)/y + return X,Y,Z + +for key in whitepoints.keys(): + whitepoints[key].append(triwhite(whitepoints[key][1:])) + + +transforms = {} + + +# CEBALERT: add reference. Inverse computed using scipy.linalg.inv. +transforms = {} +transforms['D65'] = sD65 = {} + +sD65['rgb_from_xyz'] = np.array([[3.2410,-1.5374,-0.4986], + [-0.9692,1.8760,0.0416], + [0.0556,-0.204,1.0570]]) + +sD65['xyz_from_rgb'] = np.array([[ 0.41238088, 0.35757284, 0.1804523 ], + [ 0.21261986, 0.71513879, 0.07214994], + [ 0.0193435 , 0.11921217, 0.95050657]]) + + +# Guth (1980) - SP; L, M, and S normalized to one) +sD65['lms_from_xyz'] = np.array([[0.2435, 0.8524, -0.0516], + [-0.3954, 1.1642, 0.0837], + [0, 0, 0.6225]]) + +sD65['xyz_from_lms'] = np.array([[1.87616336e+00, -1.37368291e+00, 3.40220544e-01], + [6.37205799e-01, 3.92411765e-01, 5.61517442e-05], + [0.00000000e+00, 0.00000000e+00, 1.60642570e+00]]) + + +### Make LCH like other spaces (0,1) + +Lmax = 100.0 +Cmax = 360.0 # ? CEBALERT: A,B typically -127 to 128 (wikipedia...), so 360 or so max for C? +Hmax = 2*pi + +def xyz_to_lch01(XYZ, whitepoint): + L,C,H = np.dsplit(xyz_to_lch(XYZ,whitepoint),3) + L/=Lmax + C/=Cmax + H/=Hmax + return np.dstack((L,C,H)) + +def lch01_to_xyz(LCH, whitepoint): + L,C,H = np.dsplit(LCH,3) + L*=Lmax + C*=Cmax + H*=Hmax + return lch_to_xyz(np.dstack((L,C,H)),whitepoint) + + + +class ColorSpace(param.Parameterized): + """ + Low-level color conversion. The 'convert' method handles color + conversion to and from (and through) XYZ, and supports RGB, LCH, + LMS and HSV. + """ + + whitepoint = param.String(default='D65', doc=""" + Name of whitepoint in lookup table.""") + + transforms = param.Dict(default=transforms,doc=""" + Structure containing the transformation matrices used by this + Class. See ``transforms`` in this file.""") + + input_limits = param.NumericTuple((0.0,1.0),doc=""" + Upper and lower bounds to verify on input values.""") + + output_limits = param.NumericTuple((0.0,1.0),doc=""" + Upper and lower bounds to enforce on output values.""") + + output_clip = param.ObjectSelector(default='silent', + objects=['silent','warn','error','none'],doc=""" + Action to take when the output value will be clipped.""") + + dtype = param.Parameter(default=np.float32, doc="Datatype to use for result.") + + + def convert(self, from_, to, what): + """ + Convert image or color "what" from "from_" colorpace to "to" + colorspace. E.g.: ``convert("rgb", "hsv", X)``, where X is a + numpy dstack or a color tuple. + """ + + if(from_.lower()==to.lower()): + return what + + # Check if there exist an optimized function that performs + # from_to_to conversion + direct_conversion = '%s_to_%s'%(from_.lower(),to.lower()) + if( hasattr(self, direct_conversion ) ): + fn = getattr(self, direct_conversion) + return fn(what) + + from_to_xyz = getattr(self, '%s_to_xyz'%(from_.lower()) ) + xyz_to_to = getattr(self, 'xyz_to_%s'%(to.lower()) ) + + return xyz_to_to( from_to_xyz(what) ) + + + def _triwp(self): + return whitepoints[self.whitepoint][3] + + + def _get_shape(self,a): + # The shape of the array if it isn't a scalar + if isinstance(a, np.ndarray) and a.ndim>0: + return a.shape + # Tuple support + try: + length = len(a) + return (length,) + except TypeError: + return None + + def _put_shape(self,a,shape): + if shape is None: + return self.dtype(a) + else: + a.shape = shape + return a + + def _prepare_input(self,a,min_,max_): + in_shape = self._get_shape(a) + a = np.array(a,copy=False,ndmin=3,dtype=self.dtype) + if a.min()max_: + raise ValueError('Input out of limits') + return a, in_shape + + def _clip(self,a,min_limit,max_limit,action='silent'): + if action=='none': + return + + if action=='error': + if a.min()max_limit: + raise ValueError('(%s,%s) outside limits (%s,%s)' + % (a.min(),a.max(),min_limit,max_limit)) + elif action=='warn': + if a.min()max_limit: + self.warning('(%s,%s) outside limits (%s,%s)' % + (a.min(),a.max(),min_limit,max_limit)) + a.clip(min_limit,max_limit,out=a) + + + def _threeDdot(self,M,a): + # b = Ma + a, in_shape = self._prepare_input(a,*self.input_limits) + b = threeDdot(M,a) + self._clip(b,*self.output_limits,action=self.output_clip) + self._put_shape(b,in_shape) + return b + + def _ABC_to_DEF_by_fn(self,ABC,fn,*fnargs): + ABC, in_shape = self._prepare_input(ABC,*self.input_limits) + DEF = fn(ABC,*fnargs) + self._clip(DEF,*self.output_limits,action=self.output_clip) + self._put_shape(DEF, in_shape) + return DEF + + ## TO XYZ: RGB, LCH, LMS, HSV(passing through RGB) + def rgb_to_xyz(self,RGB): + return self._threeDdot( + self.transforms[self.whitepoint]['xyz_from_rgb'], RGB) + + + def lch_to_xyz(self,LCH): + return self._ABC_to_DEF_by_fn(LCH,lch01_to_xyz,self._triwp()) + + + def lms_to_xyz(self,LMS): + return self._threeDdot( + self.transforms[self.whitepoint]['xyz_from_lms'], LMS) + + + def hsv_to_xyz(self,HSV): + return self.rgb_to_xyz(self.hsv_to_rgb(HSV)) + + ## XYZ TO:RGB, LCH, LMS, HSV(passing through RGB) + + def xyz_to_rgb(self,XYZ): + return self._threeDdot( + self.transforms[self.whitepoint]['rgb_from_xyz'], XYZ) + + + def xyz_to_lch(self, XYZ): + return self._ABC_to_DEF_by_fn(XYZ,xyz_to_lch01,self._triwp()) + + + def xyz_to_lms(self,XYZ): + return self._threeDdot( + self.transforms[self.whitepoint]['lms_from_xyz'], XYZ) + + + def xyz_to_hsv(self, XYZ): + return self.rgb_to_hsv( self.xyz_to_rgb(XYZ) ) + + # Optimized + @staticmethod + def _gamma_rgb(RGB): + return (12.92*RGB*(RGB<=0.0031308) + + ((1+0.055)*RGB**(1/2.4) - 0.055) * (RGB>0.0031308)) + + @staticmethod + def _ungamma_rgb(RGB): + return (RGB/12.92*(RGB<=0.04045) + + (((RGB+0.055)/1.055)**2.4) * (RGB>0.04045)) + + def rgb_to_hsv(self,RGB): + "linear rgb to hsv" + gammaRGB = self._gamma_rgb(RGB) + return self._ABC_to_DEF_by_fn(gammaRGB,rgb_to_hsv) + + def hsv_to_rgb(self,HSV): + "hsv to linear rgb" + gammaRGB = self._ABC_to_DEF_by_fn(HSV,hsv_to_rgb) + return self._ungamma_rgb(gammaRGB) + + def hsv_to_gammargb(self,HSV): + "hsv is already specifying gamma corrected rgb" + return self._ABC_to_DEF_by_fn(HSV,hsv_to_rgb) + + def lch_to_gammargb(self,LCH): + return self._gamma_rgb(self.lch_to_rgb(LCH)) + + def lms_to_lch(self,LCH): + lch_to_xyz + + + +def _swaplch(LCH): + "Reverse the order of an LCH numpy dstack or tuple for analysis." + try: # Numpy array + L,C,H = np.dsplit(LCH,3) + return np.dstack((H,C,L)) + except: # Tuple + L,C,H = LCH + return H,C,L + + + +class ColorConverter(param.Parameterized): + """ + High-level color conversion class designed to support color space + transformations along a pipeline common in color vision modelling: + image (dataset colorspace) -> working (working colorspace) -> + [higher stages] -> analysis + """ + + # CEBALERT: should be ClassSelector + + # SPG: it shouldn't be necessary to support selection of the + # ColorSpace, as the new object supports any color conversion. + colorspace = param.Parameter(default=ColorSpace(),doc=""" + Object to use for converting between color spaces.""") + + image_space = param.ObjectSelector(default='XYZ', objects=['XYZ', 'LMS', 'RGB'], doc=""" + Color space in which images are encoded.""") # CEBALERT: possibly add sRGB? + + working_space = param.ObjectSelector(default='RGB', objects=['RGB','LMS'], doc=""" + Color space to which images will be transformed to provide + working space to later stages of processing.""") + + analysis_space = param.ObjectSelector(default='HSV', + objects=['HSV','LCH'], doc=""" + Color space in which analysis is performed.""") + + swap_polar_HSVorder = { + 'HSV': lambda HSV: HSV, + 'LCH': _swaplch } + + + def image2working(self,i): + """Transform images i provided into the specified working + color space.""" + return self.colorspace.convert(self.image_space, + self.working_space, i) + + def working2analysis(self,r): + "Transform working space inputs to the analysis color space." + a = self.colorspace.convert(self.working_space, self.analysis_space, r) + return self.swap_polar_HSVorder[self.analysis_space](a) + + def analysis2working(self,a): + "Convert back from the analysis color space to the working space." + a = self.swap_polar_HSVorder[self.analysis_space](a) + return self.colorspace.convert(self.analysis_space, self.working_space, a) + + def analysis2display(self,a): + """ + Utility conversion function that transforms data from the + analysis color space to the display space (currently hard-set + to RGB) for visualization. + """ + a = self.swap_polar_HSVorder[self.analysis_space](a) + return self.colorspace.convert(self.analysis_space.lower(), 'gammargb', a) + + + def jitter_hue(self,a,amount): + "Rotate the hue component of a by the given amount." + a[:,:,0] += amount + a[:,:,0] %= 1.0 + + def multiply_sat(self,a,factor): + "Scale the saturation of a by the given amount." + a[:,:,1] *= factor + + +# Provide a shared color_conversion object +color_conversion = ColorConverter() + + +__all__ = ["ColorSpace","ColorConverter"] diff --git a/PixHtLab-Src/Docker/imagen/build/lib/imagen/deprecated.py b/PixHtLab-Src/Docker/imagen/build/lib/imagen/deprecated.py new file mode 100644 index 0000000000000000000000000000000000000000..b0e12b2845b78f11d6f549fe144b3b82633f4253 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/build/lib/imagen/deprecated.py @@ -0,0 +1,360 @@ +""" +Old patterns not intended for new code. + +These patterns are expected to be deleted eventually. +""" + +import param +import numpy as np +from numpy import pi + +from param.parameterized import ParamOverrides + +from .patterngenerator import Constant, PatternGenerator, Composite +from . import Gaussian +from .image import FileImage, PatternSampler, ImageSampler, edge_average + +class SeparatedComposite(Composite): + """ + Generalized version of the Composite PatternGenerator that + enforces spacing constraints between pattern centers. + + Currently supports minimum spacing, but can be generalized to + support maximum spacing also (and both at once). + """ + + min_separation = param.Number(default=0.0, bounds = (0,None), + softbounds = (0.0,1.0), doc=""" + Minimum distance to enforce between all pairs of pattern centers. + + Useful for ensuring that multiple randomly generated patterns + do not overlap spatially. Note that as this this value is + increased relative to the area in which locations are chosen, + the likelihood of a pattern appearing near the center of the + area will decrease. As this value approaches the available + area, the corners become far more likely to be chosen, due to + the distances being greater along the diagonals. + """) + ### JABNOTE: Should provide a mechanism for collecting and + ### plotting the training pattern center distribution, so that + ### such issues can be checked. + + max_trials = param.Integer(default = 50, bounds = (0,None), + softbounds = (0,100), precedence=-1, doc=""" + Number of times to try for a new pattern location that meets + the criteria. + + This is an essentially arbitrary timeout value that helps + prevent an endless loop in case the requirements cannot be + met.""") + + + def __distance_valid(self, g0, g1, p): + """ + Returns true if the distance between the (x,y) locations of + two generators g0 and g1 is greater than a minimum separation. + + Can be extended easily to support other criteria. + """ + dist = np.sqrt((g1.x - g0.x) ** 2 + + (g1.y - g0.y) ** 2) + return dist >= p.min_separation + + + def _advance_pattern_generators(self,p): + """ + Advance the parameters for each generator for this + presentation. + + Picks a position for each generator that is accepted by + __distance_valid for all combinations. Returns a new list of + the generators, with some potentially omitted due to failure + to meet the constraints. + """ + + valid_generators = [] + for g in p.generators: + + for trial in range(self.max_trials): + # Generate a new position and add generator if it's ok + + if np.alltrue([self.__distance_valid(g,v,p) for v in valid_generators]): + valid_generators.append(g) + break + + g.force_new_dynamic_value('x') + g.force_new_dynamic_value('y') + + else: + self.warning("Unable to place pattern %s subject to given constraints" % + g.name) + + return valid_generators + + + +#JABALERT: Can't this be replaced with a Composite? +class TwoRectangles(PatternGenerator): + """Two 2D rectangle pattern generator.""" + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,6.0), + precedence=0.31,doc= + "Ratio of width to height; size*aspect_ratio gives the width of the rectangle.") + + x1 = param.Number(default=-0.15,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + doc="X center of rectangle 1.") + + y1 = param.Number(default=-0.15,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + doc="Y center of rectangle 1.") + + x2 = param.Number(default=0.15,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + doc="X center of rectangle 2.") + + y2 = param.Number(default=0.15,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + doc="Y center of rectangle 2.") + + size = param.Number(default=0.5) + + # YC: Maybe this can be implemented much more cleanly by calling + # the parent's function() twice, but it's hard to see how to + # set the (x,y) offset for the parent. + def function(self,p): + height = p.size + width = p.aspect_ratio*height + + return np.bitwise_or( + np.bitwise_and(np.bitwise_and( + (self.pattern_x-p.x1)<=p.x1+width/4.0, + (self.pattern_x-p.x1)>=p.x1-width/4.0), + np.bitwise_and( + (self.pattern_y-p.y1)<=p.y1+height/4.0, + (self.pattern_y-p.y1)>=p.y1-height/4.0)), + np.bitwise_and(np.bitwise_and( + (self.pattern_x-p.x2)<=p.x2+width/4.0, + (self.pattern_x-p.x2)>=p.x2-width/4.0), + np.bitwise_and( + (self.pattern_y-p.y2)<=p.y2+height/4.0, + (self.pattern_y-p.y2)>=p.y2-height/4.0))) + + +### JABALERT: This class should be eliminated if at all possible; it +### is just a specialized version of Composite, and should be +### implementable directly using what is already in Composite. +class GaussiansCorner(PatternGenerator): + """ + Two Gaussian pattern generators with a variable intersection point, + appearing as a corner or cross. + """ + + x = param.Number(default=-0.15,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + doc="X center of the corner") + + y = param.Number(default=-0.15,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + doc="Y center of the corner") + + size = param.Number(default=0.5,bounds=(0,None), softbounds=(0.1,1), + doc="The size of the corner") + + aspect_ratio = param.Number(default=1/0.31, bounds=(0,None), softbounds=(1,10), + doc="Ratio of the width to the height for both Gaussians") + + angle = param.Number(default=0.5*pi,bounds=(0,pi), softbounds=(0.01*pi,0.99*pi), + doc="The angle of the corner") + + cross = param.Number(default=0.4, bounds=(0,1), softbounds=(0,1), + doc="Where the two Gaussians cross, as a fraction of their half length") + + + def __call__(self,**params_to_override): + p = ParamOverrides(self,params_to_override) + + g_1 = Gaussian() + g_2 = Gaussian() + + x_1 = g_1(orientation = p.orientation, bounds = p.bounds, xdensity = p.xdensity, + ydensity = p.ydensity, offset = p.offset, size = p.size, + aspect_ratio = p.aspect_ratio, + x = p.x + 0.7 * np.cos(p.orientation) * p.cross * p.size * p.aspect_ratio, + y = p.y + 0.7 * np.sin(p.orientation) * p.cross * p.size * p.aspect_ratio) + x_2 = g_2(orientation = p.orientation+p.angle, bounds = p.bounds, xdensity = p.xdensity, + ydensity = p.ydensity, offset = p.offset, size = p.size, + aspect_ratio = p.aspect_ratio, + x = p.x + 0.7 * np.cos(p.orientation+p.angle) * p.cross * p.size * p.aspect_ratio, + y = p.y + 0.7 * np.sin(p.orientation+p.angle) * p.cross * p.size * p.aspect_ratio) + + return np.maximum( x_1, x_2 ) + + + +class Translator(PatternGenerator): + """ + PatternGenerator that translates another PatternGenerator over + time. + + This PatternGenerator will create a series of episodes, where in + each episode the underlying generator is moved in a fixed + direction at a fixed speed. To begin an episode, the Translator's + x, y, and direction are evaluated (e.g. from random + distributions), and the underlying generator is then drawn at + those values plus changes over time that are determined by the + speed. The orientation of the underlying generator should be set + to 0 to get motion perpendicular to the generator's orientation + (which is typical). + + Note that at present the parameter values for x, y, and direction + cannot be passed in when the instance is called; only the values + set on the instance are used. + """ + generator = param.ClassSelector(default=Gaussian(), + class_=PatternGenerator,doc="""Pattern to be translated.""") + + direction = param.Number(default=0.0,softbounds=(-pi,pi),doc=""" + The direction in which the pattern should move, in radians.""") + + speed = param.Number(default=0.01,bounds=(0.0,None),doc=""" + The speed with which the pattern should move, + in sheet coordinates per time_fn unit.""") + + reset_period = param.Number(default=1,bounds=(0.0,None),doc=""" + Period between generating each new translation episode.""") + + episode_interval = param.Number(default=0,doc=""" + Interval between successive translation episodes. + + If nonzero, the episode_separator pattern is presented for + this amount of time_fn time after each episode, e.g. to + allow processing of the previous episode to complete.""") + + episode_separator = param.ClassSelector(default=Constant(scale=0.0), + class_=PatternGenerator,doc=""" + Pattern to display during the episode_interval, if any. + The default is a blank pattern.""") + + time_fn = param.Callable(default=param.Dynamic.time_fn,doc=""" + Function to generate the time used as a base for translation.""") + + def _advance_params(self): + """ + Explicitly generate new values for these parameters only + when appropriate. + """ + for p in ['x','y','direction']: + self.force_new_dynamic_value(p) + self.last_time = self.time_fn() + + + def __init__(self,**params): + super(Translator,self).__init__(**params) + self._advance_params() + + + def __call__(self,**params_to_override): + p=ParamOverrides(self,params_to_override) + + if self.time_fn() >= self.last_time + p.reset_period: + ## Returns early if within episode interval + if self.time_fn()=left) & (xbottom) & (y<=top), + self.image[r,c], + self.background_value) + + + def __apply_size_normalization(self,x,y,sheet_xdensity,sheet_ydensity,size_normalization): + pattern_rows,pattern_cols = self.image.shape + + # Instead of an if-test, could have a class of this type of + # function (c.f. OutputFunctions, etc)... + if size_normalization=='original': + return + + elif size_normalization=='stretch_to_fit': + x_sf,y_sf = pattern_cols/sheet_xdensity, pattern_rows/sheet_ydensity + x*=x_sf; y*=y_sf + + elif size_normalization=='fit_shortest': + if pattern_rows1]=1.0 + + return channel_data diff --git a/PixHtLab-Src/Docker/imagen/build/lib/imagen/patterncoordinator.py b/PixHtLab-Src/Docker/imagen/build/lib/imagen/patterncoordinator.py new file mode 100644 index 0000000000000000000000000000000000000000..ee5ad3cadbd4e6437f2fe8e646fbfecd5ff9addb --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/build/lib/imagen/patterncoordinator.py @@ -0,0 +1,423 @@ +""" +Provides the class PatternCoordinator and a family of +FeatureCoordinator classes. + +PatternCoordinator creates a set of pattern generators whose +parameters are related in some way, as controlled by a subclass of +FeatureCoordinator. +""" + +import os +import math +import json +import glob +import collections +import copy + +import param +from param.parameterized import ParamOverrides + +from imagen.patterngenerator import PatternGenerator +from imagen.image import FileImage +from imagen import Gaussian, Composite, Selector, CompositeBase + +import numbergen + + +class FeatureCoordinator(param.ParameterizedFunction): + """ + A FeatureCoordinator modifies a supplied PatternGenerator. + + The modification can depend on the string pattern_label and + pattern_number supplied, in order to coordinate a set of patterns + of the same type with systematic differences. + + FeatureCoordinators that introduce randomness should be seeded + with a value based on the supplied master_seed, so that an + entire set of patterns can be controlled with the one master_seed + value. + + Subclasses of this class can accept parameters provided in params. + + This superclass ensures a common interface across all + FeatureCoordinator subclasses, which is necessary because they are + usually stored in a list, with each item called the same way. + """ + + def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): + """ + 'pattern' is the PatternGenerator to be modified + 'pattern_label' is the name to be given to this + PatternGenerator, used to select different behaviors + 'pattern_number' is an integer value distinguishing between + multiple patterns with the same pattern_label + 'master_seed' is to be used for any random number generator + seeds used for this pattern + 'params' consists of optional keyword-value pairs to be + provided for subclasses' parameters + """ + raise NotImplementedError + + + +class XCoordinator(FeatureCoordinator): + """ + Chooses a random value for the x coordinate, subject to the + provided position_bound_x. + """ + + position_bound_x = param.Number(default=0.8,doc=""" + Left/rightmost position of the pattern center on the x axis.""") + + def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): + p = ParamOverrides(self,params,allow_extra_keywords=True) + new_pattern=copy.copy(pattern) + new_pattern.x = pattern.get_value_generator('x')+\ + numbergen.UniformRandom(lbound=-p.position_bound_x, + ubound=p.position_bound_x, + seed=master_seed+12+pattern_number, + name="XCoordinator"+str(pattern_number)) + return new_pattern + + + +class YCoordinator(FeatureCoordinator): + """ + Chooses a random value for the y coordinate, subject to the + provided position_bound_y. + """ + + position_bound_y = param.Number(default=0.8,doc=""" + Upper/lowermost position of the pattern center on the y axis.""") + + def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): + p = ParamOverrides(self,params,allow_extra_keywords=True) + new_pattern=copy.copy(pattern) + new_pattern.y = pattern.get_value_generator('y')+\ + numbergen.UniformRandom(lbound=-p.position_bound_y, + ubound=p.position_bound_y, + seed=master_seed+35+pattern_number, + name="YCoordinator"+str(pattern_number)) + return new_pattern + + + +class OrientationCoordinator(FeatureCoordinator): + """ + Chooses a random orientation within the specified + orientation_bound in each direction. + """ + + orientation_bound = param.Number(default=math.pi,doc=""" + Rotate pattern around the origin by at most orientation_bound + radians (in both directions).""") + + + align_orientations = param.Boolean(default=False, doc=""" + Whether or not to align pattern orientations when composing + multiple patterns together. + + Alignment may be useful to prevent crossing stimuli or may be + appropriate for moving patterns sweeped in a single direction + of motion. """) + + def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): + p = ParamOverrides(self,params,allow_extra_keywords=True) + new_pattern=copy.copy(pattern) + new_pattern.orientation = pattern.get_value_generator('orientation')+\ + numbergen.UniformRandom(lbound=-p.orientation_bound, + ubound=p.orientation_bound, + seed=master_seed+21+(0 if p.align_orientations else pattern_number), + name=("OrientationCoordinator" + + ('' if p.align_orientations else str(pattern_number))) + ) + return new_pattern + + +class PatternCoordinator(param.Parameterized): + """ + Returns a set of coordinated PatternGenerators, named according to + pattern_labels. + + The features to be modified are specified with the + features_to_vary parameter. A feature is something coordinated + between the PatternGenerators, either: + + a. one of the existing parameters of the PatternGenerators + (such as size), or + b. a variable from which values for one of the existing parameters + can be calculated (such as a position offset between two + PatternGenerators), or + c. a value inherent to a particular existing image dataset + (due to how the dataset was collected or generated). + + Each PatternGenerator is first instantiated with the supplied + pattern_parameters, and then subclasses of FeatureCoordinator are + applied sequentially to modify the specified or default parameter + values of each PatternGenerator. + """ + + pattern_type = param.ClassSelector(PatternGenerator,default=Gaussian,is_instance=False,doc=""" + PatternGenerator type to be used.""") + + pattern_parameters = param.Dict(default={'size': 0.088388, 'aspect_ratio': 4.66667},doc=""" + Parameter values to be passed to the PatternGenerator specified in pattern_type.""") + + patterns_per_label = param.Integer(default=2,doc=""" + Number of patterns to generate and combine for a given label.""") + + features_to_vary = param.List(default=['xy','or'],class_=str,doc=""" + Stimulus features that the caller wishes to be varied, such as: + :'xy': Position in x and y coordinates + :'or': Orientation + + Subclasses and callers may extend this list to include any + other features for which a coordinator has been defined in + feature_coordinators.""") + + pattern_labels = param.List(default=['Input'],class_=str,bounds=(1,None),doc=""" + For each string in this list, a PatternGenerator of the + requested pattern_type will be returned, with parameters whose + values may depend on the string label supplied. For instance, + if the list ["Pattern1","Pattern2"] is supplied, a metafeature + function might inspect those pattern_labels and set parameters + differently for Pattern1 and Pattern2, returning two different + PatternGenerators with those pattern_labels.""") + + master_seed = param.Integer(default=0,doc=""" + Base seed for all pattern parameter values. Each numbered + pattern on each of the various pattern_labels will normally + use a different random seed, but all of these seeds should + include this master_seed value, so that changing it will + change all of the random pattern parameter streams.""") + + composite_type = param.ClassSelector(CompositeBase,default=Composite, + is_instance=False,doc=""" + Class that combines the patterns_per_label individual patterns + and creates a single combined pattern that it returns for a + given label. For instance, imagen.Composite can merge the + individual patterns into a single pattern using a variety of + operators like add or maximum, while imagen.Selector can + choose one out of a given set of patterns.""") + + composite_parameters = param.Dict(default={},doc=""" + If present, these parameter values will be passed to the + composite specified in composite_type.""") + + feature_coordinators = param.Dict(default=collections.OrderedDict([ + ('xy', [XCoordinator,YCoordinator]), + ('or', OrientationCoordinator)]),doc=""" + Mapping from the feature name (key) to the method(s) to be + applied to the pattern generators. The value can either be a + single method or a list of methods.""") + + + def _create_patterns(self, properties=None): + """ + Return a list (of length patterns_per_label) of + PatternGenerator instances. Should use pattern_type and + pattern_parameters to create each pattern. + + properties is a dictionary, e.g. {'pattern_label': + pattern_label}, which can be used to create PatternGenerators + depending on the requested pattern_label + """ + return [self.pattern_type(**self.pattern_parameters) + for i in range(self.patterns_per_label)] + + + def __init__(self,inherent_features=[],**params): + + """ + If a dataset already and inherently includes certain features, + a list with the inherent feature names should be supplied. + + Any extra parameter values supplied here will be passed down + to the feature_coordinators requested in features_to_vary. + """ + p=ParamOverrides(self,params,allow_extra_keywords=True) + + super(PatternCoordinator, self).__init__(**p.param_keywords()) + + self._feature_params = p.extra_keywords() + + self._inherent_features = inherent_features + + # TFALERT: Once spatial frequency (sf) is added, this will + # cause warnings, because all image datasets will have a + # spatial frequency inherent feature, but mostly we just + # ignore that by having only a single size of DoG, which + # discards all but a narrow range of sf. So the dataset will + # have sf inherently, but that won't be an error or even + # worthy of a warning. + if(len(set(self._inherent_features) - set(self.features_to_vary))): + self.warning('Inherent feature present which is not requested in features') + + self._feature_coordinators_to_apply = [] + for feature, feature_coordinator in self.feature_coordinators.items(): + if feature in self.features_to_vary and feature not in self._inherent_features: + # if it is a list, append each list item individually + if isinstance(feature_coordinator,list): + for individual_feature_coordinator in feature_coordinator: + self._feature_coordinators_to_apply.append(individual_feature_coordinator) + else: + self._feature_coordinators_to_apply.append(feature_coordinator) + + def __call__(self): + coordinated_pattern_generators={} + for pattern_label in self.pattern_labels: + patterns=self._create_patterns({'pattern_label': pattern_label}) + + # Apply _feature_coordinators_to_apply + for i in range(len(patterns)): + for fn in self._feature_coordinators_to_apply: + patterns[i]=fn(patterns[i],pattern_label, i, + self.master_seed, **self._feature_params) + + combined_patterns=self.composite_type(generators=patterns, + **self.composite_parameters) + coordinated_pattern_generators.update({pattern_label:combined_patterns}) + return coordinated_pattern_generators + + + +class PatternCoordinatorImages(PatternCoordinator): + + pattern_type = param.ClassSelector(PatternGenerator, + default=FileImage,is_instance=False) + + pattern_parameters = param.Dict(default={'size': 10}) + + composite_type = param.ClassSelector(CompositeBase, + default=Selector,is_instance=False) + + def __init__(self,dataset_name,**params): + """ + dataset_name is the path to a folder containing a + MANIFEST_json (https://docs.python.org/2/library/json.html), + which contains a description for a dataset. If no + MANIFEST_json is present, all image files in the specified + folder are used. + + Any extra parameter values supplied here will be passed down + to the feature_coordinators requested in features_to_vary. + + The JSON file can contain any of the following entries, if an + entry is not present, the default is used: + + :'dataset_name': Name of the dataset (string, + default=filepath) + :'length': Number of images in the dataset (integer, + default=number of files in directory matching + filename_template) + :'description': Description of the dataset (string, + default="") + :'source': Citation of paper for which the dataset was + created (string, default=name) + :'filename_template': Path to the images with placeholders + ({placeholder_name}) for inherent features and the image + number, e.g. "filename_template": "images/image{i}.png". + The placeholders are replaced according to + placeholder_mapping. Alternatively, glob patterns such as + * or ? can be used, e.g. "filename_template": + "images/*.png" (default=path_to_dataset_name/*.*) + :'placeholder_mapping': Dictionary specifying the + replacement of placeholders in filename_template; value is + used in eval() (default={}). + :'inherent_features': Features for which the corresponding + feature_coordinators should not be applied + (default=['sf','or','cr']) + + Currently, the label of the pattern generator + ('pattern_label') as well as the image number + ('current_image') are given as parameters to each callable + supplied in placeholder_mapping, where current_image + varies from 0 to length-1 and pattern_label is one of the + items of pattern_labels. + (python code, default={'i': lambda params: '%02d' % + (params['current_image']+1)} + + Example 1: Imagine having images without any inherent + features named as follows: "images/image01.png", + "images/image02.png" and so on. Then, filename_template: + "images/image{i}.png" and "placeholder_mapping": + "{'i': lambda params: '%02d' % (params['current_image']+1)}" + This replaces {i} in the template with the current image + number + 1 + + Example 2: Imagine having image pairs from a stereo webcam + named as follows: "images/image01_left.png", + + "images/image01_right.png" and so on. If + pattern_labels=['Left','Right'], then filename_template: + "images/image{i}_{dy}" and "placeholder_mapping": + "{'i': lambda params: '%02d' % (params['current_image']+1), + 'dy':lambda params: 'left' if + params['pattern_label']=='Left' else 'right'}" + + Here, additionally {dy} gets replaced by either 'left' if + the pattern_label is 'Left' or 'right' otherwise + + If the directory does not contain a MANIFEST_json file, the + defaults are as follows: + :'filename_template': filepath/*.*, whereas filepath is + the path given in dataset_name + :'patterns_per_label': Number of image files in filepath, + whereas filepath is the path given in dataset_name + :'inherent_features': [] + :'placeholder_mapping': {} + """ + + filepath=param.resolve_path(dataset_name,path_to_file=False) + self.dataset_name=filepath + self.filename_template=filepath+"/*.*" + self.description="" + self.source=self.dataset_name + self.placeholder_mapping={} + patterns_per_label = len(glob.glob(self.filename_template)) + inherent_features=['sf','cr'] + try: + filename=param.resolve_path(dataset_name+'/MANIFEST_json') + filepath=os.path.dirname(filename) + dataset=json.loads(open(filename).read()) + + self.dataset_name=dataset.get('dataset_name', self.dataset_name) + self.description=dataset.get('description', self.description) + self.filename_template=dataset.get('filename_template', self.filename_template) + patterns_per_label=dataset.get('length', + len(glob.glob(self.filename_template))) + self.source=dataset.get('source', self.source) + self.placeholder_mapping=(eval(dataset['placeholder_mapping']) + if 'placeholder_mapping' in dataset + else self.placeholder_mapping) + inherent_features=dataset.get('inherent_features', inherent_features) + except IOError: + pass + + if 'patterns_per_label' not in params: + params['patterns_per_label'] = self.patterns_per_label + super(PatternCoordinatorImages, self).__init__(inherent_features,**params) + + + def _generate_filenames(self, params): + if(len(self.placeholder_mapping)>0): + filenames = [self.filename_template]*self.patterns_per_label + + for placeholder in self.placeholder_mapping: + filenames = [filename.replace('{'+placeholder+'}', + self.placeholder_mapping[placeholder](params)) + for filename,params['current_image'] in + zip(filenames,range(self.patterns_per_label))] + else: + filenames = sorted(glob.glob(self.filename_template)) + + return filenames + + + def _create_patterns(self, properties): + return [self.pattern_type( + filename=f, + cache_image=False, + **self.pattern_parameters) + for f,i in zip(self._generate_filenames(properties), + range(self.patterns_per_label))] diff --git a/PixHtLab-Src/Docker/imagen/build/lib/imagen/patternfn.py b/PixHtLab-Src/Docker/imagen/build/lib/imagen/patternfn.py new file mode 100644 index 0000000000000000000000000000000000000000..8274cd32a6df98b4464a399dd586b323550e463a --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/build/lib/imagen/patternfn.py @@ -0,0 +1,294 @@ +""" +Family of two-dimensional functions indexed by x and y. + +All functions are written to be valid both for scalar x and y, and for +numpy arrays of x and y (in which case the result is also an array); +the functions therefore have the same mathematical behaviour as numpy. +""" + + +import numpy as np +from numpy import pi + +from contextlib import contextmanager + +# CEBALERT: abs() is used in various places in this file, but I don't +# see it on the list of numpy imports. I guess we're mistakenly not +# using numpy's abs... + +@contextmanager +def float_error_ignore(): + """ + Many of the functions in this module use Gaussian smoothing, which + is based on a calculation like exp(divide(x*x,sigma)). When sigma + is zero the value of this expression should be zero at all points + in the plane, because such a Gaussian is infinitely small. + Obtaining the correct answer using finite-precision floating-point + array computations requires allowing infinite values to be + returned from divide(), and allowing exp() to underflow silently + to zero when given an infinite value. In numpy this is achieved + by using its seterr() function to disable divide-by-zero and + underflow warnings temporarily while these values are being + computed. + """ + oldsettings=np.seterr(divide='ignore',under='ignore') + yield + np.seterr(**oldsettings) + + +def gaussian(x, y, xsigma, ysigma): + """ + Two-dimensional oriented Gaussian pattern (i.e., 2D version of a + bell curve, like a normal distribution but not necessarily summing + to 1.0). + """ + if xsigma==0.0 or ysigma==0.0: + return x*0.0 + + with float_error_ignore(): + x_w = np.divide(x,xsigma) + y_h = np.divide(y,ysigma) + return np.exp(-0.5*x_w*x_w + -0.5*y_h*y_h) + + +def log_gaussian(x, y, x_sigma, y_sigma, mu): + """ + Two-dimensional oriented Log Gaussian pattern (i.e., 2D version of a + bell curve with an independent, movable peak). Much like a normal + distribution, but not necessarily placing the peak above the center, + and not necessarily summing to 1.0). + """ + if x_sigma==0.0 or y_sigma==0.0: + return x * 0.0 + + with float_error_ignore(): + x_w = np.divide(np.log(x)-mu, x_sigma*x_sigma) + y_h = np.divide(np.log(y)-mu, y_sigma*y_sigma) + + return np.exp(-0.5*x_w*x_w + -0.5*y_h*y_h) + + +def sigmoid(axis, slope): + """ + Sigmoid dividing axis into a positive and negative half, + with a smoothly sloping transition between them (controlled by the slope). + + At default rotation, axis refers to the vertical (y) axis. + """ + with float_error_ignore(): + return (2.0 / (1.0 + np.exp(-2.0*slope*axis))) - 1.0 + + +def exponential(x, y, xscale, yscale): + """ + Two-dimensional oriented exponential decay pattern. + """ + if xscale==0.0 or yscale==0.0: + return x*0.0 + + with float_error_ignore(): + x_w = np.divide(x,xscale) + y_h = np.divide(y,yscale) + return np.exp(-np.sqrt(x_w*x_w+y_h*y_h)) + + +def gabor(x, y, xsigma, ysigma, frequency, phase): + """ + Gabor pattern (sine grating multiplied by a circular Gaussian). + """ + if xsigma==0.0 or ysigma==0.0: + return x*0.0 + + with float_error_ignore(): + x_w = np.divide(x,xsigma) + y_h = np.divide(y,ysigma) + p = np.exp(-0.5*x_w*x_w + -0.5*y_h*y_h) + return p * 0.5*np.cos(2*pi*frequency*y + phase) + + +# JABHACKALERT: Shouldn't this use 'size' instead of 'thickness', +# for consistency with the other patterns? Right now, it has a +# size parameter and ignores it, which is very confusing. I guess +# it's called thickness to match ring, but matching gaussian and disk +# is probably more important. +def line(y, thickness, gaussian_width): + """ + Infinite-length line with a solid central region, then Gaussian fall-off at the edges. + """ + distance_from_line = abs(y) + gaussian_y_coord = distance_from_line - thickness/2.0 + sigmasq = gaussian_width*gaussian_width + + if sigmasq==0.0: + falloff = y*0.0 + else: + with float_error_ignore(): + falloff = np.exp(np.divide(-gaussian_y_coord*gaussian_y_coord,2*sigmasq)) + + return np.where(gaussian_y_coord<=0, 1.0, falloff) + + +def disk(x, y, height, gaussian_width): + """ + Circular disk with Gaussian fall-off after the solid central region. + """ + disk_radius = height/2.0 + + distance_from_origin = np.sqrt(x**2+y**2) + distance_outside_disk = distance_from_origin - disk_radius + sigmasq = gaussian_width*gaussian_width + + if sigmasq==0.0: + falloff = x*0.0 + else: + with float_error_ignore(): + falloff = np.exp(np.divide(-distance_outside_disk*distance_outside_disk, + 2*sigmasq)) + + return np.where(distance_outside_disk<=0,1.0,falloff) + + +def ring(x, y, height, thickness, gaussian_width): + """ + Circular ring (annulus) with Gaussian fall-off after the solid ring-shaped region. + """ + radius = height/2.0 + half_thickness = thickness/2.0 + + distance_from_origin = np.sqrt(x**2+y**2) + distance_outside_outer_disk = distance_from_origin - radius - half_thickness + distance_inside_inner_disk = radius - half_thickness - distance_from_origin + + ring = 1.0-np.bitwise_xor(np.greater_equal(distance_inside_inner_disk,0.0), + np.greater_equal(distance_outside_outer_disk,0.0)) + + sigmasq = gaussian_width*gaussian_width + + if sigmasq==0.0: + inner_falloff = x*0.0 + outer_falloff = x*0.0 + else: + with float_error_ignore(): + inner_falloff = np.exp(np.divide(-distance_inside_inner_disk*distance_inside_inner_disk, 2.0*sigmasq)) + outer_falloff = np.exp(np.divide(-distance_outside_outer_disk*distance_outside_outer_disk, 2.0*sigmasq)) + + return np.maximum(inner_falloff,np.maximum(outer_falloff,ring)) + + +def smooth_rectangle(x, y, rec_w, rec_h, gaussian_width_x, gaussian_width_y): + """ + Rectangle with a solid central region, then Gaussian fall-off at the edges. + """ + + gaussian_x_coord = abs(x)-rec_w/2.0 + gaussian_y_coord = abs(y)-rec_h/2.0 + + box_x=np.less(gaussian_x_coord,0.0) + box_y=np.less(gaussian_y_coord,0.0) + sigmasq_x=gaussian_width_x*gaussian_width_x + sigmasq_y=gaussian_width_y*gaussian_width_y + + with float_error_ignore(): + falloff_x=x*0.0 if sigmasq_x==0.0 else \ + np.exp(np.divide(-gaussian_x_coord*gaussian_x_coord,2*sigmasq_x)) + falloff_y=y*0.0 if sigmasq_y==0.0 else \ + np.exp(np.divide(-gaussian_y_coord*gaussian_y_coord,2*sigmasq_y)) + + return np.minimum(np.maximum(box_x,falloff_x), np.maximum(box_y,falloff_y)) + + + +def arc_by_radian(x, y, height, radian_range, thickness, gaussian_width): + """ + Radial arc with Gaussian fall-off after the solid ring-shaped + region with the given thickness, with shape specified by the + (start,end) radian_range. + """ + + # Create a circular ring (copied from the ring function) + radius = height/2.0 + half_thickness = thickness/2.0 + + distance_from_origin = np.sqrt(x**2+y**2) + distance_outside_outer_disk = distance_from_origin - radius - half_thickness + distance_inside_inner_disk = radius - half_thickness - distance_from_origin + + ring = 1.0-np.bitwise_xor(np.greater_equal(distance_inside_inner_disk,0.0), + np.greater_equal(distance_outside_outer_disk,0.0)) + + sigmasq = gaussian_width*gaussian_width + + if sigmasq==0.0: + inner_falloff = x*0.0 + outer_falloff = x*0.0 + else: + with float_error_ignore(): + inner_falloff = np.exp(np.divide(-distance_inside_inner_disk*distance_inside_inner_disk, 2.0*sigmasq)) + outer_falloff = np.exp(np.divide(-distance_outside_outer_disk*distance_outside_outer_disk, 2.0*sigmasq)) + + output_ring = np.maximum(inner_falloff,np.maximum(outer_falloff,ring)) + + # Calculate radians (in 4 phases) and cut according to the set range) + + # RZHACKALERT: + # Function float_error_ignore() cannot catch the exception when + # both np.dividend and divisor are 0.0, and when only divisor is 0.0 + # it returns 'Inf' rather than 0.0. In x, y and + # distance_from_origin, only one point in distance_from_origin can + # be 0.0 (circle center) and in this point x and y must be 0.0 as + # well. So here is a hack to avoid the 'invalid value encountered + # in divide' error by turning 0.0 to 1e-5 in distance_from_origin. + distance_from_origin += np.where(distance_from_origin == 0.0, 1e-5, 0) + + with float_error_ignore(): + sines = np.divide(y, distance_from_origin) + cosines = np.divide(x, distance_from_origin) + arcsines = np.arcsin(sines) + + phase_1 = np.where(np.logical_and(sines >= 0, cosines >= 0), 2*pi-arcsines, 0) + phase_2 = np.where(np.logical_and(sines >= 0, cosines < 0), pi+arcsines, 0) + phase_3 = np.where(np.logical_and(sines < 0, cosines < 0), pi+arcsines, 0) + phase_4 = np.where(np.logical_and(sines < 0, cosines >= 0), -arcsines, 0) + arcsines = phase_1 + phase_2 + phase_3 + phase_4 + + if radian_range[0] <= radian_range[1]: + return np.where(np.logical_and(arcsines >= radian_range[0], arcsines <= radian_range[1]), + output_ring, 0.0) + else: + return np.where(np.logical_or(arcsines >= radian_range[0], arcsines <= radian_range[1]), + output_ring, 0.0) + + +def arc_by_center(x, y, arc_box, constant_length, thickness, gaussian_width): + """ + Arc with Gaussian fall-off after the solid ring-shaped region and specified + by point of tangency (x and y) and arc width and height. + + This function calculates the start and end radian from the given width and + height, and then calls arc_by_radian function to draw the curve. + """ + + arc_w=arc_box[0] + arc_h=abs(arc_box[1]) + + if arc_w==0.0: # arc_w=0, don't draw anything + radius=0.0 + angles=(0.0,0.0) + elif arc_h==0.0: # draw a horizontal line, width=arc_w + return smooth_rectangle(x, y, arc_w, thickness, 0.0, gaussian_width) + else: + if constant_length: + curvature=arc_h/arc_w + radius=arc_w/(2*pi*curvature) + angle=curvature*(2*pi)/2.0 + else: # constant width + radius=arc_h/2.0+arc_w**2.0/(8*arc_h) + angle=np.arcsin(arc_w/2.0/radius) + if arc_box[1]<0: # convex shape + y=y+radius + angles=(3.0/2.0*pi-angle, 3.0/2.0*pi+angle) + else: # concave shape + y=y-radius + angles=(pi/2.0-angle, pi/2.0+angle) + + return arc_by_radian(x, y, radius*2.0, angles, thickness, gaussian_width) diff --git a/PixHtLab-Src/Docker/imagen/build/lib/imagen/patterngenerator.py b/PixHtLab-Src/Docker/imagen/build/lib/imagen/patterngenerator.py new file mode 100644 index 0000000000000000000000000000000000000000..3e7b550b07259e6229221c3d2d8a52c3a7a748f6 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/build/lib/imagen/patterngenerator.py @@ -0,0 +1,666 @@ +""" +PatternGenerator abstract class, basic example concrete class, and +multichannel support. + +PatternGenerators support both single-channel patterns, i.e. bare +arrays, and multiple channels, such as for color images. See +``PatternGenerator.__call__`` and ``PatternGenerator.channels`` for +more information. +""" + +import numpy as np +from numpy import pi +import collections + +import param +from param.parameterized import ParamOverrides + +from holoviews import HoloMap, Image, RGB, Dimension +from holoviews.core import BoundingBox, BoundingRegionParameter, SheetCoordinateSystem + +from .transferfn import TransferFn + + +# CEBALERT: PatternGenerator has become a bit of a monster abstract +# class. Can it be split into the minimum required to specify the +# interface, with a subclass implementing the rest (this subclass +# still being above the rest of the PatternGenerators)? We want to +# make it easy to add new types of PatternGenerator that don't match +# the assumptions of the current ones (OneDPowerSpectrum is an example +# of a PG that doesn't match the current assumptions), but still lets +# them be used like the current ones. +# (PatternGenerator-->TwoDPatternGenerator?) + +# JLALERT: PatternGenerator should have +# override_plasticity_state/restore_plasticity_state functions which +# can override the plasticity of any output_fn that has state, in case +# anyone ever uses such an object in a PatternGenerator. Will also +# need to support Composite patterns. + + +class PatternGenerator(param.Parameterized): + """ + A class hierarchy for callable objects that can generate 2D patterns. + + Once initialized, PatternGenerators can be called to generate a + value or a matrix of values from a 2D function, typically + accepting at least x and y. + + A PatternGenerator's Parameters can make use of Parameter's + precedence attribute to specify the order in which they should + appear, e.g. in a GUI. The precedence attribute has a nominal + range of 0.0 to 1.0, with ordering going from 0.0 (first) to 1.0 + (last), but any value is allowed. + + The orientation and layout of the pattern matrices is defined by + the SheetCoordinateSystem class, which see. + + Note that not every parameter defined for a PatternGenerator will + be used by every subclass. For instance, a Constant pattern will + ignore the x, y, orientation, and size parameters, because the + pattern does not vary with any of those parameters. However, + those parameters are still defined for all PatternGenerators, even + Constant patterns, to allow PatternGenerators to be scaled, rotated, + translated, etc. uniformly. + """ + __abstract = True + + bounds = BoundingRegionParameter( + default=BoundingBox(points=((-0.5,-0.5), (0.5,0.5))),precedence=-1, + doc="BoundingBox of the area in which the pattern is generated.") + + xdensity = param.Number(default=256,bounds=(0,None),precedence=-1,doc=""" + Density (number of samples per 1.0 length) in the x direction.""") + + ydensity = param.Number(default=256,bounds=(0,None),precedence=-1,doc=""" + Density (number of samples per 1.0 length) in the y direction. + Typically the same as the xdensity.""") + + x = param.Number(default=0.0,softbounds=(-1.0,1.0),precedence=0.20,doc=""" + X-coordinate location of pattern center.""") + + y = param.Number(default=0.0,softbounds=(-1.0,1.0),precedence=0.21,doc=""" + Y-coordinate location of pattern center.""") + + z = param.ClassSelector(default=None, precedence=-1, class_=Dimension, doc=""" + The Dimension object associated with the z-values generated by + the PatternGenerator . If None, uses the default set by + HoloViews.Image.""") + + group = param.String(default='Pattern', precedence=-1, doc=""" + The group name assigned to the returned HoloViews object.""") + + position = param.Composite(attribs=['x','y'],precedence=-1,doc=""" + Coordinates of location of pattern center. + Provides a convenient way to set the x and y parameters together + as a tuple (x,y), but shares the same actual storage as x and y + (and thus only position OR x and y need to be specified).""") + + orientation = param.Number(default=0.0,softbounds=(0.0,2*pi),precedence=0.40,doc=""" + Polar angle of pattern, i.e., the orientation in the Cartesian coordinate + system, with zero at 3 o'clock and increasing counterclockwise.""") + + size = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,6.0), + precedence=0.30,doc="""Determines the overall size of the pattern.""") + + scale = param.Number(default=1.0,softbounds=(0.0,2.0),precedence=0.10,doc=""" + Multiplicative strength of input pattern, defaulting to 1.0""") + + offset = param.Number(default=0.0,softbounds=(-1.0,1.0),precedence=0.11,doc=""" + Additive offset to input pattern, defaulting to 0.0""") + + mask = param.Parameter(default=None,precedence=-1,doc=""" + Optional object (expected to be an array) with which to multiply the + pattern array after it has been created, before any output_fns are + applied. This can be used to shape the pattern.""") + + # Note that the class type is overridden to PatternGenerator below + mask_shape = param.ClassSelector(param.Parameterized,default=None,precedence=0.06,doc=""" + Optional PatternGenerator used to construct a mask to be applied to + the pattern.""") + + output_fns = param.HookList(default=[], precedence=0.08,doc=""" + Optional function(s) to apply to the pattern array after it has been created. + Can be used for normalization, thresholding, etc.""") + + + def __init__(self,**params): + super(PatternGenerator, self).__init__(**params) + self.set_matrix_dimensions(self.bounds, self.xdensity, self.ydensity) + + + def __call__(self,**params_to_override): + """ + Call the subclass's 'function' method on a rotated and scaled + coordinate system. + + Creates and fills an array with the requested pattern. If + called without any params, uses the values for the Parameters + as currently set on the object. Otherwise, any params + specified override those currently set on the object. + """ + if 'output_fns' in params_to_override: + self.warning("Output functions specified through the call method will be ignored.") + + p=ParamOverrides(self,params_to_override) + + # CEBERRORALERT: position parameter is not currently + # supported. We should delete the position parameter or fix + # this. + # + # position=params_to_override.get('position',None) if position + # is not None: x,y = position + + self._setup_xy(p.bounds,p.xdensity,p.ydensity,p.x,p.y,p.orientation) + fn_result = self.function(p) + self._apply_mask(p,fn_result) + if p.scale != 1.0: + result = p.scale * fn_result + else: + result = fn_result + if p.offset != 0.0: + result += p.offset + + for of in p.output_fns: + of(result) + + return result + + + def __getitem__(self, coords): + value_dims = {} + if self.num_channels() in [0, 1]: + raster, data = Image, self() + value_dims = {'value_dimensions':[self.z]} if self.z else value_dims + elif self.num_channels() in [3,4]: + raster = RGB + data = np.dstack(self.channels().values()[1:]) + + image = raster(data, bounds=self.bounds, + **dict(group=self.group, + label=self.__class__.__name__, **value_dims)) + # Works round a bug fixed shortly after HoloViews 1.0.0 release + return image if isinstance(coords, slice) else image.__getitem__(coords) + + + + + def channels(self, use_cached=False, **params_to_override): + """ + Channels() adds a shared interface for single channel and + multichannel structures. It will always return an ordered + dict: its first element is the single channel of the pattern + (if single-channel) or the channel average (if multichannel); + the successive elements are the individual channels' arrays + (key: 0,1,..N-1). + """ + return collections.OrderedDict({ 'default':self.__call__(**params_to_override) }) + + + def num_channels(self): + """ + Query the number of channels implemented by the + PatternGenerator. In case of single-channel generators this + will return 1; in case of multichannel, it will return the + number of channels (eg, in the case of RGB images it would + return '3', Red-Green-Blue, even though the OrderedDict + returned by channels() will have 4 elements -- the 3 channels + + their average). + """ + return 1 + + + def _setup_xy(self,bounds,xdensity,ydensity,x,y,orientation): + """ + Produce pattern coordinate matrices from the bounds and + density (or rows and cols), and transforms them according to + x, y, and orientation. + """ + self.debug("bounds=%s, xdensity=%s, ydensity=%s, x=%s, y=%s, orientation=%s",bounds,xdensity,ydensity,x,y,orientation) + # Generate vectors representing coordinates at which the pattern + # will be sampled. + + # CB: note to myself - use slice_._scs if supplied? + x_points,y_points = SheetCoordinateSystem(bounds,xdensity,ydensity).sheetcoordinates_of_matrixidx() + + # Generate matrices of x and y sheet coordinates at which to + # sample pattern, at the correct orientation + self.pattern_x, self.pattern_y = self._create_and_rotate_coordinate_arrays(x_points-x,y_points-y,orientation) + + + def function(self,p): + """ + Function to draw a pattern that will then be scaled and rotated. + + Instead of implementing __call__ directly, PatternGenerator + subclasses will typically implement this helper function used + by __call__, because that way they can let __call__ handle the + scaling and rotation for them. Alternatively, __call__ itself + can be reimplemented entirely by a subclass (e.g. if it does + not need to do any scaling or rotation), in which case this + function will be ignored. + """ + raise NotImplementedError + + + def _create_and_rotate_coordinate_arrays(self, x, y, orientation): + """ + Create pattern matrices from x and y vectors, and rotate them + to the specified orientation. + """ + # Using this two-liner requires that x increase from left to + # right and y decrease from left to right; I don't think it + # can be rewritten in so little code otherwise - but please + # prove me wrong. + pattern_y = np.subtract.outer(np.cos(orientation)*y, np.sin(orientation)*x) + pattern_x = np.add.outer(np.sin(orientation)*y, np.cos(orientation)*x) + return pattern_x, pattern_y + + + def _apply_mask(self,p,mat): + """Create (if necessary) and apply the mask to the given matrix mat.""" + mask = p.mask + ms=p.mask_shape + if ms is not None: + mask = ms(x=p.x+p.size*(ms.x*np.cos(p.orientation)-ms.y*np.sin(p.orientation)), + y=p.y+p.size*(ms.x*np.sin(p.orientation)+ms.y*np.cos(p.orientation)), + orientation=ms.orientation+p.orientation,size=ms.size*p.size, + bounds=p.bounds,ydensity=p.ydensity,xdensity=p.xdensity) + if mask is not None: + mat*=mask + + + def set_matrix_dimensions(self, bounds, xdensity, ydensity): + """ + Change the dimensions of the matrix into which the pattern + will be drawn. Users of this class should call this method + rather than changing the bounds, xdensity, and ydensity + parameters directly. Subclasses can override this method to + update any internal data structures that may depend on the + matrix dimensions. + """ + self.bounds = bounds + self.xdensity = xdensity + self.ydensity = ydensity + scs = SheetCoordinateSystem(bounds, xdensity, ydensity) + for of in self.output_fns: + if isinstance(of, TransferFn): + of.initialize(SCS=scs, shape=scs.shape) + + def state_push(self): + "Save the state of the output functions, to be restored with state_pop." + for of in self.output_fns: + if hasattr(of,'state_push'): + of.state_push() + super(PatternGenerator, self).state_push() + + + def state_pop(self): + "Restore the state of the output functions saved by state_push." + for of in self.output_fns: + if hasattr(of,'state_pop'): + of.state_pop() + super(PatternGenerator, self).state_pop() + + + def anim(self, duration, offset=0, timestep=1, + label=None, unit=None, + time_fn=param.Dynamic.time_fn): + """ + duration: The temporal duration to animate in the units + defined on the global time function. + + offset: The temporal offset from which the animation is + generated given the supplied pattern + + timestep: The time interval between successive frames. The + duration must be an exact multiple of the timestep. + + label: A label string to override the label of the global time + function (if not None). + + unit: The unit string to override the unit value of the global + time function (if not None). + + time_fn: The global time function object that is shared across + the time-varying objects that are being sampled. + + Note that the offset, timestep and time_fn only affect + patterns parameterized by time-dependent number + generators. Otherwise, the frames are generated by successive + call to the pattern which may or may not be varying (e.g to + view the patterns contained within a Selector). + """ + frames = (duration // timestep) + 1 + if duration % timestep != 0: + raise ValueError("The duration value must be an exact multiple of the timestep.") + + if label is None: + label = time_fn.label if hasattr(time_fn, 'label') else 'Time' + + unit = time_fn.unit if (not unit and hasattr(time_fn, 'unit')) else unit + vmap = HoloMap(kdims=[Dimension(label, unit=unit if unit else '')]) + + self.state_push() + with time_fn as t: + t(offset) + for i in range(frames): + vmap[t()] = self[:] + t += timestep + self.state_pop() + return vmap + + ## Support for compositional expressions of PatternGenerator objects + def _promote(self,other): + if not isinstance(other,PatternGenerator): + other = Constant(scale=other,offset=0) + return [self,other] + + def _rpromote(self,other): + if not isinstance(other,PatternGenerator): + other = Constant(scale=other,offset=0) + return [other,self] + + # Could define any of Python's operators here, esp. if they have operator or ufunc equivalents + def __add__ (self,other): return Composite(generators=self._promote(other),operator=np.add) + def __sub__ (self,other): return Composite(generators=self._promote(other),operator=np.subtract) + def __mul__ (self,other): return Composite(generators=self._promote(other),operator=np.multiply) + def __mod__ (self,other): return Composite(generators=self._promote(other),operator=np.mod) + def __pow__ (self,other): return Composite(generators=self._promote(other),operator=np.power) + def __div__ (self,other): return Composite(generators=self._promote(other),operator=np.divide) + def __and__ (self,other): return Composite(generators=self._promote(other),operator=np.minimum) + def __or__ (self,other): return Composite(generators=self._promote(other),operator=np.maximum) + + + def __radd__ (self,other): return Composite(generators=self._rpromote(other),operator=np.add) + def __rsub__ (self,other): return Composite(generators=self._rpromote(other),operator=np.subtract) + def __rmul__ (self,other): return Composite(generators=self._rpromote(other),operator=np.multiply) + def __rmod__ (self,other): return Composite(generators=self._rpromote(other),operator=np.mod) + def __rpow__ (self,other): return Composite(generators=self._rpromote(other),operator=np.power) + def __rdiv__ (self,other): return Composite(generators=self._rpromote(other),operator=np.divide) + def __rand__ (self,other): return Composite(generators=self._rpromote(other),operator=np.minimum) + def __ror__ (self,other): return Composite(generators=self._rpromote(other),operator=np.maximum) + + + def __neg__ (self): return Composite(generators=[Constant(scale=0),self],operator=np.subtract) + + class abs_first(object): + @staticmethod + def reduce(x): return np.abs(x[0]) + + def __abs__ (self): return Composite(generators=[self],operator=self.abs_first) + + + def pil(self, **params_to_override): + """Returns a PIL image for this pattern, overriding parameters if provided.""" + from PIL.Image import fromarray + nchans = self.num_channels() + + if nchans in [0, 1]: + mode, arr = None, self(**params_to_override) + arr = (255.0 / arr.max() * (arr - arr.min())).astype(np.uint8) + + elif nchans in [3,4]: + mode = 'RGB' if nchans==3 else 'RGBA' + arr = np.dstack(self.channels(**params_to_override).values()[1:]) + arr = (255.0*arr).astype(np.uint8) + + else: + raise ValueError("Unsupported number of channels") + + return fromarray(arr, mode) + + +# Override class type; must be set here rather than when mask_shape is declared, +# to avoid referring to class not yet constructed +PatternGenerator.params('mask_shape').class_=PatternGenerator + + + +# Trivial example of a PatternGenerator, provided for when a default is +# needed. The other concrete PatternGenerator classes are stored +# elsewhere, to be imported as needed. + +class Constant(PatternGenerator): + """Constant pattern generator, i.e., a solid, uniform field of the same value.""" + + # The orientation is ignored, so we don't show it in + # auto-generated lists of parameters (e.g. in the GUI) + orientation = param.Number(precedence=-1) + + # Optimization: We use a simpler __call__ method here to skip the + # coordinate transformations (which would have no effect anyway) + def __call__(self,**params_to_override): + p = ParamOverrides(self,params_to_override) + + shape = SheetCoordinateSystem(p.bounds,p.xdensity,p.ydensity).shape + + result = p.scale*np.ones(shape, np.float)+p.offset + self._apply_mask(p,result) + + for of in p.output_fns: + of(result) + + return result + + + +class CompositeBase(PatternGenerator): + """ + PatternGenerator that combines or selects from a list of other + PatternGenerators. + """ + + __abstract=True + + generators = param.List(class_=PatternGenerator,default=[Constant(scale=0.0)], + bounds=(1,None),precedence=0.97, doc=""" + List of patterns to combine or select from. The default pattern is a blank pattern, + and thus should be overridden for any useful work.""") + + size = param.Number(default=1.0,doc="""Scaling factor applied to all sub-patterns.""") + + + +class Composite(CompositeBase): + """ + PatternGenerator that accepts a list of other PatternGenerators. + To create a new pattern, asks each of the PatternGenerators in the + list to create a pattern, then it combines the patterns to create + a single pattern that it returns. + """ + + # The Accum_Replace operator from LISSOM is not yet supported, + # but it should be added once PatternGenerator bounding boxes + # are respected and/or GenericImage patterns support transparency. + operator = param.Parameter(np.maximum,precedence=0.98,doc=""" + Binary Numpy function used to combine the individual patterns. + + Any binary Numpy array "ufunc" returning the same + type of array as the operands and supporting the reduce + operator is allowed here. Supported ufuncs include:: + + add + subtract + multiply + divide + maximum + minimum + remainder + power + + The most useful ones are probably add and maximum, but there + are uses for at least some of the others as well (e.g. to + remove pieces of other patterns). + + You can also write your own operators, by making a class that + has a static method named "reduce" that returns an array of the + same size and type as the arrays in the list. For example:: + + class return_first(object): + @staticmethod + def reduce(x): + return x[0] + + """) + + + def _advance_pattern_generators(self,p): + """ + Subclasses can override this method to provide constraints on + the values of generators' parameters and/or eliminate + generators from this list if necessary. + """ + return p.generators + + def state_push(self): + """ + Push the state of all generators + """ + super(Composite,self).state_push() + for gen in self.generators: + gen.state_push() + + def state_pop(self): + """ + Pop the state of all generators + """ + super(Composite,self).state_pop() + for gen in self.generators: + gen.state_pop() + + # JABALERT: To support large numbers of patterns on a large input region, + # should be changed to evaluate each pattern in a small box, and then + # combine them at the full Composite Bounding box size. + def function(self,p): + """Constructs combined pattern out of the individual ones.""" + generators = self._advance_pattern_generators(p) + + assert hasattr(p.operator,'reduce'),repr(p.operator)+" does not support 'reduce'." + + # CEBALERT: mask gets applied by all PGs including the Composite itself + # (leads to redundant calculations in current lissom_oo_or usage, but + # will lead to problems/limitations in the future). + patterns = [pg(xdensity=p.xdensity,ydensity=p.ydensity, + bounds=p.bounds,mask=p.mask, + x=p.x+p.size*(pg.x*np.cos(p.orientation)- pg.y*np.sin(p.orientation)), + y=p.y+p.size*(pg.x*np.sin(p.orientation)+ pg.y*np.cos(p.orientation)), + orientation=pg.orientation+p.orientation, + size=pg.size*p.size) + for pg in generators] + image_array = p.operator.reduce(patterns) + return image_array + + + +class ChannelTransform(param.Parameterized): + """ + A ChannelTransform is a callable object that takes channels as + input (an ordered dictionary of arrays) and transforms their + contents in some way before returning them. + """ + + __abstract = True + + def __call__(self, channels): + raise NotImplementedError + + + +# Example of a ChannelTransform +class CorrelateChannels(ChannelTransform): + """ + Correlate channels by mixing a fraction of one channel into another. + """ + + from_channel = param.Number(default=1, doc=""" + Name of the channel to take data from.""") + + to_channel = param.Number(default=2, doc=""" + Name of the channel to change data of.""") + + strength = param.Number(default=0, doc=""" + Strength of the correlation to add, with 0 being no change, + and 1.0 overwriting to_channel with from_channel.""") + + def __call__(self, channel_data): + channel_data[self.to_channel] = \ + self.strength*channel_data[self.from_channel] + \ + (1-self.strength)*channel_data[self.to_channel] + + return channel_data + + + +class ChannelGenerator(PatternGenerator): + """ + Abstract base class for patterns supporting multiple channels natively. + """ + + __abstract = True + + channel_transforms = param.HookList(class_=ChannelTransform,default=[],doc=""" + Optional functions to apply post processing to the set of channels.""") + + + def __init__(self, **params): + self._original_channel_data = [] # channel data before processing + self._channel_data = [] # channel data after processing + super(ChannelGenerator, self).__init__(**params) + + + def channels(self, use_cached=False, **params_to_override): + res = collections.OrderedDict() + + if not use_cached: + default = self(**params_to_override) + res['default'] = default + else: + res['default'] = None + + for i in range(len(self._channel_data)): + res[i] = self._channel_data[i] + + return res + + def num_channels(self): + return len(self._channel_data) + + +class ComposeChannels(ChannelGenerator): + """ + Create a multi-channel PatternGenerator from a list of + PatternGenerators, with the specified channel_transforms applied. + """ + + generators = param.List(class_=PatternGenerator,default=[Constant(scale=0.0)], + bounds=(1,None), doc=""" + List of patterns to use for each channel. Generators which already have more than one + channel will only contribute to a single channel of ComposeChannels.""") + + + def __init__(self,**params): + super(ComposeChannels,self).__init__(**params) + + for i in range(len(self.generators)): + self._channel_data.append( None ) + + + def __call__(self,**params): + # Generates all channels, then returns the default channel + + p = param.ParamOverrides(self,params) + + params['xdensity']=p.xdensity + params['ydensity']=p.ydensity + params['bounds']=p.bounds + + # (not **p) + for i in range(len(p.generators)): + self._channel_data[i] = p.generators[i]( **params ) + + + for c in self.channel_transforms: + self._channel_data = c(self._channel_data) + + return sum(act for act in self._channel_data)/len(self._channel_data) diff --git a/PixHtLab-Src/Docker/imagen/build/lib/imagen/random.py b/PixHtLab-Src/Docker/imagen/build/lib/imagen/random.py new file mode 100644 index 0000000000000000000000000000000000000000..a5a0890875110c14c2007321ea8be83efb6a529d --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/build/lib/imagen/random.py @@ -0,0 +1,626 @@ +""" +Two-dimensional pattern generators drawing from various random +distributions. +""" + +import warnings +import numpy as np +import param +from param.parameterized import ParamOverrides + +from holoviews.core import SheetCoordinateSystem + +from .patterngenerator import PatternGenerator +from imagen import Composite, Gaussian +from numbergen import TimeAwareRandomState, TimeAware + + + +def seed(seed=None): + """ + Set the seed on the shared RandomState instance. + """ + warnings.warn("imagen.random.seed is deprecated; use param.random_seed instead.", FutureWarning) + RandomGenerator.random_generator.seed(seed) + + +class RandomGenerator(PatternGenerator, TimeAwareRandomState): + """ + 2D random noise pattern generator abstract class. + + This class generalizes time-controlled randomness as defined by + the numbergen.TimeAwareRandomState to imagen + patterns. Time-controlled randomness allows random scalars to be + generated as a function of time in numbergen, whereas in imagen it + allows time-dependent random patterns with higer dimensionality. + + The notion of time is defined by time_fn (inherited from + TimeAwareRandomState) which outputs the time value. The + time_dependent parameter then toggles between behaviour where a + new random pattern is generated per call and where any randomness + in the pattern is controlled as a function of time. + + By default, RandomGenerators use the same global time_fn as + numbergen objects, namely param.Dynamic.time_fn. This means that + when set to time_dependent, the facilities of param.Time can be + used. This allows the timeline to be explored non-linearly, e.g to + reproduce a pattern from an earlier time. + + For more information about time-dependent random number streams, + consult the docstring of the TimeAwareRandomState class. + """ + + __abstract = True + + # The orientation is ignored, so we don't show it in + # auto-generated lists of parameters (e.g. in the GUI) + orientation = param.Number(precedence=-1) + + random_generator = param.Parameter( + default=np.random.RandomState(seed=(500,500)),precedence=-1,doc= + """ + Using Numpy's RandomState class instead of random.Random as + the former can generate random arrays from more random + distributions. See RandomState's help for more information. + """) + + seed = param.Parameter(default=(500,500), doc=""" + Random seed used to set the random number generator. Set to + (500,500) by default for backwards compatibility.""" ) + + + def __init__(self, **params): + super(RandomGenerator, self).__init__(**params) + self._initialize_random_state(seed=self.seed, shared=True) + + def _distrib(self,shape,p): + """Method for subclasses to override with a particular random distribution.""" + raise NotImplementedError + + # Optimization: We use a simpler __call__ method here to skip the + # coordinate transformations (which would have no effect anyway) + def __call__(self,**params_to_override): + p = ParamOverrides(self,params_to_override) + if self.time_dependent: + if 'name' in p: + self._initialize_random_state(seed=self.seed, shared=True, name=p.name) + self._hash_and_seed() + + shape = SheetCoordinateSystem(p.bounds,p.xdensity,p.ydensity).shape + + result = self._distrib(shape,p) + self._apply_mask(p,result) + + for of in p.output_fns: + of(result) + + return result + + + +class UniformRandom(RandomGenerator): + """2D uniform random noise pattern generator.""" + + def _distrib(self,shape,p): + return p.random_generator.uniform(p.offset, p.offset+p.scale, shape) + + + +class UniformRandomInt(RandomGenerator): + """ + 2D distribution of integer values from low to high in the in the + half-open interval [`low`, `high`). + + Matches semantics of numpy.random.randint. + """ + + low = param.Integer(default=0, doc=""" + Lowest integer to be drawn from the distribution.""") + + high = param.Integer(default=2, doc=""" + The highest integer to be drawn from the distribution.""") + + def _distrib(self,shape,p): + return p.random_generator.randint(p.low, p.high, shape) + + + +class BinaryUniformRandom(RandomGenerator): + """ + 2D binary uniform random noise pattern generator. + + Generates an array of random numbers that are 1.0 with the given + on_probability, or else 0.0, then scales it and adds the offset as + for other patterns. For the default scale and offset, the result + is a binary mask where some elements are on at random. + """ + + on_probability = param.Number(default=0.5,bounds=[0.0,1.0],doc=""" + Probability (in the range 0.0 to 1.0) that the binary value + (before scaling) is on rather than off (1.0 rather than 0.0).""") + + def _distrib(self,shape,p): + rmin = p.on_probability-0.5 + return p.offset+p.scale*(p.random_generator.uniform(rmin,rmin+1.0,shape).round()) + + + +class GaussianRandom(RandomGenerator): + """ + 2D Gaussian random noise pattern generator. + + Each pixel is chosen independently from a Gaussian distribution + of zero mean and unit variance, then multiplied by the given + scale and adjusted by the given offset. + """ + + scale = param.Number(default=0.25,softbounds=(0.0,2.0)) + offset = param.Number(default=0.50,softbounds=(-2.0,2.0)) + + def _distrib(self,shape,p): + return p.offset+p.scale*p.random_generator.standard_normal(shape) + + +# CEBALERT: in e.g. script_repr, an instance of this class appears to +# have only pattern.Constant() in its list of generators, which might +# be confusing. The Constant pattern has no effect because the +# generators list is overridden in __call__. Shouldn't the generators +# parameter be hidden for this class (and possibly for others based on +# pattern.Composite)? For that to be safe, we'd at least have to have +# a warning if someone ever sets a hidden parameter, so that having it +# revert to the default value would always be ok. + +class GaussianCloud(Composite, TimeAware): + """Uniform random noise masked by a circular Gaussian.""" + + operator = param.Parameter(np.multiply) + + gaussian_size = param.Number(default=1.0,doc="Size of the Gaussian pattern.") + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc=""" + Ratio of gaussian width to height; width is gaussian_size*aspect_ratio.""") + + def __call__(self,**params_to_override): + p = ParamOverrides(self,params_to_override) + p.generators=[Gaussian(aspect_ratio=p.aspect_ratio,size=p.gaussian_size), + UniformRandom(name=p.name, + time_dependent=p.time_dependent, + time_fn = p.time_fn)] + return super(GaussianCloud,self).__call__(**p) + + + +### JABHACKALERT: This code seems to work fine when the input regions +### are all the same size and shape, but for +### e.g. examples/hierarchical.ty the resulting images in the Test +### Pattern preview window are square (instead of the actual +### rectangular shapes), matching between the eyes (instead of the +### actual two different rectangles), and with dot sizes that don't +### match between the eyes. It's not clear why this happens. + +### JLALERT: Not implementing time_dependent=True + +class RandomDotStereogram(PatternGenerator): + """ + Random dot stereogram using rectangular black and white patches. + + Based on Matlab code originally from Jenny Read, reimplemented + in Python by Tikesh Ramtohul (2006). + """ + + # Suppress unused parameters + x = param.Number(precedence=-1) + y = param.Number(precedence=-1) + size = param.Number(precedence=-1) + orientation = param.Number(precedence=-1) + + # Override defaults to make them appropriate + scale = param.Number(default=0.5) + offset = param.Number(default=0.5) + + # New parameters for this pattern + + #JABALERT: Should rename xdisparity and ydisparity to x and y, and simply + #set them to different values for each pattern to get disparity + xdisparity = param.Number(default=0.0,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + precedence=0.50,doc="Disparity in the horizontal direction.") + + ydisparity = param.Number(default=0.0,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + precedence=0.51,doc="Disparity in the vertical direction.") + + dotdensity = param.Number(default=0.5,bounds=(0.0,None),softbounds=(0.1,0.9), + precedence=0.52,doc="Number of dots per unit area; 0.5=50% coverage.") + + dotsize = param.Number(default=0.1,bounds=(0.0,None),softbounds=(0.05,0.15), + precedence=0.53,doc="Edge length of each square dot.") + + random_seed=param.Integer(default=500,bounds=(0,1000), + precedence=0.54,doc="Seed value for the random position of the dots.") + + + def __call__(self,**params_to_override): + p = ParamOverrides(self,params_to_override) + + xsize,ysize = SheetCoordinateSystem(p.bounds,p.xdensity,p.ydensity).shape + xsize,ysize = int(round(xsize)),int(round(ysize)) + + xdisparity = int(round(xsize*p.xdisparity)) + ydisparity = int(round(xsize*p.ydisparity)) + dotsize = int(round(xsize*p.dotsize)) + + bigxsize = 2*xsize + bigysize = 2*ysize + ndots=int(round(p.dotdensity * (bigxsize+2*dotsize) * (bigysize+2*dotsize) / + min(dotsize,xsize) / min(dotsize,ysize))) + halfdot = np.floor(dotsize/2) + + # Choose random colors and locations of square dots + random_seed = p.random_seed + + np.random.seed(random_seed*12+random_seed*99) + col=np.where(np.random.random((ndots))>=0.5, 1.0, -1.0) + + np.random.seed(random_seed*122+random_seed*799) + xpos=np.floor(np.random.random((ndots))*(bigxsize+2*dotsize)) - halfdot + + np.random.seed(random_seed*1243+random_seed*9349) + ypos=np.floor(np.random.random((ndots))*(bigysize+2*dotsize)) - halfdot + + # Construct arrays of points specifying the boundaries of each + # dot, cropping them by the big image size (0,0) to (bigxsize,bigysize) + x1=xpos.astype('l') ; x1=np.choose(np.less(x1,0),(x1,0)) + y1=ypos.astype('l') ; y1=np.choose(np.less(y1,0),(y1,0)) + x2=(xpos+(dotsize-1)).astype('l') ; x2=np.choose(np.greater(x2,bigxsize),(x2,bigxsize)) + y2=(ypos+(dotsize-1)).astype('l') ; y2=np.choose(np.greater(y2,bigysize),(y2,bigysize)) + + # Draw each dot in the big image, on a blank background + bigimage = np.zeros((bigysize,bigxsize)) + for i in range(ndots): + bigimage[y1[i]:y2[i]+1,x1[i]:x2[i]+1] = col[i] + + result = p.offset + p.scale*bigimage[ (ysize/2)+ydisparity:(3*ysize/2)+ydisparity , + (xsize/2)+xdisparity:(3*xsize/2)+xdisparity ] + + for of in p.output_fns: + of(result) + + return result + + + + +class DenseNoise(RandomGenerator): + """ + 2D Dense noise pattern generator, constrained to a grid. + + Similar to UniformRandom, but draws the noise pattern in a grid + that can be smaller than the actual density of the + PatternGenerator. + + By default, this produces a matrix with random values 0.0, 0.5, and 1. + When a scale and an offset are provided the transformation maps them to: + + 0 -> offset + 0.5 -> offset + 0.5 * scale + 1 -> offset + scale + + -------- + Examples + -------- + + DenseNoise(grid_density=1, bounds=BoundingBox(radius=1), + xdensity=4, ydensity=4) will produce something like this: + + [[ 1. 1. 1. 1. 0. 0. 0. 0. ] + [ 1. 1. 1. 1. 0. 0. 0. 0. ] + [ 1. 1. 1. 1. 0. 0. 0. 0. ] Here the Sheet-coordinate size is 2.0x2.0, + [ 1. 1. 1. 1. 0. 0. 0. 0. ] so grid_density=1 yields a 2x2 grid + [ 0. 0. 0. 0. 0.5 0.5 0.5 0.5] sampled at 4 units per grid cell + [ 0. 0. 0. 0. 0.5 0.5 0.5 0.5] + [ 0. 0. 0. 0. 0.5 0.5 0.5 0.5] + [ 0. 0. 0. 0. 0.5 0.5 0.5 0.5]]) + + + + DenseNoise(grid_density=2, bounds=BoundingBox(radius=1), + xdensity=4, ydensity=4) on the other hand will produce something like: + + [[ 1. 1. 0. 0. 0. 0. 0.5 0.5] + [ 1. 1. 0. 0. 0. 0. 0.5 0.5] + [ 1. 1. 1. 1. 0. 0. 0. 0. ] Again the Sheet-coordinate size is 2.0x2.0, + [ 1. 1. 1. 1. 0. 0. 0. 0. ] but grid_density=2 yields a 4x4 grid + [ 0. 0. 0.5 0.5 1. 1. 1. 1. ] with 2 units per grid cell + [ 0. 0. 0.5 0.5 1. 1. 1. 1. ] + [ 1. 1. 0. 0. 1. 1. 1. 1. ] + [ 1. 1. 0. 0. 1. 1. 1. 1. ]] + + ----- + Notes + ----- + + 1. This method works much faster when the noise matrix falls neatly + into the pixel matrix (~100 times faster). + + 2. The value of each pixel in the generated pattern is determined + by where the center of that pixel lies in the underlying grid, + regardless of any overlap of that pixel with other grid + squares. + + 3. If a particular number of cells N is wanted, divide it by the + length of the side of the bounding box to determine the + grid_density. For example, if the user wants to have N=10 cells + for a BoundingBox(radius=1) (which gives a bounding box size of + 2.0x2.0), the grid_density must be set to N/2 = 5 in order to + have ten cells. + + 4. The xdensity and ydensity must both be at least as large as the + grid_density, e.g. 5 for the above example. + """ + + grid_density = param.Number(default=10, bounds=(1,None), softbounds=(1,50), doc=""" + Grid elements per 1.0 distance in Sheet coordinates.""") + + # Hide unused parameters + x = param.Number(precedence=-1) + y = param.Number(precedence=-1) + size = param.Number(precedence=-1) + + + def _distrib(self, shape, p): + max_density = min(p.xdensity,p.ydensity) + if (p.grid_density > max_density and not hasattr(self,"warned_about_density")): + self.warning("Requested grid_density %s larger than xdensity %s or ydensity %s; capped at %s" % + (p.grid_density,p.xdensity,p.ydensity,max_density)) + p.grid_density = max_density + self.warned_about_density=True + + Nx = shape[1] + Ny = shape[0] # Size of the pixel matrix + + assert (Nx>0 and Ny>0), 'Pixel matrix cannot be zero' + + SC = SheetCoordinateSystem(p.bounds, p.xdensity, p.ydensity) + unitary_distance_x = SC._SheetCoordinateSystem__xstep + unitary_distance_y = SC._SheetCoordinateSystem__ystep + + + sheet_x_size = unitary_distance_x * Nx + sheet_y_size = unitary_distance_y * Ny + + # Sizes of the structure matrix + nx = int(round(sheet_x_size * p.grid_density)) # Number of points in the x's + ny = int(round(sheet_y_size * p.grid_density)) # Number of points in the y's + + assert ( nx > 0 ), 'Grid density or bound box in the x dimension too small' + assert ( ny > 0 ), 'Grid density or bound box in the y dimension too small' + + # If the noise grid is proportional to the pixel grid and fits + # neatly into it then this method is ~100 times faster + if ( Nx % nx == 0) and (Ny % ny == 0): + + if (Nx == nx) and (Ny == ny): #This is faster to call the whole procedure + result = 0.5 * (p.random_generator.randint(-1, 2, shape) + 1) + return result * p.scale + p.offset + + else: + # This is the actual matrix of the pixels + A = np.zeros(shape) + # Noise matrix that contains the structure of 0, 0.5, and 1's + Z = 0.5 * (p.random_generator.randint(-1, 2, (nx, ny)) + 1 ) + + ps_x = int(round(Nx * 1.0/ nx)) #Closest integer + ps_y = int(round(Ny * 1.0/ ny)) + + # Noise matrix is mapped to the pixel matrix + for i in range(nx): + for j in range(ny): + A[i * ps_y: (i + 1) * ps_y, j * ps_x: (j + 1) * ps_x] = Z[i,j] + + return A * p.scale + p.offset + + # General method in case the noise grid does not + # fall neatly in the pixel grid + else: + + # Obtain length of the side and length of the + # division line between the grid + x_points,y_points = SC.sheetcoordinates_of_matrixidx() + + # This is the actual matrix of the pixels + A = np.zeros(shape) + # Noise matrix that contains the structure of 0, 0.5, and 1's + Z = 0.5 * (p.random_generator.randint(-1, 2, (nx, ny)) + 1 ) + + size_of_block_x = Nx * 1.0 / nx + size_of_block_y = Ny * 1.0 / ny + + # Noise matrix is mapped to the pixel matrix + for i in range(Nx): + for j in range(Ny): + # Map along the x coordinates + x_entry = int( i / size_of_block_x) + y_entry = int( j / size_of_block_y) + A[j][i] = Z[x_entry][y_entry] + + return A * p.scale + p.offset + + + +class SparseNoise(RandomGenerator): + """ + 2D sparse noise pattern generator, with optional constraining to a grid. + + Draws a square pixel of random brightness at a random location, + either entirely random on the pattern surface or chosen from a + predefined grid of possible positions. + + By default, produces a matrix with 0.5 everywhere except for a + square patch in one random location. This value is randomly + assigned to either 0 or 1, and then is scaled with the parameters + scale and offset in the following way: + + 0 -> offset + 1 -> offset + scale + + -------- + Examples + -------- + + SparseNoise(grid_density=1, grid=True, bounds=BoundingBox(radius=1), + xdensity=4, ydensity=4) will produce something like this: + + [[ 0.5 0.5 0.5 0.5 0. 0. 0. 0. ] + [ 0.5 0.5 0.5 0.5 0. 0. 0. 0. ] + [ 0.5 0.5 0.5 0.5 0. 0. 0. 0. ] Here the Sheet-coordinate size is 2.0x2.0, + [ 0.5 0.5 0.5 0.5 0. 0. 0. 0. ] so grid_density=1 yields a 2x2 grid + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] sampled at 4 units per grid cell, with 0.5 + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] everywhere except the one active cell + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5]] + + SparseNoise(grid_density=2, grid=True, bounds=BoundingBox(radius=1), + xdensity=4, ydensity=4) on the other hand will produce something like: + + [[ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] Again the Sheet-coordinate size is 2.0x2.0, + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] but grid_density=2 yields a 4x4 grid + [ 0.5 0.5 0.5 0.5 0.5 0.5 1. 1. ] with 2 units per grid cell + [ 0.5 0.5 0.5 0.5 0.5 0.5 1. 1. ] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5]] + + SparseNoise(grid_density=2, grid=False, bounds=BoundingBox(radius=1), + xdensity=4, ydensity=4) will produce something like: + + [[ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] Here notice that the patch is no longer + [ 0.5 0.5 0.5 0.5 0.5 0. 0. 0.5] aligned with a fixed grid + [ 0.5 0.5 0.5 0.5 0.5 0. 0. 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5]] + + + ----- + Notes + ----- + + 1. This method works ~100 times faster when the noise matrix falls neatly + into the pixel matrix. + + 2. The value of each pixel in the generated pattern is determined + by where the center of that pixel lies in the underlying grid, + regardless of any overlap of that pixel with other grid + squares. + + 3. If a particular number of cells N is wanted, divide it by the + length of the side of the bounding box to determine the + grid_density. For example, if the user wants to have N=10 cells + for a BoundingBox(radius=1) (which gives a bounding box size of + 2.0x2.0), the grid_density must be set to N/2 = 5 in order to + have ten cells. + + 4. The xdensity and ydensity must both be at least as large as the + grid_density, e.g. 5 for the above example. + """ + + grid_density = param.Number(default=10, bounds=(1,None), softbounds=(1,50), doc=""" + Grid elements per 1.0 distance in Sheet coordinates.""") + + grid = param.Boolean(default=True, doc=""" + If True, each spot is snapped to a grid, so that subsequent + spots are forced to overlap either entirely or not at all, + never partially. Otherwise, the spot size is fixed by the + grid_density, but it may appear anywhere.""") + + + # Hide unused parameters + x = param.Number(precedence=-1) + y = param.Number(precedence=-1) + size = param.Number(precedence=-1) + + def _distrib(self, shape, p): + max_density = min(p.xdensity,p.ydensity) + if (p.grid_density > max_density and not hasattr(self,"warned_about_density")): + self.warning("Requested grid_density %s larger than xdensity %s or ydensity %s; capped at %s" % + (p.grid_density,p.xdensity,p.ydensity,max_density)) + p.grid_density = max_density + self.warned_about_density=True + + Nx = shape[1] + Ny = shape[0] # Size of the pixel matrix + + assert (Nx>0 and Ny>0), 'Pixel matrix cannot be zero' + + SC = SheetCoordinateSystem(p.bounds, p.xdensity, p.ydensity) + unitary_distance_x = SC._SheetCoordinateSystem__xstep + unitary_distance_y = SC._SheetCoordinateSystem__ystep + + sheet_x_size = unitary_distance_x * Nx + sheet_y_size = unitary_distance_y * Ny + + # Sizes of the structure matrix + nx = int(round(sheet_x_size * p.grid_density)) # Number of points in the x's + ny = int(round(sheet_y_size * p.grid_density)) # Number of points in the y's + + assert ( nx > 0 ), 'Grid density or bound box in the x dimension too small' + assert ( ny > 0 ), 'Grid density or bound box in the y dimension too smal' + + ps_x = int(round(Nx / nx)) #Closest integer + ps_y = int(round(Ny / ny)) + + # This is the actual matrix of the pixels + A = np.ones(shape) * 0.5 + + if p.grid == False: #The centers of the spots are randomly distributed in space + + x = p.random_generator.randint(0, Nx - ps_x + 1) + y = p.random_generator.randint(0, Ny - ps_y + 1) + z = p.random_generator.randint(0,2) + + # Noise matrix is mapped to the pixel matrix + A[x: (x + ps_y), y: (y + ps_x)] = z + + return A * p.scale + p.offset + + else: #In case you want the grid + + if ( Nx % nx == 0) and (Ny % ny == 0): #When the noise grid falls neatly into the the pixel grid + x = p.random_generator.randint(0, nx) + y = p.random_generator.randint(0, ny) + z = p.random_generator.randint(0,2) + + # Noise matrix is mapped to the pixel matrix (faster method) + A[x*ps_y: (x*ps_y + ps_y), y*ps_x: (y*ps_x + ps_x)] = z + + return A * p.scale + p.offset + + else: # If noise grid does not fit neatly in the pixel grid (slow method) + + x_points,y_points = SC.sheetcoordinates_of_matrixidx() + + # Obtain length of the side and length of the + # division line between the grid + + size_of_block_x = Nx * 1.0 / nx + size_of_block_y = Ny * 1.0 / ny + + # Construct the noise matrix + Z = np.ones((nx,ny)) * 0.5 + x = p.random_generator.randint(0, nx) + y = p.random_generator.randint(0, ny) + z = p.random_generator.randint(0,2) + Z[x,y] = z + + # Noise matrix is mapped to the pixel matrix + for i in range(Nx): + for j in range(Ny): + # Map along the x coordinates + x_entry = int( i / size_of_block_x) + y_entry = int( j / size_of_block_y) + A[j][i] = Z[x_entry][y_entry] + + return A * p.scale + p.offset diff --git a/PixHtLab-Src/Docker/imagen/build/lib/imagen/transferfn/__init__.py b/PixHtLab-Src/Docker/imagen/build/lib/imagen/transferfn/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bfe5a56b597ec14ff63e0524fbaf52d009c60eff --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/build/lib/imagen/transferfn/__init__.py @@ -0,0 +1,303 @@ +""" +TransferFns: accept and modify a 2d array +""" + +import numpy +import copy +import param + + +class TransferFn(param.Parameterized): + """ + Function object to modify a matrix in place, e.g. for normalization. + + Used for transforming an array of intermediate results into a + final version, by cropping it, normalizing it, squaring it, etc. + + Objects in this class must support being called as a function with + one matrix argument, and are expected to change that matrix in place. + """ + __abstract = True + + init_keys = param.List(default=[], constant=True, doc=""" + List of item key labels for metadata that that must be + supplied to the initialize method before the TransferFn may be + used.""") + + # CEBALERT: can we have this here - is there a more appropriate + # term for it, general to output functions? JAB: Please do rename it! + norm_value = param.Parameter(default=None) + + def initialize(self, **kwargs): + """ + Transfer functions may need additional information before the + supplied numpy array can be modified in place. For instance, + transfer functions may have state which needs to be allocated + in memory with a certain size. In other cases, the transfer + function may need to know about the coordinate system + associated with the input data. + """ + if not set(kwargs.keys()).issuperset(self.init_keys): + raise Exception("TransferFn needs to be initialized with %s" + % ','.join(repr(el) for el in self.init_keys)) + + def __call__(self,x): + raise NotImplementedError + + +class TransferFnWithState(TransferFn): + """ + Abstract base class for TransferFns that need to maintain a + self.plastic parameter. + + These TransferFns typically maintain some form of internal history + or other state from previous calls, which can be disabled by + override_plasticity_state(). + """ + + plastic = param.Boolean(default=True, doc=""" + Whether or not to update the internal state on each call. + Allows plasticity to be temporarily turned off (e.g for + analysis purposes).""") + + __abstract = True + + def __init__(self,**params): + super(TransferFnWithState,self).__init__(**params) + self._plasticity_setting_stack = [] + + + def override_plasticity_state(self, new_plasticity_state): + """ + Temporarily disable plasticity of internal state. + + This function should be implemented by all subclasses so that + after a call, the output should always be the same for any + given input pattern, and no call should have any effect that + persists after restore_plasticity_state() is called. + + By default, simply saves a copy of the 'plastic' parameter to + an internal stack (so that it can be restored by + restore_plasticity_state()), and then sets the plastic + parameter to the given value (True or False). + """ + self._plasticity_setting_stack.append(self.plastic) + self.plastic=new_plasticity_state + + + def restore_plasticity_state(self): + """ + Re-enable plasticity of internal state after an + override_plasticity_state call. + + This function should be implemented by all subclasses to + remove the effect of the most recent override_plasticity_state call, + i.e. to reenable changes to the internal state, without any + lasting effect from the time during which plasticity was disabled. + + By default, simply restores the last saved value of the + 'plastic' parameter. + """ + self.plastic = self._plasticity_setting_stack.pop() + + def state_push(self): + """ + Save the current state onto a stack, to be restored with + state_pop. + + Subclasses must implement state_push and state_pop to store + state across invocations. The behaviour should be such that + after state_pop, the state is restored to what it was at + the time when state_push was called. + """ + pass + + def state_pop(self): + """ + Restore the state saved by the most recent state_push call. + """ + pass + + + +class IdentityTF(TransferFn): + """ + Identity function, returning its argument as-is. + + For speed, calling this function object is sometimes optimized + away entirely. To make this feasible, it is not allowable to + derive other classes from this object, modify it to have different + behavior, add side effects, or anything of that nature. + """ + + def __call__(self,x,sum=None): + pass + + +class Scale(TransferFn): + """ + Multiply the input array by some constant factor. + """ + + scale = param.Number(default=1.0, doc=""" + The multiplicative factor that scales the input values.""") + + def __call__(self, x): + x *= self.scale + + + +class Threshold(TransferFn): + """ + Forces all values below a threshold to zero, and leaves others unchanged. + """ + + threshold = param.Number(default=0.25, doc=""" + Decision point for determining values to clip.""") + + def __call__(self,x): + numpy.minimum(x,self.threshold,x) + + + +class BinaryThreshold(TransferFn): + """ + Forces all values below a threshold to zero, and above it to 1.0. + """ + + threshold = param.Number(default=0.25, doc=""" + Decision point for determining binary value.""") + + def __call__(self,x): + above_threshold = x>=self.threshold + x *= 0.0 + x += above_threshold + + + +class DivisiveNormalizeL1(TransferFn): + """ + TransferFn that divides an array by its L1 norm. + + This operation ensures that the sum of the absolute values of the + array is equal to the specified norm_value, rescaling each value + to make this true. The array is unchanged if the sum of absolute + values is zero. For arrays of non-negative values where at least + one is non-zero, this operation is equivalent to a divisive sum + normalization. + """ + norm_value = param.Number(default=1.0) + + def __call__(self,x): + """L1-normalize the input array, if it has a nonzero sum.""" + current_sum = 1.0*numpy.sum(abs(x.ravel())) + if current_sum != 0: + factor = (self.norm_value/current_sum) + x *= factor + + + +class DivisiveNormalizeL2(TransferFn): + """ + TransferFn to divide an array by its Euclidean length (aka its L2 norm). + + For a given array interpreted as a flattened vector, keeps the + Euclidean length of the vector at a specified norm_value. + """ + norm_value = param.Number(default=1.0) + + def __call__(self,x): + xr = x.ravel() + tot = 1.0*numpy.sqrt(numpy.dot(xr,xr)) + if tot != 0: + factor = (self.norm_value/tot) + x *= factor + + + +class DivisiveNormalizeLinf(TransferFn): + """ + TransferFn to divide an array by its L-infinity norm + (i.e. the maximum absolute value of its elements). + + For a given array interpreted as a flattened vector, scales the + elements divisively so that the maximum absolute value is the + specified norm_value. + + The L-infinity norm is also known as the divisive infinity norm + and Chebyshev norm. + """ + norm_value = param.Number(default=1.0) + + def __call__(self,x): + tot = 1.0*(numpy.abs(x)).max() + if tot != 0: + factor = (self.norm_value/tot) + x *= factor + + + +def norm(v,p=2): + """ + Returns the Lp norm of v, where p is an arbitrary number defaulting to 2. + """ + return (numpy.abs(v)**p).sum()**(1.0/p) + + + +class DivisiveNormalizeLp(TransferFn): + """ + TransferFn to divide an array by its Lp-Norm, where p is specified. + + For a parameter p and a given array interpreted as a flattened + vector, keeps the Lp-norm of the vector at a specified norm_value. + Faster versions are provided separately for the typical L1-norm + and L2-norm cases. Defaults to be the same as an L2-norm, i.e., + DivisiveNormalizeL2. + """ + p = param.Number(default=2) + norm_value = param.Number(default=1.0) + + def __call__(self,x): + tot = 1.0*norm(x.ravel(),self.p) + if tot != 0: + factor = (self.norm_value/tot) + x *=factor + + +class Hysteresis(TransferFnWithState): + """ + Smoothly interpolates a matrix between simulation time steps, with + exponential falloff. + """ + + time_constant = param.Number(default=0.3,doc=""" + Controls the time scale of the interpolation.""") + + def __init__(self,**params): + super(Hysteresis,self).__init__(**params) + self.first_call = True + self.__current_state_stack=[] + self.old_a = 0 + + def __call__(self,x): + if self.first_call is True: + self.old_a = x.copy() * 0.0 + self.first_call = False + + new_a = x.copy() + self.old_a = self.old_a + (new_a - self.old_a)*self.time_constant + x*=0 + x += self.old_a + + def reset(self): + self.old_a *= 0 + + def state_push(self): + self.__current_state_stack.append((copy.copy(self.old_a), + copy.copy(self.first_call))) + super(Hysteresis,self).state_push() + + def state_pop(self): + self.old_a,self.first_call = self.__current_state_stack.pop() + super(Hysteresis,self).state_pop() diff --git a/PixHtLab-Src/Docker/imagen/build/lib/imagen/transferfn/sheet_tf.py b/PixHtLab-Src/Docker/imagen/build/lib/imagen/transferfn/sheet_tf.py new file mode 100644 index 0000000000000000000000000000000000000000..4a2e0e5769008f0f7918167ba43604da46064736 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/build/lib/imagen/transferfn/sheet_tf.py @@ -0,0 +1,62 @@ +""" +A family of transfer functions that are aware of sheet coordinate +systems. + +The transfer functions in this file are allowed to make use of Imagen +patterns and are to be supplied with an appropriate +SheetCoordinateSystem object via the initialize method. +""" + +import numpy as np + +import param +import copy +from imagen import PatternGenerator, Gaussian +from imagen.transferfn import TransferFn + + +class Convolve(TransferFn): + """ + Transfer function that convolves the array data with the supplied + kernel pattern. + + The bounds and densities of the supplied kernel pattern do not + affect the convolution operation. The spatial scale of the + convolution is determined by the 'size' parameter of the + kernel. The resulting convolution is applied of a spatial scale + relative to the overall size of the input, as expressed in + sheetcoordinates. + """ + + kernel_pattern = param.ClassSelector(PatternGenerator, + default=Gaussian(size=0.05,aspect_ratio=1.0), doc=""" + The kernel pattern used in the convolution. The default kernel + results in an isotropic Gaussian blur.""") + + init_keys = param.List(default=['SCS'], constant=True) + + def __init__(self, **params): + super(Convolve,self).__init__(**params) + + + def initialize(self, **kwargs): + super(Convolve, self).initialize(**kwargs) + scs = kwargs['SCS'] + pattern_copy = copy.deepcopy(self.kernel_pattern) + pattern_copy.set_matrix_dimensions(self.kernel_pattern.bounds, + scs.xdensity, + scs.ydensity) + self.kernel = pattern_copy() + + def __call__(self, x): + if not hasattr(self, 'kernel'): + raise Exception("Convolve must be initialized before being called.") + fft1 = np.fft.fft2(x) + fft2 = np.fft.fft2(self.kernel, s=x.shape) + convolved_raw = np.fft.ifft2( fft1 * fft2).real + + k_rows, k_cols = self.kernel.shape # ORIGINAL + rolled = np.roll(np.roll(convolved_raw, -(k_cols//2), axis=-1), -(k_rows//2), axis=-2) + convolved = rolled / float(self.kernel.sum()) + x.fill(0.0) + x+=convolved diff --git a/PixHtLab-Src/Docker/imagen/doc/Makefile b/PixHtLab-Src/Docker/imagen/doc/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..5174d3fb9881f885ac76f0a07f6a984447e0a0a9 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/doc/Makefile @@ -0,0 +1,11 @@ +# Makefile for Sphinx documentation +# + +PROJECT = 'ImaGen' +MODULE = 'imagen' + +include ./builder/Makefile +export + +%: + $(MAKE) -f ./builder/Makefile $(CFLAGS) diff --git a/PixHtLab-Src/Docker/imagen/doc/Tutorials/hegde_cc07.ipynb b/PixHtLab-Src/Docker/imagen/doc/Tutorials/hegde_cc07.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..00fff3cd7ebe85ad15ceae1f2809583dede03289 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/doc/Tutorials/hegde_cc07.ipynb @@ -0,0 +1,283 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visual patterns from Hegde and Van Essen (2007)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visual test patterns implemented by Jiri Machalek and James A. Bednar from:\n", + "\n", + "J. Hegde and D. Van Essen, A comparative study of shape representation in macaque visual areas V2 and V4, Cerebral Cortex (2007) 17:1100-1116. http://dx.doi.org/10.1093/cercor/bhl020\n", + "\n", + "\n", + "Includes various grating and contour stimuli subclasses. Stimuli from one subclass have common shape characteristics but vary in orientation, size and/or spatial frequency. Patterns have not been matched bit for bit to the originals, but should be reasonably equivalent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import imagen as ig\n", + "import numpy as np\n", + "import holoviews as hv\n", + "hv.notebook_extension(\"matplotlib\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%output dpi=150 size=100\n", + "%opts Layout [sublabel_format=\"\" vertical_spacing=0.05 horizontal_spacing=0.05] Image (cmap='gray') [show_xaxis=None show_yaxis=None show_frame=True]\n", + "from imagen import *\n", + "variants = 4 # Number of variants for each subclass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "orientations = (i*np.pi/variants for i in range(variants)) \n", + "frequencies = [2.0, 3.1, 4.2]\n", + "sin = {(o, f): SineGrating(phase=np.pi/2, frequency=f,orientation=o)\n", + " for o in orientations for f in frequencies}\n", + "sinusoidal = hv.NdLayout({k:v[:] for k,v in sin.items()}, key_dimensions=['Orientation', 'Frequency']) \n", + "sinusoidal.cols(6)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "size_thickness = zip([0.18, 0.27, 0.36], [0.015, 0.03, 0.04])\n", + "orientations = (i*np.pi/(2*variants) for i in range(variants))\n", + "hyp = {(s, t, o): HyperbolicGrating(size=s, thickness=t, orientation=o)\n", + " for o in orientations for (s, t) in size_thickness}\n", + "hyperbolic = hv.NdLayout({k:v[:] for k,v in hyp.items()}, key_dimensions=['Size', 'Thickness', 'Orientation'])\n", + "hyperbolic.cols(6)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pol1 = [ConcentricRings(size=0.35/(1+j*0.5),thickness=0.05/(1+j*0.35),smoothing=0.05/(1+j*0.15)) for j in range(variants)]\n", + "\n", + "pol2 = [SpiralGrating(parts=(j+1)*2,turning=0.19+0.30*j,smoothing=0.110+0.015*j) for j in range(variants)]\n", + "pol3 = [SpiralGrating(parts=(j+1)*2,turning=0.09+0.13*j,smoothing=0.050+0.006*j) for j in range(variants)]\n", + "pol4 = [SpiralGrating(parts=(j+1)*2,turning=0.06+0.09*j,smoothing=0.035+0.006*j) for j in range(variants)]\n", + "pol5 = [SpiralGrating(parts=(j+1)*2,turning=0.05+0.07*j,smoothing=0.030+0.003*j) for j in range(variants)]\n", + "\n", + "pol6 = [RadialGrating(parts=(j+1)*2) for j in range(variants)]\n", + "\n", + "polar = pol1 + pol2 + pol3 + pol4 + pol5 + pol6\n", + "\n", + "hv.Layout([p[:] for p in polar]).cols(8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "bar1 = [Rectangle(orientation=j*np.pi/4,smoothing=0.015,aspect_ratio=0.1,size=0.5)\n", + " for j in range(variants)]\n", + "bar2 = [Rectangle(orientation=j*np.pi/4,smoothing=0.015,aspect_ratio=0.2,size=0.25)\n", + " for j in range(variants)]\n", + "bar = bar1 + bar2\n", + "hv.Layout([p[:] for p in bar]).cols(8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "star1 = [Asterisk(parts=3, size=0.50, orientation=j*np.pi/2) for j in range(variants)]\n", + "star2 = [Asterisk(parts=3, size=0.25, orientation=j*np.pi/2) for j in range(variants)]\n", + "tristar = star1 + star2\n", + "hv.Layout([p[:] for p in tristar]).cols(8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "star3 = [Asterisk(parts=4, size=0.50, orientation=j*np.pi/8) for j in range(variants)]\n", + "star4 = [Asterisk(parts=4, size=0.25, orientation=j*np.pi/8) for j in range(variants)]\n", + "cross = star3 + star4\n", + "hv.Layout([p[:] for p in cross]).cols(8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "star5 = [Asterisk(parts=5, size=0.50, orientation=j*np.pi) for j in range(2)]\n", + "star5+= [Asterisk(parts=6, size=0.50)]\n", + "star5+= [Ring(smoothing=0.015,thickness=0.05,size=0.5)]\n", + "star6 = [Asterisk(parts=5, size=0.25, orientation=j*np.pi) for j in range(2)]\n", + "star6+= [Asterisk(parts=6, size=0.25)]\n", + "star6+= [Ring(smoothing=0.015,thickness=0.05,size=0.25)]\n", + "star = star5 + star6\n", + "hv.Layout([p[:] for p in star]).cols(8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ang1 = [Angle(size=0.50,angle=np.pi/8, orientation=j*2*np.pi/variants) for j in range(variants)]\n", + "ang2 = [Angle(size=0.25,angle=np.pi/8, orientation=j*2*np.pi/variants) for j in range(variants)]\n", + "acute = ang1 + ang2\n", + "hv.Layout([p[:] for p in acute]).cols(8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ang3 = [Angle(size=0.50,angle=np.pi/4, orientation=j*2*np.pi/variants) for j in range(variants)]\n", + "ang4 = [Angle(size=0.25,angle=np.pi/4, orientation=j*2*np.pi/variants) for j in range(variants)]\n", + "right = ang3 + ang4\n", + "hv.Layout([p[:] for p in right]).cols(8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ang5 = [Angle(size=0.50,angle=np.pi/3, orientation=j*2*np.pi/variants) for j in range(variants)]\n", + "ang6 = [Angle(size=0.25,angle=np.pi/3, orientation=j*2*np.pi/variants) for j in range(variants)]\n", + "obtuse = ang5 + ang6\n", + "hv.Layout([p[:] for p in obtuse]).cols(8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "arc1 = [ArcCentered(arc_length=np.pi/2,smoothing=0.015,thickness=0.05,size=0.50, orientation=i*2*np.pi/variants)\n", + " for i in range(variants)]\n", + "arc2 = [ArcCentered(arc_length=np.pi/2,smoothing=0.015,thickness=0.05,size=0.25,orientation=i*2*np.pi/variants)\n", + " for i in range(variants)]\n", + "quarter = arc1 + arc2\n", + "hv.Layout([p[:] for p in quarter]).cols(8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "arc3 = [ArcCentered(arc_length=np.pi,smoothing=0.015,thickness=0.05,size=0.5,orientation=i*2*np.pi/variants)\n", + " for i in range(variants)]\n", + "arc4 = [ArcCentered(arc_length=np.pi,smoothing=0.015,thickness=0.05,size=0.25,orientation=i*2*np.pi/variants)\n", + " for i in range(variants)]\n", + "semi = arc3 + arc4\n", + "hv.Layout([p[:] for p in semi]).cols(8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "arc5 = [ArcCentered(arc_length=3*np.pi/2,smoothing=0.015,thickness=0.05,size=0.50,orientation=i*2*np.pi/variants)\n", + " for i in range(variants)]\n", + "arc6 = [ArcCentered(arc_length=3*np.pi/2,smoothing=0.015,thickness=0.05,size=0.25,orientation=i*2*np.pi/variants)\n", + " for i in range(variants)]\n", + "threeqtrs = arc5 + arc6\n", + "hv.Layout([p[:] for p in threeqtrs]).cols(8)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "concentric_like = pol1 + pol2[1:] + pol3[2:] + pol4[2:] + pol5[3:]\n", + "radial_like = pol2[:1] + pol3[:2] + pol4[:2] + pol5[:3] + pol6\n", + "\n", + "grating_stimuli_subclasses = [list(sin.values()), list(hyp.values()), concentric_like, radial_like]\n", + "grating_stimuli_subclasses_labels = ['sinusoidal''hyperbolic','concentric-like','radial-like']\n", + "\n", + "contour_stimuli_subclasses = [bar,tristar,cross,star,acute,right,obtuse,quarter,semi,threeqtrs]\n", + "contour_stimuli_subclasses_labels = ['bar','tri-star','cross','star/circle','acute angle',\n", + " 'right angle','obtuse angle','quarter arc','semi-circle','3/4 arc']\n", + "\n", + "all_stimuli_subclasses = grating_stimuli_subclasses + contour_stimuli_subclasses\n", + "all_stimuli_subclasses_labels = grating_stimuli_subclasses_labels + contour_stimuli_subclasses_labels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Can view all patterns at once if you wish:\n", + "\n", + "```python\n", + "hv.Layout([p[:] for c in all_stimuli_subclasses for p in c]).cols(8)\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.13" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/PixHtLab-Src/Docker/imagen/doc/Tutorials/index.rst b/PixHtLab-Src/Docker/imagen/doc/Tutorials/index.rst new file mode 100644 index 0000000000000000000000000000000000000000..a1087f983535c572c7cd4a7c54345e0d0a7b8249 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/doc/Tutorials/index.rst @@ -0,0 +1,9 @@ +**************** +ImaGen Tutorials +**************** + +The main home page shows how to use ImaGen in general. Examples +focusing on specific domains are included here: + +* `Hegde and Van Essen (2007): `_ + Sample visual test patterns used to measure neural response properties. diff --git a/PixHtLab-Src/Docker/imagen/doc/_templates/page.html b/PixHtLab-Src/Docker/imagen/doc/_templates/page.html new file mode 100644 index 0000000000000000000000000000000000000000..578ae48f3af15d440e1fea1b1362357e53054ebf --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/doc/_templates/page.html @@ -0,0 +1,65 @@ +{% extends "!page.html" %} +{# add our custom css and js #} +{% set css_files = css_files + ["_static/bootstrap.css", "_static/custom.css"] %} +{% set script_files = script_files + ["_static/custom.js", "_static/require.js"] %} + +{% if 'Tutorial' in pagename %} +{% set abs_path = "http://ioam.github.io/imagen/" %} +{% else %} +{% set abs_path = "" %} +{% endif %} + +{# the menu at the top #} +{% block rootrellink %} +{% if 'Tutorial' in pagename %} +
  • ImaGen Home
    • +
  • Tutorials
    • +
  • Reference Manual
    • +{% else %} +
  • ImaGen Home
    • +
  • Tutorials
    • +
  • Reference Manual
    • +{% endif %} +{# display "Current section:" when in a manual subpage #} +{% if parents %} +
    • +{% endif %} + +{% endblock %} + +{# close the above #} +{% block relbaritems %} +{% if parents %} +
    • +{% endif %} +{% endblock %} + +{% block sidebarsourcelink %} +

    {{ _('This Page') }}

    + +{% endblock %} + +{% block sidebartoc %} +

    ImaGen

    + +

    {{ _('Table Of Contents') }}

    +{% else %} +
  • Home
    • +
  • Tutorials
    • +
  • Reference Manual
    • +
  • Github Source Code
    • +
  • Site Map
    • + +

    {{ _('Table Of Contents') }}

    +{% endif %} +{{ toc }} +{% endblock %} diff --git a/PixHtLab-Src/Docker/imagen/doc/conf.py b/PixHtLab-Src/Docker/imagen/doc/conf.py new file mode 100644 index 0000000000000000000000000000000000000000..d7f02bafc9a5e4eb9405bd0d749a7324a6db3b4b --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/doc/conf.py @@ -0,0 +1,90 @@ +# -*- coding: utf-8 -*- + +import sys, os +sys.path.append(os.path.dirname(os.path.abspath(__file__))) + +from builder.shared_conf import * # pyflakes:ignore (API import) + +paths = ['../param/', '../holoviews/', '.', '..'] +add_paths(paths) + +# General information about the project. +project = u'ImaGen' +copyright = u'2014, IOAM' + +# The version info for the project you're documenting, acts as replacement for +# |version| and |release|, also used in various other places throughout the +# built documents. +# +# The short X.Y version. +version = '1.0' +# The full version, including alpha/beta/rc tags. +release = '1.0-dev' + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +exclude_patterns = ['_build', 'test_data', 'reference_data', 'nbpublisher', + 'builder'] + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ['_static', 'builder/_shared_static'] + +# Output file base name for HTML help builder. +htmlhelp_basename = 'ImaGendoc' + + +# -- Options for LaTeX output -------------------------------------------------- + +# Grouping the document tree into LaTeX files. List of tuples +# (source start file, target name, title, author, documentclass [howto/manual]). +latex_documents = [ + ('index', 'ImaGen.tex', u'ImaGen Documentation', + u'IOAM', 'manual'), +] + + +# -- Options for manual page output -------------------------------------------- + +# One entry per manual page. List of tuples +# (source start file, name, description, authors, manual section). +man_pages = [ + ('index', 'imagen', u'ImaGen Documentation', + [u'IOAM'], 1) +] + +# If true, show URL addresses after external links. +#man_show_urls = False + + +# -- Options for Texinfo output ------------------------------------------------ + +# Grouping the document tree into Texinfo files. List of tuples +# (source start file, target name, title, author, +# dir menu entry, description, category) +texinfo_documents = [ + ('index', 'ImaGen', u'ImaGen Documentation', + u'IOAM', 'ImaGen', 'One line description of project.', + 'Miscellaneous'), +] + + +# Example configuration for intersphinx: refer to the Python standard library. +intersphinx_mapping = {'http://docs.python.org/': None, + 'http://ioam.github.io/param/': None, + 'http://ioam.github.io/holoviews/': None, + 'http://ipython.org/ipython-doc/2/' : None} + + +from builder.paramdoc import param_formatter +from nbpublisher import nbbuild + +def setup(app): + app.connect('autodoc-process-docstring', param_formatter) + nbbuild.setup(app) + try: + import runipy # pyflakes:ignore (Warning import) + except: + print('RunIPy could not be imported, pages including the ' + 'Notebook directive will not build correctly') diff --git a/PixHtLab-Src/Docker/imagen/doc/images/ellen_arthur.pgm b/PixHtLab-Src/Docker/imagen/doc/images/ellen_arthur.pgm new file mode 100644 index 0000000000000000000000000000000000000000..e22924898614456ce38b3566f3d79f8a464fdeaf --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/doc/images/ellen_arthur.pgm @@ -0,0 +1,6 @@ +P5 +# CREATOR: XV Version 3.10a Rev: 12/29/94 (PNG patch 1.2) +# CREATOR: The GIMP's PNM Filter Version 1.0 +200 256 +255 +æåæåæåææååæææåååååååååååååååååååååååÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÝÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÝÕÝÕÕÝÕÝÕÝÕÝÕÕÝÕÝÝÝÝÝÝÝÕÝÝÝÝÝÕÝÕÕÕÝÕÕÝÕÕÕÝÕÕÕÕÕÕÕÝÝÝÝÝÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝååååååååååæååæåæåæåææææææææîæîæîîîîîæîîææåæææææææææææææååååååååååååååååååÝååååÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÕÝÕÕÕÕÝÕÕÕÝÝÝÝÝÝÝÝÕÕÕÝÝÝÝÝÝÕÝÕÝÕÕÝÕÝÕÝÕÕÝÕÕÕÕÕÕÕÝÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝååååååååååæåååæææææææææîææîæîîæîîîîîîîîææææææææîæîæîææææææååææååååååååååÝååÝåÝÝÝÝÝÝÝÝÝÕÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÝÝÕÝÝÝÕÕÝÕÝÝÝÝÕÝÝÝÕÝÕÕÝÝÕÝÕÝÝÝÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåååååååååååæææåææææææææææîæîæîæîîæîîîîîîæææææîæîæîæîæîæææææååååååååååååååååååÝåÝÝÝÝÝÝÕÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÝÕÝÕÕÝÕÝÝÝÕÕÝÕÝÝÕÝÝÝÝÝÕÕÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝååååååååååååæææææææææåæææææææîæîæîîîöîöîîæææææîæîæææîæææææææææåååååååååååååååÝåÝÝÝÝÝÝÝÝÕÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÕÕÕÕÕÕÕÕÕÝÝÕÝÕÝÝÕÕÕÝÕÝÕÝÝÕÝÝÕÕÕÕÕÕÕÝÝÝÕÝÝÝÝÝÝÕÝÝÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝååÝååååååååååååæææææååæææææîæîîæîîîîîîîîîææææîæîîæîîææîîæîæææææåæååååååååååååååÝÝÝÝÝÝÝÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÕÕÝÝÕÕÕÝÕÝÕÕÕÕÕÝÕÕÕÕÕÕÕÕÝÝÝÕÝÕÝÝÝÝÝÝÝÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝåÝååÝåååååååååååæåææåæææîæææîææîæîæîîîîîîîæææîæîæîîæîîææææîææææææååååååååÝåÝåÝåÝÝÝÝÝÝÝÝÝÕÝÝÝÝÕÝÝÝÕÝÕÕÝÕÝÝÕÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÕÝÕÕÕÝÕÕÝÕÕÝÕÕÝÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÝÕÝÝÕÝÝÝÝÝÝÕÝÝÝÕÝÝÝÝÝååÝååååååååååååååææææææææææææîæîæîæîîîîîæææîæîîææîîæîîææîææææææååååååååÝåÝåÝÝÝÝÝÝÝÝÝÝÝÕÝÝÝÝÝÝÕÝÕÕÕÕÕÝÕÝÕÝÝÝÝÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÝÝÕÝÕÝÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÝÕÝÝÕÝÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝååÝåÝÝååååååååååææææææææææææîæîæîîîæîæîæææææîæîææææîæææææææåæååååååååååÝååÝåÝåÝÝÝÝÝÕÝÕÕÝÝÕÝÝÕÝÕÝÕÝÕÝÕÕÕÝÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÍÕÕÕÕÝÕÝÕÕÕÕÕÝÕÕÝÝÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÝÕÝÕÕÝÕÝÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝåååååååååååååååææææææææææîæææîæîæîæîæææææîæîæîæîæææææææææåååååååååååÝååÝåÝÝÝÝÝÝÝÕÕÝÝÕÝÝÕÕÝÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÍÕÕÕÕÝÕÝÕÝÕÕÕÕÝÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝååÝåÝååååååååååååæææææææææææîæææîîæîîææææææîææææææîæææææææåååååååååååååÝåÝåÝÝÝÝÝÝÝÕÕÝÕÕÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÍÕÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÝÕÝÕÝÕÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝåÝåÝåååååÝåååååååææææææææææîææîæîææææææææîæîæîææææîææææåååååååååååÝåÝååÝÝÝåÝÝÝÝÕÝÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÍÕÕÕÍÕÍÍÕÕÕÕÕÕÕÕÕÝÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÝÕÝÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝååÝåÝåÝÝååååååååååååååååæææææîæîîæææææîæîæææîæææææææåååååååååÝååÝååÝåÝåÝÝÝÝÝÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÍÍÍÍÕÍÍÍÍÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝÝåÝåååååååååååååååååææîææææææææåæææîæææîæææææææååååååÝååÝåååÝÝåÝÝÝÝÝÝÝÝÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÍÍÍÍÕÕÍÕÍÍÍÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÍÕÍÍÕÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÝÕÝÝÝÝÝÝÕÝÝÕÝÝÝÝÝÝÝÝÝåÝÝåååååååååååååååååååæææîîæîææååææîæîæîæææææææææååååååååÝååÝÝÝÝåÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÍÕÍÍÍÍÕÍÕÍÍÕÍÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÍÕÍÍÍÍÕÍÍÍÕÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÍÍÍÕÕÕÕÕÕÕÕÝÕÕÝÕÝÕÝÕÝÝÕÝÕÝÕÝÝÕÝÝÝÝÝÝÝÝÝÝåÝååÝåååååååååååååååæææææææææååæææîæææææææææææåååååååÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÍÕÍÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÍÍÍÍÍÕÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÕÕÍÍÍÕÍÕÕÍÕÕÕÍÕÕÕÕÕÕÕÕÝÕÕÕÝÕÕÝÕÝÕÝÝÕÕÝÝÝÝÝÝÝÝÝÝåÝåÝåÝååååÝååååååååååææææîæææåæææææîææææîæææææåååååååÝåÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÝÕÍÍÕÕÕÕÕÕÕÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÍÕÍÍÕÍÍÕÕÕÕÕÕÕÕÕÕÕÍÕÍÕÕÍÍÕÍÍÍÍÍÍÍÍÍÕÍÍÕÍÍÍÕÍÍÍÕÕÕÕÕÕÕÕÕÕÍÕÍÍÕÍÕÕÕÕÕÕÕÕÕÕÝÕÕÕÝÕÝÝÝÕÕÕÕÕÝÕÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝåååÝååÝåÝååÝåååååååæææææææååææææææîæææææåååååååååÝåÝÝÝÝÝÝÝÝÝÝÕÝÕÝÕÕÕÕÍÍÍÕÍÍÍÕÍÍÍÍÕÍÕÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÍÕÍÍÕÕÕÕÕÕÕÕÍÍÍÕÍÕÍÍÕÍÍÍÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÍÕÍÕÍÕÍÍÕÍÍÕÍÕÕÍÕÍÕÕÕÕÕÕÕÕÕÕÝÕÝÝÕÕÝÕÕÕÝÕÕÝÝÝÝÝÝÝÕÝÝÝÝÝÝåÝååÝåÝÝåÝÝÝÝååååååææææææååæææîæææææææååååååååååÝÝåÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÍÍÕÍÍÍÍÍÍÍÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÍÍÕÕÍÕÕÕÕÕÍÍÕÍÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÍÍÍÍÍÕÍÍÍÍÍÕÍÍÍÍÍÍÕÍÍÕÕÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÕÕÝÕÝÝÝÕÝÕÕÕÝÝÝÝÝåÝåÝåÝåÝÝÝåÝååååååååææîææåååææææææææææåååååååÝååÝåÝÝÝÝÝÝÝÕÝÝÝÝÝÕÕÕÕÕÍÍÍÍÕÍÍÍÍÍÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÍÍÕÍÍÍÕÍÕÍÃÍÍÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÍÕÍÍÍÍÍÍÍÍÍÍÍÕÍÕÍÍÍÍÕÍÕÕÍÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÝÕÕÝÝÕÝÝÝÝÝÝÝÝåÝåÝÝÝåÝåÝÝÝåååååæææææåååææææîæîæåååååååÝÝåÝåÝÝÝÝÝÝÝÝÝÝÝÝÕÝÕÝÕÕÕÍÕÍÍÕÍÍÍÍÍÍÍÍÍÕÍÍÍÍÍÍÍÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÍÍÍÍÍÍÕÍÍÍÍÍÃÃÍÃÍÃÍÃÃÃÃÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÍÕÍÕÍÕÍÍÍÍÕÕÕÍÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÝÕÝÕÕÝÝÕÕÝÕÝÝÝÝÝÝÝÝåÝÝÝÝÝÝÝåÝååÝåååææåååååååæææææææååååååÝåÝÝÝÝåÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÍÕÕÍÕÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÃÍÍÍÍÍÍÕÍÕÍÍÕÍÍÕÍÍÍÍÃÍÃÃÃÃÃÃÃû«¥´ÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÍÍÕÍÍÍÕÍÍÕÕÍÕÕÕÍÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÕÕÕÝÝÝÝÝÝÝÝÝÝÝåÝåÝåååÝåååååååååååååæææææææåååååååÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÝÝÕÕÕÕÕÕÍÕÕÍÕÍÍÍÍÍÍÃÍÍÍÍÍÍÍÍÍÍÃÍÍÍÍÍÍÍÍÍÍÍÃÍÃÍÍÕÍÍÍÍÍÍÍÍÕÍÍÍÃÍÃÃû»»»»´«‹YRu«´»»ÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÍÍÕÍÍÍÕÍÍÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÝåÝÝÝÝåÝÝåååååååååååååæåååååååååÝÝÝåÝÝÝÝÝÝÝÝÝÝÕÝÕÕÝÝÝÕÝÕÕÕÕÕÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÃÍÃÍÍÍÍÃÍÍÍÍÃÃÍÃÍÃÍÍÍÍÍÍÍÍÕÍÍÍÍÍÍÍû»¥—‘„ulll^RRMll„„—´»»ÃÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÍÕÍÕÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝåååååååååååååååååååååååÝÝåÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÝÕÝÝÕÝÕÕÕÕÕÕÍÍÍÕÍÍÍÍÍÍÍÍÍÍÃÍÍÍÍÍÍÍÍÃÃÍÃÍÃÍÃÍÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍû¥}^MMDDMDYYYY^lll}‹—¥‘«ÃÃÃÍÍÍÍÍÍÍÍÍÍÕÍÍÍÕÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝååÝåååååååååååååååååååååååååÝåÝåÝÝÝÝÝÝÝÝÕÕÕÕÝÝÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÍÍÍÍÃÍÍÍÃÍÍÍÍÍÍÍÍÍÍÍÃÃÍÍÃÃÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÃû—lYR;;;DDDRYYYluu„‹‘—¥—«´«´»ÃÃÍÍÍÍÍÍÕÍÍÍÍÍÕÍÕÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝåÝåÝåååååååååÝååååååååååååÝååÝåÝåÝÝÝÝÝÝÕÕÕÕÕÕÕÕÝÕÕÕÕÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÃÍÃÍÍÃÍÍÍÃÍÃÃÃÍÃÃÃÃÍÃÍÃÃÍÍÍÃÍÍÃÍÃû¥uYM;;;;;DMMMRYlu}———«¥«´««´´´»ÃÍÍÍÍÍÍÍÍÍÍÕÍÕÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÍÕÕÕÕÕÕÕÝÕÝÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝååÝåååÝååÝÝåååååååååååÝåÝåÝÝÝÝÝÝÝÝÝÕÕÕÕÝÕÕÕÝÕÕÕÕÕÕÍÍÍÍÍÍÍÍÍÍÍÍÃÍÍÍÍÃÍÍÃÍÍÍÍÍÃÃÍûÃÃÃÃÍÃÃûÃÃÃÍÃÃÃûÃë„RD;;..DMRMRMYYlu„‹‘—««´««««´»»»ÃÃÍÍÍÍÍÍÍÍÍÕÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÍÕÍÕÍÕÍÕÍÕÕÕÕÕÕÕÕÝÕÕÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåååååÝåÝåÝåååååååååÝÝåÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÝÕÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÃÃÍÍÍÍÍÍÍÍÍÃÍÃÃÍÍÍÍÍÃÍÍÃÃÍÃÃÃÃû»´«««´ÃÃÃÍ»Ãû‹YDD..;.;MMY^lllu„„‹‘‘¥««´´»´»»ÃÃÃÃÃÍÍÃÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÍÕÕÍÍÕÍÍÕÍÕÕÕÕÕÕÕÕÝÕÝÕÝÕÝÝÕÝÝÝÝÝÝÝÝåÝÝåÝåååååÝåÝåååååååååÝåÝÝÝÝÝÝÝÝÝÝÝÕÝÕÕÕÕÕÕÕÕÕÕÕÍÕÕÍÍÍÍÍÍÍÍÃÍÃÍÍÍÍÍÍÃÃÍÃÃÍÍÃÍÍÃÃÍÃÃÃÃû´«¥—‘‹‘«»Ãû»Ãë}M;D;....-;R^u}}‹—————¥¥¥´»»ÃÃÃÃÃÍÃÍÃÃÍÃÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÍÕÍÍÕÍÕÍÕÕÕÕÕÝÕÝÝÕÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝååÝåååÝååÝÝåÝåååååÝÝåÝÝÝåÝÝÝÝÝÕÕÝÕÕÕÕÕÕÕÕÕÍÍÕÍÕÍÍÍÍÍÍÍÍÃÃÃÍÍÍÍÃÍÃÃÍÃÃÃÍÃÍÃÃÃÃÃÃû»´¥‹‹‘„}„‘«»»»´»Ã»¥^DDDMMDMDD;;R^^}‹—«¥«¥—¥«»»ÃÃÃÃÃÃÃÃÃÃÃÃÃÍÍÍÍÍÍÍÍÍÃÍÕÍÕÕÕÕÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÍÕÕÕÕÕÕÕÝÕÝÕÕÕÕÕÝÕÝÕÝÕÝÝÝÝÝÝåÝåååÝååÝÝåÝåååååååÝååÝÝÝåÝÝÝÝÕÝÕÕÕÕÕÕÕÕÍÕÍÕÍÕÍÍÍÍÍÍÍÍÃÃÃÃÃÍÃÍÍÃÍÃÍÃÍÃÍÍÃÃÃÃÃÃû´—u^lllu‹‘«´»»»»Ãû—YD;;DDDMRRY^l}„„}„—‘—¥¥«´´´»ÃÃÃÃÃÃÍÃÍÃÃÃÃÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÍÕÕÕÕÕÕÕÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÝÕÕÕÝÕÝÕÝÝÝÝÝÝåÝåÝåååÝåÝÝÝåÝååååååÝåÝÝÝåÝÝÝÝÝÕÕÝÕÕÕÕÕÕÍÕÕÍÍÍÍÍÍÍÍÍÍÃÍÃÃÃÃÃÃÃÃÃÍÍÃÃÃÍÃÍÃÃû»»Ã»«}D.;DMl„——´»»ÃÃÍÃô‹RDDMRDMYY^^u‹——‘‘——‹‘‘«««««´´»ÃÃÃÃÍÃÃû»ÃÃÃÃÍÍÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÍÍÕÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝåÝåååÝÝÝåÝååååååÝÝÝÝÝÝÝÝÝÝÝÝÕÝÕÕÕÕÕÕÍÕÍÕÍÍÍÍÍÍÍÍÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÍÃÃÃÍÃÃû»´´´‘M.-$-.Ml‹—´´»ÃÃÃÍû—lRDD;DDDRYuu}„‘—¥—«´«¥‘‘¥¥««´»»Ã»»ÃÃÃÍÃÃÃûÃÃÃÃÍÍÍÍÍÍÍÕÍÕÍÍÕÕÕÍÕÕÍÕÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÝÝÝÝÝÝÝÝÝåÝåÝåÝåÝÝÝÝåååååååÝÝÝÝÝÝÝÝÝÝÝÕÝÕÕÕÕÕÍÕÍÕÍÍÍÍÍÍÍÍÍÍÍÃÃÃÃÃÃÍÃÃÃÃÍÃÃÃÃÃÃÃÃû»´«l;$$$$$.Yu}¥´»»»»ÃÍô¥uRD;D;..DR^u}„‘¥¥«´»´´««¥‘¥«´´´»´´»ÃÃÃÃÃÃû»»»ÃÃÍÃÍÍÍÍÍÍÕÕÍÍÍÕÍÕÍÕÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÝÕÕÝÕÕÝÝÝÝÝÝÝÝåÝÝÝåÝåÝÝÝåÝåååååååÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÍÕÕÍÍÍÍÃÍÍÃÍÍÃÃÃÃÃÃÃÃÃÃûÃÃÃÍÃÃÃÃÃÃû»»¥Y-$$$$$-;Y}‘«´»»»ÃÃû¥„YD;DD;;DMYluu}}„—¥«´´´´´´´«¥««´»»´´»»»Ã»ÃÃû»Ã»ÃÃÃÃÍÍÍÍÕÍÕÕÕÍÕÍÍÍÍÍÍÍÃÃÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝåååååÝåÝÝÝÝÝÝÕÝÝÕÕÕÕÕÕÍÕÕÍÍÍÍÃÍÃÃÍÃÍÃÃûÃÍÃÃÃÃÃûÃÃÃÃÃÃÃÃû»´¥M-$$$$--M}—«´»»»»ÃÍô‹^M;.;;;;DM^lllu„‘¥¥«´«´´´´»´´´¥—¥´´»»»Ã»»»ÃÃÃÃÃû»»ÃÃÍÍÍÍÕÍÕÕÍÕÍÍÍÍÍÍÍÍÍÃÍÍÍÍÍÕÕÍÕÍÕÕÕÕÕÝÝÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝåÝÝÝÝÝÝÝåååååÝÝÝÝÝÝÝÝÝÕÝÝÕÕÕÕÕÍÍÍÍÍÍÃÍÃÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃû´—R-$$$$.Y}‘«´´»»ÃÃÃÍô‘lR;..-;;DR^^}‹‘¥¥«««´´»´«´»´»´«—‹‘«´»»»»»»»Ã»ÃÃÃû»»»ÃÍÍÍÍÕÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÍÕÕÕÕÕÕÕÝÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝåÝÝÝÝÝÝÝååååÝåÝÝÝÝÝÝÝÝÕÕÕÕÕÕÍÍÍÍÃÍÍÍÍÃÃûÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃûÃÃÃÃÃû´‘D$$$$-;^„‘—«´´»»ÃÍÍÃô„^YD..D;;;MRll‹—««´´´»´´´´´««´«««´¥‘¥«»»´´´´´»»ÃÃûû»»ÃÍÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÝÕÕÝÝÕÕÝÕÝÝÝÝÝÝÝÝÝÝåÝÝÝÝåÝåååÝÝÝÝÝÝÝÝÝÝÝÝÕÝÕÕÕÍÍÍÍÍÍÍÃÍÍÍÃÍÃÃÍÃÍÃÃûÃÃÃÃÃÃÃÍÃÃÃÃÃÃÃô‘D$$$$$-;RRY}„‘¥¥´»ÃÃÍÍÃ¥u^^MMDDDDD;RRl‹‘««´»»»´´´»««´´¥—«´«¥¥¥—¥¥´´«««´»»»ÃÃÃû»ÃÃÍÃÍÍÍÍÍÍÍÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÝÕÕÕÝÝÝÝÝÝÝÝÝÝÝÝåÝÝÝÝåÝåÝååÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÃÍÃÃÍÃÍÃÍÃÃÃÃÃÃÃûÃÃÍÃÃÃÃÃÃÃû‘M-$$$$.;;.;MYl„¥«»ÃÃÍÍë}YDD;DRY^RMD.;MY„—«´»»´»»«¥¥««¥«¥«¥¥¥—‘„„‹‘¥«¥¥««»»ÃÃû»»ÃÃÃÍÍÍÍÍÍÍÍÍÍÃÍÃÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÍÍÕÕÕÕÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝåÝååÝåÝÝÝÝÝÝÝÕÕÝÕÕÕÕÕÍÍÍÍÃÃÃÃÃÃÃÃÍÃÍÃÃÃÃÃÃÃÃû»ÃÃÃÍÃÃûû¥M-$-$$$-.DR}¥«»»ÃÍÍÍë‹Y;;.;MRYllll^^^^l}„‹‘¥«´«¥—¥‘———‘———¥—‘‹u}‹‘——¥¥«´»»Ã»»»Ã»ÃÍÍÃÍÍÍÍÃÍÃÍÍÍÍÍÃÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÝÕÕÝÝÝÝÝåÝÝÝåÝÝÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÝÕÕÕÕÕÍÍÍÍÃÃÃÃÍÃÃÃÃÍÃÃÃÃÃÃÃÃÃÃû»ÃÃÍû»´»»¥Y-$$$$$$-;Dl„¥´»»ÃÍÍû«}RD;.;MMDMRYl}‘¥—‘„lM;D^‘‹‘‘‘‘‘‘—‹‹„„‘——¥‹„}‹‘‹‘‘‘¥´«´»»»»´»ÃÃÃÃÍÃÍÍÃÍÃÃÃÃÍÃÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÝÝÕÕÝÕÝÝÝÝåÝåÝÝåÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÝÕÕÕÍÍÍÍÍÍÃÍÃÍÃÃÃÃÃÃÃÃÃûÃÃÃû»ÃÃû»Ãû»´Y-$$$$$$$$$$-.;Rl‘´»ÃÃÍÃû—lRD;.MYYDRYYRR}‘«´«´¥}DMYYYRYY^^uuuu^uu‹‘‘‘‹„}}u}}‹——¥«´´´´´´»ÃÃÃÃÍÃÃÍÃÃÍÍÃÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÝÝÕÝÝåÝåÝåÝÝÝåÝÝÝÝÝÝåÝÝÝÝÝÝÝÕÕÕÕÕÕÕÍÍÕÕÍÍÍÍÍÍÍÍÃÍÃÃÃûûû»ÃÃûûÃûûû´}--$$$$$$$$$$$$Du—´»ÃÃÃÍô—uRRRDMYYY^}‹„‹‹‘¥¥««¥‹RMMMD;;D;..;DRMMY^u}‹‹}l^^l^u„‹‘‘—¥«««´´»»ÃÃÃÃÃÃÍÍÃÍÍÍÃÍÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÝÕÝÝÝÝåÝåÝÝÝÝÝÝÝÝÝÝÝåÝÝÝÝÝÝÕÍÕÕÕÕÕÕÍÍÕÍÕÍÍÍÍÃÍÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃûû»‘.-$$$$$$$$-Ml‘«´ÃÍÃÍô‘Y;DMMR^^lu‹—«´´´´´´«—}^YYMD;...$$$$$.DDDM^^YlYY^l^u}}uuu‹——«««´»»ÃÃÃÃÍÃÃÍÃÃÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÝÕÝÝÝÝÝåÝÝåÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÍÍÕÕÍÍÍÍÍÍÍÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃû»»»—D$$$$$$$$$--;u—¥´ÃÃÍÃëuYDDRRu„„‘—´«´´´´´´´´«—‘„^R;;---$-$$$$--;;DMRYYYYuu^^^^^u}‹——¥«»»ÃÃÃÃÃÍÃÃÍÃÍÍÍÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÝÕÝÝÝÝåÝÝåÝÝÝÝÝÝÕÝÝÝÝÝÕÕÝÕÝÕÕÕÕÕÕÍÕÍÕÍÍÍÍÍÍÍÍÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃû»Ã»Ã»»»¥M$$-$$$$$-M„¥¥´ÃÃÃÍ»«uYRMYu‘—¥‘—¥¥«¥—¥—«¥«¥——„l^RM;..-$$$$$$..DMDDYl^RMMDDMRl‹‘¥«´»»»ÃÃÃÃÃÃÍÍÃÍÍÍÍÍÍÍÍÍÕÍÍÕÍÕÕÕÝÕÕÕÝÝÝÝåÝÝÝÝÝÝÝÝÝÕÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÍÍÍÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃû»»Ãû´¥Y$$$$$$$$$Du‘«»ÃÃÃÃ×Y;DY^^l^RYl‘—¥¥—«´»»»´¥—‹u^^R;;.-$$$$$---.D;D.D....;Dl„—«»»»ÃÃÃÃÃÍÃÃÍÍÍÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÕÕÝÕÝÝÕÝÕÕÕÕÕÕÕÕÕÕÍÕÍÍÍÍÃÍÍÃÍÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃû»´u$$$$$-Dl‹¥´ÃÍÍû‘M;M^R--Ml‹——««´´»»Ã»»´«—‹„}^MM;;-$-$$-$..;---.-;M}—«´»»»ÃÃÃÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÝÕÝÝÝÝåÝåÝÝÝÝÝÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÍÕÍÍÍÍÃÃÃÃÃÃÃÃÃÃûÃû»ÃÃÃÃÃÃû»»»—;$$$$.Ru„«´ÃÃÃë‹RDRYRD^‹—´«¥«´´»»Ã»»´«¥‘„}uRMD..-$$$$$$$$$$$$$$$;l‹«´»ÃÃÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÝÝÝÝÝÝåÝÝÝÝÕÕÝÕÝÝÕÕÕÝÕÕÕÕÕÕÍÕÕÍÍÍÍÍÍÃÍÃÃÃÍÃû»ÃÃû»»ÃÃÃÃÃûÃû»¥Y$$$$.D^„¥´»Ãû´—}^u}‹‘‘¥¥¥¥««´´´»»»´´«—„}}lYRRM.-$$$$$;^—«»»»ÃÃÃÃÃÍÃÍÃÍÍÍÍÍÍÃÍÕÍÕÍÕÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÝÕÕÕÝÕÕÕÕÕÕÍÕÍÍÍÍÍÍÍÃÍÃÃÃÃÃÃû»ÃÃÃûÃÃû»»ÃÃû»«}-$$-;}¥»»Ãû»¥„l}„‘‹u}„‘¥´´»»»Ã»Ã´«¥—‹„uYMMD;;.-$$$-.R‹«»»ÃÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÍÕÕÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÝÝÕÕÝÕÕÕÕÕÕÍÕÍÍÍÍÍÍÍÃÃÃÍÃÃÃÃÃÃÃÃûÃÃÃÃû»ÃÃÃô—D$-D}¥´ÃÃû´‘}RR^^l^‹—««´»»»ÃÃÃû´¥‹„}ulM;..--$$$$$R‘´»»»»ÃÃÃÃÍÃÍÍÍÍÍÍÍÍÕÍÕÕÍÕÕÕÕÕÝÕÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÍÍÍÍÍÍÍÍÍÃÃÃÍÃÃÍÃÃÃûÃûÃÃÃÃÃÃÃÃû«Y$$;Y„¥´»»Ã»«‹uYDMl}}„‹‹—«´´´´»»»´´«¥„uuRD..;-$-$$$u—´»»ÃÃÃÃÃÍÃÍÍÍÍÍÍÍÕÍÍÍÍÍÍÕÕÕÕÕÝÕÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÃÍÍÃÃÃÃÃÃÃÃÃÃÃûÃûÃûÃÃÃû»´„$$Dl‹«´»Ãû´¥‘lRYMMRlu„‹——¥—¥¥¥¥«¥¥—‘}lYD;;-$-$$D‹¥´»»ÃÃÃÃÃÃÃÍÍÃÍÍÍÍÍÕÍÍÕÍÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝÕÕÕÍÕÕÕÕÕÕÝÕÕÍÕÕÍÍÍÍÍÃÃÃÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃû´¥M$$$Dl‹¥´»Ãû»«‘^R;;MYuluu„‘¥¥¥«´««´´¥‘‹}^D.;-$-^—«´»»ÃÃÃÃÍÃÃÃÍÍÍÍÍÍÕÍÕÍÕÍÕÕÕÕÝÕÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÍÍÍÍÃÍÍÃÃÃÍÃûÃÃÃÃÃÃÃÍÃÃÍÃÃÃû´«^$$$-M„—¥´»Ãû´¥‘u^RYDDR^‹—««´´»´»»»´´«‘„ulMD.-$$D‹«´´»ÃÃÃÍÃÍÃÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÕÕÍÍÕÕÕÕÕÕÕÕÕÕÕÍÍÍÍÍÍÍÍÍÍÃÃÃÃÃÃÃÃÃûÃÃÃÃÃÃÃûÃô´„--.Dl‹¥´»ÃÃû«‘}^DMMR^u„‘—¥«´»»Ã»»´´¥‹lYD.D...-$$.u—«´»ÃÃÃÍÍÃÍÃÍÍÍÍÍÍÕÕÍÕÕÕÕÕÝÕÕÝÝÝÝÝÝÝÝÝÝÕÍÕÕÕÕÕÕÕÕÕÕÕÕÍÍÍÍÍÃÍÍÍÃÍÃÍÃÃÃÃÍÃûÃÃÃÃÃÃÃÃÃû´‘;$$.;R„«´»Ãû»´—lYD.DDMMRu}‹—«´»»»´´´—‹uY;--$--$-$$^—««»»ÃÃÃÃÍÃÍÃÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÝÕÝÝÝÝÝÝÝÕÕÍÍÕÕÕÕÕÕÍÕÕÍÍÍÍÍÍÍÃÍÃÍÃÍÃÍÃÍÃÍÃÍ»ÃÃÃÃÃÃÃÃÃû»«Y$$$.DY„«´´»Ãû»«uYD;;;;DRYl}u„—¥´««¥—‹u^M.-$$$$$$D‹¥«´»ÃÃÍÃÃÍÃÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÕÕÕÍÕÕÕÕÕÕÕÍÍÍÕÍÍÍÍÃÍÃÃÃÍÃÍÍÃÍÍÃÃÃÃÃÃÃÃÃûÃûô„$$$D^u‘´»»Ã»»´¥„uYYR^luul^lu‹‘—««¥‘‘}YYM.$$$$$l—«´»ÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÍÕÍÕÕÕÝÕÝÕÝÝÕÝÝÝÝÝÕÕÍÕÍÕÕÕÕÕÕÕÕÍÍÍÍÍÃÍûÍÍÍÍÃÃÃÃÃÃÃûÃÃÃû»»»»»»¥D$-Ru‹¥´»»»»»´¥‘—‘‹‹‹—¥¥——¥«««´»´´«¥‘‹„}YM.-$ M‘¥«´»ÃÃÃÃÍÃÍÍÍÍÍÍÍÕÍÕÕÕÕÕÝÕÝÝÝÝÝÝÝÝÝÝÝÕÍÕÕÕÕÍÕÕÍÍÍÍÍÃÍÍÍÃÍÃÃÍÍÃÃÃÍÃÍÃÃû»»Ãû»»»»»«l$$-DRl„—«´»Ã»»»»´«¥¥¥««´´´»»»»»»»»»»»´´´««¥¥‘„lD-   .‹¥¥´»ÃÃÃÍÃÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÕÕÍÍÕÍÍÍÕÍÍÍÍÍÍÍÍÃÍÃÃÃÍÃÍÃÃÃÃÃÃû»´»»»»»»»´´‘; -DRu‹—«´»»Ã»»»´«¥«´´´»»»»»»»»»»»»»»»»´»´´´´««—„^D.$  -l—¥´´ÃÃÃÃÃÃÍÍÍÍÍÍÍÍÕÕÕÍÕÕÕÝÕÝÝÝÕÝÝÝÝÝÝÕÍÍÕÍÕÍÍÕÍÍÍÍÍÍÍÃÍÃÍÃÃÃÃÃÃÍÃÃÃû»»»Ã»»´´´»´¥Y $.Rl„—««´»»»»»»´´´´»´»»»»»»»»»Ã»»»»»Ã»»»»»´´´´´¥¥—‹lM-    $R‘¥«´»ÃÃÃÃÃÃÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÝÕÝÝÕÝÝÝÝÝÝÕÍÍÍÍÍÍÍÍÍÍÍÍÃÍÃÃÃÃÍÃÃÃÃÃÃÃÃû»»´´Ã»»»´´»´«‹$    $$-DY^„‘—«´«´»»»»»»»»»»»»»»»»»»Ã»»»»»»»»Ã»»»»»´»´´´««««¥—‹Y.    D‹¥««»ÃÃÃÃÃÃÍÍÍÍÍÍÍÍÕÕÍÕÕÝÝÕÝÕÕÝÝÝÝÝÝÝÕÍÍÍÍÍÍÍÍÍÍÍÍÃÍÃÃÃÍÃÃÃÃÃÃÃÃÃû»»´´»Ã»»´´´«—Y   $.;DRu„‘—¥«´´´»´´»»»»»»»´»»»»»»»»»»»´»»»»»»»»»»»»»´´´´´´´«««—‘^;$   D„—¥«´»»ÃÃÍÃÍÃÍÃÍÍÍÕÕÍÕÕÕÕÕÕÕÝÕÝÝÝÝÝÝÝÕÍÍÍÕÍÍÍÍÃÃÍÍÍÍûÃÃÃÃÃÃÃÃÃÃÃûÃûû»Ã»»´´´‹$   -;Ylu„‘¥¥¥«´´»»»»»»»»»»»´´»»»»»Ã»»»»»»»»»»»»»»»´»»´»´´´´´´´«´«¥¥‘};   ;„—¥¥«´»ÃÃÃÍÃÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÝÝÝÝÝÝÕÕÃÍÍÍÍÍÍÍÃÍÃÍÃÍÃÃÃÃÃÃÃÃûÃÃÃÃûû»»»»»»´´«Y  -Mu‹‹—¥¥¥««´´´»»»»´»»»»´´´´»»»»»»»»»»»»»»»»»»»´´»»»´´´´´´´´´«´«¥¥¥‘‹R$  .„——¥«´»»ÃÃÃÍÍÍÍÕÍÕÍÕÍÕÕÕÕÕÕÕÝÕÝÝÝÝÝÝÝÕÍÍÍÍÍÍÍÍÍÃÃÃÍÍÍÃÃÃûÃÃûÃÃÃû»»»»»»»»»»´—.   $D^„‹¥¥«««««´´»»»»´»´»»»»»»»»»´»»»»»»»»»»»»»»»»»´»»»»´´´´´´´´´««´««¥——}R-  -l———«´´»ÃÃÃÃÍÍÍÍÍÍÕÍÕÕÕÕÕÕÝÕÝÝÝÝÝÝÝÝÕÕÍÍÕÍÕÍÃÃÍÍÃÍÍÍÍÃÃÃÃÃÃÃÃÃÃÃÃû»»»»´»»»»»«}   -Yu‹‘¥««´´´´´´´»´»»´»»»»»´»»»»»»»»»»»»»»»´´»»»»»»»´´´´´´´´´´´´´«´´«««¥—‹uR- Y‘—‘¥¥«»ÃÃÃÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÝÕÕÝÝÝÝÝÝÕÕÍÍÍÍÍÍÃÍÍÍÃÍÍÍÍÍÃÃûÃÃÃÃÃÃÃû»»»»»»»»»´«R  -Mu‹—¥««´´´´´´´»´´»´»»»´»»»»´»»»»»»»´»»´»´»´´»»´»´´´´««´´´´´«´´«´´««««¥¥‘‹uD$ M‹‘———«»ÃÃÃÃÍÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÝÝÝÝÕÕÕÍÍÍÍÍÃÍÍÍÍÃÍÃÍÍÃÍÃÃÃÃÃÃÃÃÃû»»»´´»»»»»´‘. ;Y}‘—¥«««´´«´´´´´´´´´´»»»»»»´»»»´´´´´«´»»´´´»´»´´´´´´´´«´«´´´«´««««««««««—‘„Y.    D}‘——¥¥«»»ÃÃÃÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÝÕÝÕÕÍÍÍÍÍÍÍÍÍÃÃÍÃÍÃû»ÃÃÍÃÃû»Ã»»Ã»»´»»»»»«„$ -M^}‹‘¥¥«««´´´´´´´´´´´«´»»»»»´´´»´´´´´»´´´»´´´´´´´´´«´´´«´´´««««´«««¥«««««¥‘‹}^M$ M}‹‘—¥¥«»»ÃÃÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÝÕÝÝÕÕÕÝÕÕÍÍÍÍÍÍÍÍÍÍÃÃÃÍÃÃÃÃÃÃÃÃÃÃÃû»»»»»»»»»´´«l .Yu„‘——¥¥«««´«´«´´´´´´´´»»»»»»»»´»´´´´´»´´»´´´´´´´´´´´´´«´««««««««««««««¥««¥—‘}YM-   Dl}„‹¥—¥«´ÃÃÃÍÃÍÃÍÍÕÕÕÕÝÕÕÕÕÕÝÕÕÕÕÝÕÕÕÃÍÍÍÍÍÍÍûÃÃÍÃÍÃÃÍÃÃÃÃÍÃÃÃû»»»»»»»»´´¥; ;^u„‘——¥¥«´´´´««´««´«´´´´´»»»´´»´´´´´´´´´´»´´´´´«´«´´´´´´««´««´««««««««««««¥¥—‘„uM$   ;Ylu‹¥¥¥—¥»ÃÃÃÍÃÍÍÕÕÕÕÕÕÕÕÕÕÝÕÝÝÕÝÕÝÕÕÍÃÍÍÍÍÍÍ»»ÃÃÍÍÃÃÍÃÃÃÃÃÃÃÃÍû»»»´´»»»´´—-  -Yu„‘—¥¥¥¥«´´´´´´´««««´´´´´´´´´´´´´´´´´´´´´»´´´´«´´«´´´´´´´«««««««««««¥¥«¥«¥¥¥—‘„uY- .^YY}‘—¥——»»ÃÃÃÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÝÕÕÕÃÍÍÍÍÃÃÃÃÃÍÃÍÍÃÍ»ÃÃÃÃÃÃÃÃûû»»´´´»»´«‹$  ;Y}‹—¥—¥¥¥¥«««´«´«´««´´´«»»´´´´´´´´´´´´´´´´»´´«´«´««´«´´««´«««««««¥¥«¥««¥¥¥¥¥¥‘‘}lM-  DRDRl„‘¥—‘«»ÃÃÍÍÍÍÕÕÍÍÕÕÕÕÝÕÕÕÕÕÝÕÝÕÕÕÃÍÃÍÍÍÃÍÃÍÃÍÃÃÃÃÍÃÃÃû»Ã»ÃÃû»»»´´»´´«}  $DY}‹‘——¥«¥««««´««´´´´´´´´´´´´»´´´´´´´´´´´´´´´´´«´««¥«´´´´««««««««««««¥«««¥¥¥¥——‘„^D-  $DM.MR}‘¥‹}¥»»ÃÃÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÝÕÝÕÕÝÕÕÍÍÍÍÍÍÍÃÍÍÃÃÃÃÍÃÃÃÃÃÃûÃÃû»»»»»´´´´´¥^ -DRu„‘‘—¥««´««´«´«´´´´´»´´´´´´´´´´´´´´´´´´´´´´´«««¥—««´´««««««««««««««¥«««¥¥«¥———‹lM.$  MD-..Y‹—‘„—»ÃÃÃÃÍÍÍÕÕÍÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÍÍÍÍÍÍÍÃÃÃÃÃÃÃÃÃÃÃÃÍÃÃûû»»»»»»´´´´´¥R $;Ml}‹—‘—««««´«´««´«´´´»´´´´´««´´´´´´»´´´´´´´´´´««««««´´«««´«´««««««««««««¥¥«¥¥——‘uR;$    $;.$$$D}‹‹‹¥´»ÃÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÕÕÕÍÍÍÍÍÍÃÍÍÍÍÃûÃÃÍÍÃÃÃûû»Ã»»»»»´´´´«‘;  .Ru}‹‘—¥¥¥«««««´´«´´´´´´´´´«««´´´´´´´»´´´´´´´«´«´´´´«««´´´««´«´«´««´«¥««««¥¥«¥¥¥‘„YD-   -.-$;u‹‘‘¥´»ÃÃÃÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÝÝÕÕÕÕÕÍÍÍÍÍÍÍÍÍÃÍÃÍÃÃÍÃû»Ã»Ã»»»»»»»»»´´´««‹.   ;MRu‹——¥¥«««««««´´´´´´´«´««´´´´´´«´´´´´´´´´´´«««´«´´´«´«´´«´´«´««««««««««««¥¥¥¥¥—‘„Y;$   $$-^‹‹‘¥´ÃÃÃÍÃÍÍÍÍÕÕÍÍÕÕÕÕÕÝÕÕÕÕÕÕÕÍÍÍÍÍÍÍÍÃÍÃÃÃÍÃÃÃÃÃÃÃû»»»»»»»´»´´´«¥„.  .DR}‹‘———«¥««««««´´´´´´´«´´´´´´´´´´´´´´´´´´´´´´´´´´´««´´«´´´«´´´«««««««¥¥«««¥¥«¥——‘uR$   -^‹‘‘¥´»ÃÃÃÃÍÍÍÍÕÍÕÍÍÕÕÕÕÕÝÕÕÕÕÕÕÍÃÍÍÍÍÍÍÃÍÃÃÃÃÃÃÍÃÃÃÃû»´»´»»´»´»´´«¥}-  -;Ml‹‘——¥¥«¥«´´´«´´´´´´´«´´´´´´»´´´´´´´´´´´´´´««´´´«««««««««´«´´«««´««««««««««¥«¥——„Y.$  $-R„‘‘¥´»»ÃÍÃÍÍÍÍÕÍÍÕÕÍÕÕÝÕÕÕÕÕÕÕÕÍÍÍÍÍÍÃÍûÃÃÃÃÃÃÃÍ»Ãû»»»»´»´»»»´´´¥‘l $.Ml„——¥¥¥¥¥«´««´´´´´´´«´´´´´´´´´´´´´«´´´´«´«««´´´«««««««««´´´´«´´´´´«««««««««¥¥«¥¥‹uM-  $-..$$-R}‹„‹«´»ÃÃÍÍÃÍÍÍÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÃÍÍÍÍÍÍÍÍ»»»ÃÃÍÃû»»»»´´»»´»´»´»´´´«‘D ;Rl„‘—¥¥¥¥¥´«´««´«´««««´´´´»´»´´´´´´´´«««´««´«´««´«¥¥««««´´«´´´´«´´´««´«««««««¥«¥¥‘„Y;$ $;MR^lR.$R„‹u„—´»»ÃÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÍÃÍÍÍÃÃÍÃÃÃûͻû»ÃûÃû»»´´´´´»»´´«}- .Y^„—¥—«¥«««««««««««««´´´´´´´´´´´´´«´´««««««´´«««´«¥««¥¥«««««««´««´««««´««««««¥«¥¥—‘uM- $.DDRuuu}}l;$-M^„„}‹«»»ÃÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÍÃÍÍÍÍÃÃÃÃÃÃÃÃû»ÃÃÃÃÃÃô»»´´´»»»´´««l $;R^}‘—¥¥¥««««««««««««´¥´«««´´´´´´´´´«´«««««´«««¥««««««¥¥¥««¥¥««««´´«´««´«««—««««¥¥¥—‹l;$$$$$DRRYluu}„„„u;$-;Y„‘‹‹—»»ÃÃÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÍÍÍÍÃÃÃÃÃÍû»»»ÃÃÃÃÃû´»»´´»´»»»´´¥Y .M^}„—¥¥¥«««««¥¥«««««´««««´«´´´´´´´´´´«««««««««««¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥««««««´«««¥««¥¥¥¥¥—‘}M-$$$$-.;R^YYu}uu}uu}uR--.l‹—‘„‘´»ÃÃÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÍÃÍÃÃÃÃÃÍÃÃÃÃÃÃÃÃͻûû»»»»»´´»»´´«—D   -MY}‹‘—¥¥¥¥«««¥¥««««««««««««´´´´««´«´«««««««¥¥¥¥—¥—¥—¥¥—¥———¥———‘¥¥¥¥¥¥«««´««««¥¥¥¥¥—„lD.-$$$-.;MR^^^lu}l}u^^YYR-$Du‘—‘„}«»ÃÃÍÍÍÃÍÍÕÍÕÍÕÕÕÕÝÕÕÝÕÕÕÃÃÃÃÍÃÃÍÍÃÃûÃû»Ãû»Ã»»»»»»»´»»´««‘.  $DYu‘—¥—¥¥¥«¥¥¥¥¥«««««««««««««´«««««««««¥¥¥¥¥———¥———‘‹‹‹‹}}‹„„‹‘‘————‘——¥««´«««¥¥¥¥¥—‘„^M;.-.;DRYRYYYllll^R;..--$M}‘‘‘„}¥»ÃÃÃÍÃÍÍÍÍÕÕÕÕÕÕÕÝÕÕÝÕÕÍÃÃÃÃÍÍÍÍÃÃÃÃÃûÃûû»»´´»»´»»´»»´´«„$    $MYl‹‘‘—¥¥—«¥¥¥¥¥¥¥¥¥¥«¥«««««««««´««««¥«¥¥¥¥¥————‘„}l^YYR;;YR^l„„„„‹„‘‹‘—««««¥—¥¥«««¥—‘„l^YDMMY^lYYD$;Y^^R;$$$$$.}‘‘—„l‘´ÃÃÍÃÃÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕ»ÃÍÍÍÍÃÃÍÃÃû»Ã»ÃÃû»»´»»»»»´´´´´´¥^   DYu‹‹‘——¥¥¥—¥—¥—¥—¥¥—¥¥¥¥¥¥«««««««««¥¥«¥¥¥¥——‘}lRM;$$$--;DMR^uuluu}‘‘‘¥¥¥«««¥¥««««¥——„u^uY^llu^M-$.MD.$-u‘‹‹„^‘´»ÃÃûÃÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÃÃÃÃÃÃÃÍÃûÃÃÃÃÃû»»»»´´»»»»´´´«´«¥Y  ;l}„‘—‘————¥—————‘——¥———¥¥¥««««¥«««¥«¥¥———‘‹}^;$$;RYl}}‹‹‘‘‘„„‘¥——¥¥««««««´«««¥—‹}lul„„„}Y--.$$^‹}}}Y‹´»ÃÃûÃÍÍÍÕÕÍÕÕÕÕÝÕÕÕÕÕÍûÃÃÃÃÃÃÍÃÃÃû»Ã»»»Ã»»»´»»»»»»´«««—^    Dl}„}}u}}}‹‹‹‹„‹‘‘‘‘‘‘————¥¥¥¥«««««—¥—¥‘‹„}^M;$-;DRlu}‹‹‘——¥——¥—¥———¥«««««´««´«««¥„}ll}‘‘‹„R$$$$Y„ullRu«»ÃÃÃÃÍÍÍÕÍÕÕÕÕÕÕÕÝÕÕÕÕÕûÃÃÃÃÃÃÃûÃÃûûû»»»´´´»»»»´»´««¥Y   ;uuYM;-DDRMDMMRYllu„}l„‘‘‘‘—¥¥—¥¥¥¥—¥—‹„l^^R;..;D;DMRY^u}}„‹‹‘‘——————¥¥¥—¥««««´«´«««¥¥‘}uu„‘‘‹}M- $YlRY^Mu«»ÃÃÃÍÃÍÍÍÍÕÕÕÕÕÕÕÕÝÕÝÕÕÃÃÃÍÍÃÃÃÃÃÃÃÃûÃÃÃû»´»´´´´´»»´´´´¥l   ;uR--$--$-$$$;D;RY^uu}‘——¥¥¥—¥¥—‘}YRMRDRRRRMD;;;DMRR^lu}„„‹‘——¥—¥‘—¥«««´«««««««¥—„}„‹‘‘‹}R; $MR;;MD}«´»ÃÍÃÃÍÍÍÍÍÕÕÕÕÕÝÕÕÕÕÕÕÃÃÍÃÃÃÃÃûÃÃÃÃÃûû»»´»´«¥«´´´´´´´«„-   -Y;$$$ $.MR^‹——¥—¥¥¥¥—‘}lRR^^^^^YM.$$-.;;Rl}‹‹——‘¥¥¥¥««««««««¥«¥‹}„‘‘‘„^RD- $$-$$.;}«´»ÃÃÃÃÍÍÍÍÕÕÕÕÕÕÝÝÕÕÕÕÕÃÃÃÃû»Ã»Ã»ÃÃÃûÃû»»´´««´´´´´´´´´«‘.   -Y;$$$$.DY‹‘‘¥¥—¥¥¥—‹}lluuu^lY;- $^M-RM.-$-;Ml‹‘——«¥«««««««««¥¥—‘}‹‹‹‘}Y;;-$$--„«´ÃÃÃÃÍÍÍÍÕÕÕÕÕÕÕÝÕÕÕÕÕջûû»»»Ã»Ã»ÃûÃû»»´´´»´»»»»»»»´´´‘R     YD$$$$.DMMYYRRMD-$$$;l„‹——¥¥¥——‘‹„„}}}l^D.--.}^M„‹}^D..;Dl„‘—¥¥«««´«««««««¥‘„}„„„uY;;.$$.‹«´»ÃÍÃÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕ»»ÃÃûÃÃûÃûûÃû»»«»»»´»´»»»»»´»´¥}-       $RD--.;RYYY^lRRD.$$$-Du‹—¥—¥¥¥——‘‘‹}uulY.;;Y...R‘——‹u^luuu}‹¥¥«««¥«««««««««¥‹uu}}„lYM.$.$$;‘«´»»ÃÃÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÃû»Ã»ÃÃûÃûÃÃû»»»»»»´»´»»»»»´´´´¥‹;    $RM.DMYlRYRM;- .$$.^‹‘—¥¥¥¥¥¥——‘‹}uuMDDYlM$$-l———‘‹‘‹‘‘‘‹—¥¥¥¥«¥«««««««««¥‘uu}„‹‹uR; $.D.$$D‹´´»ÃÃÍÍÍÍÍÕÕÍÕÕÕÕÕÕÝÕÕÕջûÃÃÃÃÃû»Ãû»»»Ã»»»´»´»´»»»»´´´´«¥‹M    YYRMMYRM.$ .R^^;$-Y‹—¥—¥«¥¥¥¥‘‘‘}}u^YluulD$R‘¥¥—¥———¥——¥¥¥««««««««««««««¥—„„‹‘——‘lD$$DD$-Du¥´»ÃÃÍÍÍÍÍÕÍÕÍÍÕÕÕÕÕÝÕÕÕ»»ÃûÃÃÃû»»Ã»´ÃÃÃû´´´´»»»´´´´´´´«¥‘M      ^^YMDD.$   Y„}‹l.$$-M„—¥¥¥¥««¥—¥—‘‹‹„}l}llu^YDDl‘¥¥¥¥¥———¥¥—¥¥««««««««««¥¥«´¥——‘„„‘—¥—„R--..$.Dl¥´ÃÃÃÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕ»»ÃÃÃÃÃÃû»»»»»»Ãû»»»´»»»»´»»»»´´««‹D    $^lYMD;- $ -MY‹‹};$$Du‘¥¥¥¥¥¥¥¥¥——‘‘‘}ul^l}}}„‹‘—¥¥—¥¥¥—¥¥¥¥¥««´´´¥««´«««¥««««¥‘‘—¥¥—¥‘u;$----;^^¥´»ÃÍÍÍÍÍÍÕÍÕÕÕÕÕÝÕÕÝÕÕÕ»ÃûÃûÃÃû»Ã»Ãû»Ã»´»»»»»´´´»»´»´´¥‹D    ^uYRD.$ ;$ R‘‘„^$$;u‘—¥¥¥¥¥¥¥—¥—‘‘‹‹„}uuu}}„‹‘————¥¥¥¥—«¥«««´«««««´´««««««««¥¥—¥¥¥¥¥—„M$$$$.^}^‘»ÃÃÃÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÝÕÕÃû»ÃÃÃÍÃû´´»»»»»»»»´´´´´´´´»»»´´«¥‹;   $Yu^RD.$$$.; $„‘‘‹^-$-^‘—¥¥¥¥¥¥—¥———‹‘‹„ulllu}„‹——¥¥¥¥¥«—¥¥¥««««´«´´««´«««««««««¥—¥««««¥‹^;.Yuu^‘«»ÃÍÍÍÍÍÍÍÕÕÕÕÕÕÕÝÕÕÕÕÕÃÃÃÃÍÍÃÃÃÃû»»»»»»»»»»»´«´´´»»»´»´´¥„;    ^uu^RM-$-DR^R- -l‹‘‘‹lMD;$$l‘¥—¥¥¥¥¥¥¥—¥——¥‘‘„ul^uu„„‘‘‘—¥¥«««««««««´´´««««««««««««¥¥—«¥««««——‹^;^u„}u‘´ÃÃÍÍÍÕÍÕÕÕÕÕÕÕÕÕÝÕÝÕÕÕ»ÃÃÃÍÃÍÃÃÃÃÃûû»»»»»»´´´´´´»»»´´´«—‘M   ^„ul^R;..;^}}}l^Yl}‹‹‹‹}u^R;$l——¥¥¥¥«¥¥¥«—¥¥¥——„‹„}lu}}‹‘—¥¥¥«««««««««««««´«´««««««««««««¥««««¥—‘l$$;^}}„u}—´ÃÃÍÍÍÍÕÕÕÕÕÕÕÕÕÝÕÕÕÝÕÕÃÃÃÃÃÃÍÃÍÃÃÃÃÃÃÃÃÃû»»´´´»«´´»»´´«««—^   ^„}uul^^RDYu„„}}}„}}„„„ulu^R-$u—¥¥¥—¥¥¥«¥¥¥—¥¥¥——‘‘‹„„‹‘—¥¥«««««««««««««««´«´«««¥«««««««««««««´«¥‘u-;luu}}u—»ÃÃÍÍÕÍÕÕÍÕÕÕÕÕÕÝÕÝÕÕÕÕÃÃÃÃÃÃÃÍÍÃÃÃÃÃûÃû»»»´»»´´´´»»´´«««¥}$  Y„}}}„}u^MDYuu}}}‹„}„„„}}„}^.D}—¥—¥¥¥¥¥¥¥¥¥¥¥—¥¥¥——‘‘——¥«¥«´´´««««««««««¥´««««««¥««««««««««««««´«—„.;lluuul¥»ÃÍÍÍÍÕÍÕÍÕÕÕÕÕÕÝÕÕÕÕÕÕÃÃÃÃÍÍÃÍÃÃÃÃÃÃû»»»»»»»»»»»»»»»»´´´«¥„.  M}‹‹‹‹„}u^RMYl}u„„‹„‹‹‹‹‘‹„lD^‹—¥¥¥¥¥¥«¥«««««¥¥¥¥¥¥———¥¥¥«««´«««´«¥«««««««««««««««««««´«´«««´´´«¥¥‹;$Yl^uuR^¥»ÃÃÍÍÍÍÕÍÕÕÕÕÕÝÝÕÕÕÕÕÕÕÃÃÍÃÍÍÍÍÃÃÍû»Ãû»´»»»»»»Ãû»»»´»´»´¥‘M   M„‹‘‘—‘‘‹}lMY^ul}}„„‹‹‘‘‘‹„ul}‹—¥¥¥¥¥¥¥¥««««««««««¥—¥¥¥¥¥«´««««««««««´«««««««´«««««««´´´´«´´´´´´«¥‹.-RRRYYMl«ÃÃÍÍÍÍÍÕÍÕÕÕÕÕÕÝÕÝÕÝÕÕÕ»ÃÃÍÍÍÍÍÍÍÍÍ»ÃÃû»»»»»»»Ã»»»»»»»´´´««—u$   D}‹‘—«¥——‘‹„}}}}„‹‘‘‘—‘‘‘‹„„}„‹—¥¥«¥¥¥¥¥¥««¥««««««¥«¥¥««¥¥««´««««««´«´««««´««´««««´´´´´´«´´´´´´««¥}$$--.;D;„´ÃÃÍÍÃÍÍÍÍÍÕÕÕÕÕÕÝÕÝÕÝÕÕÃÃÍÍÍÍÍÍÍÍÍÃÃÃû»»»»Ã»»Ã»Ã»»»´´«´´´´«¥‹;  -u‹—¥¥¥¥¥—¥—‘‹‘—‘————‘‘‘‹‹‹‹„}‹¥¥««««¥«««««¥«¥««««««««¥¥«««´«´«««´««´´´´´´«¥««««´´«´«´´«´´«´´´´««—Y$$-$.M—»ÃÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÃÃÍÍÍÍÍÍÍÍÃÃÍÃÃû»»»»´´»»»»»»´´´´»´´««‘l$    ^‹‘¥—¥¥¥¥¥¥¥—¥¥¥¥«¥——¥‘—‘‘‘‹„‘¥¥¥«««¥«««««¥«¥««««¥«¥«««««««««««´«´´«´´´´«««««««««««´´´´´´´´´´´´«—;$$$.}´»ÃÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÃÃÍÍÍÍÍÍÍÍÃÃÃÍÃûÃô»»´»»´»´´´´»´´´´««¥‹M   ^„‘—¥¥¥¥¥¥¥«¥¥¥¥¥¥——¥——¥——‘„„‘—¥¥«««¥««««¥«¥«¥««««««««««««««««««´´´´´´«´«««´«´««««««´´«´´´»´´´««‹-$$M‘´»ÃÃÍÃÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÃÍÍÍÍÕÍÍÍÍÍÃÃÃÃÃû»»»»»»Ã»»´»´»»»´´´´«¥—}-   D}‘¥«¥¥¥«¥««««¥—¥¥¥¥¥¥—¥—‘‹}„——¥¥«««¥««««¥¥«««««´«´«««««««««´««´´´´«´´´´´««««´«´«´´´´´«´«´»´´´«¥u$$-u¥´ÃÍÍÍÃÍÍÍÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÃÃÍÍÍÍÍÍÕÍÍÃÍÃûÍÃÃû»»»Ã»»»Ã»»´»»´«´´´¥‘Y   -u‹—¥¥««¥¥¥¥««««««¥¥¥¥—¥——„}‹—¥¥¥««««««««««¥«««««´««««««««««««´«´´´«´´´´´«´«´««««««´´´´«´´»´´´«‘;$M—´»ÃÃÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÃÃÍÍÍÍÍÍÍÍÍÍÃÃÃÃÃÃÃû»»»ÃÃû»»»´»´´´´´´«—‹R  ^„‘—¥¥¥¥««¥«««««¥¥¥¥¥¥——‘ul‹—¥¥¥«¥¥««««««««««¥««««««««««««««´´´´´«´´´´´´´´««««¥´«««´«´«««´´«¥¥l$$l«´»ÃÃÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÝÕÕÃÃÃÃÍÍÍÕÍÍÃÃÍÍÃÃÍÃûÃû»Ã»»»»»»Ã»»»»´´´´«¥„Y$    M}‘———¥¥¥««««««««¥¥¥¥¥——‹^u‘¥¥¥¥««««¥¥¥«—¥«««¥««««««´«¥¥«««´´´´´´´´«´«´««´«´««´´´«´´´««‘‘¥¥¥«„$$u«»ÃÃÍÍÍÍÍÍÕÍÕÕÕÕÕÕÍÕÕÕÕÝÕÕÕÃÃÃÍÍÍÍÍÕÍÍÍÃÃÃÃÃÃÃÃÃû»Ãû»»»»»»´»»´´´´«¥—‘u.   .l}‹‘‘¥¥««««««««««¥¥¥¥¥—„^„‘—¥¥¥¥¥¥¥¥¥¥«¥¥«¥¥¥—¥¥«««««««««´´´´´´´´´´«´´´´´´´´««´´´´´´«¥R.Y^}‘D$-}«»ÃÍÍÍÍÍÍÍÍÕÕÕÕÕÍÕÕÕÕÕÕÕÝÕÕ»ÃÃÃÍÃÍÍÍÍÍÍÃÃÃÃÍûÃÃÃûÃû»»»»»´´»´´»´´«¥¥¥—l   $Y}‹‘‘—¥¥««««««««««¥¥—¥‘uR}‘¥—¥¥¥¥¥¥¥¥¥¥«««¥¥¥¥—¥¥¥««««««««´´´´««´´´´´´«««´«´«´´´´´´´«¥D$-R‘—„Y.$$.‹´»ÃÍÍÍÍÍÍÍÕÕÕÍÕÍÕÕÕÕÕÕÕÝÝÕÕ»ÃÃÍÍÍÍÍÍÍÍÍÃÃÃÃÃÃÃÃÃô»Ãû»»»´»´»´´´´´«««««¥„;  M}}„‘——«««««««««««¥¥——‘^Y„——¥¥¥¥¥¥¥¥¥¥¥¥¥««¥¥———¥—¥¥««¥«««««´«´´´«´´««¥««´´´´´´´´´´´«—.$l¥««¥‘„;$$$$.‘´»ÃÍÍÍÍÍÃÃÍÕÍÕÍÍÍÍÕÕÕÕÕÝÕÕÕÃÃÃÍÍÕÍÍÍÍÃÃÃÃÍÃÃÃÍÃû»»Ãû»»»»»»»»»´´´«««´«¥‹D   .uu„‹—¥¥¥««««««««¥¥¥¥‘‘l^}‹‘¥¥¥¥¥¥¥¥—¥¥—¥«¥¥—¥———‘¥¥¥¥««««´««´««´´´´´´«´´´´´´´´´´´»´«„-D—´«—‘——l$.-$$D—»»ÃÍÍÍÍÍÃÍÍÕÍÕÕÕÍÕÕÕÕÝÕÝÝÕÕÃÃÍÃÍÍÍÍÍÍÍÍÍÃÍÃÃû»Ã»»»Ã»Ã»´»´»»»»»´´´«´««««—R   $Yu}‹‘¥¥¥«¥««««««««¥¥‘„^ll}‘———¥¥¥¥———————¥————¥‘‘—¥«¥«««««««´¥««´´´«´«««««´´´»»»»»´´}.„¥««¥¥——‹.$.;$$-M«»ÃÃÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÝÝÕÝÕÃÃÍÍÍÍÍÍÍÍÍÍÃÃÃÃÃûÃû»Ã»Ãû»»»´»»´´´´´´´´«««—Y   Dl}}‹—¥«¥««««««««¥¥¥—„u^Yl„‘‘——¥—————‘‘‘—‘—¥¥——————¥¥¥¥«««««««««««««´««´«´´«´»»»»´´«„^¥‘„‹¥——¥‹;$-;-$$-u«»ÃÃÃÍÍÍÍÍÍÕÍÕÕÕÕÍÕÕÕÝÝÕÝÝÕÕÃÃÍÍÍÍÍÍÍÍÍÃÃÃÃûû»ÃÃû»»»´»»´´»»»»´»´´´´´««¥^    .^u}‹‘—«¥««««««««¥¥——„^YD;^„‘‘—————‘„u^}„‹‘‘—¥¥—————¥—¥—¥¥¥«««««´´«´«««´«´´´´´»»»»´«„‹—„‹¥«««¥‘R$--$$$;‘»»ÃÃÍÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÝÕÝÕÝÕÕÃÃÍÃÍÍÍÃÍÍÍÃÃû»Ã»ÃÃÃÃû»»»»»»»´»»»»»»´«»´«««¥u   Yll„‘—¥¥««««««««¥¥¥‘„^M-.M^}}‹‹—‘‘lD;$-M^}‹¥¥««¥¥—‘‘—¥¥¥—«¥««««´´´«´«´´«´´´´´»»»´«¥}‹‹u—¥¥«¥¥—^$$$$$-u«»ÃÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÝÕÝÕÝÕ´»ÃÍÍÍÍÍÍÍÍÃû»»Ãû»ÃÃÃÃû»»»»´««»»»»´»´´´«¥¥¥‹-    ;^^l„‘——«¥¥¥««¥¥¥¥——}YD-.Rlu}„„lYR^YD;Ru‘¥¥«¥¥¥——‘‘——¥¥¥¥«¥¥««««´«««´«´´´´»´»´´´¥„‘}„¥««´¥¥‘l-$$$$M—»ÃÃÍÍÍÍÕÍÍÍÕÕÍÕÕÕÕÕÕÕÕÝÕÝÕÝÝÕÃÃÃÍÍÍÃÍÃÃÃÃÃû»ÃûÃÃû»»»»»´´´´´»´»»»»´´««««¥‹M     $R^u}‹‘—¥¥¥«¥¥¥¥¥¥—‘}M.$ -;R^llulu„ul^u‹—«¥¥¥¥¥¥—‘‘‘——¥«¥¥¥¥¥«¥«««««««´«««´´´´´«¥u‹„—«´´«¥¥—l$$-$$D‹´»ÃÃÍÍÍÍÍÍÍÕÍÕÕÕÍÕÕÕÕÕÕÕÝÝÝÝÕÕÃÃÃÍÍÃÍÃÃÃÃÃÃû»»ÃûÃÃÃÃû»»»»»»´»»»»»»«´«¥¥¥«—}   ;^lu„„‘——¥¥¥¥¥¥—¥—‹uRM- -;DYlu„‹‹‹‘——¥¥«¥«¥«¥¥¥‘‘‘‘¥¥¥¥¥¥¥¥«¥««««««´««´´´´´´«—Yll‹¥¥¥¥—¥‘M$M‹«»»ÃÃÍÃÍÕÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÝÝÕÝÕÕÕÃÃÍÃÍÍÃÃÍÍÃÃÃÃÃÃÃÃû»»»Ã»»Ã»»»»´»»»»»»´´´««´««¥—M    .Y^llu„‘—¥‘—¥¥¥¥—‘‹}lY; $Ml‹‹‘—¥—«¥¥¥¥«¥«¥¥¥¥¥—‘——¥—«¥¥¥—¥¥««¥««««««´»´»´´«„;Y;.u‘—‘‹‘}$$$D‹«´»ÃÃÍÃÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÝÕÝÕÝÝÕÕ»ÃÍÍÍÃÍÃÃÃÃûÃÃÃÃû»»»»»»»»»´´´»´»»»»´´´´´´´«¥¥¥}.    -R^R^lu„‘———¥¥—¥——‹„}^M-$.;Ru‹‘—¥—¥¥¥¥¥¥¥¥«¥¥¥¥¥¥————¥—¥—«——¥¥«¥¥««´«´´»´´´´¥u-RM$M„„ulu;D„¥´»ÃÃÍÍÍÍÃÍÍÍÍÍÍÕÕÍÕÕÕÕÕÕÕÕÕÕÝÝÕÕûÃÍÃÃÍÍÍÃÃÃÃÃÃÃÃû»»´»»»»Ã»»´»´»»´´´´«´«´«´««¥—¥u.  $$DYMYlu}‘‘—¥—¥—¥¥‘‘‹„lR;$$-.DYYl„‹‘¥¥¥¥«¥¥¥«««««¥¥«¥¥¥¥¥—¥—¥¥¥—¥¥¥¥¥««´«´´´»´»´«¥Y.Y;;lu^Y-$Y—«»»ÃÃÃÍÍÍÍÍÃÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÝÕÝÕÕÃÃÃÃÃÃÍÍÃÃÃû»ÃÃÃû»Ã»»»»»»»»»´´»»»´´»´«´´´«´«¥¥¥‘„R$ -DMMYll„‹‹‘———‘———‘„u^M...DYlu}„‹‘¥¥¥¥¥¥¥¥¥¥¥«¥«¥¥¥¥¥¥¥——¥—¥—¥¥¥¥¥¥««´´´´´´´´´«—Y;DDY^R$.}¥´»ÃÃÍÍÍÍÍÍÍÍÍÕÍÍÕÍÕÕÕÕÍÍÕÕÍÕÕÕÕÕջûÃÃÃÃÃûÃÃÃÃÃÃÃÃÃû»´»»»»´´´´´´´´´´´´´´´´«««¥¥—¥—‘lD$ .$ DMMMY^}„‹‘‘‘‘‹—‘‘‘‹„uYD;DM^u}„‹‹‘—¥¥¥¥¥«¥¥¥¥¥—¥¥¥—¥¥¥—¥¥¥¥¥¥¥¥¥¥««««´´´»´»´´´¥—M$.;-$$M—«»»ÃÍÃÍÍÍÍÍÍÍÍÍÍÍÕÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕ»´ÃÍÃÃûÃÃÃÃÃÃÃÃÃÃÃû»»Ã»»´´´´´«´´´«´´´««¥«¥««¥¥————‘„^R.;- .RMDMR^u}‹‘‘‘‹‘‹‹‹„}uYYMMYu}‹‹‘————¥¥—¥¥——¥¥—¥¥—¥¥—¥—¥¥¥¥¥¥¥¥¥«««««´´´´»´´»´««‘;$D$$.u«´»ÃÃÃÍÃÃÍÍÍÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÃÃÃÃÃÍÃÃÃÃÃÃûÃÃû»ÃÃÃû»»»´´´´´«´´´´´´«««¥‘¥¥—«—¥—————‹„R;-- $;DDDRRR^„„‹„‹‹‹„‹„}ull^^l}‹‹‘———‘——¥——————‘—‘‘——¥‘——¥¥¥¥¥¥¥¥¥««««««´´´´´´»´«¥„$D};$l¥«´ÃÃÃÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÍÃÃÃÃÃÃÃÃûÃÃûÍÃûûÃû»Ã»»»´´´´«´«´´««««¥¥¥¥¥«¥—¥¥——¥—‘‘‹l.$$;;;MMDMYl}}„‹‹‹‹}uluullll}}‹‹‹‘‘‘‹„„}uuu„„„„„„‹‘„„„‹‘¥¥¥¥¥¥¥¥«««««´´´´´´´´´«—u-Y-$D‘«´»»ÃÃÃÃÃÃÃÃÃÃÃÍÃÍÍÍÕÍÍÕÕÕÕÍÕÕÕÕÕÕÍÕ»ÃÃÍÃÃÃÃÃû»Ã»ÃÃÃû»Ãû»»»»»»´´´«´´´«««««¥¥¥¥¥¥¥¥¥¥¥¥¥¥——‘„R--;DMDDDRMY^l}„‹„}lYY^ll^lYYY^u}}„lll^YRY^YYRMDMRMMYY}‹—¥¥¥«¥¥«««´«´´´´»´´´´««—R$$M„¥´´»»ÃÃÃÃÃÃÃÃÃÃÃÍÍÍÍÍÍÍÍÕÍÕÍÕÍÕÍÍÕÍÕÍ»ÃÃÃÃÍÃÍÃûÃû»»»Ã»Ãûû»»´´´»«««´´««´«««¥¥¥¥¥¥—¥¥¥¥—¥¥—¥—‹}M .DRD;DRMYluu}}ul^MRYRYR;.-$$.;MYM;;D...DD..DRY^Rlluu„—¥¥¥««««««´´´«´»»´»´´«¥‹-   $M„¥´´»»»Ã»ÃÃÃÃÃÃÃÃÃÃÍÍÍÍÍÍÕÍÕÍÕÍÕÍÕÍÕÕÕÍûÃÃÃÃÃÃÃÃû»»»»Ãûû»»»»´´´»´«´«´´««´«¥¥¥¥¥¥¥¥¥¥——¥——¥———‘„Y -;;D;MDMRlllllYRM..;--$$$-;;-.MRMMluu}„„‹‘‘‘‘‹‹‹—¥¥«¥¥«««««««´´´´»´´´«—u  .l‘¥´´»»»Ã»Ã»»ÃÃÃÃÃÃÃÃÃÍÍÍÍÍÍÕÍÕÕÍÕÕÍÍÕÕÍÕ»ÃÃÃÃÍÃÍÃÃû»»»´»ÃÃû»»»»´´´»´´´´«´««««¥¥«¥¥——¥¥—¥———¥—¥——‘‹uD- ;;DDMMMRY^l^^YM.-$ -DDRu‹‘‘————————————‘‘‘—¥¥¥¥¥¥«««««´´´´´´´´«¥—R  -M„¥«´´»»»ÃÃÃÃÃÃÃûÃÃÃÃÃÃÍÃÍÍÍÍÕÍÕÕÍÕÕÍÍÕÕÍÍ»ÃÃÃÍÃÃÍÃÃÃû»´´»»Ãû»´»»´´´´´´´´´´«¥—«««¥¥¥———«¥—¥¥¥—¥————‘‹uY;;DDMRMMRR^llYYM;$  ---MR^u„‘—¥¥¥¥¥¥———¥¥¥—¥—————¥¥¥¥«¥««´´«´«´««««««¥‹-  .Y}‘¥¥«´»»»ÃÃÃÃÃûÃÃÃÃÍÃÍÃÍÃÍÍÍÍÍÍÕÍÍÍÕÍÕÍÍÕÍÍ»ÃÃÃÍÍÃͻû»Ã»»»»»»Ã»´»»»»»´´´´´««´«¥¥¥«¥¥——¥——¥———¥——‘——‘—‘‘‹„„lRMD;DRRRDRYll^YMD-$ $MY^u„‹‹‘——¥¥¥¥—¥¥—¥—¥—¥¥¥¥¥——¥¥¥¥«¥«««««««««´´««¥‘^ D„‘¥¥¥««»»»»ÃÃÃÃÃûÃÃÃÃÃÃÃÃÃÍÍÍÍÍÍÍÍÕÍÍÕÕÕÍÕÍÕÍ»»ÃÍÃÃÍÃû»Ã»»»´»»»»´»´´»´´´´´´««««««¥¥¥¥¥—¥¥—¥—¥—¥———‘‹‘—‘‘‘‹‹‹‹uM;D;DMRRRluul^RRR;$$-.;Yu}„‹‘‘———¥¥¥¥¥¥—¥—¥—¥—«¥¥¥———¥¥¥««¥¥««¥««««´««¥¥„. $M„—¥¥««»´»»»Ã»Ã»Ã»Ã»ÃÃÃÃÃÃÃÃÍÃÍÍÍÍÍÍÕÍÕÕÕÍÍÕÍÕÍÍ»ÃÃÃûÃÃû»»»´»»»´»»»»»´»»»»´´´´´«´««¥«¥¥¥———¥¥¥—————————‘—‘‘‹„‹„l.;DMDMYY^lluu^YYYD.$--;MYu}}„‘—‘————‘———¥—¥—¥—«««¥«¥¥¥¥¥¥¥«¥¥««««««´««¥¥‘R  ;^‹——«´´»´»´»»»Ã»ÃÃÃÃÃÃÃÃÃÃÃÃÍÃÍÍÍÍÍÍÕÍÍÍÍÍÕÕÍÍÍÍÍÃÃÃÃÃÃû»»´´´´»»»»»´»»»»»»»»´»´´´«´«««««««¥¥—¥———————¥——‘‘‘‘‘‹‹„„lRDMMMYY^^YYllY^^^YD.--;DM^u}„„„‹‹‹„‹‹‹‘‹‘——¥¥«¥¥«««¥¥¥¥¥¥¥¥««¥«¥««´´««¥—l.Y„——¥¥¥«´»»»»»Ã»»ÃÃûÃû»ÃÃÃÃÍÃÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÍÍÍÍÃÃûÃÃÃû»´«««»»»»»´´»»»»»»»´´´´´«´««««««¥¥¥¥—¥—————————‘—‹‘—‘‹‘„}u^YRYRR^YYRY^l^^^^YM..;.;MY^^lll^lllll}„‘——¥¥¥«¥«««¥¥¥¥¥¥¥¥«¥¥«««««««——„-$$;Rl‹‹—¥¥«´´´´»»»»»»ÃÃÃû»»»»»ÃÃÃÃÍÃÃÍÍÍÍÍÍÍÍÍÕÕÕÕÍÍÕÍÍÍÃÃûÃÃÃû»»»´»»»»´´´»»´´´»´´´»»´´««¥«««««—¥———‘¥——‘‘—‘‘‘—‘‘‘‘‘‹‹‹„„u^RRMRRRRMR^lllu^^RM.-.--;;DDDDD;MRYYl„‘‘—¥¥¥«««««««««¥¥¥¥¥¥¥««««¥¥—¥„;$;luu}‹‘‘—¥—«««´´´´»´»»»Ã»»»Ãû»»ÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÍÍÍÍÍ´»ÃÃÃÃûû»»»»»»´´´´´»´«´´»´´´»´´´««««««¥¥—¥—‘—¥————‘‘‹‘‘‘‘‘‘—‘‹‘‹‹„}YRMMRYYRMRYllll^YRD..---.;..;;MMY^^u}‘—¥¥¥¥««««««««¥¥«««¥¥««¥«¥¥¥—‘l;D^„‘‘‘‘¥—¥¥¥««««´´«´«´»´»»»»»Ã»»Ãû»ÃÃÃÃÃÍÍÃÍÍÍÃÍÍÍÍÕÕÕÕÍÕÍÍÍÍ»»Ãû»Ãû»»»Ã»»»»´´´»´´««´«««´´´´´´««««««¥—¥¥—¥—¥—‘———‘———‘‘—‘‘‘‹‹„}}lYMMMRRYYR^^^llu^l^M;.D;;;DMRDM^luu}‹—¥¥«¥«¥¥«««««««¥¥««¥¥«¥¥«¥¥‘—‹„„‹‹‘‘‘—¥—¥¥¥¥¥«¥««´´´«´´»´»»»´Ã»ÃûûÃÃÃÍÃÍÍÃÍÍÍÍÍÍÍÍÕÕÕÕÍÍÕÍÍÍ»ÃÃû»ÃÃÃûû»»»´´´´»»»´´´«««««´««´«´««««¥¥—«¥—¥‘‘—‘‘‘———‘‘‘—‘‘‹‹„}llMRRMDRMRRR^^YY^uulu^YMMRM;R^^^Yu„}u‹‘¥¥¥««¥¥¥««««««¥¥¥¥¥«¥—¥—¥——‘‘‘‘——————«¥¥—¥¥¥¥¥¥«««´«´´»´´´»»´Ã»»»ÃÃÃÃÃÃÃÍÃÃÃÍÍÍÍÍÍÍÕÍÕÕÍÕÍÍÕÍÍ»»ÃÃûû»»»»»»´´´´´´´»´´«´««´«´««´«¥¥«««¥¥¥¥¥¥—¥———‘‘———¥——‘‘‘‘‹‘„}lM-;MMRRM;Y^YYYY^luuul^^^Ylll}}}„‹‘‘‘¥¥¥«¥«««¥«««««««¥««¥¥¥¥———‘‘‹‹‘‘———¥——«¥¥¥¥¥¥¥¥¥««¥«««´´»´´´»»»Ã»»»ÃûÃÃÃÃÍÃÃÃÃÃÍÃÍÍÍÍÍÕÍÕÕÍÕÍÍÍ»»»ÃÃû»´»»»»´»´»»´´´´´»´´´«´«««««¥¥¥««¥¥¥«¥¥¥¥—¥————‘—————‘‘‘‹‘‹}^^R.$.DMRDMR^MMDMYuluul}uuu„„„„‹„‘‘¥—¥¥¥¥¥«««««««««««««¥«¥¥¥——‹‘‹„„‹——¥—‘——¥¥¥¥—¥¥¥¥¥«¥«¥««´´«´´´´»»»»»Ãû»ÃÃÃÃÃÃÍÃÃÃÃÍÃÃÍÍÍÍÍÕÕÍÕÍÕÍÍ´»»ÃÃû»»»»»´´»»»´´»´´´»´´´´«¥«««««¥¥¥¥—¥—«¥¥¥—¥———————¥¥—‘‘‘—‘‹}^^^YM-DRMMMRMDRYY^llluu„}„‹‹‹‘‘———¥¥¥¥¥«¥«««¥««««««««¥¥¥—¥——‹„}‹‹‹‘—¥—¥—‘—¥—¥¥¥¥——¥««¥««´´´´´´´»»´»»»»»Ã»»ÃÃÃÃÃÍÃÍÃÍÍÍÃÍÍÃÍÍÍÍÕÍÕÕÍÍÍ»»»ÃÃÃû»»»´´´´´»»´»»´´´´´´«´«««««««¥¥¥——¥¥¥——«—‘‘‘—‘——————‘—‹„„„uullR$ -MMMMM;;MMR^^lu}}„‹‘‘„‹‘——¥—¥¥—«¥¥¥«¥«¥««««««¥¥————‹„‹}}„‹‹‹‘¥———————¥¥—¥—¥¥«¥¥¥««««´´«´»»»´»»»»»Ã»»ÃÃÃÃÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÍÍÕÍÍÍÍÍ»»ÃÃÃÃÃû»»»´´´»»»´´´´«»´´««´««««««««««¥¥¥¥¥¥—¥—‘—¥——‘————‘—‘‹„}„}u}uY; .MDDMD;DMRR^luuu„‹‘—‘‘—¥¥—¥—¥¥¥««¥¥¥¥««««««¥¥¥—‘‘‘„uuu„‹‹‹„‘—¥—————¥—¥¥¥¥—¥¥¥«««´´«´´´´´»»»»»»»»Ã»»Ã»ÃÃÃÃÍÃÃÍ»ÃÍÍÍÍÍÕÍÍÕÍÍÕÕÍÍ»ÃÃÃÃÃÃû»»Ã»»»»»´´´´´´»´»´´´«´««««¥¥¥¥¥¥¥¥¥¥—«——¥———‘—‘‘‘—‘—‘‹„‹„„„}lR- .MMDDD;MMRY^luu}‹‘——‹——¥—¥¥—¥¥¥¥¥¥¥¥«¥«¥«¥———‘„‹„uuu„‹‹„‹‘————————¥¥—¥¥¥¥¥«««««««´´´´´´´»»»»»Ãû»»»»»»ÃÃÃÍÃÃÃÍÍÍÍÍÍÍÍÕÍÕÕÕÕÍÍ»Ãû»ÃûûÃû»»Ã»´´´´´´´´´´´´«««¥¥¥¥—¥¥¥—¥¥¥——¥¥¥———‘‘————¥————‘‘‹‹„lRY;$ -DMD;;DMDMR^lu}„‹‹‘—¥—«¥¥—¥—¥¥¥¥¥¥¥¥¥—¥¥——‘‹}uuu^l}‹‹‹„„‘——‘————¥—¥——¥¥¥¥«««««´««´´´´´´»´»»»»»»»»»Ã»ÃÃÃÃÍÃÍÍÃÍÍÍÍÕÍÍÕÕÕÕÕÕÕÕ»»»Ãû»»»»»Ã»»»»´´´´»»«´´´´´´´«¥¥—¥———¥——¥¥¥———¥—¥————¥¥¥¥¥¥¥¥¥———‹„^RYY; .MMMDMMMDMYYlu}}„‹‘—¥————¥—¥——¥—¥——————‘‹„}u^^luu‹‹‹‹„}‹—‘—————¥———¥—¥¥¥««««««««´««´´´´´»»»»»»»»»»ÃÃûÃÃÍÃÍÃÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕ»»ÃÃû»ÃÃÃû»´´»´«´´»»´»´´´´´«««««¥—¥¥¥—‘‘————¥—¥—¥¥¥¥««««¥¥¥¥¥————‹}l}uYD- $;MMMMMDMYYYllu}‹‘—‘——¥—‘————————‘‘‘‘‹}}u^^^llu„„‹‹‹„„‹‘‘——————¥—¥¥¥¥¥¥««««¥«´«´«´´»´´´´´´»»»»»»»»ÃÃÃÃÃÃÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÍ»»ÃÃû»»»Ãû»´´´´´´´´´´»´´«´«««¥««¥——¥¥„Y}‘‹}„‘——¥—¥««««««¥¥¥¥¥¥—¥—‹‹„}u^RD- -;DMD;MMMRYY^l}u„‹‹‘‘‹‹‹‹‹‹‘‹‹‘‹‹„}lYYY^^lu}„‹‹‘‘‹„„‘‘——‘——¥¥———¥¥¥«¥«««««««««´«´««´´«´´»»»»»»»ÃÃÃÃÃÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕ´´»»ÃÃû´Ã»´»´»»««´´´´««´´«´´´´¥««—‘„‹‹^;MuYRu‹‘—¥««´´´´«««««¥¥¥¥——‘‹‹„u^RR;-$.DDDDDMMRRYYYuu}„„}uu}}}„„}}lll^RRMYll}u„„‹‘—‘‹„‹‘‘‘———¥—‘—¥—«¥¥¥¥«««««¥«««««´«««´´«´»´»»»»»»ÃÃÃÍÃÍÍÍÍÍÍÕÕÕÕÝÕÝÕÝÕÕÕÍ»»Ã»»Ã»Ã»»»»´»´´´«««´««´´´´´´««¥«¥¥„RluR..DM^‘—‘‘«««´´´««¥¥««¥¥——¥¥—‘—‹„}llMD- $-DDMMMDMMMRY^^^l^YRR^^lll^YRYMRYYlu}u„„‘‹‘‘—„}‹——‘‘———————¥—¥¥¥«¥««««««««««««««´´´´´»»»»Ã»ÃÃÃÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÝÕÕÕÕÍ»ÃÃÃÃÃÃû»»»»»»´´´«´»´´«´¥«««««¥«¥—u;DM;.$$R‘—‹}‹«´´´´´´«««««¥¥¥¥¥———‘¥‘‹‹‹u^M.$ -.;;MDDMMRRMRRD;;MYRMRRMDRRM^ulu„‹„„‹‘‘‘‘‹}u‹‘‘‘—————¥—‘‘—¥¥¥¥¥««««««¥««««««´´´´´»»»»ÃÃÃÃÃÍÍÍÍÍÍÍÍÍÕÕÕÕÕÝÕÝÕÝÕÕÕÕ»ÃÃÃÃÃÃû»»»»»´´«´´´´«´«´«¥«¥«¥¥¥¥‘R.;;;.R}}„‹¥´´´´´´´´´«««¥¥¥¥—‘‹———‘——‘‹}llD$ $-;;;;;;M;DDD;;DM;;D;DMRYlu}„„‹‹‘‹‘‘‘‘‹„„}„‘‘———¥——¥————¥¥¥¥¥¥«¥¥¥¥¥«««´«´´´´´»»»»ÃÃÃÃÍÍÍÍÍÍÍÍÍÕÍÕÕÕÝÕÕÝÕÝÕÝÕÕÕ»»»»ÃÃû»»»´´»´´´´´´´´«´´«¥««¥——‘‘„D..-$$.DRl„„‘«´´´´´´«´´«´«¥¥¥¥—‹———¥————‹‹„l^M$-$..;;;.;;..;.;DM;RY^}}}„‹‹‘‘‘‘‘——‘‘‹„„‹———‘—————¥——¥—¥—¥¥«¥¥¥¥¥¥¥«´´«´´»»»»»ÃÃÃÃÃÃÃÃÍÍÍÕÍÕÕÍÕÕÕÕÕÕÕÕÝÝÝÕÝÕÕ´»ÃÃÃÃû»»»»´»´´´´´»´«´«´´¥«««¥‹^lR-$R^Yu}‘—««´´«´´´´´´«««¥¥——‹—¥—¥¥¥¥——‹„„}lD$$$$$$.-...;;.;;DDDRY^l}}}„‹‘‘‘‘‘‘‘——‘‘„}„‘‘‘‘‘—————————¥—¥¥¥¥¥—¥¥¥—¥«««´´´»»»»ÃÃÃÃÃÃÃÃÍÍÍÍÕÍÍÕÕÕÕÕÕÕÝÝÝÝÝÕÝÕÕÕûûÃÃûû»´´«´´´´´´´´´««¥¥«««¥‹R;-$.--^}‘—‘‘‘«««´´´´´´«««¥¥¥—«¥«¥««¥——‹‹„„}^M-$$$----$..;.;.D;DDRYYlu}}„„‹„‹——‘‹———‘‘‹„}„‹‘‘‘‘‘—————¥——¥—¥¥¥¥—¥¥—¥¥—««¥«´»´»»´»»ÃûÃÃÃÍÍÍÍÍÍÕÕÍÍÍÕÕÕÕÕÝÝÝÝÝÝÕÕÕÃÃÃû»Ã»»»»´´´´´´´´«´´´´¥¥¥¥«¥¥—„^RD-$.u„‹‘‹‹—««««´´´´«´¥«¥¥¥««««¥«¥———‘‹u„„}YD;-$$----.--...;;;DMRYllu}„‹„‹‘‘‘——‘‘‘——‘‘‹„„„‹‘‘‘————‘‘——————¥—¥¥—¥—¥¥«««¥«´´»´»´»»Ã»»ÃÃÃÍÍÍÍÍÍÕÕÍÍÕÍÕÕÕÕÕÕÕÝÝÝÕÝÕÕÃÃÃÃÃÃÃû»»»»»´´´´´´»´´´´´¥¥¥¥—¥‘‹„lM-$$;Y}„„‹‘——«««´«´´«««¥«««¥««««¥—¥«¥—‹}‘‹„ulYDD;...;;...;.DD;MRRYllu„}„‹‹‹————‘‹‘————‘„}}„‘‘‘‘——‘‘‘‘—‘—————¥¥—¥—¥—¥¥«¥¥«´´»»»»»»»»»ÃÃÃÍÍÍÍÕÍÍÕÍÕÍÕÕÕÕÕÕÕÝÕÝÕÝÕÕÕ»ÃÃÃûû»»»´»´»»´´»´´´«´´«¥—„llluulM..;D;.-$DYu}u}‘¥¥´´«´´«««««««¥¥¥«««¥««¥¥‹‘—‘‘‹}}^YRM;MDDD;;DMDDRR^^l}u}„‹‹‹‹‘‘‘—‘‘‘‘———‘‹„}}}„‘‘‘‘‘——‘——‘——‘—‘——¥¥«¥¥‘‘‘¥¥«´´»»»´´»´»»ÃÃÃÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÝÝÕÝÝÝÕÕÕÕ´»Ã»»ÃÃû´»»´»»´´´»»´´´««‘}lM;...;D;;MDMR^R;-.;;}‘¥—««¥¥´´´´´«´«¥¥¥¥¥¥«««¥¥¥¥‘‹‘‘‹„}u^YMMRRMMDMMMMY^luu}}„‹‘‘‹‹‘‘‘———‘‘—‘—‘„u}„‹‹‹‘‹‘‘‘—‘—‘‘‘‘‘‹‹‘—¥««««„M^‘¥«´»»»»««»»»»ÃÃÃÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÝÕÝÕÝÝÕÕÕ»»ÃÃû»Ã»»»´´´´´«´»´´´«—}YRMD.--.;DDDMRRR^^^R$R„‹„„‹‹¥¥´´´´«´´««««««««¥«««««———‘„„„„lYl^^YMY^YY^Y^^lu}}}‹‹‹‘‘‹‘‘‘—‘‘‹‹‘‘‘‘„}„‹‘‹‹‹‘‘‘‘‘—‘‘‘‹‹‘‘‘¥¥««´´«—^R}¥«´´»»´´´»»»ÃÃÃÍÍÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÝÝÝÝÝÕÕÕ»ÃÃÃû»»»»»´´«««—«««««¥uDDMRM..-.;.MMRYYRR^llM$D„ll}‹‹¥«´´«´´´´««´´««««««««««—¥‹}l}„‹„}„}u^Yl^^l^luuuu}„„„„„‹‘‘‘‹‘‘‹‘‘‘‘—‘‹„„‹‘‘‹‹‘‘‹‘—‘‘‘‘„„‘——¥¥««´««««‹DR—««´´´´«´»»ÃÃÃÍÍÍÍÍÍÍÕÍÍÍÕÕÕÍÕÍÕÕÕÕÝÝÝÝÝÕÕ»ÃÃÃÃû»»´´´««¥««—¥‘‘„^RRYY^lRD.---;MMY^^YRMYlMDuRl„‘‘¥«´´´´«´´«´«´««««««««««¥—‘‘‹}„‹‘‹‹„„u^uuulluuuu}}}„‹‹‹‹‘‘‹‘‘‘——‘‘‘‘‘‹„}‹‘‘‘‘‹‹‹‘‹‘‘‘‹u„‘—¥¥¥«««««««—M.„¥««´««´»»Ã»ÃÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÝÝÝÝÝÝÕÕ»»ÃÃû»»»»´»´¥¥—‘}u^YRMRY^u„}u^RD--$.MYllllRDMM--.^u„‘—««´´´´´´«¥««´««¥¥«««««—¥—‘‹u„‘—‘‘‹‘‹ul}}luuuuu}}„}‹‹‹‹„‘‘‘‘‘‘——‘‘‘‘‹}„——‘‘‹‹„‹‹‘‘‘‹}u}‘¥¥¥««««««««—l.u—¥¥«´´»»Ã»ÃÍûÃÍÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÝÝÝÝÝÕÕÕ»»ÃÃû»»´»»´¥—}lRYY^^RMYYll‹„uul^Y;--.DR^uulM;.--.Mll—«´´´««´«¥¥«´´«¥¥«««¥¥¥———„u‹—¥————‘‘‹„}}uuu^lu„}}„‹‹‹„‘‘‘‘——‘‘‘‘‘‹„}‹—¥—‘‹‘‘‹‹‹‘‹}uu„‘—¥¥¥¥«¥«¥¥¥—};^—¥¥«´´»»ÃÃÃÃÃÃÃÍÍÍÍÍÍÍÍÍÃÃÃÃÃÍÍÕÕÝÕÝÝÕÕÕÕ»»Ã»»«´»´´´—‹lRMRR^u^^^^lll}uul^}}^R...;D^uuYM;..$ M—¥««««´«««¥««««¥««¥¥—¥¥¥—‘‹‹—¥———¥‘———‘„}}}}}u}}}„‹„„‹‹‘‘——————‘‘‘‹„}‹¥———‘‘‘‹‹‹‹„u^‹‘—¥¥¥¥¥¥—¥———‘l;M„¥¥«´´»»ÃÃÃÃÃÃÍÍÍÍÍÍÍÍÃÃû»»ÃÃÃÕÕÕÝÕÕÝÕÕÕ´´´»»´»»««—„lYYRMMY^YY^^ulu}ulY^u}„u^RD;.MYl^RD.-$.‹‘¥¥—¥««««««´«««¥¥¥—‹¥¥¥————¥—¥—‘‘——¥——‹„}}„}„„„„‹‘‹‹‹‹‹‘——‘———‘‘‘‹}u‹—¥——‘‘‹‹‘‘}^l}‘‘——¥————‘‘‘—‘‹lMDu¥««´»»»ÃÃÃÃÃÃÍÍÍÍÍÃÍÃÃÃû»»ÃÃÃÍÕÕÕÕÝÕÝÕÕ´´»Ãû»´¥‘ull^RRYRRRMMRYYl}„}lYDR^„}}}uRD;;RYRM.$$$ ^‹‘—‘¥¥««««««««¥¥¥¥¥¥¥¥¥——«¥¥¥—‘‹‹¥¥¥—¥‘‘‹‹‹‹„‹„„‘‹‘‘‘‘——————¥—‘‘‹„l^„—¥¥——‘‘‘‹‹}lu‹‘‘—¥——‘‹‘‘‘‘‘‘‹„„„—¥«´´»»ÃÃÃÃÃÃÃÍÍÍÃÍÃÃÃû»»´»»»»ÃÍÕÕÕÝÕÝÕÕ´»»»»´—‹}ull^^YYRRMDDMMMDMYluuYM;MRl^u„lYD.;;MMD$$$ ^‹‘————¥¥¥¥¥««««««««¥¥¥¥¥¥¥¥¥——‘‘—¥—¥¥—¥———‹‹‘‘‘‹‘‘‘———¥—¥——————‘‘„u^‹¥¥—¥—‘‹‹‹}lu„‘—‘—‘‘‹„„‹‘—‘‘‘——¥—««´´»»ÃÃÃÃÃÃÃÍÍÍÍÍÃÃÃû´´´´»»»»ÃÍÕÝÕÝÕÕÕÕ»´´¥—‹l^^lul^l^^YYMM;;DD;DY^^lYM;.;;.^„}}YM;..;;;.  .Ru‹‘———¥¥¥¥«¥¥¥«««««¥—¥¥¥¥¥¥¥————¥¥—¥¥¥¥¥——‘‘‘——‘————¥¥—¥¥———‘‘‘‹„^l‘¥¥¥¥—‘‘‹„l^„‹‘———‘‹„‹‹‘—‘‘—¥¥—¥««´´»»»ÃÃûÃÃÍÃÍÃÃÃÃÃÃû´´«´´´»»ÍÍÕÕÕÕÕÕÕÕ´«—„u^^^ll}ullluluYY;..;D;RRlul^MD.;DRlu}llYD..;;.$ $Rl„‹‘——¥¥¥¥¥¥«««««¥¥¥¥¥«¥¥¥¥¥—¥¥—¥¥¥¥¥¥¥¥‘————‘———¥—¥——¥—‘——‘‹„}^„—¥¥¥¥¥‘‘‹}^l„‘‘‘‘‹‘‹‘‘‘——‘—¥¥¥¥«««´´»»Ã»»»ÃÃÃÃÍÃÍÃÃÃÃû»»»«´´»»ÃÍÍÕÕÕÕÕÕÕÕ¥‘l^u^l^^llulu}}}}}lRD;..-.DMYllYMDDDDMYluu}lMD;D;;$   $M^u}‘——¥¥¥¥¥¥¥«¥¥¥¥««¥¥¥—¥—¥‘—¥¥¥¥¥¥¥¥—¥——————¥—¥——¥—————‘‘‹„u^—«¥«¥¥¥——‹lY„‹‘—‘‹‹‹‹‹‘——¥¥—¥¥¥¥«´´´»»»»»ÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃû»´»»»»ÃÍÕÕÕÕÝÕÕÕÕ‹l^llll^llll^uu}luuul^R;-$--;MRYRMD;;;;MRlluu^RDDDD;-$  R‘———¥—¥¥¥¥««¥¥¥«««¥¥¥«¥—‘—¥¥¥¥¥—¥¥¥—¥——‘—¥——¥¥—¥—¥———‘‘‹„}„—«¥«¥««¥¥‹}u„‹‹‘‘‹‹‹„‹‘——¥¥¥——¥««´´»»»»»»»ÃÃÃÃÃÃÃÃÃÃÍÍÃÍÃû»ÃÃÃÃÍÍÕÕÕÕÕÕÕÕÍ^RRRY^llllul^uuu^lllu^lRD.--$.;MMMMDDD;;DR^u}ulRM;;D..--   -Y‹‘————¥¥¥«¥««¥¥¥¥¥¥¥«¥———¥¥——¥——¥—¥———‘‘———¥——————‘‘‘‹„}}—¥¥«««««¥—„l}‹‘‘‹„‹‹}‹‹‘—¥¥¥———««´´´´»»´«´»ÃÃÃÃÃÃÃÃÃÃÍÍÍÍÃÍÃÃÃÃÍÍÍÕÍÕÕÕÕÕÕÕÍRMMYYYuulu}uuull^^^R^^^^RM..-$.;;DMMMDD;DMR^u}ul^MDD..$.-  .l„‹————¥¥¥«««««¥¥—¥«—¥—¥¥—¥—¥‘¥——¥———‘‹‹„‹——¥————‘—‘‹‹}}‹¥¥«««««¥¥—‘}„„‹‹„‹„}}„‘‘———¥——¥¥«´´´´´«—‘´»ÃÃÃÃÃÃÃÍÃÍÍÍÍÃÍÍÃÃÍÍÍÍÕÍÕÕÕÕÕÕÕÍÍMMMRRR^l^u„„„„}ul^YMMMMYllYM;-$---.DMDMMM;DDRlu}}YYM.-$---  -M„‘—‘——¥¥¥«««««¥««¥——«¥¥¥¥———‹‹————„„‹„}}‘‘—¥——————‘‹„‘¥««««¥«««¥¥——‘‹„„}uuu„„„‹‘‘——¥¥«««´´´»´´‘‹´»ÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÍÍÍÍÍÕÍÍÕÍÍÕÍÍÍÍÍÍMMMDMRRR^u„‹‘‹‹‹‹uuYRMMRYYYYYD.--$...;;DDDD;MYlluu^YD..-$$  ^‘‹‘———¥¥«¥«««¥¥¥¥¥¥¥«¥¥—¥—‘}l„‹‹„„‹‹}ul„‹‘——‹‘‘‘—‹‘‘¥¥¥¥«¥¥««««¥¥—‘„uluRY^uuuu}„‘—¥¥«´«´´´»´´´«»ÃÃÃÃÃÃÃÃÍÍÍÍÍÍÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍMDMMMMMDM^u„‘‘‘‘‘„}llY^YRRRMRRDD-$-$--.;DDDMMRYluuu^MD;;-$   $R^„‹„‘——«¥¥«¥¥«¥¥¥¥¥¥¥—‘‘„‹l;..M}‹‘‹}R;}‘‘—‘‹„„‹‹‹‘¥¥¥¥¥¥¥«««««¥¥—‘lMDD...;;;;Dl‹—¥««´´´´´´»»»»´»ÃÃÃÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÃÃÃÍÍÍÍÍÍÍMMMMDMMRRYlu}‹‘‘‘‹„}uYu^^YRMRRMRD;-$$-..DDDDDMMY^uulRD;D..$    $.Y„‘¥—¥¥«¥«««¥¥¥¥¥¥‹}uu}.;}‹‹„l.l‘——¥—„lYu„‘—¥¥«¥¥¥¥¥¥¥¥¥¥¥—‹R$$$R‹—¥«´´´´«´´´´»»»»ÃÃÃÃÃÍÃÍÃÍÍÍÍÍÍÃÃÃÃÍÃÃÃÍÍÍÍÕÕÍÕÍÍMMMMMMMRRYYl}„‹‹‘„„„lYY^^^RRMRYYYRD......;;DDMRRR^uulMD;;...   ^‘——¥¥¥—¥«««««¥¥‘lD^}l$ D„‹‘„Mu‘—¥¥———}MR}‹—¥¥¥¥¥¥—¥‘‹—¥¥¥—‘Y  ^‘—«««´«¥¥—„„¥»»»»ÃÃÃÃÍÃÍÍÍÃÍÍÃÃÃû»»»»ÃÍÍÕÍÕÕÍÕÍÍÍRMMMRRMRRR^^ulu}„„‘‹‹„u^R^YRMDMRl^YMD.$-$$-.;;DDRRlll^YM;..--  D„‘——¥—«¥«¥«««¥¥‘^.l}l^Y;D„‹‹„}‹‹——¥¥——‹lM^}‘—¥¥¥¥‘„}^Ru¥¥¥¥—l $l‹—¥«´´«¥¥‘ul„´Ã»ÃÃÃÃÍÃÍÃÃÍÃÃû»»´«¥—´ÃÍÍÕÕÕÕÕÕÕÕÍÍMMMMMRRRYYl^ll^llu}„„„}lMDMMDD;MY^l^RD.-$$$-.;;;;MRYlulYM.-$-   M„‘———¥¥¥¥««¥¥¥—l$Mu„‹‹‹^;^„‘‘‹„‹——¥¥——‘„ul}‘—¥——‘‹}^RRu—¥¥¥‘„; $^„‘¥¥«¥¥¥¥«¥—«´»»ÃÃÃÃÃÃÃÃÃûô«¥—‘‹‘«»ÍÍÍÍÕÕÕÕÕÕÍÍÕMMMMMMM^l^YY^l^l^YYu}„‹}M;DDDMMMY^uuuYD;--$$-....DDY^u}uYR;;.$   ;}‹‘—¥—¥¥¥‘—¥——^$-l‹‹‹‹‘}}‹‘‘„„—¥¥¥———‘‹‘„„‘—‘‘‘„„„uMYY‹—¥———„.  M}‹—¥¥———««««´´»»»ÃÃÃÃû»Ã»´«‘}u}}‹«»ÍÍÍÕÕÍÕÕÕÕÕÕÍÍRRRRRYR^^YRYYY^YYYR^l„‘‹lMDM;DD;RY^uulYM;.-$$-.-..DRR^}„}lM;;.  Y„‘———¥—————‘Y$-Y„‹‹‹‘‘‘‘‘‹}‘——«¥¥—‘‘‘‘‹‘——‹‹‹ul}uuuDY‹—¥¥—‘}. .l„‘——‘‘¥¥««««»»»ÃÃÃû»»»´´¥„l^u}‘«ÃÍÍÕÍÍÍÕÕÕÕÕÕÕÍÍRRRRY^^lYRRYYYYMMMRR^}‘‘‘lMMDDM;DDRYl}ulR;---$---.D;D^„„„uYD..$   Mu‹‘——¥¥——‘u;$-Dl}‹‹‹‘‘‘‘}u„‘——¥‘—‘———————‘‘‹ul^u„„Y;u—¥¥——‹^ $;^}‹„u}‘¥¥¥¥«´»»ÃÃû»´´´¥‹u^^uu‘«ÃÍÍÍÍÕÍÕÕÕÕÕÕÕÍÕÍYYY^^u^l^R^Y^YRMDDMMR^}‘‘„lYDDM;D;M^u„„}lM..----$...;Yu}„„lR;-$   Rl}‹———‘‹^-$$;MY^u}„‘‘^..Y‘‘lY„—‘——¥¥¥——‘‹uR;Y„}^DR‹¥¥¥—‘}-.YulDDu‘‘—¥¥«´»»Ã»»»´«‘}YRllu‹«»ÃÃÍÍÍÍÕÍÕÕÕÕÕÕÕÍÕY^}l}„}ll^^„„RMM;DMDMRl}‹‘‹^DD;;;;R^l}„„}lM;--------.D^}„„}^D--$   R‹‘‘„l...Ru‹‹u.$M‘‘l^‹‘‘‹‘¥—¥—‘‹}Y-;RuYRMR„—¥¥¥‘}--DD-$;u‹‹—¥«´´»»»´«¥‘lMMYllu—»ÃÃÍÃÍÍÕÍÕÕÕÕÕÕÍÕÕÍl}‹‘‘‘—‘„uluuRMD;;;;DMR^}}‹}YD.;.;MR^u„„„}lD...---$$..Rl}}}lM;.-   -u‹„uR. ;u‹‘‘„^‹——‘‘‹‘‹‘—¥¥¥—‘uR;;M;;-.RRY‘¥¥——Y$$$-;l—¥««´´»´´«—„R;DMYYl‘´»ÃÃÍÍÍÍÍÕÕÕÕÕÕÍÕÕÕÕYl‘—««««—}ll^YM;;;;;;DRYYMRulM;;;;DR^l„„„„uRD.;...$$-.DMl}ul^RD-   $Y}lMM.$ M}‘‘—‹‹‘—¥—‘‹‹‹‘¥—¥¥‘‹^D;R^D.$$DD-„—¥¥—^$-^—¥«««´´´´¥u;.;;MR^‹«»ÃÃÍÍÍÕÍÍÍÕÕÕÕÕÍÕÕÕÕY^„‘¥«««¥‘‹„u^RD;;.;;;R^R..;YlM;D;DDRYu„‹„‹lM.D.;.-...DDRl}lu^Y.$    -^lMY;.u„„‹‹l„‘‘—‹„‹‘‘—¥¥——‘}D$$M^M;.$;D-u‘¥«¥‘;.„—««´´´´´«‹M;;.DDR}¥´»ÃÃÍÍÍÍÍÍÍÕÕÍÕÕÕÕÕÕÕMR^}—¥‹‘‘«¥¥‘uYM;;;.;;^}l;$$.l^M;D;;MR^‹‹‹‹}uMD;D;.;.;.DDRlluu^R-   $.YMD;$Duu„uY^„‘‘‹‹‹‘————¥—‘„^$-Y;;D$...^‘—¥—‘l$$D„¥«´´»´´«¥„YMD;.Dl‘«´»ÃÃÍÃÍÍÍÍÍÕÍÍÕÕÕÕÕÕÍDMRYu‹‘‹„‘—«¥‹uM;....Dl„u;$$D^MD;D;DR^„‘‹‹}uYM.;;;;;;;..;MRllu^M   .;$ $Mu}R-^‹‹‹‹‹‹‘¥—‘‘‹‹‹};$D;.MD.$$;^‘‹„‘}-$-$$Y„—«´»»´´¥‹}l^Y;.Ml—«´»ÃÃÃÃÃÃÍÍÍÍÕÍÕÍÕÍÕÕÍMDMMR^„‘‹}‹‘——„lD;;..Dl}uM$$DR;D;;DM^„„‘‹}uYM;.;;..D..-.;DR^luY-  $ ;M-u„}}„‹‹„‹‹‹ul}l^--.R^R.$;}ul„u$---$.u‹¥«´´»´««—‹„}lR;;u‹¥«´»Ã»»´ÃÃÃÍÍÍÍÍÍÍÕÍÍÕMRRMDMR}‘‹}u}‘—‹^D.;..luYR--YRD;MDM^}‹‘‹‘„}RMDD;.;;;..;;DMY^ul;   $   .uuuuu„}}„„u^l^RR.;YllR$$-RD.YR$-.-$;}‘—«´´´«««——‘‘„lD.D^„—¥«´´¥‘—´»ÃÃÍÍÍÍÍÍÕÍÍMMYYRM;Mu‘‘ulu‹‘„R;.;;^^MR.$$;^RDD;;Ml‹‘—‘‘„lYR;;;.;;;.;.;;MR^lM $$  .Yl^^^llu}uM;R;.M--;^^Y.$--..$-;.-M}‘¥«´´«¥«´«¥——‘}M..;Dl„—««‘}„‘«´»»»ÃÃÍÍÍÍÕMMRu„uD;D^‹„llu}„lM;.;Y^;MD$-R^RD;;D^‹——‘‘‹„u^MD;;;.;;.;.;;;MRD$ -$$$ -.-$--.MD.$;$R$DRMD-$$-$-;D.$$;u‘¥««´¥¥«´´«¥¥‘„M...;;R}‘‘„}}„‘¥««««´»ÍÍÍÍMMR^‘—uM;D^„‹u^u}„lD..Rl.;R.$;u^MDMMR„‘‘‘‘‹‹„}^MD;.;...-.;;;DDD$  $$$$Y-$.^l-$$.D;-$$$;l‹—¥¥¥¥¥«´««¥¥‘uD....;DRY}}}}„‘¥««¥¥—«»ÍÕÍRRMR}——lD.;Y„„u^^}}^D.D^D;RM-$-R}lRRDMu‘‘‹‘‘‹„„lRM;;;.-....;.;;.$$$$$$Y;$.l}D$-;DD.$$-$$.Y}‘‘——‘—¥««««¥—};.....;;M^„„‘‘¥«´«¥‹‹—»ÃÍÍl^RRY„—‹Y;.DY„„lY^„„R;;^R.M^R$$;l}RRRMR„—‘‘‹‹‘„}lRDD;;-;;;;.;;;-$-$$$$$.;MDRM$$$.l}Y-$--;;;---$$$-Ml‹‘‘‹}‹—««´««¥‹M......;D^}‹‘¥««´«—„}‘´ÃÍÍ‹„^RR^‹—uM;.;Y‹‹l^u‹}DDY^;D^l.$-MulRRRMl‹‹‹‘‘—‘‹lRDDD...;.DD;.;.-$$$$-$$$$$$$$M}}Y$RY$$$.---l}Y-$$-.;D.$-.-$-.M^„‘‘}M^„—¥««´¥‘l;....;.DRl}‹¥«´´´‘„„—´ÃÃÍ——„YYYu‘‘lM..D^‹‹l^}‹^DM^DDRlM$$.l}YRRYYu„‹‹‘‘—‘„^YDDD;;;DDDD;;.-$ $$$$$$$---$$$$$$$$$R‹‘‹R-Ml-$$$$.;$-^^M$$$-.;$-;.-$.Y^^„‘}M-.Yu‹—¥«¥—u;;.;;.;;DMYu‹—«¥¥—‘——«´»»¥¥—}YY^‹¥‘‹R;.D^‹„^^„‹RMYD.DR^;$.R}uRRYYYu}„‹‘‹‘‹uYRMDD;DDDMMD;;- $$$--..-$$$$$$$$$$$$$$$^———‘Y$;u;$-$$.$-;.$$.D--;;.-Du}u}‹^.---Dl„—¥¥—}D;;.;DDDDMMR^„‘—‘——¥‹‘——«‘—¥‹l^l}‘««„R;.D^‹„uu‹uRYR;;MlM$$$;l„YMMMYu‹‹„„„‘‘„lRRDMDDDDDRMDD-$ -$$$$-$$.$$$$$$$$$$$-$^—¥¥—‹M$.uR$$$$-D--D-$$.;;.R}„„}}M-$-$-.R„———uD;;;;DMMDDDMMYlu„‘¥—‹}}‹¥‘—¥¥‹llu‘«´¥}M..Ml‘‹u‹‘„ulM;DRY.$$$;u„uMMRRl„‘„}u„‘‹}YRDDDMDDDMMRD.$ $$$-$-$$$$$-$$-$$.‹¥¥¥¥—‹D.ll$-$$-RM$-D;--;D;DY}„}}Y.--$---.Y}‹„Y;;;;DMMMMMDMMRRYl„‘—u^l„‘‹‘¥«—}ul}¥´«¥„M..Dl‹„‘——‘}^M;;R;-$-Mu}YRRRY}‹‹ulu„‘„uYRMMDDDMMMMD;$$$$$$$$$-$$$--$..Du—««««¥—}-Yu-$$$.YR--DM;-.RMDMlu^M;------..;MYYM;DDDDRRRMMMRMMRYRluu^^^u‹u}—«´‘„u}‘«´´¥„M..Ml‘—¥¥¥‹lM;D;;-$$-;R}u^RRR^}‹‹ulu‹‹}RRRDDMMMDMMM;$$--$$$$$$$$$$$-.;MRu—«´«««««‹-;}D$$$$$$.;$$;DD.;RRDMRM;.--....;;..;DMDD;DDMR^YMMMMMMRRRR^YYR^^l^l„‘«¥‘„‹‘««««¥l;.;Ml‘—¥—„uYD;.;-$$.Ml}}YRMRu‹‹uuu‹‹ulRDDMDDDDRYRD$$-$$$-$.-$$$$$-RYl}‘«´´´´´««—D-lY-$-$$$$$$$-.M;;Y^RD;.--$...;;DD;;;DDDDDDDMRY^RMMMMMMRYYYYYYYYYYY^}‹¥¥¥«´««´´¥‘^;.;Mu‘——‹ulR;;..-$-;R}„^RMR^}‹„u}„‘„lYMMDDDDMMYRM.$-$$$$$$$$$$$$.$$$$.u‹‘—««´´´´´´«—M$^^-$-$$$$$$-D;D^lYDD;...D.;;;DM;DDDDDDDMMMR^^RRMMMMMRR^^YYY^YYRRRY^}„—«´»´´««—„R.;;Mu‘—‘„lRD;.;-$$-;R}‹lMDDR^}„l^u‹‹}YMMRMMMMMRRRM-$$--$$-$$$$-$--$$$$;}‘¥««´´´´´´´«¥R-Y}.-$$$$$$$-;DDY^RMMMD;;DD;DDMRMDDMDMMMMRMR^^YRMRRMRYYY^^YY^YYRRYY^^Y^u‹¥««—¥‘‹lM..;Mu——„}YM;;..$$.;R}‹^RDMR^}ull}„‘‹YMMDMRRRYMRYY;$$$$-$$$$$$--$$$$$-D‘¥««´´»»´´´´«¥^.M};-$$$$--$$$;DMYlYRMDRDDDDDDMMMMDDMMMMMRRMY^^RRRMMMR^^YYYYY^^^YY^uluu^^Y^u„‹—‘‹}^D..;R}‹‘}YRDD..-$-.Dl‹lYRR^„‘‘}}„‘¥‹^RMDDRRRRRRY^M--$---..--$-$--$$$$-Y—¥«´´»»»»»´´«¥}-;}M--$$$----$;MRY^YYRMRYRMMDDMRRMMMMMMRRRRMRRYYYYRRRY^^^YYYYYllY^uuu}„„}lllY^}‘—‹uY;..DR}‘‹lRDD;.-$--.Y„„lYRu‘¥‘„u‹——}YRDDDMMMMYYY^Y;$$.------$$$$$--$$$$.}—«´´»»»»´»»´´«‹..}Y--$$$$$$$--$;MYYlllRMR^^RDDDMRMDDMRRMMMRRMRYl^^YY^^l^^YYY^^^llY^luu}‹„„‹‘‹„}uu}‹„uM;..DR„‘uYDD;..-$-.Ml„u^l}‘—‘}}‹‘‹lRMMMRMMRRYMR^^R.$$$.-$$-$-$$---$$$--R‘««´´»»»»»»»´´«—D-uu-$$$$$$$---;RYluuYRRllRMMDRYRDMRMRRRRRRRYYll^^^lulll^^^lllu}YYY^luu}}‹—«¥¥‘‘}}„„lM..;;Y„„^RMD;.-$-.D^‹}lu‹——‹}‹——‹^RMMDMMDMRYMRYlY;$$$$-$$$----$-$$---M‹¥«´»»»»»»»»»´´¥Y-l„.$$$$--.;DR^}}^YYll^MMDRYYMRMMMRRRYYYY^llluu}uu}ull^lu}}}ll^YRYYY^u„—«¥««—‹}}}lR...;l‹}YRD;.--$--R„‘‹‹———‹‹—¥—}^MMDD;MMDMYMRYY^R-$$$$$$$$$$$--$-$$$$---;l¥«´»»»»»»»»»´´«u.Y„M$$$$$$--.;DRu„„uYRl}lRMMMYRDMRRRRYYYY^lluu„„‹‘„„„}l^lu}‹‹„u}}ll^RRYRYu„—¥¥¥¥„}uulM..;u}„uYR;..----.l„‹——‘‘——¥¥‘lRMMD;;DDMMMRRRYMRD$-$$$$$$$$$-.--.---$$--D‹¥´´´»»»»»»»»´´«„DRuM$$$$$$-..;D^‹‹}YR^„u^RMRYMMMRRYRRRY^^ll}‹‘‹—‘‘‘‘‹uuu„‘‘‘‘RYY^uulluu^Yl}„}„‹‘}}uulD..R^}„lR;;.----.;Rl„„‘‘¥¥¥—„lRMMDDD;MMMDDMRYMDM--$$$$--$$$--;;.---$$$-$$;‘¥«´´´»»»»»»»»´«‘^MlY$$$$$$$$--;Y‹‹„lRYuu^RRYYRMRRRRYYYRYY^}‹‘‘———¥¥—‹„}‘——¥——YRRRY^u}„„}ll„uY^uulu„}}Y;..;R„„^M;.-$---.;MRlu‹‘¥¥—}lRD;DMDDMDMDDDRR^YD-$$$-$.$$-..;;;$$$$$-$$.‹¥««´´´´»»»»»»´«—u.^l$$$$$$$-.M}‹‹}YY}}lYMRRRRYYYYYRYYYYu„‹—‘———¥¥—‹‹‘¥¥«¥¥¥ul^^YRR^u}}u}‘‘u^^^^ll}uYD...D^‘}RD.--$--.;;MRl„‹‹—„lRRDDMMMDMRRM;DRR^^R;-$$--$$-....$$$$$$$$-M‘¥«´»´´»»»»»»´¥¥}.Ml;$$$$$$$$$--Dl‹‘}RYu}lYRR^YYYYYRYYRYY^}„‘‹‘——¥—¥‹‹—«´´´´´«„}u}}lRMR^}}„‘—¥‘}^ll^uu^M;...M}„^M;------.;DMYlu‹‹„^RD;MMMDMR^^YRRRRYlYR.$-$--$$$$$$$$$--$$--M‹««´»»»»»»»´«¥—‹;D}Y$$$$$$$$$.Dl‹‘„^Yl}uRMRYRRRRRMRRRYY^}„„„„‘—‘—‘‘¥«´´»»´»»uul}„}YMMMYu„‹—¥—¥‹u^^lulYM...;Y‹„YD..-$---.DMR^}‹‘‹lRMDDDMDMRlul^RYYR^YY;$$$---$-$$$$$$$$-$$$$---l¥«´´´´»´´´´¥¥—„.;uR$$$$$$$$$$-;Y‹‘„l^u„lYMRYRRYRMMRRYY^lu}}}‹‘‘‘„‘—´«´´»»»»»}uuu„„}YMDDM^„‘¥¥«´¥„l^^^lRD..;;u‹}M..---$-.;;DRl‹—‹^YMDD;DMDRl‹}uYYRYYYY;-$$$$$---$$-----$$$$$$--R—««´´´´´´««¥¥—l--lY$$$$--$$$$$$$$-M}‹„lYl„}^RRRRRRMRRRRY^^l^lu}„‘¥‘‘—«´»»»»»»ÃË‹„„‹‘‹„^RDDMR}‘¥«´´«‘}^YRRR;;.;R}„YD..-----.;DM^‹—‹^RMDD;D;RY}‘—„lYRYY^YR.-$$$$$-.-$$$--....-$$$$$$--l—¥«´«´««‹‹‘‘‘u-$^u$$$$$$$-$$$$$$$$$-;u„„}Yl}}^RRRRYRYRRRRR^^^^l^u„‹‹‘—««´»»»»»»»»‹‹‹‹‹‘‹‹„u^RDDM^„—«´´«—„^MRYR...;Mu^M;.----.;DDDY}—}YMDD;;D;R^‘——„l^RYYlYR.-$$$-$-.--$$$--...$$---$-$D„—««««¥„;;M^lR-$^}.-$$$$$$$$$$$$$$$$$$.^‹‹„ll}}uRRRRRR^RRRRYY^^^^^}}}„‹—¥¥´´»»»»´´»——‘‘¥‘‹„‘‘‹uYRMM^‹—¥´´¥‘u^YRY;..;;^„RD...--..D;.;Y‹}RMD;;;DDYu‘——„}lY^Y^lMD-$$-----$-$-$$$$$-;-$-$-.„—¥¥¥—R-$$$$$--Y„D$$$$$$-$$$$$$$$$$$.Ru‹}^l}„lRRRYY^YYRRRYY^YYYl^l}„‘—¥´´´»»»´´»Ã¥¥‘——‘‹‹‘‘‘„u^YRMl„‘¥´´¥l^RRRM;..;MulM;;..-....--D^uRMD;;;DMY„—¥——‹Y^YYll^R.-$---$$$$$$$$$$---$-$-$;Y}}uu.$$$$$$-M„Y-$$$$$$$-----$$$$$$$$$$.;Y„„l^u}^YRYY^^^^YYR^YYYMMYl}„‹——«»»»»»´»´Ã×—‘‘—‘——‘—‹‹„ulRMRl„‘¥«¥„YYRMMD;.;;Y}^D;..---.-.DY}lRMD;;DMRl‹¥««¥„lYYYYllR.-$$--$$$$$$$-$$-$$--$-$-$$$$$---$$$$-D„^-$$$$$$$$-----$$$$$$$$$$-.D„‹}^uu^Y^Y^l^^^YYYYRRMMMRl}‹‘—«´»´´´´»»»ÃÃ¥¥«´««¥———‘‹‘‘„ulYYu‘«««‘u^YMMDD;.;Ml}RD....--..Ml‹uMM;;DMR^„¥¥¥¥¥‹u^YY^ulY;$$$-$$$$$$$$$$$$$$$$$--$$$--$-$-$$$$$$--$$$$$;„}.-$$$$$$$$$$$----$$$$$$$$$-.M}‹u^uul^^^ll^^YYY^YYRMDMRu}‹—««»»´´««»»ÃÃÃ¥«»Ãû´´«´¥—¥———‘‹}u‘´´´¥„l^YMDD;;;;R}uM;....--..u‹^MD;;MRY^‹¥¥¥¥¥‘}^^Y^^u^D-$$-$$$$$$--$$$$$$$$$----$---$-$--$$$$..$$$-u„;-$$$$$$$$$$$----$$$$$-$$$--D}‘‹ulu^^Y^l}^YYYRYYYRDDDYu„—¥¥´»»´´´´»»ÃÃÃ¥«ÃÍÃû´´«¥—¥—¥¥¥¥‘‘‘«´´¥‹ul^YRDD;;;D^}Y;.;..---.Y„YRDDDDR^}‘¥—¥¥¥‘„^^YY^uuM-$$$-$$$$$$$$$----$$------$----$$--$$$$$--$$$Y‹M--$$$$$$$$$$-----$$$$$$$$-.D}‹‹ull^Y^lu}l^RYRYYYMDDM^}‘—«´´»»´´´´»»»»»‘—»ÃÃÃÃû«—‘}„‹‘‘‘———‘¥¥—‘„}}l^MD;;;;MuuM;....--.RlYYMDDDR^‹¥——‘—¥‘„lYYY^ulR.-$-$$$$$$$$-$--$---$------------$--$$$$$$$$$$$M„Y.---$-$$$$$--...--$$$$-$--.Du‹‹uu}lYYl}„llYYYYYRMDMRl„—««´´´´¥´´´´´««¥‹‘«»ÍÍÃÍô´—‹}l^^^ll^^^ll^lluu}YMD;;;;RuYD;.....;M^YYMMDMR}—¥————¥‘lYYYRYlu^D----$$$$$$$-----$-$-$-..-----.-.---$$$$$$$$$$$$$$;„l.-----$-$$$-..-..-$-$$$$--;Du‹„}}}uYYl„ul^Y^Y^YMMDRRl„—¥¥—¥—¥—¥«««¥¥¥¥„‹‘´ÃÍÃÃÃÃÃô«¥‹u^^YRRMMMMMR^„‘}YD;;;;Dl}M;;....;RulYMMMMY‘¥¥—«¥¥—‹lY^YYYYl^M..---$$-$$---$--------....---....-.-$$$$$$$$$$$$$$-u„;------$-$------..-$-$-$--.Ru}ul}‹uY^l}}^l^l^^^MMDDR^}‹‹‹„}}„‘‘——‘‘‘‘¥u}‘¥´ÃûÃÃÃÃû´«——‘„}ull^ll}„‘¥—uMD;;;;M}Y;;;..;;Y‹uRMMMY}—¥¥¥¥«¥—‘ulYYYYY^uR;-..-----$--....-..---;;;;.--.D;--.---$$$$$$$$$$$$-^‹;---.------....;;..---$--.;Rlul^„‹}^^l}}lY^^^^YMDDDRYuuuulluu„‹‹‹‹‹‘¥«lu‹—´»»»Ã»»»»Ãû»»»««´¥«««««—‘—¥‘lMD;;;;MYD;;.;.Dl‹lRMRR^‘«´¥¥¥¥«¥‘}^YYYRM^}RD-...------...DD.;.---;DD..--..;.;...-$$--$-$-$$$$$R‹R--.-...-..;.;;.;;.--$---.;R^l^l}‹}^^l}}l^^^^^YMDDMRY^^l^llu}‹„„„„„—«»}u„‘«´«»Ãû»»»»»ÃÃÃû»»»»´´´«¥¥«—„YDD;;;;MM;;;.;Du„uYRRY}—´«¥¥¥¥¥¥—‹uYYYRY^uYD..;-------.;.;;;;.....D;......;;;...--$--$--$--$--;‹^---.....;.;;;;..;..-----.;MYllu„‹}l^luu^^^^^^RDDDMMRYY^l^uu}uuu}„—«´´‹„‹‘¥««´´ÃÃû»»´ÃÃÃÃûû»»Ã´«¥««¥„lRDD;;;DDD;;;;Mu‹uYRYl‹«««««¥—¥«‘‹lYRYRRYlYM.;..--.---;;.;;;.;;...;;;.....;.;...--------------.‹u----..;;.;.D;;..;..----..DR^l^u}‹ul^l^l^^Y^^YMDDMMRRRRY^^llulu}„‹¥«««‹„„‹¥¥—¥«´»»»»»´´ÃÃÃû»Ã»»´´«««´«‹u^DD;;;;;D;;;;Mu‹u^YY}—´««¥«¥—¥«—}^RRRRR^^^M;;;........;;;D;;.;;;..;;...;;.;.....--.----------.}„;----..;.;;;D;;;.;.-----.DY^^ll„‹}^lY^Y^lY^^RMDDMMRRRRY^^lluul}„‘‘¥‘¥„„}‹‹—‘—¥¥´´»»»»´»»»Ã»»»»´«¥««««¥‘}^MD;;;;;;D;;;M}„}^^u—´«¥¥««¥¥¥¥‘u^YY^^^^lYR;;;;..;...;;.DD;;;.;..;.;....;.;;..;.--.-----------l‹D-----.;..;;;D;;;...---..DYlY^u„‹}l^YYYYY^YYMMDMMMRMRRYY^^^llu}„„}„‹‹ \ No newline at end of file diff --git a/PixHtLab-Src/Docker/imagen/doc/index.ipynb b/PixHtLab-Src/Docker/imagen/doc/index.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..4f91262c23ae35a348c427a95201521a3036dac6 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/doc/index.ipynb @@ -0,0 +1,407 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
    " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The ImaGen package provides comprehensive support for creating resolution-independent two-dimensional pattern distributions. ImaGen consists of a large library of spatial patterns, including mathematical functions, geometric primitives, and images read from files, along with many ways to combine or select from any other patterns. These patterns can be used in any Python program that needs configurable patterns or streams of patterns. Basically, as long as the code can accept a Python callable and will call it each time it needs a new pattern, users can then specify any pattern possible in ImaGen's simple declarative pattern language, and the downstream code need not worry about any of the details about how the pattern is specified or generated. This approach gives users full flexibility about which patterns they wish to use, while relieving the downstream code from having to implement anything about patterns. The detailed examples below should help make this clear.\n", + "\n", + "## Usage\n", + "\n", + "To create a pattern, just ``import imagen``, then instantiate one of ImaGen's ``PatternGenerator`` classes. Each of these classes support various parameters, which are each described in the [Reference Manual](Reference_Manual) or via ``help(``pattern-object-or-class``)``. Any parameter values specified on instantiation become the defaults for that object:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import imagen as ig\n", + "line=ig.Line(xdensity=5, ydensity=5, smoothing=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then whenever the ``line`` object is called, you'll get a new [NumPy](http://numpy.org) array:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "line()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here the parameters ``xdensity`` and ``ydensity`` specified that a continuous 1.0×1.0 region in (x,y) space should be sampled on a 5×5 grid. The ``line`` object can now be called repeatedly to get new arrays of data, with any parameter values specified to override those declared above:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "np.set_printoptions(1)\n", + "line(smoothing=0.1,orientation=0.8,thickness=0.4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see, the results are in the form of a Numpy array, and here we have used very small arrays to avoid generating a lot of numeric output. For larger arrays, it is convenient to view them as images, which you can do easily if you have the ``PIL`` or ``pillow`` libraries installed:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "line.set_param(xdensity=72,ydensity=72,orientation=np.pi/4, thickness=0.1, smoothing=0.02)\n", + "\n", + "line.pil(orientation=3*np.pi/4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see, the `.pil()` method accepts the same options as supported elsewhere, making it simple to create the image that you need to generate. `.pil()` returns a PIL image, which can be exported to files on disk using the methods described in the PIL documentation.\n", + "\n", + "ImaGen depends only on NumPy, Param, and HoloViews, none of which have any other required dependencies, and it is thus easy to incorporate ImaGen into your own code to generate or use patterns freely. That said, HoloViews supports various plotting libraries, including Matplotlib and Bokeh, and if you have one of those installed then imagen provides a convenient way to plot the pattern objects with axes and labels:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import holoviews as hv\n", + "hv.notebook_extension(\"matplotlib\")\n", + "\n", + "line[:]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use this plotting interface to show off the remaining patterns, but please remember that the main purpose of ImaGen is to generate arrays for use in other programs, not simply to draw pretty patterns for plotting!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dynamic parameter values\n", + "\n", + "As you can see above, ``PatternGenerator`` objects return different patterns depending on their parameter values. An important feature of these parameter values is that any of them can be set to \"dynamic\" values, which will then result in a different pattern each time (see the [Param package](http://ioam.github.io/param) and its ``numbergen`` module for details). With dynamic parameters, ``PatternGenerators`` provide streams of patterns, not just individual patterns. For example, let's define a ``SineGrating`` object with a random orientation, collect four of them at different times (using the ``.anim()`` method), and lay them out next to each other (using the ``NdLayout`` class from HoloViews):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numbergen as ng\n", + "from holoviews import NdLayout\n", + "import param\n", + "param.Dynamic.time_dependent=True\n", + "NdLayout(ig.SineGrating(orientation=np.pi*ng.UniformRandom()).anim(3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see, each time the sine grating was rendered, the pattern differed, because the parameter value for orientation was chosen randomly. Of course, you can set any combination of patterns to dynamic values, to get arbitrarily complex variation over time:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%opts Image (cmap='gray')\n", + "sine_disk = ig.SineGrating(orientation=np.pi*ng.UniformRandom(),\n", + " scale=0.25*ng.ExponentialDecay(time_constant=3),\n", + " frequency=4+7*ng.UniformRandom(),\n", + " x=0.3*ng.NormalRandom(seed=1),\n", + " y=0.2*ng.UniformRandom(seed=2)-0.1,\n", + " mask_shape=ig.Disk(size=0.5,smoothing=0.01))\n", + "NdLayout(sine_disk.anim(3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Composite patterns\n", + "\n", + "As you can see above, ``PatternGenerator`` objects can also be used as a ``mask`` for another ``PatternGenerator``, which is one simple way to combine them. \n", + "\n", + "``PatternGenerator``s can also be combined directly with each other to create ``Composite`` ``PatternGenerator``s, which can make any possible 2D pattern. For instance, we can easily sum 10 oriented ``Gaussian`` patterns, each with random positions and orientations, giving a different overall pattern at each time:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gs = ig.Composite(operator=np.add,\n", + " generators=[ig.Gaussian(size=0.15,\n", + " x=ng.UniformRandom(seed=i+1)-0.5,\n", + " y=ng.UniformRandom(seed=i+2)-0.5,\n", + " orientation=np.pi*ng.UniformRandom(seed=i+3))\n", + " for i in range(10)])\n", + " \n", + "NdLayout(gs.anim(4)).cols(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once it has been defined, a ``Composite`` pattern works just like any other pattern, so that it can be placed, rotated, combined with others, etc., allowing you to build up arbitrarily complex objects out of simple primitives. Here we created a ``Composite`` pattern explicitly, but it's usually easier to create them by simply using any of the usual Python operators (``+``, ``-``, ``*``, ``/``, ``**``, ``%``, ``&`` (min), and ``|`` (max)) as in the examples below.\n", + "\n", + "For instance, here's an example using ``np.maximum`` (via the ``|`` operator on ``PatternGenerator``s), rotating the composite pattern together as a unit. We also leave it as a HoloViews animation rather than laying it out over space:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%opts Image.Pattern (cmap='Blues_r')\n", + "l1 = ig.Line(orientation=-np.pi/4)\n", + "l2 = ig.Line(orientation=+np.pi/4)\n", + "cross = l1 | l2\n", + "cross.orientation=ng.ScaledTime()*(np.pi/-20)\n", + "l1.anim(20) + l2.anim(20) + cross.anim(20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The ``.anim()`` method collects results at different times conveniently. What it's doing repeatedly is getting a copy of each pattern, then running ``param.Dynamic.time_fn.advance(1.0)`` to advance the nominal time, then getting another copy of each pattern until 20 different times have been sampled. The values are \"time dependent\" (because we set them to be so above), so that any randomness changes only when the time changes, and the randomness is computed as a function of time. That way, regardless of the order you generate the patterns, or even if you go back and forward in time, you will always get the same results at a given nominal time. In your own code, you can turn off time dependence (``param.Dynamic.time_dependent=False``), in which case new parameter values will be generated for every call to the ``PatternGenerator``. Or, if you are working in a domain that has a clear temporal component, such as simulation, you can set ``param.Dynamic.time_fn`` to a function based on your own nominal time, advancing it as appropriate. You can even set that function to real time, in which case you'll get completely unpredictable randomness, which may be appropriate in some circumstances. Whenever there is some notion of time that governs the patterns you want to see, setting ``time_dependent=True`` is a good idea, so that you have precise control over the randomness to ensure reproducible results.\n", + "\n", + "We used one operator above to make the cross image, but we can combine operators in any combination, here to build a cartoon face and add the result to a sweeping ``Line`` pattern masked with a ``Disk``, creating an animated GIF of the results with HoloViews:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%opts Image (cmap='gray')\n", + "import param\n", + "\n", + "param.Dynamic.time_fn.advance(1)\n", + "\n", + "print(\"The current nominal time value is %s\" % param.Dynamic.time_fn())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%output backend='matplotlib' holomap='gif'\n", + "lefteye = ig.Disk(aspect_ratio=0.7, x=0.04, y=0.10, size=0.08,smoothing=0.005)\n", + "leftpupil = ig.Disk(aspect_ratio=1.0, x=0.03, y=0.08, size=0.04,smoothing=0.005)\n", + "righteye = ig.Disk(aspect_ratio=0.7, x=0.04, y=-0.1, size=0.08,smoothing=0.005)\n", + "rightpupil = ig.Disk(aspect_ratio=1.0, x=0.03, y=-0.08,size=0.04,smoothing=0.005)\n", + "nose = ig.Gaussian(aspect_ratio=0.8, x=-0.1, y=0.00, size=0.04)\n", + "mouth = ig.Gaussian(aspect_ratio=0.8, x=-0.2, y=0.00, size=0.06)\n", + "head = ig.Disk( aspect_ratio=1.5, x=-0.02,y=0.00, size=0.40, scale=0.70,smoothing=0.005)\n", + "face=head + lefteye - 1.6*leftpupil + righteye - 1.6*rightpupil - 0.5*nose - 0.8*mouth\n", + "face.set_param(x=0.2, y=0.1, offset=0.5, size=0.75)\n", + "face.orientation=ng.ScaledTime()*np.pi/20\n", + "\n", + "line = ig.Line(y=0.6-ng.ScaledTime()*0.03)\n", + "disk = ig.Disk(smoothing=0.01, size=0.4, x=-0.2, y=-0.2)\n", + "\n", + "(face + line*disk).anim(39)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Image patterns\n", + "\n", + "ImaGen can load and manipulate photographic images just like other patterns, apart from them not being resolution independent. For full functionality this requires the optional PIL or Pillow library, but support for Numpy arrays as images is provided with no further dependencies. For instance, if you have a database of images (here consisting of only one image for simplicity), you can repeatedly select an image at random from the database using ``Selector``, rotate it randomly if desired, and select a random patch of the image at each time:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from imagen.image import FileImage\n", + "inputs=[FileImage(filename=f, size=6.0,\n", + " x=ng.UniformRandom(lbound=-2,ubound=2),\n", + " y=ng.UniformRandom(lbound=-2,ubound=2),\n", + " orientation=ng.NormalRandom(sigma=0.1*np.pi))\n", + " for f in [\"images/ellen_arthur.pgm\"]]\n", + "\n", + "random_selection=ig.Selector(generators=inputs)\n", + "NdLayout(random_selection.anim(5)).cols(6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Applying functions to generated patterns\n", + "\n", + "Once the pattern has been generated, but before it is returned, you can apply any function to the data that you like, via the ``output_fns`` parameter. A variety of useful ``TransferFn``s are supplied for use as ``output_fns``, such as thresholding functions, normalizing functions (L0, L1, L2, L-infinity, etc.), and convolutions. Any number of these or your own functions (anything that can operate on a 2D Numpy array) can be applied, in order:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import imagen.transferfn as tf\n", + "from imagen.transferfn.sheet_tf import Convolve\n", + "\n", + "(FileImage()[:] + \\\n", + "FileImage(output_fns=[tf.BinaryThreshold()])[:] + \\\n", + "FileImage(output_fns=[Convolve()])[:] + \\\n", + "FileImage(output_fns=[Convolve(),tf.BinaryThreshold(threshold=0.45)])[:] + \\\n", + "FileImage(output_fns=[Convolve(kernel_pattern=ig.DifferenceOfGaussians(size=0.12)),\n", + " tf.BinaryThreshold()])[:]).cols(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Multi-channel patterns\n", + "\n", + "The above examples all show \"single-channel\" ``PatternGenerator`` objects, which are very general and usable for a huge variety of applications, as they are simply Numpy arrays. \n", + "\n", + "``PatternGenerator`` objects can have any number of channels, with each channel generating a Numpy array of the same size. Multi-channel patterns are used less often, but are particularly useful for generating color images. Color images loaded by the ``FileImage`` pattern will have four channels, one for the monochrome image (as above), and the other three for the red, green, and blue channels (accessed using *object*``.channels()``). RGB images can also be constructed by colorizing a monochrome pattern, or out of combinations of any of the other patterns, using the ``ComposeChannels`` object:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from imagen.image import ScaleChannels\n", + "ig.ComposeChannels(generators=[ig.Spiral(smoothing=0.02),ig.Spiral(),ig.Spiral(scale=0)])[:] + \\\n", + "ig.ComposeChannels(generators=[ig.Line(orientation=np.pi/2),ig.Ring(),ig.SquareGrating()])[:]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Three- or four-channel patterns support ``.pil()``, generating RGB or RGBA color images." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ig.ComposeChannels(generators=[ig.Line(orientation=np.pi/2),ig.Ring(),ig.SquareGrating(),ig.Disk()]).pil()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pattern types provided\n", + "\n", + "\n", + "Below are shown examples of each of the pattern types currently provided, using their default parameter values. Very many different parameter values can be chosen, to produce a much wider range of patterns, and of course new patterns can be created as ``Composite`` patterns as shown above. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%opts Layout [sublabel_format=\"\" horizontal_spacing=.1 vertical_spacing=.1]\n", + "%opts Image (cmap='gray') [xaxis=None yaxis=None show_frame=True] {+axiswise}\n", + "\n", + "from imagen import *\n", + "from imagen.random import *\n", + "from imagen.image import *\n", + "\n", + "pattern_classes = [x for _, x in sorted(locals().items()) if isinstance(x,type)\n", + " and issubclass(x,PatternGenerator) and not x.abstract]\n", + "\n", + "all_patterns = [x()[:] for x in pattern_classes[10:]]\n", + "\n", + "hv.Layout(all_patterns).cols(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extending ImaGen\n", + "\n", + "New ``Composite`` patterns can be created easily without writing new classes, as shown above. If you want to create a new non-composite type, you can simply define a new class inheriting from ``PatternGenerator``, then override ``self.function()`` to draw the pattern, and declare any new parameter(s) used by ``self.function()``. The new pattern can then be rotated, scaled, translated, etc. automatically, with no further coding, it will support dynamic pattern streams automatically, and it can be combined with any existing or new pattern to make new ``Composite`` patterns. If you don't want the automatic scaling, rotating, etc. (e.g. for a whole-field pattern like a new type of random distribution), you can override ``self.__call__`` instead of ``self.function()``, which allows you to do anything that returns a Numpy array of the requested size. See the many classes in ``imagen/__init__.py`` and ``imagen/random.py`` for examples of each approach." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [default]", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.13" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/PixHtLab-Src/Docker/imagen/doc/index.rst b/PixHtLab-Src/Docker/imagen/doc/index.rst new file mode 100644 index 0000000000000000000000000000000000000000..a59e12cac7929d899b2641e64fd3c2e82e9345e0 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/doc/index.rst @@ -0,0 +1,68 @@ +****** +ImaGen +****** + +.. toctree:: + :maxdepth: 2 + +.. notebook:: imagen index.ipynb + +Installation +============ + +|Package|_ |License|_ |PyVersions|_ + +ImaGen requires `NumPy `_, +`Param `_, and +`HoloViews `_, none +of which have any required external dependencies. + +Official releases of ImaGen are available on +`PyPI `_ , and can be installed using ``pip``. +If you don't have ``pip`` already, we recommend installing a +scientific Python distribution like +`Anaconda `_ first. Then installation +of ImaGen and required dependencies is simply:: + + pip install imagen + +Once you've installed ImaGen, an easy way to get started is to launch +IPython Notebook:: + + ipython notebook + +Now you can download the `tutorial notebooks +`_, unzip them somewhere IPython +Notebook can find them, and then open the index.ipynb tutorial in the +Notebook. Then try out any of the patterns you like, using +``help(``*obj-or-class*``)`` to find out its parameters and their +options, or repeatedly press ```` in IPython after opening +an object constructor. Just add ``[:]`` after your pattern object to +plot it using matplotlib and HoloViews. Note that IPython Notebook and +matplotlib are not in any way required for ImaGen, but when used with +HoloViews they do provide a very handy way to visualize and explore +the patterns interactively even if you will eventually use them +separately from IPython and matplotlib. + + +Support +======= + +Questions and comments are welcome at https://github.com/ioam/imagen/issues. + +.. |Package| image:: https://pypip.in/version/imagen/badge.svg?style=flat +.. _Package: https://pypi.python.org/pypi/imagen + +.. |PyVersions| image:: https://pypip.in/py_versions/imagen/badge.svg?style=flat +.. _PyVersions: https://pypi.python.org/pypi/imagen + +.. |License| image:: https://pypip.in/license/imagen/badge.svg?style=flat +.. _License: https://github.com/ioam/imagen/blob/master/LICENSE.txt + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` + diff --git a/PixHtLab-Src/Docker/imagen/doc/notebook.json b/PixHtLab-Src/Docker/imagen/doc/notebook.json new file mode 100644 index 0000000000000000000000000000000000000000..ce5fc881d24f1ea3f8db353f66ba80f0f40d3720 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/doc/notebook.json @@ -0,0 +1 @@ +{"imagen": {"fast": ["doc/Tutorials/*.ipynb"]}, "links": {}} \ No newline at end of file diff --git a/PixHtLab-Src/Docker/imagen/doc/site_map.rst b/PixHtLab-Src/Docker/imagen/doc/site_map.rst new file mode 100644 index 0000000000000000000000000000000000000000..f34000e36480f49a6837cf42d9fafaa24932f730 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/doc/site_map.rst @@ -0,0 +1,8 @@ +***************************** +Map of the FeatureMapper Site +***************************** + +.. toctree:: + index + Tutorials/index + Reference_Manual/imagen-module diff --git a/PixHtLab-Src/Docker/imagen/imagen/__init__.py b/PixHtLab-Src/Docker/imagen/imagen/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5965ca118b1d5c2d9d1d7c8069ecef4bc005446e --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/imagen/__init__.py @@ -0,0 +1,1552 @@ +""" +Objects capable of generating a two-dimensional array of values. + +Such patterns can be used as input to machine learning, neural +network, or compuatational neuroscience algorithms, or for any other +purpose where a two-dimensional pattern may be needed. Any new +PatternGenerator classes can be derived from these, and can then be +combined with the existing classes easily. +""" + +import sys, os, copy + +# Add param submodule to sys.path +cwd = os.path.abspath(os.path.split(__file__)[0]) +sys.path.insert(0, os.path.join(cwd, '..', 'param')) +sys.path.insert(0, os.path.join(cwd, '..', 'holoviews')) + +import param +from param.version import Version + +__version__ = Version(release=(2,1,0), fpath=__file__, + commit="$Format:%h$", reponame='imagen') + + +import numpy as np +from numpy import pi + +from param.parameterized import ParamOverrides +from param import ClassSelector + +# Imported here so that all PatternGenerators will be in the same package +from .patterngenerator import PatternGenerator, CompositeBase, Composite +from .patterngenerator import Constant, ChannelTransform, ChannelGenerator # pyflakes:ignore (API import) +from .patterngenerator import CorrelateChannels, ComposeChannels # pyflakes:ignore (API import) + + +from holoviews.element import Image # pyflakes:ignore (API import) + +from holoviews.core import SheetCoordinateSystem # pyflakes:ignore (API import) +from holoviews.core import boundingregion, sheetcoords # pyflakes:ignore (API import) + +from .patternfn import gaussian,exponential,gabor,line,disk,ring,\ + sigmoid,arc_by_radian,arc_by_center,smooth_rectangle,float_error_ignore, \ + log_gaussian + +import numbergen +from imagen.transferfn import DivisiveNormalizeL1 + +# Could add a Gradient class, where the brightness varies as a +# function of an equation for a plane. This could be useful as a +# background, or to see how sharp a gradient is needed to get a +# response. + + +class HalfPlane(PatternGenerator): + """ + Constant pattern on in half of the plane, and off in the rest, + with optional Gaussian smoothing. + """ + + smoothing = param.Number(default=0.02,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off.") + + def function(self,p): + if p.smoothing==0.0: + falloff=self.pattern_y*0.0 + else: + with float_error_ignore(): + falloff=np.exp(np.divide(-self.pattern_y*self.pattern_y, + 2*p.smoothing*p.smoothing)) + + return np.where(self.pattern_y>0.0,1.0,falloff) + + +class Gaussian(PatternGenerator): + """ + 2D Gaussian pattern generator. + + The sigmas of the Gaussian are calculated from the size and + aspect_ratio parameters: + + ysigma=size/2 + xsigma=ysigma*aspect_ratio + + The Gaussian is then computed for the given (x,y) values as:: + + exp(-x^2/(2*xsigma^2) - y^2/(2*ysigma^2) + """ + + aspect_ratio = param.Number(default=1/0.31,bounds=(0.0,None),softbounds=(0.0,6.0), + precedence=0.31,doc=""" + Ratio of the width to the height. + Specifically, xsigma=ysigma*aspect_ratio (see size).""") + + size = param.Number(default=0.155,doc=""" + Overall size of the Gaussian, defined by: + exp(-x^2/(2*xsigma^2) - y^2/(2*ysigma^2) + where ysigma=size/2 and xsigma=size/2*aspect_ratio.""") + + def function(self,p): + ysigma = p.size/2.0 + xsigma = p.aspect_ratio*ysigma + + return gaussian(self.pattern_x,self.pattern_y,xsigma,ysigma) + + +class ExponentialDecay(PatternGenerator): + """ + 2D Exponential pattern generator. + + Exponential decay based on distance from a central peak, + i.e. exp(-d), where d is the distance from the center (assuming + size=1.0 and aspect_ratio==1.0). More generally, the size and + aspect ratio determine the scaling of x and y dimensions: + + yscale=size/2 + xscale=yscale*aspect_ratio + + The exponential is then computed for the given (x,y) values as:: + + exp(-sqrt((x/xscale)^2 - (y/yscale)^2)) + """ + + aspect_ratio = param.Number(default=1/0.31,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc="""Ratio of the width to the height.""") + + size = param.Number(default=0.155,doc=""" + Overall scaling of the x and y dimensions.""") + + def function(self,p): + yscale = p.size/2.0 + xscale = p.aspect_ratio*yscale + + return exponential(self.pattern_x,self.pattern_y,xscale,yscale) + + +class SineGrating(PatternGenerator): + """2D sine grating pattern generator.""" + + frequency = param.Number(default=2.4,bounds=(0.0,None),softbounds=(0.0,10.0), + precedence=0.50, doc="Frequency of the sine grating.") + + phase = param.Number(default=0.0,bounds=(0.0,None),softbounds=(0.0,2*pi), + precedence=0.51,doc="Phase of the sine grating.") + + def function(self,p): + """Return a sine grating pattern (two-dimensional sine wave).""" + return 0.5 + 0.5*np.sin(p.frequency*2*pi*self.pattern_y + p.phase) + + + +class Gabor(PatternGenerator): + """2D Gabor pattern generator.""" + + frequency = param.Number(default=2.4,bounds=(0.0,None),softbounds=(0.0,10.0), + precedence=0.50,doc="Frequency of the sine grating component.") + + phase = param.Number(default=0.0,bounds=(0.0,None),softbounds=(0.0,2*pi), + precedence=0.51,doc="Phase of the sine grating component.") + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc= + """ + Ratio of pattern width to height. + The width of the Gaussian component is size*aspect_ratio (see Gaussian). + """) + + size = param.Number(default=0.25,doc=""" + Determines the height of the Gaussian component (see Gaussian).""") + + def function(self,p): + height = p.size/2.0 + width = p.aspect_ratio*height + + return gabor(self.pattern_x,self.pattern_y,width,height, + p.frequency,p.phase) + + +class Line(PatternGenerator): + """2D line pattern generator.""" + + # Hide unused parameters + size = param.Number(precedence=-1.0) + + thickness = param.Number(default=0.006,bounds=(0.0,None),softbounds=(0.0,1.0), + precedence=0.60,doc=""" + Thickness (width) of the solid central part of the line.""") + + enforce_minimal_thickness = param.Boolean(default=False,precedence=0.60, doc=""" + If True, ensure that the line is at least one pixel in width even for + small thicknesses where the line could otherwise fall in between pixel + centers and thus disappear at some orientations.""") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61, doc=""" + Width of the Gaussian fall-off.""") + + + def _pixelsize(self, p): + """Calculate line width necessary to cover at least one pixel on all axes.""" + xpixelsize = 1./float(p.xdensity) + ypixelsize = 1./float(p.ydensity) + return max([xpixelsize,ypixelsize]) + + def _effective_thickness(self, p): + """Enforce minimum thickness based on the minimum pixel size.""" + return max([p.thickness,self._pixelsize(p)]) + + def _count_pixels_on_line(self, y, p): + """Count the number of pixels rendered on this line.""" + h = line(y, self._effective_thickness(p), 0.0) + return h.sum() + + def _minimal_y(self, p): + """ + For the specified y and one offset by half a pixel, return the + one that results in the fewest pixels turned on, so that when + the thickness has been enforced to be at least one pixel, no + extra pixels are needlessly included (which would cause + double-width lines). + """ + y0 = self.pattern_y + y1 = y0 + self._pixelsize(p)/2. + return y0 if self._count_pixels_on_line(y0, p) < self._count_pixels_on_line(y1, p) else y1 + + def function(self,p): + return line( + self.pattern_y if not p.enforce_minimal_thickness else self._minimal_y(p), + p.thickness if not p.enforce_minimal_thickness else self._effective_thickness(p), + p.smoothing) + + + +class Disk(PatternGenerator): + """ + 2D disk pattern generator. + + An elliptical disk can be obtained by adjusting the aspect_ratio + of a circular disk; this transforms a circle into an ellipse by + stretching the circle in the y (vertical) direction. + + The Gaussian fall-off at a point P is an approximation for + non-circular disks, since the point on the ellipse closest to P is + taken to be the same point as the point on the circle before + stretching that was closest to P. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc= + "Ratio of width to height; size*aspect_ratio gives the width of the disk.") + + size = param.Number(default=0.5,doc="Top to bottom height of the disk") + + smoothing = param.Number(default=0.1,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off") + + def function(self,p): + height = p.size + + if p.aspect_ratio==0.0: + return self.pattern_x*0.0 + + return disk(self.pattern_x/p.aspect_ratio,self.pattern_y,height, + p.smoothing) + + +class Ring(PatternGenerator): + """ + 2D ring pattern generator. + + See the Disk class for a note about the Gaussian fall-off. + """ + + thickness = param.Number(default=0.015,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness (line width) of the ring.") + + smoothing = param.Number(default=0.1,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off inside and outside the ring.") + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc= + "Ratio of width to height; size*aspect_ratio gives the overall width.") + + size = param.Number(default=0.5) + + def function(self,p): + height = p.size + if p.aspect_ratio==0.0: + return self.pattern_x*0.0 + + return ring(self.pattern_x/p.aspect_ratio,self.pattern_y,height, + p.thickness,p.smoothing) + + +class OrientationContrast(SineGrating): + """ + Circular pattern for testing responses to differences in contrast. + + The pattern contains a sine grating ring surrounding a sine + grating disk, each with parameters (orientation, size, scale and + offset) that can be changed independently. + """ + + orientationcenter = param.Number(default=0.0,bounds=(0.0,2*pi), doc="Orientation of the center grating.") + orientationsurround = param.Number(default=0.0,bounds=(-pi*2,pi*2), doc="Orientation of the surround grating, either absolute or relative to the central grating.") + surround_orientation_relative = param.Boolean(default=False, doc="Determines whether the surround grating is relative to the central grating.") + sizecenter = param.Number(default=0.5,bounds=(0.0,None),softbounds=(0.0,10.0), doc="Size of the center grating.") + sizesurround = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,10.0), doc="Size of the surround grating.") + scalecenter = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,10.0), doc="Scale of the center grating.") + scalesurround = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,10.0), doc="Scale of the surround grating.") + offsetcenter = param.Number(default=0.0,bounds=(0.0,None),softbounds=(0.0,10.0), doc="Offset of the center grating.") + offsetsurround = param.Number(default=0.0,bounds=(0.0,None),softbounds=(0.0,10.0), doc="Offset of the surround grating.") + smoothing = param.Number(default=0.0,bounds=(0.0,None),softbounds=(0.0,0.5), doc="Width of the Gaussian fall-off inside and outside the ring.") + thickness = param.Number(default=0.3,bounds=(0.0,None),softbounds=(0.0,0.5), doc="Thickness (line width) of the ring.") + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), doc="Ratio of width to height; size*aspect_ratio gives the overall width.") + size = param.Number(default=0.5) + + def __call__(self,**params_to_override): + p = ParamOverrides(self,params_to_override) + input_1=SineGrating(mask_shape=Disk(smoothing=0,size=1.0),phase=p.phase, frequency=p.frequency, + orientation=p.orientationcenter, + scale=p.scalecenter, offset=p.offsetcenter, + x=p.x, y=p.y,size=p.sizecenter) + if p.surround_orientation_relative: + surround_or = p.orientationcenter + p.orientationsurround + else: + surround_or = p.orientationsurround + input_2=SineGrating(mask_shape=Ring(thickness=p.thickness,smoothing=0,size=1.0),phase=p.phase, frequency=p.frequency, + orientation=surround_or, scale=p.scalesurround, offset=p.offsetsurround, + x=p.x, y=p.y, size=p.sizesurround) + + patterns = [input_1(xdensity=p.xdensity,ydensity=p.ydensity,bounds=p.bounds), + input_2(xdensity=p.xdensity,ydensity=p.ydensity,bounds=p.bounds)] + + image_array = np.add.reduce(patterns) + return image_array + + + +class RawRectangle(PatternGenerator): + """ + 2D rectangle pattern generator with no smoothing, for use when + drawing patterns pixel by pixel. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc= + "Ratio of width to height; size*aspect_ratio gives the width of the rectangle.") + + size = param.Number(default=0.5,doc="Height of the rectangle.") + + def function(self,p): + height = p.size + width = p.aspect_ratio*height + return np.bitwise_and(np.abs(self.pattern_x)<=width/2.0, + np.abs(self.pattern_y)<=height/2.0) + + + +class Rectangle(PatternGenerator): + """ + 2D rectangle pattern, with Gaussian smoothing around the + edges. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,6.0), + precedence=0.31,doc= + "Ratio of width to height; size*aspect_ratio gives the width of the rectangle.") + + size = param.Number(default=0.5,doc="Height of the rectangle.") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off outside the rectangle.") + + def function(self,p): + height=p.size + width=p.aspect_ratio*height + + return smooth_rectangle(self.pattern_x, self.pattern_y, + width, height, p.smoothing, p.smoothing) + + + +class Arc(PatternGenerator): + """ + 2D arc pattern generator. + + Draws an arc (partial ring) of the specified size (radius*2), + starting at radian 0.0 and ending at arc_length. The orientation + can be changed to choose other start locations. The pattern is + centered at the center of the ring. + + See the Disk class for a note about the Gaussian fall-off. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,6.0), + precedence=0.31,doc=""" + Ratio of width to height; size*aspect_ratio gives the overall width.""") + + thickness = param.Number(default=0.015,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness (line width) of the ring.") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off inside and outside the ring.") + + arc_length = param.Number(default=pi,bounds=(0.0,None),softbounds=(0.0,2.0*pi), + inclusive_bounds=(True,False),precedence=0.62, doc=""" + Length of the arc, in radians, starting from orientation 0.0.""") + + size = param.Number(default=0.5) + + def function(self,p): + if p.aspect_ratio==0.0: + return self.pattern_x*0.0 + + return arc_by_radian(self.pattern_x/p.aspect_ratio, self.pattern_y, p.size, + (2*pi-p.arc_length, 0.0), p.thickness, p.smoothing) + + +class Curve(Arc): + """ + 2D curve pattern generator. + + Based on Arc, but centered on a tangent point midway through the + arc, rather than at the center of a ring, and with curvature + controlled directly rather than through the overall size of the + pattern. + + Depending on the size_type, the size parameter can control either + the width of the pattern, keeping this constant regardless of + curvature, or the length of the curve, keeping that constant + instead (as for a long thin object being bent). + + Specifically, for size_type=='constant_length', the curvature + parameter determines the ratio of height to width of the arc, with + positive curvature for concave shape and negative for convex. The + size parameter determines the width of the curve. + + For size_type=='constant_width', the curvature parameter + determines the portion of curve radian to 2pi, and the curve + radius is changed accordingly following the formula:: + + size=2pi*radius*curvature + + Thus, the size parameter determines the total length of the + curve. Positive curvature stands for concave shape, and negative + for convex. + + See the Disk class for a note about the Gaussian fall-off. + """ + + # Hide unused parameters + arc_length = param.Number(precedence=-1.0) + aspect_ratio = param.Number(default=1.0, precedence=-1.0) + + size_type = param.ObjectSelector(default='constant_length', + objects=['constant_length','constant_width'],precedence=0.61,doc=""" + For a given size, whether to draw a curve with that total length, + or with that width, keeping it constant as curvature is varied.""") + + curvature = param.Number(default=0.5, bounds=(-0.5, 0.5), precedence=0.62, doc=""" + Ratio of height to width of the arc, with positive value giving + a concave shape and negative value giving convex.""") + + def function(self,p): + return arc_by_center(self.pattern_x/p.aspect_ratio,self.pattern_y, + (p.size,p.size*p.curvature), + (p.size_type=='constant_length'), + p.thickness, p.smoothing) + + + +class SquareGrating(PatternGenerator): + """2D squarewave (symmetric or asymmetric) grating pattern generator.""" + + frequency = param.Number(default=2.4,bounds=(0.0,None),softbounds=(0.0,10.0), + precedence=0.50,doc="Frequency of the square grating.") + + phase = param.Number(default=0.0,bounds=(0.0,None),softbounds=(0.0,2*pi), + precedence=0.51,doc="Phase of the square grating.") + + duty_cycle = param.Number(default=0.5,bounds=(0.0,1.0), + precedence=0.51,doc=""" + The duty cycle is the ratio between the pulse duration (width of the bright bar) + and the period (1/frequency). + The pulse is defined as the time during which the square wave signal is 1 (high).""") + + # We will probably want to add anti-aliasing to this, + # and there might be an easier way to do it than by + # cropping a sine grating. + + def function(self,p): + """ + Return a square-wave grating (alternating black and white bars). + """ + return np.around( + 0.5 + + 0.5*np.sin(pi*(p.duty_cycle-0.5)) + + 0.5*np.sin(p.frequency*2*pi*self.pattern_y + p.phase)) + + +#JABALERT: replace with x%1.0 below +def wrap(lower, upper, x): + """ + Circularly alias the numeric value x into the range [lower,upper). + + Valid for cyclic quantities like orientations or hues. + """ + #I have no idea how I came up with this algorithm; it should be simplified. + # + # Note that Python's % operator works on floats and arrays; + # usually one can simply use that instead. E.g. to wrap array or + # scalar x into 0,2*pi, just use "x % (2*pi)". + range_=upper-lower + return lower + np.fmod(x-lower + 2*range_*(1-np.floor(x/(2*range_))), range_) + + + +class Selector(CompositeBase): + """ + PatternGenerator that selects from a list of other PatternGenerators. + """ + + # CB: needs to have time_fn=None + index = param.Number(default=numbergen.UniformRandom(lbound=0,ubound=1.0,seed=76), + bounds=(-1.0,1.0),precedence=0.20,doc=""" + Index into the list of pattern generators, on a scale from 0 + (start of the list) to 1.0 (end of the list). Typically a + random value or other number generator, to allow a different item + to be selected each time.""") + + + def function(self,p): + """Selects and returns one of the patterns in the list.""" + int_index=int(len(p.generators)*wrap(0,1.0,p.index)) + pg=p.generators[int_index] + + image_array = pg(xdensity=p.xdensity,ydensity=p.ydensity,bounds=p.bounds, + x=p.x+p.size*(pg.x*np.cos(p.orientation)-pg.y*np.sin(p.orientation)), + y=p.y+p.size*(pg.x*np.sin(p.orientation)+pg.y*np.cos(p.orientation)), + orientation=pg.orientation+p.orientation,size=pg.size*p.size, + scale=pg.scale*p.scale,offset=pg.offset+p.offset) + + return image_array + + def get_current_generator(self): + """Return the current generator (as specified by self.index).""" + int_index=int(len(self.generators)*wrap(0,1.0,self.inspect_value('index'))) + return self.generators[int_index] + + def channels(self, use_cached=False, **params_to_override): + """ + Get channel data from the current generator. use_cached is + not supported at the moment, though it must be forced to be + True in the current_generator in order to avoid generating the + same data twice (the first time by self() and the second with + current_generator.channels() ). + """ + default = self(**params_to_override) + current_generator = self.get_current_generator() + + res = current_generator.channels(use_cached=True) + res['default'] = default + + return res + + def num_channels(self): + """ + Get the number of channels in the input generators. + """ + if(self.inspect_value('index') is None): + if(len(self.generators)>0): + return self.generators[0].num_channels() + return 0 + + return self.get_current_generator().num_channels() + + +class OffsetTimeFn(param.Parameterized): + """ + A picklable version of the global time function with a custom offset + and reset period. + """ + + offset = param.Number(default=0, doc=""" + The time offset from which frames are generated given the + supplied pattern.""") + + reset_period = param.Number(default=4,bounds=(0,None),doc=""" + Period between generating each new translation episode.""") + + time_fn = param.Callable(default=param.Dynamic.time_fn,doc=""" + Function to generate the time used as a base for translation.""") + + def __call__(self): + time = self.time_fn() + return self.time_fn.time_type((time // self.reset_period) + self.offset) + + + +class Sweeper(ChannelGenerator): + """ + PatternGenerator that sweeps a supplied PatternGenerator in a + direction perpendicular to its orientation. Each time step, the + supplied PatternGenerator is sweeped further at a fixed speed, and + after reset_period time steps a new pattern is drawn. + """ + generator = param.ClassSelector(PatternGenerator,default=Gaussian(),precedence=0.97, + doc="Pattern to sweep.") + + time_offset = param.Number(default=0, doc=""" + The time offset from which frames are generated given the + supplied pattern.""") + + step_offset = param.Number(default=0, doc=""" + The number of steps to offset the sweeper by.""") + + reset_period = param.Number(default=4,bounds=(0,None),doc=""" + Period between generating each new translation episode.""") + + speed = param.Number(default=2.0/24.0,bounds=(0.0,None),doc=""" + The speed with which the pattern should move, + in sheet coordinates per time_fn unit.""") + + relative_motion_orientation = param.Number(default=pi/2.0,bounds=(0,2*pi),doc=""" + The direction in which the pattern should be moved, relative + to the orientation of the supplied generator""") + + time_fn = param.Callable(default=param.Dynamic.time_fn,doc=""" + Function to generate the time used as a base for translation.""") + + + def num_channels(self): + return self.generator.num_channels() + + + def function(self, p): + motion_time_fn = OffsetTimeFn(offset=p.time_offset, + reset_period=p.reset_period, + time_fn=p.time_fn) + pg = p.generator + pg.set_dynamic_time_fn(motion_time_fn) + motion_orientation = pg.orientation + p.relative_motion_orientation + + step = int(p.time_fn() % p.reset_period) + p.step_offset + + new_x = p.x + p.size * pg.x + new_y = p.y + p.size * pg.y + + try: + #TFALERT: Not sure whether this is needed + if(len(self._channel_data)!=len(pg._channel_data)): + self._channel_data=copy.deepcopy(pg._channel_data) + + # For multichannel pattern generators + for i in range(len(pg._channel_data)): + self._channel_data[i] = pg.channels( + x=new_x + p.speed * step * np.cos(motion_orientation), + y=new_y + p.speed * step * np.sin(motion_orientation), + xdensity=p.xdensity, ydensity=p.ydensity, + bounds=p.bounds, + orientation=pg.orientation + p.orientation, + scale=pg.scale * p.scale, offset=pg.offset + p.offset)[i] + except AttributeError: + pass + + image_array = pg(xdensity=p.xdensity, ydensity=p.ydensity, + bounds=p.bounds, + x=new_x + p.speed * step * np.cos(motion_orientation), + y=new_y + p.speed * step * np.sin(motion_orientation), + orientation=pg.orientation + p.orientation, + scale=pg.scale * p.scale, offset=pg.offset + p.offset) + + return image_array + + + +class Spiral(PatternGenerator): + """ + Archimedean spiral. + Successive turnings of the spiral have a constant separation distance. + + Spiral is defined by polar equation r=size*angle plotted in Gaussian plane. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Ratio of width to height.") + + thickness = param.Number(default=0.02,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness (line width) of the spiral.") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off inside and outside the spiral.") + + turning = param.Number(default=0.05,bounds=(0.01,None),softbounds=(0.01,2.0), + precedence=0.62,doc="Density of turnings; turning*angle gives the actual radius.") + + def function(self,p): + aspect_ratio = p.aspect_ratio + x = self.pattern_x/aspect_ratio + y = self.pattern_y + thickness = p.thickness + gaussian_width = p.smoothing + turning = p.turning + + spacing = turning*2*pi + + distance_from_origin = np.sqrt(x**2+y**2) + distance_from_spiral_middle = np.fmod(spacing + distance_from_origin - turning*np.arctan2(y,x),spacing) + + distance_from_spiral_middle = np.minimum(distance_from_spiral_middle,spacing - distance_from_spiral_middle) + distance_from_spiral = distance_from_spiral_middle - thickness/2.0 + + spiral = 1.0 - np.greater_equal(distance_from_spiral,0.0) + + sigmasq = gaussian_width*gaussian_width + + with float_error_ignore(): + falloff = np.exp(np.divide(-distance_from_spiral*distance_from_spiral, 2.0*sigmasq)) + + return np.maximum(falloff, spiral) + + + +class SpiralGrating(Composite): + """ + Grating pattern made from overlaid spirals. + """ + + parts = param.Integer(default=2,bounds=(1,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Number of parts in the grating.") + + thickness = param.Number(default=0.00,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness (line width) of the spiral.") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off inside and outside the spiral.") + + turning = param.Number(default=0.05,bounds=(0.01,None),softbounds=(0.01,2.0), + precedence=0.62,doc="Density of turnings; turning*angle gives the actual radius.") + + + def function(self, p): + gens = [Spiral(turning=p.turning,smoothing=p.smoothing,thickness=p.thickness, + orientation=i*2*np.pi/p.parts) for i in range(p.parts)] + + return Composite(generators=gens, bounds=p.bounds, orientation=p.orientation, + xdensity=p.xdensity, ydensity=p.ydensity)() + + + +class HyperbolicGrating(PatternGenerator): + """ + Concentric rectangular hyperbolas with Gaussian fall-off which share the same asymptotes. + abs(x^2/a^2 - y^2/a^2) = 1, where a mod size = 0 + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Ratio of width to height.") + + thickness = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness of the hyperbolas.") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off inside and outside the hyperbolas.") + + size = param.Number(default=0.5,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.62,doc="Size as distance of inner hyperbola vertices from the centre.") + + def function(self,p): + aspect_ratio = p.aspect_ratio + x = self.pattern_x/aspect_ratio + y = self.pattern_y + thickness = p.thickness + gaussian_width = p.smoothing + size = p.size + + distance_from_vertex_middle = np.fmod(np.sqrt(np.absolute(x**2 - y**2)),size) + distance_from_vertex_middle = np.minimum(distance_from_vertex_middle,size - distance_from_vertex_middle) + + distance_from_vertex = distance_from_vertex_middle - thickness/2.0 + + hyperbola = 1.0 - np.greater_equal(distance_from_vertex,0.0) + + sigmasq = gaussian_width*gaussian_width + + with float_error_ignore(): + falloff = np.exp(np.divide(-distance_from_vertex*distance_from_vertex, 2.0*sigmasq)) + + return np.maximum(falloff, hyperbola) + + + +class Wedge(PatternGenerator): + """ + A sector of a circle with Gaussian fall-off, with size determining the arc length. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Ratio of width to height.") + + size = param.Number(default=pi/4,bounds=(0.0,None),softbounds=(0.0,2.0*pi), + precedence=0.60,doc="Angular length of the sector, in radians.") + + smoothing = param.Number(default=0.4,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off outside the sector.") + + def function(self,p): + aspect_ratio = p.aspect_ratio + x = self.pattern_x/aspect_ratio + y = self.pattern_y + gaussian_width = p.smoothing + + angle = np.absolute(np.arctan2(y,x)) + half_length = p.size/2 + + radius = 1.0 - np.greater_equal(angle,half_length) + distance = angle - half_length + + sigmasq = gaussian_width*gaussian_width + + with float_error_ignore(): + falloff = np.exp(np.divide(-distance*distance, 2.0*sigmasq)) + + return np.maximum(radius, falloff) + + + +class RadialGrating(Composite): + """ + Grating pattern made from alternating smooth circular segments (pie-shapes). + """ + + parts = param.Integer(default=4,bounds=(1,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Number of parts in the grating.") + + smoothing = param.Number(default=0.8,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc=""" + Width of the Gaussian fall-off outside the sector, scaled by parts.""") + + def function(self, p): + gens = [Wedge(size=1.0/p.parts,smoothing=p.smoothing/p.parts, + orientation=i*2*np.pi/p.parts) for i in range(p.parts)] + + return Composite(generators=gens, bounds=p.bounds, orientation=p.orientation, + xdensity=p.xdensity, ydensity=p.ydensity)() + + +class Asterisk(Composite): + """ + Asterisk-like object composed of radial rectangular lines. + Also makes crosses and tripods. + """ + + parts = param.Integer(default=3,bounds=(1,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Number of parts in the asterisk.") + + thickness = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness of the rectangle.") + + smoothing = param.Number(default=0.015,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off around the rectangles.") + + size = param.Number(default=0.5,bounds=(0.01,None),softbounds=(0.1,2.0), + precedence=0.62,doc="Overall diameter of the pattern.") + + def function(self, p): + o=2*np.pi/p.parts + gens = [Rectangle(orientation=i*o,smoothing=p.smoothing, + aspect_ratio=2*p.thickness/p.size, + size=p.size/2, + x=-p.size/4*np.sin(i*o), + y= p.size/4*np.cos(i*o)) + for i in range(p.parts)] + + return Composite(generators=gens, bounds=p.bounds, orientation=p.orientation, + xdensity=p.xdensity, ydensity=p.ydensity)() + + + +class Angle(Composite): + """ + Angle composed of two line segments. + """ + + thickness = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness of the rectangle.") + + smoothing = param.Number(default=0.015,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off around the rectangles.") + + size = param.Number(default=0.5,bounds=(0.01,None),softbounds=(0.1,2.0), + precedence=0.62,doc="Overall diameter of the pattern, if angle=pi.") + + angle = param.Number(default=pi/4,bounds=(0.0,None),softbounds=(0,pi), + precedence=0.63,doc="Angle between the two line segments.") + + def function(self, p): + gens=[Rectangle(orientation=i*p.angle,smoothing=p.smoothing, + aspect_ratio=p.thickness/p.size,size=p.size, + x=-p.size/2*np.sin(i*p.angle)) + for i in [-1,1]] + + return Composite(generators=gens, bounds=p.bounds, orientation=p.orientation, + xdensity=p.xdensity, ydensity=p.ydensity)() + + + +class ConcentricRings(PatternGenerator): + """ + Concentric rings with linearly increasing radius. + Gaussian fall-off at the edges. + """ + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc="Ratio of width to height.") + + thickness = param.Number(default=0.04,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.60,doc="Thickness (line width) of the ring.") + + smoothing = param.Number(default=0.05,bounds=(0.0,None),softbounds=(0.0,0.5), + precedence=0.61,doc="Width of the Gaussian fall-off inside and outside the rings.") + + size = param.Number(default=0.4,bounds=(0.01,None),softbounds=(0.1,2.0), + precedence=0.62,doc="Radius difference of neighbouring rings.") + + def function(self,p): + aspect_ratio = p.aspect_ratio + x = self.pattern_x/aspect_ratio + y = self.pattern_y + thickness = p.thickness + gaussian_width = p.smoothing + size = p.size + + distance_from_origin = np.sqrt(x**2+y**2) + + distance_from_ring_middle = np.fmod(distance_from_origin,size) + distance_from_ring_middle = np.minimum(distance_from_ring_middle,size - distance_from_ring_middle) + + distance_from_ring = distance_from_ring_middle - thickness/2.0 + + ring = 1.0 - np.greater_equal(distance_from_ring,0.0) + + sigmasq = gaussian_width*gaussian_width + + with float_error_ignore(): + falloff = np.exp(np.divide(-distance_from_ring*distance_from_ring, 2.0*sigmasq)) + + return np.maximum(falloff, ring) + + + +class ArcCentered(Arc): + """ + 2D arc pattern generator (centered at the middle of the arc). + + Draws an arc (partial ring) of the specified size (radius*2), + with middle at radian 0.0 and starting at arc_length/2 and ending + at -arc_length/2. The pattern is centered at the middle of the arc. + + See the Disk class for a note about the Gaussian fall-off. + """ + + def function(self,p): + if p.aspect_ratio==0.0: + return self.pattern_x*0.0 + self.pattern_x -= (1+np.cos(pi-p.arc_length/2))*p.size/4 + + return arc_by_radian((self.pattern_x+p.size/2)/p.aspect_ratio, self.pattern_y, p.size, + (2*pi-p.arc_length/2, p.arc_length/2), p.thickness, p.smoothing) + + +class DifferenceOfGaussians(PatternGenerator): + """ + Two-dimensional difference of Gaussians pattern. + """ + + positive_size = param.Number(default=0.1, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(1), + doc="""Size of the positive region of the pattern.""") + + positive_aspect_ratio = param.Number(default=1.5, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(2), + doc="""Ratio of width to height for the positive region of the pattern.""") + + positive_x = param.Number(default=0.0, bounds=(None,None), softbounds=(-2.0,2.0), precedence=(3), + doc="""X position for the central peak of the positive region.""") + + positive_y = param.Number(default=0.0, bounds=(None,None), softbounds=(-2.0,2.0), precedence=(4), + doc="""Y position for the central peak of the positive region.""") + + + negative_size = param.Number(default=0.3, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(5), + doc="""Size of the negative region of the pattern.""") + + negative_aspect_ratio = param.Number(default=1.5, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(6), + doc="""Ratio of width to height for the negative region of the pattern.""") + + negative_x = param.Number(default=0.0, bounds=(None,None), softbounds=(-2.0,2.0), precedence=(7), + doc="""X position for the central peak of the negative region.""") + + negative_y = param.Number(default=0.0, bounds=(None,None), softbounds=(-2.0,2.0), precedence=(8), + doc="""Y position for the central peak of the negative region.""") + + + def function(self, p): + positive = Gaussian(x=p.positive_x+p.x, y=p.positive_y+p.y, + size=p.positive_size*p.size, aspect_ratio=p.positive_aspect_ratio, + orientation=p.orientation, output_fns=[DivisiveNormalizeL1()]) + + negative = Gaussian(x=p.negative_x+p.x, y=p.negative_y+p.y, + size=p.negative_size*p.size, aspect_ratio=p.negative_aspect_ratio, + orientation=p.orientation, output_fns=[DivisiveNormalizeL1()]) + + return Composite(generators=[positive,negative], operator=np.subtract, + xdensity=p.xdensity, ydensity=p.ydensity, bounds=p.bounds)() + + + +class Sigmoid(PatternGenerator): + """ + Two-dimensional sigmoid pattern, dividing the plane into positive + and negative halves with a smoothly sloping transition between + them. + """ + + slope = param.Number(default=10.0, bounds=(None,None), softbounds=(-100.0,100.0), + doc="""Parameter controlling the smoothness of the transition + between the two regions; high values give a sharp transition.""") + + + def function(self, p): + return sigmoid(self.pattern_y, p.slope) + + + +class SigmoidedDoG(PatternGenerator): + """ + Sigmoid multiplicatively combined with a difference of Gaussians, + such that one part of the plane can be the mirror image of the other. + """ + + size = param.Number(default=0.5) + + positive_size = param.Number(default=0.15, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(1), + doc="""Size of the positive Gaussian pattern.""") + + positive_aspect_ratio = param.Number(default=2.0, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(2), + doc="""Ratio of width to height for the positive Gaussian pattern.""") + + negative_size = param.Number(default=0.25, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(3), + doc="""Size of the negative Gaussian pattern.""") + + negative_aspect_ratio = param.Number(default=1.0, bounds=(0.0,None), softbounds=(0.0,5.0), precedence=(4), + doc="""Ratio of width to height for the negative Gaussian pattern.""") + + sigmoid_slope = param.Number(default=10.0, bounds=(None,None), softbounds=(-100.0,100.0), precedence=(5), + doc="""Parameter controlling the smoothness of the transition between the two regions; + high values give a sharp transition.""") + + sigmoid_position = param.Number(default=0.0, bounds=(None,None), softbounds=(-1.0,1.0), precedence=(6), + doc="""X position of the transition between the two regions.""") + + + def function(self, p): + diff_of_gaussians = DifferenceOfGaussians(positive_x=p.x, positive_y=p.y, negative_x=p.x, negative_y=p.y, + positive_size=p.positive_size*p.size, positive_aspect_ratio=p.positive_aspect_ratio, + negative_size=p.negative_size*p.size, negative_aspect_ratio=p.negative_aspect_ratio) + + sigmoid = Sigmoid(slope=p.sigmoid_slope, orientation=p.orientation+pi/2, x=p.x+p.sigmoid_position) + + return Composite(generators=[diff_of_gaussians, sigmoid], bounds=p.bounds, + operator=np.multiply, xdensity=p.xdensity, ydensity=p.ydensity)() + + + +class LogGaussian(PatternGenerator): + """ + 2D Log Gaussian pattern generator allowing standard gaussian + patterns but with the added advantage of movable peaks. + + The spread governs decay rates from the peak of the Gaussian, + mathematically this is the sigma term. + + The center governs the peak position of the Gaussian, + mathematically this is the mean term. + """ + + aspect_ratio = param.Number(default=0.5, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,1.0), + doc="""Ratio of the pattern's width to height.""") + + x_shape = param.Number(default=0.8, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,5.0), + doc="""The length of the tail along the x axis.""") + + y_shape = param.Number(default=0.35, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,5.0), + doc="""The length of the tail along the y axis.""") + + + def __call__(self, **params_to_override): + """ + Call the subclass's 'function' method on a rotated and scaled + coordinate system. + + Creates and fills an array with the requested pattern. If + called without any params, uses the values for the Parameters + as currently set on the object. Otherwise, any params + specified override those currently set on the object. + """ + p = ParamOverrides(self, params_to_override) + + self._setup_xy(p) + fn_result = self.function(p) + self._apply_mask(p, fn_result) + + scale_factor = p.scale / np.max(fn_result) + result = scale_factor*fn_result + p.offset + + for of in p.output_fns: + of(result) + + return result + + + def _setup_xy(self, p): + """ + Produce pattern coordinate matrices from the bounds and + density (or rows and cols), and transforms them according to + x, y, and orientation. + """ + self.debug("bounds=%s, xdensity=%s, ydensity=%s, x=%s, y=%s, orientation=%s",p.bounds, p.xdensity, p.ydensity, p.x, p.y, p.orientation) + + x_points,y_points = SheetCoordinateSystem(p.bounds, p.xdensity, p.ydensity).sheetcoordinates_of_matrixidx() + + self.pattern_x, self.pattern_y = self._create_and_rotate_coordinate_arrays(x_points-p.x, y_points-p.y, p) + + + def _create_and_rotate_coordinate_arrays(self, x, y, p): + """ + Create pattern matrices from x and y vectors, and rotate + them to the specified orientation. + """ + + if p.aspect_ratio == 0 or p.size == 0: + x = x * 0.0 + y = y * 0.0 + else: + x = (x*10.0) / (p.size*p.aspect_ratio) + y = (y*10.0) / p.size + + offset = np.exp(p.size) + pattern_x = np.add.outer(np.sin(p.orientation)*y, np.cos(p.orientation)*x) + offset + pattern_y = np.subtract.outer(np.cos(p.orientation)*y, np.sin(p.orientation)*x) + offset + + np.clip(pattern_x, 0, np.Infinity, out=pattern_x) + np.clip(pattern_y, 0, np.Infinity, out=pattern_y) + + return pattern_x, pattern_y + + + def function(self, p): + return log_gaussian(self.pattern_x, self.pattern_y, p.x_shape, p.y_shape, p.size) + + + +class SigmoidedDoLG(PatternGenerator): + """ + Sigmoid multiplicatively combined with a difference of Log + Gaussians, such that one part of the plane can be the mirror image + of the other, and the peaks of the gaussians are movable. + """ + + size = param.Number(default=1.5) + + + positive_size = param.Number(default=0.5, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,10.0), + doc="""Size of the positive LogGaussian pattern.""") + + positive_aspect_ratio = param.Number(default=0.5, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,1.0), + doc="""Ratio of width to height for the positive LogGaussian pattern.""") + + positive_x_shape = param.Number(default=0.8, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,5.0), + doc="""The length of the tail along the x axis for the positive LogGaussian pattern.""") + + positive_y_shape = param.Number(default=0.35, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,5.0), + doc="""The length of the tail along the y axis for the positive LogGaussian pattern.""") + + positive_scale = param.Number(default=1.5, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,10.0), + doc="""Multiplicative scale for the positive LogGaussian pattern.""") + + + negative_size = param.Number(default=0.8, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,10.0), + doc="""Size of the negative LogGaussian pattern.""") + + negative_aspect_ratio = param.Number(default=0.3, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,1.0), + doc="""Ratio of width to height for the negative LogGaussian pattern.""") + + negative_x_shape = param.Number(default=0.8, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,5.0), + doc="""The length of the tail along the x axis for the negative LogGaussian pattern.""") + + negative_y_shape = param.Number(default=0.35, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,5.0), + doc="""The length of the tail along the y axis for the negative LogGaussian pattern.""") + + negative_scale = param.Number(default=1.0, bounds=(0.0,None), inclusive_bounds=(True,False), softbounds=(0.0,10.0), + doc="""Multiplicative scale for the negative LogGaussian pattern.""") + + + sigmoid_slope = param.Number(default=50.0, bounds=(None,None), softbounds=(-100.0,100.0), + doc="""Parameter controlling the smoothness of the transition between the two regions; + high values give a sharp transition.""") + + sigmoid_position = param.Number(default=0.05, bounds=(None,None), softbounds=(-1.0,1.0), + doc="""X position of the transition between the two regions.""") + + + def function(self, p): + positive = LogGaussian(size=p.positive_size*p.size, aspect_ratio=p.positive_aspect_ratio, x_shape=p.positive_x_shape, + y_shape=p.positive_y_shape, scale=p.positive_scale*p.scale, orientation=p.orientation, x=p.x, y=p.y, + output_fns=[]) + + negative = LogGaussian(size=p.negative_size*p.size, aspect_ratio=p.negative_aspect_ratio, x_shape=p.negative_x_shape, + y_shape=p.negative_y_shape, scale=p.negative_scale*p.scale, orientation=p.orientation, x=p.x, y=p.y, + output_fns=[]) + + diff_of_log_gaussians = Composite(generators=[positive, negative], operator=np.subtract, + xdensity=p.xdensity, ydensity=p.ydensity, bounds=p.bounds) + + sigmoid = Sigmoid(x=p.x+p.sigmoid_position, slope=p.sigmoid_slope, orientation=p.orientation+pi/2.0) + + return Composite(generators=[diff_of_log_gaussians, sigmoid], bounds=p.bounds, + operator=np.multiply, xdensity=p.xdensity, ydensity=p.ydensity, output_fns=[DivisiveNormalizeL1()])() + + + +class TimeSeries(param.Parameterized): + """ + Generic class to return intervals of a discretized time series. + """ + + time_series = param.Array(default=np.repeat(np.array([0,1]),50), + doc="""An array of numbers that form a series.""") + + sample_rate = param.Integer(default=50, allow_None=True, bounds=(0,None), inclusive_bounds=(False,False), softbounds=(0,44100), + doc="""The number of samples taken per second to form the series.""") + + seconds_per_iteration = param.Number(default=0.1, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,1.0), + doc="""Number of seconds advanced along the time series on each iteration.""") + + interval_length = param.Number(default=0.1, bounds=(0.0,None), inclusive_bounds=(False,False), softbounds=(0.0,1.0), + doc="""The length of time in seconds to be returned on each iteration.""") + + repeat = param.Boolean(default=True, + doc="""Whether the signal loops or terminates once it reaches its end.""") + + + def __init__(self, **params): + super(TimeSeries, self).__init__(**params) + self._next_interval_start = 0 + + if self.seconds_per_iteration > self.interval_length: + self.warning("Seconds per iteration > interval length, some signal will be skipped.") + + + def append_signal(self, new_signal): + self.time_series = np.hstack((self.time_series, new_signal)) + + + def extract_specific_interval(self, interval_start, interval_end): + """ + Overload if special behaviour is required when a series ends. + """ + + interval_start = int(interval_start) + interval_end = int(interval_end) + + if interval_start >= interval_end: + raise ValueError("Requested interval's start point is past the requested end point.") + + elif interval_start > self.time_series.size: + if self.repeat: + interval_end = interval_end - interval_start + interval_start = 0 + else: + raise ValueError("Requested interval's start point is past the end of the time series.") + + if interval_end < self.time_series.size: + interval = self.time_series[interval_start:interval_end] + + else: + requested_interval_size = interval_end - interval_start + remaining_signal = self.time_series[interval_start:self.time_series.size] + + if self.repeat: + if requested_interval_size < self.time_series.size: + self._next_interval_start = requested_interval_size-remaining_signal.size + interval = np.hstack((remaining_signal, self.time_series[0:self._next_interval_start])) + + else: + repeated_signal = np.repeat(self.time_series, np.floor(requested_interval_size/self.time_series.size)) + self._next_interval_start = requested_interval_size % self.time_series.size + + interval = (np.hstack((remaining_signal, repeated_signal)))[0:requested_interval_size] + + else: + self.warning("Returning last interval of the time series.") + self._next_interval_start = self.time_series.size + 1 + + samples_per_interval = self.interval_length*self.sample_rate + interval = np.hstack((remaining_signal, np.zeros(samples_per_interval-remaining_signal.size))) + + return interval + + + def __call__(self): + interval_start = self._next_interval_start + interval_end = int(np.floor(interval_start + self.interval_length*self.sample_rate)) + + self._next_interval_start += int(np.floor(self.seconds_per_iteration*self.sample_rate)) + return self.extract_specific_interval(interval_start, interval_end) + + + +def generate_sine_wave(duration, frequency, sample_rate): + time_axis = np.linspace(0.0, duration, int(duration*sample_rate)) + return np.sin(2.0*pi*frequency * time_axis) + + + +class TimeSeriesParam(ClassSelector): + """ + Parameter whose value is a TimeSeries object. + """ + + def __init__(self, **params): + super(TimeSeriesParam, self).__init__(TimeSeries, **params) + + + +class PowerSpectrum(PatternGenerator): + """ + Outputs the spectral density of a rolling interval of the input + signal each time it is called. Over time, the results could be + arranged into a spectrogram, e.g. for an audio signal. + """ + + x = param.Number(precedence=(-1)) + y = param.Number(precedence=(-1)) + size = param.Number(precedence=(-1)) + orientation = param.Number(precedence=(-1)) + + scale = param.Number(default=0.01, bounds=(0,None), inclusive_bounds=(False,False), softbounds=(0.001,1000), + doc="""The amount by which to scale amplitudes by. This is useful if we want to rescale to say a range [0:1]. + + Note: Constant scaling is preferable to dynamic scaling so as not to artificially ramp down loud sounds while ramping + up hiss and other background interference.""") + + signal = TimeSeriesParam(default=TimeSeries(time_series=generate_sine_wave(0.1,5000,20000), sample_rate=20000), + doc="""A TimeSeries object on which to perfom the Fourier Transform.""") + + min_frequency = param.Integer(default=0, bounds=(0,None), inclusive_bounds=(True,False), softbounds=(0,10000), + doc="""Smallest frequency for which to return an amplitude.""") + + max_frequency = param.Integer(default=9999, bounds=(0,None), inclusive_bounds=(False,False), softbounds=(0,10000), + doc="""Largest frequency for which to return an amplitude.""") + + windowing_function = param.Parameter(default=None, + doc="""This function is multiplied with the current interval, i.e. the most recent portion of the + waveform interval of a signal, before performing the Fourier transform. It thus shapes the interval, + which is otherwise always rectangular. + + The function chosen here dictates the tradeoff between resolving comparable signal strengths with similar + frequencies, and resolving disparate signal strengths with dissimilar frequencies. + + numpy provides a number of options, e.g. bartlett, blackman, hamming, hanning, kaiser; see + http://docs.scipy.org/doc/numpy/reference/routines.window.html + + You may also supply your own.""") + + + def __init__(self, **params): + super(PowerSpectrum, self).__init__(**params) + + self._previous_min_frequency = self.min_frequency + self._previous_max_frequency = self.max_frequency + + + def _create_frequency_indices(self): + if self.min_frequency >= self.max_frequency: + raise ValueError("PowerSpectrum: min frequency must be lower than max frequency.") + + # calculate the discrete frequencies possible for the given sample rate. + sample_rate = self.signal.sample_rate + available_frequency_range = np.fft.fftfreq(sample_rate, d=1.0/sample_rate)[0:sample_rate/2] + + if not available_frequency_range.min() <= self.min_frequency or not available_frequency_range.max() >= self.max_frequency: + raise ValueError("Specified frequency interval [%s:%s] is unavailable, available range is [%s:%s]. Adjust to these frequencies or modify the sample rate of the TimeSeries object." %(self.min_frequency, self.max_frequency, available_frequency_range.min(), available_frequency_range.max())) + + min_freq = np.nonzero(available_frequency_range >= self.min_frequency)[0][0] + max_freq = np.nonzero(available_frequency_range <= self.max_frequency)[0][-1] + + self._set_frequency_spacing(min_freq, max_freq) + + + def _set_frequency_spacing(self, min_freq, max_freq): + """ + Frequency spacing to use, i.e. how to map the available + frequency range to the discrete sheet rows. + + NOTE: We're calculating the spacing of a range between the + highest and lowest frequencies, the actual segmentation and + averaging of the frequencies to fit this spacing occurs in + _getAmplitudes(). + + This method is here solely to provide a minimal overload if + custom spacing is required. + """ + + self.frequency_spacing = np.linspace(min_freq, max_freq, num=self._sheet_dimensions[0]+1, endpoint=True) + + + def _get_row_amplitudes(self): + """ + Perform a real Discrete Fourier Transform (DFT; implemented + using a Fast Fourier Transform algorithm, FFT) of the current + sample from the signal multiplied by the smoothing window. + + See numpy.rfft for information about the Fourier transform. + """ + + signal_interval = self.signal() + sample_rate = self.signal.sample_rate + + # A signal window *must* span one sample rate + signal_window = np.tile(signal_interval, int(np.ceil(1.0/self.signal.interval_length))) + + if self.windowing_function: + smoothed_window = signal_window[0:sample_rate] * self.windowing_function(sample_rate) + else: + smoothed_window = signal_window[0:sample_rate] + + amplitudes = (np.abs(np.fft.rfft(smoothed_window))[0:sample_rate/2] + self.offset) * self.scale + + for index in range(0, self._sheet_dimensions[0]-2): + start_frequency = self.frequency_spacing[index] + end_frequency = self.frequency_spacing[index+1] + + normalisation_factor = end_frequency - start_frequency + if normalisation_factor == 0: + amplitudes[index] = amplitudes[start_frequency] + else: + amplitudes[index] = np.sum(amplitudes[int(start_frequency):int(end_frequency)]) / normalisation_factor + + return np.flipud(amplitudes[0:self._sheet_dimensions[0]].reshape(-1,1)) + + + def set_matrix_dimensions(self, bounds, xdensity, ydensity): + super(PowerSpectrum, self).set_matrix_dimensions(bounds, xdensity, ydensity) + + self._sheet_dimensions = SheetCoordinateSystem(bounds, xdensity, ydensity).shape + self._create_frequency_indices() + + + def _shape_response(self, row_amplitudes): + if self._sheet_dimensions[1] > 1: + row_amplitudes = np.repeat(row_amplitudes, self._sheet_dimensions[1], axis=1) + + return row_amplitudes + + + def __call__(self): + if self._previous_min_frequency != self.min_frequency or self._previous_max_frequency != self.max_frequency: + self._previous_min_frequency = self.min_frequency + self._previous_max_frequency = self.max_frequency + self._create_frequency_indices() + + return self._shape_response(self._get_row_amplitudes()) + + + +class Spectrogram(PowerSpectrum): + """ + Extends PowerSpectrum to provide a temporal buffer, yielding a 2D + representation of a fixed-width spectrogram. + """ + + min_latency = param.Integer(default=0, precedence=1, + bounds=(0,None), inclusive_bounds=(True,False), softbounds=(0,1000), + doc="""Smallest latency (in milliseconds) for which to return amplitudes.""") + + max_latency = param.Integer(default=500, precedence=2, + bounds=(0,None), inclusive_bounds=(False,False), softbounds=(0,1000), + doc="""Largest latency (in milliseconds) for which to return amplitudes.""") + + + def __init__(self, **params): + super(Spectrogram, self).__init__(**params) + + self._previous_min_latency = self.min_latency + self._previous_max_latency = self.max_latency + + + def _shape_response(self, new_column): + + millisecs_per_iteration = int(self.signal.seconds_per_iteration * 1000) + + if millisecs_per_iteration > self.max_latency: + self._spectrogram[0:,0:] = new_column + else: + # Slide old values along, add new data to left hand side. + self._spectrogram[0:, millisecs_per_iteration:] = self._spectrogram[0:, 0:self._spectrogram.shape[1]-millisecs_per_iteration] + self._spectrogram[0:, 0:millisecs_per_iteration] = new_column + + sheet_representation = np.zeros(self._sheet_dimensions) + + for column in range(0,self._sheet_dimensions[1]): + start_latency = int(self._latency_spacing[column]) + end_latency = int(self._latency_spacing[column+1]) + + normalisation_factor = end_latency - start_latency + if normalisation_factor > 1: + sheet_representation[0:, column] = np.sum(self._spectrogram[0:, start_latency:end_latency], axis=1) / normalisation_factor + else: + sheet_representation[0:, column] = self._spectrogram[0:, start_latency] + + return sheet_representation + + + def set_matrix_dimensions(self, bounds, xdensity, ydensity): + super(Spectrogram, self).set_matrix_dimensions(bounds, xdensity, ydensity) + self._create_latency_indices() + + + def _create_latency_indices(self): + if self.min_latency >= self.max_latency: + raise ValueError("Spectrogram: min latency must be lower than max latency.") + + self._latency_spacing = np.floor(np.linspace(self.min_latency, self.max_latency, num=self._sheet_dimensions[1]+1, endpoint=True)) + self._spectrogram = np.zeros([self._sheet_dimensions[0],self.max_latency]) + + + def __call__(self): + if self._previous_min_latency != self.min_latency or self._previous_max_latency != self.max_latency: + self._previous_min_latency = self.min_latency + self._previous_max_latency = self.max_latency + self._create_latency_indices() + + return super(Spectrogram, self).__call__() + + + + +_public = list(set([_k for _k,_v in locals().items() if isinstance(_v,type) and issubclass(_v,PatternGenerator)])) +__all__ = _public + ["image", "random", "patterncoordinator", "boundingregion", "sheetcoords"] +# Should avoid loading audio.py and other modules that rely on external +# libraries that might not be present on this system. diff --git a/PixHtLab-Src/Docker/imagen/imagen/audio.py b/PixHtLab-Src/Docker/imagen/imagen/audio.py new file mode 100644 index 0000000000000000000000000000000000000000..8031c97a36cccebb9e999be19da07c0935ea46e7 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/imagen/audio.py @@ -0,0 +1,524 @@ +""" +Pattern generators for audio signals. +""" + + +import param +import os + +from . import TimeSeries, Spectrogram, PowerSpectrum + +from numpy import arange, array, ceil, complex64, cos, exp, fft, flipud, \ + float64, floor, hanning, hstack, log, log10, logspace, multiply, \ + nonzero, ones, pi, reshape, shape, size, sqrt, sum, tile, zeros + +try: + import scikits.audiolab as audiolab + +except ImportError: + param.Parameterized().warning("audio.py classes will not be usable because scikits.audiolab is not available.") + + + +class AudioFile(TimeSeries): + """ + Requires an audio file in any format accepted by audiolab (wav, aiff, flac). + """ + + time_series = param.Array(precedence=(-1)) + sample_rate = param.Number(precedence=(-1)) + + filename = param.Filename(default='sounds/complex/daisy.wav', doc=""" + File path (can be relative to Param's base path) to an audio file. + The audio can be in any format accepted by audiolab, e.g. WAV, AIFF, or FLAC.""") + + precision = param.Parameter(default=float64, doc=""" + The float precision to use for loaded audio files.""") + + + def __init__(self, **params): + super(AudioFile, self).__init__(**params) + self._load_audio_file() + + + def _load_audio_file(self): + source = audiolab.Sndfile(self.filename, 'r') + + # audiolab scales the range by the bit depth automatically so the dynamic range is now [-1.0, 1.0] + # we rescale it to the range [0.0, 1.0] + self.time_series = (source.read_frames(source.nframes, dtype=self.precision) + 1) / 2 + self.sample_rate = source.samplerate + + + +class AudioFolder(AudioFile): + """ + Returns a rolling spectrogram, i.e. the spectral density over time + of a rolling window of the input audio signal, for all files in the + specified folder. + """ + + filename = param.Filename(precedence=(-1)) + + folderpath = param.Foldername(default='sounds/sine_waves/normalized', + doc="""Folder path (can be relative to Param's base path) to a + folder containing audio files. The audio can be in any format accepted + by audiolab, i.e. WAV, AIFF, or FLAC.""") + + gap_between_sounds = param.Number(default=0.0, bounds=(0.0,None), + doc="""The gap in seconds to insert between consecutive soundfiles.""") + + + def __init__(self, **params): + super(AudioFolder, self).__init__(**params) + self._load_audio_folder() + + + def _load_audio_folder(self): + folder_contents = os.listdir(self.folderpath) + self.sound_files = [] + + for file in folder_contents: + if file[-4:]==".wav" or file[-3:]==".wv" or file[-5:]==".aiff" or file[-4:]==".aif" or file[-5:]==".flac": + self.sound_files.append(self.folderpath + "/" + file) + + self.filename=self.sound_files[0] + self._load_audio_file() + self.next_file = 1 + + + def extract_specific_interval(self, interval_start, interval_end): + """ + Overload if special behaviour is required when a series ends. + """ + + interval_start = int(interval_start) + interval_end = int(interval_end) + + if interval_start >= interval_end: + raise ValueError("Requested interval's start point is past the requested end point.") + + elif interval_start > self.time_series.size: + if self.repeat: + interval_end = interval_end - interval_start + interval_start = 0 + else: + raise ValueError("Requested interval's start point is past the end of the time series.") + + if interval_end < self.time_series.size: + interval = self.time_series[interval_start:interval_end] + + else: + requested_interval_size = interval_end - interval_start + remaining_signal = self.time_series[interval_start:self.time_series.size] + + if self.next_file == len(self.sound_files) and self.repeat: + self.next_file = 0 + + if self.next_file < len(self.sound_files): + next_source = audiolab.Sndfile(self.sound_files[self.next_file], 'r') + self.next_file += 1 + + if next_source.samplerate != self.sample_rate: + raise ValueError("All sound files must be of the same sample rate") + + if self.gap_between_sounds > 0: + remaining_signal = hstack((remaining_signal, zeros(int(self.gap_between_sounds*self.sample_rate), dtype=self.precision))) + + self.time_series = hstack((remaining_signal, next_source.read_frames(next_source.nframes, dtype=self.precision))) + + interval = self.time_series[0:requested_interval_size] + self._next_interval_start = requested_interval_size + + else: + self.warning("Returning last interval of the time series.") + self._next_interval_start = self.time_series.size + 1 + + samples_per_interval = self.interval_length*self.sample_rate + interval = hstack((remaining_signal, zeros(samples_per_interval-remaining_signal.size))) + + return interval + + + +class LogSpectrogram(Spectrogram): + """ + Extends Spectrogram to provide a response over an octave scale. + """ + + log_base = param.Integer(default=2, bounds=(0.0,None), + doc="""The base of the logarithm used to generate logarithmic frequency spacing.""") + + + def _get_row_amplitudes(self): + signal_interval = self.signal() + sample_rate = self.signal.sample_rate + + # A signal window *must* span one sample rate + signal_window = tile(signal_interval, ceil(1.0/self.signal.interval_length)) + + if self.windowing_function: + smoothed_window = signal_window[0:sample_rate] * self.windowing_function(sample_rate) + else: + smoothed_window = signal_window[0:sample_rate] + + amplitudes = (abs(fft.rfft(smoothed_window))[0:sample_rate/2] + self.offset) * self.scale + + for index in range(0, self._sheet_dimensions[0]-2): + start_frequency = self.frequency_spacing[index] + end_frequency = self.frequency_spacing[index+1] + + normalisation_factor = nonzero(amplitudes[start_frequency:end_frequency])[0].size + if normalisation_factor == 0: + amplitudes[index] = 0 + else: + amplitudes[index] = sum(amplitudes[start_frequency:end_frequency]) / normalisation_factor + + return flipud(amplitudes[0:self._sheet_dimensions[0]].reshape(-1,1)) + + + def _set_frequency_spacing(self, min_freq, max_freq): + min_frequency = log10(min_freq+1) / log10(self.log_base) + max_frequency = log10(max_freq) / log10(self.log_base) + + self.frequency_spacing = logspace(min_frequency, max_frequency, + num=self._sheet_dimensions[0]+1, endpoint=True, base=self.log_base) + + + +class ModulatedLogSpectrogram(LogSpectrogram): + """ + Extends OctaveSpectrogram with a simple model of outer ear + amplification. One can set both the range to amplify and the + amount. + """ + + lower_freq_bound = param.Number(default=1000.0, bounds=(0.0,None), + doc="""The lower bound of the frequency range to be modulated.""") + + upper_freq_bound = param.Number(default=7000.0, bounds=(0.0,None), + doc="""The upper bound of the frequency range to be modulated.""") + + modulation_function = param.Parameter(default=hanning, + doc="""The function by which to modulate the signal between the + specified frequency range. + + The default (hanning) multiplies a section of the signal by a + hanning window.""") + + + def __init__(self, **params): + super(ModulatedLogSpectrogram, self).__init__(**params) + + if self.lower_freq_bound > self.upper_freq_bound: + raise ValueError("Modulation frequency lower bound must be less than the upper bound.") + + + def set_matrix_dimensions(self, bounds, xdensity, ydensity): + super(ModulatedLogSpectrogram, self).set_matrix_dimensions(bounds, xdensity, ydensity) + + self._modulation_start_index = nonzero(self.frequency_spacing >= self.lower_freq_bound)[0][0] + self._modulation_end_index = nonzero(self.frequency_spacing >= self.upper_freq_bound)[0][0] + + self._modulation = self.modulation_function(self._modulation_end_index-self._modulation_start_index) + self._modulation = reshape(self._modulation, [-1,1]) + + + def _shape_response(self, new_column): + if self.amplify_by_percentage > 0: + if (self.lower_freq_bound < self.min_frequency) or (self.lower_freq_bound > self.max_frequency): + raise ValueError("Lower bound of frequency to amplify is outside the global frequency range.") + + elif (self.upper_freq_bound < self.min_frequency) or (self.upper_freq_bound > self.max_frequency): + raise ValueError("Upper bound of frequency to amplify is outside the global frequency range.") + + else: + new_column[self._modulation_start_index:self._modulation_end_index] *= self._modulation + + return super(ModulatedLogSpectrogram, self)._shape_response(new_column) + + + +class LyonsCochlearModel(PowerSpectrum): + """ + Outputs a cochlear decomposition as a set of frequency responses of linear + band-pass filters. Employs Lyons Cochlear Model to do so. + + R. F. Lyon, "A computational model of filtering, detection and compression + in the cochlea." in Proc. of the IEEE Int. Conf. Acoust., Speech, Signal + Processing, Paris, France, May 1982. + + Specific implementation details can be found in: + + Malcolm Slaney, "Lyon's Cochlear Model, in Advanced Technology Group, + Apple Technical Report #13", 1988. + """ + + signal = param.Parameter(default=None, doc=""" + A TimeSeries object to be fed to the model. + + This can be any kind of signal, be it from audio files or live + from a mic, as long as the values conform to a TimeSeries. + """) + + quality_factor = param.Number(default=8.0, doc=""" + Quality factor controls the bandwidth of each cochlear filter. + + The bandwidth of each cochlear filter is a function of its + center frequency. At high frequencies the bandwidth is + approximately equal to the center frequency divided by a + quality constant (quality_factor). At lower frequncies the + bandwidth approaches a constant given by: 1000/quality_factor. + """) + + stage_overlap_factor = param.Number(default=4.0, doc=""" + The degree of overlap between filters. + + Successive filter stages are overlapped by a fraction of their + bandwidth. The number is arbitrary but smaller numbers lead to + more computations. We currently overlap 4 stages within the + bandpass region of any one filter. + """) + + precision = param.Parameter(default=float64, doc=""" + The float precision to use when calculating ear stage filters.""") + + + def __init__(self, **params): + super(LyonsCochlearModel, self).__init__(**params) + + # Hardwired Parameters specific to model, which is to say changing + # them without knowledge of the mathematics of the model is a bad idea. + self.sample_rate = self.signal.sample_rate + self.half_sample_rate = float(self.sample_rate/2.0) + self.quart_sample_rate = float(self.half_sample_rate/2.0) + + self.ear_q = float(self.quality_factor) + self.ear_step_factor = float(1.0/self.stage_overlap_factor) + + self.ear_break_f = float(1000.0) + self.ear_break_squared = self.ear_break_f*self.ear_break_f + + self.ear_preemph_corner_f = float(300.0) + self.ear_zero_offset = float(1.5) + self.ear_sharpness = float(5.0) + + self._num_of_channels = self._num_of_channels() + self._generateCochlearFilters() + + + def _ear_bandwidth(self, cf): + return sqrt(cf*cf + self.ear_break_squared) / self.ear_q + + + def _max_frequency(self): + bandwidth_step_max_f = self._ear_bandwidth(self.half_sample_rate) * self.ear_step_factor + return self.half_sample_rate + bandwidth_step_max_f - bandwidth_step_max_f*self.ear_zero_offset + + + def _num_of_channels(self): + min_f = self.ear_break_f / sqrt(4.0*self.ear_q*self.ear_q - 1.0) + channels = log(self.max_f_calc) - log(min_f + sqrt(min_f*min_f + self.ear_break_squared)) + + return int(floor(self.ear_q*channels/self.ear_step_factor)) + + + def _calc_centre_frequencies_till(self, channel_index): + if (self.centre_frequencies[channel_index] > 0): + return self.centre_frequencies[channel_index] + else: + step = self._calc_centre_frequencies_till(channel_index-1) + channel_cf = step - self.ear_step_factor*self._ear_bandwidth(step) + self.centre_frequencies[channel_index] = channel_cf + + return channel_cf + + + def _evaluate_filters_for_frequencies(self, filters, frequencies): + Zs = exp(2j*pi*frequencies/self.sample_rate) + Z_squareds = Zs * Zs + + zeros = ones((shape(frequencies)[0], shape(filters[0])[0], 3), dtype=complex64) + zeros[:,:,2] = filters[0][:,2] * Z_squareds + zeros[:,:,1] = filters[0][:,1] * Zs + zeros[:,:,0] = filters[0][:,0] + zeros = sum(zeros, axis=2) + + poles = ones((shape(frequencies)[0], shape(filters[1])[0], 3), dtype=complex64) + poles[:,:,2] = filters[1][:,2] * Z_squareds + poles[:,:,1] = filters[1][:,1] * Zs + poles[:,:,0] = filters[1][:,0] + poles = sum(poles, axis=2) + + return zeros / poles + + + # a frequency and gain are specified so that the resulting filter can + # be normalized to have any desired gain at a specified frequency. + def _make_filters(self, zeros, poles, f, desired_gains): + desired_gains = reshape(desired_gains,[size(desired_gains),1]) + + unit_gains = self._evaluate_filters_for_frequencies([zeros,poles], f) + unit_gains = reshape(unit_gains,[size(unit_gains),1]) + + return [zeros*desired_gains, poles*unit_gains] + + + def _frequency_responses(self, evaluated_filters): + evaluated_filters[evaluated_filters==0] = 1.0 + return 20.0 * log10(abs(evaluated_filters)) + + + def _specific_filter(self, x2_coefficient, x_coefficient, constant): + return array([[x2_coefficient,x_coefficient,constant], ], dtype=self.precision) + + + def _first_order_filter_from_corner(self, corner_f): + polynomial = zeros((1,3), dtype=self.precision) + polynomial[:,0] = -exp(-2.0*pi*corner_f/self.sample_rate) + polynomial[:,1] = 1.0 + + return polynomial + + + def _second_order_filter_from_center_q(self, cf, quality): + cf_as_ratio = cf/self.sample_rate + + rho = exp(-pi*cf_as_ratio/quality) + rho_squared = rho*rho + + theta = 2.0*pi*cf_as_ratio * sqrt(1.0-1.0/(4.0*quality*quality)) + theta_calc = -2.0*rho*cos(theta) + + polynomial = ones((size(cf),3), dtype=self.precision) + polynomial[:,1] = theta_calc + polynomial[:,2] = rho_squared + + return polynomial + + + def _ear_filter_gains(self): + return self.centre_frequencies[:-1] / self.centre_frequencies[1:] + + + def _ear_first_stage(self): + outer_middle_ear_filter = self._make_filters(self._first_order_filter_from_corner(self.ear_preemph_corner_f), + self._specific_filter(1.0,0.0,0.0), array([0.0]), 1.0) + + high_freq_compensator = self._make_filters(self._specific_filter(1.0,0.0,-1.0), self._specific_filter(0.0,0.0,1.0), + array([self.quart_sample_rate]), 1.0) + + pole_pair = self._make_filters(self._specific_filter(0.0,0.0,1.0), + self._second_order_filter_from_center_q(self.cascade_pole_cfs[0],self.cascade_pole_qs[0]), + array([self.quart_sample_rate]), 1.0) + + outer_middle_ear_evaluations = self._evaluate_filters_for_frequencies(outer_middle_ear_filter, self.frequencies) + high_freq_compensator_evaluations = self._evaluate_filters_for_frequencies(high_freq_compensator, self.frequencies) + pole_pair_evaluations = self._evaluate_filters_for_frequencies(pole_pair, self.frequencies) + + return outer_middle_ear_evaluations * high_freq_compensator_evaluations * pole_pair_evaluations + + + def _ear_all_other_stages(self): + zeros = self._second_order_filter_from_center_q(self.cascade_zero_cfs[1:], self.cascade_zero_qs[1:]) + poles = self._second_order_filter_from_center_q(self.cascade_pole_cfs[1:], self.cascade_pole_qs[1:]) + + stage_filters = self._make_filters(zeros, poles, array([0.0]), self.ear_filter_gains) + return self._evaluate_filters_for_frequencies(stage_filters, self.frequencies) + + + def _generate_cascade_filters(self): + cascade_filters = self.ear_stages + + for channel in range(1,self._num_of_channels): + cascade_filters[channel,:] = cascade_filters[channel,:] * cascade_filters[channel-1,:] + + return self._frequency_responses(cascade_filters) + + + def _generateCochlearFilters(self): + max_f = self._max_frequency() + self.max_f_calc = max_f + sqrt(max_f*max_f + self.ear_break_squared) + + self.centre_frequencies = zeros(self._num_of_channels, dtype=self.precision) + self.centre_frequencies[0] = max_f + self._calc_centre_frequencies_till(self._num_of_channels-1) + + bandwidths = self._ear_bandwidth(self.centre_frequencies) + + self.cascade_zero_cfs = self.centre_frequencies + bandwidths*self.ear_step_factor*self.ear_zero_offset + self.cascade_zero_qs = self.ear_sharpness * self.cascade_zero_cfs / bandwidths + self.cascade_pole_cfs = self.centre_frequencies + self.cascade_pole_qs = self.centre_frequencies / bandwidths + + self.ear_filter_gains = self._ear_filter_gains() + + self.frequencies = arange(self.half_sample_rate).reshape(self.half_sample_rate, 1) + + self.ear_stages = hstack((self._ear_first_stage(), self._ear_all_other_stages())).transpose() + + self.cochlear_channels = self._generate_cascade_filters() + + + def _get_row_amplitudes(self): + """ + Perform a real Discrete Fourier Transform (DFT; implemented + using a Fast Fourier Transform algorithm, FFT) of the current + sample from the signal multiplied by the smoothing window. + + See numpy.rfft for information about the Fourier transform. + """ + + sample_rate = self.signal.sample_rate + + # A signal window *must* span one sample rate, irrespective of interval length. + signal_window = tile(self.signal(), ceil(1.0/self.signal.interval_length)) + + if self.windowing_function == None: + smoothed_window = signal_window[0:sample_rate] + else: + smoothed_window = signal_window[0:sample_rate] * self.windowing_function(sample_rate) + + row_amplitudes = abs(fft.rfft(smoothed_window))[0:sample_rate/2] + row_amplitudes = row_amplitudes.reshape(1,sample_rate/2.0) + + filter_responses = multiply(self.cochlear_channels, row_amplitudes) + sheet_responses = zeros(self._num_of_channels) + + for channel in range(0,self._num_of_channels): + time_responses = abs(fft.ifft(filter_responses[channel])) + sheet_responses[channel] = sum(time_responses) / (sample_rate/2.0) + + return sheet_responses.reshape(self._num_of_channels, 1) + + + def set_matrix_dimensions(self, bounds, xdensity, ydensity): + super(LyonsCochlearModel, self).set_matrix_dimensions(bounds, xdensity, ydensity) + + self._num_of_channels = self._num_of_channels() + if self._sheet_dimensions[0] == self._num_of_channels: + self._generateCochlearFilters() + else: + raise ValueError("The number of Sheet Rows must correspond to the number of Lyons Filters. Adjust the number sheet rows from [%s] to [%s]." %(self._sheet_dimensions[0], self._num_of_channels)) + + + +class LyonsCochleogram(LyonsCochlearModel): + """ + Employs Lyons Cochlear Model to return a Cochleoogram, + i.e. the response over time along the cochlea. + """ + + def _update_cochleogram(self, new_column): + self._cochleogram = hstack((new_column, self._cochleogram)) + self._cochleogram = self._cochleogram[0:, 0:self._sheet_dimensions[1]] + + + def set_matrix_dimensions(self, bounds, xdensity, ydensity): + super(LyonsCochleogram, self).set_matrix_dimensions(bounds, xdensity, ydensity) + self._cochleogram = zeros(self._sheet_dimensions) + + + def __call__(self, **params_to_override): + self._update_cochleogram(self._get_row_amplitudes()) + return self._cochleogram diff --git a/PixHtLab-Src/Docker/imagen/imagen/colorspaces.py b/PixHtLab-Src/Docker/imagen/imagen/colorspaces.py new file mode 100644 index 0000000000000000000000000000000000000000..17168f8645778eb7b5d57bdcd5376c8dfd365835 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/imagen/colorspaces.py @@ -0,0 +1,517 @@ +""" +Utilities for converting images between various color spaces, such as: + + * RGB (for display on computer monitor red, green, and blue channels) + * HSV (allowing manipulation of the hue, saturation, and value), + * LMS (estimates of human long, medium, and short cone responses), + * LCH (CIE perceptually uniform luminance, chroma (saturation), and hue) + * LAB (CIE opponent black/white, red/green, blue/yellow axes) + * XYZ (CIE interchange format) + +See http://en.wikipedia.org/wiki/Color_space for more detailed descriptions. + +To use these utilities, users should instantiate one of these two classes: + +ColorSpace + Provides a convert(from, to, what) method to perform conversion + between colorspaces, e.g. ``convert("rgb", "hsv", X)``, where ``X`` + is assumed to be a numpy.dstack() object with three matching arrays. + +FeatureColorConverter + Declare a set of color spaces to allow external code to work the + same for any combination of color spaces. Specifically, declares: + + * image color space (the space in which a dataset of images has + been stored), + * working color space (to which the images will be converted), + e.g. to transform images to a different working dataset, and + * analysis color space (space in which analyses will be performed) + + These values can be set using:: + + color_conversion.image_space="XYZ" # e.g. RGB, XYZ, LMS + color_conversion.working_space="RGB" # e.g. RGB, LMS + color_conversion.analysis_space="HSV" # e.g. HSV, LCH + +The other code in this file is primarily implementation for these two +classes, and will rarely need to be used directly. + +""" + +from math import pi, fmod, floor + +import param +import copy +import colorsys +import numpy as np + + +def _threeDdot_simple(M,a): + "Return Ma, where M is a 3x3 transformation matrix, for each pixel" + + result = np.empty(a.shape,dtype=a.dtype) + + for i in range(a.shape[0]): + for j in range(a.shape[1]): + A = np.array([a[i,j,0],a[i,j,1],a[i,j,2]]).reshape((3,1)) + L = np.dot(M,A) + result[i,j,0] = L[0] + result[i,j,1] = L[1] + result[i,j,2] = L[2] + + return result + + +def _threeDdot_opt(M,a): + swapped = a.swapaxes(0,2) + shape = swapped.shape + result = np.dot(M,swapped.reshape((3,-1))) + result.shape = shape + b = result.swapaxes(2,0) + # need to do asarray to ensure dtype? + return np.asarray(b,dtype=a.dtype) + +# CB: probably could make a faster version if do aM instead, +# e.g. something like (untested): + +#def _threeDdot(M,a): +# shape = a.shape +# result = np.dot(a.reshape((-1,3)),M) +# result.shape = shape +# return result + +threeDdot = _threeDdot_opt + + +def _abc_to_def_array(ABC,fn): + shape = ABC[:,:,0].shape + dtype = ABC.dtype + + DEF = np.zeros(ABC.shape,dtype=dtype) + + for i in range(shape[0]): + for j in range(shape[1]): + DEF[i,j,0],DEF[i,j,1],DEF[i,j,2]=fn(ABC[i,j,0],ABC[i,j,1],ABC[i,j,2]) + + return DEF + + +def _rgb_to_hsv_array(RGB): + """Equivalent to colorsys.rgb_to_hsv, except expects array like :,:,3""" + return _abc_to_def_array(RGB,colorsys.rgb_to_hsv) + + +def _hsv_to_rgb_array(HSV): + """Equivalent to colorsys.hsv_to_rgb, except expects array like :,:,3""" + return _abc_to_def_array(HSV,colorsys.hsv_to_rgb) + + +# these aliases can be overriden after loading this file, if +# optimized versions are available +rgb_to_hsv = _rgb_to_hsv_array +hsv_to_rgb = _hsv_to_rgb_array + + +# Should document where these constants are from. +KAP = 24389/27.0 +EPS = 216/24389.0 + + +def xyz_to_lab(XYZ,wp): + + X,Y,Z = np.dsplit(XYZ,3) + xn,yn,zn = X/wp[0], Y/wp[1], Z/wp[2] + + def f(t): + t = t.copy() # probably unnecessary! + t_eps = t>EPS + t_not_eps = t<=EPS + t[t_eps] = np.power(t[t_eps], 1.0/3) + t[t_not_eps] = (KAP*t[t_not_eps]+16.0)/116. + return t + + fx,fy,fz = f(xn), f(yn), f(zn) + L = 116*fy - 16 + a = 500*(fx - fy) + b = 200*(fy - fz) + + return np.dstack((L,a,b)) + + +def lab_to_xyz(LAB,wp): + + L,a,b = np.dsplit(LAB,3) + fy = (L+16)/116.0 + fz = fy - b / 200.0 + fx = a/500.0 + fy + + def finv(y): + y =copy.copy(y) # CEBALERT: why copy? + eps3 = EPS**3 + return np.where(y > eps3, + np.power(y,3), + (116*y-16)/KAP) + + xr, yr, zr = finv(fx), finv(fy), finv(fz) + return np.dstack((xr*wp[0],yr*wp[1],zr*wp[2])) + + +def lch_to_lab(LCH): + L,C,H = np.dsplit(LCH,3) + return np.dstack( (L,C*np.cos(H),C*np.sin(H)) ) + + +def lab_to_lch(LAB): + L,A,B = np.dsplit(LAB,3) + range_ = 2*pi + x = np.arctan2(B,A) + return np.dstack( (L, np.hypot(A,B), fmod(x + 2*range_*(1-floor(x/(2*range_))), range_) ) ) + + +def xyz_to_lch(XYZ,whitepoint): + return lab_to_lch(xyz_to_lab(XYZ,whitepoint)) + + +def lch_to_xyz(LCH,whitepoint): + return lab_to_xyz(lch_to_lab(LCH),whitepoint) + + + + +# Preceding functions started from ceball's colorfns.py file +# the rest started from +# http://projects.scipy.org/scipy/browser/trunk/Lib/sandbox/image/color.py?rev=1698 + +whitepoints = {'CIE A': ['Normal incandescent', 0.4476, 0.4074], + 'CIE B': ['Direct sunlight', 0.3457, 0.3585], + 'CIE C': ['Average sunlight', 0.3101, 0.3162], + 'CIE E': ['Normalized reference', 1.0/3, 1.0/3], + 'D50': ['Bright tungsten', 0.3457, 0.3585], + 'D55': ['Cloudy daylight', 0.3324, 0.3474], + 'D65': ['Daylight', 0.312713, 0.329016], + 'D75': ['?', 0.299, 0.3149], + 'D93': ['low-quality old CRT', 0.2848, 0.2932] + } + + +def triwhite(chrwhite): + x,y = chrwhite + X = float(x) / y + Y = 1.0 + Z = (1-x-y)/y + return X,Y,Z + +for key in whitepoints.keys(): + whitepoints[key].append(triwhite(whitepoints[key][1:])) + + +transforms = {} + + +# CEBALERT: add reference. Inverse computed using scipy.linalg.inv. +transforms = {} +transforms['D65'] = sD65 = {} + +sD65['rgb_from_xyz'] = np.array([[3.2410,-1.5374,-0.4986], + [-0.9692,1.8760,0.0416], + [0.0556,-0.204,1.0570]]) + +sD65['xyz_from_rgb'] = np.array([[ 0.41238088, 0.35757284, 0.1804523 ], + [ 0.21261986, 0.71513879, 0.07214994], + [ 0.0193435 , 0.11921217, 0.95050657]]) + + +# Guth (1980) - SP; L, M, and S normalized to one) +sD65['lms_from_xyz'] = np.array([[0.2435, 0.8524, -0.0516], + [-0.3954, 1.1642, 0.0837], + [0, 0, 0.6225]]) + +sD65['xyz_from_lms'] = np.array([[1.87616336e+00, -1.37368291e+00, 3.40220544e-01], + [6.37205799e-01, 3.92411765e-01, 5.61517442e-05], + [0.00000000e+00, 0.00000000e+00, 1.60642570e+00]]) + + +### Make LCH like other spaces (0,1) + +Lmax = 100.0 +Cmax = 360.0 # ? CEBALERT: A,B typically -127 to 128 (wikipedia...), so 360 or so max for C? +Hmax = 2*pi + +def xyz_to_lch01(XYZ, whitepoint): + L,C,H = np.dsplit(xyz_to_lch(XYZ,whitepoint),3) + L/=Lmax + C/=Cmax + H/=Hmax + return np.dstack((L,C,H)) + +def lch01_to_xyz(LCH, whitepoint): + L,C,H = np.dsplit(LCH,3) + L*=Lmax + C*=Cmax + H*=Hmax + return lch_to_xyz(np.dstack((L,C,H)),whitepoint) + + + +class ColorSpace(param.Parameterized): + """ + Low-level color conversion. The 'convert' method handles color + conversion to and from (and through) XYZ, and supports RGB, LCH, + LMS and HSV. + """ + + whitepoint = param.String(default='D65', doc=""" + Name of whitepoint in lookup table.""") + + transforms = param.Dict(default=transforms,doc=""" + Structure containing the transformation matrices used by this + Class. See ``transforms`` in this file.""") + + input_limits = param.NumericTuple((0.0,1.0),doc=""" + Upper and lower bounds to verify on input values.""") + + output_limits = param.NumericTuple((0.0,1.0),doc=""" + Upper and lower bounds to enforce on output values.""") + + output_clip = param.ObjectSelector(default='silent', + objects=['silent','warn','error','none'],doc=""" + Action to take when the output value will be clipped.""") + + dtype = param.Parameter(default=np.float32, doc="Datatype to use for result.") + + + def convert(self, from_, to, what): + """ + Convert image or color "what" from "from_" colorpace to "to" + colorspace. E.g.: ``convert("rgb", "hsv", X)``, where X is a + numpy dstack or a color tuple. + """ + + if(from_.lower()==to.lower()): + return what + + # Check if there exist an optimized function that performs + # from_to_to conversion + direct_conversion = '%s_to_%s'%(from_.lower(),to.lower()) + if( hasattr(self, direct_conversion ) ): + fn = getattr(self, direct_conversion) + return fn(what) + + from_to_xyz = getattr(self, '%s_to_xyz'%(from_.lower()) ) + xyz_to_to = getattr(self, 'xyz_to_%s'%(to.lower()) ) + + return xyz_to_to( from_to_xyz(what) ) + + + def _triwp(self): + return whitepoints[self.whitepoint][3] + + + def _get_shape(self,a): + # The shape of the array if it isn't a scalar + if isinstance(a, np.ndarray) and a.ndim>0: + return a.shape + # Tuple support + try: + length = len(a) + return (length,) + except TypeError: + return None + + def _put_shape(self,a,shape): + if shape is None: + return self.dtype(a) + else: + a.shape = shape + return a + + def _prepare_input(self,a,min_,max_): + in_shape = self._get_shape(a) + a = np.array(a,copy=False,ndmin=3,dtype=self.dtype) + if a.min()max_: + raise ValueError('Input out of limits') + return a, in_shape + + def _clip(self,a,min_limit,max_limit,action='silent'): + if action=='none': + return + + if action=='error': + if a.min()max_limit: + raise ValueError('(%s,%s) outside limits (%s,%s)' + % (a.min(),a.max(),min_limit,max_limit)) + elif action=='warn': + if a.min()max_limit: + self.warning('(%s,%s) outside limits (%s,%s)' % + (a.min(),a.max(),min_limit,max_limit)) + a.clip(min_limit,max_limit,out=a) + + + def _threeDdot(self,M,a): + # b = Ma + a, in_shape = self._prepare_input(a,*self.input_limits) + b = threeDdot(M,a) + self._clip(b,*self.output_limits,action=self.output_clip) + self._put_shape(b,in_shape) + return b + + def _ABC_to_DEF_by_fn(self,ABC,fn,*fnargs): + ABC, in_shape = self._prepare_input(ABC,*self.input_limits) + DEF = fn(ABC,*fnargs) + self._clip(DEF,*self.output_limits,action=self.output_clip) + self._put_shape(DEF, in_shape) + return DEF + + ## TO XYZ: RGB, LCH, LMS, HSV(passing through RGB) + def rgb_to_xyz(self,RGB): + return self._threeDdot( + self.transforms[self.whitepoint]['xyz_from_rgb'], RGB) + + + def lch_to_xyz(self,LCH): + return self._ABC_to_DEF_by_fn(LCH,lch01_to_xyz,self._triwp()) + + + def lms_to_xyz(self,LMS): + return self._threeDdot( + self.transforms[self.whitepoint]['xyz_from_lms'], LMS) + + + def hsv_to_xyz(self,HSV): + return self.rgb_to_xyz(self.hsv_to_rgb(HSV)) + + ## XYZ TO:RGB, LCH, LMS, HSV(passing through RGB) + + def xyz_to_rgb(self,XYZ): + return self._threeDdot( + self.transforms[self.whitepoint]['rgb_from_xyz'], XYZ) + + + def xyz_to_lch(self, XYZ): + return self._ABC_to_DEF_by_fn(XYZ,xyz_to_lch01,self._triwp()) + + + def xyz_to_lms(self,XYZ): + return self._threeDdot( + self.transforms[self.whitepoint]['lms_from_xyz'], XYZ) + + + def xyz_to_hsv(self, XYZ): + return self.rgb_to_hsv( self.xyz_to_rgb(XYZ) ) + + # Optimized + @staticmethod + def _gamma_rgb(RGB): + return (12.92*RGB*(RGB<=0.0031308) + + ((1+0.055)*RGB**(1/2.4) - 0.055) * (RGB>0.0031308)) + + @staticmethod + def _ungamma_rgb(RGB): + return (RGB/12.92*(RGB<=0.04045) + + (((RGB+0.055)/1.055)**2.4) * (RGB>0.04045)) + + def rgb_to_hsv(self,RGB): + "linear rgb to hsv" + gammaRGB = self._gamma_rgb(RGB) + return self._ABC_to_DEF_by_fn(gammaRGB,rgb_to_hsv) + + def hsv_to_rgb(self,HSV): + "hsv to linear rgb" + gammaRGB = self._ABC_to_DEF_by_fn(HSV,hsv_to_rgb) + return self._ungamma_rgb(gammaRGB) + + def hsv_to_gammargb(self,HSV): + "hsv is already specifying gamma corrected rgb" + return self._ABC_to_DEF_by_fn(HSV,hsv_to_rgb) + + def lch_to_gammargb(self,LCH): + return self._gamma_rgb(self.lch_to_rgb(LCH)) + + def lms_to_lch(self,LCH): + lch_to_xyz + + + +def _swaplch(LCH): + "Reverse the order of an LCH numpy dstack or tuple for analysis." + try: # Numpy array + L,C,H = np.dsplit(LCH,3) + return np.dstack((H,C,L)) + except: # Tuple + L,C,H = LCH + return H,C,L + + + +class ColorConverter(param.Parameterized): + """ + High-level color conversion class designed to support color space + transformations along a pipeline common in color vision modelling: + image (dataset colorspace) -> working (working colorspace) -> + [higher stages] -> analysis + """ + + # CEBALERT: should be ClassSelector + + # SPG: it shouldn't be necessary to support selection of the + # ColorSpace, as the new object supports any color conversion. + colorspace = param.Parameter(default=ColorSpace(),doc=""" + Object to use for converting between color spaces.""") + + image_space = param.ObjectSelector(default='XYZ', objects=['XYZ', 'LMS', 'RGB'], doc=""" + Color space in which images are encoded.""") # CEBALERT: possibly add sRGB? + + working_space = param.ObjectSelector(default='RGB', objects=['RGB','LMS'], doc=""" + Color space to which images will be transformed to provide + working space to later stages of processing.""") + + analysis_space = param.ObjectSelector(default='HSV', + objects=['HSV','LCH'], doc=""" + Color space in which analysis is performed.""") + + swap_polar_HSVorder = { + 'HSV': lambda HSV: HSV, + 'LCH': _swaplch } + + + def image2working(self,i): + """Transform images i provided into the specified working + color space.""" + return self.colorspace.convert(self.image_space, + self.working_space, i) + + def working2analysis(self,r): + "Transform working space inputs to the analysis color space." + a = self.colorspace.convert(self.working_space, self.analysis_space, r) + return self.swap_polar_HSVorder[self.analysis_space](a) + + def analysis2working(self,a): + "Convert back from the analysis color space to the working space." + a = self.swap_polar_HSVorder[self.analysis_space](a) + return self.colorspace.convert(self.analysis_space, self.working_space, a) + + def analysis2display(self,a): + """ + Utility conversion function that transforms data from the + analysis color space to the display space (currently hard-set + to RGB) for visualization. + """ + a = self.swap_polar_HSVorder[self.analysis_space](a) + return self.colorspace.convert(self.analysis_space.lower(), 'gammargb', a) + + + def jitter_hue(self,a,amount): + "Rotate the hue component of a by the given amount." + a[:,:,0] += amount + a[:,:,0] %= 1.0 + + def multiply_sat(self,a,factor): + "Scale the saturation of a by the given amount." + a[:,:,1] *= factor + + +# Provide a shared color_conversion object +color_conversion = ColorConverter() + + +__all__ = ["ColorSpace","ColorConverter"] diff --git a/PixHtLab-Src/Docker/imagen/imagen/deprecated.py b/PixHtLab-Src/Docker/imagen/imagen/deprecated.py new file mode 100644 index 0000000000000000000000000000000000000000..b0e12b2845b78f11d6f549fe144b3b82633f4253 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/imagen/deprecated.py @@ -0,0 +1,360 @@ +""" +Old patterns not intended for new code. + +These patterns are expected to be deleted eventually. +""" + +import param +import numpy as np +from numpy import pi + +from param.parameterized import ParamOverrides + +from .patterngenerator import Constant, PatternGenerator, Composite +from . import Gaussian +from .image import FileImage, PatternSampler, ImageSampler, edge_average + +class SeparatedComposite(Composite): + """ + Generalized version of the Composite PatternGenerator that + enforces spacing constraints between pattern centers. + + Currently supports minimum spacing, but can be generalized to + support maximum spacing also (and both at once). + """ + + min_separation = param.Number(default=0.0, bounds = (0,None), + softbounds = (0.0,1.0), doc=""" + Minimum distance to enforce between all pairs of pattern centers. + + Useful for ensuring that multiple randomly generated patterns + do not overlap spatially. Note that as this this value is + increased relative to the area in which locations are chosen, + the likelihood of a pattern appearing near the center of the + area will decrease. As this value approaches the available + area, the corners become far more likely to be chosen, due to + the distances being greater along the diagonals. + """) + ### JABNOTE: Should provide a mechanism for collecting and + ### plotting the training pattern center distribution, so that + ### such issues can be checked. + + max_trials = param.Integer(default = 50, bounds = (0,None), + softbounds = (0,100), precedence=-1, doc=""" + Number of times to try for a new pattern location that meets + the criteria. + + This is an essentially arbitrary timeout value that helps + prevent an endless loop in case the requirements cannot be + met.""") + + + def __distance_valid(self, g0, g1, p): + """ + Returns true if the distance between the (x,y) locations of + two generators g0 and g1 is greater than a minimum separation. + + Can be extended easily to support other criteria. + """ + dist = np.sqrt((g1.x - g0.x) ** 2 + + (g1.y - g0.y) ** 2) + return dist >= p.min_separation + + + def _advance_pattern_generators(self,p): + """ + Advance the parameters for each generator for this + presentation. + + Picks a position for each generator that is accepted by + __distance_valid for all combinations. Returns a new list of + the generators, with some potentially omitted due to failure + to meet the constraints. + """ + + valid_generators = [] + for g in p.generators: + + for trial in range(self.max_trials): + # Generate a new position and add generator if it's ok + + if np.alltrue([self.__distance_valid(g,v,p) for v in valid_generators]): + valid_generators.append(g) + break + + g.force_new_dynamic_value('x') + g.force_new_dynamic_value('y') + + else: + self.warning("Unable to place pattern %s subject to given constraints" % + g.name) + + return valid_generators + + + +#JABALERT: Can't this be replaced with a Composite? +class TwoRectangles(PatternGenerator): + """Two 2D rectangle pattern generator.""" + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,6.0), + precedence=0.31,doc= + "Ratio of width to height; size*aspect_ratio gives the width of the rectangle.") + + x1 = param.Number(default=-0.15,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + doc="X center of rectangle 1.") + + y1 = param.Number(default=-0.15,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + doc="Y center of rectangle 1.") + + x2 = param.Number(default=0.15,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + doc="X center of rectangle 2.") + + y2 = param.Number(default=0.15,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + doc="Y center of rectangle 2.") + + size = param.Number(default=0.5) + + # YC: Maybe this can be implemented much more cleanly by calling + # the parent's function() twice, but it's hard to see how to + # set the (x,y) offset for the parent. + def function(self,p): + height = p.size + width = p.aspect_ratio*height + + return np.bitwise_or( + np.bitwise_and(np.bitwise_and( + (self.pattern_x-p.x1)<=p.x1+width/4.0, + (self.pattern_x-p.x1)>=p.x1-width/4.0), + np.bitwise_and( + (self.pattern_y-p.y1)<=p.y1+height/4.0, + (self.pattern_y-p.y1)>=p.y1-height/4.0)), + np.bitwise_and(np.bitwise_and( + (self.pattern_x-p.x2)<=p.x2+width/4.0, + (self.pattern_x-p.x2)>=p.x2-width/4.0), + np.bitwise_and( + (self.pattern_y-p.y2)<=p.y2+height/4.0, + (self.pattern_y-p.y2)>=p.y2-height/4.0))) + + +### JABALERT: This class should be eliminated if at all possible; it +### is just a specialized version of Composite, and should be +### implementable directly using what is already in Composite. +class GaussiansCorner(PatternGenerator): + """ + Two Gaussian pattern generators with a variable intersection point, + appearing as a corner or cross. + """ + + x = param.Number(default=-0.15,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + doc="X center of the corner") + + y = param.Number(default=-0.15,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + doc="Y center of the corner") + + size = param.Number(default=0.5,bounds=(0,None), softbounds=(0.1,1), + doc="The size of the corner") + + aspect_ratio = param.Number(default=1/0.31, bounds=(0,None), softbounds=(1,10), + doc="Ratio of the width to the height for both Gaussians") + + angle = param.Number(default=0.5*pi,bounds=(0,pi), softbounds=(0.01*pi,0.99*pi), + doc="The angle of the corner") + + cross = param.Number(default=0.4, bounds=(0,1), softbounds=(0,1), + doc="Where the two Gaussians cross, as a fraction of their half length") + + + def __call__(self,**params_to_override): + p = ParamOverrides(self,params_to_override) + + g_1 = Gaussian() + g_2 = Gaussian() + + x_1 = g_1(orientation = p.orientation, bounds = p.bounds, xdensity = p.xdensity, + ydensity = p.ydensity, offset = p.offset, size = p.size, + aspect_ratio = p.aspect_ratio, + x = p.x + 0.7 * np.cos(p.orientation) * p.cross * p.size * p.aspect_ratio, + y = p.y + 0.7 * np.sin(p.orientation) * p.cross * p.size * p.aspect_ratio) + x_2 = g_2(orientation = p.orientation+p.angle, bounds = p.bounds, xdensity = p.xdensity, + ydensity = p.ydensity, offset = p.offset, size = p.size, + aspect_ratio = p.aspect_ratio, + x = p.x + 0.7 * np.cos(p.orientation+p.angle) * p.cross * p.size * p.aspect_ratio, + y = p.y + 0.7 * np.sin(p.orientation+p.angle) * p.cross * p.size * p.aspect_ratio) + + return np.maximum( x_1, x_2 ) + + + +class Translator(PatternGenerator): + """ + PatternGenerator that translates another PatternGenerator over + time. + + This PatternGenerator will create a series of episodes, where in + each episode the underlying generator is moved in a fixed + direction at a fixed speed. To begin an episode, the Translator's + x, y, and direction are evaluated (e.g. from random + distributions), and the underlying generator is then drawn at + those values plus changes over time that are determined by the + speed. The orientation of the underlying generator should be set + to 0 to get motion perpendicular to the generator's orientation + (which is typical). + + Note that at present the parameter values for x, y, and direction + cannot be passed in when the instance is called; only the values + set on the instance are used. + """ + generator = param.ClassSelector(default=Gaussian(), + class_=PatternGenerator,doc="""Pattern to be translated.""") + + direction = param.Number(default=0.0,softbounds=(-pi,pi),doc=""" + The direction in which the pattern should move, in radians.""") + + speed = param.Number(default=0.01,bounds=(0.0,None),doc=""" + The speed with which the pattern should move, + in sheet coordinates per time_fn unit.""") + + reset_period = param.Number(default=1,bounds=(0.0,None),doc=""" + Period between generating each new translation episode.""") + + episode_interval = param.Number(default=0,doc=""" + Interval between successive translation episodes. + + If nonzero, the episode_separator pattern is presented for + this amount of time_fn time after each episode, e.g. to + allow processing of the previous episode to complete.""") + + episode_separator = param.ClassSelector(default=Constant(scale=0.0), + class_=PatternGenerator,doc=""" + Pattern to display during the episode_interval, if any. + The default is a blank pattern.""") + + time_fn = param.Callable(default=param.Dynamic.time_fn,doc=""" + Function to generate the time used as a base for translation.""") + + def _advance_params(self): + """ + Explicitly generate new values for these parameters only + when appropriate. + """ + for p in ['x','y','direction']: + self.force_new_dynamic_value(p) + self.last_time = self.time_fn() + + + def __init__(self,**params): + super(Translator,self).__init__(**params) + self._advance_params() + + + def __call__(self,**params_to_override): + p=ParamOverrides(self,params_to_override) + + if self.time_fn() >= self.last_time + p.reset_period: + ## Returns early if within episode interval + if self.time_fn()=left) & (xbottom) & (y<=top), + self.image[r,c], + self.background_value) + + + def __apply_size_normalization(self,x,y,sheet_xdensity,sheet_ydensity,size_normalization): + pattern_rows,pattern_cols = self.image.shape + + # Instead of an if-test, could have a class of this type of + # function (c.f. OutputFunctions, etc)... + if size_normalization=='original': + return + + elif size_normalization=='stretch_to_fit': + x_sf,y_sf = pattern_cols/sheet_xdensity, pattern_rows/sheet_ydensity + x*=x_sf; y*=y_sf + + elif size_normalization=='fit_shortest': + if pattern_rows1]=1.0 + + return channel_data diff --git a/PixHtLab-Src/Docker/imagen/imagen/patterncoordinator.py b/PixHtLab-Src/Docker/imagen/imagen/patterncoordinator.py new file mode 100644 index 0000000000000000000000000000000000000000..ee5ad3cadbd4e6437f2fe8e646fbfecd5ff9addb --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/imagen/patterncoordinator.py @@ -0,0 +1,423 @@ +""" +Provides the class PatternCoordinator and a family of +FeatureCoordinator classes. + +PatternCoordinator creates a set of pattern generators whose +parameters are related in some way, as controlled by a subclass of +FeatureCoordinator. +""" + +import os +import math +import json +import glob +import collections +import copy + +import param +from param.parameterized import ParamOverrides + +from imagen.patterngenerator import PatternGenerator +from imagen.image import FileImage +from imagen import Gaussian, Composite, Selector, CompositeBase + +import numbergen + + +class FeatureCoordinator(param.ParameterizedFunction): + """ + A FeatureCoordinator modifies a supplied PatternGenerator. + + The modification can depend on the string pattern_label and + pattern_number supplied, in order to coordinate a set of patterns + of the same type with systematic differences. + + FeatureCoordinators that introduce randomness should be seeded + with a value based on the supplied master_seed, so that an + entire set of patterns can be controlled with the one master_seed + value. + + Subclasses of this class can accept parameters provided in params. + + This superclass ensures a common interface across all + FeatureCoordinator subclasses, which is necessary because they are + usually stored in a list, with each item called the same way. + """ + + def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): + """ + 'pattern' is the PatternGenerator to be modified + 'pattern_label' is the name to be given to this + PatternGenerator, used to select different behaviors + 'pattern_number' is an integer value distinguishing between + multiple patterns with the same pattern_label + 'master_seed' is to be used for any random number generator + seeds used for this pattern + 'params' consists of optional keyword-value pairs to be + provided for subclasses' parameters + """ + raise NotImplementedError + + + +class XCoordinator(FeatureCoordinator): + """ + Chooses a random value for the x coordinate, subject to the + provided position_bound_x. + """ + + position_bound_x = param.Number(default=0.8,doc=""" + Left/rightmost position of the pattern center on the x axis.""") + + def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): + p = ParamOverrides(self,params,allow_extra_keywords=True) + new_pattern=copy.copy(pattern) + new_pattern.x = pattern.get_value_generator('x')+\ + numbergen.UniformRandom(lbound=-p.position_bound_x, + ubound=p.position_bound_x, + seed=master_seed+12+pattern_number, + name="XCoordinator"+str(pattern_number)) + return new_pattern + + + +class YCoordinator(FeatureCoordinator): + """ + Chooses a random value for the y coordinate, subject to the + provided position_bound_y. + """ + + position_bound_y = param.Number(default=0.8,doc=""" + Upper/lowermost position of the pattern center on the y axis.""") + + def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): + p = ParamOverrides(self,params,allow_extra_keywords=True) + new_pattern=copy.copy(pattern) + new_pattern.y = pattern.get_value_generator('y')+\ + numbergen.UniformRandom(lbound=-p.position_bound_y, + ubound=p.position_bound_y, + seed=master_seed+35+pattern_number, + name="YCoordinator"+str(pattern_number)) + return new_pattern + + + +class OrientationCoordinator(FeatureCoordinator): + """ + Chooses a random orientation within the specified + orientation_bound in each direction. + """ + + orientation_bound = param.Number(default=math.pi,doc=""" + Rotate pattern around the origin by at most orientation_bound + radians (in both directions).""") + + + align_orientations = param.Boolean(default=False, doc=""" + Whether or not to align pattern orientations when composing + multiple patterns together. + + Alignment may be useful to prevent crossing stimuli or may be + appropriate for moving patterns sweeped in a single direction + of motion. """) + + def __call__(self, pattern, pattern_label, pattern_number, master_seed, **params): + p = ParamOverrides(self,params,allow_extra_keywords=True) + new_pattern=copy.copy(pattern) + new_pattern.orientation = pattern.get_value_generator('orientation')+\ + numbergen.UniformRandom(lbound=-p.orientation_bound, + ubound=p.orientation_bound, + seed=master_seed+21+(0 if p.align_orientations else pattern_number), + name=("OrientationCoordinator" + + ('' if p.align_orientations else str(pattern_number))) + ) + return new_pattern + + +class PatternCoordinator(param.Parameterized): + """ + Returns a set of coordinated PatternGenerators, named according to + pattern_labels. + + The features to be modified are specified with the + features_to_vary parameter. A feature is something coordinated + between the PatternGenerators, either: + + a. one of the existing parameters of the PatternGenerators + (such as size), or + b. a variable from which values for one of the existing parameters + can be calculated (such as a position offset between two + PatternGenerators), or + c. a value inherent to a particular existing image dataset + (due to how the dataset was collected or generated). + + Each PatternGenerator is first instantiated with the supplied + pattern_parameters, and then subclasses of FeatureCoordinator are + applied sequentially to modify the specified or default parameter + values of each PatternGenerator. + """ + + pattern_type = param.ClassSelector(PatternGenerator,default=Gaussian,is_instance=False,doc=""" + PatternGenerator type to be used.""") + + pattern_parameters = param.Dict(default={'size': 0.088388, 'aspect_ratio': 4.66667},doc=""" + Parameter values to be passed to the PatternGenerator specified in pattern_type.""") + + patterns_per_label = param.Integer(default=2,doc=""" + Number of patterns to generate and combine for a given label.""") + + features_to_vary = param.List(default=['xy','or'],class_=str,doc=""" + Stimulus features that the caller wishes to be varied, such as: + :'xy': Position in x and y coordinates + :'or': Orientation + + Subclasses and callers may extend this list to include any + other features for which a coordinator has been defined in + feature_coordinators.""") + + pattern_labels = param.List(default=['Input'],class_=str,bounds=(1,None),doc=""" + For each string in this list, a PatternGenerator of the + requested pattern_type will be returned, with parameters whose + values may depend on the string label supplied. For instance, + if the list ["Pattern1","Pattern2"] is supplied, a metafeature + function might inspect those pattern_labels and set parameters + differently for Pattern1 and Pattern2, returning two different + PatternGenerators with those pattern_labels.""") + + master_seed = param.Integer(default=0,doc=""" + Base seed for all pattern parameter values. Each numbered + pattern on each of the various pattern_labels will normally + use a different random seed, but all of these seeds should + include this master_seed value, so that changing it will + change all of the random pattern parameter streams.""") + + composite_type = param.ClassSelector(CompositeBase,default=Composite, + is_instance=False,doc=""" + Class that combines the patterns_per_label individual patterns + and creates a single combined pattern that it returns for a + given label. For instance, imagen.Composite can merge the + individual patterns into a single pattern using a variety of + operators like add or maximum, while imagen.Selector can + choose one out of a given set of patterns.""") + + composite_parameters = param.Dict(default={},doc=""" + If present, these parameter values will be passed to the + composite specified in composite_type.""") + + feature_coordinators = param.Dict(default=collections.OrderedDict([ + ('xy', [XCoordinator,YCoordinator]), + ('or', OrientationCoordinator)]),doc=""" + Mapping from the feature name (key) to the method(s) to be + applied to the pattern generators. The value can either be a + single method or a list of methods.""") + + + def _create_patterns(self, properties=None): + """ + Return a list (of length patterns_per_label) of + PatternGenerator instances. Should use pattern_type and + pattern_parameters to create each pattern. + + properties is a dictionary, e.g. {'pattern_label': + pattern_label}, which can be used to create PatternGenerators + depending on the requested pattern_label + """ + return [self.pattern_type(**self.pattern_parameters) + for i in range(self.patterns_per_label)] + + + def __init__(self,inherent_features=[],**params): + + """ + If a dataset already and inherently includes certain features, + a list with the inherent feature names should be supplied. + + Any extra parameter values supplied here will be passed down + to the feature_coordinators requested in features_to_vary. + """ + p=ParamOverrides(self,params,allow_extra_keywords=True) + + super(PatternCoordinator, self).__init__(**p.param_keywords()) + + self._feature_params = p.extra_keywords() + + self._inherent_features = inherent_features + + # TFALERT: Once spatial frequency (sf) is added, this will + # cause warnings, because all image datasets will have a + # spatial frequency inherent feature, but mostly we just + # ignore that by having only a single size of DoG, which + # discards all but a narrow range of sf. So the dataset will + # have sf inherently, but that won't be an error or even + # worthy of a warning. + if(len(set(self._inherent_features) - set(self.features_to_vary))): + self.warning('Inherent feature present which is not requested in features') + + self._feature_coordinators_to_apply = [] + for feature, feature_coordinator in self.feature_coordinators.items(): + if feature in self.features_to_vary and feature not in self._inherent_features: + # if it is a list, append each list item individually + if isinstance(feature_coordinator,list): + for individual_feature_coordinator in feature_coordinator: + self._feature_coordinators_to_apply.append(individual_feature_coordinator) + else: + self._feature_coordinators_to_apply.append(feature_coordinator) + + def __call__(self): + coordinated_pattern_generators={} + for pattern_label in self.pattern_labels: + patterns=self._create_patterns({'pattern_label': pattern_label}) + + # Apply _feature_coordinators_to_apply + for i in range(len(patterns)): + for fn in self._feature_coordinators_to_apply: + patterns[i]=fn(patterns[i],pattern_label, i, + self.master_seed, **self._feature_params) + + combined_patterns=self.composite_type(generators=patterns, + **self.composite_parameters) + coordinated_pattern_generators.update({pattern_label:combined_patterns}) + return coordinated_pattern_generators + + + +class PatternCoordinatorImages(PatternCoordinator): + + pattern_type = param.ClassSelector(PatternGenerator, + default=FileImage,is_instance=False) + + pattern_parameters = param.Dict(default={'size': 10}) + + composite_type = param.ClassSelector(CompositeBase, + default=Selector,is_instance=False) + + def __init__(self,dataset_name,**params): + """ + dataset_name is the path to a folder containing a + MANIFEST_json (https://docs.python.org/2/library/json.html), + which contains a description for a dataset. If no + MANIFEST_json is present, all image files in the specified + folder are used. + + Any extra parameter values supplied here will be passed down + to the feature_coordinators requested in features_to_vary. + + The JSON file can contain any of the following entries, if an + entry is not present, the default is used: + + :'dataset_name': Name of the dataset (string, + default=filepath) + :'length': Number of images in the dataset (integer, + default=number of files in directory matching + filename_template) + :'description': Description of the dataset (string, + default="") + :'source': Citation of paper for which the dataset was + created (string, default=name) + :'filename_template': Path to the images with placeholders + ({placeholder_name}) for inherent features and the image + number, e.g. "filename_template": "images/image{i}.png". + The placeholders are replaced according to + placeholder_mapping. Alternatively, glob patterns such as + * or ? can be used, e.g. "filename_template": + "images/*.png" (default=path_to_dataset_name/*.*) + :'placeholder_mapping': Dictionary specifying the + replacement of placeholders in filename_template; value is + used in eval() (default={}). + :'inherent_features': Features for which the corresponding + feature_coordinators should not be applied + (default=['sf','or','cr']) + + Currently, the label of the pattern generator + ('pattern_label') as well as the image number + ('current_image') are given as parameters to each callable + supplied in placeholder_mapping, where current_image + varies from 0 to length-1 and pattern_label is one of the + items of pattern_labels. + (python code, default={'i': lambda params: '%02d' % + (params['current_image']+1)} + + Example 1: Imagine having images without any inherent + features named as follows: "images/image01.png", + "images/image02.png" and so on. Then, filename_template: + "images/image{i}.png" and "placeholder_mapping": + "{'i': lambda params: '%02d' % (params['current_image']+1)}" + This replaces {i} in the template with the current image + number + 1 + + Example 2: Imagine having image pairs from a stereo webcam + named as follows: "images/image01_left.png", + + "images/image01_right.png" and so on. If + pattern_labels=['Left','Right'], then filename_template: + "images/image{i}_{dy}" and "placeholder_mapping": + "{'i': lambda params: '%02d' % (params['current_image']+1), + 'dy':lambda params: 'left' if + params['pattern_label']=='Left' else 'right'}" + + Here, additionally {dy} gets replaced by either 'left' if + the pattern_label is 'Left' or 'right' otherwise + + If the directory does not contain a MANIFEST_json file, the + defaults are as follows: + :'filename_template': filepath/*.*, whereas filepath is + the path given in dataset_name + :'patterns_per_label': Number of image files in filepath, + whereas filepath is the path given in dataset_name + :'inherent_features': [] + :'placeholder_mapping': {} + """ + + filepath=param.resolve_path(dataset_name,path_to_file=False) + self.dataset_name=filepath + self.filename_template=filepath+"/*.*" + self.description="" + self.source=self.dataset_name + self.placeholder_mapping={} + patterns_per_label = len(glob.glob(self.filename_template)) + inherent_features=['sf','cr'] + try: + filename=param.resolve_path(dataset_name+'/MANIFEST_json') + filepath=os.path.dirname(filename) + dataset=json.loads(open(filename).read()) + + self.dataset_name=dataset.get('dataset_name', self.dataset_name) + self.description=dataset.get('description', self.description) + self.filename_template=dataset.get('filename_template', self.filename_template) + patterns_per_label=dataset.get('length', + len(glob.glob(self.filename_template))) + self.source=dataset.get('source', self.source) + self.placeholder_mapping=(eval(dataset['placeholder_mapping']) + if 'placeholder_mapping' in dataset + else self.placeholder_mapping) + inherent_features=dataset.get('inherent_features', inherent_features) + except IOError: + pass + + if 'patterns_per_label' not in params: + params['patterns_per_label'] = self.patterns_per_label + super(PatternCoordinatorImages, self).__init__(inherent_features,**params) + + + def _generate_filenames(self, params): + if(len(self.placeholder_mapping)>0): + filenames = [self.filename_template]*self.patterns_per_label + + for placeholder in self.placeholder_mapping: + filenames = [filename.replace('{'+placeholder+'}', + self.placeholder_mapping[placeholder](params)) + for filename,params['current_image'] in + zip(filenames,range(self.patterns_per_label))] + else: + filenames = sorted(glob.glob(self.filename_template)) + + return filenames + + + def _create_patterns(self, properties): + return [self.pattern_type( + filename=f, + cache_image=False, + **self.pattern_parameters) + for f,i in zip(self._generate_filenames(properties), + range(self.patterns_per_label))] diff --git a/PixHtLab-Src/Docker/imagen/imagen/patternfn.py b/PixHtLab-Src/Docker/imagen/imagen/patternfn.py new file mode 100644 index 0000000000000000000000000000000000000000..8274cd32a6df98b4464a399dd586b323550e463a --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/imagen/patternfn.py @@ -0,0 +1,294 @@ +""" +Family of two-dimensional functions indexed by x and y. + +All functions are written to be valid both for scalar x and y, and for +numpy arrays of x and y (in which case the result is also an array); +the functions therefore have the same mathematical behaviour as numpy. +""" + + +import numpy as np +from numpy import pi + +from contextlib import contextmanager + +# CEBALERT: abs() is used in various places in this file, but I don't +# see it on the list of numpy imports. I guess we're mistakenly not +# using numpy's abs... + +@contextmanager +def float_error_ignore(): + """ + Many of the functions in this module use Gaussian smoothing, which + is based on a calculation like exp(divide(x*x,sigma)). When sigma + is zero the value of this expression should be zero at all points + in the plane, because such a Gaussian is infinitely small. + Obtaining the correct answer using finite-precision floating-point + array computations requires allowing infinite values to be + returned from divide(), and allowing exp() to underflow silently + to zero when given an infinite value. In numpy this is achieved + by using its seterr() function to disable divide-by-zero and + underflow warnings temporarily while these values are being + computed. + """ + oldsettings=np.seterr(divide='ignore',under='ignore') + yield + np.seterr(**oldsettings) + + +def gaussian(x, y, xsigma, ysigma): + """ + Two-dimensional oriented Gaussian pattern (i.e., 2D version of a + bell curve, like a normal distribution but not necessarily summing + to 1.0). + """ + if xsigma==0.0 or ysigma==0.0: + return x*0.0 + + with float_error_ignore(): + x_w = np.divide(x,xsigma) + y_h = np.divide(y,ysigma) + return np.exp(-0.5*x_w*x_w + -0.5*y_h*y_h) + + +def log_gaussian(x, y, x_sigma, y_sigma, mu): + """ + Two-dimensional oriented Log Gaussian pattern (i.e., 2D version of a + bell curve with an independent, movable peak). Much like a normal + distribution, but not necessarily placing the peak above the center, + and not necessarily summing to 1.0). + """ + if x_sigma==0.0 or y_sigma==0.0: + return x * 0.0 + + with float_error_ignore(): + x_w = np.divide(np.log(x)-mu, x_sigma*x_sigma) + y_h = np.divide(np.log(y)-mu, y_sigma*y_sigma) + + return np.exp(-0.5*x_w*x_w + -0.5*y_h*y_h) + + +def sigmoid(axis, slope): + """ + Sigmoid dividing axis into a positive and negative half, + with a smoothly sloping transition between them (controlled by the slope). + + At default rotation, axis refers to the vertical (y) axis. + """ + with float_error_ignore(): + return (2.0 / (1.0 + np.exp(-2.0*slope*axis))) - 1.0 + + +def exponential(x, y, xscale, yscale): + """ + Two-dimensional oriented exponential decay pattern. + """ + if xscale==0.0 or yscale==0.0: + return x*0.0 + + with float_error_ignore(): + x_w = np.divide(x,xscale) + y_h = np.divide(y,yscale) + return np.exp(-np.sqrt(x_w*x_w+y_h*y_h)) + + +def gabor(x, y, xsigma, ysigma, frequency, phase): + """ + Gabor pattern (sine grating multiplied by a circular Gaussian). + """ + if xsigma==0.0 or ysigma==0.0: + return x*0.0 + + with float_error_ignore(): + x_w = np.divide(x,xsigma) + y_h = np.divide(y,ysigma) + p = np.exp(-0.5*x_w*x_w + -0.5*y_h*y_h) + return p * 0.5*np.cos(2*pi*frequency*y + phase) + + +# JABHACKALERT: Shouldn't this use 'size' instead of 'thickness', +# for consistency with the other patterns? Right now, it has a +# size parameter and ignores it, which is very confusing. I guess +# it's called thickness to match ring, but matching gaussian and disk +# is probably more important. +def line(y, thickness, gaussian_width): + """ + Infinite-length line with a solid central region, then Gaussian fall-off at the edges. + """ + distance_from_line = abs(y) + gaussian_y_coord = distance_from_line - thickness/2.0 + sigmasq = gaussian_width*gaussian_width + + if sigmasq==0.0: + falloff = y*0.0 + else: + with float_error_ignore(): + falloff = np.exp(np.divide(-gaussian_y_coord*gaussian_y_coord,2*sigmasq)) + + return np.where(gaussian_y_coord<=0, 1.0, falloff) + + +def disk(x, y, height, gaussian_width): + """ + Circular disk with Gaussian fall-off after the solid central region. + """ + disk_radius = height/2.0 + + distance_from_origin = np.sqrt(x**2+y**2) + distance_outside_disk = distance_from_origin - disk_radius + sigmasq = gaussian_width*gaussian_width + + if sigmasq==0.0: + falloff = x*0.0 + else: + with float_error_ignore(): + falloff = np.exp(np.divide(-distance_outside_disk*distance_outside_disk, + 2*sigmasq)) + + return np.where(distance_outside_disk<=0,1.0,falloff) + + +def ring(x, y, height, thickness, gaussian_width): + """ + Circular ring (annulus) with Gaussian fall-off after the solid ring-shaped region. + """ + radius = height/2.0 + half_thickness = thickness/2.0 + + distance_from_origin = np.sqrt(x**2+y**2) + distance_outside_outer_disk = distance_from_origin - radius - half_thickness + distance_inside_inner_disk = radius - half_thickness - distance_from_origin + + ring = 1.0-np.bitwise_xor(np.greater_equal(distance_inside_inner_disk,0.0), + np.greater_equal(distance_outside_outer_disk,0.0)) + + sigmasq = gaussian_width*gaussian_width + + if sigmasq==0.0: + inner_falloff = x*0.0 + outer_falloff = x*0.0 + else: + with float_error_ignore(): + inner_falloff = np.exp(np.divide(-distance_inside_inner_disk*distance_inside_inner_disk, 2.0*sigmasq)) + outer_falloff = np.exp(np.divide(-distance_outside_outer_disk*distance_outside_outer_disk, 2.0*sigmasq)) + + return np.maximum(inner_falloff,np.maximum(outer_falloff,ring)) + + +def smooth_rectangle(x, y, rec_w, rec_h, gaussian_width_x, gaussian_width_y): + """ + Rectangle with a solid central region, then Gaussian fall-off at the edges. + """ + + gaussian_x_coord = abs(x)-rec_w/2.0 + gaussian_y_coord = abs(y)-rec_h/2.0 + + box_x=np.less(gaussian_x_coord,0.0) + box_y=np.less(gaussian_y_coord,0.0) + sigmasq_x=gaussian_width_x*gaussian_width_x + sigmasq_y=gaussian_width_y*gaussian_width_y + + with float_error_ignore(): + falloff_x=x*0.0 if sigmasq_x==0.0 else \ + np.exp(np.divide(-gaussian_x_coord*gaussian_x_coord,2*sigmasq_x)) + falloff_y=y*0.0 if sigmasq_y==0.0 else \ + np.exp(np.divide(-gaussian_y_coord*gaussian_y_coord,2*sigmasq_y)) + + return np.minimum(np.maximum(box_x,falloff_x), np.maximum(box_y,falloff_y)) + + + +def arc_by_radian(x, y, height, radian_range, thickness, gaussian_width): + """ + Radial arc with Gaussian fall-off after the solid ring-shaped + region with the given thickness, with shape specified by the + (start,end) radian_range. + """ + + # Create a circular ring (copied from the ring function) + radius = height/2.0 + half_thickness = thickness/2.0 + + distance_from_origin = np.sqrt(x**2+y**2) + distance_outside_outer_disk = distance_from_origin - radius - half_thickness + distance_inside_inner_disk = radius - half_thickness - distance_from_origin + + ring = 1.0-np.bitwise_xor(np.greater_equal(distance_inside_inner_disk,0.0), + np.greater_equal(distance_outside_outer_disk,0.0)) + + sigmasq = gaussian_width*gaussian_width + + if sigmasq==0.0: + inner_falloff = x*0.0 + outer_falloff = x*0.0 + else: + with float_error_ignore(): + inner_falloff = np.exp(np.divide(-distance_inside_inner_disk*distance_inside_inner_disk, 2.0*sigmasq)) + outer_falloff = np.exp(np.divide(-distance_outside_outer_disk*distance_outside_outer_disk, 2.0*sigmasq)) + + output_ring = np.maximum(inner_falloff,np.maximum(outer_falloff,ring)) + + # Calculate radians (in 4 phases) and cut according to the set range) + + # RZHACKALERT: + # Function float_error_ignore() cannot catch the exception when + # both np.dividend and divisor are 0.0, and when only divisor is 0.0 + # it returns 'Inf' rather than 0.0. In x, y and + # distance_from_origin, only one point in distance_from_origin can + # be 0.0 (circle center) and in this point x and y must be 0.0 as + # well. So here is a hack to avoid the 'invalid value encountered + # in divide' error by turning 0.0 to 1e-5 in distance_from_origin. + distance_from_origin += np.where(distance_from_origin == 0.0, 1e-5, 0) + + with float_error_ignore(): + sines = np.divide(y, distance_from_origin) + cosines = np.divide(x, distance_from_origin) + arcsines = np.arcsin(sines) + + phase_1 = np.where(np.logical_and(sines >= 0, cosines >= 0), 2*pi-arcsines, 0) + phase_2 = np.where(np.logical_and(sines >= 0, cosines < 0), pi+arcsines, 0) + phase_3 = np.where(np.logical_and(sines < 0, cosines < 0), pi+arcsines, 0) + phase_4 = np.where(np.logical_and(sines < 0, cosines >= 0), -arcsines, 0) + arcsines = phase_1 + phase_2 + phase_3 + phase_4 + + if radian_range[0] <= radian_range[1]: + return np.where(np.logical_and(arcsines >= radian_range[0], arcsines <= radian_range[1]), + output_ring, 0.0) + else: + return np.where(np.logical_or(arcsines >= radian_range[0], arcsines <= radian_range[1]), + output_ring, 0.0) + + +def arc_by_center(x, y, arc_box, constant_length, thickness, gaussian_width): + """ + Arc with Gaussian fall-off after the solid ring-shaped region and specified + by point of tangency (x and y) and arc width and height. + + This function calculates the start and end radian from the given width and + height, and then calls arc_by_radian function to draw the curve. + """ + + arc_w=arc_box[0] + arc_h=abs(arc_box[1]) + + if arc_w==0.0: # arc_w=0, don't draw anything + radius=0.0 + angles=(0.0,0.0) + elif arc_h==0.0: # draw a horizontal line, width=arc_w + return smooth_rectangle(x, y, arc_w, thickness, 0.0, gaussian_width) + else: + if constant_length: + curvature=arc_h/arc_w + radius=arc_w/(2*pi*curvature) + angle=curvature*(2*pi)/2.0 + else: # constant width + radius=arc_h/2.0+arc_w**2.0/(8*arc_h) + angle=np.arcsin(arc_w/2.0/radius) + if arc_box[1]<0: # convex shape + y=y+radius + angles=(3.0/2.0*pi-angle, 3.0/2.0*pi+angle) + else: # concave shape + y=y-radius + angles=(pi/2.0-angle, pi/2.0+angle) + + return arc_by_radian(x, y, radius*2.0, angles, thickness, gaussian_width) diff --git a/PixHtLab-Src/Docker/imagen/imagen/patterngenerator.py b/PixHtLab-Src/Docker/imagen/imagen/patterngenerator.py new file mode 100644 index 0000000000000000000000000000000000000000..3e7b550b07259e6229221c3d2d8a52c3a7a748f6 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/imagen/patterngenerator.py @@ -0,0 +1,666 @@ +""" +PatternGenerator abstract class, basic example concrete class, and +multichannel support. + +PatternGenerators support both single-channel patterns, i.e. bare +arrays, and multiple channels, such as for color images. See +``PatternGenerator.__call__`` and ``PatternGenerator.channels`` for +more information. +""" + +import numpy as np +from numpy import pi +import collections + +import param +from param.parameterized import ParamOverrides + +from holoviews import HoloMap, Image, RGB, Dimension +from holoviews.core import BoundingBox, BoundingRegionParameter, SheetCoordinateSystem + +from .transferfn import TransferFn + + +# CEBALERT: PatternGenerator has become a bit of a monster abstract +# class. Can it be split into the minimum required to specify the +# interface, with a subclass implementing the rest (this subclass +# still being above the rest of the PatternGenerators)? We want to +# make it easy to add new types of PatternGenerator that don't match +# the assumptions of the current ones (OneDPowerSpectrum is an example +# of a PG that doesn't match the current assumptions), but still lets +# them be used like the current ones. +# (PatternGenerator-->TwoDPatternGenerator?) + +# JLALERT: PatternGenerator should have +# override_plasticity_state/restore_plasticity_state functions which +# can override the plasticity of any output_fn that has state, in case +# anyone ever uses such an object in a PatternGenerator. Will also +# need to support Composite patterns. + + +class PatternGenerator(param.Parameterized): + """ + A class hierarchy for callable objects that can generate 2D patterns. + + Once initialized, PatternGenerators can be called to generate a + value or a matrix of values from a 2D function, typically + accepting at least x and y. + + A PatternGenerator's Parameters can make use of Parameter's + precedence attribute to specify the order in which they should + appear, e.g. in a GUI. The precedence attribute has a nominal + range of 0.0 to 1.0, with ordering going from 0.0 (first) to 1.0 + (last), but any value is allowed. + + The orientation and layout of the pattern matrices is defined by + the SheetCoordinateSystem class, which see. + + Note that not every parameter defined for a PatternGenerator will + be used by every subclass. For instance, a Constant pattern will + ignore the x, y, orientation, and size parameters, because the + pattern does not vary with any of those parameters. However, + those parameters are still defined for all PatternGenerators, even + Constant patterns, to allow PatternGenerators to be scaled, rotated, + translated, etc. uniformly. + """ + __abstract = True + + bounds = BoundingRegionParameter( + default=BoundingBox(points=((-0.5,-0.5), (0.5,0.5))),precedence=-1, + doc="BoundingBox of the area in which the pattern is generated.") + + xdensity = param.Number(default=256,bounds=(0,None),precedence=-1,doc=""" + Density (number of samples per 1.0 length) in the x direction.""") + + ydensity = param.Number(default=256,bounds=(0,None),precedence=-1,doc=""" + Density (number of samples per 1.0 length) in the y direction. + Typically the same as the xdensity.""") + + x = param.Number(default=0.0,softbounds=(-1.0,1.0),precedence=0.20,doc=""" + X-coordinate location of pattern center.""") + + y = param.Number(default=0.0,softbounds=(-1.0,1.0),precedence=0.21,doc=""" + Y-coordinate location of pattern center.""") + + z = param.ClassSelector(default=None, precedence=-1, class_=Dimension, doc=""" + The Dimension object associated with the z-values generated by + the PatternGenerator . If None, uses the default set by + HoloViews.Image.""") + + group = param.String(default='Pattern', precedence=-1, doc=""" + The group name assigned to the returned HoloViews object.""") + + position = param.Composite(attribs=['x','y'],precedence=-1,doc=""" + Coordinates of location of pattern center. + Provides a convenient way to set the x and y parameters together + as a tuple (x,y), but shares the same actual storage as x and y + (and thus only position OR x and y need to be specified).""") + + orientation = param.Number(default=0.0,softbounds=(0.0,2*pi),precedence=0.40,doc=""" + Polar angle of pattern, i.e., the orientation in the Cartesian coordinate + system, with zero at 3 o'clock and increasing counterclockwise.""") + + size = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,6.0), + precedence=0.30,doc="""Determines the overall size of the pattern.""") + + scale = param.Number(default=1.0,softbounds=(0.0,2.0),precedence=0.10,doc=""" + Multiplicative strength of input pattern, defaulting to 1.0""") + + offset = param.Number(default=0.0,softbounds=(-1.0,1.0),precedence=0.11,doc=""" + Additive offset to input pattern, defaulting to 0.0""") + + mask = param.Parameter(default=None,precedence=-1,doc=""" + Optional object (expected to be an array) with which to multiply the + pattern array after it has been created, before any output_fns are + applied. This can be used to shape the pattern.""") + + # Note that the class type is overridden to PatternGenerator below + mask_shape = param.ClassSelector(param.Parameterized,default=None,precedence=0.06,doc=""" + Optional PatternGenerator used to construct a mask to be applied to + the pattern.""") + + output_fns = param.HookList(default=[], precedence=0.08,doc=""" + Optional function(s) to apply to the pattern array after it has been created. + Can be used for normalization, thresholding, etc.""") + + + def __init__(self,**params): + super(PatternGenerator, self).__init__(**params) + self.set_matrix_dimensions(self.bounds, self.xdensity, self.ydensity) + + + def __call__(self,**params_to_override): + """ + Call the subclass's 'function' method on a rotated and scaled + coordinate system. + + Creates and fills an array with the requested pattern. If + called without any params, uses the values for the Parameters + as currently set on the object. Otherwise, any params + specified override those currently set on the object. + """ + if 'output_fns' in params_to_override: + self.warning("Output functions specified through the call method will be ignored.") + + p=ParamOverrides(self,params_to_override) + + # CEBERRORALERT: position parameter is not currently + # supported. We should delete the position parameter or fix + # this. + # + # position=params_to_override.get('position',None) if position + # is not None: x,y = position + + self._setup_xy(p.bounds,p.xdensity,p.ydensity,p.x,p.y,p.orientation) + fn_result = self.function(p) + self._apply_mask(p,fn_result) + if p.scale != 1.0: + result = p.scale * fn_result + else: + result = fn_result + if p.offset != 0.0: + result += p.offset + + for of in p.output_fns: + of(result) + + return result + + + def __getitem__(self, coords): + value_dims = {} + if self.num_channels() in [0, 1]: + raster, data = Image, self() + value_dims = {'value_dimensions':[self.z]} if self.z else value_dims + elif self.num_channels() in [3,4]: + raster = RGB + data = np.dstack(self.channels().values()[1:]) + + image = raster(data, bounds=self.bounds, + **dict(group=self.group, + label=self.__class__.__name__, **value_dims)) + # Works round a bug fixed shortly after HoloViews 1.0.0 release + return image if isinstance(coords, slice) else image.__getitem__(coords) + + + + + def channels(self, use_cached=False, **params_to_override): + """ + Channels() adds a shared interface for single channel and + multichannel structures. It will always return an ordered + dict: its first element is the single channel of the pattern + (if single-channel) or the channel average (if multichannel); + the successive elements are the individual channels' arrays + (key: 0,1,..N-1). + """ + return collections.OrderedDict({ 'default':self.__call__(**params_to_override) }) + + + def num_channels(self): + """ + Query the number of channels implemented by the + PatternGenerator. In case of single-channel generators this + will return 1; in case of multichannel, it will return the + number of channels (eg, in the case of RGB images it would + return '3', Red-Green-Blue, even though the OrderedDict + returned by channels() will have 4 elements -- the 3 channels + + their average). + """ + return 1 + + + def _setup_xy(self,bounds,xdensity,ydensity,x,y,orientation): + """ + Produce pattern coordinate matrices from the bounds and + density (or rows and cols), and transforms them according to + x, y, and orientation. + """ + self.debug("bounds=%s, xdensity=%s, ydensity=%s, x=%s, y=%s, orientation=%s",bounds,xdensity,ydensity,x,y,orientation) + # Generate vectors representing coordinates at which the pattern + # will be sampled. + + # CB: note to myself - use slice_._scs if supplied? + x_points,y_points = SheetCoordinateSystem(bounds,xdensity,ydensity).sheetcoordinates_of_matrixidx() + + # Generate matrices of x and y sheet coordinates at which to + # sample pattern, at the correct orientation + self.pattern_x, self.pattern_y = self._create_and_rotate_coordinate_arrays(x_points-x,y_points-y,orientation) + + + def function(self,p): + """ + Function to draw a pattern that will then be scaled and rotated. + + Instead of implementing __call__ directly, PatternGenerator + subclasses will typically implement this helper function used + by __call__, because that way they can let __call__ handle the + scaling and rotation for them. Alternatively, __call__ itself + can be reimplemented entirely by a subclass (e.g. if it does + not need to do any scaling or rotation), in which case this + function will be ignored. + """ + raise NotImplementedError + + + def _create_and_rotate_coordinate_arrays(self, x, y, orientation): + """ + Create pattern matrices from x and y vectors, and rotate them + to the specified orientation. + """ + # Using this two-liner requires that x increase from left to + # right and y decrease from left to right; I don't think it + # can be rewritten in so little code otherwise - but please + # prove me wrong. + pattern_y = np.subtract.outer(np.cos(orientation)*y, np.sin(orientation)*x) + pattern_x = np.add.outer(np.sin(orientation)*y, np.cos(orientation)*x) + return pattern_x, pattern_y + + + def _apply_mask(self,p,mat): + """Create (if necessary) and apply the mask to the given matrix mat.""" + mask = p.mask + ms=p.mask_shape + if ms is not None: + mask = ms(x=p.x+p.size*(ms.x*np.cos(p.orientation)-ms.y*np.sin(p.orientation)), + y=p.y+p.size*(ms.x*np.sin(p.orientation)+ms.y*np.cos(p.orientation)), + orientation=ms.orientation+p.orientation,size=ms.size*p.size, + bounds=p.bounds,ydensity=p.ydensity,xdensity=p.xdensity) + if mask is not None: + mat*=mask + + + def set_matrix_dimensions(self, bounds, xdensity, ydensity): + """ + Change the dimensions of the matrix into which the pattern + will be drawn. Users of this class should call this method + rather than changing the bounds, xdensity, and ydensity + parameters directly. Subclasses can override this method to + update any internal data structures that may depend on the + matrix dimensions. + """ + self.bounds = bounds + self.xdensity = xdensity + self.ydensity = ydensity + scs = SheetCoordinateSystem(bounds, xdensity, ydensity) + for of in self.output_fns: + if isinstance(of, TransferFn): + of.initialize(SCS=scs, shape=scs.shape) + + def state_push(self): + "Save the state of the output functions, to be restored with state_pop." + for of in self.output_fns: + if hasattr(of,'state_push'): + of.state_push() + super(PatternGenerator, self).state_push() + + + def state_pop(self): + "Restore the state of the output functions saved by state_push." + for of in self.output_fns: + if hasattr(of,'state_pop'): + of.state_pop() + super(PatternGenerator, self).state_pop() + + + def anim(self, duration, offset=0, timestep=1, + label=None, unit=None, + time_fn=param.Dynamic.time_fn): + """ + duration: The temporal duration to animate in the units + defined on the global time function. + + offset: The temporal offset from which the animation is + generated given the supplied pattern + + timestep: The time interval between successive frames. The + duration must be an exact multiple of the timestep. + + label: A label string to override the label of the global time + function (if not None). + + unit: The unit string to override the unit value of the global + time function (if not None). + + time_fn: The global time function object that is shared across + the time-varying objects that are being sampled. + + Note that the offset, timestep and time_fn only affect + patterns parameterized by time-dependent number + generators. Otherwise, the frames are generated by successive + call to the pattern which may or may not be varying (e.g to + view the patterns contained within a Selector). + """ + frames = (duration // timestep) + 1 + if duration % timestep != 0: + raise ValueError("The duration value must be an exact multiple of the timestep.") + + if label is None: + label = time_fn.label if hasattr(time_fn, 'label') else 'Time' + + unit = time_fn.unit if (not unit and hasattr(time_fn, 'unit')) else unit + vmap = HoloMap(kdims=[Dimension(label, unit=unit if unit else '')]) + + self.state_push() + with time_fn as t: + t(offset) + for i in range(frames): + vmap[t()] = self[:] + t += timestep + self.state_pop() + return vmap + + ## Support for compositional expressions of PatternGenerator objects + def _promote(self,other): + if not isinstance(other,PatternGenerator): + other = Constant(scale=other,offset=0) + return [self,other] + + def _rpromote(self,other): + if not isinstance(other,PatternGenerator): + other = Constant(scale=other,offset=0) + return [other,self] + + # Could define any of Python's operators here, esp. if they have operator or ufunc equivalents + def __add__ (self,other): return Composite(generators=self._promote(other),operator=np.add) + def __sub__ (self,other): return Composite(generators=self._promote(other),operator=np.subtract) + def __mul__ (self,other): return Composite(generators=self._promote(other),operator=np.multiply) + def __mod__ (self,other): return Composite(generators=self._promote(other),operator=np.mod) + def __pow__ (self,other): return Composite(generators=self._promote(other),operator=np.power) + def __div__ (self,other): return Composite(generators=self._promote(other),operator=np.divide) + def __and__ (self,other): return Composite(generators=self._promote(other),operator=np.minimum) + def __or__ (self,other): return Composite(generators=self._promote(other),operator=np.maximum) + + + def __radd__ (self,other): return Composite(generators=self._rpromote(other),operator=np.add) + def __rsub__ (self,other): return Composite(generators=self._rpromote(other),operator=np.subtract) + def __rmul__ (self,other): return Composite(generators=self._rpromote(other),operator=np.multiply) + def __rmod__ (self,other): return Composite(generators=self._rpromote(other),operator=np.mod) + def __rpow__ (self,other): return Composite(generators=self._rpromote(other),operator=np.power) + def __rdiv__ (self,other): return Composite(generators=self._rpromote(other),operator=np.divide) + def __rand__ (self,other): return Composite(generators=self._rpromote(other),operator=np.minimum) + def __ror__ (self,other): return Composite(generators=self._rpromote(other),operator=np.maximum) + + + def __neg__ (self): return Composite(generators=[Constant(scale=0),self],operator=np.subtract) + + class abs_first(object): + @staticmethod + def reduce(x): return np.abs(x[0]) + + def __abs__ (self): return Composite(generators=[self],operator=self.abs_first) + + + def pil(self, **params_to_override): + """Returns a PIL image for this pattern, overriding parameters if provided.""" + from PIL.Image import fromarray + nchans = self.num_channels() + + if nchans in [0, 1]: + mode, arr = None, self(**params_to_override) + arr = (255.0 / arr.max() * (arr - arr.min())).astype(np.uint8) + + elif nchans in [3,4]: + mode = 'RGB' if nchans==3 else 'RGBA' + arr = np.dstack(self.channels(**params_to_override).values()[1:]) + arr = (255.0*arr).astype(np.uint8) + + else: + raise ValueError("Unsupported number of channels") + + return fromarray(arr, mode) + + +# Override class type; must be set here rather than when mask_shape is declared, +# to avoid referring to class not yet constructed +PatternGenerator.params('mask_shape').class_=PatternGenerator + + + +# Trivial example of a PatternGenerator, provided for when a default is +# needed. The other concrete PatternGenerator classes are stored +# elsewhere, to be imported as needed. + +class Constant(PatternGenerator): + """Constant pattern generator, i.e., a solid, uniform field of the same value.""" + + # The orientation is ignored, so we don't show it in + # auto-generated lists of parameters (e.g. in the GUI) + orientation = param.Number(precedence=-1) + + # Optimization: We use a simpler __call__ method here to skip the + # coordinate transformations (which would have no effect anyway) + def __call__(self,**params_to_override): + p = ParamOverrides(self,params_to_override) + + shape = SheetCoordinateSystem(p.bounds,p.xdensity,p.ydensity).shape + + result = p.scale*np.ones(shape, np.float)+p.offset + self._apply_mask(p,result) + + for of in p.output_fns: + of(result) + + return result + + + +class CompositeBase(PatternGenerator): + """ + PatternGenerator that combines or selects from a list of other + PatternGenerators. + """ + + __abstract=True + + generators = param.List(class_=PatternGenerator,default=[Constant(scale=0.0)], + bounds=(1,None),precedence=0.97, doc=""" + List of patterns to combine or select from. The default pattern is a blank pattern, + and thus should be overridden for any useful work.""") + + size = param.Number(default=1.0,doc="""Scaling factor applied to all sub-patterns.""") + + + +class Composite(CompositeBase): + """ + PatternGenerator that accepts a list of other PatternGenerators. + To create a new pattern, asks each of the PatternGenerators in the + list to create a pattern, then it combines the patterns to create + a single pattern that it returns. + """ + + # The Accum_Replace operator from LISSOM is not yet supported, + # but it should be added once PatternGenerator bounding boxes + # are respected and/or GenericImage patterns support transparency. + operator = param.Parameter(np.maximum,precedence=0.98,doc=""" + Binary Numpy function used to combine the individual patterns. + + Any binary Numpy array "ufunc" returning the same + type of array as the operands and supporting the reduce + operator is allowed here. Supported ufuncs include:: + + add + subtract + multiply + divide + maximum + minimum + remainder + power + + The most useful ones are probably add and maximum, but there + are uses for at least some of the others as well (e.g. to + remove pieces of other patterns). + + You can also write your own operators, by making a class that + has a static method named "reduce" that returns an array of the + same size and type as the arrays in the list. For example:: + + class return_first(object): + @staticmethod + def reduce(x): + return x[0] + + """) + + + def _advance_pattern_generators(self,p): + """ + Subclasses can override this method to provide constraints on + the values of generators' parameters and/or eliminate + generators from this list if necessary. + """ + return p.generators + + def state_push(self): + """ + Push the state of all generators + """ + super(Composite,self).state_push() + for gen in self.generators: + gen.state_push() + + def state_pop(self): + """ + Pop the state of all generators + """ + super(Composite,self).state_pop() + for gen in self.generators: + gen.state_pop() + + # JABALERT: To support large numbers of patterns on a large input region, + # should be changed to evaluate each pattern in a small box, and then + # combine them at the full Composite Bounding box size. + def function(self,p): + """Constructs combined pattern out of the individual ones.""" + generators = self._advance_pattern_generators(p) + + assert hasattr(p.operator,'reduce'),repr(p.operator)+" does not support 'reduce'." + + # CEBALERT: mask gets applied by all PGs including the Composite itself + # (leads to redundant calculations in current lissom_oo_or usage, but + # will lead to problems/limitations in the future). + patterns = [pg(xdensity=p.xdensity,ydensity=p.ydensity, + bounds=p.bounds,mask=p.mask, + x=p.x+p.size*(pg.x*np.cos(p.orientation)- pg.y*np.sin(p.orientation)), + y=p.y+p.size*(pg.x*np.sin(p.orientation)+ pg.y*np.cos(p.orientation)), + orientation=pg.orientation+p.orientation, + size=pg.size*p.size) + for pg in generators] + image_array = p.operator.reduce(patterns) + return image_array + + + +class ChannelTransform(param.Parameterized): + """ + A ChannelTransform is a callable object that takes channels as + input (an ordered dictionary of arrays) and transforms their + contents in some way before returning them. + """ + + __abstract = True + + def __call__(self, channels): + raise NotImplementedError + + + +# Example of a ChannelTransform +class CorrelateChannels(ChannelTransform): + """ + Correlate channels by mixing a fraction of one channel into another. + """ + + from_channel = param.Number(default=1, doc=""" + Name of the channel to take data from.""") + + to_channel = param.Number(default=2, doc=""" + Name of the channel to change data of.""") + + strength = param.Number(default=0, doc=""" + Strength of the correlation to add, with 0 being no change, + and 1.0 overwriting to_channel with from_channel.""") + + def __call__(self, channel_data): + channel_data[self.to_channel] = \ + self.strength*channel_data[self.from_channel] + \ + (1-self.strength)*channel_data[self.to_channel] + + return channel_data + + + +class ChannelGenerator(PatternGenerator): + """ + Abstract base class for patterns supporting multiple channels natively. + """ + + __abstract = True + + channel_transforms = param.HookList(class_=ChannelTransform,default=[],doc=""" + Optional functions to apply post processing to the set of channels.""") + + + def __init__(self, **params): + self._original_channel_data = [] # channel data before processing + self._channel_data = [] # channel data after processing + super(ChannelGenerator, self).__init__(**params) + + + def channels(self, use_cached=False, **params_to_override): + res = collections.OrderedDict() + + if not use_cached: + default = self(**params_to_override) + res['default'] = default + else: + res['default'] = None + + for i in range(len(self._channel_data)): + res[i] = self._channel_data[i] + + return res + + def num_channels(self): + return len(self._channel_data) + + +class ComposeChannels(ChannelGenerator): + """ + Create a multi-channel PatternGenerator from a list of + PatternGenerators, with the specified channel_transforms applied. + """ + + generators = param.List(class_=PatternGenerator,default=[Constant(scale=0.0)], + bounds=(1,None), doc=""" + List of patterns to use for each channel. Generators which already have more than one + channel will only contribute to a single channel of ComposeChannels.""") + + + def __init__(self,**params): + super(ComposeChannels,self).__init__(**params) + + for i in range(len(self.generators)): + self._channel_data.append( None ) + + + def __call__(self,**params): + # Generates all channels, then returns the default channel + + p = param.ParamOverrides(self,params) + + params['xdensity']=p.xdensity + params['ydensity']=p.ydensity + params['bounds']=p.bounds + + # (not **p) + for i in range(len(p.generators)): + self._channel_data[i] = p.generators[i]( **params ) + + + for c in self.channel_transforms: + self._channel_data = c(self._channel_data) + + return sum(act for act in self._channel_data)/len(self._channel_data) diff --git a/PixHtLab-Src/Docker/imagen/imagen/random.py b/PixHtLab-Src/Docker/imagen/imagen/random.py new file mode 100644 index 0000000000000000000000000000000000000000..a5a0890875110c14c2007321ea8be83efb6a529d --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/imagen/random.py @@ -0,0 +1,626 @@ +""" +Two-dimensional pattern generators drawing from various random +distributions. +""" + +import warnings +import numpy as np +import param +from param.parameterized import ParamOverrides + +from holoviews.core import SheetCoordinateSystem + +from .patterngenerator import PatternGenerator +from imagen import Composite, Gaussian +from numbergen import TimeAwareRandomState, TimeAware + + + +def seed(seed=None): + """ + Set the seed on the shared RandomState instance. + """ + warnings.warn("imagen.random.seed is deprecated; use param.random_seed instead.", FutureWarning) + RandomGenerator.random_generator.seed(seed) + + +class RandomGenerator(PatternGenerator, TimeAwareRandomState): + """ + 2D random noise pattern generator abstract class. + + This class generalizes time-controlled randomness as defined by + the numbergen.TimeAwareRandomState to imagen + patterns. Time-controlled randomness allows random scalars to be + generated as a function of time in numbergen, whereas in imagen it + allows time-dependent random patterns with higer dimensionality. + + The notion of time is defined by time_fn (inherited from + TimeAwareRandomState) which outputs the time value. The + time_dependent parameter then toggles between behaviour where a + new random pattern is generated per call and where any randomness + in the pattern is controlled as a function of time. + + By default, RandomGenerators use the same global time_fn as + numbergen objects, namely param.Dynamic.time_fn. This means that + when set to time_dependent, the facilities of param.Time can be + used. This allows the timeline to be explored non-linearly, e.g to + reproduce a pattern from an earlier time. + + For more information about time-dependent random number streams, + consult the docstring of the TimeAwareRandomState class. + """ + + __abstract = True + + # The orientation is ignored, so we don't show it in + # auto-generated lists of parameters (e.g. in the GUI) + orientation = param.Number(precedence=-1) + + random_generator = param.Parameter( + default=np.random.RandomState(seed=(500,500)),precedence=-1,doc= + """ + Using Numpy's RandomState class instead of random.Random as + the former can generate random arrays from more random + distributions. See RandomState's help for more information. + """) + + seed = param.Parameter(default=(500,500), doc=""" + Random seed used to set the random number generator. Set to + (500,500) by default for backwards compatibility.""" ) + + + def __init__(self, **params): + super(RandomGenerator, self).__init__(**params) + self._initialize_random_state(seed=self.seed, shared=True) + + def _distrib(self,shape,p): + """Method for subclasses to override with a particular random distribution.""" + raise NotImplementedError + + # Optimization: We use a simpler __call__ method here to skip the + # coordinate transformations (which would have no effect anyway) + def __call__(self,**params_to_override): + p = ParamOverrides(self,params_to_override) + if self.time_dependent: + if 'name' in p: + self._initialize_random_state(seed=self.seed, shared=True, name=p.name) + self._hash_and_seed() + + shape = SheetCoordinateSystem(p.bounds,p.xdensity,p.ydensity).shape + + result = self._distrib(shape,p) + self._apply_mask(p,result) + + for of in p.output_fns: + of(result) + + return result + + + +class UniformRandom(RandomGenerator): + """2D uniform random noise pattern generator.""" + + def _distrib(self,shape,p): + return p.random_generator.uniform(p.offset, p.offset+p.scale, shape) + + + +class UniformRandomInt(RandomGenerator): + """ + 2D distribution of integer values from low to high in the in the + half-open interval [`low`, `high`). + + Matches semantics of numpy.random.randint. + """ + + low = param.Integer(default=0, doc=""" + Lowest integer to be drawn from the distribution.""") + + high = param.Integer(default=2, doc=""" + The highest integer to be drawn from the distribution.""") + + def _distrib(self,shape,p): + return p.random_generator.randint(p.low, p.high, shape) + + + +class BinaryUniformRandom(RandomGenerator): + """ + 2D binary uniform random noise pattern generator. + + Generates an array of random numbers that are 1.0 with the given + on_probability, or else 0.0, then scales it and adds the offset as + for other patterns. For the default scale and offset, the result + is a binary mask where some elements are on at random. + """ + + on_probability = param.Number(default=0.5,bounds=[0.0,1.0],doc=""" + Probability (in the range 0.0 to 1.0) that the binary value + (before scaling) is on rather than off (1.0 rather than 0.0).""") + + def _distrib(self,shape,p): + rmin = p.on_probability-0.5 + return p.offset+p.scale*(p.random_generator.uniform(rmin,rmin+1.0,shape).round()) + + + +class GaussianRandom(RandomGenerator): + """ + 2D Gaussian random noise pattern generator. + + Each pixel is chosen independently from a Gaussian distribution + of zero mean and unit variance, then multiplied by the given + scale and adjusted by the given offset. + """ + + scale = param.Number(default=0.25,softbounds=(0.0,2.0)) + offset = param.Number(default=0.50,softbounds=(-2.0,2.0)) + + def _distrib(self,shape,p): + return p.offset+p.scale*p.random_generator.standard_normal(shape) + + +# CEBALERT: in e.g. script_repr, an instance of this class appears to +# have only pattern.Constant() in its list of generators, which might +# be confusing. The Constant pattern has no effect because the +# generators list is overridden in __call__. Shouldn't the generators +# parameter be hidden for this class (and possibly for others based on +# pattern.Composite)? For that to be safe, we'd at least have to have +# a warning if someone ever sets a hidden parameter, so that having it +# revert to the default value would always be ok. + +class GaussianCloud(Composite, TimeAware): + """Uniform random noise masked by a circular Gaussian.""" + + operator = param.Parameter(np.multiply) + + gaussian_size = param.Number(default=1.0,doc="Size of the Gaussian pattern.") + + aspect_ratio = param.Number(default=1.0,bounds=(0.0,None),softbounds=(0.0,2.0), + precedence=0.31,doc=""" + Ratio of gaussian width to height; width is gaussian_size*aspect_ratio.""") + + def __call__(self,**params_to_override): + p = ParamOverrides(self,params_to_override) + p.generators=[Gaussian(aspect_ratio=p.aspect_ratio,size=p.gaussian_size), + UniformRandom(name=p.name, + time_dependent=p.time_dependent, + time_fn = p.time_fn)] + return super(GaussianCloud,self).__call__(**p) + + + +### JABHACKALERT: This code seems to work fine when the input regions +### are all the same size and shape, but for +### e.g. examples/hierarchical.ty the resulting images in the Test +### Pattern preview window are square (instead of the actual +### rectangular shapes), matching between the eyes (instead of the +### actual two different rectangles), and with dot sizes that don't +### match between the eyes. It's not clear why this happens. + +### JLALERT: Not implementing time_dependent=True + +class RandomDotStereogram(PatternGenerator): + """ + Random dot stereogram using rectangular black and white patches. + + Based on Matlab code originally from Jenny Read, reimplemented + in Python by Tikesh Ramtohul (2006). + """ + + # Suppress unused parameters + x = param.Number(precedence=-1) + y = param.Number(precedence=-1) + size = param.Number(precedence=-1) + orientation = param.Number(precedence=-1) + + # Override defaults to make them appropriate + scale = param.Number(default=0.5) + offset = param.Number(default=0.5) + + # New parameters for this pattern + + #JABALERT: Should rename xdisparity and ydisparity to x and y, and simply + #set them to different values for each pattern to get disparity + xdisparity = param.Number(default=0.0,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + precedence=0.50,doc="Disparity in the horizontal direction.") + + ydisparity = param.Number(default=0.0,bounds=(-1.0,1.0),softbounds=(-0.5,0.5), + precedence=0.51,doc="Disparity in the vertical direction.") + + dotdensity = param.Number(default=0.5,bounds=(0.0,None),softbounds=(0.1,0.9), + precedence=0.52,doc="Number of dots per unit area; 0.5=50% coverage.") + + dotsize = param.Number(default=0.1,bounds=(0.0,None),softbounds=(0.05,0.15), + precedence=0.53,doc="Edge length of each square dot.") + + random_seed=param.Integer(default=500,bounds=(0,1000), + precedence=0.54,doc="Seed value for the random position of the dots.") + + + def __call__(self,**params_to_override): + p = ParamOverrides(self,params_to_override) + + xsize,ysize = SheetCoordinateSystem(p.bounds,p.xdensity,p.ydensity).shape + xsize,ysize = int(round(xsize)),int(round(ysize)) + + xdisparity = int(round(xsize*p.xdisparity)) + ydisparity = int(round(xsize*p.ydisparity)) + dotsize = int(round(xsize*p.dotsize)) + + bigxsize = 2*xsize + bigysize = 2*ysize + ndots=int(round(p.dotdensity * (bigxsize+2*dotsize) * (bigysize+2*dotsize) / + min(dotsize,xsize) / min(dotsize,ysize))) + halfdot = np.floor(dotsize/2) + + # Choose random colors and locations of square dots + random_seed = p.random_seed + + np.random.seed(random_seed*12+random_seed*99) + col=np.where(np.random.random((ndots))>=0.5, 1.0, -1.0) + + np.random.seed(random_seed*122+random_seed*799) + xpos=np.floor(np.random.random((ndots))*(bigxsize+2*dotsize)) - halfdot + + np.random.seed(random_seed*1243+random_seed*9349) + ypos=np.floor(np.random.random((ndots))*(bigysize+2*dotsize)) - halfdot + + # Construct arrays of points specifying the boundaries of each + # dot, cropping them by the big image size (0,0) to (bigxsize,bigysize) + x1=xpos.astype('l') ; x1=np.choose(np.less(x1,0),(x1,0)) + y1=ypos.astype('l') ; y1=np.choose(np.less(y1,0),(y1,0)) + x2=(xpos+(dotsize-1)).astype('l') ; x2=np.choose(np.greater(x2,bigxsize),(x2,bigxsize)) + y2=(ypos+(dotsize-1)).astype('l') ; y2=np.choose(np.greater(y2,bigysize),(y2,bigysize)) + + # Draw each dot in the big image, on a blank background + bigimage = np.zeros((bigysize,bigxsize)) + for i in range(ndots): + bigimage[y1[i]:y2[i]+1,x1[i]:x2[i]+1] = col[i] + + result = p.offset + p.scale*bigimage[ (ysize/2)+ydisparity:(3*ysize/2)+ydisparity , + (xsize/2)+xdisparity:(3*xsize/2)+xdisparity ] + + for of in p.output_fns: + of(result) + + return result + + + + +class DenseNoise(RandomGenerator): + """ + 2D Dense noise pattern generator, constrained to a grid. + + Similar to UniformRandom, but draws the noise pattern in a grid + that can be smaller than the actual density of the + PatternGenerator. + + By default, this produces a matrix with random values 0.0, 0.5, and 1. + When a scale and an offset are provided the transformation maps them to: + + 0 -> offset + 0.5 -> offset + 0.5 * scale + 1 -> offset + scale + + -------- + Examples + -------- + + DenseNoise(grid_density=1, bounds=BoundingBox(radius=1), + xdensity=4, ydensity=4) will produce something like this: + + [[ 1. 1. 1. 1. 0. 0. 0. 0. ] + [ 1. 1. 1. 1. 0. 0. 0. 0. ] + [ 1. 1. 1. 1. 0. 0. 0. 0. ] Here the Sheet-coordinate size is 2.0x2.0, + [ 1. 1. 1. 1. 0. 0. 0. 0. ] so grid_density=1 yields a 2x2 grid + [ 0. 0. 0. 0. 0.5 0.5 0.5 0.5] sampled at 4 units per grid cell + [ 0. 0. 0. 0. 0.5 0.5 0.5 0.5] + [ 0. 0. 0. 0. 0.5 0.5 0.5 0.5] + [ 0. 0. 0. 0. 0.5 0.5 0.5 0.5]]) + + + + DenseNoise(grid_density=2, bounds=BoundingBox(radius=1), + xdensity=4, ydensity=4) on the other hand will produce something like: + + [[ 1. 1. 0. 0. 0. 0. 0.5 0.5] + [ 1. 1. 0. 0. 0. 0. 0.5 0.5] + [ 1. 1. 1. 1. 0. 0. 0. 0. ] Again the Sheet-coordinate size is 2.0x2.0, + [ 1. 1. 1. 1. 0. 0. 0. 0. ] but grid_density=2 yields a 4x4 grid + [ 0. 0. 0.5 0.5 1. 1. 1. 1. ] with 2 units per grid cell + [ 0. 0. 0.5 0.5 1. 1. 1. 1. ] + [ 1. 1. 0. 0. 1. 1. 1. 1. ] + [ 1. 1. 0. 0. 1. 1. 1. 1. ]] + + ----- + Notes + ----- + + 1. This method works much faster when the noise matrix falls neatly + into the pixel matrix (~100 times faster). + + 2. The value of each pixel in the generated pattern is determined + by where the center of that pixel lies in the underlying grid, + regardless of any overlap of that pixel with other grid + squares. + + 3. If a particular number of cells N is wanted, divide it by the + length of the side of the bounding box to determine the + grid_density. For example, if the user wants to have N=10 cells + for a BoundingBox(radius=1) (which gives a bounding box size of + 2.0x2.0), the grid_density must be set to N/2 = 5 in order to + have ten cells. + + 4. The xdensity and ydensity must both be at least as large as the + grid_density, e.g. 5 for the above example. + """ + + grid_density = param.Number(default=10, bounds=(1,None), softbounds=(1,50), doc=""" + Grid elements per 1.0 distance in Sheet coordinates.""") + + # Hide unused parameters + x = param.Number(precedence=-1) + y = param.Number(precedence=-1) + size = param.Number(precedence=-1) + + + def _distrib(self, shape, p): + max_density = min(p.xdensity,p.ydensity) + if (p.grid_density > max_density and not hasattr(self,"warned_about_density")): + self.warning("Requested grid_density %s larger than xdensity %s or ydensity %s; capped at %s" % + (p.grid_density,p.xdensity,p.ydensity,max_density)) + p.grid_density = max_density + self.warned_about_density=True + + Nx = shape[1] + Ny = shape[0] # Size of the pixel matrix + + assert (Nx>0 and Ny>0), 'Pixel matrix cannot be zero' + + SC = SheetCoordinateSystem(p.bounds, p.xdensity, p.ydensity) + unitary_distance_x = SC._SheetCoordinateSystem__xstep + unitary_distance_y = SC._SheetCoordinateSystem__ystep + + + sheet_x_size = unitary_distance_x * Nx + sheet_y_size = unitary_distance_y * Ny + + # Sizes of the structure matrix + nx = int(round(sheet_x_size * p.grid_density)) # Number of points in the x's + ny = int(round(sheet_y_size * p.grid_density)) # Number of points in the y's + + assert ( nx > 0 ), 'Grid density or bound box in the x dimension too small' + assert ( ny > 0 ), 'Grid density or bound box in the y dimension too small' + + # If the noise grid is proportional to the pixel grid and fits + # neatly into it then this method is ~100 times faster + if ( Nx % nx == 0) and (Ny % ny == 0): + + if (Nx == nx) and (Ny == ny): #This is faster to call the whole procedure + result = 0.5 * (p.random_generator.randint(-1, 2, shape) + 1) + return result * p.scale + p.offset + + else: + # This is the actual matrix of the pixels + A = np.zeros(shape) + # Noise matrix that contains the structure of 0, 0.5, and 1's + Z = 0.5 * (p.random_generator.randint(-1, 2, (nx, ny)) + 1 ) + + ps_x = int(round(Nx * 1.0/ nx)) #Closest integer + ps_y = int(round(Ny * 1.0/ ny)) + + # Noise matrix is mapped to the pixel matrix + for i in range(nx): + for j in range(ny): + A[i * ps_y: (i + 1) * ps_y, j * ps_x: (j + 1) * ps_x] = Z[i,j] + + return A * p.scale + p.offset + + # General method in case the noise grid does not + # fall neatly in the pixel grid + else: + + # Obtain length of the side and length of the + # division line between the grid + x_points,y_points = SC.sheetcoordinates_of_matrixidx() + + # This is the actual matrix of the pixels + A = np.zeros(shape) + # Noise matrix that contains the structure of 0, 0.5, and 1's + Z = 0.5 * (p.random_generator.randint(-1, 2, (nx, ny)) + 1 ) + + size_of_block_x = Nx * 1.0 / nx + size_of_block_y = Ny * 1.0 / ny + + # Noise matrix is mapped to the pixel matrix + for i in range(Nx): + for j in range(Ny): + # Map along the x coordinates + x_entry = int( i / size_of_block_x) + y_entry = int( j / size_of_block_y) + A[j][i] = Z[x_entry][y_entry] + + return A * p.scale + p.offset + + + +class SparseNoise(RandomGenerator): + """ + 2D sparse noise pattern generator, with optional constraining to a grid. + + Draws a square pixel of random brightness at a random location, + either entirely random on the pattern surface or chosen from a + predefined grid of possible positions. + + By default, produces a matrix with 0.5 everywhere except for a + square patch in one random location. This value is randomly + assigned to either 0 or 1, and then is scaled with the parameters + scale and offset in the following way: + + 0 -> offset + 1 -> offset + scale + + -------- + Examples + -------- + + SparseNoise(grid_density=1, grid=True, bounds=BoundingBox(radius=1), + xdensity=4, ydensity=4) will produce something like this: + + [[ 0.5 0.5 0.5 0.5 0. 0. 0. 0. ] + [ 0.5 0.5 0.5 0.5 0. 0. 0. 0. ] + [ 0.5 0.5 0.5 0.5 0. 0. 0. 0. ] Here the Sheet-coordinate size is 2.0x2.0, + [ 0.5 0.5 0.5 0.5 0. 0. 0. 0. ] so grid_density=1 yields a 2x2 grid + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] sampled at 4 units per grid cell, with 0.5 + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] everywhere except the one active cell + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5]] + + SparseNoise(grid_density=2, grid=True, bounds=BoundingBox(radius=1), + xdensity=4, ydensity=4) on the other hand will produce something like: + + [[ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] Again the Sheet-coordinate size is 2.0x2.0, + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] but grid_density=2 yields a 4x4 grid + [ 0.5 0.5 0.5 0.5 0.5 0.5 1. 1. ] with 2 units per grid cell + [ 0.5 0.5 0.5 0.5 0.5 0.5 1. 1. ] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5]] + + SparseNoise(grid_density=2, grid=False, bounds=BoundingBox(radius=1), + xdensity=4, ydensity=4) will produce something like: + + [[ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] Here notice that the patch is no longer + [ 0.5 0.5 0.5 0.5 0.5 0. 0. 0.5] aligned with a fixed grid + [ 0.5 0.5 0.5 0.5 0.5 0. 0. 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5] + [ 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5]] + + + ----- + Notes + ----- + + 1. This method works ~100 times faster when the noise matrix falls neatly + into the pixel matrix. + + 2. The value of each pixel in the generated pattern is determined + by where the center of that pixel lies in the underlying grid, + regardless of any overlap of that pixel with other grid + squares. + + 3. If a particular number of cells N is wanted, divide it by the + length of the side of the bounding box to determine the + grid_density. For example, if the user wants to have N=10 cells + for a BoundingBox(radius=1) (which gives a bounding box size of + 2.0x2.0), the grid_density must be set to N/2 = 5 in order to + have ten cells. + + 4. The xdensity and ydensity must both be at least as large as the + grid_density, e.g. 5 for the above example. + """ + + grid_density = param.Number(default=10, bounds=(1,None), softbounds=(1,50), doc=""" + Grid elements per 1.0 distance in Sheet coordinates.""") + + grid = param.Boolean(default=True, doc=""" + If True, each spot is snapped to a grid, so that subsequent + spots are forced to overlap either entirely or not at all, + never partially. Otherwise, the spot size is fixed by the + grid_density, but it may appear anywhere.""") + + + # Hide unused parameters + x = param.Number(precedence=-1) + y = param.Number(precedence=-1) + size = param.Number(precedence=-1) + + def _distrib(self, shape, p): + max_density = min(p.xdensity,p.ydensity) + if (p.grid_density > max_density and not hasattr(self,"warned_about_density")): + self.warning("Requested grid_density %s larger than xdensity %s or ydensity %s; capped at %s" % + (p.grid_density,p.xdensity,p.ydensity,max_density)) + p.grid_density = max_density + self.warned_about_density=True + + Nx = shape[1] + Ny = shape[0] # Size of the pixel matrix + + assert (Nx>0 and Ny>0), 'Pixel matrix cannot be zero' + + SC = SheetCoordinateSystem(p.bounds, p.xdensity, p.ydensity) + unitary_distance_x = SC._SheetCoordinateSystem__xstep + unitary_distance_y = SC._SheetCoordinateSystem__ystep + + sheet_x_size = unitary_distance_x * Nx + sheet_y_size = unitary_distance_y * Ny + + # Sizes of the structure matrix + nx = int(round(sheet_x_size * p.grid_density)) # Number of points in the x's + ny = int(round(sheet_y_size * p.grid_density)) # Number of points in the y's + + assert ( nx > 0 ), 'Grid density or bound box in the x dimension too small' + assert ( ny > 0 ), 'Grid density or bound box in the y dimension too smal' + + ps_x = int(round(Nx / nx)) #Closest integer + ps_y = int(round(Ny / ny)) + + # This is the actual matrix of the pixels + A = np.ones(shape) * 0.5 + + if p.grid == False: #The centers of the spots are randomly distributed in space + + x = p.random_generator.randint(0, Nx - ps_x + 1) + y = p.random_generator.randint(0, Ny - ps_y + 1) + z = p.random_generator.randint(0,2) + + # Noise matrix is mapped to the pixel matrix + A[x: (x + ps_y), y: (y + ps_x)] = z + + return A * p.scale + p.offset + + else: #In case you want the grid + + if ( Nx % nx == 0) and (Ny % ny == 0): #When the noise grid falls neatly into the the pixel grid + x = p.random_generator.randint(0, nx) + y = p.random_generator.randint(0, ny) + z = p.random_generator.randint(0,2) + + # Noise matrix is mapped to the pixel matrix (faster method) + A[x*ps_y: (x*ps_y + ps_y), y*ps_x: (y*ps_x + ps_x)] = z + + return A * p.scale + p.offset + + else: # If noise grid does not fit neatly in the pixel grid (slow method) + + x_points,y_points = SC.sheetcoordinates_of_matrixidx() + + # Obtain length of the side and length of the + # division line between the grid + + size_of_block_x = Nx * 1.0 / nx + size_of_block_y = Ny * 1.0 / ny + + # Construct the noise matrix + Z = np.ones((nx,ny)) * 0.5 + x = p.random_generator.randint(0, nx) + y = p.random_generator.randint(0, ny) + z = p.random_generator.randint(0,2) + Z[x,y] = z + + # Noise matrix is mapped to the pixel matrix + for i in range(Nx): + for j in range(Ny): + # Map along the x coordinates + x_entry = int( i / size_of_block_x) + y_entry = int( j / size_of_block_y) + A[j][i] = Z[x_entry][y_entry] + + return A * p.scale + p.offset diff --git a/PixHtLab-Src/Docker/imagen/imagen/transferfn/__init__.py b/PixHtLab-Src/Docker/imagen/imagen/transferfn/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bfe5a56b597ec14ff63e0524fbaf52d009c60eff --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/imagen/transferfn/__init__.py @@ -0,0 +1,303 @@ +""" +TransferFns: accept and modify a 2d array +""" + +import numpy +import copy +import param + + +class TransferFn(param.Parameterized): + """ + Function object to modify a matrix in place, e.g. for normalization. + + Used for transforming an array of intermediate results into a + final version, by cropping it, normalizing it, squaring it, etc. + + Objects in this class must support being called as a function with + one matrix argument, and are expected to change that matrix in place. + """ + __abstract = True + + init_keys = param.List(default=[], constant=True, doc=""" + List of item key labels for metadata that that must be + supplied to the initialize method before the TransferFn may be + used.""") + + # CEBALERT: can we have this here - is there a more appropriate + # term for it, general to output functions? JAB: Please do rename it! + norm_value = param.Parameter(default=None) + + def initialize(self, **kwargs): + """ + Transfer functions may need additional information before the + supplied numpy array can be modified in place. For instance, + transfer functions may have state which needs to be allocated + in memory with a certain size. In other cases, the transfer + function may need to know about the coordinate system + associated with the input data. + """ + if not set(kwargs.keys()).issuperset(self.init_keys): + raise Exception("TransferFn needs to be initialized with %s" + % ','.join(repr(el) for el in self.init_keys)) + + def __call__(self,x): + raise NotImplementedError + + +class TransferFnWithState(TransferFn): + """ + Abstract base class for TransferFns that need to maintain a + self.plastic parameter. + + These TransferFns typically maintain some form of internal history + or other state from previous calls, which can be disabled by + override_plasticity_state(). + """ + + plastic = param.Boolean(default=True, doc=""" + Whether or not to update the internal state on each call. + Allows plasticity to be temporarily turned off (e.g for + analysis purposes).""") + + __abstract = True + + def __init__(self,**params): + super(TransferFnWithState,self).__init__(**params) + self._plasticity_setting_stack = [] + + + def override_plasticity_state(self, new_plasticity_state): + """ + Temporarily disable plasticity of internal state. + + This function should be implemented by all subclasses so that + after a call, the output should always be the same for any + given input pattern, and no call should have any effect that + persists after restore_plasticity_state() is called. + + By default, simply saves a copy of the 'plastic' parameter to + an internal stack (so that it can be restored by + restore_plasticity_state()), and then sets the plastic + parameter to the given value (True or False). + """ + self._plasticity_setting_stack.append(self.plastic) + self.plastic=new_plasticity_state + + + def restore_plasticity_state(self): + """ + Re-enable plasticity of internal state after an + override_plasticity_state call. + + This function should be implemented by all subclasses to + remove the effect of the most recent override_plasticity_state call, + i.e. to reenable changes to the internal state, without any + lasting effect from the time during which plasticity was disabled. + + By default, simply restores the last saved value of the + 'plastic' parameter. + """ + self.plastic = self._plasticity_setting_stack.pop() + + def state_push(self): + """ + Save the current state onto a stack, to be restored with + state_pop. + + Subclasses must implement state_push and state_pop to store + state across invocations. The behaviour should be such that + after state_pop, the state is restored to what it was at + the time when state_push was called. + """ + pass + + def state_pop(self): + """ + Restore the state saved by the most recent state_push call. + """ + pass + + + +class IdentityTF(TransferFn): + """ + Identity function, returning its argument as-is. + + For speed, calling this function object is sometimes optimized + away entirely. To make this feasible, it is not allowable to + derive other classes from this object, modify it to have different + behavior, add side effects, or anything of that nature. + """ + + def __call__(self,x,sum=None): + pass + + +class Scale(TransferFn): + """ + Multiply the input array by some constant factor. + """ + + scale = param.Number(default=1.0, doc=""" + The multiplicative factor that scales the input values.""") + + def __call__(self, x): + x *= self.scale + + + +class Threshold(TransferFn): + """ + Forces all values below a threshold to zero, and leaves others unchanged. + """ + + threshold = param.Number(default=0.25, doc=""" + Decision point for determining values to clip.""") + + def __call__(self,x): + numpy.minimum(x,self.threshold,x) + + + +class BinaryThreshold(TransferFn): + """ + Forces all values below a threshold to zero, and above it to 1.0. + """ + + threshold = param.Number(default=0.25, doc=""" + Decision point for determining binary value.""") + + def __call__(self,x): + above_threshold = x>=self.threshold + x *= 0.0 + x += above_threshold + + + +class DivisiveNormalizeL1(TransferFn): + """ + TransferFn that divides an array by its L1 norm. + + This operation ensures that the sum of the absolute values of the + array is equal to the specified norm_value, rescaling each value + to make this true. The array is unchanged if the sum of absolute + values is zero. For arrays of non-negative values where at least + one is non-zero, this operation is equivalent to a divisive sum + normalization. + """ + norm_value = param.Number(default=1.0) + + def __call__(self,x): + """L1-normalize the input array, if it has a nonzero sum.""" + current_sum = 1.0*numpy.sum(abs(x.ravel())) + if current_sum != 0: + factor = (self.norm_value/current_sum) + x *= factor + + + +class DivisiveNormalizeL2(TransferFn): + """ + TransferFn to divide an array by its Euclidean length (aka its L2 norm). + + For a given array interpreted as a flattened vector, keeps the + Euclidean length of the vector at a specified norm_value. + """ + norm_value = param.Number(default=1.0) + + def __call__(self,x): + xr = x.ravel() + tot = 1.0*numpy.sqrt(numpy.dot(xr,xr)) + if tot != 0: + factor = (self.norm_value/tot) + x *= factor + + + +class DivisiveNormalizeLinf(TransferFn): + """ + TransferFn to divide an array by its L-infinity norm + (i.e. the maximum absolute value of its elements). + + For a given array interpreted as a flattened vector, scales the + elements divisively so that the maximum absolute value is the + specified norm_value. + + The L-infinity norm is also known as the divisive infinity norm + and Chebyshev norm. + """ + norm_value = param.Number(default=1.0) + + def __call__(self,x): + tot = 1.0*(numpy.abs(x)).max() + if tot != 0: + factor = (self.norm_value/tot) + x *= factor + + + +def norm(v,p=2): + """ + Returns the Lp norm of v, where p is an arbitrary number defaulting to 2. + """ + return (numpy.abs(v)**p).sum()**(1.0/p) + + + +class DivisiveNormalizeLp(TransferFn): + """ + TransferFn to divide an array by its Lp-Norm, where p is specified. + + For a parameter p and a given array interpreted as a flattened + vector, keeps the Lp-norm of the vector at a specified norm_value. + Faster versions are provided separately for the typical L1-norm + and L2-norm cases. Defaults to be the same as an L2-norm, i.e., + DivisiveNormalizeL2. + """ + p = param.Number(default=2) + norm_value = param.Number(default=1.0) + + def __call__(self,x): + tot = 1.0*norm(x.ravel(),self.p) + if tot != 0: + factor = (self.norm_value/tot) + x *=factor + + +class Hysteresis(TransferFnWithState): + """ + Smoothly interpolates a matrix between simulation time steps, with + exponential falloff. + """ + + time_constant = param.Number(default=0.3,doc=""" + Controls the time scale of the interpolation.""") + + def __init__(self,**params): + super(Hysteresis,self).__init__(**params) + self.first_call = True + self.__current_state_stack=[] + self.old_a = 0 + + def __call__(self,x): + if self.first_call is True: + self.old_a = x.copy() * 0.0 + self.first_call = False + + new_a = x.copy() + self.old_a = self.old_a + (new_a - self.old_a)*self.time_constant + x*=0 + x += self.old_a + + def reset(self): + self.old_a *= 0 + + def state_push(self): + self.__current_state_stack.append((copy.copy(self.old_a), + copy.copy(self.first_call))) + super(Hysteresis,self).state_push() + + def state_pop(self): + self.old_a,self.first_call = self.__current_state_stack.pop() + super(Hysteresis,self).state_pop() diff --git a/PixHtLab-Src/Docker/imagen/imagen/transferfn/sheet_tf.py b/PixHtLab-Src/Docker/imagen/imagen/transferfn/sheet_tf.py new file mode 100644 index 0000000000000000000000000000000000000000..4a2e0e5769008f0f7918167ba43604da46064736 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/imagen/transferfn/sheet_tf.py @@ -0,0 +1,62 @@ +""" +A family of transfer functions that are aware of sheet coordinate +systems. + +The transfer functions in this file are allowed to make use of Imagen +patterns and are to be supplied with an appropriate +SheetCoordinateSystem object via the initialize method. +""" + +import numpy as np + +import param +import copy +from imagen import PatternGenerator, Gaussian +from imagen.transferfn import TransferFn + + +class Convolve(TransferFn): + """ + Transfer function that convolves the array data with the supplied + kernel pattern. + + The bounds and densities of the supplied kernel pattern do not + affect the convolution operation. The spatial scale of the + convolution is determined by the 'size' parameter of the + kernel. The resulting convolution is applied of a spatial scale + relative to the overall size of the input, as expressed in + sheetcoordinates. + """ + + kernel_pattern = param.ClassSelector(PatternGenerator, + default=Gaussian(size=0.05,aspect_ratio=1.0), doc=""" + The kernel pattern used in the convolution. The default kernel + results in an isotropic Gaussian blur.""") + + init_keys = param.List(default=['SCS'], constant=True) + + def __init__(self, **params): + super(Convolve,self).__init__(**params) + + + def initialize(self, **kwargs): + super(Convolve, self).initialize(**kwargs) + scs = kwargs['SCS'] + pattern_copy = copy.deepcopy(self.kernel_pattern) + pattern_copy.set_matrix_dimensions(self.kernel_pattern.bounds, + scs.xdensity, + scs.ydensity) + self.kernel = pattern_copy() + + def __call__(self, x): + if not hasattr(self, 'kernel'): + raise Exception("Convolve must be initialized before being called.") + fft1 = np.fft.fft2(x) + fft2 = np.fft.fft2(self.kernel, s=x.shape) + convolved_raw = np.fft.ifft2( fft1 * fft2).real + + k_rows, k_cols = self.kernel.shape # ORIGINAL + rolled = np.roll(np.roll(convolved_raw, -(k_cols//2), axis=-1), -(k_rows//2), axis=-2) + convolved = rolled / float(self.kernel.sum()) + x.fill(0.0) + x+=convolved diff --git a/PixHtLab-Src/Docker/imagen/images/ellen_arthur.pgm b/PixHtLab-Src/Docker/imagen/images/ellen_arthur.pgm new file mode 100644 index 0000000000000000000000000000000000000000..e22924898614456ce38b3566f3d79f8a464fdeaf --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/images/ellen_arthur.pgm @@ -0,0 +1,6 @@ +P5 +# CREATOR: XV Version 3.10a Rev: 12/29/94 (PNG patch 1.2) +# CREATOR: The GIMP's PNM Filter Version 1.0 +200 256 +255 +æåæåæåææååæææåååååååååååååååååååååååÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÝÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÝÕÝÕÕÝÕÝÕÝÕÝÕÕÝÕÝÝÝÝÝÝÝÕÝÝÝÝÝÕÝÕÕÕÝÕÕÝÕÕÕÝÕÕÕÕÕÕÕÝÝÝÝÝÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝååååååååååæååæåæåæåææææææææîæîæîîîîîæîîææåæææææææææææææååååååååååååååååååÝååååÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÕÝÕÕÕÕÝÕÕÕÝÝÝÝÝÝÝÝÕÕÕÝÝÝÝÝÝÕÝÕÝÕÕÝÕÝÕÝÕÕÝÕÕÕÕÕÕÕÝÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝååååååååååæåååæææææææææîææîæîîæîîîîîîîîææææææææîæîæîææææææååææååååååååååÝååÝåÝÝÝÝÝÝÝÝÝÕÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÝÝÕÝÝÝÕÕÝÕÝÝÝÝÕÝÝÝÕÝÕÕÝÝÕÝÕÝÝÝÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåååååååååååæææåææææææææææîæîæîæîîæîîîîîîæææææîæîæîæîæîæææææååååååååååååååååååÝåÝÝÝÝÝÝÕÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÝÕÝÕÕÝÕÝÝÝÕÕÝÕÝÝÕÝÝÝÝÝÕÕÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝååååååååååååæææææææææåæææææææîæîæîîîöîöîîæææææîæîæææîæææææææææåååååååååååååååÝåÝÝÝÝÝÝÝÝÕÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÕÕÕÕÕÕÕÕÕÝÝÕÝÕÝÝÕÕÕÝÕÝÕÝÝÕÝÝÕÕÕÕÕÕÕÝÝÝÕÝÝÝÝÝÝÕÝÝÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝååÝååååååååååååæææææååæææææîæîîæîîîîîîîîîææææîæîîæîîææîîæîæææææåæååååååååååååååÝÝÝÝÝÝÝÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÕÕÝÝÕÕÕÝÕÝÕÕÕÕÕÝÕÕÕÕÕÕÕÕÝÝÝÕÝÕÝÝÝÝÝÝÝÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝåÝååÝåååååååååååæåææåæææîæææîææîæîæîîîîîîîæææîæîæîîæîîææææîææææææååååååååÝåÝåÝåÝÝÝÝÝÝÝÝÝÕÝÝÝÝÕÝÝÝÕÝÕÕÝÕÝÝÕÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÕÝÕÕÕÝÕÕÝÕÕÝÕÕÝÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÝÕÝÝÕÝÝÝÝÝÝÕÝÝÝÕÝÝÝÝÝååÝååååååååååååååææææææææææææîæîæîæîîîîîæææîæîîææîîæîîææîææææææååååååååÝåÝåÝÝÝÝÝÝÝÝÝÝÝÕÝÝÝÝÝÝÕÝÕÕÕÕÕÝÕÝÕÝÝÝÝÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÝÝÕÝÕÝÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÝÕÝÝÕÝÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝååÝåÝÝååååååååååææææææææææææîæîæîîîæîæîæææææîæîææææîæææææææåæååååååååååÝååÝåÝåÝÝÝÝÝÕÝÕÕÝÝÕÝÝÕÝÕÝÕÝÕÝÕÕÕÝÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÍÕÕÕÕÝÕÝÕÕÕÕÕÝÕÕÝÝÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÝÕÝÕÕÝÕÝÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝåååååååååååååååææææææææææîæææîæîæîæîæææææîæîæîæîæææææææææåååååååååååÝååÝåÝÝÝÝÝÝÝÕÕÝÝÕÝÝÕÕÝÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÍÕÕÕÕÝÕÝÕÝÕÕÕÕÝÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝååÝåÝååååååååååååæææææææææææîæææîîæîîææææææîææææææîæææææææåååååååååååååÝåÝåÝÝÝÝÝÝÝÕÕÝÕÕÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÍÕÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÝÕÝÕÝÕÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝåÝåÝåååååÝåååååååææææææææææîææîæîææææææææîæîæîææææîææææåååååååååååÝåÝååÝÝÝåÝÝÝÝÕÝÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÍÕÕÕÍÕÍÍÕÕÕÕÕÕÕÕÕÝÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÝÕÝÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝååÝåÝåÝÝååååååååååååååååæææææîæîîæææææîæîæææîæææææææåååååååååÝååÝååÝåÝåÝÝÝÝÝÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÍÍÍÍÕÍÍÍÍÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝÝåÝåååååååååååååååååææîææææææææåæææîæææîæææææææååååååÝååÝåååÝÝåÝÝÝÝÝÝÝÝÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÍÍÍÍÕÕÍÕÍÍÍÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÍÕÍÍÕÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÝÕÝÝÝÝÝÝÕÝÝÕÝÝÝÝÝÝÝÝÝåÝÝåååååååååååååååååååæææîîæîææååææîæîæîæææææææææååååååååÝååÝÝÝÝåÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÍÕÍÍÍÍÕÍÕÍÍÕÍÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÍÕÍÍÍÍÕÍÍÍÕÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÍÍÍÕÕÕÕÕÕÕÕÝÕÕÝÕÝÕÝÕÝÝÕÝÕÝÕÝÝÕÝÝÝÝÝÝÝÝÝÝåÝååÝåååååååååååååååæææææææææååæææîæææææææææææåååååååÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÍÕÍÕÕÕÍÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÍÍÍÍÍÕÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÕÕÍÍÍÕÍÕÕÍÕÕÕÍÕÕÕÕÕÕÕÕÝÕÕÕÝÕÕÝÕÝÕÝÝÕÕÝÝÝÝÝÝÝÝÝÝåÝåÝåÝååååÝååååååååååææææîæææåæææææîææææîæææææåååååååÝåÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÝÕÍÍÕÕÕÕÕÕÕÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÍÕÍÍÕÍÍÕÕÕÕÕÕÕÕÕÕÕÍÕÍÕÕÍÍÕÍÍÍÍÍÍÍÍÍÕÍÍÕÍÍÍÕÍÍÍÕÕÕÕÕÕÕÕÕÕÍÕÍÍÕÍÕÕÕÕÕÕÕÕÕÕÝÕÕÕÝÕÝÝÝÕÕÕÕÕÝÕÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝåååÝååÝåÝååÝåååååååæææææææååææææææîæææææåååååååååÝåÝÝÝÝÝÝÝÝÝÝÕÝÕÝÕÕÕÕÍÍÍÕÍÍÍÕÍÍÍÍÕÍÕÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÍÕÍÍÕÕÕÕÕÕÕÕÍÍÍÕÍÕÍÍÕÍÍÍÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÍÕÍÕÍÕÍÍÕÍÍÕÍÕÕÍÕÍÕÕÕÕÕÕÕÕÕÕÝÕÝÝÕÕÝÕÕÕÝÕÕÝÝÝÝÝÝÝÕÝÝÝÝÝÝåÝååÝåÝÝåÝÝÝÝååååååææææææååæææîæææææææååååååååååÝÝåÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÍÍÕÍÍÍÍÍÍÍÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÍÍÕÕÍÕÕÕÕÕÍÍÕÍÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÍÍÍÍÍÕÍÍÍÍÍÕÍÍÍÍÍÍÕÍÍÕÕÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÕÕÝÕÝÝÝÕÝÕÕÕÝÝÝÝÝåÝåÝåÝåÝÝÝåÝååååååååææîææåååææææææææææåååååååÝååÝåÝÝÝÝÝÝÝÕÝÝÝÝÝÕÕÕÕÕÍÍÍÍÕÍÍÍÍÍÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÍÍÕÍÍÍÕÍÕÍÃÍÍÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÍÕÍÍÍÍÍÍÍÍÍÍÍÕÍÕÍÍÍÍÕÍÕÕÍÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÝÕÕÝÝÕÝÝÝÝÝÝÝÝåÝåÝÝÝåÝåÝÝÝåååååæææææåååææææîæîæåååååååÝÝåÝåÝÝÝÝÝÝÝÝÝÝÝÝÕÝÕÝÕÕÕÍÕÍÍÕÍÍÍÍÍÍÍÍÍÕÍÍÍÍÍÍÍÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÍÍÍÍÍÍÕÍÍÍÍÍÃÃÍÃÍÃÍÃÃÃÃÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÍÕÍÕÍÕÍÍÍÍÕÕÕÍÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÝÕÝÕÕÝÝÕÕÝÕÝÝÝÝÝÝÝÝåÝÝÝÝÝÝÝåÝååÝåååææåååååååæææææææååååååÝåÝÝÝÝåÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÍÕÕÍÕÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÃÍÍÍÍÍÍÕÍÕÍÍÕÍÍÕÍÍÍÍÃÍÃÃÃÃÃÃÃû«¥´ÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÍÍÕÍÍÍÕÍÍÕÕÍÕÕÕÍÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÕÕÕÝÝÝÝÝÝÝÝÝÝÝåÝåÝåååÝåååååååååååååæææææææåååååååÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÝÝÕÕÕÕÕÕÍÕÕÍÕÍÍÍÍÍÍÃÍÍÍÍÍÍÍÍÍÍÃÍÍÍÍÍÍÍÍÍÍÍÃÍÃÍÍÕÍÍÍÍÍÍÍÍÕÍÍÍÃÍÃÃû»»»»´«‹YRu«´»»ÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÍÍÕÍÍÍÕÍÍÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÝåÝÝÝÝåÝÝåååååååååååååæåååååååååÝÝÝåÝÝÝÝÝÝÝÝÝÝÕÝÕÕÝÝÝÕÝÕÕÕÕÕÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÃÍÃÍÍÍÍÃÍÍÍÍÃÃÍÃÍÃÍÍÍÍÍÍÍÍÕÍÍÍÍÍÍÍû»¥—‘„ulll^RRMll„„—´»»ÃÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÍÕÍÕÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝåååååååååååååååååååååååÝÝåÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÝÕÝÝÕÝÕÕÕÕÕÕÍÍÍÕÍÍÍÍÍÍÍÍÍÍÃÍÍÍÍÍÍÍÍÃÃÍÃÍÃÍÃÍÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍû¥}^MMDDMDYYYY^lll}‹—¥‘«ÃÃÃÍÍÍÍÍÍÍÍÍÍÕÍÍÍÕÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝååÝåååååååååååååååååååååååååÝåÝåÝÝÝÝÝÝÝÝÕÕÕÕÝÝÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÍÍÍÍÃÍÍÍÃÍÍÍÍÍÍÍÍÍÍÍÃÃÍÍÃÃÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÃû—lYR;;;DDDRYYYluu„‹‘—¥—«´«´»ÃÃÍÍÍÍÍÍÕÍÍÍÍÍÕÍÕÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝåÝåÝåååååååååÝååååååååååååÝååÝåÝåÝÝÝÝÝÝÕÕÕÕÕÕÕÕÝÕÕÕÕÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÃÍÃÍÍÃÍÍÍÃÍÃÃÃÍÃÃÃÃÍÃÍÃÃÍÍÍÃÍÍÃÍÃû¥uYM;;;;;DMMMRYlu}———«¥«´««´´´»ÃÍÍÍÍÍÍÍÍÍÍÕÍÕÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÕÍÕÕÕÕÕÕÕÝÕÝÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝååÝåååÝååÝÝåååååååååååÝåÝåÝÝÝÝÝÝÝÝÝÕÕÕÕÝÕÕÕÝÕÕÕÕÕÕÍÍÍÍÍÍÍÍÍÍÍÍÃÍÍÍÍÃÍÍÃÍÍÍÍÍÃÃÍûÃÃÃÃÍÃÃûÃÃÃÍÃÃÃûÃë„RD;;..DMRMRMYYlu„‹‘—««´««««´»»»ÃÃÍÍÍÍÍÍÍÍÍÕÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÍÕÍÕÍÕÍÕÍÕÕÕÕÕÕÕÕÝÕÕÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåååååÝåÝåÝåååååååååÝÝåÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÝÕÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÃÃÍÍÍÍÍÍÍÍÍÃÍÃÃÍÍÍÍÍÃÍÍÃÃÍÃÃÃÃû»´«««´ÃÃÃÍ»Ãû‹YDD..;.;MMY^lllu„„‹‘‘¥««´´»´»»ÃÃÃÃÃÍÍÃÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÍÕÕÍÍÕÍÍÕÍÕÕÕÕÕÕÕÕÝÕÝÕÝÕÝÝÕÝÝÝÝÝÝÝÝåÝÝåÝåååååÝåÝåååååååååÝåÝÝÝÝÝÝÝÝÝÝÝÕÝÕÕÕÕÕÕÕÕÕÕÕÍÕÕÍÍÍÍÍÍÍÍÃÍÃÍÍÍÍÍÍÃÃÍÃÃÍÍÃÍÍÃÃÍÃÃÃÃû´«¥—‘‹‘«»Ãû»Ãë}M;D;....-;R^u}}‹—————¥¥¥´»»ÃÃÃÃÃÍÃÍÃÃÍÃÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÍÕÍÍÕÍÕÍÕÕÕÕÕÝÕÝÝÕÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝååÝåååÝååÝÝåÝåååååÝÝåÝÝÝåÝÝÝÝÝÕÕÝÕÕÕÕÕÕÕÕÕÍÍÕÍÕÍÍÍÍÍÍÍÍÃÃÃÍÍÍÍÃÍÃÃÍÃÃÃÍÃÍÃÃÃÃÃÃû»´¥‹‹‘„}„‘«»»»´»Ã»¥^DDDMMDMDD;;R^^}‹—«¥«¥—¥«»»ÃÃÃÃÃÃÃÃÃÃÃÃÃÍÍÍÍÍÍÍÍÍÃÍÕÍÕÕÕÕÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÍÕÕÕÕÕÕÕÝÕÝÕÕÕÕÕÝÕÝÕÝÕÝÝÝÝÝÝåÝåååÝååÝÝåÝåååååååÝååÝÝÝåÝÝÝÝÕÝÕÕÕÕÕÕÕÕÍÕÍÕÍÕÍÍÍÍÍÍÍÍÃÃÃÃÃÍÃÍÍÃÍÃÍÃÍÃÍÍÃÃÃÃÃÃû´—u^lllu‹‘«´»»»»Ãû—YD;;DDDMRRY^l}„„}„—‘—¥¥«´´´»ÃÃÃÃÃÃÍÃÍÃÃÃÃÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÍÕÕÕÕÕÕÕÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÝÕÕÕÝÕÝÕÝÝÝÝÝÝåÝåÝåååÝåÝÝÝåÝååååååÝåÝÝÝåÝÝÝÝÝÕÕÝÕÕÕÕÕÕÍÕÕÍÍÍÍÍÍÍÍÍÍÃÍÃÃÃÃÃÃÃÃÃÍÍÃÃÃÍÃÍÃÃû»»Ã»«}D.;DMl„——´»»ÃÃÍÃô‹RDDMRDMYY^^u‹——‘‘——‹‘‘«««««´´»ÃÃÃÃÍÃÃû»ÃÃÃÃÍÍÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÍÍÕÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝåÝåååÝÝÝåÝååååååÝÝÝÝÝÝÝÝÝÝÝÝÕÝÕÕÕÕÕÕÍÕÍÕÍÍÍÍÍÍÍÍÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÍÃÃÃÍÃÃû»´´´‘M.-$-.Ml‹—´´»ÃÃÃÍû—lRDD;DDDRYuu}„‘—¥—«´«¥‘‘¥¥««´»»Ã»»ÃÃÃÍÃÃÃûÃÃÃÃÍÍÍÍÍÍÍÕÍÕÍÍÕÕÕÍÕÕÍÕÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÝÝÝÝÝÝÝÝÝÝåÝåÝåÝåÝÝÝÝåååååååÝÝÝÝÝÝÝÝÝÝÝÕÝÕÕÕÕÕÍÕÍÕÍÍÍÍÍÍÍÍÍÍÍÃÃÃÃÃÃÍÃÃÃÃÍÃÃÃÃÃÃÃÃû»´«l;$$$$$.Yu}¥´»»»»ÃÍô¥uRD;D;..DR^u}„‘¥¥«´»´´««¥‘¥«´´´»´´»ÃÃÃÃÃÃû»»»ÃÃÍÃÍÍÍÍÍÍÕÕÍÍÍÕÍÕÍÕÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÝÕÕÝÕÕÝÝÝÝÝÝÝÝåÝÝÝåÝåÝÝÝåÝåååååååÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÍÕÕÍÍÍÍÃÍÍÃÍÍÃÃÃÃÃÃÃÃÃÃûÃÃÃÍÃÃÃÃÃÃû»»¥Y-$$$$$-;Y}‘«´»»»ÃÃû¥„YD;DD;;DMYluu}}„—¥«´´´´´´´«¥««´»»´´»»»Ã»ÃÃû»Ã»ÃÃÃÃÍÍÍÍÕÍÕÕÕÍÕÍÍÍÍÍÍÍÃÃÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝåååååÝåÝÝÝÝÝÝÕÝÝÕÕÕÕÕÕÍÕÕÍÍÍÍÃÍÃÃÍÃÍÃÃûÃÍÃÃÃÃÃûÃÃÃÃÃÃÃÃû»´¥M-$$$$--M}—«´»»»»ÃÍô‹^M;.;;;;DM^lllu„‘¥¥«´«´´´´»´´´¥—¥´´»»»Ã»»»ÃÃÃÃÃû»»ÃÃÍÍÍÍÕÍÕÕÍÕÍÍÍÍÍÍÍÍÍÃÍÍÍÍÍÕÕÍÕÍÕÕÕÕÕÝÝÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝåÝÝÝÝÝÝÝåååååÝÝÝÝÝÝÝÝÝÕÝÝÕÕÕÕÕÍÍÍÍÍÍÃÍÃÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃû´—R-$$$$.Y}‘«´´»»ÃÃÃÍô‘lR;..-;;DR^^}‹‘¥¥«««´´»´«´»´»´«—‹‘«´»»»»»»»Ã»ÃÃÃû»»»ÃÍÍÍÍÕÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÍÍÕÕÕÕÕÕÕÝÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝåÝÝÝÝÝÝÝååååÝåÝÝÝÝÝÝÝÝÕÕÕÕÕÕÍÍÍÍÃÍÍÍÍÃÃûÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃûÃÃÃÃÃû´‘D$$$$-;^„‘—«´´»»ÃÍÍÃô„^YD..D;;;MRll‹—««´´´»´´´´´««´«««´¥‘¥«»»´´´´´»»ÃÃûû»»ÃÍÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÝÕÕÝÝÕÕÝÕÝÝÝÝÝÝÝÝÝÝåÝÝÝÝåÝåååÝÝÝÝÝÝÝÝÝÝÝÝÕÝÕÕÕÍÍÍÍÍÍÍÃÍÍÍÃÍÃÃÍÃÍÃÃûÃÃÃÃÃÃÃÍÃÃÃÃÃÃÃô‘D$$$$$-;RRY}„‘¥¥´»ÃÃÍÍÃ¥u^^MMDDDDD;RRl‹‘««´»»»´´´»««´´¥—«´«¥¥¥—¥¥´´«««´»»»ÃÃÃû»ÃÃÍÃÍÍÍÍÍÍÍÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÝÕÕÕÝÝÝÝÝÝÝÝÝÝÝÝåÝÝÝÝåÝåÝååÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÃÍÃÃÍÃÍÃÍÃÃÃÃÃÃÃûÃÃÍÃÃÃÃÃÃÃû‘M-$$$$.;;.;MYl„¥«»ÃÃÍÍë}YDD;DRY^RMD.;MY„—«´»»´»»«¥¥««¥«¥«¥¥¥—‘„„‹‘¥«¥¥««»»ÃÃû»»ÃÃÃÍÍÍÍÍÍÍÍÍÍÃÍÃÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÍÍÕÕÕÕÕÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝåÝåÝååÝåÝÝÝÝÝÝÝÕÕÝÕÕÕÕÕÍÍÍÍÃÃÃÃÃÃÃÃÍÃÍÃÃÃÃÃÃÃÃû»ÃÃÃÍÃÃûû¥M-$-$$$-.DR}¥«»»ÃÍÍÍë‹Y;;.;MRYllll^^^^l}„‹‘¥«´«¥—¥‘———‘———¥—‘‹u}‹‘——¥¥«´»»Ã»»»Ã»ÃÍÍÃÍÍÍÍÃÍÃÍÍÍÍÍÃÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÝÕÕÝÝÝÝÝåÝÝÝåÝÝÝÝÕÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÝÕÕÕÕÕÍÍÍÍÃÃÃÃÍÃÃÃÃÍÃÃÃÃÃÃÃÃÃÃû»ÃÃÍû»´»»¥Y-$$$$$$-;Dl„¥´»»ÃÍÍû«}RD;.;MMDMRYl}‘¥—‘„lM;D^‘‹‘‘‘‘‘‘—‹‹„„‘——¥‹„}‹‘‹‘‘‘¥´«´»»»»´»ÃÃÃÃÍÃÍÍÃÍÃÃÃÃÍÃÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÝÝÕÕÝÕÝÝÝÝåÝåÝÝåÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÝÕÕÕÍÍÍÍÍÍÃÍÃÍÃÃÃÃÃÃÃÃÃûÃÃÃû»ÃÃû»Ãû»´Y-$$$$$$$$$$-.;Rl‘´»ÃÃÍÃû—lRD;.MYYDRYYRR}‘«´«´¥}DMYYYRYY^^uuuu^uu‹‘‘‘‹„}}u}}‹——¥«´´´´´´»ÃÃÃÃÍÃÃÍÃÃÍÍÃÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÝÝÕÝÝåÝåÝåÝÝÝåÝÝÝÝÝÝåÝÝÝÝÝÝÝÕÕÕÕÕÕÕÍÍÕÕÍÍÍÍÍÍÍÍÃÍÃÃÃûûû»ÃÃûûÃûûû´}--$$$$$$$$$$$$Du—´»ÃÃÃÍô—uRRRDMYYY^}‹„‹‹‘¥¥««¥‹RMMMD;;D;..;DRMMY^u}‹‹}l^^l^u„‹‘‘—¥«««´´»»ÃÃÃÃÃÃÍÍÃÍÍÍÃÍÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÝÕÝÝÝÝåÝåÝÝÝÝÝÝÝÝÝÝÝåÝÝÝÝÝÝÕÍÕÕÕÕÕÕÍÍÕÍÕÍÍÍÍÃÍÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃûû»‘.-$$$$$$$$-Ml‘«´ÃÍÃÍô‘Y;DMMR^^lu‹—«´´´´´´«—}^YYMD;...$$$$$.DDDM^^YlYY^l^u}}uuu‹——«««´»»ÃÃÃÃÍÃÃÍÃÃÍÍÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÝÕÝÝÝÝÝåÝÝåÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÍÍÕÕÍÍÍÍÍÍÍÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃû»»»—D$$$$$$$$$--;u—¥´ÃÃÍÃëuYDDRRu„„‘—´«´´´´´´´´«—‘„^R;;---$-$$$$--;;DMRYYYYuu^^^^^u}‹——¥«»»ÃÃÃÃÃÍÃÃÍÃÍÍÍÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÝÕÝÝÝÝåÝÝåÝÝÝÝÝÝÕÝÝÝÝÝÕÕÝÕÝÕÕÕÕÕÕÍÕÍÕÍÍÍÍÍÍÍÍÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃû»Ã»Ã»»»¥M$$-$$$$$-M„¥¥´ÃÃÃÍ»«uYRMYu‘—¥‘—¥¥«¥—¥—«¥«¥——„l^RM;..-$$$$$$..DMDDYl^RMMDDMRl‹‘¥«´»»»ÃÃÃÃÃÃÍÍÃÍÍÍÍÍÍÍÍÍÕÍÍÕÍÕÕÕÝÕÕÕÝÝÝÝåÝÝÝÝÝÝÝÝÝÕÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÍÍÍÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃû»»Ãû´¥Y$$$$$$$$$Du‘«»ÃÃÃÃ×Y;DY^^l^RYl‘—¥¥—«´»»»´¥—‹u^^R;;.-$$$$$---.D;D.D....;Dl„—«»»»ÃÃÃÃÃÍÃÃÍÍÍÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÝÕÝÕÝÝÝÝÝÝÝÝÝÝÝÕÕÝÕÝÝÕÝÕÕÕÕÕÕÕÕÕÕÍÕÍÍÍÍÃÍÍÃÍÍÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃû»´u$$$$$-Dl‹¥´ÃÍÍû‘M;M^R--Ml‹——««´´»»Ã»»´«—‹„}^MM;;-$-$$-$..;---.-;M}—«´»»»ÃÃÃÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÝÕÝÝÝÝåÝåÝÝÝÝÝÕÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÕÍÕÍÍÍÍÃÃÃÃÃÃÃÃÃÃûÃû»ÃÃÃÃÃÃû»»»—;$$$$.Ru„«´ÃÃÃë‹RDRYRD^‹—´«¥«´´»»Ã»»´«¥‘„}uRMD..-$$$$$$$$$$$$$$$;l‹«´»ÃÃÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÝÝÝÝÝÝåÝÝÝÝÕÕÝÕÝÝÕÕÕÝÕÕÕÕÕÕÍÕÕÍÍÍÍÍÍÃÍÃÃÃÍÃû»ÃÃû»»ÃÃÃÃÃûÃû»¥Y$$$$.D^„¥´»Ãû´—}^u}‹‘‘¥¥¥¥««´´´»»»´´«—„}}lYRRM.-$$$$$;^—«»»»ÃÃÃÃÃÍÃÍÃÍÍÍÍÍÍÃÍÕÍÕÍÕÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÝÕÕÕÝÕÕÕÕÕÕÍÕÍÍÍÍÍÍÍÃÍÃÃÃÃÃÃû»ÃÃÃûÃÃû»»ÃÃû»«}-$$-;}¥»»Ãû»¥„l}„‘‹u}„‘¥´´»»»Ã»Ã´«¥—‹„uYMMD;;.-$$$-.R‹«»»ÃÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÍÕÕÝÝÝÝÝÝÝÝÝÝÝÕÕÕÕÕÝÝÕÕÝÕÕÕÕÕÕÍÕÍÍÍÍÍÍÍÃÃÃÍÃÃÃÃÃÃÃÃûÃÃÃÃû»ÃÃÃô—D$-D}¥´ÃÃû´‘}RR^^l^‹—««´»»»ÃÃÃû´¥‹„}ulM;..--$$$$$R‘´»»»»ÃÃÃÃÍÃÍÍÍÍÍÍÍÍÕÍÕÕÍÕÕÕÕÕÝÕÝÝÝÝÝÝÝÝÝÕÕÕÕÕÕÝÕÕÕÕÕÕÕÕÕÕÍÍÍÍÍÍÍÍÍÃÃÃÍÃÃÍÃÃÃûÃûÃÃÃÃÃÃÃÃû«Y$$;Y„¥´»»Ã»«‹uYDMl}}„‹‹—«´´´´»»»´´«¥„uuRD..;-$-$$$u—´»»ÃÃÃÃÃÍÃÍÍÍÍÍÍÍÕÍÍÍÍÍÍÕÕÕÕÕÝÕÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÕÍÍÍÍÍÍÃÍÍÃÃÃÃÃÃÃÃÃÃÃûÃûÃûÃÃÃû»´„$$Dl‹«´»Ãû´¥‘lRYMMRlu„‹——¥—¥¥¥¥«¥¥—‘}lYD;;-$-$$D‹¥´»»ÃÃÃÃÃÃÃÍÍÃÍÍÍÍÍÕÍÍÕÍÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝÕÕÕÍÕÕÕÕÕÕÝÕÕÍÕÕÍÍÍÍÍÃÃÃÃÍÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃû´¥M$$$Dl‹¥´»Ãû»«‘^R;;MYuluu„‘¥¥¥«´««´´¥‘‹}^D.;-$-^—«´»»ÃÃÃÃÍÃÃÃÍÍÍÍÍÍÕÍÕÍÕÍÕÕÕÕÝÕÝÝÝÝÝÝÝÝÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÍÍÍÍÃÍÍÃÃÃÍÃûÃÃÃÃÃÃÃÍÃÃÍÃÃÃû´«^$$$-M„—¥´»Ãû´¥‘u^RYDDR^‹—««´´»´»»»´´«‘„ulMD.-$$D‹«´´»ÃÃÃÍÃÍÃÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÕÕÍÍÕÕÕÕÕÕÕÕÕÕÕÍÍÍÍÍÍÍÍÍÍÃÃÃÃÃÃÃÃÃûÃÃÃÃÃÃÃûÃô´„--.Dl‹¥´»ÃÃû«‘}^DMMR^u„‘—¥«´»»Ã»»´´¥‹lYD.D...-$$.u—«´»ÃÃÃÍÍÃÍÃÍÍÍÍÍÍÕÕÍÕÕÕÕÕÝÕÕÝÝÝÝÝÝÝÝÝÝÕÍÕÕÕÕÕÕÕÕÕÕÕÕÍÍÍÍÍÃÍÍÍÃÍÃÍÃÃÃÃÍÃûÃÃÃÃÃÃÃÃÃû´‘;$$.;R„«´»Ãû»´—lYD.DDMMRu}‹—«´»»»´´´—‹uY;--$--$-$$^—««»»ÃÃÃÃÍÃÍÃÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÝÕÝÝÝÝÝÝÝÕÕÍÍÕÕÕÕÕÕÍÕÕÍÍÍÍÍÍÍÃÍÃÍÃÍÃÍÃÍÃÍÃÍ»ÃÃÃÃÃÃÃÃÃû»«Y$$$.DY„«´´»Ãû»«uYD;;;;DRYl}u„—¥´««¥—‹u^M.-$$$$$$D‹¥«´»ÃÃÍÃÃÍÃÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÕÕÕÍÕÕÕÕÕÕÕÍÍÍÕÍÍÍÍÃÍÃÃÃÍÃÍÍÃÍÍÃÃÃÃÃÃÃÃÃûÃûô„$$$D^u‘´»»Ã»»´¥„uYYR^luul^lu‹‘—««¥‘‘}YYM.$$$$$l—«´»ÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÍÕÍÕÕÕÝÕÝÕÝÝÕÝÝÝÝÝÕÕÍÕÍÕÕÕÕÕÕÕÕÍÍÍÍÍÃÍûÍÍÍÍÃÃÃÃÃÃÃûÃÃÃû»»»»»»¥D$-Ru‹¥´»»»»»´¥‘—‘‹‹‹—¥¥——¥«««´»´´«¥‘‹„}YM.-$ M‘¥«´»ÃÃÃÃÍÃÍÍÍÍÍÍÍÕÍÕÕÕÕÕÝÕÝÝÝÝÝÝÝÝÝÝÝÕÍÕÕÕÕÍÕÕÍÍÍÍÍÃÍÍÍÃÍÃÃÍÍÃÃÃÍÃÍÃÃû»»Ãû»»»»»«l$$-DRl„—«´»Ã»»»»´«¥¥¥««´´´»»»»»»»»»»»´´´««¥¥‘„lD-   .‹¥¥´»ÃÃÃÍÃÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÝÝÝÝÝÝÝÝÝÝÝÕÕÍÍÕÍÍÍÕÍÍÍÍÍÍÍÍÃÍÃÃÃÍÃÍÃÃÃÃÃÃû»´»»»»»»»´´‘; -DRu‹—«´»»Ã»»»´«¥«´´´»»»»»»»»»»»»»»»»´»´´´´««—„^D.$  -l—¥´´ÃÃÃÃÃÃÍÍÍÍÍÍÍÍÕÕÕÍÕÕÕÝÕÝÝÝÕÝÝÝÝÝÝÕÍÍÕÍÕÍÍÕÍÍÍÍÍÍÍÃÍÃÍÃÃÃÃÃÃÍÃÃÃû»»»Ã»»´´´»´¥Y $.Rl„—««´»»»»»»´´´´»´»»»»»»»»»Ã»»»»»Ã»»»»»´´´´´¥¥—‹lM-    $R‘¥«´»ÃÃÃÃÃÃÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÝÕÝÝÕÝÝÝÝÝÝÕÍÍÍÍÍÍÍÍÍÍÍÍÃÍÃÃÃÃÍÃÃÃÃÃÃÃÃû»»´´Ã»»»´´»´«‹$    $$-DY^„‘—«´«´»»»»»»»»»»»»»»»»»»Ã»»»»»»»»Ã»»»»»´»´´´««««¥—‹Y.    D‹¥««»ÃÃÃÃÃÃÍÍÍÍÍÍÍÍÕÕÍÕÕÝÝÕÝÕÕÝÝÝÝÝÝÝÕÍÍÍÍÍÍÍÍÍÍÍÍÃÍÃÃÃÍÃÃÃÃÃÃÃÃÃû»»´´»Ã»»´´´«—Y   $.;DRu„‘—¥«´´´»´´»»»»»»»´»»»»»»»»»»»´»»»»»»»»»»»»»´´´´´´´«««—‘^;$   D„—¥«´»»ÃÃÍÃÍÃÍÃÍÍÍÕÕÍÕÕÕÕÕÕÕÝÕÝÝÝÝÝÝÝÕÍÍÍÕÍÍÍÍÃÃÍÍÍÍûÃÃÃÃÃÃÃÃÃÃÃûÃûû»Ã»»´´´‹$   -;Ylu„‘¥¥¥«´´»»»»»»»»»»»´´»»»»»Ã»»»»»»»»»»»»»»»´»»´»´´´´´´´«´«¥¥‘};   ;„—¥¥«´»ÃÃÃÍÃÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÝÝÝÝÝÝÕÕÃÍÍÍÍÍÍÍÃÍÃÍÃÍÃÃÃÃÃÃÃÃûÃÃÃÃûû»»»»»»´´«Y  -Mu‹‹—¥¥¥««´´´»»»»´»»»»´´´´»»»»»»»»»»»»»»»»»»»´´»»»´´´´´´´´´«´«¥¥¥‘‹R$  .„——¥«´»»ÃÃÃÍÍÍÍÕÍÕÍÕÍÕÕÕÕÕÕÕÝÕÝÝÝÝÝÝÝÕÍÍÍÍÍÍÍÍÍÃÃÃÍÍÍÃÃÃûÃÃûÃÃÃû»»»»»»»»»»´—.   $D^„‹¥¥«««««´´»»»»´»´»»»»»»»»»´»»»»»»»»»»»»»»»»»´»»»»´´´´´´´´´««´««¥——}R-  -l———«´´»ÃÃÃÃÍÍÍÍÍÍÕÍÕÕÕÕÕÕÝÕÝÝÝÝÝÝÝÝÕÕÍÍÕÍÕÍÃÃÍÍÃÍÍÍÍÃÃÃÃÃÃÃÃÃÃÃÃû»»»»´»»»»»«}   -Yu‹‘¥««´´´´´´´»´»»´»»»»»´»»»»»»»»»»»»»»»´´»»»»»»»´´´´´´´´´´´´´«´´«««¥—‹uR- Y‘—‘¥¥«»ÃÃÃÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÝÕÕÝÝÝÝÝÝÕÕÍÍÍÍÍÍÃÍÍÍÃÍÍÍÍÍÃÃûÃÃÃÃÃÃÃû»»»»»»»»»´«R  -Mu‹—¥««´´´´´´´»´´»´»»»´»»»»´»»»»»»»´»»´»´»´´»»´»´´´´««´´´´´«´´«´´««««¥¥‘‹uD$ M‹‘———«»ÃÃÃÃÍÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÝÝÝÝÕÕÕÍÍÍÍÍÃÍÍÍÍÃÍÃÍÍÃÍÃÃÃÃÃÃÃÃÃû»»»´´»»»»»´‘. ;Y}‘—¥«««´´«´´´´´´´´´´»»»»»»´»»»´´´´´«´»»´´´»´»´´´´´´´´«´«´´´«´««««««««««—‘„Y.    D}‘——¥¥«»»ÃÃÃÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÝÕÝÕÕÍÍÍÍÍÍÍÍÍÃÃÍÃÍÃû»ÃÃÍÃÃû»Ã»»Ã»»´»»»»»«„$ -M^}‹‘¥¥«««´´´´´´´´´´´«´»»»»»´´´»´´´´´»´´´»´´´´´´´´´«´´´«´´´««««´«««¥«««««¥‘‹}^M$ M}‹‘—¥¥«»»ÃÃÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÝÕÝÝÕÕÕÝÕÕÍÍÍÍÍÍÍÍÍÍÃÃÃÍÃÃÃÃÃÃÃÃÃÃÃû»»»»»»»»»´´«l .Yu„‘——¥¥«««´«´«´´´´´´´´»»»»»»»»´»´´´´´»´´»´´´´´´´´´´´´´«´««««««««««««««¥««¥—‘}YM-   Dl}„‹¥—¥«´ÃÃÃÍÃÍÃÍÍÕÕÕÕÝÕÕÕÕÕÝÕÕÕÕÝÕÕÕÃÍÍÍÍÍÍÍûÃÃÍÃÍÃÃÍÃÃÃÃÍÃÃÃû»»»»»»»»´´¥; ;^u„‘——¥¥«´´´´««´««´«´´´´´»»»´´»´´´´´´´´´´»´´´´´«´«´´´´´´««´««´««««««««««««¥¥—‘„uM$   ;Ylu‹¥¥¥—¥»ÃÃÃÍÃÍÍÕÕÕÕÕÕÕÕÕÕÝÕÝÝÕÝÕÝÕÕÍÃÍÍÍÍÍÍ»»ÃÃÍÍÃÃÍÃÃÃÃÃÃÃÃÍû»»»´´»»»´´—-  -Yu„‘—¥¥¥¥«´´´´´´´««««´´´´´´´´´´´´´´´´´´´´´»´´´´«´´«´´´´´´´«««««««««««¥¥«¥«¥¥¥—‘„uY- .^YY}‘—¥——»»ÃÃÃÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÝÕÕÝÕÕÕÃÍÍÍÍÃÃÃÃÃÍÃÍÍÃÍ»ÃÃÃÃÃÃÃÃûû»»´´´»»´«‹$  ;Y}‹—¥—¥¥¥¥«««´«´«´««´´´«»»´´´´´´´´´´´´´´´´»´´«´«´««´«´´««´«««««««¥¥«¥««¥¥¥¥¥¥‘‘}lM-  DRDRl„‘¥—‘«»ÃÃÍÍÍÍÕÕÍÍÕÕÕÕÝÕÕÕÕÕÝÕÝÕÕÕÃÍÃÍÍÍÃÍÃÍÃÍÃÃÃÃÍÃÃÃû»Ã»ÃÃû»»»´´»´´«}  $DY}‹‘——¥«¥««««´««´´´´´´´´´´´´»´´´´´´´´´´´´´´´´´«´««¥«´´´´««««««««««««¥«««¥¥¥¥——‘„^D-  $DM.MR}‘¥‹}¥»»ÃÃÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÝÕÝÕÕÝÕÕÍÍÍÍÍÍÍÃÍÍÃÃÃÃÍÃÃÃÃÃÃûÃÃû»»»»»´´´´´¥^ -DRu„‘‘—¥««´««´«´«´´´´´»´´´´´´´´´´´´´´´´´´´´´´´«««¥—««´´««««««««««««««¥«««¥¥«¥———‹lM.$  MD-..Y‹—‘„—»ÃÃÃÃÍÍÍÕÕÍÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÍÍÍÍÍÍÍÃÃÃÃÃÃÃÃÃÃÃÃÍÃÃûû»»»»»»´´´´´¥R $;Ml}‹—‘—««««´«´««´«´´´»´´´´´««´´´´´´»´´´´´´´´´´««««««´´«««´«´««««««««««««¥¥«¥¥——‘uR;$    $;.$$$D}‹‹‹¥´»ÃÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÝÕÝÕÕÕÕÍÍÍÍÍÍÃÍÍÍÍÃûÃÃÍÍÃÃÃûû»Ã»»»»»´´´´«‘;  .Ru}‹‘—¥¥¥«««««´´«´´´´´´´´´«««´´´´´´´»´´´´´´´«´«´´´´«««´´´««´«´«´««´«¥««««¥¥«¥¥¥‘„YD-   -.-$;u‹‘‘¥´»ÃÃÃÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÝÝÕÕÕÕÕÍÍÍÍÍÍÍÍÍÃÍÃÍÃÃÍÃû»Ã»Ã»»»»»»»»»´´´««‹.   ;MRu‹——¥¥«««««««´´´´´´´«´««´´´´´´«´´´´´´´´´´´«««´«´´´«´«´´«´´«´««««««««««««¥¥¥¥¥—‘„Y;$   $$-^‹‹‘¥´ÃÃÃÍÃÍÍÍÍÕÕÍÍÕÕÕÕÕÝÕÕÕÕÕÕÕÍÍÍÍÍÍÍÍÃÍÃÃÃÍÃÃÃÃÃÃÃû»»»»»»»´»´´´«¥„.  .DR}‹‘———«¥««««««´´´´´´´«´´´´´´´´´´´´´´´´´´´´´´´´´´´««´´«´´´«´´´«««««««¥¥«««¥¥«¥——‘uR$   -^‹‘‘¥´»ÃÃÃÃÍÍÍÍÕÍÕÍÍÕÕÕÕÕÝÕÕÕÕÕÕÍÃÍÍÍÍÍÍÃÍÃÃÃÃÃÃÍÃÃÃÃû»´»´»»´»´»´´«¥}-  -;Ml‹‘——¥¥«¥«´´´«´´´´´´´«´´´´´´»´´´´´´´´´´´´´´««´´´«««««««««´«´´«««´««««««««««¥«¥——„Y.$  $-R„‘‘¥´»»ÃÍÃÍÍÍÍÕÍÍÕÕÍÕÕÝÕÕÕÕÕÕÕÕÍÍÍÍÍÍÃÍûÃÃÃÃÃÃÃÍ»Ãû»»»»´»´»»»´´´¥‘l $.Ml„——¥¥¥¥¥«´««´´´´´´´«´´´´´´´´´´´´´«´´´´«´«««´´´«««««««««´´´´«´´´´´«««««««««¥¥«¥¥‹uM-  $-..$$-R}‹„‹«´»ÃÃÍÍÃÍÍÍÕÕÕÕÕÕÕÕÕÝÕÕÕÕÕÕÃÍÍÍÍÍÍÍÍ»»»ÃÃÍÃû»»»»´´»»´»´»´»´´´«‘D ;Rl„‘—¥¥¥¥¥´«´««´«´««««´´´´»´»´´´´´´´´«««´««´«´««´«¥¥««««´´«´´´´«´´´««´«««««««¥«¥¥‘„Y;$ $;MR^lR.$R„‹u„—´»»ÃÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÍÃÍÍÍÃÃÍÃÃÃûͻû»ÃûÃû»»´´´´´»»´´«}- .Y^„—¥—«¥«««««««««««««´´´´´´´´´´´´´«´´««««««´´«««´«¥««¥¥«««««««´««´««««´««««««¥«¥¥—‘uM- $.DDRuuu}}l;$-M^„„}‹«»»ÃÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÍÃÍÍÍÍÃÃÃÃÃÃÃÃû»ÃÃÃÃÃÃô»»´´´»»»´´««l $;R^}‘—¥¥¥««««««««««««´¥´«««´´´´´´´´´«´«««««´«««¥««««««¥¥¥««¥¥««««´´«´««´«««—««««¥¥¥—‹l;$$$$$DRRYluu}„„„u;$-;Y„‘‹‹—»»ÃÃÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÍÍÍÍÍÃÃÃÃÃÍû»»»ÃÃÃÃÃû´»»´´»´»»»´´¥Y .M^}„—¥¥¥«««««¥¥«««««´««««´«´´´´´´´´´´«««««««««««¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥««««««´«««¥««¥¥¥¥¥—‘}M-$$$$-.;R^YYu}uu}uu}uR--.l‹—‘„‘´»ÃÃÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÍÃÍÃÃÃÃÃÍÃÃÃÃÃÃÃÃͻûû»»»»»´´»»´´«—D   -MY}‹‘—¥¥¥¥«««¥¥««««««««««««´´´´««´«´«««««««¥¥¥¥—¥—¥—¥¥—¥———¥———‘¥¥¥¥¥¥«««´««««¥¥¥¥¥—„lD.-$$$-.;MR^^^lu}l}u^^YYR-$Du‘—‘„}«»ÃÃÍÍÍÃÍÍÕÍÕÍÕÕÕÕÝÕÕÝÕÕÕÃÃÃÃÍÃÃÍÍÃÃûÃû»Ãû»Ã»»»»»»»´»»´««‘.  $DYu‘—¥—¥¥¥«¥¥¥¥¥«««««««««««««´«««««««««¥¥¥¥¥———¥———‘‹‹‹‹}}‹„„‹‘‘————‘——¥««´«««¥¥¥¥¥—‘„^M;.-.;DRYRYYYllll^R;..--$M}‘‘‘„}¥»ÃÃÃÍÃÍÍÍÍÕÕÕÕÕÕÕÝÕÕÝÕÕÍÃÃÃÃÍÍÍÍÃÃÃÃÃûÃûû»»´´»»´»»´»»´´«„$    $MYl‹‘‘—¥¥—«¥¥¥¥¥¥¥¥¥¥«¥«««««««««´««««¥«¥¥¥¥¥————‘„}l^YYR;;YR^l„„„„‹„‘‹‘—««««¥—¥¥«««¥—‘„l^YDMMY^lYYD$;Y^^R;$$$$$.}‘‘—„l‘´ÃÃÍÃÃÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕ»ÃÍÍÍÍÃÃÍÃÃû»Ã»ÃÃû»»´»»»»»´´´´´´¥^   DYu‹‹‘——¥¥¥—¥—¥—¥—¥¥—¥¥¥¥¥¥«««««««««¥¥«¥¥¥¥——‘}lRM;$$$--;DMR^uuluu}‘‘‘¥¥¥«««¥¥««««¥——„u^uY^llu^M-$.MD.$-u‘‹‹„^‘´»ÃÃûÃÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÃÃÃÃÃÃÃÍÃûÃÃÃÃÃû»»»»´´»»»»´´´«´«¥Y  ;l}„‘—‘————¥—————‘——¥———¥¥¥««««¥«««¥«¥¥———‘‹}^;$$;RYl}}‹‹‘‘‘„„‘¥——¥¥««««««´«««¥—‹}lul„„„}Y--.$$^‹}}}Y‹´»ÃÃûÃÍÍÍÕÕÍÕÕÕÕÝÕÕÕÕÕÍûÃÃÃÃÃÃÍÃÃÃû»Ã»»»Ã»»»´»»»»»»´«««—^    Dl}„}}u}}}‹‹‹‹„‹‘‘‘‘‘‘————¥¥¥¥«««««—¥—¥‘‹„}^M;$-;DRlu}‹‹‘——¥——¥—¥———¥«««««´««´«««¥„}ll}‘‘‹„R$$$$Y„ullRu«»ÃÃÃÃÍÍÍÕÍÕÕÕÕÕÕÕÝÕÕÕÕÕûÃÃÃÃÃÃÃûÃÃûûû»»»´´´»»»»´»´««¥Y   ;uuYM;-DDRMDMMRYllu„}l„‘‘‘‘—¥¥—¥¥¥¥—¥—‹„l^^R;..;D;DMRY^u}}„‹‹‘‘——————¥¥¥—¥««««´«´«««¥¥‘}uu„‘‘‹}M- $YlRY^Mu«»ÃÃÃÍÃÍÍÍÍÕÕÕÕÕÕÕÕÝÕÝÕÕÃÃÃÍÍÃÃÃÃÃÃÃÃûÃÃÃû»´»´´´´´»»´´´´¥l   ;uR--$--$-$$$;D;RY^uu}‘——¥¥¥—¥¥—‘}YRMRDRRRRMD;;;DMRR^lu}„„‹‘——¥—¥‘—¥«««´«««««««¥—„}„‹‘‘‹}R; $MR;;MD}«´»ÃÍÃÃÍÍÍÍÍÕÕÕÕÕÝÕÕÕÕÕÕÃÃÍÃÃÃÃÃûÃÃÃÃÃûû»»´»´«¥«´´´´´´´«„-   -Y;$$$ $.MR^‹——¥—¥¥¥¥—‘}lRR^^^^^YM.$$-.;;Rl}‹‹——‘¥¥¥¥««««««««¥«¥‹}„‘‘‘„^RD- $$-$$.;}«´»ÃÃÃÃÍÍÍÍÕÕÕÕÕÕÝÝÕÕÕÕÕÃÃÃÃû»Ã»Ã»ÃÃÃûÃû»»´´««´´´´´´´´´«‘.   -Y;$$$$.DY‹‘‘¥¥—¥¥¥—‹}lluuu^lY;- $^M-RM.-$-;Ml‹‘——«¥«««««««««¥¥—‘}‹‹‹‘}Y;;-$$--„«´ÃÃÃÃÍÍÍÍÕÕÕÕÕÕÕÝÕÕÕÕÕջûû»»»Ã»Ã»ÃûÃû»»´´´»´»»»»»»»´´´‘R     YD$$$$.DMMYYRRMD-$$$;l„‹——¥¥¥——‘‹„„}}}l^D.--.}^M„‹}^D..;Dl„‘—¥¥«««´«««««««¥‘„}„„„uY;;.$$.‹«´»ÃÍÃÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕ»»ÃÃûÃÃûÃûûÃû»»«»»»´»´»»»»»´»´¥}-       $RD--.;RYYY^lRRD.$$$-Du‹—¥—¥¥¥——‘‘‹}uulY.;;Y...R‘——‹u^luuu}‹¥¥«««¥«««««««««¥‹uu}}„lYM.$.$$;‘«´»»ÃÃÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÃû»Ã»ÃÃûÃûÃÃû»»»»»»´»´»»»»»´´´´¥‹;    $RM.DMYlRYRM;- .$$.^‹‘—¥¥¥¥¥¥——‘‹}uuMDDYlM$$-l———‘‹‘‹‘‘‘‹—¥¥¥¥«¥«««««««««¥‘uu}„‹‹uR; $.D.$$D‹´´»ÃÃÍÍÍÍÍÕÕÍÕÕÕÕÕÕÝÕÕÕջûÃÃÃÃÃû»Ãû»»»Ã»»»´»´»´»»»»´´´´«¥‹M    YYRMMYRM.$ .R^^;$-Y‹—¥—¥«¥¥¥¥‘‘‘}}u^YluulD$R‘¥¥—¥———¥——¥¥¥««««««««««««««¥—„„‹‘——‘lD$$DD$-Du¥´»ÃÃÍÍÍÍÍÕÍÕÍÍÕÕÕÕÕÝÕÕÕ»»ÃûÃÃÃû»»Ã»´ÃÃÃû´´´´»»»´´´´´´´«¥‘M      ^^YMDD.$   Y„}‹l.$$-M„—¥¥¥¥««¥—¥—‘‹‹„}l}llu^YDDl‘¥¥¥¥¥———¥¥—¥¥««««««««««¥¥«´¥——‘„„‘—¥—„R--..$.Dl¥´ÃÃÃÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕ»»ÃÃÃÃÃÃû»»»»»»Ãû»»»´»»»»´»»»»´´««‹D    $^lYMD;- $ -MY‹‹};$$Du‘¥¥¥¥¥¥¥¥¥——‘‘‘}ul^l}}}„‹‘—¥¥—¥¥¥—¥¥¥¥¥««´´´¥««´«««¥««««¥‘‘—¥¥—¥‘u;$----;^^¥´»ÃÍÍÍÍÍÍÕÍÕÕÕÕÕÝÕÕÝÕÕÕ»ÃûÃûÃÃû»Ã»Ãû»Ã»´»»»»»´´´»»´»´´¥‹D    ^uYRD.$ ;$ R‘‘„^$$;u‘—¥¥¥¥¥¥¥—¥—‘‘‹‹„}uuu}}„‹‘————¥¥¥¥—«¥«««´«««««´´««««««««¥¥—¥¥¥¥¥—„M$$$$.^}^‘»ÃÃÃÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÝÕÕÃû»ÃÃÃÍÃû´´»»»»»»»»´´´´´´´´»»»´´«¥‹;   $Yu^RD.$$$.; $„‘‘‹^-$-^‘—¥¥¥¥¥¥—¥———‹‘‹„ulllu}„‹——¥¥¥¥¥«—¥¥¥««««´«´´««´«««««««««¥—¥««««¥‹^;.Yuu^‘«»ÃÍÍÍÍÍÍÍÕÕÕÕÕÕÕÝÕÕÕÕÕÃÃÃÃÍÍÃÃÃÃû»»»»»»»»»»»´«´´´»»»´»´´¥„;    ^uu^RM-$-DR^R- -l‹‘‘‹lMD;$$l‘¥—¥¥¥¥¥¥¥—¥——¥‘‘„ul^uu„„‘‘‘—¥¥«««««««««´´´««««««««««««¥¥—«¥««««——‹^;^u„}u‘´ÃÃÍÍÍÕÍÕÕÕÕÕÕÕÕÕÝÕÝÕÕÕ»ÃÃÃÍÃÍÃÃÃÃÃûû»»»»»»´´´´´´»»»´´´«—‘M   ^„ul^R;..;^}}}l^Yl}‹‹‹‹}u^R;$l——¥¥¥¥«¥¥¥«—¥¥¥——„‹„}lu}}‹‘—¥¥¥«««««««««««««´«´««««««««««««¥««««¥—‘l$$;^}}„u}—´ÃÃÍÍÍÍÕÕÕÕÕÕÕÕÕÝÕÕÕÝÕÕÃÃÃÃÃÃÍÃÍÃÃÃÃÃÃÃÃÃû»»´´´»«´´»»´´«««—^   ^„}uul^^RDYu„„}}}„}}„„„ulu^R-$u—¥¥¥—¥¥¥«¥¥¥—¥¥¥——‘‘‹„„‹‘—¥¥«««««««««««««««´«´«««¥«««««««««««««´«¥‘u-;luu}}u—»ÃÃÍÍÕÍÕÕÍÕÕÕÕÕÕÝÕÝÕÕÕÕÃÃÃÃÃÃÃÍÍÃÃÃÃÃûÃû»»»´»»´´´´»»´´«««¥}$  Y„}}}„}u^MDYuu}}}‹„}„„„}}„}^.D}—¥—¥¥¥¥¥¥¥¥¥¥¥—¥¥¥——‘‘——¥«¥«´´´««««««««««¥´««««««¥««««««««««««««´«—„.;lluuul¥»ÃÍÍÍÍÕÍÕÍÕÕÕÕÕÕÝÕÕÕÕÕÕÃÃÃÃÍÍÃÍÃÃÃÃÃÃû»»»»»»»»»»»»»»»»´´´«¥„.  M}‹‹‹‹„}u^RMYl}u„„‹„‹‹‹‹‘‹„lD^‹—¥¥¥¥¥¥«¥«««««¥¥¥¥¥¥———¥¥¥«««´«««´«¥«««««««««««««««««««´«´«««´´´«¥¥‹;$Yl^uuR^¥»ÃÃÍÍÍÍÕÍÕÕÕÕÕÝÝÕÕÕÕÕÕÕÃÃÍÃÍÍÍÍÃÃÍû»Ãû»´»»»»»»Ãû»»»´»´»´¥‘M   M„‹‘‘—‘‘‹}lMY^ul}}„„‹‹‘‘‘‹„ul}‹—¥¥¥¥¥¥¥¥««««««««««¥—¥¥¥¥¥«´««««««««««´«««««««´«««««««´´´´«´´´´´´«¥‹.-RRRYYMl«ÃÃÍÍÍÍÍÕÍÕÕÕÕÕÕÝÕÝÕÝÕÕÕ»ÃÃÍÍÍÍÍÍÍÍÍ»ÃÃû»»»»»»»Ã»»»»»»»´´´««—u$   D}‹‘—«¥——‘‹„}}}}„‹‘‘‘—‘‘‘‹„„}„‹—¥¥«¥¥¥¥¥¥««¥««««««¥«¥¥««¥¥««´««««««´«´««««´««´««««´´´´´´«´´´´´´««¥}$$--.;D;„´ÃÃÍÍÃÍÍÍÍÍÕÕÕÕÕÕÝÕÝÕÝÕÕÃÃÍÍÍÍÍÍÍÍÍÃÃÃû»»»»Ã»»Ã»Ã»»»´´«´´´´«¥‹;  -u‹—¥¥¥¥¥—¥—‘‹‘—‘————‘‘‘‹‹‹‹„}‹¥¥««««¥«««««¥«¥««««««««¥¥«««´«´«««´««´´´´´´«¥««««´´«´«´´«´´«´´´´««—Y$$-$.M—»ÃÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÃÃÍÍÍÍÍÍÍÍÃÃÍÃÃû»»»»´´»»»»»»´´´´»´´««‘l$    ^‹‘¥—¥¥¥¥¥¥¥—¥¥¥¥«¥——¥‘—‘‘‘‹„‘¥¥¥«««¥«««««¥«¥««««¥«¥«««««««««««´«´´«´´´´«««««««««««´´´´´´´´´´´´«—;$$$.}´»ÃÃÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÃÃÍÍÍÍÍÍÍÍÃÃÃÍÃûÃô»»´»»´»´´´´»´´´´««¥‹M   ^„‘—¥¥¥¥¥¥¥«¥¥¥¥¥¥——¥——¥——‘„„‘—¥¥«««¥««««¥«¥«¥««««««««««««««««««´´´´´´«´«««´«´««««««´´«´´´»´´´««‹-$$M‘´»ÃÃÍÃÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÃÍÍÍÍÕÍÍÍÍÍÃÃÃÃÃû»»»»»»Ã»»´»´»»»´´´´«¥—}-   D}‘¥«¥¥¥«¥««««¥—¥¥¥¥¥¥—¥—‘‹}„——¥¥«««¥««««¥¥«««««´«´«««««««««´««´´´´«´´´´´««««´«´«´´´´´«´«´»´´´«¥u$$-u¥´ÃÍÍÍÃÍÍÍÕÕÕÕÕÕÕÍÕÕÕÕÕÕÕÕÃÃÍÍÍÍÍÍÕÍÍÃÍÃûÍÃÃû»»»Ã»»»Ã»»´»»´«´´´¥‘Y   -u‹—¥¥««¥¥¥¥««««««¥¥¥¥—¥——„}‹—¥¥¥««««««««««¥«««««´««««««««««««´«´´´«´´´´´«´«´««««««´´´´«´´»´´´«‘;$M—´»ÃÃÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕÃÃÍÍÍÍÍÍÍÍÍÍÃÃÃÃÃÃÃû»»»ÃÃû»»»´»´´´´´´«—‹R  ^„‘—¥¥¥¥««¥«««««¥¥¥¥¥¥——‘ul‹—¥¥¥«¥¥««««««««««¥««««««««««««««´´´´´«´´´´´´´´««««¥´«««´«´«««´´«¥¥l$$l«´»ÃÃÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕÝÕÕÃÃÃÃÍÍÍÕÍÍÃÃÍÍÃÃÍÃûÃû»Ã»»»»»»Ã»»»»´´´´«¥„Y$    M}‘———¥¥¥««««««««¥¥¥¥¥——‹^u‘¥¥¥¥««««¥¥¥«—¥«««¥««««««´«¥¥«««´´´´´´´´«´«´««´«´««´´´«´´´««‘‘¥¥¥«„$$u«»ÃÃÍÍÍÍÍÍÕÍÕÕÕÕÕÕÍÕÕÕÕÝÕÕÕÃÃÃÍÍÍÍÍÕÍÍÍÃÃÃÃÃÃÃÃÃû»Ãû»»»»»»´»»´´´´«¥—‘u.   .l}‹‘‘¥¥««««««««««¥¥¥¥¥—„^„‘—¥¥¥¥¥¥¥¥¥¥«¥¥«¥¥¥—¥¥«««««««««´´´´´´´´´´«´´´´´´´´««´´´´´´«¥R.Y^}‘D$-}«»ÃÍÍÍÍÍÍÍÍÕÕÕÕÕÍÕÕÕÕÕÕÕÝÕÕ»ÃÃÃÍÃÍÍÍÍÍÍÃÃÃÃÍûÃÃÃûÃû»»»»»´´»´´»´´«¥¥¥—l   $Y}‹‘‘—¥¥««««««««««¥¥—¥‘uR}‘¥—¥¥¥¥¥¥¥¥¥¥«««¥¥¥¥—¥¥¥««««««««´´´´««´´´´´´«««´«´«´´´´´´´«¥D$-R‘—„Y.$$.‹´»ÃÍÍÍÍÍÍÍÕÕÕÍÕÍÕÕÕÕÕÕÕÝÝÕÕ»ÃÃÍÍÍÍÍÍÍÍÍÃÃÃÃÃÃÃÃÃô»Ãû»»»´»´»´´´´´«««««¥„;  M}}„‘——«««««««««««¥¥——‘^Y„——¥¥¥¥¥¥¥¥¥¥¥¥¥««¥¥———¥—¥¥««¥«««««´«´´´«´´««¥««´´´´´´´´´´´«—.$l¥««¥‘„;$$$$.‘´»ÃÍÍÍÍÍÃÃÍÕÍÕÍÍÍÍÕÕÕÕÕÝÕÕÕÃÃÃÍÍÕÍÍÍÍÃÃÃÃÍÃÃÃÍÃû»»Ãû»»»»»»»»»´´´«««´«¥‹D   .uu„‹—¥¥¥««««««««¥¥¥¥‘‘l^}‹‘¥¥¥¥¥¥¥¥—¥¥—¥«¥¥—¥———‘¥¥¥¥««««´««´««´´´´´´«´´´´´´´´´´´»´«„-D—´«—‘——l$.-$$D—»»ÃÍÍÍÍÍÃÍÍÕÍÕÕÕÍÕÕÕÕÝÕÝÝÕÕÃÃÍÃÍÍÍÍÍÍÍÍÍÃÍÃÃû»Ã»»»Ã»Ã»´»´»»»»»´´´«´««««—R   $Yu}‹‘¥¥¥«¥««««««««¥¥‘„^ll}‘———¥¥¥¥———————¥————¥‘‘—¥«¥«««««««´¥««´´´«´«««««´´´»»»»»´´}.„¥««¥¥——‹.$.;$$-M«»ÃÃÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÝÝÕÝÕÃÃÍÍÍÍÍÍÍÍÍÍÃÃÃÃÃûÃû»Ã»Ãû»»»´»»´´´´´´´´«««—Y   Dl}}‹—¥«¥««««««««¥¥¥—„u^Yl„‘‘——¥—————‘‘‘—‘—¥¥——————¥¥¥¥«««««««««««««´««´«´´«´»»»»´´«„^¥‘„‹¥——¥‹;$-;-$$-u«»ÃÃÃÍÍÍÍÍÍÕÍÕÕÕÕÍÕÕÕÝÝÕÝÝÕÕÃÃÍÍÍÍÍÍÍÍÍÃÃÃÃûû»ÃÃû»»»´»»´´»»»»´»´´´´´««¥^    .^u}‹‘—«¥««««««««¥¥——„^YD;^„‘‘—————‘„u^}„‹‘‘—¥¥—————¥—¥—¥¥¥«««««´´«´«««´«´´´´´»»»»´«„‹—„‹¥«««¥‘R$--$$$;‘»»ÃÃÍÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÝÕÝÕÝÕÕÃÃÍÃÍÍÍÃÍÍÍÃÃû»Ã»ÃÃÃÃû»»»»»»»´»»»»»»´«»´«««¥u   Yll„‘—¥¥««««««««¥¥¥‘„^M-.M^}}‹‹—‘‘lD;$-M^}‹¥¥««¥¥—‘‘—¥¥¥—«¥««««´´´«´«´´«´´´´´»»»´«¥}‹‹u—¥¥«¥¥—^$$$$$-u«»ÃÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÝÕÝÕÝÕ´»ÃÍÍÍÍÍÍÍÍÃû»»Ãû»ÃÃÃÃû»»»»´««»»»»´»´´´«¥¥¥‹-    ;^^l„‘——«¥¥¥««¥¥¥¥——}YD-.Rlu}„„lYR^YD;Ru‘¥¥«¥¥¥——‘‘——¥¥¥¥«¥¥««««´«««´«´´´´»´»´´´¥„‘}„¥««´¥¥‘l-$$$$M—»ÃÃÍÍÍÍÕÍÍÍÕÕÍÕÕÕÕÕÕÕÕÝÕÝÕÝÝÕÃÃÃÍÍÍÃÍÃÃÃÃÃû»ÃûÃÃû»»»»»´´´´´»´»»»»´´««««¥‹M     $R^u}‹‘—¥¥¥«¥¥¥¥¥¥—‘}M.$ -;R^llulu„ul^u‹—«¥¥¥¥¥¥—‘‘‘——¥«¥¥¥¥¥«¥«««««««´«««´´´´´«¥u‹„—«´´«¥¥—l$$-$$D‹´»ÃÃÍÍÍÍÍÍÍÕÍÕÕÕÍÕÕÕÕÕÕÕÝÝÝÝÕÕÃÃÃÍÍÃÍÃÃÃÃÃÃû»»ÃûÃÃÃÃû»»»»»»´»»»»»»«´«¥¥¥«—}   ;^lu„„‘——¥¥¥¥¥¥—¥—‹uRM- -;DYlu„‹‹‹‘——¥¥«¥«¥«¥¥¥‘‘‘‘¥¥¥¥¥¥¥¥«¥««««««´««´´´´´´«—Yll‹¥¥¥¥—¥‘M$M‹«»»ÃÃÍÃÍÕÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÝÝÕÝÕÕÕÃÃÍÃÍÍÃÃÍÍÃÃÃÃÃÃÃÃû»»»Ã»»Ã»»»»´»»»»»»´´´««´««¥—M    .Y^llu„‘—¥‘—¥¥¥¥—‘‹}lY; $Ml‹‹‘—¥—«¥¥¥¥«¥«¥¥¥¥¥—‘——¥—«¥¥¥—¥¥««¥««««««´»´»´´«„;Y;.u‘—‘‹‘}$$$D‹«´»ÃÃÍÃÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÝÕÝÕÝÝÕÕ»ÃÍÍÍÃÍÃÃÃÃûÃÃÃÃû»»»»»»»»»´´´»´»»»»´´´´´´´«¥¥¥}.    -R^R^lu„‘———¥¥—¥——‹„}^M-$.;Ru‹‘—¥—¥¥¥¥¥¥¥¥«¥¥¥¥¥¥————¥—¥—«——¥¥«¥¥««´«´´»´´´´¥u-RM$M„„ulu;D„¥´»ÃÃÍÍÍÍÃÍÍÍÍÍÍÕÕÍÕÕÕÕÕÕÕÕÕÕÝÝÕÕûÃÍÃÃÍÍÍÃÃÃÃÃÃÃÃû»»´»»»»Ã»»´»´»»´´´´«´«´«´««¥—¥u.  $$DYMYlu}‘‘—¥—¥—¥¥‘‘‹„lR;$$-.DYYl„‹‘¥¥¥¥«¥¥¥«««««¥¥«¥¥¥¥¥—¥—¥¥¥—¥¥¥¥¥««´«´´´»´»´«¥Y.Y;;lu^Y-$Y—«»»ÃÃÃÍÍÍÍÍÃÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÝÕÝÕÕÃÃÃÃÃÃÍÍÃÃÃû»ÃÃÃû»Ã»»»»»»»»»´´»»»´´»´«´´´«´«¥¥¥‘„R$ -DMMYll„‹‹‘———‘———‘„u^M...DYlu}„‹‘¥¥¥¥¥¥¥¥¥¥¥«¥«¥¥¥¥¥¥¥——¥—¥—¥¥¥¥¥¥««´´´´´´´´´«—Y;DDY^R$.}¥´»ÃÃÍÍÍÍÍÍÍÍÍÕÍÍÕÍÕÕÕÕÍÍÕÕÍÕÕÕÕÕջûÃÃÃÃÃûÃÃÃÃÃÃÃÃÃû»´»»»»´´´´´´´´´´´´´´´´«««¥¥—¥—‘lD$ .$ DMMMY^}„‹‘‘‘‘‹—‘‘‘‹„uYD;DM^u}„‹‹‘—¥¥¥¥¥«¥¥¥¥¥—¥¥¥—¥¥¥—¥¥¥¥¥¥¥¥¥¥««««´´´»´»´´´¥—M$.;-$$M—«»»ÃÍÃÍÍÍÍÍÍÍÍÍÍÍÕÍÍÕÕÕÕÕÕÕÕÕÕÕÕÕÕ»´ÃÍÃÃûÃÃÃÃÃÃÃÃÃÃÃû»»Ã»»´´´´´«´´´«´´´««¥«¥««¥¥————‘„^R.;- .RMDMR^u}‹‘‘‘‹‘‹‹‹„}uYYMMYu}‹‹‘————¥¥—¥¥——¥¥—¥¥—¥¥—¥—¥¥¥¥¥¥¥¥¥«««««´´´´»´´»´««‘;$D$$.u«´»ÃÃÃÍÃÃÍÍÍÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÃÃÃÃÃÍÃÃÃÃÃÃûÃÃû»ÃÃÃû»»»´´´´´«´´´´´´«««¥‘¥¥—«—¥—————‹„R;-- $;DDDRRR^„„‹„‹‹‹„‹„}ull^^l}‹‹‘———‘——¥——————‘—‘‘——¥‘——¥¥¥¥¥¥¥¥¥««««««´´´´´´»´«¥„$D};$l¥«´ÃÃÃÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕÍÃÃÃÃÃÃÃÃûÃÃûÍÃûûÃû»Ã»»»´´´´«´«´´««««¥¥¥¥¥«¥—¥¥——¥—‘‘‹l.$$;;;MMDMYl}}„‹‹‹‹}uluullll}}‹‹‹‘‘‘‹„„}uuu„„„„„„‹‘„„„‹‘¥¥¥¥¥¥¥¥«««««´´´´´´´´´«—u-Y-$D‘«´»»ÃÃÃÃÃÃÃÃÃÃÃÍÃÍÍÍÕÍÍÕÕÕÕÍÕÕÕÕÕÕÍÕ»ÃÃÍÃÃÃÃÃû»Ã»ÃÃÃû»Ãû»»»»»»´´´«´´´«««««¥¥¥¥¥¥¥¥¥¥¥¥¥¥——‘„R--;DMDDDRMY^l}„‹„}lYY^ll^lYYY^u}}„lll^YRY^YYRMDMRMMYY}‹—¥¥¥«¥¥«««´«´´´´»´´´´««—R$$M„¥´´»»ÃÃÃÃÃÃÃÃÃÃÃÍÍÍÍÍÍÍÍÕÍÕÍÕÍÕÍÍÕÍÕÍ»ÃÃÃÃÍÃÍÃûÃû»»»Ã»Ãûû»»´´´»«««´´««´«««¥¥¥¥¥¥—¥¥¥¥—¥¥—¥—‹}M .DRD;DRMYluu}}ul^MRYRYR;.-$$.;MYM;;D...DD..DRY^Rlluu„—¥¥¥««««««´´´«´»»´»´´«¥‹-   $M„¥´´»»»Ã»ÃÃÃÃÃÃÃÃÃÃÍÍÍÍÍÍÕÍÕÍÕÍÕÍÕÍÕÕÕÍûÃÃÃÃÃÃÃÃû»»»»Ãûû»»»»´´´»´«´«´´««´«¥¥¥¥¥¥¥¥¥¥——¥——¥———‘„Y -;;D;MDMRlllllYRM..;--$$$-;;-.MRMMluu}„„‹‘‘‘‘‹‹‹—¥¥«¥¥«««««««´´´´»´´´«—u  .l‘¥´´»»»Ã»Ã»»ÃÃÃÃÃÃÃÃÃÍÍÍÍÍÍÕÍÕÕÍÕÕÍÍÕÕÍÕ»ÃÃÃÃÍÃÍÃÃû»»»´»ÃÃû»»»»´´´»´´´´«´««««¥¥«¥¥——¥¥—¥———¥—¥——‘‹uD- ;;DDMMMRY^l^^YM.-$ -DDRu‹‘‘————————————‘‘‘—¥¥¥¥¥¥«««««´´´´´´´´«¥—R  -M„¥«´´»»»ÃÃÃÃÃÃÃûÃÃÃÃÃÃÍÃÍÍÍÍÕÍÕÕÍÕÕÍÍÕÕÍÍ»ÃÃÃÍÃÃÍÃÃÃû»´´»»Ãû»´»»´´´´´´´´´´«¥—«««¥¥¥———«¥—¥¥¥—¥————‘‹uY;;DDMRMMRR^llYYM;$  ---MR^u„‘—¥¥¥¥¥¥———¥¥¥—¥—————¥¥¥¥«¥««´´«´«´««««««¥‹-  .Y}‘¥¥«´»»»ÃÃÃÃÃûÃÃÃÃÍÃÍÃÍÃÍÍÍÍÍÍÕÍÍÍÕÍÕÍÍÕÍÍ»ÃÃÃÍÍÃͻû»Ã»»»»»»Ã»´»»»»»´´´´´««´«¥¥¥«¥¥——¥——¥———¥——‘——‘—‘‘‹„„lRMD;DRRRDRYll^YMD-$ $MY^u„‹‹‘——¥¥¥¥—¥¥—¥—¥—¥¥¥¥¥——¥¥¥¥«¥«««««««««´´««¥‘^ D„‘¥¥¥««»»»»ÃÃÃÃÃûÃÃÃÃÃÃÃÃÃÍÍÍÍÍÍÍÍÕÍÍÕÕÕÍÕÍÕÍ»»ÃÍÃÃÍÃû»Ã»»»´»»»»´»´´»´´´´´´««««««¥¥¥¥¥—¥¥—¥—¥—¥———‘‹‘—‘‘‘‹‹‹‹uM;D;DMRRRluul^RRR;$$-.;Yu}„‹‘‘———¥¥¥¥¥¥—¥—¥—¥—«¥¥¥———¥¥¥««¥¥««¥««««´««¥¥„. $M„—¥¥««»´»»»Ã»Ã»Ã»Ã»ÃÃÃÃÃÃÃÃÍÃÍÍÍÍÍÍÕÍÕÕÕÍÍÕÍÕÍÍ»ÃÃÃûÃÃû»»»´»»»´»»»»»´»»»»´´´´´«´««¥«¥¥¥———¥¥¥—————————‘—‘‘‹„‹„l.;DMDMYY^lluu^YYYD.$--;MYu}}„‘—‘————‘———¥—¥—¥—«««¥«¥¥¥¥¥¥¥«¥¥««««««´««¥¥‘R  ;^‹——«´´»´»´»»»Ã»ÃÃÃÃÃÃÃÃÃÃÃÃÍÃÍÍÍÍÍÍÕÍÍÍÍÍÕÕÍÍÍÍÍÃÃÃÃÃÃû»»´´´´»»»»»´»»»»»»»»´»´´´«´«««««««¥¥—¥———————¥——‘‘‘‘‘‹‹„„lRDMMMYY^^YYllY^^^YD.--;DM^u}„„„‹‹‹„‹‹‹‘‹‘——¥¥«¥¥«««¥¥¥¥¥¥¥¥««¥«¥««´´««¥—l.Y„——¥¥¥«´»»»»»Ã»»ÃÃûÃû»ÃÃÃÃÍÃÍÍÍÍÍÍÍÍÍÍÕÍÕÕÕÕÍÍÍÍÃÃûÃÃÃû»´«««»»»»»´´»»»»»»»´´´´´«´««««««¥¥¥¥—¥—————————‘—‹‘—‘‹‘„}u^YRYRR^YYRY^l^^^^YM..;.;MY^^lll^lllll}„‘——¥¥¥«¥«««¥¥¥¥¥¥¥¥«¥¥«««««««——„-$$;Rl‹‹—¥¥«´´´´»»»»»»ÃÃÃû»»»»»ÃÃÃÃÍÃÃÍÍÍÍÍÍÍÍÍÕÕÕÕÍÍÕÍÍÍÃÃûÃÃÃû»»»´»»»»´´´»»´´´»´´´»»´´««¥«««««—¥———‘¥——‘‘—‘‘‘—‘‘‘‘‘‹‹‹„„u^RRMRRRRMR^lllu^^RM.-.--;;DDDDD;MRYYl„‘‘—¥¥¥«««««««««¥¥¥¥¥¥¥««««¥¥—¥„;$;luu}‹‘‘—¥—«««´´´´»´»»»Ã»»»Ãû»»ÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÍÍÍÕÕÕÕÕÍÍÍÍÍ´»ÃÃÃÃûû»»»»»»´´´´´»´«´´»´´´»´´´««««««¥¥—¥—‘—¥————‘‘‹‘‘‘‘‘‘—‘‹‘‹‹„}YRMMRYYRMRYllll^YRD..---.;..;;MMY^^u}‘—¥¥¥¥««««««««¥¥«««¥¥««¥«¥¥¥—‘l;D^„‘‘‘‘¥—¥¥¥««««´´«´«´»´»»»»»Ã»»Ãû»ÃÃÃÃÃÍÍÃÍÍÍÃÍÍÍÍÕÕÕÕÍÕÍÍÍÍ»»Ãû»Ãû»»»Ã»»»»´´´»´´««´«««´´´´´´««««««¥—¥¥—¥—¥—‘———‘———‘‘—‘‘‘‹‹„}}lYMMMRRYYR^^^llu^l^M;.D;;;DMRDM^luu}‹—¥¥«¥«¥¥«««««««¥¥««¥¥«¥¥«¥¥‘—‹„„‹‹‘‘‘—¥—¥¥¥¥¥«¥««´´´«´´»´»»»´Ã»ÃûûÃÃÃÍÃÍÍÃÍÍÍÍÍÍÍÍÕÕÕÕÍÍÕÍÍÍ»ÃÃû»ÃÃÃûû»»»´´´´»»»´´´«««««´««´«´««««¥¥—«¥—¥‘‘—‘‘‘———‘‘‘—‘‘‹‹„}llMRRMDRMRRR^^YY^uulu^YMMRM;R^^^Yu„}u‹‘¥¥¥««¥¥¥««««««¥¥¥¥¥«¥—¥—¥——‘‘‘‘——————«¥¥—¥¥¥¥¥¥«««´«´´»´´´»»´Ã»»»ÃÃÃÃÃÃÃÍÃÃÃÍÍÍÍÍÍÍÕÍÕÕÍÕÍÍÕÍÍ»»ÃÃûû»»»»»»´´´´´´´»´´«´««´«´««´«¥¥«««¥¥¥¥¥¥—¥———‘‘———¥——‘‘‘‘‹‘„}lM-;MMRRM;Y^YYYY^luuul^^^Ylll}}}„‹‘‘‘¥¥¥«¥«««¥«««««««¥««¥¥¥¥———‘‘‹‹‘‘———¥——«¥¥¥¥¥¥¥¥¥««¥«««´´»´´´»»»Ã»»»ÃûÃÃÃÃÍÃÃÃÃÃÍÃÍÍÍÍÍÕÍÕÕÍÕÍÍÍ»»»ÃÃû»´»»»»´»´»»´´´´´»´´´«´«««««¥¥¥««¥¥¥«¥¥¥¥—¥————‘—————‘‘‘‹‘‹}^^R.$.DMRDMR^MMDMYuluul}uuu„„„„‹„‘‘¥—¥¥¥¥¥«««««««««««««¥«¥¥¥——‹‘‹„„‹——¥—‘——¥¥¥¥—¥¥¥¥¥«¥«¥««´´«´´´´»»»»»Ãû»ÃÃÃÃÃÃÍÃÃÃÃÍÃÃÍÍÍÍÍÕÕÍÕÍÕÍÍ´»»ÃÃû»»»»»´´»»»´´»´´´»´´´´«¥«««««¥¥¥¥—¥—«¥¥¥—¥———————¥¥—‘‘‘—‘‹}^^^YM-DRMMMRMDRYY^llluu„}„‹‹‹‘‘———¥¥¥¥¥«¥«««¥««««««««¥¥¥—¥——‹„}‹‹‹‘—¥—¥—‘—¥—¥¥¥¥——¥««¥««´´´´´´´»»´»»»»»Ã»»ÃÃÃÃÃÍÃÍÃÍÍÍÃÍÍÃÍÍÍÍÕÍÕÕÍÍÍ»»»ÃÃÃû»»»´´´´´»»´»»´´´´´´«´«««««««¥¥¥——¥¥¥——«—‘‘‘—‘——————‘—‹„„„uullR$ -MMMMM;;MMR^^lu}}„‹‘‘„‹‘——¥—¥¥—«¥¥¥«¥«¥««««««¥¥————‹„‹}}„‹‹‹‘¥———————¥¥—¥—¥¥«¥¥¥««««´´«´»»»´»»»»»Ã»»ÃÃÃÃÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÍÍÕÍÍÍÍÍ»»ÃÃÃÃÃû»»»´´´»»»´´´´«»´´««´««««««««««¥¥¥¥¥¥—¥—‘—¥——‘————‘—‘‹„}„}u}uY; .MDDMD;DMRR^luuu„‹‘—‘‘—¥¥—¥—¥¥¥««¥¥¥¥««««««¥¥¥—‘‘‘„uuu„‹‹‹„‘—¥—————¥—¥¥¥¥—¥¥¥«««´´«´´´´´»»»»»»»»Ã»»Ã»ÃÃÃÃÍÃÃÍ»ÃÍÍÍÍÍÕÍÍÕÍÍÕÕÍÍ»ÃÃÃÃÃÃû»»Ã»»»»»´´´´´´»´»´´´«´««««¥¥¥¥¥¥¥¥¥¥—«——¥———‘—‘‘‘—‘—‘‹„‹„„„}lR- .MMDDD;MMRY^luu}‹‘——‹——¥—¥¥—¥¥¥¥¥¥¥¥«¥«¥«¥———‘„‹„uuu„‹‹„‹‘————————¥¥—¥¥¥¥¥«««««««´´´´´´´»»»»»Ãû»»»»»»ÃÃÃÍÃÃÃÍÍÍÍÍÍÍÍÕÍÕÕÕÕÍÍ»Ãû»ÃûûÃû»»Ã»´´´´´´´´´´´´«««¥¥¥¥—¥¥¥—¥¥¥——¥¥¥———‘‘————¥————‘‘‹‹„lRY;$ -DMD;;DMDMR^lu}„‹‹‘—¥—«¥¥—¥—¥¥¥¥¥¥¥¥¥—¥¥——‘‹}uuu^l}‹‹‹„„‘——‘————¥—¥——¥¥¥¥«««««´««´´´´´´»´»»»»»»»»»Ã»ÃÃÃÃÍÃÍÍÃÍÍÍÍÕÍÍÕÕÕÕÕÕÕÕ»»»Ãû»»»»»Ã»»»»´´´´»»«´´´´´´´«¥¥—¥———¥——¥¥¥———¥—¥————¥¥¥¥¥¥¥¥¥———‹„^RYY; .MMMDMMMDMYYlu}}„‹‘—¥————¥—¥——¥—¥——————‘‹„}u^^luu‹‹‹‹„}‹—‘—————¥———¥—¥¥¥««««««««´««´´´´´»»»»»»»»»»ÃÃûÃÃÍÃÍÃÍÍÍÍÍÕÕÕÕÕÕÕÕÕÕ»»ÃÃû»ÃÃÃû»´´»´«´´»»´»´´´´´«««««¥—¥¥¥—‘‘————¥—¥—¥¥¥¥««««¥¥¥¥¥————‹}l}uYD- $;MMMMMDMYYYllu}‹‘—‘——¥—‘————————‘‘‘‘‹}}u^^^llu„„‹‹‹„„‹‘‘——————¥—¥¥¥¥¥¥««««¥«´«´«´´»´´´´´´»»»»»»»»ÃÃÃÃÃÃÍÍÍÍÍÍÍÍÕÕÕÕÕÕÕÕÕÍ»»ÃÃû»»»Ãû»´´´´´´´´´´»´´«´«««¥««¥——¥¥„Y}‘‹}„‘——¥—¥««««««¥¥¥¥¥¥—¥—‹‹„}u^RD- -;DMD;MMMRYY^l}u„‹‹‘‘‹‹‹‹‹‹‘‹‹‘‹‹„}lYYY^^lu}„‹‹‘‘‹„„‘‘——‘——¥¥———¥¥¥«¥«««««««««´«´««´´«´´»»»»»»»ÃÃÃÃÃÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÕÕÕÕ´´»»ÃÃû´Ã»´»´»»««´´´´««´´«´´´´¥««—‘„‹‹^;MuYRu‹‘—¥««´´´´«««««¥¥¥¥——‘‹‹„u^RR;-$.DDDDDMMRRYYYuu}„„}uu}}}„„}}lll^RRMYll}u„„‹‘—‘‹„‹‘‘‘———¥—‘—¥—«¥¥¥¥«««««¥«««««´«««´´«´»´»»»»»»ÃÃÃÍÃÍÍÍÍÍÍÕÕÕÕÝÕÝÕÝÕÕÕÍ»»Ã»»Ã»Ã»»»»´»´´´«««´««´´´´´´««¥«¥¥„RluR..DM^‘—‘‘«««´´´««¥¥««¥¥——¥¥—‘—‹„}llMD- $-DDMMMDMMMRY^^^l^YRR^^lll^YRYMRYYlu}u„„‘‹‘‘—„}‹——‘‘———————¥—¥¥¥«¥««««««««««««««´´´´´»»»»Ã»ÃÃÃÍÍÍÍÍÍÕÍÕÕÕÕÕÕÕÕÝÕÕÕÕÍ»ÃÃÃÃÃÃû»»»»»»´´´«´»´´«´¥«««««¥«¥—u;DM;.$$R‘—‹}‹«´´´´´´«««««¥¥¥¥¥———‘¥‘‹‹‹u^M.$ -.;;MDDMMRRMRRD;;MYRMRRMDRRM^ulu„‹„„‹‘‘‘‘‹}u‹‘‘‘—————¥—‘‘—¥¥¥¥¥««««««¥««««««´´´´´»»»»ÃÃÃÃÃÍÍÍÍÍÍÍÍÍÕÕÕÕÕÝÕÝÕÝÕÕÕÕ»ÃÃÃÃÃÃû»»»»»´´«´´´´«´«´«¥«¥«¥¥¥¥‘R.;;;.R}}„‹¥´´´´´´´´´«««¥¥¥¥—‘‹———‘——‘‹}llD$ $-;;;;;;M;DDD;;DM;;D;DMRYlu}„„‹‹‘‹‘‘‘‘‹„„}„‘‘———¥——¥————¥¥¥¥¥¥«¥¥¥¥¥«««´«´´´´´»»»»ÃÃÃÃÍÍÍÍÍÍÍÍÍÕÍÕÕÕÝÕÕÝÕÝÕÝÕÕÕ»»»»ÃÃû»»»´´»´´´´´´´´«´´«¥««¥——‘‘„D..-$$.DRl„„‘«´´´´´´«´´«´«¥¥¥¥—‹———¥————‹‹„l^M$-$..;;;.;;..;.;DM;RY^}}}„‹‹‘‘‘‘‘——‘‘‹„„‹———‘—————¥——¥—¥—¥¥«¥¥¥¥¥¥¥«´´«´´»»»»»ÃÃÃÃÃÃÃÃÍÍÍÕÍÕÕÍÕÕÕÕÕÕÕÕÝÝÝÕÝÕÕ´»ÃÃÃÃû»»»»´»´´´´´»´«´«´´¥«««¥‹^lR-$R^Yu}‘—««´´«´´´´´´«««¥¥——‹—¥—¥¥¥¥——‹„„}lD$$$$$$.-...;;.;;DDDRY^l}}}„‹‘‘‘‘‘‘‘——‘‘„}„‘‘‘‘‘—————————¥—¥¥¥¥¥—¥¥¥—¥«««´´´»»»»ÃÃÃÃÃÃÃÃÍÍÍÍÕÍÍÕÕÕÕÕÕÕÝÝÝÝÝÕÝÕÕÕûûÃÃûû»´´«´´´´´´´´´««¥¥«««¥‹R;-$.--^}‘—‘‘‘«««´´´´´´«««¥¥¥—«¥«¥««¥——‹‹„„}^M-$$$----$..;.;.D;DDRYYlu}}„„‹„‹——‘‹———‘‘‹„}„‹‘‘‘‘‘—————¥——¥—¥¥¥¥—¥¥—¥¥—««¥«´»´»»´»»ÃûÃÃÃÍÍÍÍÍÍÕÕÍÍÍÕÕÕÕÕÝÝÝÝÝÝÕÕÕÃÃÃû»Ã»»»»´´´´´´´´«´´´´¥¥¥¥«¥¥—„^RD-$.u„‹‘‹‹—««««´´´´«´¥«¥¥¥««««¥«¥———‘‹u„„}YD;-$$----.--...;;;DMRYllu}„‹„‹‘‘‘——‘‘‘——‘‘‹„„„‹‘‘‘————‘‘——————¥—¥¥—¥—¥¥«««¥«´´»´»´»»Ã»»ÃÃÃÍÍÍÍÍÍÕÕÍÍÕÍÕÕÕÕÕÕÕÝÝÝÕÝÕÕÃÃÃÃÃÃÃû»»»»»´´´´´´»´´´´´¥¥¥¥—¥‘‹„lM-$$;Y}„„‹‘——«««´«´´«««¥«««¥««««¥—¥«¥—‹}‘‹„ulYDD;...;;...;.DD;MRRYllu„}„‹‹‹————‘‹‘————‘„}}„‘‘‘‘——‘‘‘‘—‘—————¥¥—¥—¥—¥¥«¥¥«´´»»»»»»»»»ÃÃÃÍÍÍÍÕÍÍÕÍÕÍÕÕÕÕÕÕÕÝÕÝÕÝÕÕÕ»ÃÃÃûû»»»´»´»»´´»´´´«´´«¥—„llluulM..;D;.-$DYu}u}‘¥¥´´«´´«««««««¥¥¥«««¥««¥¥‹‘—‘‘‹}}^YRM;MDDD;;DMDDRR^^l}u}„‹‹‹‹‘‘‘—‘‘‘‘———‘‹„}}}„‘‘‘‘‘——‘——‘——‘—‘——¥¥«¥¥‘‘‘¥¥«´´»»»´´»´»»ÃÃÃÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÝÝÕÝÝÝÕÕÕÕ´»Ã»»ÃÃû´»»´»»´´´»»´´´««‘}lM;...;D;;MDMR^R;-.;;}‘¥—««¥¥´´´´´«´«¥¥¥¥¥¥«««¥¥¥¥‘‹‘‘‹„}u^YMMRRMMDMMMMY^luu}}„‹‘‘‹‹‘‘‘———‘‘—‘—‘„u}„‹‹‹‘‹‘‘‘—‘—‘‘‘‘‘‹‹‘—¥««««„M^‘¥«´»»»»««»»»»ÃÃÃÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÝÕÝÕÝÝÕÕÕ»»ÃÃû»Ã»»»´´´´´«´»´´´«—}YRMD.--.;DDDMRRR^^^R$R„‹„„‹‹¥¥´´´´«´´««««««««¥«««««———‘„„„„lYl^^YMY^YY^Y^^lu}}}‹‹‹‘‘‹‘‘‘—‘‘‹‹‘‘‘‘„}„‹‘‹‹‹‘‘‘‘‘—‘‘‘‹‹‘‘‘¥¥««´´«—^R}¥«´´»»´´´»»»ÃÃÃÍÍÍÍÍÍÍÍÍÕÍÕÍÕÕÕÕÕÕÝÝÝÝÝÕÕÕ»ÃÃÃû»»»»»´´«««—«««««¥uDDMRM..-.;.MMRYYRR^llM$D„ll}‹‹¥«´´«´´´´««´´««««««««««—¥‹}l}„‹„}„}u^Yl^^l^luuuu}„„„„„‹‘‘‘‹‘‘‹‘‘‘‘—‘‹„„‹‘‘‹‹‘‘‹‘—‘‘‘‘„„‘——¥¥««´««««‹DR—««´´´´«´»»ÃÃÃÍÍÍÍÍÍÍÕÍÍÍÕÕÕÍÕÍÕÕÕÕÝÝÝÝÝÕÕ»ÃÃÃÃû»»´´´««¥««—¥‘‘„^RRYY^lRD.---;MMY^^YRMYlMDuRl„‘‘¥«´´´´«´´«´«´««««««««««¥—‘‘‹}„‹‘‹‹„„u^uuulluuuu}}}„‹‹‹‹‘‘‹‘‘‘——‘‘‘‘‘‹„}‹‘‘‘‘‹‹‹‘‹‘‘‘‹u„‘—¥¥¥«««««««—M.„¥««´««´»»Ã»ÃÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÕÕÝÝÝÝÝÝÕÕ»»ÃÃû»»»»´»´¥¥—‘}u^YRMRY^u„}u^RD--$.MYllllRDMM--.^u„‘—««´´´´´´«¥««´««¥¥«««««—¥—‘‹u„‘—‘‘‹‘‹ul}}luuuuu}}„}‹‹‹‹„‘‘‘‘‘‘——‘‘‘‘‹}„——‘‘‹‹„‹‹‘‘‘‹}u}‘¥¥¥««««««««—l.u—¥¥«´´»»Ã»ÃÍûÃÍÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÕÕÝÝÝÝÝÕÕÕ»»ÃÃû»»´»»´¥—}lRYY^^RMYYll‹„uul^Y;--.DR^uulM;.--.Mll—«´´´««´«¥¥«´´«¥¥«««¥¥¥———„u‹—¥————‘‘‹„}}uuu^lu„}}„‹‹‹„‘‘‘‘——‘‘‘‘‘‹„}‹—¥—‘‹‘‘‹‹‹‘‹}uu„‘—¥¥¥¥«¥«¥¥¥—};^—¥¥«´´»»ÃÃÃÃÃÃÃÍÍÍÍÍÍÍÍÍÃÃÃÃÃÍÍÕÕÝÕÝÝÕÕÕÕ»»Ã»»«´»´´´—‹lRMRR^u^^^^lll}uul^}}^R...;D^uuYM;..$ M—¥««««´«««¥««««¥««¥¥—¥¥¥—‘‹‹—¥———¥‘———‘„}}}}}u}}}„‹„„‹‹‘‘——————‘‘‘‹„}‹¥———‘‘‘‹‹‹‹„u^‹‘—¥¥¥¥¥¥—¥———‘l;M„¥¥«´´»»ÃÃÃÃÃÃÍÍÍÍÍÍÍÍÃÃû»»ÃÃÃÕÕÕÝÕÕÝÕÕÕ´´´»»´»»««—„lYYRMMY^YY^^ulu}ulY^u}„u^RD;.MYl^RD.-$.‹‘¥¥—¥««««««´«««¥¥¥—‹¥¥¥————¥—¥—‘‘——¥——‹„}}„}„„„„‹‘‹‹‹‹‹‘——‘———‘‘‘‹}u‹—¥——‘‘‹‹‘‘}^l}‘‘——¥————‘‘‘—‘‹lMDu¥««´»»»ÃÃÃÃÃÃÍÍÍÍÍÃÍÃÃÃû»»ÃÃÃÍÕÕÕÕÝÕÝÕÕ´´»Ãû»´¥‘ull^RRYRRRMMRYYl}„}lYDR^„}}}uRD;;RYRM.$$$ ^‹‘—‘¥¥««««««««¥¥¥¥¥¥¥¥¥——«¥¥¥—‘‹‹¥¥¥—¥‘‘‹‹‹‹„‹„„‘‹‘‘‘‘——————¥—‘‘‹„l^„—¥¥——‘‘‘‹‹}lu‹‘‘—¥——‘‹‘‘‘‘‘‘‹„„„—¥«´´»»ÃÃÃÃÃÃÃÍÍÍÃÍÃÃÃû»»´»»»»ÃÍÕÕÕÝÕÝÕÕ´»»»»´—‹}ull^^YYRRMDDMMMDMYluuYM;MRl^u„lYD.;;MMD$$$ ^‹‘————¥¥¥¥¥««««««««¥¥¥¥¥¥¥¥¥——‘‘—¥—¥¥—¥———‹‹‘‘‘‹‘‘‘———¥—¥——————‘‘„u^‹¥¥—¥—‘‹‹‹}lu„‘—‘—‘‘‹„„‹‘—‘‘‘——¥—««´´»»ÃÃÃÃÃÃÃÍÍÍÍÍÃÃÃû´´´´»»»»ÃÍÕÝÕÝÕÕÕÕ»´´¥—‹l^^lul^l^^YYMM;;DD;DY^^lYM;.;;.^„}}YM;..;;;.  .Ru‹‘———¥¥¥¥«¥¥¥«««««¥—¥¥¥¥¥¥¥————¥¥—¥¥¥¥¥——‘‘‘——‘————¥¥—¥¥———‘‘‘‹„^l‘¥¥¥¥—‘‘‹„l^„‹‘———‘‹„‹‹‘—‘‘—¥¥—¥««´´»»»ÃÃûÃÃÍÃÍÃÃÃÃÃÃû´´«´´´»»ÍÍÕÕÕÕÕÕÕÕ´«—„u^^^ll}ullluluYY;..;D;RRlul^MD.;DRlu}llYD..;;.$ $Rl„‹‘——¥¥¥¥¥¥«««««¥¥¥¥¥«¥¥¥¥¥—¥¥—¥¥¥¥¥¥¥¥‘————‘———¥—¥——¥—‘——‘‹„}^„—¥¥¥¥¥‘‘‹}^l„‘‘‘‘‹‘‹‘‘‘——‘—¥¥¥¥«««´´»»Ã»»»ÃÃÃÃÍÃÍÃÃÃÃû»»»«´´»»ÃÍÍÕÕÕÕÕÕÕÕ¥‘l^u^l^^llulu}}}}}lRD;..-.DMYllYMDDDDMYluu}lMD;D;;$   $M^u}‘——¥¥¥¥¥¥¥«¥¥¥¥««¥¥¥—¥—¥‘—¥¥¥¥¥¥¥¥—¥——————¥—¥——¥—————‘‘‹„u^—«¥«¥¥¥——‹lY„‹‘—‘‹‹‹‹‹‘——¥¥—¥¥¥¥«´´´»»»»»ÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃû»´»»»»ÃÍÕÕÕÕÝÕÕÕÕ‹l^llll^llll^uu}luuul^R;-$--;MRYRMD;;;;MRlluu^RDDDD;-$  R‘———¥—¥¥¥¥««¥¥¥«««¥¥¥«¥—‘—¥¥¥¥¥—¥¥¥—¥——‘—¥——¥¥—¥—¥———‘‘‹„}„—«¥«¥««¥¥‹}u„‹‹‘‘‹‹‹„‹‘——¥¥¥——¥««´´»»»»»»»ÃÃÃÃÃÃÃÃÃÃÍÍÃÍÃû»ÃÃÃÃÍÍÕÕÕÕÕÕÕÕÍ^RRRY^llllul^uuu^lllu^lRD.--$.;MMMMDDD;;DR^u}ulRM;;D..--   -Y‹‘————¥¥¥«¥««¥¥¥¥¥¥¥«¥———¥¥——¥——¥—¥———‘‘———¥——————‘‘‘‹„}}—¥¥«««««¥—„l}‹‘‘‹„‹‹}‹‹‘—¥¥¥———««´´´´»»´«´»ÃÃÃÃÃÃÃÃÃÃÍÍÍÍÃÍÃÃÃÃÍÍÍÕÍÕÕÕÕÕÕÕÍRMMYYYuulu}uuull^^^R^^^^RM..-$.;;DMMMDD;DMR^u}ul^MDD..$.-  .l„‹————¥¥¥«««««¥¥—¥«—¥—¥¥—¥—¥‘¥——¥———‘‹‹„‹——¥————‘—‘‹‹}}‹¥¥«««««¥¥—‘}„„‹‹„‹„}}„‘‘———¥——¥¥«´´´´´«—‘´»ÃÃÃÃÃÃÃÍÃÍÍÍÍÃÍÍÃÃÍÍÍÍÕÍÕÕÕÕÕÕÕÍÍMMMRRR^l^u„„„„}ul^YMMMMYllYM;-$---.DMDMMM;DDRlu}}YYM.-$---  -M„‘—‘——¥¥¥«««««¥««¥——«¥¥¥¥———‹‹————„„‹„}}‘‘—¥——————‘‹„‘¥««««¥«««¥¥——‘‹„„}uuu„„„‹‘‘——¥¥«««´´´»´´‘‹´»ÃÃÃÃÃÃÍÃÍÍÍÍÍÍÍÍÍÍÍÍÕÍÍÕÍÍÕÍÍÍÍÍÍMMMDMRRR^u„‹‘‹‹‹‹uuYRMMRYYYYYD.--$...;;DDDD;MYlluu^YD..-$$  ^‘‹‘———¥¥«¥«««¥¥¥¥¥¥¥«¥¥—¥—‘}l„‹‹„„‹‹}ul„‹‘——‹‘‘‘—‹‘‘¥¥¥¥«¥¥««««¥¥—‘„uluRY^uuuu}„‘—¥¥«´«´´´»´´´«»ÃÃÃÃÃÃÃÃÍÍÍÍÍÍÍÍÍÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍMDMMMMMDM^u„‘‘‘‘‘„}llY^YRRRMRRDD-$-$--.;DDDMMRYluuu^MD;;-$   $R^„‹„‘——«¥¥«¥¥«¥¥¥¥¥¥¥—‘‘„‹l;..M}‹‘‹}R;}‘‘—‘‹„„‹‹‹‘¥¥¥¥¥¥¥«««««¥¥—‘lMDD...;;;;Dl‹—¥««´´´´´´»»»»´»ÃÃÃÃÃÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÃÃÃÍÍÍÍÍÍÍMMMMDMMRRYlu}‹‘‘‘‹„}uYu^^YRMRRMRD;-$$-..DDDDDMMY^uulRD;D..$    $.Y„‘¥—¥¥«¥«««¥¥¥¥¥¥‹}uu}.;}‹‹„l.l‘——¥—„lYu„‘—¥¥«¥¥¥¥¥¥¥¥¥¥¥—‹R$$$R‹—¥«´´´´«´´´´»»»»ÃÃÃÃÃÍÃÍÃÍÍÍÍÍÍÃÃÃÃÍÃÃÃÍÍÍÍÕÕÍÕÍÍMMMMMMMRRYYl}„‹‹‘„„„lYY^^^RRMRYYYRD......;;DDMRRR^uulMD;;...   ^‘——¥¥¥—¥«««««¥¥‘lD^}l$ D„‹‘„Mu‘—¥¥———}MR}‹—¥¥¥¥¥¥—¥‘‹—¥¥¥—‘Y  ^‘—«««´«¥¥—„„¥»»»»ÃÃÃÃÍÃÍÍÍÃÍÍÃÃÃû»»»»ÃÍÍÕÍÕÕÍÕÍÍÍRMMMRRMRRR^^ulu}„„‘‹‹„u^R^YRMDMRl^YMD.$-$$-.;;DDRRlll^YM;..--  D„‘——¥—«¥«¥«««¥¥‘^.l}l^Y;D„‹‹„}‹‹——¥¥——‹lM^}‘—¥¥¥¥‘„}^Ru¥¥¥¥—l $l‹—¥«´´«¥¥‘ul„´Ã»ÃÃÃÃÍÃÍÃÃÍÃÃû»»´«¥—´ÃÍÍÕÕÕÕÕÕÕÕÍÍMMMMMRRRYYl^ll^llu}„„„}lMDMMDD;MY^l^RD.-$$$-.;;;;MRYlulYM.-$-   M„‘———¥¥¥¥««¥¥¥—l$Mu„‹‹‹^;^„‘‘‹„‹——¥¥——‘„ul}‘—¥——‘‹}^RRu—¥¥¥‘„; $^„‘¥¥«¥¥¥¥«¥—«´»»ÃÃÃÃÃÃÃÃÃûô«¥—‘‹‘«»ÍÍÍÍÕÕÕÕÕÕÍÍÕMMMMMMM^l^YY^l^l^YYu}„‹}M;DDDMMMY^uuuYD;--$$-....DDY^u}uYR;;.$   ;}‹‘—¥—¥¥¥‘—¥——^$-l‹‹‹‹‘}}‹‘‘„„—¥¥¥———‘‹‘„„‘—‘‘‘„„„uMYY‹—¥———„.  M}‹—¥¥———««««´´»»»ÃÃÃÃû»Ã»´«‘}u}}‹«»ÍÍÍÕÕÍÕÕÕÕÕÕÍÍRRRRRYR^^YRYYY^YYYR^l„‘‹lMDM;DD;RY^uulYM;.-$$-.-..DRR^}„}lM;;.  Y„‘———¥—————‘Y$-Y„‹‹‹‘‘‘‘‘‹}‘——«¥¥—‘‘‘‘‹‘——‹‹‹ul}uuuDY‹—¥¥—‘}. .l„‘——‘‘¥¥««««»»»ÃÃÃû»»»´´¥„l^u}‘«ÃÍÍÕÍÍÍÕÕÕÕÕÕÕÍÍRRRRY^^lYRRYYYYMMMRR^}‘‘‘lMMDDM;DDRYl}ulR;---$---.D;D^„„„uYD..$   Mu‹‘——¥¥——‘u;$-Dl}‹‹‹‘‘‘‘}u„‘——¥‘—‘———————‘‘‹ul^u„„Y;u—¥¥——‹^ $;^}‹„u}‘¥¥¥¥«´»»ÃÃû»´´´¥‹u^^uu‘«ÃÍÍÍÍÕÍÕÕÕÕÕÕÕÍÕÍYYY^^u^l^R^Y^YRMDDMMR^}‘‘„lYDDM;D;M^u„„}lM..----$...;Yu}„„lR;-$   Rl}‹———‘‹^-$$;MY^u}„‘‘^..Y‘‘lY„—‘——¥¥¥——‘‹uR;Y„}^DR‹¥¥¥—‘}-.YulDDu‘‘—¥¥«´»»Ã»»»´«‘}YRllu‹«»ÃÃÍÍÍÍÕÍÕÕÕÕÕÕÕÍÕY^}l}„}ll^^„„RMM;DMDMRl}‹‘‹^DD;;;;R^l}„„}lM;--------.D^}„„}^D--$   R‹‘‘„l...Ru‹‹u.$M‘‘l^‹‘‘‹‘¥—¥—‘‹}Y-;RuYRMR„—¥¥¥‘}--DD-$;u‹‹—¥«´´»»»´«¥‘lMMYllu—»ÃÃÍÃÍÍÕÍÕÕÕÕÕÕÍÕÕÍl}‹‘‘‘—‘„uluuRMD;;;;DMR^}}‹}YD.;.;MR^u„„„}lD...---$$..Rl}}}lM;.-   -u‹„uR. ;u‹‘‘„^‹——‘‘‹‘‹‘—¥¥¥—‘uR;;M;;-.RRY‘¥¥——Y$$$-;l—¥««´´»´´«—„R;DMYYl‘´»ÃÃÍÍÍÍÍÕÕÕÕÕÕÍÕÕÕÕYl‘—««««—}ll^YM;;;;;;DRYYMRulM;;;;DR^l„„„„uRD.;...$$-.DMl}ul^RD-   $Y}lMM.$ M}‘‘—‹‹‘—¥—‘‹‹‹‘¥—¥¥‘‹^D;R^D.$$DD-„—¥¥—^$-^—¥«««´´´´¥u;.;;MR^‹«»ÃÃÍÍÍÕÍÍÍÕÕÕÕÕÍÕÕÕÕY^„‘¥«««¥‘‹„u^RD;;.;;;R^R..;YlM;D;DDRYu„‹„‹lM.D.;.-...DDRl}lu^Y.$    -^lMY;.u„„‹‹l„‘‘—‹„‹‘‘—¥¥——‘}D$$M^M;.$;D-u‘¥«¥‘;.„—««´´´´´«‹M;;.DDR}¥´»ÃÃÍÍÍÍÍÍÍÕÕÍÕÕÕÕÕÕÕMR^}—¥‹‘‘«¥¥‘uYM;;;.;;^}l;$$.l^M;D;;MR^‹‹‹‹}uMD;D;.;.;.DDRlluu^R-   $.YMD;$Duu„uY^„‘‘‹‹‹‘————¥—‘„^$-Y;;D$...^‘—¥—‘l$$D„¥«´´»´´«¥„YMD;.Dl‘«´»ÃÃÍÃÍÍÍÍÍÕÍÍÕÕÕÕÕÕÍDMRYu‹‘‹„‘—«¥‹uM;....Dl„u;$$D^MD;D;DR^„‘‹‹}uYM.;;;;;;;..;MRllu^M   .;$ $Mu}R-^‹‹‹‹‹‹‘¥—‘‘‹‹‹};$D;.MD.$$;^‘‹„‘}-$-$$Y„—«´»»´´¥‹}l^Y;.Ml—«´»ÃÃÃÃÃÃÍÍÍÍÕÍÕÍÕÍÕÕÍMDMMR^„‘‹}‹‘——„lD;;..Dl}uM$$DR;D;;DM^„„‘‹}uYM;.;;..D..-.;DR^luY-  $ ;M-u„}}„‹‹„‹‹‹ul}l^--.R^R.$;}ul„u$---$.u‹¥«´´»´««—‹„}lR;;u‹¥«´»Ã»»´ÃÃÃÍÍÍÍÍÍÍÕÍÍÕMRRMDMR}‘‹}u}‘—‹^D.;..luYR--YRD;MDM^}‹‘‹‘„}RMDD;.;;;..;;DMY^ul;   $   .uuuuu„}}„„u^l^RR.;YllR$$-RD.YR$-.-$;}‘—«´´´«««——‘‘„lD.D^„—¥«´´¥‘—´»ÃÃÍÍÍÍÍÍÕÍÍMMYYRM;Mu‘‘ulu‹‘„R;.;;^^MR.$$;^RDD;;Ml‹‘—‘‘„lYR;;;.;;;.;.;;MR^lM $$  .Yl^^^llu}uM;R;.M--;^^Y.$--..$-;.-M}‘¥«´´«¥«´«¥——‘}M..;Dl„—««‘}„‘«´»»»ÃÃÍÍÍÍÕMMRu„uD;D^‹„llu}„lM;.;Y^;MD$-R^RD;;D^‹——‘‘‹„u^MD;;;.;;.;.;;;MRD$ -$$$ -.-$--.MD.$;$R$DRMD-$$-$-;D.$$;u‘¥««´¥¥«´´«¥¥‘„M...;;R}‘‘„}}„‘¥««««´»ÍÍÍÍMMR^‘—uM;D^„‹u^u}„lD..Rl.;R.$;u^MDMMR„‘‘‘‘‹‹„}^MD;.;...-.;;;DDD$  $$$$Y-$.^l-$$.D;-$$$;l‹—¥¥¥¥¥«´««¥¥‘uD....;DRY}}}}„‘¥««¥¥—«»ÍÕÍRRMR}——lD.;Y„„u^^}}^D.D^D;RM-$-R}lRRDMu‘‘‹‘‘‹„„lRM;;;.-....;.;;.$$$$$$Y;$.l}D$-;DD.$$-$$.Y}‘‘——‘—¥««««¥—};.....;;M^„„‘‘¥«´«¥‹‹—»ÃÍÍl^RRY„—‹Y;.DY„„lY^„„R;;^R.M^R$$;l}RRRMR„—‘‘‹‹‘„}lRDD;;-;;;;.;;;-$-$$$$$.;MDRM$$$.l}Y-$--;;;---$$$-Ml‹‘‘‹}‹—««´««¥‹M......;D^}‹‘¥««´«—„}‘´ÃÍÍ‹„^RR^‹—uM;.;Y‹‹l^u‹}DDY^;D^l.$-MulRRRMl‹‹‹‘‘—‘‹lRDDD...;.DD;.;.-$$$$-$$$$$$$$M}}Y$RY$$$.---l}Y-$$-.;D.$-.-$-.M^„‘‘}M^„—¥««´¥‘l;....;.DRl}‹¥«´´´‘„„—´ÃÃÍ——„YYYu‘‘lM..D^‹‹l^}‹^DM^DDRlM$$.l}YRRYYu„‹‹‘‘—‘„^YDDD;;;DDDD;;.-$ $$$$$$$---$$$$$$$$$R‹‘‹R-Ml-$$$$.;$-^^M$$$-.;$-;.-$.Y^^„‘}M-.Yu‹—¥«¥—u;;.;;.;;DMYu‹—«¥¥—‘——«´»»¥¥—}YY^‹¥‘‹R;.D^‹„^^„‹RMYD.DR^;$.R}uRRYYYu}„‹‘‹‘‹uYRMDD;DDDMMD;;- $$$--..-$$$$$$$$$$$$$$$^———‘Y$;u;$-$$.$-;.$$.D--;;.-Du}u}‹^.---Dl„—¥¥—}D;;.;DDDDMMR^„‘—‘——¥‹‘——«‘—¥‹l^l}‘««„R;.D^‹„uu‹uRYR;;MlM$$$;l„YMMMYu‹‹„„„‘‘„lRRDMDDDDDRMDD-$ -$$$$-$$.$$$$$$$$$$$-$^—¥¥—‹M$.uR$$$$-D--D-$$.;;.R}„„}}M-$-$-.R„———uD;;;;DMMDDDMMYlu„‘¥—‹}}‹¥‘—¥¥‹llu‘«´¥}M..Ml‘‹u‹‘„ulM;DRY.$$$;u„uMMRRl„‘„}u„‘‹}YRDDDMDDDMMRD.$ $$$-$-$$$$$-$$-$$.‹¥¥¥¥—‹D.ll$-$$-RM$-D;--;D;DY}„}}Y.--$---.Y}‹„Y;;;;DMMMMMDMMRRYl„‘—u^l„‘‹‘¥«—}ul}¥´«¥„M..Dl‹„‘——‘}^M;;R;-$-Mu}YRRRY}‹‹ulu„‘„uYRMMDDDMMMMD;$$$$$$$$$-$$$--$..Du—««««¥—}-Yu-$$$.YR--DM;-.RMDMlu^M;------..;MYYM;DDDDRRRMMMRMMRYRluu^^^u‹u}—«´‘„u}‘«´´¥„M..Ml‘—¥¥¥‹lM;D;;-$$-;R}u^RRR^}‹‹ulu‹‹}RRRDDMMMDMMM;$$--$$$$$$$$$$$-.;MRu—«´«««««‹-;}D$$$$$$.;$$;DD.;RRDMRM;.--....;;..;DMDD;DDMR^YMMMMMMRRRR^YYR^^l^l„‘«¥‘„‹‘««««¥l;.;Ml‘—¥—„uYD;.;-$$.Ml}}YRMRu‹‹uuu‹‹ulRDDMDDDDRYRD$$-$$$-$.-$$$$$-RYl}‘«´´´´´««—D-lY-$-$$$$$$$-.M;;Y^RD;.--$...;;DD;;;DDDDDDDMRY^RMMMMMMRYYYYYYYYYYY^}‹¥¥¥«´««´´¥‘^;.;Mu‘——‹ulR;;..-$-;R}„^RMR^}‹„u}„‘„lYMMDDDDMMYRM.$-$$$$$$$$$$$$.$$$$.u‹‘—««´´´´´´«—M$^^-$-$$$$$$-D;D^lYDD;...D.;;;DM;DDDDDDDMMMR^^RRMMMMMRR^^YYY^YYRRRY^}„—«´»´´««—„R.;;Mu‘—‘„lRD;.;-$$-;R}‹lMDDR^}„l^u‹‹}YMMRMMMMMRRRM-$$--$$-$$$$-$--$$$$;}‘¥««´´´´´´´«¥R-Y}.-$$$$$$$-;DDY^RMMMD;;DD;DDMRMDDMDMMMMRMR^^YRMRRMRYYY^^YY^YYRRYY^^Y^u‹¥««—¥‘‹lM..;Mu——„}YM;;..$$.;R}‹^RDMR^}ull}„‘‹YMMDMRRRYMRYY;$$$$-$$$$$$--$$$$$-D‘¥««´´»»´´´´«¥^.M};-$$$$--$$$;DMYlYRMDRDDDDDDMMMMDDMMMMMRRMY^^RRRMMMR^^YYYYY^^^YY^uluu^^Y^u„‹—‘‹}^D..;R}‹‘}YRDD..-$-.Dl‹lYRR^„‘‘}}„‘¥‹^RMDDRRRRRRY^M--$---..--$-$--$$$$-Y—¥«´´»»»»»´´«¥}-;}M--$$$----$;MRY^YYRMRYRMMDDMRRMMMMMMRRRRMRRYYYYRRRY^^^YYYYYllY^uuu}„„}lllY^}‘—‹uY;..DR}‘‹lRDD;.-$--.Y„„lYRu‘¥‘„u‹——}YRDDDMMMMYYY^Y;$$.------$$$$$--$$$$.}—«´´»»»»´»»´´«‹..}Y--$$$$$$$--$;MYYlllRMR^^RDDDMRMDDMRRMMMRRMRYl^^YY^^l^^YYY^^^llY^luu}‹„„‹‘‹„}uu}‹„uM;..DR„‘uYDD;..-$-.Ml„u^l}‘—‘}}‹‘‹lRMMMRMMRRYMR^^R.$$$.-$$-$-$$---$$$--R‘««´´»»»»»»»´´«—D-uu-$$$$$$$---;RYluuYRRllRMMDRYRDMRMRRRRRRRYYll^^^lulll^^^lllu}YYY^luu}}‹—«¥¥‘‘}}„„lM..;;Y„„^RMD;.-$-.D^‹}lu‹——‹}‹——‹^RMMDMMDMRYMRYlY;$$$$-$$$----$-$$---M‹¥«´»»»»»»»»»´´¥Y-l„.$$$$--.;DR^}}^YYll^MMDRYYMRMMMRRRYYYY^llluu}uu}ull^lu}}}ll^YRYYY^u„—«¥««—‹}}}lR...;l‹}YRD;.--$--R„‘‹‹———‹‹—¥—}^MMDD;MMDMYMRYY^R-$$$$$$$$$$$--$-$$$$---;l¥«´»»»»»»»»»´´«u.Y„M$$$$$$--.;DRu„„uYRl}lRMMMYRDMRRRRYYYY^lluu„„‹‘„„„}l^lu}‹‹„u}}ll^RRYRYu„—¥¥¥¥„}uulM..;u}„uYR;..----.l„‹——‘‘——¥¥‘lRMMD;;DDMMMRRRYMRD$-$$$$$$$$$-.--.---$$--D‹¥´´´»»»»»»»»´´«„DRuM$$$$$$-..;D^‹‹}YR^„u^RMRYMMMRRYRRRY^^ll}‹‘‹—‘‘‘‘‹uuu„‘‘‘‘RYY^uulluu^Yl}„}„‹‘}}uulD..R^}„lR;;.----.;Rl„„‘‘¥¥¥—„lRMMDDD;MMMDDMRYMDM--$$$$--$$$--;;.---$$$-$$;‘¥«´´´»»»»»»»»´«‘^MlY$$$$$$$$--;Y‹‹„lRYuu^RRYYRMRRRRYYYRYY^}‹‘‘———¥¥—‹„}‘——¥——YRRRY^u}„„}ll„uY^uulu„}}Y;..;R„„^M;.-$---.;MRlu‹‘¥¥—}lRD;DMDDMDMDDDRR^YD-$$$-$.$$-..;;;$$$$$-$$.‹¥««´´´´»»»»»»´«—u.^l$$$$$$$-.M}‹‹}YY}}lYMRRRRYYYYYRYYYYu„‹—‘———¥¥—‹‹‘¥¥«¥¥¥ul^^YRR^u}}u}‘‘u^^^^ll}uYD...D^‘}RD.--$--.;;MRl„‹‹—„lRRDDMMMDMRRM;DRR^^R;-$$--$$-....$$$$$$$$-M‘¥«´»´´»»»»»»´¥¥}.Ml;$$$$$$$$$--Dl‹‘}RYu}lYRR^YYYYYRYYRYY^}„‘‹‘——¥—¥‹‹—«´´´´´«„}u}}lRMR^}}„‘—¥‘}^ll^uu^M;...M}„^M;------.;DMYlu‹‹„^RD;MMMDMR^^YRRRRYlYR.$-$--$$$$$$$$$--$$--M‹««´»»»»»»»´«¥—‹;D}Y$$$$$$$$$.Dl‹‘„^Yl}uRMRYRRRRRMRRRYY^}„„„„‘—‘—‘‘¥«´´»»´»»uul}„}YMMMYu„‹—¥—¥‹u^^lulYM...;Y‹„YD..-$---.DMR^}‹‘‹lRMDDDMDMRlul^RYYR^YY;$$$---$-$$$$$$$$-$$$$---l¥«´´´´»´´´´¥¥—„.;uR$$$$$$$$$$-;Y‹‘„l^u„lYMRYRRYRMMRRYY^lu}}}‹‘‘‘„‘—´«´´»»»»»}uuu„„}YMDDM^„‘¥¥«´¥„l^^^lRD..;;u‹}M..---$-.;;DRl‹—‹^YMDD;DMDRl‹}uYYRYYYY;-$$$$$---$$-----$$$$$$--R—««´´´´´´««¥¥—l--lY$$$$--$$$$$$$$-M}‹„lYl„}^RRRRRRMRRRRY^^l^lu}„‘¥‘‘—«´»»»»»»ÃË‹„„‹‘‹„^RDDMR}‘¥«´´«‘}^YRRR;;.;R}„YD..-----.;DM^‹—‹^RMDD;D;RY}‘—„lYRYY^YR.-$$$$$-.-$$$--....-$$$$$$--l—¥«´«´««‹‹‘‘‘u-$^u$$$$$$$-$$$$$$$$$-;u„„}Yl}}^RRRRYRYRRRRR^^^^l^u„‹‹‘—««´»»»»»»»»‹‹‹‹‹‘‹‹„u^RDDM^„—«´´«—„^MRYR...;Mu^M;.----.;DDDY}—}YMDD;;D;R^‘——„l^RYYlYR.-$$$-$-.--$$$--...$$---$-$D„—««««¥„;;M^lR-$^}.-$$$$$$$$$$$$$$$$$$.^‹‹„ll}}uRRRRRR^RRRRYY^^^^^}}}„‹—¥¥´´»»»»´´»——‘‘¥‘‹„‘‘‹uYRMM^‹—¥´´¥‘u^YRY;..;;^„RD...--..D;.;Y‹}RMD;;;DDYu‘——„}lY^Y^lMD-$$-----$-$-$$$$$-;-$-$-.„—¥¥¥—R-$$$$$--Y„D$$$$$$-$$$$$$$$$$$.Ru‹}^l}„lRRRYY^YYRRRYY^YYYl^l}„‘—¥´´´»»»´´»Ã¥¥‘——‘‹‹‘‘‘„u^YRMl„‘¥´´¥l^RRRM;..;MulM;;..-....--D^uRMD;;;DMY„—¥——‹Y^YYll^R.-$---$$$$$$$$$$---$-$-$;Y}}uu.$$$$$$-M„Y-$$$$$$$-----$$$$$$$$$$.;Y„„l^u}^YRYY^^^^YYR^YYYMMYl}„‹——«»»»»»´»´Ã×—‘‘—‘——‘—‹‹„ulRMRl„‘¥«¥„YYRMMD;.;;Y}^D;..---.-.DY}lRMD;;DMRl‹¥««¥„lYYYYllR.-$$--$$$$$$$-$$-$$--$-$-$$$$$---$$$$-D„^-$$$$$$$$-----$$$$$$$$$$-.D„‹}^uu^Y^Y^l^^^YYYYRRMMMRl}‹‘—«´»´´´´»»»ÃÃ¥¥«´««¥———‘‹‘‘„ulYYu‘«««‘u^YMMDD;.;Ml}RD....--..Ml‹uMM;;DMR^„¥¥¥¥¥‹u^YY^ulY;$$$-$$$$$$$$$$$$$$$$$--$$$--$-$-$$$$$$--$$$$$;„}.-$$$$$$$$$$$----$$$$$$$$$-.M}‹u^uul^^^ll^^YYY^YYRMDMRu}‹—««»»´´««»»ÃÃÃ¥«»Ãû´´«´¥—¥———‘‹}u‘´´´¥„l^YMDD;;;;R}uM;....--..u‹^MD;;MRY^‹¥¥¥¥¥‘}^^Y^^u^D-$$-$$$$$$--$$$$$$$$$----$---$-$--$$$$..$$$-u„;-$$$$$$$$$$$----$$$$$-$$$--D}‘‹ulu^^Y^l}^YYYRYYYRDDDYu„—¥¥´»»´´´´»»ÃÃÃ¥«ÃÍÃû´´«¥—¥—¥¥¥¥‘‘‘«´´¥‹ul^YRDD;;;D^}Y;.;..---.Y„YRDDDDR^}‘¥—¥¥¥‘„^^YY^uuM-$$$-$$$$$$$$$----$$------$----$$--$$$$$--$$$Y‹M--$$$$$$$$$$-----$$$$$$$$-.D}‹‹ull^Y^lu}l^RYRYYYMDDM^}‘—«´´»»´´´´»»»»»‘—»ÃÃÃÃû«—‘}„‹‘‘‘———‘¥¥—‘„}}l^MD;;;;MuuM;....--.RlYYMDDDR^‹¥——‘—¥‘„lYYY^ulR.-$-$$$$$$$$-$--$---$------------$--$$$$$$$$$$$M„Y.---$-$$$$$--...--$$$$-$--.Du‹‹uu}lYYl}„llYYYYYRMDMRl„—««´´´´¥´´´´´««¥‹‘«»ÍÍÃÍô´—‹}l^^^ll^^^ll^lluu}YMD;;;;RuYD;.....;M^YYMMDMR}—¥————¥‘lYYYRYlu^D----$$$$$$$-----$-$-$-..-----.-.---$$$$$$$$$$$$$$;„l.-----$-$$$-..-..-$-$$$$--;Du‹„}}}uYYl„ul^Y^Y^YMMDRRl„—¥¥—¥—¥—¥«««¥¥¥¥„‹‘´ÃÍÃÃÃÃÃô«¥‹u^^YRRMMMMMR^„‘}YD;;;;Dl}M;;....;RulYMMMMY‘¥¥—«¥¥—‹lY^YYYYl^M..---$$-$$---$--------....---....-.-$$$$$$$$$$$$$$-u„;------$-$------..-$-$-$--.Ru}ul}‹uY^l}}^l^l^^^MMDDR^}‹‹‹„}}„‘‘——‘‘‘‘¥u}‘¥´ÃûÃÃÃÃû´«——‘„}ull^ll}„‘¥—uMD;;;;M}Y;;;..;;Y‹uRMMMY}—¥¥¥¥«¥—‘ulYYYYY^uR;-..-----$--....-..---;;;;.--.D;--.---$$$$$$$$$$$$-^‹;---.------....;;..---$--.;Rlul^„‹}^^l}}lY^^^^YMDDDRYuuuulluu„‹‹‹‹‹‘¥«lu‹—´»»»Ã»»»»Ãû»»»««´¥«««««—‘—¥‘lMD;;;;MYD;;.;.Dl‹lRMRR^‘«´¥¥¥¥«¥‘}^YYYRM^}RD-...------...DD.;.---;DD..--..;.;...-$$--$-$-$$$$$R‹R--.-...-..;.;;.;;.--$---.;R^l^l}‹}^^l}}l^^^^^YMDDMRY^^l^llu}‹„„„„„—«»}u„‘«´«»Ãû»»»»»ÃÃÃû»»»»´´´«¥¥«—„YDD;;;;MM;;;.;Du„uYRRY}—´«¥¥¥¥¥¥—‹uYYYRY^uYD..;-------.;.;;;;.....D;......;;;...--$--$--$--$--;‹^---.....;.;;;;..;..-----.;MYllu„‹}l^luu^^^^^^RDDDMMRYY^l^uu}uuu}„—«´´‹„‹‘¥««´´ÃÃû»»´ÃÃÃÃûû»»Ã´«¥««¥„lRDD;;;DDD;;;;Mu‹uYRYl‹«««««¥—¥«‘‹lYRYRRYlYM.;..--.---;;.;;;.;;...;;;.....;.;...--------------.‹u----..;;.;.D;;..;..----..DR^l^u}‹ul^l^l^^Y^^YMDDMMRRRRY^^llulu}„‹¥«««‹„„‹¥¥—¥«´»»»»»´´ÃÃÃû»Ã»»´´«««´«‹u^DD;;;;;D;;;;Mu‹u^YY}—´««¥«¥—¥«—}^RRRRR^^^M;;;........;;;D;;.;;;..;;...;;.;.....--.----------.}„;----..;.;;;D;;;.;.-----.DY^^ll„‹}^lY^Y^lY^^RMDDMMRRRRY^^lluul}„‘‘¥‘¥„„}‹‹—‘—¥¥´´»»»»´»»»Ã»»»»´«¥««««¥‘}^MD;;;;;;D;;;M}„}^^u—´«¥¥««¥¥¥¥‘u^YY^^^^lYR;;;;..;...;;.DD;;;.;..;.;....;.;;..;.--.-----------l‹D-----.;..;;;D;;;...---..DYlY^u„‹}l^YYYYY^YYMMDMMMRMRRYY^^^llu}„„}„‹‹ \ No newline at end of file diff --git a/PixHtLab-Src/Docker/imagen/meta.yaml b/PixHtLab-Src/Docker/imagen/meta.yaml new file mode 100644 index 0000000000000000000000000000000000000000..bb4921a9e027c330b2805becc7f8a9591d604311 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/meta.yaml @@ -0,0 +1,27 @@ +package: + name: imagen + version: 2.1 + +source: + path: . + +requirements: + build: + - python + - setuptools + run: + - python + - param + - numpy + - pillow + - holoviews + +test: + imports: + - imagen + +about: + home: http://ioam.github.io/imagen/ + summary: Generic Python library for 0D, 1D, and 2D pattern distributions + license: BSD + diff --git a/PixHtLab-Src/Docker/imagen/setup.py b/PixHtLab-Src/Docker/imagen/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..0430e33a36165e999514480d0d5e26e7d7bfed6b --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/setup.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python + +import os, sys +from distutils.core import setup + +setup_args = {} + +############################################################################################# +##### CEBALERT: copied from topographica; should be simplified + +required = {'param':">=1.3.1", + 'numpy':">=1.0", + 'holoviews':">=1.0.1"} + +# could add tkinter, paramtk +# optional = {} + +packages_to_install = [required] +packages_to_state = [required] + +setup_args = {} + +if 'setuptools' in sys.modules: + # support easy_install without depending on setuptools + install_requires = [] + for package_list in packages_to_install: + install_requires+=["%s%s"%(package,version) for package,version in package_list.items()] + setup_args['install_requires']=install_requires + setup_args['dependency_links']=["http://pypi.python.org/simple/"] + setup_args['zip_safe']=False # CEBALERT: probably ok for imagen; haven't checked + +for package_list in packages_to_state: + requires = [] + requires+=["%s (%s)"%(package,version) for package,version in package_list.items()] + setup_args['requires']=requires + +############################################################################################# + + +setup_args.update(dict( + name='imagen', + version="2.1.0", + description='Generic Python library for 0D, 1D, and 2D pattern distributions.', + long_description=open('README.rst').read() if os.path.isfile('README.rst') else 'Consult README.rst', + author= "IOAM", + author_email= "developers@topographica.org", + maintainer= "IOAM", + maintainer_email= "developers@topographica.org", + platforms=['Windows', 'Mac OS X', 'Linux'], + license='BSD', + url='http://ioam.github.com/imagen/', + packages = ["imagen", + "imagen.transferfn"], + package_data={}, + classifiers = [ + "License :: OSI Approved :: BSD License", + "Development Status :: 5 - Production/Stable", + "Programming Language :: Python :: 2.7", + "Programming Language :: Python :: 3.5", + "Programming Language :: Python :: 3.6", + "Programming Language :: Python :: 3.7", + "Operating System :: OS Independent", + "Intended Audience :: Science/Research", + "Intended Audience :: Developers", + "Natural Language :: English", + "Topic :: Scientific/Engineering", + "Topic :: Software Development :: Libraries"] +)) + + +def check_pseudo_package(path): + """ + Verifies that a fake subpackage path for assets (notebooks, svgs, + pngs etc) both exists and is populated with files. + """ + if not os.path.isdir(path): + raise Exception("Please make sure pseudo-package %s exists." % path) + else: + assets = os.listdir(path) + if len(assets) == 0: + raise Exception("Please make sure pseudo-package %s is populated." % path) + + +if __name__=="__main__": + if ('upload' in sys.argv) or ('sdist' in sys.argv): + import imagen + imagen.__version__.verify(setup_args['version']) + + setup(**setup_args) diff --git a/PixHtLab-Src/Docker/imagen/tests/__init__.py b/PixHtLab-Src/Docker/imagen/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/PixHtLab-Src/Docker/imagen/tests/test_line.py b/PixHtLab-Src/Docker/imagen/tests/test_line.py new file mode 100644 index 0000000000000000000000000000000000000000..6b6a2fbb68a6e3d87a2a3c50d9b60866ff78d614 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/tests/test_line.py @@ -0,0 +1,67 @@ +from numpy import pi, where + +import imagen +from holoviews.core.boundingregion import BoundingBox + +try: + import unittest2 as unittest +except ImportError: + import unittest + +class LineTest(unittest.TestCase): + """Tests the behavior of the line pattern, + particularly for small thicknesses""" + + def minimal_line_thickness(self,c): + """ + help function used by the test_* functions. + + It checks that the line width is of one pixel + """ + radius = c['radius'] + bounds=BoundingBox(radius = radius) + xdensity = c['density'] + ydensity = c['density'] + x=c['x'] + for orientation in [0, pi/4, pi/2]: + c['orientation'] = orientation + im = imagen.Line( + scale=1,offset=0,orientation=orientation, + enforce_minimal_thickness=True, + thickness=0.0,x=x, y=0., + smoothing=0.0, + xdensity=xdensity, ydensity=ydensity, + bounds=bounds)() + number_of_ones=(im==1).sum() + if orientation==pi/4: + y_crossing=where(im[:,-1]>=1)[0][0] + else: + y_crossing=0.0 + width_in_pixels = 2*radius*ydensity-y_crossing + msg = """ + Thickness of the line should be of one pixel. + Actual line has an everage thickness of: %f. + Experimental conditions: + """ % (number_of_ones/float(width_in_pixels)) + str(c) + self.assertEqual( + number_of_ones, width_in_pixels, + msg=msg + ) + + def test_minimal_line_thickness_density20_x_jitter(self): + c = {'radius':5, 'density': 20, 'x': -0.001/20}; self.minimal_line_thickness(c) + + def test_minimal_line_thickness_density20_x0(self): + c = {'radius':5, 'density': 20, 'x': 0.}; self.minimal_line_thickness(c) + + def test_minimal_line_thickness_density100_x0(self): + c = {'radius':1, 'density': 100, 'x': 0.}; self.minimal_line_thickness(c) + + def test_minimal_line_thickness_density1000_x0(self): + c = {'radius':0.1,'density': 1000,'x': 0.}; self.minimal_line_thickness(c) + + def test_minimal_line_thickness_density20_x2(self): + c = {'radius':5, 'density': 20, 'x': 2.}; self.minimal_line_thickness(c) + +if __name__ == '__main__': + unittest.main() diff --git a/PixHtLab-Src/Docker/imagen/tests/testpatterngenerator.py b/PixHtLab-Src/Docker/imagen/tests/testpatterngenerator.py new file mode 100644 index 0000000000000000000000000000000000000000..977885bcea2951b4bfc6354084bd2673e225c3e3 --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/tests/testpatterngenerator.py @@ -0,0 +1,245 @@ +""" +Tests PatternGenerator (position and orientation), and some of the +basic patterns. + +Original written as a unit test as part of the Topographica project. +""" + +import os +import unittest + + +cwd = os.path.abspath(os.path.split(__file__)[0]) + +import param +import numpy as np +from numpy.testing import assert_array_equal +from holoviews.core.boundingregion import BoundingBox +from imagen import Constant,PatternGenerator +from imagen import Rectangle,Gaussian,Composite,Selector +import numbergen + + + +class TestPatternGenerator(unittest.TestCase): + + def test_a_basic_patterngenerator(self): + pattern_bounds = BoundingBox(points=((0.3,0.2),(0.5,0.5))) + + pattern_target = np.array([[1,1], + [1,1], + [1,1]]) + + r = Rectangle(bounds=pattern_bounds,xdensity=10, + ydensity=10,aspect_ratio=1,size=1,smoothing=0.0) + assert_array_equal(r(),pattern_target) + + + def test_constant(self): + """ + Constant overrides PatternGenerator's usual matrix creation. + """ + pattern_bounds = BoundingBox(points=((0.3,0.2),(0.5,0.5))) + + pattern_target = np.array([[1,1], + [1,1], + [1,1]]) + + c = Constant(bounds=pattern_bounds,xdensity=10.0,ydensity=10) + assert_array_equal(c(),pattern_target) + + + def test_position(self): + """ + Test that a pattern is drawn correctly at different + locations. + """ + + initial = np.array([[0,0,0,0], + [0,1,1,0], + [0,1,1,0], + [0,0,0,0]]) + + r = Rectangle(bounds=BoundingBox(radius=2),xdensity=1, + ydensity=1,aspect_ratio=1,size=2,smoothing=0.0) + assert_array_equal(r(),initial) + + ### x offset + x_offset = np.array([[0,0,0,0], + [0,0,1,1], + [0,0,1,1], + [0,0,0,0]]) + + assert_array_equal(r(x=1),x_offset) + + ### y offset + y_offset = np.rot90(x_offset) + assert_array_equal(r(y=1),y_offset) + + ### x and y offset + target = np.array([[0,0,0,0,0,0,0,0,0,0], + [0,0,0,0,0,0,0,0,0,0], + [0,0,0,0,0,0,0,0,0,0], + [0,0,0,0,0,0,0,0,0,0], + [0,0,0,0,0,0,0,0,0,0], + [0,0,0,0,0,0,0,0,0,0], + [1,1,0,0,0,0,0,0,0,0], + [1,1,0,0,0,0,0,0,0,0], + [1,1,0,0,0,0,0,0,0,0], + [1,1,0,0,0,0,0,0,0,0]]) + + width = 0.2 + height = 0.4 + + r = Rectangle(bounds=BoundingBox(radius=0.5), + xdensity=10,ydensity=10,smoothing=0.0, + aspect_ratio=width/height,size=height) + + assert_array_equal(r(x=-0.4,y=-0.3),target) + + ### x and y offset with bounds offset by the same + target = np.array([[0,0,0,0,0,0,0,0,0,0], + [0,0,0,0,0,0,0,0,0,0], + [0,0,0,0,0,0,0,0,0,0], + [0,0,0,0,1,1,0,0,0,0], + [0,0,0,0,1,1,0,0,0,0], + [0,0,0,0,1,1,0,0,0,0], + [0,0,0,0,1,1,0,0,0,0], + [0,0,0,0,0,0,0,0,0,0], + [0,0,0,0,0,0,0,0,0,0], + [0,0,0,0,0,0,0,0,0,0]]) + + width = 0.2 + height = 0.4 + + bounds = BoundingBox(points=((-0.9,-0.8),(0.1,0.2))) + r = Rectangle(bounds=bounds,xdensity=10,ydensity=10,smoothing=0.0, + aspect_ratio=width/height,size=height) + + assert_array_equal(r(x=-0.4,y=-0.3),target) + + + + def test_orientation_and_rotation(self): + """ + Test that a pattern is drawn with the correct orientation, + and is rotated correctly. + """ + ### Test initial orientation and 90-degree rotation + target = np.array([[0, 0, 0, 0, 0, 0], + [0, 0, 1, 1, 0, 0], + [0, 0, 1, 1, 0, 0], + [0, 0, 1, 1, 0, 0], + [0, 0, 1, 1, 0, 0], + [0, 0, 0, 0, 0, 0]]) + + bounds = BoundingBox(radius=0.3) + xdensity = 10 + ydensity = 10 + width = 2.0/xdensity + height = 4.0/ydensity + + rect = Rectangle(size=height, + aspect_ratio=width/height,smoothing=0.0, + xdensity=xdensity,ydensity=ydensity,bounds=bounds) + + assert_array_equal(rect(),target) + assert_array_equal(rect(orientation=np.pi/2),np.rot90(target)) + + + ### 45-degree rotation about the origin + rot_45 = np.array([[0, 0, 0, 0, 0, 0], + [0, 0, 1, 0, 0, 0], + [0, 1, 1, 1, 0, 0], + [0, 0, 1, 1, 1, 0], + [0, 0, 0, 1, 0, 0], + [0, 0, 0, 0, 0, 0]]) + + assert_array_equal(rect(orientation=np.pi/4),rot_45) + + + ### 45-degree rotation that's not about the origin + rot_45_offset = np.array([[0, 1, 0, 0, 0, 0], + [1, 1, 1, 0, 0, 0], + [0, 1, 1, 1, 0, 0], + [0, 0, 1, 0, 0, 0], + [0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0]]) + + assert_array_equal(rect(x=-1.0/xdensity,y=1.0/ydensity,orientation=np.pi/4), + rot_45_offset) + + + + def test_composite_pattern_basic(self): + """ + Test that a composite pattern consisting of just one Gaussian + is the same as that actual Gaussian pattern, and that a + composite pattern of two rectangles is the same as adding the + two individual matrices. + """ + bbox=BoundingBox(radius=0.5) + g = Gaussian(size=0.2,aspect_ratio=0.5,orientation=0,x=0.2,y=-0.03) + c = Composite(generators=[g],bounds=bbox,xdensity=7,ydensity=7) + assert_array_equal(g(bounds=bbox,xdensity=7,ydensity=7),c()) + + r1=Rectangle(size=0.2,aspect_ratio=1,x=0.3,y=0.3,orientation=0,smoothing=0.0) + r2=Rectangle(size=0.2,aspect_ratio=1,x=-0.3,y=-0.3,orientation=0,bounds=BoundingBox(radius=0.8),xdensity=2,smoothing=0.0) + c_true = r1(bounds=bbox,xdensity=7,ydensity=7)+r2(bounds=bbox,xdensity=7,ydensity=7) + c = Composite(generators=[r1,r2],bounds=bbox,xdensity=7,ydensity=7) + assert_array_equal(c(),c_true) + + + def test_composite_pattern_moves(self): + """ + Test that moving a composite pattern yields the correct pattern. + """ + bbox=BoundingBox(radius=0.5) + g = Gaussian(size=0.2,aspect_ratio=0.5,orientation=np.pi/3,x=0,y=0) + c = Composite(generators=[g],x=-0.3,y=0.4,xdensity=4,ydensity=4,bounds=bbox) + g_moved = g(x=-0.3,y=0.4,xdensity=4,ydensity=4,bounds=bbox) + + assert_array_equal(c(),g_moved) + + # Should also test rotating, resizing... + + def test_bug__dynamic_param_advanced_by_repr(self): + """Check for bug where repr of a PatternGenerator causes a DynamicNumber to change.""" + # CEB: can probably remove this test now we have time-controlled dynamic parameters + + p=PatternGenerator(x=numbergen.UniformRandom(lbound=-1,ubound=1,seed=1)) + + with param.Dynamic.time_fn as t: + t(0) + x0 = p.x + t(1) + x1 = p.x + self.assertNotEqual(x0,x1) # check we have setup something that actually changes + + x2 = p.inspect_value('x') + repr(p) + x3 = p.inspect_value('x') + self.assertEqual(x2,x3) # value of x should not have been changed by repr(p) + + + +# CB: does not test most features of Selector! +class TestSelector(unittest.TestCase): + + def setUp(self): + self.g1 = Gaussian(x=numbergen.UniformRandom()) + self.g2 = Gaussian(x=numbergen.UniformRandom()) + self.s = Selector(generators=[self.g1,self.g2]) + self.s.set_dynamic_time_fn(None,'generators') + + def test_dynamic_index(self): + """index should always vary""" + self.assertNotEqual(self.s.index,self.s.index) + + def test_dynamic_inheritance(self): + """time_fn should have been applied to subpatterns""" + self.assertNotEqual(self.g1.x,self.g1.x) + +if __name__ == "__main__": + import nose + nose.runmodule() diff --git a/PixHtLab-Src/Docker/imagen/tests/testtimedependentrandom.py b/PixHtLab-Src/Docker/imagen/tests/testtimedependentrandom.py new file mode 100644 index 0000000000000000000000000000000000000000..3de1a1f26fb38507cfcca473e8e943566dea8e5d --- /dev/null +++ b/PixHtLab-Src/Docker/imagen/tests/testtimedependentrandom.py @@ -0,0 +1,144 @@ +""" +Unit tests for time-dependent random imagen patterns. +""" + +from imagen.random import UniformRandom, RandomGenerator +import unittest +import param + +import numpy as np +from numpy.testing import assert_almost_equal + + +class TestTimeDependentRandom(unittest.TestCase): + """ + These tests focus on the UniformRandom pattern as an example of + time-dependent random streams. + """ + + def setUp(self): + param.Dynamic.time_dependent=None + self.time_fn= param.Time(time_type=int) + + + self.non_td_t0 = np.array([[ 0.42126358, 0.31223736, 0.6377056 ], + [ 0.39064891, 0.41890129, 0.03101435], + [ 0.67184411, 0.09738222, 0.46043459]]) + + self.non_td_t1 = np.array([[ 0.26362267, 0.55429345, 0.46786591], + [ 0.10548665, 0.35680933, 0.95669633], + [ 0.9689579 , 0.77990637, 0.55152049]]) + + self.td_p1_t0 = np.array([[ 0.33532388, 0.60655109, 0.64335319], + [ 0.79866631, 0.97845841, 0.81552961], + [ 0.80266319, 0.22363254, 0.00939643]]) + + self.td_p2_t0 = np.array([[ 0.95266048, 0.13381049, 0.69471505], + [ 0.12987513, 0.67797684, 0.00453637], + [ 0.09066964, 0.31480213, 0.67968573]]) + + self.td_p1_t1 = np.array([[ 0.60069123, 0.28276134, 0.21280783], + [ 0.57636133, 0.53144412, 0.29766811], + [ 0.60853213, 0.06351663, 0.03819535]]) + + self.td_p2_t1 = np.array([[ 0.40411503, 0.26346125, 0.39546975], + [ 0.95572014, 0.28943148, 0.26373155], + [ 0.61059597, 0.81626189, 0.16745686]]) + + def test_non_time_dependent(self): + param.Dynamic.time_dependent=None + param.Dynamic.time_fn = self.time_fn + pattern = UniformRandom(name='test1', xdensity=3, ydensity=3) + + t0 = pattern() + t1 = pattern() + + assert_almost_equal(t0, self.non_td_t0, err_msg="UniformRandom output doesn't match reference (t0).") + if np.allclose(t0, t1): + raise self.failureException("UniformRandom output hasn't changed between calls.") + assert_almost_equal(t1, self.non_td_t1, err_msg="UniformRandom output doesn't match reference (t1).") + + + def test_time_dependent_t0(self): + RandomGenerator.time_dependent = True + RandomGenerator.time_fn = self.time_fn + + self.assertEqual(self.time_fn(), 0) + + pattern1 = UniformRandom(name='test1', xdensity=3, ydensity=3) + pattern2 = UniformRandom(name='test2', xdensity=3, ydensity=3) + + p1_t0 = pattern1() + p2_t0 = pattern2() + + assert_almost_equal(p1_t0, self.td_p1_t0, + err_msg="UniformRandom output doesn't match reference (pattern 1 @ t0).") + + assert_almost_equal(p2_t0, self.td_p2_t0, + err_msg="UniformRandom output doesn't match reference (pattern 2 @ t0).") + + assert_almost_equal(pattern1(), p1_t0, + err_msg = "Output shouldn't change between calls (pattern 1).") + + assert_almost_equal(pattern2(), p2_t0, + err_msg = "Output shouldn't change between calls (pattern 2).") + + if np.allclose(pattern1(), pattern2()): + raise self.failureException("UniformRandom with different names should have different output") + + + def test_time_dependent_t1(self): + RandomGenerator.time_dependent = True + RandomGenerator.time_fn = self.time_fn + + self.time_fn.advance(1) + self.assertEqual(self.time_fn(), 1) + + pattern1 = UniformRandom(name='test1', xdensity=3, ydensity=3) + pattern2 = UniformRandom(name='test2', xdensity=3, ydensity=3) + + p1_t1 = pattern1() + p2_t1 = pattern2() + + assert_almost_equal(p1_t1, self.td_p1_t1, + err_msg="UniformRandom output doesn't match reference (pattern 1 @ t1).") + + assert_almost_equal(p2_t1, self.td_p2_t1, + err_msg="UniformRandom output doesn't match reference (pattern 2 @ t1).") + + assert_almost_equal(pattern1(), p1_t1, + err_msg = "Output shouldn't change between calls (pattern 1).") + + assert_almost_equal(pattern2(), p2_t1, + err_msg = "Output shouldn't change between calls (pattern 2).") + + if np.allclose(pattern1(), pattern2()): + raise self.failureException("UniformRandom with different names should have different output") + + + def test_time_dependent_time_switch_pattern1(self): + RandomGenerator.time_dependent = True + RandomGenerator.time_fn = self.time_fn + + pattern1 = UniformRandom(name='test1', xdensity=3, ydensity=3) + + p1_t0 = pattern1() + self.time_fn.advance(1) + p1_t1 = pattern1() + self.time_fn.advance(-1) + p1_t0_2 = pattern1() + + assert_almost_equal(p1_t0, self.td_p1_t0, + err_msg="UniformRandom output doesn't match reference (pattern 1 @ t0).") + + assert_almost_equal(p1_t1, self.td_p1_t1, + err_msg="UniformRandom output doesn't match reference (pattern 1 @ t1).") + + assert_almost_equal(p1_t0_2, self.td_p1_t0, + err_msg="UniformRandom output doesn't match reference (pattern 1 @ t0).") + + + +if __name__ == "__main__": + import nose + nose.runmodule() diff --git a/PixHtLab-Src/Docker/pixht.def b/PixHtLab-Src/Docker/pixht.def new file mode 100644 index 0000000000000000000000000000000000000000..85f6b4abdf6d621de7b4ffb9365921ff247e9b71 --- /dev/null +++ b/PixHtLab-Src/Docker/pixht.def @@ -0,0 +1,14 @@ +bootstrap: docker +From: yichensheng/pixht + +Stage: build + +%post + export DEBIAN_FRONTEND=noninteractive + # apt-get update && apt-get install -y netcat && apt-get install -y ffmpeg + NOW=`date` + echo "export NOW=\"${NOW}\"" >> $SINGULARITY_ENVIRONMENT + echo "export SHELL=/bin/bash" >> $SINGULARITY_ENVIRONMENT + +%environment + export SHELL=/bin/bash diff --git a/PixHtLab-Src/Docker/zsh-in-docker.sh b/PixHtLab-Src/Docker/zsh-in-docker.sh new file mode 100644 index 0000000000000000000000000000000000000000..9a2ffbb59ee3f019265e5fc971e7ee8995d3168f --- /dev/null +++ b/PixHtLab-Src/Docker/zsh-in-docker.sh @@ -0,0 +1,175 @@ +#!/bin/sh + +####################################################################################################### +# MIT License (MIT) +# Copyright 2019 Deluan Quintao +# +# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +# associated documentation files (the "Software"), to deal in the Software without restriction, +# including without limitation the rights to use, copy, modify, merge, publish, distribute, +# sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all copies or +# substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +# NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +# OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +####################################################################################################### + +set -e + +THEME=default +PLUGINS="" +ZSHRC_APPEND="" + +while getopts ":t:p:a:" opt; do + case ${opt} in + t) THEME=$OPTARG + ;; + p) PLUGINS="${PLUGINS}$OPTARG " + ;; + a) ZSHRC_APPEND="$ZSHRC_APPEND\n$OPTARG" + ;; + \?) + echo "Invalid option: $OPTARG" 1>&2 + ;; + :) + echo "Invalid option: $OPTARG requires an argument" 1>&2 + ;; + esac +done +shift $((OPTIND -1)) + +echo +echo "Installing Oh-My-Zsh with:" +echo " THEME = $THEME" +echo " PLUGINS = $PLUGINS" +echo + +check_dist() { + ( + . /etc/os-release + echo "$ID" + ) +} + +check_version() { + ( + . /etc/os-release + echo "$VERSION_ID" + ) +} + +install_dependencies() { + DIST=$(check_dist) + VERSION=$(check_version) + echo "###### Installing dependencies for $DIST" + + if [ "$(id -u)" = "0" ]; then + Sudo='' + elif which sudo; then + Sudo='sudo' + else + echo "WARNING: 'sudo' command not found. Skipping the installation of dependencies. " + echo "If this fails, you need to do one of these options:" + echo " 1) Install 'sudo' before calling this script" + echo "OR" + echo " 2) Install the required dependencies: git curl zsh" + return + fi + + case $DIST in + alpine) + $Sudo apk add --update --no-cache git curl zsh + ;; + amzn) + $Sudo yum update -y + $Sudo yum install -y git curl zsh + $Sudo yum install -y ncurses-compat-libs # this is required for AMZN Linux (ref: https://github.com/emqx/emqx/issues/2503) + ;; + *) + $Sudo apt-get update + $Sudo apt-get -y install git curl zsh locales + if [ "$VERSION" != "14.04" ]; then + $Sudo apt-get -y install locales-all + fi + $Sudo locale-gen en_US.UTF-8 + esac +} + +zshrc_template() { + _HOME=$1; + _THEME=$2; shift; shift + _PLUGINS=$*; + + if [ "$_THEME" = "default" ]; then + _THEME="powerlevel10k/powerlevel10k" + fi + + cat < "$HOME"/.zshrc + +# Install powerlevel10k if no other theme was specified +if [ "$THEME" = "default" ]; then + git clone --depth 1 https://github.com/romkatv/powerlevel10k "$HOME"/.oh-my-zsh/custom/themes/powerlevel10k + powerline10k_config >> "$HOME"/.zshrc +fi diff --git a/PixHtLab-Src/README.md b/PixHtLab-Src/README.md new file mode 100644 index 0000000000000000000000000000000000000000..fc27350270a5f23018fece7272a6de1b2d1d9dc0 --- /dev/null +++ b/PixHtLab-Src/README.md @@ -0,0 +1,151 @@ +# PixHtLab +This is the source code([[**Paper**](https://arxiv.org/pdf/2303.00137.pdf)] [[**SSN Demo**](#ssn-demo)] [[**SSN Training**](#ssn-training)] [[**PixHtLab Demo**](#pixhtlab-demo)] [[**SSG & PixHtLab Training**](#pixhtlab-training)]) repository for three papers: + + +* [(CVPR 2023 highlight) PixHt-Lab: Pixel Height Based Light Effect Generation for Image Compositing](https://arxiv.org/pdf/2303.00137.pdf) + +

    + +

    + +* [(ECCV 2022) Controllable Shadow Generation Using Pixel Height Maps](https://arxiv.org/pdf/2207.05385.pdf) + +

    + +

    + + +* [(CVPR 2021 oral) SSN: Soft Shadow Network for Image Composition](https://arxiv.org/abs/2007.08211) + +

    + +

    + +# SSN +We released the training codes, a gradio demo (also hosted in huggingface) and the training dataset. + +## Dataset +The training dataset can created by code provided in the SSN [old repo](https://github.com/ShengCN/SSN_SoftShadowNet). + +We provide a precomputed dataset composed of 558 different 3D models, which can be downloaded from our huggingface dataset repo. +See the [**ssn_dataset.hdf5**](https://huggingface.co/datasets/ysheng/SSN-SSG-PixHtLab/resolve/main/SSN/Dataset) file. + + +## SSN-Demo +A gradio-based GUI demo is provided in the `Demo/SSN` folder. First, download the [weight](https://huggingface.co/datasets/ysheng/SSN-SSG-PixHtLab/tree/main/SSN/weights) it used. +Then run the following code to see the demo: +``` bash +python app.py +``` + +## SSN-Training +The training codes are under `Train` folder. To reproduce the training process, first prepare the dataset discussed above, then run the following command: + +``` bash +cd Train + +# before running, try to check the setting in SSN.yaml. +# The YAML file assumes the dataset file path is: Train/Dataset/SSN/ssn_dataset.hdf5 +python app/Trainer.py --config configs/SSN.yaml +``` + +# SSG & PixHtLab +We find shadow can be rendered using pixel height maps. We further explored rendering in pixel height representation and found not only shadow can be rendered, 3D light effects (shadow, reflection, refractions, etc) can be rendered as well. So SSG can be viewed as a subset of PixHtLab. For simplicity, this repo directly release the code for PixHtLab. + +## Environment Setup +First, create a conda environment with python 3.9. + +```bash +conda create -n pixht python=3.9 -y +conda activate pixht +``` + +Then run the ``env.sh`` script. I noticed that the environment to setup the training framework is becoming to be a little tricky due to some python package updates. So I will build a Docker for the ease of use. + +```bash +bash env.sh +``` + +## Dataset +As the file is large (173G), the dataset file is put in Dropbox. Use this [link](https://www.dropbox.com/scl/fi/ux7wr5uz2rne6vu70eq2f/dataset.hdf5?rlkey=pzubhj41m6j1muj393j33iuzm&dl=0) to download. The advantage of Dropbox link is that you can use wget to download. + +```bash +# remember to cd to where you want to save the dataset file. +wget -O dataset.hdf5 https://www.dropbox.com/scl/fi/ux7wr5uz2rne6vu70eq2f/dataset.hdf5?rlkey=pzubhj41m6j1muj393j33iuzm&dl=0 +``` + + +## PixHtLab-Demo +For PixHtLab, we do not have Gradio demo as the computation relies on CUDA layer operation. The free Gradio demo on huggingface only provides CPU calculations. +Instead, I put a jupyter notebook in the ``Demo/PixhtLab/Demo.ipynb``. It provides an example to show how to use PixHtLab to render shadow and reflections. + +### Weight File +Soft shadow rendering needs pre-trained SSN. The weight can be downloaded from [here](https://www.dropbox.com/scl/fi/x1zmz5w4l0lyklqkjabq3/human_baseline_all_21-July-04-52-AM.pt?rlkey=4kbm1d7lah6d83ecftd2gch59&st=wqqgodx8&dl=0). Create a weight folder (weights) under ``Demo/PixhtLab/`` and put the weight there. Or use the following command to do this: + +```Bash +mkdir Demo/PixhtLab/weights +cd Demo/PixhtLab/weights + +# wget to download +wget -O human_baseline_all_21-July-04-52-AM.pt https://www.dropbox.com/scl/fi/7vzb0hlff0wbbb6l6qiyb/human_baseline_all_21-July-04-52-AM.pt?rlkey=lw34u1qao6had58t9vqy3bfbj&dl=0 +``` + +This demo weight is a little old. But it should be enough for most cases for demonstration. If you want better weight, you can try to replace this weight with the latest SSN [weight](https://huggingface.co/datasets/ysheng/SSN-SSG-PixHtLab/resolve/main/SSN/weights/0000001000.pt?download=true) discussed above. I have not tested if directly replacing the weight is OK. If it is not OK, try to replace the inference module using the above SSN inference module. + + +## PixHtLab-Training +The training codes are under `Train` folder. To reproduce the training process, first prepare the dataset discussed above. The dataset for SSG and SSN++ (sometimes I call it GSSN) is the same hdf5 file. Then run the following command: + +``` bash +cd Train + +# Before running, try to check the setting in SSG.yaml. +# The YAML file assumes the dataset file path is: Train/Dataset/SSG/dataset.hdf5 +python app/Trainer.py --config configs/SSG.yaml + +# or if you want to train SSN++ with 3D-aware buffer channels, try this: +# The YAML file assumes the dataset file path is: Train/Dataset/SSG/dataset.hdf5 +python app/Trainer.py --config configs/GSSN.yaml +``` + + +# Updates +- [x] [2023-03-16] Basic setup. +- [x] [2024-01-02] SSN dataset/demo/inference/training +- [x] [2024-02-20] (Sry, I was busy at that time.) SSG/PixhtLab dataset/demo/inference/training +- [x] [2024-02-20] Python environment setup +- [ ] Build a docker image + +# License +This code repo can only be used for non-commercial use only. + +# Citation +If you think the code/dataset is useful, please remember to cite the three papers: +``` +@inproceedings{sheng2023pixht, + title={PixHt-Lab: Pixel Height Based Light Effect Generation for Image Compositing}, + author={Sheng, Yichen and Zhang, Jianming and Philip, Julien and Hold-Geoffroy, Yannick and Sun, Xin and Zhang, He and Ling, Lu and Benes, Bedrich}, + booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition}, + pages={16643--16653}, + year={2023} +} + +@inproceedings{sheng2022controllable, + title={Controllable shadow generation using pixel height maps}, + author={Sheng, Yichen and Liu, Yifan and Zhang, Jianming and Yin, Wei and Oztireli, A Cengiz and Zhang, He and Lin, Zhe and Shechtman, Eli and Benes, Bedrich}, + booktitle={European Conference on Computer Vision}, + pages={240--256}, + year={2022}, + organization={Springer} +} + +@inproceedings{sheng2021ssn, + title={SSN: Soft shadow network for image compositing}, + author={Sheng, Yichen and Zhang, Jianming and Benes, Bedrich}, + booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition}, + pages={4380--4390}, + year={2021} +} +``` + + diff --git a/PixHtLab-Src/env.sh b/PixHtLab-Src/env.sh new file mode 100644 index 0000000000000000000000000000000000000000..5530f5a0aa81b81ae789b5fa454f8a4b79d70c17 --- /dev/null +++ b/PixHtLab-Src/env.sh @@ -0,0 +1,15 @@ +# conda create -n pixht python=3.9 -y +# conda activate pixht + +conda install pytorch==1.12.1 torchvision==0.13.1 torchaudio==0.12.1 cudatoolkit=11.3 -c pytorch -y + +cd Docker/imagen && pip install . && cd - && echo "Imagen Installed" + +cd Demo/PixhtLab/Torch_Render && pip install . && cd - && echo "Torch Render Installed" + + +pip install matplotlib pandas scipy dominate tensorboard opencv-python h5py jupyterlab PyQt5 gradio==3.45.0 +conda install conda-forge::meshplot -y + +pip install holoviews==1.17.0 +pip install --force-reinstall --user param==1.13.0 numpy==1.26.0