def requestStatus(self, avg_support = True):
self.blockSize = 0
self.socket.abort()
block = QtCore.QByteArray()
commStream = QtCore.QDataStream(block, QtCore.QIODevice.WriteOnly)
commStream.setVersion(QtCore.QDataStream.Qt_4_0)
commStream.writeUInt16(0)
commStream.writeUInt16(self.STATUS_CMD)
commStream.device().seek(0)
commStream.writeUInt16(block.count() - 2)
self.socket.connectToHost(self.ipAddress, self.portNumber)
self.socket.waitForConnected(10)
self.socket.write(block)
self.socket.waitForReadyRead()
inStream = QtCore.QDataStream(self.socket)
inStream.setVersion(QtCore.QDataStream.Qt_4_0)
if self.blockSize == 0:
if self.socket.bytesAvailable() < 2:
print("LVC: No Data Received...")
return
self.blockSize = inStream.readUInt16()
self.framesLeft = inStream.readUInt16()
self.fps = inStream.readUInt16()
if avg_support:
self.numAvgs_stat = inStream.readUInt16(); # new
else:
self.numAvgs_stat = 1;
return (self.framesLeft, self.fps, self.numAvgs_stat);
def loadFromMemory(self):
""" This slot function is called in the second Dialog process, when the
user presses the "Load Image from Shared Memory" button. First, it
attaches the process to the shared memory segment created by the first
Dialog process. Then it locks the segment for exclusive access, copies
the image data from the segment into a QBuffer, and streams the QBuffer
into a QImage. Then it unlocks the shared memory segment, detaches
from it, and finally displays the QImage in the Dialog.
"""
if not self.sharedMemory.attach():
self.ui.label.setText(
"Unable to attach to shared memory segment.\nLoad an "
"image first.")
return
buf = QtCore.QBuffer()
ins = QtCore.QDataStream(buf)
image = QtGui.QImage()
self.sharedMemory.lock()
buf.setData(self.sharedMemory.constData())
buf.open(QtCore.QBuffer.ReadOnly)
ins >> image
self.sharedMemory.unlock()
self.sharedMemory.detach()
self.ui.label.setPixmap(QtGui.QPixmap.fromImage(image))
def sendInstruction(self):
block = QtCore.QByteArray()
out = QtCore.QDataStream(block, QtCore.QIODevice.WriteOnly)
out.setVersion(QtCore.QDataStream.Qt_4_0)
out.writeUInt16(0)
try:
# Python v3.
instruction = bytes(self.instruction, encoding='ascii')
except:
# Python v2.
print("Error")
out.writeString(instruction)
out.device().seek(0)
out.writeUInt16(block.size() - 2)
clientConnection = self.tcpServer.nextPendingConnection()
clientConnection.disconnected.connect(clientConnection.deleteLater)
clientConnection.write(block)
clientConnection.disconnectFromHost()
if self.animation == 1:
self.animation = 0
self.updateInstruction()
def dropEvent(self, ev):
src = ev.source()
if hasattr(src, 'implements') and src.implements('dock'):
area = self.dropArea
if area is None:
return
if area == 'center':
area = 'above'
self.area.moveDock(ev.source(), area, self)
self.dropArea = None
self.overlay.setDropArea(self.dropArea)
elif ev.mimeData().hasFormat('captureName'):
mime = ev.mimeData()
itemData = mime.data('captureName')
dataStream = QtCore.QDataStream(itemData,
QtCore.QIODevice.ReadOnly)
text = QtCore.QByteArray()
offset = QtCore.QPoint()
dataStream >> text >> offset
self.captureDropped(str(ev.mimeData().text()))
self.dropArea = None
self.overlay.setDropArea(self.dropArea)
def onDropEvent(self, event):
if event.mimeData().hasFormat('application/x-text'):
# decode drop stuff
data = event.mimeData().data('application/x-text')
stream = QtCore.QDataStream(data, QtCore.QIODevice.ReadOnly)
dirName = QtCore.QString()
nodeName = QtCore.QString()
stream >> dirName
stream >> nodeName
event.setDropAction(QtCore.Qt.CopyAction)
event.accept()
# save dropPoint in scene space
self.dropNodePoint = self.controller.gfxPanel.mapToScene(
event.pos())
# create an add node command and execute it
from command.command import AddNodeCommand
addNodeCommand = AddNodeCommand(self.controller.shaderLink,
self.controller.gfxPanel,
unicode(dirName),
unicode(nodeName),
self.dropNodePoint)
self.controller.commandProcessor.executeCommand(addNodeCommand)
else:
event.ignore()
def dropMimeData(self, data, action, row, column, parent):
if not data.hasFormat('image/x-puzzle-piece'):
return False
if action == QtCore.Qt.IgnoreAction:
return True
if column > 0:
return False
if not parent.isValid():
if row < 0:
endRow = len(self.pixmaps)
else:
endRow = min(row, len(self.pixmaps))
else:
endRow = parent.row()
encodedData = data.data('image/x-puzzle-piece')
stream = QtCore.QDataStream(encodedData, QtCore.QIODevice.ReadOnly)
while not stream.atEnd():
pixmap = QtGui.QPixmap()
location = QtGui.QPoint()
stream >> pixmap >> location
self.beginInsertRows(QtCore.QModelIndex(), endRow, endRow)
self.pixmaps.insert(endRow, pixmap)
self.locations.insert(endRow, location)
self.endInsertRows()
endRow += 1
return True
def mousePressEvent(self, event):
child = self.childAt(event.pos())
if not child:
return
pixmap = QtGui.QPixmap(child.pixmap())
itemData = QtCore.QByteArray()
dataStream = QtCore.QDataStream(itemData, QtCore.QIODevice.WriteOnly)
dataStream << pixmap << QtCore.QPoint(event.pos() - child.pos())
mimeData = QtCore.QMimeData()
mimeData.setData('application/x-dnditemdata', itemData)
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(pixmap)
drag.setHotSpot(event.pos() - child.pos())
tempPixmap = QtGui.QPixmap(pixmap)
painter = QtGui.QPainter()
painter.begin(tempPixmap)
painter.fillRect(pixmap.rect(), QtGui.QColor(127, 127, 127, 127))
painter.end()
child.setPixmap(tempPixmap)
if drag.exec_(QtCore.Qt.CopyAction | QtCore.Qt.MoveAction, QtCore.Qt.CopyAction) == QtCore.Qt.MoveAction:
child.close()
else:
child.show()
child.setPixmap(pixmap)
def getScene(self):
instr = QtCore.QDataStream(self.tcpSocket)
instr.setVersion(QtCore.QDataStream.Qt_4_0)
while not self.kill_now:
if self.blockSize == 0:
if self.tcpSocket.bytesAvailable() < 4:
return
self.blockSize = instr.readUInt32()
if self.tcpSocket.bytesAvailable() < self.blockSize:
return
self.blockSize = 0
pix = QtGui.QImage()
ba = QtCore.QByteArray()
instr >> ba
# skip this frame if there is another one in buffer
if self.tcpSocket.bytesAvailable() > 0:
rospy.loginfo("Frame dropped")
continue
# 16ms
if not pix.loadFromData(ba, "JPG"):
rospy.logerr("Failed to load image from received data")
return
self.get_image(pix)
def readFortune(self):
instr = QtCore.QDataStream(self.tcpSocket)
instr.setVersion(QtCore.QDataStream.Qt_4_0)
if self.blockSize == 0:
if self.tcpSocket.bytesAvailable() < 2:
return
self.blockSize = instr.readUInt16()
if self.tcpSocket.bytesAvailable() < self.blockSize:
return
nextFortune = instr.readString()
try:
# Python v3.
nextFortune = str(nextFortune, encoding='ascii')
except TypeError:
# Python v2.
pass
if nextFortune == self.currentFortune:
QtCore.QTimer.singleShot(0, self.requestNewFortune)
return
self.currentFortune = nextFortune
self.statusLabel.setText(self.currentFortune)
self.getFortuneButton.setEnabled(True)
def startDrag(self, dropActions):
item = self.currentItem()
# check parent name and return if top level node
if item.parent() == None:
return
# get dir name
dirName = unicode(item.parent().text(0))
# get node from library
nodeName = unicode(item.text(0))
# set custom data
data = QtCore.QByteArray()
stream = QtCore.QDataStream(data, QtCore.QIODevice.WriteOnly)
stream << item.parent().text(0) << item.text(0)
mimeData = QtCore.QMimeData()
mimeData.setData('application/x-text', data)
# set drag
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(QtGui.QPixmap(':/node.png'))
drag.start(QtCore.Qt.CopyAction)
def readData(self):
if self.proxySocket.isValid() :
if self.proxySocket.bytesAvailable() == 0 :
return
ins = QtCore.QDataStream(self.proxySocket)
ins.setVersion(QtCore.QDataStream.Qt_4_2)
while ins.atEnd() == False :
if self.proxySocket.isValid() :
if self.blockSize == 0:
if self.proxySocket.isValid() :
if self.proxySocket.bytesAvailable() < 4:
return
self.blockSize = ins.readUInt32()
else :
return
if self.proxySocket.isValid() :
if self.proxySocket.bytesAvailable() < self.blockSize:
return
else :
return
port = ins.readUInt16()
packet = ins.readQVariant()
self.tranfertToUdp(port, packet)
self.blockSize = 0
else :
return
return
def writeToServer(self, action, *args, **kw):
logger.debug(
("writeToServer(" + action + ", [" + ', '.join(args) + "])"))
block = QtCore.QByteArray()
out = QtCore.QDataStream(block, QtCore.QIODevice.ReadWrite)
out.setVersion(QtCore.QDataStream.Qt_4_2)
out.writeUInt32(0)
out.writeQString(action)
for arg in args:
if type(arg) is IntType:
out.writeInt(arg)
elif isinstance(arg, basestring):
out.writeQString(arg)
elif type(arg) is FloatType:
out.writeFloat(arg)
elif type(arg) is ListType:
out.writeQVariantList(arg)
else:
logger.warn("Uninterpreted Data Type: " + str(type(arg)) +
" of value: " + str(arg))
out.writeQString(str(arg))
out.device().seek(0)
out.writeUInt32(block.size() - 4)
self.bytesToSend = block.size() - 4
self.replayVaultSocket.write(block)
def SaveTools(self):
try:
if os.path.isfile(self.filepath):
QtCore.QFile.remove(self.file)
self.file.open(QtCore.QIODevice.WriteOnly)
datastream = QtCore.QDataStream(self.file)
count = self.MyToolsBars.topLevelItemCount()
datastream.writeUInt32(count)
for i in range(0, count):
item = self.MyToolsBars.topLevelItem(i)
item.write(datastream)
self.bar = None
self.CreateToolBar(item)
self.save_item(item, datastream)
self.hasChanged = False
self.file.close()
# Restauramos la lista de herramientas de Qgis.
state = self.saveWidgetState(self.ToolBars)
self.PopulateQgisTools()
self.loadWidgetState(self.ToolBars, state)
self.iface.messageBar().pushMessage("Info: ", "Save correctly.", level=QgsMessageBar.INFO, duration=3)
self.rename_btn.setEnabled(False)
self.delete_btn.setEnabled(False)
self.restore = {}
except:
self.iface.messageBar().pushMessage("Error: ", "Error save tools ", level=QgsMessageBar.CRITICAL, duration=3)
return
def send_to_clients_evt(self):
if len(self.connections) == 0:
return
# start = time.time()
pix = QtGui.QImage(
self.scene.width(),
self.scene.height(),
QtGui.QImage.Format_RGB888)
painter = QtGui.QPainter(pix)
painter.setRenderHint(QtGui.QPainter.Antialiasing)
self.scene.render(painter)
painter.end()
pix = pix.mirrored()
block = QtCore.QByteArray()
out = QtCore.QDataStream(block, QtCore.QIODevice.WriteOnly)
out.setVersion(QtCore.QDataStream.Qt_4_0)
out.writeUInt32(0)
img = QtCore.QByteArray()
buffer = QtCore.QBuffer(img)
buffer.open(QtCore.QIODevice.WriteOnly)
pix.save(buffer, "JPG", 95)
out << img
out.device().seek(0)
out.writeUInt32(block.size() - 4)
# print block.size()
for con in self.connections:
con.write(block)
def dropMimeData(self, QMimeData, Qt_DropAction, p_int, p_int_1,
QModelIndex):
encodedData = QMimeData.data("joblist")
dataStream = QtCore.QDataStream(encodedData, QtCore.QIODevice.ReadOnly)
newItems = []
while not dataStream.atEnd():
# text=""
# dataStream>>text
# newItems<<text
newItems += dataStream.readBytes().decode()
rows = len(newItems)
count = 0
parentShift = 0
newItems = sorted(newItems)
if int(newItems[0]) < QModelIndex.row() and int(
newItems[-1]) > QModelIndex.row():
return False
else:
for row in newItems:
row = int(row)
if not QModelIndex.row(
) + parentShift == row + count + 1 and QModelIndex.isValid():
if QModelIndex.row() + parentShift < row + count:
self.moveRows(QtCore.QModelIndex(), row + count, 1,
QtCore.QModelIndex(),
QModelIndex.row() + parentShift)
parentShift += 1
else:
self.moveRows(QtCore.QModelIndex(), row + count, 1,
QtCore.QModelIndex(),
QModelIndex.row() + parentShift)
count -= 1
return True
def mimeData(self, indexes):
"""Returns an object that contains serialized items of data
corresponding to the list of indexes specified.
When a node is dragged the information required to drop it later
on is encoded by this method and returned as a QMimeData object.
:Parameter indexes: a list of indexes
"""
mime_data = QtCore.QMimeData()
encoded_data = QtCore.QByteArray()
stream = QtCore.QDataStream(encoded_data, QtCore.QIODevice.WriteOnly)
# Only one item selections are allowed in the tree of databases
# view so indexes contains always one element
for index in indexes:
if index.isValid():
filepath = self.data(index, QtCore.Qt.UserRole)
nodepath = self.data(index, QtCore.Qt.UserRole + 1)
row = unicode(index.row())
stream.writeQString(filepath)
stream.writeQString(nodepath)
stream.writeQString(row)
self.initial_parent = self.parent(index)
mime_data.setData("application/x-dbstreemodeldatalist", encoded_data)
return mime_data
def dropEvent(self, event):
if event.mimeData().hasFormat('image/x-puzzle-piece') and self.findPiece(self.targetSquare(event.pos())) == -1:
pieceData = event.mimeData().data('image/x-puzzle-piece')
dataStream = QtCore.QDataStream(pieceData, QtCore.QIODevice.ReadOnly)
square = self.targetSquare(event.pos())
pixmap = QtGui.QPixmap()
location = QtCore.QPoint()
dataStream >> pixmap >> location
self.pieceLocations.append(location)
self.piecePixmaps.append(pixmap)
self.pieceRects.append(square)
self.hightlightedRect = QtCore.QRect()
self.update(square)
event.setDropAction(QtCore.Qt.MoveAction)
event.accept()
if location == QtCore.QPoint(square.x() / 80, square.y() / 80):
self.inPlace += 1
if self.inPlace == 25:
self.puzzleCompleted.emit()
else:
self.highlightedRect = QtCore.QRect()
event.ignore()
def makeFromMimeData(mimeData):
'''
Creates a new ClusterNode object from the given QtCore.QMimeData object.
'''
assert mimeData.hasFormat(ClusterNode.sMimeType)
node_data = mimeData.data(ClusterNode.sMimeType)
data_stream = QtCore.QDataStream(node_data, QtCore.QIODevice.ReadOnly)
# The MIME data for an ensemble node contains its XML element, its
# state identifier, and its IP address. All of these are stored as
# QtCore.QString instances.
xml_elt = QtCore.QString()
state = QtCore.QString()
ip_addr = QtCore.QString()
data_stream >> xml_elt >> state >> ip_addr
if len(str(ip_addr)) == 0:
ip_addr = None
else:
ip_addr = str(ip_addr)
return ClusterNode(ET.fromstring(str(xml_elt)),
state.toInt()[0], ip_addr)
def readData(self):
instr = QtCore.QDataStream(self.connection)
if self.connection.bytesAvailable >= 8:
self.renderView.GetActiveCamera().Azimuth(instr.readDouble())
if not self.timer.isActive():
self.timer.start(30)
if self.connection.bytesAvailable() >= 8:
QtCore.QTimer.singleShot(30, self.readData)
def receiveMessage(self):
ins = QtCore.QDataStream(self.socket)
ins.setVersion(QtCore.QDataStream.Qt_4_4)
self.socket.bytesAvailable()
result = QtCore.QByteArray()
ins >> result
self.hasRight = json.loads(forceString(result))
def getScene(self):
instr = QtCore.QDataStream(self.tcpSocket)
instr.setVersion(QtCore.QDataStream.Qt_4_0)
while True:
if self.blockSize == 0:
if self.tcpSocket.bytesAvailable() < 4:
return
self.blockSize = instr.readUInt32()
if self.tcpSocket.bytesAvailable() < self.blockSize:
return
self.blockSize = 0
pix = QtGui.QImage()
ba = QtCore.QByteArray()
instr >> ba
# skip this frame if there is another one in buffer
if self.tcpSocket.bytesAvailable() > 0:
rospy.logdebug("Frame dropped")
continue
# start = time.time()
# 16ms
if not pix.loadFromData(ba, "JPG"):
rospy.logerr("Failed to load image from received data")
return
if self.calibrating or not self.projectors_calibrated or not self.maps_ready:
return
# 3ms
img = pix.convertToFormat(QtGui.QImage.Format_ARGB32)
v = qimage2ndarray.rgb_view(img)
# TODO some further optimalization? this is about 30ms (with INTER_LINEAR)s...
image_np = cv2.remap(v, self.map_x, self.map_y, cv2.INTER_LINEAR)
# this is about 3ms
height, width, channel = image_np.shape
bytesPerLine = 3 * width
image = QtGui.QPixmap.fromImage(
QtGui.QImage(image_np.data, width, height, bytesPerLine,
QtGui.QImage.Format_RGB888))
self.pix_label.setPixmap(image)
self.update()
# end = time.time()
# rospy.logdebug("Frame loaded in: " + str(end-start))
return
def sendMessage(self):
buf = QtCore.QBuffer()
buf.open(QtCore.QBuffer.ReadWrite)
out = QtCore.QDataStream(buf)
out.setVersion(QtCore.QDataStream.Qt_4_4)
out << QtCore.QByteArray(json.dumps(self.hasRight))
self.serverSocket.write(buf.data().data())
self.serverSocket.flush()
def writeToServer(self, action, *args, **kw):
'''
This method is the workhorse of the client, and is used to send messages, queries and commands to the server.
'''
logger.debug("Client: " + action)
block = QtCore.QByteArray()
out = QtCore.QDataStream(block, QtCore.QIODevice.ReadWrite)
out.setVersion(QtCore.QDataStream.Qt_4_2)
out.writeUInt32(0)
out.writeQString(action)
for arg in args:
if type(arg) is IntType:
out.writeInt(arg)
elif isinstance(arg, basestring):
out.writeQString(arg)
elif type(arg) is FloatType:
out.writeFloat(arg)
elif type(arg) is ListType:
out.writeQVariantList(arg)
elif type(arg) is DictType:
out.writeQString(json.dumps(arg))
elif type(arg) is QtCore.QFile:
arg.open(QtCore.QIODevice.ReadOnly)
fileDatas = QtCore.QByteArray(arg.readAll())
#seems that that logger doesn't work
#logger.debug("file size ", int(fileDatas.size()))
out.writeInt(fileDatas.size())
out.writeRawData(fileDatas)
# This may take a while. We display the progress bar so the user get a feedback
self.sendFile = True
self.progress.setLabelText("Sending file to server")
self.progress.setCancelButton(None)
self.progress.setWindowFlags(QtCore.Qt.CustomizeWindowHint
| QtCore.Qt.WindowTitleHint)
self.progress.setAutoClose(True)
self.progress.setMinimum(0)
self.progress.setMaximum(100)
self.progress.setModal(1)
self.progress.setWindowTitle("Uploading in progress")
self.progress.show()
arg.close()
else:
logger.warn("Uninterpreted Data Type: " + str(type(arg)) +
" sent as str: " + str(arg))
out.writeQString(str(arg))
out.device().seek(0)
out.writeUInt32(block.size() - 4)
self.bytesToSend = block.size() - 4
self.socket.write(block)
def save(self, device):
stream = QtCore.QDataStream(device)
stream.writeQString(self.m_name)
stream.writeInt(len(self.m_frames))
for frame in self.m_frames:
stream.writeInt(frame.nodeCount())
for i in range(frame.nodeCount()):
stream << frame.nodePos(i)
def sendMessage():
global sock, timer
bl = QtCore.QByteArray()
out = QtCore.QDataStream(bl, QtCore.QIODevice.WriteOnly)
out.writeDouble(10)
sock.write(bl)
timer.start(30)
def accept(self):
settings = QtCore.QSettings()
for name in self.fontsDict.keys():
font = self.fontsDict.get(name).font()
arr = QtCore.QByteArray()
buf = QtCore.QBuffer(arr)
buf.open(QtCore.QIODevice.WriteOnly)
QtCore.QDataStream(buf) << font
settings.setValue(name, arr)
settings.sync()
super(FontSettingsDialog, self).accept()
def unpackReplay(self,rfile):
rfile = str(rfile)
replay = open(rfile, "rb")
if rfile.endswith(".fafreplay"):
self.fafInfo = json.loads(replay.readline())
self.unpackedFile = QtCore.qUncompress(QtCore.QByteArray.fromBase64(replay.read()))
self.binary = QtCore.QDataStream(self.unpackedFile)
self.binary.setByteOrder(QtCore.QDataStream.LittleEndian)
self.binary.setFloatingPointPrecision(QtCore.QDataStream.SinglePrecision)
#w = open("out.SCFAReplay","wb")
#w.write(self.binary)
#w.close()
else:
self.unpackedFile = QtCore.QByteArray(replay.read())
self.binary = QtCore.QDataStream(self.unpackedFile)
self.binary.setByteOrder(QtCore.QDataStream.LittleEndian)
self.binary.setFloatingPointPrecision(QtCore.QDataStream.SinglePrecision)
replay.close()
def readDataFromServer(self):
self.lastData = time.time() # Keep resetting that timeout counter
ins = QtCore.QDataStream(self.updateSocket)
ins.setVersion(QtCore.QDataStream.Qt_4_2)
while not ins.atEnd():
#log("Bytes Available: %d" % self.updateSocket.bytesAvailable())
# Nothing was read yet, commence a new block.
if self.blockSize == 0:
self.progress.reset()
#wait for enough bytes to piece together block size information
if self.updateSocket.bytesAvailable() < 4:
return
self.blockSize = ins.readUInt32()
if (self.blockSize > 65536):
self.progress.setLabelText("Downloading...")
self.progress.setValue(0)
self.progress.setMaximum(self.blockSize)
else:
self.progress.setValue(0)
self.progress.setMinimum(0)
self.progress.setMaximum(0)
# Update our Gui at least once before proceeding (we might be receiving a huge file and this is not the first time we get here)
self.lastData = time.time()
QtGui.QApplication.processEvents()
#We have an incoming block, wait for enough bytes to accumulate
if self.updateSocket.bytesAvailable() < self.blockSize:
self.progress.setValue(self.updateSocket.bytesAvailable())
return #until later, this slot is reentrant
#Enough bytes accumulated. Carry on.
self.progress.setValue(self.blockSize)
# Update our Gui at least once before proceeding (we might have to write a big file)
self.lastData = time.time()
QtGui.QApplication.processEvents()
# Find out what the server just sent us, and process it.
action = ins.readQString()
self.handleAction(self.blockSize, action, ins)
# Prepare to read the next block
self.blockSize = 0
self.progress.setValue(0)
self.progress.setMinimum(0)
self.progress.setMaximum(0)
def update_socket(self, socket):
self.tcpSocket = socket
self.tcpSocket.disconnected.connect(self.on_disconnect)
self.tcpSocket.readyRead.connect(self.read)
#Reading data
self.blockSize = 0
self.dataStream = QtCore.QDataStream(self.tcpSocket)
self.dataStream.setVersion(QtCore.QDataStream.Qt_4_0)
self.connected = True
#send data if needed
self.send_update_state()
self.send_expDone()
self.send_expFail()
def mimeData(self, items):
mimeData = QtGui.QTreeWidget.mimeData(self, items)
encodedData = QtCore.QByteArray()
stream = QtCore.QDataStream(encodedData, QtCore.QIODevice.WriteOnly)
for item in items:
if isinstance(item, GsLayerItem):
layer = item.element
uri = uri_utils.layerMimeUri(layer)
stream.writeQString(uri)
mimeData.setData(self.QGIS_URI_MIME, encodedData)
return mimeData
