Rendererclient (#134)

* render-parameters: initial renderparameters retrieval

* client: add rendererClient calls

* renderparams: add renderparameter apis

* renderer: add renderer client to render renderparameters

* client: python 2 compatibility

Author: RussTorres

integration_tests/test_client_integrated.py

@@ -361,6 +361,29 @@ def test_processpools_parallelfuncs(
         mpPool=poolclass)
 
 
+@pytest.fixture(scope='module')
+def example_renderparameters(render, teststack):
+    zvalues = render.run(renderapi.stack.get_z_values_for_stack, teststack)
+    z = zvalues[0]
+    bounds = render.run(renderapi.stack.get_bounds_from_z, teststack, z)
+    width = (bounds['maxX'] - bounds['minX']) / 2
+    height = (bounds['maxY'] - bounds['minY']) / 2
+    x = bounds['minX'] + width / 4
+    y = bounds['minY'] + width / 4
+    renderparams = renderapi.image.get_bb_renderparams(
+        teststack, z, x, y, width, height,
+        scale=0.25, render=render)
+    yield renderparams
+
+
+@pytest.fixture(scope='module')
+def renderedimg_renderparams(render, example_renderparameters):
+    # TODO is there a "render from renderparams" api?
+    arr = renderapi.image.get_renderparameters_image(
+        example_renderparameters, render=render)
+    yield arr, example_renderparameters
+
+
 @pytest.fixture(scope='module')
 def tile_tilespec():
     tile_dims = (256, 256)
@@ -393,3 +416,13 @@ def test_ARGBrenderclient(render, tile_tilespec):
         tilearr = np.array(tileimg)
         assert arr.shape[:-1] == (tspec.width, tspec.height) == tilearr.shape
         assert np.all(arr[:, :, 0] == tilearr)
+
+
+def testRendererClient(render, renderedimg_renderparams):
+    renderedarr, renderparams = renderedimg_renderparams
+    arr = renderapi.client.render_renderparameters(renderparams, render=render)
+    assert arr.shape[:-1] == (
+        int(renderparams['height'] * renderparams['scale']),
+        int(renderparams['width'] * renderparams['scale'])
+    ) == renderedarr.shape[:-1]
+    assert np.all(arr == renderedarr)

integration_tests/test_stack_integrated.py

@@ -323,6 +323,25 @@ def test_bb_image_options(render, teststack):
                   maxIntensity=255)
 
 
+def test_bb_renderparams(render, teststack):
+    zvalues = render.run(renderapi.stack.get_z_values_for_stack, teststack)
+    z = zvalues[0]
+    bounds = render.run(renderapi.stack.get_bounds_from_z, teststack, z)
+    width = (bounds['maxX'] - bounds['minX']) / 2
+    height = (bounds['maxY'] - bounds['minY']) / 2
+    x = bounds['minX'] + width / 4
+    y = bounds['minY'] + width / 4
+    scale = 0.25
+
+    rp = renderapi.image.get_bb_renderparams(
+        teststack, z, x, y, width, height, scale=scale, render=render)
+    assert int(rp['width'] * rp['scale']) == int(width * scale)
+    assert int(rp['height'] * rp['scale']) == int(height * scale)
+    assert int(rp['x']) == int(x)
+    assert int(rp['y']) == int(y)
+    assert len(rp['tileSpecs'])
+
+
 def test_tile_image(render, teststack, render_example_tilespec_and_transforms,
                     **kwargs):
     (tilespecs, tforms) = render_example_tilespec_and_transforms
@@ -346,6 +365,23 @@ def test_tile_image_options(render, teststack,
         scale=testscale, filter=True, normalizeForMatching=False)
 
 
+def test_tile_renderparams(render, teststack):
+    zvalues = render.run(renderapi.stack.get_z_values_for_stack, teststack)
+    z = zvalues[0]
+
+    tspecs = renderapi.tilespec.get_tile_specs_from_z(
+        teststack, z, render=render)
+    ts = tspecs[0]
+
+    rp = renderapi.image.get_tile_renderparams(
+        teststack, ts.tileId, render=render)
+    assert int(rp['x']) == int(ts.minX)
+    assert int(rp['y']) == int(ts.minY)
+    assert len(rp['tileSpecs']) == 1
+    assert rp['height'] - 1 == int(ts.maxY - ts.minY)
+    assert rp['width'] - 1 == int(ts.maxX - ts.minX)
+
+
 def test_section_image(render, teststack, **kwargs):
     zvalues = render.run(renderapi.stack.get_z_values_for_stack, teststack)
     z = zvalues[0]
@@ -367,6 +403,19 @@ def test_section_image_options(render, teststack):
                        maxTileSpecsToRender=50)
 
 
+def test_section_renderparams(render, teststack):
+    zvalues = render.run(renderapi.stack.get_z_values_for_stack, teststack)
+    z = zvalues[0]
+    tspecs = renderapi.tilespec.get_tile_specs_from_z(
+        teststack, z, render=render)
+
+    scalefactor = 0.05
+    rp = renderapi.image.get_section_renderparams(
+        teststack, z, scale=scalefactor, render=render)
+    assert len(rp['tileSpecs']) == len(tspecs)
+    assert rp['scale'] == scalefactor
+
+
 def fail_image_get(render, teststack, render_example_tilespec_and_transforms):
     with pytest.raises(KeyError):
         render.run(renderapi.image.get_tile_image_data, teststack,

renderapi/client/client.py

@@ -17,7 +17,7 @@
 from renderapi.external.processpools.stdlib_pool import WithMultiprocessingPool
 
 from .utils import renderclientaccess
-from .client_calls import importJsonClient, call_run_ws_client, renderClient
+from .client_calls import importJsonClient, call_run_ws_client, renderClient, rendererClient
 
 # setup logger
 logger = logging.getLogger(__name__)
@@ -397,11 +397,32 @@ def render_tilespec(*args, **kwargs):
     return arr
 
 
+@renderclientaccess
+def materialize_renderparameters_image(
+        obj, out_fn=None, subprocess_mode=None, client_script=None, memGB=None,
+        render=None, **kwargs):
+    tfile = renderdump_temp(obj)
+    rendererClient(parameters_url=tfile, out_fn=out_fn,
+                   subprocess_mode=subprocess_mode,
+                   client_script=client_script, memGB=memGB, **kwargs)
+    os.remove(tfile)
+
+
+def render_renderparameters(*args, **kwargs):
+    # NOTE this is python2 compatible hack for keyword-only args
+    image_ext = kwargs.get('image_ext', '.png')
+    with tempfile.NamedTemporaryFile(suffix=image_ext) as f:
+        materialize_renderparameters_image(*args, out_fn=f.name, **kwargs)
+        arr = numpy.array(Image.open(f.name))
+    return arr
+
+
 __all__ = [
     "import_single_json_file",
     "import_jsonfiles_and_transforms_parallel_by_z",
     "import_jsonfiles_parallel", "import_jsonfiles",
     "import_jsonfiles_validate_client", "import_tilespecs",
     "import_tilespecs_parallel", "local_to_world_array",
     "world_to_local_array", "WithPool",
-    "render_tilespec", "materialize_tilespec_image"]
+    "render_tilespec", "materialize_tilespec_image",
+    "materialize_renderparameters_image", "render_renderparameters"]

renderapi/client/client_calls.py

@@ -682,9 +682,53 @@ def renderClient(tile_spec_url=None, height=None, width=None, in_fn=None,
                        **kwargs)
 
 
+@renderclientaccess
+def rendererClient(tile_spec_url=None, meshCellSize=None, minMeshCellSize=None,
+                   in_fn=None, out_fn=None, x=None, y=None, width=None,
+                   height=None, scale=None, area_offset=None,
+                   minIntensity=None, maxIntensity=None, gray=None,
+                   quality=None, threads=None, skip_interpolation=None,
+                   binary_mask=None, exclude_mask=None, parameters_url=None,
+                   do_filter=None, background_color=None, fill_with_noise=None,
+                   channels=None, subprocess_mode=None, client_script=None,
+                   memGB=None, render=None, **kwargs):
+    get_cmd_opt = ArgumentParameters.get_cmd_opt
+
+    argvs = (get_cmd_opt(tile_spec_url, '--tile_spec_url') +
+             get_cmd_opt(height, '--height') +
+             get_cmd_opt(width, '--width') +
+             get_cmd_opt(in_fn, '--in') +
+             get_cmd_opt(out_fn, '--out') +
+             get_cmd_opt(x, '--x') +
+             get_cmd_opt(y, '--y') +
+             get_cmd_opt(meshCellSize, '--meshCellSize') +
+             get_cmd_opt(minMeshCellSize, '--minMeshCellSize') +
+             get_cmd_opt(scale, '--scale') +
+             get_cmd_opt(area_offset, '--area_offset') +
+             get_cmd_opt(minIntensity, '--minIntensity') +
+             get_cmd_opt(maxIntensity, '--maxIntensity') +
+             get_cmd_opt(gray, '--gray') +
+             get_cmd_opt(quality, '--quality') +
+             get_cmd_opt(threads, '--threads') +
+             get_cmd_opt(skip_interpolation, '--skip_interpolation') +
+             get_cmd_opt(binary_mask, '--binary_mask') +
+             get_cmd_opt(exclude_mask, '--exclude_mask') +
+             get_cmd_opt(parameters_url, '--parameters_url') +
+             get_cmd_opt(do_filter, '--do_filter') +
+             get_cmd_opt(background_color, '--background_color') +
+             get_cmd_opt(fill_with_noise, '--fill_with_noise') +
+             get_cmd_opt(channels, '--channels'))
+
+    call_run_ws_client('org.janelia.alignment.Render',
+                       memGB=memGB, client_script=client_script,
+                       subprocess_mode=subprocess_mode, add_args=argvs,
+                       **kwargs)
+
+
 __all__ = [
     "call_run_ws_client", "run_subprocess_mode",
     "importJsonClient", "tilePairClient",
     "importTransformChangesClient", "coordinateClient",
     "renderSectionClient", "transformSectionClient",
-    "get_canvas_url_template", "pointMatchClient"]
+    "get_canvas_url_template", "pointMatchClient", "renderClient",
+    "rendererClient"]

renderapi/image.py

@@ -5,9 +5,9 @@
 from PIL import Image
 import numpy as np
 import logging
-from .render import format_preamble, renderaccess
+from .render import format_preamble, format_baseurl, renderaccess
 from .errors import RenderError
-from .utils import NullHandler, jbool
+from .utils import NullHandler, jbool, get_json, put_json
 
 logger = logging.getLogger(__name__)
 logger.addHandler(NullHandler())
@@ -25,6 +25,38 @@
                  None: 'png-image'}  # Default to png
 
 
+def _strip_None_value_dictitems(d, exclude_keys=[]):
+    return {k: v for k, v in d.items()
+            if v is not None and k not in exclude_keys}
+
+
+@renderaccess
+def get_bb_renderparams(stack, z, x, y, width, height, scale=1.0,
+                        channel=None, minIntensity=None, maxIntensity=None,
+                        binaryMask=None, filter=None, filterListName=None,
+                        convertToGray=None, excludeMask=None,
+                        host=None, port=None, owner=None,
+                        project=None, session=requests.session(),
+                        render=None, **kwargs):
+
+    request_url = format_preamble(
+        host, port, owner, project, stack) + \
+        "/z/%d/box/%d,%d,%d,%d,%f/render-parameters" % (
+        z, x, y, width, height, scale)
+
+    qparams = _strip_None_value_dictitems({
+        "minIntensity": minIntensity,
+        "maxIntensity": maxIntensity,
+        "binaryMask": binaryMask,
+        "filter": filter,
+        "filterListName": filterListName,
+        "convertToGray": convertToGray,
+        "excludeMask": excludeMask,
+        "channels": channel})
+
+    return get_json(session, request_url, params=qparams)
+
+
 @renderaccess
 def get_bb_image(stack, z, x, y, width, height, scale=1.0,
                  channel=None,
@@ -109,6 +141,41 @@ def get_bb_image(stack, z, x, y, width, height, scale=1.0,
         return RenderError(r.text)
 
 
+@renderaccess
+def get_tile_renderparams(
+        stack, tileId, channel=None, normalizeForMatching=None,
+        excludeAllTransforms=None, excludeTransformsAfterLast=None,
+        excludeFirstTransformAndAllAfter=None, scale=None,
+        width=None, height=None, minIntensity=None, maxIntensity=None,
+        filter=None, filterListName=None, excludeMask=None, convertToGray=None,
+        binaryMask=None, host=None, port=None, owner=None,
+        project=None, img_format=None,
+        session=requests.session(), render=None, **kwargs):
+    request_url = format_preamble(
+        host, port, owner, project, stack) + \
+        "/tile/%s/render-parameters" % (
+        tileId)
+
+    qparams = _strip_None_value_dictitems({
+        "normalizeForMatching": normalizeForMatching,
+        "excludeAllTransforms": excludeAllTransforms,
+        "excludeTransformsAfterLast": excludeTransformsAfterLast,
+        "excludeFirstTransformAndAllAfter": excludeFirstTransformAndAllAfter,
+        "scale": scale,
+        "width": width,
+        "height": height,
+        "minIntensity": minIntensity,
+        "maxIntensity": maxIntensity,
+        "binaryMask": binaryMask,
+        "filter": filter,
+        "filterListName": filterListName,
+        "convertToGray": convertToGray,
+        "excludeMask": excludeMask,
+        "channels": channel})
+
+    return get_json(session, request_url, params=qparams)
+
+
 @renderaccess
 def get_tile_image_data(stack, tileId, channel=None, normalizeForMatching=True,
                         excludeAllTransforms=False, scale=None,
@@ -191,6 +258,32 @@ def get_tile_image_data(stack, tileId, channel=None, normalizeForMatching=True,
         return RenderError(r.text)
 
 
+@renderaccess
+def get_section_renderparams(stack, z, binaryMask=None, channel=None,
+                             convertToGray=None, excludeMask=None, filter=None,
+                             filterListName=None, minIntensity=None,
+                             maxIntensity=None, scale=None,
+                             host=None, port=None, owner=None, project=None,
+                             session=requests.session(),
+                             render=None, **kwargs):
+    request_url = format_preamble(
+        host, port, owner, project, stack) + "/z/{}/render-parameters".format(
+            z)
+
+    qparams = _strip_None_value_dictitems({
+        "scale": scale,
+        "minIntensity": minIntensity,
+        "maxIntensity": maxIntensity,
+        "binaryMask": binaryMask,
+        "filter": filter,
+        "filterListName": filterListName,
+        "convertToGray": convertToGray,
+        "excludeMask": excludeMask,
+        "channels": channel})
+
+    return get_json(session, request_url, params=qparams)
+
+
 @renderaccess
 def get_section_image(stack, z, scale=1.0, channel=None,
                       filter=False,
@@ -255,3 +348,20 @@ def get_section_image(stack, z, scale=1.0, channel=None,
 
     r = session.get(request_url, params=qparams)
     return np.asarray(Image.open(io.BytesIO(r.content)))
+
+
+@renderaccess
+def get_renderparameters_image(renderparams, img_format=None,
+                               host=None, port=None, owner=None,
+                               session=requests.session(),
+                               render=None, **kwargs):
+    try:
+        image_ext = IMAGE_FORMATS[img_format]
+    except KeyError as e:  # pragma: no cover
+        raise ValueError('{} is not a valid render image format!'.format(e))
+
+    request_url = format_baseurl(host, port) + '/owner/{owner}/{ext}'.format(
+        owner=owner, ext=image_ext)
+
+    r = put_json(session, request_url, renderparams)
+    return np.array(Image.open(io.BytesIO(r.content)))