def recordPlot(self):
# Make the temporary directory
if not os.path.exists("./temp/"):
os.mkdir("./temp")
# Choose file location
dialog = QFileDialog()
fl = dialog.getSaveFileName(self.window, "Save Video", "",
"MP4 file (*.mp4)")
if fl[0] == "":
return
# Update UI So the user doesnt get confused
self.btRecord.setText("Recording")
self.btRecord.setStyleSheet("background-color: red")
out = cv2.VideoWriter(fl[0], cv2.VideoWriter_fourcc(*'DIVX'), 30,
(800, 600))
# Loop through each frame and create file. Use created file to make video
for i in range(self.slideStart.value(), self.slideEnd.value()):
self.frame = i
self.plotData()
d = self.plot.renderToArray((800, 600))
pg.makeQImage(d).save("./temp/test" + str(i) + ".png")
img = cv2.imread("./temp/test" + str(i) + ".png")
out.write(img)
# Erase image files after creation
for i in range(self.slideStart.value(), self.slideEnd.value()):
os.remove("./temp/test" + str(i) + ".png")
out.release()
self.btRecord.setText("Record")
self.btRecord.setStyleSheet(self.recordStyle)
def set_data(self, data):
self.v.setData(data)
if not self.centered:
self.v.resetTransform()
self.v.translate(-data.shape[0] / 2, -data.shape[1] / 2, -data.shape[2] / 2)
self.centered = True
d = self.renderToArray((1920, 1080))
image_file_path = self.latest_test_dir_path.joinpath(self.latest_task_name + ".png").as_posix()
print(image_file_path)
pg.makeQImage(d, alpha=False).save(image_file_path)
def export(self, fileName=None):
if fileName is None:
filter = ["*."+str(f) for f in QtGui.QImageWriter.supportedImageFormats()]
preferred = ['*.png', '*.tif', '*.jpg']
for p in preferred[::-1]:
if p in filter:
filter.remove(p)
filter.insert(0, p)
self.fileSaveDialog(filter=filter)
return
targetRect = QtCore.QRect(0, 0, self.params['width'], self.params['height'])
sourceRect = self.getSourceRect()
#self.png = QtGui.QImage(targetRect.size(), QtGui.QImage.Format_ARGB32)
#self.png.fill(pyqtgraph.mkColor(self.params['background']))
bg = np.empty((self.params['width'], self.params['height'], 4), dtype=np.ubyte)
color = self.params['background']
bg[:,:,0] = color.blue()
bg[:,:,1] = color.green()
bg[:,:,2] = color.red()
bg[:,:,3] = color.alpha()
self.png = pg.makeQImage(bg, alpha=True)
painter = QtGui.QPainter(self.png)
try:
self.setExportMode(True, {'antialias': self.params['antialias'], 'background': self.params['background']})
painter.setRenderHint(QtGui.QPainter.Antialiasing, self.params['antialias'])
self.getScene().render(painter, QtCore.QRectF(targetRect), sourceRect)
finally:
self.setExportMode(False)
self.png.save(fileName)
painter.end()
def render(self):
#Convert data to QImage for display.
#profile = debug.Profiler()
if self.image is None or self.image.size == 0:
return
if isinstance(self.lut, collections.Callable):
lut = self.lut(self.image)
else:
lut = self.lut
if False:#self.autoDownsample:
# reduce dimensions of image based on screen resolution
o = self.mapToDevice(QtCore.QPointF(0,0))
x = self.mapToDevice(QtCore.QPointF(1,0))
y = self.mapToDevice(QtCore.QPointF(0,1))
w = Point(x-o).length()
h = Point(y-o).length()
xds = int(1/max(1, w))
yds = int(1/max(1, h))
image = pg.downsample(self.image, xds, axis=0)
image = pg.downsample(image, yds, axis=1)
else:
image = self.image
imageRGBA = makeRGBAImage(image,self.cppLut)
imageNew = imageRGBA
argb, alpha = pg.makeARGB(imageNew.transpose((1, 0, 2)[:imageNew.ndim]), lut=None, levels=None)
self.qimage = pg.makeQImage(argb, alpha, transpose=False)
def render(self):
# simplified pg.ImageITem
if self.image is None or self.image.size == 0:
return
if isinstance(self.lut, collections.Callable):
lut = self.lut(self.image)
else:
lut = self.lut
image = self.image
levels = self.levels
if self.axisOrder == 'col-major':
image = image.transpose((1, 0, 2)[:image.ndim])
argb, alpha = pg.makeARGB(image, lut=lut, levels=levels) # format is bgra
argb[np.isnan(image)] = (100, 100, 100, 255) # replace unknown values with a color
w = 1
if np.any(self.selection):
max_sel = np.max(self.selection)
colors = DiscreteVariable(values=map(str, range(max_sel))).colors
fargb = argb.astype(np.float32)
for i, color in enumerate(colors):
color = np.hstack((color[::-1], [255])) # qt color
sel = self.selection == i+1
# average the current color with the selection color
argb[sel] = (fargb[sel] + w*color) / (1+w)
alpha = True
argb[:, :, 3] = np.maximum((self.selection > 0)*255, 100)
self.qimage = pg.makeQImage(argb, alpha, transpose=False)
def render(self):
# simplified pg.ImageITem
if self.image is None or self.image.size == 0:
return
if isinstance(self.lut, collections.Callable):
lut = self.lut(self.image)
else:
lut = self.lut
image = self.image
levels = self.levels
if self.axisOrder == 'col-major':
image = image.transpose((1, 0, 2)[:image.ndim])
argb, alpha = pg.makeARGB(image, lut=lut, levels=levels) # format is bgra
argb[np.isnan(image)] = (100, 100, 100, 255) # replace unknown values with a color
w = 1
if np.any(self.selection):
max_sel = np.max(self.selection)
colors = DiscreteVariable(values=map(str, range(max_sel))).colors
fargb = argb.astype(np.float32)
for i, color in enumerate(colors):
color = np.hstack((color[::-1], [255])) # qt color
sel = self.selection == i+1
# average the current color with the selection color
argb[sel] = (fargb[sel] + w*color) / (1+w)
alpha = True
argb[:, :, 3] = np.maximum((self.selection > 0)*255, 100)
self.qimage = pg.makeQImage(argb, alpha, transpose=False)
def get_image_to_save(self, quality):
image1 = self.grabFrameBuffer(False)
width1 = image1.width()
height1 = image1.height()
width2 = 200 * quality
factor = width2 / width1
length2 = int(factor * height1)
self.xygrid.setThickness(self.size_grid * factor)
self.yzgrid.setThickness(self.size_grid * factor)
self.xzgrid.setThickness(self.size_grid * factor)
self.scatter_plot.setData(pos=self.pos,
size=1.2 * factor * self.size_traj,
color=self.color,
pxMode=False)
self.scatter_plot.setGLOptions('opaque')
image = pg.makeQImage(self.renderToArray((width2, length2)))
self.xygrid.setThickness(self.size_grid)
self.yzgrid.setThickness(self.size_grid)
self.xzgrid.setThickness(self.size_grid)
self.scatter_plot.setData(pos=self.pos,
size=self.size_traj,
color=self.color,
pxMode=False)
self.scatter_plot.setGLOptions('opaque')
return image
def export(self, fileName=None, toBytes=False, copy=False):
if fileName is None and not toBytes and not copy:
filter = [
"*." + str(f)
for f in QtGui.QImageWriter.supportedImageFormats()
]
preferred = ['*.png', '*.tif', '*.jpg']
for p in preferred[::-1]:
if p in filter:
filter.remove(p)
filter.insert(0, p)
self.fileSaveDialog(filter=filter)
return
targetRect = QtCore.QRect(0, 0, self.params['width'],
self.params['height'])
sourceRect = self.getSourceRect()
#self.png = QtGui.QImage(targetRect.size(), QtGui.QImage.Format_ARGB32)
#self.png.fill(pyqtgraph.mkColor(self.params['background']))
bg = np.empty((self.params['width'], self.params['height'], 4),
dtype=np.ubyte)
color = self.params['background']
bg[:, :, 0] = color.blue()
bg[:, :, 1] = color.green()
bg[:, :, 2] = color.red()
bg[:, :, 3] = color.alpha()
self.png = pg.makeQImage(bg, alpha=True)
## set resolution of image:
origTargetRect = self.getTargetRect()
resolutionScale = targetRect.width() / origTargetRect.width()
#self.png.setDotsPerMeterX(self.png.dotsPerMeterX() * resolutionScale)
#self.png.setDotsPerMeterY(self.png.dotsPerMeterY() * resolutionScale)
painter = QtGui.QPainter(self.png)
#dtr = painter.deviceTransform()
try:
self.setExportMode(
True, {
'antialias': self.params['antialias'],
'background': self.params['background'],
'painter': painter,
'resolutionScale': resolutionScale
})
painter.setRenderHint(QtGui.QPainter.Antialiasing,
self.params['antialias'])
self.getScene().render(painter, QtCore.QRectF(targetRect),
QtCore.QRectF(sourceRect))
finally:
self.setExportMode(False)
painter.end()
if copy:
QtGui.QApplication.clipboard().setImage(self.png)
elif toBytes:
return self.png
else:
self.png.save(fileName)
def export(self, fileName=None, toBytes=False, copy=False):
if fileName is None and not toBytes and not copy:
if USE_PYSIDE:
filter = ["*." + str(f) for f in QtGui.QImageWriter.supportedImageFormats()]
else:
filter = ["*." + bytes(f).decode("utf-8") for f in QtGui.QImageWriter.supportedImageFormats()]
preferred = ["*.png", "*.tif", "*.jpg"]
for p in preferred[::-1]:
if p in filter:
filter.remove(p)
filter.insert(0, p)
self.fileSaveDialog(filter=filter)
return
targetRect = QtCore.QRect(0, 0, self.params["width"], self.params["height"])
sourceRect = self.getSourceRect()
# self.png = QtGui.QImage(targetRect.size(), QtGui.QImage.Format_ARGB32)
# self.png.fill(pyqtgraph.mkColor(self.params['background']))
bg = np.empty((self.params["width"], self.params["height"], 4), dtype=np.ubyte)
color = self.params["background"]
bg[:, :, 0] = color.blue()
bg[:, :, 1] = color.green()
bg[:, :, 2] = color.red()
bg[:, :, 3] = color.alpha()
self.png = pg.makeQImage(bg, alpha=True)
## set resolution of image:
origTargetRect = self.getTargetRect()
resolutionScale = targetRect.width() / origTargetRect.width()
# self.png.setDotsPerMeterX(self.png.dotsPerMeterX() * resolutionScale)
# self.png.setDotsPerMeterY(self.png.dotsPerMeterY() * resolutionScale)
painter = QtGui.QPainter(self.png)
# dtr = painter.deviceTransform()
try:
self.setExportMode(
True,
{
"antialias": self.params["antialias"],
"background": self.params["background"],
"painter": painter,
"resolutionScale": resolutionScale,
},
)
painter.setRenderHint(QtGui.QPainter.Antialiasing, self.params["antialias"])
self.getScene().render(painter, QtCore.QRectF(targetRect), QtCore.QRectF(sourceRect))
finally:
self.setExportMode(False)
painter.end()
if copy:
QtGui.QApplication.clipboard().setImage(self.png)
elif toBytes:
return self.png
else:
self.png.save(fileName)
def export(self, fileName=None, toBytes=False, copy=False):
if fileName is None and not toBytes and not copy:
if USE_PYSIDE:
filter = ["*."+str(f) for f in QtGui.QImageWriter.supportedImageFormats()]
else:
filter = ["*."+bytes(f).decode('utf-8') for f in QtGui.QImageWriter.supportedImageFormats()]
preferred = ['*.png', '*.tif', '*.jpg']
for p in preferred[::-1]:
if p in filter:
filter.remove(p)
filter.insert(0, p)
self.fileSaveDialog(filter=filter)
return
targetRect = QtCore.QRect(0, 0, self.params['width'], self.params['height'])
sourceRect = self.getSourceRect()
#self.png = QtGui.QImage(targetRect.size(), QtGui.QImage.Format_ARGB32)
#self.png.fill(pyqtgraph.mkColor(self.params['background']))
w, h = self.params['width'], self.params['height']
if w == 0 or h == 0:
raise Exception("Cannot export image with size=0 (requested export size is %dx%d)" % (w,h))
bg = np.empty((self.params['width'], self.params['height'], 4), dtype=np.ubyte)
color = self.params['background']
bg[:,:,0] = color.blue()
bg[:,:,1] = color.green()
bg[:,:,2] = color.red()
bg[:,:,3] = color.alpha()
self.png = pg.makeQImage(bg, alpha=True)
## set resolution of image:
origTargetRect = self.getTargetRect()
resolutionScale = targetRect.width() / origTargetRect.width()
#self.png.setDotsPerMeterX(self.png.dotsPerMeterX() * resolutionScale)
#self.png.setDotsPerMeterY(self.png.dotsPerMeterY() * resolutionScale)
painter = QtGui.QPainter(self.png)
#dtr = painter.deviceTransform()
try:
self.setExportMode(True, {'antialias': self.params['antialias'], 'background': self.params['background'], 'painter': painter, 'resolutionScale': resolutionScale})
painter.setRenderHint(QtGui.QPainter.Antialiasing, self.params['antialias'])
self.getScene().render(painter, QtCore.QRectF(targetRect), QtCore.QRectF(sourceRect))
finally:
self.setExportMode(False)
painter.end()
if copy:
QtGui.QApplication.clipboard().setImage(self.png)
elif toBytes:
return self.png
else:
self.png.save(fileName)
def update(self):
fileHdf5 = h5py.File(self.allFiles[self.current], "r")
conData = fileHdf5['/energy/density']['cTheta'].value.reshape(self.Lx,self.Lx,self.Lz)
meanData = np.mean(conData)
conData = conData/meanData
self.data = np.zeros(conData.shape + (4,), dtype=np.ubyte)
pData = np.clip(conData, 0, 10)**2
self.data[..., 0] = pData * (255./pData.max())
self.data[..., 1] = self.data[..., 0]
self.data[..., 2] = self.data[..., 0]
self.data[..., 3] = ((self.data[...,0].astype(float)/255.)**2)*255
self.z = fileHdf5['/'].attrs.get("z")
self.view.updateZ(self.z)
self.plt.setData(data=self.data)
#self.view.grabFrameBuffer().save("img.%04d.png" % self.current)
img = self.view.renderToArray((1920, 1080))
pg.makeQImage(img).save("img.%04d.png" % self.current)
self.current = (self.current+self.step)
fileHdf5.close()
if self.current >= self.nFiles:
QtGui.QApplication.instance().closeAllWindows()
def export(self, fileName=None):
if fileName is None:
filter = [
"*." + str(f)
for f in QtGui.QImageWriter.supportedImageFormats()
]
preferred = ['*.png', '*.tif', '*.jpg']
for p in preferred[::-1]:
if p in filter:
filter.remove(p)
filter.insert(0, p)
self.fileSaveDialog(filter=filter)
return
targetRect = QtCore.QRect(0, 0, self.params['width'],
self.params['height'])
sourceRect = self.getSourceRect()
#self.png = QtGui.QImage(targetRect.size(), QtGui.QImage.Format_ARGB32)
#self.png.fill(pyqtgraph.mkColor(self.params['background']))
bg = np.empty((self.params['width'], self.params['height'], 4),
dtype=np.ubyte)
color = self.params['background']
bg[:, :, 0] = color.blue()
bg[:, :, 1] = color.green()
bg[:, :, 2] = color.red()
bg[:, :, 3] = color.alpha()
self.png = pg.makeQImage(bg, alpha=True)
painter = QtGui.QPainter(self.png)
try:
self.setExportMode(
True, {
'antialias': self.params['antialias'],
'background': self.params['background']
})
painter.setRenderHint(QtGui.QPainter.Antialiasing,
self.params['antialias'])
self.getScene().render(painter, QtCore.QRectF(targetRect),
sourceRect)
finally:
self.setExportMode(False)
self.png.save(fileName)
painter.end()
def render(self):
# simplified pg.ImageITem
if self.image is None or self.image.size == 0:
return
if isinstance(self.lut, collections.Callable):
lut = self.lut(self.image)
else:
lut = self.lut
image = self.image
levels = self.levels
if self.axisOrder == 'col-major':
image = image.transpose((1, 0, 2)[:image.ndim])
argb, alpha = pg.makeARGB(image, lut=lut, levels=levels)
argb[np.isnan(image)] = (100, 100, 100, 255
) # replace unknown values with a color
self.qimage = pg.makeQImage(argb, alpha, transpose=False)
def export(self, fileName=None, toBytes=False, copy=False):
if fileName is None and not toBytes and not copy:
filter = ["*."+str(f) for f in QtGui.QImageWriter.supportedImageFormats()]
preferred = ['*.bmp', '*.png', '*.tif', '*.jpg']
for p in preferred[::-1]:
if p in filter:
filter.remove(p)
filter.insert(0, p)
self.fileSaveDialog(filter=filter)
return
targetRect = QtCore.QRect(0, 0, self.params['width'], self.params['height'])
sourceRect = self.getSourceRect()
bg = np.empty((self.params['width'], self.params['height'], 4), dtype=np.ubyte)
color = self.params['background']
bg[:,:,0] = color.blue()
bg[:,:,1] = color.green()
bg[:,:,2] = color.red()
bg[:,:,3] = color.alpha()
self.png = pg.makeQImage(bg, alpha=True)
origTargetRect = self.getTargetRect()
resolutionScale = targetRect.width() / origTargetRect.width()
painter = QtGui.QPainter(self.png)
try:
self.setExportMode(True, {'antialias': self.params['antialias'], 'background': self.params['background'], 'painter': painter, 'resolutionScale': resolutionScale})
painter.setRenderHint(QtGui.QPainter.Antialiasing, self.params['antialias'])
self.getScene().render(painter, QtCore.QRectF(targetRect), QtCore.QRectF(sourceRect))
finally:
self.setExportMode(False)
painter.end()
if copy:
QtGui.QApplication.clipboard().setImage(self.png)
elif toBytes:
return self.png
else:
self.png.save(fileName)
def update(self):
global item
global item_num
num = item / 2
azimuth_value = abs(num % 120 + math.pow(-1, int((num / 120))) * 120) % 120
self.w.opts['azimuth'] = azimuth_value
print(item, ' ')
_, frame = self.cap.read()
if item % 2 != 1:
frame, W, H = resize_img(frame)
joint2D = interface2D(frame, model2D)
img2D = draw_2Dimg(frame, joint2D, 1)
if item == 0:
for _ in range(30):
self.kpt2Ds.append(joint2D)
elif item < 30:
self.kpt2Ds.append(joint2D)
self.kpt2Ds.pop(0)
else:
self.kpt2Ds.append(joint2D)
self.kpt2Ds.pop(0)
item += 1
joint3D = interface3D(model3D, np.array(self.kpt2Ds), W, H)
pos = joint3D[-1] # (17, 3)
for j, j_parent in enumerate(common.skeleton_parents):
if j_parent == -1:
continue
x = np.array([pos[j, 0], pos[j_parent, 0]]) * 10
y = np.array([pos[j, 1], pos[j_parent, 1]]) * 10
z = np.array([pos[j, 2], pos[j_parent, 2]]) * 10 - 10
pos_total = np.vstack([x, y, z]).transpose()
self.set_plotdata(
name=j, points=pos_total,
color=pg.glColor((j, 10)),
width=6)
# save
if item_num < 10:
name = '000' + str(item_num)
elif item_num < 100:
name = '00' + str(item_num)
elif item_num < 1000:
name = '0' + str(item_num)
else:
name = str(item_num)
im3Dname = 'VideoSave/' + '3D_' + name + '.png'
d = self.w.renderToArray((img2D.shape[1], img2D.shape[0])) # (W, H)
print('Save 3D image: ', im3Dname)
pg.makeQImage(d).save(im3Dname)
im2Dname = 'VideoSave/' + '2D_' + name + '.png'
print('Save 2D image: ', im2Dname)
cv2.imwrite(im2Dname, img2D)
item_num += 1
else:
item += 1
def preRender(self, image):
imageRGBA = makeRGBAImage(image,self.cppLut)
imageNew = imageRGBA
argb, alpha = pg.makeARGB(imageNew.transpose((1, 0, 2)[:imageNew.ndim]), lut=None, levels=None)
self.qimage = pg.makeQImage(argb, alpha, transpose=False)
def save(self, filename, size=(800, 450)):
pyqtgraph.makeQImage(self.view.renderToArray(size)).save(filename)
self.app.quit()
