{"id":27004462,"url":"https://github.com/tacc/galaxy","last_synced_at":"2025-07-22T21:36:29.618Z","repository":{"id":54811053,"uuid":"140471058","full_name":"TACC/Galaxy","owner":"TACC","description":"Galaxy is an asynchronous parallel visualization ray tracer for performant rendering in distributed computing environments. Galaxy builds upon Intel OSPRay and Intel Embree, including ray queueing and sending logic inspired by TACC GraviT.","archived":false,"fork":false,"pushed_at":"2024-08-20T18:56:24.000Z","size":36769,"stargazers_count":19,"open_issues_count":7,"forks_count":9,"subscribers_count":13,"default_branch":"master","last_synced_at":"2024-08-21T18:38:17.382Z","etag":null,"topics":["asynchronous","distributed","mpi","parallel","raytracing"],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/TACC.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2018-07-10T18:13:32.000Z","updated_at":"2024-08-21T18:38:17.383Z","dependencies_parsed_at":"2024-07-10T19:45:31.288Z","dependency_job_id":"c560e9bd-e421-4884-9734-360b63a76f0b","html_url":"https://github.com/TACC/Galaxy","commit_stats":null,"previous_names":[],"tags_count":8,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/TACC%2FGalaxy","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/TACC%2FGalaxy/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/TACC%2FGalaxy/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/TACC%2FGalaxy/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/TACC","download_url":"https://codeload.github.com/TACC/Galaxy/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247128739,"owners_count":20888235,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["asynchronous","distributed","mpi","parallel","raytracing"],"created_at":"2025-04-04T06:16:53.744Z","updated_at":"2025-04-04T06:16:54.394Z","avatar_url":"https://github.com/TACC.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Galaxy: an asynchronous distributed parallel framework\n\n`master`: [![Build Status](https://travis-ci.org/TACC/Galaxy.svg?branch=master)](https://travis-ci.org/TACC/Galaxy)\n`dev`: [![Build Status](https://travis-ci.org/TACC/Galaxy.svg?branch=dev)](https://travis-ci.org/TACC/Galaxy)\n\nGalaxy is an asynchronous parallel visualization framework for ray-based operations, including ray tracing, sampling and volume integration. Galaxy has been designed for performance in distributed computing environments, including in situ use. Galaxy builds upon [Intel OSPRay][1] and [Intel Embree][2] and includes ray queueing and sending logic inspired by [TACC GraviT][3]. \n\nGalaxy has been developed primarily by Greg Abram and Paul Navratil with funding from the US Department of Energy's Office of Science ASCR program (Drs. Lucy Nowell and Laura Biven, program managers) through sub-award from Los Alamos National Laboratory; from Intel Corporation through Intel Parallel Computing Center awards; and from the Texas Advanced Computing Center at the University of Texas at Austin.\nA full list of contributors can be found in the `CONTRIBUTORS` file.\n\nGalaxy is licensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License. A copy of the License is included with this software in the file `LICENSE`. If your copy does not contain the License, you may obtain a copy of the License at: [Apache License Version 2.0][15]. \nUnless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.  \n\nCopyright (c) 2014-2020 The University of Texas at Austin. All rights reserved.\n\n## Galaxy dependencies\nGalaxy has two types of dependencies: (1) components assumed to be already installed in an accessible spot; and (2) components that are associated with the Galaxy repository in the `third-party` subdirectory.\n\nGalaxy assumes the following are already installed on your system in an accessible spot (these should all be available via package manager for your OS):\n  * a modern MPI (Message Passing Interface) implementation\n  * [a recent VTK][4] (at least version 7.x)\n  * [Intel Thread Building Blocks (TBB)][6]\n  * [PNG image format library][7]\n  * [zlib compression library][8]\n  * [CMake cross-platform build utility][9]\n  * [GLFW][14] (required by OSPRay build)\n  * [Python][18] (required for testing and using python scripts in `scripts`)\n  * [Qt5][20] (at least v5.9, tested against v5.14)\n\nGalaxy has the following components associated in the `third-party` subdirectory:\n  * [Intel ISPC][10]\n  * [Intel Embree][12]\n  * [Intel OSPRay][13]\n  * [rapidjson][16]\n\n*NOTE:* the third-party component locations are intended for development builds of Galaxy. If you intend to install Galaxy for general use, you should install Embree, OSPRay and rapidjson into a generally-accessible location and use those locations in the Galaxy build.\n\n## Installing Galaxy associated dependencies\nPrior to building Galaxy itself, you should ensure that all the general dependencies are installed (we recommend your humble OS package manager). Once those are in place, you're ready to install the dependencies in `third-party`. There are two steps to this process: 1) downloading and patching the submodules, and 2) building and installing the submodules.\n\n### Scripted build\nWe recommend using the Galaxy-provided build script `scripts/install-third-party.sh`, which will configure and build all submodules with a single command (if this script does not work for your configuration, please open a [GitHub issue][19]). If you need to customize your build, please see the next section.\n\nTo **download and build** the submodules: `cd` to the root directory of your local Galaxy repository and run the script `./scripts/install-third-party.sh`, which will (1) init and update the git submodules, (2) download ispc to where Galaxy expects to find it, and (3) build each in a `build` subdirectory and install into an `install` subdirectory. This script will populate the `third-party/ispc`, `third-party/embree`, `third-party/ospray`, and `third-pary/rapidjson` subdirectories. Once built, each third-party component will be installed to a single centralized location in `third-party/install`.\n\n### Custom build\nThe third-party dependency build can also be done by hand, for example, to \nspecify custom software locations or to change the configuration of Embree or OSPRay. Note that even with a custom build, the submodules still should be patched as described below.\n\nTo **download and patch** the submodules: `cd` to the root directory of your local Galaxy repository and run the script `./scripts/prep-third-party.sh`, which will (1) init and update the git submodules, and (2) download ispc to where Galaxy expects to find it. This script will populate the `third-party/ispc`, `third-party/embree`, `third-party/ospray`, and `third-pary/rapidjson` subdirectories.\n\nTo **build and install** the submodules, do the following in `third-party/embree`, then `third-part/ospray`, then `third-party/rapidjson` (`third-party/ispc` is already installed via the script):\n\n```bash\nmkdir build\ncd build\ncmake \u003ccmake flags\u003e .. \u0026\u0026 make \u0026\u0026 make install\n```\n\n*NOTE*: for the CMake flags used for each third-party library, see the CMAKE_FLAGS variables defined in `scripts/install-third-party.sh`.\n\n#### Local installs of Galaxy associated dependencies\nIf you prefer to use local installs of any of the dependencies, you can follow instructions below. Make sure to issue `git submodule init \u003cpath\u003e` and `git submodule update \u003cpath\u003e` for the third-party dependencies you do *NOT* have locally installed. For example, to use the rapidjson submodule, type:\n```bash\ngit submodule init third-party/rapidjson\ngit submodule update third-party/rapidjson\n```\n\n#### ISPC\nThe `third-party/ispc` directory contains a script to download a recent ISPC binary for MacOS or Linux. ISPC installed using this script should be detected automatically by the Galaxy CMake configuration. If you already have a recent ISPC installed (at least version 1.9.1) you are free to use it, though you might need to specify its location by hand in the CMake configurations for Embree, OSPRay, and Galaxy.\n\nFrom the root directory of your Galaxy repository, issue the following commands:\n```bash\ncd third-party/ispc\n./get-ispc.sh \n```\n\nThis will download ISPC (currently version 1.12.0) into `third-party/ispc/ispc-v\u003cversion\u003e-\u003cOS type\u003e` (e.g., ispc-v1.10.0-macOS), and it will install the `ispc` executable in `third-party/install/bin`. If this binary does not work on your system, you will need to build ISPC by hand following the directions at the [ISPC website][10]. \n\n#### Embree\nAfter updating the git submodules as described above, the `third-party/embree` directory should contain the Embree source tree. We recommend building in `third-party/embree/build` and installing to `third-party/install`, as doing so should enable Galaxy to find Embree. The recommended install directory is configured as part of the Embree cmake flags in `scripts/install-third-party.sh`.\n\nFirst, create a build directory and build Embree. Assuming CMake can find all required dependencies, you can use the `cmake` command to configure the makefile for the Embree build:\n```bash\nmkdir build\ncd build\ncmake \u003ccmake flags\u003e .. \u0026\u0026 make \u0026\u0026 make install\n```\nIf cmake complains about missing dependencies, you can specify or change their locations using cmake `-D\u003cCMAKE VAR\u003e` command-line syntax or using the interactive `ccmake` interface with `ccmake ..` in the build directory. See `scripts/install-third-party.sh` for recommended cmake flags.\n\n#### OSPRay\nBefore installing OSPRay, make sure you have updated the Galaxy git submodules and successfully built Embree, as described above. Once the git submodules have been updated, the `third-party/ospray` directory should contain the OSPRay source tree. We recommend building in `third-party/ospray/build` and installing to `third-party/install`, as doing so should enable Galaxy to find OSPRay automatically. The recommended install directory is configured as part of the OSPRay cmake flags in `scripts/install-third-party.sh`.\n\nFirst, create a build directory and build OSPRay. Assuming CMake can find all required dependencies, you can use the `cmake` command to configure the makefile for the OSPRay build:\n```bash\nmkdir build\ncd build\ncmake \u003ccmake flags\u003e .. \u0026\u0026 make \u0026\u0026 make install\n```\nIf cmake complains about missing dependencies, you can specify or change their locations using cmake `-D\u003cCMAKE VAR\u003e` command-line syntax or using the interactive `ccmake` interface with `ccmake ..` in the build directory. See `scripts/install-third-party.sh` for recommended cmake flags.\n\n#### rapidjson\nBefore installing rapidjson, make sure you have updated the Galaxy git submodules as described above. Once the git submodules have been updated, the `third-party/rapidjson` directory should contain the rapidjson source tree. We recommend building in `third-party/rapidjson/build` and installing to `third-party/install`, as doing so should enable Galaxy to find rapidjson automatically. The recommended install directory is configured as part of the RapidJSON cmake flags in `scripts/install-third-party.sh`.\n\nFirst, create a build directory and build rapidjson. Assuming CMake can find all required dependencies, you can use the `cmake` command to configure the makefile for the rapidjson build:\n\n```bash\nmkdir build\ncd build\ncmake \u003ccmake flags\u003e .. \u0026\u0026 make \u0026\u0026 make install\n```\nIf cmake complains about missing dependencies, you can specify or change their locations using cmake `-D\u003cCMAKE VAR\u003e` command-line syntax or using the interactive `ccmake` interface with `ccmake ..` in the build directory. See `scripts/install-third-party.sh` for recommended cmake flags.\n\n## Building Galaxy\nBefore building Galaxy, make sure all assumed and third-party subdirectory dependencies have been installed as described above, which will allow the Galaxy CMake configuration to find all dependencies automatically. We recommend building in `\u003cGalaxy root\u003e/build` and installing to `\u003cGalaxy root\u003e/install`. The recommended install directory is configured as part of the Galaxy CMake configuration.\n\nAssuming CMake can find all required dependencies, you can use the `cmake` command to configure the makefile for the Galaxy build:\n\n```bash\nmkdir build\ncd build\ncmake .. \u0026\u0026 make \u0026\u0026 make install\n```\nIf cmake complains about missing dependencies, you can specify or change their locations using cmake `-D\u003cCMAKE VAR\u003e` command-line syntax or using the interactive `ccmake` interface with `ccmake ..`.\n\n## Running Galaxy\n\nThere are several ways to run Galaxy.   In this document we currently only describe the batch mode applications; interactive viewers will be added to the documentation as time allows.\n\n### Setting up the environment\n\nIn the install root, `galaxy.env` contains the necessary environment variable settings for running Galaxy.   If you use the bash or sh shells, you can 'source' that file; for csh you'll need to modify it.\n\nWe currently assume that your environment has been set up to find both VTK and Intel OSPRay libraries.   \n\n### Preparing test data\n\n```bash\nmkdir $PROJECT/test\ncd $PROJECT/test\n```\n\nMake some volumetric test data\n\n`radial -r 256 256 256`\n\nwill create a .VTI dataset (radial-0.vti - note that radial will create timestep data if requested and the '-0' reflects the timestep) with several variables: ramps in X, Y and Z; oneBall is f(x, y, z) = mag(x, y, z) and eightBalls is f(x, y, z) = mag(abs(x) - 0.5, abs(y) - 0.5, abs(z) - 0.5)    We can create native format datasets:\n\n`vti2vol radial-0.vti oneBall eightBalls`\n\nwill create radial-0-oneBall.vol, radial-0-eightBalls.vol and corresponding …raw files that actually contain the data as bricks of floats.\n\n### Sample Galaxy State File\n\nGalaxy uses a JSON state file format to describe data and visualization operations. We discuss a sample Galaxy configuraiton file below. For more details about Galaxy state files, see `docs/state_files.md`.\n\nThe following is a state file that should work with the datasets we created above, and will result in six renderings: two visualizations rendered from each of the three cameras.\n\n```json\n{\n    \"Datasets\":\n    [\n      {\n        \"name\": \"oneBall\",\n        \"type\": \"Volume\",\n        \"filename\": \"radial-0-oneBall.vol\"\n      },\n      {\n        \"name\": \"eightBalls\",\n        \"type\": \"Volume\",\n        \"filename\": \"radial-0-eightBalls.vol\"\n      }\n    ],\n    \"Renderer\": {\n        \"Lighting\": {\n          \"Sources\": [[1, 1, 0, 1]],\n          \"shadows\": true,\n          \"Ka\": 0.4,\n          \"Kd\": 0.6,\n          \"ao count\": 16,\n          \"ao radius\": 0.5\n      }\n    },\n    \"Visualizations\":\n    [\n      {\n        \"annotation\": \"\",\n        \"operators\":\n          [\n            {\n              \"type\": \"Volume\",\n              \"dataset\": \"oneBall\",\n              \"isovalues\": [ 0.25 ],\n              \"volume rendering\": false,\n              \"colormap\": [\n                [0.00,1.0,0.5,0.5],\n                [0.25,0.5,1.0,0.5],\n                [0.50,0.5,0.5,1.0],\n                [0.75,1.0,1.0,0.5],\n                [1.00,1.0,0.5,1.0]\n               ],\n              \"slices\": [ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0] ],\n              \"opacitymap\": [\n                [ 0.00, 0.05],\n                [ 0.20, 0.05],\n                [ 0.21, 0.00],\n                [ 1.00, 0.00]\n               ]\n            }\n          ]\n      },\n      {\n        \"annotation\": \"\",\n        \"operators\":\n          [\n            {\n              \"type\": \"Volume\",\n              \"dataset\": \"eightBalls\",\n              \"slices\": [ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0] ],\n              \"volume rendering\": true,\n              \"colormap\": [\n                [0.00,1.0,0.5,0.5],\n                [0.25,0.5,1.0,0.5],\n                [0.50,0.5,0.5,1.0],\n                [0.75,1.0,1.0,0.5],\n                [1.00,1.0,0.5,1.0]\n               ],\n              \"opacitymap\": [\n                [ 0.00, 0.05],\n                [ 0.20, 0.05],\n                [ 0.21, 0.00],\n                [ 1.00, 0.00]\n               ]\n            }\n          ]\n       }\n    ],\n    \"Cameras\":\n    [\n      {\n        \"aov\": 30,\n        \"Xaov\": 20,\n        \"viewpoint\": [1, 2, -3],\n        \"viewcenter\": [0, 0, 0],\n        \"viewup\": [0, 1, 0]\n      },\n      {\n        \"aov\": 30,\n        \"Xaov\": 20,\n        \"viewpoint\": [2, 1, -3],\n        \"viewcenter\": [0, 0, 0],\n        \"viewup\": [0, 1, 0]\n      },\n      {\n        \"aov\": 30,\n        \"Xaov\": 20,\n        \"viewpoint\": [3, 1, -2],\n        \"viewcenter\": [0, 0, 0],\n        \"viewup\": [0, 1, 0]\n      }\n\n    ]\n}\n```\n\nConsidering each section in turn:\n\nThe Datasets section define the datasets that are available for visualization.   Each dataset specification includes the means to access the data, either using a file name or the information necessary to attach to an external source of data, and a name to be used internally.\n\nThe Renderer section includes the properties of the rendering, which are currently common among all the results of the run.   Rendering properties currently are simply the lighting model to be used, including the light sources themselves, whether to cast shadow rays or to add a fixed proportion of diffuse lighting, and whether to cast AO rays or to add a fixed proportion of ambient light.\n\nThe Visualizations section is an array, where each element (a visualization) contains an array of operators: one or more datasets and properties to be included in the visualization.   As an example, if the following is an element in a visualization operator array, that array will include the eightBalls dataset, with one slice, one isovalue and with volume rendering using the given transfer function.\n\n```json\n{\n    \"type\": \"Volume\",\n    \"dataset\": \"eightBalls\",\n    \"volume rendering\": true,\n    \"slices\": [ [0, 0, 1, 0] ],\n    \"isovalues\": [ 0.05 ],\n    \"colormap\": [\n            [0.00,1.0,0.5,0.5],\n            [0.25,0.5,1.0,0.5],\n            [0.50,0.5,0.5,1.0],\n            [0.75,1.0,1.0,0.5],\n            [1.00,1.0,0.5,1.0]\n           ],\n    \"opacitymap\": [\n            [ 0.00, 0.05],\n            [ 0.20, 0.02],\n            [ 0.21, 0.00],\n            [ 1.00, 0.00]\n           ]\n}\n```\n\nFinally, the Cameras section is also an array, consisting of the cameras to be used.   Cameras are very simply specified.\n \n\n### Interactive Viewing\n\nInteractive mode, where images are displayed in a client viewer, is the default Galaxy CMake configuration (i.e. `GXY_WRITE_IMAGES` is off).\n\nA visualization consists of a specification of one or more datasets to appear in the visualization, along with the properties of each - the slicing planes, isovalues, transfer functions, radii etc. The Galaxy viewer will use the first camera and visualization specified in the configuratin file. The Galaxy writer will produce images for the complete cross-product of cameras and visualizations (see below).\n\nIf you cut’n’paste the complete state file above into a text file named radial.json in the test directory, you can run:\n\n`[mpirun mpiargs] gxyviewer [-s width height] radial.json`\n\n\n### Batch Mode Image Writing\n\nBatch mode, where images are written to file without an interactive viewer, relies on a state file to define one or more visualizations and one or more cameras. Batch mode is activated by turning on `GXY_WRITE_IMAGES` in the Galaxy CMake configuration.\n\nA visualization consists of a specification of one or more datasets to appear in the visualization, along with the properties of each - the slicing planes, isovalues, transfer functions, radii etc.   \nThe result of the state file is the cross product of the sets of visualizations and cameras: a rendering of each visualization from every camera will be produced.\n\nIf you cut’n’paste the complete state file above into a text file named radial.json in the test directory, you can run:\n\n`[mpirun mpiargs] gxywriter [-s width height] radial.json`\n\nYou will produce three output .png files.   \n\n### Cinema \n\nCinema[17] databases are built in batch mode, and thus from a batch file that contains arrays of visualizations and cameras. This file may contain many visualizations; for example, if the the Cinema database has a varying isovalue and a moving slicing plane, there will be a separate visualization for each combination of isosurface value and slicing plane position.   Ten isovalues and ten slicing plane positions lead to 100 unique visualizations.   Similarly, the batch file may contain many cameras, one for each desired viewpoint. To make the creation of such batch files simple, the cinema.json file specifies a single visualization and camera parametrically.   \n\n**Note: Galaxy currently creates spec C Cinema databases. You must download the Cinema viewer, the browser-based viewer requires spec D format**\n\nThe following shows an example cinema.json:\n```json\n{\n    \"Datasets\":\n    [\n      {\n        \"name\": \"oneBall\",\n        \"type\": \"Volume\",\n        \"filename\": \"oneBall-0.vol\"\n      },\n      {\n        \"name\": \"eightBalls\",\n        \"type\": \"Volume\",\n        \"filename\": \"eightBalls-0.vol\"\n      }\n    ],\n    \"Renderer\": {\n        \"Lighting\": {\n          \"Sources\": [[0, 0, -4]],\n          \"shadows\": true,\n          \"Ka\": 0.2,\n          \"Kd\": 0.8,\n          \"ao count\": 0,\n          \"ao radius\": 0.1\n      }\n    },\n    \"Visualization\":\n    [\n      {\n        \"type\": \"Isosurface\",\n        \"dataset\": \"eightBalls\",\n        \"isovalue range\": { \"min\": 0.3, \"max\": 1.3, \"count\": 10 },\n        \"colormap\": \"eightBalls_cmap.json\",\n        \"opacitymap\": \"eightBalls_omap.json\"\n      },\n      {\n        \"type\": \"Slice\",\n        \"dataset\": \"oneBall\",\n        \"plane range\":\n        {\n          \"w\": { \"min\": -0.9, \"max\": 0.9, \"count\": 10 },\n          \"normal\": [0.0, 0.0, 1.0]\n        },\n        \"colormap\": \"oneBall_cmap.json\"\n      },\n      {\n        \"type\": \"Volume Rendering\",\n        \"dataset\": \"eightBalls\",\n        \"colormap\": \"eightBalls_cmap.json\",\n        \"opacitymap\": \"eightBalls_omap.json\"\n       }\n    ],\n    \"Camera\":\n    {\n      \"viewpoint\": [3, 0, -4],\n      \"viewcenter\": [0, 0, 0],\n      \"viewup\": [0, 1, 0],\n      \"theta angle\": { \"min\": -0.5, \"max\": 0.5, \"count\": 2 },\n      \"phi angle\": { \"min\": -0.5, \"max\": 0.5, \"count\": 2 },\n      \"aov\": 30\n    }\n}\n```\nIn this example, we see a single “Visualization” element, rather than the array of visualizations given in a state file.   This, though, parametrically defines a set of 100\nvisualizations, consisting of the cross product of 10 isovalues and 10 offsets of a slicing plane (which varies from -1 to 1 based on the range of the intersection of the normal ray with the object bounding box.   Similarly, a single parametric camera is given as a base view defined by a viewpoint and view center, but varying the azimuth and elevation in a range (in radians).    This defines 4 cameras, and, with 100 visualizations, will create a Cinema database of 400 images.\n\nNote, also, that the colormaps and opacity maps can be given as file names. \n\nGiven such a cinema.json file, the included Python script cinema2state will expand the parametric cinema specification to an explicit batch file, and prepare a Cinema database.   If the above is in cinema.json, the corresponding Cinema database can be created by:\n\n`cinema2state cinema.json`\n\nwhich will create state.json and initialize cinema.cdb.  Following this, \n\n`[mpirun mpiargs] cinema [-s width height] -C state.json`\n\nwill render the necessary images and deposit them into cinema.cdb.\n\n## Galaxy Notes\n\n## Performance and a note on threading\n\nThis renderer is parallel both by using multiple processes over MPI and by threading within each process.  Both the generation of initial rays and the processing of rays is now multithreaded.   By default, only a single thread is used, but the GXY_NTHREADS environment variable can be used to increase the number of worker threads.   \n\nOn my Mac Powerbook (2.8 GHz 4 core), the above Cinema database requires 579 seconds to render at 500x500 resolution.   Using GXY_NTHREADS=8 (the activity monitor indicates there are 8 virtual cores - hyperthreading?) reduces rendering time to 156 seconds.\n\n### Galaxy environment variables\nThe following environment variables affect Galaxy behavior:\n\n  * **GXY_NTHREADS** : use the requested number of threads in the rendering thread pool (default 1)\n  * **GXY_APP_NTHREADS** : use the requested number of threads for the application (default *TBB default*)\n  * **GXY_FULLWINDOW** : render using the full window\n  * **GXY_PERMUTE_PIXELS** : vary the order in which pixels are processed (can improve image quality under camera movement)\n  * **GXY_RAYS_PER_PACKET** : The number of rays to include in a transmission packet (default 10000000)\n  * **GXY_RAYDEBUG** : turn on ray debug pathway, taking **GXY_X**, **GXY_Y**, **GXY_XMIN**, **GXY_XMAX**, **GXY_YMIN**, **GXY_YMAX** from environment variables\n  * **GXY_X** : x coordinate for single-ray debug (requires **GXY_RAYDEBUG**)\n  * **GXY_Y** : y coordinate for single-ray debug (requires **GXY_RAYDEBUG**)\n  * **GXY_XMIN** : lower x extent for debug window (requires **GXY_RAYDEBUG**)\n  * **GXY_XMAX** : upper x extent for debug window (requires **GXY_RAYDEBUG**)\n  * **GXY_YMIN** : lower y extent for debug window (requires **GXY_RAYDEBUG**)\n  * **GXY_YMAX** : upper y extent for debug window (requires **GXY_RAYDEBUG**)\n\n\n[1]: http://www.ospray.org/\n[2]: http://embree.github.io/\n[3]: http://tacc.github.io/GraviT/\n[4]: http://www.vtk.org/\n[5]: http://www.qt.io/\n[6]: https://software.intel.com/en-us/intel-tbb\n[7]: http://libpng.org/pub/png/libpng.html\n[8]: http://zlib.net/\n[9]: http://www.cmake.org/\n[10]: https://ispc.github.io/\n[12]: http://embree.github.io/\n[13]: http://www.ospray.org/\n[14]: http://www.glfw.org/\n[15]: https://www.apache.org/licenses/LICENSE-2.0\n[16]: http://rapidjson.org/\n[17]: https://cinemascience.org/\n[18]: https://www.python.org/\n[19]: https://github.com/TACC/Galaxy/issues\n[20]: https://www.qt.io/download\n\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftacc%2Fgalaxy","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Ftacc%2Fgalaxy","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftacc%2Fgalaxy/lists"}