def test_resolver(self):
op = deepimage.SetDeepImage(None)
op._resolver = "shadow"
self.assertEqual(op.resolver, "shadow")
op = deepimage.SetDeepImage(None)
op._resolver = "camera"
op.resolver = "shadow"
self.assertEqual(op._resolver, "shadow")
def test_pzstorage(self):
op = deepimage.SetDeepImage(None)
op._pzstorage = "real32"
self.assertEqual(op.pzstorage, "real32")
op = deepimage.SetDeepImage(None)
op._pzstorage = "real16"
op.pzstorage = "real32"
self.assertEqual(op._pzstorage, "real32")
def test_ofsize(self):
op = deepimage.SetDeepImage(None)
op._ofsize = 3
self.assertEqual(op.ofsize, 3)
op = deepimage.SetDeepImage(None)
op._ofsize = 1
op.ofsize = 3
self.assertEqual(op._ofsize, 3)
def test_mipmaps(self):
op = deepimage.SetDeepImage(None)
op._mipmaps = True
self.assertTrue(op.mipmaps)
op = deepimage.SetDeepImage(None)
op._mipmaps = False
op.mipmaps = True
self.assertTrue(op._mipmaps)
def test_zbias(self):
op = deepimage.SetDeepImage(None)
op._zbias = 3
self.assertEqual(op.zbias, 3)
op = deepimage.SetDeepImage(None)
op._zbias = 1
op.zbias = 3
self.assertEqual(op._zbias, 3)
def test_all_passes(self):
op = deepimage.SetDeepImage(None)
op._all_passes = True
self.assertTrue(op.all_passes)
op = deepimage.SetDeepImage(None)
op._all_passes = False
op.all_passes = True
self.assertTrue(op._all_passes)
def test_disable_deep_image(self):
op = deepimage.SetDeepImage(None)
op._disable_deep_image = True
self.assertTrue(op.disable_deep_image)
op = deepimage.SetDeepImage(None)
op._disable_deep_image = False
op.disable_deep_image = True
self.assertTrue(op._disable_deep_image)
def test_deepcompression(self):
op = deepimage.SetDeepImage(None)
op._deepcompression = 4
self.assertEqual(op.deepcompression, 4)
op = deepimage.SetDeepImage(None)
op._deepcompression = 3
op.deepcompression = 4
self.assertEqual(op._deepcompression, 4)
def test_filename(self):
op = deepimage.SetDeepImage(None)
op._filename = "/path/to/file.exr"
self.assertEqual(op.filename, "/path/to/file.exr")
op = deepimage.SetDeepImage(None)
op._filename = "foo"
op.filename = "/path/to/file.exr"
self.assertEqual(op._filename, "/path/to/file.exr")
def test_depth_planes(self):
op = deepimage.SetDeepImage(None)
op._depth_planes = "zfront,zback"
self.assertEqual(op.depth_planes, "zfront,zback")
op = deepimage.SetDeepImage(None)
op._depth_planes = "foo"
op.depth_planes = "zfront,zback"
self.assertEqual(op._depth_planes, "zfront,zback")
def test_compositing(self):
op = deepimage.SetDeepImage(None)
op._compositing = True
self.assertTrue(op.compositing)
op = deepimage.SetDeepImage(None)
op._compositing = False
op.compositing = True
self.assertTrue(op._compositing)
def test_should_run(self):
op = deepimage.SetDeepImage(None)
op._disable_deep_image = False
op._resolver = None
op._filename = None
op._compositing = None
op._deepcompression = None
op._depth_planes = None
op._mipmaps = None
op._ofsize = None
op._ofstorage = None
op._pzstorage = None
op._zbias = None
self.assertFalse(op.should_run())
op.disable_deep_image = True
self.assertTrue(op.should_run())
op.disable_deep_image = False
op.filename = "/path/to/deep.exr"
self.assertTrue(op.should_run())
op.filename = None
op.resolver = "shadow"
self.assertTrue(op.should_run())
op.resolver = None
op.compositing = 1
self.assertTrue(op.should_run())
op.compositing = None
op.deepcompression = 1
self.assertTrue(op.should_run())
op.deepcompression = None
op.depth_planes = "zback"
self.assertTrue(op.should_run())
op.depth_planes = None
op.mipmaps = 0
self.assertTrue(op.should_run())
op.mipmaps = None
op.ofsize = 1
self.assertTrue(op.should_run())
op.ofsize = None
op.ofstorage = "real16"
self.assertTrue(op.should_run())
op.ofstorage = None
op.pzstorage = "real16"
self.assertTrue(op.should_run())
op.pzstorage = None
op.zbias = 0.1
self.assertTrue(op.should_run())
op.zbias = None
def test_filterCamera__deep_args(self, mock_modify, mock_logger, mock_get,
mock_set):
"""Try to set the resolver when there is no resolver already set and
we don't provide enough data.
"""
data = {
"renderer:rendertype": "beauty",
"image:deepresolver": ["shadow", "filename", "/path/to/deep.exr"]
}
mock_get.side_effect = lambda arg: data[arg]
# No resolver type.
op = deepimage.SetDeepImage(None)
op._all_passes = False
op._disable_deep_image = False
op._filename = None
op._resolver = None
op.filterCamera()
mock_modify.assert_called_with(
["shadow", "filename", "/path/to/deep.exr"])
mock_logger.debug.assert_called()
mock_set.assert_called_with(
"image:deepresolver", ["shadow", "filename", "/path/to/deep.exr"])
def test_resolver(self):
"""Test 'resolver' property."""
op = deepimage.SetDeepImage(None)
mock_value1 = MagicMock(spec=str)
op._resolver = mock_value1
self.assertEqual(op.resolver, mock_value1)
mock_value2 = MagicMock(spec=str)
op.resolver = mock_value2
self.assertEqual(op._resolver, mock_value2)
def test_pzstorage(self):
"""Test 'pzstorage' property."""
op = deepimage.SetDeepImage(None)
mock_value1 = MagicMock(spec=str)
op._pzstorage = mock_value1
self.assertEqual(op.pzstorage, mock_value1)
mock_value2 = MagicMock(spec=str)
op.pzstorage = mock_value2
self.assertEqual(op._pzstorage, mock_value2)
def test_ofsize(self):
"""Test 'ofsize' property."""
op = deepimage.SetDeepImage(None)
mock_value1 = MagicMock(spec=int)
op._ofsize = mock_value1
self.assertEqual(op.ofsize, mock_value1)
mock_value2 = MagicMock(spec=int)
op.ofsize = mock_value2
self.assertEqual(op._ofsize, mock_value2)
def test_filename(self):
"""Test 'filename' property."""
op = deepimage.SetDeepImage(None)
mock_value1 = MagicMock(spec=str)
op._filename = mock_value1
self.assertEqual(op.filename, mock_value1)
mock_value2 = MagicMock(spec=str)
op.filename = mock_value2
self.assertEqual(op._filename, mock_value2)
def test_depth_planes(self):
"""Test 'depth_planes' property."""
op = deepimage.SetDeepImage(None)
mock_value1 = MagicMock(spec=str)
op._depth_planes = mock_value1
self.assertEqual(op.depth_planes, mock_value1)
mock_value2 = MagicMock(spec=str)
op.depth_planes = mock_value2
self.assertEqual(op._depth_planes, mock_value2)
def test_zbias(self):
"""Test 'zbias' property."""
op = deepimage.SetDeepImage(None)
mock_value1 = MagicMock(spec=int)
op._zbias = mock_value1
self.assertEqual(op.zbias, mock_value1)
mock_value2 = MagicMock(spec=int)
op.zbias = mock_value2
self.assertEqual(op._zbias, mock_value2)
def test_filterCamera__not_beatuy(self, mock_modify, mock_logger,
mock_get):
mock_get.return_value = "shadow"
op = deepimage.SetDeepImage(None)
op._all_passes = False
op.filterCamera()
mock_logger.warning.assert_called_with(
"Not a beauty render, skipping deepresolver")
def test_disable_deep_image(self):
"""Test 'disable_deep_image' property."""
op = deepimage.SetDeepImage(None)
mock_value1 = MagicMock(spec=bool)
op._disable_deep_image = mock_value1
self.assertEqual(op.disable_deep_image, mock_value1)
mock_value2 = MagicMock(spec=bool)
op.disable_deep_image = mock_value2
self.assertEqual(op._disable_deep_image, mock_value2)
def test_deepcompression(self):
"""Test 'deepcompression' property."""
op = deepimage.SetDeepImage(None)
mock_value1 = MagicMock(spec=int)
op._deepcompression = mock_value1
self.assertEqual(op.deepcompression, mock_value1)
mock_value2 = MagicMock(spec=int)
op.deepcompression = mock_value2
self.assertEqual(op._deepcompression, mock_value2)
def test_all_passes(self):
"""Test 'all_passes' property."""
op = deepimage.SetDeepImage(None)
mock_value1 = MagicMock(spec=bool)
op._all_passes = mock_value1
self.assertEqual(op.all_passes, mock_value1)
mock_value2 = MagicMock(spec=bool)
op.all_passes = mock_value2
self.assertEqual(op._all_passes, mock_value2)
def test_compositing(self):
"""Test 'compositing' property."""
op = deepimage.SetDeepImage(None)
mock_value1 = MagicMock(spec=int)
op._compositing = mock_value1
self.assertEqual(op.compositing, mock_value1)
mock_value2 = MagicMock(spec=int)
op.compositing = mock_value2
self.assertEqual(op._compositing, mock_value2)
def test_filterCamera__disable_deep_image(self, mock_modify, mock_logger,
mock_get, mock_set):
"""Try to disable deep image export."""
mock_get.return_value = "beauty"
op = deepimage.SetDeepImage(None)
op._all_passes = False
op._disable_deep_image = True
op.filterCamera()
mock_set.assert_called_with("image:deepresolver", [])
mock_logger.info.assert_called_with("Disabling deep resolver")
def test_process_parsed_args__none(self):
"""Test processing the args when they are all default."""
namespace = argparse.Namespace()
namespace.disable_deep_image = False
namespace.deep_all_passes = False
namespace.deep_image_path = None
namespace.deep_resolver = None
namespace.deep_compositing = None
namespace.deep_compression = None
namespace.deep_depth_planes = None
namespace.deep_mipmaps = None
namespace.deep_ofsize = None
namespace.deep_ofstorage = None
namespace.deep_pzstorage = None
namespace.deep_zbias = None
op = deepimage.SetDeepImage(None)
op._all_passes = True
op._disable_deep_image = True
op._resolver = "shadow"
op._filename = "/path/to/deep.exr"
op._compositing = 1
op._deepcompression = 1
op._depth_planes = "zfront,zback"
op._mipmaps = 1
op._ofsize = 1
op._ofstorage = "real16"
op._pzstorage = "real32"
op._zbias = 0.5
op.process_parsed_args(namespace)
self.assertTrue(op.disable_deep_image)
self.assertTrue(op.all_passes)
self.assertEquals(op.filename, "/path/to/deep.exr")
self.assertEquals(op.resolver, "shadow")
self.assertEquals(op.compositing, 1)
self.assertEquals(op.deepcompression, 1)
self.assertEquals(op.depth_planes, "zfront,zback")
self.assertEquals(op.mipmaps, 1)
self.assertEquals(op.ofsize, 1)
self.assertEquals(op.ofstorage, "real16")
self.assertEquals(op.pzstorage, "real32")
self.assertEquals(op.zbias, 0.5)
def test___init__(self):
mock_manager = MagicMock(spec=PyFilterManager)
op = deepimage.SetDeepImage(mock_manager)
self.assertEqual(op._data, {})
self.assertEqual(op._manager, mock_manager)
self.assertFalse(op._all_passes, False)
self.assertFalse(op._disable_deep_image, False)
self.assertIsNone(op._resolver)
self.assertIsNone(op._filename)
self.assertIsNone(op._compositing)
self.assertIsNone(op._deepcompression)
self.assertIsNone(op._depth_planes)
self.assertIsNone(op._mipmaps)
self.assertIsNone(op._ofsize)
self.assertIsNone(op._ofstorage)
self.assertIsNone(op._pzstorage)
self.assertIsNone(op._zbias)
def test___init__(self, mock_super_init):
"""Test constructor."""
mock_manager = MagicMock(spec=PyFilterManager)
op = deepimage.SetDeepImage(mock_manager)
mock_super_init.assert_called_with(mock_manager)
self.assertFalse(op._all_passes, False)
self.assertFalse(op._disable_deep_image, False)
self.assertIsNone(op._resolver)
self.assertIsNone(op._filename)
self.assertIsNone(op._compositing)
self.assertIsNone(op._deepcompression)
self.assertIsNone(op._depth_planes)
self.assertIsNone(op._mipmaps)
self.assertIsNone(op._ofsize)
self.assertIsNone(op._ofstorage)
self.assertIsNone(op._pzstorage)
self.assertIsNone(op._zbias)
def test_filterCamera__no_deep_args_no_file(self, mock_modify, mock_logger,
mock_get, mock_set):
"""Try to set the resolver when there is no resolver already set and
we don't provide enough data.
"""
data = {"renderer:rendertype": "beauty", "image:deepresolver": []}
mock_get.side_effect = lambda arg: data[arg]
# No resolver type.
op = deepimage.SetDeepImage(None)
op._all_passes = False
op._disable_deep_image = False
op._filename = None
op._resolver = "shadow"
op.filterCamera()
mock_logger.error.assert_called_with(
"Cannot set deepresolver: deep output is not enabled")
def test___init__(self, mocker):
"""Test object initialization."""
mock_super_init = mocker.patch.object(deepimage.PyFilterOperation, "__init__")
mock_manager = mocker.MagicMock(spec=PyFilterManager)
op = deepimage.SetDeepImage(mock_manager)
mock_super_init.assert_called_with(mock_manager)
assert not op._all_passes
assert not op._disable_deep_image
assert op._resolver is None
assert op._filename is None
assert op._compositing is None
assert op._deepcompression is None
assert op._depth_planes is None
assert op._mipmaps is None
assert op._ofsize is None
assert op._ofstorage is None
assert op._pzstorage is None
assert op._zbias is None
