from Tkinter import *

#from time import sleep

import csv

import ast

from util_time import *

import plotGraph

import util_loadData as ld

import colorRamp as cr

import util_geo as geo

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

from ggplot import *

import util_array as ar

# ###############

# global setting of user interface

w_photo = plotGraph.w_photo

h_photo = plotGraph.h_photo

photo_tb = plotGraph.photo_tb

photo_lr = plotGraph.photo_lr

w_window = plotGraph.w_window

h_window = plotGraph.h_window

h_slider = plotGraph.h_slider

w_graph = plotGraph.graph_width

h_graph = plotGraph.graph_height

h_slider = 10

w_slider = w_window

w_button = 3

w_ckbutton = 2

w_scale = 10

category = 7

w_span_colorscheme = category + 3

h_span_colorscheme = w_span_colorscheme

w_span_button = 1

w_span_mdh = 1

w_span_photo = w_span_mdh + w_span_colorscheme

h_span_button = 11

h_span_mdh = h_span_colorscheme / 3

w_span_year = w_span_photo

h_span_year = 1

h_span_plotagg = h_span_colorscheme

w_span_graph = w_span_button * 4

h_span_graph = 1

h_span_photo = h_span_graph * 4

s_colorcell = 28

w_mdh_slider = w_window - (s_colorcell + 2) * w_span_colorscheme

row_photo = 0

col_photo = 0

row_empty = row_photo + h_span_photo

row_month = row_empty + 1

row_date = row_month + h_span_mdh

row_hour = row_date + h_span_mdh

row_year = row_hour + h_span_mdh

row_colorscheme = row_empty

row_plotagg = row_month

row_graph_0 = 0

row_button_0 = row_year

col_photo = 0

col_mdh = 0

col_colorscheme = col_mdh + w_span_mdh

col_year = 0

col_graph_0 = col_photo + w_span_photo

col_button_0 = col_graph_0

col_plotagg = col_graph_0

hour_start = 0

hour_end = 8759

interval = (hour_end - hour_start) / 10

def display(idx, time, imgName):

plotGraph.plotAll(idx, lbound, ubound, lbound_total, ubound_total)

# control month, date, hour slider

def printimg3(event):

display(idx, time, imgName)

def printimg(event):

display(idx, time, imgName)

master = Tk()

w = str(w_graph * 2 + w_window + 10)

master.geometry(w+'x700+0+0')

master.title("Dynamic Heating-Cooling Map")

defaultbg = master.cget('bg')

bd_font = "TkDefault 8 bold"

nm_font = "TkDefault 8"

ot_font = "TkDefault 6"

font_color = "gray45"

# variables of option menu

master.typeVar = StringVar(master) # plot topic

master.typeVar.set("space heat")

master.numVar = StringVar(master) # plot quantities

master.numVar.set("single")

master.timeVar = StringVar(master) # time interval and duration

master.timeVar.set("day")

master.dimVar = StringVar(master) # 2D/3D toggle

master.dimVar.set("2D")

master.statVar = StringVar(master) # aggregation method

master.statVar.set("exact")

#reading in building information configuration

[bdCountDict, bdTypeDict, areaDict, initDict, bdSectorDict,bdFilenameDict] = ld.readLand()

bdTypelist = [key for key in bdCountDict]

bdinitlist = [initDict[key] for key in initDict] # key is building type

def showTxt():

w_span_colorscheme)

def plotBuilding():

plt.show()

# show legend in a separate window

def showLegend():

legendWd.mainloop()

# functions to control buttons to jump forward and backward

def advance24h():

allyear.set(allyear.get() + 24)

def advance1h():

allyear.set(allyear.get() + 1)

def back24h():

allyear.set(allyear.get() - 24)

def back1h():

allyear.set(allyear.get() - 1)

# clear selected landuse for calculation

def clearSelect():

global landSelection # modify the global copy

landSelection = []

hmap.g.delete("a")

# buttons to control advance and back

buttonList = [[{'text':'+24h', 'cmd':advance24h},

{'text':'clear', 'cmd':clearSelect}]]

rowcount = 0

for row in buttonList:

buttoncount = 0

for button in row:

button = Button(master, text = button['text'], command =

button['cmd'], width = w_button, font = bd_font,

fg = font_color)

button.grid(row = row_button_0 + rowcount, column =

col_button_0 + buttoncount, rowspan =

h_span_button, columnspan = w_span_button)

buttoncount += 1

rowcount += 1

showTxt()

# create a canvas and display images on canvas

hmap = plotGraph.ImgPlot("Dynamic Heat Map", row_photo, col_photo,

h_span_photo, w_span_photo, w_window,

h_window, photo_lr, photo_lr, photo_tb,

photo_tb, master)

'''

def callback(event):

with open ('landCord.txt', 'a') as wt:

wt.write ('{0}, {1}, '.format(event.x, event.y))

print event.x, event.y

'''

# reading a table with landuse and coordinates

def readLandShape():

return landDict

(x, y) = ld.read2dicts()

allDict = dict(zip(x, y))

dfSpaceHeat = pd.DataFrame(allDict["Space Heating"])

dfHeat = pd.DataFrame(allDict["Heating"])

dfElec = pd.DataFrame(allDict["Electricity:Facility"])

dfCool = pd.DataFrame(allDict["Cooling:Electricity"])

dfRecover = pd.DataFrame(allDict["Heat Recover"])

landDict = readLandShape()

initialDict = dict([(initDict[key], key) for key in initDict])

landSelection = []

def plotMethod():

return (num, choice, period, step, title, stat)

def landName(event):

print "invalid selection"

hmap.g.bind("<Button-1>", landName)

n_row = 4

n_col = 2

x = plotGraph.createAll(master, n_row, n_col, row_graph_0,

col_graph_0, h_span_graph, w_span_graph,

h_span_plotagg, w_span_graph)

(lbound, ubound, lbound_total, ubound_total) = x

empty = Canvas(width = w_mdh_slider, height = s_colorcell/2)

empty.grid(row = row_empty, column = col_mdh)

# month

month = Scale(master, from_= 1, length = w_mdh_slider, to =

12,tickinterval=1, orient=HORIZONTAL, command =

printimg3, label = "Month", width = w_scale, font =

nm_font, activebackground = "red", fg = font_color)

month.set(1)

month.grid(row = row_month, column = col_mdh, rowspan = h_span_mdh,

columnspan = w_span_mdh)

# date

date = Scale(master, from_= 1, to = 31, length = w_mdh_slider,

tickinterval=7, orient=HORIZONTAL, command = printimg3,

label = "Date", width = w_scale, font = nm_font,

activebackground = "green", fg = font_color)

date.set(1)

date.grid(row = row_date, column = col_mdh, rowspan = h_span_mdh,

columnspan = w_span_mdh)

# hour

hour = Scale(master, from_= 0, to = 23, length = w_mdh_slider,

tickinterval=4, orient=HORIZONTAL, command = printimg3,

label = "Hour", width = w_scale, font = nm_font,

activebackground = "blue", fg = font_color)

hour.set(0)

hour.grid(row = row_hour, column = col_mdh, rowspan = h_span_mdh,

columnspan = w_span_mdh)

# year slider

allyear = Scale(master, from_= hour_start, length = w_slider, to =

hour_end, tickinterval=interval, orient=HORIZONTAL,

command = printimg, label = "Year Round", width = 10,

font = nm_font, fg = font_color)

allyear.set(0)

allyear.grid(row = row_year, column = col_year, rowspan = h_span_year,

columnspan = w_span_year)

# cover the original label

monthTick = Canvas(master, width = w_slider, height = 15)

monthTick.grid(row = row_year, column = col_year, rowspan =

h_span_year, columnspan = w_span_year, sticky = S)

monthList = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",

"Sep", "Oct", "Nov", "Dec"]

w_cursor = 15

for i in range(12):

monthTick.create_line(w_cursor + 1 + w_slider/12*i, 1, w_cursor + 1 + w_slider/12*i, 8,

fill = font_color)

monthTick.create_text(w_cursor + 26 + w_slider/12*i, 7, text = monthList[i],

font = nm_font, fill = font_color)

optbuttonList = [{'opt': ['single', 'group', 'community'],

'var':master.numVar},

{'opt': ['2D', '3D'], 'var' : master.dimVar},

{'opt': ['day', 'week', 'month'], 'var':master.timeVar}]

# option menu to choose the plot method

col_opt_0 = col_button_0 + len(buttonList[0])

count = 0

for item in optbuttonList:

opt = OptionMenu(master, item['var'], *item['opt'])

opt.grid(row = row_button_0, column = col_opt_0 + count, rowspan = h_span_button, columnspan = w_span_button, sticky = "ew")

count += 1

optbuttonList = [{'opt': ['heat', 'cool', 'recover', 'space heat',

'electricity'], 'var':master.typeVar},

{'opt': ['exact', 'average', 'peak', 'total'],

'var':master.statVar}]

count = 0

for item in optbuttonList:

opt = OptionMenu(master, item['var'], *item['opt'])

opt.grid(row = row_button_0 + 1, column = col_opt_0 + count*2, rowspan = h_span_button, columnspan = w_span_button * 2, sticky = "ew")

count += 1

mainloop()