Exemple #1
0
        def __init__(self):
            try:
                project_infos = get_project_settings()
                self.eof = EphemObserverFactory()
                try:
                    self.obs = self.eof.create_observer(
                        longitude=project_infos[0][1],
                        latitude=project_infos[0][0],
                        elevation=project_infos[1][0])

                    now_datetime = datetime.utcnow()
                    self.obs.date = ephem.date(now_datetime)

                    sun = ephem.Sun(self.obs)

                    moon = ephem.Moon(self.obs)
                    frac = moon.moon_phase

                    sun_alt = ephem.degrees(sun.alt)
                    moon_alt = ephem.degrees(moon.alt)

                    self.sun_elevation = "{:.2f}".format(
                        float(math.degrees(sun_alt)))
                    self.moon_elevation = "{:.2f}".format(
                        float(math.degrees(moon_alt)))
                    self.moon_phase = "{0:.2f}".format(frac * 100)
                except Exception as e:
                    print("ephem update -> {}".format(e))
            except Exception as e:
                print("run append_camera_settings() -> {}".format(e))
Exemple #2
0
    def __init__(self):

        super(EphemerisShooter, self).__init__()

        self.ObserverFactory = EphemObserverFactory()
        # self.continuousShooterThread = ContinuousShooterThread(int(info_cam[4]))
        self.continuousShooterThread = ContinuousShooterThread(0)
        self.console = ConsoleThreadOutput()
        self.config = ConfigProject()

        info = self.config.get_geographic_settings()
        info_sun = self.config.get_moonsun_settings()

        self.latitude = info[0]  # '-45.51'
        self.longitude = info[1]  # '-23.12'
        self.elevation = info[2]  # 350

        self.max_solar_elevation = info_sun[0]  # -12
        self.ignore_lunar_position = info_sun[1]
        self.max_lunar_elevation = info_sun[2]  # 8
        self.max_lunar_phase = info_sun[3]  # 1
        self.wait_temperature = False

        self.shootOn = False
        self.controller = True
        self.count = 1
Exemple #3
0
    def __init__(self):
        super(QThreadSunMoon, self).__init__()
        self.eof = EphemObserverFactory()
        self.latitude = None
        self.longitude = None
        self.elevation = None
        self.config = None

        self.obs = None
Exemple #4
0
    def __init__(self):
        super(SThread, self).__init__()
        self.prefix = None
        self.exposure_time = None
        self.binning = None

        self.get_level1 = None
        self.get_level2 = None
        self.get_axis_xi = None
        self.get_axis_xf = None
        self.get_axis_yi = None
        self.get_axis_yf = None
        self.get_ignore_crop = None

        self.console = ConsoleThreadOutput()

        self.get_image_tif = None
        self.get_image_fit = None
        self.get_image_png = None

        self.temperatura = None

        self.eof = EphemObserverFactory()
        self.obs = None

        self.path = None
        self.tempo = None

        self.info_matrix = None
        self.img = None

        self.new_image_name = None

        self.selected_filter = None
        self.dark_or_open = "Closed"
        self.one_photo = None

        self.for_headers_dic = {}

        self.lock = Locker()
        self.info_matrix = []

        self.filter_split_label = None

        self.count_aux = 0
        self.kwargs = None

        self.message_console_one_photo = None

        self.roda_filtros = FilterControl()
Exemple #5
0
    def __init__(self):
        super(EphemerisShooter, self).__init__()
        self.camconfig = SettingsCamera()
        self.camconfig.setup_settings()
        infocam = self.camconfig.get_camera_settings()

        self.ObserverFactory = EphemObserverFactory()
        self.continuousShooterThread = ContinuousShooterThread(int(infocam[4]))
        self.console = ConsoleThreadOutput()
        self.config = ConfigProject()

        info = self.config.get_geographic_settings()
        infosun = self.config.get_moonsun_settings()

        self.latitude = info[0]  # '-45.51'
        self.longitude = info[1]  # '-23.12'
        self.elevation = info[2]  # 350

        self.max_solar_elevation = infosun[0]  # -12
        self.ignore_lunar_position = infosun[1]
        self.max_lunar_elevation = infosun[2]  # 8
        self.max_lunar_phase = infosun[3]  # 1
        self.t = False

        print(int(infocam[4]))
        try:
            self.s = int(infocam[4])
            self.continuousShooterThread.set_sleep_time(self.s)
        except Exception as e:
            self.s = 5

        self.shootOn = False
        self.controller = True
        self.count = 1
Exemple #6
0
class QThreadSunMoon(QtCore.QThread):
    signal_update_sun_moon = QtCore.pyqtSignal([list],
                                               name="signalUpdateSunMoon")

    def __init__(self):
        super(QThreadSunMoon, self).__init__()
        self.eof = EphemObserverFactory()
        self.latitude = None
        self.longitude = None
        self.elevation = None
        self.config = None

        self.obs = None

    def get_info(self):
        # Criando uma instância do ConfigProject
        self.config = ConfigProject()

        # Recebendo as informações
        info = self.config.get_geographic_settings()

        # Atribuindo valor as variáveis de geolocalização
        self.latitude = info[0]  # '-45.51'
        self.longitude = info[1]  # '-23.12'
        self.elevation = info[2]  # 350

    def set_observer(self, longitude, latitude, elevation):
        """ Essa função cria um Observatório do PyEphem para utilizar nos cálculos """
        self.obs = self.eof.create_observer(longitude=longitude,
                                            latitude=latitude,
                                            elevation=elevation)

    def run(self):
        # Pegando as informações
        self.get_info()

        # Criando um Observatório
        self.set_observer(self.longitude, self.latitude, self.elevation)

        while True:
            now_datetime = datetime.utcnow()
            self.obs.date = ephem.date(now_datetime)

            sun = ephem.Sun(self.obs)

            moon = ephem.Moon(self.obs)
            frac = moon.moon_phase

            sun_alt = ephem.degrees(sun.alt)
            moon_alt = ephem.degrees(moon.alt)

            sun_elevation = "{:.2f}º".format(float(math.degrees(sun_alt)))
            moon_elevation = "{:.2f}º".format(float(math.degrees(moon_alt)))
            moon_phase = "{0:.2f}%".format(frac * 100)

            self.signal_update_sun_moon.emit(
                [sun_elevation, moon_elevation, moon_phase])
            time.sleep(1)
Exemple #7
0
    def __init__(self):
        super(QThreadSunMoon, self).__init__()
        self.eof = EphemObserverFactory()
        self.latitude = None
        self.longitude = None
        self.elevation = None
        self.config = None

        self.obs = None
Exemple #8
0
class QThreadSunMoon(QtCore.QThread):
    signal_update_sun_moon = QtCore.pyqtSignal([list], name="signalUpdateSunMoon")

    def __init__(self):
        super(QThreadSunMoon, self).__init__()
        self.eof = EphemObserverFactory()
        self.latitude = None
        self.longitude = None
        self.elevation = None
        self.config = None

        self.obs = None

    def get_info(self):
        # Criando uma instância do ConfigProject
        self.config = ConfigProject()

        # Recebendo as informações
        info = self.config.get_geographic_settings()

        # Atribuindo valor as variáveis de geolocalização
        self.latitude = info[0]  # '-45.51'
        self.longitude = info[1]  # '-23.12'
        self.elevation = info[2]  # 350

    def set_observer(self, longitude, latitude, elevation):
        """ Essa função cria um Observatório do PyEphem para utilizar nos cálculos """
        self.obs = self.eof.create_observer(longitude=longitude,
                                            latitude=latitude,
                                            elevation=elevation)

    def run(self):
        # Pegando as informações
        self.get_info()

        # Criando um Observatório
        self.set_observer(self.longitude, self.latitude, self.elevation)

        while True:
            now_datetime = datetime.utcnow()
            self.obs.date = ephem.date(now_datetime)

            sun = ephem.Sun(self.obs)

            moon = ephem.Moon(self.obs)
            frac = moon.moon_phase

            sun_alt = ephem.degrees(sun.alt)
            moon_alt = ephem.degrees(moon.alt)

            sun_elevation = "{:.2f}º".format(float(math.degrees(sun_alt)))
            moon_elevation = "{:.2f}º".format(float(math.degrees(moon_alt)))
            moon_phase = "{0:.2f}%".format(frac * 100)

            self.signal_update_sun_moon.emit([sun_elevation, moon_elevation, moon_phase])
            time.sleep(1)
Exemple #9
0
    def __init__(self):

        super(EphemerisShooter, self).__init__()
        self.camconfig = SettingsCamera()
        self.camconfig.setup_settings()
        infocam = self.camconfig.get_camera_settings()

        self.ObserverFactory = EphemObserverFactory()
        self.continuousShooterThread = ContinuousShooterThread(int(infocam[4]))
        self.console = ConsoleThreadOutput()
        self.config = ConfigProject()

        info = self.config.get_geographic_settings()

        self.latitude = info[0]  # '-45.51'
        self.longitude = info[1]  # '-23.12'
        self.elevation = info[2]  # 350

        info_sun = self.config.get_moonsun_settings()
        self.max_solar_elevation = float(info_sun[0])  # -12
        self.ignore_lunar_position = info_sun[1]
        self.max_lunar_elevation = float(info_sun[2])  # 8
        self.max_lunar_phase = float(info_sun[3])  # 1

        self.wait_temperature = False

        print(int(infocam[4]))
        try:
            self.s = int(infocam[4])
            self.continuousShooterThread.set_sleep_time(self.s)
        except Exception as e:
            self.s = 5

        self.shootOn = False
        self.controller = True
        self.count = 1
Exemple #10
0
class EphemerisShooter(QtCore.QThread):
    signal_started_shooting = QtCore.pyqtSignal(name="signalStartedShooting")
    signal_temp = QtCore.pyqtSignal(name="signalTemp")

    def __init__(self):
        super(EphemerisShooter, self).__init__()
        self.camconfig = SettingsCamera()
        self.camconfig.setup_settings()
        infocam = self.camconfig.get_camera_settings()

        self.ObserverFactory = EphemObserverFactory()
        self.continuousShooterThread = ContinuousShooterThread(int(infocam[4]))
        self.console = ConsoleThreadOutput()
        self.config = ConfigProject()

        info = self.config.get_geographic_settings()
        infosun = self.config.get_moonsun_settings()

        self.latitude = info[0]  # '-45.51'
        self.longitude = info[1]  # '-23.12'
        self.elevation = info[2]  # 350

        self.max_solar_elevation = infosun[0]  # -12
        self.ignore_lunar_position = infosun[1]
        self.max_lunar_elevation = infosun[2]  # 8
        self.max_lunar_phase = infosun[3]  # 1
        self.t = False

        print(int(infocam[4]))
        try:
            self.s = int(infocam[4])
            self.continuousShooterThread.set_sleep_time(self.s)
        except Exception as e:
            self.s = 5

        self.shootOn = False
        self.controller = True
        self.count = 1

    def refresh_data(self):
        try:
            info = self.config.get_geographic_settings()
            self.latitude = info[0]  # '-45.51'
            self.longitude = info[1]  # '-23.12'
            self.elevation = info[2]  # 350

            infosun = self.config.get_moonsun_settings()
            self.max_solar_elevation = float(infosun[0])  # -12
            self.ignore_lunar_position = infosun[1]
            self.max_lunar_elevation = float(infosun[2])  # 8
            self.max_lunar_phase = float(infosun[3])  # 1

        except Exception as e:
            self.console.raise_text("Exception thrown to acquire information\n"
                                    "Please set an observatory information on settings\n" + str(e), level=3)
            self.latitude = 0
            self.longitude = 0
            self.elevation = 0
            self.max_solar_elevation = 0
            self.max_lunar_elevation = 0
            self.max_lunar_phase = 0

        infocam = self.camconfig.get_camera_settings()

        try:
            self.s = int(infocam[4])
        except Exception as e:
            self.s = 0

    def calculate_moon(self, obs):
        aux = obs
        aux.compute_pressure()
        aux.horizon = '8'
        moon = ephem.Moon(aux)
        return aux.previous_setting(moon), aux.next_rising(moon)

    def calculate_sun(self, obs):
        aux = obs
        aux.compute_pressure()
        aux.horizon = '-12'
        sun = ephem.Sun(aux)
        return aux.previous_setting(sun), aux.next_rising(sun)

    def set_solar_and_lunar_parameters(self, maxSolarElevation, maxLunarElevation, maxLunarPhase):
        self.max_solar_elevation = maxSolarElevation
        self.max_lunar_elevation = maxLunarElevation
        self.max_lunar_phase = maxLunarPhase

    def run(self):
        self.refresh_data()

        obs = self.ObserverFactory.create_observer(longitude=self.longitude,
                                                   latitude=self.latitude,
                                                   elevation=self.elevation)

        self.controller = True
        self.shootOn = False
        c = 0
        try:
            while self.controller:
                obs.date = ephem.date(datetime.datetime.utcnow())

                sun = ephem.Sun(obs)
                moon = ephem.Moon(obs)

                frac = moon.moon_phase

                a = ephem.degrees(sun.alt)
                b = ephem.degrees(str(moon.alt))

                # Variavel de controle do shooter
                t = 1

                if float(math.degrees(a)) < self.max_solar_elevation or t == 1:
                    if (self.ignore_lunar_position == False and float(math.degrees(b)) < self.max_lunar_elevation
                            and frac < self.max_lunar_phase) or self.ignore_lunar_position:


                        if not self.shootOn:
                            if not c:
                                self.signal_started_shooting.emit()
                                c = 1
                            self.signal_temp.emit()
                            time.sleep(5)

                            if self.t:
                                # Iniciar as Observações
                                self.start_taking_photo()
                                self.shootOn = True

                else:
                    if self.shootOn:
                        # Finalizar as Observações
                        self.stop_taking_photo()
                        c = 0
                        self.shootOn = False

                time.sleep(5)
        except Exception as e:
            self.console.raise_text("Exception no Ephemeris Shooter -> " + str(e))

    def stop_shooter(self):
        self.controller = False
        self.continuousShooterThread.stop_continuous_shooter()

    def start_taking_photo(self):
        self.continuousShooterThread.set_sleep_time(self.s)
        self.continuousShooterThread.start_continuous_shooter()
        self.continuousShooterThread.start()

    def stop_taking_photo(self):
        self.continuousShooterThread.stop_continuous_shooter()
Exemple #11
0
class EphemerisShooter(QtCore.QThread):
    '''
        classe para modo automatico
    '''

    signal_started_shooting = QtCore.pyqtSignal(name="signalStartedShooting")
    signal_temp = QtCore.pyqtSignal(name="signalTemp")

    def __init__(self):

        super(EphemerisShooter, self).__init__()

        self.ObserverFactory = EphemObserverFactory()
        # self.continuousShooterThread = ContinuousShooterThread(int(info_cam[4]))
        self.continuousShooterThread = ContinuousShooterThread(0)
        self.console = ConsoleThreadOutput()
        self.config = ConfigProject()

        info = self.config.get_geographic_settings()
        info_sun = self.config.get_moonsun_settings()

        self.latitude = info[0]  # '-45.51'
        self.longitude = info[1]  # '-23.12'
        self.elevation = info[2]  # 350

        self.max_solar_elevation = info_sun[0]  # -12
        self.ignore_lunar_position = info_sun[1]
        self.max_lunar_elevation = info_sun[2]  # 8
        self.max_lunar_phase = info_sun[3]  # 1
        self.wait_temperature = False

        self.shootOn = False
        self.controller = True
        self.count = 1

    def refresh_data(self):
        try:
            info = self.config.get_geographic_settings()
            self.latitude = info[0]  # '-45.51'
            self.longitude = info[1]  # '-23.12'
            self.elevation = info[2]  # 350

            info_sun = self.config.get_moonsun_settings()
            self.max_solar_elevation = float(info_sun[0])  # -12
            self.ignore_lunar_position = info_sun[1]
            self.max_lunar_elevation = float(info_sun[2])  # 8
            self.max_lunar_phase = float(info_sun[3])  # 1

        except Exception as e:
            self.console.raise_text(
                "Exception thrown to acquire information\n"
                "Please set an observatory information on settings\n" + str(e),
                level=3)
            self.latitude = 0
            self.longitude = 0
            self.elevation = 0
            self.max_solar_elevation = 0
            self.max_lunar_elevation = 0
            self.max_lunar_phase = 0

    def calculate_moon(self, obs):
        aux = obs
        aux.compute_pressure()
        aux.horizon = '8'
        moon = ephem.Moon(aux)
        return aux.previous_setting(moon), aux.next_rising(moon)

    def calculate_sun(self, obs):
        aux = obs
        aux.compute_pressure()
        aux.horizon = '-12'
        sun = ephem.Sun(aux)
        return aux.previous_setting(sun), aux.next_rising(sun)

    def set_solar_and_lunar_parameters(self, maxSolarElevation,
                                       maxLunarElevation, maxLunarPhase):
        self.max_solar_elevation = maxSolarElevation
        self.max_lunar_elevation = maxLunarElevation
        self.max_lunar_phase = maxLunarPhase

    def run(self):
        self.refresh_data()

        obs = self.ObserverFactory.create_observer(longitude=self.longitude,
                                                   latitude=self.latitude,
                                                   elevation=self.elevation)

        self.controller = True
        self.shootOn = False
        c = 0
        try:
            while self.controller:
                obs.date = ephem.date(datetime.datetime.utcnow())

                sun = ephem.Sun(obs)
                moon = ephem.Moon(obs)

                frac = moon.moon_phase

                a = ephem.degrees(sun.alt)
                b = ephem.degrees(str(moon.alt))

                # Variavel de controle do shooter
                t = 0

                if float(math.degrees(a)) < self.max_solar_elevation or t == 1:
                    if (not self.ignore_lunar_position and
                            float(math.degrees(b)) < self.max_lunar_elevation
                            and frac < self.max_lunar_phase
                        ) or self.ignore_lunar_position:

                        if not self.shootOn:
                            if not c:
                                self.signal_started_shooting.emit()
                                c = 1

                            self.signal_temp.emit()
                            time.sleep(5)
                            if self.wait_temperature:
                                # Iniciar as Observações
                                self.start_taking_photo()
                                self.shootOn = True

                else:
                    if self.shootOn:
                        # Finalizar as Observações
                        self.stop_taking_photo()
                        c = 0
                        self.t = False
                        self.shootOn = False

                time.sleep(5)
        except Exception as e:
            self.console.raise_text("Exception no Ephemeris Shooter -> " +
                                    str(e))

    def stop_shooter(self):
        self.controller = False
        self.continuousShooterThread.stop_continuous_shooter()

    def start_taking_photo(self):
        self.continuousShooterThread.start_continuous_shooter()
        self.continuousShooterThread.start()

    def stop_taking_photo(self):
        self.continuousShooterThread.stop_continuous_shooter()
Exemple #12
0
class EphemerisShooter(QtCore.QThread):
    '''
        classe para modo automatico
    '''

    signal_started_shooting = QtCore.pyqtSignal(name="signalStartedShooting")
    signal_temp = QtCore.pyqtSignal(name="signalTemp")

    def __init__(self):

        super(EphemerisShooter, self).__init__()
        self.camconfig = SettingsCamera()
        self.camconfig.setup_settings()
        infocam = self.camconfig.get_camera_settings()

        self.ObserverFactory = EphemObserverFactory()
        self.continuousShooterThread = ContinuousShooterThread(int(infocam[4]))
        self.console = ConsoleThreadOutput()
        self.config = ConfigProject()

        info = self.config.get_geographic_settings()

        self.latitude = info[0]  # '-45.51'
        self.longitude = info[1]  # '-23.12'
        self.elevation = info[2]  # 350

        info_sun = self.config.get_moonsun_settings()
        self.max_solar_elevation = float(info_sun[0])  # -12
        self.ignore_lunar_position = info_sun[1]
        self.max_lunar_elevation = float(info_sun[2])  # 8
        self.max_lunar_phase = float(info_sun[3])  # 1

        self.wait_temperature = False

        print(int(infocam[4]))
        try:
            self.s = int(infocam[4])
            self.continuousShooterThread.set_sleep_time(self.s)
        except Exception as e:
            self.s = 5

        self.shootOn = False
        self.controller = True
        self.count = 1

    def refresh_data(self):
        try:
            info = self.config.get_geographic_settings()
            self.latitude = info[0]  # '-45.51'
            self.longitude = info[1]  # '-23.12'
            self.elevation = info[2]  # 350

            infosun = self.config.get_moonsun_settings()
            self.max_solar_elevation = float(infosun[0])  # -12
            self.ignore_lunar_position = infosun[1]
            self.max_lunar_elevation = float(infosun[2])  # 8
            self.max_lunar_phase = float(infosun[3])  # 1

        except Exception as e:
            self.console.raise_text("Exception thrown to acquire information\n"
                                    "Please set an observatory information on settings\n" + str(e), level=3)
            self.latitude = 0
            self.longitude = 0
            self.elevation = 0
            self.max_solar_elevation = 0
            self.max_lunar_elevation = 0
            self.max_lunar_phase = 0

        infocam = self.camconfig.get_camera_settings()

        try:
            self.s = int(infocam[4])
        except Exception as e:
            self.s = 0

    def calculate_moon(self, obs):
        aux = obs
        aux.compute_pressure()
        aux.horizon = '8'
        moon = ephem.Moon(aux)
        return aux.previous_setting(moon), aux.next_rising(moon)

    def calculate_sun(self, obs):
        aux = obs
        aux.compute_pressure()
        aux.horizon = '-12'
        sun = ephem.Sun(aux)
        return aux.previous_setting(sun), aux.next_rising(sun)

    def set_solar_and_lunar_parameters(self, maxSolarElevation, maxLunarElevation, maxLunarPhase):
        self.max_solar_elevation = maxSolarElevation
        self.max_lunar_elevation = maxLunarElevation
        self.max_lunar_phase = maxLunarPhase

    def run(self):
        self.refresh_data()

        obs = self.ObserverFactory.create_observer(longitude=self.longitude,
                                                   latitude=self.latitude,
                                                   elevation=self.elevation)

        self.controller = True
        self.shootOn = False
        c = 0
        flag = 0
        try:
            while self.controller:
                obs.date = ephem.date(datetime.datetime.utcnow())
                sun = ephem.Sun(obs)
                moon = ephem.Moon(obs)

                # frac = moon.moon_phase
                frac = float(moon.moon_phase) * 100.0

                a = ephem.degrees(sun.alt)
                b = ephem.degrees(str(moon.alt))

                # Variavel de controle do shooter
                t = 0

                # print("\n\n")
                # print("math.degrees(a) = " + str(math.degrees(a)))
                # print("self.max_solar_elevation = " + str(self.max_solar_elevation))
                # print("self.ignore_lunar_position = " + str(self.ignore_lunar_position))
                # print("math.degrees(b) = " + str(math.degrees(b)))
                # print("self.max_lunar_elevation = " + str(self.max_lunar_elevation))
                # print("self.max_lunar_phase = " + str(self.max_lunar_phase))
                # print("\n\n")
                '''
                obs.date = ephem.date(now_datetime)
                sun = ephem.Sun()
                sun.compute(obs)

                moon = ephem.Moon()
                moon.compute(obs)
                frac = float(moon.moon_phase) * 100.0

                ag_s = float(repr(sun.alt))
                s_ag = math.degrees(ag_s)
                ag_m = float(repr(moon.alt))
                m_ag = math.degrees(ag_m)
                '''
                # flag = 0
                ephem_out = False

                # **************************************** Ephem Loop ****************************************

                if self.ignore_lunar_position:
                    if (float(math.degrees(a)) <= self.max_solar_elevation) and (flag == 0):

                        if not self.shootOn:
                            if not c:
                                self.signal_started_shooting.emit()
                                c = 1
                                # flag = 1
                            self.signal_temp.emit()
                            time.sleep(5)
                            if self.wait_temperature:
                                # Iniciar as Observações
                                self.start_taking_photo()
                                self.shootOn = True
                                self.log_ephem_infos()
                                flag = 1

                    if (float(math.degrees(a)) > self.max_solar_elevation) and (flag == 1):

                        if self.shootOn:
                            # Finalizar as Observações
                            self.stop_taking_photo()
                            c = 0
                            flag = 0
                            self.t = False
                            self.shootOn = False
                else:
                    if frac < self.max_lunar_phase:
                        if (float(math.degrees(a)) <= self.max_solar_elevation) and (float(math.degrees(b)) <= self.max_lunar_elevation) and (flag == 0):
                            if not self.shootOn:
                                if not c:
                                    self.signal_started_shooting.emit()
                                    c = 1
                                    # flag = 1
                                self.signal_temp.emit()
                                time.sleep(5)
                                if self.wait_temperature:
                                    # Iniciar as Observações
                                    self.start_taking_photo()
                                    self.shootOn = True
                                    self.log_ephem_infos()
                                    flag = 1

                        if (float(math.degrees(a)) > self.max_solar_elevation or float(math.degrees(b)) > self.max_lunar_elevation) and (flag == 1):

                            if self.shootOn:
                                # Finalizar as Observações
                                self.stop_taking_photo()
                                c = 0
                                flag = 0
                                self.t = False
                                self.shootOn = False
                    else:
                        if (float(math.degrees(a)) <= self.max_solar_elevation) and (float(math.degrees(b)) <= float(5.0)) and (flag == 0):
                            if not self.shootOn:
                                if not c:
                                    self.signal_started_shooting.emit()
                                    c = 1
                                    # flag = 1
                                self.signal_temp.emit()
                                time.sleep(5)
                                if self.wait_temperature:
                                    # Iniciar as Observações
                                    self.start_taking_photo()
                                    self.shootOn = True
                                    self.log_ephem_infos()
                                    flag = 1

                        if (float(math.degrees(a)) > self.max_solar_elevation or float(math.degrees(b)) > float(5.0)) and (flag == 1):
                            if self.shootOn:
                                # Finalizar as Observações
                                self.stop_taking_photo()
                                c = 0
                                flag = 0
                                self.t = False
                                self.shootOn = False

                # **************************************** Ephem Loop ****************************************

                '''
                if float(math.degrees(a)) < self.max_solar_elevation or t == 1:
                    if (not self.ignore_lunar_position and float(math.degrees(b)) < self.max_lunar_elevation
                            and frac < self.max_lunar_phase) or self.ignore_lunar_position:

                        if not self.shootOn:
                            if not c:
                                self.signal_started_shooting.emit()
                                c = 1

                            self.signal_temp.emit()
                            time.sleep(5)
                            if self.wait_temperature:
                                # Iniciar as Observações
                                self.start_taking_photo()
                                self.shootOn = True

                else:
                    if self.shootOn:
                        # Finalizar as Observações
                        self.stop_taking_photo()
                        c = 0
                        self.t = False
                        self.shootOn = False

                time.sleep(5)
                '''
        except Exception as e:
            self.console.raise_text("Exception no Ephemeris Shooter -> " + str(e))

    def stop_shooter(self):
        self.controller = False
        if self.continuousShooterThread.isRunning():
            self.continuousShooterThread.stop_continuous_shooter()
        """
        if not self.continuousShooterThread.wait_temperature:
                self.continuousShooterThread.stop_continuous_shooter()
        """

    def start_taking_photo(self):
        self.continuousShooterThread.set_sleep_time(self.s)
        self.continuousShooterThread.start_continuous_shooter()
        self.continuousShooterThread.start()

    def stop_taking_photo(self):
        self.continuousShooterThread.stop_continuous_shooter()

    def log_ephem_infos(self):
        info_start_end = result()
        start_time = str(info_start_end[0])
        start_field = start_time[:-10] + " UTC"
        end_time = str(info_start_end[1])
        end_field = end_time[:-10] + " UTC"
        '''
        time_obs_time = str(info_start_end[2]).split(":")
        time_obs_time = [z.split(".")[0] for z in time_obs_time]
        time_obs_field = time_obs_time[0] + ":" + time_obs_time[1] + " Hours"
        '''
        # self.console.raise_text("Start Time: " + start_field + "; End Time: " + end_field, 2)
        self.console.save_log("Start Time: " + start_field + "; End Time: " + end_field)
Exemple #13
0
class SThread(QtCore.QThread):
    """
    Threads são fluxos de programas que executam em paralelo dentro de uma aplicação, isto é,\
    uma ramificação de uma parte da aplicação que é executada de forma independente e\
    escalonada independentemente do fluxo inicial da aplicação.
    Fonte: http://imasters.com.br/artigo/20127/py/threads-em-python/?trace=1519021197&source=single
    """
    def __init__(self):
        super(SThread, self).__init__()
        self.prefix = None
        self.exposure_time = None
        self.binning = None

        self.get_level1 = None
        self.get_level2 = None
        self.get_axis_xi = None
        self.get_axis_xf = None
        self.get_axis_yi = None
        self.get_axis_yf = None
        self.get_ignore_crop = None

        self.console = ConsoleThreadOutput()

        self.get_image_tif = None
        self.get_image_fit = None
        self.get_image_png = None

        self.temperatura = None

        self.eof = EphemObserverFactory()
        self.obs = None

        self.path = None
        self.tempo = None

        self.info_matrix = None
        self.img = None

        self.new_image_name = None

        self.selected_filter = None
        self.dark_or_open = "Closed"
        self.one_photo = None

        self.for_headers_dic = {}

        self.lock = Locker()
        self.info_matrix = []

        self.filter_split_label = None

        self.count_aux = 0
        self.kwargs = None

        self.message_console_one_photo = None

        self.roda_filtros = FilterControl()

    def set_config_take_image(self):
        """
        seta as configuracoes para se tirar uma foto
        """
        try:
            info_cam = get_camera_settings()
            self.for_headers_dic['Set Temperature'] = info_cam[0]
            self.for_headers_dic['????Tempo de espera'] = info_cam[1]

            info_image = get_image_settings()

            try:
                self.get_level1 = float(info_image[0])
            except Exception as e:
                # print("self.get_level1 = 0.1 -> {}".format(e))
                self.get_level1 = 0.1

            try:
                self.get_level2 = float(info_image[1])
            except Exception as e:
                # print("self.get_level2 = 0.99 -> {}".format(e))
                self.get_level2 = 0.99

            try:
                self.get_axis_xi = float(info_image[2])
            except Exception as e:
                # print("self.get_axis_xi = 0 -> {}".format(e))
                self.get_axis_xi = 0

            try:
                self.get_axis_xf = float(info_image[3])
            except Exception as e:
                # print("self.get_axis_xf = 0 -> {}".format(e))
                self.get_axis_xf = 0

            try:
                self.get_axis_yi = float(info_image[4])
            except Exception as e:
                # print("self.get_axis_yi = 0 -> {}".format(e))
                self.get_axis_yi = 0

            try:
                self.get_axis_yf = float(info_image[5])
            except Exception as e:
                # print("self.get_axis_yf = 0 -> {}".format(e))
                self.get_axis_yf = 0

            try:
                self.get_ignore_crop = info_image[6]
            except Exception as e:
                print("self.get_ignore_crop = True -> {}".format(e))
                self.get_ignore_crop = True

            try:
                self.get_image_png = info_image[7]
            except Exception as e:
                print("self.get_image_png  = True -> {}".format(e))
                self.get_image_png = True

            try:
                self.get_image_tif = info_image[8]
            except Exception as e:
                print("self.get_image_tif = True -> {}".format(e))
                self.get_image_tif = True

            try:
                self.get_image_fit = info_image[9]
            except Exception as e:
                print("self.get_image_fit = True -> {}".format(e))
                self.get_image_fit = True

            try:
                self.filter_split_label = get_filter_settings()
            except Exception as e:
                print("get_filter_settings() -> {}".format(e))

            try:
                self.append_camera_settings()
            except Exception as e:
                print(
                    "self.append_camera_settings() in set_config_take_image -> {}"
                    .format(e))

        except Exception as e:
            print("Try ini definitive -> {}".format(e))

    def recebe_argumento(self, kwargs):
        self.kwargs = kwargs

    def args_one_photo(self, filter_args, kwargs):
        self.selected_filter = filter_args
        if kwargs == "Closed":
            self.kwargs = 1
        else:
            self.kwargs = 0
        self.one_photo = True

    def run(self):
        if self.kwargs == 0:
            try:
                self.create_image_open()
            except Exception as e:
                print("self.create_image_open() -> {}".format(e))
        else:
            try:
                self.create_image_close()
            except Exception as e:
                print("self.create_image_close() -> {}".format(e))

    def create_image_open(self):
        self.roda_filtros.open_shutter()
        self.set_config_take_image()
        self.lock.set_acquire()

        my_list = get_wish_filters_settings()  # list of schedule

        try:
            if self.count_aux < len(my_list):
                if self.one_photo:
                    index_of_dic = self.selected_filter
                else:
                    index_of_dic = str(my_list[self.count_aux])
                self.valores_principais_wish_filter(index_of_dic)
                self.count_aux += 1

            else:
                self.count_aux = 0
                if self.one_photo:
                    index_of_dic = self.selected_filter
                else:
                    index_of_dic = str(my_list[self.count_aux])
                self.valores_principais_wish_filter(index_of_dic)
                self.count_aux += 1

        except Exception as e:
            print("Try filter ini -> {}".format(e))

        project_infos = get_project_settings()

        name_observatory = project_infos[2][1]

        self.path, self.tempo = set_path()

        self.new_image_name = str(
            self.prefix) + "_" + str(name_observatory) + "_" + str(self.tempo)

        new_image_name = self.path + str(self.new_image_name)

        try:
            self.info_matrix = SbigDriver.photoshoot(self.exposure_time,
                                                     self.binning, 0)
        except Exception as e:
            print("self.info_matrix = SbigDriver.photoshoot ERROR -> " +
                  str(e))

        self.for_headers_dic['Open or close shutter'] = "OPEN"

        self.save_image_format(new_image_name)

        self.for_headers_dic = {}
        self.one_photo = False
        self.init_image()
        self.lock.set_release()

    def create_image_close(self):
        self.roda_filtros.close_shutter()

        my_list = get_wish_filters_settings()  # list of schedule
        my_list = set(my_list)
        my_list = sorted(my_list)
        count_aux = 0

        while count_aux < len(my_list):
            self.set_config_take_image()
            self.lock.set_acquire()

            if self.one_photo:
                index_of_dic = self.selected_filter
                count_aux = 100
            else:
                index_of_dic = str(my_list[count_aux])

            self.valores_principais_wish_filter(index_of_dic)

            project_infos = get_project_settings()

            name_observatory = project_infos[2][1]

            self.path, self.tempo = set_path()

            self.new_image_name = "DARK-" + str(
                self.prefix) + "_" + str(name_observatory) + "_" + str(
                    self.tempo)

            new_image_name = self.path + str(self.new_image_name)

            try:
                self.info_matrix = SbigDriver.photoshoot(
                    self.exposure_time, self.binning, 1)
            except Exception as e:
                print("self.info_matrix = SbigDriver.photoshoot ERROR -> " +
                      str(e))

            self.for_headers_dic['Open or close shutter'] = "CLOSED"

            self.save_image_format(new_image_name)

            self.for_headers_dic = {}
            count_aux += 1
            self.init_image()
            self.lock.set_release()

            self.one_photo = False

    def filter_wheel_control(self, wish_filter_int):
        try:
            sleep(1)
            wish_filter_int = int(wish_filter_int)
            self.roda_filtros.filter_wheel_control(wish_filter_int)
            sleep(1)
        except Exception as e:
            self.roda_filtros.home_reset()
            print(e)

    def save_image_format(self, new_image_name):
        if not os.path.isdir(self.path):
            os.makedirs(self.path)

        if self.one_photo:
            print(self.path)

        self.for_headers_dic['Start Time'] = self.tempo

        try:
            self.temperatura = SbigDriver.get_temperature()
            self.temperatura = "{0:.2f}".format(float(self.temperatura[3]))
            # self.temperatura = "25"
            self.for_headers_dic['Temperature'] = self.temperatura
        except Exception as e:
            print("Exception self.temperatura -> {}".format(e))
            self.for_headers_dic['Temperature'] = "???"

        if self.get_image_png:
            try:
                save_png(self.info_matrix, new_image_name,
                         self.for_headers_dic)
            except Exception as e:
                print("Exception save_png() -> {}".format(e))
        if self.get_image_tif:
            try:
                save_tif(self.info_matrix, new_image_name)
                if self.one_photo:
                    print(new_image_name)
            except Exception as e:
                print("Exception save_tif() -> {}".format(e))
        if self.get_image_fit:
            try:
                save_fit(self.info_matrix, new_image_name,
                         self.for_headers_dic)
            except Exception as e:
                print("Exception save_fit() -> {}".format(e))
        if not self.get_image_fit and not self.get_image_tif and not self.get_image_fit:
            try:
                save_png(self.info_matrix, new_image_name,
                         self.for_headers_dic)
            except Exception as e:
                print("Exception save_png() -> {}".format(e))

    def valores_principais_wish_filter(self, index_of_dic):
        aux = self.filter_split_label[str(index_of_dic)][0]

        aux = list(aux)
        '''
        aux[0] = self.prefix
        aux[2] = self.exposure_time
        aux[3] = self.binning
        aux[4] = wish filter
        '''

        self.prefix = str(aux[0])

        self.exposure_time = float(aux[2])
        if self.exposure_time <= 0.12:
            self.exposure_time = 0.12 * 100
        elif self.exposure_time >= 3600:
            self.exposure_time = 3600 * 100
        else:
            self.exposure_time = float(aux[2]) * 100
        self.exposure_time = int(self.exposure_time)

        self.binning = int(aux[3])

        self.filter_wheel_control(int(aux[4]))

        self.append_filters_settings(aux)

    def append_camera_settings(self):
        try:
            project_infos = get_project_settings()

            try:
                self.obs = self.eof.create_observer(
                    longitude=project_infos[0][1],
                    latitude=project_infos[0][0],
                    elevation=project_infos[1][0])

                now_datetime = datetime.utcnow()
                self.obs.date = ephem.date(now_datetime)

                sun = ephem.Sun(self.obs)

                moon = ephem.Moon(self.obs)
                frac = moon.moon_phase

                sun_alt = ephem.degrees(sun.alt)
                moon_alt = ephem.degrees(moon.alt)

                sun_elevation = "{:.2f}".format(float(math.degrees(sun_alt)))
                moon_elevation = "{:.2f}".format(float(math.degrees(moon_alt)))
                moon_phase = "{0:.2f}".format(frac * 100)
            except Exception as e:
                print("ephem update -> {}".format(e))

            self.for_headers_dic['Latitude'] = str(project_infos[0][0])
            self.for_headers_dic['Longitude'] = str(project_infos[0][1])
            self.for_headers_dic['Elevation(m)'] = str(project_infos[0][2])
            self.for_headers_dic['Pressure(mb)'] = str(project_infos[0][3])
            self.for_headers_dic['Sun Elevation'] = str(sun_elevation)
            self.for_headers_dic['Ignore Lunar Position'] = str(
                project_infos[1][1])
            self.for_headers_dic['Moon Elevation'] = str(moon_elevation)
            self.for_headers_dic['Moon Phase'] = str(moon_phase)
            self.for_headers_dic['Name'] = str(project_infos[2][0])
            self.for_headers_dic['Observatory'] = str(project_infos[2][1])
            self.for_headers_dic['Imager ID'] = str(project_infos[2][2])
            self.for_headers_dic['get_level1'] = str(self.get_level1)
            self.for_headers_dic['get_level2'] = str(self.get_level2)
            self.for_headers_dic['get_axis_xi'] = str(self.get_axis_xi)
            self.for_headers_dic['get_axis_xf'] = str(self.get_axis_xf)
            self.for_headers_dic['get_axis_yi'] = str(self.get_axis_yi)
            self.for_headers_dic['get_axis_yf'] = str(self.get_axis_yf)
            self.for_headers_dic['get_ignore_crop'] = str(self.get_ignore_crop)
        except Exception as e:
            print("run append_camera_settings() -> {}".format(e))

    def append_filters_settings(self, aux):
        try:
            self.for_headers_dic['Filter Label'] = str(aux[0])
            self.for_headers_dic['Filter Wavelength'] = str(aux[1])
            self.for_headers_dic['Exposure'] = str(self.exposure_time)
            self.for_headers_dic['Binning'] = str(aux[3])
            self.for_headers_dic['Filter Position'] = str(aux[4])
        except Exception as e:
            print("run append_filters_settings() -> {}".format(e))

    def get_new_image_name(self, local_name_image):
        self.console.raise_text(
            "Image saved in " + str(local_name_image) + ".png", 1)

    def init_image(self):
        try:
            print("\nAAAAAAAAAAAAAAAAAAAAAA\n")
            # for i in self.info_matrix:
            #     print(i)
            self.img = Image(self.path, self.new_image_name)
        except Exception as e:
            print("Image('', '') -> {}".format(e))
            self.img = Image('', '')
        return self.img

    def get_image_info(self):
        return self.img