#!/usr/bin/env python
# coding: utf-8

# In[1]:


import os, sys
from glob import glob
import networkx as nx
import numpy as np
import pickle
import matplotlib.pyplot as plt
sys.path.append('../');
import Holes as ho


# In[2]:


import geojson as gj


# In[3]:


get_ipython().run_line_magic('matplotlib', 'inline')


# In[4]:


max_dimensions=1;


# In[5]:


import scipy.io
ld = os.listdir('../stores/phom/country_high_act_low_entropy_matrices/');
countries_to_cells={}
for country in ld:
    if country == '.gitignore':
        continue
    countries_to_cells[country[:-4]]=pickle.load(open('../stores/phom/country_high_act_low_entropy_matrices/'+country))
    


# In[6]:


grid=gj.load(open('../data/poi/milano-grid.geojson'))


# In[7]:


import pandas as pd

cell_position = {}
for i,cell in enumerate(grid['features']):
    cell_position[cell["properties"]["cellId"]] = cell["geometry"]["coordinates"][0][0]


# In[8]:


import networkx as nx
country_graphs={}
for country in countries_to_cells:
    coords = np.nonzero(countries_to_cells[country]);
    country_graphs[country]=nx.Graph();
    coords = zip(coords[0],coords[1]);
    for i, cell in enumerate(coords):
        for j, other_cell in enumerate(coords):
            if i<j:
                country_graphs[country].add_edge(cell, other_cell, weight=np.linalg.norm(np.array(cell)-np.array(other_cell)))
for country in country_graphs.keys():
    if len(country_graphs[country].edges()) == 0:
        del country_graphs[country]


# # Construction of metrical filtrations for countries

# In[9]:


num_max_landmarks = 30 ## customisable max number of landmarks to be chosen 
cd = {}
subgraph_dict={}
for country in country_graphs:
    print country
    N=np.min([num_max_landmarks, country_graphs[country].number_of_nodes()]);
    relabel_dict={}
    G=country_graphs[country].copy();
    for i,n in enumerate(country_graphs[country].nodes()):
        relabel_dict[n] = i;
    G = nx.relabel_nodes(country_graphs[country],relabel_dict);
    CS_landmarks=ho.landmarks.minmax_selector(nx.adjacency_matrix(G),N);       
    DG=nx.subgraph(G,CS_landmarks);
    subgraph_dict[country]=DG.copy();
    cd[country] = ho.filtrations.metrical_filtration(DG,max_dimensions);


# In[10]:


filtration_dir='../stores/phom/filtrations/'
if not os.path.exists(filtration_dir):
    os.makedirs(filtration_dir)

for c in cd:
    pickle.dump(cd[c],open('../stores/phom/filtrations/'+str(c)+'_fil.pck','w'))


# In[11]:


output_dir = '../stores/phom/output/'
if not os.path.exists(output_dir):
    os.makedirs(output_dir)


# In[12]:


li=os.listdir(filtration_dir);

for f in li:
    if f == '.gitignore':
        continue
    print f
    ho.persistent_homology_calculation(filtration_dir+f,max_dimensions,f.split('_')[0],output_dir,m1=1000,m2=1000)


# In[13]:


generators_dict={}
for c in cd:
    filename=open(output_dir+'gen/generators_'+c+'_.pck');
    generators_dict[c]=pickle.load(filename);
    filename.close()


# In[14]:


weighted_gen_dict={}
for c in generators_dict.keys():
    weighted_gen_dict[c]=ho.weight_label_generators(generators_dict[c],subgraph_dict[c],ascending=True);
    pickle.dump(weighted_gen_dict[c],open(output_dir+'/gen/weighted_generators_'+c+'_.pck','w'))