def destinationsRect(self, destinations):
"""Return the rectangle containing all destinations."""
layout = self.view.surface().pageLayout()
rect = QRect()
for dest in destinations:
for pageNum, r in dest:
rect = rect.united(layout[pageNum].linkRect(r.normalized()))
# not larger than viewport
rect.setSize(rect.size().boundedTo(self.view.viewport().size()))
return rect
def destinationsRect(self, destinations):
"""Return the rectangle containing all destinations."""
layout = self.view.surface().pageLayout()
rect = QRect()
for dest in destinations:
for pageNum, r in dest:
rect = rect.united(layout[pageNum].linkRect(r.normalized()))
# not larger than viewport
rect.setSize(rect.size().boundedTo(self.view.viewport().size()))
return rect
def createOnlineIcon(self,color): dim = QRect(0,0,32,32) img = QImage(dim.size(),QImage.Format_ARGB32) p = QPainter(img) p.setCompositionMode(QPainter.CompositionMode_Source) p.fillRect(dim,Qt.transparent) p.setCompositionMode(QPainter.CompositionMode_SourceOver) p.setRenderHints(QPainter.Antialiasing) p.setPen(Qt.black) p.setBrush(color) p.drawEllipse(dim.adjusted(1,1,-2,-2)) return img
def createOnlineIcon(self, color):
dim = QRect(0, 0, 32, 32)
img = QImage(dim.size(), QImage.Format_ARGB32)
p = QPainter(img)
p.setCompositionMode(QPainter.CompositionMode_Source)
p.fillRect(dim, Qt.transparent)
p.setCompositionMode(QPainter.CompositionMode_SourceOver)
p.setRenderHints(QPainter.Antialiasing)
p.setPen(Qt.black)
p.setBrush(color)
p.drawEllipse(dim.adjusted(1, 1, -2, -2))
return img
def drawBackground(self, painter, rect):
QGraphicsView.drawBackground(self, painter, rect)
if not self.__backgroundIcon.isNull():
painter.setClipRect(rect)
vrect = QRect(QPoint(0, 0), self.viewport().size())
vrect = self.mapToScene(vrect).boundingRect()
pm = self.__backgroundIcon.pixmap(vrect.size().toSize().boundedTo(
QSize(200, 200)))
pmrect = QRect(QPoint(0, 0), pm.size())
pmrect.moveCenter(vrect.center().toPoint())
if rect.toRect().intersects(pmrect):
painter.drawPixmap(pmrect, pm)
def drawBackground(self, painter, rect):
QGraphicsView.drawBackground(self, painter, rect)
if not self.__backgroundIcon.isNull():
painter.setClipRect(rect)
vrect = QRect(QPoint(0, 0), self.viewport().size())
vrect = self.mapToScene(vrect).boundingRect()
pm = self.__backgroundIcon.pixmap(
vrect.size().toSize().boundedTo(QSize(200, 200))
)
pmrect = QRect(QPoint(0, 0), pm.size())
pmrect.moveCenter(vrect.center().toPoint())
if rect.toRect().intersects(pmrect):
painter.drawPixmap(pmrect, pm)
def render(self,fname):
contentsSize = self.contentFrame.contentsSize()
contentsSize -= QSize(self.m_scrollPosition.x(), self.m_scrollPosition.y())
frameRect = QRect(QPoint(0, 0), contentsSize)
#if not self.m_clipRect.isEmpty():
# frameRect = self.m_clipRect
viewportSize = self.contentPage.viewportSize()
self.contentPage.setViewportSize(contentsSize)
image = QImage(frameRect.size(), QImage.Format_ARGB32)
image.fill(qRgba(255, 255, 255, 0))
painter = QPainter()
# We use tiling approach to work-around Qt software rasterizer bug
# when dealing with very large paint device.
# See http://code.google.com/p/phantomjs/issues/detail?id=54.
tileSize = 4096
htiles = (image.width() + tileSize - 1) / tileSize
vtiles = (image.height() + tileSize - 1) / tileSize
for x in range(htiles):
for y in range(vtiles):
tileBuffer = QImage(tileSize, tileSize, QImage.Format_ARGB32)
tileBuffer.fill(qRgba(255, 255, 255, 0))
# Render the web page onto the small tile first
painter.begin(tileBuffer)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.translate(-frameRect.left(), -frameRect.top())
painter.translate(-x * tileSize, -y * tileSize)
self.contentFrame.render(painter, QRegion(frameRect))
painter.end()
# Copy the tile to the main buffer
painter.begin(image)
painter.setCompositionMode(QPainter.CompositionMode_Source)
painter.drawImage(x * tileSize, y * tileSize, tileBuffer)
painter.end()
self.contentPage.setViewportSize(viewportSize)
image.save(fname)
return True
def renderImage(self):
contentsSize = self.m_mainFrame.contentsSize()
contentsSize -= QSize(self.m_scrollPosition.x(), self.m_scrollPosition.y())
frameRect = QRect(QPoint(0, 0), contentsSize)
if not self.m_clipRect.isEmpty():
frameRect = self.m_clipRect
viewportSize = self.m_webPage.viewportSize()
self.m_webPage.setViewportSize(contentsSize)
image = QImage(frameRect.size(), QImage.Format_ARGB32)
image.fill(qRgba(255, 255, 255, 0))
painter = QPainter()
# We use tiling approach to work-around Qt software rasterizer bug
# when dealing with very large paint device.
# See http://code.google.com/p/phantomjs/issues/detail?id=54.
tileSize = 4096
htiles = (image.width() + tileSize - 1) / tileSize
vtiles = (image.height() + tileSize - 1) / tileSize
for x in range(htiles):
for y in range(vtiles):
tileBuffer = QImage(tileSize, tileSize, QImage.Format_ARGB32)
tileBuffer.fill(qRgba(255, 255, 255, 0))
# Render the web page onto the small tile first
painter.begin(tileBuffer)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.translate(-frameRect.left(), -frameRect.top())
painter.translate(-x * tileSize, -y * tileSize)
self.m_mainFrame.render(painter, QRegion(frameRect))
painter.end()
# Copy the tile to the main buffer
painter.begin(image)
painter.setCompositionMode(QPainter.CompositionMode_Source)
painter.drawImage(x * tileSize, y * tileSize, tileBuffer)
painter.end()
self.m_webPage.setViewportSize(viewportSize)
return image
def verticalGradient(cls, painter: QPainter, spanRect: QRect, clipRect: QRect, lightColored=False):
if StyleHelper.usePixmapCache():
keyColor = cls.baseColor(lightColored)
key = "mh_vertical {1} {2} {3} {4} {5}".format(
spanRect.width(), spanRect.height(), clipRect.width(),
clipRect.height(), keyColor.rgb())
pixmap = QPixmap()
if not QPixmapCache.find(key, pixmap):
pixmap = QPixmap(clipRect.size())
p = QPainter(pixmap)
rect = QRect(0, 0, clipRect.width(), clipRect.height())
StyleHelper._verticalGradientHelper(p, spanRect, rect, lightColored)
p.end()
QPixmapCache.insert(key, pixmap)
painter.drawPixmap(clipRect.topLeft(), pixmap)
else:
StyleHelper._verticalGradientHelper(painter, spanRect, clipRect, lightColored)
class Page(object):
"""Represents a page from a Poppler.Document.
It maintains its own size and can draw itself using the cache.
It also can maintain a list of links and return links at certain
points or rectangles.
The visible attribute (setVisible and visible) defaults to True but
can be set to False to hide the page from a Surface (this is done by
the Layout).
"""
def __init__(self, document, pageNumber):
self._document = document
self._pageNumber = pageNumber
self._pageSize = document.page(pageNumber).pageSize()
self._rotation = popplerqt4.Poppler.Page.Rotate0
self._rect = QRect()
self._scale = 1.0
self._visible = True
self._layout = lambda: None
self._waiting = True # whether image still needs to be generated
def document(self):
"""Returns the document."""
return self._document
def pageNumber(self):
"""Returns the page number."""
return self._pageNumber
def pageSize(self):
"""The page size in points (1/72 inch), taking rotation into account."""
return self._pageSize
def layout(self):
"""Returns the Layout if we are part of one."""
return self._layout()
def visible(self):
"""Returns True if this page is visible (will be displayed)."""
return self._visible
def setVisible(self, visible):
"""Sets whether this page is visible (will be displayed)."""
self._visible = visible
def rect(self):
"""Returns our QRect(), with position and size."""
return self._rect
def size(self):
"""Returns our size."""
return self._rect.size()
def height(self):
"""Returns our height."""
return self._rect.height()
def width(self):
"""Returns our width."""
return self._rect.width()
def pos(self):
"""Returns our position."""
return self._rect.topLeft()
def setPos(self, point):
"""Sets our position (affects the Layout)."""
self._rect.moveTopLeft(point)
def setRotation(self, rotation):
"""Sets our Poppler.Page.Rotation."""
old, self._rotation = self._rotation, rotation
if (old ^ rotation) & 1:
self._pageSize.transpose()
self.computeSize()
def rotation(self):
"""Returns our rotation."""
return self._rotation
def computeSize(self):
"""Recomputes our size."""
xdpi, ydpi = self.layout().dpi() if self.layout() else (72.0, 72.0)
x = round(self._pageSize.width() * xdpi / 72.0 * self._scale)
y = round(self._pageSize.height() * ydpi / 72.0 * self._scale)
self._rect.setSize(QSize(x, y))
def setScale(self, scale):
"""Changes the display scale."""
self._scale = scale
self.computeSize()
def scale(self):
"""Returns our display scale."""
return self._scale
def scaleForWidth(self, width):
"""Returns the scale we need to display ourselves at the given width."""
if self.layout():
return width * 72.0 / self.layout().dpi()[0] / self._pageSize.width()
else:
return float(width) / self._pageSize.width()
def scaleForHeight(self, height):
"""Returns the scale we need to display ourselves at the given height."""
if self.layout():
return height * 72.0 / self.layout().dpi()[1] / self._pageSize.height()
else:
return float(height) / self._pageSize.height()
def setWidth(self, width):
"""Change our scale to force our width to the given value."""
self.setScale(self.scaleForWidth(width))
def setHeight(self, height):
"""Change our scale to force our height to the given value."""
self.setScale(self.scaleForHeight(height))
def paint(self, painter, rect):
update_rect = rect & self.rect()
if not update_rect:
return
image_rect = QRect(update_rect.topLeft() - self.rect().topLeft(), update_rect.size())
image = cache.image(self)
self._waiting = not image
if image:
painter.drawImage(update_rect, image, image_rect)
else:
# schedule an image to be generated, if done our update() method is called
cache.generate(self)
# find suitable image to be scaled from other size
image = cache.image(self, False)
if image:
hscale = float(image.width()) / self.width()
vscale = float(image.height()) / self.height()
image_rect = QRectF(image_rect.x() * hscale, image_rect.y() * vscale,
image_rect.width() * hscale, image_rect.height() * vscale)
painter.drawImage(QRectF(update_rect), image, image_rect)
else:
# draw blank paper, using the background color of the cache rendering (if set)
# or from the document itself.
color = (cache.options(self.document()).paperColor()
or cache.options().paperColor() or self.document().paperColor())
painter.fillRect(update_rect, color)
def update(self):
"""Called when an image is drawn."""
# only redraw when we were waiting for a correctly sized image.
if self._waiting and self.layout():
self.layout().updatePage(self)
def repaint(self):
"""Call this to force a repaint (e.g. when the rendering options are changed)."""
self._waiting = True
cache.generate(self)
def image(self, rect, xdpi=72.0, ydpi=None, options=None):
"""Returns a QImage of the specified rectangle (relative to our layout).
xdpi defaults to 72.0 and ydpi defaults to xdpi.
options may be a render.RenderOptions instance that will set some document
rendering options just before rendering the image.
"""
rect = rect.normalized().intersected(self.rect())
if not rect:
return
rect.translate(-self.pos())
if ydpi is None:
ydpi = xdpi
hscale = (xdpi * self.pageSize().width()) / (72.0 * self.width())
vscale = (ydpi * self.pageSize().height()) / (72.0 * self.height())
x = rect.x() * hscale
y = rect.y() * vscale
w = rect.width() * hscale
h = rect.height() * vscale
with lock(self.document()):
options and options.write(self.document())
page = self.document().page(self._pageNumber)
image = page.renderToImage(xdpi, ydpi, x, y, w, h, self._rotation)
image.setDotsPerMeterX(int(xdpi * 39.37))
image.setDotsPerMeterY(int(ydpi * 39.37))
return image
def linksAt(self, point):
"""Returns a list() of zero or more links touched by point (relative to surface).
The list is sorted with the smallest rectangle first.
"""
# Poppler.Link objects have their linkArea() ranging in width and height
# from 0.0 to 1.0, so divide by resp. height and width of the Page.
point = point - self.pos()
x = float(point.x()) / self.width()
y = float(point.y()) / self.height()
# rotate
if self._rotation:
if self._rotation == popplerqt4.Poppler.Page.Rotate90:
x, y = y, 1-x
elif self._rotation == popplerqt4.Poppler.Page.Rotate180:
x, y = 1-x, 1-y
else: # 270
x, y = 1-y, x
return list(sorted(cache.links(self).at(x, y), key=lambda link: link.linkArea().width()))
def linksIn(self, rect):
"""Returns an unordered set() of links enclosed in rectangle (relative to surface)."""
rect = rect.normalized()
rect.translate(-self.pos())
left = float(rect.left()) / self.width()
top = float(rect.top()) / self.height()
right = float(rect.right()) / self.width()
bottom = float(rect.bottom()) / self.height()
# rotate
if self._rotation:
if self._rotation == popplerqt4.Poppler.Page.Rotate90:
left, top, right, bottom = top, 1-right, bottom, 1-left
elif self._rotation == popplerqt4.Poppler.Page.Rotate180:
left, top, right, bottom = 1-right, 1-bottom, 1-left, 1-top
else: # 270
left, top, right, bottom = 1-bottom, left, 1-top, right
return cache.links(self).inside(left, top, right, bottom)
def linkRect(self, linkarea):
"""Returns a QRect encompassing the linkArea (of a link) in coordinates of our rect()."""
left, top, right, bottom = linkarea.normalized().getCoords()
# rotate
if self._rotation:
if self._rotation == popplerqt4.Poppler.Page.Rotate90:
left, top, right, bottom = 1-bottom, left, 1-top, right
elif self._rotation == popplerqt4.Poppler.Page.Rotate180:
left, top, right, bottom = 1-right, 1-bottom, 1-left, 1-top
else: # 270
left, top, right, bottom = top, 1-right, bottom, 1-left
rect = QRect()
rect.setCoords(left * self.width(), top * self.height(), right * self.width(), bottom * self.height())
rect.translate(self.pos())
return rect
def text(self, rect):
"""Returns text inside rectangle (relative to surface)."""
rect = rect.normalized()
rect.translate(-self.pos())
w, h = self.pageSize().width(), self.pageSize().height()
left = float(rect.left()) / self.width() * w
top = float(rect.top()) / self.height() * h
right = float(rect.right()) / self.width() * w
bottom = float(rect.bottom()) / self.height() * h
if self._rotation:
if self._rotation == popplerqt4.Poppler.Page.Rotate90:
left, top, right, bottom = top, w-right, bottom, w-left
elif self._rotation == popplerqt4.Poppler.Page.Rotate180:
left, top, right, bottom = w-right, h-bottom, w-left, h-top
else: # 270
left, top, right, bottom = h-bottom, left, h-top, right
rect = QRectF()
rect.setCoords(left, top, right, bottom)
with lock(self.document()):
page = self.document().page(self._pageNumber)
return page.text(rect)
def searchRect(self, rectF):
"""Returns a QRect encompassing the given rect (in points) to our position, size and rotation."""
rect = rectF.normalized()
left, top, right, bottom = rect.getCoords()
w, h = self.pageSize().width(), self.pageSize().height()
hscale = self.width() / float(w)
vscale = self.height() / float(h)
if self._rotation:
if self._rotation == popplerqt4.Poppler.Page.Rotate90:
left, top, right, bottom = w-bottom, left, w-top, right
elif self._rotation == popplerqt4.Poppler.Page.Rotate180:
left, top, right, bottom = w-right, h-bottom, w-left, h-top
else: # 270
left, top, right, bottom = top, h-right, bottom, h-left
rect = QRect()
rect.setCoords(left * hscale, top * vscale, right * hscale, bottom * vscale)
return rect
class Phantom(QObject):
def __init__(self, args, parent=None):
QObject.__init__(self, parent)
# variable declarations
self.m_loadStatus = self.m_state = ''
self.m_var = self.m_paperSize = self.m_loadScript_cache = {}
self.m_verbose = args.verbose
self.m_page = WebPage(self)
self.m_clipRect = QRect()
# setup the values from args
self.m_script = args.script.read()
self.m_scriptFile = args.script.name
self.m_scriptDir = os.path.dirname(args.script.name) + '/'
self.m_args = args.script_args
self.m_upload_file = args.upload_file
autoLoadImages = False if args.load_images == 'no' else True
pluginsEnabled = True if args.load_plugins == 'yes' else False
args.script.close()
do_action('PhantomInitPre', Bunch(locals()))
palette = self.m_page.palette()
palette.setBrush(QPalette.Base, Qt.transparent)
self.m_page.setPalette(palette)
if not args.proxy:
QNetworkProxyFactory.setUseSystemConfiguration(True)
else:
proxy = QNetworkProxy(QNetworkProxy.HttpProxy, args.proxy[0],
int(args.proxy[1]))
QNetworkProxy.setApplicationProxy(proxy)
self.m_page.settings().setAttribute(QWebSettings.AutoLoadImages,
autoLoadImages)
self.m_page.settings().setAttribute(QWebSettings.PluginsEnabled,
pluginsEnabled)
self.m_page.settings().setAttribute(
QWebSettings.FrameFlatteningEnabled, True)
self.m_page.settings().setAttribute(
QWebSettings.OfflineStorageDatabaseEnabled, True)
self.m_page.settings().setAttribute(QWebSettings.LocalStorageEnabled,
True)
self.m_page.settings().setLocalStoragePath(
QDesktopServices.storageLocation(QDesktopServices.DataLocation))
self.m_page.settings().setOfflineStoragePath(
QDesktopServices.storageLocation(QDesktopServices.DataLocation))
# Ensure we have a document.body.
self.m_page.mainFrame().setHtml('<html><body></body></html>')
self.m_page.mainFrame().setScrollBarPolicy(Qt.Horizontal,
Qt.ScrollBarAlwaysOff)
self.m_page.mainFrame().setScrollBarPolicy(Qt.Vertical,
Qt.ScrollBarAlwaysOff)
m_netAccessMan = NetworkAccessManager(args.disk_cache,
args.ignore_ssl_errors, self)
self.m_page.setNetworkAccessManager(m_netAccessMan)
# inject our properties and slots into javascript
self.m_page.mainFrame().javaScriptWindowObjectCleared.connect(
self.inject)
self.m_page.loadFinished.connect(self.finish)
do_action('PhantomInitPost', Bunch(locals()))
def execute(self):
if self.m_script.startswith('#!'):
self.m_script = '//' + self.m_script
if self.m_scriptFile.lower().endswith('.coffee'):
coffee = CSConverter(self)
self.m_script = coffee.convert(self.m_script)
self.m_page.mainFrame().evaluateJavaScript(self.m_script)
def finish(self, success):
self.m_loadStatus = 'success' if success else 'fail'
self.m_page.mainFrame().evaluateJavaScript(self.m_script)
def inject(self):
self.m_page.mainFrame().addToJavaScriptWindowObject('phantom', self)
def renderPdf(self, fileName):
p = QPrinter()
p.setOutputFormat(QPrinter.PdfFormat)
p.setOutputFileName(fileName)
p.setResolution(pdf_dpi)
paperSize = self.m_paperSize
if not len(paperSize):
pageSize = QSize(self.m_page.mainFrame().contentsSize())
paperSize['width'] = str(pageSize.width()) + 'px'
paperSize['height'] = str(pageSize.height()) + 'px'
paperSize['border'] = '0px'
if paperSize.get('width') and paperSize.get('height'):
sizePt = QSizeF(ceil(self.stringToPointSize(paperSize['width'])),
ceil(self.stringToPointSize(paperSize['height'])))
p.setPaperSize(sizePt, QPrinter.Point)
elif 'format' in paperSize:
orientation = QPrinter.Landscape if paperSize.get(
'orientation') and paperSize['orientation'].lower(
) == 'landscape' else QPrinter.Portrait
orientation = QPrinter.Orientation(orientation)
p.setOrientation(orientation)
formats = {
'A3': QPrinter.A3,
'A4': QPrinter.A4,
'A5': QPrinter.A5,
'Legal': QPrinter.Legal,
'Letter': QPrinter.Letter,
'Tabloid': QPrinter.Tabloid
}
p.setPaperSize(QPrinter.A4) # fallback
for format, size in formats.items():
if format.lower() == paperSize['format'].lower():
p.setPaperSize(size)
break
else:
return False
border = floor(self.stringToPointSize(
paperSize['border'])) if paperSize.get('border') else 0
p.setPageMargins(border, border, border, border, QPrinter.Point)
self.m_page.mainFrame().print_(p)
return True
def returnValue(self):
return self.m_returnValue
def stringToPointSize(self, string):
units = (('mm', 72 / 25.4), ('cm', 72 / 2.54), ('in', 72.0),
('px', 72.0 / pdf_dpi / 2.54), ('', 72.0 / pdf_dpi / 2.54))
for unit, format in units:
if string.endswith(unit):
value = string.rstrip(unit)
return float(value) * format
return 0
##
# Properties and methods exposed to JavaScript
##
@pyqtProperty('QStringList')
def args(self):
return self.m_args
@pyqtProperty('QVariantMap')
def clipRect(self):
result = {
'width': self.m_clipRect.width(),
'height': self.m_clipRect.height(),
'top': self.m_clipRect.top(),
'left': self.m_clipRect.left()
}
return result
@clipRect.setter
def clipRect(self, size):
names = ('width', 'height', 'top', 'left')
for item in names:
try:
globals()[item] = int(size[item])
if globals()[item] < 0:
if item not in ('top', 'left'):
globals()[item] = 0
except KeyError:
globals()[item] = getattr(self.m_clipRect, item)()
self.m_clipRect = QRect(left, top, width, height)
@pyqtProperty(str)
def content(self):
return self.m_page.mainFrame().toHtml()
@content.setter
def content(self, content):
self.m_page.mainFrame().setHtml(content)
@pyqtSlot()
@pyqtSlot(int)
def exit(self, code=0):
self.m_returnValue = code
self.m_page.loadFinished.disconnect(self.finish)
QTimer.singleShot(0, qApp, SLOT('quit()'))
@pyqtProperty(str)
def loadStatus(self):
return self.m_loadStatus
@pyqtSlot(str, result=bool)
def loadScript(self, script):
if script in self.m_loadScript_cache:
self.m_page.mainFrame().evaluateJavaScript(
self.m_loadScript_cache[script])
return True
scriptFile = script
try:
script = codecs.open(self.m_scriptDir + script, encoding='utf-8')
script = script.read()
except IOError:
return False
if script.startswith('#!'):
script = '//' + script
if scriptFile.lower().endswith('.coffee'):
coffee = CSConverter(self)
script = coffee.convert(script)
self.m_loadScript_cache[scriptFile] = script
self.m_page.mainFrame().evaluateJavaScript(script)
return True
@pyqtSlot(str, name='open')
def open_(self, address):
qDebug('Opening address %s' % address)
self.m_page.triggerAction(QWebPage.Stop)
self.m_loadStatus = 'loading'
self.m_page.mainFrame().setUrl(QUrl(address))
@pyqtProperty('QVariantMap')
def paperSize(self):
return self.m_paperSize
@paperSize.setter
def paperSize(self, size):
self.m_paperSize = size
@pyqtSlot(str, result=bool)
def render(self, fileName):
fileInfo = QFileInfo(fileName)
path = QDir()
path.mkpath(fileInfo.absolutePath())
if fileName.lower().endswith('.pdf'):
return self.renderPdf(fileName)
viewportSize = QSize(self.m_page.viewportSize())
pageSize = QSize(self.m_page.mainFrame().contentsSize())
bufferSize = QSize()
if not self.m_clipRect.isEmpty():
bufferSize = self.m_clipRect.size()
else:
bufferSize = self.m_page.mainFrame().contentsSize()
if pageSize == '':
return False
image = QImage(bufferSize, QImage.Format_ARGB32)
image.fill(qRgba(255, 255, 255, 0))
p = QPainter(image)
p.setRenderHint(QPainter.Antialiasing, True)
p.setRenderHint(QPainter.TextAntialiasing, True)
p.setRenderHint(QPainter.SmoothPixmapTransform, True)
self.m_page.setViewportSize(pageSize)
if not self.m_clipRect.isEmpty():
p.translate(-self.m_clipRect.left(), -self.m_clipRect.top())
self.m_page.mainFrame().render(p, QRegion(self.m_clipRect))
else:
self.m_page.mainFrame().render(p)
p.end()
self.m_page.setViewportSize(viewportSize)
return image.save(fileName)
@pyqtSlot('QWebElement', str)
def setFormInputFile(self, el, fileTag):
self.m_page.m_nextFileTag = fileTag
el.evaluateJavaScript('''(function(target){
var evt = document.createEvent('MouseEvents');
evt.initMouseEvent("click", true, true, window,
0, 0, 0, 0, 0, false, false, false, false, 0, null);
target.dispatchEvent(evt);})(this);''')
@pyqtSlot(int)
def sleep(self, ms):
startTime = QTime.currentTime()
while True:
QApplication.processEvents(QEventLoop.AllEvents, 25)
if startTime.msecsTo(QTime.currentTime()) > ms:
break
usleep(0.005)
@pyqtProperty(str)
def state(self):
return self.m_state
@state.setter
def state(self, value):
self.m_state = value
@pyqtProperty(str)
def userAgent(self):
return self.m_page.m_userAgent
@userAgent.setter
def userAgent(self, ua):
self.m_page.m_userAgent = ua
@pyqtSlot(str, result='QVariant')
@pyqtSlot(int, result='QVariant')
@pyqtSlot(str, 'QVariant')
@pyqtSlot(int, 'QVariant')
def ctx(self, name, value=None):
if not value:
return self.m_var.get(name)
self.m_var[name] = value
@pyqtProperty('QVariantMap')
def version(self):
version = {
'major': version_major,
'minor': version_minor,
'patch': version_patch
}
return version
@pyqtProperty('QVariantMap')
def viewportSize(self):
size = self.m_page.viewportSize()
result = {'width': size.width(), 'height': size.height()}
return result
@viewportSize.setter
def viewportSize(self, size):
names = ('width', 'height')
for item in names:
try:
globals()[item] = int(size[item])
if globals()[item] < 0:
globals()[item] = 0
except KeyError:
globals()[item] = getattr(self.m_page.viewportSize(), item)()
self.m_page.setViewportSize(QSize(width, height))
do_action('Phantom', Bunch(locals()))
def __layout(self):
# position itself over `widget`
widget = self.__widget
if widget is None:
return
alignment = self.__alignment
policy = self.sizePolicy()
if widget.isWindow():
bounds = widget.geometry()
else:
bounds = QRect(widget.mapToGlobal(QPoint(0, 0)),
widget.size())
if self.isWindow():
bounds = bounds
else:
bounds = QRect(self.parent().mapFromGlobal(bounds.topLeft()),
bounds.size())
sh = self.sizeHint()
minsh = self.minimumSizeHint()
minsize = self.minimumSize()
if minsize.isNull():
minsize = minsh
maxsize = bounds.size().boundedTo(self.maximumSize())
minsize = minsize.boundedTo(maxsize)
effectivesh = sh.expandedTo(minsize).boundedTo(maxsize)
hpolicy = policy.horizontalPolicy()
vpolicy = policy.verticalPolicy()
def getsize(hint, minimum, maximum, policy):
if policy == QSizePolicy.Ignored:
return maximum
elif policy & QSizePolicy.ExpandFlag:
return maximum
else:
return max(hint, minimum)
width = getsize(effectivesh.width(), minsize.width(),
maxsize.width(), hpolicy)
heightforw = self.heightForWidth(width)
if heightforw > 0:
height = getsize(heightforw, minsize.height(),
maxsize.height(), vpolicy)
else:
height = getsize(effectivesh.height(), minsize.height(),
maxsize.height(), vpolicy)
size = QSize(width, height)
if alignment & Qt.AlignLeft:
x = bounds.x()
elif alignment & Qt.AlignRight:
x = bounds.right() - size.width()
else:
x = bounds.x() + max(0, bounds.width() - size.width()) // 2
if alignment & Qt.AlignTop:
y = bounds.y()
elif alignment & Qt.AlignBottom:
y = bounds.bottom() - size.height()
else:
y = bounds.y() + max(0, bounds.height() - size.height()) // 2
geom = QRect(QPoint(x, y), size)
self.setGeometry(geom)
class ImageAreaSelector (QtGui.QWidget):
'''This widget provides means to visually crop a portion of
an image by selecting it'''
# pylint: disable=W0612
NAME = 'ImageAreaSelector'
DESCRIPTION = 'A widget used to select part of an image'
AUTHOR = 'Gabriele "Whisky" Visconti'
WEBSITE = ''
# pylint: enable=W0612
selection_changed = QtCore.pyqtSignal()
def __init__(self, pixmap, parent=None):
'''Constructor'''
QtGui.QWidget.__init__(self, parent)
self._pixmap = pixmap
self._selection_rect = QRect()
self._image_origin = QPoint()
self._resize_start = None
self._drag_start = None
self._handle_size = QSize(-10, -10)
self._painter = QtGui.QPainter()
self._hl_color1 = QtGui.QPalette().color(QtGui.QPalette.Highlight)
self._hl_color2 = QtGui.QPalette().color(QtGui.QPalette.Highlight)
self._hl_color2.setAlpha(150)
self._zoom = 1.0
self.adjust_minum_size()
self.setBackgroundRole(QtGui.QPalette.Dark)
self.setMouseTracking(True)
self.setCursor(Qt.CrossCursor)
# -------------------- [BEGIN] QT_OVERRIDE
def mousePressEvent (self, event):
'''Overrides QWidget's mousePressEvent. Handles starting
a new selection, starting a drag operation'''
# pylint: disable=C0103
mouse_pos = event.pos() / self._zoom
sel_rect = self._selection_rect
if not event.button() == Qt.LeftButton:
return
if (not sel_rect.isNull()) and sel_rect.contains(mouse_pos, True):
handle_rect = QRect(sel_rect.bottomRight(), self._handle_size)
if handle_rect.contains(mouse_pos):
self._resize_start = mouse_pos
else:
self._drag_start = mouse_pos
else:
self._resize_start = mouse_pos
sel_rect.setTopLeft (mouse_pos)
self._selection_rect.setSize(QSize(0, 0))
def mouseMoveEvent (self, event):
'''Overrides QWidget's mouseMoveEvent. Handles resizing
and dragging operations on selection'''
# pylint: disable=C0103
sel_rect = self._selection_rect
if self._resize_start:
resize_end = event.pos() / self._zoom
sel_rect.setBottomRight(sel_rect.bottomRight() +
(resize_end - self._resize_start))
self._resize_start = resize_end
self.make_selection_square()
self.update()
elif self._drag_start is not None:
drag_end = event.pos() / self._zoom
sel_rect.translate(drag_end - self._drag_start)
self._drag_start = drag_end
self.update()
# cursor shape:
mouse_pos = event.pos() / self._zoom
if (not sel_rect.isNull()) and sel_rect.contains(mouse_pos, True):
handle_rect = QRect(sel_rect.bottomRight(), self._handle_size)
if handle_rect.contains(mouse_pos):
self.setCursor(Qt.SizeFDiagCursor)
else:
self.setCursor(Qt.OpenHandCursor)
else:
self.setCursor(Qt.CrossCursor)
def mouseReleaseEvent (self, event):
'''Overrides QWidget's mouseReleaseEvent. Handles ending a resizing or
draggin operation on the selection'''
# pylint: disable=C0103
self._selection_rect = self._selection_rect.normalized()
self._resize_start = None
self._drag_start = None
self.update()
if not self._selection_rect.isNull():
self.selection_changed.emit()
def paintEvent(self, event):
'''Overrides QWidtget's paintEvent.'''
# pylint: disable=C0103
QtGui.QWidget.paintEvent(self, event)
self._painter.begin(self)
pixmap_dest_rect = QRect(self._image_origin * self._zoom,
self._pixmap.size()*self._zoom)
self._painter.drawPixmap(pixmap_dest_rect, self._pixmap)
if not self._selection_rect.isNull():
# preparing the darkened frame:
sel_rect = self._selection_rect.normalized()
frame = QtGui.QPixmap(event.rect().size())
frame.fill(QtGui.QColor(0, 0, 0, 127))
frame_painter = QtGui.QPainter(frame)
# erase the selected area from the frame:
frame_painter.setCompositionMode(
QtGui.QPainter.CompositionMode_DestinationIn)
sel_rect_scaled = QRect(sel_rect.topLeft() * self._zoom,
sel_rect.size() * self._zoom)
frame_painter.fillRect(sel_rect_scaled, QtGui.QColor(0, 0, 0, 0))
# draw selection border :
frame_painter.setCompositionMode(
QtGui.QPainter.CompositionMode_SourceOver)
frame_painter.setPen(self._hl_color1)
frame_painter.drawRect(sel_rect_scaled)
# draw the resize grip (if possible)
if sel_rect_scaled.width() > 20 and sel_rect_scaled.height() > 20:
handle_rect = QRect(sel_rect_scaled.bottomRight(),
self._handle_size)
frame_painter.fillRect(handle_rect, self._hl_color2)
frame_painter.drawRect(handle_rect)
frame_painter.end()
# painting the darkened frame:
self._painter.drawPixmap(0, 0, frame)
self._painter.end()
def resizeEvent(self, event):
'''Overrides QWidget's resizeEvent. Handles image centering.'''
# pylint: disable=C0103
self.adjust_image_origin()
# -------------------- [END] QT_OVERRIDE
def adjust_image_origin(self):
'''Recalculates the top left corner's image position, so the
image is painted centered'''
# pylint: disable=C0103
new_size = self.size() / self._zoom
pix_size = self._pixmap.size()
dx = (new_size.width() - pix_size.width() ) /2
dy = (new_size.height() - pix_size.height()) /2
new_image_origin = QPoint(dx, dy)
self._selection_rect.translate(new_image_origin - self._image_origin)
self._image_origin = new_image_origin
log.info('image origin: %s' % new_image_origin)
def select_unscaled(self):
'''Selects, if possible, a 96 x 96 square centered around the original
image. In this way the image won't be scaled but won't take up all the
96 x 96 area.'''
# pylint: disable=C0103
pix_size = self._pixmap.size()
if pix_size.width() <= 96 and pix_size.height() <= 96:
viewport_size = self.size()
x = (viewport_size.width () - 96) / 2
y = (viewport_size.height() - 96) / 2
self._selection_rect.setTopLeft(QPoint(x, y))
self._selection_rect.setSize(QSize(96, 96))
self.update()
self.selection_changed.emit()
def select_all(self):
'''Selects the whole image. Currently broken for images taller
than wide.'''
# TODO: make me work!
self._selection_rect.setTopLeft(self._image_origin)
self._selection_rect.setSize(self._pixmap.size())
self.update()
self.selection_changed.emit()
def rotate_left(self):
'''Rotates the image counterclockwise.'''
self._pixmap = self._pixmap.transformed(QtGui.QTransform().rotate(-90))
self.adjust_minum_size()
self.adjust_image_origin()
self.update()
self.selection_changed.emit()
def rotate_right(self):
'''Rotates the image clockwise'''
self._pixmap = self._pixmap.transformed(QtGui.QTransform().rotate(90))
self.adjust_minum_size()
self.adjust_image_origin()
self.update()
self.selection_changed.emit()
def adjust_minum_size(self):
'''Sets the new minimum size, calculated upon the image size
and the _zoom factor.'''
pixmap = self._pixmap
if pixmap.width() < 96 or pixmap.height() < 96:
min_size = QSize(96, 96)
else:
min_size = pixmap.size()
self.setMinimumSize(min_size*self._zoom)
def make_selection_square(self):
'''Modify the selected area making it square'''
wid = self._selection_rect.width ()
self._selection_rect.setSize(QSize(wid, wid))
def set_zoom(self, zoomlevel):
'''Sets the specified zoomlevel'''
self._zoom = zoomlevel
self.adjust_minum_size()
self.adjust_image_origin()
self.update()
self.selection_changed.emit()
def fit_zoom(self):
'''Chooses a zoomlevel that makes visible the entire image.
Currently broken.'''
widget_wid = self.size().width ()
widget_hei = self.size().height()
pixmap_wid = self._pixmap.width ()
pixmap_hei = self._pixmap.height()
self._zoom = (min(widget_wid, widget_hei) /
min(pixmap_wid, pixmap_hei))
self.adjust_minum_size()
self.adjust_image_origin()
self.update()
self.selection_changed.emit()
def get_selected_pixmap(self):
'''Returns the pixmap contained in the selection rect.
Currently doesn't handle transparency correctly'''
sel_rect_scaled = QRect(self._selection_rect.topLeft() * self._zoom,
self._selection_rect.size() * self._zoom)
return QtGui.QPixmap.grabWidget(self, sel_rect_scaled)
class Page(object):
"""Represents a page from a Poppler.Document.
It maintains its own size and can draw itself using the cache.
It also can maintain a list of links and return links at certain
points or rectangles.
The visible attribute (setVisible and visible) defaults to True but
can be set to False to hide the page from a Surface (this is done by
the Layout).
"""
def __init__(self, document, pageNumber):
self._document = document
self._pageNumber = pageNumber
self._pageSize = document.page(pageNumber).pageSize()
self._rotation = popplerqt4.Poppler.Page.Rotate0
self._rect = QRect()
self._scale = 1.0
self._visible = True
self._layout = lambda: None
self._waiting = True # whether image still needs to be generated
def document(self):
"""Returns the document."""
return self._document
def pageNumber(self):
"""Returns the page number."""
return self._pageNumber
def pageSize(self):
"""The page size in points (1/72 inch), taking rotation into account."""
return self._pageSize
def layout(self):
"""Returns the Layout if we are part of one."""
return self._layout()
def visible(self):
"""Returns True if this page is visible (will be displayed)."""
return self._visible
def setVisible(self, visible):
"""Sets whether this page is visible (will be displayed)."""
self._visible = visible
def rect(self):
"""Returns our QRect(), with position and size."""
return self._rect
def size(self):
"""Returns our size."""
return self._rect.size()
def height(self):
"""Returns our height."""
return self._rect.height()
def width(self):
"""Returns our width."""
return self._rect.width()
def pos(self):
"""Returns our position."""
return self._rect.topLeft()
def setPos(self, point):
"""Sets our position (affects the Layout)."""
self._rect.moveTopLeft(point)
def setRotation(self, rotation):
"""Sets our Poppler.Page.Rotation."""
old, self._rotation = self._rotation, rotation
if (old ^ rotation) & 1:
self._pageSize.transpose()
self.computeSize()
def rotation(self):
"""Returns our rotation."""
return self._rotation
def computeSize(self):
"""Recomputes our size."""
xdpi, ydpi = self.layout().dpi() if self.layout() else (72.0, 72.0)
x = round(self._pageSize.width() * xdpi / 72.0 * self._scale)
y = round(self._pageSize.height() * ydpi / 72.0 * self._scale)
self._rect.setSize(QSize(x, y))
def setScale(self, scale):
"""Changes the display scale."""
self._scale = scale
self.computeSize()
def scale(self):
"""Returns our display scale."""
return self._scale
def scaleForWidth(self, width):
"""Returns the scale we need to display ourselves at the given width."""
if self.layout():
return width * 72.0 / self.layout().dpi(
)[0] / self._pageSize.width()
else:
return float(width) / self._pageSize.width()
def scaleForHeight(self, height):
"""Returns the scale we need to display ourselves at the given height."""
if self.layout():
return height * 72.0 / self.layout().dpi(
)[1] / self._pageSize.height()
else:
return float(height) / self._pageSize.height()
def setWidth(self, width):
"""Change our scale to force our width to the given value."""
self.setScale(self.scaleForWidth(width))
def setHeight(self, height):
"""Change our scale to force our height to the given value."""
self.setScale(self.scaleForHeight(height))
def image(self):
"""Render the page as an image or our size. Return a QImage."""
d = self._document
w, h, r = self.width(), self.height(), self.rotation()
page = d.page(self._pageNumber)
pageSize = page.pageSize()
if r & 1:
pageSize.transpose()
xres = 72.0 * w / pageSize.width()
yres = 72.0 * h / pageSize.height()
threshold = cache.options().oversampleThreshold() or cache.options(
d).oversampleThreshold()
multiplier = 2 if xres < threshold else 1
with lock(d):
cache.options().write(d)
cache.options(d).write(d)
image = page.renderToImage(xres * multiplier, yres * multiplier, 0,
0, w * multiplier, h * multiplier, r)
if multiplier == 2:
image = image.scaledToWidth(w, Qt.SmoothTransformation)
return image
def paint(self, painter, rect):
update_rect = rect & self.rect()
if not update_rect:
return
image_rect = QRect(update_rect.topLeft() - self.rect().topLeft(),
update_rect.size())
image = cache.image(self)
self._waiting = not image
if image:
painter.drawImage(update_rect, image, image_rect)
else:
# schedule an image to be generated, if done our update() method is called
cache.generate(self)
# find suitable image to be scaled from other size
image = cache.image(self, False)
if image:
hscale = float(image.width()) / self.width()
vscale = float(image.height()) / self.height()
image_rect = QRectF(image_rect.x() * hscale,
image_rect.y() * vscale,
image_rect.width() * hscale,
image_rect.height() * vscale)
painter.drawImage(QRectF(update_rect), image, image_rect)
else:
# draw blank paper, using the background color of the cache rendering (if set)
# or from the document itself.
color = (cache.options(self.document()).paperColor()
or cache.options().paperColor()
or self.document().paperColor())
painter.fillRect(update_rect, color)
def update(self):
"""Called when an image is drawn."""
# only redraw when we were waiting for a correctly sized image.
if self._waiting and self.layout():
self.layout().updatePage(self)
def repaint(self):
"""Call this to force a repaint (e.g. when the rendering options are changed)."""
self._waiting = True
cache.generate(self)
def image(self, rect, xdpi=72.0, ydpi=None, options=None):
"""Returns a QImage of the specified rectangle (relative to our layout).
xdpi defaults to 72.0 and ydpi defaults to xdpi.
options may be a render.RenderOptions instance that will set some document
rendering options just before rendering the image.
"""
rect = rect.normalized().intersected(self.rect())
if not rect:
return
rect.translate(-self.pos())
if ydpi is None:
ydpi = xdpi
hscale = (xdpi * self.pageSize().width()) / (72.0 * self.width())
vscale = (ydpi * self.pageSize().height()) / (72.0 * self.height())
x = rect.x() * hscale
y = rect.y() * vscale
w = rect.width() * hscale
h = rect.height() * vscale
with lock(self.document()):
options and options.write(self.document())
page = self.document().page(self._pageNumber)
image = page.renderToImage(xdpi, ydpi, x, y, w, h, self._rotation)
image.setDotsPerMeterX(int(xdpi * 39.37))
image.setDotsPerMeterY(int(ydpi * 39.37))
return image
def linksAt(self, point):
"""Returns a list() of zero or more links touched by point (relative to surface).
The list is sorted with the smallest rectangle first.
"""
# Poppler.Link objects have their linkArea() ranging in width and height
# from 0.0 to 1.0, so divide by resp. height and width of the Page.
point = point - self.pos()
x = float(point.x()) / self.width()
y = float(point.y()) / self.height()
# rotate
if self._rotation:
if self._rotation == popplerqt4.Poppler.Page.Rotate90:
x, y = y, 1 - x
elif self._rotation == popplerqt4.Poppler.Page.Rotate180:
x, y = 1 - x, 1 - y
else: # 270
x, y = 1 - y, x
return list(
sorted(cache.links(self).at(x, y),
key=lambda link: link.linkArea().width()))
def linksIn(self, rect):
"""Returns an unordered set() of links enclosed in rectangle (relative to surface)."""
rect = rect.normalized()
rect.translate(-self.pos())
left = float(rect.left()) / self.width()
top = float(rect.top()) / self.height()
right = float(rect.right()) / self.width()
bottom = float(rect.bottom()) / self.height()
# rotate
if self._rotation:
if self._rotation == popplerqt4.Poppler.Page.Rotate90:
left, top, right, bottom = top, 1 - right, bottom, 1 - left
elif self._rotation == popplerqt4.Poppler.Page.Rotate180:
left, top, right, bottom = 1 - right, 1 - bottom, 1 - left, 1 - top
else: # 270
left, top, right, bottom = 1 - bottom, left, 1 - top, right
return cache.links(self).inside(left, top, right, bottom)
def linkRect(self, linkarea):
"""Returns a QRect encompassing the linkArea (of a link) in coordinates of our rect()."""
left, top, right, bottom = linkarea.normalized().getCoords()
# rotate
if self._rotation:
if self._rotation == popplerqt4.Poppler.Page.Rotate90:
left, top, right, bottom = 1 - bottom, left, 1 - top, right
elif self._rotation == popplerqt4.Poppler.Page.Rotate180:
left, top, right, bottom = 1 - right, 1 - bottom, 1 - left, 1 - top
else: # 270
left, top, right, bottom = top, 1 - right, bottom, 1 - left
rect = QRect()
rect.setCoords(left * self.width(), top * self.height(),
right * self.width(), bottom * self.height())
rect.translate(self.pos())
return rect
def text(self, rect):
"""Returns text inside rectangle (relative to surface)."""
rect = rect.normalized()
rect.translate(-self.pos())
w, h = self.pageSize().width(), self.pageSize().height()
left = float(rect.left()) / self.width() * w
top = float(rect.top()) / self.height() * h
right = float(rect.right()) / self.width() * w
bottom = float(rect.bottom()) / self.height() * h
if self._rotation:
if self._rotation == popplerqt4.Poppler.Page.Rotate90:
left, top, right, bottom = top, w - right, bottom, w - left
elif self._rotation == popplerqt4.Poppler.Page.Rotate180:
left, top, right, bottom = w - right, h - bottom, w - left, h - top
else: # 270
left, top, right, bottom = h - bottom, left, h - top, right
rect = QRectF()
rect.setCoords(left, top, right, bottom)
with lock(self.document()):
page = self.document().page(self._pageNumber)
return page.text(rect)
def searchRect(self, rectF):
"""Returns a QRect encompassing the given rect (in points) to our position, size and rotation."""
rect = rectF.normalized()
left, top, right, bottom = rect.getCoords()
w, h = self.pageSize().width(), self.pageSize().height()
hscale = self.width() / float(w)
vscale = self.height() / float(h)
if self._rotation:
if self._rotation == popplerqt4.Poppler.Page.Rotate90:
left, top, right, bottom = w - bottom, left, w - top, right
elif self._rotation == popplerqt4.Poppler.Page.Rotate180:
left, top, right, bottom = w - right, h - bottom, w - left, h - top
else: # 270
left, top, right, bottom = top, h - right, bottom, h - left
rect = QRect()
rect.setCoords(left * hscale, top * vscale, right * hscale,
bottom * vscale)
return rect
class PlottingThread(QThread):
def __init__(self, parent):
QThread.__init__(self)
self.result = None
self.parent = parent
self._stopped = False
self.mutex = QMutex()
self.filePrefix = None
self.fileFormat = None
self.wallColoring = None
self.cellColoring = None
self.pointColoring = None
self.extraDrawing = []
self.pointSize = None
self.pointLineColor = None
self.pointLineThickness = None
self.ellipsisDraw = None
self.overSampling = None
self.wallThickness = None
self.bgColor = None
self.loading = False
self._crop = QRect(0,0,1,1)
self._pix = None
self._end_image_plot = False
self._loading_arguments = {}
self.retryObject = None
def end_step(self):
return len(self.result)+1
def stop(self, value = True):
self.mutex.lock()
self._stopped = value
self.mutex.unlock()
def stopped(self):
self.mutex.lock()
val = self._stopped
self.mutex.unlock()
return val
def nextImage(self):
QCoreApplication.postEvent(self.parent, NextImageEvent())
def abort(self, reason, **others):
e = AbortPlottingEvent(reason)
if others:
e.others = others
QCoreApplication.postEvent(self.parent, e)
def finished(self):
if self.loading:
QCoreApplication.postEvent(self.parent, FinishLoadingEvent())
self.loading = False
else:
QCoreApplication.postEvent(self.parent, FinishPlottingEvent())
def image_ready(self):
QCoreApplication.postEvent(self.parent, ImageReadyPlottingEvent())
def update_nb_images(self, nb):
QCoreApplication.postEvent(self.parent, UpdateNbImageEvent(nb))
@property
def crop_left(self):
return self._crop.left()
@crop_left.setter
def crop_left(self, value):
self._crop.moveLeft(int(value))
@property
def crop_top(self):
return self._crop.top()
@crop_top.setter
def crop_top(self, value):
self._crop.moveTop(int(value))
@property
def crop_width(self):
return self._crop.width()
@crop_width.setter
def crop_width(self, value):
self._crop.setWidth(int(value))
@property
def crop_height(self):
return self._crop.height()
@crop_height.setter
def crop_height(self, value):
self._crop.setHeight(int(value))
def reset_crop(self):
self._crop = QRect(QPoint(0,0), self.img_size)
@property
def crop(self):
return QRect(self._crop)
@crop.deleter
def crop(self):
self.reset_crop()
@property
def end_image_plot(self):
'''
If true, plot the growth data on the end image rather than the start image of the growth calculation.
'''
return self._end_image_plot
@end_image_plot.setter
def end_image_plot(self, value):
self._end_image_plot = bool(value)
@property
def pix(self):
'''Thread-safe image storage.'''
self.mutex.lock()
pix = self._pix
self.mutex.unlock()
return pix
@pix.setter
def pix(self, value):
self.mutex.lock()
self._pix = value
self.mutex.unlock()
def render_valid(self):
if self.result is None:
log_debug("result is None")
return False
if self.parent is None:
log_debug("parent is None")
return False
if self.ellipsisDraw is None:
log_debug("ellipsisDraw is None")
return False
if self.cellColoring is None:
log_debug("cellColoring is None")
return False
if self.wallColoring is None:
log_debug("wallColoring is None")
return False
if self.pointColoring is None:
log_debug("pointColoring is None")
return False
if self.pointSize is None:
log_debug("pointSize is None")
return False
if self.pointLineThickness is None:
log_debug("pointSize is None")
return False
if self.pointLineColor is None:
log_debug("pointSize is None")
return False
if self.wallThickness is None:
log_debug("wallThickness is None")
return False
if self.overSampling is None:
log_debug("overSampling is None")
return False
if self.bgColor is None:
log_debug("bgColor is None")
return False
return True
def valid(self):
if self.filePrefix is None:
log_debug("filePrefix is None")
return False
if not self.filePrefix:
log_debug("filePrefix is Empty")
return False
if self.fileFormat is None:
log_debug("fileFormat is None")
return False
return self.render_valid()
def drawImage(self, imageid):
cache = image_cache.cache
cellColoring = self.cellColoring
wallColoring = self.wallColoring
pointColoring = self.pointColoring
ellipsisDraw = self.ellipsisDraw
overSampling = self.overSampling
extraDrawing = self.extraDrawing
bgColor = self.bgColor.rgb()
result = self.result
if self.result_type == "Data":
data = result
img_name = result.images_name[imageid]
else:
data = result.data
img_name = result.images[imageid]
#scale = data.images_scale[img_name]
min_scale = data.minScale()
img = cache.image(data.image_path(img_name))
img_data = data[img_name]
size = self._crop.size()
pix = QImage(size*overSampling, QImage.Format_ARGB32)
pix.fill(bgColor)
painter = QPainter()
if not painter.begin(pix):
self.abort("Cannot create painter on QImage")
return None, None, None
painter.setRenderHints(QPainter.SmoothPixmapTransform, True)
painter.setRenderHints(QPainter.Antialiasing, True)
if overSampling > 1:
painter.scale(overSampling, overSampling)
painter.translate(-self._crop.topLeft())
painter.save()
painter.translate(self.translate)
log_debug("Translating: %gx%g" % (self.translate.x(), self.translate.y()) )
painter.scale(1/min_scale, 1/min_scale)
painter.save()
matrix = img_data.matrix()
painter.setWorldTransform(matrix, True)
painter.drawImage(QPoint(0,0), img)
painter.restore()
#pt_matrix = QTransform()
#pt_matrix.scale(1/min_scale, 1/min_scale)
#painter.setTransform(pt_matrix, True)
cellColoring.startImage(painter, imageid)
wallColoring.startImage(painter, imageid)
for ed in extraDrawing:
ed.startImage(painter, imageid)
if self.result_type == "Growth":
cells = result.cells[imageid]
walls = result.walls[imageid]
else:
cells = img_data.cells
walls = set()
for cid in img_data.cells:
pts = [ pt for pt in data.cells[cid] if pt in img_data ]
if len(pts) > 1:
for i in range(len(pts)):
walls.add(data.wallId(pts[i-1], pts[i]))
# Now, draw the cells and the ellipsis
for cid in cells:
painter.setPen(Qt.NoPen)
color = cellColoring(imageid, cid)
painter.setBrush(color)
pts = data.cellAtTime(cid, img_data.index)
if pts:
pts.append(pts[0])
ppts = []
for p1,p2 in zip(pts[:-1], pts[1:]):
ppts.append(img_data[p1])
ppts.extend(img_data.walls[p1,p2])
ppts.append(ppts[0])
poly = QPolygonF(ppts)
painter.drawPolygon(poly)
# And draw the walls
wallThickness = self.wallThickness*min_scale
for wid in walls:
color = wallColoring(imageid, wid)
if color.alpha() > 0:
pen = QPen(color)
pen.setWidthF(wallThickness)
painter.setPen(pen)
pts = [img_data[wid[0]]] + img_data.walls[wid[0], wid[1]] + [img_data[wid[1]]]
#painter.drawLine(img_data[wid[0]], img_data[wid[1]])
painter.drawPolyline(*pts)
# Then, draw the points
pointSize = self.pointSize*min_scale
pointLineColor = self.pointLineColor
pointLineThickness = self.pointLineThickness*min_scale
log_debug("pointSize = %g" % pointSize)
for pid in img_data:
color = pointColoring(imageid, pid)
if color.alpha() > 0:
pen = QPen(pointLineColor)
pen.setWidthF(pointLineThickness)
brush = QBrush(color)
painter.setPen(pen)
painter.setBrush(brush)
pos = img_data[pid]
rect = QRectF(pos.x()-pointSize, pos.y()-pointSize, 2*pointSize, 2*pointSize)
painter.drawEllipse(rect)
if ellipsisDraw.plot:
for cid in cells:
pts = data.cellAtTime(cid, img_data.index)
if pts:
pts.append(pts[0])
ppts = []
for p1,p2 in zip(pts[:-1], pts[1:]):
ppts.append(img_data[p1])
ppts.extend(img_data.walls[p1,p2])
ppts.append(ppts[0])
#poly = QPolygonF(ppts)
#painter.drawPolygon(poly)
ellipsisDraw(painter, imageid, cid, ppts, min_scale)
# At last, draw the extra data
for ed in extraDrawing:
ed(painter, imageid)
tr = painter.worldTransform()
painter.restore()
pic_w = wallColoring.finalizeImage(painter, imageid, tr, self.crop)
pic_c = cellColoring.finalizeImage(painter, imageid, tr, self.crop)
for ed in extraDrawing:
ed.finalizeImage(painter, imageid, tr, self.crop)
painter.end()
return pix, pic_w, pic_c
def start(self):
if self.isRunning():
assert not self.rendering_all, "Cannot run twice the rendering of all images with the same object."
return
if parameters.instance.use_thread:
log_debug("Starting rendering thread.")
QThread.start(self)
return False
else:
self.run()
return True
def render_all(self):
self.rendering_all = True
return self.start()
def render_single(self, img_id, retry=False):
if retry:
while self.isRunning():
self.wait(10000)
elif self.isRunning():
return
self.rendering_all = False
self.current_image = img_id
return self.start()
def load(self, filename):
self.loading = True
self.result = filename
return self.start()
def run(self):
if self.loading:
self.run_loader()
elif self.rendering_all:
self.run_full()
else:
self.run_single()
def run_single(self):
img = self.current_image
self.cellColoring.init()
self.wallColoring.init()
self.pointColoring.init()
log_debug("Rendering image %d" % img)
self.pix, self.pic_w, self.pic_c = self.drawImage(img)
if self.pic_w is not None:
log_debug("Has wall image")
if self.pic_c is not None:
log_debug("Has cell image")
if self.pix is not None:
log_debug("Pix correctly rendered")
log_debug("Rendered image %d = %s" % (img, self.pix))
self.image_ready()
def reload(self):
if self.retryObject is None:
return
self._loading_arguments.update(self.retryObject.method_args)
self.load(self.retryObject.filename)
def run_loader(self):
filename = self.result
try:
self.retryObject = None
# First, prepare the data by getting the images and computing how big they
# should be
f = open(filename)
first_line = f.readline()
f.close()
if first_line.startswith("TRKR_VERSION"):
result = Result(None)
result.load(self.result, **self._loading_arguments)
result_type = "Growth"
else:
result = TrackingData()
result.load(self.result, **self._loading_arguments)
result_type = "Data"
self.result = result
self.result_type = result_type
if result_type == "Data":
data = result
images = data.images_name
if data.cells:
self.has_cells = True
self.has_walls = True
else:
self.has_cells = False
self.has_walls = False
self.has_points = bool(data.cell_points)
else:
data = result.data
images = result.images
self.has_cells = False
self.has_walls = False
self.has_points = False
self.images = images
cache = image_cache.cache
self.update_nb_images(len(result))
bbox = QRectF()
ms = data.minScale()
for i in range(len(result)):
img_name = images[i]
img_data = data[img_name]
img = cache.image(data.image_path(img_name))
matrix = QTransform()
matrix = img_data.matrix()
sc = QTransform()
sc.scale(1.0/ms, 1.0/ms)
matrix *= sc
r = QRectF(img.rect())
rbox = matrix.map(QPolygonF(r)).boundingRect()
bbox |= rbox
log_debug("Image '%s':\n\tSize = %gx%g\n\tTransformed = %gx%g %+g %+g\n\tGlobal bbox = %gx%g %+g %+g\n" %
(img_name, r.width(), r.height(), rbox.width(), rbox.height(), rbox.left(), rbox.top(),
bbox.width(), bbox.height(), bbox.left(), bbox.top()))
log_debug("Matrix:\n%g\t%g\t%g\n%g\t%g\t%g\n" %
(matrix.m11(), matrix.m12(), matrix.dx(), matrix.m21(), matrix.m22(), matrix.dy()))
if result_type == "Growth":
if result.cells[i]:
self.has_cells = True
if result.walls[i]:
self.has_walls = True
self.has_points = bool(result.data.cell_points)
self.nextImage()
translate = bbox.topLeft()
translate *= -1
self.translate = translate
size = bbox.size().toSize()
self.img_size = size
self._crop = QRect(QPoint(0,0), size)
self.finished()
self._loading_arguments = {} # All done, we don't need that anymore
except RetryTrackingDataException as ex:
ex.filename = filename
self.retryObject = ex
self.finished()
return
except Exception as ex:
_, _, exceptionTraceback = sys.exc_info()
self.abort(ex, traceback=exceptionTraceback)
raise
def run_full(self):
if not self.valid():
self.abort("Object was not correctly initialized")
return
self.stop(False)
painter = None
try:
result = self.result
self.update_nb_images(len(result))
# if self.result_type == "Data":
# data = result
# images = result.images_name
# else:
# data = result.data
# images = result.images
# cache = image_cache.cache
cellColoring = self.cellColoring
wallColoring = self.wallColoring
pointColoring = self.pointColoring
file_format = self.fileFormat
file_pattern = "%s%%0%dd.%s" % (self.filePrefix, len(str(len(result))), file_format)
wall_file_pattern = "%s%%0%dd_wall.%s" % (self.filePrefix, len(str(len(result))), file_format)
cell_file_pattern = "%s%%0%dd_cell.%s" % (self.filePrefix, len(str(len(result))), file_format)
cellColoring.init()
wallColoring.init()
pointColoring.init()
self.nextImage()
for i in range(len(result)):
if self.stopped():
self.abort("User interruption")
return
pix, pic_w, pic_c = self.drawImage(i)
pix.save(file_pattern % (i+1), file_format)
if pic_w is not None:
self.saveExtra(pic_w, wall_file_pattern % (i+1), file_format)
if pic_c is not None:
self.saveExtra(pic_c, cell_file_pattern % (i+1), file_format)
self.nextImage()
self.finished()
except Exception as ex:
if painter is not None:
painter.end()
_, _, exceptionTraceback = sys.exc_info()
self.abort(ex, traceback=exceptionTraceback)
raise
def saveExtra(self, picture, file_name, file_format):
rect = picture.boundingRect()
pix = QImage(rect.size(), QImage.Format_ARGB32)
pix.fill(QColor(0, 0, 0, 0).rgba())
paint = QPainter()
paint.begin(pix)
paint.drawPicture(rect.topLeft()*-1, picture)
paint.end()
pix.save(file_name, file_format)
class Phantom(QObject):
def __init__(self, args, parent=None):
QObject.__init__(self, parent)
# variable declarations
self.m_loadStatus = self.m_state = ''
self.m_var = self.m_paperSize = self.m_loadScript_cache = {}
self.m_verbose = args.verbose
self.m_page = WebPage(self)
self.m_clipRect = QRect()
# setup the values from args
self.m_script = args.script.read()
self.m_scriptFile = args.script.name
self.m_scriptDir = os.path.dirname(args.script.name) + '/'
self.m_args = args.script_args
self.m_upload_file = args.upload_file
autoLoadImages = False if args.load_images == 'no' else True
pluginsEnabled = True if args.load_plugins == 'yes' else False
args.script.close()
do_action('PhantomInitPre', Bunch(locals()))
palette = self.m_page.palette()
palette.setBrush(QPalette.Base, Qt.transparent)
self.m_page.setPalette(palette)
if not args.proxy:
QNetworkProxyFactory.setUseSystemConfiguration(True)
else:
proxy = QNetworkProxy(QNetworkProxy.HttpProxy, args.proxy[0], int(args.proxy[1]))
QNetworkProxy.setApplicationProxy(proxy)
self.m_page.settings().setAttribute(QWebSettings.AutoLoadImages, autoLoadImages)
self.m_page.settings().setAttribute(QWebSettings.PluginsEnabled, pluginsEnabled)
self.m_page.settings().setAttribute(QWebSettings.FrameFlatteningEnabled, True)
self.m_page.settings().setAttribute(QWebSettings.OfflineStorageDatabaseEnabled, True)
self.m_page.settings().setAttribute(QWebSettings.LocalStorageEnabled, True)
self.m_page.settings().setLocalStoragePath(QDesktopServices.storageLocation(QDesktopServices.DataLocation))
self.m_page.settings().setOfflineStoragePath(QDesktopServices.storageLocation(QDesktopServices.DataLocation))
# Ensure we have a document.body.
self.m_page.mainFrame().setHtml('<html><body></body></html>')
self.m_page.mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
self.m_page.mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
m_netAccessMan = NetworkAccessManager(args.disk_cache, args.ignore_ssl_errors, self)
self.m_page.setNetworkAccessManager(m_netAccessMan)
# inject our properties and slots into javascript
self.m_page.mainFrame().javaScriptWindowObjectCleared.connect(self.inject)
self.m_page.loadFinished.connect(self.finish)
do_action('PhantomInitPost', Bunch(locals()))
def execute(self):
if self.m_script.startswith('#!'):
self.m_script = '//' + self.m_script
if self.m_scriptFile.lower().endswith('.coffee'):
coffee = CSConverter(self)
self.m_script = coffee.convert(self.m_script)
self.m_page.mainFrame().evaluateJavaScript(self.m_script)
def finish(self, success):
self.m_loadStatus = 'success' if success else 'fail'
self.m_page.mainFrame().evaluateJavaScript(self.m_script)
def inject(self):
self.m_page.mainFrame().addToJavaScriptWindowObject('phantom', self)
def renderPdf(self, fileName):
p = QPrinter()
p.setOutputFormat(QPrinter.PdfFormat)
p.setOutputFileName(fileName)
p.setResolution(pdf_dpi)
paperSize = self.m_paperSize
if not len(paperSize):
pageSize = QSize(self.m_page.mainFrame().contentsSize())
paperSize['width'] = str(pageSize.width()) + 'px'
paperSize['height'] = str(pageSize.height()) + 'px'
paperSize['border'] = '0px'
if paperSize.get('width') and paperSize.get('height'):
sizePt = QSizeF(ceil(self.stringToPointSize(paperSize['width'])),
ceil(self.stringToPointSize(paperSize['height'])))
p.setPaperSize(sizePt, QPrinter.Point)
elif 'format' in paperSize:
orientation = QPrinter.Landscape if paperSize.get('orientation') and paperSize['orientation'].lower() == 'landscape' else QPrinter.Portrait
orientation = QPrinter.Orientation(orientation)
p.setOrientation(orientation)
formats = {
'A3': QPrinter.A3,
'A4': QPrinter.A4,
'A5': QPrinter.A5,
'Legal': QPrinter.Legal,
'Letter': QPrinter.Letter,
'Tabloid': QPrinter.Tabloid
}
p.setPaperSize(QPrinter.A4) # fallback
for format, size in formats.items():
if format.lower() == paperSize['format'].lower():
p.setPaperSize(size)
break
else:
return False
border = floor(self.stringToPointSize(paperSize['border'])) if paperSize.get('border') else 0
p.setPageMargins(border, border, border, border, QPrinter.Point)
self.m_page.mainFrame().print_(p)
return True
def returnValue(self):
return self.m_returnValue
def stringToPointSize(self, string):
units = (
('mm', 72 / 25.4),
('cm', 72 / 2.54),
('in', 72.0),
('px', 72.0 / pdf_dpi / 2.54),
('', 72.0 / pdf_dpi / 2.54)
)
for unit, format in units:
if string.endswith(unit):
value = string.rstrip(unit)
return float(value) * format
return 0
##
# Properties and methods exposed to JavaScript
##
@pyqtProperty('QStringList')
def args(self):
return self.m_args
@pyqtProperty('QVariantMap')
def clipRect(self):
result = {
'width': self.m_clipRect.width(),
'height': self.m_clipRect.height(),
'top': self.m_clipRect.top(),
'left': self.m_clipRect.left()
}
return result
@clipRect.setter
def clipRect(self, size):
names = ('width', 'height', 'top', 'left')
for item in names:
try:
globals()[item] = int(size[item])
if globals()[item] < 0:
if item not in ('top', 'left'):
globals()[item] = 0
except KeyError:
globals()[item] = getattr(self.m_clipRect, item)()
self.m_clipRect = QRect(left, top, width, height)
@pyqtProperty(str)
def content(self):
return self.m_page.mainFrame().toHtml()
@content.setter
def content(self, content):
self.m_page.mainFrame().setHtml(content)
@pyqtSlot()
@pyqtSlot(int)
def exit(self, code=0):
self.m_returnValue = code
self.m_page.loadFinished.disconnect(self.finish)
QTimer.singleShot(0, qApp, SLOT('quit()'))
@pyqtProperty(str)
def loadStatus(self):
return self.m_loadStatus
@pyqtSlot(str, result=bool)
def loadScript(self, script):
if script in self.m_loadScript_cache:
self.m_page.mainFrame().evaluateJavaScript(self.m_loadScript_cache[script])
return True
scriptFile = script
try:
script = codecs.open(self.m_scriptDir + script, encoding='utf-8')
script = script.read()
except IOError:
return False
if script.startswith('#!'):
script = '//' + script
if scriptFile.lower().endswith('.coffee'):
coffee = CSConverter(self)
script = coffee.convert(script)
self.m_loadScript_cache[scriptFile] = script
self.m_page.mainFrame().evaluateJavaScript(script)
return True
@pyqtSlot(str, name='open')
def open_(self, address):
qDebug('Opening address %s' % address)
self.m_page.triggerAction(QWebPage.Stop)
self.m_loadStatus = 'loading'
self.m_page.mainFrame().setUrl(QUrl(address))
@pyqtProperty('QVariantMap')
def paperSize(self):
return self.m_paperSize
@paperSize.setter
def paperSize(self, size):
self.m_paperSize = size
@pyqtSlot(str, result=bool)
def render(self, fileName):
fileInfo = QFileInfo(fileName)
path = QDir()
path.mkpath(fileInfo.absolutePath())
if fileName.lower().endswith('.pdf'):
return self.renderPdf(fileName)
viewportSize = QSize(self.m_page.viewportSize())
pageSize = QSize(self.m_page.mainFrame().contentsSize())
bufferSize = QSize()
if not self.m_clipRect.isEmpty():
bufferSize = self.m_clipRect.size()
else:
bufferSize = self.m_page.mainFrame().contentsSize()
if pageSize == '':
return False
image = QImage(bufferSize, QImage.Format_ARGB32)
image.fill(qRgba(255, 255, 255, 0))
p = QPainter(image)
p.setRenderHint(QPainter.Antialiasing, True)
p.setRenderHint(QPainter.TextAntialiasing, True)
p.setRenderHint(QPainter.SmoothPixmapTransform, True)
self.m_page.setViewportSize(pageSize)
if not self.m_clipRect.isEmpty():
p.translate(-self.m_clipRect.left(), -self.m_clipRect.top())
self.m_page.mainFrame().render(p, QRegion(self.m_clipRect))
else:
self.m_page.mainFrame().render(p)
p.end()
self.m_page.setViewportSize(viewportSize)
return image.save(fileName)
@pyqtSlot('QWebElement', str)
def setFormInputFile(self, el, fileTag):
self.m_page.m_nextFileTag = fileTag
el.evaluateJavaScript('''(function(target){
var evt = document.createEvent('MouseEvents');
evt.initMouseEvent("click", true, true, window,
0, 0, 0, 0, 0, false, false, false, false, 0, null);
target.dispatchEvent(evt);})(this);''')
@pyqtSlot(int)
def sleep(self, ms):
startTime = QTime.currentTime()
while True:
QApplication.processEvents(QEventLoop.AllEvents, 25)
if startTime.msecsTo(QTime.currentTime()) > ms:
break
usleep(0.005)
@pyqtProperty(str)
def state(self):
return self.m_state
@state.setter
def state(self, value):
self.m_state = value
@pyqtProperty(str)
def userAgent(self):
return self.m_page.m_userAgent
@userAgent.setter
def userAgent(self, ua):
self.m_page.m_userAgent = ua
@pyqtSlot(str, result='QVariant')
@pyqtSlot(int, result='QVariant')
@pyqtSlot(str, 'QVariant')
@pyqtSlot(int, 'QVariant')
def ctx(self, name, value=None):
if not value:
return self.m_var.get(name)
self.m_var[name] = value
@pyqtProperty('QVariantMap')
def version(self):
version = {
'major': version_major,
'minor': version_minor,
'patch': version_patch
}
return version
@pyqtProperty('QVariantMap')
def viewportSize(self):
size = self.m_page.viewportSize()
result = {
'width': size.width(),
'height': size.height()
}
return result
@viewportSize.setter
def viewportSize(self, size):
names = ('width', 'height')
for item in names:
try:
globals()[item] = int(size[item])
if globals()[item] < 0:
globals()[item] = 0
except KeyError:
globals()[item] = getattr(self.m_page.viewportSize(), item)()
self.m_page.setViewportSize(QSize(width, height))
do_action('Phantom', Bunch(locals()))
class PlottingThread(QThread):
def __init__(self, parent):
QThread.__init__(self)
self.result = None
self.parent = parent
self._stopped = False
self.mutex = QMutex()
self.filePrefix = None
self.fileFormat = None
self.wallColoring = None
self.cellColoring = None
self.pointColoring = None
self.extraDrawing = []
self.pointSize = None
self.pointLineColor = None
self.pointLineThickness = None
self.ellipsisDraw = None
self.overSampling = None
self.wallThickness = None
self.bgColor = None
self.loading = False
self._crop = QRect(0, 0, 1, 1)
self._pix = None
self._end_image_plot = False
self._loading_arguments = {}
self.retryObject = None
def end_step(self):
return len(self.result) + 1
def stop(self, value=True):
self.mutex.lock()
self._stopped = value
self.mutex.unlock()
def stopped(self):
self.mutex.lock()
val = self._stopped
self.mutex.unlock()
return val
def nextImage(self):
QCoreApplication.postEvent(self.parent, NextImageEvent())
def abort(self, reason, **others):
e = AbortPlottingEvent(reason)
if others:
e.others = others
QCoreApplication.postEvent(self.parent, e)
def finished(self):
if self.loading:
QCoreApplication.postEvent(self.parent, FinishLoadingEvent())
self.loading = False
else:
QCoreApplication.postEvent(self.parent, FinishPlottingEvent())
def image_ready(self):
QCoreApplication.postEvent(self.parent, ImageReadyPlottingEvent())
def update_nb_images(self, nb):
QCoreApplication.postEvent(self.parent, UpdateNbImageEvent(nb))
@property
def crop_left(self):
return self._crop.left()
@crop_left.setter
def crop_left(self, value):
self._crop.moveLeft(int(value))
@property
def crop_top(self):
return self._crop.top()
@crop_top.setter
def crop_top(self, value):
self._crop.moveTop(int(value))
@property
def crop_width(self):
return self._crop.width()
@crop_width.setter
def crop_width(self, value):
self._crop.setWidth(int(value))
@property
def crop_height(self):
return self._crop.height()
@crop_height.setter
def crop_height(self, value):
self._crop.setHeight(int(value))
def reset_crop(self):
self._crop = QRect(QPoint(0, 0), self.img_size)
@property
def crop(self):
return QRect(self._crop)
@crop.deleter
def crop(self):
self.reset_crop()
@property
def end_image_plot(self):
'''
If true, plot the growth data on the end image rather than the start image of the growth calculation.
'''
return self._end_image_plot
@end_image_plot.setter
def end_image_plot(self, value):
self._end_image_plot = bool(value)
@property
def pix(self):
'''Thread-safe image storage.'''
self.mutex.lock()
pix = self._pix
self.mutex.unlock()
return pix
@pix.setter
def pix(self, value):
self.mutex.lock()
self._pix = value
self.mutex.unlock()
def render_valid(self):
if self.result is None:
log_debug("result is None")
return False
if self.parent is None:
log_debug("parent is None")
return False
if self.ellipsisDraw is None:
log_debug("ellipsisDraw is None")
return False
if self.cellColoring is None:
log_debug("cellColoring is None")
return False
if self.wallColoring is None:
log_debug("wallColoring is None")
return False
if self.pointColoring is None:
log_debug("pointColoring is None")
return False
if self.pointSize is None:
log_debug("pointSize is None")
return False
if self.pointLineThickness is None:
log_debug("pointSize is None")
return False
if self.pointLineColor is None:
log_debug("pointSize is None")
return False
if self.wallThickness is None:
log_debug("wallThickness is None")
return False
if self.overSampling is None:
log_debug("overSampling is None")
return False
if self.bgColor is None:
log_debug("bgColor is None")
return False
return True
def valid(self):
if self.filePrefix is None:
log_debug("filePrefix is None")
return False
if not self.filePrefix:
log_debug("filePrefix is Empty")
return False
if self.fileFormat is None:
log_debug("fileFormat is None")
return False
return self.render_valid()
def drawImage(self, imageid):
cache = image_cache.cache
cellColoring = self.cellColoring
wallColoring = self.wallColoring
pointColoring = self.pointColoring
ellipsisDraw = self.ellipsisDraw
overSampling = self.overSampling
extraDrawing = self.extraDrawing
bgColor = self.bgColor.rgb()
result = self.result
if self.result_type == "Data":
data = result
img_name = result.images_name[imageid]
else:
data = result.data
img_name = result.images[imageid]
#scale = data.images_scale[img_name]
min_scale = data.minScale()
img = cache.image(data.image_path(img_name))
img_data = data[img_name]
size = self._crop.size()
pix = QImage(size * overSampling, QImage.Format_ARGB32)
pix.fill(bgColor)
painter = QPainter()
if not painter.begin(pix):
self.abort("Cannot create painter on QImage")
return None, None, None
painter.setRenderHints(QPainter.SmoothPixmapTransform, True)
painter.setRenderHints(QPainter.Antialiasing, True)
if overSampling > 1:
painter.scale(overSampling, overSampling)
painter.translate(-self._crop.topLeft())
painter.save()
painter.translate(self.translate)
log_debug("Translating: %gx%g" %
(self.translate.x(), self.translate.y()))
painter.scale(1 / min_scale, 1 / min_scale)
painter.save()
matrix = img_data.matrix()
painter.setWorldTransform(matrix, True)
painter.drawImage(QPoint(0, 0), img)
painter.restore()
#pt_matrix = QTransform()
#pt_matrix.scale(1/min_scale, 1/min_scale)
#painter.setTransform(pt_matrix, True)
cellColoring.startImage(painter, imageid)
wallColoring.startImage(painter, imageid)
for ed in extraDrawing:
ed.startImage(painter, imageid)
if self.result_type == "Growth":
cells = result.cells[imageid]
walls = result.walls[imageid]
else:
cells = img_data.cells
walls = set()
for cid in img_data.cells:
pts = [pt for pt in data.cells[cid] if pt in img_data]
if len(pts) > 1:
for i in range(len(pts)):
walls.add(data.wallId(pts[i - 1], pts[i]))
# Now, draw the cells and the ellipsis
for cid in cells:
painter.setPen(Qt.NoPen)
color = cellColoring(imageid, cid)
painter.setBrush(color)
pts = data.cellAtTime(cid, img_data.index)
if pts:
pts.append(pts[0])
ppts = []
for p1, p2 in zip(pts[:-1], pts[1:]):
ppts.append(img_data[p1])
ppts.extend(img_data.walls[p1, p2])
ppts.append(ppts[0])
poly = QPolygonF(ppts)
painter.drawPolygon(poly)
# And draw the walls
wallThickness = self.wallThickness * min_scale
for wid in walls:
color = wallColoring(imageid, wid)
if color.alpha() > 0:
pen = QPen(color)
pen.setWidthF(wallThickness)
painter.setPen(pen)
pts = [img_data[wid[0]]
] + img_data.walls[wid[0], wid[1]] + [img_data[wid[1]]]
#painter.drawLine(img_data[wid[0]], img_data[wid[1]])
painter.drawPolyline(*pts)
# Then, draw the points
pointSize = self.pointSize * min_scale
pointLineColor = self.pointLineColor
pointLineThickness = self.pointLineThickness * min_scale
log_debug("pointSize = %g" % pointSize)
for pid in img_data:
color = pointColoring(imageid, pid)
if color.alpha() > 0:
pen = QPen(pointLineColor)
pen.setWidthF(pointLineThickness)
brush = QBrush(color)
painter.setPen(pen)
painter.setBrush(brush)
pos = img_data[pid]
rect = QRectF(pos.x() - pointSize,
pos.y() - pointSize, 2 * pointSize,
2 * pointSize)
painter.drawEllipse(rect)
if ellipsisDraw.plot:
for cid in cells:
pts = data.cellAtTime(cid, img_data.index)
if pts:
pts.append(pts[0])
ppts = []
for p1, p2 in zip(pts[:-1], pts[1:]):
ppts.append(img_data[p1])
ppts.extend(img_data.walls[p1, p2])
ppts.append(ppts[0])
#poly = QPolygonF(ppts)
#painter.drawPolygon(poly)
ellipsisDraw(painter, imageid, cid, ppts, min_scale)
# At last, draw the extra data
for ed in extraDrawing:
ed(painter, imageid)
tr = painter.worldTransform()
painter.restore()
pic_w = wallColoring.finalizeImage(painter, imageid, tr, self.crop)
pic_c = cellColoring.finalizeImage(painter, imageid, tr, self.crop)
for ed in extraDrawing:
ed.finalizeImage(painter, imageid, tr, self.crop)
painter.end()
return pix, pic_w, pic_c
def start(self):
if self.isRunning():
assert not self.rendering_all, "Cannot run twice the rendering of all images with the same object."
return
if parameters.instance.use_thread:
log_debug("Starting rendering thread.")
QThread.start(self)
return False
else:
self.run()
return True
def render_all(self):
self.rendering_all = True
return self.start()
def render_single(self, img_id, retry=False):
if retry:
while self.isRunning():
self.wait(10000)
elif self.isRunning():
return
self.rendering_all = False
self.current_image = img_id
return self.start()
def load(self, filename):
self.loading = True
self.result = filename
return self.start()
def run(self):
if self.loading:
self.run_loader()
elif self.rendering_all:
self.run_full()
else:
self.run_single()
def run_single(self):
img = self.current_image
self.cellColoring.init()
self.wallColoring.init()
self.pointColoring.init()
log_debug("Rendering image %d" % img)
self.pix, self.pic_w, self.pic_c = self.drawImage(img)
if self.pic_w is not None:
log_debug("Has wall image")
if self.pic_c is not None:
log_debug("Has cell image")
if self.pix is not None:
log_debug("Pix correctly rendered")
log_debug("Rendered image %d = %s" % (img, self.pix))
self.image_ready()
def reload(self):
if self.retryObject is None:
return
self._loading_arguments.update(self.retryObject.method_args)
self.load(self.retryObject.filename)
def run_loader(self):
filename = self.result
try:
self.retryObject = None
# First, prepare the data by getting the images and computing how big they
# should be
f = open(filename)
first_line = f.readline()
f.close()
if first_line.startswith("TRKR_VERSION"):
result = Result(None)
result.load(self.result, **self._loading_arguments)
result_type = "Growth"
else:
result = TrackingData()
result.load(self.result, **self._loading_arguments)
result_type = "Data"
self.result = result
self.result_type = result_type
if result_type == "Data":
data = result
images = data.images_name
if data.cells:
self.has_cells = True
self.has_walls = True
else:
self.has_cells = False
self.has_walls = False
self.has_points = bool(data.cell_points)
else:
data = result.data
images = result.images
self.has_cells = False
self.has_walls = False
self.has_points = False
self.images = images
cache = image_cache.cache
self.update_nb_images(len(result))
bbox = QRectF()
ms = data.minScale()
for i in range(len(result)):
img_name = images[i]
img_data = data[img_name]
img = cache.image(data.image_path(img_name))
matrix = QTransform()
matrix = img_data.matrix()
sc = QTransform()
sc.scale(1.0 / ms, 1.0 / ms)
matrix *= sc
r = QRectF(img.rect())
rbox = matrix.map(QPolygonF(r)).boundingRect()
bbox |= rbox
log_debug(
"Image '%s':\n\tSize = %gx%g\n\tTransformed = %gx%g %+g %+g\n\tGlobal bbox = %gx%g %+g %+g\n"
% (img_name, r.width(), r.height(), rbox.width(),
rbox.height(), rbox.left(), rbox.top(), bbox.width(),
bbox.height(), bbox.left(), bbox.top()))
log_debug("Matrix:\n%g\t%g\t%g\n%g\t%g\t%g\n" %
(matrix.m11(), matrix.m12(), matrix.dx(),
matrix.m21(), matrix.m22(), matrix.dy()))
if result_type == "Growth":
if result.cells[i]:
self.has_cells = True
if result.walls[i]:
self.has_walls = True
self.has_points = bool(result.data.cell_points)
self.nextImage()
translate = bbox.topLeft()
translate *= -1
self.translate = translate
size = bbox.size().toSize()
self.img_size = size
self._crop = QRect(QPoint(0, 0), size)
self.finished()
self._loading_arguments = {
} # All done, we don't need that anymore
except RetryTrackingDataException as ex:
ex.filename = filename
self.retryObject = ex
self.finished()
return
except Exception as ex:
_, _, exceptionTraceback = sys.exc_info()
self.abort(ex, traceback=exceptionTraceback)
raise
def run_full(self):
if not self.valid():
self.abort("Object was not correctly initialized")
return
self.stop(False)
painter = None
try:
result = self.result
self.update_nb_images(len(result))
# if self.result_type == "Data":
# data = result
# images = result.images_name
# else:
# data = result.data
# images = result.images
# cache = image_cache.cache
cellColoring = self.cellColoring
wallColoring = self.wallColoring
pointColoring = self.pointColoring
file_format = self.fileFormat
file_pattern = "%s%%0%dd.%s" % (self.filePrefix,
len(str(len(result))), file_format)
wall_file_pattern = "%s%%0%dd_wall.%s" % (
self.filePrefix, len(str(len(result))), file_format)
cell_file_pattern = "%s%%0%dd_cell.%s" % (
self.filePrefix, len(str(len(result))), file_format)
cellColoring.init()
wallColoring.init()
pointColoring.init()
self.nextImage()
for i in range(len(result)):
if self.stopped():
self.abort("User interruption")
return
pix, pic_w, pic_c = self.drawImage(i)
pix.save(file_pattern % (i + 1), file_format)
if pic_w is not None:
self.saveExtra(pic_w, wall_file_pattern % (i + 1),
file_format)
if pic_c is not None:
self.saveExtra(pic_c, cell_file_pattern % (i + 1),
file_format)
self.nextImage()
self.finished()
except Exception as ex:
if painter is not None:
painter.end()
_, _, exceptionTraceback = sys.exc_info()
self.abort(ex, traceback=exceptionTraceback)
raise
def saveExtra(self, picture, file_name, file_format):
rect = picture.boundingRect()
pix = QImage(rect.size(), QImage.Format_ARGB32)
pix.fill(QColor(0, 0, 0, 0).rgba())
paint = QPainter()
paint.begin(pix)
paint.drawPicture(rect.topLeft() * -1, picture)
paint.end()
pix.save(file_name, file_format)
class ImageAreaSelector(QtGui.QWidget):
'''This widget provides means to visually crop a portion of
an image by selecting it'''
# pylint: disable=W0612
NAME = 'ImageAreaSelector'
DESCRIPTION = 'A widget used to select part of an image'
AUTHOR = 'Gabriele "Whisky" Visconti'
WEBSITE = ''
# pylint: enable=W0612
selection_changed = QtCore.pyqtSignal()
def __init__(self, pixmap, parent=None):
'''Constructor'''
QtGui.QWidget.__init__(self, parent)
self._pixmap = pixmap
self._selection_rect = QRect()
self._image_origin = QPoint()
self._resize_start = None
self._drag_start = None
self._handle_size = QSize(-10, -10)
self._painter = QtGui.QPainter()
self._hl_color1 = QtGui.QPalette().color(QtGui.QPalette.Highlight)
self._hl_color2 = QtGui.QPalette().color(QtGui.QPalette.Highlight)
self._hl_color2.setAlpha(150)
self._zoom = 1.0
self.adjust_minum_size()
self.setBackgroundRole(QtGui.QPalette.Dark)
self.setMouseTracking(True)
self.setCursor(Qt.CrossCursor)
# -------------------- [BEGIN] QT_OVERRIDE
def mousePressEvent(self, event):
'''Overrides QWidget's mousePressEvent. Handles starting
a new selection, starting a drag operation'''
# pylint: disable=C0103
mouse_pos = event.pos() / self._zoom
sel_rect = self._selection_rect
if not event.button() == Qt.LeftButton:
return
if (not sel_rect.isNull()) and sel_rect.contains(mouse_pos, True):
handle_rect = QRect(sel_rect.bottomRight(), self._handle_size)
if handle_rect.contains(mouse_pos):
self._resize_start = mouse_pos
else:
self._drag_start = mouse_pos
else:
self._resize_start = mouse_pos
sel_rect.setTopLeft(mouse_pos)
self._selection_rect.setSize(QSize(0, 0))
def mouseMoveEvent(self, event):
'''Overrides QWidget's mouseMoveEvent. Handles resizing
and dragging operations on selection'''
# pylint: disable=C0103
sel_rect = self._selection_rect
if self._resize_start:
resize_end = event.pos() / self._zoom
sel_rect.setBottomRight(sel_rect.bottomRight() +
(resize_end - self._resize_start))
self._resize_start = resize_end
self.make_selection_square()
self.update()
elif self._drag_start is not None:
drag_end = event.pos() / self._zoom
sel_rect.translate(drag_end - self._drag_start)
self._drag_start = drag_end
self.update()
# cursor shape:
mouse_pos = event.pos() / self._zoom
if (not sel_rect.isNull()) and sel_rect.contains(mouse_pos, True):
handle_rect = QRect(sel_rect.bottomRight(), self._handle_size)
if handle_rect.contains(mouse_pos):
self.setCursor(Qt.SizeFDiagCursor)
else:
self.setCursor(Qt.OpenHandCursor)
else:
self.setCursor(Qt.CrossCursor)
def mouseReleaseEvent(self, event):
'''Overrides QWidget's mouseReleaseEvent. Handles ending a resizing or
draggin operation on the selection'''
# pylint: disable=C0103
self._selection_rect = self._selection_rect.normalized()
self._resize_start = None
self._drag_start = None
self.update()
if not self._selection_rect.isNull():
self.selection_changed.emit()
def paintEvent(self, event):
'''Overrides QWidtget's paintEvent.'''
# pylint: disable=C0103
QtGui.QWidget.paintEvent(self, event)
self._painter.begin(self)
pixmap_dest_rect = QRect(self._image_origin * self._zoom,
self._pixmap.size() * self._zoom)
self._painter.drawPixmap(pixmap_dest_rect, self._pixmap)
if not self._selection_rect.isNull():
# preparing the darkened frame:
sel_rect = self._selection_rect.normalized()
frame = QtGui.QPixmap(event.rect().size())
frame.fill(QtGui.QColor(0, 0, 0, 127))
frame_painter = QtGui.QPainter(frame)
# erase the selected area from the frame:
frame_painter.setCompositionMode(
QtGui.QPainter.CompositionMode_DestinationIn)
sel_rect_scaled = QRect(sel_rect.topLeft() * self._zoom,
sel_rect.size() * self._zoom)
frame_painter.fillRect(sel_rect_scaled, QtGui.QColor(0, 0, 0, 0))
# draw selection border :
frame_painter.setCompositionMode(
QtGui.QPainter.CompositionMode_SourceOver)
frame_painter.setPen(self._hl_color1)
frame_painter.drawRect(sel_rect_scaled)
# draw the resize grip (if possible)
if sel_rect_scaled.width() > 20 and sel_rect_scaled.height() > 20:
handle_rect = QRect(sel_rect_scaled.bottomRight(),
self._handle_size)
frame_painter.fillRect(handle_rect, self._hl_color2)
frame_painter.drawRect(handle_rect)
frame_painter.end()
# painting the darkened frame:
self._painter.drawPixmap(0, 0, frame)
self._painter.end()
def resizeEvent(self, event):
'''Overrides QWidget's resizeEvent. Handles image centering.'''
# pylint: disable=C0103
self.adjust_image_origin()
# -------------------- [END] QT_OVERRIDE
def adjust_image_origin(self):
'''Recalculates the top left corner's image position, so the
image is painted centered'''
# pylint: disable=C0103
new_size = self.size() / self._zoom
pix_size = self._pixmap.size()
dx = (new_size.width() - pix_size.width()) / 2
dy = (new_size.height() - pix_size.height()) / 2
new_image_origin = QPoint(dx, dy)
self._selection_rect.translate(new_image_origin - self._image_origin)
self._image_origin = new_image_origin
log.info('image origin: %s' % new_image_origin)
def select_unscaled(self):
'''Selects, if possible, a 96 x 96 square centered around the original
image. In this way the image won't be scaled but won't take up all the
96 x 96 area.'''
# pylint: disable=C0103
pix_size = self._pixmap.size()
if pix_size.width() <= 96 and pix_size.height() <= 96:
viewport_size = self.size()
x = (viewport_size.width() - 96) / 2
y = (viewport_size.height() - 96) / 2
self._selection_rect.setTopLeft(QPoint(x, y))
self._selection_rect.setSize(QSize(96, 96))
self.update()
self.selection_changed.emit()
def select_all(self):
'''Selects the whole image. Currently broken for images taller
than wide.'''
# TODO: make me work!
self._selection_rect.setTopLeft(self._image_origin)
self._selection_rect.setSize(self._pixmap.size())
self.update()
self.selection_changed.emit()
def rotate_left(self):
'''Rotates the image counterclockwise.'''
self._pixmap = self._pixmap.transformed(QtGui.QTransform().rotate(-90))
self.adjust_minum_size()
self.adjust_image_origin()
self.update()
self.selection_changed.emit()
def rotate_right(self):
'''Rotates the image clockwise'''
self._pixmap = self._pixmap.transformed(QtGui.QTransform().rotate(90))
self.adjust_minum_size()
self.adjust_image_origin()
self.update()
self.selection_changed.emit()
def adjust_minum_size(self):
'''Sets the new minimum size, calculated upon the image size
and the _zoom factor.'''
pixmap = self._pixmap
if pixmap.width() < 96 or pixmap.height() < 96:
min_size = QSize(96, 96)
else:
min_size = pixmap.size()
self.setMinimumSize(min_size * self._zoom)
def make_selection_square(self):
'''Modify the selected area making it square'''
wid = self._selection_rect.width()
self._selection_rect.setSize(QSize(wid, wid))
def set_zoom(self, zoomlevel):
'''Sets the specified zoomlevel'''
self._zoom = zoomlevel
self.adjust_minum_size()
self.adjust_image_origin()
self.update()
self.selection_changed.emit()
def fit_zoom(self):
'''Chooses a zoomlevel that makes visible the entire image.
Currently broken.'''
widget_wid = self.size().width()
widget_hei = self.size().height()
pixmap_wid = self._pixmap.width()
pixmap_hei = self._pixmap.height()
self._zoom = (min(widget_wid, widget_hei) /
min(pixmap_wid, pixmap_hei))
self.adjust_minum_size()
self.adjust_image_origin()
self.update()
self.selection_changed.emit()
def get_selected_pixmap(self):
'''Returns the pixmap contained in the selection rect.
Currently doesn't handle transparency correctly'''
sel_rect_scaled = QRect(self._selection_rect.topLeft() * self._zoom,
self._selection_rect.size() * self._zoom)
return QtGui.QPixmap.grabWidget(self, sel_rect_scaled)
