├── header.py
├── example.py
├── LICENSE
├── get_fixation.py
├── data
    └── README.md
├── saldat_saliency.py
├── head_orientation_lib.py
├── README.md
├── saldat_eval.py
├── Quaternion.py
├── saldat_head_orientation.py
└── sal_eval.ipynb


/header.py:
--------------------------------------------------------------------------------
1 | dirpath1 = u'./data/head-orientation/dataset1'
2 | dirpath2 = u'./data/head-orientation/dataset2/Experiment_1'
3 | dirpath3 = u'./data/head-orientation/dataset3/sensory/orientation'
4 | ext1 = '.txt'
5 | ext2 = '.csv'
6 | ext3 = '.csv'


--------------------------------------------------------------------------------
/example.py:
--------------------------------------------------------------------------------
 1 | import pickle
 2 | 
 3 | if __name__ == "__main__":
 4 |     #TODO: a simple example to load a saliency dataset file
 5 |     #RETURN: the values of the first record of the file. The record includes: timestamp, fixation_list, and saliency_map
 6 |     #note: this script assumes the dataset has been download from the LINK provided in the ./data folder
 7 |     
 8 |     #load the dataset file named `saliency_ds1_topicparis` (ds=1, video=paris). Assuming the dataset file is in ./data folder
 9 |     data = pickle.load(open('./data/saliency_ds1_topicparis'))
10 |     
11 |     #access the first record
12 |     timestamp, fixation_list, saliency_map = data[0]
13 |     
14 |     #print out the values of fields in the first record
15 |     print timestamp
16 |     print fixation_list
17 |     print saliency_map
18 |     
19 |     
20 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Anh Phan Nguyen
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/get_fixation.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import numpy as np
 3 | import pickle
 4 | import header
 5 | import sys
 6 | 
 7 | 
 8 | import head_orientation_lib
 9 | import saldat_head_orientation
10 | import saldat_saliency
11 | 
12 | if __name__ == "__main__":
13 |     #specify dataset & video name to extract
14 |     TOPIC = sys.argv[2]#for 6, modify 2 places, for loop vlength, and output file with _part
15 |     DELTA = 0.06
16 |     
17 |     dataset = int(sys.argv[1])#saldat_head_orientation.HeadOrientation._DATASET2
18 |     topic = TOPIC#dataset 1: paris, roller, venise,diving,timelapse, 
19 |                    #dataset 2: '0', '1', '2', '3', '4', '5', '6', '7', '8'
20 |                    #dataset 3: ['coaster2_', 'coaster_', 'diving', 'drive', 'game', 'landscape', 'pacman', 'panel', 'ride', 'sport']
21 |     #specify output address to store the saliency maps
22 |     
23 |     #initialize head_oren
24 |     print ("generating saliency maps for ds={}, topic={}".format(dataset, TOPIC))
25 |     dirpath1 = header.dirpath1#u'./data/head-orientation/dataset1'
26 |     dirpath2 = header.dirpath2#u'./data/head-orientation/dataset2/Experiment_1'
27 |     dirpath3 = header.dirpath3#u'./data/head-orientation/dataset3/sensory/orientation'
28 |     ext1 = header.ext1
29 |     ext2 = header.ext2
30 |     ext3 = header.ext3
31 |     headoren = saldat_head_orientation.HeadOrientation(dirpath1, dirpath2, dirpath3, ext1, ext2, ext3)
32 |     #initialize 
33 |     var = 20
34 |     salsal = saldat_saliency.Fixation(var)
35 |     
36 |     dirpath, filename_list, f_parse, f_extract_direction = headoren.load_filename_list(dataset, topic)
37 |     series_ds = headoren.load_series_ds(filename_list, f_parse)
38 |     vector_ds = headoren.headpos_to_headvec(series_ds, f_extract_direction)
39 |     vector_ds = headoren.cutoff_vel_acc(vector_ds, dataset=dataset)
40 | 
41 |     _, vlength, _, _ = head_orientation_lib.topic_info_dict[topic]
42 |     saliency_ds = []
43 |     for t in np.arange(1, vlength, DELTA):#0.06
44 |     #for t in np.arange( vlength/2, vlength, DELTA):
45 |         try:
46 |             fixation_list = headoren.get_fixation(vector_ds, t)
47 |             v_list = [item[1] for item in fixation_list]
48 | 
49 |             print (t, len(fixation_list))
50 |             fmap0 = headoren.create_fixation_map(fixation_list, dataset)
51 |             heat_map0 = salsal.create_saliency(fixation_list, dataset)
52 |             saliency_ds.append([t, v_list, heat_map0])
53 |         
54 |         except:
55 |             continue
56 |     pickle.dump(saliency_ds, open('./data/saliency_ds{}_topic{}'.format(dataset, topic), 'wb'))
57 | 


--------------------------------------------------------------------------------
/data/README.md:
--------------------------------------------------------------------------------
 1 | Saliency maps can be directly accessed from this [link](https://zenodo.org/record/2641282#.XLYYGkMpDAg)
 2 | <!--(https://drive.google.com/open?id=1zNzxwMhSsvsGgMt5WWemPZopVjdRdm-5).-->
 3 | 
 4 | The following table are the description of the videos associated with each saliency map file. Note that each file are identified by the dataset index (ds) and the video name.  
 5 | 
 6 | | No | Video description | Video name | Dataset Index | From (seconds) | To (seconds) | Original file location (Youtube Id/Url)        |
 7 | |----|-------------------|------------|---------------|----------------|--------------|---------------------------------------|
 8 | | 1  | Paris             | Paris      | 1             | 1              | 244          | sJxiPiAaB4k                           |
 9 | | 2  | Roller Coaster    | Roller     | 1             | 66             | 134          | 8lsB-P8nGSM                           |
10 | | 3  | Diving            | Diving     | 1             | 41             | 412          | 2OzlksZBTiA                           |
11 | | 4  | Newyork           | Timelapse  | 1             | 1              | 91           | CIw8R8thnm8                           |
12 | | 5  | Venise            | Venise     | 1             | 1              | 175          | s-AJRFQuAtE                           |
13 | | 6  | Conan 1           | Conan 1    | 2             | 1              | 164          | FiClYLgxJ5s |
14 | | 7  | Skiing            | Skiing     | 2             | 1              | 201          | 0wC3x_bnnps |
15 | | 8  | Alien             | Alien      | 2             | 1              | 293          | G-XZhKqQAHU |
16 | | 9  | Conan 2           | Conan 2    | 2             | 1              | 172          | 39MfLCMXGj0 |
17 | | 10 | Surfing           | Surfing    | 2             | 1              | 205          | MKWWhf8RAV8 |
18 | | 11 | War               | War        | 2             | 1              | 655          | _Ar0UkmID6s |
19 | | 12 | Cooking           | Cooking    | 2             | 1              | 451          | JpAdLz3iDPE |
20 | | 13 | Football          | Football   | 2             | 1              | 164          | lvH89OkkKQ8 |
21 | | 14 | Rhinos            | Rhinos     | 2             | 1              | 292          | AXG96ECE4hA |
22 | | 15 | Roller Coaster    | Coaster_   | 3             | 21             | 140          | 8lsB-P8nGSM                           |
23 | | 16 | Mega Coaster      | Coaster2_  | 3             | 91             | 150          | -xNN-bJQ4vI                           |
24 | | 17 | Shark Shipwreck   | Diving2    | 3             | 31             | 90           | aQd41nbQM-U                           |
25 | | 18 | Driving with      | Drive      | 3             | 49             | 108          | LKWXHKFCMO8                           |
26 | | 19 | Game Hog Rider    | Game       | 3             | 1              | 60           | yVLfEHXQk08                           |
27 | | 20 | Kangaroo Island   | Landscape  | 3             | 2              | 61           | MXlHCTXtcNs                           |
28 | | 21 | Pacman            | Pacman     | 3             | 11             | 70           | p9h3ZqJa1iA                           |
29 | | 22 | Perils Panel      | Panel      | 3             | 11             | 70           | kiP5vWqPryY                           |
30 | | 23 | Chariot Race      | Ride       | 3             | 3              | 62           | jMyDqZe0z7M                           |
31 | | 24 | SFR Sport         | Sport      | 3             | 17             | 76           | lo5N90TlzwU                           |
32 | 


--------------------------------------------------------------------------------
/saldat_saliency.py:
--------------------------------------------------------------------------------
 1 | from scipy import stats
 2 | import numpy as np
 3 | from Quaternion import Quat
 4 | from pyquaternion import Quaternion
 5 | import head_orientation_lib
 6 | 
 7 | import timeit
 8 | 
 9 | class Fixation:
10 |     _DATASET1 = 1
11 |     _DATASET2 = 2
12 |     _DATASET3 = 3
13 |     
14 |     _gaussian_dict = {}
15 |     _vec_map = None
16 |     #_dataset_info_dict = {_DATASET1: [head_orientation_lib.extract_direction_dataset1], _DATASET2: [head_orientation_lib.extract_direction_dataset1]}
17 |     
18 |     def __init__(self, var):
19 |         self._gaussian_dict = {np.around(_d, 1):stats.multivariate_normal.pdf(_d, mean=0, cov=var) for _d in np.arange(0.0, 180, .1  )}
20 |         #self._f_extract_direction = self._dataset_info_dict[dataset][0]
21 |         self._vec_map = self.create_pixel_vecmap()
22 |     
23 |     def f_extract_direction(self, q):
24 |         return head_orientation_lib.extract_direction_dataset1(q)
25 |         
26 |     def gaussian_from_distance(self, _d):
27 |         temp = np.around(_d, 1)
28 |         return self._gaussian_dict[temp] if temp in self._gaussian_dict else 0.0
29 |         
30 |     def create_pixel_vecmap(self):
31 |         vec_map = np.zeros((head_orientation_lib.H, head_orientation_lib.W)).tolist()
32 |         for i in range(head_orientation_lib.H):
33 |             for j in range(head_orientation_lib.W):
34 |                 theta, phi = head_orientation_lib.pixel_to_ang(i, j, head_orientation_lib.H, head_orientation_lib.W)
35 |                 t = Quat([0.0, theta, phi]).q #nolonger use Quat
36 |                 q = Quaternion([t[3], t[2], -t[1], t[0]])
37 |                 vec_map[i][j] = self.f_extract_direction(q)
38 |         return vec_map
39 |     
40 |     def create_saliency(self, fixation_list, dataset):
41 |         idx = 0
42 |         heat_map = np.zeros((head_orientation_lib.H, head_orientation_lib.W))
43 |         for i in range(heat_map.shape[0]):
44 |             for j in range(heat_map.shape[1]):
45 |                 qxy = self._vec_map[i][j]
46 |                 for fixation in fixation_list:
47 |                     q0 = fixation[1] 
48 |                     btime = timeit.default_timer()
49 |                     d = head_orientation_lib.degree_distance(q0, qxy)
50 | 
51 |                     dd_time = timeit.default_timer() - btime
52 | 
53 |                     heat_map[i, j] += 1.0 * self.gaussian_from_distance(d)
54 |                     gau_time = timeit.default_timer() - btime - dd_time
55 |                   
56 |         if dataset == self._DATASET2:
57 |             heat_map1 = np.fliplr(heat_map)
58 |             heat_map1 = np.flipud(heat_map1)
59 |             pos = int(head_orientation_lib.W/2)
60 |             temp = np.copy(heat_map1[:, pos:])
61 |             heat_map1[:, pos:] = heat_map1[:, :pos]
62 |             heat_map1[:, :pos] = temp
63 |         
64 |         elif dataset == self._DATASET1:
65 |             ##heat_map1 = np.fliplr(heat_map1)
66 |             heat_map1 = np.flipud(heat_map)
67 |             pos = int(head_orientation_lib.W/2)
68 |             temp = np.copy(heat_map1[:, pos:])
69 |             heat_map1[:, pos:] = heat_map1[:, :pos]
70 |             heat_map1[:, :pos] = temp
71 |                        
72 |         elif dataset == self._DATASET3:
73 |             heat_map1 = np.fliplr(heat_map)
74 |             heat_map1 = np.flipud(heat_map1)
75 |             pos = int(head_orientation_lib.W/4)
76 |             npos = int(head_orientation_lib.W/4*3)
77 |             temp = np.copy(heat_map1[:, :npos])
78 |             heat_map1[:, :pos] = heat_map1[:, npos:]
79 |             heat_map1[:, pos:] = temp
80 |             
81 |         
82 |         return heat_map1


--------------------------------------------------------------------------------
/head_orientation_lib.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | from pyquaternion import Quaternion
  3 | 
  4 | H = 90
  5 | W = 160
  6 | topic_info_dict = {'paris': ['paris.mp4', 244.06047, 3840, 2048], \
  7 |                    'timelapse': ['newyork.webm', 91.03333, 3840, 2048], \
  8 |                    '3': ['conan2.mp4', 172.5724, 2560, 1440], \
  9 |                    '1': ['skiing.mp4', 201.13426, 2560, 1440], \
 10 |                    '0': ['conan1.mp4', 164.1973, 2560, 1440], \
 11 |                    'venise': ['venise.webm', 175.04, 3840, 2160],\
 12 |                    '2': ['alien.mp4', 293.2333, 2560, 1440], \
 13 |                    '5': ['war.mp4', 655.0544, 2160, 1080], \
 14 |                    '4': ['surfing.mp4', 205.7055, 2560, 1440], \
 15 |                    '7': ['football.mp4', 164.8, 2560, 1440], \
 16 |                    '6': ['cooking.mp4', 451.12, 2560, 1440], \
 17 |                    'diving': ['ocean40.webm', 372.23853, 3840, 2048], \
 18 |                    'roller': ['roller65.webm', 69.0, 3840, 2048], \
 19 |                    '8': ['rhinos.mp4', 292.0584, 2560, 1440],\
 20 |                    'coaster2_': ['', 60.0, -1, -1], \
 21 |                    'coaster_': ['', 60.0, -1, -1], \
 22 |                    'diving': ['', 60.0, -1, -1], \
 23 |                    'drive': ['', 60.0, -1, -1], \
 24 |                    'game': ['', 60.0, -1, -1], \
 25 |                    'landscape': ['', 60.0, -1, -1], \
 26 |                    'pacman': ['', 60.0, -1, -1],\
 27 |                    'panel': ['', 60.0, -1, -1], \
 28 |                    'ride': ['', 60.0, -1, -1], \
 29 |                    'sport': ['', 60.0, -1, -1] }
 30 | 
 31 | #['coaster2_', 'coaster', 'diving', 'drive', 'game', 'landscape', 'pacman', 'panel', 'ride', 'sport']
 32 | 
 33 | def extract_direction_dataset1(q):
 34 |         #q is quaternion
 35 |         v0 = [1, 0, 0]
 36 |         q = Quaternion([q[3], q[2], q[1], q[0]])
 37 |         return q.rotate(v0)
 38 |     
 39 | def extract_direction_dataset2(q):
 40 |         #q is quaternion
 41 |         v0 = [0, 0, 1]
 42 |         q = Quaternion([q[3], -q[2], q[1], -q[0]])
 43 |         return q.rotate(v0)
 44 |     
 45 | def extract_direction_dataset3(q):
 46 |         #q is quaternion
 47 |         v0 = [0, 0, 1]
 48 |         q = Quaternion([q[3], -q[2], q[1], -q[0]])
 49 |         return q.rotate(v0)
 50 | 
 51 | def pixel_to_ang(_x, _y, _geo_h, _geo_w):
 52 |     phi = geoy_to_phi(_x, _geo_h)
 53 |     theta = -(_y * 1.0 / _geo_w) * 360
 54 |     if theta < -180: theta = 360 + theta
 55 |     return theta, phi
 56 | 
 57 | def geoy_to_phi(_geoy, _height):
 58 |     d = (_height/2 - _geoy) * 1.0 / (_height/2)
 59 |     s = -1 if d < 0 else 1
 60 |     return s * np.arcsin(np.abs(d)) / np.pi * 180
 61 | 
 62 | def unit_vector(vector):
 63 |     return vector / np.linalg.norm(vector)
 64 | 
 65 | def degree_distance(v1, v2):
 66 |     v1_u = unit_vector(v1)
 67 |     v2_u = unit_vector(v2)
 68 |     return np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))/np.pi * 180
 69 | 
 70 | def angle_between(v1, v2):
 71 |     v1_u = unit_vector(v1)
 72 |     v2_u = unit_vector(v2)
 73 |     return np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))/np.pi * 180
 74 | 
 75 | 
 76 | #lib to create fixation map
 77 | 
 78 | def vector_to_ang(_v):
 79 |     #v = np.array(vector_ds[0][600][1])
 80 |     #v = np.array([0, 0, 1])
 81 |     _v = np.array(_v)
 82 |     alpha = degree_distance(_v, [0, 1, 0])#degree between v and [0, 1, 0]
 83 |     phi = 90.0 - alpha
 84 |     proj1 = [0, np.cos(alpha/180.0 * np.pi), 0] #proj1 is the projection of v onto [0, 1, 0] axis
 85 |     proj2 = _v - proj1#proj2 is the projection of v onto the plane([1, 0, 0], [0, 0, 1])
 86 |     theta = degree_distance(proj2, [1, 0, 0])#theta = degree between project vector to plane and [1, 0, 0]
 87 |     sign = -1.0 if degree_distance(_v, [0, 0, -1]) > 90 else 1.0
 88 |     theta = sign * theta
 89 |     return theta, phi
 90 | 
 91 | 
 92 | def ang_to_geoxy(_theta, _phi, _h, _w):
 93 |     x = _h/2.0 - (_h/2.0) * np.sin(_phi/180.0 * np.pi)
 94 |     temp = _theta
 95 |     if temp < 0: temp = 180 + temp + 180
 96 |     temp = 360 - temp
 97 |     y = (temp * 1.0/360 * _w)
 98 |     return x, y#wi, hi
 99 | 
100 | 
101 | def adjust_pixel_dataset3(hi, wi, H, W):
102 |     wi = W - wi
103 |     wi = wi - W/4
104 |     if wi < 0: 
105 |         wi = wi + W
106 |     return hi, wi
107 | 
108 | def adjust_pixel_dataset2(hi, wi, H, W):
109 |     wi = W - wi
110 |     if wi < 0: 
111 |         wi = wi + W
112 |     return hi, wi
113 | 
114 | def adjust_pixel_dataset1(hi, wi, H, W):
115 |     hi = H - hi
116 |     if hi < 0: 
117 |         hi = hi + H
118 |     return hi, wi
119 | 
120 | 
121 | 
122 | def adjust_pixellist_dataset(dataset, pixel_list, H, W):
123 |     rhi_list = []
124 |     rwi_list = []
125 |     for hi, wi in pixel_list:
126 |         if dataset == 1:
127 |             hi, wi = adjust_pixel_dataset1(hi, wi, H, W)
128 |         elif dataset == 2:
129 |             hi, wi = adjust_pixel_dataset2(hi, wi, H, W)
130 |         elif dataset == 3:
131 |             hi, wi = adjust_pixel_dataset3(hi, wi, H, W)
132 |         rhi_list.append(hi)
133 |         rwi_list.append(wi)
134 |     return zip(rhi_list, rwi_list)
135 | 
136 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # A Saliency Dataset for 360-Degree Videos 
 2 | This README file contains the instructions to use our 360-degree saliency dataset and how to reproduce the saliency maps which were discussed in the paper:
 3 | 
 4 | Anh Nguyen and Zhisheng Yan. A saliency dataset for 360-degree videos. In Proceedings of the 10th ACM Multimedia Systems Conference (MMSys’19), 2019.
 5 | 
 6 | The data and source code are distributed under the terms of the MIT license. Our contributions in this project are:
 7 | - A 360-degree saliency dataset with 50,654 saliency maps from 24 diverse videos. (original YouTube links of these videos are also provided).
 8 | - An open-source software to create 360-degree saliency maps from head tracking logs. 
 9 | 
10 | To cite our paper, use this Bibtex code: 
11 | ```
12 | @inproceedings{anguyen139,
13 | AUTHOR = {Nguyen, Anh and Yan, Zhisheng},
14 |  title = {A Saliency Dataset for 360-Degree Videos},
15 |  booktitle = {Proceedings of the 10th ACM Multimedia Systems Conference (MMSys'19)},
16 |  year = {2019}
17 | }
18 | ```
19 | 
20 | # Paper Abstract
21 | Despite the increasing popularity, realizing 360-degree videos in everyday applications is still challenging. Considering the unique viewing behavior in head-mounted display (HMD), understanding the saliency of 360-degree videos becomes the key to various 360-degree video research. Unfortunately, existing saliency datasets are either irrelevant to 360-degree videos or too small to support saliency modeling. In this paper, we introduce a large saliency dataset for 360-degree videos with 50,654 saliency maps from 24 diverse videos. The dataset is created by a new methodology supported by psychology studies in HMD viewing. Evaluation of the dataset shows that the generated saliency is highly correlated with the actual user fixation and that the saliency data can provide useful insight on user attention in 360-degree video viewing. The dataset and the program used to extract saliency are both made publicly available to facilitate future research. 
22 | 
23 | # 360-Degree Saliency Dataset  
24 | The dataset includes 50,654 saliency maps from 24 videos. The saliency maps for each video are stored together in one file. The data in each file is organized into records. Each record has three fields: `timestamp`, `fixation`, and `saliency map`. The first field is the relative video time in seconds for the saliency maps. The second field is a list of fixation points. Each fixation point is a unit vector representing the head orientation in the three-dimensional space. The third field is the saliency map, where each pixel is a float number representing the saliency level in the original video frame.
25 | 
26 | To access the dataset, please follow the link provided inside `./data` folder.
27 | 
28 | # Program
29 | ## Program structure
30 | `/data` contains the [link](https://zenodo.org/record/2641282#.XLYYGkMpDAg) to Zenodo.org where the saliency maps are stored.  
31 | `/data/head-orientation` is the folder where input head tracking logs are supposed to reside. However, the input logs can also be specified inside the `/header.py` script file.   
32 | `/get_fixation.py` is the main entry to create 360-degree saliency maps from head tracking logs.  
33 | `/example.py`is the example Python code to retrieve the saliency maps from files in `data` folder.  
34 | 
35 | ## Requirement & Installation
36 | 1. Download Python 2  
37 | The program is developed Python 2.7. It is recommended that the [Anaconda2](https://www.anaconda.com/distribution/) packages is used  
38 | 2. Install [pyquarternion](http://kieranwynn.github.io/pyquaternion/).  
39 | ```sh
40 | pip install pyquaternion
41 | ```
42 | 3. Collect Head Tracking Logs  
43 | The program can received head tracking logs either in quarternion or Euler angles, and output saliency maps. Currently, head tracking logs are received from [Wu](https://wuchlei-thu.github.io/), [Corbillon](http://dash.ipv6.enstb.fr/headMovements/), and [Lo](https://nmsl.cs.nthu.edu.tw/360video/) . 
44 | 
45 | ## Dataset Collection Program
46 | 
47 | To access our generated saliency maps, refer to the example in the file `./example.py`. The saliency maps are stored in python pickle format, which need to be extracted by a python program.  
48 | 
49 | To generate saliency map from heade tracking logs, refer to the file `./get_fixation.py`. The program assumes input head tracking logs have been downloaded and the file paths have been provided in `header.py`. To run the program, execute this command from terminal:  
50 | ```sh
51 | python get_fixation.py <ds> <video>
52 | ```
53 | The `get_fixation.py` file receives two parameters `ds` and `video`, which specify which head tracking logs and which video to convert. Here are the possible values:  
54 | if `ds=1`, `video` can be `paris`, `roller`, `venise`, `diving`, `timelapse`  
55 | if `ds=2`, `video` can be `0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`  
56 | if `ds=3`, `video` can be `coaster2_`, `coaster_`, `diving`, `drive`, `game`, `landscape`, `pacman`, `panel`, `ride`, `sport`  
57 | 
58 | # License
59 | This project is licensed under the terms of the MIT license.  
60 | 
61 | # Contact
62 | If you have any general doubt about our work, please use the [public issues section](https://github.com/phananh1010/PanoSalNet/issues) on this github. Alternatively, drop us an e-mail at <mailto:anguy59@gmu.edu> or <mailto:zyan4@gmu.edu>.
63 | 


--------------------------------------------------------------------------------
/saldat_eval.py:
--------------------------------------------------------------------------------
  1 | import pickle
  2 | import numpy as np
  3 | from sklearn import metrics
  4 | import head_orientation_lib
  5 | 
  6 | class SalEvaluation:
  7 |     topic_dict ={head_orientation_lib.DATASET1:['paris', 'roller', 'diving', 'timelapse', 'venise'],\
  8 |         head_orientation_lib.DATASET2:['0', '1', '2', '3', '4', '5_part1', '6_part1', '7', '8'],\
  9 |         head_orientation_lib.DATASET3:['coaster2_', 'coaster_', 'diving', 'drive', 'game', 'landscape', 'pacman', 'panel', 'ride', 'sport']}
 10 |     template = './data/saliency_ds{}_topic{}'
 11 |     dat_filepath = './data/saliency_evaldat'
 12 |    
 13 |     dat = {}
 14 |     
 15 |     bl_center_salmap = None
 16 |     #baseline_equator = None
 17 |     
 18 |     headoren = None
 19 |     salsal = None
 20 |     
 21 |     def __init__(self, headoren, salsal, verbose=False):
 22 |         #must supplement salat_headoren & saldat salsal objects when initialize
 23 |         
 24 |         self.headoren = headoren
 25 |         self.salsal = salsal
 26 |         
 27 |         print 'Read/Initialize samples for evaluation'
 28 |         try:
 29 |             dat_dict = pickle.load(open(self.dat_filepath))
 30 |         except:
 31 |             dat1 = self.create_sample(head_orientation_lib.DATASET1, verbose=verbose)
 32 |             dat2 = self.create_sample(head_orientation_lib.DATASET2, verbose=verbose)
 33 |             dat3 = self.create_sample(head_orientation_lib.DATASET3, verbose=verbose)
 34 |             
 35 |             np.random.shuffle(dat1)
 36 |             np.random.shuffle(dat2)
 37 |             np.random.shuffle(dat3)
 38 | 
 39 |             dat_dict = {head_orientation_lib.DATASET1: dat1[:1000], \
 40 |                         head_orientation_lib.DATASET2: dat2[:1000], \
 41 |                         head_orientation_lib.DATASET3: dat3[:1000]}
 42 |             pickle.dump(dat_dict, open(self.dat_filepath, 'wb'))
 43 |         self.dat = dat_dict
 44 |         
 45 |         print 'Initialize baselines (center & equator)'
 46 |         self.bl_center_salmap = salsal.create_saliency([[0.0, [-1.0, 0, 0], 0, 0]], 1)
 47 |         self.bl_center_salmap = self.bl_center_salmap*1.0 / self.bl_center_salmap.max()
 48 |         
 49 |         return
 50 |     
 51 |     def create_sample(self, dataset, verbose=False):
 52 |         #TODO: for each topic, 
 53 |         #open the ds file, 
 54 |         #create random idx then append the list of sample to result
 55 | 
 56 |         result = []
 57 | 
 58 |         
 59 | 
 60 |         topic_list = self.topic_dict[dataset]
 61 |         for topic in topic_list:
 62 |             if verbose==True:
 63 |                 print 'reading {} - {}'.format(dataset, topic)
 64 |             
 65 |             filepath = self.template.format(dataset, topic)
 66 |             dat = pickle.load(open(filepath))      #load the saliency dataset file
 67 |             idx_randlist = np.arange(len(dat))
 68 |             np.random.shuffle(idx_randlist)
 69 |             idx_randlist = idx_randlist[:300]
 70 | 
 71 |             for idx in idx_randlist:
 72 |                 timestamp, fix_list, sal_map = dat[idx]
 73 |                 result.append([topic, timestamp, fix_list, sal_map])
 74 |         return result
 75 |     
 76 |     def get_negative_sample(self, dataset, topic, TOP=3):
 77 |         #return five sample same dataset, different topic
 78 |         temp = []
 79 |         for top, t, fixlist, salmap in self.dat[dataset]:
 80 |             if topic != top:
 81 |                 temp.append([top, t, fixlist, salmap])
 82 |         np.random.shuffle(temp)
 83 |         return temp[:TOP]
 84 |     
 85 |     def get_negative_fixations(self, dataset, topic):
 86 |         neg_list = self.get_negative_sample(dataset, topic)
 87 |         neg_vlist = []
 88 |         for top, t, fixlist, salmap in neg_list:
 89 |             neg_vlist += fixlist
 90 |         return neg_vlist
 91 |     
 92 |     def model_blequator(self, pixel_list):
 93 |         #the equator assign saliency chance to list of pixel coordination (human fixation)
 94 |         return [1.0 - np.abs(head_orientation_lib.geoy_to_phi(hi, head_orientation_lib.H))/90.0 for (hi, wi) in pixel_list]
 95 |     
 96 |     def model_blcircle(self, pixel_list):
 97 |         return [self.bl_center_salmap[hi, wi] for (hi, wi) in pixel_list]
 98 |     
 99 |     def sauc(self, dataset, topic, vpos_list):
100 |         vneg_list = self.get_negative_fixations(dataset, topic)
101 | 
102 |         #now I have positive, negative fixation, need to create saliency list
103 |         fixpos_list = [(0, v, 0, 0) for v in vpos_list]
104 |         fixneg_list = [(0, v, 0, 0) for v in vneg_list]
105 |         fposmap = self.headoren.create_fixation_map(fixpos_list, dataset)
106 |         fnegmap = self.headoren.create_fixation_map(fixneg_list, dataset)
107 | 
108 |         np.random.shuffle(fixpos_list)
109 |         npos= len(fixpos_list)/3
110 |         fixposeval_list = fixpos_list[:npos]
111 |         fixpostrain_list = fixpos_list[npos:]
112 |         val_salmap = self.salsal.create_saliency(fixposeval_list, dataset)
113 |         train_fmap = self.headoren.create_fixation_map(fixpostrain_list, dataset)
114 |         geoxy_train = zip(*np.where(train_fmap==1))
115 |         geoxy_neg = zip(*np.where(fnegmap==1))
116 | 
117 |         #val_salmap must be evaluated against geoxy_train + geoxy_neg
118 | 
119 |         y_pred = [val_salmap[hi, wi] for (hi, wi) in geoxy_train]
120 |         y_pred += [val_salmap[hi, wi] for (hi, wi) in geoxy_neg]
121 | 
122 |         y_true = [1 for item in geoxy_train]
123 |         y_true += [0 for item in geoxy_neg]
124 | 
125 |         return metrics.roc_auc_score(y_true, y_pred)
126 | 
127 |         
128 | 
129 |     def cc(self, salmap, fixmap):
130 |         return
131 |     
132 |     def nss(self, salmap, fixmap):
133 |         prediction = salmap - np.mean(salmap)
134 |         prediction = prediction / np.std(prediction)
135 |         return np.mean(prediction[fixmap==1])


--------------------------------------------------------------------------------
/Quaternion.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Quaternion provides a class for manipulating quaternion objects.  This class provides:
  3 |    - a convenient constructor to convert to/from Euler Angles (RA,Dec,Roll) 
  4 |        to/from quaternions
  5 |    - class methods to multiply and divide quaternions 
  6 | """
  7 | 
  8 | """Copyright 2009 Smithsonian Astrophysical Observatory
  9 |    Released under New BSD / 3-Clause BSD License
 10 |    All rights reserved
 11 | """
 12 | """
 13 |    Modified 2012 by Nick Foster
 14 |    Modified from version 0.3.1
 15 |    http://pypi.python.org/pypi/Quaternion/0.03
 16 |    Added _get_angle_axis to get the angle-axis representation
 17 |    Added _latlontoquat to get a rotation quat to ECEF from lat/lon
 18 | """
 19 | 
 20 | 
 21 |       
 22 | import numpy as np
 23 | from math import cos, sin, radians, degrees, atan2, sqrt, acos, pi
 24 | 
 25 | class Quat(object):
 26 |    """
 27 |    Quaternion class
 28 |    
 29 |    Example usage::
 30 |     >>> from Quaternion import Quat
 31 |     >>> quat = Quat((12,45,45))
 32 |     >>> quat.ra, quat.dec, quat.roll
 33 |     (12, 45, 45)
 34 |     >>> quat.q
 35 |     array([ 0.38857298, -0.3146602 ,  0.23486498,  0.8335697 ])
 36 |     >>> q2 = Quat([ 0.38857298, -0.3146602 ,  0.23486498,  0.8335697])
 37 |     >>> q2.ra
 38 |     11.999999315925008
 39 |    Multiplication and division operators are overloaded for the class to 
 40 |    perform appropriate quaternion multiplication and division.
 41 |    Example usage::
 42 |    
 43 |     >>> q1 = Quat((20,30,40))
 44 |     >>> q2 = Quat((30,40,50))
 45 |     >>> q = q1 / q2
 46 |    Performs the operation as q1 * inverse q2
 47 |    Example usage::
 48 |     >>> q1 = Quat((20,30,40))
 49 |     >>> q2 = Quat((30,40,50))
 50 |     >>> q = q1 * q2
 51 |    :param attitude: initialization attitude for quat
 52 |    ``attitude`` may be:
 53 |      * another Quat
 54 |      * a 4 element array (expects x,y,z,w quat form)
 55 |      * a 3 element array (expects ra,dec,roll in degrees)
 56 |      * a 3x3 transform/rotation matrix
 57 |    """
 58 |    def __init__(self, attitude):
 59 |       self._q = None
 60 |       self._equatorial = None
 61 |       self._T = None
 62 |       # checks to see if we've been passed a Quat 
 63 |       if isinstance(attitude, Quat):
 64 |          self._set_q(attitude.q)
 65 |       else:
 66 |          # make it an array and check to see if it is a supported shape
 67 |          attitude = np.array(attitude)
 68 |          if len(attitude) == 4:
 69 |             self._set_q(attitude)
 70 |          elif attitude.shape == (3,3):
 71 |             self._set_transform(attitude)
 72 |          elif attitude.shape == (3,):
 73 |             self._set_equatorial(attitude)
 74 |          elif attitude.shape == (2,):
 75 |             self._set_latlon(attitude)
 76 |          else:
 77 |             raise TypeError("attitude is not one of possible types (2, 3 or 4 elements, Quat, or 3x3 matrix)")
 78 |          
 79 | 
 80 |    def _set_q(self, q):
 81 |       """
 82 |       Set the value of the 4 element quaternion vector 
 83 |       :param q: list or array of normalized quaternion elements
 84 |       """
 85 |       q = np.array(q)
 86 |       if abs(np.sum(q**2) - 1.0) > 1e-6:
 87 |          raise ValueError('Quaternion must be normalized so sum(q**2) == 1; use Quaternion.normalize')
 88 |       self._q = (q if q[3] > 0 else -q)
 89 |       # Erase internal values of other representations
 90 |       self._equatorial = None
 91 |       self._T = None
 92 | 
 93 |    def _get_q(self):
 94 |       """
 95 |       Retrieve 4-vector of quaternion elements in [x, y, z, w] form
 96 |       
 97 |       :rtype: numpy array
 98 |       """
 99 |       if self._q is None:
100 |          # Figure out q from available values, doing nothing others are not defined
101 |          if self._equatorial is not None:
102 |             self._q = self._equatorial2quat()
103 |          elif self._T is not None:
104 |             self._q = self._transform2quat()
105 |       return self._q
106 | 
107 |    # use property to make this get/set automatic
108 |    q = property(_get_q, _set_q)
109 | 
110 |    def _set_equatorial(self, equatorial):
111 |       """Set the value of the 3 element equatorial coordinate list [RA,Dec,Roll]
112 |          expects values in degrees
113 |          bounds are not checked
114 |       
115 |          :param equatorial: list or array [ RA, Dec, Roll] in degrees
116 |          
117 |       """
118 |       att = np.array(equatorial)
119 |       ra, dec, roll = att
120 |       self._ra0 = ra
121 |       if ( ra > 180 ):
122 |          self._ra0 = ra - 360
123 |          self._roll0 = roll
124 |       if ( roll > 180):
125 |          self._roll0 = roll - 360
126 |       self._equatorial = att
127 | 
128 |    def _set_latlon(self, latlon):
129 |       self._q = self._latlontoquat(latlon)
130 |     
131 |    def _get_equatorial(self):
132 |       """Retrieve [RA, Dec, Roll]
133 |       :rtype: numpy array
134 |       """
135 |       if self._equatorial is None:
136 |          if self._q is not None:
137 |             self._equatorial = self._quat2equatorial()
138 |          elif self._T is not None:
139 |             self._q = self._transform2quat()
140 |             self._equatorial = self._quat2equatorial()
141 |       return self._equatorial
142 | 
143 |    equatorial = property(_get_equatorial,_set_equatorial)
144 | 
145 |    def _get_ra(self):
146 |       """Retrieve RA term from equatorial system in degrees"""
147 |       return self.equatorial[0]
148 |         
149 |    def _get_dec(self):
150 |       """Retrieve Dec term from equatorial system in degrees"""
151 |       return self.equatorial[1]
152 |         
153 |    def _get_roll(self):
154 |       """Retrieve Roll term from equatorial system in degrees"""
155 |       return self.equatorial[2]
156 | 
157 |    ra = property(_get_ra)
158 |    dec = property(_get_dec)
159 |    roll = property(_get_roll)
160 | 
161 |    def _set_transform(self, T):
162 |       """
163 |       Set the value of the 3x3 rotation/transform matrix
164 |       
165 |       :param T: 3x3 array/numpy array
166 |       """
167 |       transform = np.array(T)
168 |       self._T = transform
169 | 
170 |    def _get_transform(self):
171 |       """
172 |       Retrieve the value of the 3x3 rotation/transform matrix
173 |       :returns: 3x3 rotation/transform matrix
174 |       :rtype: numpy array
175 |       
176 |       """
177 |       if self._T is None:
178 |          if self._q is not None:
179 |             self._T = self._quat2transform()
180 |          elif self._equatorial is not None:
181 |             self._T = self._equatorial2transform()
182 |       return self._T
183 | 
184 |    transform = property(_get_transform, _set_transform)
185 | 
186 |    def _quat2equatorial(self):
187 |       """
188 |       Determine Right Ascension, Declination, and Roll for the object quaternion
189 |       
190 |       :returns: RA, Dec, Roll
191 |       :rtype: numpy array [ra,dec,roll]
192 |       """
193 |       
194 |       q = self.q
195 |       q2 = self.q**2
196 | 
197 |       ## calculate direction cosine matrix elements from $quaternions
198 |       xa = q2[0] - q2[1] - q2[2] + q2[3] 
199 |       xb = 2 * (q[0] * q[1] + q[2] * q[3]) 
200 |       xn = 2 * (q[0] * q[2] - q[1] * q[3]) 
201 |       yn = 2 * (q[1] * q[2] + q[0] * q[3]) 
202 |       zn = q2[3] + q2[2] - q2[0] - q2[1] 
203 | 
204 |       ##; calculate RA, Dec, Roll from cosine matrix elements
205 |       ra   = degrees(atan2(xb , xa)) ;
206 |       dec  = degrees(atan2(xn , sqrt(1 - xn**2)));
207 |       roll = degrees(atan2(yn , zn)) ;
208 |       if ( ra < 0 ):
209 |          ra += 360
210 |       if ( roll < 0 ):
211 |          roll += 360
212 | 
213 |       return np.array([ra, dec, roll])
214 | 
215 | 
216 |    def _quat2transform(self):
217 |       """
218 |       Transform a unit quaternion into its corresponding rotation matrix (to
219 |       be applied on the right side).
220 |       
221 |       :returns: transform matrix
222 |       :rtype: numpy array
223 |       
224 |       """
225 |       x, y, z, w = self.q
226 |       xx2 = 2 * x * x
227 |       yy2 = 2 * y * y
228 |       zz2 = 2 * z * z
229 |       xy2 = 2 * x * y
230 |       wz2 = 2 * w * z
231 |       zx2 = 2 * z * x
232 |       wy2 = 2 * w * y
233 |       yz2 = 2 * y * z
234 |       wx2 = 2 * w * x
235 |       
236 |       rmat = np.empty((3, 3), float)
237 |       rmat[0,0] = 1. - yy2 - zz2
238 |       rmat[0,1] = xy2 - wz2
239 |       rmat[0,2] = zx2 + wy2
240 |       rmat[1,0] = xy2 + wz2
241 |       rmat[1,1] = 1. - xx2 - zz2
242 |       rmat[1,2] = yz2 - wx2
243 |       rmat[2,0] = zx2 - wy2
244 |       rmat[2,1] = yz2 + wx2
245 |       rmat[2,2] = 1. - xx2 - yy2
246 |       
247 |       return rmat
248 | 
249 |    def _equatorial2quat( self ):
250 |       """Dummy method to return return quat. 
251 |       :returns: quaternion
252 |       :rtype: Quat
253 |       
254 |       """
255 |       return self._transform2quat()
256 |    
257 |    def _equatorial2transform( self ):
258 |       """Construct the transform/rotation matrix from RA,Dec,Roll
259 |       :returns: transform matrix
260 |       :rtype: 3x3 numpy array
261 |       """
262 |       ra = radians(self._get_ra())
263 |       dec = radians(self._get_dec())
264 |       roll = radians(self._get_roll())
265 |       ca = cos(ra)
266 |       sa = sin(ra)
267 |       cd = cos(dec)
268 |       sd = sin(dec)
269 |       cr = cos(roll)
270 |       sr = sin(roll)
271 |       
272 |       # This is the transpose of the transformation matrix (related to translation
273 |       # of original perl code
274 |       rmat = np.array([[ca * cd,                    sa * cd,                  sd     ],
275 |                        [-ca * sd * sr - sa * cr,   -sa * sd * sr + ca * cr,   cd * sr],
276 |                        [-ca * sd * cr + sa * sr,   -sa * sd * cr - ca * sr,   cd * cr]])
277 | 
278 |       return rmat.transpose()
279 | 
280 |    def _transform2quat( self ):
281 |       """Construct quaternion from the transform/rotation matrix 
282 |       :returns: quaternion formed from transform matrix
283 |       :rtype: numpy array
284 |       """
285 | 
286 |       # Code was copied from perl PDL code that uses backwards index ordering
287 |       T = self.transform.transpose()  
288 |       den = np.array([ 1.0 + T[0,0] - T[1,1] - T[2,2],
289 |                        1.0 - T[0,0] + T[1,1] - T[2,2],
290 |                        1.0 - T[0,0] - T[1,1] + T[2,2],
291 |                        1.0 + T[0,0] + T[1,1] + T[2,2]])
292 |       
293 |       max_idx = np.flatnonzero(den == max(den))[0]
294 | 
295 |       q = np.zeros(4)
296 |       q[max_idx] = 0.5 * sqrt(max(den))
297 |       denom = 4.0 * q[max_idx]
298 |       if (max_idx == 0):
299 |          q[1] =  (T[1,0] + T[0,1]) / denom 
300 |          q[2] =  (T[2,0] + T[0,2]) / denom 
301 |          q[3] = -(T[2,1] - T[1,2]) / denom 
302 |       if (max_idx == 1):
303 |          q[0] =  (T[1,0] + T[0,1]) / denom 
304 |          q[2] =  (T[2,1] + T[1,2]) / denom 
305 |          q[3] = -(T[0,2] - T[2,0]) / denom 
306 |       if (max_idx == 2):
307 |          q[0] =  (T[2,0] + T[0,2]) / denom 
308 |          q[1] =  (T[2,1] + T[1,2]) / denom 
309 |          q[3] = -(T[1,0] - T[0,1]) / denom 
310 |       if (max_idx == 3):
311 |          q[0] = -(T[2,1] - T[1,2]) / denom 
312 |          q[1] = -(T[0,2] - T[2,0]) / denom 
313 |          q[2] = -(T[1,0] - T[0,1]) / denom 
314 | 
315 |       return q
316 |       
317 |    def _get_angle_axis(self):
318 |       lim = 1e-12
319 |       norm = np.linalg.norm(self.q)
320 |       if norm < lim:
321 |          angle = 0
322 |          axis = [0,0,0]
323 |       else:
324 |          rnorm = 1.0 / norm
325 |          angle = acos(max(-1, min(1, rnorm*self.q[3])));
326 |          sangle = sin(angle)
327 |          if sangle < lim:
328 |             axis = [0,0,0]
329 |          else:
330 |             axis = (rnorm / sangle) * np.array(self.q[0:3])
331 | 
332 |          angle *= 2
333 | 
334 |       return (angle, axis)
335 | 
336 |    def _latlontoquat ( self, latlon ):
337 |       q = np.zeros(4)
338 |       
339 |       lon = latlon[1]*(pi/180.)
340 |       lat = latlon[0]*(pi/180.)
341 |       zd2 = 0.5*lon
342 |       yd2 = -0.25*pi - 0.5*lat
343 |       Szd2 = sin(zd2)
344 |       Syd2 = sin(yd2)
345 |       Czd2 = cos(zd2)
346 |       Cyd2 = cos(yd2)
347 |       q[0] = -Szd2*Syd2
348 |       q[1] = Czd2*Syd2
349 |       q[2] = Szd2*Cyd2
350 |       q[3] = Czd2*Cyd2
351 | 
352 |       return q
353 | 
354 |    def __div__(self, quat2):
355 |       """
356 |       Divide one quaternion by another.
357 |       
358 |       Example usage::
359 |        >>> q1 = Quat((20,30,40))
360 |        >>> q2 = Quat((30,40,50))
361 |        >>> q = q1 / q2
362 |       Performs the operation as q1 * inverse q2
363 |       :returns: product q1 * inverse q2
364 |       :rtype: Quat
365 |       """
366 |       return self * quat2.inv()
367 | 
368 | 
369 |    def __mul__(self, quat2):
370 |       """
371 |       Multiply quaternion by another.
372 |       Example usage::
373 |         >>> q1 = Quat((20,30,40))
374 |         >>> q2 = Quat((30,40,50))
375 |         >>> (q1 * q2).equatorial
376 |         array([ 349.73395729,   76.25393056,  127.61636727])
377 |       :returns: product q1 * q2
378 |       :rtype: Quat
379 |       """
380 |       q1 = self.q
381 |       q2 = quat2.q
382 |       mult = np.zeros(4)
383 |       mult[0] = q1[3]*q2[0] - q1[2]*q2[1] + q1[1]*q2[2] + q1[0]*q2[3]
384 |       mult[1] = q1[2]*q2[0] + q1[3]*q2[1] - q1[0]*q2[2] + q1[1]*q2[3]
385 |       mult[2] = -q1[1]*q2[0] + q1[0]*q2[1] + q1[3]*q2[2] + q1[2]*q2[3]
386 |       mult[3] = -q1[0]*q2[0] - q1[1]*q2[1] - q1[2]*q2[2] + q1[3]*q2[3]
387 |       return Quat(mult)
388 | 
389 |    def inv(self):
390 |       """
391 |       Invert the quaternion 
392 |       :returns: inverted quaternion
393 |       :rtype: Quat
394 |       """
395 |       return Quat([self.q[0], self.q[1], self.q[2], -self.q[3]])
396 | 
397 |         
398 |         
399 | 
400 | 
401 | def normalize(array):
402 |    """ 
403 |    Normalize a 4 element array/list/numpy.array for use as a quaternion
404 |    
405 |    :param quat_array: 4 element list/array
406 |    :returns: normalized array
407 |    :rtype: numpy array
408 |    """
409 |    quat = np.array(array)
410 |    return quat / np.sqrt(np.dot(quat, quat))
411 | 


--------------------------------------------------------------------------------
/saldat_head_orientation.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import numpy as np
  3 | from Quaternion import Quat
  4 | from pyquaternion import Quaternion
  5 | 
  6 | from sklearn import model_selection
  7 | from sklearn import metrics
  8 | from sklearn.cluster import DBSCAN
  9 | from sklearn.datasets.samples_generator import make_blobs
 10 | from sklearn.preprocessing import StandardScaler
 11 | 
 12 | import head_orientation_lib
 13 | #reload(head_orientation_lib)
 14 | 
 15 | class HeadOrientation:
 16 |     #NOTE: original DBSCAN param is: _bp=3, _ap=1, eps=0.3, worked best for ds=2
 17 |     #      for ds=1 use _bp=1, _ap=1, eps=.35
 18 |     #       for ds=3 use 
 19 |     _DATASET1 = 1
 20 |     _DATASET2 = 2
 21 |     _DATASET3 = 3
 22 |     
 23 |     _dirpath_dat1 = ''#u'/home/u9168/salnet/Datasets/Dataset1/results/'
 24 |     _dirpath_dat2 = ''#u'/home/u9168/salnet/Datasets/Dataset2/Formated_Data/Experiment_1/'
 25 |     _dirpath_dat3 = ''#u'/home/u9168/saliency_dataset/data/head-orientation/dataset3/sensory/orientation'
 26 |     _file_ext1 = '.txt'
 27 |     _file_ext2 = '.csv'
 28 |     _file_ext3 = '.csv'
 29 |     _dataset_info_dict = {_DATASET1:[], _DATASET2:[], _DATASET3:[]}
 30 |     
 31 |     _topic_dict = {_DATASET1:['venise', 'diving', 'roller', 'paris', 'timelapse'], \
 32 |               _DATASET2:['1', '0', '3', '2', '5', '4', '7', '6', '8'],\
 33 |               _DATASET3:['coaster', 'coaster2', 'diving', 'drive', 'game', 'landscape', 'pacman', 'panel', 'ride', 'sport']}
 34 |     
 35 |     def __init__(self, dir_path1, dir_path2, dir_path3, file_ext1, file_ext2, file_ext3):
 36 |         self._dirpath_dat1 = dir_path1
 37 |         self._dirpath_dat2 = dir_path2
 38 |         self._dirpath_dat3 = dir_path3
 39 |         self._file_ext1 = file_ext1
 40 |         self._file_ext2 = file_ext2
 41 |         self._file_ext3 = file_ext3
 42 |         self._dataset_info_dict = {self._DATASET1:[self._dirpath_dat1, self._file_ext1, self.parse_dat1, head_orientation_lib.extract_direction_dataset1], \
 43 |                                 self._DATASET2:[self._dirpath_dat2, self._file_ext2, self.parse_dat2, head_orientation_lib.extract_direction_dataset2], \
 44 |                                self._DATASET3:[self._dirpath_dat3, self._file_ext3, self.parse_dat3, head_orientation_lib.extract_direction_dataset3]}
 45 |         
 46 |     def parse_dat1(self, _file_name):#for X.Corbillon dataset
 47 |         temp = open(_file_name).read().split('\n')[:-1]
 48 |         temp2 = [list(map(float, item.split(' '))) for item in temp]
 49 |         for i, _ in enumerate(temp2):
 50 |             item = temp2[i]
 51 |             temp2[i] = [item[0], item[1], item[3], item[5], item[4], item[2]]
 52 |         return np.array(temp2)
 53 | 
 54 |     def parse_dat2(self, _file_name):#for Wu dataset
 55 |         temp = open(_file_name).read().split('\n')[1:-1]#remove header and useless last line
 56 |         temp2 = [list(map(float, item.split(',')[1:])) for item in temp]
 57 |         #timestamp_list = [datetime.datetime.strptime(item.split(',')[0], "%Y-%m-%d %H:%M:%S.%f") for item in temp]
 58 |         for i, _ in enumerate(temp2):
 59 |             item = temp2[i]#timestamp, z, y, x, w, ....
 60 |             temp2[i] = [item[0], -1, item[3], item[2], item[1], item[4]]
 61 |         return np.array(temp2)
 62 |     
 63 |     def parse_dat3(self, _file_name):#for Wen Lo dataset
 64 |         temp = open(_file_name).read().split('\n')[1:-1]#remove header and useless last line
 65 |         temp2 = [list(map(float, item.split(','))) for item in temp]
 66 | 
 67 |         for i, _ in enumerate(temp2):
 68 |             fid, _, _, _, _, _, _, theta, phi, psi = temp2[i]
 69 |             tstamp = fid * 1.0/30
 70 |             t = Quat([psi, theta, phi]).q #nolonger use Quat
 71 |             q = Quaternion([t[3], t[2], -t[1], t[0]])
 72 |             
 73 |             w, x, y, z = q.elements#{} + {}i + {}j + {}k, a=w, b=x, c=y, d=z
 74 |             temp2[i] = [tstamp, fid, z, y, x, w]
 75 | 
 76 |         return np.array(temp2)
 77 |     
 78 |     def load_filename_list(self, dataset, topic):
 79 |         #load all headpos log of all users for a given dataset & video_topic
 80 |         filename_list = []
 81 |         if dataset != self._DATASET1 and dataset != self._DATASET2 and dataset != self._DATASET3:
 82 |             print ('ERROR, dataset number must be either 1 or 2 or 3')
 83 |             raise Exception
 84 |         
 85 |         dirpath, file_ext, f_parse, f_extract_orientation = self._dataset_info_dict[dataset]
 86 | 
 87 |         for root, dirs, files in os.walk(dirpath):
 88 |             for file in files:
 89 |                 if file.endswith(file_ext) and file.lower().find(topic) >= 0:
 90 |                      filename_list.append((os.path.join(root, file)))          
 91 |         return dirpath, filename_list, f_parse, f_extract_orientation
 92 | 
 93 |     
 94 |     def load_series_ds(self, filename_list, f_parse):
 95 |         series_ds = []
 96 | 
 97 |         for idx, file_name in enumerate(filename_list):
 98 |             series = f_parse(file_name);
 99 |             series_ds.append(series.tolist())
100 |         
101 |         for uid in range(len(series_ds)):
102 |             t_list = set()
103 |             tmp = []
104 |             for item in series_ds[uid]:
105 |                 #print (item)
106 |                 t = item[0]
107 |                 if t not in t_list:
108 |                     t_list.add(t)
109 |                     tmp.append(item)
110 |             series_ds[uid] = np.array(tmp)
111 |         return series_ds
112 |     
113 |     def load_vector_ds(self, dataset, topic):
114 |         dirpath, filename_list, f_parse, f_extract_direction = self.load_filename_list(dataset, topic)
115 |         series_ds = self.load_series_ds(filename_list, f_parse)
116 |         vector_ds = self.headpos_to_headvec(series_ds, f_extract_direction)
117 |         return vector_ds
118 |     
119 |     
120 |     def headpos_to_headvec(self, series_ds, f_extract_direction):
121 |         #from raw head quarternion, convert to head direction vector
122 |         vector_ds = []
123 |         for series in series_ds:
124 |             vec = []
125 |             #for item in series:
126 |             for idx in np.arange(0, len(series)):
127 |                 item = series[idx]
128 |                 q = item[2:6]
129 |                 v = f_extract_direction(q)#
130 |                 vec.append([item[0], v, 0, 0])#time, cur pos, angular vec, angular acc
131 |             vector_ds.append(vec)
132 |         return vector_ds
133 | 
134 |     def get_stats_ds0(self, vector_ds, sample_distance):
135 |         #TODO: get angular movement for ALL user, store in list structure
136 |         dd = sample_distance
137 |         stats_ds = []
138 |         for vec in vector_ds:
139 |             stats = []
140 |             for idx in range(len(vec)):
141 |                 if idx < dd+2:
142 |                     #stats.append([vec[idx][0], 0, 0, 0])
143 |                     continue
144 |                 dt = vec[idx][0] - vec[idx-dd][0]
145 |                 theta = head_orientation_lib.angle_between(vec[idx][1], vec[idx-dd][1])
146 |                 v = theta * 1.0 / dt   
147 |                 vec[idx][2] = v
148 | 
149 |                 dv = vec[idx][2] - vec[idx-dd][2]
150 |                 a = dv * 1.0 / dt
151 |                 vec[idx][3] = a
152 |                 item = [vec[idx][0], theta, v, a]
153 |                 stats.append(item)
154 |             stats = np.array(stats)
155 |             stats_ds.append(stats)
156 |         return stats_ds
157 |     
158 |     def get_stats_ds(self, vector_ds, sample_distance):
159 |         #TODO: get angular movement for ALL user, store in list structure
160 |         dd = sample_distance
161 |         stats_ds = []
162 |         for vec in vector_ds:
163 |             stats = []
164 |             for idx in range(len(vec)):
165 |                 if idx < dd+2:
166 |                     stats.append([vec[idx][0], 0, 0, 0])
167 |                     continue
168 |                 dt = vec[idx][0] - vec[idx-dd][0]
169 |                 theta = head_orientation_lib.angle_between(vec[idx][1], vec[idx-dd][1])
170 |                 v = theta * 1.0 / dt   
171 | #                 vec[idx][2] = v
172 | 
173 | #                 dv = vec[idx][2] - vec[idx-dd][2]
174 | #                 a = dv * 1.0 / dt
175 | #                 vec[idx][3] = a
176 |                 item = [vec[idx][0], theta, v, 0]
177 |                 stats.append(item)
178 |             stats = np.array(stats)
179 |             t_list, dtheta_list, _, _ = (stats[:, i] for i in range(4) )
180 |             #stats[:, 2] = np.gradient(dtheta_list, t_list) #calculate velocity incorrectly
181 |             stats[:, 3] = np.gradient(stats[:, 2], t_list)
182 |             stats_ds.append(stats)
183 |         return stats_ds
184 |     
185 |     def cutoff_vel_acc_compliment(self, vector_ds, dataset=2, thres_list=(), sample_distance=7):
186 |         if len(thres_list) < 2:
187 |             thres_dict = {1:(20, 50), 2:(20, 50), 3:(27, 60)}
188 |             vthres, athres = thres_dict[dataset]
189 |         else:
190 |             vthres, athres = thres_list      
191 |         stats_ds = self.get_stats_ds(vector_ds, sample_distance=sample_distance)
192 |         result = []
193 |         for uid in range(len(stats_ds)):
194 |             t_list, dtheta_list, v_list, a_list = stats_ds[uid].T
195 |             idx_list = np.argwhere(v_list>vthres).ravel()
196 |             result.append([vector_ds[uid][idx] for idx in idx_list])
197 |         return result
198 | 
199 |     def cutoff_vel_acc(self, vector_ds, dataset=2, thres_list=(), sample_distance=7):
200 |         if len(thres_list) < 2:
201 |             thres_dict = {1:(20, 50), 2:(20, 50), 3:(27, 60)}
202 |             vthres, athres = thres_dict[dataset]
203 |         else:
204 |             vthres, athres = thres_list
205 |         #print (f'DEBUG: threslist: {thres_list}')
206 |         #return stats_ds having same shape as vector ds, which 
207 |         stats_ds = self.get_stats_ds(vector_ds, sample_distance=sample_distance)
208 |         result = []
209 |         for uid in range(len(stats_ds)):
210 |             t_list, dtheta_list, v_list, a_list = stats_ds[uid].T
211 |             idx_list = np.argwhere(v_list<=vthres).ravel()
212 |             result.append([vector_ds[uid][idx] for idx in idx_list])
213 |         
214 | #         result = []
215 | #         for vector in stats_ds:
216 | #             #removing too fast movement
217 | #             remove_idx = set()
218 | #             collect_mode = 0 #0 is normal, 1 is begin fast, 2 is begin slow
219 | #             #print stats_ds[0]
220 | #             for idx, (timestamp, theta, v, a) in enumerate(vector):
221 | #                 if v > vthres and a > athres:
222 | #                     collect_mode = 1;
223 | #                 if a < (-athres) and collect_mode == 1:#slowing down#previously, -athres + 10
224 | #                     collect_mode = 2
225 | #                 if collect_mode == 2 and a > -athres  and v < vthres:#slowing down finish
226 | #                     collect_mode = 0
227 | #                 if collect_mode == 1 or collect_mode == 2:
228 | #                     remove_idx.add(idx)
229 | #             result.append([vector[idx] for idx,_ in enumerate(vector) if idx not in remove_idx])
230 |         return result
231 |     
232 |     def get_fixation(self, vector_ds, time, _bp=2, _ap=1, filter_fix=True):
233 |         dt = 1.0/30
234 |         series_dt = []
235 |         for vector in vector_ds:
236 |             temp = []
237 |             for item in vector: 
238 |                 if item[0] >= time - _bp*dt and item[0] <= time + _ap*dt:
239 |                     temp.append(item)
240 |             series_dt.append(temp)
241 |         #get quaternion from the first elements of each users
242 |         result = []
243 |         for series in series_dt:
244 |             for item in series:
245 |                 result.append(item)
246 |                 
247 |         #now filter the fixation before returning
248 |         pixel_set0, fix_list0 = self.create_fixation_pixelset(result)
249 |         if filter_fix == True:
250 |             pixel_set, idx_list = self.filter_fixation(fix_list0)
251 |             return [fix_list0[idx] for idx in idx_list]
252 |         else:
253 |             return fix_list0
254 |     
255 |     def create_fixation_pixellist(self, fixation_list):
256 |         #return list of (hi, wi) coord
257 |         pixel_list = []
258 |         for time, v, _, _ in fixation_list:
259 |             theta, phi = head_orientation_lib.vector_to_ang(v)
260 |             x, y = head_orientation_lib.ang_to_geoxy(theta, phi, head_orientation_lib.H, head_orientation_lib.W)
261 |             pixel_list.append((x, y))
262 |         return pixel_list
263 | 
264 |     def create_fixation_pixelset(self, fixation_list):
265 |         #return set of (hi, wi) coord, eliminate redundancy
266 |         pixel_set = set()
267 |         orifix_list = []
268 |         for time, v, _, _ in fixation_list:
269 |             theta, phi = head_orientation_lib.vector_to_ang(v)
270 |             x, y = head_orientation_lib.ang_to_geoxy(theta, phi, head_orientation_lib.H, head_orientation_lib.W)
271 |             if (int(x), int(y)) not in pixel_set:
272 |                 pixel_set.add((int(x), int(y)))
273 |                 orifix_list.append([time, v, 0, 0])
274 |         return pixel_set, orifix_list    
275 |     
276 |     def filter_fixation(self, _fix_list, eps=.4, min_samples=3):
277 |         result = set()
278 |         _geoxy_set = self.create_fixation_pixellist(_fix_list)
279 | 
280 |         X = [[xy[0], xy[1]] for xy in _geoxy_set]
281 |         #labels_true += [0 for xy in geoxy_false_set]
282 |         std = StandardScaler()
283 |         X = std.fit_transform(X)
284 | 
285 |         db = DBSCAN(eps=eps, min_samples=min_samples)
286 |         db.fit_predict(X)
287 |         temp = std.inverse_transform(X[db.core_sample_indices_])
288 | 
289 |         return set([(int(item[0]), int(item[1])) for item in temp]), db.core_sample_indices_
290 | 
291 |     def create_fixation_map(self, fixation_list, dataset):
292 |         result = np.zeros(shape=(head_orientation_lib.H, head_orientation_lib.W), dtype=np.int)
293 |         pixel_list = self.create_fixation_pixellist(fixation_list)
294 |         for x, y in pixel_list:
295 |             result[int(x), int(y)] = 1
296 | 
297 |         if dataset == self._DATASET2:
298 |             result1 = np.fliplr(result)
299 |             result1 = np.flipud(result1)
300 |         elif dataset == self._DATASET1:
301 |             result1 = np.fliplr(result)
302 |             result1 = np.flipud(result1)
303 |             result1 = np.fliplr(result1)
304 |         elif dataset == self._DATASET3:
305 |             pos = int(head_orientation_lib.W/4)
306 |             npos = int(head_orientation_lib.W/4*3)
307 |             
308 |             result1 = np.fliplr(result)
309 |             temp = np.copy(result1[:, pos:])
310 |             result1[:, npos:] = result1[:, :pos]
311 |             result1[:, :npos] = temp
312 |             result1 = np.flipud(result1)
313 | 
314 |         else:
315 |             print ('INVALID dataset')
316 |             raise
317 |             
318 |         return result1
319 |     
320 |     @staticmethod
321 |     def pixellist_from_v_list(v_list):
322 |         #note, pixellist need to compatible with dataset
323 |         #dataset 2: fliplr
324 |         #dataset 1: maybe flipud
325 |         
326 |         pixel_list = []
327 |         for v in v_list:
328 |             theta, phi = head_orientation_lib.vector_to_ang(v)
329 |             hi, wi = head_orientation_lib.ang_to_geoxy(theta, phi, head_orientation_lib.H, head_orientation_lib.W)
330 |             pixel_list.append([hi, wi])
331 |         return pixel_list


--------------------------------------------------------------------------------
/sal_eval.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 78,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     " #now, get 3k samples, one thousand for each dataset. Then, \n",
 10 |     "    #how to select sample"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 105,
 16 |    "metadata": {},
 17 |    "outputs": [
 18 |     {
 19 |      "name": "stdout",
 20 |      "output_type": "stream",
 21 |      "text": [
 22 |       "\u001b[0m\u001b[34;42m360dataset_rev\u001b[0m/              saliency_ds2_topic6_part1\r\n",
 23 |       "360dataset_v2.zip            saliency_ds2_topic6_part2\r\n",
 24 |       "\u001b[01;34mbk\u001b[0m/                          saliency_ds2_topic6_part3\r\n",
 25 |       "\u001b[01;34mhead-orientation\u001b[0m/            saliency_ds2_topic7\r\n",
 26 |       "README.md                    saliency_ds2_topic8\r\n",
 27 |       "saleval_bk                   saliency_ds3_topiccoaster_\r\n",
 28 |       "saliency_ds1_topicdiving     saliency_ds3_topiccoaster2_\r\n",
 29 |       "saliency_ds1_topicparis      saliency_ds3_topicdiving\r\n",
 30 |       "saliency_ds1_topicroller     saliency_ds3_topicdrive\r\n",
 31 |       "saliency_ds1_topictimelapse  saliency_ds3_topicgame\r\n",
 32 |       "saliency_ds1_topicvenise     saliency_ds3_topiclandscape\r\n",
 33 |       "saliency_ds2_topic0          saliency_ds3_topicpacman\r\n",
 34 |       "saliency_ds2_topic1          saliency_ds3_topicpanel\r\n",
 35 |       "saliency_ds2_topic2          saliency_ds3_topicride\r\n",
 36 |       "saliency_ds2_topic3          saliency_ds3_topicsport\r\n",
 37 |       "saliency_ds2_topic4          saliency_evaldat\r\n",
 38 |       "saliency_ds2_topic5_part1    viz_filtered_fixation\r\n",
 39 |       "saliency_ds2_topic5_part2\r\n"
 40 |      ]
 41 |     }
 42 |    ],
 43 |    "source": [
 44 |     "ls ./data"
 45 |    ]
 46 |   },
 47 |   {
 48 |    "cell_type": "code",
 49 |    "execution_count": null,
 50 |    "metadata": {},
 51 |    "outputs": [],
 52 |    "source": []
 53 |   },
 54 |   {
 55 |    "cell_type": "code",
 56 |    "execution_count": 106,
 57 |    "metadata": {},
 58 |    "outputs": [],
 59 |    "source": [
 60 |     "import pickle\n",
 61 |     "import numpy as np\n",
 62 |     "import head_orientation_lib\n",
 63 |     "import saldat_head_orientation\n",
 64 |     "import saldat_eval\n",
 65 |     "import saldat_saliency\n",
 66 |     "from sklearn import metrics\n",
 67 |     "\n",
 68 |     "reload(head_orientation_lib)\n",
 69 |     "reload(saldat_eval)\n",
 70 |     "\n",
 71 |     "from matplotlib import pyplot as plt\n",
 72 |     "%matplotlib inline"
 73 |    ]
 74 |   },
 75 |   {
 76 |    "cell_type": "code",
 77 |    "execution_count": null,
 78 |    "metadata": {},
 79 |    "outputs": [],
 80 |    "source": []
 81 |   },
 82 |   {
 83 |    "cell_type": "code",
 84 |    "execution_count": 107,
 85 |    "metadata": {},
 86 |    "outputs": [
 87 |     {
 88 |      "name": "stdout",
 89 |      "output_type": "stream",
 90 |      "text": [
 91 |       "Read/Initialize samples for evaluation\n",
 92 |       "Initialize baselines (center & equator)\n"
 93 |      ]
 94 |     }
 95 |    ],
 96 |    "source": [
 97 |     "dirpath1 = u'./data/head-orientation/dataset1'\n",
 98 |     "dirpath2 = u'./data/head-orientation/dataset2/Experiment_1'\n",
 99 |     "dirpath3 = u'./data/head-orientation/dataset3/sensory/orientation'\n",
100 |     "ext1 = '.txt'\n",
101 |     "ext2 = '.csv'\n",
102 |     "ext3 = '.csv'\n",
103 |     "headoren = saldat_head_orientation.HeadOrientation(dirpath1, dirpath2, dirpath3, ext1, ext2, ext3)\n",
104 |     "\n",
105 |     "var = 20\n",
106 |     "salsal = saldat_saliency.Fixation(var)\n",
107 |     "\n",
108 |     "saleval = saldat_eval.SalEvaluation(headoren, salsal, verbose=True)"
109 |    ]
110 |   },
111 |   {
112 |    "cell_type": "code",
113 |    "execution_count": 6,
114 |    "metadata": {},
115 |    "outputs": [],
116 |    "source": [
117 |     "#dataset = 3\n",
118 |     "#dirpath, filename_list, f_parse, f_extract_direction = headoren.load_filename_list(dataset, topic)\n",
119 |     "#series_ds = headoren.load_series_ds(filename_list, f_parse)\n",
120 |     "#vector_ds = headoren.headpos_to_headvec(series_ds, f_extract_direction)\n",
121 |     "#vector_ds = headoren.cutoff_vel_acc(vector_ds)"
122 |    ]
123 |   },
124 |   {
125 |    "cell_type": "code",
126 |    "execution_count": 7,
127 |    "metadata": {},
128 |    "outputs": [
129 |     {
130 |      "name": "stdout",
131 |      "output_type": "stream",
132 |      "text": [
133 |       "27.640000000000022 panel\n"
134 |      ]
135 |     },
136 |     {
137 |      "data": {
138 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADfCAYAAADmzyjKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
139 |       "text/plain": [
140 |        "<matplotlib.figure.Figure at 0x1473a6723550>"
141 |       ]
142 |      },
143 |      "metadata": {},
144 |      "output_type": "display_data"
145 |     },
146 |     {
147 |      "data": {
148 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADfCAYAAADmzyjKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nVegiIg2hCl1EpCFUoYuINMT/B/gGEskaDSoyAAAAAElFTkSuQmCC\n",
149 |       "text/plain": [
150 |        "<matplotlib.figure.Figure at 0x1473a6723d10>"
151 |       ]
152 |      },
153 |      "metadata": {},
154 |      "output_type": "display_data"
155 |     }
156 |    ],
157 |    "source": [
158 |     "dataset = 3\n",
159 |     "ds, t, vlist, salmap = saleval.dat[dataset][0]\n",
160 |     "fixlist = [[t, vlist[idx], -1, -1] for idx,_ in enumerate(vlist)]\n",
161 |     "fmap = headoren.create_fixation_map(fixlist, dataset)\n",
162 |     "plt.imshow(fmap)\n",
163 |     "plt.figure()\n",
164 |     "plt.imshow(salmap)\n",
165 |     "print t, ds"
166 |    ]
167 |   },
168 |   {
169 |    "cell_type": "code",
170 |    "execution_count": 15,
171 |    "metadata": {},
172 |    "outputs": [
173 |     {
174 |      "name": "stdout",
175 |      "output_type": "stream",
176 |      "text": [
177 |       "0.08920620580763855 0.00027063952802410966 0.0 1.0133570250784742e-89\n"
178 |      ]
179 |     },
180 |     {
181 |      "data": {
182 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADfCAYAAADmzyjKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSpjQJakSJnRJqsT/AWv+1QnTTt8nAAAAAElFTkSuQmCC\n",
183 |       "text/plain": [
184 |        "<matplotlib.figure.Figure at 0x1473a44c5b10>"
185 |       ]
186 |      },
187 |      "metadata": {},
188 |      "output_type": "display_data"
189 |     }
190 |    ],
191 |    "source": [
192 |     "\n",
193 |     "heat_mapi = salsal.create_saliency([fixlist[0]], dataset)\n",
194 |     "plt.imshow(heat_mapi)\n",
195 |     "heat_mapi = salsal.create_saliency([[0.0, [-1.0, 0, 0], 0, 0]], 1)\n",
196 |     "plt.imshow(heat_mapi)\n",
197 |     "print heat_mapi.max(), heat_mapi.mean(), heat_mapi.min(), np.median(heat_mapi)\n"
198 |    ]
199 |   },
200 |   {
201 |    "cell_type": "code",
202 |    "execution_count": 8,
203 |    "metadata": {},
204 |    "outputs": [
205 |     {
206 |      "name": "stdout",
207 |      "output_type": "stream",
208 |      "text": [
209 |       "8.7027258873\n"
210 |      ]
211 |     }
212 |    ],
213 |    "source": [
214 |     "#create individual heat map for saliency. Important\n",
215 |     "import timeit\n",
216 |     "btime = timeit.default_timer()\n",
217 |     "\n",
218 |     "heat_map_list = []\n",
219 |     "for i in np.arange(len(fixlist)):\n",
220 |     "    heat_mapi = salsal.create_saliency([fixlist[i]], dataset)\n",
221 |     "    heat_map_list.append(heat_mapi)\n",
222 |     "print timeit.default_timer() - btime\n",
223 |     "\n",
224 |     "#10 seconds for 1 frames, total number of evaluation: "
225 |    ]
226 |   },
227 |   {
228 |    "cell_type": "code",
229 |    "execution_count": 16,
230 |    "metadata": {},
231 |    "outputs": [],
232 |    "source": [
233 |     "def get_false_geoxy(_topic, _false_gxy_dict, topk=5):\n",
234 |     "    temp = []\n",
235 |     "    result = []\n",
236 |     "    for t in _false_gxy_dict.keys():\n",
237 |     "        if t != _topic:\n",
238 |     "            temp = temp + _false_gxy_dict[t]\n",
239 |     "    idx_list = range(len(temp))\n",
240 |     "    np.random.shuffle(idx_list)\n",
241 |     "    idx_list = idx_list[:topk]\n",
242 |     "    for idx in idx_list:\n",
243 |     "        result += temp[idx]\n",
244 |     "    return result\n",
245 |     "\n",
246 |     "def sAUC_baseline(_heat_map_list, _true_fixation_list, _true_geoxy_list, _false_geoxy_dict, _vec_map, _gaussian_dict, _width, _height):\n",
247 |     "    split_n = 3\n",
248 |     "    split_pos = 0   \n",
249 |     "    \n",
250 |     "    false_geoxy_list = get_false_geoxy('2', _false_geoxy_dict, topk=5)\n",
251 |     "    \n",
252 |     "\n",
253 |     "    idx_list_train, idx_list_val, fixation_train_list, fixation_val_list =\\\n",
254 |     "                create_split(split_n, split_pos, _true_fixation_list)\n",
255 |     "    salient_map = sum([_heat_map_list[i] for i in idx_list_val])\n",
256 |     "    true_geoxy_list_train = [_true_geoxy_list[idx] for idx in idx_list_train]\n",
257 |     "        \n",
258 |     "    #human model\n",
259 |     "    y_pred = [salient_map[x, y] for (x, y) in true_geoxy_list_train]\n",
260 |     "    y_pred += [salient_map[x, y] for (x, y) in false_geoxy_list]\n",
261 |     "    #horizontal model\n",
262 |     "    y_pred_horizon = [1.0 - np.abs(get_fixation.geoy_to_phi(x, _height))/90.0 for (x, y) in true_geoxy_list_train]\n",
263 |     "    y_pred_horizon += [1.0 - np.abs(get_fixation.geoy_to_phi(x, _height))/90.0 for (x, y) in false_geoxy_list]\n",
264 |     "    #center model\n",
265 |     "    y_pred_center = [salient_center_map[x, y] for (x, y) in true_geoxy_list_train]\n",
266 |     "    y_pred_center += [salient_center_map[x, y] for (x, y) in false_geoxy_list]\n",
267 |     "    #true fixation\n",
268 |     "    y_true = [1 for (y, x) in true_geoxy_list_train]\n",
269 |     "    y_true += [0 for (y, x) in false_geoxy_list]\n",
270 |     "\n",
271 |     "    return metrics.roc_auc_score(y_true, y_pred),\\\n",
272 |     "            metrics.roc_auc_score(y_true, y_pred_horizon),\\\n",
273 |     "            metrics.roc_auc_score(y_true, y_pred_center)"
274 |    ]
275 |   },
276 |   {
277 |    "cell_type": "code",
278 |    "execution_count": 68,
279 |    "metadata": {},
280 |    "outputs": [
281 |     {
282 |      "name": "stdout",
283 |      "output_type": "stream",
284 |      "text": [
285 |       "pacman 27.460000000000022\n"
286 |      ]
287 |     }
288 |    ],
289 |    "source": []
290 |   },
291 |   {
292 |    "cell_type": "code",
293 |    "execution_count": 77,
294 |    "metadata": {},
295 |    "outputs": [
296 |     {
297 |      "name": "stdout",
298 |      "output_type": "stream",
299 |      "text": [
300 |       "pacman 10.600000000000009\n",
301 |       "12\n",
302 |       "0.9857142857142857\n",
303 |       "total time taken:  1.38693213463\n"
304 |      ]
305 |     },
306 |     {
307 |      "data": {
308 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADfCAYAAADmzyjKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nbVWYQgAAAABJRU5ErkJggg==\n",
309 |       "text/plain": [
310 |        "<matplotlib.figure.Figure at 0x1473a7a8e850>"
311 |       ]
312 |      },
313 |      "metadata": {},
314 |      "output_type": "display_data"
315 |     },
316 |     {
317 |      "data": {
318 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADfCAYAAADmzyjKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
319 |       "text/plain": [
320 |        "<matplotlib.figure.Figure at 0x1473a3b6c1d0>"
321 |       ]
322 |      },
323 |      "metadata": {},
324 |      "output_type": "display_data"
325 |     },
326 |     {
327 |      "data": {
328 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADfCAYAAADmzyjKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nsxIdrEahaDwAAAAASUVORK5CYII=\n",
329 |       "text/plain": [
330 |        "<matplotlib.figure.Figure at 0x1473a6c97b10>"
331 |       ]
332 |      },
333 |      "metadata": {},
334 |      "output_type": "display_data"
335 |     },
336 |     {
337 |      "data": {
338 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADfCAYAAADmzyjKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSY34fzxshMAKiD1+AAAAAElFTkSuQmCC\n",
339 |       "text/plain": [
340 |        "<matplotlib.figure.Figure at 0x1473a8b37dd0>"
341 |       ]
342 |      },
343 |      "metadata": {},
344 |      "output_type": "display_data"
345 |     }
346 |    ],
347 |    "source": [
348 |     "import timeit\n",
349 |     "\n",
350 |     "btime = timeit.default_timer()\n",
351 |     "\n",
352 |     "dataset = 3\n",
353 |     "idx = np.random.randint(len(saleval.dat[dataset]))\n",
354 |     "topic, t, vpos_list, salmap = saleval.dat[dataset][idx]\n",
355 |     "vneg_list = saleval.get_negative_fixations(dataset, topic)\n",
356 |     "print topic, t\n",
357 |     "\n",
358 |     "#now I have positive, negative fixation, need to create saliency list\n",
359 |     "fixpos_list = [(t, v, _, _) for v in vpos_list]\n",
360 |     "fixneg_list = [(t, v, _, _) for v in vneg_list]\n",
361 |     "fposmap = headoren.create_fixation_map(fixpos_list, dataset)\n",
362 |     "fnegmap = headoren.create_fixation_map(fixneg_list, dataset)\n",
363 |     "\n",
364 |     "np.random.shuffle(fixpos_list)\n",
365 |     "npos= len(fixpos_list)/3\n",
366 |     "fixposeval_list = fixpos_list[:npos]\n",
367 |     "fixpostrain_list = fixpos_list[npos:]\n",
368 |     "val_salmap = salsal.create_saliency(fixposeval_list, dataset)\n",
369 |     "train_fmap = headoren.create_fixation_map(fixpostrain_list, dataset)\n",
370 |     "geoxy_train = zip(*np.where(train_fmap==1))\n",
371 |     "geoxy_neg = zip(*np.where(fnegmap==1))\n",
372 |     "\n",
373 |     "#val_salmap must be evaluated against geoxy_train + geoxy_neg\n",
374 |     "\n",
375 |     "y_pred = [val_salmap[hi, wi] for (hi, wi) in geoxy_train]\n",
376 |     "y_pred += [val_salmap[hi, wi] for (hi, wi) in geoxy_neg]\n",
377 |     "\n",
378 |     "y_true = [1 for item in geoxy_train]\n",
379 |     "y_true += [0 for item in geoxy_neg]\n",
380 |     "\n",
381 |     "plt.imshow(fposmap)\n",
382 |     "plt.figure()\n",
383 |     "plt.imshow(fnegmap)\n",
384 |     "plt.figure()\n",
385 |     "\n",
386 |     "plt.imshow(val_salmap)\n",
387 |     "plt.figure()\n",
388 |     "plt.imshow(train_fmap)\n",
389 |     "\n",
390 |     "print len(fixpos_list)\n",
391 |     "print metrics.roc_auc_score(y_true, y_pred)\n",
392 |     "\n",
393 |     "print 'total time taken: ', timeit.default_timer() - btime"
394 |    ]
395 |   },
396 |   {
397 |    "cell_type": "code",
398 |    "execution_count": 71,
399 |    "metadata": {},
400 |    "outputs": [],
401 |    "source": [
402 |     "baseline_circle = None\n",
403 |     "baseline_equator = [1.0 - np.abs(head_orientation_lib.geoy_to_phi(hi, head_orientation_lib.H))/90.0 for (hi, wi) in geoxy_train]"
404 |    ]
405 |   },
406 |   {
407 |    "cell_type": "code",
408 |    "execution_count": 59,
409 |    "metadata": {},
410 |    "outputs": [
411 |     {
412 |      "data": {
413 |       "text/plain": [
414 |        "(45, 80)"
415 |       ]
416 |      },
417 |      "execution_count": 59,
418 |      "metadata": {},
419 |      "output_type": "execute_result"
420 |     }
421 |    ],
422 |    "source": [
423 |     "head_orientation_lib.H/2, head_orientation_lib.W/2"
424 |    ]
425 |   },
426 |   {
427 |    "cell_type": "code",
428 |    "execution_count": 111,
429 |    "metadata": {},
430 |    "outputs": [
431 |     {
432 |      "name": "stdout",
433 |      "output_type": "stream",
434 |      "text": [
435 |       "0 0.9600694444444444 nan panel 27.640000000000022 23\n",
436 |       "1 0.7582417582417582 0.9600694444444444 ride 50.50000000000004 19\n",
437 |       "2 0.7972972972972973 0.8591556013431013 diving 8.260000000000007 21\n",
438 |       "3 0.731186224489796 0.8385361666611666 coaster2_ 50.08000000000004 47\n",
439 |       "4 0.5118159203980099 0.811698681118324 landscape 59.86000000000005 17\n",
440 |       "5 0.7578125 0.7517221289742612 game 5.740000000000004 36\n",
441 |       "6 1.0 0.7527371908118843 sport 28.240000000000023 20\n",
442 |       "Warning, not enough data at : panel, 31.06, 14, SKIPPED\n",
443 |       "8 1.0 0.7880604492673294 drive 40.42000000000004 27\n",
444 |       "9 0.8974603174603175 0.8145528931089132 coaster_ 44.08000000000004 37\n",
445 |       "10 0.6534598214285714 0.8237648291479581 panel 19.480000000000018 20\n",
446 |       "11 0.6870527000650618 0.8067343283760195 coaster2_ 52.96000000000004 43\n",
447 |       "12 0.8295454545454546 0.7958541803477506 coaster_ 16.900000000000013 16\n",
448 |       "13 0.8090909090909091 0.7986617865308926 diving 59.68000000000005 38\n",
449 |       "14 0.9030054644808744 0.7994640267278169 panel 49.780000000000044 17\n",
450 |       "Warning, not enough data at : game, 2.86, 12, SKIPPED\n",
451 |       "16 0.6277472527472527 0.8068598437101782 coaster2_ 38.74000000000003 42\n",
452 |       "Warning, not enough data at : pacman, 20.5, 12, SKIPPED\n",
453 |       "Warning, not enough data at : drive, 21.22, 14, SKIPPED\n",
454 |       "19 0.7698863636363636 0.7949190043126497 coaster2_ 49.12000000000004 23\n",
455 |       "20 0.6319942611190816 0.7933544642703819 ride 7.360000000000006 25\n",
456 |       "21 0.557983682983683 0.783862687614423 panel 41.080000000000034 32\n",
457 |       "22 0.7661913250148544 0.7713138540238264 game 49.72000000000004 25\n",
458 |       "Warning, not enough data at : landscape, 22.24, 13, SKIPPED\n",
459 |       "24 0.9181096681096681 0.7710442472338804 game 52.00000000000004 20\n",
460 |       "25 0.9371794871794872 0.7783975182776699 coaster_ 58.66000000000005 17\n",
461 |       "26 0.6058122205663189 0.7859585644158517 diving 28.900000000000023 32\n",
462 |       "27 0.8538461538461539 0.7777700942408728 coaster_ 36.70000000000003 27\n",
463 |       "28 0.6051587301587301 0.7810777490063198 coaster2_ 28.000000000000025 42\n",
464 |       "Warning, not enough data at : game, 3.64, 10, SKIPPED\n",
465 |       "30 0.8246268656716418 0.7737477898876705 game 25.18000000000002 21\n",
466 |       "31 0.5873015873015873 0.7757829529190293 diving 51.280000000000044 27\n",
467 |       "32 0.8623481781376519 0.7685336696260509 coaster2_ 6.820000000000006 28\n",
468 |       "Warning, not enough data at : pacman, 12.04, 6, SKIPPED\n",
469 |       "34 0.7413793103448275 0.7720082810524064 sport 16.660000000000014 29\n",
470 |       "Warning, not enough data at : landscape, 1.06, 14, SKIPPED\n",
471 |       "36 0.8743228602383533 0.7709143892414215 sport 6.820000000000006 19\n",
472 |       "37 0.7803571428571427 0.7744801985861434 diving 25.420000000000023 29\n",
473 |       "38 0.653061224489796 0.7746760967285099 panel 39.580000000000034 21\n",
474 |       "39 0.88 0.7707530363337127 game 23.20000000000002 29\n",
475 |       "40 0.7376373626373627 0.7741670039482841 sport 32.260000000000026 21\n",
476 |       "41 0.787012987012987 0.7730600451206804 pacman 47.920000000000044 21\n",
477 |       "Warning, not enough data at : coaster_, 1.36, 5, SKIPPED\n",
478 |       "43 0.7699214365881033 0.7734704257645717 ride 48.82000000000004 32\n",
479 |       "Warning, not enough data at : panel, 10.24, 6, SKIPPED\n",
480 |       "45 0.8968599033816425 0.7733690260738154 sport 39.040000000000035 34\n",
481 |       "46 0.7622641509433963 0.7767993282212551 coaster_ 36.040000000000035 30\n",
482 |       "47 0.9192546583850931 0.7764064855921238 coaster2_ 53.920000000000044 31\n",
483 |       "48 0.8777777777777778 0.780165648034044 coaster_ 57.28000000000005 26\n",
484 |       "49 0.8315972222222222 0.7826685231556781 pacman 50.200000000000045 17\n",
485 |       "50 0.7749999999999999 0.7838917406323418 pacman 31.900000000000027 22\n",
486 |       "51 0.974537037037037 0.7836748689096017 coaster_ 58.00000000000005 26\n",
487 |       "52 0.7549751243781094 0.7882192062459692 drive 9.220000000000008 17\n",
488 |       "53 0.6866666666666666 0.7874460880629957 coaster_ 22.000000000000018 37\n",
489 |       "Warning, not enough data at : panel, 14.68, 14, SKIPPED\n",
490 |       "Warning, not enough data at : panel, 13.48, 11, SKIPPED\n",
491 |       "56 0.48087686567164184 0.7851556466676246 landscape 19.360000000000017 24\n",
492 |       "57 0.6351351351351351 0.7783938959788249 drive 19.360000000000017 21\n",
493 |       "58 0.9766414141414141 0.7752795750909186 landscape 46.90000000000004 16\n",
494 |       "59 0.6212121212121213 0.7795638695388015 landscape 18.700000000000017 16\n",
495 |       "Warning, not enough data at : sport, 55.48, 13, SKIPPED\n",
496 |       "61 0.9611823361823362 0.7762648747819959 diving 33.10000000000003 26\n",
497 |       "62 0.7439814814814815 0.7800387005248599 coaster2_ 35.32000000000003 30\n",
498 |       "63 0.886328125 0.7793175561439923 pacman 59.620000000000054 24\n",
499 |       "64 0.7960164835164835 0.7814158025921494 ride 40.24000000000004 19\n",
500 |       "Warning, not enough data at : pacman, 59.08, 8, SKIPPED\n",
501 |       "66 0.728813559322034 0.7816965849176173 coaster2_ 39.70000000000003 30\n",
502 |       "67 0.6816964285714286 0.7806987919818515 coaster2_ 11.68000000000001 24\n",
503 |       "Warning, not enough data at : ride, 17.44, 8, SKIPPED\n",
504 |       "69 0.6641386782231854 0.7788654148816585 pacman 24.52000000000002 19\n",
505 |       "70 0.8354700854700855 0.7767794742151408 pacman 44.26000000000004 18\n",
506 |       "71 0.9795 0.7778275208446935 drive 26.560000000000024 29\n",
507 |       "72 0.8208333333333333 0.7813656345140848 landscape 29.320000000000025 21\n",
508 |       "Warning, not enough data at : drive, 8.44, 12, SKIPPED\n",
509 |       "74 0.5322463768115941 0.7820461120799339 panel 52.840000000000046 29\n",
510 |       "75 0.9929378531073446 0.7778122182618264 drive 27.520000000000024 26\n",
511 |       "76 0.9812446717817562 0.7813976455092517 panel 29.380000000000024 25\n",
512 |       "77 0.8930288461538461 0.7846738262678175 sport 19.960000000000015 48\n",
513 |       "78 0.8539553752535498 0.7864214878788824 pacman 33.88000000000003 25\n",
514 |       "Warning, not enough data at : panel, 22.72, 12, SKIPPED\n",
515 |       "Warning, not enough data at : sport, 51.04, 5, SKIPPED\n",
516 |       "Warning, not enough data at : landscape, 53.44, 13, SKIPPED\n",
517 |       "Warning, not enough data at : landscape, 57.1, 13, SKIPPED\n",
518 |       "83 0.8214285714285714 0.787493454345147 coaster2_ 51.76000000000005 35\n",
519 |       "84 0.6922619047619047 0.7880236905495754 landscape 27.760000000000023 22\n",
520 |       "85 0.8041666666666667 0.7865504323066882 sport 56.32000000000005 17\n",
521 |       "Warning, not enough data at : panel, 10.3, 9, SKIPPED\n",
522 |       "87 0.6858710562414267 0.7868173449485061 pacman 34.36000000000003 27\n",
523 |       "Warning, not enough data at : diving, 55.18, 10, SKIPPED\n",
524 |       "89 0.9324324324324325 0.7853106839230273 coaster2_ 29.440000000000026 27\n",
525 |       "90 0.7456467661691542 0.7874742390481656 ride 18.520000000000017 18\n",
526 |       "91 0.9099999999999999 0.7868680437890495 sport 39.52000000000003 37\n",
527 |       "92 0.8294573643410852 0.7886270717349202 diving 39.70000000000003 17\n",
528 |       "93 0.6759485924112606 0.789202146278669 panel 43.360000000000035 28\n",
529 |       "94 0.9422700587084148 0.7876291802527328 drive 23.14000000000002 21\n",
530 |       "95 0.8625 0.7897475484507558 panel 38.62000000000003 30\n",
531 |       "96 0.9768518518518519 0.7907306896879077 landscape 45.34000000000004 27\n",
532 |       "97 0.9448924731182795 0.793212305183427 coaster_ 29.200000000000024 17\n",
533 |       "98 0.718694885361552 0.7952080968667804 game 17.740000000000016 21\n",
534 |       "Warning, not enough data at : landscape, 11.38, 12, SKIPPED\n",
535 |       "100 0.7584325396825398 0.7942144187952839 sport 41.98000000000004 23\n",
536 |       "101 0.7716823406478578 0.7937556767553768 landscape 33.64000000000003 16\n",
537 |       "102 0.5557909604519775 0.7934762674375602 sport 22.000000000000018 36\n",
538 |       "103 0.9598765432098766 0.7905052011002404 coaster_ 16.720000000000013 24\n",
539 |       "Warning, not enough data at : pacman, 40.66, 13, SKIPPED\n",
540 |       "105 0.6976495726495726 0.7925962053238161 pacman 36.76000000000003 17\n",
541 |       "106 0.8660818713450293 0.791438319559496 game 42.220000000000034 44\n",
542 |       "107 0.9963570127504553 0.7923376394605265 drive 22.42000000000002 26\n",
543 |       "108 0.8340080971659919 0.7947664415235018 panel 4.4200000000000035 28\n",
544 |       "109 0.7850438047559449 0.7952281080604723 ride 5.740000000000004 25\n",
545 |       "110 0.6960978835978836 0.7951096859290243 diving 12.28000000000001 35\n",
546 |       "111 0.8164665523156089 0.7939716192355629 ride 11.440000000000008 16\n",
547 |       "112 0.6891774891774891 0.794227243475109 landscape 15.580000000000013 22\n",
548 |       "113 0.8590686274509804 0.7930469091571583 sport 21.40000000000002 45\n",
549 |       "114 0.892109500805153 0.7937804838048674 sport 14.500000000000012 34\n",
550 |       "115 0.6769957983193278 0.7948610224532222 coaster2_ 12.820000000000011 25\n",
551 |       "Warning, not enough data at : pacman, 30.7, 3, SKIPPED\n",
552 |       "Warning, not enough data at : sport, 51.88, 3, SKIPPED\n",
553 |       "118 0.6747619047619047 0.7935798787126364 diving 13.24000000000001 22\n",
554 |       "119 1.0 0.7923022660895103 sport 28.480000000000025 22\n",
555 |       "120 0.6760416666666668 0.7945118164502601 ride 48.94000000000004 26\n",
556 |       "121 0.7546884452510587 0.7932647622420117 ride 36.76000000000003 28\n",
557 |       "122 0.8667840375586855 0.7928629256066894 sport 47.32000000000004 17\n",
558 |       "123 0.59145880574452 0.7936249989257821 ride 25.36000000000002 31\n",
559 |       "124 0.8063427800269906 0.7915620785871978 sport 26.740000000000023 38\n"
560 |      ]
561 |     },
562 |     {
563 |      "name": "stdout",
564 |      "output_type": "stream",
565 |      "text": [
566 |       "125 0.5162579957356077 0.7917113786017412 panel 52.54000000000005 41\n",
567 |       "126 0.7016806722689075 0.7889568447730799 ride 23.56000000000002 25\n",
568 |       "127 0.6022727272727273 0.7880927242532366 landscape 33.28000000000003 30\n",
569 |       "128 0.7217365967365967 0.7862709595769573 game 34.42000000000003 32\n",
570 |       "129 0.7950872656755009 0.7856444123649148 pacman 48.94000000000004 25\n",
571 |       "130 0.4792768959435626 0.7857352090313625 diving 6.580000000000005 31\n",
572 |       "131 0.6600361663652803 0.7828165584305263 coaster2_ 34.78000000000003 31\n",
573 |       "Warning, not enough data at : pacman, 13.72, 1, SKIPPED\n",
574 |       "133 0.8370726495726497 0.781658252845005 pacman 13.24000000000001 17\n",
575 |       "134 0.809274193548387 0.7821761444032073 coaster2_ 43.78000000000004 30\n",
576 |       "135 0.8128551136363636 0.7824270522656627 landscape 11.740000000000009 24\n",
577 |       "136 0.8067226890756303 0.7827062087919994 coaster_ 13.900000000000011 25\n",
578 |       "Warning, not enough data at : pacman, 13.06, 7, SKIPPED\n",
579 |       "138 0.7317004504504504 0.7829245404309414 coaster_ 51.94000000000005 35\n",
580 |       "139 0.5715539947322212 0.7824630621428289 diving 42.820000000000036 25\n",
581 |       "140 0.575 0.78057994546952 pacman 28.300000000000026 17\n",
582 |       "141 0.8970377448638318 0.7787606539166925 coaster2_ 20.020000000000017 34\n",
583 |       "142 0.9093567251461988 0.779798172258334 panel 19.960000000000015 17\n",
584 |       "143 0.44692460317460314 0.7809247683704025 ride 54.100000000000044 20\n",
585 |       "144 0.9028301886792452 0.7780454566014732 drive 59.56000000000005 29\n",
586 |       "145 0.931469298245614 0.7791119927730781 coaster_ 28.120000000000026 35\n",
587 |       "146 0.6030303030303029 0.7804031563787776 pacman 36.400000000000034 22\n",
588 |       "147 0.7160493827160493 0.7789126281993787 drive 12.70000000000001 18\n",
589 |       "148 0.9795751633986928 0.7783887678203508 panel 25.960000000000022 26\n",
590 |       "Warning, not enough data at : landscape, 58.9, 14, SKIPPED\n",
591 |       "150 0.656392694063927 0.7800514653044693 drive 18.760000000000016 26\n",
592 |       "151 0.559016393442623 0.7790378688188911 landscape 15.820000000000013 22\n",
593 |       "152 0.6705328017397608 0.7772490763361571 coaster2_ 42.94000000000004 46\n",
594 |       "153 0.9555555555555556 0.7763884612184444 drive 14.380000000000011 22\n",
595 |       "154 0.6615853658536586 0.7778217979731412 diving 9.460000000000008 23\n",
596 |       "155 0.8820512820512821 0.7768992866071135 panel 33.70000000000003 26\n",
597 |       "156 0.8961805555555555 0.7777272550751778 sport 26.800000000000022 44\n",
598 |       "157 0.6109589041095891 0.7786526714851809 ride 7.6600000000000055 15\n",
599 |       "158 0.9158653846153846 0.7773527198000989 coaster_ 44.74000000000004 38\n",
600 |       "159 0.7123233908948194 0.7784182018371395 landscape 1.0 21\n",
601 |       "160 0.9860759493670885 0.777913661295595 panel 5.380000000000004 15\n",
602 |       "161 0.8327721661054994 0.7794906483264397 panel 15.760000000000012 32\n",
603 |       "Warning, not enough data at : pacman, 10.24, 6, SKIPPED\n",
604 |       "163 0.7954545454545454 0.7798912612420718 game 31.84000000000003 16\n",
605 |       "164 1.0 0.7800074051541052 sport 34.24000000000003 26\n",
606 |       "165 0.7853618421052632 0.7816369799307413 ride 27.520000000000024 23\n",
607 |       "166 0.8452380952380952 0.7816643686232011 game 51.700000000000045 20\n",
608 |       "167 0.7565104166666667 0.7821284104233097 diving 42.460000000000036 17\n",
609 |       "168 0.6514161220043574 0.7819427727873921 diving 57.58000000000005 27\n",
610 |       "169 0.75 0.7810037321342768 drive 29.920000000000027 18\n",
611 |       "170 0.7787114845938377 0.7807822769047462 pacman 56.200000000000045 21\n",
612 |       "171 0.9044715447154471 0.780767590434456 game 50.50000000000004 18\n",
613 |       "172 0.8358288770053475 0.7816387450420687 game 4.360000000000003 25\n",
614 |       "Warning, not enough data at : pacman, 44.5, 13, SKIPPED\n",
615 |       "174 1.0 0.7820176970138398 drive 45.460000000000036 22\n",
616 |       "175 0.8775313404050145 0.7835314630067993 ride 2.200000000000001 25\n",
617 |       "176 0.9036300777873811 0.7841797380233386 pacman 6.880000000000005 19\n",
618 |       "177 0.8584183673469388 0.7849978910354212 panel 51.520000000000046 20\n",
619 |       "178 0.9476415094339623 0.7854973500579485 coaster_ 24.16000000000002 29\n",
620 |       "179 0.7830459770114943 0.786592918702381 coaster2_ 52.600000000000044 36\n",
621 |       "180 0.6905128205128205 0.7865691137245898 coaster_ 50.560000000000045 44\n",
622 |       "Warning, not enough data at : sport, 56.08, 10, SKIPPED\n",
623 |       "Warning, not enough data at : drive, 1.9, 2, SKIPPED\n",
624 |       "183 0.4243727598566308 0.7859287384365113 diving 39.580000000000034 22\n",
625 |       "184 0.886322463768116 0.78353432798234 pacman 36.82000000000003 18\n",
626 |       "185 0.5994687131050767 0.7842105657177727 panel 54.22000000000005 32\n",
627 |       "Warning, not enough data at : pacman, 10.6, 12, SKIPPED\n",
628 |       "187 0.9088541666666666 0.7830031026288009 game 55.060000000000045 21\n",
629 |       "188 1.0 0.7838203173303454 drive 36.52000000000003 36\n",
630 |       "189 0.741860465116279 0.7852150249604722 game 4.9600000000000035 30\n",
631 |       "190 0.8095238095238095 0.7849371111153172 panel 54.160000000000046 34\n",
632 |       "191 0.6856702619414483 0.7850937142898936 game 10.540000000000008 32\n",
633 |       "192 0.9523281596452329 0.7844644519332579 coaster_ 35.38000000000003 32\n",
634 |       "193 0.4518229166666667 0.7855201985226413 landscape 21.76000000000002 18\n",
635 |       "194 0.644758064516129 0.7834345905110414 coaster_ 2.200000000000001 29\n",
636 |       "195 0.7824675324675323 0.7825732456290855 pacman 45.34000000000004 16\n",
637 |       "196 0.9867788461538461 0.7825725930787055 pacman 14.380000000000011 24\n",
638 |       "197 0.6494897959183674 0.783825392177326 ride 30.220000000000027 30\n",
639 |       "Warning, not enough data at : game, 13.06, 4, SKIPPED\n",
640 |       "199 0.9791666666666666 0.7830062726879422 panel 31.84000000000003 21\n",
641 |       "0.7841951235605404\n"
642 |      ]
643 |     }
644 |    ],
645 |    "source": [
646 |     "dataset = 3\n",
647 |     "result = []\n",
648 |     "for idx, (topic, t, vpos_list, salmap) in enumerate(saleval.dat[dataset][:200]):\n",
649 |     "    if len(vpos_list) < 15:\n",
650 |     "        print 'Warning, not enough data at : {}, {}, {}, SKIPPED'.format(topic, t, len(vpos_list))\n",
651 |     "        continue\n",
652 |     "    sauc = saleval.sauc(dataset, topic, vpos_list)\n",
653 |     "    print idx, sauc, np.mean(result), topic, t, len(vpos_list)\n",
654 |     "    result.append(sauc)\n",
655 |     "result = np.array(result)\n",
656 |     "print result.mean()"
657 |    ]
658 |   },
659 |   {
660 |    "cell_type": "code",
661 |    "execution_count": null,
662 |    "metadata": {},
663 |    "outputs": [],
664 |    "source": [
665 |     "saleval.dat"
666 |    ]
667 |   },
668 |   {
669 |    "cell_type": "code",
670 |    "execution_count": null,
671 |    "metadata": {},
672 |    "outputs": [],
673 |    "source": []
674 |   }
675 |  ],
676 |  "metadata": {
677 |   "kernelspec": {
678 |    "display_name": "Python 2 (Intel, 2018 update 1)",
679 |    "language": "python",
680 |    "name": "c009-intel_distribution_of_python_2_2018u1"
681 |   },
682 |   "language_info": {
683 |    "codemirror_mode": {
684 |     "name": "ipython",
685 |     "version": 2
686 |    },
687 |    "file_extension": ".py",
688 |    "mimetype": "text/x-python",
689 |    "name": "python",
690 |    "nbconvert_exporter": "python",
691 |    "pygments_lexer": "ipython2",
692 |    "version": "2.7.14"
693 |   }
694 |  },
695 |  "nbformat": 4,
696 |  "nbformat_minor": 2
697 | }
698 | 


--------------------------------------------------------------------------------