def center(self):
t = QDesktopWidget().availableGeometry()
oneline = int((t.height() + t.top()) / 10)
self.resize(t.width(), t.height() + t.top())
self.move(0, 0)
self.lb1.move(15, oneline * 1.5)
self.lb1.resize(t.width() - 30, oneline)
self.lb2.move(15, oneline * 3.5)
self.lb2.resize(t.width() - 30, oneline)
self.lb3.move(15, oneline * 5.5)
self.lb3.resize(t.width() - 30, oneline)
self.lb4.move(15, oneline * 7.5)
self.lb4.resize(t.width() - 30, oneline)
def _init_gui(self):
self.setWindowFlags(Qt.FramelessWindowHint)
self.setWindowFlags(Qt.X11BypassWindowManagerHint)
self.setWindowState(Qt.WindowFullScreen)
self.setWindowFlags(Qt.WindowStaysOnTopHint)
self.setWindowModality(Qt.WindowModal)
self.bg="/usr/share/runomatic/rsrc/background2.png"
self.previousIcon=QtGui.QIcon.fromTheme("go-previous")
self.previousIcon=QtGui.QIcon.fromTheme("go-home")
btnPrevious=QPushButton()
btnPrevious.setObjectName("PushButton")
btnPrevious.setIcon(self.previousIcon)
btnPrevious.setIconSize(QSize(TAB_BTN_SIZE,TAB_BTN_SIZE))
self.sigmap_tabSelect.setMapping(btnPrevious,0)
btnPrevious.clicked.connect(self.sigmap_tabSelect.map)
self.homeIcon=QtGui.QIcon.fromTheme("go-home")
btnHome=QPushButton()
btnHome.setObjectName("PushButton")
btnHome.setIcon(self.homeIcon)
btnHome.setIconSize(QSize(TAB_BTN_SIZE,TAB_BTN_SIZE))
self.tab_id[0]={'index':self.id,'thread':0,'xephyr':None,'wid':0,'show':btnHome,'close':btnPrevious,'display':"%s"%os.environ['DISPLAY']}
self.closeIcon=QtGui.QIcon.fromTheme("window-close")
self.grab=False
self.setStyleSheet(self._define_css())
monitor=QDesktopWidget().screenGeometry(1)
self.move(monitor.left(),monitor.top())
cursor=QtGui.QCursor(Qt.PointingHandCursor)
self.setCursor(cursor)
self.showFullScreen()
def __init__(self, transparent):
super().__init__()
layout = QVBoxLayout()
self.label = QLabel("Secondary Window")
self.label.setStyleSheet("background:transparent;")
# create transparent layout
layout.addWidget(self.label)
self.setLayout(layout)
# self.setStyleSheet("background:white;")
if transparent:
self.setAttribute(Qt.WA_TranslucentBackground)
else:
self.setStyleSheet("background:white;")
# show the window on the second screen
if QDesktopWidget.screenCount(QDesktopWidget()) > 1:
monitor = QDesktopWidget().screenGeometry(1)
self.move(monitor.left(), monitor.top())
self.showMaximized()
self.setWindowFlags(Qt.FramelessWindowHint)
# to get the screen size
for displayNr in range(QDesktopWidget().screenCount()):
self.screen = QDesktopWidget().screenGeometry(displayNr)
self.secHeight = self.screen.height() - 40
self.secWidth = self.screen.width() - 40
self.setMinimumSize(self.secWidth, self.secHeight)
def showStream(self, screenNumber):
stream.show_content()
monitor = QDesktopWidget().screenGeometry(screenNumber)
stream.move(monitor.left(), monitor.top())
stream.showFullScreen()
mainWindow.show_results_button.setText('Завершить трансляцию')
self.close()
def create_gui(self):
outer_frame = QWidget()
outer_layout = QVBoxLayout()
outer_layout.addWidget(self.create_frame_top())
middle_frame = QWidget()
middle_layout = QHBoxLayout()
middle_layout.setContentsMargins(0, 0, 0, 0)
# middle_layout.addWidget(self.create_frame_left())
middle_layout.addWidget(self.create_frame_central())
middle_layout.addWidget(self.create_frame_right())
middle_frame.setLayout(middle_layout)
outer_layout.addWidget(middle_frame)
outer_layout.addWidget(self.create_frame_bottom())
outer_frame.setLayout(outer_layout)
self.main_window.setCentralWidget(outer_frame)
self.main_window.setWindowTitle(self.config["window.title"])
# in development, 1=left monitor
monitor = QDesktopWidget().screenGeometry(1)
self.main_window.move(monitor.left() + 1300, monitor.top() + 0)
self.main_window.showMaximized()
def center(self):
# get screen coordinate system
screen = QDesktopWidget().screenGeometry()
# get window coordinate system
window = self.geometry()
# calculate the site
new_left = (screen.width() - window.width()) / 2
new_top = (screen.top() - window.top()) / 2
# move the window
self.move(new_left, new_top)
def main():
widget = QMainWindow() # define your widget
image = QImage(f"{PATTERNS_PATH}/{patterns[0]}")
label.setPixmap(QPixmap.fromImage(image))
widget.setCentralWidget(label)
monitor = QDesktopWidget().screenGeometry(display_monitor)
widget.move(monitor.left(), monitor.top())
widget.showFullScreen()
threading.Thread(target=network_thread).start()
app.exec_()
def initUI(self):
global displayed
QSound.play("sounds/shutter.wav")
self.pressed = False
QApplication.setOverrideCursor(Qt.CrossCursor)
# Create widget
self.l_imFullscreen = QLabel(self)
self.l_mousePos = QLabel(self)
self.l_dimensions = QLabel(self)
font = QFont("Calibri", 15)
self.l_dimensions.setFont(font)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.showFullscreenshotMenu)
self.setTextLabelPosition(0, 0)
setMouseTracking(self, True)
self.rect_x1 = self.rect_y1 = self.rect_x2 = \
self.rect_y2 = self.line_x = self.line_y = 0
im = screenshot()
# Remove alpha
self.im = removeAlpha(im)
h, w, c = self.im.shape
print('New shape: {},{},{}'.format(h, w, c))
qImg = QImage(self.im, w, h, QImage.Format_RGB888).rgbSwapped()
pixmap = QPixmap.fromImage(qImg)
self.l_imFullscreen.setPixmap(pixmap)
self.l_imFullscreen.resize(pixmap.width(), pixmap.height())
self.overlay = overlay(self.l_imFullscreen)
self.overlay.resize(pixmap.width(), pixmap.height())
print("Overlay size: {}, {}".format(
self.overlay.frameGeometry().width(),
self.overlay.frameGeometry().height()))
setMouseTracking(self, True)
monitor = QDesktopWidget().screenGeometry(-1)
self.move(monitor.left(), monitor.top())
displayed = True
self.showFullScreen()
def _run_qt(self):
"""Initialise the slm.
Open the connection and initialize main parameters.
"""
self.app = QApplication([])
self.label = QLabel()
self.widget = QMainWindow() # define your widget
zero = np.zeros((self.Nx, self.Ny))
image = QImage(zero, self.Nx, self.Ny, QImage.Format_Grayscale8)
self.label.setPixmap(QPixmap(image))
self.widget.setCentralWidget(self.label)
monitor = QDesktopWidget().screenGeometry(self.display_monitor)
self.widget.move(monitor.left(), monitor.top())
self.widget.showFullScreen()
# TODO: Test if thread is necessary and works.
self.app.exec_()
def _run_qt(self):
"""Initialise the slm.
Open the connection and initialize main parameters.
"""
self.app = QApplication(sys.argv)
self.label = QLabel()
widget = QMainWindow() # define your widget
image = QImage(f"{self.patterns_path}/{self.patterns[0]}")
self.label.setPixmap(QPixmap.fromImage(image))
widget.setCentralWidget(self.label)
monitor = QDesktopWidget().screenGeometry(self.display_monitor)
widget.move(monitor.left(), monitor.top())
widget.showFullScreen()
# TODO: Test if thread is necessary and works.
self.app.exec_()
def __init__(self, parent=None):
super().__init__(parent)
super().setupUi(self)
self.bible = Bible()
self.bible.listener = self.bible_listener
self.configuracoes_window = ConfiguracoesWindow()
self.projetor_window = ProjetorWindow()
monitor = QDesktopWidget().screenGeometry(2)
self.projetor_window.move(monitor.left(), monitor.top())
self.versoesComboBox.addItems(self.bible.get_versoes())
self.pesquisarButton.clicked.connect(self.pesquisar)
self.projetarButton.clicked.connect(self.projetar)
self.atualizarButton.clicked.connect(self.atualizar_texto_projetor)
self.configuracoesButton.clicked.connect(self.show_configuracoes)
self.pesquisaLineEdit.returnPressed.connect(self.pesquisar)
self.versoesComboBox.currentTextChanged.connect(self.atualizar_versao)
def main() -> None:
import sys
app = QApplication(sys.argv)
screen_count = QDesktopWidget().screenCount()
info_app = InfoPad(screen_count)
# Register hotkeys
keybinder.init()
keybinder.register_hotkey(info_app.winId(), "Ctrl+F13", info_app.grid_sd)
keybinder.register_hotkey(info_app.winId(), "Ctrl+F14", info_app.grid_su)
keybinder.register_hotkey(info_app.winId(), "Ctrl+F15", info_app.grid_9)
keybinder.register_hotkey(info_app.winId(), "Ctrl+F16", info_app.grid_1)
keybinder.register_hotkey(info_app.winId(), "Ctrl+F17", info_app.grid_2)
keybinder.register_hotkey(info_app.winId(), "Ctrl+F18", info_app.grid_3)
keybinder.register_hotkey(info_app.winId(), "Ctrl+F19", info_app.grid_4)
keybinder.register_hotkey(info_app.winId(), "Ctrl+F20", info_app.grid_5)
keybinder.register_hotkey(info_app.winId(), "Ctrl+F21", info_app.grid_6)
keybinder.register_hotkey(info_app.winId(), "Ctrl+F22", info_app.grid_7)
keybinder.register_hotkey(info_app.winId(), "Ctrl+F23", info_app.grid_8)
keybinder.register_hotkey(info_app.winId(), "Ctrl+Alt+F13", info_app.grid_home)
keybinder.register_hotkey(info_app.winId(), "Ctrl+Alt+F14", info_app.grid_mm)
keybinder.register_hotkey(info_app.winId(), "Ctrl+Alt+F15", info_app.grid_ou)
keybinder.register_hotkey(info_app.winId(), "Ctrl+Alt+F16", info_app.grid_od)
keybinder.register_hotkey(info_app.winId(), "Ctrl+Alt+F17", info_app.grid_view_o)
# Install native event filter
win_event_filter = WinEventFilter(keybinder)
event_dispatcher = QAbstractEventDispatcher.instance()
event_dispatcher.installNativeEventFilter(win_event_filter)
# If three monitors detected, move window to thirds screen and make it fullscreen
if screen_count == 3:
monitor = QDesktopWidget().screenGeometry(2)
info_app.move(monitor.left(), monitor.top())
info_app.showFullScreen()
sys.exit(app.exec_())
textEdit.setMaximumHeight(45)
gridLayout.addWidget(textEdit, 0, 0, 1, 3)
btnNext = QPushButton("Next", self)
# btnNext.setGeometry(QtCore.QRect(100,100,150,50))
btnNext.setIcon(QtGui.QIcon("droite-80.png"))
btnNext.setIconSize(QtCore.QSize(35, 35))
btnNext.setMaximumHeight(45)
gridLayout.addWidget(btnNext, 1, 0)
btnRecall = QPushButton("Recall", self)
btnRecall.setIcon(QtGui.QIcon("refresh.png"))
btnRecall.setIconSize(QtCore.QSize(35, 35))
btnRecall.setMaximumHeight(45)
gridLayout.addWidget(btnRecall, 1, 1)
btnCancel = QPushButton('Cancel', self)
btnCancel.setIcon(QtGui.QIcon("cancel.png"))
btnCancel.setIconSize(QtCore.QSize(35, 35))
btnCancel.setMaximumHeight(45)
gridLayout.addWidget(btnCancel, 1, 2)
self.groupBox.setLayout(gridLayout)
if __name__ == "__main__":
App = QApplication(sys.argv)
window = MainWindow()
monitor = QDesktopWidget().screenGeometry(1)
window.move(monitor.left(), monitor.top())
window.show()
sys.exit(App.exec())
# -*- coding: utf-8 -*-
"""
Created on Thu Dec 22 13:36:40 2016
@author: Serj
"""
import sys, os
sys.path.append(os.path.dirname(os.path.realpath(__file__))[:-16])
#sys.path.append('C:/science/python')
#sys.path.append('/media/serj/3078FE3678FDFB04/science/python')
import spectro.sviewer.sviewer as sv
from PyQt5.QtWidgets import (QApplication, QDesktopWidget)
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = sv.sviewer()
if 0:
monitor = QDesktopWidget().screenGeometry(2)
print(monitor)
ex.move(monitor.left(), monitor.top())
ex.resize(monitor.width(), monitor.height())
#ex.showFullScreen()
sys.exit(app.exec_())
def item_images_clicked(self, item):
global curframe
UUID2 = []
Title = []
path1 = self.directoryPath + '/data/Content/'
actual_filename = []
for entry in self.data_entries:
actual_filename.append(entry)
test = item
print("test", test)
test = test.replace("\n", " ")
print("FFFFFFFFFFFFFFFFf", test)
with open('json_received.json') as f:
data = json.load(f)
for data in data:
if data['CONTENTTITLE'] == test:
print("File_name if image clicked =", data['CONTENTUUID'])
Item = data['CONTENTITEM']
print("Item1", Item)
Item1 = Item.split(".")
print("Item1[1]", Item1[1])
test0 = data['CONTENTUUID'] + "." + Item1[1]
test1 = test0
print("test1", test1)
test1 = test1.split(".")
a = glob.glob(path1 + test1[0] + ".*")
print("value of A " + str(a))
print(a[0])
L = a[0].split(".")
if (curframe == 0):
self.uiV = Ui_VideoWindow()
widget = self.uiV # define your widget
display_monitor = 1 # the number of the monitor you want to display your widget
monitor = QDesktopWidget().screenGeometry(display_monitor)
widget.move(monitor.left(), monitor.top())
widget.showFullScreen()
self.uiV.videoframe.showFullScreen()
sizeObject = QtWidgets.QDesktopWidget().screenGeometry(-1)
print(" Screen size : " + str(sizeObject.height()) + "x" +
str(sizeObject.width()))
self.uiV.label.setGeometry(
QtCore.QRect(0, 0, sizeObject.width(), sizeObject.height()))
self.uiV.label.hide()
#self.window = QtWidgets.QMainWindow()
if L[1] == "mp4":
if (curframe == 0):
curframe = 1
print("Changing from 0 to 1 from mp4")
if (curframe == 2):
try:
print("Changing image frame to video")
#self.uiV.photo_label.hide()
self.uiV.label.hide()
curframe = 1
except:
pass
#self.uiV = Ui_VideoWindow()
PATH2 = a[0]
self.uiV.Path(PATH2)
self.uiV.mediaplayer.play()
else:
if (curframe == 0):
try:
self.uiV.label.showFullScreen()
curframe = 2
print("image current frame photo set 0 to 2")
except:
pass
else:
print("Passing 3")
if (curframe == 1):
try:
self.uiV.label.showFullScreen()
self.uiV.mediaplayer.stop()
curframe = 2
print("current frame 2 from 1")
except:
pass
else:
print("passing 4")
# display_monitor = 1 # the number of the monitor you want to display your widget
# monitor = QDesktopWidget().screenGeometry(display_monitor)
# widget = self.uiV # define your widget
# widget.showFullScreen()
# widget.move(monitor.left(), monitor.top())
#self.uiV.videoframe.showFullScreen()
#self.uiV.label.showFullScreen()
#self.uiV.videoframe.hide()
# self.uiV.mediaplayer.stop()
print(self.uiV.size())
sizeObject = QtWidgets.QDesktopWidget().screenGeometry(-1)
print(" Screen size : " + str(sizeObject.height()) + "x" +
str(sizeObject.width()))
self.uiV.label.setPixmap(
QtGui.QPixmap(a[0]).scaled(self.uiV.size(),
QtCore.Qt.KeepAspectRatio))
def __init__(self):
super().__init__()
self.setupUi(self)
#Tela secundaria
self.telaSecundaria = QtWidgets.QWidget()
self.telaSecundaria.setStyleSheet("background-color: rgb(0, 0, 0);")
self.frameVideo.setStyleSheet("background-color: rgb(0, 0, 0);")
# dialogo para o link do youtube
self.inputYoutube = QtWidgets.QInputDialog()
self.inputYoutube.textValueSelected.connect(self.linkMidia)
#Tela principal
self.listaDeMidia = []
self.botaoAdicionar.clicked.connect(self.adicionarExterno) # conector botaoAdicionar para função adicionarExterno
self.botaoRemover.clicked.connect(self.removerItemDePlayList) # conector botaoRemover para função removerItemDePlayList
self.listaPlaylist.itemClicked.connect(self.itemclicadoPlayList) # conector listaPlaylist para função removerItemDePlayList
self.listaPlaylist.itemDoubleClicked.connect(self.midiaParaReproduzirVindoDaLista)
self.botaoVolume.clicked.connect(self.mutar)
self.botaoPlay.clicked.connect(self.play)
self.botaoStop.clicked.connect(self.stop)
#self.slideVolume.sliderMoved.connect(self.volume)
self.slideMusica.sliderPressed.connect(self.slidePressed)
self.slideMusica.sliderReleased.connect(self.slideReleased)
self.slideMusica.sliderMoved.connect(self.mudartempo)
self.comboMusica.activated.connect(self.mudarFaixaDeAudio)
self.comboLegenda.activated.connect(self.mudarFaixaDeLegenda)
self.areaBusca.returnPressed.connect(self.busca)
self.listaBanco.itemDoubleClicked.connect(self.midiaParaReproduzirVindoDoBanco)
self.botaoAdicionar_2.clicked.connect(self.itemDoBancoParaPlaylist)
self.listaBanco.itemClicked.connect(self.itemClicadoBanco)
self.botaoRedimencionar.clicked.connect(self.redimencionar)
self.botaoPlayList.clicked.connect(self.playList)
self.listaTrecho.setVisible(False)
self.botaoIniciarPlayback.clicked.connect(self.botao_iniciar_playback_clicado)
self.botaoYoutube.clicked.connect(self.adicionarFromYoutube)
self.slideMusicaPressionado = 0
self.botaoRedimencionarEstado = 0
self.ativarPlayList = False
self.botaoIniciarPB_clicado = False
self.audios = False
self.legendas = False
#atalhos no techado
atalhoPlay = QShortcut(QtGui.QKeySequence("space"), self)
atalhoPlay.activated.connect(self.play)
atalhoStop = QShortcut(QtGui.QKeySequence("s"), self)
atalhoStop.activated.connect(self.stop)
atalhoSairColetanea = QShortcut(QtGui.QKeySequence("esc"), self)
atalhoSairColetanea.activated.connect(self.voltar_coletanea)
#reprodutor
self.player = vlc.Instance()
self.mediaList = self.player.media_list_new()
self.mediaInstancia = self.player.media_list_new()
self.reprodutorInstance2 = self.player.media_player_new()
self.reprodutorInstance = self.player.media_player_new()
if sys.platform.startswith('linux'): # para linux X Server
self.reprodutorInstance2.set_xwindow(self.telaSecundaria.winId())
self.reprodutorInstance.set_xwindow(self.frameVideo.winId())
elif sys.platform == "win32": # para Windows
self.reprodutorInstance2.set_hwnd(self.telaSecundaria.winId())
self.reprodutorInstance.set_hwnd(self.frameVideo.winId())
elif sys.platform == "darwin": # para MacOS
self.reprodutorInstance.set_nsobject(int(self.frameVideo.winId()))
self.reprodutorInstance2.set_nsobject(int(self.telaSecundaria.winId()))
self.reprodutorInstance.stop()
self.reprodutorInstance.audio_set_volume(100)
self.reprodutorInstancePlayList = vlc.MediaListPlayer()
self.reprodutorInstancePlayList.set_media_list(self.mediaList)
self.reprodutorInstancePlayList.set_media_player(self.reprodutorInstance)
self.reprodutorInstancePlayListExterno = vlc.MediaListPlayer()
self.reprodutorInstancePlayListExterno.set_media_list(self.mediaList)
self.reprodutorInstancePlayListExterno.set_media_player(self.reprodutorInstance2)
#lista a tela secundaria do sistema
display_monitor = len(QtGui.QGuiApplication.screens()) #quantas telas tem no sistema
monitor = QDesktopWidget().screenGeometry(1) #propriedades do monitor
self.telaSecundaria.move(monitor.left(), monitor.top()) #informando para a tela secundaria qual monitor aparecerá
#Eventos
event_manager = self.reprodutorInstance2.event_manager()
event_manager.event_attach(vlc.EventType.MediaPlayerPlaying, self.reproduzindo)
event_manager.event_attach(vlc.EventType.MediaPlayerMuted, self.mute)
event_manager.event_attach(vlc.EventType.MediaPlayerPositionChanged,self.tempo)
event_manager.event_attach(vlc.EventType.MediaPlayerEndReached,self.fimdaReproducao)
#Timer
self.timer = QTimer(self)
def create_gui(self):
sender_frame = QFrame()
sender_frame.setFrameStyle(QFrame.StyledPanel)
sender_layout = QHBoxLayout()
enable_cb = QCheckBox("Enable Gcode Sending")
enable_cb.stateChanged.connect(self.changed_enable_state)
enable_cb.setChecked(self.gcode_sender_enable)
sender_layout.addWidget(enable_cb)
sender_frame.setLayout(sender_layout)
outer_frame = QWidget()
outer_layout = QHBoxLayout()
left_frame = QWidget()
left_frame.setMinimumWidth(400)
left_layout = QVBoxLayout()
left_layout.setContentsMargins(0, 0, 0, 0)
left_layout.addWidget(SerialConnectionWidget(pendant=self))
left_layout.addWidget(sender_frame)
left_layout.addWidget(self.gcode_log)
# tabbed pane for system log and stdin
tabs = QTabWidget()
tabs.addTab(self.log_object, "System Log")
tabs.addTab(self.stdin_log, self.stdin_log.title)
left_layout.addWidget(tabs)
left_frame.setLayout(left_layout)
right_frame = QFrame()
right_layout = QVBoxLayout()
right_layout.setContentsMargins(0, 0, 0, 0)
right_layout.addWidget(ProbeFrame(pendant=self))
right_layout.addWidget(
NotifyFrame(pendant=self, notify_manager=self.notify_manager))
emu_frame = PendantEmulator(pendant=self)
self.add_client_msg_receiver(emu_frame)
right_layout.addWidget(emu_frame)
right_frame.setLayout(right_layout)
outer_layout.addWidget(left_frame)
outer_layout.addWidget(right_frame)
outer_frame.setLayout(outer_layout)
self.main_window.setCentralWidget(outer_frame)
self.main_window.setWindowTitle("HC Pendant 2020")
if self.config.getboolean("window_position"):
print("setting window position")
monitor = QDesktopWidget().screenGeometry(
int(self.config["window_monitor"]))
self.main_window.move(
monitor.left() + int(self.config["window_x"]),
monitor.top() + int(self.config["window_y"]))
else:
print(
"config says don't set window position, allowing default to continue"
)
self.main_window.show()
class ScreenDisplayFringe(QMainWindow):
def __init__(self,
monitor_number=2,
shift_orientation=1.35,
scale=1.0,
update_time=100,
wavelength=0.561,
NA=0.75,
magnification=40,
tune_scale=40):
super().__init__()
self.writeUpdateTime(update_time)
self.monitor_number = monitor_number
self.orientation = shift_orientation # pi/18
self.scale = scale # 2*pi/32
self.counter = 0
self.monitor = QDesktopWidget().screenGeometry(self.monitor_number)
self.move(self.monitor.left(), self.monitor.top())
self.wavelength = wavelength
self.NA = NA
self.M = magnification
self.factor = tune_scale
self.img = np.zeros([self.monitor.height(), self.monitor.width(), 7])
self.img488_2b = self.twoBeamGenerator(0.488)
self.img561_2b = self.twoBeamGenerator(0.561)
self.setPatterns(wavelength)
self.screen = QLabel(self)
self.setCentralWidget(self.screen)
self.timer = QTimer(self)
self.timer.timeout.connect(self.displayFrame)
def writeUpdateTime(self, update_time):
self._update_time = update_time
def getScreenWidth(self):
return self.monitor.width()
def getScreenHeight(self):
return self.monitor.height()
def enableTimer(self):
self.counter = 0
self.timer.start(self._update_time)
print('Display once')
def disableTimer(self):
self.timer.stop()
def changeTimer(self, update_time):
self.timer.setInterval(update_time)
def displayFrameN(self, frame_number):
'Display a selected pattern'
img_n = self.img[:, :, frame_number]
img_buffer = QtGui.QImage(img_n.data.tobytes(), img_n.shape[1],
img_n.shape[0],
QtGui.QImage.Format_Grayscale8)
self.screen.setPixmap(QtGui.QPixmap(img_buffer))
self.showFullScreen()
self.show()
def displayFrame(self):
'Display the patterns in a sequential mode'
if self.counter >= self.img.shape[2]:
self.counter = 0
print(self.counter)
img_n = self.img[:, :, self.counter]
img_buffer = QtGui.QImage(img_n.data.tobytes(), img_n.shape[1],
img_n.shape[0],
QtGui.QImage.Format_Grayscale8)
self.screen.setPixmap(QtGui.QPixmap(img_buffer))
self.counter += 1
def twoBeamGenerator(self, wavelength):
w = self.monitor.width()
h = self.monitor.height()
img = np.ones([h, w, 7])
X, Y = np.meshgrid(np.linspace(0, w, w), np.linspace(0, h, h))
scalefactor = self.factor * self.NA * self.scale / wavelength / self.M
for i in range(3):
phi = X * cos(-self.orientation - i * 2 * pi / 3 +
pi / 3) * scalefactor + Y * sin(
-self.orientation - i * 2 * pi / 3 +
pi / 3) * scalefactor # self.orientation = 1.36
img[:, :, i] = 255 * (cos(phi) > 0.0)
return np.require(img, np.uint8, 'C')
def setPatterns(self, wavelength):
self.wavelength = wavelength
if self.wavelength == 0.488:
self.img = self.img488_2b
elif self.wavelength == 0.561:
self.img = self.img561_2b
def keyPressEvent(self, input):
if input.key() == Qt.Key_Escape:
self.close()
class ScreenDisplay(QMainWindow):
def __init__(self,
monitor_number=2,
shift_orientation=pi / 18,
scale=1.5,
update_time=100,
wavelength=0.561,
NA=1.1,
magnification=60,
tune_scale=40):
super().__init__()
self.writeUpdateTime(update_time)
self.monitor_number = monitor_number
self.orientation = shift_orientation # pi/18
self.scale = scale # 2*pi/32
self.counter = 0
self.monitor = QDesktopWidget().screenGeometry(self.monitor_number)
self.move(self.monitor.left(), self.monitor.top())
self.wavelength = wavelength
self.NA = NA
self.M = magnification
self.factor = tune_scale
# self.img = self.imgGenerate()
self.img = np.zeros([self.monitor.height(), self.monitor.width(), 7])
self.img488 = self.imgGenerator(0.488)
self.img561 = self.imgGenerator(0.561)
# self.img488_2b = self.twoBeamGenerator(0.488)
# self.img561_2b = self.twoBeamGenerator(0.561)
self.setPatterns(wavelength)
# self.img = self.imgRead()
self.screen = QLabel(self)
self.setCentralWidget(self.screen)
self.timer = QTimer(self)
self.timer.timeout.connect(self.displayFrame)
def writeUpdateTime(self, update_time):
self._update_time = update_time
def getScreenWidth(self):
return self.monitor.width()
def getScreenHeight(self):
return self.monitor.height()
def enableTimer(self):
self.counter = 0
self.timer.start(self._update_time)
print('Display once')
def disableTimer(self):
self.timer.stop()
def changeTimer(self, update_time):
self.timer.setInterval(update_time)
def displayFrameN(self, frame_number):
'Display a selected pattern'
img_n = self.img[:, :, frame_number]
img_buffer = QtGui.QImage(img_n.data.tobytes(), img_n.shape[1],
img_n.shape[0],
QtGui.QImage.Format_Grayscale8)
self.screen.setPixmap(QtGui.QPixmap(img_buffer))
self.showFullScreen()
self.show()
def displayFrame(self):
'Display the patterns in a sequential mode'
if self.counter >= self.img.shape[2]:
self.counter = 0
print(self.counter)
img_n = self.img[:, :, self.counter]
img_buffer = QtGui.QImage(img_n.data.tobytes(), img_n.shape[1],
img_n.shape[0],
QtGui.QImage.Format_Grayscale8)
self.screen.setPixmap(QtGui.QPixmap(img_buffer))
self.counter += 1
# def imgGenerate(self):
# 'Generate the polka pattern'
# w = self.monitor.width()
# h = self.monitor.height()
# X, Y = np.meshgrid(np.linspace(0, w, w), np.linspace(0, h, h))
# scalefactor = self.factor*self.NA*self.scale/self.wavelength/self.M
# p = 4 * pi / sqrt(3) / scalefactor
# r0 = 0.33 * p
# img = np.ones([h,w,7])
# # 40. * NA * scalefactor / 0.532 / M
# # print("Orientation:",self.orientation,"Scalefactor:",scalefactor)
# st = time.time()
# for i in range (7):
# phase = i * 2 * pi / 7
# xr = -X * sin(-self.orientation) + Y * cos(-self.orientation) - 1.0 * p * phase / (2 * pi)
# yr = -X * cos(-self.orientation) - Y * sin(-self.orientation) + 2.0 / sqrt(3) * p * phase / (2 * pi)
# yi = floor(yr / (p * sqrt(3) / 2) + 0.5)
# xi = floor((xr / p) - (yi % 2.0) / 2.0 + 0.5) + (yi % 2.0) / 2.0
# y0 = yi * p * sqrt(3) / 2
# x0 = xi * p
# r = sqrt((xr - x0) ** 2 + (yr - y0) ** 2)
# img[:, :, i] = 255*(r < r0)
# print(time.time()-st)
# return np.require(img, np.uint8, 'C')
#''' Remove the hash to switch to original code
def imgGenerator(self, wavelength): # Modified 10/06/2021
'Generate the polka pattern'
w = self.monitor.width()
h = self.monitor.height()
orientation = self.orientation
X, Y = np.meshgrid(np.linspace(0, w, w), np.linspace(0, h, h))
scalefactor = self.factor * self.NA * self.scale / wavelength / self.M
p = 4 * pi / 3**.5 / scalefactor
r0 = 0.33 * p
# img = np.ones([h,w,7], dtype=np.uint8)
img = []
print("Orientation:", self.orientation, "Scalefactor:", scalefactor)
# st = time.time()
Xs = X * sin(-orientation)
Yc = Y * cos(-orientation)
Xc = X * cos(-orientation)
Ys = Y * sin(-orientation)
for i in range(7):
phase = i * 2 * pi / 7
xr = -Xs + Yc - 1.0 * p * phase / (2 * pi)
yr = -Xc - Ys + 2.0 / 3**.5 * p * phase / (2 * pi)
yi = floor(yr / (p * 3**.5 / 2) + 0.5).astype('int')
# temp = yi % 2 / 2.0
temp = (yi & 1) / 2.0
xi = floor((xr / p) - temp + 0.5) + temp
y0 = yi * (p * 3**.5 / 2)
x0 = xi * p
r = (xr - x0)**2 + (yr - y0)**2
img.append(255 * (r < r0**2))
img = np.array(img, dtype=np.uint8).transpose((1, 2, 0))
return np.require(img, np.uint8, 'C')
''' # Original
def o_imgGenerator(self, wavelength):
'Generate the polka pattern'
w = self.monitor.width()
h = self.monitor.height()
orientation = self.orientation
X, Y = np.meshgrid(np.linspace(0, w, w), np.linspace(0, h, h))
scalefactor = self.factor*self.NA*self.scale/wavelength/self.M
p = 4 * pi / sqrt(3) / scalefactor
r0 = 0.33 * p
img = np.ones([h,w,7])
print("Orientation:",self.orientation,"Scalefactor:",scalefactor)
# st = time.time()
Xs = X * sin(-orientation)
Yc = Y * cos(-orientation)
Xc = X * cos(-orientation)
Ys = Y * sin(-orientation)
for i in range (7):
phase = i * 2 * pi / 7
xr = -Xs + Yc - 1.0 * p * phase / (2 * pi)
yr = -Xc - Ys + 2.0 / sqrt(3) * p * phase / (2 * pi)
yi = floor(yr / (p * sqrt(3) / 2) + 0.5)
xi = floor((xr / p) - (yi % 2.0) / 2.0 + 0.5) + (yi % 2.0) / 2.0
y0 = yi * p * sqrt(3) / 2
x0 = xi * p
r = sqrt((xr - x0) ** 2 + (yr - y0) ** 2)
img[:, :, i] = 255*(r < r0)
# print(time.time() - st)
return np.require(img, np.uint8, 'C')
#'''
#''' Remove the hash to switch to original code
def twoBeamGenerator(self, wavelength): # Modified 10/06/2021
w = self.monitor.width()
h = self.monitor.height()
img = []
X, Y = np.meshgrid(np.linspace(0, w, w), np.linspace(0, h, h))
scalefactor = self.factor * self.NA * self.scale / wavelength / self.M
p = 4 * pi / 3**.5 / scalefactor
r0 = 0.33 * p
for i in range(7):
if i <= 2:
phi = (X * cos(-self.orientation - i * 2 * pi / 3 + pi / 3) *
scalefactor +
Y * sin(-self.orientation - i * 2 * pi / 3 + pi / 3) *
scalefactor) # self.orientation = 1.36
img.append(255 * (cos(phi) > 0.0))
elif i > 2:
phase = i * 2 * pi / 7
xr = (-X * sin(-self.orientation) +
Y * cos(-self.orientation) - 1.0 * p * phase / (2 * pi))
yr = (-X * cos(-self.orientation) -
Y * sin(-self.orientation) + 2.0 / 3**.5 * p * phase /
(2 * pi))
yi = floor(yr / (p * 3**.5 / 2) + 0.5).astype('int')
temp = (yi & 1) / 2.0
xi = floor((xr / p) - temp + 0.5) + temp
y0 = yi * p * 3**.5 / 2
x0 = xi * p
r = (xr - x0)**2 + (yr - y0)**2
img.append(255 * (r < r0**2))
img = np.array(img, dtype=np.uint8).transpose((1, 2, 0))
return np.require(img, np.uint8, 'C')
''' # Original
def o_twoBeamGenerator(self,wavelength):
w = self.monitor.width()
h = self.monitor.height()
img = np.ones([h,w,7])
X, Y = np.meshgrid(np.linspace(0, w, w), np.linspace(0, h, h))
scalefactor = self.factor * self.NA * self.scale / wavelength / self.M
p = 4 * pi / sqrt(3) / scalefactor
r0 = 0.33 * p
for i in range(7):
if i<=2:
phi = X*cos(-self.orientation-i*2*pi/3+pi/3)*scalefactor+Y*sin(-self.orientation-i*2*pi/3+pi/3)*scalefactor # self.orientation = 1.36
img[:, :, i] = 255 * (cos(phi) > 0.0)
elif i>2:
phase = i * 2 * pi / 7
xr = -X * sin(-self.orientation) + Y * cos(-self.orientation) - 1.0 * p * phase / (2 * pi)
yr = -X * cos(-self.orientation) - Y * sin(-self.orientation) + 2.0 / sqrt(3) * p * phase / (2 * pi)
yi = floor(yr / (p * sqrt(3) / 2) + 0.5)
xi = floor((xr / p) - (yi % 2.0) / 2.0 + 0.5) + (yi % 2.0) / 2.0
y0 = yi * p * sqrt(3) / 2
x0 = xi * p
r = sqrt((xr - x0) ** 2 + (yr - y0) ** 2)
img[:, :, i] = 255 * (r < r0)
return np.require(img,np.uint8,'C')
#'''
def imgRead(self):
w = self.monitor.width()
h = self.monitor.height()
img = np.zeros((h, w, 7))
for i in range(7):
name_tmp = str(i).zfill(3)
file_name = './patterns/' + name_tmp + '.bmp'
img_tmp = Image.open(file_name)
img[:, :,
i] = resize(np.sum(np.array(img_tmp), axis=2) / 3, (h, w))
return np.require(img, np.uint8, 'C')
def setPatterns(self, wavelength):
self.wavelength = wavelength
if self.wavelength == 0.488:
self.img = self.img488
elif self.wavelength == 0.561:
self.img = self.img561
# elif self.wavelength == 2.488:
# self.img = self.img488_2b
#
# elif self.wavelength == 2.561:
# self.img = self.img561_2b
def keyPressEvent(self, input):
if input.key() == Qt.Key_Escape:
self.close()
