def __init__(self,
viewName=None,
rows=None,
columns=None,
filename=None,
positionRange=None,
rangeShrink=None):
viewName = viewName if viewName else "Red"
rows = rows if rows else 4
columns = columns if columns else 6
sliceWidget = slicer.app.layoutManager().sliceWidget(viewName)
if positionRange is None:
sliceBounds = [0, 0, 0, 0, 0, 0]
sliceWidget.sliceLogic().GetLowestVolumeSliceBounds(sliceBounds)
slicePositionRange = [sliceBounds[0], sliceBounds[1]]
else:
slicePositionRange = [positionRange[0], positionRange[1]]
if rangeShrink:
slicePositionRange[0] += rangeShrink[0]
slicePositionRange[1] -= rangeShrink[1]
# Capture red slice view, 30 images, from position -125.0 to 75.0
# into current folder, with name image_00001.png, image_00002.png, ...
import ScreenCapture
screenCaptureLogic = ScreenCapture.ScreenCaptureLogic()
viewNodeID = 'vtkMRMLSliceNodeRed'
destinationFolder = 'outputs/Capture-SliceSweep'
numberOfFrames = rows * columns
filenamePattern = "_lightbox_tmp_image_%05d.png"
viewNode = sliceWidget.mrmlSliceNode()
# Suppress log messages
def noLog(msg):
pass
screenCaptureLogic.addLog = noLog
# Capture images
screenCaptureLogic.captureSliceSweep(viewNode, slicePositionRange[0],
slicePositionRange[1],
numberOfFrames, destinationFolder,
filenamePattern)
# Create lightbox image
resultImageFilename = filename if filename else filenamePattern % numberOfFrames
screenCaptureLogic.createLightboxImage(columns, destinationFolder,
filenamePattern, numberOfFrames,
resultImageFilename)
# Save result
with open(destinationFolder + "/" + resultImageFilename, "rb") as file:
self.dataValue = file.read()
self.dataType = "image/png"
# This could be used to create an image widget: img = Image(value=image, format='png')
# Clean up
screenCaptureLogic.deleteTemporaryFiles(
destinationFolder, filenamePattern,
numberOfFrames if filename else numberOfFrames + 1)
def __init__(self, text="", parent=None, **kwargs):
super(ScreenShotButton, self).__init__(text, parent, **kwargs)
import ScreenCapture
self.cap = ScreenCapture.ScreenCaptureLogic()
self.checkable = False
self._caseResultDir = ""
self.imageIndex = 0
def __init__(self, layoutManager):
self.stop = True
self.layoutManager = layoutManager
self.threeDView = layoutManager.threeDWidget(0).threeDView()
self.red = layoutManager.sliceWidget('Red')
self.yellow = layoutManager.sliceWidget('Yellow')
self.green = layoutManager.sliceWidget('Green')
self.redController = self.red.sliceController()
self.yellowController = self.yellow.sliceController()
self.greenController = self.green.sliceController()
self.redLogic = self.red.sliceLogic()
self.yellowLogic = self.yellow.sliceLogic()
self.greenLogic = self.green.sliceLogic()
self.redNode = self.redLogic.GetSliceNode()
self.yellowNode = self.yellowLogic.GetSliceNode()
self.greenNode = self.greenLogic.GetSliceNode()
self.redCompositeNode = self.redLogic.GetSliceCompositeNode()
self.yellowCompositeNode = self.yellowLogic.GetSliceCompositeNode()
self.greenCompositeNode = self.greenLogic.GetSliceCompositeNode()
# logic for taking a screenshot
self.cap = ScreenCapture.ScreenCaptureLogic()
# sets last function as the previous command
self.previous_command = self.conventional
# dictionary for functions that manipulate the red/yellow/green slices
self.colorSwitcher = {"red" : {"john" : self.showRed, "show" : self.showRed, "hide" : self.hideRed , "view" : self.redView, "unlink" : self.unlinkRed, "link" : self.linkRed, "offset" : self.manipulateRed} ,
"read" : {"john" : self.showRed, "show" : self.showRed, "hide" : self.hideRed , "view" : self.redView, "unlink" : self.unlinkRed, "link" : self.linkRed, "offset" : self.manipulateRed},
"yellow" : {"john" : self.showYellow, "show" : self.showYellow, "hide" : self.hideYellow, "view" : self.yellowView, "unlink" : self.unlinkYellow, "link" : self.linkYellow, "offset" : self.manipulateYellow},
"green" : {"john" : self.showGreen, "hyde" : self.hideGreen, "show" : self.showGreen, "hide" : self.hideGreen, "view" : self.greenView, "unlink" : self.unlinkGreen, "link" : self.linkGreen,"offset" : self.manipulateGreen }
}
# all other functions that don't have parameters
# TODO: try and implement dictionary with parameters
self.functionSwitcher = {"conventional" : self.conventional, "screenshot" : self.captureView, "save scene" : self.saveScene, "repeat" : self.repeat,
"right" : self.rightAxis, "left" : self.leftAxis, "superior" : self.superiorAxis, "inferior" : self.inferiorAxis,
"anterior" : self.anteriorAxis, "posterior" : self.posteriorAxis, "reset axis" : self.resetFocalPoint,
"zoom in" : self.zoomIn, "zoom out" : self.zoomOut
}
self.sliceOffset = 10
self.zoom_factor = 0.5
if not os.path.exists('../slicer_imgs'): os.mkdir('../slicer_imgs')
current_dir = os.listdir(target_folder)
image_folders = []
for d in current_dir:
if d.find('.') == -1:
image_folders.append(d)
print("Folders: " + str(image_folders))
for folder in image_folders:
for i, f in enumerate(target_files):
loc = '%s/%s/%s' % (target_folder, folder, f)
if os.path.exists(loc):
name = f.split('.')[0]
flag, vol = slicer.util.loadVolume(
loc, properties={'show':
1}, returnNode=True) # Load image metric
stats = LabelStatisticsLogic(vol, atlas)
stats.saveStats(
'../slicer_outputs/%s_%s.csv' %
(folder, str(name))) # Compute and save metrics to csv
cap = ScreenCapture.ScreenCaptureLogic()
cap.captureImageFromView(
None, '../slicer_imgs/%s_%s.png' %
(folder, str(name))) # Save image for error-checking
slicer.mrmlScene.RemoveNode(
vol) # Remove volume to allow visualization of next volume
from time import time
import cv2 as cv
import numpy as np
import win32con
import win32gui
import win32ui
import ScreenCapture
app_name = '950459: IFCMarkets-Demo - Demo Account - [XAUOIL,H1]'
ScreenCapture.list_window_names()
max_fps = 0
min_fps = 60
wincap = ScreenCapture.WindowCapture(app_name)
cv.namedWindow('Meta Trader', cv.WINDOW_GUI_NORMAL)
while 1:
st = time()
screenshot = wincap.get_screenshot()
fps = 1 / (time() - st)
if fps > max_fps:
max_fps = fps
if fps < min_fps:
min_fps = fps
print('FPS: {:.2f}, min: {:.2f}, max: {:.2f}'.format(
fps, min_fps, max_fps))
cv.imshow('Meta Trader', screenshot)
if cv.waitKey(1) == ord('q'):
cv.destroyAllWindows()
break
import ScreenCapture
import Display
import Process
import multiprocessing
from threading import Thread, Event
import queue
import concurrent.futures
import time
import cv2
capturer2process = multiprocessing.Queue()
process2display = multiprocessing.Queue()
display2control = multiprocessing.Queue()
controller = VirtualJoystick.VirtualJoystick(display2control)
capturer = ScreenCapture.ScreenCapture(controller.ETS_window_coords[1],
controller.ETS_window_coords[0],
controller.ETS_window_coords[2],
controller.ETS_window_coords[3],
capturer2process)
process = Process.Process(capturer2process, process2display, "jarcyk")
displayer = Display.Display(process2display, display2control)
controller.start()
#
capturer.start()
process.start()
displayer.start()
HEIGHT = 270
LR = 0.0001
EPOCH = 30
MODEL_NAME = 'MinecraftBot-{}-{}-{}-epochs.model'.format(
LR, 'alexnetColor', EPOCH)
model = alexnet(WIDTH, HEIGHT, LR)
model.load('./TrainedModels/Color/' + MODEL_NAME)
# print("down")
# pyautogui.keyDown(W)
# time.sleep(1)
# pyautogui.keyUp(W)
paused = False
while (True):
if not paused:
screenImage = cv2.resize(sc.getScreen(), (WIDTH, HEIGHT))
prediction = model.predict([screenImage.reshape(WIDTH, HEIGHT, 3)])
choice = np.around(prediction).astype(int).tolist()
print(choice)
# Up
if choice == [[0., 1., 0., 0]]:
print("Up")
pressKey(W)
releaseKey(SPACE)
releaseKey(A)
releaseKey(D)
# time.sleep(0.5)
# Up and Space
if choice == [[0., 1., 0., 1.]]:
elif 'A' in keys:
output[0] = 1
return [1, 0, 0, 0]
elif 'D' in keys:
output[2] = 1
return [0, 0, 1, 0]
elif ' ' in keys:
output[3] = 1
return [0, 0, 0, 1]
return output
paused = False
while (True):
if not paused:
screenImage = cv2.resize(sc.getScreen(), (480, 270))
keys = keyCheck()
output = keysToOutput(keys)
trainingData.append([screenImage, output])
print(output)
if len(trainingData) % 500 == 0:
print(len(trainingData))
print("saving")
trainingDataPath = 'Data/Gray/dataGRAY480x270-p{}.npy'.format(i)
np.save(trainingDataPath, trainingData)
# trainingData = []
keys = keyCheck()
if 'T' in keys:
if paused:
paused = False
time.sleep(1)