import time

import pyds9 as ds9

import os

import glob

from collections import deque

import astropy.io.fits as fits

from watchdog.observers import Observer

from watchdog.events import PatternMatchingEventHandler

import subprocess as sub

from astropy.coordinates import SkyCoord

from astropy import units as u

from astropy.wcs import WCS

from astropy.time import Time

import warnings

import threading

import numpy as np

import scipy.optimize as optimize

import math

from photutils import CircularAnnulus, CircularAperture

from photutils import aperture_photometry

import matplotlib.pyplot as plt

import matplotlib

import sys

# import pygame

from photutils import DAOStarFinder

from astropy.stats import sigma_clipped_stats

import matplotlib.image as mpimg

from pymodbus.client.sync import ModbusTcpClient as ModbusClient

from pymodbus.constants import Endian

from pymodbus.payload import BinaryPayloadBuilder

from pymodbus.payload import BinaryPayloadDecoder

from collections import OrderedDict

import struct

from datetime import datetime as dt

warnings.filterwarnings('ignore')

watchdog_img = mpimg.imread('/opt/ObsAssistant/watchdog.dif')

matplotlib.use('QT4Agg')

# photometry, backgrund estimation, snr etc.

radius = 30 # radius from object center (fits coordinates) for backgroun est.

sigma = 2.0 # The number of standard deviations to use as the clipping limit.

fwhm_daofind = 2.0 # estimate FWHM for daofind

fwhm_multiplier = 2 # fwhm * fwhm_multiplier = aperture

annulis_in = 2 # value add to aperture

annulis_out = 4 # value add to aperture

# solve-filed param

time_limit = 30 # time limit before giving up

scale_low = 1.11 # arcsec

scale_high = 1.13 # arcsec

solve_radius = 2 # deg

solve_depth = '40,80,100,160,250'

# head Key

ra_key = 'RA'

dec_key = 'DEC'

filter_key = 'FILTER'

object_key = 'OBJECT'

exp_key = 'EXPTIME'

date_key = 'DATE-OBS'

time_key = 'TIME-OBS'

# watchdog param

file_to_watch = ["*.fits"]

sleep_time = 1.0

max_sleep = 300

sleep_dur = 0

# plot parameters

max_plot_len = 50

x_plot = 10

y_plot = 8

imageSize = 1000

# clear

files_to_rm = ['*.axy', '*.corr', '*.xyls', '*.match',

'*.new', '*.rdls', '*.solved', '*.wcs']

# MODBUS

modbus_ip = '192.168.2.16'

modbus_port = 502

modbus_UNIT = 0x1

c_registers = 2

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

flux_tab = deque(maxlen=max_plot_len)

snr_tab = deque(maxlen=max_plot_len)

fwhm_tab = deque(maxlen=max_plot_len)

pol_tab = deque(maxlen=max_plot_len)

pol_flux_tab = deque(maxlen=max_plot_len)

plt.ion()

avg_pol = 0

im_object_name = ''

im_counter = 0

plot_clear = False

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

class WatchObs(PatternMatchingEventHandler):

show_ds9(None, None, solve=False)

"""

def on_modified(self, event):

print("Got it!", event.src_path)

global sleep_dur

sleep_dur = 0

self.file_to_open = event.src_path

fits_coo = open_file(self.file_to_open)

if solve_field(fits_coo):

solve_coo, solve_file_hdr, solve_file_data = open_solve_file(

str(self.file_to_open).split(".")[0]+".new")

show_ds9(fits_coo, solve_coo)

"""

class Star:

return final_sum[0], aperture_area

def show_ds9(fits_coo, solve_coo, solve=True):

print("DS9 PROBLEM")

def solve_field(fits_coo):

return False

def open_file(file_to_open):

return fits_coo

def open_solve_file(file_to_open):

return solve_coo, hdr, data.astype(int)

def star_pix(solve_file_hdr, fits_coo):

return int(px), int(py)

def pol_calc(flux, solve_file_hdr):

return pol_tab, avg_pol

def filter_check(solve_file_hdr):

return False

def plot(flux_tab, snr_tab, fwhm_tab, pol_tab, avg_pol, hdr, clear, im_counter, bkg_median):

plt.pause(0.01)

def clear():

os.remove(j)

def connect_modbus(modbus_ip, modbus_port):

return None

def read_modbus():

pass

def write_modbus(solve_coo, solve_file_hdr):

return True

def calculate_ha(coo, hdr):

return ha_hdr_rad

if __name__ == "__main__":

args = sys.argv[1:]

if len(args) > 0:

path = args[0]

else:

print("error - write path to files")

modbus_client = connect_modbus(modbus_ip, modbus_port)

event_handler = WatchObs()

observer = Observer()

observer.schedule(event_handler, path=path, recursive=False)

observer.start()

#pygame.init()

try:

while True:

time.sleep(sleep_time)

sleep_dur += 1

#if sleep_dur >= max_sleep:

# pygame.mixer.music.load('/opt/ObsAssistant/Angry-dog.mp3')

# pygame.mixer.music.play()

# time.sleep(7)

#else:

# pygame.mixer.music.stop()

except KeyboardInterrupt:

clear()

observer.stop()

observer.join()