Merge branch '1.6_maintenance'

Author: murraystevenson

Changes.md

@@ -63,7 +63,17 @@ Build
 1.6.x.x (relative to 1.6.12.0)
 =======
 
+Improvements
+------------
+
+- Crop : Added `Auto` mode for `areaSource`, automatically cropping to show only non-empty pixels.
+- GraphEditor : Improved responsiveness of select-drag, by deferring NodeEditor update until the drag ends.
+
+API
+---
 
+- Widget : Added `currentButtons()` static method. This returns the state of the mouse buttons during the last UI event to be processed.
+- LazyMethod : Added `deferUntilButtonRelease` option.
 
 1.6.12.0 (relative to 1.6.11.1)
 ========

include/GafferImage/Crop.h

@@ -60,7 +60,8 @@ class GAFFERIMAGE_API Crop : public ImageProcessor
 			Area = 0,
 			DataWindow = 1,
 			DisplayWindow = 2,
-			Format = 3
+			Format = 3,
+			Auto = 4
 		};
 
 		Gaffer::IntPlug *areaSourcePlug();
@@ -95,6 +96,9 @@ class GAFFERIMAGE_API Crop : public ImageProcessor
 		void hash( const Gaffer::ValuePlug *output, const Gaffer::Context *context, IECore::MurmurHash &h ) const override;
 		void compute( Gaffer::ValuePlug *output, const Gaffer::Context *context ) const override;
 
+		Gaffer::ValuePlug::CachePolicy computeCachePolicy( const Gaffer::ValuePlug *output ) const override;
+		Gaffer::ValuePlug::CachePolicy hashCachePolicy( const Gaffer::ValuePlug *output ) const override;
+
 	private :
 
 		Gaffer::AtomicBox2iPlug *cropWindowPlug();
@@ -106,6 +110,20 @@ class GAFFERIMAGE_API Crop : public ImageProcessor
 		Gaffer::V2iPlug *offsetPlug();
 		const Gaffer::V2iPlug *offsetPlug() const;
 
+		Gaffer::AtomicBox2iPlug *tileAutoAreaPlug();
+		const Gaffer::AtomicBox2iPlug *tileAutoAreaPlug() const;
+
+		Gaffer::AtomicBox2iPlug *autoAreaPlug();
+		const Gaffer::AtomicBox2iPlug *autoAreaPlug() const;
+
+		bool affectsTileAutoArea( const Gaffer::Plug *input ) const;
+		void hashTileAutoArea( const Gaffer::Context *context, IECore::MurmurHash &h ) const;
+		Imath::Box2i computeTileAutoArea( const Gaffer::Context *context ) const;
+
+		bool affectsAutoArea( const Gaffer::Plug *input ) const;
+		void hashAutoArea( const Gaffer::Context *context, IECore::MurmurHash &h ) const;
+		Imath::Box2i computeAutoArea( const Gaffer::Context *context ) const;
+
 		static size_t g_firstPlugIndex;
 };
 

python/GafferImageTest/CropTest.py

@@ -36,7 +36,7 @@
 ##########################################################################
 
 import unittest
-import os
+import random
 import imath
 
 import IECore
@@ -305,5 +305,121 @@ def testFormatAffectsOutput( self ) :
 		crop["format"].setValue( GafferImage.Format( 100, 200 ) )
 		self.assertIn( crop["out"]["dataWindow"], { x[0] for x in cs } )
 
+	def testAutoArea( self ) :
+
+		# Rectangle will have a data window fitted perfectly to
+		# the rectangle it draws.
+		rectangle = GafferImage.Rectangle()
+
+		# Merging over a constant (even with zero alpha) will
+		# destroy that data window.
+		constant = GafferImage.Constant()
+		constant["color"]["a"].setValue( 0 )
+
+		merge = GafferImage.Merge()
+		merge["in"][0].setInput( constant["out"] )
+		merge["in"][1].setInput( rectangle["out"] )
+
+		# But we can restore it using a crop with `AreaSource.Auto`.
+		crop = GafferImage.Crop()
+		crop["in"].setInput( merge["out"] )
+		crop["areaSource"].setValue( crop.AreaSource.Auto )
+		crop["affectDisplayWindow"].setValue( False )
+		rectangle["lineWidth"].setValue( 0.5 )
+
+		random.seed( 100 )
+		for i in range( 0, 10 ) :
+
+			area = imath.Box2f()
+			for p in range( 0, 2 ) :
+				area.extendBy( imath.V2f( random.uniform( 0, 1000 ), random.uniform( 0, 1000 ) ) )
+
+			with self.subTest( area = area ) :
+
+				rectangle["area"].setValue( area )
+				self.assertEqual( crop["out"].dataWindow(), rectangle["out"].dataWindow() )
+
+		rectangle["color"].setValue( imath.Color4f( 0 ) )
+		self.assertTrue( crop["out"].dataWindow().isEmpty() )
+
+	def testEmptyAutoArea( self ) :
+
+		constant = GafferImage.Constant()
+		constant["color"]["a"].setValue( 0 )
+
+		crop = GafferImage.Crop()
+		crop["in"].setInput( constant["out"] )
+		crop["areaSource"].setValue( crop.AreaSource.Auto )
+		crop["affectDisplayWindow"].setValue( False )
+
+		self.assertTrue( crop["out"].dataWindow().isEmpty() )
+
+	def testAutoAreaReusesTileResults( self ) :
+
+		constant = GafferImage.Constant()
+		constant["color"].setValue( imath.Color4f( 1 ) )
+		constant["format"].setValue(
+			GafferImage.Format( int( GafferImage.ImagePlug.tileSize() * 2.5 ), int( GafferImage.ImagePlug.tileSize() * 3.5 ) )
+		)
+
+		crop = GafferImage.Crop()
+		crop["in"].setInput( constant["out"] )
+		crop["areaSource"].setValue( crop.AreaSource.Auto )
+
+		# Limit to one thread to avoid concurrent computes of the same thing.
+		with IECore.tbb_global_control(
+			IECore.tbb_global_control.parameter.max_allowed_parallelism, 1
+		) :
+			# Compute the entire image.
+			with Gaffer.PerformanceMonitor() as monitor :
+				self.assertImagesEqual( crop["out"], crop["in"] )
+
+		# All tiles of the constant are the same, so there is only one compute.
+		self.assertEqual( monitor.plugStatistics( constant["out"]["channelData"] ).computeCount, 1 )
+		# The tile auto-areas can be shared for all tiles with the same local
+		# crop window. Which gives us 4 unique results even though there are
+		# 12 tiles.
+		self.assertEqual( monitor.plugStatistics( crop["__tileAutoArea"] ).computeCount, 4 )
+
+	def testDeepAutoArea( self ) :
+
+		reader = GafferImage.ImageReader()
+		reader["fileName"].setValue( self.imagesPath() / "representativeDeepImage.exr" )
+
+		slice = GafferImage.DeepSlice()
+		slice["in"].setInput( reader["out"] )
+		slice["nearClip"]["enabled"].setValue( True )
+		slice["nearClip"]["value"].setValue( 2.86 )
+		slice["farClip"]["enabled"].setValue( True )
+		slice["farClip"]["value"].setValue( 3.6 )
+
+		crop = GafferImage.Crop()
+		crop["in"].setInput( slice["out"] )
+		crop["areaSource"].setValue( crop.AreaSource.Auto )
+		crop["affectDisplayWindow"].setValue( False )
+
+		self.assertEqual(
+			crop["out"].dataWindow(),
+			imath.Box2i(
+				imath.V2i( 14, 3 ),
+				imath.V2i( 93, 56 )
+			)
+		)
+
+	def testChannelDataOnlyAffectsDataWindowForAutoArea( self ) :
+
+		constant = GafferImage.Constant()
+		crop = GafferImage.Crop()
+		crop["in"].setInput( constant["out"] )
+
+		cs = GafferTest.CapturingSlot( crop.plugDirtiedSignal() )
+		constant["color"]["r"].setValue( 0.1 )
+		self.assertNotIn( crop["out"]["dataWindow"], { x[0] for x in cs } )
+
+		crop["areaSource"].setValue( crop.AreaSource.Auto )
+		del cs[:]
+		constant["color"]["r"].setValue( 0.2 )
+		self.assertIn( crop["out"]["dataWindow"], { x[0] for x in cs } )
+
 if __name__ == "__main__":
 	unittest.main()

python/GafferImageUI/CropUI.py

@@ -74,17 +74,23 @@ def postCreate( node, menu ) :
 
 			"description" :
 			"""
-			Where to source the actual area to use. If this is
-			set to DataWindow, it will use the input's Data Window,
-			if it is set to DisplayWindow, it will use the input's
-			Display Window, and if it is set to Area, it will use
-			the Area plug.
+			The source of the area to crop to.
+
+			- Area : A user-defined area specified by the `area` plug.
+			- Format : A user-defined area specified by the `format` plug.
+			- DataWindow : The data window of the input image.
+			- DisplayWindow : The display window of the input image.
+			- Auto : The minimal area that contains all the non-empty pixels
+			  of the input image. For flat images, this means pixels
+			  with a non-zero value in at least one channel, and for deep images
+			  it means pixels with at least one sample.
 			""",
 
 			"preset:Area" : GafferImage.Crop.AreaSource.Area,
 			"preset:Format" : GafferImage.Crop.AreaSource.Format,
 			"preset:DataWindow" : GafferImage.Crop.AreaSource.DataWindow,
 			"preset:DisplayWindow" : GafferImage.Crop.AreaSource.DisplayWindow,
+			"preset:Auto" : GafferImage.Crop.AreaSource.Auto,
 
 			"plugValueWidget:type" : "GafferUI.PresetsPlugValueWidget",
 

python/GafferUI/LazyMethod.py

@@ -49,11 +49,12 @@ class LazyMethod( object ) :
 	# Using `deferUntilPlaybackStops` requires that the widget has a
 	# `scriptNode()` method that returns the appropriate ScriptNode from which
 	# to acquire a Playback object.
-	def __init__( self, deferUntilVisible = True, deferUntilIdle = True, deferUntilPlaybackStops = False, replacePendingCalls = True ) :
+	def __init__( self, deferUntilVisible = True, deferUntilIdle = True, deferUntilPlaybackStops = False, replacePendingCalls = True, deferUntilButtonRelease = False ) :
 
 		self.__deferUntilVisible = deferUntilVisible
 		self.__deferUntilIdle = deferUntilIdle
 		self.__deferUntilPlaybackStops = deferUntilPlaybackStops
+		self.__deferUntilButtonRelease = deferUntilButtonRelease
 		self.__replacePendingCalls = replacePendingCalls
 
 	# Called to return the decorated method.
@@ -108,6 +109,10 @@ def wrapper( widget, *args, **kw ) :
 					)
 				)
 
+			elif self.__deferUntilButtonRelease and GafferUI.Widget.currentButtons() :
+
+				GafferUI.EventLoop.addIdleCallback( functools.partial( self.__idleForButtonRelease, weakref.ref( widget ), method ) )
+
 			elif self.__deferUntilIdle :
 
 				GafferUI.EventLoop.addIdleCallback( functools.partial( self.__idle, weakref.ref( widget ), method ) )
@@ -162,6 +167,27 @@ def __idle( cls, widgetWeakref, method ) :
 
 		return False # Remove idle callback
 
+	@classmethod
+	def __idleForButtonRelease( cls, widgetWeakref, method ) :
+
+		# There's no global Qt signal for button releases that we can
+		# hook into, so for now we do a busy-wait until all buttons are
+		# released.
+		## \todo If a lot of clients use `deferUntilButtonRelease` then
+		# we should consider mechanisms for making this more efficient.
+
+		if GafferUI.Widget.currentButtons() :
+			# Get called again in a bit.
+			return True
+
+		widget = widgetWeakref()
+		if widget is None or not GafferUI._qtObjectIsValid( widget._qtWidget() ):
+			return
+
+		cls.__doPendingCalls( widget, method )
+
+		return False # Remove idle callback
+
 	@classmethod
 	def __doPendingCalls( cls, widget, method ) :
 

python/GafferUI/NodeSetEditor.py

@@ -276,7 +276,7 @@ def __membersChanged( self, set, member ) :
 
 		self.__lazyUpdate()
 
-	@GafferUI.LazyMethod()
+	@GafferUI.LazyMethod( deferUntilButtonRelease = True )
 	def __lazyUpdate( self ) :
 
 		self._updateFromSet()

python/GafferUI/Widget.py

@@ -680,6 +680,11 @@ def mousePosition( relativeTo=None ) :
 
 		return p
 
+	@staticmethod
+	def currentButtons() :
+
+		return _eventFilter.currentButtons()
+
 	@staticmethod
 	def currentModifiers() :
 
@@ -969,6 +974,7 @@ def __init__( self ) :
 		QtCore.QObject.__init__( self )
 
 		# variables used in the implementation of drag and drop.
+		self.__virtualButton = GafferUI.ButtonEvent.Buttons.None_
 		self.__lastButtonPressWidget = None
 		self.__lastButtonPressEvent = None
 		self.__dragDropEvent = None
@@ -1002,6 +1008,10 @@ def __init__( self ) :
 			QtCore.QEvent.Drop,
 		) )
 
+	def currentButtons( self ) :
+
+		return self.__virtualButtons( QtWidgets.QApplication.mouseButtons() )
+
 	def eventFilter( self, qObject, qEvent ) :
 
 		qEventType = qEvent.type() # for speed it's best not to keep calling this below
@@ -1144,27 +1154,23 @@ def __keyRelease( self, qObject, qEvent ) :
 
 		return False
 
-	def __virtualButtons( self, qtButtons ):
-		result = Widget._buttons( qtButtons )
-		if self.__dragDropEvent is not None and self.__dragDropEvent.__startedByKeyPress :
-			result |= GafferUI.ButtonEvent.Buttons.Left
-		return GafferUI.ButtonEvent.Buttons( result )
+	def __virtualButtons( self, qtButtons ) :
+
+		return GafferUI.ButtonEvent.Buttons( self.__virtualButton | Widget._buttons( qtButtons ) )
 
 	def __mouseButtonPress( self, qObject, qEvent ) :
 
-		if (
-			self.__dragDropEvent is not None and self.__dragDropEvent.__startedByKeyPress
-			and ( Widget._buttons( qEvent.button() ) & GafferUI.ButtonEvent.Buttons.Left )
-		) :
-			# We are doing a virtual drag based on a keypress, but once the actual mouse button gets pressed,
-			# we replace it with an actual drag.
-			self.__dragDropEvent.__startedByKeyPress = False
+		pressedButton = Widget._buttons( qEvent.button() )
+		if self.__dragDropEvent is not None and pressedButton == self.__virtualButton :
+			# We were doing a drag based on a virtual button press, but now the actual mouse button has been pressed,
+			# so we can replace it.
+			self.__virtualButton = GafferUI.ButtonEvent.Buttons.None_
 			return True
 
 		widget = Widget._owner( qObject )
 		if widget._buttonPressSignal is not None :
 			event = GafferUI.ButtonEvent(
-				Widget._buttons( qEvent.button() ),
+				pressedButton,
 				self.__virtualButtons( qEvent.buttons() ),
 				self.__widgetSpaceLine( qEvent, widget ),
 				0.0,
@@ -1337,7 +1343,7 @@ def __doDrag( self, qObject, qEvent ) :
 
 		return False
 
-	def __startDrag( self, qObject, qEvent, forKeyPress = False ) :
+	def __startDrag( self, qObject, qEvent, threshold = 3 ) :
 
 		if self.__lastButtonPressWidget is None :
 			return False
@@ -1357,7 +1363,6 @@ def __startDrag( self, qObject, qEvent, forKeyPress = False ) :
 			# the widget died
 			return False
 
-		threshold = 3 if not forKeyPress else 0
 		if ( self.__lastButtonPressEvent.line.p0 - self.__widgetSpaceLine( qEvent, sourceWidget ).p0 ).length() < threshold :
 			return False
 
@@ -1372,7 +1377,6 @@ def __startDrag( self, qObject, qEvent, forKeyPress = False ) :
 		)
 		dragDropEvent.sourceWidget = sourceWidget
 		dragDropEvent.destinationWidget = None
-		dragDropEvent.__startedByKeyPress = forKeyPress
 
 		dragData = sourceWidget._dragBeginSignal( sourceWidget, dragDropEvent )
 		if dragData is not None :
@@ -1519,9 +1523,12 @@ def __dragKeyPress( self, qObject, qKeyEvent ) :
 				qKeyEvent.modifiers()
 			)
 
+			self.__virtualButton = GafferUI.ButtonEvent.Buttons.Left
 			if self.__mouseButtonPress( qWidget, qEvent ) :
-				self.__startDrag( qWidget, qEvent, forKeyPress = True )
+				self.__startDrag( qWidget, qEvent, threshold = 0 )
 				return True
+			else :
+				self.__virtualButton = GafferUI.ButtonEvent.Buttons.None_
 
 		else :
 
@@ -1539,6 +1546,7 @@ def __dragKeyPress( self, qObject, qKeyEvent ) :
 				qKeyEvent.modifiers()
 			)
 
+			self.__virtualButton = GafferUI.ButtonEvent.Buttons.None_
 			self.__endDrag( self.__dragDropEvent.sourceWidget._qtWidget(), qEvent )
 			return True