Beispiel #1
0
def get_camera_settings():
    """
    Pega os valores no ini camera
    info_cam[0] = temperature_camera
    info_cam[1] = tempo de espera até atingir temperatura desejada
    info_cam[2] = dark(Open or close shutter)
    """
    settings = SettingsCamera()
    info_cam = settings.get_camera_settings()

    return info_cam
Beispiel #2
0
 def get_camera_settings(self):
     '''
     pega os valores no ini camera
     info[0] = temperature_camera
     info[1] = prefixo/filter name
     info[2] = tempo_exposicao
     info[3] = tempo_fotos(tempo entre fotos)
     info[4] = time_cooling(CCD cooling time)
     info[5] = Image contrast: bottom
     info[6] = Image contrast: top level
     info[7] = Booleano para decidir se a foto é dark
     '''
     settings = SettingsCamera()
     info = settings.get_camera_settings()
     return info
Beispiel #3
0
class DarkShooterThread(QtCore.QThread):
    def __init__(self, timeSleep):
        self.continuous = None
        super(DarkShooterThread, self).__init__()
        self.console = ConsoleThreadOutput()
        self.s = timeSleep
        self.ss = SThread()
        self.settings = SettingsCamera()

    def run(self):
        self.s = int(self.settings.get_camera_settings()[4])
        while self.continuous:
            time.sleep(self.s)
            if self.continuous:
                self.console.raise_text("Taking dark photo", 1)
                self.ss.take_dark()
Beispiel #4
0
    def get_camera_settings(self):
        '''
        pega os valores no ini camera
        info[0] = temperature_camera
        info[1] = prefixo/filter name
        info[2] = tempo_exposicao
        info[3] = binning
        info[4] = tempo_fotos(tempo entre fotos)
        info[5] = time_cooling(CCD cooling time)
        info[6] = Image contrast: bottom
        info[7] = Image contrast: top level
        info[8] = Booleano para decidir se a foto é dark
        info[9] = axis_xi inicial
        info[10] = axis_xf final
        info[11] = axis_yi inicial
        info[12] = axis_yf final
        info[13] = ignore_crop
        info[14] = image_tif
        info[15] = image_fit
        '''
        settings = SettingsCamera()
        info = settings.get_camera_settings()

        return info
Beispiel #5
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()
Beispiel #6
0
 def get_camera_settings_ini(self):
     settings = SettingsCamera()
     info_ini = settings.get_camera_settings()
     return info_ini
Beispiel #7
0
class Camera(metaclass=Singleton):
    '''
        classe de controle que faz comunicao com a camera fisica.
    '''
    def __init__(self):
        self.lock = Locker()
        self.console = ConsoleThreadOutput()
        self.settings = SettingsCamera()
        self.settings.setup_settings()
        self.fan = Fan()

        # Campos da janela principal para as informações da câmera
        self.firmware_field = None
        self.model_field = None
        self.valor_pixels_x = None
        self.valor_pixels_y = None

        self.main = Status()
        self.now_plus = datetime.now()
        self.settedhour = datetime.now()
        """
        executa o modo manual continuousShooterThread
        """
        self.continuousShooterThread = ContinuousShooterThread(
            int(self.settings.get_camera_settings()[4]))
        """
        executa o modo automatico ephemerisShooterThread
        """
        self.ephemerisShooterThread = EphemerisShooter()

        self.sthread = SThread()

        self.commands = CameraQThread(self)
        self.shooting = False
        # Initiating the Slots
        self.init_slots()

        self.info_ini = []
        self.pass_list = [1024, 1024]
        self.pass_list_str = ["1024", "1024"]

        info_ini = self.get_camera_settings_ini()
        self.aux_temperature = int(info_ini[0])

        self.temp = 0
        self.temp_contador = False
        self.temp_contador_manual = False
        self.is_connected = False

    def init_slots(self):
        """
        Ephemeris Shooter Slots
        """
        self.ephemerisShooterThread.started.connect(self.eshooter_started)
        self.ephemerisShooterThread.finished.connect(self.eshooter_finished)
        self.ephemerisShooterThread.signal_started_shooting.connect(
            self.shooter_mode)
        self.ephemerisShooterThread.signal_temp.connect(self.check_temp)
        self.ephemerisShooterThread.continuousShooterThread.signal_temp.connect(
            self.check_temp)

        self.ephemerisShooterThread.continuousShooterThread.started.connect(
            self.eshooter_observation_started)
        self.ephemerisShooterThread.continuousShooterThread.finished.connect(
            self.eshooter_observation_finished)
        """
        Criando connect da temperatura
        """
        # self.ephemerisShooterThread.continuousShooterThread.signalAfterShooting.connect()
        self.continuousShooterThread.signal_temp.connect(
            self.check_temp_manual)
        self.continuousShooterThread.finished.connect(self.standby_mode)

        # Camera Commands Slots
        self.commands.finished.connect(self.eita)
        self.commands.connectSignal.connect(self.connect_mainwindow_update)

    def get_firmware_and_model_and_pixels(self):
        info = self.get_info()
        return str(info[0]), str(info[2])[2:len(str(info[2])) - 1], str(
            info[-2]), str(info[-1])

    def get_model_and_pixels_new(self):
        return self.model_field.text(), self.valor_pixels_x.text(
        ), self.valor_pixels_y.text()

    def set_firmware_and_model_fields(self, modelField, X_Pixels, Y_Pixels):
        # self.firmware_field = firmwareField
        self.model_field = modelField
        self.valor_pixels_x = X_Pixels
        self.valor_pixels_y = Y_Pixels

    def set_firmware_and_model_values(self):
        firmware, model, y_pixels, x_pixels = self.get_firmware_and_model_and_pixels(
        )
        # self.firmware_field.setText("Firmware: " + firmware)
        self.model_field.setText("Camera: " + model)
        self.valor_pixels_x.setText(x_pixels + "       X ")
        self.valor_pixels_y.setText(y_pixels + " Pixels")
        self.pass_list = [
            int(self.valor_pixels_x.text().split(" ")[0]),
            int(self.valor_pixels_y.text().split(" ")[0])
        ]
        self.pass_list_str = [
            self.valor_pixels_x.text().split(" ")[0],
            self.valor_pixels_y.text().split(" ")[0]
        ]

    def clear_firmware_and_model_values(self):
        # self.firmware_field.setText("Firmware: ")
        self.model_field.setText("Camera: ")

    def get_info(self):
        '''
        Function to get the CCD Info
        This function will return [CameraFirmware, CameraType, CameraName, Pixels]
        '''
        ret = None
        self.lock.set_acquire()
        try:
            ret = tuple(ccdinfo())
        except Exception as e:
            self.console.raise_text(
                "Failed to get camera information.\n{}".format(e))
        finally:
            self.lock.set_release()
        return ret

    def connect(self):
        try:
            a = open_driver()
            open_deviceusb()
            c = establishinglink()
            if a is True and c is True:
                self.console.raise_text("Open Device = {}".format(a), 2)
                time.sleep(1)
                # self.console.save_log("Open Device = {}".format(a))
                self.console.raise_text("Established Link = {}".format(c), 2)
                time.sleep(1)
                # self.console.save_log("Established Link = {}".format(c))
                self.console.raise_text("Successfully connected!", 2)
                time.sleep(1)
                # self.console.save_log("Successfully connected!")
                self.set_firmware_and_model_values()
                self.is_connected = True
                '''
                Fan Field sera atualizado automaticamente
                atualizado pela thread de refresh temp.
                '''
                # self.fan.refresh_fan_status()
                return True
            else:
                self.is_connected = False
                self.console.raise_text("Connection error", 3)

        except Exception as e:
            self.is_connected = False
            self.console.raise_text(
                'Failed to connect the camera!\n{}'.format(e), 3)

        return False

    def disconnect(self):
        try:
            self.standby_mode()
            cd = close_device()
            cdr = close_driver()

            if cd and cdr:
                self.console.raise_text("Close Device = {}".format(cd), 2)
                self.console.raise_text("Close Driver = {}".format(cdr), 2)
                self.console.raise_text("Successfully disconnected", 2)
                self.clear_firmware_and_model_values()
                self.is_connected = False
            else:
                self.console.raise_text(
                    "Error disconnect! {} {}".format(cd, cdr), 3)
        except Exception as e:
            self.console.raise_text(
                "It failed to disconnect the camera!\n{}".format(e), 3)

    def set_temperature(self, value):
        if getlinkstatus() is True:
            self.lock.set_acquire()
            try:
                set_temperature(regulation=True,
                                setpoint=value,
                                autofreeze=False)
            except Exception as e:
                self.console.raise_text(
                    "Error setting the temperature.\n{}".format(e), 3)
            finally:
                self.lock.set_release()
                self.console.raise_text(
                    "Temperature set to {}°C".format(int(value)), 1)
                time.sleep(1)
                # self.check_fan()
                # self.console.save_log("Temperature set to {}°C".format(int(value)))
        else:
            self.console.raise_text("The camera is not connected!", 3)

    def get_temperature(self):
        temp = "NAN"
        try:
            if getlinkstatus() is True:
                if not self.lock.is_locked():
                    self.lock.set_acquire()
                    temp = get_temperature()[3]
                    self.temp = temp
                    self.lock.set_release()
            # else:
            # if getlinkstatus() is True:
            #     sleep(1)
            #     self.lock.set_acquire()
            #     temp = tuple(get_temperature())[3]
            #     self.lock.set_release()
            # temp = "None",
        except Exception as e:
            self.console.raise_text(
                "Unable to retrieve the temperature.\n{}".format(e), 3)
            time.sleep(1)
            temp = "NAN"

        return temp

    def check_link(self):
        return getlinkstatus()

    def get_camera_settings_ini(self):
        settings = SettingsCamera()
        info_ini = settings.get_camera_settings()
        return info_ini

    # Camera Mode
    def standby_mode(self):
        self.set_temperature(15.00)
        self.fan.set_fan_off()
        self.check_fan()

    def check_fan(self):
        if SbigDriver.is_fanning():
            self.console.raise_text("Fan: ON", 2)
            time.sleep(1)
        else:
            self.console.raise_text("Fan: OFF", 2)
            time.sleep(1)

    def shooter_mode(self):
        info_ini = self.get_camera_settings_ini()
        self.aux_temperature = int(info_ini[0])
        self.set_temperature(int(self.aux_temperature))
        self.fan.set_fan_on()
        self.check_fan()
        self.console.raise_text(
            "Waiting temperature to " + str(self.aux_temperature) + "°C", 2)
        time.sleep(1)

    # Shooters
    def start_one_photo(self):

        try:
            self.continuousShooterThread.one_photo = True
            self.continuousShooterThread.wait_temperature = True
            self.continuousShooterThread.start_continuous_shooter()
            self.continuousShooterThread.start()
        except Exception as e:
            print(e)

    def start_taking_photo(self):
        try:
            if getlinkstatus() is True:
                self.shooter_mode()
                self.continuousShooterThread.start_continuous_shooter()
                self.continuousShooterThread.start()
            else:
                self.console.raise_text("The camera is not connected", 3)
        except Exception as e:
            print(e)

    def stop_taking_photo(self):
        if getlinkstatus() is True:
            if not self.continuousShooterThread.wait_temperature:
                self.continuousShooterThread.stop_continuous_shooter()
            self.continuousShooterThread.stop_continuous_shooter()
            # self.standby_mode()
        else:
            self.console.raise_text("The camera is not connected!", 3)

    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)
        time.sleep(1)

    def start_ephemeris_shooter(self):
        if getlinkstatus() is True:
            self.ephemerisShooterThread.start()
        else:
            self.console.raise_text("The camera is not connected!", 3)

    def stop_ephemeris_shooter(self):
        if getlinkstatus() is True:
            self.ephemerisShooterThread.stop_shooter()
            # self.standby_mode()
        else:
            self.console.raise_text("The camera is not connected!", 3)

    # All PyQt Slots

    def eshooter_started(self):
        self.console.raise_text("Shooter Ephemeris Started!", 1)
        time.sleep(1)
        # self.console.save_log("Shooter Ephemeris Started!")
        self.log_ephem_infos()
        self.standby_mode()

    def eshooter_finished(self):
        self.console.raise_text('Shooter Finished\n', 2)
        time.sleep(1)
        self.log_ephem_infos()
        self.standby_mode()

    def eshooter_observation_started(self):
        self.shooting = True
        self.console.raise_text("Observation Started\n", 2)
        time.sleep(1)
        self.log_ephem_infos()

    def eshooter_observation_finished(self):
        self.console.raise_text("Observation Finalized", 2)
        self.standby_mode()
        self.continuousShooterThread.wait_temperature = False
        self.continuousShooterThread.one_photo = False
        self.ephemerisShooterThread.wait_temperature = False
        self.ephemerisShooterThread.continuousShooterThread.wait_temperature = False
        self.temp_contador_manual = 0
        self.shooting = False
        self.log_ephem_infos()

    # Commands Slots
    def check_temp_manual(self):
        '''
        funcao que espera temperatura setada ou tempo pre-determinado
        '''
        try:
            now = datetime.now()
            if not self.temp_contador_manual:
                self.now_plus = now + timedelta(
                    seconds=int(self.settings.get_camera_settings()[5]))
                self.temp_contador_manual = True
            elif self.temp <= int(
                    self.aux_temperature) or now >= self.now_plus:
                self.continuousShooterThread.wait_temperature = True
                self.temp_contador_manual = False
            else:
                self.temp_contador_manual = True

        except Exception as e:
            print(e)

    def check_temp(self):
        '''
        funcao que espera temperatura setada ou tempo pre-determinado
        '''
        try:
            now = datetime.now()
            if not self.temp_contador:
                self.now_plus = now + timedelta(
                    seconds=int(self.settings.get_camera_settings()[5]))
                self.temp_contador = True
            if self.temp <= int(self.aux_temperature) or now >= self.now_plus:
                self.ephemerisShooterThread.wait_temperature = True
                self.ephemerisShooterThread.continuousShooterThread.wait_temperature = True

                self.temp_contador = False
        except Exception as e:
            print(e)

    def connect_mainwindow_update(self):
        self.set_firmware_and_model_values()
        self.fan.refresh_fan_status()

    def eita(self):
        self.console.raise_text(self.commands.text, 1)
Beispiel #8
0
class SettingsWindow(QtWidgets.QWidget):
    def __init__(self, parent=None):
        super(SettingsWindow, self).__init__(parent)
        self.cam = SettingsCamera()
        self.camera = Camera()
        self.console = ConsoleThreadOutput()
        #self.a_temp_regulation = TempRegulation(self)
        self.create_cam_widgets()
        self.p = parent
        self.fan = Fan(self.fanButton)

        #self.button_clear = QtWidgets.QPushButton('Clear', self)

        self.setField_temperature = QtWidgets.QLineEdit(self)
        self.setting_values()

        self.one_photo = SThread()

        self.setLayout(
            set_lvbox(
                set_hbox(self.setField_temperature_label,
                         self.setField_temperature),
                set_hbox(self.pre, self.prel), set_hbox(self.exp, self.expl),
                set_hbox(self.binning, self.combo),
                set_hbox(self.tempo_fotos_label, self.tempo_fotos),
                set_hbox(self.time_colling_label, self.time_colling),
                set_hbox(self.dark, self.close_open),
                set_hbox(self.getlevel1, self.getlevel1l),
                set_hbox(self.getlevel2, self.getlevel2l),
                set_hbox(self.btn_one_photo,
                         self.tempButton,
                         self.fanButton,
                         stretch2=1),
                set_hbox(self.buttonok,
                         self.button_clear,
                         self.buttoncancel,
                         stretch2=1)))

    def get_camera_settings(self):
        settings = SettingsCamera()
        info = settings.get_camera_settings()
        return info

    def get_values(self):
        return self.cam.get_camera_settings()

    def setting_values(self):
        info = self.get_values()
        self.set_values(info[0], info[1], info[2], info[3], info[4], info[5],
                        info[6], info[7], info[8])

    def set_values(self, temperature_camera, prefixo, exposicao, binning,
                   tempo_entre_fotos, time_colling, get_level1, get_level2,
                   dark_photo):
        self.setField_temperature.setText(temperature_camera)
        self.prel.setText(prefixo)
        self.expl.setText(exposicao)

        try:
            b = int(binning)
        except:
            b = 0
        try:
            open_or_close = int(dark_photo)
        except:
            open_or_close = 0
        self.tempo_fotos.setText(tempo_entre_fotos)
        self.time_colling.setText(time_colling)
        self.combo.setCurrentIndex(b)
        self.close_open.setCurrentIndex(open_or_close)
        self.getlevel1l.setText(get_level1)
        self.getlevel2l.setText(get_level2)

    def create_cam_widgets(self):
        self.setField_temperature_label = QtWidgets.QLabel(
            "Temperature(°C):", self)
        self.pre = QtWidgets.QLabel("Filter name:", self)
        self.prel = QtWidgets.QLineEdit(self)

        self.exp = QtWidgets.QLabel("Exposure time(s):", self)
        self.expl = QtWidgets.QLineEdit(self)

        self.binning = QtWidgets.QLabel("Binning:", self)
        self.combo = QtWidgets.QComboBox(self)
        self.fill_combo()

        self.dark = QtWidgets.QLabel("Shooter:", self)
        self.close_open = QtWidgets.QComboBox(self)
        self.fill_combo_close_open()

        self.getlevel1 = QtWidgets.QLabel("Image contrast: bottom level:",
                                          self)
        self.getlevel1l = QtWidgets.QLineEdit(self)

        self.getlevel2 = QtWidgets.QLabel("Image contrast:       top level:",
                                          self)
        self.getlevel2l = QtWidgets.QLineEdit(self)

        self.button_clear = QtWidgets.QPushButton('Clear', self)
        self.button_clear.clicked.connect(self.clear_all)

        self.btn_one_photo = QtWidgets.QPushButton('Take Photo', self)
        self.btn_one_photo.clicked.connect(self.take_one_photo)

        self.tempButton = QtWidgets.QPushButton("Set Temp", self)
        self.tempButton.clicked.connect(self.btn_temperature)

        self.fanButton = QtWidgets.QPushButton("Fan (On/Off)")
        self.fanButton.clicked.connect(self.button_fan_func)

        self.buttonok = QtWidgets.QPushButton("Save", self)
        self.buttonok.clicked.connect(self.button_ok_func)

        self.buttoncancel = QtWidgets.QPushButton("Cancel", self)
        self.buttoncancel.clicked.connect(self.func_cancel)

        self.tempo_fotos_label = QtWidgets.QLabel("Time between photos(s):",
                                                  self)
        self.tempo_fotos = QtWidgets.QLineEdit(self)

        self.time_colling_label = QtWidgets.QLabel("CCD Cooling Time(s):",
                                                   self)
        self.time_colling = QtWidgets.QLineEdit(self)

    def button_ok_func(self):
        try:
            # Saving the Settings
            self.cam.set_camera_settings(self.setField_temperature.text(), self.prel.text(), self.expl.text(),\
                                         self.combo.currentIndex(), self.tempo_fotos.text(), self.time_colling.text(), \
                                         self.getlevel1l.text(), self.getlevel2l.text(), self.close_open.currentIndex())
            self.cam.save_settings()
            self.console.raise_text("Camera settings successfully saved!", 1)
        except Exception as e:
            self.console.raise_text("Camera settings were not saved.", 3)
        finally:
            pass
            #self.p.close()

    def clear_all(self):
        self.setField_temperature.clear()
        self.prel.clear()
        self.expl.clear()
        self.tempo_fotos.clear()

    def take_one_photo(self):
        try:
            info = self.get_camera_settings()
            if int(info[6]) == 1:
                self.console.raise_text("Taking dark photo", 1)
                self.one_photo.start()
            else:
                self.console.raise_text("Taking photo", 1)
                self.one_photo.start()
        except Exception:
            self.console.raise_text("Not possible taking photo", 1)

    def func_cancel(self):
        self.p.close()

    def button_fan_func(self):
        if getlinkstatus() is True:
            try:
                self.fan.set_fan()
                self.console.raise_text('State changed Fan!', 2)
            except Exception:
                self.console.raise_text("The camera is not connected!", 3)
                self.console.raise_text('State Fan unchanged', 3)
        else:
            self.console.raise_text("The camera is not connected!", 3)
            self.console.raise_text('State Fan unchanged', 3)

    def fill_combo(self):
        self.combo.addItem("1x1", 0)
        self.combo.addItem("2x2", 1)
        self.combo.addItem("3x3", 2)

    def fill_combo_close_open(self):
        self.close_open.addItem("Open", 0)
        self.close_open.addItem("Close", 1)

    def btn_temperature(self):
        try:
            value = self.setField_temperature.text()
            if value is '':
                pass
            else:
                self.camera.set_temperature(float(value))
        except Exception as e:
            print("Exception -> {}".format(e))
Beispiel #9
0
class SettingsWindow(QtWidgets.QWidget):
    '''
    Cria os campos e espaços no menu settings window
    '''
    def __init__(self, parent=None):
        super(SettingsWindow, self).__init__(parent)
        self.cam = SettingsCamera()
        self.camera = Camera()
        self.console = ConsoleThreadOutput()
        self.create_cam_widgets()
        self.p = parent
        self.fan = Fan(self.fanButton)

        self.lock = Locker()

        self.setting_values()

        self.one_photo = SThread()

        self.setLayout(
            set_lvbox(
                set_hbox(self.setField_temperature_label,
                         self.setField_temperature),
                set_hbox(self.pre, self.prel), set_hbox(self.exp, self.expl),
                set_hbox(self.binning, self.combo),
                set_hbox(self.dark, self.close_open),
                set_hbox(self.tempo_fotos_label, self.tempo_fotos),
                set_hbox(self.time_colling_label, self.time_colling),
                set_hbox(self.contrast_msg),
                set_hbox(self.getlevel1, self.getlevel1l, self.getlevel2,
                         self.getlevel2l), set_hbox(self.ignore_crop_l),
                set_hbox(self.crop_msg),
                set_hbox(self.crop_xi, self.getcropxi_l, self.crop_xf,
                         self.getcropxf_l),
                set_hbox(self.crop_yi, self.getcropyi_l, self.crop_yf,
                         self.getcropyf_l), set_hbox(self.image_tif_l),
                set_hbox(self.image_fit_l),
                set_hbox(self.btn_one_photo,
                         self.tempButton,
                         self.fanButton,
                         stretch2=1),
                set_hbox(self.buttonok,
                         self.button_clear,
                         self.buttoncancel,
                         stretch2=1)))

    def get_camera_settings(self):
        settings = SettingsCamera()
        info = settings.get_camera_settings()
        return info

    def get_pixels(self):
        info = self.get_info_pixels()
        return int(info[-2]), int(info[-1])

    def get_info_pixels(self):
        '''
        Function to get the CCD Info
        This function will return [Pixels]
        '''
        ret = None
        self.lock.set_acquire()
        try:
            ret = tuple(ccdinfo())
        except Exception as e:
            self.console.raise_text(
                "Failed to get camera information.\n{}".format(e))
        finally:
            self.lock.set_release()
        return ret

    def get_values(self):
        return self.cam.get_camera_settings()

    def setting_values(self):
        info = self.get_values()
        self.set_values(info[0], info[1], info[2], info[3], info[4], info[5], info[6], info[7], info[8], info[9],\
                        info[10], info[11], info[12], info[13], info[14], info[15])

    def set_values(self, temperature_camera, prefixo, exposicao, binning, tempo_entre_fotos, time_colling, get_level1,\
                   get_level2, dark_photo, crop_xi, crop_xf, crop_yi, crop_yf, ignore_crop, image_tif, image_fit):
        self.setField_temperature.setText(temperature_camera)
        self.prel.setText(prefixo)
        self.expl.setText(exposicao)

        try:
            b = int(binning)
        except:
            b = 0

        try:
            open_or_close = int(dark_photo)
        except:
            open_or_close = 0

        self.tempo_fotos.setText(tempo_entre_fotos)
        self.time_colling.setText(time_colling)
        self.combo.setCurrentIndex(b)
        self.close_open.setCurrentIndex(open_or_close)

        self.getlevel1l.setText(get_level1)
        self.getlevel2l.setText(get_level2)

        self.getcropxi_l.setText(crop_xi)
        self.getcropxf_l.setText(crop_xf)
        self.getcropyi_l.setText(crop_yi)
        self.getcropyf_l.setText(crop_yf)

        self.ignore_crop_l.setChecked(ignore_crop)

        self.image_tif_l.setChecked(image_tif)
        self.image_fit_l.setChecked(image_fit)

    def create_cam_widgets(self):
        self.setField_temperature_label = QtWidgets.QLabel(
            "CCD Temperature(°C):", self)
        self.setField_temperature_label.setAlignment(QtCore.Qt.AlignRight
                                                     | QtCore.Qt.AlignVCenter)

        self.setField_temperature = QtWidgets.QLineEdit(self)
        self.setField_temperature.setMaximumWidth(100)

        self.pre = QtWidgets.QLabel("Filter Name:", self)
        self.pre.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

        self.prel = QtWidgets.QLineEdit(self)
        self.prel.setMaximumWidth(100)

        self.exp = QtWidgets.QLabel("Exposure time (s):", self)
        self.exp.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

        self.expl = QtWidgets.QLineEdit(self)
        self.expl.setMaximumWidth(100)

        self.binning = QtWidgets.QLabel("Binning:", self)
        self.binning.setAlignment(QtCore.Qt.AlignRight
                                  | QtCore.Qt.AlignVCenter)

        self.combo = QtWidgets.QComboBox(self)
        self.combo.setMaximumWidth(100)
        self.fill_combo()

        self.dark = QtWidgets.QLabel("Shutter:", self)
        self.dark.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

        self.close_open = QtWidgets.QComboBox(self)
        self.close_open.setMaximumWidth(100)
        self.fill_combo_close_open()

        self.tempo_fotos_label = QtWidgets.QLabel("Time Between Images (s):",
                                                  self)
        self.tempo_fotos_label.setAlignment(QtCore.Qt.AlignRight
                                            | QtCore.Qt.AlignVCenter)

        self.tempo_fotos = QtWidgets.QLineEdit(self)
        self.tempo_fotos.setMaximumWidth(100)

        self.time_colling_label = QtWidgets.QLabel("CCD Cooling Time (s):",
                                                   self)
        self.time_colling_label.setAlignment(QtCore.Qt.AlignRight
                                             | QtCore.Qt.AlignVCenter)

        self.time_colling = QtWidgets.QLineEdit(self)
        self.time_colling.setMaximumWidth(100)

        self.contrast_msg = QtWidgets.QLabel("Image Contrast:", self)
        self.getlevel1 = QtWidgets.QLabel("Bottom Level:", self)
        self.getlevel1.setAlignment(QtCore.Qt.AlignRight
                                    | QtCore.Qt.AlignVCenter)

        self.getlevel1l = QtWidgets.QLineEdit(self)
        self.getlevel1l.setMaximumWidth(50)

        self.getlevel2 = QtWidgets.QLabel("Top Level:", self)
        self.getlevel2.setAlignment(QtCore.Qt.AlignRight
                                    | QtCore.Qt.AlignVCenter)

        self.getlevel2l = QtWidgets.QLineEdit(self)
        self.getlevel2l.setMaximumWidth(50)

        self.ignore_crop_l = QtWidgets.QCheckBox('Ignore Crop Image', self)

        self.crop_msg = QtWidgets.QLabel("Crop Image", self)
        self.crop_xi = QtWidgets.QLabel("Width: Wi:", self)
        self.crop_xi.setAlignment(QtCore.Qt.AlignRight
                                  | QtCore.Qt.AlignVCenter)

        self.getcropxi_l = QtWidgets.QLineEdit(self)
        self.getcropxi_l.setMaximumWidth(50)

        self.crop_xf = QtWidgets.QLabel("Wf:", self)
        self.crop_xf.setAlignment(QtCore.Qt.AlignRight
                                  | QtCore.Qt.AlignVCenter)

        self.getcropxf_l = QtWidgets.QLineEdit(self)
        self.getcropxf_l.setMaximumWidth(50)

        self.crop_yi = QtWidgets.QLabel("Height: Hi:", self)
        self.crop_yi.setAlignment(QtCore.Qt.AlignRight
                                  | QtCore.Qt.AlignVCenter)

        self.getcropyi_l = QtWidgets.QLineEdit(self)
        self.getcropyi_l.setMaximumWidth(50)

        self.crop_yf = QtWidgets.QLabel("Hf:", self)
        self.crop_yf.setAlignment(QtCore.Qt.AlignRight
                                  | QtCore.Qt.AlignVCenter)

        self.getcropyf_l = QtWidgets.QLineEdit(self)
        self.getcropyf_l.setMaximumWidth(50)

        self.image_tif_l = QtWidgets.QCheckBox('Image .tif', self)

        self.image_fit_l = QtWidgets.QCheckBox('Image .fit', self)

        self.button_clear = QtWidgets.QPushButton('Clear', self)
        self.button_clear.clicked.connect(self.clear_all)

        self.btn_one_photo = QtWidgets.QPushButton('Take Photo', self)
        self.btn_one_photo.clicked.connect(self.camera.start_one_photo)

        self.tempButton = QtWidgets.QPushButton("Set Temp", self)
        self.tempButton.clicked.connect(self.btn_temperature)

        self.fanButton = QtWidgets.QPushButton("Fan (On/Off)")
        self.fanButton.clicked.connect(self.button_fan_func)

        self.buttonok = QtWidgets.QPushButton("Save", self)
        self.buttonok.clicked.connect(self.button_ok_func)

        self.buttoncancel = QtWidgets.QPushButton("Cancel", self)
        self.buttoncancel.clicked.connect(self.func_cancel)

    def button_ok_func(self):
        try:
            y_pixels, x_pixels = self.get_pixels()

            # Saving the Settings
            if int(self.getcropxi_l.text()) > int(self.getcropxf_l.text()) or\
                            int(self.getcropyi_l.text()) > int(self.getcropyf_l.text()) or\
                            int(self.getcropxf_l.text()) >= x_pixels/(int(self.combo.currentIndex() + 1)) or \
                            int(self.getcropyf_l.text()) >= y_pixels/(int(self.combo.currentIndex() + 1)):
                self.console.raise_text("Wrong values for image crop.", 3)
            else:
                self.cam.set_camera_settings(self.setField_temperature.text(),
                                             self.time_colling.text(),
                                             self.tempo_fotos.text())
                self.cam.save_settings()
                self.console.raise_text("Camera settings successfully saved!",
                                        1)
                """
                self.setField_temperature.text(), self.prel.text(), self.expl.text(),
                self.combo.currentIndex(), self.tempo_fotos.text(), self.time_colling.text(),
                self.getlevel1l.text(), self.getlevel2l.text(), self.close_open.currentIndex(),
                self.getcropxi_l.text(), self.getcropxf_l.text(),
                self.getcropyi_l.text(), self.getcropyf_l.text(),
                self.ignore_crop_l.isChecked(),
                self.image_tif_l.isChecked(),
                self.image_fit_l.isChecked()
                """
        except Exception as e:
            self.console.raise_text("Camera settings were not saved.", 3)

    def clear_all(self):
        self.setField_temperature.clear()
        self.prel.clear()
        self.expl.clear()
        self.tempo_fotos.clear()

    def take_one_photo(self):
        try:
            info = self.get_camera_settings()
            if int(info[8]) == 1:
                self.console.raise_text("Taking dark photo", 1)
                self.one_photo.start()
            else:
                self.console.raise_text("Taking photo", 1)
                self.one_photo.start()
        except Exception:
            self.console.raise_text("Not possible taking photo", 1)

    def func_cancel(self):
        self.p.close()

    def button_fan_func(self):
        if getlinkstatus() is True:
            try:
                self.fan.set_fan()
                self.console.raise_text('State changed Fan!', 2)
            except Exception:
                self.console.raise_text("The camera is not connected!", 3)
                self.console.raise_text('State Fan unchanged', 3)
        else:
            self.console.raise_text("The camera is not connected!", 3)
            self.console.raise_text('State Fan unchanged', 3)

    def fill_combo(self):
        self.combo.addItem("1x1", 0)
        self.combo.addItem("2x2", 1)
        self.combo.addItem("3x3", 2)

    def fill_combo_close_open(self):
        self.close_open.addItem("Open", 0)
        self.close_open.addItem("Close", 1)

    def btn_temperature(self):
        try:
            value = self.setField_temperature.text()
            if value is '':
                pass
            else:
                self.camera.set_temperature(float(value))
        except Exception as e:
            print("Exception -> {}".format(e))
Beispiel #10
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)
Beispiel #11
0
class Shooter(QtWidgets.QWidget):
    """
    Class for Taking photo Widget
    """
    def __init__(self, parent=None):
        super(Shooter, self).__init__(parent)
        self.cam = Camera()
        self.cond = 0
        self.sref_calc = SettingsCamera()

        # Label for Image
        self.img = QtWidgets.QLabel(self)
        self.config_img_label()

        # Creating a Pallete
        self.pa = QtGui.QPalette()

        self.set_layout()
        self.link_signals()

    def link_signals(self):
        self.cam.ephemerisShooterThread.continuousShooterThread.ss.finished.connect(
            self.get_image_automatic)
        self.cam.continuousShooterThread.ss.finished.connect(
            self.get_image_manual)

    def get_image_automatic(self):
        img = self.cam.ephemerisShooterThread.continuousShooterThread.ss.get_image_info(
        )
        self.set_image(img)

    def get_image_manual(self):
        img = self.cam.continuousShooterThread.ss.get_image_info()
        self.set_image(img)

    def set_layout(self):
        hb2 = set_hbox(self.prefix, self.date, self.hour)

        self.setLayout(set_lvbox(set_hbox(self.img), hb2))
        self.config_pallete()

    def config_img_label(self):
        self.img.setPixmap(QtGui.QPixmap("noimage.png"))
        self.prefix = QtWidgets.QLabel(self)
        self.date = QtWidgets.QLabel(self)
        self.hour = QtWidgets.QLabel(self)

    def config_pallete(self):
        self.pa.setColor(QtGui.QPalette.Foreground,
                         QtCore.Qt.red)  # Setting the style
        self.prefix.setPalette(self.pa)
        self.date.setPalette(self.pa)
        self.hour.setPalette(self.pa)

    def shoot_function(self):
        self.cam.shoot(int(self.tb.text()), self.pre.text(),
                       int(self.combo.currentIndex()))
        self.set_image()

    def auto_shoot(self):
        try:
            self.cam.autoshoot(int(self.htext.text()), int(self.mtext.text()),
                               int(self.tb.text()), self.pre.text(),
                               int(self.combo.currentIndex()))
        except Exception as e:
            print(e)

    def set_image(self, img):
        print("Setting Pixmap")
        print("CCCCCCCCCCCCCCCCCCCCCCCCCCC")
        try:
            path = img.final_image_name
            str_name_image = str(img.final_image_name)

            # image = Image.open(path)]

            try:
                if os.path.splitext(path)[1] == '.fit':
                    print("1111111111111111111")
                    img = getdata(path)
                else:
                    print("222222222222222222222")
                    img = skimage.io.imread(path)

                print("\n\n>>>>>>>>>>>>>>>>>>>>>>")
                print(img)

            except Exception as e:
                print("Exception os.path.splitext -> {}".format(e))
            image = img

            sref_min = float(self.sref_calc.get_camera_settings()[6])
            sref_max = float(self.sref_calc.get_camera_settings()[7])

            img_hist_equal = Image_Processing.img_hist_equal(
                image, sref_min, sref_max)
            im3 = toimage(img_hist_equal)
            im4 = im3.resize((int(512), int(512)))
            im5 = Image_Processing.draw_image(im4, str_name_image)

            try:
                qim = ImageQt(im5)
                self.img.setPixmap(QtGui.QPixmap.fromImage(qim))
            except Exception as e:
                print(
                    "Exception setPixmap(QtGui.QPixmap(image_to_show)) -> {}".
                    format(e))

            print(path)

        except Exception as e:
            print("Exception Setting Pixmap -> {}".format(e))

    def fill_combo(self):
        self.combo.addItem("1x1", 0)
        self.combo.addItem("2x2", 1)
        self.combo.addItem("3x3", 2)

    def clear_image_info(self):
        self.prefix.clear()
Beispiel #12
0
class Camera(metaclass=Singleton):

    def __init__(self):
        self.lock = Locker()
        self.console = ConsoleThreadOutput()
        self.settings = SettingsCamera()
        self.settings.setup_settings()
        self.fan = Fan()

        # Campos da janela principal para as informações da câmera
        self.firmware_field = None
        self.model_field = None

        self.main = Status()
        self.settedhour = datetime.now()
        self.continuousShooterThread = ContinuousShooterThread(int(self.settings.get_camera_settings()[4]))
        self.ephemerisShooterThread = EphemerisShooter()

        self.commands = CameraQThread(self)
        self.shooting = False

        # Initiating the Slots
        self.init_slots()

        self.temp = 0
        self.temp_contador = 0

    def init_slots(self):
        # Ephemeris Shooter Slots
        self.ephemerisShooterThread.started.connect(self.eshooter_started)
        self.ephemerisShooterThread.finished.connect(self.eshooter_finished)
        self.ephemerisShooterThread.signal_started_shooting.connect(self.shooter_mode)
        self.ephemerisShooterThread.signal_temp.connect(self.check_temp)

        self.ephemerisShooterThread.continuousShooterThread.started.connect(self.eshooter_observation_started)
        self.ephemerisShooterThread.continuousShooterThread.finished.connect(self.eshooter_observation_finished)

        # Criando connect da temperatura
        # self.ephemerisShooterThread.continuousShooterThread.signalAfterShooting.connect()

        self.continuousShooterThread.finished.connect(self.standby_mode)

        # Camera Commands Slots
        self.commands.finished.connect(self.eita)
        self.commands.connectSignal.connect(self.connect_mainwindow_update)

    def get_firmware_and_model(self):
        info = self.get_info()
        return str(info[0]), str(info[2])[2:len(str(info[2]))-1]

    def set_firmware_and_model_fields(self, firmwareField, modelField):
        self.firmware_field = firmwareField
        self.model_field = modelField

    def set_firmware_and_model_values(self):
        firmware, model = self.get_firmware_and_model()
        self.firmware_field.setText("Firmware: " + firmware)
        self.model_field.setText("Camera: " + model)

    def clear_firmware_and_model_values(self):
        self.firmware_field.setText("Firmware: ")
        self.model_field.setText("Camera: ")

    def get_info(self):
        """
            Function to get the CCD Info
            This function will return [CameraFirmware, CameraType, CameraName]
        """
        ret = None
        self.lock.set_acquire()
        try:
            ret = tuple(ccdinfo())
        except Exception as e:
            self.console.raise_text("Failed to get camera information.\n{}".format(e))
        finally:
            self.lock.set_release()
        return ret

    def connect(self):
        try:
            a = open_driver()
            open_deviceusb()
            c = establishinglink()
            if a is True and c is True:
                self.console.raise_text("Successfully connected! {} {}".format(a, c), 2)
                self.set_firmware_and_model_values()

                '''
                    Fan Field sera atualizado automaticamente
                    atualizado pela thread de refresh temp.
                '''
                # self.fan.refresh_fan_status()
                return True
            else:
                self.console.raise_text("Connection error", 3)

        except Exception as e:
            self.console.raise_text('Failed to connect the camera!\n{}'.format(e), 3)

        return False

    def disconnect(self):
        try:
            self.standby_mode()
            cd = close_device()
            cdr = close_driver()

            if cd and cdr:
                self.console.raise_text("Successfully disconnected!{} {}".format(cd, cdr), 2)
                self.clear_firmware_and_model_values()
            else:
                self.console.raise_text("Error disconnect! {} {}".format(cd, cdr), 3)
        except Exception as e:
            self.console.raise_text("It failed to disconnect the camera!\n{}".format(e), 3)

    def set_temperature(self, value):
        if getlinkstatus() is True:
            self.lock.set_acquire()
            try:
                set_temperature(regulation=True, setpoint=value, autofreeze=False)
            except Exception as e:
                self.console.raise_text("Error setting the temperature.\n{}".format(e), 3)
            finally:
                self.lock.set_release()
                self.console.raise_text("Temperature set to {}".format(int(value)), 1)
        else:
            self.console.raise_text("The camera is not connected!", 3)

    def get_temperature(self):
        temp = "None"
        try:
            if getlinkstatus() is True:
                if not self.lock.is_locked():
                    self.lock.set_acquire()
                    temp = tuple(get_temperature())[3]
                    self.temp = temp
                    self.lock.set_release()
                else:
                    temp = "None"
            else:
                # if getlinkstatus() is True:
                #     sleep(1)
                #     self.lock.set_acquire()
                #     temp = tuple(get_temperature())[3]
                #     self.lock.set_release()
            # else:
                temp = "None"
        except Exception as e:
            self.console.raise_text("Unable to retrieve the temperature.\n{}".format(e), 3)

        return temp

    def check_link(self):
        return getlinkstatus()

    # Camera Mode
    def standby_mode(self):
        self.set_temperature(15.00)
        self.fan.set_fan_off()

    def shooter_mode(self):
        self.set_temperature(-16.00)
        self.fan.set_fan_on()
        while self.get_temperature() < -15:
            sleep(1)

    # Shooters
    def start_taking_photo(self):
        try:
            if getlinkstatus() is True:
                self.continuousShooterThread.start_continuous_shooter()
                self.continuousShooterThread.start()
            else:
                self.console.raise_text("The camera is not connected", 3)
        except Exception as e:
            print(e)

    def stop_taking_photo(self):
        if getlinkstatus() is True:
            self.continuousShooterThread.stop_continuous_shooter()
        else:
            self.console.raise_text("The camera is not connected!", 3)

    def start_ephemeris_shooter(self):
        if getlinkstatus() is True:
            self.ephemerisShooterThread.start()
        else:
            self.console.raise_text("The camera is not connected!", 3)

    def stop_ephemeris_shooter(self):
        if getlinkstatus() is True:
            self.ephemerisShooterThread.stop_shooter()
        else:
            self.console.raise_text("The camera is not connected!", 3)

    # All PyQt Slots

    def eshooter_started(self):
        self.console.raise_text("Shooter Ephemeris Started!", 1)
        self.standby_mode()

    def eshooter_finished(self):
        self.console.raise_text('Shooter finalized', 1)

    def eshooter_observation_started(self):
        self.shooting = True
        self.console.raise_text("Observation Started", 1)

    def eshooter_observation_finished(self):
        self.console.raise_text("Observation Finalized", 1)
        self.standby_mode()
        self.shooting = False

    # Commands Slots
    def check_temp(self):
        if self.temp <= -15 or self.temp_contador == 60:
            self.ephemerisShooterThread.t = True
        else:
            self.console.raise_text("Temp_contador = " + str(self.temp_contador), 1)
            self.console.raise_text("CCD cooling to -15", 1)
            self.temp_contador += 1

    def connect_mainwindow_update(self):
        self.set_firmware_and_model_values()
        self.fan.refresh_fan_status()

    def eita(self):
        self.console.raise_text(self.commands.text, 1)
Beispiel #13
0
class Camera(metaclass=Singleton):
    '''
        classe de controle da camera
    '''
    def __init__(self):
        self.lock = Locker()
        self.console = ConsoleThreadOutput()
        self.settings = SettingsCamera()
        self.settings.setup_settings()
        self.fan = Fan()

        # Campos da janela principal para as informações da câmera
        self.firmware_field = None
        self.model_field = None

        self.main = Status()
        self.now_plus_10 = datetime.now()
        self.settedhour = datetime.now()
        self.continuousShooterThread = ContinuousShooterThread(
            int(self.settings.get_camera_settings()[4]))
        self.ephemerisShooterThread = EphemerisShooter()

        self.sthread = SThread()

        self.commands = CameraQThread(self)
        self.shooting = False
        # Initiating the Slots
        self.init_slots()

        self.info_ini = []

        info_ini = self.get_camera_settings_ini()
        self.aux_temperature = int(info_ini[0])

        self.temp = 0
        self.temp_contador = 0
        self.temp_contador_manual = 0

    def init_slots(self):
        # Ephemeris Shooter Slots
        self.ephemerisShooterThread.started.connect(self.eshooter_started)
        self.ephemerisShooterThread.finished.connect(self.eshooter_finished)
        self.ephemerisShooterThread.signal_started_shooting.connect(
            self.shooter_mode)
        self.ephemerisShooterThread.signal_temp.connect(self.check_temp)
        self.ephemerisShooterThread.continuousShooterThread.signal_temp.connect(
            self.check_temp)

        self.ephemerisShooterThread.continuousShooterThread.started.connect(
            self.eshooter_observation_started)
        self.ephemerisShooterThread.continuousShooterThread.finished.connect(
            self.eshooter_observation_finished)

        # Criando connect da temperatura
        # self.ephemerisShooterThread.continuousShooterThread.signalAfterShooting.connect()
        self.continuousShooterThread.signal_temp.connect(
            self.check_temp_manual)
        self.continuousShooterThread.finished.connect(self.standby_mode)

        # Camera Commands Slots
        self.commands.finished.connect(self.eita)
        self.commands.connectSignal.connect(self.connect_mainwindow_update)

    def get_firmware_and_model(self):
        info = self.get_info()
        return str(info[0]), str(info[2])[2:len(str(info[2])) - 1]

    def set_firmware_and_model_fields(self, firmwareField, modelField):
        self.firmware_field = firmwareField
        self.model_field = modelField

    def set_firmware_and_model_values(self):
        firmware, model = self.get_firmware_and_model()
        self.firmware_field.setText("Firmware: " + firmware)
        self.model_field.setText("Camera: " + model)

    def clear_firmware_and_model_values(self):
        self.firmware_field.setText("Firmware: ")
        self.model_field.setText("Camera: ")

    def get_info(self):
        '''
            Function to get the CCD Info
            This function will return [CameraFirmware, CameraType, CameraName]
        '''
        ret = None
        self.lock.set_acquire()
        try:
            ret = tuple(ccdinfo())
        except Exception as e:
            self.console.raise_text(
                "Failed to get camera information.\n{}".format(e))
        finally:
            self.lock.set_release()
        return ret

    def connect(self):
        try:
            a = open_driver()
            open_deviceusb()
            c = establishinglink()
            if a is True and c is True:
                self.console.raise_text("Open Device = {}".format(a), 2)
                self.console.raise_text("Established Link = {}".format(c), 2)
                self.console.raise_text("Successfully connected!", 2)
                self.set_firmware_and_model_values()
                '''
                    Fan Field sera atualizado automaticamente
                    atualizado pela thread de refresh temp.
                '''
                # self.fan.refresh_fan_status()
                return True
            else:
                self.console.raise_text("Connection error", 3)

        except Exception as e:
            self.console.raise_text(
                'Failed to connect the camera!\n{}'.format(e), 3)

        return False

    def disconnect(self):
        try:
            self.standby_mode()
            cd = close_device()
            cdr = close_driver()

            if cd and cdr:
                self.console.raise_text("Close Device = {}".format(cd), 2)
                self.console.raise_text("Close Driver = {}".format(cdr), 2)
                self.console.raise_text("Successfully disconnected", 2)
                self.clear_firmware_and_model_values()
            else:
                self.console.raise_text(
                    "Error disconnect! {} {}".format(cd, cdr), 3)
        except Exception as e:
            self.console.raise_text(
                "It failed to disconnect the camera!\n{}".format(e), 3)

    def set_temperature(self, value):
        if getlinkstatus() is True:
            self.lock.set_acquire()
            try:
                set_temperature(regulation=True,
                                setpoint=value,
                                autofreeze=False)
            except Exception as e:
                self.console.raise_text(
                    "Error setting the temperature.\n{}".format(e), 3)
            finally:
                self.lock.set_release()
                self.console.raise_text(
                    "Temperature set to {}°C".format(int(value)), 1)
        else:
            self.console.raise_text("The camera is not connected!", 3)

    def get_temperature(self):
        temp = "None"
        try:
            if getlinkstatus() is True:
                if not self.lock.is_locked():
                    self.lock.set_acquire()
                    temp = tuple(get_temperature())[3]
                    self.temp = temp
                    self.lock.set_release()
                else:
                    temp = "None"
            else:
                # if getlinkstatus() is True:
                #     sleep(1)
                #     self.lock.set_acquire()
                #     temp = tuple(get_temperature())[3]
                #     self.lock.set_release()
                temp = "None"
        except Exception as e:
            self.console.raise_text(
                "Unable to retrieve the temperature.\n{}".format(e), 3)

        return temp

    def check_link(self):
        return getlinkstatus()

    def get_camera_settings_ini(self):
        settings = SettingsCamera()
        info_ini = settings.get_camera_settings()
        return info_ini

    # Camera Mode
    def standby_mode(self):
        self.set_temperature(15.00)
        self.fan.set_fan_off()

    def shooter_mode(self):
        self.set_temperature(int(self.aux_temperature))
        self.fan.set_fan_on()
        self.console.raise_text(
            "Waiting temperature to " + str(self.aux_temperature) + "°C", 2)

    # Shooters
    def start_taking_photo(self):
        try:
            if getlinkstatus() is True:
                self.shooter_mode()
                self.continuousShooterThread.start_continuous_shooter()
                self.continuousShooterThread.start()
            else:
                self.console.raise_text("The camera is not connected", 3)
        except Exception as e:
            print(e)

    def stop_taking_photo(self):
        if getlinkstatus() is True:
            self.continuousShooterThread.stop_continuous_shooter()
        else:
            self.console.raise_text("The camera is not connected!", 3)

    def start_ephemeris_shooter(self):
        if getlinkstatus() is True:
            self.ephemerisShooterThread.start()
        else:
            self.console.raise_text("The camera is not connected!", 3)

    def stop_ephemeris_shooter(self):
        if getlinkstatus() is True:
            self.ephemerisShooterThread.stop_shooter()
        else:
            self.console.raise_text("The camera is not connected!", 3)

    # All PyQt Slots

    def eshooter_started(self):
        self.console.raise_text("Shooter Ephemeris Started!", 1)
        self.standby_mode()

    def eshooter_finished(self):
        self.console.raise_text('Shooter finalized\n', 1)

    def eshooter_observation_started(self):
        self.shooting = True
        self.console.raise_text("Observation Started", 1)

    def eshooter_observation_finished(self):
        self.console.raise_text("Observation Finalized", 1)
        self.standby_mode()
        self.continuousShooterThread.wait_temperature = False
        self.ephemerisShooterThread.wait_temperature = False
        self.ephemerisShooterThread.continuousShooterThread.wait_temperature = False
        self.temp_contador_manual = 0
        self.shooting = False

    # Commands Slots
    def check_temp_manual(self):
        '''
        funcao que espera temperatura setada ou tempo pre-determinada
        '''
        try:
            now = datetime.now()
            if self.temp_contador_manual == 0:
                self.now_plus_10 = datetime.now() + timedelta(minutes=10)
                self.temp_contador_manual += 2
            elif self.temp <= int(
                    self.aux_temperature) or now >= self.now_plus_10:
                self.continuousShooterThread.wait_temperature = True
                self.temp_contador_manual = 0
            else:
                self.temp_contador_manual += 2

        except Exception as e:
            print(e)

    def check_temp(self):
        '''
            funcao que espera temperatura setada ou tempo pre-determinada
        '''
        try:
            now = datetime.now()
            if self.temp_contador == 0:
                self.now_plus_10 = datetime.now() + timedelta(minutes=10)
                self.temp_contador += 1
            if self.temp <= int(
                    self.aux_temperature) or now >= self.now_plus_10:
                self.ephemerisShooterThread.wait_temperature = True
                self.ephemerisShooterThread.continuousShooterThread.wait_temperature = True

                self.temp_contador = 0
        except Exception as e:
            print(e)

    def connect_mainwindow_update(self):
        self.set_firmware_and_model_values()
        self.fan.refresh_fan_status()

    def eita(self):
        self.console.raise_text(self.commands.text, 1)
Beispiel #14
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()
        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.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
        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 (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.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.set_sleep_time(self.s)
        self.continuousShooterThread.start_continuous_shooter()
        self.continuousShooterThread.start()

    def stop_taking_photo(self):
        self.continuousShooterThread.stop_continuous_shooter()
Beispiel #15
0
 def get_camera_settings(self):
     settings = SettingsCamera()
     info = settings.get_camera_settings()
     return info
Beispiel #16
0
class SettingsCCDInfos(QWidget):
    def __init__(self, parent=None):
        super(SettingsCCDInfos, self).__init__(parent)

        # Instance attributes create_filter_wheel_info_group
        self.serial_filter_wheel_info_l = None
        self.serial_filter_wheel_info_f = None
        self.tempt_filter_wheel_info_l = None
        self.tempt_filter_wheel_info_f = None
        self.slots_filter_wheel_info_l = None
        self.slots_filter_wheel_info_f = None

        # Instance attributes create_filter_wheel_group
        self.shutter_l = None
        self.close_open_filter_wheel = None
        self.close_open_filter_wheel_info = None
        self.btn_set_shutter = None
        self.get_filter_l = None
        self.filter_position = None
        self.btn_set_filter = None
        self.set_filter_position = None
        self.btn_home_position_filter = None

        # Instance attributes create_ccd_info_group
        self.info_port_ccd_l = None
        self.info_port_ccd_f = None
        self.info_camera_model_l = None
        self.info_camera_model_f = None
        self.info_pixel_array_l = None
        self.info_pixel_array_f = None

        # Instance attributes create_ccd_camera_group
        self.close_open = None
        self.temp_set_point_l = None
        self.temp_set_point_f = None
        self.temp_init_l = None
        self.temp_init_f = None
        self.one_photoButton = None
        self.tempButton = None
        self.fanButton = None

        # Instance attributes create_push_button_group
        self.saveButton = None
        self.cancelButton = None
        self.clearButton = None

        self.select_filter_manual = 1
        self.select_filter_shutter = "Closed"

        self.imager_window = parent

        self.cam = Camera()

        self.roda_filtros = FilterControl()

        self.var_save_ini_camera = SettingsCamera()

        self.console = ConsoleThreadOutput()

        self.fan = Fan(self.fanButton)

        self.one_photo = SThread()

        self.lock = Locker()

        self.firmware = "????"
        self.model = "????"
        self.y_pixels = "????"
        self.x_pixels = "????"

        grid = QGridLayout()
        grid.addWidget(self.create_filter_wheel_info_group(), 0, 0)
        grid.addWidget(self.create_filter_wheel_group(), 1, 0)
        grid.addWidget(self.create_ccd_info_group(), 0, 1)
        grid.addWidget(self.create_ccd_camera_group(), 1, 1)
        grid.addWidget(self.create_push_button_group(), 2, 1)
        self.setLayout(grid)

        self.button_settings()

        self.setWindowTitle("Imager Box")
        self.resize(500, 340)
        self.info_cam()

    def create_filter_wheel_info_group(self):
        group_box = QGroupBox("&Filter Wheel Info")

        self.serial_filter_wheel_info_l = QtWidgets.QLabel("Serial Port: ", self)
        self.serial_filter_wheel_info_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

        try:
            motor_door_aux = str(self.roda_filtros.motor_door)
        except Exception as e:
            print(e)
            motor_door_aux = "???"

        self.serial_filter_wheel_info_f = QtWidgets.QLabel(motor_door_aux, self)
        self.serial_filter_wheel_info_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)

        self.slots_filter_wheel_info_l = QtWidgets.QLabel("Filter Slot: ", self)
        self.slots_filter_wheel_info_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
        self.slots_filter_wheel_info_f = QtWidgets.QLabel("6", self)
        self.slots_filter_wheel_info_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)

        self.tempt_filter_wheel_info_l = QtWidgets.QLabel("Filter Temperature: ", self)
        self.tempt_filter_wheel_info_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
        self.tempt_filter_wheel_info_f = QtWidgets.QLabel("25 °C", self)
        self.tempt_filter_wheel_info_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)

        group_box.setLayout(set_lvbox(set_hbox(self.serial_filter_wheel_info_l, self.serial_filter_wheel_info_f),
                                      set_hbox(self.slots_filter_wheel_info_l, self.slots_filter_wheel_info_f),
                                      set_hbox(self.tempt_filter_wheel_info_l, self.tempt_filter_wheel_info_f)))

        return group_box

    def create_filter_wheel_group(self):
        group_box = QGroupBox("&Filter Wheel Control")
        group_box.setCheckable(True)
        group_box.setChecked(False)
        self.shutter_l = QtWidgets.QLabel("Shutter status:", self)
        self.shutter_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
        self.close_open_filter_wheel_info = QtWidgets.QLabel("Closed")
        self.close_open_filter_wheel_info.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

        self.btn_set_shutter = QtWidgets.QPushButton('Set shutter', self)
        self.close_open_filter_wheel = QtWidgets.QComboBox(self)
        self.close_open_filter_wheel.setMaximumWidth(100)
        self.fill_combo_close_open_filter_wheel_shutter()

        filter_position = self.roda_filtros.get_current_filter()

        if filter_position == "None":
            filter_position = "1"

        self.get_filter_l = QtWidgets.QLabel('Current filter:', self)
        self.filter_position = QtWidgets.QLabel(filter_position)
        self.filter_position.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
        self.filter_position.setMinimumWidth(60)

        self.btn_set_filter = QtWidgets.QPushButton('Set filter', self)
        self.set_filter_position = QtWidgets.QComboBox(self)
        self.set_filter_position.setMaximumWidth(100)
        self.fill_combo_filter_position()

        self.btn_home_position_filter = QtWidgets.QPushButton('Home Reset', self)

        group_box.setLayout(set_lvbox(set_hbox(self.shutter_l, self.close_open_filter_wheel_info),
                                      set_hbox(self.btn_set_shutter, self.close_open_filter_wheel),
                                      set_hbox(self.get_filter_l, self.filter_position, stretch2=1),
                                      set_hbox(self.btn_set_filter, self.set_filter_position),
                                      set_hbox(self.btn_home_position_filter)))
        return group_box

    def create_ccd_info_group(self):
        group_box = QGroupBox("Info CCD")

        self.info_port_ccd_l = QtWidgets.QLabel("Camera Firmware: ", self)
        self.info_port_ccd_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
        self.info_port_ccd_f = QtWidgets.QLabel(self.firmware)
        self.info_port_ccd_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)

        self.info_camera_model_l = QtWidgets.QLabel("Camera Model: ", self)
        self.info_camera_model_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
        self.info_camera_model_f = QtWidgets.QLabel(self.model)
        self.info_camera_model_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)

        self.info_pixel_array_l = QtWidgets.QLabel("Pixel array: ", self)
        self.info_pixel_array_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
        self.info_pixel_array_f = QtWidgets.QLabel(self.x_pixels + " X " + self.y_pixels + " Pixels")
        self.info_pixel_array_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)

        group_box.setLayout(set_lvbox(set_hbox(self.info_port_ccd_l, self.info_port_ccd_f),
                                      set_hbox(self.info_camera_model_l, self.info_camera_model_f),
                                      set_hbox(self.info_pixel_array_l, self.info_pixel_array_f)))
        return group_box

    def create_ccd_camera_group(self):
        group_box = QGroupBox("Settings")
        group_box.setCheckable(True)
        group_box.setChecked(False)

        self.shutter_l = QtWidgets.QLabel("Shutter:", self)
        self.shutter_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
        self.close_open = QtWidgets.QLabel("Closed")
        self.close_open.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)

        self.temp_set_point_l = QtWidgets.QLabel("CCD Temp Set Point (°C):", self)
        self.temp_set_point_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
        self.temp_set_point_f = QtWidgets.QLineEdit(self)
        self.temp_set_point_f.setMaximumWidth(100)
        self.temp_set_point_f.setValidator(QIntValidator(-100, 30))

        self.temp_init_l = QtWidgets.QLabel("Tempo para iniciar(s):", self)
        self.temp_init_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
        self.temp_init_f = QtWidgets.QLineEdit(self)
        self.temp_init_f.setMaximumWidth(100)
        self.temp_init_f.setValidator(QIntValidator(0, 600))

        self.one_photoButton = QtWidgets.QPushButton('Take Photo', self)
        self.one_photoButton.clicked.connect(self.take_one_photo)

        self.tempButton = QtWidgets.QPushButton("Set Temp", self)
        self.tempButton.clicked.connect(self.btn_temperature)

        self.fanButton = QtWidgets.QPushButton("Fan (On/Off)")
        self.fanButton.clicked.connect(self.button_fan_func)

        self.setting_values()

        group_box.setLayout(set_lvbox(set_hbox(self.shutter_l, self.close_open),
                                      set_hbox(self.temp_set_point_l, self.temp_set_point_f),
                                      set_hbox(self.temp_init_l, self.temp_init_f),
                                      set_hbox(self.one_photoButton, self.tempButton, self.fanButton, stretch2=1)))
        return group_box

    def create_push_button_group(self):
        group_box = QGroupBox("&Push Buttons")
        # group_box.setCheckable(True)
        # group_box.setChecked(True)

        self.saveButton = QPushButton("Save")
        self.saveButton.clicked.connect(self.button_ok_func)

        self.cancelButton = QPushButton("Cancel")
        self.cancelButton.clicked.connect(self.func_cancel)

        self.clearButton = QPushButton("Clear")
        self.clearButton.clicked.connect(self.clear_all)

        group_box.setLayout(set_lvbox(set_hbox(self.saveButton, self.clearButton, self.cancelButton)))

        return group_box

    def get_info_pixels(self):
        # Function to get the CCD Info
        # This function will return [Pixels]

        ret = None
        self.lock.set_acquire()
        try:
            ret = tuple(ccdinfo())
        except Exception as e:
            self.console.raise_text("Failed to get camera information.\n{}".format(e))
        finally:
            self.lock.set_release()
        return ret

    def fill_combo_close_open_filter_wheel_shutter(self):
        self.close_open_filter_wheel.addItem("Closed", 2)
        self.close_open_filter_wheel.addItem("Opened", 1)

    def func_close_open_shutter(self):
        my_slot_close_open_shutter = self.close_open_filter_wheel.currentIndex()

        if my_slot_close_open_shutter == 0:
            self.roda_filtros.close_shutter()
            self.select_filter_shutter = "Closed"
            self.console.raise_text("Shutter Filter Wheel Closed", 1)
            self.close_open.setText("Closed")
            self.close_open_filter_wheel_info.setText("Closed")
        else:
            self.roda_filtros.open_shutter()
            self.select_filter_shutter = "Opened"
            self.console.raise_text("Shutter Filter Wheel Opened ", 1)
            self.close_open.setText("Opened")
            self.close_open_filter_wheel_info.setText("Opened")

    def fill_combo_filter_position(self):
        self.set_filter_position.addItem("1", 1)
        self.set_filter_position.addItem("2", 2)
        self.set_filter_position.addItem("3", 3)
        self.set_filter_position.addItem("4", 4)
        self.set_filter_position.addItem("5", 5)
        self.set_filter_position.addItem("6", 6)

    def func_filter_position(self):
        available_filters_list_and_commons = get_filter_settings()
        available_filters_list_and_commons = list(available_filters_list_and_commons)

        permited_filters = ''

        for x in available_filters_list_and_commons:
            permited_filters += str(x)

        try:
            if self.roda_filtros.connect_state:
                sleep(1)
                wish_filter_int = self.set_filter_position.currentIndex() + 1
                aux = 1
                for x in permited_filters:
                    if int(wish_filter_int) == int(x):
                        aux = 0

                if aux == 0:
                    self.roda_filtros.filter_wheel_control(int(wish_filter_int))
                else:
                    self.console.raise_text("There is no filter on slot number " + str(wish_filter_int) + "!", 3)
                    self.console.raise_text("Please include a new filter on the Filters Settings Menu!", 3)

                sleep(1)
        except Exception as e:
            print("def func_filter_position(self): -> " + str(e))

        finally:
            if aux == 0:
                if self.roda_filtros.connect_state:
                    self.select_filter_manual = wish_filter_int

                    self.filter_position.setText(str(wish_filter_int))
                    self.console.raise_text("Filter Position: {}".format(str(wish_filter_int)), 2)
                else:
                    self.filter_position.setText("?")
                    self.console.raise_text("Filter Wheel is not connect!", 3)

    def button_settings(self):
        self.btn_set_shutter.clicked.connect(self.func_close_open_shutter)
        self.btn_set_filter.clicked.connect(self.func_filter_position)
        self.btn_home_position_filter.clicked.connect(self.func_home_position)

    def func_home_position(self):
        try:
            if self.roda_filtros.connect_state:
                sleep(0.5)
                print("Home Position")
                self.roda_filtros.home_reset()
                sleep(1)
        except Exception as e:
            print(e)
        finally:
            if self.roda_filtros.connect_state:
                self.filter_position.setText("1")
                self.console.raise_text("Filter Position: 1", 2)
                self.console.raise_text("Shutter Filter Wheel Closed", 1)
                self.close_open.setText("Closed")
                self.close_open_filter_wheel_info.setText("Closed")
            else:
                self.filter_position.setText("?")
                self.console.raise_text("Filter Wheel is not connect!", 3)

    def get_values(self):
        return self.var_save_ini_camera.get_camera_settings()

    def setting_values(self):
        info = self.get_values()
        self.set_values(info[0], info[1])

    def set_values(self, temperature_camera, temp_init_f):
        self.temp_set_point_f.setText(temperature_camera)
        self.temp_init_f.setText(temp_init_f)

    def button_ok_func(self):
        try:
            self.var_save_ini_camera.set_camera_settings(self.temp_set_point_f.text(),
                                                         self.temp_init_f.text())

            self.var_save_ini_camera.save_settings()
            self.console.raise_text("Camera settings successfully saved!", 1)

        except Exception as e:
            print(e)

    def clear_all(self):
        self.temp_set_point_f.clear()
        self.temp_init_f.clear()

    def func_cancel(self):
        self.imager_window.close()

    def take_one_photo(self):
        try:
            if self.select_filter_shutter == "Closed":
                self.console.raise_text("AQUI dark photo", 1)
                self.cam.start_one_photo(self.select_filter_manual, self.select_filter_shutter)
                # self.one_photo.args_one_photo(self.select_filter_manual, self.select_filter_shutter)
                # self.one_photo.start()
            else:
                self.console.raise_text("AQUI photo", 1)
                self.cam.start_one_photo(self.select_filter_manual, self.select_filter_shutter)
        except Exception as e:
            self.console.raise_text("Not possible taking photo -> {}".format(e), 1)

    def button_fan_func(self):
        if getlinkstatus() is True:
            try:
                self.fan.set_fan()
                self.console.raise_text('State changed Fan!', 2)
            except Exception as e:
                self.console.raise_text("The camera is not connected!", 3)
                self.console.raise_text('State Fan unchanged', 3)
                self.console.raise_text("Exception -> {}".format(e))
        else:
            self.console.raise_text("The camera is not connected!", 3)
            self.console.raise_text('State Fan unchanged', 3)

    def btn_temperature(self):
        try:
            value = self.temp_set_point_f.text()
            if value is '':
                pass
            else:
                try:
                    self.cam.set_temperature(float(value))
                except TypeError:
                    self.cam.set_temperature(float(20.0))
        except Exception as e:
            print("Exception -> {}".format(e))

    def info_cam(self):
        try:
            if getlinkstatus() is True:
                self.firmware, self.model, self.y_pixels, self.x_pixels = \
                    self.cam.get_firmware_and_model_and_pixels()
            else:
                self.firmware, self.model, self.y_pixels, self.x_pixels = "????", "????", \
                                                                          "????", "????"

            self.info_port_ccd_f.setText(self.firmware)
            self.info_camera_model_f.setText(self.model)
            self.info_pixel_array_f.setText(str(self.y_pixels) + " x " + str(self.x_pixels))

        except Exception as e:
            print("CCDInfos get_firmware_and_model_and_pixels -> {}".format(e))
            self.firmware, self.model, self.y_pixels, self.x_pixels = "????", "????", \
                                                                      "????", "????"
Beispiel #17
0
class Shooter(QtWidgets.QWidget):
    """
    Class for Taking photo Widget
    """
    def __init__(self, parent=None):
        super(Shooter, self).__init__(parent)
        self.console = ConsoleThreadOutput()
        self.cam = Camera()
        self.cond = 0
        self.sref_calc = SettingsCamera()

        # Label for Image
        self.img = QtWidgets.QLabel(self)
        self.config_img_label()

        # Creating a Pallete
        self.pa = QtGui.QPalette()

        self.set_layout()
        self.link_signals()

    def log_ephem_infos(self):
        elevations = make_elevations_info()
        headers_camera = get_camera_settings()
        temp = SbigDriver.get_temperature()[3]
        set_temp = headers_camera[0]
        ephem_infos_1 = "Sun Elevation: " + str(elevations[2]) + "; Moon Elevation: " + str(elevations[1]) +\
                        "; Moon Phase: " + str(elevations[0])
        self.console.save_log(ephem_infos_1)
        time.sleep(1)
        ephem_infos_2 = "Camera Temperature: " + "{0:.2f}".format(temp) + "; Set Temperature: " +\
                        set_temp + "; Status Temp. Filtro: 25ºC"
        self.console.save_log(ephem_infos_2)

    def link_signals(self):
        self.cam.ephemerisShooterThread.continuousShooterThread.ss.finished.connect(
            self.get_image_automatic)
        self.cam.continuousShooterThread.ss.finished.connect(
            self.get_image_manual)

    def get_image_automatic(self):
        img = self.cam.ephemerisShooterThread.continuousShooterThread.ss.get_image_info(
        )
        self.set_image(img)

    def get_image_manual(self):
        img = self.cam.continuousShooterThread.ss.get_image_info()
        self.set_image(img)

    def set_layout(self):
        hb2 = set_hbox(self.prefix, self.date, self.hour)

        self.setLayout(set_lvbox(set_hbox(self.img), hb2))
        self.config_pallete()

    def config_img_label(self):
        self.img.setPixmap(QtGui.QPixmap("noimage.png"))
        self.img.setMaximumSize(425, 425)
        self.prefix = QtWidgets.QLabel(self)
        self.date = QtWidgets.QLabel(self)
        self.hour = QtWidgets.QLabel(self)

    def config_pallete(self):
        self.pa.setColor(QtGui.QPalette.Foreground,
                         QtCore.Qt.red)  # Setting the style
        self.prefix.setPalette(self.pa)
        self.date.setPalette(self.pa)
        self.hour.setPalette(self.pa)

    def shoot_function(self):
        self.cam.shoot(int(self.tb.text()), self.pre.text(),
                       int(self.combo.currentIndex()))
        self.set_image()

    def auto_shoot(self):
        try:
            self.cam.autoshoot(int(self.htext.text()), int(self.mtext.text()),
                               int(self.tb.text()), self.pre.text(),
                               int(self.combo.currentIndex()))
        except Exception as e:
            print(e)

    def set_image(self, img):
        print("Setting Pixmap")
        print("CCCCCCCCCCCCCCCCCCCCCCCCCCC")
        try:
            path = img.final_image_name

            # image = Image.open(path)]

            try:
                if os.path.splitext(path)[1] == '.fit':
                    print("1111111111111111111")
                    img = getdata(path)
                else:
                    print("222222222222222222222")
                    # img = skimage.io.imread('/home/cristiano')
                    img = skimage.io.imread(path)

                print("\n\n>>>>>>>>>>>>>>>>>>>>>>")
                print(img)

            except Exception as e:
                print("Exception os.path.splitext -> {}".format(e))
            image = img  #im

            sref_min = float(self.sref_calc.get_camera_settings()[6])
            sref_max = float(self.sref_calc.get_camera_settings()[7])

            img_hist_equal = Image_Processing.img_hist_equal(
                image, sref_min, sref_max)
            im3 = toimage(img_hist_equal)
            im4 = im3.resize((int(425), int(425)))
            im5 = Image_Processing.draw_image(im4, path)

            try:
                qim = ImageQt(im5)
                self.img.setPixmap(QtGui.QPixmap.fromImage(qim))
            except Exception as e:
                print(
                    "Exception setPixmap(QtGui.QPixmap(image_to_show)) -> {}".
                    format(e))

            print(path)
            self.log_ephem_infos()
        except Exception as e:
            print("Exception Setting Pixmap -> {}".format(e))

    def fill_combo(self):
        self.combo.addItem("1x1", 0)
        self.combo.addItem("2x2", 1)
        self.combo.addItem("3x3", 2)

    def clear_image_info(self):
        self.prefix.clear()
Beispiel #18
0
class SettingsWindow(QtWidgets.QWidget):
    def __init__(self, parent=None):
        super(SettingsWindow, self).__init__(parent)
        self.cam = SettingsCamera()
        self.camera = Camera()
        self.console = ConsoleThreadOutput()
        #self.a_temp_regulation = TempRegulation(self)
        self.create_cam_widgets()
        self.p = parent
        self.fan = Fan(self.fanButton)

        #self.button_clear = QtWidgets.QPushButton('Clear', self)

        self.setField_temperature = QtWidgets.QLineEdit(self)
        self.setting_values()

        self.setLayout(set_lvbox(set_hbox(self.setField_temperature_label, self.setField_temperature),
                                 set_hbox(self.pre, self.prel),
                                 set_hbox(self.exp, self.expl),
                                 set_hbox(self.binning, self.combo),
                                 set_hbox(self.tempo_fotos_label, self.tempo_fotos),
                                 set_hbox(self.tempButton, self.fanButton, stretch2=1),
                                 set_hbox(self.buttonok, self.button_clear, self.buttoncancel, stretch2=1)))

    def get_values(self):
        return self.cam.get_camera_settings()

    def setting_values(self):
        info = self.get_values()
        self.set_values(info[0], info[1], info[2], info[3], info[4])

    def set_values(self, temperature_camera, prefixo, exposicao, binning, tempo_entre_fotos):
        self.setField_temperature.setText(temperature_camera)
        self.prel.setText(prefixo)
        self.expl.setText(exposicao)
        try:
            b = int(binning)
        except:
            b = 0
        self.tempo_fotos.setText(tempo_entre_fotos)
        self.combo.setCurrentIndex(b)

    def create_cam_widgets(self):
        self.setField_temperature_label = QtWidgets.QLabel("Temperature:", self)
        self.pre = QtWidgets.QLabel("Filter:", self)
        self.prel = QtWidgets.QLineEdit(self)

        self.exp = QtWidgets.QLabel("Exposure time:", self)
        self.expl = QtWidgets.QLineEdit(self)

        self.binning = QtWidgets.QLabel("Binning:", self)
        self.combo = QtWidgets.QComboBox(self)
        self.fill_combo()

        self.button_clear = QtWidgets.QPushButton('Clear', self)
        self.button_clear.clicked.connect(self.clear_all)

        self.tempButton = QtWidgets.QPushButton("Set Temp", self)
        self.tempButton.clicked.connect(self.btn_temperature)

        self.fanButton = QtWidgets.QPushButton("Fan")
        self.fanButton.clicked.connect(self.button_fan_func)

        self.buttonok = QtWidgets.QPushButton("Save", self)
        self.buttonok.clicked.connect(self.button_ok_func)

        self.buttoncancel = QtWidgets.QPushButton("Cancel", self)
        self.buttoncancel.clicked.connect(self.func_cancel)

        self.tempo_fotos_label = QtWidgets.QLabel("Time between photos:", self)
        self.tempo_fotos = QtWidgets.QLineEdit(self)

    def button_ok_func(self):
        try:
            # Setting the Temperature
            '''value = self.setField_temperature.text()
            if value is '':
                value = 20
            self.camera.set_temperature(float(value))'''

            # Saving the Settings
            self.cam.set_camera_settings(self.setField_temperature.text(), self.prel.text(), self.expl.text(), self.combo.currentIndex(), self.tempo_fotos.text())
            self.cam.save_settings()
            self.console.raise_text("Camera settings successfully saved!", 1)
        except Exception as e:
            self.console.raise_text("Camera settings were not saved.", 3)
        finally:
            self.p.close()

    def clear_all(self):
        self.setField_temperature.clear()
        self.prel.clear()
        self.expl.clear()
        self.tempo_fotos.clear()

    def func_cancel(self):
        self.p.close()

    def button_fan_func(self):
        if getlinkstatus() is True:
            try:
                self.fan.set_fan()
                self.console.raise_text('State changed Fan!', 2)
            except Exception:
                self.console.raise_text("The camera is not connected!", 3)
                self.console.raise_text('State Fan unchanged', 3)
        else:
            self.console.raise_text("The camera is not connected!", 3)
            self.console.raise_text('State Fan unchanged', 3)

    def fill_combo(self):
        self.combo.addItem("1x1", 0)
        self.combo.addItem("2x2", 1)
        self.combo.addItem("3x3", 2)

    def btn_temperature(self):
            try:
                value = self.setField_temperature.text()
                if value is '':
                    pass
                else:
                    self.camera.set_temperature(float(value))
            except Exception as e:
                print("Exception -> {}".format(e))